[mirror_ubuntu-bionic-kernel.git] / tools / power / x86 / x86_energy_perf_policy / x86_energy_perf_policy.c

/*
 * x86_energy_perf_policy -- set the energy versus performance
 * policy preference bias on recent X86 processors.
 */
/*
 * Copyright (c) 2010, Intel Corporation.
 * Len Brown <len.brown@intel.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/resource.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/time.h>
#include <stdlib.h>
#include <string.h>

unsigned int verbose;		/* set with -v */
unsigned int read_only;		/* set with -r */
char *progname;
unsigned long long new_bias;
int cpu = -1;

/*
 * Usage:
 *
 * -c cpu: limit action to a single CPU (default is all CPUs)
 * -v: verbose output (can invoke more than once)
 * -r: read-only, don't change any settings
 *
 *  performance
 *	Performance is paramount.
 *	Unwilling to sacrifice any performance
 *	for the sake of energy saving. (hardware default)
 *
 *  normal
 *	Can tolerate minor performance compromise
 *	for potentially significant energy savings.
 *	(reasonable default for most desktops and servers)
 *
 *  powersave
 *	Can tolerate significant performance hit
 *	to maximize energy savings.
 *
 * n
 *	a numerical value to write to the underlying MSR.
 */
void usage(void)
{
	printf("%s: [-c cpu] [-v] "
		"(-r | 'performance' | 'normal' | 'powersave' | n)\n",
		progname);
	exit(1);
}

#define MSR_IA32_ENERGY_PERF_BIAS	0x000001b0

#define	BIAS_PERFORMANCE		0
#define BIAS_BALANCE			6
#define	BIAS_POWERSAVE			15

void cmdline(int argc, char **argv)
{
	int opt;

	progname = argv[0];

	while ((opt = getopt(argc, argv, "+rvc:")) != -1) {
		switch (opt) {
		case 'c':
			cpu = atoi(optarg);
			break;
		case 'r':
			read_only = 1;
			break;
		case 'v':
			verbose++;
			break;
		default:
			usage();
		}
	}
	/* if -r, then should be no additional optind */
	if (read_only && (argc > optind))
		usage();

	/*
	 * if no -r , then must be one additional optind
	 */
	if (!read_only) {

		if (argc != optind + 1) {
			printf("must supply -r or policy param\n");
			usage();
			}

		if (!strcmp("performance", argv[optind])) {
			new_bias = BIAS_PERFORMANCE;
		} else if (!strcmp("normal", argv[optind])) {
			new_bias = BIAS_BALANCE;
		} else if (!strcmp("powersave", argv[optind])) {
			new_bias = BIAS_POWERSAVE;
		} else {
			char *endptr;

			new_bias = strtoull(argv[optind], &endptr, 0);
			if (endptr == argv[optind] ||
				new_bias > BIAS_POWERSAVE) {
					fprintf(stderr, "invalid value: %s\n",
						argv[optind]);
				usage();
			}
		}
	}
}

/*
 * validate_cpuid()
 * returns on success, quietly exits on failure (make verbose with -v)
 */
void validate_cpuid(void)
{
	unsigned int eax, ebx, ecx, edx, max_level;
	char brand[16];
	unsigned int fms, family, model, stepping;

	eax = ebx = ecx = edx = 0;

	asm("cpuid" : "=a" (max_level), "=b" (ebx), "=c" (ecx),
		"=d" (edx) : "a" (0));

	if (ebx != 0x756e6547 || edx != 0x49656e69 || ecx != 0x6c65746e) {
		if (verbose)
			fprintf(stderr, "%.4s%.4s%.4s != GenuineIntel",
				(char *)&ebx, (char *)&edx, (char *)&ecx);
		exit(1);
	}

	asm("cpuid" : "=a" (fms), "=c" (ecx), "=d" (edx) : "a" (1) : "ebx");
	family = (fms >> 8) & 0xf;
	model = (fms >> 4) & 0xf;
	stepping = fms & 0xf;
	if (family == 6 || family == 0xf)
		model += ((fms >> 16) & 0xf) << 4;

	if (verbose > 1)
		printf("CPUID %s %d levels family:model:stepping "
			"0x%x:%x:%x (%d:%d:%d)\n", brand, max_level,
			family, model, stepping, family, model, stepping);

	if (!(edx & (1 << 5))) {
		if (verbose)
			printf("CPUID: no MSR\n");
		exit(1);
	}

	/*
	 * Support for MSR_IA32_ENERGY_PERF_BIAS
	 * is indicated by CPUID.06H.ECX.bit3
	 */
	asm("cpuid" : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (6));
	if (verbose)
		printf("CPUID.06H.ECX: 0x%x\n", ecx);
	if (!(ecx & (1 << 3))) {
		if (verbose)
			printf("CPUID: No MSR_IA32_ENERGY_PERF_BIAS\n");
		exit(1);
	}
	return;	/* success */
}

