Lines Matching +full:switching +full:- +full:freq
1 // SPDX-License-Identifier: GPL-2.0-only
5 * Parts came from builtin-{top,stat,record}.c, see those files for further
15 #include <traceevent/event-parse.h>
43 #include "trace-event.h"
48 #include "../perf-sys.h"
49 #include "util/parse-branch-options.h"
88 return -EINVAL; in evsel__object_config()
102 #define FD(e, x, y) (*(int *)xyarray__entry(e->core.fd, x, y))
121 * __perf_evsel__calc_id_pos - calculate id_pos.
136 return -1; in __perf_evsel__calc_id_pos()
154 * __perf_evsel__calc_is_pos - calculate is_pos.
158 * (PERF_SAMPLE_ID or PERF_SAMPLE_IDENTIFIER) in a non-sample event i.e. if
159 * sample_id_all is used there is an id sample appended to non-sample events.
169 return -1; in __perf_evsel__calc_is_pos()
182 evsel->id_pos = __perf_evsel__calc_id_pos(evsel->core.attr.sample_type); in evsel__calc_id_pos()
183 evsel->is_pos = __perf_evsel__calc_is_pos(evsel->core.attr.sample_type); in evsel__calc_id_pos()
189 if (!(evsel->core.attr.sample_type & bit)) { in __evsel__set_sample_bit()
190 evsel->core.attr.sample_type |= bit; in __evsel__set_sample_bit()
191 evsel->sample_size += sizeof(u64); in __evsel__set_sample_bit()
199 if (evsel->core.attr.sample_type & bit) { in __evsel__reset_sample_bit()
200 evsel->core.attr.sample_type &= ~bit; in __evsel__reset_sample_bit()
201 evsel->sample_size -= sizeof(u64); in __evsel__reset_sample_bit()
215 evsel->core.attr.read_format |= PERF_FORMAT_ID; in evsel__set_sample_id()
219 * evsel__is_function_event - Return whether given evsel is a function
222 * @evsel - evsel selector to be tested
230 return evsel->name && in evsel__is_function_event()
231 !strncmp(FUNCTION_EVENT, evsel->name, sizeof(FUNCTION_EVENT)); in evsel__is_function_event()
239 perf_evsel__init(&evsel->core, attr); in evsel__init()
240 evsel->idx = idx; in evsel__init()
241 evsel->tracking = !idx; in evsel__init()
242 evsel->leader = evsel; in evsel__init()
243 evsel->unit = ""; in evsel__init()
244 evsel->scale = 1.0; in evsel__init()
245 evsel->max_events = ULONG_MAX; in evsel__init()
246 evsel->evlist = NULL; in evsel__init()
247 evsel->bpf_obj = NULL; in evsel__init()
248 evsel->bpf_fd = -1; in evsel__init()
249 INIT_LIST_HEAD(&evsel->config_terms); in evsel__init()
251 evsel->sample_size = __evsel__sample_size(attr->sample_type); in evsel__init()
253 evsel->cmdline_group_boundary = false; in evsel__init()
254 evsel->metric_expr = NULL; in evsel__init()
255 evsel->metric_name = NULL; in evsel__init()
256 evsel->metric_events = NULL; in evsel__init()
257 evsel->per_pkg_mask = NULL; in evsel__init()
258 evsel->collect_stat = false; in evsel__init()
259 evsel->pmu_name = NULL; in evsel__init()
271 evsel->core.attr.sample_type |= (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | in evsel__new_idx()
273 evsel->core.attr.sample_period = 1; in evsel__new_idx()
278 * The evsel->unit points to static alias->unit in evsel__new_idx()
283 evsel->unit = unit; in evsel__new_idx()
284 evsel->scale = 1e-6; in evsel__new_idx()
318 evsel->precise_max = true; in evsel__new_cycles()
321 if (asprintf(&evsel->name, "cycles%s%s%.*s", in evsel__new_cycles()
338 list_for_each_entry(pos, &src->config_terms, list) { in evsel__copy_config_terms()
341 return -ENOMEM; in evsel__copy_config_terms()
344 if (tmp->free_str) { in evsel__copy_config_terms()
345 tmp->val.str = strdup(pos->val.str); in evsel__copy_config_terms()
346 if (tmp->val.str == NULL) { in evsel__copy_config_terms()
348 return -ENOMEM; in evsel__copy_config_terms()
351 list_add_tail(&tmp->list, &dst->config_terms); in evsel__copy_config_terms()
357 * evsel__clone - create a new evsel copied from @orig
367 BUG_ON(orig->core.fd); in evsel__clone()
368 BUG_ON(orig->counts); in evsel__clone()
369 BUG_ON(orig->priv); in evsel__clone()
370 BUG_ON(orig->per_pkg_mask); in evsel__clone()
373 if (orig->bpf_obj) in evsel__clone()
376 evsel = evsel__new(&orig->core.attr); in evsel__clone()
380 evsel->core.cpus = perf_cpu_map__get(orig->core.cpus); in evsel__clone()
381 evsel->core.own_cpus = perf_cpu_map__get(orig->core.own_cpus); in evsel__clone()
382 evsel->core.threads = perf_thread_map__get(orig->core.threads); in evsel__clone()
383 evsel->core.nr_members = orig->core.nr_members; in evsel__clone()
384 evsel->core.system_wide = orig->core.system_wide; in evsel__clone()
386 if (orig->name) { in evsel__clone()
387 evsel->name = strdup(orig->name); in evsel__clone()
388 if (evsel->name == NULL) in evsel__clone()
391 if (orig->group_name) { in evsel__clone()
392 evsel->group_name = strdup(orig->group_name); in evsel__clone()
393 if (evsel->group_name == NULL) in evsel__clone()
396 if (orig->pmu_name) { in evsel__clone()
397 evsel->pmu_name = strdup(orig->pmu_name); in evsel__clone()
398 if (evsel->pmu_name == NULL) in evsel__clone()
401 if (orig->filter) { in evsel__clone()
402 evsel->filter = strdup(orig->filter); in evsel__clone()
403 if (evsel->filter == NULL) in evsel__clone()
406 evsel->cgrp = cgroup__get(orig->cgrp); in evsel__clone()
407 evsel->tp_format = orig->tp_format; in evsel__clone()
408 evsel->handler = orig->handler; in evsel__clone()
409 evsel->leader = orig->leader; in evsel__clone()
411 evsel->max_events = orig->max_events; in evsel__clone()
412 evsel->tool_event = orig->tool_event; in evsel__clone()
413 evsel->unit = orig->unit; in evsel__clone()
414 evsel->scale = orig->scale; in evsel__clone()
415 evsel->snapshot = orig->snapshot; in evsel__clone()
416 evsel->per_pkg = orig->per_pkg; in evsel__clone()
417 evsel->percore = orig->percore; in evsel__clone()
418 evsel->precise_max = orig->precise_max; in evsel__clone()
419 evsel->use_uncore_alias = orig->use_uncore_alias; in evsel__clone()
420 evsel->is_libpfm_event = orig->is_libpfm_event; in evsel__clone()
422 evsel->exclude_GH = orig->exclude_GH; in evsel__clone()
423 evsel->sample_read = orig->sample_read; in evsel__clone()
424 evsel->auto_merge_stats = orig->auto_merge_stats; in evsel__clone()
425 evsel->collect_stat = orig->collect_stat; in evsel__clone()
426 evsel->weak_group = orig->weak_group; in evsel__clone()
444 int err = -ENOMEM; in evsel__newtp_idx()
455 if (asprintf(&evsel->name, "%s:%s", sys, name) < 0) in evsel__newtp_idx()
458 evsel->tp_format = trace_event__tp_format(sys, name); in evsel__newtp_idx()
459 if (IS_ERR(evsel->tp_format)) { in evsel__newtp_idx()
460 err = PTR_ERR(evsel->tp_format); in evsel__newtp_idx()
465 attr.config = evsel->tp_format->id; in evsel__newtp_idx()
473 zfree(&evsel->name); in evsel__newtp_idx()
482 "cache-references",
483 "cache-misses",
485 "branch-misses",
486 "bus-cycles",
487 "stalled-cycles-frontend",
488 "stalled-cycles-backend",
489 "ref-cycles",
497 return "unknown-hardware"; in __evsel__hw_name()
503 struct perf_event_attr *attr = &evsel->core.attr; in perf_evsel__add_modifiers()
507 if (!attr->exclude_##context) { \ in perf_evsel__add_modifiers()
509 r += scnprintf(bf + r, size - r, "%c", mod); \ in perf_evsel__add_modifiers()
512 if (attr->exclude_kernel || attr->exclude_user || attr->exclude_hv) { in perf_evsel__add_modifiers()
519 if (attr->precise_ip) { in perf_evsel__add_modifiers()
522 r += scnprintf(bf + r, size - r, "%.*s", attr->precise_ip, "ppp"); in perf_evsel__add_modifiers()
526 if (attr->exclude_host || attr->exclude_guest == exclude_guest_default) { in perf_evsel__add_modifiers()
532 bf[colon - 1] = ':'; in perf_evsel__add_modifiers()
538 int r = scnprintf(bf, size, "%s", __evsel__hw_name(evsel->core.attr.config)); in evsel__hw_name()
539 return r + perf_evsel__add_modifiers(evsel, bf + r, size - r); in evsel__hw_name()
543 "cpu-clock",
544 "task-clock",
545 "page-faults",
546 "context-switches",
547 "cpu-migrations",
548 "minor-faults",
549 "major-faults",
550 "alignment-faults",
551 "emulation-faults",
559 return "unknown-software"; in __evsel__sw_name()
564 int r = scnprintf(bf, size, "%s", __evsel__sw_name(evsel->core.attr.config)); in evsel__sw_name()
565 return r + perf_evsel__add_modifiers(evsel, bf + r, size - r); in evsel__sw_name()
575 r += scnprintf(bf + r, size - r, "r"); in __evsel__bp_name()
578 r += scnprintf(bf + r, size - r, "w"); in __evsel__bp_name()
581 r += scnprintf(bf + r, size - r, "x"); in __evsel__bp_name()
588 struct perf_event_attr *attr = &evsel->core.attr; in evsel__bp_name()
589 int r = __evsel__bp_name(bf, size, attr->bp_addr, attr->bp_type); in evsel__bp_name()
590 return r + perf_evsel__add_modifiers(evsel, bf + r, size - r); in evsel__bp_name()
594 { "L1-dcache", "l1-d", "l1d", "L1-data", },
595 { "L1-icache", "l1-i", "l1i", "L1-instruction", },
597 { "dTLB", "d-tlb", "Data-TLB", },
598 { "iTLB", "i-tlb", "Instruction-TLB", },
606 { "prefetch", "prefetches", "speculative-read", "speculative-load", },
623 * ITLB and BPU : Read-only
646 return scnprintf(bf, size, "%s-%s-%s", evsel__hw_cache[type][0], in __evsel__hw_cache_type_op_res_name()
651 return scnprintf(bf, size, "%s-%s", evsel__hw_cache[type][0], in __evsel__hw_cache_type_op_res_name()
658 const char *err = "unknown-ext-hardware-cache-type"; in __evsel__hw_cache_name()
664 err = "unknown-ext-hardware-cache-op"; in __evsel__hw_cache_name()
669 err = "unknown-ext-hardware-cache-result"; in __evsel__hw_cache_name()
673 err = "invalid-cache"; in __evsel__hw_cache_name()
684 int ret = __evsel__hw_cache_name(evsel->core.attr.config, bf, size); in evsel__hw_cache_name()
685 return ret + perf_evsel__add_modifiers(evsel, bf + ret, size - ret); in evsel__hw_cache_name()
690 int ret = scnprintf(bf, size, "raw 0x%" PRIx64, evsel->core.attr.config); in evsel__raw_name()
691 return ret + perf_evsel__add_modifiers(evsel, bf + ret, size - ret); in evsel__raw_name()
707 if (evsel->name) in evsel__name()
708 return evsel->name; in evsel__name()
710 switch (evsel->core.attr.type) { in evsel__name()
724 if (evsel->tool_event) in evsel__name()
740 evsel->core.attr.type); in evsel__name()
744 evsel->name = strdup(bf); in evsel__name()
746 if (evsel->name) in evsel__name()
747 return evsel->name; in evsel__name()
754 return evsel->group_name ?: "anon group"; in evsel__group_name()
761 * For record -e '{cycles,instructions}'
764 * For record -e 'cycles,instructions' and report --group
773 if (!evsel->forced_leader) in evsel__group_desc()
776 ret += scnprintf(buf + ret, size - ret, "%s", evsel__name(evsel)); in evsel__group_desc()
779 ret += scnprintf(buf + ret, size - ret, ", %s", evsel__name(pos)); in evsel__group_desc()
781 if (!evsel->forced_leader) in evsel__group_desc()
782 ret += scnprintf(buf + ret, size - ret, " }"); in evsel__group_desc()
791 struct perf_event_attr *attr = &evsel->core.attr; in __evsel__config_callchain()
795 attr->sample_max_stack = param->max_stack; in __evsel__config_callchain()
797 if (opts->kernel_callchains) in __evsel__config_callchain()
798 attr->exclude_callchain_user = 1; in __evsel__config_callchain()
799 if (opts->user_callchains) in __evsel__config_callchain()
800 attr->exclude_callchain_kernel = 1; in __evsel__config_callchain()
801 if (param->record_mode == CALLCHAIN_LBR) { in __evsel__config_callchain()
802 if (!opts->branch_stack) { in __evsel__config_callchain()
803 if (attr->exclude_user) { in __evsel__config_callchain()
809 attr->branch_sample_type = PERF_SAMPLE_BRANCH_USER | in __evsel__config_callchain()
820 if (param->record_mode == CALLCHAIN_DWARF) { in __evsel__config_callchain()
824 if (opts->sample_user_regs && DWARF_MINIMAL_REGS != PERF_REGS_MASK) { in __evsel__config_callchain()
825 attr->sample_regs_user |= DWARF_MINIMAL_REGS; in __evsel__config_callchain()
826 pr_warning("WARNING: The use of --call-graph=dwarf may require all the user registers, " in __evsel__config_callchain()
827 "specifying a subset with --user-regs may render DWARF unwinding unreliable, " in __evsel__config_callchain()
830 attr->sample_regs_user |= PERF_REGS_MASK; in __evsel__config_callchain()
832 attr->sample_stack_user = param->dump_size; in __evsel__config_callchain()
833 attr->exclude_callchain_user = 1; in __evsel__config_callchain()
842 attr->exclude_callchain_user = 1; in __evsel__config_callchain()
849 if (param->enabled) in evsel__config_callchain()
857 struct perf_event_attr *attr = &evsel->core.attr; in perf_evsel__reset_callgraph()
860 if (param->record_mode == CALLCHAIN_LBR) { in perf_evsel__reset_callgraph()
862 attr->branch_sample_type &= ~(PERF_SAMPLE_BRANCH_USER | in perf_evsel__reset_callgraph()
866 if (param->record_mode == CALLCHAIN_DWARF) { in perf_evsel__reset_callgraph()
876 struct list_head *config_terms = &evsel->config_terms; in evsel__apply_config_terms()
877 struct perf_event_attr *attr = &evsel->core.attr; in evsel__apply_config_terms()
887 switch (term->type) { in evsel__apply_config_terms()
889 if (!(term->weak && opts->user_interval != ULLONG_MAX)) { in evsel__apply_config_terms()
890 attr->sample_period = term->val.period; in evsel__apply_config_terms()
891 attr->freq = 0; in evsel__apply_config_terms()
896 if (!(term->weak && opts->user_freq != UINT_MAX)) { in evsel__apply_config_terms()
897 attr->sample_freq = term->val.freq; in evsel__apply_config_terms()
898 attr->freq = 1; in evsel__apply_config_terms()
903 if (term->val.time) in evsel__apply_config_terms()
909 callgraph_buf = term->val.str; in evsel__apply_config_terms()
912 if (term->val.str && strcmp(term->val.str, "no")) { in evsel__apply_config_terms()
914 parse_branch_str(term->val.str, in evsel__apply_config_terms()
915 &attr->branch_sample_type); in evsel__apply_config_terms()
920 dump_size = term->val.stack_user; in evsel__apply_config_terms()
923 max_stack = term->val.max_stack; in evsel__apply_config_terms()
926 evsel->max_events = term->val.max_events; in evsel__apply_config_terms()
930 * attr->inherit should has already been set by in evsel__apply_config_terms()
933 * opt->no_inherit setting. in evsel__apply_config_terms()
935 attr->inherit = term->val.inherit ? 1 : 0; in evsel__apply_config_terms()
938 attr->write_backward = term->val.overwrite ? 1 : 0; in evsel__apply_config_terms()
945 attr->aux_output = term->val.aux_output ? 1 : 0; in evsel__apply_config_terms()
957 /* User explicitly set per-event callgraph, clear the old setting and reset. */ in evsel__apply_config_terms()
975 pr_err("per-event callgraph setting for %s failed. " in evsel__apply_config_terms()
977 evsel->name); in evsel__apply_config_terms()
993 /* set perf-event callgraph */ in evsel__apply_config_terms()
998 evsel->core.attr.mmap_data = track; in evsel__apply_config_terms()
1009 list_for_each_entry(term, &evsel->config_terms, list) { in __evsel__get_config_term()
1010 if (term->type == type) in __evsel__get_config_term()
1020 if (opts->freq) { in evsel__set_default_freq_period()
1021 attr->freq = 1; in evsel__set_default_freq_period()
1022 attr->sample_freq = opts->freq; in evsel__set_default_freq_period()
1024 attr->sample_period = opts->default_interval; in evsel__set_default_freq_period()
1032 * - all independent events and group leaders are disabled
1033 * - all group members are enabled
1039 * - all independent events and group leaders have
1041 * - we don't specifically enable or disable any event during
1049 * - we specifically enable or disable all events during
1059 struct evsel *leader = evsel->leader; in evsel__config()
1060 struct perf_event_attr *attr = &evsel->core.attr; in evsel__config()
1061 int track = evsel->tracking; in evsel__config()
1062 bool per_cpu = opts->target.default_per_cpu && !opts->target.per_thread; in evsel__config()
1064 attr->sample_id_all = perf_missing_features.sample_id_all ? 0 : 1; in evsel__config()
1065 attr->inherit = !opts->no_inherit; in evsel__config()
1066 attr->write_backward = opts->overwrite ? 1 : 0; in evsel__config()
1071 if (evsel->sample_read) { in evsel__config()
1084 if (leader->core.nr_members > 1) { in evsel__config()
1085 attr->read_format |= PERF_FORMAT_GROUP; in evsel__config()
1086 attr->inherit = 0; in evsel__config()
1094 if ((evsel->is_libpfm_event && !attr->sample_period) || in evsel__config()
1095 (!evsel->is_libpfm_event && (!attr->sample_period || in evsel__config()
1096 opts->user_freq != UINT_MAX || in evsel__config()
1097 opts->user_interval != ULLONG_MAX))) in evsel__config()
1101 * If attr->freq was set (here or earlier), ask for period in evsel__config()
1104 if (attr->freq) in evsel__config()
1107 if (opts->no_samples) in evsel__config()
1108 attr->sample_freq = 0; in evsel__config()
1110 if (opts->inherit_stat) { in evsel__config()
1111 evsel->core.attr.read_format |= in evsel__config()
1115 attr->inherit_stat = 1; in evsel__config()
1118 if (opts->sample_address) { in evsel__config()
1120 attr->mmap_data = track; in evsel__config()
1129 evsel->core.attr.exclude_callchain_user = 1; in evsel__config()
1131 if (callchain && callchain->enabled && !evsel->no_aux_samples) in evsel__config()
1134 if (opts->sample_intr_regs && !evsel->no_aux_samples && in evsel__config()
1136 attr->sample_regs_intr = opts->sample_intr_regs; in evsel__config()
1140 if (opts->sample_user_regs && !evsel->no_aux_samples && in evsel__config()
1142 attr->sample_regs_user |= opts->sample_user_regs; in evsel__config()
1146 if (target__has_cpu(&opts->target) || opts->sample_cpu) in evsel__config()
1152 if (opts->sample_time && in evsel__config()
1154 (!opts->no_inherit || target__has_cpu(&opts->target) || per_cpu || in evsel__config()
1155 opts->sample_time_set))) in evsel__config()
1158 if (opts->raw_samples && !evsel->no_aux_samples) { in evsel__config()
1164 if (opts->sample_address) in evsel__config()
1167 if (opts->sample_phys_addr) in evsel__config()
1170 if (opts->no_buffering) { in evsel__config()
1171 attr->watermark = 0; in evsel__config()
1172 attr->wakeup_events = 1; in evsel__config()
1174 if (opts->branch_stack && !evsel->no_aux_samples) { in evsel__config()
1176 attr->branch_sample_type = opts->branch_stack; in evsel__config()
1179 if (opts->sample_weight) in evsel__config()
1182 attr->task = track; in evsel__config()
1183 attr->mmap = track; in evsel__config()
1184 attr->mmap2 = track && !perf_missing_features.mmap2; in evsel__config()
1185 attr->comm = track; in evsel__config()
1190 if (!opts->text_poke) in evsel__config()
1191 attr->ksymbol = track && !perf_missing_features.ksymbol; in evsel__config()
1192 attr->bpf_event = track && !opts->no_bpf_event && !perf_missing_features.bpf; in evsel__config()
1194 if (opts->record_namespaces) in evsel__config()
1195 attr->namespaces = track; in evsel__config()
1197 if (opts->record_cgroup) { in evsel__config()
1198 attr->cgroup = track && !perf_missing_features.cgroup; in evsel__config()
1202 if (opts->record_switch_events) in evsel__config()
1203 attr->context_switch = track; in evsel__config()
1205 if (opts->sample_transaction) in evsel__config()
1208 if (opts->running_time) { in evsel__config()
1209 evsel->core.attr.read_format |= in evsel__config()
1221 attr->disabled = 1; in evsel__config()
1227 if (target__none(&opts->target) && evsel__is_group_leader(evsel) && in evsel__config()
1228 !opts->initial_delay) in evsel__config()
1229 attr->enable_on_exec = 1; in evsel__config()
1231 if (evsel->immediate) { in evsel__config()
1232 attr->disabled = 0; in evsel__config()
1233 attr->enable_on_exec = 0; in evsel__config()
1236 clockid = opts->clockid; in evsel__config()
1237 if (opts->use_clockid) { in evsel__config()
1238 attr->use_clockid = 1; in evsel__config()
1239 attr->clockid = opts->clockid; in evsel__config()
1242 if (evsel->precise_max) in evsel__config()
1243 attr->precise_ip = 3; in evsel__config()
1245 if (opts->all_user) { in evsel__config()
1246 attr->exclude_kernel = 1; in evsel__config()
1247 attr->exclude_user = 0; in evsel__config()
1250 if (opts->all_kernel) { in evsel__config()
1251 attr->exclude_kernel = 0; in evsel__config()
1252 attr->exclude_user = 1; in evsel__config()
1255 if (evsel->core.own_cpus || evsel->unit) in evsel__config()
1256 evsel->core.attr.read_format |= PERF_FORMAT_ID; in evsel__config()
1264 evsel->ignore_missing_thread = opts->ignore_missing_thread; in evsel__config()
1266 /* The --period option takes the precedence. */ in evsel__config()
1267 if (opts->period_set) { in evsel__config()
1268 if (opts->period) in evsel__config()
1279 * The software event will trigger -EOPNOTSUPP error out, in evsel__config()
1291 free(evsel->filter); in evsel__set_filter()
1292 evsel->filter = new_filter; in evsel__set_filter()
1296 return -1; in evsel__set_filter()
1303 if (evsel->filter == NULL) in evsel__append_filter()
1306 if (asprintf(&new_filter, fmt, evsel->filter, filter) > 0) { in evsel__append_filter()
1307 free(evsel->filter); in evsel__append_filter()
1308 evsel->filter = new_filter; in evsel__append_filter()
1312 return -1; in evsel__append_filter()
1328 return perf_evsel__enable_cpu(&evsel->core, cpu); in evsel__enable_cpu()
1333 int err = perf_evsel__enable(&evsel->core); in evsel__enable()
1336 evsel->disabled = false; in evsel__enable()
1343 return perf_evsel__disable_cpu(&evsel->core, cpu); in evsel__disable_cpu()
1348 int err = perf_evsel__disable(&evsel->core); in evsel__disable()
1356 evsel->disabled = true; in evsel__disable()
1365 list_for_each_entry_safe(term, h, &evsel->config_terms, list) { in evsel__free_config_terms()
1366 list_del_init(&term->list); in evsel__free_config_terms()
1367 if (term->free_str) in evsel__free_config_terms()
1368 zfree(&term->val.str); in evsel__free_config_terms()
1375 assert(list_empty(&evsel->core.node)); in evsel__exit()
1376 assert(evsel->evlist == NULL); in evsel__exit()
1378 perf_evsel__free_fd(&evsel->core); in evsel__exit()
1379 perf_evsel__free_id(&evsel->core); in evsel__exit()
1381 cgroup__put(evsel->cgrp); in evsel__exit()
1382 perf_cpu_map__put(evsel->core.cpus); in evsel__exit()
1383 perf_cpu_map__put(evsel->core.own_cpus); in evsel__exit()
1384 perf_thread_map__put(evsel->core.threads); in evsel__exit()
1385 zfree(&evsel->group_name); in evsel__exit()
1386 zfree(&evsel->name); in evsel__exit()
1387 zfree(&evsel->pmu_name); in evsel__exit()
1388 zfree(&evsel->per_pkg_mask); in evsel__exit()
1389 zfree(&evsel->metric_events); in evsel__exit()
1404 if (!evsel->prev_raw_counts) in evsel__compute_deltas()
1407 if (cpu == -1) { in evsel__compute_deltas()
1408 tmp = evsel->prev_raw_counts->aggr; in evsel__compute_deltas()
1409 evsel->prev_raw_counts->aggr = *count; in evsel__compute_deltas()
1411 tmp = *perf_counts(evsel->prev_raw_counts, cpu, thread); in evsel__compute_deltas()
1412 *perf_counts(evsel->prev_raw_counts, cpu, thread) = *count; in evsel__compute_deltas()
1415 count->val = count->val - tmp.val; in evsel__compute_deltas()
1416 count->ena = count->ena - tmp.ena; in evsel__compute_deltas()
1417 count->run = count->run - tmp.run; in evsel__compute_deltas()
1426 if (count->run == 0) { in perf_counts_values__scale()
1427 scaled = -1; in perf_counts_values__scale()
1428 count->val = 0; in perf_counts_values__scale()
1429 } else if (count->run < count->ena) { in perf_counts_values__scale()
1431 count->val = (u64)((double) count->val * count->ena / count->run); in perf_counts_values__scale()
1441 struct perf_counts_values *count = perf_counts(evsel->counts, cpu, thread); in evsel__read_one()
1443 return perf_evsel__read(&evsel->core, cpu, thread, count); in evsel__read_one()
1452 count = perf_counts(counter->counts, cpu, thread); in perf_evsel__set_count()
1454 count->val = val; in perf_evsel__set_count()
1455 count->ena = ena; in perf_evsel__set_count()
1456 count->run = run; in perf_evsel__set_count()
1458 perf_counts__set_loaded(counter->counts, cpu, thread, true); in perf_evsel__set_count()
1465 u64 read_format = leader->core.attr.read_format; in perf_evsel__process_group_data()
1471 if (nr != (u64) leader->core.nr_members) in perf_evsel__process_group_data()
1472 return -EINVAL; in perf_evsel__process_group_data()
1488 counter = perf_evlist__id2evsel(leader->evlist, v[i].id); in perf_evsel__process_group_data()
1490 return -EINVAL; in perf_evsel__process_group_data()
1501 struct perf_stat_evsel *ps = leader->stats; in evsel__read_group()
1502 u64 read_format = leader->core.attr.read_format; in evsel__read_group()
1503 int size = perf_evsel__read_size(&leader->core); in evsel__read_group()
1504 u64 *data = ps->group_data; in evsel__read_group()
1507 return -EINVAL; in evsel__read_group()
1510 return -EINVAL; in evsel__read_group()
1515 return -ENOMEM; in evsel__read_group()
1517 ps->group_data = data; in evsel__read_group()
1521 return -EINVAL; in evsel__read_group()
1524 return -errno; in evsel__read_group()
1531 u64 read_format = evsel->core.attr.read_format; in evsel__read_counter()
1545 return -EINVAL; in __evsel__read_on_cpu()
1547 if (evsel->counts == NULL && evsel__alloc_counts(evsel, cpu + 1, thread + 1) < 0) in __evsel__read_on_cpu()
1548 return -ENOMEM; in __evsel__read_on_cpu()
1551 return -errno; in __evsel__read_on_cpu()
1555 *perf_counts(evsel->counts, cpu, thread) = count; in __evsel__read_on_cpu()
1561 struct evsel *leader = evsel->leader; in get_group_fd()
1565 return -1; in get_group_fd()
1571 BUG_ON(!leader->core.fd); in get_group_fd()
1574 BUG_ON(fd == -1); in get_group_fd()
1584 for (int thread = thread_idx; thread < nr_threads - 1; thread++) in perf_evsel__remove_fd()
1595 return -EINVAL; in update_fds()
1597 evlist__for_each_entry(evsel->evlist, pos) { in update_fds()
1619 if (!evsel->ignore_missing_thread) in ignore_missing_thread()
1623 if (evsel->core.system_wide) in ignore_missing_thread()
1626 /* The -ESRCH is perf event syscall errno for pid's not found. */ in ignore_missing_thread()
1627 if (err != -ESRCH) in ignore_missing_thread()
1631 if (threads->nr == 1) in ignore_missing_thread()
1636 * because thread_map__remove() will decrease threads->nr. in ignore_missing_thread()
1638 if (update_fds(evsel, nr_cpus, cpu, threads->nr, thread)) in ignore_missing_thread()
1652 return fprintf(fp, " %-32s %s\n", name, val); in __open_attr__fprintf()
1669 int precise_ip = evsel->core.attr.precise_ip; in perf_event_open()
1676 fd = sys_perf_event_open(&evsel->core.attr, pid, cpu, group_fd, flags); in perf_event_open()
1681 if (!evsel->precise_max) in perf_event_open()
1688 if (!evsel->core.attr.precise_ip) { in perf_event_open()
1689 evsel->core.attr.precise_ip = precise_ip; in perf_event_open()
1693 pr_debug2_peo("\nsys_perf_event_open failed, error %d\n", -ENOTSUP); in perf_event_open()
1694 evsel->core.attr.precise_ip--; in perf_event_open()
1695 pr_debug2_peo("decreasing precise_ip by one (%d)\n", evsel->core.attr.precise_ip); in perf_event_open()
1696 display_attr(&evsel->core.attr); in perf_event_open()
1708 int pid = -1, err, old_errno; in evsel__open_cpu()
1711 if ((perf_missing_features.write_backward && evsel->core.attr.write_backward) || in evsel__open_cpu()
1712 (perf_missing_features.aux_output && evsel->core.attr.aux_output)) in evsel__open_cpu()
1713 return -EINVAL; in evsel__open_cpu()
1721 return -ENOMEM; in evsel__open_cpu()
1731 empty_thread_map = thread_map__new_by_tid(-1); in evsel__open_cpu()
1733 return -ENOMEM; in evsel__open_cpu()
1739 if (evsel->core.system_wide) in evsel__open_cpu()
1742 nthreads = threads->nr; in evsel__open_cpu()
1744 if (evsel->core.fd == NULL && in evsel__open_cpu()
1745 perf_evsel__alloc_fd(&evsel->core, cpus->nr, nthreads) < 0) in evsel__open_cpu()
1746 return -ENOMEM; in evsel__open_cpu()
1748 if (evsel->cgrp) { in evsel__open_cpu()
1750 pid = evsel->cgrp->fd; in evsel__open_cpu()
1755 evsel->core.attr.clockid = CLOCK_MONOTONIC; /* should always work */ in evsel__open_cpu()
1757 evsel->core.attr.use_clockid = 0; in evsel__open_cpu()
1758 evsel->core.attr.clockid = 0; in evsel__open_cpu()
1763 evsel->core.attr.mmap2 = 0; in evsel__open_cpu()
1765 evsel->core.attr.exclude_guest = evsel->core.attr.exclude_host = 0; in evsel__open_cpu()
1767 evsel->core.attr.branch_sample_type &= ~(PERF_SAMPLE_BRANCH_NO_FLAGS | in evsel__open_cpu()
1769 if (perf_missing_features.group_read && evsel->core.attr.inherit) in evsel__open_cpu()
1770 evsel->core.attr.read_format &= ~(PERF_FORMAT_GROUP|PERF_FORMAT_ID); in evsel__open_cpu()
1772 evsel->core.attr.ksymbol = 0; in evsel__open_cpu()
1774 evsel->core.attr.bpf_event = 0; in evsel__open_cpu()
1776 evsel->core.attr.branch_sample_type &= ~PERF_SAMPLE_BRANCH_HW_INDEX; in evsel__open_cpu()
1779 evsel->core.attr.sample_id_all = 0; in evsel__open_cpu()
1781 display_attr(&evsel->core.attr); in evsel__open_cpu()
1788 if (!evsel->cgrp && !evsel->core.system_wide) in evsel__open_cpu()
1795 fd = perf_event_open(evsel, pid, cpus->map[cpu], in evsel__open_cpu()
1801 test_attr__open(&evsel->core.attr, pid, cpus->map[cpu], in evsel__open_cpu()
1806 err = -errno; in evsel__open_cpu()
1808 if (ignore_missing_thread(evsel, cpus->nr, cpu, threads, thread, err)) { in evsel__open_cpu()
1814 nthreads--; in evsel__open_cpu()
1815 thread--; in evsel__open_cpu()
1829 if (evsel->bpf_fd >= 0) { in evsel__open_cpu()
1831 int bpf_fd = evsel->bpf_fd; in evsel__open_cpu()
1839 err = -EINVAL; in evsel__open_cpu()
1852 err = -EINVAL; in evsel__open_cpu()
1865 if (err == -EMFILE && set_rlimit < INCREASED_MAX) { in evsel__open_cpu()
1885 if (err != -EINVAL || cpu > 0 || thread > 0) in evsel__open_cpu()
1892 if (!perf_missing_features.cgroup && evsel->core.attr.cgroup) { in evsel__open_cpu()
1897 (evsel->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_HW_INDEX)) { in evsel__open_cpu()
1899 pr_debug2("switching off branch HW index support\n"); in evsel__open_cpu()
1901 } else if (!perf_missing_features.aux_output && evsel->core.attr.aux_output) { in evsel__open_cpu()
1905 } else if (!perf_missing_features.bpf && evsel->core.attr.bpf_event) { in evsel__open_cpu()
1907 pr_debug2_peo("switching off bpf_event\n"); in evsel__open_cpu()
1909 } else if (!perf_missing_features.ksymbol && evsel->core.attr.ksymbol) { in evsel__open_cpu()
1911 pr_debug2_peo("switching off ksymbol\n"); in evsel__open_cpu()
1913 } else if (!perf_missing_features.write_backward && evsel->core.attr.write_backward) { in evsel__open_cpu()
1915 pr_debug2_peo("switching off write_backward\n"); in evsel__open_cpu()
1917 } else if (!perf_missing_features.clockid_wrong && evsel->core.attr.use_clockid) { in evsel__open_cpu()
1919 pr_debug2_peo("switching off clockid\n"); in evsel__open_cpu()
1921 } else if (!perf_missing_features.clockid && evsel->core.attr.use_clockid) { in evsel__open_cpu()
1923 pr_debug2_peo("switching off use_clockid\n"); in evsel__open_cpu()
1927 pr_debug2_peo("switching off cloexec flag\n"); in evsel__open_cpu()
1929 } else if (!perf_missing_features.mmap2 && evsel->core.attr.mmap2) { in evsel__open_cpu()
1931 pr_debug2_peo("switching off mmap2\n"); in evsel__open_cpu()
1934 (evsel->core.attr.exclude_guest || evsel->core.attr.exclude_host)) { in evsel__open_cpu()
1936 pr_debug2_peo("switching off exclude_guest, exclude_host\n"); in evsel__open_cpu()
1940 pr_debug2_peo("switching off sample_id_all\n"); in evsel__open_cpu()
1943 (evsel->core.attr.branch_sample_type & in evsel__open_cpu()
1947 pr_debug2_peo("switching off branch sample type no (cycles/flags)\n"); in evsel__open_cpu()
1950 evsel->core.attr.inherit && in evsel__open_cpu()
1951 (evsel->core.attr.read_format & PERF_FORMAT_GROUP) && in evsel__open_cpu()
1954 pr_debug2_peo("switching off group read\n"); in evsel__open_cpu()
1959 threads->err_thread = thread; in evsel__open_cpu()
1963 while (--thread >= 0) { in evsel__open_cpu()
1966 FD(evsel, cpu, thread) = -1; in evsel__open_cpu()
1969 } while (--cpu >= 0); in evsel__open_cpu()
1977 return evsel__open_cpu(evsel, cpus, threads, 0, cpus ? cpus->nr : 1); in evsel__open()
1982 perf_evsel__close(&evsel->core); in evsel__close()
1983 perf_evsel__free_id(&evsel->core); in evsel__close()
1988 if (cpu == -1) in evsel__open_per_cpu()
1990 cpus ? cpus->nr : 1); in evsel__open_per_cpu()
2004 u64 type = evsel->core.attr.sample_type; in perf_evsel__parse_id_sample()
2005 const __u64 *array = event->sample.array; in perf_evsel__parse_id_sample()
2006 bool swapped = evsel->needs_swap; in perf_evsel__parse_id_sample()
2009 array += ((event->header.size - in perf_evsel__parse_id_sample()
2010 sizeof(event->header)) / sizeof(u64)) - 1; in perf_evsel__parse_id_sample()
2013 sample->id = *array; in perf_evsel__parse_id_sample()
2014 array--; in perf_evsel__parse_id_sample()
2025 sample->cpu = u.val32[0]; in perf_evsel__parse_id_sample()
2026 array--; in perf_evsel__parse_id_sample()
2030 sample->stream_id = *array; in perf_evsel__parse_id_sample()
2031 array--; in perf_evsel__parse_id_sample()
2035 sample->id = *array; in perf_evsel__parse_id_sample()
2036 array--; in perf_evsel__parse_id_sample()
2040 sample->time = *array; in perf_evsel__parse_id_sample()
2041 array--; in perf_evsel__parse_id_sample()
2053 sample->pid = u.val32[0]; in perf_evsel__parse_id_sample()
2054 sample->tid = u.val32[1]; in perf_evsel__parse_id_sample()
2055 array--; in perf_evsel__parse_id_sample()
2070 return -EFAULT; \
2084 if (sample_size + sizeof(event->header) > event->header.size) in perf_event__check_size()
2085 return -EFAULT; in perf_event__check_size()
2093 u64 type = evsel->core.attr.sample_type; in evsel__parse_sample()
2094 bool swapped = evsel->needs_swap; in evsel__parse_sample()
2096 u16 max_size = event->header.size; in evsel__parse_sample()
2101 * used for cross-endian analysis. See git commit 65014ab3 in evsel__parse_sample()
2107 data->cpu = data->pid = data->tid = -1; in evsel__parse_sample()
2108 data->stream_id = data->id = data->time = -1ULL; in evsel__parse_sample()
2109 data->period = evsel->core.attr.sample_period; in evsel__parse_sample()
2110 data->cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; in evsel__parse_sample()
2111 data->misc = event->header.misc; in evsel__parse_sample()
2112 data->id = -1ULL; in evsel__parse_sample()
2113 data->data_src = PERF_MEM_DATA_SRC_NONE; in evsel__parse_sample()
2115 if (event->header.type != PERF_RECORD_SAMPLE) { in evsel__parse_sample()
2116 if (!evsel->core.attr.sample_id_all) in evsel__parse_sample()
2121 array = event->sample.array; in evsel__parse_sample()
2123 if (perf_event__check_size(event, evsel->sample_size)) in evsel__parse_sample()
2124 return -EFAULT; in evsel__parse_sample()
2127 data->id = *array; in evsel__parse_sample()
2132 data->ip = *array; in evsel__parse_sample()
2145 data->pid = u.val32[0]; in evsel__parse_sample()
2146 data->tid = u.val32[1]; in evsel__parse_sample()
2151 data->time = *array; in evsel__parse_sample()
2156 data->addr = *array; in evsel__parse_sample()
2161 data->id = *array; in evsel__parse_sample()
2166 data->stream_id = *array; in evsel__parse_sample()
2179 data->cpu = u.val32[0]; in evsel__parse_sample()
2184 data->period = *array; in evsel__parse_sample()
2189 u64 read_format = evsel->core.attr.read_format; in evsel__parse_sample()
2193 data->read.group.nr = *array; in evsel__parse_sample()
2195 data->read.one.value = *array; in evsel__parse_sample()
2201 data->read.time_enabled = *array; in evsel__parse_sample()
2207 data->read.time_running = *array; in evsel__parse_sample()
2216 if (data->read.group.nr > max_group_nr) in evsel__parse_sample()
2217 return -EFAULT; in evsel__parse_sample()
2218 sz = data->read.group.nr * in evsel__parse_sample()
2221 data->read.group.values = in evsel__parse_sample()
2226 data->read.one.id = *array; in evsel__parse_sample()
2235 data->callchain = (struct ip_callchain *)array++; in evsel__parse_sample()
2236 if (data->callchain->nr > max_callchain_nr) in evsel__parse_sample()
2237 return -EFAULT; in evsel__parse_sample()
2238 sz = data->callchain->nr * sizeof(u64); in evsel__parse_sample()
2258 data->raw_size = u.val32[0]; in evsel__parse_sample()
2265 mem_bswap_64((void *) array, data->raw_size); in evsel__parse_sample()
2269 OVERFLOW_CHECK(array, data->raw_size, max_size); in evsel__parse_sample()
2270 data->raw_data = (void *)array; in evsel__parse_sample()
2271 array = (void *)array + data->raw_size; in evsel__parse_sample()
2279 data->branch_stack = (struct branch_stack *)array++; in evsel__parse_sample()
2281 if (data->branch_stack->nr > max_branch_nr) in evsel__parse_sample()
2282 return -EFAULT; in evsel__parse_sample()
2284 sz = data->branch_stack->nr * sizeof(struct branch_entry); in evsel__parse_sample()
2288 data->no_hw_idx = true; in evsel__parse_sample()
2295 data->user_regs.abi = *array; in evsel__parse_sample()
2298 if (data->user_regs.abi) { in evsel__parse_sample()
2299 u64 mask = evsel->core.attr.sample_regs_user; in evsel__parse_sample()
2303 data->user_regs.mask = mask; in evsel__parse_sample()
2304 data->user_regs.regs = (u64 *)array; in evsel__parse_sample()
2313 data->user_stack.offset = ((char *)(array - 1) in evsel__parse_sample()
2314 - (char *) event); in evsel__parse_sample()
2317 data->user_stack.size = 0; in evsel__parse_sample()
2320 data->user_stack.data = (char *)array; in evsel__parse_sample()
2323 data->user_stack.size = *array++; in evsel__parse_sample()
2324 if (WARN_ONCE(data->user_stack.size > sz, in evsel__parse_sample()
2326 return -EFAULT; in evsel__parse_sample()
2332 data->weight = *array; in evsel__parse_sample()
2338 data->data_src = *array; in evsel__parse_sample()
2344 data->transaction = *array; in evsel__parse_sample()
2348 data->intr_regs.abi = PERF_SAMPLE_REGS_ABI_NONE; in evsel__parse_sample()
2351 data->intr_regs.abi = *array; in evsel__parse_sample()
2354 if (data->intr_regs.abi != PERF_SAMPLE_REGS_ABI_NONE) { in evsel__parse_sample()
2355 u64 mask = evsel->core.attr.sample_regs_intr; in evsel__parse_sample()
2359 data->intr_regs.mask = mask; in evsel__parse_sample()
2360 data->intr_regs.regs = (u64 *)array; in evsel__parse_sample()
2365 data->phys_addr = 0; in evsel__parse_sample()
2367 data->phys_addr = *array; in evsel__parse_sample()
2371 data->cgroup = 0; in evsel__parse_sample()
2373 data->cgroup = *array; in evsel__parse_sample()
2385 data->aux_sample.size = sz; in evsel__parse_sample()
2386 data->aux_sample.data = (char *)array; in evsel__parse_sample()
2396 u64 type = evsel->core.attr.sample_type; in evsel__parse_sample_timestamp()
2400 return -1; in evsel__parse_sample_timestamp()
2402 if (event->header.type != PERF_RECORD_SAMPLE) { in evsel__parse_sample_timestamp()
2404 .time = -1ULL, in evsel__parse_sample_timestamp()
2407 if (!evsel->core.attr.sample_id_all) in evsel__parse_sample_timestamp()
2408 return -1; in evsel__parse_sample_timestamp()
2410 return -1; in evsel__parse_sample_timestamp()
2416 array = event->sample.array; in evsel__parse_sample_timestamp()
2418 if (perf_event__check_size(event, evsel->sample_size)) in evsel__parse_sample_timestamp()
2419 return -EFAULT; in evsel__parse_sample_timestamp()
2438 return tep_find_field(evsel->tp_format, name); in evsel__field()
2449 offset = field->offset; in evsel__rawptr()
2451 if (field->flags & TEP_FIELD_IS_DYNAMIC) { in evsel__rawptr()
2452 offset = *(int *)(sample->raw_data + field->offset); in evsel__rawptr()
2456 return sample->raw_data + offset; in evsel__rawptr()
2463 void *ptr = sample->raw_data + field->offset; in format_field__intval()
2465 switch (field->size) { in format_field__intval()
2484 switch (field->size) { in format_field__intval()
2505 return field ? format_field__intval(field, sample, evsel->needs_swap) : 0; in evsel__intval()
2513 evsel->core.attr.type == PERF_TYPE_HARDWARE && in evsel__fallback()
2514 evsel->core.attr.config == PERF_COUNT_HW_CPU_CYCLES) { in evsel__fallback()
2517 * cpu-clock-tick sw counter, which is always available even if in evsel__fallback()
2524 "The cycles event is not supported, trying to fall back to cpu-clock-ticks"); in evsel__fallback()
2526 evsel->core.attr.type = PERF_TYPE_SOFTWARE; in evsel__fallback()
2527 evsel->core.attr.config = PERF_COUNT_SW_CPU_CLOCK; in evsel__fallback()
2529 zfree(&evsel->name); in evsel__fallback()
2531 } else if (err == EACCES && !evsel->core.attr.exclude_kernel && in evsel__fallback()
2538 if (evsel->core.attr.exclude_user) in evsel__fallback()
2543 (strchr(name, ':') && !evsel->is_libpfm_event)) in evsel__fallback()
2549 if (evsel->name) in evsel__fallback()
2550 free(evsel->name); in evsel__fallback()
2551 evsel->name = new_name; in evsel__fallback()
2555 evsel->core.attr.exclude_kernel = 1; in evsel__fallback()
2556 evsel->core.attr.exclude_hv = 1; in evsel__fallback()
2569 int ret = -1; in find_process()
2581 if ((d->d_type != DT_DIR) || in find_process()
2582 !strcmp(".", d->d_name) || in find_process()
2583 !strcmp("..", d->d_name)) in find_process()
2587 procfs__mountpoint(), d->d_name); in find_process()
2609 printed += scnprintf(msg + printed, size - printed, in evsel__open_strerror()
2614 printed += scnprintf(msg + printed, size - printed, in evsel__open_strerror()
2625 return scnprintf(msg + printed, size - printed, in evsel__open_strerror()
2630 "https://www.kernel.org/doc/html/latest/admin-guide/perf-security.html\n" in evsel__open_strerror()
2632 " -1: Allow use of (almost) all events by all users\n" in evsel__open_strerror()
2647 "Hint: Try increasing the limit with 'ulimit -n <limit>'"); in evsel__open_strerror()
2657 if (target->cpu_list) in evsel__open_strerror()
2659 "No such device - did you specify an out-of-range profile CPU?"); in evsel__open_strerror()
2662 if (evsel->core.attr.aux_output) in evsel__open_strerror()
2666 if (evsel->core.attr.sample_period != 0) in evsel__open_strerror()
2668 "%s: PMU Hardware doesn't support sampling/overflow-interrupts. Try 'perf stat'", in evsel__open_strerror()
2670 if (evsel->core.attr.precise_ip) in evsel__open_strerror()
2674 if (evsel->core.attr.type == PERF_TYPE_HARDWARE) in evsel__open_strerror()
2686 if (evsel->core.attr.write_backward && perf_missing_features.write_backward) in evsel__open_strerror()
2701 "/bin/dmesg | grep -i perf may provide additional information.\n", in evsel__open_strerror()
2707 if (evsel && evsel->evlist) in evsel__env()
2708 return evsel->evlist->env; in evsel__env()
2716 for (cpu = 0; cpu < xyarray__max_x(evsel->core.fd); cpu++) { in store_evsel_ids()
2717 for (thread = 0; thread < xyarray__max_y(evsel->core.fd); in store_evsel_ids()
2721 if (perf_evlist__id_add_fd(&evlist->core, &evsel->core, in store_evsel_ids()
2723 return -1; in store_evsel_ids()
2732 struct perf_cpu_map *cpus = evsel->core.cpus; in evsel__store_ids()
2733 struct perf_thread_map *threads = evsel->core.threads; in evsel__store_ids()
2735 if (perf_evsel__alloc_id(&evsel->core, cpus->nr, threads->nr)) in evsel__store_ids()
2736 return -ENOMEM; in evsel__store_ids()