tools/power/cpupower/utils/cpufreq-info.c

   1 /*
   2  *  (C) 2004-2009  Dominik Brodowski <linux@dominikbrodowski.de>
   3  *
   4  *  Licensed under the terms of the GNU GPL License version 2.
   5  */
   6
   7
   8 #include <unistd.h>
   9 #include <stdio.h>
  10 #include <errno.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 #include <getopt.h>
  15
  16 #include "cpufreq.h"
  17 #include "helpers/helpers.h"
  18 #include "helpers/bitmask.h"
  19
  20 #define LINE_LEN 10
  21
  22 static unsigned int count_cpus(void)
  23 {
  24         FILE *fp;
  25         char value[LINE_LEN];
  26         unsigned int ret = 0;
  27         unsigned int cpunr = 0;
  28
  29         fp = fopen("/proc/stat", "r");
  30         if (!fp) {
  31                 printf(_("Couldn't count the number of CPUs (%s: %s), assuming 1\n"), "/proc/stat", strerror(errno));
  32                 return 1;
  33         }
  34
  35         while (!feof(fp)) {
  36                 if (!fgets(value, LINE_LEN, fp))
  37                         continue;
  38                 value[LINE_LEN - 1] = '\0';
  39                 if (strlen(value) < (LINE_LEN - 2))
  40                         continue;
  41                 if (strstr(value, "cpu "))
  42                         continue;
  43                 if (sscanf(value, "cpu%d ", &cpunr) != 1)
  44                         continue;
  45                 if (cpunr > ret)
  46                         ret = cpunr;
  47         }
  48         fclose(fp);
  49
  50         /* cpu count starts from 0, on error return 1 (UP) */
  51         return ret + 1;
  52 }
  53
  54
  55 static void proc_cpufreq_output(void)
  56 {
  57         unsigned int cpu, nr_cpus;
  58         struct cpufreq_policy *policy;
  59         unsigned int min_pctg = 0;
  60         unsigned int max_pctg = 0;
  61         unsigned long min, max;
  62
  63         printf(_("          minimum CPU frequency  -  maximum CPU frequency  -  governor\n"));
  64
  65         nr_cpus = count_cpus();
  66         for (cpu = 0; cpu < nr_cpus; cpu++) {
  67                 policy = cpufreq_get_policy(cpu);
  68                 if (!policy)
  69                         continue;
  70
  71                 if (cpufreq_get_hardware_limits(cpu, &min, &max)) {
  72                         max = 0;
  73                 } else {
  74                         min_pctg = (policy->min * 100) / max;
  75                         max_pctg = (policy->max * 100) / max;
  76                 }
  77                 printf("CPU%3d    %9lu kHz (%3d %%)  -  %9lu kHz (%3d %%)  -  %s\n",
  78                         cpu , policy->min, max ? min_pctg : 0, policy->max,
  79                         max ? max_pctg : 0, policy->governor);
  80
  81                 cpufreq_put_policy(policy);
  82         }
  83 }
  84
  85 static void print_speed(unsigned long speed)
  86 {
  87         unsigned long tmp;
  88
  89         if (speed > 1000000) {
  90                 tmp = speed % 10000;
  91                 if (tmp >= 5000)
  92                         speed += 10000;
  93                 printf("%u.%02u GHz", ((unsigned int) speed/1000000),
  94                         ((unsigned int) (speed%1000000)/10000));
  95         } else if (speed > 100000) {
  96                 tmp = speed % 1000;
  97                 if (tmp >= 500)
  98                         speed += 1000;
  99                 printf("%u MHz", ((unsigned int) speed / 1000));
 100         } else if (speed > 1000) {
 101                 tmp = speed % 100;
 102                 if (tmp >= 50)
 103                         speed += 100;
 104                 printf("%u.%01u MHz", ((unsigned int) speed/1000),
 105                         ((unsigned int) (speed%1000)/100));
 106         } else
 107                 printf("%lu kHz", speed);
 108
 109         return;
 110 }
 111
 112 static void print_duration(unsigned long duration)
 113 {
 114         unsigned long tmp;
 115
 116         if (duration > 1000000) {
 117                 tmp = duration % 10000;
 118                 if (tmp >= 5000)
 119                         duration += 10000;
 120                 printf("%u.%02u ms", ((unsigned int) duration/1000000),
 121                         ((unsigned int) (duration%1000000)/10000));
 122         } else if (duration > 100000) {
 123                 tmp = duration % 1000;
 124                 if (tmp >= 500)
 125                         duration += 1000;
 126                 printf("%u us", ((unsigned int) duration / 1000));
 127         } else if (duration > 1000) {
 128                 tmp = duration % 100;
 129                 if (tmp >= 50)
 130                         duration += 100;
 131                 printf("%u.%01u us", ((unsigned int) duration/1000),
 132                         ((unsigned int) (duration%1000)/100));
 133         } else
 134                 printf("%lu ns", duration);
 135
 136         return;
 137 }
 138
 139 /* --boost / -b */
 140
 141 static int get_boost_mode(unsigned int cpu)
 142 {
 143         int support, active, b_states = 0, ret, pstate_no, i;
 144         /* ToDo: Make this more global */
 145         unsigned long pstates[MAX_HW_PSTATES] = {0,};
 146
 147         if (cpupower_cpu_info.vendor != X86_VENDOR_AMD &&
 148             cpupower_cpu_info.vendor != X86_VENDOR_INTEL)
 149                 return 0;
 150
 151         ret = cpufreq_has_boost_support(cpu, &support, &active, &b_states);
 152         if (ret) {
 153                 printf(_("Error while evaluating Boost Capabilities"
 154                                 " on CPU %d -- are you root?\n"), cpu);
 155                 return ret;
 156         }
 157         /* P state changes via MSR are identified via cpuid 80000007
 158            on Intel and AMD, but we assume boost capable machines can do that
 159            if (cpuid_eax(0x80000000) >= 0x80000007
 160            && (cpuid_edx(0x80000007) & (1 << 7)))
 161         */
 162
 163         printf(_("  boost state support:\n"));
 164
 165         printf(_("    Supported: %s\n"), support ? _("yes") : _("no"));
 166         printf(_("    Active: %s\n"), active ? _("yes") : _("no"));
 167
 168         if (cpupower_cpu_info.vendor == X86_VENDOR_AMD &&
 169             cpupower_cpu_info.family >= 0x10) {
 170                 ret = decode_pstates(cpu, cpupower_cpu_info.family, b_states,
 171                                      pstates, &pstate_no);
 172                 if (ret)
 173                         return ret;
 174
 175                 printf(_("    Boost States: %d\n"), b_states);
 176                 printf(_("    Total States: %d\n"), pstate_no);
 177                 for (i = 0; i < pstate_no; i++) {
 178                         if (i < b_states)
 179                                 printf(_("    Pstate-Pb%d: %luMHz (boost state)"
 180                                          "\n"), i, pstates[i]);
 181                         else
 182                                 printf(_("    Pstate-P%d:  %luMHz\n"),
 183                                        i - b_states, pstates[i]);
 184                 }
 185         } else if (cpupower_cpu_info.caps & CPUPOWER_CAP_HAS_TURBO_RATIO) {
 186                 double bclk;
 187                 unsigned long long intel_turbo_ratio = 0;
 188                 unsigned int ratio;
 189
 190                 /* Any way to autodetect this ? */
 191                 if (cpupower_cpu_info.caps & CPUPOWER_CAP_IS_SNB)
 192                         bclk = 100.00;
 193                 else
 194                         bclk = 133.33;
 195                 intel_turbo_ratio = msr_intel_get_turbo_ratio(cpu);
 196                 dprint ("    Ratio: 0x%llx - bclk: %f\n",
 197                         intel_turbo_ratio, bclk);
 198
 199                 ratio = (intel_turbo_ratio >> 24) & 0xFF;
 200                 if (ratio)
 201                         printf(_("    %.0f MHz max turbo 4 active cores\n"),
 202                                ratio * bclk);
 203
 204                 ratio = (intel_turbo_ratio >> 16) & 0xFF;
 205                 if (ratio)
 206                         printf(_("    %.0f MHz max turbo 3 active cores\n"),
 207                                ratio * bclk);
 208
 209                 ratio = (intel_turbo_ratio >> 8) & 0xFF;
 210                 if (ratio)
 211                         printf(_("    %.0f MHz max turbo 2 active cores\n"),
 212                                ratio * bclk);
 213
 214                 ratio = (intel_turbo_ratio >> 0) & 0xFF;
 215                 if (ratio)
 216                         printf(_("    %.0f MHz max turbo 1 active cores\n"),
 217                                ratio * bclk);
 218         }
 219         return 0;
 220 }
 221
 222 static void debug_output_one(unsigned int cpu)
 223 {
 224         char *driver;
 225         struct cpufreq_affected_cpus *cpus;
 226         struct cpufreq_available_frequencies *freqs;
 227         unsigned long min, max, freq_kernel, freq_hardware;
 228         unsigned long total_trans, latency;
 229         unsigned long long total_time;
 230         struct cpufreq_policy *policy;
 231         struct cpufreq_available_governors *governors;
 232         struct cpufreq_stats *stats;
 233
 234         if (cpufreq_cpu_exists(cpu))
 235                 return;
 236
 237         freq_kernel = cpufreq_get_freq_kernel(cpu);
 238         freq_hardware = cpufreq_get_freq_hardware(cpu);
 239
 240         driver = cpufreq_get_driver(cpu);
 241         if (!driver) {
 242                 printf(_("  no or unknown cpufreq driver is active on this CPU\n"));
 243         } else {
 244                 printf(_("  driver: %s\n"), driver);
 245                 cpufreq_put_driver(driver);
 246         }
 247
 248         cpus = cpufreq_get_related_cpus(cpu);
 249         if (cpus) {
 250                 printf(_("  CPUs which run at the same hardware frequency: "));
 251                 while (cpus->next) {
 252                         printf("%d ", cpus->cpu);
 253                         cpus = cpus->next;
 254                 }
 255                 printf("%d\n", cpus->cpu);
 256                 cpufreq_put_related_cpus(cpus);
 257         }
 258
 259         cpus = cpufreq_get_affected_cpus(cpu);
 260         if (cpus) {
 261                 printf(_("  CPUs which need to have their frequency coordinated by software: "));
 262                 while (cpus->next) {
 263                         printf("%d ", cpus->cpu);
 264                         cpus = cpus->next;
 265                 }
 266                 printf("%d\n", cpus->cpu);
 267                 cpufreq_put_affected_cpus(cpus);
 268         }
 269
 270         latency = cpufreq_get_transition_latency(cpu);
 271         if (latency) {
 272                 printf(_("  maximum transition latency: "));
 273                 print_duration(latency);
 274                 printf(".\n");
 275         }
 276
 277         if (!(cpufreq_get_hardware_limits(cpu, &min, &max))) {
 278                 printf(_("  hardware limits: "));
 279                 print_speed(min);
 280                 printf(" - ");
 281                 print_speed(max);
 282                 printf("\n");
 283         }
 284
 285         freqs = cpufreq_get_available_frequencies(cpu);
 286         if (freqs) {
 287                 printf(_("  available frequency steps: "));
 288                 while (freqs->next) {
 289                         print_speed(freqs->frequency);
 290                         printf(", ");
 291                         freqs = freqs->next;
 292                 }
 293                 print_speed(freqs->frequency);
 294                 printf("\n");
 295                 cpufreq_put_available_frequencies(freqs);
 296         }
 297
 298         governors = cpufreq_get_available_governors(cpu);
 299         if (governors) {
 300                 printf(_("  available cpufreq governors: "));
 301                 while (governors->next) {
 302                         printf("%s, ", governors->governor);
 303                         governors = governors->next;
 304                 }
 305                 printf("%s\n", governors->governor);
 306                 cpufreq_put_available_governors(governors);
 307         }
 308
 309         policy = cpufreq_get_policy(cpu);
 310         if (policy) {
 311                 printf(_("  current policy: frequency should be within "));
 312                 print_speed(policy->min);
 313                 printf(_(" and "));
 314                 print_speed(policy->max);
 315
 316                 printf(".\n                  ");
 317                 printf(_("The governor \"%s\" may"
 318                        " decide which speed to use\n                  within this range.\n"),
 319                        policy->governor);
 320                 cpufreq_put_policy(policy);
 321         }
 322
 323         if (freq_kernel || freq_hardware) {
 324                 printf(_("  current CPU frequency is "));
 325                 if (freq_hardware) {
 326                         print_speed(freq_hardware);
 327                         printf(_(" (asserted by call to hardware)"));
 328                 } else
 329                         print_speed(freq_kernel);
 330                 printf(".\n");
 331         }
 332         stats = cpufreq_get_stats(cpu, &total_time);
 333         if (stats) {
 334                 printf(_("  cpufreq stats: "));
 335                 while (stats) {
 336                         print_speed(stats->frequency);
 337                         printf(":%.2f%%", (100.0 * stats->time_in_state) / total_time);
 338                         stats = stats->next;
 339                         if (stats)
 340                                 printf(", ");
 341                 }
 342                 cpufreq_put_stats(stats);
 343                 total_trans = cpufreq_get_transitions(cpu);
 344                 if (total_trans)
 345                         printf("  (%lu)\n", total_trans);
 346                 else
 347                         printf("\n");
 348         }
 349         get_boost_mode(cpu);
 350
 351 }
 352
 353 /* --freq / -f */
 354
 355 static int get_freq_kernel(unsigned int cpu, unsigned int human)
 356 {
 357         unsigned long freq = cpufreq_get_freq_kernel(cpu);
 358         if (!freq)
 359                 return -EINVAL;
 360         if (human) {
 361                 print_speed(freq);
 362                 printf("\n");
 363         } else
 364                 printf("%lu\n", freq);
 365         return 0;
 366 }
 367
 368
 369 /* --hwfreq / -w */
 370
 371 static int get_freq_hardware(unsigned int cpu, unsigned int human)
 372 {
 373         unsigned long freq = cpufreq_get_freq_hardware(cpu);
 374         if (!freq)
 375                 return -EINVAL;
 376         if (human) {
 377                 print_speed(freq);
 378                 printf("\n");
 379         } else
 380                 printf("%lu\n", freq);
 381         return 0;
 382 }
 383
 384 /* --hwlimits / -l */
 385
 386 static int get_hardware_limits(unsigned int cpu)
 387 {
 388         unsigned long min, max;
 389         if (cpufreq_get_hardware_limits(cpu, &min, &max))
 390                 return -EINVAL;
 391         printf("%lu %lu\n", min, max);
 392         return 0;
 393 }
 394
 395 /* --driver / -d */
 396
 397 static int get_driver(unsigned int cpu)
 398 {
 399         char *driver = cpufreq_get_driver(cpu);
 400         if (!driver)
 401                 return -EINVAL;
 402         printf("%s\n", driver);
 403         cpufreq_put_driver(driver);
 404         return 0;
 405 }
 406
 407 /* --policy / -p */
 408
 409 static int get_policy(unsigned int cpu)
 410 {
 411         struct cpufreq_policy *policy = cpufreq_get_policy(cpu);
 412         if (!policy)
 413                 return -EINVAL;
 414         printf("%lu %lu %s\n", policy->min, policy->max, policy->governor);
 415         cpufreq_put_policy(policy);
 416         return 0;
 417 }
 418
 419 /* --governors / -g */
 420
 421 static int get_available_governors(unsigned int cpu)
 422 {
 423         struct cpufreq_available_governors *governors =
 424                 cpufreq_get_available_governors(cpu);
 425         if (!governors)
 426                 return -EINVAL;
 427
 428         while (governors->next) {
 429                 printf("%s ", governors->governor);
 430                 governors = governors->next;
 431         }
 432         printf("%s\n", governors->governor);
 433         cpufreq_put_available_governors(governors);
 434         return 0;
 435 }
 436
 437
 438 /* --affected-cpus  / -a */
 439
 440 static int get_affected_cpus(unsigned int cpu)
 441 {
 442         struct cpufreq_affected_cpus *cpus = cpufreq_get_affected_cpus(cpu);
 443         if (!cpus)
 444                 return -EINVAL;
 445
 446         while (cpus->next) {
 447                 printf("%d ", cpus->cpu);
 448                 cpus = cpus->next;
 449         }
 450         printf("%d\n", cpus->cpu);
 451         cpufreq_put_affected_cpus(cpus);
 452         return 0;
 453 }
 454
 455 /* --related-cpus  / -r */
 456
 457 static int get_related_cpus(unsigned int cpu)
 458 {
 459         struct cpufreq_affected_cpus *cpus = cpufreq_get_related_cpus(cpu);
 460         if (!cpus)
 461                 return -EINVAL;
 462
 463         while (cpus->next) {
 464                 printf("%d ", cpus->cpu);
 465                 cpus = cpus->next;
 466         }
 467         printf("%d\n", cpus->cpu);
 468         cpufreq_put_related_cpus(cpus);
 469         return 0;
 470 }
 471
 472 /* --stats / -s */
 473
 474 static int get_freq_stats(unsigned int cpu, unsigned int human)
 475 {
 476         unsigned long total_trans = cpufreq_get_transitions(cpu);
 477         unsigned long long total_time;
 478         struct cpufreq_stats *stats = cpufreq_get_stats(cpu, &total_time);
 479         while (stats) {
 480                 if (human) {
 481                         print_speed(stats->frequency);
 482                         printf(":%.2f%%",
 483                                 (100.0 * stats->time_in_state) / total_time);
 484                 } else
 485                         printf("%lu:%llu",
 486                                 stats->frequency, stats->time_in_state);
 487                 stats = stats->next;
 488                 if (stats)
 489                         printf(", ");
 490         }
 491         cpufreq_put_stats(stats);
 492         if (total_trans)
 493                 printf("  (%lu)\n", total_trans);
 494         return 0;
 495 }
 496
 497 /* --latency / -y */
 498
 499 static int get_latency(unsigned int cpu, unsigned int human)
 500 {
 501         unsigned long latency = cpufreq_get_transition_latency(cpu);
 502         if (!latency)
 503                 return -EINVAL;
 504
 505         if (human) {
 506                 print_duration(latency);
 507                 printf("\n");
 508         } else
 509                 printf("%lu\n", latency);
 510         return 0;
 511 }
 512
 513 static struct option info_opts[] = {
 514         { .name = "debug",      .has_arg = no_argument,         .flag = NULL,   .val = 'e'},
 515         { .name = "boost",      .has_arg = no_argument,         .flag = NULL,   .val = 'b'},
 516         { .name = "freq",       .has_arg = no_argument,         .flag = NULL,   .val = 'f'},
 517         { .name = "hwfreq",     .has_arg = no_argument,         .flag = NULL,   .val = 'w'},
 518         { .name = "hwlimits",   .has_arg = no_argument,         .flag = NULL,   .val = 'l'},
 519         { .name = "driver",     .has_arg = no_argument,         .flag = NULL,   .val = 'd'},
 520         { .name = "policy",     .has_arg = no_argument,         .flag = NULL,   .val = 'p'},
 521         { .name = "governors",  .has_arg = no_argument,         .flag = NULL,   .val = 'g'},
 522         { .name = "related-cpus", .has_arg = no_argument,       .flag = NULL,   .val = 'r'},
 523         { .name = "affected-cpus",.has_arg = no_argument,       .flag = NULL,   .val = 'a'},
 524         { .name = "stats",      .has_arg = no_argument,         .flag = NULL,   .val = 's'},
 525         { .name = "latency",    .has_arg = no_argument,         .flag = NULL,   .val = 'y'},
 526         { .name = "proc",       .has_arg = no_argument,         .flag = NULL,   .val = 'o'},
 527         { .name = "human",      .has_arg = no_argument,         .flag = NULL,   .val = 'm'},
 528         { },
 529 };
 530
 531 int cmd_freq_info(int argc, char **argv)
 532 {
 533         extern char *optarg;
 534         extern int optind, opterr, optopt;
 535         int ret = 0, cont = 1;
 536         unsigned int cpu = 0;
 537         unsigned int human = 0;
 538         int output_param = 0;
 539
 540         do {
 541                 ret = getopt_long(argc, argv, "oefwldpgrasmyb", info_opts, NULL);
 542                 switch (ret) {
 543                 case '?':
 544                         output_param = '?';
 545                         cont = 0;
 546                         break;
 547                 case -1:
 548                         cont = 0;
 549                         break;
 550                 case 'b':
 551                 case 'o':
 552                 case 'a':
 553                 case 'r':
 554                 case 'g':
 555                 case 'p':
 556                 case 'd':
 557                 case 'l':
 558                 case 'w':
 559                 case 'f':
 560                 case 'e':
 561                 case 's':
 562                 case 'y':
 563                         if (output_param) {
 564                                 output_param = -1;
 565                                 cont = 0;
 566                                 break;
 567                         }
 568                         output_param = ret;
 569                         break;
 570                 case 'm':
 571                         if (human) {
 572                                 output_param = -1;
 573                                 cont = 0;
 574                                 break;
 575                         }
 576                         human = 1;
 577                         break;
 578                 default:
 579                         fprintf(stderr, "invalid or unknown argument\n");
 580                         return EXIT_FAILURE;
 581                 }
 582         } while (cont);
 583
 584         switch (output_param) {
 585         case 'o':
 586                 if (!bitmask_isallclear(cpus_chosen)) {
 587                         printf(_("The argument passed to this tool can't be "
 588                                  "combined with passing a --cpu argument\n"));
 589                         return -EINVAL;
 590                 }
 591                 break;
 592         case 0:
 593                 output_param = 'e';
 594         }
 595
 596         ret = 0;
 597
 598         /* Default is: show output of CPU 0 only */
 599         if (bitmask_isallclear(cpus_chosen))
 600                 bitmask_setbit(cpus_chosen, 0);
 601
 602         switch (output_param) {
 603         case -1:
 604                 printf(_("You can't specify more than one --cpu parameter and/or\n"
 605                        "more than one output-specific argument\n"));
 606                 return -EINVAL;
 607         case '?':
 608                 printf(_("invalid or unknown argument\n"));
 609                 return -EINVAL;
 610         case 'o':
 611                 proc_cpufreq_output();
 612                 return EXIT_SUCCESS;
 613         }
 614
 615         for (cpu = bitmask_first(cpus_chosen);
 616              cpu <= bitmask_last(cpus_chosen); cpu++) {
 617
 618                 if (!bitmask_isbitset(cpus_chosen, cpu))
 619                         continue;
 620                 if (cpufreq_cpu_exists(cpu)) {
 621                         printf(_("couldn't analyze CPU %d as it doesn't seem to be present\n"), cpu);
 622                         continue;
 623                 }
 624                 printf(_("analyzing CPU %d:\n"), cpu);
 625
 626                 switch (output_param) {
 627                 case 'b':
 628                         get_boost_mode(cpu);
 629                         break;
 630                 case 'e':
 631                         debug_output_one(cpu);
 632                         break;
 633                 case 'a':
 634                         ret = get_affected_cpus(cpu);
 635                         break;
 636                 case 'r':
 637                         ret = get_related_cpus(cpu);
 638                         break;
 639                 case 'g':
 640                         ret = get_available_governors(cpu);
 641                         break;
 642                 case 'p':
 643                         ret = get_policy(cpu);
 644                         break;
 645                 case 'd':
 646                         ret = get_driver(cpu);
 647                         break;
 648                 case 'l':
 649                         ret = get_hardware_limits(cpu);
 650                         break;
 651                 case 'w':
 652                         ret = get_freq_hardware(cpu, human);
 653                         break;
 654                 case 'f':
 655                         ret = get_freq_kernel(cpu, human);
 656                         break;
 657                 case 's':
 658                         ret = get_freq_stats(cpu, human);
 659                         break;
 660                 case 'y':
 661                         ret = get_latency(cpu, human);
 662                         break;
 663                 }
 664                 if (ret)
 665                         return ret;
 666         }
 667         return ret;
 668 }