This source file includes following definitions.
- perf_evsel__no_extra_init
- test_attr__ready
- perf_evsel__no_extra_fini
- perf_evsel__object_config
- __perf_evsel__sample_size
- __perf_evsel__calc_id_pos
- __perf_evsel__calc_is_pos
- perf_evsel__calc_id_pos
- __perf_evsel__set_sample_bit
- __perf_evsel__reset_sample_bit
- perf_evsel__set_sample_id
- perf_evsel__is_function_event
- evsel__init
- perf_evsel__new_idx
- perf_event_can_profile_kernel
- perf_evsel__new_cycles
- perf_evsel__newtp_idx
- __perf_evsel__hw_name
- perf_evsel__add_modifiers
- perf_evsel__hw_name
- __perf_evsel__sw_name
- perf_evsel__sw_name
- __perf_evsel__bp_name
- perf_evsel__bp_name
- perf_evsel__is_cache_op_valid
- __perf_evsel__hw_cache_type_op_res_name
- __perf_evsel__hw_cache_name
- perf_evsel__hw_cache_name
- perf_evsel__raw_name
- perf_evsel__tool_name
- perf_evsel__name
- perf_evsel__group_name
- perf_evsel__group_desc
- __perf_evsel__config_callchain
- perf_evsel__config_callchain
- perf_evsel__reset_callgraph
- apply_config_terms
- is_dummy_event
- perf_evsel__config
- perf_evsel__set_filter
- perf_evsel__append_filter
- perf_evsel__append_tp_filter
- perf_evsel__append_addr_filter
- evsel__enable
- evsel__disable
- perf_evsel__free_config_terms
- perf_evsel__exit
- evsel__delete
- perf_evsel__compute_deltas
- perf_counts_values__scale
- perf_evsel__read_one
- perf_evsel__set_count
- perf_evsel__process_group_data
- perf_evsel__read_group
- perf_evsel__read_counter
- __perf_evsel__read_on_cpu
- get_group_fd
- perf_evsel__remove_fd
- update_fds
- ignore_missing_thread
- __open_attr__fprintf
- display_attr
- perf_event_open
- evsel__open
- evsel__close
- perf_evsel__open_per_cpu
- perf_evsel__open_per_thread
- perf_evsel__parse_id_sample
- overflow
- perf_event__check_size
- perf_evsel__parse_sample
- perf_evsel__parse_sample_timestamp
- perf_evsel__field
- perf_evsel__rawptr
- format_field__intval
- perf_evsel__intval
- perf_evsel__fallback
- find_process
- perf_evsel__open_strerror
- perf_evsel__env
- store_evsel_ids
- perf_evsel__store_ids
1
2
3
4
5
6
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 <traceevent/event-parse.h>
16 #include <linux/hw_breakpoint.h>
17 #include <linux/perf_event.h>
18 #include <linux/compiler.h>
19 #include <linux/err.h>
20 #include <linux/zalloc.h>
21 #include <sys/ioctl.h>
22 #include <sys/resource.h>
23 #include <sys/types.h>
24 #include <dirent.h>
25 #include <stdlib.h>
26 #include <perf/evsel.h>
27 #include "asm/bug.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 "../perf-sys.h"
49 #include "util/parse-branch-options.h"
50 #include <internal/xyarray.h>
51 #include <internal/lib.h>
52
53 #include <linux/ctype.h>
54
55 struct perf_missing_features perf_missing_features;
56
57 static clockid_t clockid;
58
59 static int perf_evsel__no_extra_init(struct evsel *evsel __maybe_unused)
60 {
61 return 0;
62 }
63
64 void __weak test_attr__ready(void) { }
65
66 static void perf_evsel__no_extra_fini(struct evsel *evsel __maybe_unused)
67 {
68 }
69
70 static struct {
71 size_t size;
72 int (*init)(struct evsel *evsel);
73 void (*fini)(struct evsel *evsel);
74 } perf_evsel__object = {
75 .size = sizeof(struct evsel),
76 .init = perf_evsel__no_extra_init,
77 .fini = perf_evsel__no_extra_fini,
78 };
79
80 int perf_evsel__object_config(size_t object_size,
81 int (*init)(struct evsel *evsel),
82 void (*fini)(struct evsel *evsel))
83 {
84
85 if (object_size == 0)
86 goto set_methods;
87
88 if (perf_evsel__object.size > object_size)
89 return -EINVAL;
90
91 perf_evsel__object.size = object_size;
92
93 set_methods:
94 if (init != NULL)
95 perf_evsel__object.init = init;
96
97 if (fini != NULL)
98 perf_evsel__object.fini = fini;
99
100 return 0;
101 }
102
103 #define FD(e, x, y) (*(int *)xyarray__entry(e->core.fd, x, y))
104
105 int __perf_evsel__sample_size(u64 sample_type)
106 {
107 u64 mask = sample_type & PERF_SAMPLE_MASK;
108 int size = 0;
109 int i;
110
111 for (i = 0; i < 64; i++) {
112 if (mask & (1ULL << i))
113 size++;
114 }
115
116 size *= sizeof(u64);
117
118 return size;
119 }
120
121
122
123
124
125
126
127
128
129 static int __perf_evsel__calc_id_pos(u64 sample_type)
130 {
131 int idx = 0;
132
133 if (sample_type & PERF_SAMPLE_IDENTIFIER)
134 return 0;
135
136 if (!(sample_type & PERF_SAMPLE_ID))
137 return -1;
138
139 if (sample_type & PERF_SAMPLE_IP)
140 idx += 1;
141
142 if (sample_type & PERF_SAMPLE_TID)
143 idx += 1;
144
145 if (sample_type & PERF_SAMPLE_TIME)
146 idx += 1;
147
148 if (sample_type & PERF_SAMPLE_ADDR)
149 idx += 1;
150
151 return idx;
152 }
153
154
155
156
157
158
159
160
161
162 static int __perf_evsel__calc_is_pos(u64 sample_type)
163 {
164 int idx = 1;
165
166 if (sample_type & PERF_SAMPLE_IDENTIFIER)
167 return 1;
168
169 if (!(sample_type & PERF_SAMPLE_ID))
170 return -1;
171
172 if (sample_type & PERF_SAMPLE_CPU)
173 idx += 1;
174
175 if (sample_type & PERF_SAMPLE_STREAM_ID)
176 idx += 1;
177
178 return idx;
179 }
180
181 void perf_evsel__calc_id_pos(struct evsel *evsel)
182 {
183 evsel->id_pos = __perf_evsel__calc_id_pos(evsel->core.attr.sample_type);
184 evsel->is_pos = __perf_evsel__calc_is_pos(evsel->core.attr.sample_type);
185 }
186
187 void __perf_evsel__set_sample_bit(struct evsel *evsel,
188 enum perf_event_sample_format bit)
189 {
190 if (!(evsel->core.attr.sample_type & bit)) {
191 evsel->core.attr.sample_type |= bit;
192 evsel->sample_size += sizeof(u64);
193 perf_evsel__calc_id_pos(evsel);
194 }
195 }
196
197 void __perf_evsel__reset_sample_bit(struct evsel *evsel,
198 enum perf_event_sample_format bit)
199 {
200 if (evsel->core.attr.sample_type & bit) {
201 evsel->core.attr.sample_type &= ~bit;
202 evsel->sample_size -= sizeof(u64);
203 perf_evsel__calc_id_pos(evsel);
204 }
205 }
206
207 void perf_evsel__set_sample_id(struct evsel *evsel,
208 bool can_sample_identifier)
209 {
210 if (can_sample_identifier) {
211 perf_evsel__reset_sample_bit(evsel, ID);
212 perf_evsel__set_sample_bit(evsel, IDENTIFIER);
213 } else {
214 perf_evsel__set_sample_bit(evsel, ID);
215 }
216 evsel->core.attr.read_format |= PERF_FORMAT_ID;
217 }
218
219
220
221
222
223
224
225
226
227 bool perf_evsel__is_function_event(struct evsel *evsel)
228 {
229 #define FUNCTION_EVENT "ftrace:function"
230
231 return evsel->name &&
232 !strncmp(FUNCTION_EVENT, evsel->name, sizeof(FUNCTION_EVENT));
233
234 #undef FUNCTION_EVENT
235 }
236
237 void evsel__init(struct evsel *evsel,
238 struct perf_event_attr *attr, int idx)
239 {
240 perf_evsel__init(&evsel->core, attr);
241 evsel->idx = idx;
242 evsel->tracking = !idx;
243 evsel->leader = evsel;
244 evsel->unit = "";
245 evsel->scale = 1.0;
246 evsel->max_events = ULONG_MAX;
247 evsel->evlist = NULL;
248 evsel->bpf_obj = NULL;
249 evsel->bpf_fd = -1;
250 INIT_LIST_HEAD(&evsel->config_terms);
251 perf_evsel__object.init(evsel);
252 evsel->sample_size = __perf_evsel__sample_size(attr->sample_type);
253 perf_evsel__calc_id_pos(evsel);
254 evsel->cmdline_group_boundary = false;
255 evsel->metric_expr = NULL;
256 evsel->metric_name = NULL;
257 evsel->metric_events = NULL;
258 evsel->collect_stat = false;
259 evsel->pmu_name = NULL;
260 }
261
262 struct evsel *perf_evsel__new_idx(struct perf_event_attr *attr, int idx)
263 {
264 struct evsel *evsel = zalloc(perf_evsel__object.size);
265
266 if (!evsel)
267 return NULL;
268 evsel__init(evsel, attr, idx);
269
270 if (perf_evsel__is_bpf_output(evsel)) {
271 evsel->core.attr.sample_type |= (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME |
272 PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD),
273 evsel->core.attr.sample_period = 1;
274 }
275
276 if (perf_evsel__is_clock(evsel)) {
277
278
279
280
281 static const char *unit = "msec";
282
283 evsel->unit = unit;
284 evsel->scale = 1e-6;
285 }
286
287 return evsel;
288 }
289
290 static bool perf_event_can_profile_kernel(void)
291 {
292 return perf_event_paranoid_check(1);
293 }
294
295 struct evsel *perf_evsel__new_cycles(bool precise)
296 {
297 struct perf_event_attr attr = {
298 .type = PERF_TYPE_HARDWARE,
299 .config = PERF_COUNT_HW_CPU_CYCLES,
300 .exclude_kernel = !perf_event_can_profile_kernel(),
301 };
302 struct evsel *evsel;
303
304 event_attr_init(&attr);
305
306 if (!precise)
307 goto new_event;
308
309
310
311
312
313 new_event:
314 evsel = evsel__new(&attr);
315 if (evsel == NULL)
316 goto out;
317
318 evsel->precise_max = true;
319
320
321 if (asprintf(&evsel->name, "cycles%s%s%.*s",
322 (attr.precise_ip || attr.exclude_kernel) ? ":" : "",
323 attr.exclude_kernel ? "u" : "",
324 attr.precise_ip ? attr.precise_ip + 1 : 0, "ppp") < 0)
325 goto error_free;
326 out:
327 return evsel;
328 error_free:
329 evsel__delete(evsel);
330 evsel = NULL;
331 goto out;
332 }
333
334
335
336
337 struct evsel *perf_evsel__newtp_idx(const char *sys, const char *name, int idx)
338 {
339 struct evsel *evsel = zalloc(perf_evsel__object.size);
340 int err = -ENOMEM;
341
342 if (evsel == NULL) {
343 goto out_err;
344 } else {
345 struct perf_event_attr attr = {
346 .type = PERF_TYPE_TRACEPOINT,
347 .sample_type = (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME |
348 PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD),
349 };
350
351 if (asprintf(&evsel->name, "%s:%s", sys, name) < 0)
352 goto out_free;
353
354 evsel->tp_format = trace_event__tp_format(sys, name);
355 if (IS_ERR(evsel->tp_format)) {
356 err = PTR_ERR(evsel->tp_format);
357 goto out_free;
358 }
359
360 event_attr_init(&attr);
361 attr.config = evsel->tp_format->id;
362 attr.sample_period = 1;
363 evsel__init(evsel, &attr, idx);
364 }
365
366 return evsel;
367
368 out_free:
369 zfree(&evsel->name);
370 free(evsel);
371 out_err:
372 return ERR_PTR(err);
373 }
374
375 const char *perf_evsel__hw_names[PERF_COUNT_HW_MAX] = {
376 "cycles",
377 "instructions",
378 "cache-references",
379 "cache-misses",
380 "branches",
381 "branch-misses",
382 "bus-cycles",
383 "stalled-cycles-frontend",
384 "stalled-cycles-backend",
385 "ref-cycles",
386 };
387
388 static const char *__perf_evsel__hw_name(u64 config)
389 {
390 if (config < PERF_COUNT_HW_MAX && perf_evsel__hw_names[config])
391 return perf_evsel__hw_names[config];
392
393 return "unknown-hardware";
394 }
395
396 static int perf_evsel__add_modifiers(struct evsel *evsel, char *bf, size_t size)
397 {
398 int colon = 0, r = 0;
399 struct perf_event_attr *attr = &evsel->core.attr;
400 bool exclude_guest_default = false;
401
402 #define MOD_PRINT(context, mod) do { \
403 if (!attr->exclude_##context) { \
404 if (!colon) colon = ++r; \
405 r += scnprintf(bf + r, size - r, "%c", mod); \
406 } } while(0)
407
408 if (attr->exclude_kernel || attr->exclude_user || attr->exclude_hv) {
409 MOD_PRINT(kernel, 'k');
410 MOD_PRINT(user, 'u');
411 MOD_PRINT(hv, 'h');
412 exclude_guest_default = true;
413 }
414
415 if (attr->precise_ip) {
416 if (!colon)
417 colon = ++r;
418 r += scnprintf(bf + r, size - r, "%.*s", attr->precise_ip, "ppp");
419 exclude_guest_default = true;
420 }
421
422 if (attr->exclude_host || attr->exclude_guest == exclude_guest_default) {
423 MOD_PRINT(host, 'H');
424 MOD_PRINT(guest, 'G');
425 }
426 #undef MOD_PRINT
427 if (colon)
428 bf[colon - 1] = ':';
429 return r;
430 }
431
432 static int perf_evsel__hw_name(struct evsel *evsel, char *bf, size_t size)
433 {
434 int r = scnprintf(bf, size, "%s", __perf_evsel__hw_name(evsel->core.attr.config));
435 return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
436 }
437
438 const char *perf_evsel__sw_names[PERF_COUNT_SW_MAX] = {
439 "cpu-clock",
440 "task-clock",
441 "page-faults",
442 "context-switches",
443 "cpu-migrations",
444 "minor-faults",
445 "major-faults",
446 "alignment-faults",
447 "emulation-faults",
448 "dummy",
449 };
450
451 static const char *__perf_evsel__sw_name(u64 config)
452 {
453 if (config < PERF_COUNT_SW_MAX && perf_evsel__sw_names[config])
454 return perf_evsel__sw_names[config];
455 return "unknown-software";
456 }
457
458 static int perf_evsel__sw_name(struct evsel *evsel, char *bf, size_t size)
459 {
460 int r = scnprintf(bf, size, "%s", __perf_evsel__sw_name(evsel->core.attr.config));
461 return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
462 }
463
464 static int __perf_evsel__bp_name(char *bf, size_t size, u64 addr, u64 type)
465 {
466 int r;
467
468 r = scnprintf(bf, size, "mem:0x%" PRIx64 ":", addr);
469
470 if (type & HW_BREAKPOINT_R)
471 r += scnprintf(bf + r, size - r, "r");
472
473 if (type & HW_BREAKPOINT_W)
474 r += scnprintf(bf + r, size - r, "w");
475
476 if (type & HW_BREAKPOINT_X)
477 r += scnprintf(bf + r, size - r, "x");
478
479 return r;
480 }
481
482 static int perf_evsel__bp_name(struct evsel *evsel, char *bf, size_t size)
483 {
484 struct perf_event_attr *attr = &evsel->core.attr;
485 int r = __perf_evsel__bp_name(bf, size, attr->bp_addr, attr->bp_type);
486 return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
487 }
488
489 const char *perf_evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX]
490 [PERF_EVSEL__MAX_ALIASES] = {
491 { "L1-dcache", "l1-d", "l1d", "L1-data", },
492 { "L1-icache", "l1-i", "l1i", "L1-instruction", },
493 { "LLC", "L2", },
494 { "dTLB", "d-tlb", "Data-TLB", },
495 { "iTLB", "i-tlb", "Instruction-TLB", },
496 { "branch", "branches", "bpu", "btb", "bpc", },
497 { "node", },
498 };
499
500 const char *perf_evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX]
501 [PERF_EVSEL__MAX_ALIASES] = {
502 { "load", "loads", "read", },
503 { "store", "stores", "write", },
504 { "prefetch", "prefetches", "speculative-read", "speculative-load", },
505 };
506
507 const char *perf_evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
508 [PERF_EVSEL__MAX_ALIASES] = {
509 { "refs", "Reference", "ops", "access", },
510 { "misses", "miss", },
511 };
512
513 #define C(x) PERF_COUNT_HW_CACHE_##x
514 #define CACHE_READ (1 << C(OP_READ))
515 #define CACHE_WRITE (1 << C(OP_WRITE))
516 #define CACHE_PREFETCH (1 << C(OP_PREFETCH))
517 #define COP(x) (1 << x)
518
519
520
521
522
523
524 static unsigned long perf_evsel__hw_cache_stat[C(MAX)] = {
525 [C(L1D)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
526 [C(L1I)] = (CACHE_READ | CACHE_PREFETCH),
527 [C(LL)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
528 [C(DTLB)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
529 [C(ITLB)] = (CACHE_READ),
530 [C(BPU)] = (CACHE_READ),
531 [C(NODE)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
532 };
533
534 bool perf_evsel__is_cache_op_valid(u8 type, u8 op)
535 {
536 if (perf_evsel__hw_cache_stat[type] & COP(op))
537 return true;
538 else
539 return false;
540 }
541
542 int __perf_evsel__hw_cache_type_op_res_name(u8 type, u8 op, u8 result,
543 char *bf, size_t size)
544 {
545 if (result) {
546 return scnprintf(bf, size, "%s-%s-%s", perf_evsel__hw_cache[type][0],
547 perf_evsel__hw_cache_op[op][0],
548 perf_evsel__hw_cache_result[result][0]);
549 }
550
551 return scnprintf(bf, size, "%s-%s", perf_evsel__hw_cache[type][0],
552 perf_evsel__hw_cache_op[op][1]);
553 }
554
555 static int __perf_evsel__hw_cache_name(u64 config, char *bf, size_t size)
556 {
557 u8 op, result, type = (config >> 0) & 0xff;
558 const char *err = "unknown-ext-hardware-cache-type";
559
560 if (type >= PERF_COUNT_HW_CACHE_MAX)
561 goto out_err;
562
563 op = (config >> 8) & 0xff;
564 err = "unknown-ext-hardware-cache-op";
565 if (op >= PERF_COUNT_HW_CACHE_OP_MAX)
566 goto out_err;
567
568 result = (config >> 16) & 0xff;
569 err = "unknown-ext-hardware-cache-result";
570 if (result >= PERF_COUNT_HW_CACHE_RESULT_MAX)
571 goto out_err;
572
573 err = "invalid-cache";
574 if (!perf_evsel__is_cache_op_valid(type, op))
575 goto out_err;
576
577 return __perf_evsel__hw_cache_type_op_res_name(type, op, result, bf, size);
578 out_err:
579 return scnprintf(bf, size, "%s", err);
580 }
581
582 static int perf_evsel__hw_cache_name(struct evsel *evsel, char *bf, size_t size)
583 {
584 int ret = __perf_evsel__hw_cache_name(evsel->core.attr.config, bf, size);
585 return ret + perf_evsel__add_modifiers(evsel, bf + ret, size - ret);
586 }
587
588 static int perf_evsel__raw_name(struct evsel *evsel, char *bf, size_t size)
589 {
590 int ret = scnprintf(bf, size, "raw 0x%" PRIx64, evsel->core.attr.config);
591 return ret + perf_evsel__add_modifiers(evsel, bf + ret, size - ret);
592 }
593
594 static int perf_evsel__tool_name(char *bf, size_t size)
595 {
596 int ret = scnprintf(bf, size, "duration_time");
597 return ret;
598 }
599
600 const char *perf_evsel__name(struct evsel *evsel)
601 {
602 char bf[128];
603
604 if (!evsel)
605 goto out_unknown;
606
607 if (evsel->name)
608 return evsel->name;
609
610 switch (evsel->core.attr.type) {
611 case PERF_TYPE_RAW:
612 perf_evsel__raw_name(evsel, bf, sizeof(bf));
613 break;
614
615 case PERF_TYPE_HARDWARE:
616 perf_evsel__hw_name(evsel, bf, sizeof(bf));
617 break;
618
619 case PERF_TYPE_HW_CACHE:
620 perf_evsel__hw_cache_name(evsel, bf, sizeof(bf));
621 break;
622
623 case PERF_TYPE_SOFTWARE:
624 if (evsel->tool_event)
625 perf_evsel__tool_name(bf, sizeof(bf));
626 else
627 perf_evsel__sw_name(evsel, bf, sizeof(bf));
628 break;
629
630 case PERF_TYPE_TRACEPOINT:
631 scnprintf(bf, sizeof(bf), "%s", "unknown tracepoint");
632 break;
633
634 case PERF_TYPE_BREAKPOINT:
635 perf_evsel__bp_name(evsel, bf, sizeof(bf));
636 break;
637
638 default:
639 scnprintf(bf, sizeof(bf), "unknown attr type: %d",
640 evsel->core.attr.type);
641 break;
642 }
643
644 evsel->name = strdup(bf);
645
646 if (evsel->name)
647 return evsel->name;
648 out_unknown:
649 return "unknown";
650 }
651
652 const char *perf_evsel__group_name(struct evsel *evsel)
653 {
654 return evsel->group_name ?: "anon group";
655 }
656
657
658
659
660
661
662
663
664
665
666
667 int perf_evsel__group_desc(struct evsel *evsel, char *buf, size_t size)
668 {
669 int ret = 0;
670 struct evsel *pos;
671 const char *group_name = perf_evsel__group_name(evsel);
672
673 if (!evsel->forced_leader)
674 ret = scnprintf(buf, size, "%s { ", group_name);
675
676 ret += scnprintf(buf + ret, size - ret, "%s",
677 perf_evsel__name(evsel));
678
679 for_each_group_member(pos, evsel)
680 ret += scnprintf(buf + ret, size - ret, ", %s",
681 perf_evsel__name(pos));
682
683 if (!evsel->forced_leader)
684 ret += scnprintf(buf + ret, size - ret, " }");
685
686 return ret;
687 }
688
689 static void __perf_evsel__config_callchain(struct evsel *evsel,
690 struct record_opts *opts,
691 struct callchain_param *param)
692 {
693 bool function = perf_evsel__is_function_event(evsel);
694 struct perf_event_attr *attr = &evsel->core.attr;
695
696 perf_evsel__set_sample_bit(evsel, CALLCHAIN);
697
698 attr->sample_max_stack = param->max_stack;
699
700 if (opts->kernel_callchains)
701 attr->exclude_callchain_user = 1;
702 if (opts->user_callchains)
703 attr->exclude_callchain_kernel = 1;
704 if (param->record_mode == CALLCHAIN_LBR) {
705 if (!opts->branch_stack) {
706 if (attr->exclude_user) {
707 pr_warning("LBR callstack option is only available "
708 "to get user callchain information. "
709 "Falling back to framepointers.\n");
710 } else {
711 perf_evsel__set_sample_bit(evsel, BRANCH_STACK);
712 attr->branch_sample_type = PERF_SAMPLE_BRANCH_USER |
713 PERF_SAMPLE_BRANCH_CALL_STACK |
714 PERF_SAMPLE_BRANCH_NO_CYCLES |
715 PERF_SAMPLE_BRANCH_NO_FLAGS;
716 }
717 } else
718 pr_warning("Cannot use LBR callstack with branch stack. "
719 "Falling back to framepointers.\n");
720 }
721
722 if (param->record_mode == CALLCHAIN_DWARF) {
723 if (!function) {
724 perf_evsel__set_sample_bit(evsel, REGS_USER);
725 perf_evsel__set_sample_bit(evsel, STACK_USER);
726 if (opts->sample_user_regs && DWARF_MINIMAL_REGS != PERF_REGS_MASK) {
727 attr->sample_regs_user |= DWARF_MINIMAL_REGS;
728 pr_warning("WARNING: The use of --call-graph=dwarf may require all the user registers, "
729 "specifying a subset with --user-regs may render DWARF unwinding unreliable, "
730 "so the minimal registers set (IP, SP) is explicitly forced.\n");
731 } else {
732 attr->sample_regs_user |= PERF_REGS_MASK;
733 }
734 attr->sample_stack_user = param->dump_size;
735 attr->exclude_callchain_user = 1;
736 } else {
737 pr_info("Cannot use DWARF unwind for function trace event,"
738 " falling back to framepointers.\n");
739 }
740 }
741
742 if (function) {
743 pr_info("Disabling user space callchains for function trace event.\n");
744 attr->exclude_callchain_user = 1;
745 }
746 }
747
748 void perf_evsel__config_callchain(struct evsel *evsel,
749 struct record_opts *opts,
750 struct callchain_param *param)
751 {
752 if (param->enabled)
753 return __perf_evsel__config_callchain(evsel, opts, param);
754 }
755
756 static void
757 perf_evsel__reset_callgraph(struct evsel *evsel,
758 struct callchain_param *param)
759 {
760 struct perf_event_attr *attr = &evsel->core.attr;
761
762 perf_evsel__reset_sample_bit(evsel, CALLCHAIN);
763 if (param->record_mode == CALLCHAIN_LBR) {
764 perf_evsel__reset_sample_bit(evsel, BRANCH_STACK);
765 attr->branch_sample_type &= ~(PERF_SAMPLE_BRANCH_USER |
766 PERF_SAMPLE_BRANCH_CALL_STACK);
767 }
768 if (param->record_mode == CALLCHAIN_DWARF) {
769 perf_evsel__reset_sample_bit(evsel, REGS_USER);
770 perf_evsel__reset_sample_bit(evsel, STACK_USER);
771 }
772 }
773
774 static void apply_config_terms(struct evsel *evsel,
775 struct record_opts *opts, bool track)
776 {
777 struct perf_evsel_config_term *term;
778 struct list_head *config_terms = &evsel->config_terms;
779 struct perf_event_attr *attr = &evsel->core.attr;
780
781 struct callchain_param param = {
782 .record_mode = callchain_param.record_mode,
783 };
784 u32 dump_size = 0;
785 int max_stack = 0;
786 const char *callgraph_buf = NULL;
787
788 list_for_each_entry(term, config_terms, list) {
789 switch (term->type) {
790 case PERF_EVSEL__CONFIG_TERM_PERIOD:
791 if (!(term->weak && opts->user_interval != ULLONG_MAX)) {
792 attr->sample_period = term->val.period;
793 attr->freq = 0;
794 perf_evsel__reset_sample_bit(evsel, PERIOD);
795 }
796 break;
797 case PERF_EVSEL__CONFIG_TERM_FREQ:
798 if (!(term->weak && opts->user_freq != UINT_MAX)) {
799 attr->sample_freq = term->val.freq;
800 attr->freq = 1;
801 perf_evsel__set_sample_bit(evsel, PERIOD);
802 }
803 break;
804 case PERF_EVSEL__CONFIG_TERM_TIME:
805 if (term->val.time)
806 perf_evsel__set_sample_bit(evsel, TIME);
807 else
808 perf_evsel__reset_sample_bit(evsel, TIME);
809 break;
810 case PERF_EVSEL__CONFIG_TERM_CALLGRAPH:
811 callgraph_buf = term->val.callgraph;
812 break;
813 case PERF_EVSEL__CONFIG_TERM_BRANCH:
814 if (term->val.branch && strcmp(term->val.branch, "no")) {
815 perf_evsel__set_sample_bit(evsel, BRANCH_STACK);
816 parse_branch_str(term->val.branch,
817 &attr->branch_sample_type);
818 } else
819 perf_evsel__reset_sample_bit(evsel, BRANCH_STACK);
820 break;
821 case PERF_EVSEL__CONFIG_TERM_STACK_USER:
822 dump_size = term->val.stack_user;
823 break;
824 case PERF_EVSEL__CONFIG_TERM_MAX_STACK:
825 max_stack = term->val.max_stack;
826 break;
827 case PERF_EVSEL__CONFIG_TERM_MAX_EVENTS:
828 evsel->max_events = term->val.max_events;
829 break;
830 case PERF_EVSEL__CONFIG_TERM_INHERIT:
831
832
833
834
835
836
837 attr->inherit = term->val.inherit ? 1 : 0;
838 break;
839 case PERF_EVSEL__CONFIG_TERM_OVERWRITE:
840 attr->write_backward = term->val.overwrite ? 1 : 0;
841 break;
842 case PERF_EVSEL__CONFIG_TERM_DRV_CFG:
843 break;
844 case PERF_EVSEL__CONFIG_TERM_PERCORE:
845 break;
846 case PERF_EVSEL__CONFIG_TERM_AUX_OUTPUT:
847 attr->aux_output = term->val.aux_output ? 1 : 0;
848 break;
849 default:
850 break;
851 }
852 }
853
854
855 if ((callgraph_buf != NULL) || (dump_size > 0) || max_stack) {
856 bool sample_address = false;
857
858 if (max_stack) {
859 param.max_stack = max_stack;
860 if (callgraph_buf == NULL)
861 callgraph_buf = "fp";
862 }
863
864
865 if (callgraph_buf != NULL) {
866 if (!strcmp(callgraph_buf, "no")) {
867 param.enabled = false;
868 param.record_mode = CALLCHAIN_NONE;
869 } else {
870 param.enabled = true;
871 if (parse_callchain_record(callgraph_buf, ¶m)) {
872 pr_err("per-event callgraph setting for %s failed. "
873 "Apply callgraph global setting for it\n",
874 evsel->name);
875 return;
876 }
877 if (param.record_mode == CALLCHAIN_DWARF)
878 sample_address = true;
879 }
880 }
881 if (dump_size > 0) {
882 dump_size = round_up(dump_size, sizeof(u64));
883 param.dump_size = dump_size;
884 }
885
886
887 if (callchain_param.enabled)
888 perf_evsel__reset_callgraph(evsel, &callchain_param);
889
890
891 if (param.enabled) {
892 if (sample_address) {
893 perf_evsel__set_sample_bit(evsel, ADDR);
894 perf_evsel__set_sample_bit(evsel, DATA_SRC);
895 evsel->core.attr.mmap_data = track;
896 }
897 perf_evsel__config_callchain(evsel, opts, ¶m);
898 }
899 }
900 }
901
902 static bool is_dummy_event(struct evsel *evsel)
903 {
904 return (evsel->core.attr.type == PERF_TYPE_SOFTWARE) &&
905 (evsel->core.attr.config == PERF_COUNT_SW_DUMMY);
906 }
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936 void perf_evsel__config(struct evsel *evsel, struct record_opts *opts,
937 struct callchain_param *callchain)
938 {
939 struct evsel *leader = evsel->leader;
940 struct perf_event_attr *attr = &evsel->core.attr;
941 int track = evsel->tracking;
942 bool per_cpu = opts->target.default_per_cpu && !opts->target.per_thread;
943
944 attr->sample_id_all = perf_missing_features.sample_id_all ? 0 : 1;
945 attr->inherit = !opts->no_inherit;
946 attr->write_backward = opts->overwrite ? 1 : 0;
947
948 perf_evsel__set_sample_bit(evsel, IP);
949 perf_evsel__set_sample_bit(evsel, TID);
950
951 if (evsel->sample_read) {
952 perf_evsel__set_sample_bit(evsel, READ);
953
954
955
956
957
958 perf_evsel__set_sample_id(evsel, false);
959
960
961
962
963
964 if (leader->core.nr_members > 1) {
965 attr->read_format |= PERF_FORMAT_GROUP;
966 attr->inherit = 0;
967 }
968 }
969
970
971
972
973
974 if (!attr->sample_period || (opts->user_freq != UINT_MAX ||
975 opts->user_interval != ULLONG_MAX)) {
976 if (opts->freq) {
977 perf_evsel__set_sample_bit(evsel, PERIOD);
978 attr->freq = 1;
979 attr->sample_freq = opts->freq;
980 } else {
981 attr->sample_period = opts->default_interval;
982 }
983 }
984
985
986
987
988
989 if ((leader != evsel) && leader->sample_read) {
990 attr->freq = 0;
991 attr->sample_freq = 0;
992 attr->sample_period = 0;
993 attr->write_backward = 0;
994
995
996
997
998
999
1000
1001 attr->sample_type = leader->core.attr.sample_type;
1002 }
1003
1004 if (opts->no_samples)
1005 attr->sample_freq = 0;
1006
1007 if (opts->inherit_stat) {
1008 evsel->core.attr.read_format |=
1009 PERF_FORMAT_TOTAL_TIME_ENABLED |
1010 PERF_FORMAT_TOTAL_TIME_RUNNING |
1011 PERF_FORMAT_ID;
1012 attr->inherit_stat = 1;
1013 }
1014
1015 if (opts->sample_address) {
1016 perf_evsel__set_sample_bit(evsel, ADDR);
1017 attr->mmap_data = track;
1018 }
1019
1020
1021
1022
1023
1024
1025 if (perf_evsel__is_function_event(evsel))
1026 evsel->core.attr.exclude_callchain_user = 1;
1027
1028 if (callchain && callchain->enabled && !evsel->no_aux_samples)
1029 perf_evsel__config_callchain(evsel, opts, callchain);
1030
1031 if (opts->sample_intr_regs) {
1032 attr->sample_regs_intr = opts->sample_intr_regs;
1033 perf_evsel__set_sample_bit(evsel, REGS_INTR);
1034 }
1035
1036 if (opts->sample_user_regs) {
1037 attr->sample_regs_user |= opts->sample_user_regs;
1038 perf_evsel__set_sample_bit(evsel, REGS_USER);
1039 }
1040
1041 if (target__has_cpu(&opts->target) || opts->sample_cpu)
1042 perf_evsel__set_sample_bit(evsel, CPU);
1043
1044
1045
1046
1047 if (opts->sample_time &&
1048 (!perf_missing_features.sample_id_all &&
1049 (!opts->no_inherit || target__has_cpu(&opts->target) || per_cpu ||
1050 opts->sample_time_set)))
1051 perf_evsel__set_sample_bit(evsel, TIME);
1052
1053 if (opts->raw_samples && !evsel->no_aux_samples) {
1054 perf_evsel__set_sample_bit(evsel, TIME);
1055 perf_evsel__set_sample_bit(evsel, RAW);
1056 perf_evsel__set_sample_bit(evsel, CPU);
1057 }
1058
1059 if (opts->sample_address)
1060 perf_evsel__set_sample_bit(evsel, DATA_SRC);
1061
1062 if (opts->sample_phys_addr)
1063 perf_evsel__set_sample_bit(evsel, PHYS_ADDR);
1064
1065 if (opts->no_buffering) {
1066 attr->watermark = 0;
1067 attr->wakeup_events = 1;
1068 }
1069 if (opts->branch_stack && !evsel->no_aux_samples) {
1070 perf_evsel__set_sample_bit(evsel, BRANCH_STACK);
1071 attr->branch_sample_type = opts->branch_stack;
1072 }
1073
1074 if (opts->sample_weight)
1075 perf_evsel__set_sample_bit(evsel, WEIGHT);
1076
1077 attr->task = track;
1078 attr->mmap = track;
1079 attr->mmap2 = track && !perf_missing_features.mmap2;
1080 attr->comm = track;
1081 attr->ksymbol = track && !perf_missing_features.ksymbol;
1082 attr->bpf_event = track && !opts->no_bpf_event && !perf_missing_features.bpf;
1083
1084 if (opts->record_namespaces)
1085 attr->namespaces = track;
1086
1087 if (opts->record_switch_events)
1088 attr->context_switch = track;
1089
1090 if (opts->sample_transaction)
1091 perf_evsel__set_sample_bit(evsel, TRANSACTION);
1092
1093 if (opts->running_time) {
1094 evsel->core.attr.read_format |=
1095 PERF_FORMAT_TOTAL_TIME_ENABLED |
1096 PERF_FORMAT_TOTAL_TIME_RUNNING;
1097 }
1098
1099
1100
1101
1102
1103
1104
1105 if (perf_evsel__is_group_leader(evsel))
1106 attr->disabled = 1;
1107
1108
1109
1110
1111
1112 if (target__none(&opts->target) && perf_evsel__is_group_leader(evsel) &&
1113 !opts->initial_delay)
1114 attr->enable_on_exec = 1;
1115
1116 if (evsel->immediate) {
1117 attr->disabled = 0;
1118 attr->enable_on_exec = 0;
1119 }
1120
1121 clockid = opts->clockid;
1122 if (opts->use_clockid) {
1123 attr->use_clockid = 1;
1124 attr->clockid = opts->clockid;
1125 }
1126
1127 if (evsel->precise_max)
1128 attr->precise_ip = 3;
1129
1130 if (opts->all_user) {
1131 attr->exclude_kernel = 1;
1132 attr->exclude_user = 0;
1133 }
1134
1135 if (opts->all_kernel) {
1136 attr->exclude_kernel = 0;
1137 attr->exclude_user = 1;
1138 }
1139
1140 if (evsel->core.own_cpus || evsel->unit)
1141 evsel->core.attr.read_format |= PERF_FORMAT_ID;
1142
1143
1144
1145
1146
1147 apply_config_terms(evsel, opts, track);
1148
1149 evsel->ignore_missing_thread = opts->ignore_missing_thread;
1150
1151
1152 if (opts->period_set) {
1153 if (opts->period)
1154 perf_evsel__set_sample_bit(evsel, PERIOD);
1155 else
1156 perf_evsel__reset_sample_bit(evsel, PERIOD);
1157 }
1158
1159
1160
1161
1162
1163
1164 if (opts->initial_delay && is_dummy_event(evsel))
1165 perf_evsel__reset_sample_bit(evsel, BRANCH_STACK);
1166 }
1167
1168 int perf_evsel__set_filter(struct evsel *evsel, const char *filter)
1169 {
1170 char *new_filter = strdup(filter);
1171
1172 if (new_filter != NULL) {
1173 free(evsel->filter);
1174 evsel->filter = new_filter;
1175 return 0;
1176 }
1177
1178 return -1;
1179 }
1180
1181 static int perf_evsel__append_filter(struct evsel *evsel,
1182 const char *fmt, const char *filter)
1183 {
1184 char *new_filter;
1185
1186 if (evsel->filter == NULL)
1187 return perf_evsel__set_filter(evsel, filter);
1188
1189 if (asprintf(&new_filter, fmt, evsel->filter, filter) > 0) {
1190 free(evsel->filter);
1191 evsel->filter = new_filter;
1192 return 0;
1193 }
1194
1195 return -1;
1196 }
1197
1198 int perf_evsel__append_tp_filter(struct evsel *evsel, const char *filter)
1199 {
1200 return perf_evsel__append_filter(evsel, "(%s) && (%s)", filter);
1201 }
1202
1203 int perf_evsel__append_addr_filter(struct evsel *evsel, const char *filter)
1204 {
1205 return perf_evsel__append_filter(evsel, "%s,%s", filter);
1206 }
1207
1208 int evsel__enable(struct evsel *evsel)
1209 {
1210 int err = perf_evsel__enable(&evsel->core);
1211
1212 if (!err)
1213 evsel->disabled = false;
1214
1215 return err;
1216 }
1217
1218 int evsel__disable(struct evsel *evsel)
1219 {
1220 int err = perf_evsel__disable(&evsel->core);
1221
1222
1223
1224
1225
1226
1227 if (!err)
1228 evsel->disabled = true;
1229
1230 return err;
1231 }
1232
1233 static void perf_evsel__free_config_terms(struct evsel *evsel)
1234 {
1235 struct perf_evsel_config_term *term, *h;
1236
1237 list_for_each_entry_safe(term, h, &evsel->config_terms, list) {
1238 list_del_init(&term->list);
1239 free(term);
1240 }
1241 }
1242
1243 void perf_evsel__exit(struct evsel *evsel)
1244 {
1245 assert(list_empty(&evsel->core.node));
1246 assert(evsel->evlist == NULL);
1247 perf_evsel__free_counts(evsel);
1248 perf_evsel__free_fd(&evsel->core);
1249 perf_evsel__free_id(&evsel->core);
1250 perf_evsel__free_config_terms(evsel);
1251 cgroup__put(evsel->cgrp);
1252 perf_cpu_map__put(evsel->core.cpus);
1253 perf_cpu_map__put(evsel->core.own_cpus);
1254 perf_thread_map__put(evsel->core.threads);
1255 zfree(&evsel->group_name);
1256 zfree(&evsel->name);
1257 perf_evsel__object.fini(evsel);
1258 }
1259
1260 void evsel__delete(struct evsel *evsel)
1261 {
1262 perf_evsel__exit(evsel);
1263 free(evsel);
1264 }
1265
1266 void perf_evsel__compute_deltas(struct evsel *evsel, int cpu, int thread,
1267 struct perf_counts_values *count)
1268 {
1269 struct perf_counts_values tmp;
1270
1271 if (!evsel->prev_raw_counts)
1272 return;
1273
1274 if (cpu == -1) {
1275 tmp = evsel->prev_raw_counts->aggr;
1276 evsel->prev_raw_counts->aggr = *count;
1277 } else {
1278 tmp = *perf_counts(evsel->prev_raw_counts, cpu, thread);
1279 *perf_counts(evsel->prev_raw_counts, cpu, thread) = *count;
1280 }
1281
1282 count->val = count->val - tmp.val;
1283 count->ena = count->ena - tmp.ena;
1284 count->run = count->run - tmp.run;
1285 }
1286
1287 void perf_counts_values__scale(struct perf_counts_values *count,
1288 bool scale, s8 *pscaled)
1289 {
1290 s8 scaled = 0;
1291
1292 if (scale) {
1293 if (count->run == 0) {
1294 scaled = -1;
1295 count->val = 0;
1296 } else if (count->run < count->ena) {
1297 scaled = 1;
1298 count->val = (u64)((double) count->val * count->ena / count->run);
1299 }
1300 }
1301
1302 if (pscaled)
1303 *pscaled = scaled;
1304 }
1305
1306 static int
1307 perf_evsel__read_one(struct evsel *evsel, int cpu, int thread)
1308 {
1309 struct perf_counts_values *count = perf_counts(evsel->counts, cpu, thread);
1310
1311 return perf_evsel__read(&evsel->core, cpu, thread, count);
1312 }
1313
1314 static void
1315 perf_evsel__set_count(struct evsel *counter, int cpu, int thread,
1316 u64 val, u64 ena, u64 run)
1317 {
1318 struct perf_counts_values *count;
1319
1320 count = perf_counts(counter->counts, cpu, thread);
1321
1322 count->val = val;
1323 count->ena = ena;
1324 count->run = run;
1325
1326 perf_counts__set_loaded(counter->counts, cpu, thread, true);
1327 }
1328
1329 static int
1330 perf_evsel__process_group_data(struct evsel *leader,
1331 int cpu, int thread, u64 *data)
1332 {
1333 u64 read_format = leader->core.attr.read_format;
1334 struct sample_read_value *v;
1335 u64 nr, ena = 0, run = 0, i;
1336
1337 nr = *data++;
1338
1339 if (nr != (u64) leader->core.nr_members)
1340 return -EINVAL;
1341
1342 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
1343 ena = *data++;
1344
1345 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
1346 run = *data++;
1347
1348 v = (struct sample_read_value *) data;
1349
1350 perf_evsel__set_count(leader, cpu, thread,
1351 v[0].value, ena, run);
1352
1353 for (i = 1; i < nr; i++) {
1354 struct evsel *counter;
1355
1356 counter = perf_evlist__id2evsel(leader->evlist, v[i].id);
1357 if (!counter)
1358 return -EINVAL;
1359
1360 perf_evsel__set_count(counter, cpu, thread,
1361 v[i].value, ena, run);
1362 }
1363
1364 return 0;
1365 }
1366
1367 static int
1368 perf_evsel__read_group(struct evsel *leader, int cpu, int thread)
1369 {
1370 struct perf_stat_evsel *ps = leader->stats;
1371 u64 read_format = leader->core.attr.read_format;
1372 int size = perf_evsel__read_size(&leader->core);
1373 u64 *data = ps->group_data;
1374
1375 if (!(read_format & PERF_FORMAT_ID))
1376 return -EINVAL;
1377
1378 if (!perf_evsel__is_group_leader(leader))
1379 return -EINVAL;
1380
1381 if (!data) {
1382 data = zalloc(size);
1383 if (!data)
1384 return -ENOMEM;
1385
1386 ps->group_data = data;
1387 }
1388
1389 if (FD(leader, cpu, thread) < 0)
1390 return -EINVAL;
1391
1392 if (readn(FD(leader, cpu, thread), data, size) <= 0)
1393 return -errno;
1394
1395 return perf_evsel__process_group_data(leader, cpu, thread, data);
1396 }
1397
1398 int perf_evsel__read_counter(struct evsel *evsel, int cpu, int thread)
1399 {
1400 u64 read_format = evsel->core.attr.read_format;
1401
1402 if (read_format & PERF_FORMAT_GROUP)
1403 return perf_evsel__read_group(evsel, cpu, thread);
1404 else
1405 return perf_evsel__read_one(evsel, cpu, thread);
1406 }
1407
1408 int __perf_evsel__read_on_cpu(struct evsel *evsel,
1409 int cpu, int thread, bool scale)
1410 {
1411 struct perf_counts_values count;
1412 size_t nv = scale ? 3 : 1;
1413
1414 if (FD(evsel, cpu, thread) < 0)
1415 return -EINVAL;
1416
1417 if (evsel->counts == NULL && perf_evsel__alloc_counts(evsel, cpu + 1, thread + 1) < 0)
1418 return -ENOMEM;
1419
1420 if (readn(FD(evsel, cpu, thread), &count, nv * sizeof(u64)) <= 0)
1421 return -errno;
1422
1423 perf_evsel__compute_deltas(evsel, cpu, thread, &count);
1424 perf_counts_values__scale(&count, scale, NULL);
1425 *perf_counts(evsel->counts, cpu, thread) = count;
1426 return 0;
1427 }
1428
1429 static int get_group_fd(struct evsel *evsel, int cpu, int thread)
1430 {
1431 struct evsel *leader = evsel->leader;
1432 int fd;
1433
1434 if (perf_evsel__is_group_leader(evsel))
1435 return -1;
1436
1437
1438
1439
1440
1441 BUG_ON(!leader->core.fd);
1442
1443 fd = FD(leader, cpu, thread);
1444 BUG_ON(fd == -1);
1445
1446 return fd;
1447 }
1448
1449 static void perf_evsel__remove_fd(struct evsel *pos,
1450 int nr_cpus, int nr_threads,
1451 int thread_idx)
1452 {
1453 for (int cpu = 0; cpu < nr_cpus; cpu++)
1454 for (int thread = thread_idx; thread < nr_threads - 1; thread++)
1455 FD(pos, cpu, thread) = FD(pos, cpu, thread + 1);
1456 }
1457
1458 static int update_fds(struct evsel *evsel,
1459 int nr_cpus, int cpu_idx,
1460 int nr_threads, int thread_idx)
1461 {
1462 struct evsel *pos;
1463
1464 if (cpu_idx >= nr_cpus || thread_idx >= nr_threads)
1465 return -EINVAL;
1466
1467 evlist__for_each_entry(evsel->evlist, pos) {
1468 nr_cpus = pos != evsel ? nr_cpus : cpu_idx;
1469
1470 perf_evsel__remove_fd(pos, nr_cpus, nr_threads, thread_idx);
1471
1472
1473
1474
1475
1476 if (pos == evsel)
1477 break;
1478 }
1479 return 0;
1480 }
1481
1482 static bool ignore_missing_thread(struct evsel *evsel,
1483 int nr_cpus, int cpu,
1484 struct perf_thread_map *threads,
1485 int thread, int err)
1486 {
1487 pid_t ignore_pid = perf_thread_map__pid(threads, thread);
1488
1489 if (!evsel->ignore_missing_thread)
1490 return false;
1491
1492
1493 if (evsel->core.system_wide)
1494 return false;
1495
1496
1497 if (err != -ESRCH)
1498 return false;
1499
1500
1501 if (threads->nr == 1)
1502 return false;
1503
1504
1505
1506
1507
1508 if (update_fds(evsel, nr_cpus, cpu, threads->nr, thread))
1509 return false;
1510
1511 if (thread_map__remove(threads, thread))
1512 return false;
1513
1514 pr_warning("WARNING: Ignored open failure for pid %d\n",
1515 ignore_pid);
1516 return true;
1517 }
1518
1519 static int __open_attr__fprintf(FILE *fp, const char *name, const char *val,
1520 void *priv __maybe_unused)
1521 {
1522 return fprintf(fp, " %-32s %s\n", name, val);
1523 }
1524
1525 static void display_attr(struct perf_event_attr *attr)
1526 {
1527 if (verbose >= 2) {
1528 fprintf(stderr, "%.60s\n", graph_dotted_line);
1529 fprintf(stderr, "perf_event_attr:\n");
1530 perf_event_attr__fprintf(stderr, attr, __open_attr__fprintf, NULL);
1531 fprintf(stderr, "%.60s\n", graph_dotted_line);
1532 }
1533 }
1534
1535 static int perf_event_open(struct evsel *evsel,
1536 pid_t pid, int cpu, int group_fd,
1537 unsigned long flags)
1538 {
1539 int precise_ip = evsel->core.attr.precise_ip;
1540 int fd;
1541
1542 while (1) {
1543 pr_debug2("sys_perf_event_open: pid %d cpu %d group_fd %d flags %#lx",
1544 pid, cpu, group_fd, flags);
1545
1546 fd = sys_perf_event_open(&evsel->core.attr, pid, cpu, group_fd, flags);
1547 if (fd >= 0)
1548 break;
1549
1550
1551 if (!evsel->precise_max)
1552 break;
1553
1554
1555
1556
1557
1558 if (!evsel->core.attr.precise_ip) {
1559 evsel->core.attr.precise_ip = precise_ip;
1560 break;
1561 }
1562
1563 pr_debug2("\nsys_perf_event_open failed, error %d\n", -ENOTSUP);
1564 evsel->core.attr.precise_ip--;
1565 pr_debug2("decreasing precise_ip by one (%d)\n", evsel->core.attr.precise_ip);
1566 display_attr(&evsel->core.attr);
1567 }
1568
1569 return fd;
1570 }
1571
1572 int evsel__open(struct evsel *evsel, struct perf_cpu_map *cpus,
1573 struct perf_thread_map *threads)
1574 {
1575 int cpu, thread, nthreads;
1576 unsigned long flags = PERF_FLAG_FD_CLOEXEC;
1577 int pid = -1, err;
1578 enum { NO_CHANGE, SET_TO_MAX, INCREASED_MAX } set_rlimit = NO_CHANGE;
1579
1580 if ((perf_missing_features.write_backward && evsel->core.attr.write_backward) ||
1581 (perf_missing_features.aux_output && evsel->core.attr.aux_output))
1582 return -EINVAL;
1583
1584 if (cpus == NULL) {
1585 static struct perf_cpu_map *empty_cpu_map;
1586
1587 if (empty_cpu_map == NULL) {
1588 empty_cpu_map = perf_cpu_map__dummy_new();
1589 if (empty_cpu_map == NULL)
1590 return -ENOMEM;
1591 }
1592
1593 cpus = empty_cpu_map;
1594 }
1595
1596 if (threads == NULL) {
1597 static struct perf_thread_map *empty_thread_map;
1598
1599 if (empty_thread_map == NULL) {
1600 empty_thread_map = thread_map__new_by_tid(-1);
1601 if (empty_thread_map == NULL)
1602 return -ENOMEM;
1603 }
1604
1605 threads = empty_thread_map;
1606 }
1607
1608 if (evsel->core.system_wide)
1609 nthreads = 1;
1610 else
1611 nthreads = threads->nr;
1612
1613 if (evsel->core.fd == NULL &&
1614 perf_evsel__alloc_fd(&evsel->core, cpus->nr, nthreads) < 0)
1615 return -ENOMEM;
1616
1617 if (evsel->cgrp) {
1618 flags |= PERF_FLAG_PID_CGROUP;
1619 pid = evsel->cgrp->fd;
1620 }
1621
1622 fallback_missing_features:
1623 if (perf_missing_features.clockid_wrong)
1624 evsel->core.attr.clockid = CLOCK_MONOTONIC;
1625 if (perf_missing_features.clockid) {
1626 evsel->core.attr.use_clockid = 0;
1627 evsel->core.attr.clockid = 0;
1628 }
1629 if (perf_missing_features.cloexec)
1630 flags &= ~(unsigned long)PERF_FLAG_FD_CLOEXEC;
1631 if (perf_missing_features.mmap2)
1632 evsel->core.attr.mmap2 = 0;
1633 if (perf_missing_features.exclude_guest)
1634 evsel->core.attr.exclude_guest = evsel->core.attr.exclude_host = 0;
1635 if (perf_missing_features.lbr_flags)
1636 evsel->core.attr.branch_sample_type &= ~(PERF_SAMPLE_BRANCH_NO_FLAGS |
1637 PERF_SAMPLE_BRANCH_NO_CYCLES);
1638 if (perf_missing_features.group_read && evsel->core.attr.inherit)
1639 evsel->core.attr.read_format &= ~(PERF_FORMAT_GROUP|PERF_FORMAT_ID);
1640 if (perf_missing_features.ksymbol)
1641 evsel->core.attr.ksymbol = 0;
1642 if (perf_missing_features.bpf)
1643 evsel->core.attr.bpf_event = 0;
1644 retry_sample_id:
1645 if (perf_missing_features.sample_id_all)
1646 evsel->core.attr.sample_id_all = 0;
1647
1648 display_attr(&evsel->core.attr);
1649
1650 for (cpu = 0; cpu < cpus->nr; cpu++) {
1651
1652 for (thread = 0; thread < nthreads; thread++) {
1653 int fd, group_fd;
1654
1655 if (!evsel->cgrp && !evsel->core.system_wide)
1656 pid = perf_thread_map__pid(threads, thread);
1657
1658 group_fd = get_group_fd(evsel, cpu, thread);
1659 retry_open:
1660 test_attr__ready();
1661
1662 fd = perf_event_open(evsel, pid, cpus->map[cpu],
1663 group_fd, flags);
1664
1665 FD(evsel, cpu, thread) = fd;
1666
1667 if (fd < 0) {
1668 err = -errno;
1669
1670 if (ignore_missing_thread(evsel, cpus->nr, cpu, threads, thread, err)) {
1671
1672
1673
1674
1675
1676 nthreads--;
1677 thread--;
1678
1679
1680 err = 0;
1681 continue;
1682 }
1683
1684 pr_debug2("\nsys_perf_event_open failed, error %d\n",
1685 err);
1686 goto try_fallback;
1687 }
1688
1689 pr_debug2(" = %d\n", fd);
1690
1691 if (evsel->bpf_fd >= 0) {
1692 int evt_fd = fd;
1693 int bpf_fd = evsel->bpf_fd;
1694
1695 err = ioctl(evt_fd,
1696 PERF_EVENT_IOC_SET_BPF,
1697 bpf_fd);
1698 if (err && errno != EEXIST) {
1699 pr_err("failed to attach bpf fd %d: %s\n",
1700 bpf_fd, strerror(errno));
1701 err = -EINVAL;
1702 goto out_close;
1703 }
1704 }
1705
1706 set_rlimit = NO_CHANGE;
1707
1708
1709
1710
1711
1712
1713 if (perf_missing_features.clockid ||
1714 perf_missing_features.clockid_wrong) {
1715 err = -EINVAL;
1716 goto out_close;
1717 }
1718 }
1719 }
1720
1721 return 0;
1722
1723 try_fallback:
1724
1725
1726
1727
1728 if (err == -EMFILE && set_rlimit < INCREASED_MAX) {
1729 struct rlimit l;
1730 int old_errno = errno;
1731
1732 if (getrlimit(RLIMIT_NOFILE, &l) == 0) {
1733 if (set_rlimit == NO_CHANGE)
1734 l.rlim_cur = l.rlim_max;
1735 else {
1736 l.rlim_cur = l.rlim_max + 1000;
1737 l.rlim_max = l.rlim_cur;
1738 }
1739 if (setrlimit(RLIMIT_NOFILE, &l) == 0) {
1740 set_rlimit++;
1741 errno = old_errno;
1742 goto retry_open;
1743 }
1744 }
1745 errno = old_errno;
1746 }
1747
1748 if (err != -EINVAL || cpu > 0 || thread > 0)
1749 goto out_close;
1750
1751
1752
1753
1754
1755 if (!perf_missing_features.aux_output && evsel->core.attr.aux_output) {
1756 perf_missing_features.aux_output = true;
1757 pr_debug2("Kernel has no attr.aux_output support, bailing out\n");
1758 goto out_close;
1759 } else if (!perf_missing_features.bpf && evsel->core.attr.bpf_event) {
1760 perf_missing_features.bpf = true;
1761 pr_debug2("switching off bpf_event\n");
1762 goto fallback_missing_features;
1763 } else if (!perf_missing_features.ksymbol && evsel->core.attr.ksymbol) {
1764 perf_missing_features.ksymbol = true;
1765 pr_debug2("switching off ksymbol\n");
1766 goto fallback_missing_features;
1767 } else if (!perf_missing_features.write_backward && evsel->core.attr.write_backward) {
1768 perf_missing_features.write_backward = true;
1769 pr_debug2("switching off write_backward\n");
1770 goto out_close;
1771 } else if (!perf_missing_features.clockid_wrong && evsel->core.attr.use_clockid) {
1772 perf_missing_features.clockid_wrong = true;
1773 pr_debug2("switching off clockid\n");
1774 goto fallback_missing_features;
1775 } else if (!perf_missing_features.clockid && evsel->core.attr.use_clockid) {
1776 perf_missing_features.clockid = true;
1777 pr_debug2("switching off use_clockid\n");
1778 goto fallback_missing_features;
1779 } else if (!perf_missing_features.cloexec && (flags & PERF_FLAG_FD_CLOEXEC)) {
1780 perf_missing_features.cloexec = true;
1781 pr_debug2("switching off cloexec flag\n");
1782 goto fallback_missing_features;
1783 } else if (!perf_missing_features.mmap2 && evsel->core.attr.mmap2) {
1784 perf_missing_features.mmap2 = true;
1785 pr_debug2("switching off mmap2\n");
1786 goto fallback_missing_features;
1787 } else if (!perf_missing_features.exclude_guest &&
1788 (evsel->core.attr.exclude_guest || evsel->core.attr.exclude_host)) {
1789 perf_missing_features.exclude_guest = true;
1790 pr_debug2("switching off exclude_guest, exclude_host\n");
1791 goto fallback_missing_features;
1792 } else if (!perf_missing_features.sample_id_all) {
1793 perf_missing_features.sample_id_all = true;
1794 pr_debug2("switching off sample_id_all\n");
1795 goto retry_sample_id;
1796 } else if (!perf_missing_features.lbr_flags &&
1797 (evsel->core.attr.branch_sample_type &
1798 (PERF_SAMPLE_BRANCH_NO_CYCLES |
1799 PERF_SAMPLE_BRANCH_NO_FLAGS))) {
1800 perf_missing_features.lbr_flags = true;
1801 pr_debug2("switching off branch sample type no (cycles/flags)\n");
1802 goto fallback_missing_features;
1803 } else if (!perf_missing_features.group_read &&
1804 evsel->core.attr.inherit &&
1805 (evsel->core.attr.read_format & PERF_FORMAT_GROUP) &&
1806 perf_evsel__is_group_leader(evsel)) {
1807 perf_missing_features.group_read = true;
1808 pr_debug2("switching off group read\n");
1809 goto fallback_missing_features;
1810 }
1811 out_close:
1812 if (err)
1813 threads->err_thread = thread;
1814
1815 do {
1816 while (--thread >= 0) {
1817 close(FD(evsel, cpu, thread));
1818 FD(evsel, cpu, thread) = -1;
1819 }
1820 thread = nthreads;
1821 } while (--cpu >= 0);
1822 return err;
1823 }
1824
1825 void evsel__close(struct evsel *evsel)
1826 {
1827 perf_evsel__close(&evsel->core);
1828 perf_evsel__free_id(&evsel->core);
1829 }
1830
1831 int perf_evsel__open_per_cpu(struct evsel *evsel,
1832 struct perf_cpu_map *cpus)
1833 {
1834 return evsel__open(evsel, cpus, NULL);
1835 }
1836
1837 int perf_evsel__open_per_thread(struct evsel *evsel,
1838 struct perf_thread_map *threads)
1839 {
1840 return evsel__open(evsel, NULL, threads);
1841 }
1842
1843 static int perf_evsel__parse_id_sample(const struct evsel *evsel,
1844 const union perf_event *event,
1845 struct perf_sample *sample)
1846 {
1847 u64 type = evsel->core.attr.sample_type;
1848 const __u64 *array = event->sample.array;
1849 bool swapped = evsel->needs_swap;
1850 union u64_swap u;
1851
1852 array += ((event->header.size -
1853 sizeof(event->header)) / sizeof(u64)) - 1;
1854
1855 if (type & PERF_SAMPLE_IDENTIFIER) {
1856 sample->id = *array;
1857 array--;
1858 }
1859
1860 if (type & PERF_SAMPLE_CPU) {
1861 u.val64 = *array;
1862 if (swapped) {
1863
1864 u.val64 = bswap_64(u.val64);
1865 u.val32[0] = bswap_32(u.val32[0]);
1866 }
1867
1868 sample->cpu = u.val32[0];
1869 array--;
1870 }
1871
1872 if (type & PERF_SAMPLE_STREAM_ID) {
1873 sample->stream_id = *array;
1874 array--;
1875 }
1876
1877 if (type & PERF_SAMPLE_ID) {
1878 sample->id = *array;
1879 array--;
1880 }
1881
1882 if (type & PERF_SAMPLE_TIME) {
1883 sample->time = *array;
1884 array--;
1885 }
1886
1887 if (type & PERF_SAMPLE_TID) {
1888 u.val64 = *array;
1889 if (swapped) {
1890
1891 u.val64 = bswap_64(u.val64);
1892 u.val32[0] = bswap_32(u.val32[0]);
1893 u.val32[1] = bswap_32(u.val32[1]);
1894 }
1895
1896 sample->pid = u.val32[0];
1897 sample->tid = u.val32[1];
1898 array--;
1899 }
1900
1901 return 0;
1902 }
1903
1904 static inline bool overflow(const void *endp, u16 max_size, const void *offset,
1905 u64 size)
1906 {
1907 return size > max_size || offset + size > endp;
1908 }
1909
1910 #define OVERFLOW_CHECK(offset, size, max_size) \
1911 do { \
1912 if (overflow(endp, (max_size), (offset), (size))) \
1913 return -EFAULT; \
1914 } while (0)
1915
1916 #define OVERFLOW_CHECK_u64(offset) \
1917 OVERFLOW_CHECK(offset, sizeof(u64), sizeof(u64))
1918
1919 static int
1920 perf_event__check_size(union perf_event *event, unsigned int sample_size)
1921 {
1922
1923
1924
1925
1926
1927 if (sample_size + sizeof(event->header) > event->header.size)
1928 return -EFAULT;
1929
1930 return 0;
1931 }
1932
1933 int perf_evsel__parse_sample(struct evsel *evsel, union perf_event *event,
1934 struct perf_sample *data)
1935 {
1936 u64 type = evsel->core.attr.sample_type;
1937 bool swapped = evsel->needs_swap;
1938 const __u64 *array;
1939 u16 max_size = event->header.size;
1940 const void *endp = (void *)event + max_size;
1941 u64 sz;
1942
1943
1944
1945
1946
1947 union u64_swap u;
1948
1949 memset(data, 0, sizeof(*data));
1950 data->cpu = data->pid = data->tid = -1;
1951 data->stream_id = data->id = data->time = -1ULL;
1952 data->period = evsel->core.attr.sample_period;
1953 data->cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1954 data->misc = event->header.misc;
1955 data->id = -1ULL;
1956 data->data_src = PERF_MEM_DATA_SRC_NONE;
1957
1958 if (event->header.type != PERF_RECORD_SAMPLE) {
1959 if (!evsel->core.attr.sample_id_all)
1960 return 0;
1961 return perf_evsel__parse_id_sample(evsel, event, data);
1962 }
1963
1964 array = event->sample.array;
1965
1966 if (perf_event__check_size(event, evsel->sample_size))
1967 return -EFAULT;
1968
1969 if (type & PERF_SAMPLE_IDENTIFIER) {
1970 data->id = *array;
1971 array++;
1972 }
1973
1974 if (type & PERF_SAMPLE_IP) {
1975 data->ip = *array;
1976 array++;
1977 }
1978
1979 if (type & PERF_SAMPLE_TID) {
1980 u.val64 = *array;
1981 if (swapped) {
1982
1983 u.val64 = bswap_64(u.val64);
1984 u.val32[0] = bswap_32(u.val32[0]);
1985 u.val32[1] = bswap_32(u.val32[1]);
1986 }
1987
1988 data->pid = u.val32[0];
1989 data->tid = u.val32[1];
1990 array++;
1991 }
1992
1993 if (type & PERF_SAMPLE_TIME) {
1994 data->time = *array;
1995 array++;
1996 }
1997
1998 if (type & PERF_SAMPLE_ADDR) {
1999 data->addr = *array;
2000 array++;
2001 }
2002
2003 if (type & PERF_SAMPLE_ID) {
2004 data->id = *array;
2005 array++;
2006 }
2007
2008 if (type & PERF_SAMPLE_STREAM_ID) {
2009 data->stream_id = *array;
2010 array++;
2011 }
2012
2013 if (type & PERF_SAMPLE_CPU) {
2014
2015 u.val64 = *array;
2016 if (swapped) {
2017
2018 u.val64 = bswap_64(u.val64);
2019 u.val32[0] = bswap_32(u.val32[0]);
2020 }
2021
2022 data->cpu = u.val32[0];
2023 array++;
2024 }
2025
2026 if (type & PERF_SAMPLE_PERIOD) {
2027 data->period = *array;
2028 array++;
2029 }
2030
2031 if (type & PERF_SAMPLE_READ) {
2032 u64 read_format = evsel->core.attr.read_format;
2033
2034 OVERFLOW_CHECK_u64(array);
2035 if (read_format & PERF_FORMAT_GROUP)
2036 data->read.group.nr = *array;
2037 else
2038 data->read.one.value = *array;
2039
2040 array++;
2041
2042 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
2043 OVERFLOW_CHECK_u64(array);
2044 data->read.time_enabled = *array;
2045 array++;
2046 }
2047
2048 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
2049 OVERFLOW_CHECK_u64(array);
2050 data->read.time_running = *array;
2051 array++;
2052 }
2053
2054
2055 if (read_format & PERF_FORMAT_GROUP) {
2056 const u64 max_group_nr = UINT64_MAX /
2057 sizeof(struct sample_read_value);
2058
2059 if (data->read.group.nr > max_group_nr)
2060 return -EFAULT;
2061 sz = data->read.group.nr *
2062 sizeof(struct sample_read_value);
2063 OVERFLOW_CHECK(array, sz, max_size);
2064 data->read.group.values =
2065 (struct sample_read_value *)array;
2066 array = (void *)array + sz;
2067 } else {
2068 OVERFLOW_CHECK_u64(array);
2069 data->read.one.id = *array;
2070 array++;
2071 }
2072 }
2073
2074 if (evsel__has_callchain(evsel)) {
2075 const u64 max_callchain_nr = UINT64_MAX / sizeof(u64);
2076
2077 OVERFLOW_CHECK_u64(array);
2078 data->callchain = (struct ip_callchain *)array++;
2079 if (data->callchain->nr > max_callchain_nr)
2080 return -EFAULT;
2081 sz = data->callchain->nr * sizeof(u64);
2082 OVERFLOW_CHECK(array, sz, max_size);
2083 array = (void *)array + sz;
2084 }
2085
2086 if (type & PERF_SAMPLE_RAW) {
2087 OVERFLOW_CHECK_u64(array);
2088 u.val64 = *array;
2089
2090
2091
2092
2093
2094
2095
2096 if (swapped) {
2097 u.val64 = bswap_64(u.val64);
2098 u.val32[0] = bswap_32(u.val32[0]);
2099 u.val32[1] = bswap_32(u.val32[1]);
2100 }
2101 data->raw_size = u.val32[0];
2102
2103
2104
2105
2106
2107 if (swapped)
2108 mem_bswap_64((void *) array, data->raw_size);
2109
2110 array = (void *)array + sizeof(u32);
2111
2112 OVERFLOW_CHECK(array, data->raw_size, max_size);
2113 data->raw_data = (void *)array;
2114 array = (void *)array + data->raw_size;
2115 }
2116
2117 if (type & PERF_SAMPLE_BRANCH_STACK) {
2118 const u64 max_branch_nr = UINT64_MAX /
2119 sizeof(struct branch_entry);
2120
2121 OVERFLOW_CHECK_u64(array);
2122 data->branch_stack = (struct branch_stack *)array++;
2123
2124 if (data->branch_stack->nr > max_branch_nr)
2125 return -EFAULT;
2126 sz = data->branch_stack->nr * sizeof(struct branch_entry);
2127 OVERFLOW_CHECK(array, sz, max_size);
2128 array = (void *)array + sz;
2129 }
2130
2131 if (type & PERF_SAMPLE_REGS_USER) {
2132 OVERFLOW_CHECK_u64(array);
2133 data->user_regs.abi = *array;
2134 array++;
2135
2136 if (data->user_regs.abi) {
2137 u64 mask = evsel->core.attr.sample_regs_user;
2138
2139 sz = hweight64(mask) * sizeof(u64);
2140 OVERFLOW_CHECK(array, sz, max_size);
2141 data->user_regs.mask = mask;
2142 data->user_regs.regs = (u64 *)array;
2143 array = (void *)array + sz;
2144 }
2145 }
2146
2147 if (type & PERF_SAMPLE_STACK_USER) {
2148 OVERFLOW_CHECK_u64(array);
2149 sz = *array++;
2150
2151 data->user_stack.offset = ((char *)(array - 1)
2152 - (char *) event);
2153
2154 if (!sz) {
2155 data->user_stack.size = 0;
2156 } else {
2157 OVERFLOW_CHECK(array, sz, max_size);
2158 data->user_stack.data = (char *)array;
2159 array = (void *)array + sz;
2160 OVERFLOW_CHECK_u64(array);
2161 data->user_stack.size = *array++;
2162 if (WARN_ONCE(data->user_stack.size > sz,
2163 "user stack dump failure\n"))
2164 return -EFAULT;
2165 }
2166 }
2167
2168 if (type & PERF_SAMPLE_WEIGHT) {
2169 OVERFLOW_CHECK_u64(array);
2170 data->weight = *array;
2171 array++;
2172 }
2173
2174 if (type & PERF_SAMPLE_DATA_SRC) {
2175 OVERFLOW_CHECK_u64(array);
2176 data->data_src = *array;
2177 array++;
2178 }
2179
2180 if (type & PERF_SAMPLE_TRANSACTION) {
2181 OVERFLOW_CHECK_u64(array);
2182 data->transaction = *array;
2183 array++;
2184 }
2185
2186 data->intr_regs.abi = PERF_SAMPLE_REGS_ABI_NONE;
2187 if (type & PERF_SAMPLE_REGS_INTR) {
2188 OVERFLOW_CHECK_u64(array);
2189 data->intr_regs.abi = *array;
2190 array++;
2191
2192 if (data->intr_regs.abi != PERF_SAMPLE_REGS_ABI_NONE) {
2193 u64 mask = evsel->core.attr.sample_regs_intr;
2194
2195 sz = hweight64(mask) * sizeof(u64);
2196 OVERFLOW_CHECK(array, sz, max_size);
2197 data->intr_regs.mask = mask;
2198 data->intr_regs.regs = (u64 *)array;
2199 array = (void *)array + sz;
2200 }
2201 }
2202
2203 data->phys_addr = 0;
2204 if (type & PERF_SAMPLE_PHYS_ADDR) {
2205 data->phys_addr = *array;
2206 array++;
2207 }
2208
2209 return 0;
2210 }
2211
2212 int perf_evsel__parse_sample_timestamp(struct evsel *evsel,
2213 union perf_event *event,
2214 u64 *timestamp)
2215 {
2216 u64 type = evsel->core.attr.sample_type;
2217 const __u64 *array;
2218
2219 if (!(type & PERF_SAMPLE_TIME))
2220 return -1;
2221
2222 if (event->header.type != PERF_RECORD_SAMPLE) {
2223 struct perf_sample data = {
2224 .time = -1ULL,
2225 };
2226
2227 if (!evsel->core.attr.sample_id_all)
2228 return -1;
2229 if (perf_evsel__parse_id_sample(evsel, event, &data))
2230 return -1;
2231
2232 *timestamp = data.time;
2233 return 0;
2234 }
2235
2236 array = event->sample.array;
2237
2238 if (perf_event__check_size(event, evsel->sample_size))
2239 return -EFAULT;
2240
2241 if (type & PERF_SAMPLE_IDENTIFIER)
2242 array++;
2243
2244 if (type & PERF_SAMPLE_IP)
2245 array++;
2246
2247 if (type & PERF_SAMPLE_TID)
2248 array++;
2249
2250 if (type & PERF_SAMPLE_TIME)
2251 *timestamp = *array;
2252
2253 return 0;
2254 }
2255
2256 struct tep_format_field *perf_evsel__field(struct evsel *evsel, const char *name)
2257 {
2258 return tep_find_field(evsel->tp_format, name);
2259 }
2260
2261 void *perf_evsel__rawptr(struct evsel *evsel, struct perf_sample *sample,
2262 const char *name)
2263 {
2264 struct tep_format_field *field = perf_evsel__field(evsel, name);
2265 int offset;
2266
2267 if (!field)
2268 return NULL;
2269
2270 offset = field->offset;
2271
2272 if (field->flags & TEP_FIELD_IS_DYNAMIC) {
2273 offset = *(int *)(sample->raw_data + field->offset);
2274 offset &= 0xffff;
2275 }
2276
2277 return sample->raw_data + offset;
2278 }
2279
2280 u64 format_field__intval(struct tep_format_field *field, struct perf_sample *sample,
2281 bool needs_swap)
2282 {
2283 u64 value;
2284 void *ptr = sample->raw_data + field->offset;
2285
2286 switch (field->size) {
2287 case 1:
2288 return *(u8 *)ptr;
2289 case 2:
2290 value = *(u16 *)ptr;
2291 break;
2292 case 4:
2293 value = *(u32 *)ptr;
2294 break;
2295 case 8:
2296 memcpy(&value, ptr, sizeof(u64));
2297 break;
2298 default:
2299 return 0;
2300 }
2301
2302 if (!needs_swap)
2303 return value;
2304
2305 switch (field->size) {
2306 case 2:
2307 return bswap_16(value);
2308 case 4:
2309 return bswap_32(value);
2310 case 8:
2311 return bswap_64(value);
2312 default:
2313 return 0;
2314 }
2315
2316 return 0;
2317 }
2318
2319 u64 perf_evsel__intval(struct evsel *evsel, struct perf_sample *sample,
2320 const char *name)
2321 {
2322 struct tep_format_field *field = perf_evsel__field(evsel, name);
2323
2324 if (!field)
2325 return 0;
2326
2327 return field ? format_field__intval(field, sample, evsel->needs_swap) : 0;
2328 }
2329
2330 bool perf_evsel__fallback(struct evsel *evsel, int err,
2331 char *msg, size_t msgsize)
2332 {
2333 int paranoid;
2334
2335 if ((err == ENOENT || err == ENXIO || err == ENODEV) &&
2336 evsel->core.attr.type == PERF_TYPE_HARDWARE &&
2337 evsel->core.attr.config == PERF_COUNT_HW_CPU_CYCLES) {
2338
2339
2340
2341
2342
2343
2344
2345
2346 scnprintf(msg, msgsize, "%s",
2347 "The cycles event is not supported, trying to fall back to cpu-clock-ticks");
2348
2349 evsel->core.attr.type = PERF_TYPE_SOFTWARE;
2350 evsel->core.attr.config = PERF_COUNT_SW_CPU_CLOCK;
2351
2352 zfree(&evsel->name);
2353 return true;
2354 } else if (err == EACCES && !evsel->core.attr.exclude_kernel &&
2355 (paranoid = perf_event_paranoid()) > 1) {
2356 const char *name = perf_evsel__name(evsel);
2357 char *new_name;
2358 const char *sep = ":";
2359
2360
2361 if (strchr(name, '/') ||
2362 strchr(name, ':'))
2363 sep = "";
2364
2365 if (asprintf(&new_name, "%s%su", name, sep) < 0)
2366 return false;
2367
2368 if (evsel->name)
2369 free(evsel->name);
2370 evsel->name = new_name;
2371 scnprintf(msg, msgsize, "kernel.perf_event_paranoid=%d, trying "
2372 "to fall back to excluding kernel and hypervisor "
2373 " samples", paranoid);
2374 evsel->core.attr.exclude_kernel = 1;
2375 evsel->core.attr.exclude_hv = 1;
2376
2377 return true;
2378 }
2379
2380 return false;
2381 }
2382
2383 static bool find_process(const char *name)
2384 {
2385 size_t len = strlen(name);
2386 DIR *dir;
2387 struct dirent *d;
2388 int ret = -1;
2389
2390 dir = opendir(procfs__mountpoint());
2391 if (!dir)
2392 return false;
2393
2394
2395 while (ret && (d = readdir(dir)) != NULL) {
2396 char path[PATH_MAX];
2397 char *data;
2398 size_t size;
2399
2400 if ((d->d_type != DT_DIR) ||
2401 !strcmp(".", d->d_name) ||
2402 !strcmp("..", d->d_name))
2403 continue;
2404
2405 scnprintf(path, sizeof(path), "%s/%s/comm",
2406 procfs__mountpoint(), d->d_name);
2407
2408 if (filename__read_str(path, &data, &size))
2409 continue;
2410
2411 ret = strncmp(name, data, len);
2412 free(data);
2413 }
2414
2415 closedir(dir);
2416 return ret ? false : true;
2417 }
2418
2419 int perf_evsel__open_strerror(struct evsel *evsel, struct target *target,
2420 int err, char *msg, size_t size)
2421 {
2422 char sbuf[STRERR_BUFSIZE];
2423 int printed = 0;
2424
2425 switch (err) {
2426 case EPERM:
2427 case EACCES:
2428 if (err == EPERM)
2429 printed = scnprintf(msg, size,
2430 "No permission to enable %s event.\n\n",
2431 perf_evsel__name(evsel));
2432
2433 return scnprintf(msg + printed, size - printed,
2434 "You may not have permission to collect %sstats.\n\n"
2435 "Consider tweaking /proc/sys/kernel/perf_event_paranoid,\n"
2436 "which controls use of the performance events system by\n"
2437 "unprivileged users (without CAP_SYS_ADMIN).\n\n"
2438 "The current value is %d:\n\n"
2439 " -1: Allow use of (almost) all events by all users\n"
2440 " Ignore mlock limit after perf_event_mlock_kb without CAP_IPC_LOCK\n"
2441 ">= 0: Disallow ftrace function tracepoint by users without CAP_SYS_ADMIN\n"
2442 " Disallow raw tracepoint access by users without CAP_SYS_ADMIN\n"
2443 ">= 1: Disallow CPU event access by users without CAP_SYS_ADMIN\n"
2444 ">= 2: Disallow kernel profiling by users without CAP_SYS_ADMIN\n\n"
2445 "To make this setting permanent, edit /etc/sysctl.conf too, e.g.:\n\n"
2446 " kernel.perf_event_paranoid = -1\n" ,
2447 target->system_wide ? "system-wide " : "",
2448 perf_event_paranoid());
2449 case ENOENT:
2450 return scnprintf(msg, size, "The %s event is not supported.",
2451 perf_evsel__name(evsel));
2452 case EMFILE:
2453 return scnprintf(msg, size, "%s",
2454 "Too many events are opened.\n"
2455 "Probably the maximum number of open file descriptors has been reached.\n"
2456 "Hint: Try again after reducing the number of events.\n"
2457 "Hint: Try increasing the limit with 'ulimit -n <limit>'");
2458 case ENOMEM:
2459 if (evsel__has_callchain(evsel) &&
2460 access("/proc/sys/kernel/perf_event_max_stack", F_OK) == 0)
2461 return scnprintf(msg, size,
2462 "Not enough memory to setup event with callchain.\n"
2463 "Hint: Try tweaking /proc/sys/kernel/perf_event_max_stack\n"
2464 "Hint: Current value: %d", sysctl__max_stack());
2465 break;
2466 case ENODEV:
2467 if (target->cpu_list)
2468 return scnprintf(msg, size, "%s",
2469 "No such device - did you specify an out-of-range profile CPU?");
2470 break;
2471 case EOPNOTSUPP:
2472 if (evsel->core.attr.sample_period != 0)
2473 return scnprintf(msg, size,
2474 "%s: PMU Hardware doesn't support sampling/overflow-interrupts. Try 'perf stat'",
2475 perf_evsel__name(evsel));
2476 if (evsel->core.attr.precise_ip)
2477 return scnprintf(msg, size, "%s",
2478 "\'precise\' request may not be supported. Try removing 'p' modifier.");
2479 #if defined(__i386__) || defined(__x86_64__)
2480 if (evsel->core.attr.type == PERF_TYPE_HARDWARE)
2481 return scnprintf(msg, size, "%s",
2482 "No hardware sampling interrupt available.\n");
2483 #endif
2484 break;
2485 case EBUSY:
2486 if (find_process("oprofiled"))
2487 return scnprintf(msg, size,
2488 "The PMU counters are busy/taken by another profiler.\n"
2489 "We found oprofile daemon running, please stop it and try again.");
2490 break;
2491 case EINVAL:
2492 if (evsel->core.attr.write_backward && perf_missing_features.write_backward)
2493 return scnprintf(msg, size, "Reading from overwrite event is not supported by this kernel.");
2494 if (perf_missing_features.clockid)
2495 return scnprintf(msg, size, "clockid feature not supported.");
2496 if (perf_missing_features.clockid_wrong)
2497 return scnprintf(msg, size, "wrong clockid (%d).", clockid);
2498 if (perf_missing_features.aux_output)
2499 return scnprintf(msg, size, "The 'aux_output' feature is not supported, update the kernel.");
2500 break;
2501 default:
2502 break;
2503 }
2504
2505 return scnprintf(msg, size,
2506 "The sys_perf_event_open() syscall returned with %d (%s) for event (%s).\n"
2507 "/bin/dmesg | grep -i perf may provide additional information.\n",
2508 err, str_error_r(err, sbuf, sizeof(sbuf)),
2509 perf_evsel__name(evsel));
2510 }
2511
2512 struct perf_env *perf_evsel__env(struct evsel *evsel)
2513 {
2514 if (evsel && evsel->evlist)
2515 return evsel->evlist->env;
2516 return &perf_env;
2517 }
2518
2519 static int store_evsel_ids(struct evsel *evsel, struct evlist *evlist)
2520 {
2521 int cpu, thread;
2522
2523 for (cpu = 0; cpu < xyarray__max_x(evsel->core.fd); cpu++) {
2524 for (thread = 0; thread < xyarray__max_y(evsel->core.fd);
2525 thread++) {
2526 int fd = FD(evsel, cpu, thread);
2527
2528 if (perf_evlist__id_add_fd(&evlist->core, &evsel->core,
2529 cpu, thread, fd) < 0)
2530 return -1;
2531 }
2532 }
2533
2534 return 0;
2535 }
2536
2537 int perf_evsel__store_ids(struct evsel *evsel, struct evlist *evlist)
2538 {
2539 struct perf_cpu_map *cpus = evsel->core.cpus;
2540 struct perf_thread_map *threads = evsel->core.threads;
2541
2542 if (perf_evsel__alloc_id(&evsel->core, cpus->nr, threads->nr))
2543 return -ENOMEM;
2544
2545 return store_evsel_ids(evsel, evlist);
2546 }