cputopo.c 6.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353
  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. #include "cputopo.h"
  11. #include "cpumap.h"
  12. #include "debug.h"
  13. #include "env.h"
  14. #define CORE_SIB_FMT \
  15. "%s/devices/system/cpu/cpu%d/topology/core_siblings_list"
  16. #define DIE_SIB_FMT \
  17. "%s/devices/system/cpu/cpu%d/topology/die_cpus_list"
  18. #define THRD_SIB_FMT \
  19. "%s/devices/system/cpu/cpu%d/topology/thread_siblings_list"
  20. #define THRD_SIB_FMT_NEW \
  21. "%s/devices/system/cpu/cpu%d/topology/core_cpus_list"
  22. #define NODE_ONLINE_FMT \
  23. "%s/devices/system/node/online"
  24. #define NODE_MEMINFO_FMT \
  25. "%s/devices/system/node/node%d/meminfo"
  26. #define NODE_CPULIST_FMT \
  27. "%s/devices/system/node/node%d/cpulist"
  28. static int build_cpu_topology(struct cpu_topology *tp, int cpu)
  29. {
  30. FILE *fp;
  31. char filename[MAXPATHLEN];
  32. char *buf = NULL, *p;
  33. size_t len = 0;
  34. ssize_t sret;
  35. u32 i = 0;
  36. int ret = -1;
  37. scnprintf(filename, MAXPATHLEN, CORE_SIB_FMT,
  38. sysfs__mountpoint(), cpu);
  39. fp = fopen(filename, "r");
  40. if (!fp)
  41. goto try_dies;
  42. sret = getline(&buf, &len, fp);
  43. fclose(fp);
  44. if (sret <= 0)
  45. goto try_dies;
  46. p = strchr(buf, '\n');
  47. if (p)
  48. *p = '\0';
  49. for (i = 0; i < tp->core_sib; i++) {
  50. if (!strcmp(buf, tp->core_siblings[i]))
  51. break;
  52. }
  53. if (i == tp->core_sib) {
  54. tp->core_siblings[i] = buf;
  55. tp->core_sib++;
  56. buf = NULL;
  57. len = 0;
  58. }
  59. ret = 0;
  60. try_dies:
  61. if (!tp->die_siblings)
  62. goto try_threads;
  63. scnprintf(filename, MAXPATHLEN, DIE_SIB_FMT,
  64. sysfs__mountpoint(), cpu);
  65. fp = fopen(filename, "r");
  66. if (!fp)
  67. goto try_threads;
  68. sret = getline(&buf, &len, fp);
  69. fclose(fp);
  70. if (sret <= 0)
  71. goto try_threads;
  72. p = strchr(buf, '\n');
  73. if (p)
  74. *p = '\0';
  75. for (i = 0; i < tp->die_sib; i++) {
  76. if (!strcmp(buf, tp->die_siblings[i]))
  77. break;
  78. }
  79. if (i == tp->die_sib) {
  80. tp->die_siblings[i] = buf;
  81. tp->die_sib++;
  82. buf = NULL;
  83. len = 0;
  84. }
  85. ret = 0;
  86. try_threads:
  87. scnprintf(filename, MAXPATHLEN, THRD_SIB_FMT_NEW,
  88. sysfs__mountpoint(), cpu);
  89. if (access(filename, F_OK) == -1) {
  90. scnprintf(filename, MAXPATHLEN, THRD_SIB_FMT,
  91. sysfs__mountpoint(), cpu);
  92. }
  93. fp = fopen(filename, "r");
  94. if (!fp)
  95. goto done;
  96. if (getline(&buf, &len, fp) <= 0)
  97. goto done;
  98. p = strchr(buf, '\n');
  99. if (p)
  100. *p = '\0';
  101. for (i = 0; i < tp->thread_sib; i++) {
  102. if (!strcmp(buf, tp->thread_siblings[i]))
  103. break;
  104. }
  105. if (i == tp->thread_sib) {
  106. tp->thread_siblings[i] = buf;
  107. tp->thread_sib++;
  108. buf = NULL;
  109. }
  110. ret = 0;
  111. done:
  112. if (fp)
  113. fclose(fp);
  114. free(buf);
  115. return ret;
  116. }
  117. void cpu_topology__delete(struct cpu_topology *tp)
  118. {
  119. u32 i;
  120. if (!tp)
  121. return;
  122. for (i = 0 ; i < tp->core_sib; i++)
  123. zfree(&tp->core_siblings[i]);
  124. if (tp->die_sib) {
  125. for (i = 0 ; i < tp->die_sib; i++)
  126. zfree(&tp->die_siblings[i]);
  127. }
  128. for (i = 0 ; i < tp->thread_sib; i++)
  129. zfree(&tp->thread_siblings[i]);
  130. free(tp);
  131. }
  132. static bool has_die_topology(void)
  133. {
  134. char filename[MAXPATHLEN];
  135. struct utsname uts;
  136. if (uname(&uts) < 0)
  137. return false;
  138. if (strncmp(uts.machine, "x86_64", 6))
  139. return false;
  140. scnprintf(filename, MAXPATHLEN, DIE_SIB_FMT,
  141. sysfs__mountpoint(), 0);
  142. if (access(filename, F_OK) == -1)
  143. return false;
  144. return true;
  145. }
  146. struct cpu_topology *cpu_topology__new(void)
  147. {
  148. struct cpu_topology *tp = NULL;
  149. void *addr;
  150. u32 nr, i, nr_addr;
  151. size_t sz;
  152. long ncpus;
  153. int ret = -1;
  154. struct perf_cpu_map *map;
  155. bool has_die = has_die_topology();
  156. ncpus = cpu__max_present_cpu();
  157. /* build online CPU map */
  158. map = perf_cpu_map__new(NULL);
  159. if (map == NULL) {
  160. pr_debug("failed to get system cpumap\n");
  161. return NULL;
  162. }
  163. nr = (u32)(ncpus & UINT_MAX);
  164. sz = nr * sizeof(char *);
  165. if (has_die)
  166. nr_addr = 3;
  167. else
  168. nr_addr = 2;
  169. addr = calloc(1, sizeof(*tp) + nr_addr * sz);
  170. if (!addr)
  171. goto out_free;
  172. tp = addr;
  173. addr += sizeof(*tp);
  174. tp->core_siblings = addr;
  175. addr += sz;
  176. if (has_die) {
  177. tp->die_siblings = addr;
  178. addr += sz;
  179. }
  180. tp->thread_siblings = addr;
  181. for (i = 0; i < nr; i++) {
  182. if (!cpu_map__has(map, i))
  183. continue;
  184. ret = build_cpu_topology(tp, i);
  185. if (ret < 0)
  186. break;
  187. }
  188. out_free:
  189. perf_cpu_map__put(map);
  190. if (ret) {
  191. cpu_topology__delete(tp);
  192. tp = NULL;
  193. }
  194. return tp;
  195. }
  196. static int load_numa_node(struct numa_topology_node *node, int nr)
  197. {
  198. char str[MAXPATHLEN];
  199. char field[32];
  200. char *buf = NULL, *p;
  201. size_t len = 0;
  202. int ret = -1;
  203. FILE *fp;
  204. u64 mem;
  205. node->node = (u32) nr;
  206. scnprintf(str, MAXPATHLEN, NODE_MEMINFO_FMT,
  207. sysfs__mountpoint(), nr);
  208. fp = fopen(str, "r");
  209. if (!fp)
  210. return -1;
  211. while (getline(&buf, &len, fp) > 0) {
  212. /* skip over invalid lines */
  213. if (!strchr(buf, ':'))
  214. continue;
  215. if (sscanf(buf, "%*s %*d %31s %"PRIu64, field, &mem) != 2)
  216. goto err;
  217. if (!strcmp(field, "MemTotal:"))
  218. node->mem_total = mem;
  219. if (!strcmp(field, "MemFree:"))
  220. node->mem_free = mem;
  221. if (node->mem_total && node->mem_free)
  222. break;
  223. }
  224. fclose(fp);
  225. fp = NULL;
  226. scnprintf(str, MAXPATHLEN, NODE_CPULIST_FMT,
  227. sysfs__mountpoint(), nr);
  228. fp = fopen(str, "r");
  229. if (!fp)
  230. return -1;
  231. if (getline(&buf, &len, fp) <= 0)
  232. goto err;
  233. p = strchr(buf, '\n');
  234. if (p)
  235. *p = '\0';
  236. node->cpus = buf;
  237. fclose(fp);
  238. return 0;
  239. err:
  240. free(buf);
  241. if (fp)
  242. fclose(fp);
  243. return ret;
  244. }
  245. struct numa_topology *numa_topology__new(void)
  246. {
  247. struct perf_cpu_map *node_map = NULL;
  248. struct numa_topology *tp = NULL;
  249. char path[MAXPATHLEN];
  250. char *buf = NULL;
  251. size_t len = 0;
  252. u32 nr, i;
  253. FILE *fp;
  254. char *c;
  255. scnprintf(path, MAXPATHLEN, NODE_ONLINE_FMT,
  256. sysfs__mountpoint());
  257. fp = fopen(path, "r");
  258. if (!fp)
  259. return NULL;
  260. if (getline(&buf, &len, fp) <= 0)
  261. goto out;
  262. c = strchr(buf, '\n');
  263. if (c)
  264. *c = '\0';
  265. node_map = perf_cpu_map__new(buf);
  266. if (!node_map)
  267. goto out;
  268. nr = (u32) node_map->nr;
  269. tp = zalloc(sizeof(*tp) + sizeof(tp->nodes[0])*nr);
  270. if (!tp)
  271. goto out;
  272. tp->nr = nr;
  273. for (i = 0; i < nr; i++) {
  274. if (load_numa_node(&tp->nodes[i], node_map->map[i])) {
  275. numa_topology__delete(tp);
  276. tp = NULL;
  277. break;
  278. }
  279. }
  280. out:
  281. free(buf);
  282. fclose(fp);
  283. perf_cpu_map__put(node_map);
  284. return tp;
  285. }
  286. void numa_topology__delete(struct numa_topology *tp)
  287. {
  288. u32 i;
  289. for (i = 0; i < tp->nr; i++)
  290. zfree(&tp->nodes[i].cpus);
  291. free(tp);
  292. }