cpuidle-set.c   Interaktion und
PortierbarkeitC

// SPDX-License-Identifier: GPL-2.0
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <ctype.h>
#include <getopt.h>

#include <cpufreq.h>
#include <cpuidle.h>

#include "helpers/helpers.h"

static struct option info_opts[] = {
     {"disable", required_argument,  NULL, 'd'},
     {"enable",  required_argument,  NULL, 'e'},
     {"disable-by-latency", required_argument,  NULL, 'D'},
     {"enable-all", no_argument,   NULL, 'E'},
     { },
};


int cmd_idle_set(int argc, char **argv)
{
 extern char *optarg;
 extern int optind, opterr, optopt;
 int ret = 0, cont = 1, param = 0, disabled;
 unsigned long long latency = 0, state_latency;
 unsigned int cpu = 0, idlestate = 0, idlestates = 0;
 char *endptr;

 do {
  ret = getopt_long(argc, argv, "d:e:ED:", info_opts, NULL);
  if (ret == -1)
   break;
  switch (ret) {
  case '?':
   param = '?';
   cont = 0;
   break;
  case 'd':
  case 'e':
   if (param) {
    param = -1;
    cont = 0;
    break;
   }
   param = ret;
   strtol(optarg, &endptr, 10);
   if (*endptr != '\0') {
    printf(_("Bad value: %s, Integer expected\n"), optarg);
    exit(EXIT_FAILURE);
   } else {
    idlestate = atoi(optarg);
   }
   break;
  case 'D':
   if (param) {
    param = -1;
    cont = 0;
    break;
   }
   param = ret;
   latency = strtoull(optarg, &endptr, 10);
   if (*endptr != '\0') {
    printf(_("Bad latency value: %s\n"), optarg);
    exit(EXIT_FAILURE);
   }
   break;
  case 'E':
   if (param) {
    param = -1;
    cont = 0;
    break;
   }
   param = ret;
   break;
  case -1:
   cont = 0;
   break;
  }
 } while (cont);

 switch (param) {
 case -1:
  printf(_("You can't specify more than one "
    "output-specific argument\n"));
  exit(EXIT_FAILURE);
 case '?':
  printf(_("invalid or unknown argument\n"));
  exit(EXIT_FAILURE);
 }

 get_cpustate();

 /* Default is: set all CPUs */
 if (bitmask_isallclear(cpus_chosen))
  bitmask_setall(cpus_chosen);

 for (cpu = bitmask_first(cpus_chosen);
      cpu <= bitmask_last(cpus_chosen); cpu++) {

  if (!bitmask_isbitset(cpus_chosen, cpu))
   continue;

  if (cpupower_is_cpu_online(cpu) != 1)
   continue;

  idlestates = cpuidle_state_count(cpu);
  if (idlestates <= 0)
   continue;

  switch (param) {
  case 'd':
   ret = cpuidle_state_disable(cpu, idlestate, 1);
   if (ret == 0)
  printf(_("Idlestate %u disabled on CPU %u\n"),  idlestate, cpu);
   else if (ret == -1)
  printf(_("Idlestate %u not available on CPU %u\n"),
         idlestate, cpu);
   else if (ret == -2)
  printf(_("Idlestate disabling not supported by kernel\n"));
   else
  printf(_("Idlestate %u not disabled on CPU %u\n"),
         idlestate, cpu);
   break;
  case 'e':
   ret = cpuidle_state_disable(cpu, idlestate, 0);
   if (ret == 0)
  printf(_("Idlestate %u enabled on CPU %u\n"),  idlestate, cpu);
   else if (ret == -1)
  printf(_("Idlestate %u not available on CPU %u\n"),
         idlestate, cpu);
   else if (ret == -2)
  printf(_("Idlestate enabling not supported by kernel\n"));
   else
  printf(_("Idlestate %u not enabled on CPU %u\n"),
         idlestate, cpu);
   break;
  case 'D':
   for (idlestate = 0; idlestate < idlestates; idlestate++) {
    disabled = cpuidle_is_state_disabled
     (cpu, idlestate);
    state_latency = cpuidle_state_latency
     (cpu, idlestate);
    if (disabled == 1) {
     if (latency > state_latency){
      ret = cpuidle_state_disable
       (cpu, idlestate, 0);
      if (ret == 0)
  printf(_("Idlestate %u enabled on CPU %u\n"),  idlestate, cpu);
     }
     continue;
    }
    if (latency <= state_latency){
     ret = cpuidle_state_disable
      (cpu, idlestate, 1);
     if (ret == 0)
  printf(_("Idlestate %u disabled on CPU %u\n"), idlestate, cpu);
    }
   }
   break;
  case 'E':
   for (idlestate = 0; idlestate < idlestates; idlestate++) {
    disabled = cpuidle_is_state_disabled
     (cpu, idlestate);
    if (disabled == 1) {
     ret = cpuidle_state_disable
      (cpu, idlestate, 0);
     if (ret == 0)
  printf(_("Idlestate %u enabled on CPU %u\n"), idlestate, cpu);
    }
   }
   break;
  default:
   /* Not reachable with proper args checking */
   printf(_("Invalid or unknown argument\n"));
   exit(EXIT_FAILURE);
   break;
  }
 }

 print_offline_cpus();
 return EXIT_SUCCESS;
}