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