sys-utils/lscpu-topology.c

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