tools/perf/util/env.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include "cpumap.h"
   3 #include "env.h"
   4 #include "sane_ctype.h"
   5 #include "util.h"
   6 #include "bpf-event.h"
   7 #include <errno.h>
   8 #include <sys/utsname.h>
   9 #include <bpf/libbpf.h>
  10
  11 struct perf_env perf_env;
  12
  13 void perf_env__insert_bpf_prog_info(struct perf_env *env,
  14                                     struct bpf_prog_info_node *info_node)
  15 {
  16         __u32 prog_id = info_node->info_linear->info.id;
  17         struct bpf_prog_info_node *node;
  18         struct rb_node *parent = NULL;
  19         struct rb_node **p;
  20
  21         down_write(&env->bpf_progs.lock);
  22         p = &env->bpf_progs.infos.rb_node;
  23
  24         while (*p != NULL) {
  25                 parent = *p;
  26                 node = rb_entry(parent, struct bpf_prog_info_node, rb_node);
  27                 if (prog_id < node->info_linear->info.id) {
  28                         p = &(*p)->rb_left;
  29                 } else if (prog_id > node->info_linear->info.id) {
  30                         p = &(*p)->rb_right;
  31                 } else {
  32                         pr_debug("duplicated bpf prog info %u\n", prog_id);
  33                         goto out;
  34                 }
  35         }
  36
  37         rb_link_node(&info_node->rb_node, parent, p);
  38         rb_insert_color(&info_node->rb_node, &env->bpf_progs.infos);
  39         env->bpf_progs.infos_cnt++;
  40 out:
  41         up_write(&env->bpf_progs.lock);
  42 }
  43
  44 struct bpf_prog_info_node *perf_env__find_bpf_prog_info(struct perf_env *env,
  45                                                         __u32 prog_id)
  46 {
  47         struct bpf_prog_info_node *node = NULL;
  48         struct rb_node *n;
  49
  50         down_read(&env->bpf_progs.lock);
  51         n = env->bpf_progs.infos.rb_node;
  52
  53         while (n) {
  54                 node = rb_entry(n, struct bpf_prog_info_node, rb_node);
  55                 if (prog_id < node->info_linear->info.id)
  56                         n = n->rb_left;
  57                 else if (prog_id > node->info_linear->info.id)
  58                         n = n->rb_right;
  59                 else
  60                         break;
  61         }
  62
  63         up_read(&env->bpf_progs.lock);
  64         return node;
  65 }
  66
  67 /* purge data in bpf_progs.infos tree */
  68 static void perf_env__purge_bpf(struct perf_env *env)
  69 {
  70         struct rb_root *root;
  71         struct rb_node *next;
  72
  73         down_write(&env->bpf_progs.lock);
  74
  75         root = &env->bpf_progs.infos;
  76         next = rb_first(root);
  77
  78         while (next) {
  79                 struct bpf_prog_info_node *node;
  80
  81                 node = rb_entry(next, struct bpf_prog_info_node, rb_node);
  82                 next = rb_next(&node->rb_node);
  83                 rb_erase(&node->rb_node, root);
  84                 free(node);
  85         }
  86
  87         env->bpf_progs.infos_cnt = 0;
  88
  89         up_write(&env->bpf_progs.lock);
  90 }
  91
  92 void perf_env__exit(struct perf_env *env)
  93 {
  94         int i;
  95
  96         perf_env__purge_bpf(env);
  97         zfree(&env->hostname);
  98         zfree(&env->os_release);
  99         zfree(&env->version);
 100         zfree(&env->arch);
 101         zfree(&env->cpu_desc);
 102         zfree(&env->cpuid);
 103         zfree(&env->cmdline);
 104         zfree(&env->cmdline_argv);
 105         zfree(&env->sibling_cores);
 106         zfree(&env->sibling_threads);
 107         zfree(&env->pmu_mappings);
 108         zfree(&env->cpu);
 109
 110         for (i = 0; i < env->nr_numa_nodes; i++)
 111                 cpu_map__put(env->numa_nodes[i].map);
 112         zfree(&env->numa_nodes);
 113
 114         for (i = 0; i < env->caches_cnt; i++)
 115                 cpu_cache_level__free(&env->caches[i]);
 116         zfree(&env->caches);
 117
 118         for (i = 0; i < env->nr_memory_nodes; i++)
 119                 free(env->memory_nodes[i].set);
 120         zfree(&env->memory_nodes);
 121 }
 122
 123 void perf_env__init(struct perf_env *env)
 124 {
 125         env->bpf_progs.infos = RB_ROOT;
 126         init_rwsem(&env->bpf_progs.lock);
 127 }
 128
 129 int perf_env__set_cmdline(struct perf_env *env, int argc, const char *argv[])
 130 {
 131         int i;
 132
 133         /* do not include NULL termination */
 134         env->cmdline_argv = calloc(argc, sizeof(char *));
 135         if (env->cmdline_argv == NULL)
 136                 goto out_enomem;
 137
 138         /*
 139          * Must copy argv contents because it gets moved around during option
 140          * parsing:
 141          */
 142         for (i = 0; i < argc ; i++) {
 143                 env->cmdline_argv[i] = argv[i];
 144                 if (env->cmdline_argv[i] == NULL)
 145                         goto out_free;
 146         }
 147
 148         env->nr_cmdline = argc;
 149
 150         return 0;
 151 out_free:
 152         zfree(&env->cmdline_argv);
 153 out_enomem:
 154         return -ENOMEM;
 155 }
 156
 157 int perf_env__read_cpu_topology_map(struct perf_env *env)
 158 {
 159         int cpu, nr_cpus;
 160
 161         if (env->cpu != NULL)
 162                 return 0;
 163
 164         if (env->nr_cpus_avail == 0)
 165                 env->nr_cpus_avail = cpu__max_present_cpu();
 166
 167         nr_cpus = env->nr_cpus_avail;
 168         if (nr_cpus == -1)
 169                 return -EINVAL;
 170
 171         env->cpu = calloc(nr_cpus, sizeof(env->cpu[0]));
 172         if (env->cpu == NULL)
 173                 return -ENOMEM;
 174
 175         for (cpu = 0; cpu < nr_cpus; ++cpu) {
 176                 env->cpu[cpu].core_id   = cpu_map__get_core_id(cpu);
 177                 env->cpu[cpu].socket_id = cpu_map__get_socket_id(cpu);
 178         }
 179
 180         env->nr_cpus_avail = nr_cpus;
 181         return 0;
 182 }
 183
 184 static int perf_env__read_arch(struct perf_env *env)
 185 {
 186         struct utsname uts;
 187
 188         if (env->arch)
 189                 return 0;
 190
 191         if (!uname(&uts))
 192                 env->arch = strdup(uts.machine);
 193
 194         return env->arch ? 0 : -ENOMEM;
 195 }
 196
 197 static int perf_env__read_nr_cpus_avail(struct perf_env *env)
 198 {
 199         if (env->nr_cpus_avail == 0)
 200                 env->nr_cpus_avail = cpu__max_present_cpu();
 201
 202         return env->nr_cpus_avail ? 0 : -ENOENT;
 203 }
 204
 205 const char *perf_env__raw_arch(struct perf_env *env)
 206 {
 207         return env && !perf_env__read_arch(env) ? env->arch : "unknown";
 208 }
 209
 210 int perf_env__nr_cpus_avail(struct perf_env *env)
 211 {
 212         return env && !perf_env__read_nr_cpus_avail(env) ? env->nr_cpus_avail : 0;
 213 }
 214
 215 void cpu_cache_level__free(struct cpu_cache_level *cache)
 216 {
 217         free(cache->type);
 218         free(cache->map);
 219         free(cache->size);
 220 }
 221
 222 /*
 223  * Return architecture name in a normalized form.
 224  * The conversion logic comes from the Makefile.
 225  */
 226 static const char *normalize_arch(char *arch)
 227 {
 228         if (!strcmp(arch, "x86_64"))
 229                 return "x86";
 230         if (arch[0] == 'i' && arch[2] == '8' && arch[3] == '6')
 231                 return "x86";
 232         if (!strcmp(arch, "sun4u") || !strncmp(arch, "sparc", 5))
 233                 return "sparc";
 234         if (!strcmp(arch, "aarch64") || !strcmp(arch, "arm64"))
 235                 return "arm64";
 236         if (!strncmp(arch, "arm", 3) || !strcmp(arch, "sa110"))
 237                 return "arm";
 238         if (!strncmp(arch, "s390", 4))
 239                 return "s390";
 240         if (!strncmp(arch, "parisc", 6))
 241                 return "parisc";
 242         if (!strncmp(arch, "powerpc", 7) || !strncmp(arch, "ppc", 3))
 243                 return "powerpc";
 244         if (!strncmp(arch, "mips", 4))
 245                 return "mips";
 246         if (!strncmp(arch, "sh", 2) && isdigit(arch[2]))
 247                 return "sh";
 248
 249         return arch;
 250 }
 251
 252 const char *perf_env__arch(struct perf_env *env)
 253 {
 254         struct utsname uts;
 255         char *arch_name;
 256
 257         if (!env || !env->arch) { /* Assume local operation */
 258                 if (uname(&uts) < 0)
 259                         return NULL;
 260                 arch_name = uts.machine;
 261         } else
 262                 arch_name = env->arch;
 263
 264         return normalize_arch(arch_name);
 265 }