utils/info.c

/*
 *  (C) 2004-2009  Dominik Brodowski <linux@dominikbrodowski.de>
 *
 *  Licensed under the terms of the GNU GPL License version 2.
 */


#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>

#include <getopt.h>

#include "cpufreq.h"


#ifdef NLS
#include <libintl.h>
#define _(String) gettext (String)
#define gettext_noop(String) String
#define N_(String) gettext_noop (String)
#else
#define gettext_noop(String) String
#define _(String) gettext_noop (String)
#define gettext(String) gettext_noop (String)
#define N_(String) gettext_noop (String)
#define textdomain(String)
#endif

#define LINE_LEN 10

static unsigned int count_cpus(void)
{
	FILE *fp;
	char value[LINE_LEN];
	unsigned int ret = 0;
	unsigned int cpunr = 0;

	fp = fopen("/proc/stat", "r");
	if(!fp) {
		printf(gettext("Couldn't count the number of CPUs (%s: %s), assuming 1\n"), "/proc/stat", strerror(errno));
		return 1;
	}

	while (!feof(fp)) {
		if (!fgets(value, LINE_LEN, fp))
			continue;
		value[LINE_LEN - 1] = '\0';
		if (strlen(value) < (LINE_LEN - 2))
			continue;
		if (strstr(value, "cpu "))
			continue;
		if (sscanf(value, "cpu%d ", &cpunr) != 1)
			continue;
		if (cpunr > ret)
			ret = cpunr;
	}
	fclose(fp);

	/* cpu count starts from 0, on error return 1 (UP) */
	return (ret+1);
}


static void proc_cpufreq_output(void)
{
	unsigned int cpu, nr_cpus;
	struct cpufreq_policy *policy;
	unsigned int min_pctg = 0;
	unsigned int max_pctg = 0;
	unsigned long min, max;

	printf(gettext("          minimum CPU frequency  -  maximum CPU frequency  -  governor\n"));

	nr_cpus = count_cpus();
	for (cpu=0; cpu < nr_cpus; cpu++) {
		policy = cpufreq_get_policy(cpu);
		if (!policy)
			continue;

		if (cpufreq_get_hardware_limits(cpu, &min, &max)) {
			max = 0;
		} else {
			min_pctg = (policy->min * 100) / max;
			max_pctg = (policy->max * 100) / max;
		}
		printf("CPU%3d    %9lu kHz (%3d %%)  -  %9lu kHz (%3d %%)  -  %s\n",
		       cpu , policy->min, max ? min_pctg : 0, policy->max, max ? max_pctg : 0, policy->governor);

		cpufreq_put_policy(policy);
	}
}

static void print_speed(unsigned long speed)
{
	unsigned long tmp;

	if (speed > 1000000) {
		tmp = speed % 10000;
		if (tmp >= 5000)
			speed += 10000;
		printf ("%u.%02u GHz", ((unsigned int) speed/1000000),
			((unsigned int) (speed%1000000)/10000));
	} else if (speed > 100000) {
		tmp = speed % 1000;
		if (tmp >= 500)
			speed += 1000;
		printf ("%u MHz", ((unsigned int) speed / 1000));
	} else if (speed > 1000) {
		tmp = speed % 100;
		if (tmp >= 50)
			speed += 100;
		printf ("%u.%01u MHz", ((unsigned int) speed/1000),
			((unsigned int) (speed%1000)/100));
	} else
		printf ("%lu kHz", speed);

	return;
}

static void print_duration(unsigned long duration)
{
	unsigned long tmp;

	if (duration > 1000000) {
		tmp = duration % 10000;
		if (tmp >= 5000)
			duration += 10000;
		printf ("%u.%02u ms", ((unsigned int) duration/1000000),
			((unsigned int) (duration%1000000)/10000));
	} else if (duration > 100000) {
		tmp = duration % 1000;
		if (tmp >= 500)
			duration += 1000;
		printf ("%u us", ((unsigned int) duration / 1000));
	} else if (duration > 1000) {
		tmp = duration % 100;
		if (tmp >= 50)
			duration += 100;
		printf ("%u.%01u us", ((unsigned int) duration/1000),
			((unsigned int) (duration%1000)/100));
	} else
		printf ("%lu ns", duration);

	return;
}

static void debug_output_one(unsigned int cpu)
{
	char *driver;
	struct cpufreq_affected_cpus *cpus;
	struct cpufreq_available_frequencies *freqs;
	unsigned long min, max, freq_kernel, freq_hardware;
	unsigned long total_trans, latency;
	unsigned long long total_time;
	struct cpufreq_policy *policy;
	struct cpufreq_available_governors * governors;
	struct cpufreq_stats *stats;

	if (cpufreq_cpu_exists(cpu)) {
		printf(gettext ("couldn't analyze CPU %d as it doesn't seem to be present\n"), cpu);
		return;
	}

	printf(gettext ("analyzing CPU %d:\n"), cpu);

	freq_kernel = cpufreq_get_freq_kernel(cpu);
	freq_hardware = cpufreq_get_freq_hardware(cpu);

	driver = cpufreq_get_driver(cpu);
	if (!driver) {
		printf(gettext ("  no or unknown cpufreq driver is active on this CPU\n"));
	} else {
		printf(gettext ("  driver: %s\n"), driver);
		cpufreq_put_driver(driver);
	}

	cpus = cpufreq_get_related_cpus(cpu);
	if (cpus) {
		printf(gettext ("  CPUs which run at the same hardware frequency: "));
		while (cpus->next) {
			printf("%d ", cpus->cpu);
			cpus = cpus->next;
		}
		printf("%d\n", cpus->cpu);
		cpufreq_put_related_cpus(cpus);
	}

	cpus = cpufreq_get_affected_cpus(cpu);
	if (cpus) {
		printf(gettext ("  CPUs which need to have their frequency coordinated by software: "));
		while (cpus->next) {
			printf("%d ", cpus->cpu);
			cpus = cpus->next;
		}
		printf("%d\n", cpus->cpu);
		cpufreq_put_affected_cpus(cpus);
	}

	latency = cpufreq_get_transition_latency(cpu);
	if (latency) {
		printf(gettext ("  maximum transition latency: "));
		print_duration(latency);
		printf(".\n");
	}

	if (!(cpufreq_get_hardware_limits(cpu, &min, &max))) {
		printf(gettext ("  hardware limits: "));
		print_speed(min);
		printf(" - ");
		print_speed(max);
		printf("\n");
	}

	freqs = cpufreq_get_available_frequencies(cpu);
	if (freqs) {
		printf(gettext ("  available frequency steps: "));
		while (freqs->next) {
			print_speed(freqs->frequency);
			printf(", ");
			freqs = freqs->next;
		}
		print_speed(freqs->frequency);
		printf("\n");
		cpufreq_put_available_frequencies(freqs);
	}

	governors = cpufreq_get_available_governors(cpu);
	if (governors) {
		printf(gettext ("  available cpufreq governors: "));
		while (governors->next) {
			printf("%s, ", governors->governor);
			governors = governors->next;
		}
		printf("%s\n", governors->governor);
		cpufreq_put_available_governors(governors);
	}

	policy = cpufreq_get_policy(cpu);
	if (policy) {
		printf(gettext ("  current policy: frequency should be within "));
		print_speed(policy->min);
		printf(gettext (" and "));
		print_speed(policy->max);

		printf(".\n                  ");
		printf(gettext ("The governor \"%s\" may"
		       " decide which speed to use\n                  within this range.\n"),
		       policy->governor);
		cpufreq_put_policy(policy);
	}

	if (freq_kernel || freq_hardware) {
		printf(gettext ("  current CPU frequency is "));
		if (freq_hardware) {
			print_speed(freq_hardware);
			printf(gettext (" (asserted by call to hardware)"));
		}
		else
			print_speed(freq_kernel);
		printf(".\n");
	}
	stats = cpufreq_get_stats(cpu, &total_time);
	if (stats) {
		printf(gettext ("  cpufreq stats: "));
		while (stats) {
			print_speed(stats->frequency);
			printf(":%.2f%%", (100.0 * stats->time_in_state) / total_time);
			stats = stats->next;
			if (stats)
				printf(", ");
		}
		cpufreq_put_stats(stats);
		total_trans = cpufreq_get_transitions(cpu);
		if (total_trans)
			printf("  (%lu)\n", total_trans);
		else
			printf("\n");
	}
}

static void debug_output(unsigned int cpu, unsigned int all) {
	if (all) {
		unsigned int nr_cpus = count_cpus();
		for (cpu=0; cpu < nr_cpus; cpu++) {
			if (cpufreq_cpu_exists(cpu))
				continue;
			debug_output_one(cpu);
		}
	} else
		debug_output_one(cpu);
}


/* --freq / -f */

static int get_freq_kernel(unsigned int cpu, unsigned int human) {
	unsigned long freq = cpufreq_get_freq_kernel(cpu);
	if (!freq)
		return -EINVAL;
	if (human) {
		print_speed(freq);
		printf("\n");
	} else
		printf("%lu\n", freq);
	return 0;
}


/* --hwfreq / -w */

static int get_freq_hardware(unsigned int cpu, unsigned int human) {
	unsigned long freq = cpufreq_get_freq_hardware(cpu);
	if (!freq)
		return -EINVAL;
	if (human) {
		print_speed(freq);
		printf("\n");
	} else
		printf("%lu\n", freq);
	return 0;
}

/* --hwlimits / -l */

static int get_hardware_limits(unsigned int cpu) {
	unsigned long min, max;
	if (cpufreq_get_hardware_limits(cpu, &min, &max))
		return -EINVAL;
	printf("%lu %lu\n", min, max);
	return 0;
}

/* --driver / -d */

static int get_driver(unsigned int cpu) {
	char *driver = cpufreq_get_driver(cpu);
	if (!driver)
		return -EINVAL;
	printf("%s\n", driver);
	cpufreq_put_driver(driver);
	return 0;
}

/* --policy / -p */

static int get_policy(unsigned int cpu) {
	struct cpufreq_policy *policy = cpufreq_get_policy(cpu);
	if (!policy)
		return -EINVAL;
	printf("%lu %lu %s\n", policy->min, policy->max, policy->governor);
	cpufreq_put_policy(policy);
	return 0;
}

/* --governors / -g */

static int get_available_governors(unsigned int cpu) {
	struct cpufreq_available_governors *governors = cpufreq_get_available_governors(cpu);
	if (!governors)
		return -EINVAL;

	while (governors->next) {
		printf("%s ", governors->governor);
		governors = governors->next;
	}
	printf("%s\n", governors->governor);
	cpufreq_put_available_governors(governors);
	return 0;
}


/* --affected-cpus  / -a */

static int get_affected_cpus(unsigned int cpu) {
	struct cpufreq_affected_cpus *cpus = cpufreq_get_affected_cpus(cpu);
	if (!cpus)
		return -EINVAL;

	while (cpus->next) {
		printf("%d ", cpus->cpu);
		cpus = cpus->next;
	}
	printf("%d\n", cpus->cpu);
	cpufreq_put_affected_cpus(cpus);
	return 0;
}

/* --related-cpus  / -r */

static int get_related_cpus(unsigned int cpu) {
	struct cpufreq_affected_cpus *cpus = cpufreq_get_related_cpus(cpu);
	if (!cpus)
		return -EINVAL;

	while (cpus->next) {
		printf("%d ", cpus->cpu);
		cpus = cpus->next;
	}
	printf("%d\n", cpus->cpu);
	cpufreq_put_related_cpus(cpus);
	return 0;
}

/* --stats / -s */

static int get_freq_stats(unsigned int cpu, unsigned int human) {
	unsigned long total_trans = cpufreq_get_transitions(cpu);
	unsigned long long total_time;
	struct cpufreq_stats *stats = cpufreq_get_stats(cpu, &total_time);
	while (stats) {
		if (human) {
			print_speed(stats->frequency);
			printf(":%.2f%%", (100.0 * stats->time_in_state) / total_time);
		}
		else
			printf("%lu:%llu", stats->frequency, stats->time_in_state);
		stats = stats->next;
		if (stats)
			printf(", ");
	}
	cpufreq_put_stats(stats);
	if (total_trans)
		printf("  (%lu)\n", total_trans);
	return 0;
}

/* --latency / -y */

static int get_latency(unsigned int cpu, unsigned int human) {
	unsigned long latency = cpufreq_get_transition_latency(cpu);
	if (!latency)
		return -EINVAL;

	if (human) {
		print_duration(latency);
		printf("\n");
	} else
		printf("%lu\n", latency);
	return 0;
}

static void print_header(void) {
	printf(PACKAGE " " VERSION ": cpufreq-info (C) Dominik Brodowski 2004-2009\n");
	printf(gettext ("Report errors and bugs to %s, please.\n"), PACKAGE_BUGREPORT);
}

static void print_help(void) {
	printf(gettext ("Usage: cpufreq-info [options]\n"));
	printf(gettext ("Options:\n"));
	printf(gettext ("  -c CPU, --cpu CPU    CPU number which information shall be determined about\n"));
	printf(gettext ("  -e, --debug          Prints out debug information\n"));
	printf(gettext ("  -f, --freq           Get frequency the CPU currently runs at, according\n"
	       "                       to the cpufreq core *\n"));
	printf(gettext ("  -w, --hwfreq         Get frequency the CPU currently runs at, by reading\n"
	       "                       it from hardware (only available to root) *\n"));
	printf(gettext ("  -l, --hwlimits       Determine the minimum and maximum CPU frequency allowed *\n"));
	printf(gettext ("  -d, --driver         Determines the used cpufreq kernel driver *\n"));
	printf(gettext ("  -p, --policy         Gets the currently used cpufreq policy *\n"));
	printf(gettext ("  -g, --governors      Determines available cpufreq governors *\n"));
	printf(gettext ("  -r, --related-cpus   Determines which CPUs run at the same hardware frequency *\n"));
	printf(gettext ("  -a, --affected-cpus  Determines which CPUs need to have their frequency\n"
			"                       coordinated by software *\n"));
	printf(gettext ("  -s, --stats          Shows cpufreq statistics if available\n"));
	printf(gettext ("  -y, --latency        Determines the maximum latency on CPU frequency changes *\n"));
	printf(gettext ("  -o, --proc           Prints out information like provided by the /proc/cpufreq\n"
	       "                       interface in 2.4. and early 2.6. kernels\n"));
	printf(gettext ("  -m, --human          human-readable output for the -f, -w, -s and -y parameters\n"));
	printf(gettext ("  -h, --help           Prints out this screen\n"));

	printf("\n");
	printf(gettext ("If no argument or only the -c, --cpu parameter is given, debug output about\n"
	       "cpufreq is printed which is useful e.g. for reporting bugs.\n"));
	printf(gettext ("For the arguments marked with *, omitting the -c or --cpu argument is\n"
	"equivalent to setting it to zero\n"));
}

static struct option info_opts[] = {
	{ .name="cpu",		.has_arg=required_argument,	.flag=NULL,	.val='c'},
	{ .name="debug",	.has_arg=no_argument,		.flag=NULL,	.val='e'},
	{ .name="freq",		.has_arg=no_argument,		.flag=NULL,	.val='f'},
	{ .name="hwfreq",	.has_arg=no_argument,		.flag=NULL,	.val='w'},
	{ .name="hwlimits",	.has_arg=no_argument,		.flag=NULL,	.val='l'},
	{ .name="driver",	.has_arg=no_argument,		.flag=NULL,	.val='d'},
	{ .name="policy",	.has_arg=no_argument,		.flag=NULL,	.val='p'},
	{ .name="governors",	.has_arg=no_argument,		.flag=NULL,	.val='g'},
	{ .name="related-cpus", .has_arg=no_argument,		.flag=NULL,	.val='r'},
	{ .name="affected-cpus",.has_arg=no_argument,		.flag=NULL,	.val='a'},
	{ .name="stats",	.has_arg=no_argument,		.flag=NULL,	.val='s'},
	{ .name="latency",	.has_arg=no_argument,		.flag=NULL,	.val='y'},
	{ .name="proc",		.has_arg=no_argument,		.flag=NULL,	.val='o'},
	{ .name="human",	.has_arg=no_argument,		.flag=NULL,	.val='m'},
	{ .name="help",		.has_arg=no_argument,		.flag=NULL,	.val='h'},
};

int main(int argc, char **argv) {
	extern char *optarg;
	extern int optind, opterr, optopt;
	int ret = 0, cont = 1;
	unsigned int cpu = 0;
	unsigned int cpu_defined = 0;
	unsigned int human = 0;
	int output_param = 0;

	setlocale(LC_ALL, "");
	textdomain (PACKAGE);

	do {
		ret = getopt_long(argc, argv, "c:hoefwldpgrasmy", info_opts, NULL);
		switch (ret) {
		case '?':
			output_param = '?';
			cont = 0;
			break;
		case 'h':
			output_param = 'h';
			cont = 0;
			break;
		case -1:
			cont = 0;
			break;
		case 'o':
		case 'a':
		case 'r':
		case 'g':
		case 'p':
		case 'd':
		case 'l':
		case 'w':
		case 'f':
		case 'e':
		case 's':
		case 'y':
			if (output_param) {
				output_param = -1;
				cont = 0;
				break;
			}
			output_param = ret;
			break;
		case 'c':
			if (cpu_defined) {
				output_param = -1;
				cont = 0;
				break;
			}
			if ((sscanf(optarg, "%d ", &cpu)) != 1) {
				output_param = '?';
				cont = 0;
			}
			cpu_defined = 1;
			break;
		case 'm':
			if (human) {
				output_param = -1;
				cont = 0;
				break;
			}
			human = 1;
			break;
		}
	} while(cont);

	switch (output_param) {
	case 'o':
		if (cpu_defined) {
			print_header();
			printf(gettext ("The argument passed to this tool can't be combined with passing a --cpu argument\n"));
			return -EINVAL;
		}
		break;
	case 0:
		output_param = 'e';
	}

	ret = 0;

	switch (output_param) {
	case -1:
		print_header();
		printf(gettext ("You can't specify more than one --cpu parameter and/or\n"
		       "more than one output-specific argument\n"));
		return -EINVAL;
		break;
	case '?':
		print_header();
		printf(gettext ("invalid or unknown argument\n"));
		print_help();
		ret = -EINVAL;
		break;
	case 'h':
		print_header();
		print_help();
		break;
	case 'o':
		proc_cpufreq_output();
		break;
	case 'e':
		print_header();
		debug_output(cpu, !(cpu_defined));
		break;
	case 'a':
		ret = get_affected_cpus(cpu);
		break;
	case 'r':
		ret = get_related_cpus(cpu);
		break;
	case 'g':
		ret = get_available_governors(cpu);
		break;
	case 'p':
		ret = get_policy(cpu);
		break;
	case 'd':
		ret = get_driver(cpu);
		break;
	case 'l':
		ret = get_hardware_limits(cpu);
		break;
	case 'w':
		ret = get_freq_hardware(cpu, human);
		break;
	case 'f':
		ret = get_freq_kernel(cpu, human);
		break;
	case 's':
		ret = get_freq_stats(cpu, human);
		break;
	case 'y':
		ret = get_latency(cpu, human);
		break;
	}
	return (ret);
}