unsigned long long get_msr(int cpu, int offset)
{
	unsigned long long msr;
	char msr_path[32];
	int retval;
	int fd;

	sprintf(msr_path, "/dev/cpu/%d/msr", cpu);
	fd = open(msr_path, O_RDONLY);
	if (fd < 0) {
		printf("Try \"# modprobe msr\"\n");
		perror(msr_path);
		exit(1);
	}

	retval = pread(fd, &msr, sizeof msr, offset);

	if (retval != sizeof msr) {
		printf("pread cpu%d 0x%x = %d\n", cpu, offset, retval);
		exit(-2);
	}
	close(fd);
	return msr;
}

unsigned long long  put_msr(int cpu, unsigned long long new_msr, int offset)
{
	unsigned long long old_msr;
	char msr_path[32];
	int retval;
	int fd;

	sprintf(msr_path, "/dev/cpu/%d/msr", cpu);
	fd = open(msr_path, O_RDWR);
	if (fd < 0) {
		perror(msr_path);
		exit(1);
	}

	retval = pread(fd, &old_msr, sizeof old_msr, offset);
	if (retval != sizeof old_msr) {
		perror("pwrite");
		printf("pread cpu%d 0x%x = %d\n", cpu, offset, retval);
		exit(-2);
	}

	retval = pwrite(fd, &new_msr, sizeof new_msr, offset);
	if (retval != sizeof new_msr) {
		perror("pwrite");
		printf("pwrite cpu%d 0x%x = %d\n", cpu, offset, retval);
		exit(-2);
	}

	close(fd);

	return old_msr;
}

void print_msr(int cpu)
{
	printf("cpu%d: 0x%016llx\n",
		cpu, get_msr(cpu, MSR_IA32_ENERGY_PERF_BIAS));
}

void update_msr(int cpu)
{
	unsigned long long previous_msr;

	previous_msr = put_msr(cpu, new_bias, MSR_IA32_ENERGY_PERF_BIAS);

	if (verbose)
		printf("cpu%d  msr0x%x 0x%016llx -> 0x%016llx\n",
			cpu, MSR_IA32_ENERGY_PERF_BIAS, previous_msr, new_bias);

	return;
}

char *proc_stat = "/proc/stat";
/*
 * run func() on every cpu in /dev/cpu
 */
void for_every_cpu(void (func)(int))
{
	FILE *fp;
	int retval;

	fp = fopen(proc_stat, "r");
	if (fp == NULL) {
		perror(proc_stat);
		exit(1);
	}

	retval = fscanf(fp, "cpu %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n");
	if (retval != 0) {
		perror("/proc/stat format");
		exit(1);
	}

	while (1) {
		int cpu;

		retval = fscanf(fp,
			"cpu%u %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n",
			&cpu);
		if (retval != 1)
			return;

		func(cpu);
	}
	fclose(fp);
}

