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
perf_env__insert_bpf_prog_info(struct perf_env * env,struct bpf_prog_info_node * info_node)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
perf_env__find_bpf_prog_info(struct perf_env * env,__u32 prog_id)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
perf_env__insert_btf(struct perf_env * env,struct btf_node * btf_node)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
perf_env__find_btf(struct perf_env * env,__u32 btf_id)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 */
perf_env__purge_bpf(struct perf_env * env)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->info_linear);
146 free(node);
147 }
148
149 env->bpf_progs.infos_cnt = 0;
150
151 root = &env->bpf_progs.btfs;
152 next = rb_first(root);
153
154 while (next) {
155 struct btf_node *node;
156
157 node = rb_entry(next, struct btf_node, rb_node);
158 next = rb_next(&node->rb_node);
159 rb_erase(&node->rb_node, root);
160 free(node);
161 }
162
163 env->bpf_progs.btfs_cnt = 0;
164
165 up_write(&env->bpf_progs.lock);
166 }
167
perf_env__exit(struct perf_env * env)168 void perf_env__exit(struct perf_env *env)
169 {
170 int i;
171
172 perf_env__purge_bpf(env);
173 perf_env__purge_cgroups(env);
174 zfree(&env->hostname);
175 zfree(&env->os_release);
176 zfree(&env->version);
177 zfree(&env->arch);
178 zfree(&env->cpu_desc);
179 zfree(&env->cpuid);
180 zfree(&env->cmdline);
181 zfree(&env->cmdline_argv);
182 zfree(&env->sibling_dies);
183 zfree(&env->sibling_cores);
184 zfree(&env->sibling_threads);
185 zfree(&env->pmu_mappings);
186 zfree(&env->cpu);
187 zfree(&env->cpu_pmu_caps);
188 zfree(&env->numa_map);
189
190 for (i = 0; i < env->nr_numa_nodes; i++)
191 perf_cpu_map__put(env->numa_nodes[i].map);
192 zfree(&env->numa_nodes);
193
194 for (i = 0; i < env->caches_cnt; i++)
195 cpu_cache_level__free(&env->caches[i]);
196 zfree(&env->caches);
197
198 for (i = 0; i < env->nr_memory_nodes; i++)
199 zfree(&env->memory_nodes[i].set);
200 zfree(&env->memory_nodes);
201 }
202
perf_env__init(struct perf_env * env)203 void perf_env__init(struct perf_env *env)
204 {
205 env->bpf_progs.infos = RB_ROOT;
206 env->bpf_progs.btfs = RB_ROOT;
207 init_rwsem(&env->bpf_progs.lock);
208 }
209
perf_env__set_cmdline(struct perf_env * env,int argc,const char * argv[])210 int perf_env__set_cmdline(struct perf_env *env, int argc, const char *argv[])
211 {
212 int i;
213
214 /* do not include NULL termination */
215 env->cmdline_argv = calloc(argc, sizeof(char *));
216 if (env->cmdline_argv == NULL)
217 goto out_enomem;
218
219 /*
220 * Must copy argv contents because it gets moved around during option
221 * parsing:
222 */
223 for (i = 0; i < argc ; i++) {
224 env->cmdline_argv[i] = argv[i];
225 if (env->cmdline_argv[i] == NULL)
226 goto out_free;
227 }
228
229 env->nr_cmdline = argc;
230
231 return 0;
232 out_free:
233 zfree(&env->cmdline_argv);
234 out_enomem:
235 return -ENOMEM;
236 }
237
perf_env__read_cpu_topology_map(struct perf_env * env)238 int perf_env__read_cpu_topology_map(struct perf_env *env)
239 {
240 int cpu, nr_cpus;
241
242 if (env->cpu != NULL)
243 return 0;
244
245 if (env->nr_cpus_avail == 0)
246 env->nr_cpus_avail = cpu__max_present_cpu();
247
248 nr_cpus = env->nr_cpus_avail;
249 if (nr_cpus == -1)
250 return -EINVAL;
251
252 env->cpu = calloc(nr_cpus, sizeof(env->cpu[0]));
253 if (env->cpu == NULL)
254 return -ENOMEM;
255
256 for (cpu = 0; cpu < nr_cpus; ++cpu) {
257 env->cpu[cpu].core_id = cpu_map__get_core_id(cpu);
258 env->cpu[cpu].socket_id = cpu_map__get_socket_id(cpu);
259 env->cpu[cpu].die_id = cpu_map__get_die_id(cpu);
260 }
261
262 env->nr_cpus_avail = nr_cpus;
263 return 0;
264 }
265
perf_env__read_cpuid(struct perf_env * env)266 int perf_env__read_cpuid(struct perf_env *env)
267 {
268 char cpuid[128];
269 int err = get_cpuid(cpuid, sizeof(cpuid));
270
271 if (err)
272 return err;
273
274 free(env->cpuid);
275 env->cpuid = strdup(cpuid);
276 if (env->cpuid == NULL)
277 return ENOMEM;
278 return 0;
279 }
280
perf_env__read_arch(struct perf_env * env)281 static int perf_env__read_arch(struct perf_env *env)
282 {
283 struct utsname uts;
284
285 if (env->arch)
286 return 0;
287
288 if (!uname(&uts))
289 env->arch = strdup(uts.machine);
290
291 return env->arch ? 0 : -ENOMEM;
292 }
293
perf_env__read_nr_cpus_avail(struct perf_env * env)294 static int perf_env__read_nr_cpus_avail(struct perf_env *env)
295 {
296 if (env->nr_cpus_avail == 0)
297 env->nr_cpus_avail = cpu__max_present_cpu();
298
299 return env->nr_cpus_avail ? 0 : -ENOENT;
300 }
301
perf_env__raw_arch(struct perf_env * env)302 const char *perf_env__raw_arch(struct perf_env *env)
303 {
304 return env && !perf_env__read_arch(env) ? env->arch : "unknown";
305 }
306
perf_env__nr_cpus_avail(struct perf_env * env)307 int perf_env__nr_cpus_avail(struct perf_env *env)
308 {
309 return env && !perf_env__read_nr_cpus_avail(env) ? env->nr_cpus_avail : 0;
310 }
311
cpu_cache_level__free(struct cpu_cache_level * cache)312 void cpu_cache_level__free(struct cpu_cache_level *cache)
313 {
314 zfree(&cache->type);
315 zfree(&cache->map);
316 zfree(&cache->size);
317 }
318
319 /*
320 * Return architecture name in a normalized form.
321 * The conversion logic comes from the Makefile.
322 */
normalize_arch(char * arch)323 static const char *normalize_arch(char *arch)
324 {
325 if (!strcmp(arch, "x86_64"))
326 return "x86";
327 if (arch[0] == 'i' && arch[2] == '8' && arch[3] == '6')
328 return "x86";
329 if (!strcmp(arch, "sun4u") || !strncmp(arch, "sparc", 5))
330 return "sparc";
331 if (!strncmp(arch, "aarch64", 7) || !strncmp(arch, "arm64", 5))
332 return "arm64";
333 if (!strncmp(arch, "arm", 3) || !strcmp(arch, "sa110"))
334 return "arm";
335 if (!strncmp(arch, "s390", 4))
336 return "s390";
337 if (!strncmp(arch, "parisc", 6))
338 return "parisc";
339 if (!strncmp(arch, "powerpc", 7) || !strncmp(arch, "ppc", 3))
340 return "powerpc";
341 if (!strncmp(arch, "mips", 4))
342 return "mips";
343 if (!strncmp(arch, "sh", 2) && isdigit(arch[2]))
344 return "sh";
345
346 return arch;
347 }
348
perf_env__arch(struct perf_env * env)349 const char *perf_env__arch(struct perf_env *env)
350 {
351 char *arch_name;
352
353 if (!env || !env->arch) { /* Assume local operation */
354 static struct utsname uts = { .machine[0] = '\0', };
355 if (uts.machine[0] == '\0' && uname(&uts) < 0)
356 return NULL;
357 arch_name = uts.machine;
358 } else
359 arch_name = env->arch;
360
361 return normalize_arch(arch_name);
362 }
363
364
perf_env__numa_node(struct perf_env * env,int cpu)365 int perf_env__numa_node(struct perf_env *env, int cpu)
366 {
367 if (!env->nr_numa_map) {
368 struct numa_node *nn;
369 int i, nr = 0;
370
371 for (i = 0; i < env->nr_numa_nodes; i++) {
372 nn = &env->numa_nodes[i];
373 nr = max(nr, perf_cpu_map__max(nn->map));
374 }
375
376 nr++;
377
378 /*
379 * We initialize the numa_map array to prepare
380 * it for missing cpus, which return node -1
381 */
382 env->numa_map = malloc(nr * sizeof(int));
383 if (!env->numa_map)
384 return -1;
385
386 for (i = 0; i < nr; i++)
387 env->numa_map[i] = -1;
388
389 env->nr_numa_map = nr;
390
391 for (i = 0; i < env->nr_numa_nodes; i++) {
392 int tmp, j;
393
394 nn = &env->numa_nodes[i];
395 perf_cpu_map__for_each_cpu(j, tmp, nn->map)
396 env->numa_map[j] = i;
397 }
398 }
399
400 return cpu >= 0 && cpu < env->nr_numa_map ? env->numa_map[cpu] : -1;
401 }
402