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