| | 1 | /* |
| | 2 | * SPDX-License-Identifier: GPL-2.0-or-later |
| | 3 | * |
| | 4 | * This program is free software; you can redistribute it and/or modify |
| | 5 | * it under the terms of the GNU General Public License as published by |
| | 6 | * the Free Software Foundation; either version 2 of the License, or |
| | 7 | * (at your option) any later version. |
| | 8 | * |
| | 9 | * Copyright (C) 2008 Cai Qian <qcai@redhat.com> |
| | 10 | * Copyright (C) 2008-2023 Karel Zak <kzak@redhat.com> |
| | 11 | */ |
| | 12 | #include <errno.h> |
| | 13 | #include <stdlib.h> |
| | 14 | #include <sys/types.h> |
| | 15 | #include <sys/stat.h> |
| | 16 | #include <fcntl.h> |
| | 17 | #include <unistd.h> |
| | 18 | #include <string.h> |
| | 19 | #include <stdio.h> |
| | 20 | #include <ctype.h> |
| | 21 | |
| | 22 | #include "lscpu.h" |
| | 23 | |
| | 24 | /* add @set to the @ary, unnecessary set is deallocated. */ |
| | 25 | static int add_cpuset_to_array(cpu_set_t **ary, size_t *items, cpu_set_t *set, size_t setsize, cpu_set_t *common_cpus_set) |
| | 26 | { |
| | 27 | size_t i; |
| | 28 | |
| | 29 | if (!ary) |
| | 30 | return -EINVAL; |
| | 31 | |
| | 32 | /* |
| | 33 | * Check if @set has no cpu in common with the cpusets |
| | 34 | * saved in @ary and if so append @set to @ary. |
| | 35 | */ |
| | 36 | for (i = 0; i < *items; i++) { |
| | 37 | CPU_AND_S(setsize, common_cpus_set, set, ary[i]); |
| | 38 | if (CPU_COUNT_S(setsize, common_cpus_set)) |
| | 39 | break; |
| | 40 | } |
| | 41 | if (i == *items) { |
| | 42 | ary[*items] = set; |
| | 43 | ++*items; |
| | 44 | return 0; |
| | 45 | } |
| | 46 | CPU_FREE(set); |
| | 47 | return 1; |
| | 48 | } |
| | 49 | |
| | 50 | static void free_cpuset_array(cpu_set_t **ary, int items) |
| | 51 | { |
| | 52 | int i; |
| | 53 | |
| | 54 | if (!ary) |
| | 55 | return; |
| | 56 | for (i = 0; i < items; i++) |
| | 57 | free(ary[i]); |
| | 58 | free(ary); |
| | 59 | } |
| | 60 | |
| | 61 | void lscpu_cputype_free_topology(struct lscpu_cputype *ct) |
| | 62 | { |
| | 63 | if (!ct) |
| | 64 | return; |
| | 65 | free_cpuset_array(ct->coremaps, ct->ncores); |
| | 66 | free_cpuset_array(ct->socketmaps, ct->nsockets); |
| | 67 | free_cpuset_array(ct->bookmaps, ct->nbooks); |
| | 68 | free_cpuset_array(ct->drawermaps, ct->ndrawers); |
| | 69 | } |
| | 70 | |
| | 71 | void lscpu_free_caches(struct lscpu_cache *caches, size_t n) |
| | 72 | { |
| | 73 | size_t i; |
| | 74 | |
| | 75 | if (!caches) |
| | 76 | return; |
| | 77 | |
| | 78 | for (i = 0; i < n; i++) { |
| | 79 | struct lscpu_cache *c = &caches[i]; |
| | 80 | |
| | 81 | DBG(MISC, ul_debug(" freeing cache #%zu %s::%d", |
| | 82 | i, c->name, c->id)); |
| | 83 | |
| | 84 | free(c->name); |
| | 85 | free(c->type); |
| | 86 | free(c->allocation_policy); |
| | 87 | free(c->write_policy); |
| | 88 | free(c->sharedmap); |
| | 89 | } |
| | 90 | free(caches); |
| | 91 | } |
| | 92 | |
| | 93 | static int cmp_cache(const void *a0, const void *b0) |
| | 94 | { |
| | 95 | const struct lscpu_cache |
| | 96 | *a = (const struct lscpu_cache *) a0, |
| | 97 | *b = (const struct lscpu_cache *) b0; |
| | 98 | return strcmp(a->name, b->name); |
| | 99 | } |
| | 100 | |
| | 101 | void lscpu_sort_caches(struct lscpu_cache *caches, size_t n) |
| | 102 | { |
| | 103 | if (caches && n) |
| | 104 | qsort(caches, n, sizeof(struct lscpu_cache), cmp_cache); |
| | 105 | } |
| | 106 | |
| | 107 | /* |
| | 108 | * Get the hotplug state number representing a completely online |
| | 109 | * cpu from /sys/devices/system/cpu/hotplug/state |
| | 110 | */ |
| | 111 | static int get_online_state(struct path_cxt *sys) |
| | 112 | { |
| | 113 | int hp_online_state_val = 0, page_size, rc; |
| | 114 | char *buf, *strp; |
| | 115 | |
| | 116 | hp_online_state_val = -1; |
| | 117 | |
| | 118 | /* sysfs text files have size = page size */ |
| | 119 | page_size = getpagesize(); |
| | 120 | |
| | 121 | buf = (char *)xmalloc(page_size); |
| | 122 | rc = ul_path_readf_buffer(sys, buf, page_size, "hotplug/states"); |
| | 123 | if (rc <= 0) |
| | 124 | goto done; |
| | 125 | |
| | 126 | strp = strstr(buf, ": online"); |
| | 127 | if (!strp) |
| | 128 | goto done; |
| | 129 | |
| | 130 | strp--; /* get digits before ': online' */ |
| | 131 | while (strp >= buf && isdigit(*strp)) |
| | 132 | strp--; |
| | 133 | ul_strtos32(strp + 1, &hp_online_state_val, 10); |
| | 134 | done: |
| | 135 | free(buf); |
| | 136 | return hp_online_state_val; |
| | 137 | } |
| | 138 | |
| | 139 | /* Read topology for specified type */ |
| | 140 | static int cputype_read_topology(struct lscpu_cxt *cxt, struct lscpu_cputype *ct) |
| | 141 | { |
| | 142 | size_t i, npos; |
| | 143 | struct path_cxt *sys; |
| | 144 | int nthreads = 0, sw_topo = 0, rc, hp_state, hp_online_state; |
| | 145 | FILE *fd; |
| | 146 | cpu_set_t *temp_set; |
| | 147 | |
| | 148 | sys = cxt->syscpu; /* /sys/devices/system/cpu/ */ |
| | 149 | npos = cxt->npossibles; /* possible CPUs */ |
| | 150 | |
| | 151 | DBG(TYPE, ul_debugobj(ct, "reading %s/%s/%s topology", |
| | 152 | ct->vendor ?: "", ct->model ?: "", ct->modelname ?:"")); |
| | 153 | |
| | 154 | hp_online_state = get_online_state(sys); |
| | 155 | |
| | 156 | temp_set = CPU_ALLOC(cxt->maxcpus); |
| | 157 | if (!temp_set) |
| | 158 | err(EXIT_FAILURE, _("cpuset_alloc failed")); |
| | 159 | |
| | 160 | for (i = 0; i < cxt->npossibles; i++) { |
| | 161 | struct lscpu_cpu *cpu = cxt->cpus[i]; |
| | 162 | cpu_set_t *thread_siblings = NULL, *core_siblings = NULL; |
| | 163 | cpu_set_t *book_siblings = NULL, *drawer_siblings = NULL; |
| | 164 | int num, n = 0; |
| | 165 | |
| | 166 | if (!cpu || cpu->type != ct) |
| | 167 | continue; |
| | 168 | |
| | 169 | num = cpu->logical_id; |
| | 170 | if (ul_path_accessf(sys, F_OK, |
| | 171 | "cpu%d/topology/thread_siblings", num) != 0) |
| | 172 | continue; |
| | 173 | |
| | 174 | /* |
| | 175 | * Ignore cpus which are not fully online. |
| | 176 | * If hp_online_state is negative/zero or rc is negative, |
| | 177 | * online state could not be read correctly, skip this check. |
| | 178 | */ |
| | 179 | rc = ul_path_readf_s32(sys, &hp_state, "cpu%d/hotplug/state", num); |
| | 180 | if (hp_online_state > 0 && rc >= 0 && hp_state != hp_online_state) |
| | 181 | continue; |
| | 182 | |
| | 183 | /* read topology maps */ |
| | 184 | ul_path_readf_cpuset(sys, &thread_siblings, cxt->maxcpus, |
| | 185 | "cpu%d/topology/thread_siblings", num); |
| | 186 | ul_path_readf_cpuset(sys, &core_siblings, cxt->maxcpus, |
| | 187 | "cpu%d/topology/core_siblings", num); |
| | 188 | ul_path_readf_cpuset(sys, &book_siblings, cxt->maxcpus, |
| | 189 | "cpu%d/topology/book_siblings", num); |
| | 190 | ul_path_readf_cpuset(sys, &drawer_siblings, cxt->maxcpus, |
| | 191 | "cpu%d/topology/drawer_siblings", num); |
| | 192 | |
| | 193 | if (thread_siblings) |
| | 194 | n = CPU_COUNT_S(cxt->setsize, thread_siblings); |
| | 195 | if (!n) |
| | 196 | n = 1; |
| | 197 | if (n > nthreads) |
| | 198 | nthreads = n; |
| | 199 | |
| | 200 | /* Allocate arrays for topology maps. |
| | 201 | * |
| | 202 | * For each map we make sure that it can have up to ncpuspos |
| | 203 | * entries. This is because we cannot reliably calculate the |
| | 204 | * number of cores, sockets and books on all architectures. |
| | 205 | * E.g. completely virtualized architectures like s390 may |
| | 206 | * have multiple sockets of different sizes. |
| | 207 | */ |
| | 208 | if (!ct->coremaps && thread_siblings) |
| | 209 | ct->coremaps = xcalloc(npos, sizeof(cpu_set_t *)); |
| | 210 | if (!ct->socketmaps && core_siblings) |
| | 211 | ct->socketmaps = xcalloc(npos, sizeof(cpu_set_t *)); |
| | 212 | if (!ct->bookmaps && book_siblings) |
| | 213 | ct->bookmaps = xcalloc(npos, sizeof(cpu_set_t *)); |
| | 214 | if (!ct->drawermaps && drawer_siblings) |
| | 215 | ct->drawermaps = xcalloc(npos, sizeof(cpu_set_t *)); |
| | 216 | |
| | 217 | /* add to topology maps */ |
| | 218 | if (thread_siblings) |
| | 219 | add_cpuset_to_array(ct->coremaps, &ct->ncores, thread_siblings, cxt->setsize, temp_set); |
| | 220 | if (core_siblings) |
| | 221 | add_cpuset_to_array(ct->socketmaps, &ct->nsockets, core_siblings, cxt->setsize, temp_set); |
| | 222 | if (book_siblings) |
| | 223 | add_cpuset_to_array(ct->bookmaps, &ct->nbooks, book_siblings, cxt->setsize, temp_set); |
| | 224 | if (drawer_siblings) |
| | 225 | add_cpuset_to_array(ct->drawermaps, &ct->ndrawers, drawer_siblings, cxt->setsize, temp_set); |
| | 226 | |
| | 227 | } |
| | 228 | CPU_FREE(temp_set); |
| | 229 | |
| | 230 | /* s390 detects its cpu topology via /proc/sysinfo, if present. |
| | 231 | * Using simply the cpu topology masks in sysfs will not give |
| | 232 | * usable results since everything is virtualized. E.g. |
| | 233 | * virtual core 0 may have only 1 cpu, but virtual core 2 may |
| | 234 | * five cpus. |
| | 235 | * If the cpu topology is not exported (e.g. 2nd level guest) |
| | 236 | * fall back to old calculation scheme. |
| | 237 | */ |
| | 238 | if ((fd = ul_path_fopen(cxt->procfs, "r", "sysinfo"))) { |
| | 239 | int t0, t1; |
| | 240 | char buf[BUFSIZ]; |
| | 241 | |
| | 242 | DBG(TYPE, ul_debugobj(ct, " reading sysinfo")); |
| | 243 | |
| | 244 | while (fgets(buf, sizeof(buf), fd) != NULL) { |
| | 245 | if (sscanf(buf, "CPU Topology SW: %d %d %zu %zu %zu %zu", |
| | 246 | &t0, &t1, |
| | 247 | &ct->ndrawers_per_system, |
| | 248 | &ct->nbooks_per_drawer, |
| | 249 | &ct->nsockets_per_book, |
| | 250 | &ct->ncores_per_socket) == 6) { |
| | 251 | sw_topo = 1; |
| | 252 | DBG(TYPE, ul_debugobj(ct, " using SW topology")); |
| | 253 | break; |
| | 254 | } |
| | 255 | } |
| | 256 | if (fd) |
| | 257 | fclose(fd); |
| | 258 | } |
| | 259 | |
| | 260 | ct->nthreads_per_core = nthreads; |
| | 261 | if (ct->mtid) { |
| | 262 | uint64_t x; |
| | 263 | if (ul_strtou64(ct->mtid, &x, 10) == 0 && x <= ULONG_MAX) |
| | 264 | ct->nthreads_per_core = (size_t) x + 1; |
| | 265 | } |
| | 266 | |
| | 267 | if (!sw_topo) { |
| | 268 | ct->ncores_per_socket = ct->nsockets ? ct->ncores / ct->nsockets : 0; |
| | 269 | ct->nsockets_per_book = ct->nbooks ? ct->nsockets / ct->nbooks : 0; |
| | 270 | ct->nbooks_per_drawer = ct->ndrawers ? ct->nbooks / ct->ndrawers : 0; |
| | 271 | ct->ndrawers_per_system = ct->ndrawers; |
| | 272 | } |
| | 273 | |
| | 274 | DBG(TYPE, ul_debugobj(ct, " nthreads: %zu (per core)", ct->nthreads_per_core)); |
| | 275 | DBG(TYPE, ul_debugobj(ct, " ncores: %zu (%zu per socket)", ct->ncores, ct->ncores_per_socket)); |
| | 276 | DBG(TYPE, ul_debugobj(ct, " nsockets: %zu (%zu per books)", ct->nsockets, ct->nsockets_per_book)); |
| | 277 | DBG(TYPE, ul_debugobj(ct, " nbooks: %zu (%zu per drawer)", ct->nbooks, ct->nbooks_per_drawer)); |
| | 278 | DBG(TYPE, ul_debugobj(ct, " ndrawers: %zu (%zu per system)", ct->ndrawers, ct->ndrawers_per_system)); |
| | 279 | |
| | 280 | return 0; |
| | 281 | } |
| | 282 | |
| | 283 | /* count size of all instancess of the "name" */ |
| | 284 | size_t lscpu_get_cache_full_size(struct lscpu_cxt *cxt, const char *name, int *instances) |
| | 285 | { |
| | 286 | size_t i, sz = 0; |
| | 287 | |
| | 288 | if (instances) |
| | 289 | *instances = 0; |
| | 290 | |
| | 291 | for (i = 0; i < cxt->ncaches; i++) { |
| | 292 | if (strcmp(cxt->caches[i].name, name) == 0) { |
| | 293 | sz += cxt->caches[i].size; |
| | 294 | if (instances) |
| | 295 | (*instances)++; |
| | 296 | } |
| | 297 | } |
| | 298 | |
| | 299 | return sz; |
| | 300 | } |
| | 301 | |
| | 302 | struct lscpu_cache *lscpu_cpu_get_cache(struct lscpu_cxt *cxt, |
| | 303 | struct lscpu_cpu *cpu, const char *name) |
| | 304 | { |
| | 305 | size_t i; |
| | 306 | |
| | 307 | for (i = 0; i < cxt->ncaches; i++) { |
| | 308 | struct lscpu_cache *ca = &cxt->caches[i]; |
| | 309 | |
| | 310 | if (ca->sharedmap && |
| | 311 | strcmp(ca->name, name) == 0 && |
| | 312 | CPU_ISSET_S(cpu->logical_id, cxt->setsize, ca->sharedmap)) |
| | 313 | return ca; |
| | 314 | } |
| | 315 | |
| | 316 | return NULL; |
| | 317 | } |
| | 318 | |
| | 319 | /* |
| | 320 | * The cache is identifued by type+level+id. |
| | 321 | */ |
| | 322 | static struct lscpu_cache *get_cache(struct lscpu_cxt *cxt, |
| | 323 | const char *type, int level, int id) |
| | 324 | { |
| | 325 | size_t i; |
| | 326 | |
| | 327 | for (i = 0; i < cxt->ncaches; i++) { |
| | 328 | struct lscpu_cache *ca = &cxt->caches[i]; |
| | 329 | if (ca->id == id && |
| | 330 | ca->level == level && |
| | 331 | strcmp(ca->type, type) == 0) |
| | 332 | return ca; |
| | 333 | } |
| | 334 | return NULL; |
| | 335 | } |
| | 336 | |
| | 337 | static struct lscpu_cache *add_cache(struct lscpu_cxt *cxt, |
| | 338 | const char *type, int level, int id) |
| | 339 | { |
| | 340 | struct lscpu_cache *ca; |
| | 341 | |
| | 342 | cxt->ncaches++; |
| | 343 | cxt->caches = xreallocarray(cxt->caches, |
| | 344 | cxt->ncaches, sizeof(*cxt->caches)); |
| | 345 | |
| | 346 | ca = &cxt->caches[cxt->ncaches - 1]; |
| | 347 | memset(ca, 0 , sizeof(*ca)); |
| | 348 | |
| | 349 | ca->id = id; |
| | 350 | ca->level = level; |
| | 351 | ca->type = xstrdup(type); |
| | 352 | |
| | 353 | DBG(GATHER, ul_debugobj(cxt, "add cache %s%d::%d", type, level, id)); |
| | 354 | return ca; |
| | 355 | } |
| | 356 | |
| | 357 | static int mk_cache_id(struct lscpu_cxt *cxt, struct lscpu_cpu *cpu, char *type, int level) |
| | 358 | { |
| | 359 | size_t i; |
| | 360 | int idx = 0; |
| | 361 | |
| | 362 | for (i = 0; i < cxt->ncaches; i++) { |
| | 363 | struct lscpu_cache *ca = &cxt->caches[i]; |
| | 364 | |
| | 365 | if (ca->level != level || strcmp(ca->type, type) != 0) |
| | 366 | continue; |
| | 367 | |
| | 368 | if (ca->sharedmap && |
| | 369 | CPU_ISSET_S(cpu->logical_id, cxt->setsize, ca->sharedmap)) |
| | 370 | return idx; |
| | 371 | idx++; |
| | 372 | } |
| | 373 | |
| | 374 | return idx; |
| | 375 | } |
| | 376 | |
| | 377 | static int read_sparc_onecache(struct lscpu_cxt *cxt, struct lscpu_cpu *cpu, |
| | 378 | int level, char *typestr, int type) |
| | 379 | { |
| | 380 | struct lscpu_cache *ca; |
| | 381 | struct path_cxt *sys = cxt->syscpu; |
| | 382 | int num = cpu->logical_id; |
| | 383 | uint32_t size; |
| | 384 | int rc, id; |
| | 385 | char buf[32]; |
| | 386 | |
| | 387 | if (type) |
| | 388 | snprintf(buf, sizeof(buf), "l%d_%c", level, type); |
| | 389 | else |
| | 390 | snprintf(buf, sizeof(buf), "l%d_", level); |
| | 391 | |
| | 392 | rc = ul_path_readf_u32(sys, &size, |
| | 393 | "cpu%d/%scache_size", num, buf); |
| | 394 | if (rc != 0) |
| | 395 | return rc; |
| | 396 | |
| | 397 | DBG(CPU, ul_debugobj(cpu, "#%d reading sparc %s cache", num, buf)); |
| | 398 | |
| | 399 | id = mk_cache_id(cxt, cpu, typestr, level); |
| | 400 | |
| | 401 | ca = get_cache(cxt, typestr, level, id); |
| | 402 | if (!ca) |
| | 403 | ca = add_cache(cxt, typestr, level, id); |
| | 404 | |
| | 405 | if (!ca->name) { |
| | 406 | ul_path_readf_u32(sys, &ca->coherency_line_size, |
| | 407 | "cpu%d/%scache_line_size", num, buf); |
| | 408 | assert(ca->type); |
| | 409 | |
| | 410 | if (type) |
| | 411 | snprintf(buf, sizeof(buf), "L%d%c", ca->level, type); |
| | 412 | else |
| | 413 | snprintf(buf, sizeof(buf), "L%d", ca->level); |
| | 414 | ca->name = xstrdup(buf); |
| | 415 | ca->size = size; |
| | 416 | } |
| | 417 | /* There is no sharedmap of the cache in /sys, we assume that caches are |
| | 418 | * not shared. Send a patch if your /sys provides another information. |
| | 419 | */ |
| | 420 | if (!ca->sharedmap) { |
| | 421 | size_t setsize = 0; |
| | 422 | |
| | 423 | ca->sharedmap = cpuset_alloc(cxt->maxcpus, &setsize, NULL); |
| | 424 | CPU_ZERO_S(setsize, ca->sharedmap); |
| | 425 | CPU_SET_S(num, setsize, ca->sharedmap); |
| | 426 | } |
| | 427 | |
| | 428 | return 0; |
| | 429 | } |
| | 430 | |
| | 431 | static int read_sparc_caches(struct lscpu_cxt *cxt, struct lscpu_cpu *cpu) |
| | 432 | { |
| | 433 | read_sparc_onecache(cxt, cpu, 1, "Instruction", 'i'); |
| | 434 | read_sparc_onecache(cxt, cpu, 1, "Data", 'd'); |
| | 435 | read_sparc_onecache(cxt, cpu, 2, "Unified", 0); |
| | 436 | read_sparc_onecache(cxt, cpu, 2, "Unified", 0); |
| | 437 | |
| | 438 | return 0; |
| | 439 | } |
| | 440 | |
| | 441 | static int read_caches(struct lscpu_cxt *cxt, struct lscpu_cpu *cpu) |
| | 442 | { |
| | 443 | char buf[256]; |
| | 444 | struct path_cxt *sys = cxt->syscpu; |
| | 445 | int num = cpu->logical_id; |
| | 446 | size_t i, ncaches = 0; |
| | 447 | |
| | 448 | while (ul_path_accessf(sys, F_OK, |
| | 449 | "cpu%d/cache/index%zu", |
| | 450 | num, ncaches) == 0) |
| | 451 | ncaches++; |
| | 452 | |
| | 453 | if (ncaches == 0 && ul_path_accessf(sys, F_OK, |
| | 454 | "cpu%d/l1_icache_size", num) == 0) |
| | 455 | return read_sparc_caches(cxt, cpu); |
| | 456 | |
| | 457 | DBG(CPU, ul_debugobj(cpu, "#%d reading %zd caches", num, ncaches)); |
| | 458 | |
| | 459 | for (i = 0; i < ncaches; i++) { |
| | 460 | struct lscpu_cache *ca; |
| | 461 | int id, level; |
| | 462 | |
| | 463 | if (ul_path_readf_s32(sys, &id, "cpu%d/cache/index%zu/id", num, i) != 0) |
| | 464 | id = -1; |
| | 465 | if (ul_path_readf_s32(sys, &level, "cpu%d/cache/index%zu/level", num, i) != 0) |
| | 466 | continue; |
| | 467 | if (ul_path_readf_buffer(sys, buf, sizeof(buf), |
| | 468 | "cpu%d/cache/index%zu/type", num, i) <= 0) |
| | 469 | continue; |
| | 470 | |
| | 471 | if (id == -1) |
| | 472 | id = mk_cache_id(cxt, cpu, buf, level); |
| | 473 | |
| | 474 | ca = get_cache(cxt, buf, level, id); |
| | 475 | if (!ca) |
| | 476 | ca = add_cache(cxt, buf, level, id); |
| | 477 | |
| | 478 | if (!ca->name) { |
| | 479 | int type = 0; |
| | 480 | |
| | 481 | assert(ca->type); |
| | 482 | |
| | 483 | if (!strcmp(ca->type, "Data")) |
| | 484 | type = 'd'; |
| | 485 | else if (!strcmp(ca->type, "Instruction")) |
| | 486 | type = 'i'; |
| | 487 | |
| | 488 | if (type) |
| | 489 | snprintf(buf, sizeof(buf), "L%d%c", ca->level, type); |
| | 490 | else |
| | 491 | snprintf(buf, sizeof(buf), "L%d", ca->level); |
| | 492 | |
| | 493 | ca->name = xstrdup(buf); |
| | 494 | |
| | 495 | ul_path_readf_u32(sys, &ca->ways_of_associativity, |
| | 496 | "cpu%d/cache/index%zu/ways_of_associativity", num, i); |
| | 497 | ul_path_readf_u32(sys, &ca->physical_line_partition, |
| | 498 | "cpu%d/cache/index%zu/physical_line_partition", num, i); |
| | 499 | ul_path_readf_u32(sys, &ca->number_of_sets, |
| | 500 | "cpu%d/cache/index%zu/number_of_sets", num, i); |
| | 501 | ul_path_readf_u32(sys, &ca->coherency_line_size, |
| | 502 | "cpu%d/cache/index%zu/coherency_line_size", num, i); |
| | 503 | |
| | 504 | ul_path_readf_string(sys, &ca->allocation_policy, |
| | 505 | "cpu%d/cache/index%zu/allocation_policy", num, i); |
| | 506 | ul_path_readf_string(sys, &ca->write_policy, |
| | 507 | "cpu%d/cache/index%zu/write_policy", num, i); |
| | 508 | |
| | 509 | /* cache size */ |
| | 510 | if (ul_path_readf_buffer(sys, buf, sizeof(buf), |
| | 511 | "cpu%d/cache/index%zu/size", num, i) > 0) |
| | 512 | ul_parse_size(buf, &ca->size, NULL); |
| | 513 | else |
| | 514 | ca->size = 0; |
| | 515 | } |
| | 516 | |
| | 517 | if (!ca->sharedmap) |
| | 518 | /* information about how CPUs share different caches */ |
| | 519 | ul_path_readf_cpuset(sys, &ca->sharedmap, cxt->maxcpus, |
| | 520 | "cpu%d/cache/index%zu/shared_cpu_map", num, i); |
| | 521 | } |
| | 522 | |
| | 523 | return 0; |
| | 524 | } |
| | 525 | |
| | 526 | static int read_ids(struct lscpu_cxt *cxt, struct lscpu_cpu *cpu) |
| | 527 | { |
| | 528 | struct path_cxt *sys = cxt->syscpu; |
| | 529 | int num = cpu->logical_id; |
| | 530 | |
| | 531 | if (ul_path_accessf(sys, F_OK, "cpu%d/topology", num) != 0) |
| | 532 | return 0; |
| | 533 | |
| | 534 | DBG(CPU, ul_debugobj(cpu, "#%d reading IDs", num)); |
| | 535 | |
| | 536 | if (ul_path_readf_s32(sys, &cpu->coreid, "cpu%d/topology/core_id", num) != 0) |
| | 537 | cpu->coreid = -1; |
| | 538 | if (ul_path_readf_s32(sys, &cpu->socketid, "cpu%d/topology/physical_package_id", num) != 0) |
| | 539 | cpu->socketid = -1; |
| | 540 | if (ul_path_readf_s32(sys, &cpu->bookid, "cpu%d/topology/book_id", num) != 0) |
| | 541 | cpu->bookid = -1; |
| | 542 | if (ul_path_readf_s32(sys, &cpu->drawerid, "cpu%d/topology/drawer_id", num) != 0) |
| | 543 | cpu->drawerid = -1; |
| | 544 | |
| | 545 | return 0; |
| | 546 | } |
| | 547 | |
| | 548 | static int read_polarization(struct lscpu_cxt *cxt, struct lscpu_cpu *cpu) |
| | 549 | { |
| | 550 | struct path_cxt *sys = cxt->syscpu; |
| | 551 | int num = cpu->logical_id; |
| | 552 | char mode[64]; |
| | 553 | |
| | 554 | if (ul_path_accessf(sys, F_OK, "cpu%d/polarization", num) != 0) |
| | 555 | return 0; |
| | 556 | |
| | 557 | ul_path_readf_buffer(sys, mode, sizeof(mode), "cpu%d/polarization", num); |
| | 558 | |
| | 559 | DBG(CPU, ul_debugobj(cpu, "#%d reading polar=%s", num, mode)); |
| | 560 | |
| | 561 | if (strncmp(mode, "vertical:low", sizeof(mode)) == 0) |
| | 562 | cpu->polarization = POLAR_VLOW; |
| | 563 | else if (strncmp(mode, "vertical:medium", sizeof(mode)) == 0) |
| | 564 | cpu->polarization = POLAR_VMEDIUM; |
| | 565 | else if (strncmp(mode, "vertical:high", sizeof(mode)) == 0) |
| | 566 | cpu->polarization = POLAR_VHIGH; |
| | 567 | else if (strncmp(mode, "horizontal", sizeof(mode)) == 0) |
| | 568 | cpu->polarization = POLAR_HORIZONTAL; |
| | 569 | else |
| | 570 | cpu->polarization = POLAR_UNKNOWN; |
| | 571 | |
| | 572 | if (cpu->type) |
| | 573 | cpu->type->has_polarization = 1; |
| | 574 | return 0; |
| | 575 | } |
| | 576 | |
| | 577 | static int read_address(struct lscpu_cxt *cxt, struct lscpu_cpu *cpu) |
| | 578 | { |
| | 579 | struct path_cxt *sys = cxt->syscpu; |
| | 580 | int num = cpu->logical_id; |
| | 581 | |
| | 582 | if (ul_path_accessf(sys, F_OK, "cpu%d/address", num) != 0) |
| | 583 | return 0; |
| | 584 | |
| | 585 | DBG(CPU, ul_debugobj(cpu, "#%d reading address", num)); |
| | 586 | |
| | 587 | ul_path_readf_s32(sys, &cpu->address, "cpu%d/address", num); |
| | 588 | if (cpu->type) |
| | 589 | cpu->type->has_addresses = 1; |
| | 590 | return 0; |
| | 591 | } |
| | 592 | |
| | 593 | static int read_configure(struct lscpu_cxt *cxt, struct lscpu_cpu *cpu) |
| | 594 | { |
| | 595 | struct path_cxt *sys = cxt->syscpu; |
| | 596 | int num = cpu->logical_id; |
| | 597 | |
| | 598 | if (ul_path_accessf(sys, F_OK, "cpu%d/configure", num) != 0) |
| | 599 | return 0; |
| | 600 | |
| | 601 | DBG(CPU, ul_debugobj(cpu, "#%d reading configure", num)); |
| | 602 | |
| | 603 | ul_path_readf_s32(sys, &cpu->configured, "cpu%d/configure", num); |
| | 604 | if (cpu->type) |
| | 605 | cpu->type->has_configured = 1; |
| | 606 | return 0; |
| | 607 | } |
| | 608 | |
| | 609 | static int read_mhz(struct lscpu_cxt *cxt, struct lscpu_cpu *cpu) |
| | 610 | { |
| | 611 | struct path_cxt *sys = cxt->syscpu; |
| | 612 | int num = cpu->logical_id; |
| | 613 | int mhz; |
| | 614 | |
| | 615 | DBG(CPU, ul_debugobj(cpu, "#%d reading mhz", num)); |
| | 616 | |
| | 617 | if (ul_path_readf_s32(sys, &mhz, "cpu%d/cpufreq/cpuinfo_max_freq", num) == 0) |
| | 618 | cpu->mhz_max_freq = (float) mhz / 1000; |
| | 619 | if (ul_path_readf_s32(sys, &mhz, "cpu%d/cpufreq/cpuinfo_min_freq", num) == 0) |
| | 620 | cpu->mhz_min_freq = (float) mhz / 1000; |
| | 621 | |
| | 622 | /* The default current-frequency value comes is from /proc/cpuinfo (if |
| | 623 | * available). This /proc value is usually based on MSR registers |
| | 624 | * (APERF/APERF) and it changes pretty often. It seems better to read |
| | 625 | * frequency from cpufreq subsystem that provides the current frequency |
| | 626 | * for the current policy. There is also cpuinfo_cur_freq in sysfs, but |
| | 627 | * it's not always available. |
| | 628 | */ |
| | 629 | if (ul_path_readf_s32(sys, &mhz, "cpu%d/cpufreq/scaling_cur_freq", num) == 0) |
| | 630 | cpu->mhz_cur_freq = (float) mhz / 1000; |
| | 631 | |
| | 632 | if (cpu->type && (cpu->mhz_min_freq || cpu->mhz_max_freq)) |
| | 633 | cpu->type->has_freq = 1; |
| | 634 | |
| | 635 | return 0; |
| | 636 | } |
| | 637 | |
| | 638 | float lsblk_cputype_get_maxmhz(struct lscpu_cxt *cxt, struct lscpu_cputype *ct) |
| | 639 | { |
| | 640 | size_t i; |
| | 641 | float res = 0.0; |
| | 642 | |
| | 643 | for (i = 0; i < cxt->npossibles; i++) { |
| | 644 | struct lscpu_cpu *cpu = cxt->cpus[i]; |
| | 645 | |
| | 646 | if (!cpu || cpu->type != ct || !is_cpu_present(cxt, cpu)) |
| | 647 | continue; |
| | 648 | res = max(res, cpu->mhz_max_freq); |
| | 649 | } |
| | 650 | return res; |
| | 651 | } |
| | 652 | |
| | 653 | float lsblk_cputype_get_minmhz(struct lscpu_cxt *cxt, struct lscpu_cputype *ct) |
| | 654 | { |
| | 655 | size_t i; |
| | 656 | float res = -1.0; |
| | 657 | |
| | 658 | for (i = 0; i < cxt->npossibles; i++) { |
| | 659 | struct lscpu_cpu *cpu = cxt->cpus[i]; |
| | 660 | |
| | 661 | if (!cpu || cpu->type != ct || !is_cpu_present(cxt, cpu)) |
| | 662 | continue; |
| | 663 | if (!cpu->mhz_min_freq) |
| | 664 | continue; |
| | 665 | if (res < 0.0 || cpu->mhz_min_freq < res) |
| | 666 | res = cpu->mhz_min_freq; |
| | 667 | } |
| | 668 | return res; |
| | 669 | } |
| | 670 | |
| | 671 | /* returns scaling (use) of CPUs freq. in percent */ |
| | 672 | float lsblk_cputype_get_scalmhz(struct lscpu_cxt *cxt, struct lscpu_cputype *ct) |
| | 673 | { |
| | 674 | size_t i; |
| | 675 | float fmax = 0, fcur = 0; |
| | 676 | |
| | 677 | for (i = 0; i < cxt->npossibles; i++) { |
| | 678 | struct lscpu_cpu *cpu = cxt->cpus[i]; |
| | 679 | |
| | 680 | if (!cpu || cpu->type != ct || !is_cpu_present(cxt, cpu)) |
| | 681 | continue; |
| | 682 | if (cpu->mhz_max_freq <= 0.0 || cpu->mhz_cur_freq <= 0.0) |
| | 683 | continue; |
| | 684 | fmax += cpu->mhz_max_freq; |
| | 685 | fcur += cpu->mhz_cur_freq; |
| | 686 | } |
| | 687 | if (fcur <= 0.0) |
| | 688 | return 0.0; |
| | 689 | return fcur / fmax * 100; |
| | 690 | } |
| | 691 | |
| | 692 | int lscpu_read_topology(struct lscpu_cxt *cxt) |
| | 693 | { |
| | 694 | size_t i; |
| | 695 | int rc = 0; |
| | 696 | |
| | 697 | |
| | 698 | for (i = 0; i < cxt->ncputypes; i++) |
| | 699 | rc += cputype_read_topology(cxt, cxt->cputypes[i]); |
| | 700 | |
| | 701 | for (i = 0; rc == 0 && i < cxt->npossibles; i++) { |
| | 702 | struct lscpu_cpu *cpu = cxt->cpus[i]; |
| | 703 | |
| | 704 | if (!cpu || !cpu->type) |
| | 705 | continue; |
| | 706 | |
| | 707 | DBG(CPU, ul_debugobj(cpu, "#%d reading topology", cpu->logical_id)); |
| | 708 | |
| | 709 | rc = read_ids(cxt, cpu); |
| | 710 | if (!rc) |
| | 711 | rc = read_polarization(cxt, cpu); |
| | 712 | if (!rc) |
| | 713 | rc = read_address(cxt, cpu); |
| | 714 | if (!rc) |
| | 715 | rc = read_configure(cxt, cpu); |
| | 716 | if (!rc) |
| | 717 | rc = read_mhz(cxt, cpu); |
| | 718 | if (!rc) |
| | 719 | rc = read_caches(cxt, cpu); |
| | 720 | } |
| | 721 | |
| | 722 | lscpu_sort_caches(cxt->caches, cxt->ncaches); |
| | 723 | DBG(GATHER, ul_debugobj(cxt, " L1d: %zu", lscpu_get_cache_full_size(cxt, "L1d", NULL))); |
| | 724 | DBG(GATHER, ul_debugobj(cxt, " L1i: %zu", lscpu_get_cache_full_size(cxt, "L1i", NULL))); |
| | 725 | DBG(GATHER, ul_debugobj(cxt, " L2: %zu", lscpu_get_cache_full_size(cxt, "L2", NULL))); |
| | 726 | DBG(GATHER, ul_debugobj(cxt, " L3: %zu", lscpu_get_cache_full_size(cxt, "L3", NULL))); |
| | 727 | |
| | 728 | return rc; |
| | 729 | } |
| | 730 | |
| | 731 | |
projects / thirdparty / util-linux.git / blame_incremental