]> Git Repo - J-linux.git/blob - tools/perf/util/cputopo.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / tools / perf / util / cputopo.c
1 // SPDX-License-Identifier: GPL-2.0
2 #include <sys/param.h>
3 #include <sys/utsname.h>
4 #include <inttypes.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #include <api/fs/fs.h>
8 #include <linux/zalloc.h>
9 #include <perf/cpumap.h>
10
11 #include "cputopo.h"
12 #include "cpumap.h"
13 #include "debug.h"
14 #include "env.h"
15 #include "pmu.h"
16 #include "pmus.h"
17
18 #define PACKAGE_CPUS_FMT \
19         "%s/devices/system/cpu/cpu%d/topology/package_cpus_list"
20 #define PACKAGE_CPUS_FMT_OLD \
21         "%s/devices/system/cpu/cpu%d/topology/core_siblings_list"
22 #define DIE_CPUS_FMT \
23         "%s/devices/system/cpu/cpu%d/topology/die_cpus_list"
24 #define CORE_CPUS_FMT \
25         "%s/devices/system/cpu/cpu%d/topology/core_cpus_list"
26 #define CORE_CPUS_FMT_OLD \
27         "%s/devices/system/cpu/cpu%d/topology/thread_siblings_list"
28 #define NODE_ONLINE_FMT \
29         "%s/devices/system/node/online"
30 #define NODE_MEMINFO_FMT \
31         "%s/devices/system/node/node%d/meminfo"
32 #define NODE_CPULIST_FMT \
33         "%s/devices/system/node/node%d/cpulist"
34
35 static int build_cpu_topology(struct cpu_topology *tp, int cpu)
36 {
37         FILE *fp;
38         char filename[MAXPATHLEN];
39         char *buf = NULL, *p;
40         size_t len = 0;
41         ssize_t sret;
42         u32 i = 0;
43         int ret = -1;
44
45         scnprintf(filename, MAXPATHLEN, PACKAGE_CPUS_FMT,
46                   sysfs__mountpoint(), cpu);
47         if (access(filename, F_OK) == -1) {
48                 scnprintf(filename, MAXPATHLEN, PACKAGE_CPUS_FMT_OLD,
49                         sysfs__mountpoint(), cpu);
50         }
51         fp = fopen(filename, "r");
52         if (!fp)
53                 goto try_dies;
54
55         sret = getline(&buf, &len, fp);
56         fclose(fp);
57         if (sret <= 0)
58                 goto try_dies;
59
60         p = strchr(buf, '\n');
61         if (p)
62                 *p = '\0';
63
64         for (i = 0; i < tp->package_cpus_lists; i++) {
65                 if (!strcmp(buf, tp->package_cpus_list[i]))
66                         break;
67         }
68         if (i == tp->package_cpus_lists) {
69                 tp->package_cpus_list[i] = buf;
70                 tp->package_cpus_lists++;
71                 buf = NULL;
72                 len = 0;
73         }
74         ret = 0;
75
76 try_dies:
77         if (!tp->die_cpus_list)
78                 goto try_threads;
79
80         scnprintf(filename, MAXPATHLEN, DIE_CPUS_FMT,
81                   sysfs__mountpoint(), cpu);
82         fp = fopen(filename, "r");
83         if (!fp)
84                 goto try_threads;
85
86         sret = getline(&buf, &len, fp);
87         fclose(fp);
88         if (sret <= 0)
89                 goto try_threads;
90
91         p = strchr(buf, '\n');
92         if (p)
93                 *p = '\0';
94
95         for (i = 0; i < tp->die_cpus_lists; i++) {
96                 if (!strcmp(buf, tp->die_cpus_list[i]))
97                         break;
98         }
99         if (i == tp->die_cpus_lists) {
100                 tp->die_cpus_list[i] = buf;
101                 tp->die_cpus_lists++;
102                 buf = NULL;
103                 len = 0;
104         }
105         ret = 0;
106
107 try_threads:
108         scnprintf(filename, MAXPATHLEN, CORE_CPUS_FMT,
109                   sysfs__mountpoint(), cpu);
110         if (access(filename, F_OK) == -1) {
111                 scnprintf(filename, MAXPATHLEN, CORE_CPUS_FMT_OLD,
112                           sysfs__mountpoint(), cpu);
113         }
114         fp = fopen(filename, "r");
115         if (!fp)
116                 goto done;
117
118         if (getline(&buf, &len, fp) <= 0)
119                 goto done;
120
121         p = strchr(buf, '\n');
122         if (p)
123                 *p = '\0';
124
125         for (i = 0; i < tp->core_cpus_lists; i++) {
126                 if (!strcmp(buf, tp->core_cpus_list[i]))
127                         break;
128         }
129         if (i == tp->core_cpus_lists) {
130                 tp->core_cpus_list[i] = buf;
131                 tp->core_cpus_lists++;
132                 buf = NULL;
133         }
134         ret = 0;
135 done:
136         if (fp)
137                 fclose(fp);
138         free(buf);
139         return ret;
140 }
141
142 void cpu_topology__delete(struct cpu_topology *tp)
143 {
144         u32 i;
145
146         if (!tp)
147                 return;
148
149         for (i = 0 ; i < tp->package_cpus_lists; i++)
150                 zfree(&tp->package_cpus_list[i]);
151
152         for (i = 0 ; i < tp->die_cpus_lists; i++)
153                 zfree(&tp->die_cpus_list[i]);
154
155         for (i = 0 ; i < tp->core_cpus_lists; i++)
156                 zfree(&tp->core_cpus_list[i]);
157
158         free(tp);
159 }
160
161 bool cpu_topology__smt_on(const struct cpu_topology *topology)
162 {
163         for (u32 i = 0; i < topology->core_cpus_lists; i++) {
164                 const char *cpu_list = topology->core_cpus_list[i];
165
166                 /*
167                  * If there is a need to separate siblings in a core then SMT is
168                  * enabled.
169                  */
170                 if (strchr(cpu_list, ',') || strchr(cpu_list, '-'))
171                         return true;
172         }
173         return false;
174 }
175
176 bool cpu_topology__core_wide(const struct cpu_topology *topology,
177                              const char *user_requested_cpu_list)
178 {
179         struct perf_cpu_map *user_requested_cpus;
180
181         /*
182          * If user_requested_cpu_list is empty then all CPUs are recorded and so
183          * core_wide is true.
184          */
185         if (!user_requested_cpu_list)
186                 return true;
187
188         user_requested_cpus = perf_cpu_map__new(user_requested_cpu_list);
189         /* Check that every user requested CPU is the complete set of SMT threads on a core. */
190         for (u32 i = 0; i < topology->core_cpus_lists; i++) {
191                 const char *core_cpu_list = topology->core_cpus_list[i];
192                 struct perf_cpu_map *core_cpus = perf_cpu_map__new(core_cpu_list);
193                 struct perf_cpu cpu;
194                 int idx;
195                 bool has_first, first = true;
196
197                 perf_cpu_map__for_each_cpu(cpu, idx, core_cpus) {
198                         if (first) {
199                                 has_first = perf_cpu_map__has(user_requested_cpus, cpu);
200                                 first = false;
201                         } else {
202                                 /*
203                                  * If the first core CPU is user requested then
204                                  * all subsequent CPUs in the core must be user
205                                  * requested too. If the first CPU isn't user
206                                  * requested then none of the others must be
207                                  * too.
208                                  */
209                                 if (perf_cpu_map__has(user_requested_cpus, cpu) != has_first) {
210                                         perf_cpu_map__put(core_cpus);
211                                         perf_cpu_map__put(user_requested_cpus);
212                                         return false;
213                                 }
214                         }
215                 }
216                 perf_cpu_map__put(core_cpus);
217         }
218         perf_cpu_map__put(user_requested_cpus);
219         return true;
220 }
221
222 static bool has_die_topology(void)
223 {
224         char filename[MAXPATHLEN];
225         struct utsname uts;
226
227         if (uname(&uts) < 0)
228                 return false;
229
230         if (strncmp(uts.machine, "x86_64", 6) &&
231             strncmp(uts.machine, "s390x", 5))
232                 return false;
233
234         scnprintf(filename, MAXPATHLEN, DIE_CPUS_FMT,
235                   sysfs__mountpoint(), 0);
236         if (access(filename, F_OK) == -1)
237                 return false;
238
239         return true;
240 }
241
242 const struct cpu_topology *online_topology(void)
243 {
244         static const struct cpu_topology *topology;
245
246         if (!topology) {
247                 topology = cpu_topology__new();
248                 if (!topology) {
249                         pr_err("Error creating CPU topology");
250                         abort();
251                 }
252         }
253         return topology;
254 }
255
256 struct cpu_topology *cpu_topology__new(void)
257 {
258         struct cpu_topology *tp = NULL;
259         void *addr;
260         u32 nr, i, nr_addr;
261         size_t sz;
262         long ncpus;
263         int ret = -1;
264         struct perf_cpu_map *map;
265         bool has_die = has_die_topology();
266
267         ncpus = cpu__max_present_cpu().cpu;
268
269         /* build online CPU map */
270         map = perf_cpu_map__new_online_cpus();
271         if (map == NULL) {
272                 pr_debug("failed to get system cpumap\n");
273                 return NULL;
274         }
275
276         nr = (u32)(ncpus & UINT_MAX);
277
278         sz = nr * sizeof(char *);
279         if (has_die)
280                 nr_addr = 3;
281         else
282                 nr_addr = 2;
283         addr = calloc(1, sizeof(*tp) + nr_addr * sz);
284         if (!addr)
285                 goto out_free;
286
287         tp = addr;
288         addr += sizeof(*tp);
289         tp->package_cpus_list = addr;
290         addr += sz;
291         if (has_die) {
292                 tp->die_cpus_list = addr;
293                 addr += sz;
294         }
295         tp->core_cpus_list = addr;
296
297         for (i = 0; i < nr; i++) {
298                 if (!perf_cpu_map__has(map, (struct perf_cpu){ .cpu = i }))
299                         continue;
300
301                 ret = build_cpu_topology(tp, i);
302                 if (ret < 0)
303                         break;
304         }
305
306 out_free:
307         perf_cpu_map__put(map);
308         if (ret) {
309                 cpu_topology__delete(tp);
310                 tp = NULL;
311         }
312         return tp;
313 }
314
315 static int load_numa_node(struct numa_topology_node *node, int nr)
316 {
317         char str[MAXPATHLEN];
318         char field[32];
319         char *buf = NULL, *p;
320         size_t len = 0;
321         int ret = -1;
322         FILE *fp;
323         u64 mem;
324
325         node->node = (u32) nr;
326
327         scnprintf(str, MAXPATHLEN, NODE_MEMINFO_FMT,
328                   sysfs__mountpoint(), nr);
329         fp = fopen(str, "r");
330         if (!fp)
331                 return -1;
332
333         while (getline(&buf, &len, fp) > 0) {
334                 /* skip over invalid lines */
335                 if (!strchr(buf, ':'))
336                         continue;
337                 if (sscanf(buf, "%*s %*d %31s %"PRIu64, field, &mem) != 2)
338                         goto err;
339                 if (!strcmp(field, "MemTotal:"))
340                         node->mem_total = mem;
341                 if (!strcmp(field, "MemFree:"))
342                         node->mem_free = mem;
343                 if (node->mem_total && node->mem_free)
344                         break;
345         }
346
347         fclose(fp);
348         fp = NULL;
349
350         scnprintf(str, MAXPATHLEN, NODE_CPULIST_FMT,
351                   sysfs__mountpoint(), nr);
352
353         fp = fopen(str, "r");
354         if (!fp)
355                 return -1;
356
357         if (getline(&buf, &len, fp) <= 0)
358                 goto err;
359
360         p = strchr(buf, '\n');
361         if (p)
362                 *p = '\0';
363
364         node->cpus = buf;
365         fclose(fp);
366         return 0;
367
368 err:
369         free(buf);
370         if (fp)
371                 fclose(fp);
372         return ret;
373 }
374
375 struct numa_topology *numa_topology__new(void)
376 {
377         struct perf_cpu_map *node_map = NULL;
378         struct numa_topology *tp = NULL;
379         char path[MAXPATHLEN];
380         char *buf = NULL;
381         size_t len = 0;
382         u32 nr, i;
383         FILE *fp;
384         char *c;
385
386         scnprintf(path, MAXPATHLEN, NODE_ONLINE_FMT,
387                   sysfs__mountpoint());
388
389         fp = fopen(path, "r");
390         if (!fp)
391                 return NULL;
392
393         if (getline(&buf, &len, fp) <= 0)
394                 goto out;
395
396         c = strchr(buf, '\n');
397         if (c)
398                 *c = '\0';
399
400         node_map = perf_cpu_map__new(buf);
401         if (!node_map)
402                 goto out;
403
404         nr = (u32) perf_cpu_map__nr(node_map);
405
406         tp = zalloc(sizeof(*tp) + sizeof(tp->nodes[0])*nr);
407         if (!tp)
408                 goto out;
409
410         tp->nr = nr;
411
412         for (i = 0; i < nr; i++) {
413                 if (load_numa_node(&tp->nodes[i], perf_cpu_map__cpu(node_map, i).cpu)) {
414                         numa_topology__delete(tp);
415                         tp = NULL;
416                         break;
417                 }
418         }
419
420 out:
421         free(buf);
422         fclose(fp);
423         perf_cpu_map__put(node_map);
424         return tp;
425 }
426
427 void numa_topology__delete(struct numa_topology *tp)
428 {
429         u32 i;
430
431         for (i = 0; i < tp->nr; i++)
432                 zfree(&tp->nodes[i].cpus);
433
434         free(tp);
435 }
436
437 static int load_hybrid_node(struct hybrid_topology_node *node,
438                             struct perf_pmu *pmu)
439 {
440         char *buf = NULL, *p;
441         FILE *fp;
442         size_t len = 0;
443
444         node->pmu_name = strdup(pmu->name);
445         if (!node->pmu_name)
446                 return -1;
447
448         fp = perf_pmu__open_file(pmu, "cpus");
449         if (!fp)
450                 goto err;
451
452         if (getline(&buf, &len, fp) <= 0) {
453                 fclose(fp);
454                 goto err;
455         }
456
457         p = strchr(buf, '\n');
458         if (p)
459                 *p = '\0';
460
461         fclose(fp);
462         node->cpus = buf;
463         return 0;
464
465 err:
466         zfree(&node->pmu_name);
467         free(buf);
468         return -1;
469 }
470
471 struct hybrid_topology *hybrid_topology__new(void)
472 {
473         struct perf_pmu *pmu = NULL;
474         struct hybrid_topology *tp = NULL;
475         int nr = perf_pmus__num_core_pmus(), i = 0;
476
477         if (nr <= 1)
478                 return NULL;
479
480         tp = zalloc(sizeof(*tp) + sizeof(tp->nodes[0]) * nr);
481         if (!tp)
482                 return NULL;
483
484         tp->nr = nr;
485         while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {
486                 if (load_hybrid_node(&tp->nodes[i], pmu)) {
487                         hybrid_topology__delete(tp);
488                         return NULL;
489                 }
490                 i++;
491         }
492
493         return tp;
494 }
495
496 void hybrid_topology__delete(struct hybrid_topology *tp)
497 {
498         u32 i;
499
500         for (i = 0; i < tp->nr; i++) {
501                 zfree(&tp->nodes[i].pmu_name);
502                 zfree(&tp->nodes[i].cpus);
503         }
504
505         free(tp);
506 }
This page took 0.057161 seconds and 4 git commands to generate.