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

   1 /*
   2  *  (C) 2004-2009  Dominik Brodowski <linux@dominikbrodowski.de>
   3  *  (C) 2010       Thomas Renninger <trenn@suse.de>
   4  *
   5  *  Licensed under the terms of the GNU GPL License version 2.
   6  */
   7
   8
   9 #include <unistd.h>
  10 #include <stdio.h>
  11 #include <errno.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <getopt.h>
  15 #include <cpufreq.h>
  16
  17 #include "helpers/helpers.h"
  18 #include "helpers/sysfs.h"
  19 #include "helpers/bitmask.h"
  20
  21 #define LINE_LEN 10
  22
  23 static void cpuidle_cpu_output(unsigned int cpu, int verbose)
  24 {
  25         int idlestates, idlestate;
  26         char *tmp;
  27
  28         printf(_ ("Analyzing CPU %d:\n"), cpu);
  29
  30         idlestates = sysfs_get_idlestate_count(cpu);
  31         if (idlestates == 0) {
  32                 printf(_("CPU %u: No idle states\n"), cpu);
  33                 return;
  34         } else if (idlestates <= 0) {
  35                 printf(_("CPU %u: Can't read idle state info\n"), cpu);
  36                 return;
  37         }
  38         printf(_("Number of idle states: %d\n"), idlestates);
  39         printf(_("Available idle states:"));
  40         for (idlestate = 0; idlestate < idlestates; idlestate++) {
  41                 tmp = sysfs_get_idlestate_name(cpu, idlestate);
  42                 if (!tmp)
  43                         continue;
  44                 printf(" %s", tmp);
  45                 free(tmp);
  46         }
  47         printf("\n");
  48
  49         if (!verbose)
  50                 return;
  51
  52         for (idlestate = 0; idlestate < idlestates; idlestate++) {
  53                 tmp = sysfs_get_idlestate_name(cpu, idlestate);
  54                 if (!tmp)
  55                         continue;
  56                 printf("%s:\n", tmp);
  57                 free(tmp);
  58
  59                 tmp = sysfs_get_idlestate_desc(cpu, idlestate);
  60                 if (!tmp)
  61                         continue;
  62                 printf(_("Flags/Description: %s\n"), tmp);
  63                 free(tmp);
  64
  65                 printf(_("Latency: %lu\n"),
  66                        sysfs_get_idlestate_latency(cpu, idlestate));
  67                 printf(_("Usage: %lu\n"),
  68                        sysfs_get_idlestate_usage(cpu, idlestate));
  69                 printf(_("Duration: %llu\n"),
  70                        sysfs_get_idlestate_time(cpu, idlestate));
  71         }
  72         printf("\n");
  73 }
  74
  75 static void cpuidle_general_output(void)
  76 {
  77         char *tmp;
  78
  79         tmp = sysfs_get_cpuidle_driver();
  80         if (!tmp) {
  81                 printf(_("Could not determine cpuidle driver\n"));
  82                 return;
  83         }
  84
  85         printf(_("CPUidle driver: %s\n"), tmp);
  86         free(tmp);
  87
  88         tmp = sysfs_get_cpuidle_governor();
  89         if (!tmp) {
  90                 printf(_("Could not determine cpuidle governor\n"));
  91                 return;
  92         }
  93
  94         printf(_("CPUidle governor: %s\n"), tmp);
  95         free(tmp);
  96 }
  97
  98 static void proc_cpuidle_cpu_output(unsigned int cpu)
  99 {
 100         long max_allowed_cstate = 2000000000;
 101         int cstates, cstate;
 102
 103         cstates = sysfs_get_idlestate_count(cpu);
 104         if (cstates == 0) {
 105                 /*
 106                  * Go on and print same useless info as you'd see with
 107                  * cat /proc/acpi/processor/../power
 108                  *      printf(_("CPU %u: No C-states available\n"), cpu);
 109                  *      return;
 110                  */
 111         } else if (cstates <= 0) {
 112                 printf(_("CPU %u: Can't read C-state info\n"), cpu);
 113                 return;
 114         }
 115         /* printf("Cstates: %d\n", cstates); */
 116
 117         printf(_("active state:            C0\n"));
 118         printf(_("max_cstate:              C%u\n"), cstates-1);
 119         printf(_("maximum allowed latency: %lu usec\n"), max_allowed_cstate);
 120         printf(_("states:\t\n"));
 121         for (cstate = 1; cstate < cstates; cstate++) {
 122                 printf(_("    C%d:                  "
 123                          "type[C%d] "), cstate, cstate);
 124                 printf(_("promotion[--] demotion[--] "));
 125                 printf(_("latency[%03lu] "),
 126                        sysfs_get_idlestate_latency(cpu, cstate));
 127                 printf(_("usage[%08lu] "),
 128                        sysfs_get_idlestate_usage(cpu, cstate));
 129                 printf(_("duration[%020Lu] \n"),
 130                        sysfs_get_idlestate_time(cpu, cstate));
 131         }
 132 }
 133
 134 static struct option info_opts[] = {
 135         { .name = "silent",     .has_arg = no_argument, .flag = NULL,   .val = 's'},
 136         { .name = "proc",       .has_arg = no_argument, .flag = NULL,   .val = 'o'},
 137         { },
 138 };
 139
 140 static inline void cpuidle_exit(int fail)
 141 {
 142         exit(EXIT_FAILURE);
 143 }
 144
 145 int cmd_idle_info(int argc, char **argv)
 146 {
 147         extern char *optarg;
 148         extern int optind, opterr, optopt;
 149         int ret = 0, cont = 1, output_param = 0, verbose = 1;
 150         unsigned int cpu = 0;
 151
 152         do {
 153                 ret = getopt_long(argc, argv, "os", info_opts, NULL);
 154                 if (ret == -1)
 155                         break;
 156                 switch (ret) {
 157                 case '?':
 158                         output_param = '?';
 159                         cont = 0;
 160                         break;
 161                 case 's':
 162                         verbose = 0;
 163                         break;
 164                 case -1:
 165                         cont = 0;
 166                         break;
 167                 case 'o':
 168                         if (output_param) {
 169                                 output_param = -1;
 170                                 cont = 0;
 171                                 break;
 172                         }
 173                         output_param = ret;
 174                         break;
 175                 }
 176         } while (cont);
 177
 178         switch (output_param) {
 179         case -1:
 180                 printf(_("You can't specify more than one "
 181                          "output-specific argument\n"));
 182                 cpuidle_exit(EXIT_FAILURE);
 183         case '?':
 184                 printf(_("invalid or unknown argument\n"));
 185                 cpuidle_exit(EXIT_FAILURE);
 186         }
 187
 188         /* Default is: show output of CPU 0 only */
 189         if (bitmask_isallclear(cpus_chosen))
 190                 bitmask_setbit(cpus_chosen, 0);
 191
 192         if (output_param == 0)
 193                 cpuidle_general_output();
 194
 195         for (cpu = bitmask_first(cpus_chosen);
 196              cpu <= bitmask_last(cpus_chosen); cpu++) {
 197
 198                 if (!bitmask_isbitset(cpus_chosen, cpu) ||
 199                     cpufreq_cpu_exists(cpu))
 200                         continue;
 201
 202                 switch (output_param) {
 203
 204                 case 'o':
 205                         proc_cpuidle_cpu_output(cpu);
 206                         break;
 207                 case 0:
 208                         printf("\n");
 209                         cpuidle_cpu_output(cpu, verbose);
 210                         break;
 211                 }
 212         }
 213         return EXIT_SUCCESS;
 214 }