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