1 // SPDX-License-Identifier: GPL-2.0
5 #include "util/header.h"
6 #include "linux/compiler.h"
7 #include <linux/ctype.h>
8 #include <linux/zalloc.h>
11 #include <sys/utsname.h>
16 #include "trace/beauty/beauty.h"
18 struct perf_env perf_env;
20 #ifdef HAVE_LIBBPF_SUPPORT
21 #include "bpf-event.h"
22 #include "bpf-utils.h"
23 #include <bpf/libbpf.h>
25 void perf_env__insert_bpf_prog_info(struct perf_env *env,
26 struct bpf_prog_info_node *info_node)
28 down_write(&env->bpf_progs.lock);
29 __perf_env__insert_bpf_prog_info(env, info_node);
30 up_write(&env->bpf_progs.lock);
33 void __perf_env__insert_bpf_prog_info(struct perf_env *env, struct bpf_prog_info_node *info_node)
35 __u32 prog_id = info_node->info_linear->info.id;
36 struct bpf_prog_info_node *node;
37 struct rb_node *parent = NULL;
40 p = &env->bpf_progs.infos.rb_node;
44 node = rb_entry(parent, struct bpf_prog_info_node, rb_node);
45 if (prog_id < node->info_linear->info.id) {
47 } else if (prog_id > node->info_linear->info.id) {
50 pr_debug("duplicated bpf prog info %u\n", prog_id);
55 rb_link_node(&info_node->rb_node, parent, p);
56 rb_insert_color(&info_node->rb_node, &env->bpf_progs.infos);
57 env->bpf_progs.infos_cnt++;
60 struct bpf_prog_info_node *perf_env__find_bpf_prog_info(struct perf_env *env,
63 struct bpf_prog_info_node *node = NULL;
66 down_read(&env->bpf_progs.lock);
67 n = env->bpf_progs.infos.rb_node;
70 node = rb_entry(n, struct bpf_prog_info_node, rb_node);
71 if (prog_id < node->info_linear->info.id)
73 else if (prog_id > node->info_linear->info.id)
81 up_read(&env->bpf_progs.lock);
85 bool perf_env__insert_btf(struct perf_env *env, struct btf_node *btf_node)
89 down_write(&env->bpf_progs.lock);
90 ret = __perf_env__insert_btf(env, btf_node);
91 up_write(&env->bpf_progs.lock);
95 bool __perf_env__insert_btf(struct perf_env *env, struct btf_node *btf_node)
97 struct rb_node *parent = NULL;
98 __u32 btf_id = btf_node->id;
99 struct btf_node *node;
102 p = &env->bpf_progs.btfs.rb_node;
106 node = rb_entry(parent, struct btf_node, rb_node);
107 if (btf_id < node->id) {
109 } else if (btf_id > node->id) {
112 pr_debug("duplicated btf %u\n", btf_id);
117 rb_link_node(&btf_node->rb_node, parent, p);
118 rb_insert_color(&btf_node->rb_node, &env->bpf_progs.btfs);
119 env->bpf_progs.btfs_cnt++;
123 struct btf_node *perf_env__find_btf(struct perf_env *env, __u32 btf_id)
125 struct btf_node *res;
127 down_read(&env->bpf_progs.lock);
128 res = __perf_env__find_btf(env, btf_id);
129 up_read(&env->bpf_progs.lock);
133 struct btf_node *__perf_env__find_btf(struct perf_env *env, __u32 btf_id)
135 struct btf_node *node = NULL;
138 n = env->bpf_progs.btfs.rb_node;
141 node = rb_entry(n, struct btf_node, rb_node);
142 if (btf_id < node->id)
144 else if (btf_id > node->id)
152 /* purge data in bpf_progs.infos tree */
153 static void perf_env__purge_bpf(struct perf_env *env)
155 struct rb_root *root;
156 struct rb_node *next;
158 down_write(&env->bpf_progs.lock);
160 root = &env->bpf_progs.infos;
161 next = rb_first(root);
164 struct bpf_prog_info_node *node;
166 node = rb_entry(next, struct bpf_prog_info_node, rb_node);
167 next = rb_next(&node->rb_node);
168 rb_erase(&node->rb_node, root);
169 zfree(&node->info_linear);
173 env->bpf_progs.infos_cnt = 0;
175 root = &env->bpf_progs.btfs;
176 next = rb_first(root);
179 struct btf_node *node;
181 node = rb_entry(next, struct btf_node, rb_node);
182 next = rb_next(&node->rb_node);
183 rb_erase(&node->rb_node, root);
187 env->bpf_progs.btfs_cnt = 0;
189 up_write(&env->bpf_progs.lock);
191 #else // HAVE_LIBBPF_SUPPORT
192 static void perf_env__purge_bpf(struct perf_env *env __maybe_unused)
195 #endif // HAVE_LIBBPF_SUPPORT
197 void perf_env__exit(struct perf_env *env)
201 perf_env__purge_bpf(env);
202 perf_env__purge_cgroups(env);
203 zfree(&env->hostname);
204 zfree(&env->os_release);
205 zfree(&env->version);
207 zfree(&env->cpu_desc);
209 zfree(&env->cmdline);
210 zfree(&env->cmdline_argv);
211 zfree(&env->sibling_dies);
212 zfree(&env->sibling_cores);
213 zfree(&env->sibling_threads);
214 zfree(&env->pmu_mappings);
216 for (i = 0; i < env->nr_cpu_pmu_caps; i++)
217 zfree(&env->cpu_pmu_caps[i]);
218 zfree(&env->cpu_pmu_caps);
219 zfree(&env->numa_map);
221 for (i = 0; i < env->nr_numa_nodes; i++)
222 perf_cpu_map__put(env->numa_nodes[i].map);
223 zfree(&env->numa_nodes);
225 for (i = 0; i < env->caches_cnt; i++)
226 cpu_cache_level__free(&env->caches[i]);
229 for (i = 0; i < env->nr_memory_nodes; i++)
230 zfree(&env->memory_nodes[i].set);
231 zfree(&env->memory_nodes);
233 for (i = 0; i < env->nr_hybrid_nodes; i++) {
234 zfree(&env->hybrid_nodes[i].pmu_name);
235 zfree(&env->hybrid_nodes[i].cpus);
237 zfree(&env->hybrid_nodes);
239 for (i = 0; i < env->nr_pmus_with_caps; i++) {
240 for (j = 0; j < env->pmu_caps[i].nr_caps; j++)
241 zfree(&env->pmu_caps[i].caps[j]);
242 zfree(&env->pmu_caps[i].caps);
243 zfree(&env->pmu_caps[i].pmu_name);
245 zfree(&env->pmu_caps);
248 void perf_env__init(struct perf_env *env)
250 #ifdef HAVE_LIBBPF_SUPPORT
251 env->bpf_progs.infos = RB_ROOT;
252 env->bpf_progs.btfs = RB_ROOT;
253 init_rwsem(&env->bpf_progs.lock);
255 env->kernel_is_64_bit = -1;
258 static void perf_env__init_kernel_mode(struct perf_env *env)
260 const char *arch = perf_env__raw_arch(env);
262 if (!strncmp(arch, "x86_64", 6) || !strncmp(arch, "aarch64", 7) ||
263 !strncmp(arch, "arm64", 5) || !strncmp(arch, "mips64", 6) ||
264 !strncmp(arch, "parisc64", 8) || !strncmp(arch, "riscv64", 7) ||
265 !strncmp(arch, "s390x", 5) || !strncmp(arch, "sparc64", 7))
266 env->kernel_is_64_bit = 1;
268 env->kernel_is_64_bit = 0;
271 int perf_env__kernel_is_64_bit(struct perf_env *env)
273 if (env->kernel_is_64_bit == -1)
274 perf_env__init_kernel_mode(env);
276 return env->kernel_is_64_bit;
279 int perf_env__set_cmdline(struct perf_env *env, int argc, const char *argv[])
283 /* do not include NULL termination */
284 env->cmdline_argv = calloc(argc, sizeof(char *));
285 if (env->cmdline_argv == NULL)
289 * Must copy argv contents because it gets moved around during option
292 for (i = 0; i < argc ; i++) {
293 env->cmdline_argv[i] = argv[i];
294 if (env->cmdline_argv[i] == NULL)
298 env->nr_cmdline = argc;
302 zfree(&env->cmdline_argv);
307 int perf_env__read_cpu_topology_map(struct perf_env *env)
311 if (env->cpu != NULL)
314 if (env->nr_cpus_avail == 0)
315 env->nr_cpus_avail = cpu__max_present_cpu().cpu;
317 nr_cpus = env->nr_cpus_avail;
321 env->cpu = calloc(nr_cpus, sizeof(env->cpu[0]));
322 if (env->cpu == NULL)
325 for (idx = 0; idx < nr_cpus; ++idx) {
326 struct perf_cpu cpu = { .cpu = idx };
328 env->cpu[idx].core_id = cpu__get_core_id(cpu);
329 env->cpu[idx].socket_id = cpu__get_socket_id(cpu);
330 env->cpu[idx].die_id = cpu__get_die_id(cpu);
333 env->nr_cpus_avail = nr_cpus;
337 int perf_env__read_pmu_mappings(struct perf_env *env)
339 struct perf_pmu *pmu = NULL;
343 while ((pmu = perf_pmus__scan(pmu)))
347 pr_debug("pmu mappings not available\n");
350 env->nr_pmu_mappings = pmu_num;
352 if (strbuf_init(&sb, 128 * pmu_num) < 0)
355 while ((pmu = perf_pmus__scan(pmu))) {
356 if (strbuf_addf(&sb, "%u:%s", pmu->type, pmu->name) < 0)
358 /* include a NULL character at the end */
359 if (strbuf_add(&sb, "", 1) < 0)
363 env->pmu_mappings = strbuf_detach(&sb, NULL);
372 int perf_env__read_cpuid(struct perf_env *env)
375 int err = get_cpuid(cpuid, sizeof(cpuid));
381 env->cpuid = strdup(cpuid);
382 if (env->cpuid == NULL)
387 static int perf_env__read_arch(struct perf_env *env)
395 env->arch = strdup(uts.machine);
397 return env->arch ? 0 : -ENOMEM;
400 static int perf_env__read_nr_cpus_avail(struct perf_env *env)
402 if (env->nr_cpus_avail == 0)
403 env->nr_cpus_avail = cpu__max_present_cpu().cpu;
405 return env->nr_cpus_avail ? 0 : -ENOENT;
408 const char *perf_env__raw_arch(struct perf_env *env)
410 return env && !perf_env__read_arch(env) ? env->arch : "unknown";
413 int perf_env__nr_cpus_avail(struct perf_env *env)
415 return env && !perf_env__read_nr_cpus_avail(env) ? env->nr_cpus_avail : 0;
418 void cpu_cache_level__free(struct cpu_cache_level *cache)
426 * Return architecture name in a normalized form.
427 * The conversion logic comes from the Makefile.
429 static const char *normalize_arch(char *arch)
431 if (!strcmp(arch, "x86_64"))
433 if (arch[0] == 'i' && arch[2] == '8' && arch[3] == '6')
435 if (!strcmp(arch, "sun4u") || !strncmp(arch, "sparc", 5))
437 if (!strncmp(arch, "aarch64", 7) || !strncmp(arch, "arm64", 5))
439 if (!strncmp(arch, "arm", 3) || !strcmp(arch, "sa110"))
441 if (!strncmp(arch, "s390", 4))
443 if (!strncmp(arch, "parisc", 6))
445 if (!strncmp(arch, "powerpc", 7) || !strncmp(arch, "ppc", 3))
447 if (!strncmp(arch, "mips", 4))
449 if (!strncmp(arch, "sh", 2) && isdigit(arch[2]))
451 if (!strncmp(arch, "loongarch", 9))
457 const char *perf_env__arch(struct perf_env *env)
461 if (!env || !env->arch) { /* Assume local operation */
462 static struct utsname uts = { .machine[0] = '\0', };
463 if (uts.machine[0] == '\0' && uname(&uts) < 0)
465 arch_name = uts.machine;
467 arch_name = env->arch;
469 return normalize_arch(arch_name);
472 const char *perf_env__arch_strerrno(struct perf_env *env __maybe_unused, int err __maybe_unused)
474 #if defined(HAVE_SYSCALL_TABLE_SUPPORT) && defined(HAVE_LIBTRACEEVENT)
475 if (env->arch_strerrno == NULL)
476 env->arch_strerrno = arch_syscalls__strerrno_function(perf_env__arch(env));
478 return env->arch_strerrno ? env->arch_strerrno(err) : "no arch specific strerrno function";
480 return "!(HAVE_SYSCALL_TABLE_SUPPORT && HAVE_LIBTRACEEVENT)";
484 const char *perf_env__cpuid(struct perf_env *env)
488 if (!env->cpuid) { /* Assume local operation */
489 status = perf_env__read_cpuid(env);
497 int perf_env__nr_pmu_mappings(struct perf_env *env)
501 if (!env->nr_pmu_mappings) { /* Assume local operation */
502 status = perf_env__read_pmu_mappings(env);
507 return env->nr_pmu_mappings;
510 const char *perf_env__pmu_mappings(struct perf_env *env)
514 if (!env->pmu_mappings) { /* Assume local operation */
515 status = perf_env__read_pmu_mappings(env);
520 return env->pmu_mappings;
523 int perf_env__numa_node(struct perf_env *env, struct perf_cpu cpu)
525 if (!env->nr_numa_map) {
526 struct numa_node *nn;
529 for (i = 0; i < env->nr_numa_nodes; i++) {
530 nn = &env->numa_nodes[i];
531 nr = max(nr, perf_cpu_map__max(nn->map).cpu);
537 * We initialize the numa_map array to prepare
538 * it for missing cpus, which return node -1
540 env->numa_map = malloc(nr * sizeof(int));
544 for (i = 0; i < nr; i++)
545 env->numa_map[i] = -1;
547 env->nr_numa_map = nr;
549 for (i = 0; i < env->nr_numa_nodes; i++) {
553 nn = &env->numa_nodes[i];
554 perf_cpu_map__for_each_cpu(tmp, j, nn->map)
555 env->numa_map[tmp.cpu] = i;
559 return cpu.cpu >= 0 && cpu.cpu < env->nr_numa_map ? env->numa_map[cpu.cpu] : -1;
562 bool perf_env__has_pmu_mapping(struct perf_env *env, const char *pmu_name)
564 char *pmu_mapping = env->pmu_mappings, *colon;
566 for (int i = 0; i < env->nr_pmu_mappings; ++i) {
567 if (strtoul(pmu_mapping, &colon, 0) == ULONG_MAX || *colon != ':')
570 pmu_mapping = colon + 1;
571 if (strcmp(pmu_mapping, pmu_name) == 0)
574 pmu_mapping += strlen(pmu_mapping) + 1;
580 char *perf_env__find_pmu_cap(struct perf_env *env, const char *pmu_name,
588 if (!pmu_name || !cap)
591 cap_size = strlen(cap);
592 cap_eq = zalloc(cap_size + 2);
596 memcpy(cap_eq, cap, cap_size);
597 cap_eq[cap_size] = '=';
599 if (!strcmp(pmu_name, "cpu")) {
600 for (i = 0; i < env->nr_cpu_pmu_caps; i++) {
601 if (!strncmp(env->cpu_pmu_caps[i], cap_eq, cap_size + 1)) {
603 return &env->cpu_pmu_caps[i][cap_size + 1];
609 for (i = 0; i < env->nr_pmus_with_caps; i++) {
610 if (strcmp(env->pmu_caps[i].pmu_name, pmu_name))
613 ptr = env->pmu_caps[i].caps;
615 for (j = 0; j < env->pmu_caps[i].nr_caps; j++) {
616 if (!strncmp(ptr[j], cap_eq, cap_size + 1)) {
618 return &ptr[j][cap_size + 1];