1 // SPDX-License-Identifier: GPL-2.0 2 #include "cpumap.h" 3 #include "debug.h" 4 #include "env.h" 5 #include "util/header.h" 6 #include <linux/ctype.h> 7 #include <linux/zalloc.h> 8 #include "bpf-event.h" 9 #include "cgroup.h" 10 #include <errno.h> 11 #include <sys/utsname.h> 12 #include <bpf/libbpf.h> 13 #include <stdlib.h> 14 #include <string.h> 15 16 struct perf_env perf_env; 17 18 void perf_env__insert_bpf_prog_info(struct perf_env *env, 19 struct bpf_prog_info_node *info_node) 20 { 21 __u32 prog_id = info_node->info_linear->info.id; 22 struct bpf_prog_info_node *node; 23 struct rb_node *parent = NULL; 24 struct rb_node **p; 25 26 down_write(&env->bpf_progs.lock); 27 p = &env->bpf_progs.infos.rb_node; 28 29 while (*p != NULL) { 30 parent = *p; 31 node = rb_entry(parent, struct bpf_prog_info_node, rb_node); 32 if (prog_id < node->info_linear->info.id) { 33 p = &(*p)->rb_left; 34 } else if (prog_id > node->info_linear->info.id) { 35 p = &(*p)->rb_right; 36 } else { 37 pr_debug("duplicated bpf prog info %u\n", prog_id); 38 goto out; 39 } 40 } 41 42 rb_link_node(&info_node->rb_node, parent, p); 43 rb_insert_color(&info_node->rb_node, &env->bpf_progs.infos); 44 env->bpf_progs.infos_cnt++; 45 out: 46 up_write(&env->bpf_progs.lock); 47 } 48 49 struct bpf_prog_info_node *perf_env__find_bpf_prog_info(struct perf_env *env, 50 __u32 prog_id) 51 { 52 struct bpf_prog_info_node *node = NULL; 53 struct rb_node *n; 54 55 down_read(&env->bpf_progs.lock); 56 n = env->bpf_progs.infos.rb_node; 57 58 while (n) { 59 node = rb_entry(n, struct bpf_prog_info_node, rb_node); 60 if (prog_id < node->info_linear->info.id) 61 n = n->rb_left; 62 else if (prog_id > node->info_linear->info.id) 63 n = n->rb_right; 64 else 65 goto out; 66 } 67 node = NULL; 68 69 out: 70 up_read(&env->bpf_progs.lock); 71 return node; 72 } 73 74 void perf_env__insert_btf(struct perf_env *env, struct btf_node *btf_node) 75 { 76 struct rb_node *parent = NULL; 77 __u32 btf_id = btf_node->id; 78 struct btf_node *node; 79 struct rb_node **p; 80 81 down_write(&env->bpf_progs.lock); 82 p = &env->bpf_progs.btfs.rb_node; 83 84 while (*p != NULL) { 85 parent = *p; 86 node = rb_entry(parent, struct btf_node, rb_node); 87 if (btf_id < node->id) { 88 p = &(*p)->rb_left; 89 } else if (btf_id > node->id) { 90 p = &(*p)->rb_right; 91 } else { 92 pr_debug("duplicated btf %u\n", btf_id); 93 goto out; 94 } 95 } 96 97 rb_link_node(&btf_node->rb_node, parent, p); 98 rb_insert_color(&btf_node->rb_node, &env->bpf_progs.btfs); 99 env->bpf_progs.btfs_cnt++; 100 out: 101 up_write(&env->bpf_progs.lock); 102 } 103 104 struct btf_node *perf_env__find_btf(struct perf_env *env, __u32 btf_id) 105 { 106 struct btf_node *node = NULL; 107 struct rb_node *n; 108 109 down_read(&env->bpf_progs.lock); 110 n = env->bpf_progs.btfs.rb_node; 111 112 while (n) { 113 node = rb_entry(n, struct btf_node, rb_node); 114 if (btf_id < node->id) 115 n = n->rb_left; 116 else if (btf_id > node->id) 117 n = n->rb_right; 118 else 119 goto out; 120 } 121 node = NULL; 122 123 out: 124 up_read(&env->bpf_progs.lock); 125 return node; 126 } 127 128 /* purge data in bpf_progs.infos tree */ 129 static void perf_env__purge_bpf(struct perf_env *env) 130 { 131 struct rb_root *root; 132 struct rb_node *next; 133 134 down_write(&env->bpf_progs.lock); 135 136 root = &env->bpf_progs.infos; 137 next = rb_first(root); 138 139 while (next) { 140 struct bpf_prog_info_node *node; 141 142 node = rb_entry(next, struct bpf_prog_info_node, rb_node); 143 next = rb_next(&node->rb_node); 144 rb_erase(&node->rb_node, root); 145 free(node); 146 } 147 148 env->bpf_progs.infos_cnt = 0; 149 150 root = &env->bpf_progs.btfs; 151 next = rb_first(root); 152 153 while (next) { 154 struct btf_node *node; 155 156 node = rb_entry(next, struct btf_node, rb_node); 157 next = rb_next(&node->rb_node); 158 rb_erase(&node->rb_node, root); 159 free(node); 160 } 161 162 env->bpf_progs.btfs_cnt = 0; 163 164 up_write(&env->bpf_progs.lock); 165 } 166 167 void perf_env__exit(struct perf_env *env) 168 { 169 int i; 170 171 perf_env__purge_bpf(env); 172 perf_env__purge_cgroups(env); 173 zfree(&env->hostname); 174 zfree(&env->os_release); 175 zfree(&env->version); 176 zfree(&env->arch); 177 zfree(&env->cpu_desc); 178 zfree(&env->cpuid); 179 zfree(&env->cmdline); 180 zfree(&env->cmdline_argv); 181 zfree(&env->sibling_cores); 182 zfree(&env->sibling_threads); 183 zfree(&env->pmu_mappings); 184 zfree(&env->cpu); 185 zfree(&env->numa_map); 186 187 for (i = 0; i < env->nr_numa_nodes; i++) 188 perf_cpu_map__put(env->numa_nodes[i].map); 189 zfree(&env->numa_nodes); 190 191 for (i = 0; i < env->caches_cnt; i++) 192 cpu_cache_level__free(&env->caches[i]); 193 zfree(&env->caches); 194 195 for (i = 0; i < env->nr_memory_nodes; i++) 196 zfree(&env->memory_nodes[i].set); 197 zfree(&env->memory_nodes); 198 } 199 200 void perf_env__init(struct perf_env *env) 201 { 202 env->bpf_progs.infos = RB_ROOT; 203 env->bpf_progs.btfs = RB_ROOT; 204 init_rwsem(&env->bpf_progs.lock); 205 } 206 207 int perf_env__set_cmdline(struct perf_env *env, int argc, const char *argv[]) 208 { 209 int i; 210 211 /* do not include NULL termination */ 212 env->cmdline_argv = calloc(argc, sizeof(char *)); 213 if (env->cmdline_argv == NULL) 214 goto out_enomem; 215 216 /* 217 * Must copy argv contents because it gets moved around during option 218 * parsing: 219 */ 220 for (i = 0; i < argc ; i++) { 221 env->cmdline_argv[i] = argv[i]; 222 if (env->cmdline_argv[i] == NULL) 223 goto out_free; 224 } 225 226 env->nr_cmdline = argc; 227 228 return 0; 229 out_free: 230 zfree(&env->cmdline_argv); 231 out_enomem: 232 return -ENOMEM; 233 } 234 235 int perf_env__read_cpu_topology_map(struct perf_env *env) 236 { 237 int cpu, nr_cpus; 238 239 if (env->cpu != NULL) 240 return 0; 241 242 if (env->nr_cpus_avail == 0) 243 env->nr_cpus_avail = cpu__max_present_cpu(); 244 245 nr_cpus = env->nr_cpus_avail; 246 if (nr_cpus == -1) 247 return -EINVAL; 248 249 env->cpu = calloc(nr_cpus, sizeof(env->cpu[0])); 250 if (env->cpu == NULL) 251 return -ENOMEM; 252 253 for (cpu = 0; cpu < nr_cpus; ++cpu) { 254 env->cpu[cpu].core_id = cpu_map__get_core_id(cpu); 255 env->cpu[cpu].socket_id = cpu_map__get_socket_id(cpu); 256 env->cpu[cpu].die_id = cpu_map__get_die_id(cpu); 257 } 258 259 env->nr_cpus_avail = nr_cpus; 260 return 0; 261 } 262 263 int perf_env__read_cpuid(struct perf_env *env) 264 { 265 char cpuid[128]; 266 int err = get_cpuid(cpuid, sizeof(cpuid)); 267 268 if (err) 269 return err; 270 271 free(env->cpuid); 272 env->cpuid = strdup(cpuid); 273 if (env->cpuid == NULL) 274 return ENOMEM; 275 return 0; 276 } 277 278 static int perf_env__read_arch(struct perf_env *env) 279 { 280 struct utsname uts; 281 282 if (env->arch) 283 return 0; 284 285 if (!uname(&uts)) 286 env->arch = strdup(uts.machine); 287 288 return env->arch ? 0 : -ENOMEM; 289 } 290 291 static int perf_env__read_nr_cpus_avail(struct perf_env *env) 292 { 293 if (env->nr_cpus_avail == 0) 294 env->nr_cpus_avail = cpu__max_present_cpu(); 295 296 return env->nr_cpus_avail ? 0 : -ENOENT; 297 } 298 299 const char *perf_env__raw_arch(struct perf_env *env) 300 { 301 return env && !perf_env__read_arch(env) ? env->arch : "unknown"; 302 } 303 304 int perf_env__nr_cpus_avail(struct perf_env *env) 305 { 306 return env && !perf_env__read_nr_cpus_avail(env) ? env->nr_cpus_avail : 0; 307 } 308 309 void cpu_cache_level__free(struct cpu_cache_level *cache) 310 { 311 zfree(&cache->type); 312 zfree(&cache->map); 313 zfree(&cache->size); 314 } 315 316 /* 317 * Return architecture name in a normalized form. 318 * The conversion logic comes from the Makefile. 319 */ 320 static const char *normalize_arch(char *arch) 321 { 322 if (!strcmp(arch, "x86_64")) 323 return "x86"; 324 if (arch[0] == 'i' && arch[2] == '8' && arch[3] == '6') 325 return "x86"; 326 if (!strcmp(arch, "sun4u") || !strncmp(arch, "sparc", 5)) 327 return "sparc"; 328 if (!strcmp(arch, "aarch64") || !strcmp(arch, "arm64")) 329 return "arm64"; 330 if (!strncmp(arch, "arm", 3) || !strcmp(arch, "sa110")) 331 return "arm"; 332 if (!strncmp(arch, "s390", 4)) 333 return "s390"; 334 if (!strncmp(arch, "parisc", 6)) 335 return "parisc"; 336 if (!strncmp(arch, "powerpc", 7) || !strncmp(arch, "ppc", 3)) 337 return "powerpc"; 338 if (!strncmp(arch, "mips", 4)) 339 return "mips"; 340 if (!strncmp(arch, "sh", 2) && isdigit(arch[2])) 341 return "sh"; 342 343 return arch; 344 } 345 346 const char *perf_env__arch(struct perf_env *env) 347 { 348 char *arch_name; 349 350 if (!env || !env->arch) { /* Assume local operation */ 351 static struct utsname uts = { .machine[0] = '\0', }; 352 if (uts.machine[0] == '\0' && uname(&uts) < 0) 353 return NULL; 354 arch_name = uts.machine; 355 } else 356 arch_name = env->arch; 357 358 return normalize_arch(arch_name); 359 } 360 361 362 int perf_env__numa_node(struct perf_env *env, int cpu) 363 { 364 if (!env->nr_numa_map) { 365 struct numa_node *nn; 366 int i, nr = 0; 367 368 for (i = 0; i < env->nr_numa_nodes; i++) { 369 nn = &env->numa_nodes[i]; 370 nr = max(nr, perf_cpu_map__max(nn->map)); 371 } 372 373 nr++; 374 375 /* 376 * We initialize the numa_map array to prepare 377 * it for missing cpus, which return node -1 378 */ 379 env->numa_map = malloc(nr * sizeof(int)); 380 if (!env->numa_map) 381 return -1; 382 383 for (i = 0; i < nr; i++) 384 env->numa_map[i] = -1; 385 386 env->nr_numa_map = nr; 387 388 for (i = 0; i < env->nr_numa_nodes; i++) { 389 int tmp, j; 390 391 nn = &env->numa_nodes[i]; 392 perf_cpu_map__for_each_cpu(j, tmp, nn->map) 393 env->numa_map[j] = i; 394 } 395 } 396 397 return cpu >= 0 && cpu < env->nr_numa_map ? env->numa_map[cpu] : -1; 398 } 399