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