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