Lines Matching refs:evsel
26 #include <perf/evsel.h>
32 #include "evsel.h"
59 static int evsel__no_extra_init(struct evsel *evsel __maybe_unused)
66 static void evsel__no_extra_fini(struct evsel *evsel __maybe_unused)
72 int (*init)(struct evsel *evsel);
73 void (*fini)(struct evsel *evsel);
75 .size = sizeof(struct evsel),
80 int evsel__object_config(size_t object_size, int (*init)(struct evsel *evsel),
81 void (*fini)(struct evsel *evsel))
180 void evsel__calc_id_pos(struct evsel *evsel)
182 evsel->id_pos = __perf_evsel__calc_id_pos(evsel->core.attr.sample_type);
183 evsel->is_pos = __perf_evsel__calc_is_pos(evsel->core.attr.sample_type);
186 void __evsel__set_sample_bit(struct evsel *evsel,
189 if (!(evsel->core.attr.sample_type & bit)) {
190 evsel->core.attr.sample_type |= bit;
191 evsel->sample_size += sizeof(u64);
192 evsel__calc_id_pos(evsel);
196 void __evsel__reset_sample_bit(struct evsel *evsel,
199 if (evsel->core.attr.sample_type & bit) {
200 evsel->core.attr.sample_type &= ~bit;
201 evsel->sample_size -= sizeof(u64);
202 evsel__calc_id_pos(evsel);
206 void evsel__set_sample_id(struct evsel *evsel,
210 evsel__reset_sample_bit(evsel, ID);
211 evsel__set_sample_bit(evsel, IDENTIFIER);
213 evsel__set_sample_bit(evsel, ID);
215 evsel->core.attr.read_format |= PERF_FORMAT_ID;
219 * evsel__is_function_event - Return whether given evsel is a function
222 * @evsel - evsel selector to be tested
226 bool evsel__is_function_event(struct evsel *evsel)
230 return evsel->name &&
231 !strncmp(FUNCTION_EVENT, evsel->name, sizeof(FUNCTION_EVENT));
236 void evsel__init(struct evsel *evsel,
239 perf_evsel__init(&evsel->core, attr);
240 evsel->idx = idx;
241 evsel->tracking = !idx;
242 evsel->leader = evsel;
243 evsel->unit = "";
244 evsel->scale = 1.0;
245 evsel->max_events = ULONG_MAX;
246 evsel->evlist = NULL;
247 evsel->bpf_obj = NULL;
248 evsel->bpf_fd = -1;
249 INIT_LIST_HEAD(&evsel->config_terms);
250 perf_evsel__object.init(evsel);
251 evsel->sample_size = __evsel__sample_size(attr->sample_type);
252 evsel__calc_id_pos(evsel);
253 evsel->cmdline_group_boundary = false;
254 evsel->metric_expr = NULL;
255 evsel->metric_name = NULL;
256 evsel->metric_events = NULL;
257 evsel->per_pkg_mask = NULL;
258 evsel->collect_stat = false;
259 evsel->pmu_name = NULL;
262 struct evsel *evsel__new_idx(struct perf_event_attr *attr, int idx)
264 struct evsel *evsel = zalloc(perf_evsel__object.size);
266 if (!evsel)
268 evsel__init(evsel, attr, idx);
270 if (evsel__is_bpf_output(evsel)) {
271 evsel->core.attr.sample_type |= (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME |
273 evsel->core.attr.sample_period = 1;
276 if (evsel__is_clock(evsel)) {
278 * The evsel->unit points to static alias->unit
283 evsel->unit = unit;
284 evsel->scale = 1e-6;
287 return evsel;
295 struct evsel *evsel__new_cycles(bool precise)
302 struct evsel *evsel;
314 evsel = evsel__new(&attr);
315 if (evsel == NULL)
318 evsel->precise_max = true;
320 /* use asprintf() because free(evsel) assumes name is allocated */
321 if (asprintf(&evsel->name, "cycles%s%s%.*s",
327 return evsel;
329 evsel__delete(evsel);
330 evsel = NULL;
334 static int evsel__copy_config_terms(struct evsel *dst, struct evsel *src)
357 * evsel__clone - create a new evsel copied from @orig
358 * @orig: original evsel
363 struct evsel *evsel__clone(struct evsel *orig)
365 struct evsel *evsel;
376 evsel = evsel__new(&orig->core.attr);
377 if (evsel == NULL)
380 evsel->core.cpus = perf_cpu_map__get(orig->core.cpus);
381 evsel->core.own_cpus = perf_cpu_map__get(orig->core.own_cpus);
382 evsel->core.threads = perf_thread_map__get(orig->core.threads);
383 evsel->core.nr_members = orig->core.nr_members;
384 evsel->core.system_wide = orig->core.system_wide;
387 evsel->name = strdup(orig->name);
388 if (evsel->name == NULL)
392 evsel->group_name = strdup(orig->group_name);
393 if (evsel->group_name == NULL)
397 evsel->pmu_name = strdup(orig->pmu_name);
398 if (evsel->pmu_name == NULL)
402 evsel->filter = strdup(orig->filter);
403 if (evsel->filter == NULL)
406 evsel->cgrp = cgroup__get(orig->cgrp);
407 evsel->tp_format = orig->tp_format;
408 evsel->handler = orig->handler;
409 evsel->leader = orig->leader;
411 evsel->max_events = orig->max_events;
412 evsel->tool_event = orig->tool_event;
413 evsel->unit = orig->unit;
414 evsel->scale = orig->scale;
415 evsel->snapshot = orig->snapshot;
416 evsel->per_pkg = orig->per_pkg;
417 evsel->percore = orig->percore;
418 evsel->precise_max = orig->precise_max;
419 evsel->use_uncore_alias = orig->use_uncore_alias;
420 evsel->is_libpfm_event = orig->is_libpfm_event;
422 evsel->exclude_GH = orig->exclude_GH;
423 evsel->sample_read = orig->sample_read;
424 evsel->auto_merge_stats = orig->auto_merge_stats;
425 evsel->collect_stat = orig->collect_stat;
426 evsel->weak_group = orig->weak_group;
428 if (evsel__copy_config_terms(evsel, orig) < 0)
431 return evsel;
434 evsel__delete(evsel);
441 struct evsel *evsel__newtp_idx(const char *sys, const char *name, int idx)
443 struct evsel *evsel = zalloc(perf_evsel__object.size);
446 if (evsel == NULL) {
455 if (asprintf(&evsel->name, "%s:%s", sys, name) < 0)
458 evsel->tp_format = trace_event__tp_format(sys, name);
459 if (IS_ERR(evsel->tp_format)) {
460 err = PTR_ERR(evsel->tp_format);
465 attr.config = evsel->tp_format->id;
467 evsel__init(evsel, &attr, idx);
470 return evsel;
473 zfree(&evsel->name);
474 free(evsel);
500 static int perf_evsel__add_modifiers(struct evsel *evsel, char *bf, size_t size)
503 struct perf_event_attr *attr = &evsel->core.attr;
536 static int evsel__hw_name(struct evsel *evsel, char *bf, size_t size)
538 int r = scnprintf(bf, size, "%s", __evsel__hw_name(evsel->core.attr.config));
539 return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
562 static int evsel__sw_name(struct evsel *evsel, char *bf, size_t size)
564 int r = scnprintf(bf, size, "%s", __evsel__sw_name(evsel->core.attr.config));
565 return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
586 static int evsel__bp_name(struct evsel *evsel, char *bf, size_t size)
588 struct perf_event_attr *attr = &evsel->core.attr;
590 return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
682 static int evsel__hw_cache_name(struct evsel *evsel, char *bf, size_t size)
684 int ret = __evsel__hw_cache_name(evsel->core.attr.config, bf, size);
685 return ret + perf_evsel__add_modifiers(evsel, bf + ret, size - ret);
688 static int evsel__raw_name(struct evsel *evsel, char *bf, size_t size)
690 int ret = scnprintf(bf, size, "raw 0x%" PRIx64, evsel->core.attr.config);
691 return ret + perf_evsel__add_modifiers(evsel, bf + ret, size - ret);
700 const char *evsel__name(struct evsel *evsel)
704 if (!evsel)
707 if (evsel->name)
708 return evsel->name;
710 switch (evsel->core.attr.type) {
712 evsel__raw_name(evsel, bf, sizeof(bf));
716 evsel__hw_name(evsel, bf, sizeof(bf));
720 evsel__hw_cache_name(evsel, bf, sizeof(bf));
724 if (evsel->tool_event)
727 evsel__sw_name(evsel, bf, sizeof(bf));
735 evsel__bp_name(evsel, bf, sizeof(bf));
740 evsel->core.attr.type);
744 evsel->name = strdup(bf);
746 if (evsel->name)
747 return evsel->name;
752 const char *evsel__group_name(struct evsel *evsel)
754 return evsel->group_name ?: "anon group";
767 int evsel__group_desc(struct evsel *evsel, char *buf, size_t size)
770 struct evsel *pos;
771 const char *group_name = evsel__group_name(evsel);
773 if (!evsel->forced_leader)
776 ret += scnprintf(buf + ret, size - ret, "%s", evsel__name(evsel));
778 for_each_group_member(pos, evsel)
781 if (!evsel->forced_leader)
787 static void __evsel__config_callchain(struct evsel *evsel, struct record_opts *opts,
790 bool function = evsel__is_function_event(evsel);
791 struct perf_event_attr *attr = &evsel->core.attr;
793 evsel__set_sample_bit(evsel, CALLCHAIN);
808 evsel__set_sample_bit(evsel, BRANCH_STACK);
822 evsel__set_sample_bit(evsel, REGS_USER);
823 evsel__set_sample_bit(evsel, STACK_USER);
846 void evsel__config_callchain(struct evsel *evsel, struct record_opts *opts,
850 return __evsel__config_callchain(evsel, opts, param);
854 perf_evsel__reset_callgraph(struct evsel *evsel,
857 struct perf_event_attr *attr = &evsel->core.attr;
859 evsel__reset_sample_bit(evsel, CALLCHAIN);
861 evsel__reset_sample_bit(evsel, BRANCH_STACK);
867 evsel__reset_sample_bit(evsel, REGS_USER);
868 evsel__reset_sample_bit(evsel, STACK_USER);
872 static void evsel__apply_config_terms(struct evsel *evsel,
876 struct list_head *config_terms = &evsel->config_terms;
877 struct perf_event_attr *attr = &evsel->core.attr;
892 evsel__reset_sample_bit(evsel, PERIOD);
899 evsel__set_sample_bit(evsel, PERIOD);
904 evsel__set_sample_bit(evsel, TIME);
906 evsel__reset_sample_bit(evsel, TIME);
913 evsel__set_sample_bit(evsel, BRANCH_STACK);
917 evsel__reset_sample_bit(evsel, BRANCH_STACK);
926 evsel->max_events = term->val.max_events;
977 evsel->name);
991 perf_evsel__reset_callgraph(evsel, &callchain_param);
996 evsel__set_sample_bit(evsel, ADDR);
997 evsel__set_sample_bit(evsel, DATA_SRC);
998 evsel->core.attr.mmap_data = track;
1000 evsel__config_callchain(evsel, opts, ¶m);
1005 struct evsel_config_term *__evsel__get_config_term(struct evsel *evsel, enum evsel_term_type type)
1009 list_for_each_entry(term, &evsel->config_terms, list) {
1056 void evsel__config(struct evsel *evsel, struct record_opts *opts,
1059 struct evsel *leader = evsel->leader;
1060 struct perf_event_attr *attr = &evsel->core.attr;
1061 int track = evsel->tracking;
1068 evsel__set_sample_bit(evsel, IP);
1069 evsel__set_sample_bit(evsel, TID);
1071 if (evsel->sample_read) {
1072 evsel__set_sample_bit(evsel, READ);
1078 evsel__set_sample_id(evsel, false);
1094 if ((evsel->is_libpfm_event && !attr->sample_period) ||
1095 (!evsel->is_libpfm_event && (!attr->sample_period ||
1105 evsel__set_sample_bit(evsel, PERIOD);
1111 evsel->core.attr.read_format |=
1119 evsel__set_sample_bit(evsel, ADDR);
1128 if (evsel__is_function_event(evsel))
1129 evsel->core.attr.exclude_callchain_user = 1;
1131 if (callchain && callchain->enabled && !evsel->no_aux_samples)
1132 evsel__config_callchain(evsel, opts, callchain);
1134 if (opts->sample_intr_regs && !evsel->no_aux_samples &&
1135 !evsel__is_dummy_event(evsel)) {
1137 evsel__set_sample_bit(evsel, REGS_INTR);
1140 if (opts->sample_user_regs && !evsel->no_aux_samples &&
1141 !evsel__is_dummy_event(evsel)) {
1143 evsel__set_sample_bit(evsel, REGS_USER);
1147 evsel__set_sample_bit(evsel, CPU);
1156 evsel__set_sample_bit(evsel, TIME);
1158 if (opts->raw_samples && !evsel->no_aux_samples) {
1159 evsel__set_sample_bit(evsel, TIME);
1160 evsel__set_sample_bit(evsel, RAW);
1161 evsel__set_sample_bit(evsel, CPU);
1165 evsel__set_sample_bit(evsel, DATA_SRC);
1168 evsel__set_sample_bit(evsel, PHYS_ADDR);
1174 if (opts->branch_stack && !evsel->no_aux_samples) {
1175 evsel__set_sample_bit(evsel, BRANCH_STACK);
1180 evsel__set_sample_bit(evsel, WEIGHT);
1199 evsel__set_sample_bit(evsel, CGROUP);
1206 evsel__set_sample_bit(evsel, TRANSACTION);
1209 evsel->core.attr.read_format |=
1220 if (evsel__is_group_leader(evsel))
1227 if (target__none(&opts->target) && evsel__is_group_leader(evsel) &&
1231 if (evsel->immediate) {
1242 if (evsel->precise_max)
1255 if (evsel->core.own_cpus || evsel->unit)
1256 evsel->core.attr.read_format |= PERF_FORMAT_ID;
1262 evsel__apply_config_terms(evsel, opts, track);
1264 evsel->ignore_missing_thread = opts->ignore_missing_thread;
1269 evsel__set_sample_bit(evsel, PERIOD);
1271 evsel__reset_sample_bit(evsel, PERIOD);
1282 if (evsel__is_dummy_event(evsel))
1283 evsel__reset_sample_bit(evsel, BRANCH_STACK);
1286 int evsel__set_filter(struct evsel *evsel, const char *filter)
1291 free(evsel->filter);
1292 evsel->filter = new_filter;
1299 static int evsel__append_filter(struct evsel *evsel, const char *fmt, const char *filter)
1303 if (evsel->filter == NULL)
1304 return evsel__set_filter(evsel, filter);
1306 if (asprintf(&new_filter, fmt, evsel->filter, filter) > 0) {
1307 free(evsel->filter);
1308 evsel->filter = new_filter;
1315 int evsel__append_tp_filter(struct evsel *evsel, const char *filter)
1317 return evsel__append_filter(evsel, "(%s) && (%s)", filter);
1320 int evsel__append_addr_filter(struct evsel *evsel, const char *filter)
1322 return evsel__append_filter(evsel, "%s,%s", filter);
1326 int evsel__enable_cpu(struct evsel *evsel, int cpu)
1328 return perf_evsel__enable_cpu(&evsel->core, cpu);
1331 int evsel__enable(struct evsel *evsel)
1333 int err = perf_evsel__enable(&evsel->core);
1336 evsel->disabled = false;
1341 int evsel__disable_cpu(struct evsel *evsel, int cpu)
1343 return perf_evsel__disable_cpu(&evsel->core, cpu);
1346 int evsel__disable(struct evsel *evsel)
1348 int err = perf_evsel__disable(&evsel->core);
1356 evsel->disabled = true;
1361 static void evsel__free_config_terms(struct evsel *evsel)
1365 list_for_each_entry_safe(term, h, &evsel->config_terms, list) {
1373 void evsel__exit(struct evsel *evsel)
1375 assert(list_empty(&evsel->core.node));
1376 assert(evsel->evlist == NULL);
1377 evsel__free_counts(evsel);
1378 perf_evsel__free_fd(&evsel->core);
1379 perf_evsel__free_id(&evsel->core);
1380 evsel__free_config_terms(evsel);
1381 cgroup__put(evsel->cgrp);
1382 perf_cpu_map__put(evsel->core.cpus);
1383 perf_cpu_map__put(evsel->core.own_cpus);
1384 perf_thread_map__put(evsel->core.threads);
1385 zfree(&evsel->group_name);
1386 zfree(&evsel->name);
1387 zfree(&evsel->pmu_name);
1388 zfree(&evsel->per_pkg_mask);
1389 zfree(&evsel->metric_events);
1390 perf_evsel__object.fini(evsel);
1393 void evsel__delete(struct evsel *evsel)
1395 evsel__exit(evsel);
1396 free(evsel);
1399 void evsel__compute_deltas(struct evsel *evsel, int cpu, int thread,
1404 if (!evsel->prev_raw_counts)
1408 tmp = evsel->prev_raw_counts->aggr;
1409 evsel->prev_raw_counts->aggr = *count;
1411 tmp = *perf_counts(evsel->prev_raw_counts, cpu, thread);
1412 *perf_counts(evsel->prev_raw_counts, cpu, thread) = *count;
1439 static int evsel__read_one(struct evsel *evsel, int cpu, int thread)
1441 struct perf_counts_values *count = perf_counts(evsel->counts, cpu, thread);
1443 return perf_evsel__read(&evsel->core, cpu, thread, count);
1447 perf_evsel__set_count(struct evsel *counter, int cpu, int thread,
1462 perf_evsel__process_group_data(struct evsel *leader,
1486 struct evsel *counter;
1499 static int evsel__read_group(struct evsel *leader, int cpu, int thread)
1529 int evsel__read_counter(struct evsel *evsel, int cpu, int thread)
1531 u64 read_format = evsel->core.attr.read_format;
1534 return evsel__read_group(evsel, cpu, thread);
1536 return evsel__read_one(evsel, cpu, thread);
1539 int __evsel__read_on_cpu(struct evsel *evsel, int cpu, int thread, bool scale)
1544 if (FD(evsel, cpu, thread) < 0)
1547 if (evsel->counts == NULL && evsel__alloc_counts(evsel, cpu + 1, thread + 1) < 0)
1550 if (readn(FD(evsel, cpu, thread), &count, nv * sizeof(u64)) <= 0)
1553 evsel__compute_deltas(evsel, cpu, thread, &count);
1555 *perf_counts(evsel->counts, cpu, thread) = count;
1559 static int get_group_fd(struct evsel *evsel, int cpu, int thread)
1561 struct evsel *leader = evsel->leader;
1564 if (evsel__is_group_leader(evsel))
1579 static void perf_evsel__remove_fd(struct evsel *pos,
1588 static int update_fds(struct evsel *evsel,
1592 struct evsel *pos;
1597 evlist__for_each_entry(evsel->evlist, pos) {
1598 nr_cpus = pos != evsel ? nr_cpus : cpu_idx;
1603 * Since fds for next evsel has not been created,
1606 if (pos == evsel)
1612 static bool ignore_missing_thread(struct evsel *evsel,
1619 if (!evsel->ignore_missing_thread)
1623 if (evsel->core.system_wide)
1638 if (update_fds(evsel, nr_cpus, cpu, threads->nr, thread))
1665 static int perf_event_open(struct evsel *evsel,
1669 int precise_ip = evsel->core.attr.precise_ip;
1676 fd = sys_perf_event_open(&evsel->core.attr, pid, cpu, group_fd, flags);
1681 if (!evsel->precise_max)
1688 if (!evsel->core.attr.precise_ip) {
1689 evsel->core.attr.precise_ip = precise_ip;
1694 evsel->core.attr.precise_ip--;
1695 pr_debug2_peo("decreasing precise_ip by one (%d)\n", evsel->core.attr.precise_ip);
1696 display_attr(&evsel->core.attr);
1702 static int evsel__open_cpu(struct evsel *evsel, struct perf_cpu_map *cpus,
1711 if ((perf_missing_features.write_backward && evsel->core.attr.write_backward) ||
1712 (perf_missing_features.aux_output && evsel->core.attr.aux_output))
1739 if (evsel->core.system_wide)
1744 if (evsel->core.fd == NULL &&
1745 perf_evsel__alloc_fd(&evsel->core, cpus->nr, nthreads) < 0)
1748 if (evsel->cgrp) {
1750 pid = evsel->cgrp->fd;
1755 evsel->core.attr.clockid = CLOCK_MONOTONIC; /* should always work */
1757 evsel->core.attr.use_clockid = 0;
1758 evsel->core.attr.clockid = 0;
1763 evsel->core.attr.mmap2 = 0;
1765 evsel->core.attr.exclude_guest = evsel->core.attr.exclude_host = 0;
1767 evsel->core.attr.branch_sample_type &= ~(PERF_SAMPLE_BRANCH_NO_FLAGS |
1769 if (perf_missing_features.group_read && evsel->core.attr.inherit)
1770 evsel->core.attr.read_format &= ~(PERF_FORMAT_GROUP|PERF_FORMAT_ID);
1772 evsel->core.attr.ksymbol = 0;
1774 evsel->core.attr.bpf_event = 0;
1776 evsel->core.attr.branch_sample_type &= ~PERF_SAMPLE_BRANCH_HW_INDEX;
1779 evsel->core.attr.sample_id_all = 0;
1781 display_attr(&evsel->core.attr);
1788 if (!evsel->cgrp && !evsel->core.system_wide)
1791 group_fd = get_group_fd(evsel, cpu, thread);
1795 fd = perf_event_open(evsel, pid, cpus->map[cpu],
1798 FD(evsel, cpu, thread) = fd;
1801 test_attr__open(&evsel->core.attr, pid, cpus->map[cpu],
1808 if (ignore_missing_thread(evsel, cpus->nr, cpu, threads, thread, err)) {
1829 if (evsel->bpf_fd >= 0) {
1831 int bpf_fd = evsel->bpf_fd;
1892 if (!perf_missing_features.cgroup && evsel->core.attr.cgroup) {
1897 (evsel->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_HW_INDEX)) {
1901 } else if (!perf_missing_features.aux_output && evsel->core.attr.aux_output) {
1905 } else if (!perf_missing_features.bpf && evsel->core.attr.bpf_event) {
1909 } else if (!perf_missing_features.ksymbol && evsel->core.attr.ksymbol) {
1913 } else if (!perf_missing_features.write_backward && evsel->core.attr.write_backward) {
1917 } else if (!perf_missing_features.clockid_wrong && evsel->core.attr.use_clockid) {
1921 } else if (!perf_missing_features.clockid && evsel->core.attr.use_clockid) {
1929 } else if (!perf_missing_features.mmap2 && evsel->core.attr.mmap2) {
1934 (evsel->core.attr.exclude_guest || evsel->core.attr.exclude_host)) {
1943 (evsel->core.attr.branch_sample_type &
1950 evsel->core.attr.inherit &&
1951 (evsel->core.attr.read_format & PERF_FORMAT_GROUP) &&
1952 evsel__is_group_leader(evsel)) {
1964 if (FD(evsel, cpu, thread) >= 0)
1965 close(FD(evsel, cpu, thread));
1966 FD(evsel, cpu, thread) = -1;
1974 int evsel__open(struct evsel *evsel, struct perf_cpu_map *cpus,
1977 return evsel__open_cpu(evsel, cpus, threads, 0, cpus ? cpus->nr : 1);
1980 void evsel__close(struct evsel *evsel)
1982 perf_evsel__close(&evsel->core);
1983 perf_evsel__free_id(&evsel->core);
1986 int evsel__open_per_cpu(struct evsel *evsel, struct perf_cpu_map *cpus, int cpu)
1989 return evsel__open_cpu(evsel, cpus, NULL, 0,
1992 return evsel__open_cpu(evsel, cpus, NULL, cpu, cpu + 1);
1995 int evsel__open_per_thread(struct evsel *evsel, struct perf_thread_map *threads)
1997 return evsel__open(evsel, NULL, threads);
2000 static int perf_evsel__parse_id_sample(const struct evsel *evsel,
2004 u64 type = evsel->core.attr.sample_type;
2006 bool swapped = evsel->needs_swap;
2080 * The evsel's sample_size is based on PERF_SAMPLE_MASK which includes
2090 int evsel__parse_sample(struct evsel *evsel, union perf_event *event,
2093 u64 type = evsel->core.attr.sample_type;
2094 bool swapped = evsel->needs_swap;
2109 data->period = evsel->core.attr.sample_period;
2116 if (!evsel->core.attr.sample_id_all)
2118 return perf_evsel__parse_id_sample(evsel, event, data);
2123 if (perf_event__check_size(event, evsel->sample_size))
2189 u64 read_format = evsel->core.attr.read_format;
2285 if (evsel__has_branch_hw_idx(evsel))
2299 u64 mask = evsel->core.attr.sample_regs_user;
2355 u64 mask = evsel->core.attr.sample_regs_intr;
2393 int evsel__parse_sample_timestamp(struct evsel *evsel, union perf_event *event,
2396 u64 type = evsel->core.attr.sample_type;
2407 if (!evsel->core.attr.sample_id_all)
2409 if (perf_evsel__parse_id_sample(evsel, event, &data))
2418 if (perf_event__check_size(event, evsel->sample_size))
2436 struct tep_format_field *evsel__field(struct evsel *evsel, const char *name)
2438 return tep_find_field(evsel->tp_format, name);
2441 void *evsel__rawptr(struct evsel *evsel, struct perf_sample *sample, const char *name)
2443 struct tep_format_field *field = evsel__field(evsel, name);
2498 u64 evsel__intval(struct evsel *evsel, struct perf_sample *sample, const char *name)
2500 struct tep_format_field *field = evsel__field(evsel, name);
2505 return field ? format_field__intval(field, sample, evsel->needs_swap) : 0;
2508 bool evsel__fallback(struct evsel *evsel, int err, char *msg, size_t msgsize)
2513 evsel->core.attr.type == PERF_TYPE_HARDWARE &&
2514 evsel->core.attr.config == PERF_COUNT_HW_CPU_CYCLES) {
2526 evsel->core.attr.type = PERF_TYPE_SOFTWARE;
2527 evsel->core.attr.config = PERF_COUNT_SW_CPU_CLOCK;
2529 zfree(&evsel->name);
2531 } else if (err == EACCES && !evsel->core.attr.exclude_kernel &&
2533 const char *name = evsel__name(evsel);
2538 if (evsel->core.attr.exclude_user)
2543 (strchr(name, ':') && !evsel->is_libpfm_event))
2549 if (evsel->name)
2550 free(evsel->name);
2551 evsel->name = new_name;
2555 evsel->core.attr.exclude_kernel = 1;
2556 evsel->core.attr.exclude_hv = 1;
2600 int evsel__open_strerror(struct evsel *evsel, struct target *target,
2623 "No permission to enable %s event.\n\n", evsel__name(evsel));
2641 return scnprintf(msg, size, "The %s event is not supported.", evsel__name(evsel));
2649 if (evsel__has_callchain(evsel) &&
2662 if (evsel->core.attr.aux_output)
2665 evsel__name(evsel));
2666 if (evsel->core.attr.sample_period != 0)
2669 evsel__name(evsel));
2670 if (evsel->core.attr.precise_ip)
2674 if (evsel->core.attr.type == PERF_TYPE_HARDWARE)
2686 if (evsel->core.attr.write_backward && perf_missing_features.write_backward)
2702 err, str_error_r(err, sbuf, sizeof(sbuf)), evsel__name(evsel));
2705 struct perf_env *evsel__env(struct evsel *evsel)
2707 if (evsel && evsel->evlist)
2708 return evsel->evlist->env;
2712 static int store_evsel_ids(struct evsel *evsel, struct evlist *evlist)
2716 for (cpu = 0; cpu < xyarray__max_x(evsel->core.fd); cpu++) {
2717 for (thread = 0; thread < xyarray__max_y(evsel->core.fd);
2719 int fd = FD(evsel, cpu, thread);
2721 if (perf_evlist__id_add_fd(&evlist->core, &evsel->core,
2730 int evsel__store_ids(struct evsel *evsel, struct evlist *evlist)
2732 struct perf_cpu_map *cpus = evsel->core.cpus;
2733 struct perf_thread_map *threads = evsel->core.threads;
2735 if (perf_evsel__alloc_id(&evsel->core, cpus->nr, threads->nr))
2738 return store_evsel_ids(evsel, evlist);