~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/power/cpupower/utils/cpufreq-info.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 }
669 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp