static void proc_cpuidle_cpu_output(unsigned int cpu) { long max_allowed_cstate = 2000000000; int cstates, cstate; cstates = sysfs_get_idlestate_count(cpu); if (cstates == 0) { /* * Go on and print same useless info as you'd see with * cat /proc/acpi/processor/../power * printf(_("CPU %u: No C-states available\n"), cpu); * return; */ } else if (cstates <= 0) { printf(_("CPU %u: Can't read C-state info\n"), cpu); return; } /* printf("Cstates: %d\n", cstates); */ printf(_("active state: C0\n")); printf(_("max_cstate: C%u\n"), cstates-1); printf(_("maximum allowed latency: %lu usec\n"), max_allowed_cstate); printf(_("states:\t\n")); for (cstate = 1; cstate < cstates; cstate++) { printf(_(" C%d: " "type[C%d] "), cstate, cstate); printf(_("promotion[--] demotion[--] ")); printf(_("latency[%03lu] "), sysfs_get_idlestate_latency(cpu, cstate)); printf(_("usage[%08lu] "), sysfs_get_idlestate_usage(cpu, cstate)); printf(_("duration[%020Lu] \n"), sysfs_get_idlestate_time(cpu, cstate)); } }
static void proc_cpuidle_cpu_output(unsigned int cpu) { long max_allowed_cstate = 2000000000; int cstate, cstates; cstates = sysfs_get_idlestate_count(cpu); if (cstates < 1) { printf(_("CPU %u: No C-states info\n"), cpu); return; } printf(_("active state: C0\n")); printf(_("max_cstate: C%u\n"), cstates-1); printf(_("maximum allowed latency: %lu usec\n"), max_allowed_cstate); printf(_("states:\t\n")); for (cstate = 1; cstate < cstates; cstate++) { printf(_(" C%d: " "type[C%d] "), cstate, cstate); printf(_("promotion[--] demotion[--] ")); printf(_("latency[%03lu] "), sysfs_get_idlestate_latency(cpu, cstate)); printf(_("usage[%08lu] "), sysfs_get_idlestate_usage(cpu, cstate)); printf(_("duration[%020Lu] \n"), sysfs_get_idlestate_time(cpu, cstate)); } }
static void cpuidle_cpu_output(unsigned int cpu, int verbose) { int idlestates, idlestate; char *tmp; printf(_ ("Analyzing CPU %d:\n"), cpu); idlestates = sysfs_get_idlestate_count(cpu); if (idlestates == 0) { printf(_("CPU %u: No idle states\n"), cpu); return; } else if (idlestates <= 0) { printf(_("CPU %u: Can't read idle state info\n"), cpu); return; } tmp = sysfs_get_idlestate_name(cpu, idlestates - 1); if (!tmp) { printf(_("Could not determine max idle state %u\n"), idlestates - 1); return; } printf(_("Number of idle states: %d\n"), idlestates); printf(_("Available idle states:")); for (idlestate = 1; idlestate < idlestates; idlestate++) { tmp = sysfs_get_idlestate_name(cpu, idlestate); if (!tmp) continue; printf(" %s", tmp); free(tmp); } printf("\n"); if (!verbose) return; for (idlestate = 1; idlestate < idlestates; idlestate++) { tmp = sysfs_get_idlestate_name(cpu, idlestate); if (!tmp) continue; printf("%s:\n", tmp); free(tmp); tmp = sysfs_get_idlestate_desc(cpu, idlestate); if (!tmp) continue; printf(_("Flags/Description: %s\n"), tmp); free(tmp); printf(_("Latency: %lu\n"), sysfs_get_idlestate_latency(cpu, idlestate)); printf(_("Usage: %lu\n"), sysfs_get_idlestate_usage(cpu, idlestate)); printf(_("Duration: %llu\n"), sysfs_get_idlestate_time(cpu, idlestate)); } printf("\n"); }
/* * Returns: * 1 if disabled * 0 if enabled * -1 if idlestate is not available * -2 if disabling is not supported by the kernel */ int sysfs_is_idlestate_disabled(unsigned int cpu, unsigned int idlestate) { if (sysfs_get_idlestate_count(cpu) <= idlestate) return -1; if (!sysfs_idlestate_file_exists(cpu, idlestate, idlestate_value_files[IDLESTATE_DISABLE])) return -2; return sysfs_idlestate_get_one_value(cpu, idlestate, IDLESTATE_DISABLE); }
static void cpuidle_cpu_output(unsigned int cpu, int verbose) { int idlestates, idlestate; char *tmp; printf(_ ("Analyzing CPU %d:\n"), cpu); idlestates = sysfs_get_idlestate_count(cpu); if (idlestates < 1) { printf(_("CPU %u: No idle states\n"), cpu); return; } printf(_("Number of idle states: %d\n"), idlestates); printf(_("Available idle states:")); for (idlestate = 0; idlestate < idlestates; idlestate++) { tmp = sysfs_get_idlestate_name(cpu, idlestate); if (!tmp) continue; printf(" %s", tmp); free(tmp); } printf("\n"); if (!verbose) return; for (idlestate = 0; idlestate < idlestates; idlestate++) { int disabled = sysfs_is_idlestate_disabled(cpu, idlestate); /* Disabled interface not supported on older kernels */ if (disabled < 0) disabled = 0; tmp = sysfs_get_idlestate_name(cpu, idlestate); if (!tmp) continue; printf("%s%s:\n", tmp, (disabled) ? " (DISABLED) " : ""); free(tmp); tmp = sysfs_get_idlestate_desc(cpu, idlestate); if (!tmp) continue; printf(_("Flags/Description: %s\n"), tmp); free(tmp); printf(_("Latency: %lu\n"), sysfs_get_idlestate_latency(cpu, idlestate)); printf(_("Usage: %lu\n"), sysfs_get_idlestate_usage(cpu, idlestate)); printf(_("Duration: %llu\n"), sysfs_get_idlestate_time(cpu, idlestate)); } printf("\n"); }
static struct cpuidle_monitor *cpuidle_register(void) { int num; char *tmp; /* */ cpuidle_sysfs_monitor.hw_states_num = sysfs_get_idlestate_count(0); if (cpuidle_sysfs_monitor.hw_states_num <= 0) return NULL; for (num = 0; num < cpuidle_sysfs_monitor.hw_states_num; num++) { tmp = sysfs_get_idlestate_name(0, num); if (tmp == NULL) continue; fix_up_intel_idle_driver_name(tmp, num); strncpy(cpuidle_cstates[num].name, tmp, CSTATE_NAME_LEN - 1); free(tmp); tmp = sysfs_get_idlestate_desc(0, num); if (tmp == NULL) continue; strncpy(cpuidle_cstates[num].desc, tmp, CSTATE_DESC_LEN - 1); free(tmp); cpuidle_cstates[num].range = RANGE_THREAD; cpuidle_cstates[num].id = num; cpuidle_cstates[num].get_count_percent = cpuidle_get_count_percent; }; /* */ previous_count = malloc(sizeof(long long *) * cpu_count); current_count = malloc(sizeof(long long *) * cpu_count); for (num = 0; num < cpu_count; num++) { previous_count[num] = malloc(sizeof(long long) * cpuidle_sysfs_monitor.hw_states_num); current_count[num] = malloc(sizeof(long long) * cpuidle_sysfs_monitor.hw_states_num); } cpuidle_sysfs_monitor.name_len = strlen(cpuidle_sysfs_monitor.name); return &cpuidle_sysfs_monitor; }
/* * Pass 1 as last argument to disable or 0 to enable the state * Returns: * 0 on success * negative values on error, for example: * -1 if idlestate is not available * -2 if disabling is not supported by the kernel * -3 No write access to disable/enable C-states */ int sysfs_idlestate_disable(unsigned int cpu, unsigned int idlestate, unsigned int disable) { char value[SYSFS_PATH_MAX]; int bytes_written; if (sysfs_get_idlestate_count(cpu) <= idlestate) return -1; if (!sysfs_idlestate_file_exists(cpu, idlestate, idlestate_value_files[IDLESTATE_DISABLE])) return -2; snprintf(value, SYSFS_PATH_MAX, "%u", disable); bytes_written = sysfs_idlestate_write_file(cpu, idlestate, "disable", value, sizeof(disable)); if (bytes_written) return 0; return -3; }