]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
aa36ddd7 | 2 | #include "cpumap.h" |
f0ce888c | 3 | #include "env.h" |
4e8fbc1c | 4 | #include "sane_ctype.h" |
f0ce888c | 5 | #include "util.h" |
e4378f0c | 6 | #include "bpf-event.h" |
a43783ae | 7 | #include <errno.h> |
4e8fbc1c | 8 | #include <sys/utsname.h> |
e4378f0c | 9 | #include <bpf/libbpf.h> |
f0ce888c | 10 | |
b6998692 ACM |
11 | struct perf_env perf_env; |
12 | ||
e4378f0c SL |
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 | |
aa526602 | 60 | goto out; |
e4378f0c | 61 | } |
aa526602 | 62 | node = NULL; |
e4378f0c | 63 | |
aa526602 | 64 | out: |
e4378f0c SL |
65 | up_read(&env->bpf_progs.lock); |
66 | return node; | |
67 | } | |
68 | ||
3792cb2f SL |
69 | void perf_env__insert_btf(struct perf_env *env, struct btf_node *btf_node) |
70 | { | |
71 | struct rb_node *parent = NULL; | |
72 | __u32 btf_id = btf_node->id; | |
73 | struct btf_node *node; | |
74 | struct rb_node **p; | |
75 | ||
76 | down_write(&env->bpf_progs.lock); | |
77 | p = &env->bpf_progs.btfs.rb_node; | |
78 | ||
79 | while (*p != NULL) { | |
80 | parent = *p; | |
81 | node = rb_entry(parent, struct btf_node, rb_node); | |
82 | if (btf_id < node->id) { | |
83 | p = &(*p)->rb_left; | |
84 | } else if (btf_id > node->id) { | |
85 | p = &(*p)->rb_right; | |
86 | } else { | |
87 | pr_debug("duplicated btf %u\n", btf_id); | |
88 | goto out; | |
89 | } | |
90 | } | |
91 | ||
92 | rb_link_node(&btf_node->rb_node, parent, p); | |
93 | rb_insert_color(&btf_node->rb_node, &env->bpf_progs.btfs); | |
94 | env->bpf_progs.btfs_cnt++; | |
95 | out: | |
96 | up_write(&env->bpf_progs.lock); | |
97 | } | |
98 | ||
99 | struct btf_node *perf_env__find_btf(struct perf_env *env, __u32 btf_id) | |
100 | { | |
101 | struct btf_node *node = NULL; | |
102 | struct rb_node *n; | |
103 | ||
104 | down_read(&env->bpf_progs.lock); | |
105 | n = env->bpf_progs.btfs.rb_node; | |
106 | ||
107 | while (n) { | |
108 | node = rb_entry(n, struct btf_node, rb_node); | |
109 | if (btf_id < node->id) | |
110 | n = n->rb_left; | |
111 | else if (btf_id > node->id) | |
112 | n = n->rb_right; | |
113 | else | |
2db7b1e0 | 114 | goto out; |
3792cb2f | 115 | } |
2db7b1e0 | 116 | node = NULL; |
3792cb2f SL |
117 | |
118 | up_read(&env->bpf_progs.lock); | |
2db7b1e0 | 119 | out: |
3792cb2f SL |
120 | return node; |
121 | } | |
122 | ||
e4378f0c SL |
123 | /* purge data in bpf_progs.infos tree */ |
124 | static void perf_env__purge_bpf(struct perf_env *env) | |
125 | { | |
126 | struct rb_root *root; | |
127 | struct rb_node *next; | |
128 | ||
129 | down_write(&env->bpf_progs.lock); | |
130 | ||
131 | root = &env->bpf_progs.infos; | |
132 | next = rb_first(root); | |
133 | ||
134 | while (next) { | |
135 | struct bpf_prog_info_node *node; | |
136 | ||
137 | node = rb_entry(next, struct bpf_prog_info_node, rb_node); | |
138 | next = rb_next(&node->rb_node); | |
139 | rb_erase(&node->rb_node, root); | |
140 | free(node); | |
141 | } | |
142 | ||
143 | env->bpf_progs.infos_cnt = 0; | |
144 | ||
3792cb2f SL |
145 | root = &env->bpf_progs.btfs; |
146 | next = rb_first(root); | |
147 | ||
148 | while (next) { | |
149 | struct btf_node *node; | |
150 | ||
151 | node = rb_entry(next, struct btf_node, rb_node); | |
152 | next = rb_next(&node->rb_node); | |
153 | rb_erase(&node->rb_node, root); | |
154 | free(node); | |
155 | } | |
156 | ||
157 | env->bpf_progs.btfs_cnt = 0; | |
158 | ||
e4378f0c SL |
159 | up_write(&env->bpf_progs.lock); |
160 | } | |
161 | ||
f0ce888c ACM |
162 | void perf_env__exit(struct perf_env *env) |
163 | { | |
720e98b5 JO |
164 | int i; |
165 | ||
e4378f0c | 166 | perf_env__purge_bpf(env); |
f0ce888c ACM |
167 | zfree(&env->hostname); |
168 | zfree(&env->os_release); | |
169 | zfree(&env->version); | |
170 | zfree(&env->arch); | |
171 | zfree(&env->cpu_desc); | |
172 | zfree(&env->cpuid); | |
173 | zfree(&env->cmdline); | |
174 | zfree(&env->cmdline_argv); | |
175 | zfree(&env->sibling_cores); | |
176 | zfree(&env->sibling_threads); | |
f0ce888c ACM |
177 | zfree(&env->pmu_mappings); |
178 | zfree(&env->cpu); | |
720e98b5 | 179 | |
c60da22a JO |
180 | for (i = 0; i < env->nr_numa_nodes; i++) |
181 | cpu_map__put(env->numa_nodes[i].map); | |
182 | zfree(&env->numa_nodes); | |
183 | ||
720e98b5 JO |
184 | for (i = 0; i < env->caches_cnt; i++) |
185 | cpu_cache_level__free(&env->caches[i]); | |
186 | zfree(&env->caches); | |
e725920c JO |
187 | |
188 | for (i = 0; i < env->nr_memory_nodes; i++) | |
189 | free(env->memory_nodes[i].set); | |
190 | zfree(&env->memory_nodes); | |
f0ce888c | 191 | } |
b6998692 | 192 | |
e4378f0c SL |
193 | void perf_env__init(struct perf_env *env) |
194 | { | |
195 | env->bpf_progs.infos = RB_ROOT; | |
3792cb2f | 196 | env->bpf_progs.btfs = RB_ROOT; |
e4378f0c SL |
197 | init_rwsem(&env->bpf_progs.lock); |
198 | } | |
199 | ||
b6998692 ACM |
200 | int perf_env__set_cmdline(struct perf_env *env, int argc, const char *argv[]) |
201 | { | |
202 | int i; | |
203 | ||
b6998692 ACM |
204 | /* do not include NULL termination */ |
205 | env->cmdline_argv = calloc(argc, sizeof(char *)); | |
206 | if (env->cmdline_argv == NULL) | |
207 | goto out_enomem; | |
208 | ||
209 | /* | |
210 | * Must copy argv contents because it gets moved around during option | |
211 | * parsing: | |
212 | */ | |
213 | for (i = 0; i < argc ; i++) { | |
214 | env->cmdline_argv[i] = argv[i]; | |
215 | if (env->cmdline_argv[i] == NULL) | |
216 | goto out_free; | |
217 | } | |
218 | ||
219 | env->nr_cmdline = argc; | |
220 | ||
221 | return 0; | |
222 | out_free: | |
223 | zfree(&env->cmdline_argv); | |
224 | out_enomem: | |
225 | return -ENOMEM; | |
226 | } | |
aa36ddd7 ACM |
227 | |
228 | int perf_env__read_cpu_topology_map(struct perf_env *env) | |
229 | { | |
230 | int cpu, nr_cpus; | |
231 | ||
232 | if (env->cpu != NULL) | |
233 | return 0; | |
234 | ||
235 | if (env->nr_cpus_avail == 0) | |
da8a58b5 | 236 | env->nr_cpus_avail = cpu__max_present_cpu(); |
aa36ddd7 ACM |
237 | |
238 | nr_cpus = env->nr_cpus_avail; | |
239 | if (nr_cpus == -1) | |
240 | return -EINVAL; | |
241 | ||
242 | env->cpu = calloc(nr_cpus, sizeof(env->cpu[0])); | |
243 | if (env->cpu == NULL) | |
244 | return -ENOMEM; | |
245 | ||
246 | for (cpu = 0; cpu < nr_cpus; ++cpu) { | |
247 | env->cpu[cpu].core_id = cpu_map__get_core_id(cpu); | |
248 | env->cpu[cpu].socket_id = cpu_map__get_socket_id(cpu); | |
249 | } | |
250 | ||
251 | env->nr_cpus_avail = nr_cpus; | |
252 | return 0; | |
253 | } | |
720e98b5 | 254 | |
dbbd34a6 AH |
255 | static int perf_env__read_arch(struct perf_env *env) |
256 | { | |
257 | struct utsname uts; | |
258 | ||
259 | if (env->arch) | |
260 | return 0; | |
261 | ||
262 | if (!uname(&uts)) | |
263 | env->arch = strdup(uts.machine); | |
264 | ||
265 | return env->arch ? 0 : -ENOMEM; | |
266 | } | |
267 | ||
9cecca32 AH |
268 | static int perf_env__read_nr_cpus_avail(struct perf_env *env) |
269 | { | |
270 | if (env->nr_cpus_avail == 0) | |
271 | env->nr_cpus_avail = cpu__max_present_cpu(); | |
272 | ||
273 | return env->nr_cpus_avail ? 0 : -ENOENT; | |
274 | } | |
275 | ||
dbbd34a6 AH |
276 | const char *perf_env__raw_arch(struct perf_env *env) |
277 | { | |
278 | return env && !perf_env__read_arch(env) ? env->arch : "unknown"; | |
279 | } | |
280 | ||
9cecca32 AH |
281 | int perf_env__nr_cpus_avail(struct perf_env *env) |
282 | { | |
283 | return env && !perf_env__read_nr_cpus_avail(env) ? env->nr_cpus_avail : 0; | |
284 | } | |
285 | ||
720e98b5 JO |
286 | void cpu_cache_level__free(struct cpu_cache_level *cache) |
287 | { | |
288 | free(cache->type); | |
289 | free(cache->map); | |
290 | free(cache->size); | |
291 | } | |
4e8fbc1c ACM |
292 | |
293 | /* | |
294 | * Return architecture name in a normalized form. | |
295 | * The conversion logic comes from the Makefile. | |
296 | */ | |
297 | static const char *normalize_arch(char *arch) | |
298 | { | |
299 | if (!strcmp(arch, "x86_64")) | |
300 | return "x86"; | |
301 | if (arch[0] == 'i' && arch[2] == '8' && arch[3] == '6') | |
302 | return "x86"; | |
303 | if (!strcmp(arch, "sun4u") || !strncmp(arch, "sparc", 5)) | |
304 | return "sparc"; | |
305 | if (!strcmp(arch, "aarch64") || !strcmp(arch, "arm64")) | |
306 | return "arm64"; | |
307 | if (!strncmp(arch, "arm", 3) || !strcmp(arch, "sa110")) | |
308 | return "arm"; | |
309 | if (!strncmp(arch, "s390", 4)) | |
310 | return "s390"; | |
311 | if (!strncmp(arch, "parisc", 6)) | |
312 | return "parisc"; | |
313 | if (!strncmp(arch, "powerpc", 7) || !strncmp(arch, "ppc", 3)) | |
314 | return "powerpc"; | |
315 | if (!strncmp(arch, "mips", 4)) | |
316 | return "mips"; | |
317 | if (!strncmp(arch, "sh", 2) && isdigit(arch[2])) | |
318 | return "sh"; | |
319 | ||
320 | return arch; | |
321 | } | |
322 | ||
323 | const char *perf_env__arch(struct perf_env *env) | |
324 | { | |
325 | struct utsname uts; | |
326 | char *arch_name; | |
327 | ||
804234f2 | 328 | if (!env || !env->arch) { /* Assume local operation */ |
4e8fbc1c ACM |
329 | if (uname(&uts) < 0) |
330 | return NULL; | |
331 | arch_name = uts.machine; | |
332 | } else | |
333 | arch_name = env->arch; | |
334 | ||
335 | return normalize_arch(arch_name); | |
336 | } |