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