int main(int argc, char **argv)
{
	cmdline(argc, argv);

	if (verbose > 1)
		printf("x86_energy_perf_policy Nov 24, 2010"
				" - Len Brown <lenb@kernel.org>\n");
	if (verbose > 1 && !read_only)
		printf("new_bias %lld\n", new_bias);

	validate_cpuid();

	if (cpu != -1) {
		if (read_only)
			print_msr(cpu);
		else
			update_msr(cpu);
	} else {
		if (read_only)
			for_every_cpu(print_msr);
		else
			for_every_cpu(update_msr);
	}

	return 0;
}
Commit	Line	Data
d5532ee7 LB	1	/*
	2	* x86_energy_perf_policy -- set the energy versus performance
	3	* policy preference bias on recent X86 processors.
	4	*/
	5	/*
	6	* Copyright (c) 2010, Intel Corporation.
	7	* Len Brown <len.brown@intel.com>
	8	*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms and conditions of the GNU General Public License,
	11	* version 2, as published by the Free Software Foundation.
	12	*
	13	* This program is distributed in the hope it will be useful, but WITHOUT
	14	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	15	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	16	* more details.
	17	*
	18	* You should have received a copy of the GNU General Public License along with
	19	* this program; if not, write to the Free Software Foundation, Inc.,
	20	* 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
	21	*/
	22
	23	#include <stdio.h>
	24	#include <unistd.h>
	25	#include <sys/types.h>
	26	#include <sys/stat.h>
	27	#include <sys/resource.h>
	28	#include <fcntl.h>
	29	#include <signal.h>
	30	#include <sys/time.h>
	31	#include <stdlib.h>
	32	#include <string.h>
	33
	34	unsigned int verbose; /* set with -v */
	35	unsigned int read_only; /* set with -r */
	36	char *progname;
	37	unsigned long long new_bias;
	38	int cpu = -1;
	39
	40	/*
	41	* Usage:
	42	*
	43	* -c cpu: limit action to a single CPU (default is all CPUs)
	44	* -v: verbose output (can invoke more than once)
	45	* -r: read-only, don't change any settings
	46	*
	47	* performance
	48	* Performance is paramount.
25985edc	49	* Unwilling to sacrifice any performance
d5532ee7 LB	50	* for the sake of energy saving. (hardware default)
	51	*
	52	* normal
	53	* Can tolerate minor performance compromise
	54	* for potentially significant energy savings.
	55	* (reasonable default for most desktops and servers)
	56	*
	57	* powersave
	58	* Can tolerate significant performance hit
	59	* to maximize energy savings.
	60	*
	61	* n
	62	* a numerical value to write to the underlying MSR.
	63	*/
	64	void usage(void)
	65	{
	66	printf("%s: [-c cpu] [-v] "
	67	"(-r \| 'performance' \| 'normal' \| 'powersave' \| n)\n",
	68	progname);
	69	exit(1);
	70	}
	71
	72	#define MSR_IA32_ENERGY_PERF_BIAS 0x000001b0
	73
	74	#define BIAS_PERFORMANCE 0
	75	#define BIAS_BALANCE 6
	76	#define BIAS_POWERSAVE 15
	77
	78	void cmdline(int argc, char **argv)
	79	{
	80	int opt;
	81
	82	progname = argv[0];
	83
	84	while ((opt = getopt(argc, argv, "+rvc:")) != -1) {
	85	switch (opt) {
	86	case 'c':
	87	cpu = atoi(optarg);
	88	break;
	89	case 'r':
	90	read_only = 1;
	91	break;
	92	case 'v':
	93	verbose++;
	94	break;
	95	default:
	96	usage();
	97	}
	98	}
	99	/* if -r, then should be no additional optind */
	100	if (read_only && (argc > optind))
	101	usage();
	102
	103	/*
	104	* if no -r , then must be one additional optind
	105	*/
	106	if (!read_only) {
	107
	108	if (argc != optind + 1) {
	109	printf("must supply -r or policy param\n");
	110	usage();
	111	}
	112
	113	if (!strcmp("performance", argv[optind])) {
114	new_bias = BIAS_PERFORMANCE;
115	} else if (!strcmp("normal", argv[optind])) {
116	new_bias = BIAS_BALANCE;
117	} else if (!strcmp("powersave", argv[optind])) {
118	new_bias = BIAS_POWERSAVE;
119	} else {
120	char *endptr;
121
122	new_bias = strtoull(argv[optind], &endptr, 0);
123	if (endptr == argv[optind] \|\|
124	new_bias > BIAS_POWERSAVE) {
125	fprintf(stderr, "invalid value: %s\n",
126	argv[optind]);
127	usage();
128	}
129	}
130	}
131	}
132
133	/*
134	* validate_cpuid()
135	* returns on success, quietly exits on failure (make verbose with -v)
136	*/
137	void validate_cpuid(void)
138	{
139	unsigned int eax, ebx, ecx, edx, max_level;
140	char brand[16];
141	unsigned int fms, family, model, stepping;
142
143	eax = ebx = ecx = edx = 0;
144
145	asm("cpuid" : "=a" (max_level), "=b" (ebx), "=c" (ecx),
146	"=d" (edx) : "a" (0));
147
148	if (ebx != 0x756e6547 \|\| edx != 0x49656e69 \|\| ecx != 0x6c65746e) {
149	if (verbose)
150	fprintf(stderr, "%.4s%.4s%.4s != GenuineIntel",
151	(char )&ebx, (char )&edx, (char *)&ecx);
152	exit(1);
153	}
154
155	asm("cpuid" : "=a" (fms), "=c" (ecx), "=d" (edx) : "a" (1) : "ebx");
156	family = (fms >> 8) & 0xf;
157	model = (fms >> 4) & 0xf;
158	stepping = fms & 0xf;
159	if (family == 6 \|\| family == 0xf)
160	model += ((fms >> 16) & 0xf) << 4;
161
162	if (verbose > 1)
163	printf("CPUID %s %d levels family:model:stepping "
164	"0x%x:%x:%x (%d:%d:%d)\n", brand, max_level,
165	family, model, stepping, family, model, stepping);
166
167	if (!(edx & (1 << 5))) {
168	if (verbose)
169	printf("CPUID: no MSR\n");
170	exit(1);
171	}
172
173	/*
174	* Support for MSR_IA32_ENERGY_PERF_BIAS
175	* is indicated by CPUID.06H.ECX.bit3
176	*/
177	asm("cpuid" : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (6));
178	if (verbose)
179	printf("CPUID.06H.ECX: 0x%x\n", ecx);
180	if (!(ecx & (1 << 3))) {
181	if (verbose)
182	printf("CPUID: No MSR_IA32_ENERGY_PERF_BIAS\n");
183	exit(1);
184	}
185	return; /* success */
186	}
187
188	unsigned long long get_msr(int cpu, int offset)
189	{
190	unsigned long long msr;
191	char msr_path[32];
192	int retval;
193	int fd;
194
195	sprintf(msr_path, "/dev/cpu/%d/msr", cpu);
196	fd = open(msr_path, O_RDONLY);
197	if (fd < 0) {
198	printf("Try \"# modprobe msr\"\n");
199	perror(msr_path);
200	exit(1);
201	}
202
203	retval = pread(fd, &msr, sizeof msr, offset);
204
205	if (retval != sizeof msr) {
206	printf("pread cpu%d 0x%x = %d\n", cpu, offset, retval);
207	exit(-2);
208	}
209	close(fd);
210	return msr;
211	}
212
213	unsigned long long put_msr(int cpu, unsigned long long new_msr, int offset)
214	{
215	unsigned long long old_msr;
216	char msr_path[32];
217	int retval;
218	int fd;
219
220	sprintf(msr_path, "/dev/cpu/%d/msr", cpu);
221	fd = open(msr_path, O_RDWR);
222	if (fd < 0) {
223	perror(msr_path);
224	exit(1);
225	}
226
227	retval = pread(fd, &old_msr, sizeof old_msr, offset);
228	if (retval != sizeof old_msr) {
229	perror("pwrite");
230	printf("pread cpu%d 0x%x = %d\n", cpu, offset, retval);
231	exit(-2);
232	}
233
234	retval = pwrite(fd, &new_msr, sizeof new_msr, offset);
235	if (retval != sizeof new_msr) {
236	perror("pwrite");
237	printf("pwrite cpu%d 0x%x = %d\n", cpu, offset, retval);
238	exit(-2);
239	}
240
241	close(fd);
242
243	return old_msr;
244	}
245
246	void print_msr(int cpu)
247	{
248	printf("cpu%d: 0x%016llx\n",
249	cpu, get_msr(cpu, MSR_IA32_ENERGY_PERF_BIAS));
250	}
251
252	void update_msr(int cpu)
253	{
254	unsigned long long previous_msr;
255
256	previous_msr = put_msr(cpu, new_bias, MSR_IA32_ENERGY_PERF_BIAS);
257
258	if (verbose)
259	printf("cpu%d msr0x%x 0x%016llx -> 0x%016llx\n",
260	cpu, MSR_IA32_ENERGY_PERF_BIAS, previous_msr, new_bias);
261
262	return;
263	}
264
265	char *proc_stat = "/proc/stat";
266	/*
267	* run func() on every cpu in /dev/cpu
268	*/
269	void for_every_cpu(void (func)(int))
270	{
271	FILE *fp;
272	int retval;
273
274	fp = fopen(proc_stat, "r");
275	if (fp == NULL) {
276	perror(proc_stat);
277	exit(1);
278	}
279
280	retval = fscanf(fp, "cpu %d %d %d %d %d %d %d %d %d %d\n");
281	if (retval != 0) {
282	perror("/proc/stat format");
283	exit(1);
284	}
285
286	while (1) {
287	int cpu;
288
289	retval = fscanf(fp,
290	"cpu%u %d %d %d %d %d %d %d %d %d %d\n",
291	&cpu);
292	if (retval != 1)
293	return;
294
295	func(cpu);
296	}
297	fclose(fp);
298	}
299
300	int main(int argc, char **argv)
301	{
302	cmdline(argc, argv);
303
304	if (verbose > 1)
305	printf("x86_energy_perf_policy Nov 24, 2010"
306	" - Len Brown <lenb@kernel.org>\n");
307	if (verbose > 1 && !read_only)
308	printf("new_bias %lld\n", new_bias);
309
310	validate_cpuid();
311
312	if (cpu != -1) {
313	if (read_only)
314	print_msr(cpu);
315	else
316	update_msr(cpu);
317	} else {
318	if (read_only)
319	for_every_cpu(print_msr);
320	else
321	for_every_cpu(update_msr);
322	}
323
324	return 0;
325	}