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