Lines Matching +full:cpu +full:- +full:core
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()
1021 * - all independent events and group leaders are disabled
1022 * - all group members are enabled
1028 * - all independent events and group leaders have
1030 * - we don't specifically enable or disable any event during
1038 * - we specifically enable or disable all events during
1048 struct evsel *leader = evsel->leader; in evsel__config()
1049 struct perf_event_attr *attr = &evsel->core.attr; in evsel__config()
1050 int track = evsel->tracking; in evsel__config()
1051 bool per_cpu = opts->target.default_per_cpu && !opts->target.per_thread; in evsel__config()
1053 attr->sample_id_all = perf_missing_features.sample_id_all ? 0 : 1; in evsel__config()
1054 attr->inherit = !opts->no_inherit; in evsel__config()
1055 attr->write_backward = opts->overwrite ? 1 : 0; in evsel__config()
1060 if (evsel->sample_read) { in evsel__config()
1073 if (leader->core.nr_members > 1) { in evsel__config()
1074 attr->read_format |= PERF_FORMAT_GROUP; in evsel__config()
1075 attr->inherit = 0; in evsel__config()
1083 if (!attr->sample_period) { in evsel__config()
1084 if (opts->freq) { in evsel__config()
1085 attr->freq = 1; in evsel__config()
1086 attr->sample_freq = opts->freq; in evsel__config()
1088 attr->sample_period = opts->default_interval; in evsel__config()
1092 * If attr->freq was set (here or earlier), ask for period in evsel__config()
1095 if (attr->freq) in evsel__config()
1098 if (opts->no_samples) in evsel__config()
1099 attr->sample_freq = 0; in evsel__config()
1101 if (opts->inherit_stat) { in evsel__config()
1102 evsel->core.attr.read_format |= in evsel__config()
1106 attr->inherit_stat = 1; in evsel__config()
1109 if (opts->sample_address) { in evsel__config()
1111 attr->mmap_data = track; in evsel__config()
1120 evsel->core.attr.exclude_callchain_user = 1; in evsel__config()
1122 if (callchain && callchain->enabled && !evsel->no_aux_samples) in evsel__config()
1125 if (opts->sample_intr_regs && !evsel->no_aux_samples && in evsel__config()
1127 attr->sample_regs_intr = opts->sample_intr_regs; in evsel__config()
1131 if (opts->sample_user_regs && !evsel->no_aux_samples && in evsel__config()
1133 attr->sample_regs_user |= opts->sample_user_regs; in evsel__config()
1137 if (target__has_cpu(&opts->target) || opts->sample_cpu) in evsel__config()
1138 evsel__set_sample_bit(evsel, CPU); in evsel__config()
1143 if (opts->sample_time && in evsel__config()
1145 (!opts->no_inherit || target__has_cpu(&opts->target) || per_cpu || in evsel__config()
1146 opts->sample_time_set))) in evsel__config()
1149 if (opts->raw_samples && !evsel->no_aux_samples) { in evsel__config()
1152 evsel__set_sample_bit(evsel, CPU); in evsel__config()
1155 if (opts->sample_address) in evsel__config()
1158 if (opts->sample_phys_addr) in evsel__config()
1161 if (opts->no_buffering) { in evsel__config()
1162 attr->watermark = 0; in evsel__config()
1163 attr->wakeup_events = 1; in evsel__config()
1165 if (opts->branch_stack && !evsel->no_aux_samples) { in evsel__config()
1167 attr->branch_sample_type = opts->branch_stack; in evsel__config()
1170 if (opts->sample_weight) in evsel__config()
1173 attr->task = track; in evsel__config()
1174 attr->mmap = track; in evsel__config()
1175 attr->mmap2 = track && !perf_missing_features.mmap2; in evsel__config()
1176 attr->comm = track; in evsel__config()
1181 if (!opts->text_poke) in evsel__config()
1182 attr->ksymbol = track && !perf_missing_features.ksymbol; in evsel__config()
1183 attr->bpf_event = track && !opts->no_bpf_event && !perf_missing_features.bpf; in evsel__config()
1185 if (opts->record_namespaces) in evsel__config()
1186 attr->namespaces = track; in evsel__config()
1188 if (opts->record_cgroup) { in evsel__config()
1189 attr->cgroup = track && !perf_missing_features.cgroup; in evsel__config()
1193 if (opts->record_switch_events) in evsel__config()
1194 attr->context_switch = track; in evsel__config()
1196 if (opts->sample_transaction) in evsel__config()
1199 if (opts->running_time) { in evsel__config()
1200 evsel->core.attr.read_format |= in evsel__config()
1212 attr->disabled = 1; in evsel__config()
1218 if (target__none(&opts->target) && evsel__is_group_leader(evsel) && in evsel__config()
1219 !opts->initial_delay) in evsel__config()
1220 attr->enable_on_exec = 1; in evsel__config()
1222 if (evsel->immediate) { in evsel__config()
1223 attr->disabled = 0; in evsel__config()
1224 attr->enable_on_exec = 0; in evsel__config()
1227 clockid = opts->clockid; in evsel__config()
1228 if (opts->use_clockid) { in evsel__config()
1229 attr->use_clockid = 1; in evsel__config()
1230 attr->clockid = opts->clockid; in evsel__config()
1233 if (evsel->precise_max) in evsel__config()
1234 attr->precise_ip = 3; in evsel__config()
1236 if (opts->all_user) { in evsel__config()
1237 attr->exclude_kernel = 1; in evsel__config()
1238 attr->exclude_user = 0; in evsel__config()
1241 if (opts->all_kernel) { in evsel__config()
1242 attr->exclude_kernel = 0; in evsel__config()
1243 attr->exclude_user = 1; in evsel__config()
1246 if (evsel->core.own_cpus || evsel->unit) in evsel__config()
1247 evsel->core.attr.read_format |= PERF_FORMAT_ID; in evsel__config()
1255 evsel->ignore_missing_thread = opts->ignore_missing_thread; in evsel__config()
1257 /* The --period option takes the precedence. */ in evsel__config()
1258 if (opts->period_set) { in evsel__config()
1259 if (opts->period) in evsel__config()
1270 * The software event will trigger -EOPNOTSUPP error out, in evsel__config()
1282 free(evsel->filter); in evsel__set_filter()
1283 evsel->filter = new_filter; in evsel__set_filter()
1287 return -1; in evsel__set_filter()
1294 if (evsel->filter == NULL) in evsel__append_filter()
1297 if (asprintf(&new_filter, fmt, evsel->filter, filter) > 0) { in evsel__append_filter()
1298 free(evsel->filter); in evsel__append_filter()
1299 evsel->filter = new_filter; in evsel__append_filter()
1303 return -1; in evsel__append_filter()
1317 int evsel__enable_cpu(struct evsel *evsel, int cpu) in evsel__enable_cpu() argument
1319 return perf_evsel__enable_cpu(&evsel->core, cpu); in evsel__enable_cpu()
1324 int err = perf_evsel__enable(&evsel->core); in evsel__enable()
1327 evsel->disabled = false; in evsel__enable()
1332 int evsel__disable_cpu(struct evsel *evsel, int cpu) in evsel__disable_cpu() argument
1334 return perf_evsel__disable_cpu(&evsel->core, cpu); in evsel__disable_cpu()
1339 int err = perf_evsel__disable(&evsel->core); in evsel__disable()
1347 evsel->disabled = true; in evsel__disable()
1356 list_for_each_entry_safe(term, h, &evsel->config_terms, list) { in evsel__free_config_terms()
1357 list_del_init(&term->list); in evsel__free_config_terms()
1358 if (term->free_str) in evsel__free_config_terms()
1359 zfree(&term->val.str); in evsel__free_config_terms()
1366 assert(list_empty(&evsel->core.node)); in evsel__exit()
1367 assert(evsel->evlist == NULL); in evsel__exit()
1369 perf_evsel__free_fd(&evsel->core); in evsel__exit()
1370 perf_evsel__free_id(&evsel->core); in evsel__exit()
1372 cgroup__put(evsel->cgrp); in evsel__exit()
1373 perf_cpu_map__put(evsel->core.cpus); in evsel__exit()
1374 perf_cpu_map__put(evsel->core.own_cpus); in evsel__exit()
1375 perf_thread_map__put(evsel->core.threads); in evsel__exit()
1376 zfree(&evsel->group_name); in evsel__exit()
1377 zfree(&evsel->name); in evsel__exit()
1378 zfree(&evsel->pmu_name); in evsel__exit()
1379 zfree(&evsel->per_pkg_mask); in evsel__exit()
1380 zfree(&evsel->metric_events); in evsel__exit()
1390 void evsel__compute_deltas(struct evsel *evsel, int cpu, int thread, in evsel__compute_deltas() argument
1395 if (!evsel->prev_raw_counts) in evsel__compute_deltas()
1398 if (cpu == -1) { in evsel__compute_deltas()
1399 tmp = evsel->prev_raw_counts->aggr; in evsel__compute_deltas()
1400 evsel->prev_raw_counts->aggr = *count; in evsel__compute_deltas()
1402 tmp = *perf_counts(evsel->prev_raw_counts, cpu, thread); in evsel__compute_deltas()
1403 *perf_counts(evsel->prev_raw_counts, cpu, thread) = *count; in evsel__compute_deltas()
1406 count->val = count->val - tmp.val; in evsel__compute_deltas()
1407 count->ena = count->ena - tmp.ena; in evsel__compute_deltas()
1408 count->run = count->run - tmp.run; in evsel__compute_deltas()
1417 if (count->run == 0) { in perf_counts_values__scale()
1418 scaled = -1; in perf_counts_values__scale()
1419 count->val = 0; in perf_counts_values__scale()
1420 } else if (count->run < count->ena) { in perf_counts_values__scale()
1422 count->val = (u64)((double) count->val * count->ena / count->run); in perf_counts_values__scale()
1430 static int evsel__read_one(struct evsel *evsel, int cpu, int thread) in evsel__read_one() argument
1432 struct perf_counts_values *count = perf_counts(evsel->counts, cpu, thread); in evsel__read_one()
1434 return perf_evsel__read(&evsel->core, cpu, thread, count); in evsel__read_one()
1438 perf_evsel__set_count(struct evsel *counter, int cpu, int thread, in perf_evsel__set_count() argument
1443 count = perf_counts(counter->counts, cpu, thread); in perf_evsel__set_count()
1445 count->val = val; in perf_evsel__set_count()
1446 count->ena = ena; in perf_evsel__set_count()
1447 count->run = run; in perf_evsel__set_count()
1449 perf_counts__set_loaded(counter->counts, cpu, thread, true); in perf_evsel__set_count()
1454 int cpu, int thread, u64 *data) in perf_evsel__process_group_data() argument
1456 u64 read_format = leader->core.attr.read_format; in perf_evsel__process_group_data()
1462 if (nr != (u64) leader->core.nr_members) in perf_evsel__process_group_data()
1463 return -EINVAL; in perf_evsel__process_group_data()
1473 perf_evsel__set_count(leader, cpu, thread, in perf_evsel__process_group_data()
1479 counter = perf_evlist__id2evsel(leader->evlist, v[i].id); in perf_evsel__process_group_data()
1481 return -EINVAL; in perf_evsel__process_group_data()
1483 perf_evsel__set_count(counter, cpu, thread, in perf_evsel__process_group_data()
1490 static int evsel__read_group(struct evsel *leader, int cpu, int thread) in evsel__read_group() argument
1492 struct perf_stat_evsel *ps = leader->stats; in evsel__read_group()
1493 u64 read_format = leader->core.attr.read_format; in evsel__read_group()
1494 int size = perf_evsel__read_size(&leader->core); in evsel__read_group()
1495 u64 *data = ps->group_data; in evsel__read_group()
1498 return -EINVAL; in evsel__read_group()
1501 return -EINVAL; in evsel__read_group()
1506 return -ENOMEM; in evsel__read_group()
1508 ps->group_data = data; in evsel__read_group()
1511 if (FD(leader, cpu, thread) < 0) in evsel__read_group()
1512 return -EINVAL; in evsel__read_group()
1514 if (readn(FD(leader, cpu, thread), data, size) <= 0) in evsel__read_group()
1515 return -errno; in evsel__read_group()
1517 return perf_evsel__process_group_data(leader, cpu, thread, data); in evsel__read_group()
1520 int evsel__read_counter(struct evsel *evsel, int cpu, int thread) in evsel__read_counter() argument
1522 u64 read_format = evsel->core.attr.read_format; in evsel__read_counter()
1525 return evsel__read_group(evsel, cpu, thread); in evsel__read_counter()
1527 return evsel__read_one(evsel, cpu, thread); in evsel__read_counter()
1530 int __evsel__read_on_cpu(struct evsel *evsel, int cpu, int thread, bool scale) in __evsel__read_on_cpu() argument
1535 if (FD(evsel, cpu, thread) < 0) in __evsel__read_on_cpu()
1536 return -EINVAL; in __evsel__read_on_cpu()
1538 if (evsel->counts == NULL && evsel__alloc_counts(evsel, cpu + 1, thread + 1) < 0) in __evsel__read_on_cpu()
1539 return -ENOMEM; in __evsel__read_on_cpu()
1541 if (readn(FD(evsel, cpu, thread), &count, nv * sizeof(u64)) <= 0) in __evsel__read_on_cpu()
1542 return -errno; in __evsel__read_on_cpu()
1544 evsel__compute_deltas(evsel, cpu, thread, &count); in __evsel__read_on_cpu()
1546 *perf_counts(evsel->counts, cpu, thread) = count; in __evsel__read_on_cpu()
1550 static int get_group_fd(struct evsel *evsel, int cpu, int thread) in get_group_fd() argument
1552 struct evsel *leader = evsel->leader; in get_group_fd()
1556 return -1; in get_group_fd()
1562 BUG_ON(!leader->core.fd); in get_group_fd()
1564 fd = FD(leader, cpu, thread); in get_group_fd()
1565 BUG_ON(fd == -1); in get_group_fd()
1574 for (int cpu = 0; cpu < nr_cpus; cpu++) in perf_evsel__remove_fd() local
1575 for (int thread = thread_idx; thread < nr_threads - 1; thread++) in perf_evsel__remove_fd()
1576 FD(pos, cpu, thread) = FD(pos, cpu, thread + 1); in perf_evsel__remove_fd()
1586 return -EINVAL; in update_fds()
1588 evlist__for_each_entry(evsel->evlist, pos) { in update_fds()
1604 int nr_cpus, int cpu, in ignore_missing_thread() argument
1610 if (!evsel->ignore_missing_thread) in ignore_missing_thread()
1614 if (evsel->core.system_wide) in ignore_missing_thread()
1617 /* The -ESRCH is perf event syscall errno for pid's not found. */ in ignore_missing_thread()
1618 if (err != -ESRCH) in ignore_missing_thread()
1622 if (threads->nr == 1) in ignore_missing_thread()
1627 * because thread_map__remove() will decrease threads->nr. in ignore_missing_thread()
1629 if (update_fds(evsel, nr_cpus, cpu, threads->nr, thread)) in ignore_missing_thread()
1643 return fprintf(fp, " %-32s %s\n", name, val); in __open_attr__fprintf()
1657 pid_t pid, int cpu, int group_fd, in perf_event_open() argument
1660 int precise_ip = evsel->core.attr.precise_ip; in perf_event_open()
1664 pr_debug2_peo("sys_perf_event_open: pid %d cpu %d group_fd %d flags %#lx", in perf_event_open()
1665 pid, cpu, group_fd, flags); in perf_event_open()
1667 fd = sys_perf_event_open(&evsel->core.attr, pid, cpu, group_fd, flags); in perf_event_open()
1672 if (!evsel->precise_max) in perf_event_open()
1679 if (!evsel->core.attr.precise_ip) { in perf_event_open()
1680 evsel->core.attr.precise_ip = precise_ip; in perf_event_open()
1684 pr_debug2_peo("\nsys_perf_event_open failed, error %d\n", -ENOTSUP); in perf_event_open()
1685 evsel->core.attr.precise_ip--; in perf_event_open()
1686 pr_debug2_peo("decreasing precise_ip by one (%d)\n", evsel->core.attr.precise_ip); in perf_event_open()
1687 display_attr(&evsel->core.attr); in perf_event_open()
1697 int cpu, thread, nthreads; in evsel__open_cpu() local
1699 int pid = -1, err, old_errno; in evsel__open_cpu()
1702 if ((perf_missing_features.write_backward && evsel->core.attr.write_backward) || in evsel__open_cpu()
1703 (perf_missing_features.aux_output && evsel->core.attr.aux_output)) in evsel__open_cpu()
1704 return -EINVAL; in evsel__open_cpu()
1712 return -ENOMEM; in evsel__open_cpu()
1722 empty_thread_map = thread_map__new_by_tid(-1); in evsel__open_cpu()
1724 return -ENOMEM; in evsel__open_cpu()
1730 if (evsel->core.system_wide) in evsel__open_cpu()
1733 nthreads = threads->nr; in evsel__open_cpu()
1735 if (evsel->core.fd == NULL && in evsel__open_cpu()
1736 perf_evsel__alloc_fd(&evsel->core, cpus->nr, nthreads) < 0) in evsel__open_cpu()
1737 return -ENOMEM; in evsel__open_cpu()
1739 if (evsel->cgrp) { in evsel__open_cpu()
1741 pid = evsel->cgrp->fd; in evsel__open_cpu()
1746 evsel->core.attr.clockid = CLOCK_MONOTONIC; /* should always work */ in evsel__open_cpu()
1748 evsel->core.attr.use_clockid = 0; in evsel__open_cpu()
1749 evsel->core.attr.clockid = 0; in evsel__open_cpu()
1754 evsel->core.attr.mmap2 = 0; in evsel__open_cpu()
1756 evsel->core.attr.exclude_guest = evsel->core.attr.exclude_host = 0; in evsel__open_cpu()
1758 evsel->core.attr.branch_sample_type &= ~(PERF_SAMPLE_BRANCH_NO_FLAGS | in evsel__open_cpu()
1760 if (perf_missing_features.group_read && evsel->core.attr.inherit) in evsel__open_cpu()
1761 evsel->core.attr.read_format &= ~(PERF_FORMAT_GROUP|PERF_FORMAT_ID); in evsel__open_cpu()
1763 evsel->core.attr.ksymbol = 0; in evsel__open_cpu()
1765 evsel->core.attr.bpf_event = 0; in evsel__open_cpu()
1767 evsel->core.attr.branch_sample_type &= ~PERF_SAMPLE_BRANCH_HW_INDEX; in evsel__open_cpu()
1770 evsel->core.attr.sample_id_all = 0; in evsel__open_cpu()
1772 display_attr(&evsel->core.attr); in evsel__open_cpu()
1774 for (cpu = start_cpu; cpu < end_cpu; cpu++) { in evsel__open_cpu()
1779 if (!evsel->cgrp && !evsel->core.system_wide) in evsel__open_cpu()
1782 group_fd = get_group_fd(evsel, cpu, thread); in evsel__open_cpu()
1786 fd = perf_event_open(evsel, pid, cpus->map[cpu], in evsel__open_cpu()
1789 FD(evsel, cpu, thread) = fd; in evsel__open_cpu()
1792 test_attr__open(&evsel->core.attr, pid, cpus->map[cpu], in evsel__open_cpu()
1797 err = -errno; in evsel__open_cpu()
1799 if (ignore_missing_thread(evsel, cpus->nr, cpu, threads, thread, err)) { in evsel__open_cpu()
1805 nthreads--; in evsel__open_cpu()
1806 thread--; in evsel__open_cpu()
1820 if (evsel->bpf_fd >= 0) { in evsel__open_cpu()
1822 int bpf_fd = evsel->bpf_fd; in evsel__open_cpu()
1830 err = -EINVAL; in evsel__open_cpu()
1843 err = -EINVAL; in evsel__open_cpu()
1853 * perf stat needs between 5 and 22 fds per CPU. When we run out in evsel__open_cpu()
1856 if (err == -EMFILE && set_rlimit < INCREASED_MAX) { in evsel__open_cpu()
1876 if (err != -EINVAL || cpu > 0 || thread > 0) in evsel__open_cpu()
1883 if (!perf_missing_features.cgroup && evsel->core.attr.cgroup) { in evsel__open_cpu()
1888 (evsel->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_HW_INDEX)) { in evsel__open_cpu()
1892 } else if (!perf_missing_features.aux_output && evsel->core.attr.aux_output) { in evsel__open_cpu()
1896 } else if (!perf_missing_features.bpf && evsel->core.attr.bpf_event) { in evsel__open_cpu()
1900 } else if (!perf_missing_features.ksymbol && evsel->core.attr.ksymbol) { in evsel__open_cpu()
1904 } else if (!perf_missing_features.write_backward && evsel->core.attr.write_backward) { in evsel__open_cpu()
1908 } else if (!perf_missing_features.clockid_wrong && evsel->core.attr.use_clockid) { in evsel__open_cpu()
1912 } else if (!perf_missing_features.clockid && evsel->core.attr.use_clockid) { in evsel__open_cpu()
1920 } else if (!perf_missing_features.mmap2 && evsel->core.attr.mmap2) { in evsel__open_cpu()
1925 (evsel->core.attr.exclude_guest || evsel->core.attr.exclude_host)) { in evsel__open_cpu()
1934 (evsel->core.attr.branch_sample_type & in evsel__open_cpu()
1941 evsel->core.attr.inherit && in evsel__open_cpu()
1942 (evsel->core.attr.read_format & PERF_FORMAT_GROUP) && in evsel__open_cpu()
1950 threads->err_thread = thread; in evsel__open_cpu()
1954 while (--thread >= 0) { in evsel__open_cpu()
1955 if (FD(evsel, cpu, thread) >= 0) in evsel__open_cpu()
1956 close(FD(evsel, cpu, thread)); in evsel__open_cpu()
1957 FD(evsel, cpu, thread) = -1; in evsel__open_cpu()
1960 } while (--cpu >= 0); in evsel__open_cpu()
1968 return evsel__open_cpu(evsel, cpus, threads, 0, cpus ? cpus->nr : 1); in evsel__open()
1973 perf_evsel__close(&evsel->core); in evsel__close()
1974 perf_evsel__free_id(&evsel->core); in evsel__close()
1977 int evsel__open_per_cpu(struct evsel *evsel, struct perf_cpu_map *cpus, int cpu) in evsel__open_per_cpu() argument
1979 if (cpu == -1) in evsel__open_per_cpu()
1981 cpus ? cpus->nr : 1); in evsel__open_per_cpu()
1983 return evsel__open_cpu(evsel, cpus, NULL, cpu, cpu + 1); in evsel__open_per_cpu()
1995 u64 type = evsel->core.attr.sample_type; in perf_evsel__parse_id_sample()
1996 const __u64 *array = event->sample.array; in perf_evsel__parse_id_sample()
1997 bool swapped = evsel->needs_swap; in perf_evsel__parse_id_sample()
2000 array += ((event->header.size - in perf_evsel__parse_id_sample()
2001 sizeof(event->header)) / sizeof(u64)) - 1; in perf_evsel__parse_id_sample()
2004 sample->id = *array; in perf_evsel__parse_id_sample()
2005 array--; in perf_evsel__parse_id_sample()
2016 sample->cpu = u.val32[0]; in perf_evsel__parse_id_sample()
2017 array--; in perf_evsel__parse_id_sample()
2021 sample->stream_id = *array; in perf_evsel__parse_id_sample()
2022 array--; in perf_evsel__parse_id_sample()
2026 sample->id = *array; in perf_evsel__parse_id_sample()
2027 array--; in perf_evsel__parse_id_sample()
2031 sample->time = *array; in perf_evsel__parse_id_sample()
2032 array--; in perf_evsel__parse_id_sample()
2044 sample->pid = u.val32[0]; in perf_evsel__parse_id_sample()
2045 sample->tid = u.val32[1]; in perf_evsel__parse_id_sample()
2046 array--; in perf_evsel__parse_id_sample()
2061 return -EFAULT; \
2075 if (sample_size + sizeof(event->header) > event->header.size) in perf_event__check_size()
2076 return -EFAULT; in perf_event__check_size()
2084 u64 type = evsel->core.attr.sample_type; in evsel__parse_sample()
2085 bool swapped = evsel->needs_swap; in evsel__parse_sample()
2087 u16 max_size = event->header.size; in evsel__parse_sample()
2092 * used for cross-endian analysis. See git commit 65014ab3 in evsel__parse_sample()
2098 data->cpu = data->pid = data->tid = -1; in evsel__parse_sample()
2099 data->stream_id = data->id = data->time = -1ULL; in evsel__parse_sample()
2100 data->period = evsel->core.attr.sample_period; in evsel__parse_sample()
2101 data->cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; in evsel__parse_sample()
2102 data->misc = event->header.misc; in evsel__parse_sample()
2103 data->id = -1ULL; in evsel__parse_sample()
2104 data->data_src = PERF_MEM_DATA_SRC_NONE; in evsel__parse_sample()
2106 if (event->header.type != PERF_RECORD_SAMPLE) { in evsel__parse_sample()
2107 if (!evsel->core.attr.sample_id_all) in evsel__parse_sample()
2112 array = event->sample.array; in evsel__parse_sample()
2114 if (perf_event__check_size(event, evsel->sample_size)) in evsel__parse_sample()
2115 return -EFAULT; in evsel__parse_sample()
2118 data->id = *array; in evsel__parse_sample()
2123 data->ip = *array; in evsel__parse_sample()
2136 data->pid = u.val32[0]; in evsel__parse_sample()
2137 data->tid = u.val32[1]; in evsel__parse_sample()
2142 data->time = *array; in evsel__parse_sample()
2147 data->addr = *array; in evsel__parse_sample()
2152 data->id = *array; in evsel__parse_sample()
2157 data->stream_id = *array; in evsel__parse_sample()
2170 data->cpu = u.val32[0]; in evsel__parse_sample()
2175 data->period = *array; in evsel__parse_sample()
2180 u64 read_format = evsel->core.attr.read_format; in evsel__parse_sample()
2184 data->read.group.nr = *array; in evsel__parse_sample()
2186 data->read.one.value = *array; in evsel__parse_sample()
2192 data->read.time_enabled = *array; in evsel__parse_sample()
2198 data->read.time_running = *array; in evsel__parse_sample()
2207 if (data->read.group.nr > max_group_nr) in evsel__parse_sample()
2208 return -EFAULT; in evsel__parse_sample()
2209 sz = data->read.group.nr * in evsel__parse_sample()
2212 data->read.group.values = in evsel__parse_sample()
2217 data->read.one.id = *array; in evsel__parse_sample()
2226 data->callchain = (struct ip_callchain *)array++; in evsel__parse_sample()
2227 if (data->callchain->nr > max_callchain_nr) in evsel__parse_sample()
2228 return -EFAULT; in evsel__parse_sample()
2229 sz = data->callchain->nr * sizeof(u64); in evsel__parse_sample()
2249 data->raw_size = u.val32[0]; in evsel__parse_sample()
2256 mem_bswap_64((void *) array, data->raw_size); in evsel__parse_sample()
2260 OVERFLOW_CHECK(array, data->raw_size, max_size); in evsel__parse_sample()
2261 data->raw_data = (void *)array; in evsel__parse_sample()
2262 array = (void *)array + data->raw_size; in evsel__parse_sample()
2270 data->branch_stack = (struct branch_stack *)array++; in evsel__parse_sample()
2272 if (data->branch_stack->nr > max_branch_nr) in evsel__parse_sample()
2273 return -EFAULT; in evsel__parse_sample()
2275 sz = data->branch_stack->nr * sizeof(struct branch_entry); in evsel__parse_sample()
2279 data->no_hw_idx = true; in evsel__parse_sample()
2286 data->user_regs.abi = *array; in evsel__parse_sample()
2289 if (data->user_regs.abi) { in evsel__parse_sample()
2290 u64 mask = evsel->core.attr.sample_regs_user; in evsel__parse_sample()
2294 data->user_regs.mask = mask; in evsel__parse_sample()
2295 data->user_regs.regs = (u64 *)array; in evsel__parse_sample()
2304 data->user_stack.offset = ((char *)(array - 1) in evsel__parse_sample()
2305 - (char *) event); in evsel__parse_sample()
2308 data->user_stack.size = 0; in evsel__parse_sample()
2311 data->user_stack.data = (char *)array; in evsel__parse_sample()
2314 data->user_stack.size = *array++; in evsel__parse_sample()
2315 if (WARN_ONCE(data->user_stack.size > sz, in evsel__parse_sample()
2317 return -EFAULT; in evsel__parse_sample()
2323 data->weight = *array; in evsel__parse_sample()
2329 data->data_src = *array; in evsel__parse_sample()
2335 data->transaction = *array; in evsel__parse_sample()
2339 data->intr_regs.abi = PERF_SAMPLE_REGS_ABI_NONE; in evsel__parse_sample()
2342 data->intr_regs.abi = *array; in evsel__parse_sample()
2345 if (data->intr_regs.abi != PERF_SAMPLE_REGS_ABI_NONE) { in evsel__parse_sample()
2346 u64 mask = evsel->core.attr.sample_regs_intr; in evsel__parse_sample()
2350 data->intr_regs.mask = mask; in evsel__parse_sample()
2351 data->intr_regs.regs = (u64 *)array; in evsel__parse_sample()
2356 data->phys_addr = 0; in evsel__parse_sample()
2358 data->phys_addr = *array; in evsel__parse_sample()
2362 data->cgroup = 0; in evsel__parse_sample()
2364 data->cgroup = *array; in evsel__parse_sample()
2376 data->aux_sample.size = sz; in evsel__parse_sample()
2377 data->aux_sample.data = (char *)array; in evsel__parse_sample()
2387 u64 type = evsel->core.attr.sample_type; in evsel__parse_sample_timestamp()
2391 return -1; in evsel__parse_sample_timestamp()
2393 if (event->header.type != PERF_RECORD_SAMPLE) { in evsel__parse_sample_timestamp()
2395 .time = -1ULL, in evsel__parse_sample_timestamp()
2398 if (!evsel->core.attr.sample_id_all) in evsel__parse_sample_timestamp()
2399 return -1; in evsel__parse_sample_timestamp()
2401 return -1; in evsel__parse_sample_timestamp()
2407 array = event->sample.array; in evsel__parse_sample_timestamp()
2409 if (perf_event__check_size(event, evsel->sample_size)) in evsel__parse_sample_timestamp()
2410 return -EFAULT; in evsel__parse_sample_timestamp()
2429 return tep_find_field(evsel->tp_format, name); in evsel__field()
2440 offset = field->offset; in evsel__rawptr()
2442 if (field->flags & TEP_FIELD_IS_DYNAMIC) { in evsel__rawptr()
2443 offset = *(int *)(sample->raw_data + field->offset); in evsel__rawptr()
2447 return sample->raw_data + offset; in evsel__rawptr()
2454 void *ptr = sample->raw_data + field->offset; in format_field__intval()
2456 switch (field->size) { in format_field__intval()
2475 switch (field->size) { in format_field__intval()
2496 return field ? format_field__intval(field, sample, evsel->needs_swap) : 0; in evsel__intval()
2504 evsel->core.attr.type == PERF_TYPE_HARDWARE && in evsel__fallback()
2505 evsel->core.attr.config == PERF_COUNT_HW_CPU_CYCLES) { in evsel__fallback()
2508 * cpu-clock-tick sw counter, which is always available even if in evsel__fallback()
2515 "The cycles event is not supported, trying to fall back to cpu-clock-ticks"); in evsel__fallback()
2517 evsel->core.attr.type = PERF_TYPE_SOFTWARE; in evsel__fallback()
2518 evsel->core.attr.config = PERF_COUNT_SW_CPU_CLOCK; in evsel__fallback()
2520 zfree(&evsel->name); in evsel__fallback()
2522 } else if (err == EACCES && !evsel->core.attr.exclude_kernel && in evsel__fallback()
2529 if (evsel->core.attr.exclude_user) in evsel__fallback()
2534 (strchr(name, ':') && !evsel->is_libpfm_event)) in evsel__fallback()
2540 if (evsel->name) in evsel__fallback()
2541 free(evsel->name); in evsel__fallback()
2542 evsel->name = new_name; in evsel__fallback()
2546 evsel->core.attr.exclude_kernel = 1; in evsel__fallback()
2547 evsel->core.attr.exclude_hv = 1; in evsel__fallback()
2560 int ret = -1; in find_process()
2572 if ((d->d_type != DT_DIR) || in find_process()
2573 !strcmp(".", d->d_name) || in find_process()
2574 !strcmp("..", d->d_name)) in find_process()
2578 procfs__mountpoint(), d->d_name); in find_process()
2600 printed += scnprintf(msg + printed, size - printed, in evsel__open_strerror()
2605 printed += scnprintf(msg + printed, size - printed, in evsel__open_strerror()
2616 return scnprintf(msg + printed, size - printed, in evsel__open_strerror()
2621 "https://www.kernel.org/doc/html/latest/admin-guide/perf-security.html\n" in evsel__open_strerror()
2623 " -1: Allow use of (almost) all events by all users\n" in evsel__open_strerror()
2626 ">= 1: Disallow CPU event access\n" in evsel__open_strerror()
2638 "Hint: Try increasing the limit with 'ulimit -n <limit>'"); in evsel__open_strerror()
2648 if (target->cpu_list) in evsel__open_strerror()
2650 "No such device - did you specify an out-of-range profile CPU?"); in evsel__open_strerror()
2653 if (evsel->core.attr.aux_output) in evsel__open_strerror()
2657 if (evsel->core.attr.sample_period != 0) in evsel__open_strerror()
2659 "%s: PMU Hardware doesn't support sampling/overflow-interrupts. Try 'perf stat'", in evsel__open_strerror()
2661 if (evsel->core.attr.precise_ip) in evsel__open_strerror()
2665 if (evsel->core.attr.type == PERF_TYPE_HARDWARE) in evsel__open_strerror()
2677 if (evsel->core.attr.write_backward && perf_missing_features.write_backward) in evsel__open_strerror()
2692 "/bin/dmesg | grep -i perf may provide additional information.\n", in evsel__open_strerror()
2698 if (evsel && evsel->evlist) in evsel__env()
2699 return evsel->evlist->env; in evsel__env()
2705 int cpu, thread; in store_evsel_ids() local
2707 for (cpu = 0; cpu < xyarray__max_x(evsel->core.fd); cpu++) { in store_evsel_ids()
2708 for (thread = 0; thread < xyarray__max_y(evsel->core.fd); in store_evsel_ids()
2710 int fd = FD(evsel, cpu, thread); in store_evsel_ids()
2712 if (perf_evlist__id_add_fd(&evlist->core, &evsel->core, in store_evsel_ids()
2713 cpu, thread, fd) < 0) in store_evsel_ids()
2714 return -1; in store_evsel_ids()
2723 struct perf_cpu_map *cpus = evsel->core.cpus; in evsel__store_ids()
2724 struct perf_thread_map *threads = evsel->core.threads; in evsel__store_ids()
2726 if (perf_evsel__alloc_id(&evsel->core, cpus->nr, threads->nr)) in evsel__store_ids()
2727 return -ENOMEM; in evsel__store_ids()