1103a8feaSLen Brown /*
2103a8feaSLen Brown  * turbostat -- show CPU frequency and C-state residency
3103a8feaSLen Brown  * on modern Intel turbo-capable processors.
4103a8feaSLen Brown  *
5144b44b1SLen Brown  * Copyright (c) 2013 Intel Corporation.
6103a8feaSLen Brown  * Len Brown <len.brown@intel.com>
7103a8feaSLen Brown  *
8103a8feaSLen Brown  * This program is free software; you can redistribute it and/or modify it
9103a8feaSLen Brown  * under the terms and conditions of the GNU General Public License,
10103a8feaSLen Brown  * version 2, as published by the Free Software Foundation.
11103a8feaSLen Brown  *
12103a8feaSLen Brown  * This program is distributed in the hope it will be useful, but WITHOUT
13103a8feaSLen Brown  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14103a8feaSLen Brown  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
15103a8feaSLen Brown  * more details.
16103a8feaSLen Brown  *
17103a8feaSLen Brown  * You should have received a copy of the GNU General Public License along with
18103a8feaSLen Brown  * this program; if not, write to the Free Software Foundation, Inc.,
19103a8feaSLen Brown  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
20103a8feaSLen Brown  */
21103a8feaSLen Brown 
2288c3281fSLen Brown #define _GNU_SOURCE
23b731f311SJosh Triplett #include MSRHEADER
24869ce69eSLen Brown #include INTEL_FAMILY_HEADER
2595aebc44SJosh Triplett #include <stdarg.h>
26103a8feaSLen Brown #include <stdio.h>
27b2c95d90SJosh Triplett #include <err.h>
28103a8feaSLen Brown #include <unistd.h>
29103a8feaSLen Brown #include <sys/types.h>
30103a8feaSLen Brown #include <sys/wait.h>
31103a8feaSLen Brown #include <sys/stat.h>
32103a8feaSLen Brown #include <sys/resource.h>
33103a8feaSLen Brown #include <fcntl.h>
34103a8feaSLen Brown #include <signal.h>
35103a8feaSLen Brown #include <sys/time.h>
36103a8feaSLen Brown #include <stdlib.h>
37d8af6f5fSLen Brown #include <getopt.h>
38103a8feaSLen Brown #include <dirent.h>
39103a8feaSLen Brown #include <string.h>
40103a8feaSLen Brown #include <ctype.h>
4188c3281fSLen Brown #include <sched.h>
422a0609c0SLen Brown #include <time.h>
432b92865eSJosh Triplett #include <cpuid.h>
4498481e79SLen Brown #include <linux/capability.h>
4598481e79SLen Brown #include <errno.h>
46103a8feaSLen Brown 
47103a8feaSLen Brown char *proc_stat = "/proc/stat";
48b7d8c148SLen Brown FILE *outf;
4936229897SLen Brown int *fd_percpu;
502a0609c0SLen Brown struct timespec interval_ts = {5, 0};
51d8af6f5fSLen Brown unsigned int debug;
5296e47158SLen Brown unsigned int quiet;
53d8af6f5fSLen Brown unsigned int rapl_joules;
54d8af6f5fSLen Brown unsigned int summary_only;
55d8af6f5fSLen Brown unsigned int dump_only;
56103a8feaSLen Brown unsigned int do_snb_cstates;
57fb5d4327SDasaratharaman Chandramouli unsigned int do_knl_cstates;
580b2bb692SLen Brown unsigned int do_skl_residency;
59144b44b1SLen Brown unsigned int do_slm_cstates;
60144b44b1SLen Brown unsigned int use_c1_residency_msr;
61103a8feaSLen Brown unsigned int has_aperf;
62889facbeSLen Brown unsigned int has_epb;
635a63426eSLen Brown unsigned int do_irtl_snb;
645a63426eSLen Brown unsigned int do_irtl_hsw;
65fc04cc67SLen Brown unsigned int units = 1000000;	/* MHz etc */
66103a8feaSLen Brown unsigned int genuine_intel;
67103a8feaSLen Brown unsigned int has_invariant_tsc;
68d7899447SLen Brown unsigned int do_nhm_platform_info;
69cf4cbe53SLen Brown unsigned int no_MSR_MISC_PWR_MGMT;
70b2b34dfeSHubert Chrzaniuk unsigned int aperf_mperf_multiplier = 1;
71103a8feaSLen Brown double bclk;
72a2b7b749SLen Brown double base_hz;
7321ed5574SLen Brown unsigned int has_base_hz;
74a2b7b749SLen Brown double tsc_tweak = 1.0;
75c98d5d94SLen Brown unsigned int show_pkg_only;
76c98d5d94SLen Brown unsigned int show_core_only;
77c98d5d94SLen Brown char *output_buffer, *outp;
78889facbeSLen Brown unsigned int do_rapl;
79889facbeSLen Brown unsigned int do_dts;
80889facbeSLen Brown unsigned int do_ptm;
81fdf676e5SLen Brown unsigned long long  gfx_cur_rc6_ms;
8227d47356SLen Brown unsigned int gfx_cur_mhz;
83889facbeSLen Brown unsigned int tcc_activation_temp;
84889facbeSLen Brown unsigned int tcc_activation_temp_override;
8540ee8e3bSAndrey Semin double rapl_power_units, rapl_time_units;
8640ee8e3bSAndrey Semin double rapl_dram_energy_units, rapl_energy_units;
87889facbeSLen Brown double rapl_joule_counter_range;
883a9a941dSLen Brown unsigned int do_core_perf_limit_reasons;
893a9a941dSLen Brown unsigned int do_gfx_perf_limit_reasons;
903a9a941dSLen Brown unsigned int do_ring_perf_limit_reasons;
918a5bdf41SLen Brown unsigned int crystal_hz;
928a5bdf41SLen Brown unsigned long long tsc_hz;
937ce7d5deSPrarit Bhargava int base_cpu;
9421ed5574SLen Brown double discover_bclk(unsigned int family, unsigned int model);
957f5c258eSLen Brown unsigned int has_hwp;	/* IA32_PM_ENABLE, IA32_HWP_CAPABILITIES */
967f5c258eSLen Brown 			/* IA32_HWP_REQUEST, IA32_HWP_STATUS */
977f5c258eSLen Brown unsigned int has_hwp_notify;		/* IA32_HWP_INTERRUPT */
987f5c258eSLen Brown unsigned int has_hwp_activity_window;	/* IA32_HWP_REQUEST[bits 41:32] */
997f5c258eSLen Brown unsigned int has_hwp_epp;		/* IA32_HWP_REQUEST[bits 31:24] */
1007f5c258eSLen Brown unsigned int has_hwp_pkg;		/* IA32_HWP_REQUEST_PKG */
10133148d67SLen Brown unsigned int has_misc_feature_control;
102889facbeSLen Brown 
103889facbeSLen Brown #define RAPL_PKG		(1 << 0)
104e6f9bb3cSLen Brown 					/* 0x610 MSR_PKG_POWER_LIMIT */
105e6f9bb3cSLen Brown 					/* 0x611 MSR_PKG_ENERGY_STATUS */
106e6f9bb3cSLen Brown #define RAPL_PKG_PERF_STATUS	(1 << 1)
107e6f9bb3cSLen Brown 					/* 0x613 MSR_PKG_PERF_STATUS */
108e6f9bb3cSLen Brown #define RAPL_PKG_POWER_INFO	(1 << 2)
109e6f9bb3cSLen Brown 					/* 0x614 MSR_PKG_POWER_INFO */
110e6f9bb3cSLen Brown 
111889facbeSLen Brown #define RAPL_DRAM		(1 << 3)
112e6f9bb3cSLen Brown 					/* 0x618 MSR_DRAM_POWER_LIMIT */
113e6f9bb3cSLen Brown 					/* 0x619 MSR_DRAM_ENERGY_STATUS */
114e6f9bb3cSLen Brown #define RAPL_DRAM_PERF_STATUS	(1 << 4)
115e6f9bb3cSLen Brown 					/* 0x61b MSR_DRAM_PERF_STATUS */
1160b2bb692SLen Brown #define RAPL_DRAM_POWER_INFO	(1 << 5)
1170b2bb692SLen Brown 					/* 0x61c MSR_DRAM_POWER_INFO */
118e6f9bb3cSLen Brown 
1199148494cSJacob Pan #define RAPL_CORES_POWER_LIMIT	(1 << 6)
120e6f9bb3cSLen Brown 					/* 0x638 MSR_PP0_POWER_LIMIT */
1210b2bb692SLen Brown #define RAPL_CORE_POLICY	(1 << 7)
122e6f9bb3cSLen Brown 					/* 0x63a MSR_PP0_POLICY */
123e6f9bb3cSLen Brown 
1240b2bb692SLen Brown #define RAPL_GFX		(1 << 8)
125e6f9bb3cSLen Brown 					/* 0x640 MSR_PP1_POWER_LIMIT */
126e6f9bb3cSLen Brown 					/* 0x641 MSR_PP1_ENERGY_STATUS */
127e6f9bb3cSLen Brown 					/* 0x642 MSR_PP1_POLICY */
1289148494cSJacob Pan 
1299148494cSJacob Pan #define RAPL_CORES_ENERGY_STATUS	(1 << 9)
1309148494cSJacob Pan 					/* 0x639 MSR_PP0_ENERGY_STATUS */
1319148494cSJacob Pan #define RAPL_CORES (RAPL_CORES_ENERGY_STATUS | RAPL_CORES_POWER_LIMIT)
132889facbeSLen Brown #define	TJMAX_DEFAULT	100
133889facbeSLen Brown 
134889facbeSLen Brown #define MAX(a, b) ((a) > (b) ? (a) : (b))
135103a8feaSLen Brown 
136388e9c81SLen Brown /*
137388e9c81SLen Brown  * buffer size used by sscanf() for added column names
138388e9c81SLen Brown  * Usually truncated to 7 characters, but also handles 18 columns for raw 64-bit counters
139388e9c81SLen Brown  */
140388e9c81SLen Brown #define	NAME_BYTES 20
141388e9c81SLen Brown 
142103a8feaSLen Brown int backwards_count;
143103a8feaSLen Brown char *progname;
144103a8feaSLen Brown 
145c98d5d94SLen Brown cpu_set_t *cpu_present_set, *cpu_affinity_set;
146c98d5d94SLen Brown size_t cpu_present_setsize, cpu_affinity_setsize;
147678a3bd1SLen Brown #define MAX_ADDED_COUNTERS 16
148c98d5d94SLen Brown 
149c98d5d94SLen Brown struct thread_data {
150c98d5d94SLen Brown 	unsigned long long tsc;
151c98d5d94SLen Brown 	unsigned long long aperf;
152c98d5d94SLen Brown 	unsigned long long mperf;
153144b44b1SLen Brown 	unsigned long long c1;
154562a2d37SLen Brown 	unsigned int irq_count;
1551ed51011SLen Brown 	unsigned int smi_count;
156c98d5d94SLen Brown 	unsigned int cpu_id;
157c98d5d94SLen Brown 	unsigned int flags;
158c98d5d94SLen Brown #define CPU_IS_FIRST_THREAD_IN_CORE	0x2
159c98d5d94SLen Brown #define CPU_IS_FIRST_CORE_IN_PACKAGE	0x4
160678a3bd1SLen Brown 	unsigned long long counter[MAX_ADDED_COUNTERS];
161c98d5d94SLen Brown } *thread_even, *thread_odd;
162c98d5d94SLen Brown 
163c98d5d94SLen Brown struct core_data {
164c98d5d94SLen Brown 	unsigned long long c3;
165c98d5d94SLen Brown 	unsigned long long c6;
166c98d5d94SLen Brown 	unsigned long long c7;
1670539ba11SLen Brown 	unsigned long long mc6_us;	/* duplicate as per-core for now, even though per module */
168889facbeSLen Brown 	unsigned int core_temp_c;
169c98d5d94SLen Brown 	unsigned int core_id;
170678a3bd1SLen Brown 	unsigned long long counter[MAX_ADDED_COUNTERS];
171c98d5d94SLen Brown } *core_even, *core_odd;
172c98d5d94SLen Brown 
173c98d5d94SLen Brown struct pkg_data {
174c98d5d94SLen Brown 	unsigned long long pc2;
175c98d5d94SLen Brown 	unsigned long long pc3;
176c98d5d94SLen Brown 	unsigned long long pc6;
177c98d5d94SLen Brown 	unsigned long long pc7;
178ca58710fSKristen Carlson Accardi 	unsigned long long pc8;
179ca58710fSKristen Carlson Accardi 	unsigned long long pc9;
180ca58710fSKristen Carlson Accardi 	unsigned long long pc10;
1810b2bb692SLen Brown 	unsigned long long pkg_wtd_core_c0;
1820b2bb692SLen Brown 	unsigned long long pkg_any_core_c0;
1830b2bb692SLen Brown 	unsigned long long pkg_any_gfxe_c0;
1840b2bb692SLen Brown 	unsigned long long pkg_both_core_gfxe_c0;
1859185e988SLen Brown 	long long gfx_rc6_ms;
18627d47356SLen Brown 	unsigned int gfx_mhz;
187c98d5d94SLen Brown 	unsigned int package_id;
188889facbeSLen Brown 	unsigned int energy_pkg;	/* MSR_PKG_ENERGY_STATUS */
189889facbeSLen Brown 	unsigned int energy_dram;	/* MSR_DRAM_ENERGY_STATUS */
190889facbeSLen Brown 	unsigned int energy_cores;	/* MSR_PP0_ENERGY_STATUS */
191889facbeSLen Brown 	unsigned int energy_gfx;	/* MSR_PP1_ENERGY_STATUS */
192889facbeSLen Brown 	unsigned int rapl_pkg_perf_status;	/* MSR_PKG_PERF_STATUS */
193889facbeSLen Brown 	unsigned int rapl_dram_perf_status;	/* MSR_DRAM_PERF_STATUS */
194889facbeSLen Brown 	unsigned int pkg_temp_c;
195678a3bd1SLen Brown 	unsigned long long counter[MAX_ADDED_COUNTERS];
196c98d5d94SLen Brown } *package_even, *package_odd;
197c98d5d94SLen Brown 
198c98d5d94SLen Brown #define ODD_COUNTERS thread_odd, core_odd, package_odd
199c98d5d94SLen Brown #define EVEN_COUNTERS thread_even, core_even, package_even
200c98d5d94SLen Brown 
201c98d5d94SLen Brown #define GET_THREAD(thread_base, thread_no, core_no, pkg_no) \
202c98d5d94SLen Brown 	(thread_base + (pkg_no) * topo.num_cores_per_pkg * \
203c98d5d94SLen Brown 		topo.num_threads_per_core + \
204c98d5d94SLen Brown 		(core_no) * topo.num_threads_per_core + (thread_no))
205c98d5d94SLen Brown #define GET_CORE(core_base, core_no, pkg_no) \
206c98d5d94SLen Brown 	(core_base + (pkg_no) * topo.num_cores_per_pkg + (core_no))
207c98d5d94SLen Brown #define GET_PKG(pkg_base, pkg_no) (pkg_base + pkg_no)
208c98d5d94SLen Brown 
209388e9c81SLen Brown enum counter_scope {SCOPE_CPU, SCOPE_CORE, SCOPE_PACKAGE};
210388e9c81SLen Brown enum counter_type {COUNTER_CYCLES, COUNTER_SECONDS};
211388e9c81SLen Brown enum counter_format {FORMAT_RAW, FORMAT_DELTA, FORMAT_PERCENT};
212388e9c81SLen Brown 
213388e9c81SLen Brown struct msr_counter {
214388e9c81SLen Brown 	unsigned int msr_num;
215388e9c81SLen Brown 	char name[NAME_BYTES];
216388e9c81SLen Brown 	unsigned int width;
217388e9c81SLen Brown 	enum counter_type type;
218388e9c81SLen Brown 	enum counter_format format;
219388e9c81SLen Brown 	struct msr_counter *next;
220812db3f7SLen Brown 	unsigned int flags;
221812db3f7SLen Brown #define	FLAGS_HIDE	(1 << 0)
222812db3f7SLen Brown #define	FLAGS_SHOW	(1 << 1)
223388e9c81SLen Brown };
224388e9c81SLen Brown 
225388e9c81SLen Brown struct sys_counters {
226678a3bd1SLen Brown 	unsigned int added_thread_counters;
227678a3bd1SLen Brown 	unsigned int added_core_counters;
228678a3bd1SLen Brown 	unsigned int added_package_counters;
229388e9c81SLen Brown 	struct msr_counter *tp;
230388e9c81SLen Brown 	struct msr_counter *cp;
231388e9c81SLen Brown 	struct msr_counter *pp;
232388e9c81SLen Brown } sys;
233388e9c81SLen Brown 
234c98d5d94SLen Brown struct system_summary {
235c98d5d94SLen Brown 	struct thread_data threads;
236c98d5d94SLen Brown 	struct core_data cores;
237c98d5d94SLen Brown 	struct pkg_data packages;
238388e9c81SLen Brown } average;
239c98d5d94SLen Brown 
240c98d5d94SLen Brown 
241c98d5d94SLen Brown struct topo_params {
242c98d5d94SLen Brown 	int num_packages;
243103a8feaSLen Brown 	int num_cpus;
244c98d5d94SLen Brown 	int num_cores;
245c98d5d94SLen Brown 	int max_cpu_num;
246c98d5d94SLen Brown 	int num_cores_per_pkg;
247c98d5d94SLen Brown 	int num_threads_per_core;
248c98d5d94SLen Brown } topo;
249103a8feaSLen Brown 
250c98d5d94SLen Brown struct timeval tv_even, tv_odd, tv_delta;
251103a8feaSLen Brown 
252562a2d37SLen Brown int *irq_column_2_cpu;	/* /proc/interrupts column numbers */
253562a2d37SLen Brown int *irqs_per_cpu;		/* indexed by cpu_num */
254562a2d37SLen Brown 
255c98d5d94SLen Brown void setup_all_buffers(void);
256103a8feaSLen Brown 
257c98d5d94SLen Brown int cpu_is_not_present(int cpu)
258d15cf7c1SLen Brown {
259c98d5d94SLen Brown 	return !CPU_ISSET_S(cpu, cpu_present_setsize, cpu_present_set);
260c98d5d94SLen Brown }
261c98d5d94SLen Brown /*
262c98d5d94SLen Brown  * run func(thread, core, package) in topology order
263c98d5d94SLen Brown  * skip non-present cpus
264c98d5d94SLen Brown  */
265c98d5d94SLen Brown 
266c98d5d94SLen Brown int for_all_cpus(int (func)(struct thread_data *, struct core_data *, struct pkg_data *),
267c98d5d94SLen Brown 	struct thread_data *thread_base, struct core_data *core_base, struct pkg_data *pkg_base)
268c98d5d94SLen Brown {
269c98d5d94SLen Brown 	int retval, pkg_no, core_no, thread_no;
270c98d5d94SLen Brown 
271c98d5d94SLen Brown 	for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
272c98d5d94SLen Brown 		for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
273c98d5d94SLen Brown 			for (thread_no = 0; thread_no <
274c98d5d94SLen Brown 				topo.num_threads_per_core; ++thread_no) {
275c98d5d94SLen Brown 				struct thread_data *t;
276c98d5d94SLen Brown 				struct core_data *c;
277c98d5d94SLen Brown 				struct pkg_data *p;
278c98d5d94SLen Brown 
279c98d5d94SLen Brown 				t = GET_THREAD(thread_base, thread_no, core_no, pkg_no);
280c98d5d94SLen Brown 
281c98d5d94SLen Brown 				if (cpu_is_not_present(t->cpu_id))
282c98d5d94SLen Brown 					continue;
283c98d5d94SLen Brown 
284c98d5d94SLen Brown 				c = GET_CORE(core_base, core_no, pkg_no);
285c98d5d94SLen Brown 				p = GET_PKG(pkg_base, pkg_no);
286c98d5d94SLen Brown 
287c98d5d94SLen Brown 				retval = func(t, c, p);
288c98d5d94SLen Brown 				if (retval)
289c98d5d94SLen Brown 					return retval;
290c98d5d94SLen Brown 			}
291c98d5d94SLen Brown 		}
292c98d5d94SLen Brown 	}
293d15cf7c1SLen Brown 	return 0;
294d15cf7c1SLen Brown }
295d15cf7c1SLen Brown 
29688c3281fSLen Brown int cpu_migrate(int cpu)
29788c3281fSLen Brown {
298c98d5d94SLen Brown 	CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
299c98d5d94SLen Brown 	CPU_SET_S(cpu, cpu_affinity_setsize, cpu_affinity_set);
300c98d5d94SLen Brown 	if (sched_setaffinity(0, cpu_affinity_setsize, cpu_affinity_set) == -1)
30188c3281fSLen Brown 		return -1;
30288c3281fSLen Brown 	else
30388c3281fSLen Brown 		return 0;
30488c3281fSLen Brown }
30536229897SLen Brown int get_msr_fd(int cpu)
306103a8feaSLen Brown {
307103a8feaSLen Brown 	char pathname[32];
308103a8feaSLen Brown 	int fd;
309103a8feaSLen Brown 
31036229897SLen Brown 	fd = fd_percpu[cpu];
31136229897SLen Brown 
31236229897SLen Brown 	if (fd)
31336229897SLen Brown 		return fd;
31436229897SLen Brown 
315103a8feaSLen Brown 	sprintf(pathname, "/dev/cpu/%d/msr", cpu);
316103a8feaSLen Brown 	fd = open(pathname, O_RDONLY);
31715aaa346SLen Brown 	if (fd < 0)
31898481e79SLen Brown 		err(-1, "%s open failed, try chown or chmod +r /dev/cpu/*/msr, or run as root", pathname);
319103a8feaSLen Brown 
32036229897SLen Brown 	fd_percpu[cpu] = fd;
32136229897SLen Brown 
32236229897SLen Brown 	return fd;
32336229897SLen Brown }
32436229897SLen Brown 
32536229897SLen Brown int get_msr(int cpu, off_t offset, unsigned long long *msr)
32636229897SLen Brown {
32736229897SLen Brown 	ssize_t retval;
32836229897SLen Brown 
32936229897SLen Brown 	retval = pread(get_msr_fd(cpu), msr, sizeof(*msr), offset);
33015aaa346SLen Brown 
33198481e79SLen Brown 	if (retval != sizeof *msr)
332cf4cbe53SLen Brown 		err(-1, "cpu%d: msr offset 0x%llx read failed", cpu, (unsigned long long)offset);
33315aaa346SLen Brown 
33415aaa346SLen Brown 	return 0;
335103a8feaSLen Brown }
336103a8feaSLen Brown 
337fc04cc67SLen Brown /*
338812db3f7SLen Brown  * Each string in this array is compared in --show and --hide cmdline.
339812db3f7SLen Brown  * Thus, strings that are proper sub-sets must follow their more specific peers.
340fc04cc67SLen Brown  */
341812db3f7SLen Brown struct msr_counter bic[] = {
342812db3f7SLen Brown 	{ 0x0, "Package" },
343812db3f7SLen Brown 	{ 0x0, "Avg_MHz" },
344812db3f7SLen Brown 	{ 0x0, "Bzy_MHz" },
345812db3f7SLen Brown 	{ 0x0, "TSC_MHz" },
346812db3f7SLen Brown 	{ 0x0, "IRQ" },
347812db3f7SLen Brown 	{ 0x0, "SMI", 32, 0, FORMAT_DELTA, NULL},
348812db3f7SLen Brown 	{ 0x0, "Busy%" },
349812db3f7SLen Brown 	{ 0x0, "CPU%c1" },
350812db3f7SLen Brown 	{ 0x0, "CPU%c3" },
351812db3f7SLen Brown 	{ 0x0, "CPU%c6" },
352812db3f7SLen Brown 	{ 0x0, "CPU%c7" },
353812db3f7SLen Brown 	{ 0x0, "ThreadC" },
354812db3f7SLen Brown 	{ 0x0, "CoreTmp" },
355812db3f7SLen Brown 	{ 0x0, "CoreCnt" },
356812db3f7SLen Brown 	{ 0x0, "PkgTmp" },
357812db3f7SLen Brown 	{ 0x0, "GFX%rc6" },
358812db3f7SLen Brown 	{ 0x0, "GFXMHz" },
359812db3f7SLen Brown 	{ 0x0, "Pkg%pc2" },
360812db3f7SLen Brown 	{ 0x0, "Pkg%pc3" },
361812db3f7SLen Brown 	{ 0x0, "Pkg%pc6" },
362812db3f7SLen Brown 	{ 0x0, "Pkg%pc7" },
3630f47c08dSLen Brown 	{ 0x0, "Pkg%pc8" },
3640f47c08dSLen Brown 	{ 0x0, "Pkg%pc9" },
3650f47c08dSLen Brown 	{ 0x0, "Pkg%pc10" },
366812db3f7SLen Brown 	{ 0x0, "PkgWatt" },
367812db3f7SLen Brown 	{ 0x0, "CorWatt" },
368812db3f7SLen Brown 	{ 0x0, "GFXWatt" },
369812db3f7SLen Brown 	{ 0x0, "PkgCnt" },
370812db3f7SLen Brown 	{ 0x0, "RAMWatt" },
371812db3f7SLen Brown 	{ 0x0, "PKG_%" },
372812db3f7SLen Brown 	{ 0x0, "RAM_%" },
373812db3f7SLen Brown 	{ 0x0, "Pkg_J" },
374812db3f7SLen Brown 	{ 0x0, "Cor_J" },
375812db3f7SLen Brown 	{ 0x0, "GFX_J" },
376812db3f7SLen Brown 	{ 0x0, "RAM_J" },
377812db3f7SLen Brown 	{ 0x0, "Core" },
378812db3f7SLen Brown 	{ 0x0, "CPU" },
3790539ba11SLen Brown 	{ 0x0, "Mod%c6" },
380812db3f7SLen Brown };
381812db3f7SLen Brown 
382812db3f7SLen Brown #define MAX_BIC (sizeof(bic) / sizeof(struct msr_counter))
383812db3f7SLen Brown #define	BIC_Package	(1ULL << 0)
384812db3f7SLen Brown #define	BIC_Avg_MHz	(1ULL << 1)
385812db3f7SLen Brown #define	BIC_Bzy_MHz	(1ULL << 2)
386812db3f7SLen Brown #define	BIC_TSC_MHz	(1ULL << 3)
387812db3f7SLen Brown #define	BIC_IRQ		(1ULL << 4)
388812db3f7SLen Brown #define	BIC_SMI		(1ULL << 5)
389812db3f7SLen Brown #define	BIC_Busy	(1ULL << 6)
390812db3f7SLen Brown #define	BIC_CPU_c1	(1ULL << 7)
391812db3f7SLen Brown #define	BIC_CPU_c3	(1ULL << 8)
392812db3f7SLen Brown #define	BIC_CPU_c6	(1ULL << 9)
393812db3f7SLen Brown #define	BIC_CPU_c7	(1ULL << 10)
394812db3f7SLen Brown #define	BIC_ThreadC	(1ULL << 11)
395812db3f7SLen Brown #define	BIC_CoreTmp	(1ULL << 12)
396812db3f7SLen Brown #define	BIC_CoreCnt	(1ULL << 13)
397812db3f7SLen Brown #define	BIC_PkgTmp	(1ULL << 14)
398812db3f7SLen Brown #define	BIC_GFX_rc6	(1ULL << 15)
399812db3f7SLen Brown #define	BIC_GFXMHz	(1ULL << 16)
400812db3f7SLen Brown #define	BIC_Pkgpc2	(1ULL << 17)
401812db3f7SLen Brown #define	BIC_Pkgpc3	(1ULL << 18)
402812db3f7SLen Brown #define	BIC_Pkgpc6	(1ULL << 19)
403812db3f7SLen Brown #define	BIC_Pkgpc7	(1ULL << 20)
4040f47c08dSLen Brown #define	BIC_Pkgpc8	(1ULL << 21)
4050f47c08dSLen Brown #define	BIC_Pkgpc9	(1ULL << 22)
4060f47c08dSLen Brown #define	BIC_Pkgpc10	(1ULL << 23)
4070f47c08dSLen Brown #define	BIC_PkgWatt	(1ULL << 24)
4080f47c08dSLen Brown #define	BIC_CorWatt	(1ULL << 25)
4090f47c08dSLen Brown #define	BIC_GFXWatt	(1ULL << 26)
4100f47c08dSLen Brown #define	BIC_PkgCnt	(1ULL << 27)
4110f47c08dSLen Brown #define	BIC_RAMWatt	(1ULL << 28)
4120f47c08dSLen Brown #define	BIC_PKG__	(1ULL << 29)
4130f47c08dSLen Brown #define	BIC_RAM__	(1ULL << 30)
4140f47c08dSLen Brown #define	BIC_Pkg_J	(1ULL << 31)
4150f47c08dSLen Brown #define	BIC_Cor_J	(1ULL << 32)
4160f47c08dSLen Brown #define	BIC_GFX_J	(1ULL << 33)
4170f47c08dSLen Brown #define	BIC_RAM_J	(1ULL << 34)
4180f47c08dSLen Brown #define	BIC_Core	(1ULL << 35)
4190f47c08dSLen Brown #define	BIC_CPU		(1ULL << 36)
4200f47c08dSLen Brown #define	BIC_Mod_c6	(1ULL << 37)
421812db3f7SLen Brown 
422812db3f7SLen Brown unsigned long long bic_enabled = 0xFFFFFFFFFFFFFFFFULL;
423812db3f7SLen Brown unsigned long long bic_present;
424812db3f7SLen Brown 
425812db3f7SLen Brown #define DO_BIC(COUNTER_NAME) (bic_enabled & bic_present & COUNTER_NAME)
426812db3f7SLen Brown #define BIC_PRESENT(COUNTER_BIT) (bic_present |= COUNTER_BIT)
4270f47c08dSLen Brown #define BIC_NOT_PRESENT(COUNTER_BIT) (bic_present &= ~COUNTER_BIT)
428812db3f7SLen Brown 
429812db3f7SLen Brown /*
430812db3f7SLen Brown  * bic_lookup
431812db3f7SLen Brown  * for all the strings in comma separate name_list,
432812db3f7SLen Brown  * set the approprate bit in return value.
433812db3f7SLen Brown  */
434812db3f7SLen Brown unsigned long long bic_lookup(char *name_list)
435812db3f7SLen Brown {
436812db3f7SLen Brown 	int i;
437812db3f7SLen Brown 	unsigned long long retval = 0;
438812db3f7SLen Brown 
439812db3f7SLen Brown 	while (name_list) {
440812db3f7SLen Brown 		char *comma;
441812db3f7SLen Brown 
442812db3f7SLen Brown 		comma = strchr(name_list, ',');
443812db3f7SLen Brown 
444812db3f7SLen Brown 		if (comma)
445812db3f7SLen Brown 			*comma = '\0';
446812db3f7SLen Brown 
447812db3f7SLen Brown 		for (i = 0; i < MAX_BIC; ++i) {
448812db3f7SLen Brown 			if (!strcmp(name_list, bic[i].name)) {
449812db3f7SLen Brown 				retval |= (1ULL << i);
450812db3f7SLen Brown 				break;
451812db3f7SLen Brown 			}
452812db3f7SLen Brown 		}
453812db3f7SLen Brown 		if (i == MAX_BIC) {
454812db3f7SLen Brown 			fprintf(stderr, "Invalid counter name: %s\n", name_list);
455812db3f7SLen Brown 			exit(-1);
456812db3f7SLen Brown 		}
457812db3f7SLen Brown 
458812db3f7SLen Brown 		name_list = comma;
459812db3f7SLen Brown 		if (name_list)
460812db3f7SLen Brown 			name_list++;
461812db3f7SLen Brown 
462812db3f7SLen Brown 	}
463812db3f7SLen Brown 	return retval;
464812db3f7SLen Brown }
465fc04cc67SLen Brown 
466a829eb4dSLen Brown void print_header(void)
467103a8feaSLen Brown {
468388e9c81SLen Brown 	struct msr_counter *mp;
469388e9c81SLen Brown 
470812db3f7SLen Brown 	if (DO_BIC(BIC_Package))
4713d109de2SLen Brown 		outp += sprintf(outp, "\tPackage");
472812db3f7SLen Brown 	if (DO_BIC(BIC_Core))
4733d109de2SLen Brown 		outp += sprintf(outp, "\tCore");
474812db3f7SLen Brown 	if (DO_BIC(BIC_CPU))
4753d109de2SLen Brown 		outp += sprintf(outp, "\tCPU");
476812db3f7SLen Brown 	if (DO_BIC(BIC_Avg_MHz))
4773d109de2SLen Brown 		outp += sprintf(outp, "\tAvg_MHz");
478812db3f7SLen Brown 	if (DO_BIC(BIC_Busy))
4793d109de2SLen Brown 		outp += sprintf(outp, "\tBusy%%");
480812db3f7SLen Brown 	if (DO_BIC(BIC_Bzy_MHz))
4813d109de2SLen Brown 		outp += sprintf(outp, "\tBzy_MHz");
482812db3f7SLen Brown 	if (DO_BIC(BIC_TSC_MHz))
4833d109de2SLen Brown 		outp += sprintf(outp, "\tTSC_MHz");
4841cc21f7bSLen Brown 
485812db3f7SLen Brown 	if (DO_BIC(BIC_IRQ))
4863d109de2SLen Brown 		outp += sprintf(outp, "\tIRQ");
487812db3f7SLen Brown 	if (DO_BIC(BIC_SMI))
4883d109de2SLen Brown 		outp += sprintf(outp, "\tSMI");
4891cc21f7bSLen Brown 
490812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c1))
4913d109de2SLen Brown 		outp += sprintf(outp, "\tCPU%%c1");
492889facbeSLen Brown 
493388e9c81SLen Brown 	for (mp = sys.tp; mp; mp = mp->next) {
494388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
495388e9c81SLen Brown 			if (mp->width == 64)
496388e9c81SLen Brown 				outp += sprintf(outp, "\t%18.18s", mp->name);
497388e9c81SLen Brown 			else
498388e9c81SLen Brown 				outp += sprintf(outp, "\t%10.10s", mp->name);
499388e9c81SLen Brown 		} else {
500388e9c81SLen Brown 			outp += sprintf(outp, "\t%-7.7s", mp->name);
501388e9c81SLen Brown 		}
502388e9c81SLen Brown 	}
503388e9c81SLen Brown 
504812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c3) && !do_slm_cstates && !do_knl_cstates)
505678a3bd1SLen Brown 		outp += sprintf(outp, "\tCPU%%c3");
506812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c6))
507678a3bd1SLen Brown 		outp += sprintf(outp, "\tCPU%%c6");
508812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c7))
509678a3bd1SLen Brown 		outp += sprintf(outp, "\tCPU%%c7");
510678a3bd1SLen Brown 
5110539ba11SLen Brown 	if (DO_BIC(BIC_Mod_c6))
5120539ba11SLen Brown 		outp += sprintf(outp, "\tMod%%c6");
513678a3bd1SLen Brown 
514812db3f7SLen Brown 	if (DO_BIC(BIC_CoreTmp))
5153d109de2SLen Brown 		outp += sprintf(outp, "\tCoreTmp");
516388e9c81SLen Brown 
517388e9c81SLen Brown 	for (mp = sys.cp; mp; mp = mp->next) {
518388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
519388e9c81SLen Brown 			if (mp->width == 64)
520388e9c81SLen Brown 				outp += sprintf(outp, "\t%18.18s", mp->name);
521388e9c81SLen Brown 			else
522388e9c81SLen Brown 				outp += sprintf(outp, "\t%10.10s", mp->name);
523388e9c81SLen Brown 		} else {
524388e9c81SLen Brown 			outp += sprintf(outp, "\t%-7.7s", mp->name);
525388e9c81SLen Brown 		}
526388e9c81SLen Brown 	}
527388e9c81SLen Brown 
528812db3f7SLen Brown 	if (DO_BIC(BIC_PkgTmp))
5293d109de2SLen Brown 		outp += sprintf(outp, "\tPkgTmp");
530889facbeSLen Brown 
531812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_rc6))
5323d109de2SLen Brown 		outp += sprintf(outp, "\tGFX%%rc6");
533fdf676e5SLen Brown 
534812db3f7SLen Brown 	if (DO_BIC(BIC_GFXMHz))
5353d109de2SLen Brown 		outp += sprintf(outp, "\tGFXMHz");
53627d47356SLen Brown 
5370b2bb692SLen Brown 	if (do_skl_residency) {
5383d109de2SLen Brown 		outp += sprintf(outp, "\tTotl%%C0");
5393d109de2SLen Brown 		outp += sprintf(outp, "\tAny%%C0");
5403d109de2SLen Brown 		outp += sprintf(outp, "\tGFX%%C0");
5413d109de2SLen Brown 		outp += sprintf(outp, "\tCPUGFX%%");
5420b2bb692SLen Brown 	}
5430b2bb692SLen Brown 
5440f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc2))
5453d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc2");
5460f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc3))
5473d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc3");
5480f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc6))
5493d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc6");
5500f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc7))
5513d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc7");
5520f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc8))
5533d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc8");
5540f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc9))
5553d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc9");
5560f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc10))
5573d109de2SLen Brown 		outp += sprintf(outp, "\tPk%%pc10");
558103a8feaSLen Brown 
5595c56be9aSDirk Brandewie 	if (do_rapl && !rapl_joules) {
560812db3f7SLen Brown 		if (DO_BIC(BIC_PkgWatt))
5613d109de2SLen Brown 			outp += sprintf(outp, "\tPkgWatt");
562812db3f7SLen Brown 		if (DO_BIC(BIC_CorWatt))
5633d109de2SLen Brown 			outp += sprintf(outp, "\tCorWatt");
564812db3f7SLen Brown 		if (DO_BIC(BIC_GFXWatt))
5653d109de2SLen Brown 			outp += sprintf(outp, "\tGFXWatt");
566812db3f7SLen Brown 		if (DO_BIC(BIC_RAMWatt))
5673d109de2SLen Brown 			outp += sprintf(outp, "\tRAMWatt");
568812db3f7SLen Brown 		if (DO_BIC(BIC_PKG__))
5693d109de2SLen Brown 			outp += sprintf(outp, "\tPKG_%%");
570812db3f7SLen Brown 		if (DO_BIC(BIC_RAM__))
5713d109de2SLen Brown 			outp += sprintf(outp, "\tRAM_%%");
572d7899447SLen Brown 	} else if (do_rapl && rapl_joules) {
573812db3f7SLen Brown 		if (DO_BIC(BIC_Pkg_J))
5743d109de2SLen Brown 			outp += sprintf(outp, "\tPkg_J");
575812db3f7SLen Brown 		if (DO_BIC(BIC_Cor_J))
5763d109de2SLen Brown 			outp += sprintf(outp, "\tCor_J");
577812db3f7SLen Brown 		if (DO_BIC(BIC_GFX_J))
5783d109de2SLen Brown 			outp += sprintf(outp, "\tGFX_J");
579812db3f7SLen Brown 		if (DO_BIC(BIC_RAM_J))
5803d109de2SLen Brown 			outp += sprintf(outp, "\tRAM_J");
581812db3f7SLen Brown 		if (DO_BIC(BIC_PKG__))
5823d109de2SLen Brown 			outp += sprintf(outp, "\tPKG_%%");
583812db3f7SLen Brown 		if (DO_BIC(BIC_RAM__))
5843d109de2SLen Brown 			outp += sprintf(outp, "\tRAM_%%");
5855c56be9aSDirk Brandewie 	}
586388e9c81SLen Brown 	for (mp = sys.pp; mp; mp = mp->next) {
587388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
588388e9c81SLen Brown 			if (mp->width == 64)
589388e9c81SLen Brown 				outp += sprintf(outp, "\t%18.18s", mp->name);
590388e9c81SLen Brown 			else
591388e9c81SLen Brown 				outp += sprintf(outp, "\t%10.10s", mp->name);
592388e9c81SLen Brown 		} else {
593388e9c81SLen Brown 			outp += sprintf(outp, "\t%-7.7s", mp->name);
594388e9c81SLen Brown 		}
595388e9c81SLen Brown 	}
596388e9c81SLen Brown 
597c98d5d94SLen Brown 	outp += sprintf(outp, "\n");
598103a8feaSLen Brown }
599103a8feaSLen Brown 
600c98d5d94SLen Brown int dump_counters(struct thread_data *t, struct core_data *c,
601c98d5d94SLen Brown 	struct pkg_data *p)
602103a8feaSLen Brown {
603388e9c81SLen Brown 	int i;
604388e9c81SLen Brown 	struct msr_counter *mp;
605388e9c81SLen Brown 
6063b4d5c7fSAndy Shevchenko 	outp += sprintf(outp, "t %p, c %p, p %p\n", t, c, p);
607c98d5d94SLen Brown 
608c98d5d94SLen Brown 	if (t) {
6093b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "CPU: %d flags 0x%x\n",
6103b4d5c7fSAndy Shevchenko 			t->cpu_id, t->flags);
6113b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "TSC: %016llX\n", t->tsc);
6123b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "aperf: %016llX\n", t->aperf);
6133b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "mperf: %016llX\n", t->mperf);
6143b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c1: %016llX\n", t->c1);
6156886fee4SLen Brown 
616812db3f7SLen Brown 		if (DO_BIC(BIC_IRQ))
617562a2d37SLen Brown 			outp += sprintf(outp, "IRQ: %08X\n", t->irq_count);
618812db3f7SLen Brown 		if (DO_BIC(BIC_SMI))
6193b4d5c7fSAndy Shevchenko 			outp += sprintf(outp, "SMI: %08X\n", t->smi_count);
620388e9c81SLen Brown 
621388e9c81SLen Brown 		for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
622388e9c81SLen Brown 			outp += sprintf(outp, "tADDED [%d] msr0x%x: %08llX\n",
623388e9c81SLen Brown 				i, mp->msr_num, t->counter[i]);
624388e9c81SLen Brown 		}
625103a8feaSLen Brown 	}
626103a8feaSLen Brown 
627c98d5d94SLen Brown 	if (c) {
6283b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "core: %d\n", c->core_id);
6293b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c3: %016llX\n", c->c3);
6303b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c6: %016llX\n", c->c6);
6313b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c7: %016llX\n", c->c7);
6323b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "DTS: %dC\n", c->core_temp_c);
633388e9c81SLen Brown 
634388e9c81SLen Brown 		for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
635388e9c81SLen Brown 			outp += sprintf(outp, "cADDED [%d] msr0x%x: %08llX\n",
636388e9c81SLen Brown 				i, mp->msr_num, c->counter[i]);
637388e9c81SLen Brown 		}
6380539ba11SLen Brown 		outp += sprintf(outp, "mc6_us: %016llX\n", c->mc6_us);
639c98d5d94SLen Brown 	}
640103a8feaSLen Brown 
641c98d5d94SLen Brown 	if (p) {
6423b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "package: %d\n", p->package_id);
6430b2bb692SLen Brown 
6440b2bb692SLen Brown 		outp += sprintf(outp, "Weighted cores: %016llX\n", p->pkg_wtd_core_c0);
6450b2bb692SLen Brown 		outp += sprintf(outp, "Any cores: %016llX\n", p->pkg_any_core_c0);
6460b2bb692SLen Brown 		outp += sprintf(outp, "Any GFX: %016llX\n", p->pkg_any_gfxe_c0);
6470b2bb692SLen Brown 		outp += sprintf(outp, "CPU + GFX: %016llX\n", p->pkg_both_core_gfxe_c0);
6480b2bb692SLen Brown 
6493b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc2: %016llX\n", p->pc2);
6500f47c08dSLen Brown 		if (DO_BIC(BIC_Pkgpc3))
6513b4d5c7fSAndy Shevchenko 			outp += sprintf(outp, "pc3: %016llX\n", p->pc3);
6520f47c08dSLen Brown 		if (DO_BIC(BIC_Pkgpc6))
6533b4d5c7fSAndy Shevchenko 			outp += sprintf(outp, "pc6: %016llX\n", p->pc6);
6540f47c08dSLen Brown 		if (DO_BIC(BIC_Pkgpc7))
6553b4d5c7fSAndy Shevchenko 			outp += sprintf(outp, "pc7: %016llX\n", p->pc7);
6563b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc8: %016llX\n", p->pc8);
6573b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc9: %016llX\n", p->pc9);
6583b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc10: %016llX\n", p->pc10);
6593b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules PKG: %0X\n", p->energy_pkg);
6603b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules COR: %0X\n", p->energy_cores);
6613b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules GFX: %0X\n", p->energy_gfx);
6623b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules RAM: %0X\n", p->energy_dram);
6633b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Throttle PKG: %0X\n",
6643b4d5c7fSAndy Shevchenko 			p->rapl_pkg_perf_status);
6653b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Throttle RAM: %0X\n",
6663b4d5c7fSAndy Shevchenko 			p->rapl_dram_perf_status);
6673b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "PTM: %dC\n", p->pkg_temp_c);
668388e9c81SLen Brown 
669388e9c81SLen Brown 		for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
670388e9c81SLen Brown 			outp += sprintf(outp, "pADDED [%d] msr0x%x: %08llX\n",
671388e9c81SLen Brown 				i, mp->msr_num, p->counter[i]);
672388e9c81SLen Brown 		}
673c98d5d94SLen Brown 	}
6743b4d5c7fSAndy Shevchenko 
6753b4d5c7fSAndy Shevchenko 	outp += sprintf(outp, "\n");
6763b4d5c7fSAndy Shevchenko 
677c98d5d94SLen Brown 	return 0;
678103a8feaSLen Brown }
679103a8feaSLen Brown 
680e23da037SLen Brown /*
681e23da037SLen Brown  * column formatting convention & formats
682e23da037SLen Brown  */
683c98d5d94SLen Brown int format_counters(struct thread_data *t, struct core_data *c,
684c98d5d94SLen Brown 	struct pkg_data *p)
685103a8feaSLen Brown {
686008d396eSLen Brown 	double interval_float, tsc;
687fc04cc67SLen Brown 	char *fmt8;
688388e9c81SLen Brown 	int i;
689388e9c81SLen Brown 	struct msr_counter *mp;
690103a8feaSLen Brown 
691c98d5d94SLen Brown 	 /* if showing only 1st thread in core and this isn't one, bail out */
692c98d5d94SLen Brown 	if (show_core_only && !(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
693c98d5d94SLen Brown 		return 0;
694c98d5d94SLen Brown 
695c98d5d94SLen Brown 	 /* if showing only 1st thread in pkg and this isn't one, bail out */
696c98d5d94SLen Brown 	if (show_pkg_only && !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
697c98d5d94SLen Brown 		return 0;
698c98d5d94SLen Brown 
699103a8feaSLen Brown 	interval_float = tv_delta.tv_sec + tv_delta.tv_usec/1000000.0;
700103a8feaSLen Brown 
701008d396eSLen Brown 	tsc = t->tsc * tsc_tweak;
702008d396eSLen Brown 
703c98d5d94SLen Brown 	/* topo columns, print blanks on 1st (average) line */
704c98d5d94SLen Brown 	if (t == &average.threads) {
705812db3f7SLen Brown 		if (DO_BIC(BIC_Package))
7063d109de2SLen Brown 			outp += sprintf(outp, "\t-");
707812db3f7SLen Brown 		if (DO_BIC(BIC_Core))
7083d109de2SLen Brown 			outp += sprintf(outp, "\t-");
709812db3f7SLen Brown 		if (DO_BIC(BIC_CPU))
7103d109de2SLen Brown 			outp += sprintf(outp, "\t-");
711103a8feaSLen Brown 	} else {
712812db3f7SLen Brown 		if (DO_BIC(BIC_Package)) {
713c98d5d94SLen Brown 			if (p)
7143d109de2SLen Brown 				outp += sprintf(outp, "\t%d", p->package_id);
715c98d5d94SLen Brown 			else
7163d109de2SLen Brown 				outp += sprintf(outp, "\t-");
717c98d5d94SLen Brown 		}
718812db3f7SLen Brown 		if (DO_BIC(BIC_Core)) {
719c98d5d94SLen Brown 			if (c)
7203d109de2SLen Brown 				outp += sprintf(outp, "\t%d", c->core_id);
721c98d5d94SLen Brown 			else
7223d109de2SLen Brown 				outp += sprintf(outp, "\t-");
723c98d5d94SLen Brown 		}
724812db3f7SLen Brown 		if (DO_BIC(BIC_CPU))
7253d109de2SLen Brown 			outp += sprintf(outp, "\t%d", t->cpu_id);
726103a8feaSLen Brown 	}
727fc04cc67SLen Brown 
728812db3f7SLen Brown 	if (DO_BIC(BIC_Avg_MHz))
7293d109de2SLen Brown 		outp += sprintf(outp, "\t%.0f",
730fc04cc67SLen Brown 			1.0 / units * t->aperf / interval_float);
731fc04cc67SLen Brown 
732812db3f7SLen Brown 	if (DO_BIC(BIC_Busy))
733008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * t->mperf/tsc);
734103a8feaSLen Brown 
735812db3f7SLen Brown 	if (DO_BIC(BIC_Bzy_MHz)) {
73621ed5574SLen Brown 		if (has_base_hz)
7373d109de2SLen Brown 			outp += sprintf(outp, "\t%.0f", base_hz / units * t->aperf / t->mperf);
73821ed5574SLen Brown 		else
7393d109de2SLen Brown 			outp += sprintf(outp, "\t%.0f",
740008d396eSLen Brown 				tsc / units * t->aperf / t->mperf / interval_float);
74121ed5574SLen Brown 	}
742103a8feaSLen Brown 
743812db3f7SLen Brown 	if (DO_BIC(BIC_TSC_MHz))
7443d109de2SLen Brown 		outp += sprintf(outp, "\t%.0f", 1.0 * t->tsc/units/interval_float);
745103a8feaSLen Brown 
746562a2d37SLen Brown 	/* IRQ */
747812db3f7SLen Brown 	if (DO_BIC(BIC_IRQ))
7483d109de2SLen Brown 		outp += sprintf(outp, "\t%d", t->irq_count);
749562a2d37SLen Brown 
7501cc21f7bSLen Brown 	/* SMI */
751812db3f7SLen Brown 	if (DO_BIC(BIC_SMI))
7523d109de2SLen Brown 		outp += sprintf(outp, "\t%d", t->smi_count);
7531cc21f7bSLen Brown 
754678a3bd1SLen Brown 	/* C1 */
755812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c1))
756008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * t->c1/tsc);
757c98d5d94SLen Brown 
758678a3bd1SLen Brown 	/* Added counters */
759678a3bd1SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
760678a3bd1SLen Brown 		if (mp->format == FORMAT_RAW) {
761678a3bd1SLen Brown 			if (mp->width == 32)
762678a3bd1SLen Brown 				outp += sprintf(outp, "\t0x%08lx", (unsigned long) t->counter[i]);
763678a3bd1SLen Brown 			else
764678a3bd1SLen Brown 				outp += sprintf(outp, "\t0x%016llx", t->counter[i]);
765678a3bd1SLen Brown 		} else if (mp->format == FORMAT_DELTA) {
766678a3bd1SLen Brown 			outp += sprintf(outp, "\t%lld", t->counter[i]);
767678a3bd1SLen Brown 		} else if (mp->format == FORMAT_PERCENT) {
768008d396eSLen Brown 			outp += sprintf(outp, "\t%.2f", 100.0 * t->counter[i]/tsc);
769678a3bd1SLen Brown 		}
770678a3bd1SLen Brown 	}
771678a3bd1SLen Brown 
772c98d5d94SLen Brown 	/* print per-core data only for 1st thread in core */
773c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
774c98d5d94SLen Brown 		goto done;
775c98d5d94SLen Brown 
776812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c3) && !do_slm_cstates && !do_knl_cstates)
777008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * c->c3/tsc);
778812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c6))
779008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * c->c6/tsc);
780812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c7))
781008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * c->c7/tsc);
782c98d5d94SLen Brown 
7830539ba11SLen Brown 	/* Mod%c6 */
7840539ba11SLen Brown 	if (DO_BIC(BIC_Mod_c6))
785008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * c->mc6_us / tsc);
7860539ba11SLen Brown 
787812db3f7SLen Brown 	if (DO_BIC(BIC_CoreTmp))
7883d109de2SLen Brown 		outp += sprintf(outp, "\t%d", c->core_temp_c);
789889facbeSLen Brown 
790388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
791388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
792388e9c81SLen Brown 			if (mp->width == 32)
793388e9c81SLen Brown 				outp += sprintf(outp, "\t0x%08lx", (unsigned long) c->counter[i]);
794388e9c81SLen Brown 			else
795388e9c81SLen Brown 				outp += sprintf(outp, "\t0x%016llx", c->counter[i]);
796388e9c81SLen Brown 		} else if (mp->format == FORMAT_DELTA) {
797678a3bd1SLen Brown 			outp += sprintf(outp, "\t%lld", c->counter[i]);
798388e9c81SLen Brown 		} else if (mp->format == FORMAT_PERCENT) {
799008d396eSLen Brown 			outp += sprintf(outp, "\t%.2f", 100.0 * c->counter[i]/tsc);
800388e9c81SLen Brown 		}
801388e9c81SLen Brown 	}
802388e9c81SLen Brown 
803c98d5d94SLen Brown 	/* print per-package data only for 1st core in package */
804c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
805c98d5d94SLen Brown 		goto done;
806c98d5d94SLen Brown 
8070b2bb692SLen Brown 	/* PkgTmp */
808812db3f7SLen Brown 	if (DO_BIC(BIC_PkgTmp))
8093d109de2SLen Brown 		outp += sprintf(outp, "\t%d", p->pkg_temp_c);
810889facbeSLen Brown 
811fdf676e5SLen Brown 	/* GFXrc6 */
812812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_rc6)) {
813ba3dec99SLen Brown 		if (p->gfx_rc6_ms == -1) {	/* detect GFX counter reset */
8143d109de2SLen Brown 			outp += sprintf(outp, "\t**.**");
8159185e988SLen Brown 		} else {
8163d109de2SLen Brown 			outp += sprintf(outp, "\t%.2f",
8179185e988SLen Brown 				p->gfx_rc6_ms / 10.0 / interval_float);
8189185e988SLen Brown 		}
8199185e988SLen Brown 	}
820fdf676e5SLen Brown 
82127d47356SLen Brown 	/* GFXMHz */
822812db3f7SLen Brown 	if (DO_BIC(BIC_GFXMHz))
8233d109de2SLen Brown 		outp += sprintf(outp, "\t%d", p->gfx_mhz);
82427d47356SLen Brown 
8250b2bb692SLen Brown 	/* Totl%C0, Any%C0 GFX%C0 CPUGFX% */
8260b2bb692SLen Brown 	if (do_skl_residency) {
827008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_wtd_core_c0/tsc);
828008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_any_core_c0/tsc);
829008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_any_gfxe_c0/tsc);
830008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_both_core_gfxe_c0/tsc);
8310b2bb692SLen Brown 	}
8320b2bb692SLen Brown 
8330f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc2))
834008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc2/tsc);
8350f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc3))
836008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc3/tsc);
8370f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc6))
838008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc6/tsc);
8390f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc7))
840008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc7/tsc);
8410f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc8))
842008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc8/tsc);
8430f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc9))
844008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc9/tsc);
8450f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc10))
846008d396eSLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc10/tsc);
847889facbeSLen Brown 
848889facbeSLen Brown 	/*
849889facbeSLen Brown  	 * If measurement interval exceeds minimum RAPL Joule Counter range,
850889facbeSLen Brown  	 * indicate that results are suspect by printing "**" in fraction place.
851889facbeSLen Brown  	 */
852fc04cc67SLen Brown 	if (interval_float < rapl_joule_counter_range)
8533d109de2SLen Brown 		fmt8 = "\t%.2f";
854fc04cc67SLen Brown 	else
855fc04cc67SLen Brown 		fmt8 = "%6.0f**";
856889facbeSLen Brown 
857812db3f7SLen Brown 	if (DO_BIC(BIC_PkgWatt))
858fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, p->energy_pkg * rapl_energy_units / interval_float);
859812db3f7SLen Brown 	if (DO_BIC(BIC_CorWatt))
860fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, p->energy_cores * rapl_energy_units / interval_float);
861812db3f7SLen Brown 	if (DO_BIC(BIC_GFXWatt))
862fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, p->energy_gfx * rapl_energy_units / interval_float);
863812db3f7SLen Brown 	if (DO_BIC(BIC_RAMWatt))
86440ee8e3bSAndrey Semin 		outp += sprintf(outp, fmt8, p->energy_dram * rapl_dram_energy_units / interval_float);
865812db3f7SLen Brown 	if (DO_BIC(BIC_Pkg_J))
866812db3f7SLen Brown 		outp += sprintf(outp, fmt8, p->energy_pkg * rapl_energy_units);
867812db3f7SLen Brown 	if (DO_BIC(BIC_Cor_J))
868812db3f7SLen Brown 		outp += sprintf(outp, fmt8, p->energy_cores * rapl_energy_units);
869812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_J))
870812db3f7SLen Brown 		outp += sprintf(outp, fmt8, p->energy_gfx * rapl_energy_units);
871812db3f7SLen Brown 	if (DO_BIC(BIC_RAM_J))
872812db3f7SLen Brown 		outp += sprintf(outp, fmt8, p->energy_dram * rapl_dram_energy_units);
873812db3f7SLen Brown 	if (DO_BIC(BIC_PKG__))
874fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, 100.0 * p->rapl_pkg_perf_status * rapl_time_units / interval_float);
875812db3f7SLen Brown 	if (DO_BIC(BIC_RAM__))
876fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, 100.0 * p->rapl_dram_perf_status * rapl_time_units / interval_float);
877812db3f7SLen Brown 
878388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
879388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
880388e9c81SLen Brown 			if (mp->width == 32)
881388e9c81SLen Brown 				outp += sprintf(outp, "\t0x%08lx", (unsigned long) p->counter[i]);
882388e9c81SLen Brown 			else
883388e9c81SLen Brown 				outp += sprintf(outp, "\t0x%016llx", p->counter[i]);
884388e9c81SLen Brown 		} else if (mp->format == FORMAT_DELTA) {
885678a3bd1SLen Brown 			outp += sprintf(outp, "\t%lld", p->counter[i]);
886388e9c81SLen Brown 		} else if (mp->format == FORMAT_PERCENT) {
887008d396eSLen Brown 			outp += sprintf(outp, "\t%.2f", 100.0 * p->counter[i]/tsc);
888388e9c81SLen Brown 		}
889388e9c81SLen Brown 	}
890388e9c81SLen Brown 
891c98d5d94SLen Brown done:
892c98d5d94SLen Brown 	outp += sprintf(outp, "\n");
893c98d5d94SLen Brown 
894c98d5d94SLen Brown 	return 0;
895103a8feaSLen Brown }
896103a8feaSLen Brown 
897b7d8c148SLen Brown void flush_output_stdout(void)
898103a8feaSLen Brown {
899b7d8c148SLen Brown 	FILE *filep;
900b7d8c148SLen Brown 
901b7d8c148SLen Brown 	if (outf == stderr)
902b7d8c148SLen Brown 		filep = stdout;
903b7d8c148SLen Brown 	else
904b7d8c148SLen Brown 		filep = outf;
905b7d8c148SLen Brown 
906b7d8c148SLen Brown 	fputs(output_buffer, filep);
907b7d8c148SLen Brown 	fflush(filep);
908b7d8c148SLen Brown 
909c98d5d94SLen Brown 	outp = output_buffer;
910c98d5d94SLen Brown }
911b7d8c148SLen Brown void flush_output_stderr(void)
912c98d5d94SLen Brown {
913b7d8c148SLen Brown 	fputs(output_buffer, outf);
914b7d8c148SLen Brown 	fflush(outf);
915c98d5d94SLen Brown 	outp = output_buffer;
916c98d5d94SLen Brown }
917c98d5d94SLen Brown void format_all_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
918c98d5d94SLen Brown {
919e23da037SLen Brown 	static int printed;
920103a8feaSLen Brown 
921e23da037SLen Brown 	if (!printed || !summary_only)
922103a8feaSLen Brown 		print_header();
923103a8feaSLen Brown 
924c98d5d94SLen Brown 	if (topo.num_cpus > 1)
925c98d5d94SLen Brown 		format_counters(&average.threads, &average.cores,
926c98d5d94SLen Brown 			&average.packages);
927103a8feaSLen Brown 
928e23da037SLen Brown 	printed = 1;
929e23da037SLen Brown 
930e23da037SLen Brown 	if (summary_only)
931e23da037SLen Brown 		return;
932e23da037SLen Brown 
933c98d5d94SLen Brown 	for_all_cpus(format_counters, t, c, p);
934103a8feaSLen Brown }
935103a8feaSLen Brown 
936889facbeSLen Brown #define DELTA_WRAP32(new, old)			\
937889facbeSLen Brown 	if (new > old) {			\
938889facbeSLen Brown 		old = new - old;		\
939889facbeSLen Brown 	} else {				\
940889facbeSLen Brown 		old = 0x100000000 + new - old;	\
941889facbeSLen Brown 	}
942889facbeSLen Brown 
943ba3dec99SLen Brown int
944c98d5d94SLen Brown delta_package(struct pkg_data *new, struct pkg_data *old)
945103a8feaSLen Brown {
946388e9c81SLen Brown 	int i;
947388e9c81SLen Brown 	struct msr_counter *mp;
9480b2bb692SLen Brown 
9490b2bb692SLen Brown 	if (do_skl_residency) {
9500b2bb692SLen Brown 		old->pkg_wtd_core_c0 = new->pkg_wtd_core_c0 - old->pkg_wtd_core_c0;
9510b2bb692SLen Brown 		old->pkg_any_core_c0 = new->pkg_any_core_c0 - old->pkg_any_core_c0;
9520b2bb692SLen Brown 		old->pkg_any_gfxe_c0 = new->pkg_any_gfxe_c0 - old->pkg_any_gfxe_c0;
9530b2bb692SLen Brown 		old->pkg_both_core_gfxe_c0 = new->pkg_both_core_gfxe_c0 - old->pkg_both_core_gfxe_c0;
9540b2bb692SLen Brown 	}
955c98d5d94SLen Brown 	old->pc2 = new->pc2 - old->pc2;
9560f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc3))
957c98d5d94SLen Brown 		old->pc3 = new->pc3 - old->pc3;
9580f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc6))
959c98d5d94SLen Brown 		old->pc6 = new->pc6 - old->pc6;
9600f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc7))
961c98d5d94SLen Brown 		old->pc7 = new->pc7 - old->pc7;
962ca58710fSKristen Carlson Accardi 	old->pc8 = new->pc8 - old->pc8;
963ca58710fSKristen Carlson Accardi 	old->pc9 = new->pc9 - old->pc9;
964ca58710fSKristen Carlson Accardi 	old->pc10 = new->pc10 - old->pc10;
965889facbeSLen Brown 	old->pkg_temp_c = new->pkg_temp_c;
966889facbeSLen Brown 
9679185e988SLen Brown 	/* flag an error when rc6 counter resets/wraps */
9689185e988SLen Brown 	if (old->gfx_rc6_ms >  new->gfx_rc6_ms)
9699185e988SLen Brown 		old->gfx_rc6_ms = -1;
9709185e988SLen Brown 	else
971fdf676e5SLen Brown 		old->gfx_rc6_ms = new->gfx_rc6_ms - old->gfx_rc6_ms;
9729185e988SLen Brown 
97327d47356SLen Brown 	old->gfx_mhz = new->gfx_mhz;
97427d47356SLen Brown 
975889facbeSLen Brown 	DELTA_WRAP32(new->energy_pkg, old->energy_pkg);
976889facbeSLen Brown 	DELTA_WRAP32(new->energy_cores, old->energy_cores);
977889facbeSLen Brown 	DELTA_WRAP32(new->energy_gfx, old->energy_gfx);
978889facbeSLen Brown 	DELTA_WRAP32(new->energy_dram, old->energy_dram);
979889facbeSLen Brown 	DELTA_WRAP32(new->rapl_pkg_perf_status, old->rapl_pkg_perf_status);
980889facbeSLen Brown 	DELTA_WRAP32(new->rapl_dram_perf_status, old->rapl_dram_perf_status);
981ba3dec99SLen Brown 
982388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
983388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
984388e9c81SLen Brown 			old->counter[i] = new->counter[i];
985388e9c81SLen Brown 		else
986388e9c81SLen Brown 			old->counter[i] = new->counter[i] - old->counter[i];
987388e9c81SLen Brown 	}
988388e9c81SLen Brown 
989ba3dec99SLen Brown 	return 0;
990103a8feaSLen Brown }
991103a8feaSLen Brown 
992c98d5d94SLen Brown void
993c98d5d94SLen Brown delta_core(struct core_data *new, struct core_data *old)
994c98d5d94SLen Brown {
995388e9c81SLen Brown 	int i;
996388e9c81SLen Brown 	struct msr_counter *mp;
997388e9c81SLen Brown 
998c98d5d94SLen Brown 	old->c3 = new->c3 - old->c3;
999c98d5d94SLen Brown 	old->c6 = new->c6 - old->c6;
1000c98d5d94SLen Brown 	old->c7 = new->c7 - old->c7;
1001889facbeSLen Brown 	old->core_temp_c = new->core_temp_c;
10020539ba11SLen Brown 	old->mc6_us = new->mc6_us - old->mc6_us;
1003388e9c81SLen Brown 
1004388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
1005388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1006388e9c81SLen Brown 			old->counter[i] = new->counter[i];
1007388e9c81SLen Brown 		else
1008388e9c81SLen Brown 			old->counter[i] = new->counter[i] - old->counter[i];
1009388e9c81SLen Brown 	}
1010103a8feaSLen Brown }
1011c98d5d94SLen Brown 
1012c3ae331dSLen Brown /*
1013c3ae331dSLen Brown  * old = new - old
1014c3ae331dSLen Brown  */
1015ba3dec99SLen Brown int
1016c98d5d94SLen Brown delta_thread(struct thread_data *new, struct thread_data *old,
1017c98d5d94SLen Brown 	struct core_data *core_delta)
1018c98d5d94SLen Brown {
1019388e9c81SLen Brown 	int i;
1020388e9c81SLen Brown 	struct msr_counter *mp;
1021388e9c81SLen Brown 
1022c98d5d94SLen Brown 	old->tsc = new->tsc - old->tsc;
1023c98d5d94SLen Brown 
1024103a8feaSLen Brown 	/* check for TSC < 1 Mcycles over interval */
1025b2c95d90SJosh Triplett 	if (old->tsc < (1000 * 1000))
1026b2c95d90SJosh Triplett 		errx(-3, "Insanely slow TSC rate, TSC stops in idle?\n"
1027b2c95d90SJosh Triplett 		     "You can disable all c-states by booting with \"idle=poll\"\n"
1028b2c95d90SJosh Triplett 		     "or just the deep ones with \"processor.max_cstate=1\"");
1029103a8feaSLen Brown 
1030c98d5d94SLen Brown 	old->c1 = new->c1 - old->c1;
1031c98d5d94SLen Brown 
1032812db3f7SLen Brown 	if (DO_BIC(BIC_Avg_MHz) || DO_BIC(BIC_Busy) || DO_BIC(BIC_Bzy_MHz)) {
1033c98d5d94SLen Brown 		if ((new->aperf > old->aperf) && (new->mperf > old->mperf)) {
1034c98d5d94SLen Brown 			old->aperf = new->aperf - old->aperf;
1035c98d5d94SLen Brown 			old->mperf = new->mperf - old->mperf;
1036c98d5d94SLen Brown 		} else {
1037ba3dec99SLen Brown 			return -1;
1038103a8feaSLen Brown 		}
1039a729617cSLen Brown 	}
1040103a8feaSLen Brown 
1041c98d5d94SLen Brown 
1042144b44b1SLen Brown 	if (use_c1_residency_msr) {
1043144b44b1SLen Brown 		/*
1044144b44b1SLen Brown 		 * Some models have a dedicated C1 residency MSR,
1045144b44b1SLen Brown 		 * which should be more accurate than the derivation below.
1046144b44b1SLen Brown 		 */
1047144b44b1SLen Brown 	} else {
1048103a8feaSLen Brown 		/*
1049c3ae331dSLen Brown 		 * As counter collection is not atomic,
1050c3ae331dSLen Brown 		 * it is possible for mperf's non-halted cycles + idle states
1051103a8feaSLen Brown 		 * to exceed TSC's all cycles: show c1 = 0% in that case.
1052103a8feaSLen Brown 		 */
1053c3ae331dSLen Brown 		if ((old->mperf + core_delta->c3 + core_delta->c6 + core_delta->c7) > old->tsc)
1054c98d5d94SLen Brown 			old->c1 = 0;
1055c98d5d94SLen Brown 		else {
1056c98d5d94SLen Brown 			/* normal case, derive c1 */
1057008d396eSLen Brown 			old->c1 = (old->tsc * tsc_tweak) - old->mperf - core_delta->c3
1058c98d5d94SLen Brown 				- core_delta->c6 - core_delta->c7;
1059c98d5d94SLen Brown 		}
1060144b44b1SLen Brown 	}
1061c3ae331dSLen Brown 
1062c98d5d94SLen Brown 	if (old->mperf == 0) {
1063b7d8c148SLen Brown 		if (debug > 1)
1064b7d8c148SLen Brown 			fprintf(outf, "cpu%d MPERF 0!\n", old->cpu_id);
1065c98d5d94SLen Brown 		old->mperf = 1;	/* divide by 0 protection */
1066c98d5d94SLen Brown 	}
1067103a8feaSLen Brown 
1068812db3f7SLen Brown 	if (DO_BIC(BIC_IRQ))
1069562a2d37SLen Brown 		old->irq_count = new->irq_count - old->irq_count;
1070562a2d37SLen Brown 
1071812db3f7SLen Brown 	if (DO_BIC(BIC_SMI))
10721ed51011SLen Brown 		old->smi_count = new->smi_count - old->smi_count;
1073ba3dec99SLen Brown 
1074388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
1075388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1076388e9c81SLen Brown 			old->counter[i] = new->counter[i];
1077388e9c81SLen Brown 		else
1078388e9c81SLen Brown 			old->counter[i] = new->counter[i] - old->counter[i];
1079388e9c81SLen Brown 	}
1080ba3dec99SLen Brown 	return 0;
1081103a8feaSLen Brown }
1082c98d5d94SLen Brown 
1083c98d5d94SLen Brown int delta_cpu(struct thread_data *t, struct core_data *c,
1084c98d5d94SLen Brown 	struct pkg_data *p, struct thread_data *t2,
1085c98d5d94SLen Brown 	struct core_data *c2, struct pkg_data *p2)
1086c98d5d94SLen Brown {
1087ba3dec99SLen Brown 	int retval = 0;
1088ba3dec99SLen Brown 
1089c98d5d94SLen Brown 	/* calculate core delta only for 1st thread in core */
1090c98d5d94SLen Brown 	if (t->flags & CPU_IS_FIRST_THREAD_IN_CORE)
1091c98d5d94SLen Brown 		delta_core(c, c2);
1092c98d5d94SLen Brown 
1093c98d5d94SLen Brown 	/* always calculate thread delta */
1094ba3dec99SLen Brown 	retval = delta_thread(t, t2, c2);	/* c2 is core delta */
1095ba3dec99SLen Brown 	if (retval)
1096ba3dec99SLen Brown 		return retval;
1097c98d5d94SLen Brown 
1098c98d5d94SLen Brown 	/* calculate package delta only for 1st core in package */
1099c98d5d94SLen Brown 	if (t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)
1100ba3dec99SLen Brown 		retval = delta_package(p, p2);
1101c98d5d94SLen Brown 
1102ba3dec99SLen Brown 	return retval;
1103103a8feaSLen Brown }
1104103a8feaSLen Brown 
1105c98d5d94SLen Brown void clear_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
1106103a8feaSLen Brown {
1107388e9c81SLen Brown 	int i;
1108388e9c81SLen Brown 	struct msr_counter  *mp;
1109388e9c81SLen Brown 
1110c98d5d94SLen Brown 	t->tsc = 0;
1111c98d5d94SLen Brown 	t->aperf = 0;
1112c98d5d94SLen Brown 	t->mperf = 0;
1113c98d5d94SLen Brown 	t->c1 = 0;
1114103a8feaSLen Brown 
1115562a2d37SLen Brown 	t->irq_count = 0;
1116562a2d37SLen Brown 	t->smi_count = 0;
1117562a2d37SLen Brown 
1118c98d5d94SLen Brown 	/* tells format_counters to dump all fields from this set */
1119c98d5d94SLen Brown 	t->flags = CPU_IS_FIRST_THREAD_IN_CORE | CPU_IS_FIRST_CORE_IN_PACKAGE;
1120c98d5d94SLen Brown 
1121c98d5d94SLen Brown 	c->c3 = 0;
1122c98d5d94SLen Brown 	c->c6 = 0;
1123c98d5d94SLen Brown 	c->c7 = 0;
11240539ba11SLen Brown 	c->mc6_us = 0;
1125889facbeSLen Brown 	c->core_temp_c = 0;
1126c98d5d94SLen Brown 
11270b2bb692SLen Brown 	p->pkg_wtd_core_c0 = 0;
11280b2bb692SLen Brown 	p->pkg_any_core_c0 = 0;
11290b2bb692SLen Brown 	p->pkg_any_gfxe_c0 = 0;
11300b2bb692SLen Brown 	p->pkg_both_core_gfxe_c0 = 0;
11310b2bb692SLen Brown 
1132c98d5d94SLen Brown 	p->pc2 = 0;
11330f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc3))
1134c98d5d94SLen Brown 		p->pc3 = 0;
11350f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc6))
1136c98d5d94SLen Brown 		p->pc6 = 0;
11370f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc7))
1138c98d5d94SLen Brown 		p->pc7 = 0;
1139ca58710fSKristen Carlson Accardi 	p->pc8 = 0;
1140ca58710fSKristen Carlson Accardi 	p->pc9 = 0;
1141ca58710fSKristen Carlson Accardi 	p->pc10 = 0;
1142889facbeSLen Brown 
1143889facbeSLen Brown 	p->energy_pkg = 0;
1144889facbeSLen Brown 	p->energy_dram = 0;
1145889facbeSLen Brown 	p->energy_cores = 0;
1146889facbeSLen Brown 	p->energy_gfx = 0;
1147889facbeSLen Brown 	p->rapl_pkg_perf_status = 0;
1148889facbeSLen Brown 	p->rapl_dram_perf_status = 0;
1149889facbeSLen Brown 	p->pkg_temp_c = 0;
115027d47356SLen Brown 
1151fdf676e5SLen Brown 	p->gfx_rc6_ms = 0;
115227d47356SLen Brown 	p->gfx_mhz = 0;
1153388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next)
1154388e9c81SLen Brown 		t->counter[i] = 0;
1155388e9c81SLen Brown 
1156388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next)
1157388e9c81SLen Brown 		c->counter[i] = 0;
1158388e9c81SLen Brown 
1159388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next)
1160388e9c81SLen Brown 		p->counter[i] = 0;
1161103a8feaSLen Brown }
1162c98d5d94SLen Brown int sum_counters(struct thread_data *t, struct core_data *c,
1163c98d5d94SLen Brown 	struct pkg_data *p)
1164103a8feaSLen Brown {
1165388e9c81SLen Brown 	int i;
1166388e9c81SLen Brown 	struct msr_counter *mp;
1167388e9c81SLen Brown 
1168c98d5d94SLen Brown 	average.threads.tsc += t->tsc;
1169c98d5d94SLen Brown 	average.threads.aperf += t->aperf;
1170c98d5d94SLen Brown 	average.threads.mperf += t->mperf;
1171c98d5d94SLen Brown 	average.threads.c1 += t->c1;
117215aaa346SLen Brown 
1173562a2d37SLen Brown 	average.threads.irq_count += t->irq_count;
1174562a2d37SLen Brown 	average.threads.smi_count += t->smi_count;
1175562a2d37SLen Brown 
1176388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
1177388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1178388e9c81SLen Brown 			continue;
1179388e9c81SLen Brown 		average.threads.counter[i] += t->counter[i];
1180388e9c81SLen Brown 	}
1181388e9c81SLen Brown 
1182c98d5d94SLen Brown 	/* sum per-core values only for 1st thread in core */
1183c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
1184c98d5d94SLen Brown 		return 0;
1185c98d5d94SLen Brown 
1186c98d5d94SLen Brown 	average.cores.c3 += c->c3;
1187c98d5d94SLen Brown 	average.cores.c6 += c->c6;
1188c98d5d94SLen Brown 	average.cores.c7 += c->c7;
11890539ba11SLen Brown 	average.cores.mc6_us += c->mc6_us;
1190c98d5d94SLen Brown 
1191889facbeSLen Brown 	average.cores.core_temp_c = MAX(average.cores.core_temp_c, c->core_temp_c);
1192889facbeSLen Brown 
1193388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
1194388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1195388e9c81SLen Brown 			continue;
1196388e9c81SLen Brown 		average.cores.counter[i] += c->counter[i];
1197388e9c81SLen Brown 	}
1198388e9c81SLen Brown 
1199c98d5d94SLen Brown 	/* sum per-pkg values only for 1st core in pkg */
1200c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
1201c98d5d94SLen Brown 		return 0;
1202c98d5d94SLen Brown 
12030b2bb692SLen Brown 	if (do_skl_residency) {
12040b2bb692SLen Brown 		average.packages.pkg_wtd_core_c0 += p->pkg_wtd_core_c0;
12050b2bb692SLen Brown 		average.packages.pkg_any_core_c0 += p->pkg_any_core_c0;
12060b2bb692SLen Brown 		average.packages.pkg_any_gfxe_c0 += p->pkg_any_gfxe_c0;
12070b2bb692SLen Brown 		average.packages.pkg_both_core_gfxe_c0 += p->pkg_both_core_gfxe_c0;
12080b2bb692SLen Brown 	}
12090b2bb692SLen Brown 
1210c98d5d94SLen Brown 	average.packages.pc2 += p->pc2;
12110f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc3))
1212c98d5d94SLen Brown 		average.packages.pc3 += p->pc3;
12130f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc6))
1214c98d5d94SLen Brown 		average.packages.pc6 += p->pc6;
12150f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc7))
1216c98d5d94SLen Brown 		average.packages.pc7 += p->pc7;
1217ca58710fSKristen Carlson Accardi 	average.packages.pc8 += p->pc8;
1218ca58710fSKristen Carlson Accardi 	average.packages.pc9 += p->pc9;
1219ca58710fSKristen Carlson Accardi 	average.packages.pc10 += p->pc10;
1220c98d5d94SLen Brown 
1221889facbeSLen Brown 	average.packages.energy_pkg += p->energy_pkg;
1222889facbeSLen Brown 	average.packages.energy_dram += p->energy_dram;
1223889facbeSLen Brown 	average.packages.energy_cores += p->energy_cores;
1224889facbeSLen Brown 	average.packages.energy_gfx += p->energy_gfx;
1225889facbeSLen Brown 
1226fdf676e5SLen Brown 	average.packages.gfx_rc6_ms = p->gfx_rc6_ms;
122727d47356SLen Brown 	average.packages.gfx_mhz = p->gfx_mhz;
122827d47356SLen Brown 
1229889facbeSLen Brown 	average.packages.pkg_temp_c = MAX(average.packages.pkg_temp_c, p->pkg_temp_c);
1230889facbeSLen Brown 
1231889facbeSLen Brown 	average.packages.rapl_pkg_perf_status += p->rapl_pkg_perf_status;
1232889facbeSLen Brown 	average.packages.rapl_dram_perf_status += p->rapl_dram_perf_status;
1233388e9c81SLen Brown 
1234388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
1235388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1236388e9c81SLen Brown 			continue;
1237388e9c81SLen Brown 		average.packages.counter[i] += p->counter[i];
1238388e9c81SLen Brown 	}
1239c98d5d94SLen Brown 	return 0;
1240c98d5d94SLen Brown }
1241c98d5d94SLen Brown /*
1242c98d5d94SLen Brown  * sum the counters for all cpus in the system
1243c98d5d94SLen Brown  * compute the weighted average
1244c98d5d94SLen Brown  */
1245c98d5d94SLen Brown void compute_average(struct thread_data *t, struct core_data *c,
1246c98d5d94SLen Brown 	struct pkg_data *p)
1247c98d5d94SLen Brown {
1248388e9c81SLen Brown 	int i;
1249388e9c81SLen Brown 	struct msr_counter *mp;
1250388e9c81SLen Brown 
1251c98d5d94SLen Brown 	clear_counters(&average.threads, &average.cores, &average.packages);
1252c98d5d94SLen Brown 
1253c98d5d94SLen Brown 	for_all_cpus(sum_counters, t, c, p);
1254c98d5d94SLen Brown 
1255c98d5d94SLen Brown 	average.threads.tsc /= topo.num_cpus;
1256c98d5d94SLen Brown 	average.threads.aperf /= topo.num_cpus;
1257c98d5d94SLen Brown 	average.threads.mperf /= topo.num_cpus;
1258c98d5d94SLen Brown 	average.threads.c1 /= topo.num_cpus;
1259c98d5d94SLen Brown 
1260c98d5d94SLen Brown 	average.cores.c3 /= topo.num_cores;
1261c98d5d94SLen Brown 	average.cores.c6 /= topo.num_cores;
1262c98d5d94SLen Brown 	average.cores.c7 /= topo.num_cores;
12630539ba11SLen Brown 	average.cores.mc6_us /= topo.num_cores;
1264c98d5d94SLen Brown 
12650b2bb692SLen Brown 	if (do_skl_residency) {
12660b2bb692SLen Brown 		average.packages.pkg_wtd_core_c0 /= topo.num_packages;
12670b2bb692SLen Brown 		average.packages.pkg_any_core_c0 /= topo.num_packages;
12680b2bb692SLen Brown 		average.packages.pkg_any_gfxe_c0 /= topo.num_packages;
12690b2bb692SLen Brown 		average.packages.pkg_both_core_gfxe_c0 /= topo.num_packages;
12700b2bb692SLen Brown 	}
12710b2bb692SLen Brown 
1272c98d5d94SLen Brown 	average.packages.pc2 /= topo.num_packages;
12730f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc3))
1274c98d5d94SLen Brown 		average.packages.pc3 /= topo.num_packages;
12750f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc6))
1276c98d5d94SLen Brown 		average.packages.pc6 /= topo.num_packages;
12770f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc7))
1278c98d5d94SLen Brown 		average.packages.pc7 /= topo.num_packages;
1279ca58710fSKristen Carlson Accardi 
1280ca58710fSKristen Carlson Accardi 	average.packages.pc8 /= topo.num_packages;
1281ca58710fSKristen Carlson Accardi 	average.packages.pc9 /= topo.num_packages;
1282ca58710fSKristen Carlson Accardi 	average.packages.pc10 /= topo.num_packages;
1283388e9c81SLen Brown 
1284388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
1285388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1286388e9c81SLen Brown 			continue;
1287388e9c81SLen Brown 		average.threads.counter[i] /= topo.num_cpus;
1288388e9c81SLen Brown 	}
1289388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
1290388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1291388e9c81SLen Brown 			continue;
1292388e9c81SLen Brown 		average.cores.counter[i] /= topo.num_cores;
1293388e9c81SLen Brown 	}
1294388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
1295388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1296388e9c81SLen Brown 			continue;
1297388e9c81SLen Brown 		average.packages.counter[i] /= topo.num_packages;
1298388e9c81SLen Brown 	}
1299c98d5d94SLen Brown }
1300c98d5d94SLen Brown 
1301c98d5d94SLen Brown static unsigned long long rdtsc(void)
1302c98d5d94SLen Brown {
1303c98d5d94SLen Brown 	unsigned int low, high;
1304c98d5d94SLen Brown 
1305c98d5d94SLen Brown 	asm volatile("rdtsc" : "=a" (low), "=d" (high));
1306c98d5d94SLen Brown 
1307c98d5d94SLen Brown 	return low | ((unsigned long long)high) << 32;
1308c98d5d94SLen Brown }
1309c98d5d94SLen Brown 
1310c98d5d94SLen Brown /*
1311c98d5d94SLen Brown  * get_counters(...)
1312c98d5d94SLen Brown  * migrate to cpu
1313c98d5d94SLen Brown  * acquire and record local counters for that cpu
1314c98d5d94SLen Brown  */
1315c98d5d94SLen Brown int get_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
1316c98d5d94SLen Brown {
1317c98d5d94SLen Brown 	int cpu = t->cpu_id;
1318889facbeSLen Brown 	unsigned long long msr;
13190102b067SLen Brown 	int aperf_mperf_retry_count = 0;
1320388e9c81SLen Brown 	struct msr_counter *mp;
1321388e9c81SLen Brown 	int i;
1322c98d5d94SLen Brown 
1323e52966c0SLen Brown 	if (cpu_migrate(cpu)) {
1324b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
132515aaa346SLen Brown 		return -1;
1326e52966c0SLen Brown 	}
132715aaa346SLen Brown 
13280102b067SLen Brown retry:
1329c98d5d94SLen Brown 	t->tsc = rdtsc();	/* we are running on local CPU of interest */
133015aaa346SLen Brown 
1331812db3f7SLen Brown 	if (DO_BIC(BIC_Avg_MHz) || DO_BIC(BIC_Busy) || DO_BIC(BIC_Bzy_MHz)) {
13320102b067SLen Brown 		unsigned long long tsc_before, tsc_between, tsc_after, aperf_time, mperf_time;
13330102b067SLen Brown 
13340102b067SLen Brown 		/*
13350102b067SLen Brown 		 * The TSC, APERF and MPERF must be read together for
13360102b067SLen Brown 		 * APERF/MPERF and MPERF/TSC to give accurate results.
13370102b067SLen Brown 		 *
13380102b067SLen Brown 		 * Unfortunately, APERF and MPERF are read by
13390102b067SLen Brown 		 * individual system call, so delays may occur
13400102b067SLen Brown 		 * between them.  If the time to read them
13410102b067SLen Brown 		 * varies by a large amount, we re-read them.
13420102b067SLen Brown 		 */
13430102b067SLen Brown 
13440102b067SLen Brown 		/*
13450102b067SLen Brown 		 * This initial dummy APERF read has been seen to
13460102b067SLen Brown 		 * reduce jitter in the subsequent reads.
13470102b067SLen Brown 		 */
13480102b067SLen Brown 
13499c63a650SLen Brown 		if (get_msr(cpu, MSR_IA32_APERF, &t->aperf))
1350c98d5d94SLen Brown 			return -3;
13510102b067SLen Brown 
13520102b067SLen Brown 		t->tsc = rdtsc();	/* re-read close to APERF */
13530102b067SLen Brown 
13540102b067SLen Brown 		tsc_before = t->tsc;
13550102b067SLen Brown 
13560102b067SLen Brown 		if (get_msr(cpu, MSR_IA32_APERF, &t->aperf))
13570102b067SLen Brown 			return -3;
13580102b067SLen Brown 
13590102b067SLen Brown 		tsc_between = rdtsc();
13600102b067SLen Brown 
13619c63a650SLen Brown 		if (get_msr(cpu, MSR_IA32_MPERF, &t->mperf))
1362c98d5d94SLen Brown 			return -4;
13630102b067SLen Brown 
13640102b067SLen Brown 		tsc_after = rdtsc();
13650102b067SLen Brown 
13660102b067SLen Brown 		aperf_time = tsc_between - tsc_before;
13670102b067SLen Brown 		mperf_time = tsc_after - tsc_between;
13680102b067SLen Brown 
13690102b067SLen Brown 		/*
13700102b067SLen Brown 		 * If the system call latency to read APERF and MPERF
13710102b067SLen Brown 		 * differ by more than 2x, then try again.
13720102b067SLen Brown 		 */
13730102b067SLen Brown 		if ((aperf_time > (2 * mperf_time)) || (mperf_time > (2 * aperf_time))) {
13740102b067SLen Brown 			aperf_mperf_retry_count++;
13750102b067SLen Brown 			if (aperf_mperf_retry_count < 5)
13760102b067SLen Brown 				goto retry;
13770102b067SLen Brown 			else
13780102b067SLen Brown 				warnx("cpu%d jitter %lld %lld",
13790102b067SLen Brown 					cpu, aperf_time, mperf_time);
13800102b067SLen Brown 		}
13810102b067SLen Brown 		aperf_mperf_retry_count = 0;
13820102b067SLen Brown 
1383b2b34dfeSHubert Chrzaniuk 		t->aperf = t->aperf * aperf_mperf_multiplier;
1384b2b34dfeSHubert Chrzaniuk 		t->mperf = t->mperf * aperf_mperf_multiplier;
138588c3281fSLen Brown 	}
138688c3281fSLen Brown 
1387812db3f7SLen Brown 	if (DO_BIC(BIC_IRQ))
1388562a2d37SLen Brown 		t->irq_count = irqs_per_cpu[cpu];
1389812db3f7SLen Brown 	if (DO_BIC(BIC_SMI)) {
13901ed51011SLen Brown 		if (get_msr(cpu, MSR_SMI_COUNT, &msr))
13911ed51011SLen Brown 			return -5;
13921ed51011SLen Brown 		t->smi_count = msr & 0xFFFFFFFF;
13931ed51011SLen Brown 	}
13940539ba11SLen Brown 	if (DO_BIC(BIC_CPU_c1) && use_c1_residency_msr) {
1395144b44b1SLen Brown 		if (get_msr(cpu, MSR_CORE_C1_RES, &t->c1))
1396144b44b1SLen Brown 			return -6;
1397144b44b1SLen Brown 	}
1398144b44b1SLen Brown 
1399388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
1400388e9c81SLen Brown 		if (get_msr(cpu, mp->msr_num, &t->counter[i]))
1401388e9c81SLen Brown 			return -10;
1402388e9c81SLen Brown 	}
1403388e9c81SLen Brown 
1404388e9c81SLen Brown 
1405c98d5d94SLen Brown 	/* collect core counters only for 1st thread in core */
1406c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
1407c98d5d94SLen Brown 		return 0;
1408c98d5d94SLen Brown 
1409812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c3) && !do_slm_cstates && !do_knl_cstates) {
1410c98d5d94SLen Brown 		if (get_msr(cpu, MSR_CORE_C3_RESIDENCY, &c->c3))
1411c98d5d94SLen Brown 			return -6;
1412144b44b1SLen Brown 	}
1413144b44b1SLen Brown 
1414812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c6) && !do_knl_cstates) {
1415c98d5d94SLen Brown 		if (get_msr(cpu, MSR_CORE_C6_RESIDENCY, &c->c6))
1416c98d5d94SLen Brown 			return -7;
1417fb5d4327SDasaratharaman Chandramouli 	} else if (do_knl_cstates) {
1418fb5d4327SDasaratharaman Chandramouli 		if (get_msr(cpu, MSR_KNL_CORE_C6_RESIDENCY, &c->c6))
1419fb5d4327SDasaratharaman Chandramouli 			return -7;
1420103a8feaSLen Brown 	}
142115aaa346SLen Brown 
1422812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c7))
1423c98d5d94SLen Brown 		if (get_msr(cpu, MSR_CORE_C7_RESIDENCY, &c->c7))
1424c98d5d94SLen Brown 			return -8;
1425c98d5d94SLen Brown 
14260539ba11SLen Brown 	if (DO_BIC(BIC_Mod_c6))
14270539ba11SLen Brown 		if (get_msr(cpu, MSR_MODULE_C6_RES_MS, &c->mc6_us))
14280539ba11SLen Brown 			return -8;
14290539ba11SLen Brown 
1430812db3f7SLen Brown 	if (DO_BIC(BIC_CoreTmp)) {
1431889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_THERM_STATUS, &msr))
1432889facbeSLen Brown 			return -9;
1433889facbeSLen Brown 		c->core_temp_c = tcc_activation_temp - ((msr >> 16) & 0x7F);
1434889facbeSLen Brown 	}
1435889facbeSLen Brown 
1436388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
1437388e9c81SLen Brown 		if (get_msr(cpu, mp->msr_num, &c->counter[i]))
1438388e9c81SLen Brown 			return -10;
1439388e9c81SLen Brown 	}
1440889facbeSLen Brown 
1441c98d5d94SLen Brown 	/* collect package counters only for 1st core in package */
1442c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
1443c98d5d94SLen Brown 		return 0;
144415aaa346SLen Brown 
14450b2bb692SLen Brown 	if (do_skl_residency) {
14460b2bb692SLen Brown 		if (get_msr(cpu, MSR_PKG_WEIGHTED_CORE_C0_RES, &p->pkg_wtd_core_c0))
14470b2bb692SLen Brown 			return -10;
14480b2bb692SLen Brown 		if (get_msr(cpu, MSR_PKG_ANY_CORE_C0_RES, &p->pkg_any_core_c0))
14490b2bb692SLen Brown 			return -11;
14500b2bb692SLen Brown 		if (get_msr(cpu, MSR_PKG_ANY_GFXE_C0_RES, &p->pkg_any_gfxe_c0))
14510b2bb692SLen Brown 			return -12;
14520b2bb692SLen Brown 		if (get_msr(cpu, MSR_PKG_BOTH_CORE_GFXE_C0_RES, &p->pkg_both_core_gfxe_c0))
14530b2bb692SLen Brown 			return -13;
14540b2bb692SLen Brown 	}
14550f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc3))
1456c98d5d94SLen Brown 		if (get_msr(cpu, MSR_PKG_C3_RESIDENCY, &p->pc3))
1457c98d5d94SLen Brown 			return -9;
14580f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc6)) {
14590539ba11SLen Brown 		if (do_slm_cstates) {
14600539ba11SLen Brown 			if (get_msr(cpu, MSR_ATOM_PKG_C6_RESIDENCY, &p->pc6))
14610539ba11SLen Brown 				return -10;
14620539ba11SLen Brown 		} else {
1463c98d5d94SLen Brown 			if (get_msr(cpu, MSR_PKG_C6_RESIDENCY, &p->pc6))
1464c98d5d94SLen Brown 				return -10;
14650539ba11SLen Brown 		}
14660539ba11SLen Brown 	}
14670539ba11SLen Brown 
14680f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc2))
1469c98d5d94SLen Brown 		if (get_msr(cpu, MSR_PKG_C2_RESIDENCY, &p->pc2))
1470c98d5d94SLen Brown 			return -11;
14710f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc7))
1472c98d5d94SLen Brown 		if (get_msr(cpu, MSR_PKG_C7_RESIDENCY, &p->pc7))
1473c98d5d94SLen Brown 			return -12;
14740f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc8))
1475ca58710fSKristen Carlson Accardi 		if (get_msr(cpu, MSR_PKG_C8_RESIDENCY, &p->pc8))
1476ca58710fSKristen Carlson Accardi 			return -13;
14770f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc9))
1478ca58710fSKristen Carlson Accardi 		if (get_msr(cpu, MSR_PKG_C9_RESIDENCY, &p->pc9))
1479ca58710fSKristen Carlson Accardi 			return -13;
14800f47c08dSLen Brown 	if (DO_BIC(BIC_Pkgpc10))
1481ca58710fSKristen Carlson Accardi 		if (get_msr(cpu, MSR_PKG_C10_RESIDENCY, &p->pc10))
1482ca58710fSKristen Carlson Accardi 			return -13;
14830f47c08dSLen Brown 
1484889facbeSLen Brown 	if (do_rapl & RAPL_PKG) {
1485889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_ENERGY_STATUS, &msr))
1486889facbeSLen Brown 			return -13;
1487889facbeSLen Brown 		p->energy_pkg = msr & 0xFFFFFFFF;
1488889facbeSLen Brown 	}
14899148494cSJacob Pan 	if (do_rapl & RAPL_CORES_ENERGY_STATUS) {
1490889facbeSLen Brown 		if (get_msr(cpu, MSR_PP0_ENERGY_STATUS, &msr))
1491889facbeSLen Brown 			return -14;
1492889facbeSLen Brown 		p->energy_cores = msr & 0xFFFFFFFF;
1493889facbeSLen Brown 	}
1494889facbeSLen Brown 	if (do_rapl & RAPL_DRAM) {
1495889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_ENERGY_STATUS, &msr))
1496889facbeSLen Brown 			return -15;
1497889facbeSLen Brown 		p->energy_dram = msr & 0xFFFFFFFF;
1498889facbeSLen Brown 	}
1499889facbeSLen Brown 	if (do_rapl & RAPL_GFX) {
1500889facbeSLen Brown 		if (get_msr(cpu, MSR_PP1_ENERGY_STATUS, &msr))
1501889facbeSLen Brown 			return -16;
1502889facbeSLen Brown 		p->energy_gfx = msr & 0xFFFFFFFF;
1503889facbeSLen Brown 	}
1504889facbeSLen Brown 	if (do_rapl & RAPL_PKG_PERF_STATUS) {
1505889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_PERF_STATUS, &msr))
1506889facbeSLen Brown 			return -16;
1507889facbeSLen Brown 		p->rapl_pkg_perf_status = msr & 0xFFFFFFFF;
1508889facbeSLen Brown 	}
1509889facbeSLen Brown 	if (do_rapl & RAPL_DRAM_PERF_STATUS) {
1510889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_PERF_STATUS, &msr))
1511889facbeSLen Brown 			return -16;
1512889facbeSLen Brown 		p->rapl_dram_perf_status = msr & 0xFFFFFFFF;
1513889facbeSLen Brown 	}
1514812db3f7SLen Brown 	if (DO_BIC(BIC_PkgTmp)) {
1515889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_STATUS, &msr))
1516889facbeSLen Brown 			return -17;
1517889facbeSLen Brown 		p->pkg_temp_c = tcc_activation_temp - ((msr >> 16) & 0x7F);
1518889facbeSLen Brown 	}
1519fdf676e5SLen Brown 
1520812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_rc6))
1521fdf676e5SLen Brown 		p->gfx_rc6_ms = gfx_cur_rc6_ms;
1522fdf676e5SLen Brown 
1523812db3f7SLen Brown 	if (DO_BIC(BIC_GFXMHz))
152427d47356SLen Brown 		p->gfx_mhz = gfx_cur_mhz;
152527d47356SLen Brown 
1526388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
1527388e9c81SLen Brown 		if (get_msr(cpu, mp->msr_num, &p->counter[i]))
1528388e9c81SLen Brown 			return -10;
1529388e9c81SLen Brown 	}
1530388e9c81SLen Brown 
153115aaa346SLen Brown 	return 0;
1532103a8feaSLen Brown }
1533103a8feaSLen Brown 
1534ee7e38e3SLen Brown /*
1535ee7e38e3SLen Brown  * MSR_PKG_CST_CONFIG_CONTROL decoding for pkg_cstate_limit:
1536ee7e38e3SLen Brown  * If you change the values, note they are used both in comparisons
1537ee7e38e3SLen Brown  * (>= PCL__7) and to index pkg_cstate_limit_strings[].
1538ee7e38e3SLen Brown  */
1539ee7e38e3SLen Brown 
1540ee7e38e3SLen Brown #define PCLUKN 0 /* Unknown */
1541ee7e38e3SLen Brown #define PCLRSV 1 /* Reserved */
1542ee7e38e3SLen Brown #define PCL__0 2 /* PC0 */
1543ee7e38e3SLen Brown #define PCL__1 3 /* PC1 */
1544ee7e38e3SLen Brown #define PCL__2 4 /* PC2 */
1545ee7e38e3SLen Brown #define PCL__3 5 /* PC3 */
1546ee7e38e3SLen Brown #define PCL__4 6 /* PC4 */
1547ee7e38e3SLen Brown #define PCL__6 7 /* PC6 */
1548ee7e38e3SLen Brown #define PCL_6N 8 /* PC6 No Retention */
1549ee7e38e3SLen Brown #define PCL_6R 9 /* PC6 Retention */
1550ee7e38e3SLen Brown #define PCL__7 10 /* PC7 */
1551ee7e38e3SLen Brown #define PCL_7S 11 /* PC7 Shrink */
15520b2bb692SLen Brown #define PCL__8 12 /* PC8 */
15530b2bb692SLen Brown #define PCL__9 13 /* PC9 */
15540b2bb692SLen Brown #define PCLUNL 14 /* Unlimited */
1555ee7e38e3SLen Brown 
1556ee7e38e3SLen Brown int pkg_cstate_limit = PCLUKN;
1557ee7e38e3SLen Brown char *pkg_cstate_limit_strings[] = { "reserved", "unknown", "pc0", "pc1", "pc2",
15580b2bb692SLen Brown 	"pc3", "pc4", "pc6", "pc6n", "pc6r", "pc7", "pc7s", "pc8", "pc9", "unlimited"};
1559ee7e38e3SLen Brown 
1560e9257f5fSLen Brown int nhm_pkg_cstate_limits[16] = {PCL__0, PCL__1, PCL__3, PCL__6, PCL__7, PCLRSV, PCLRSV, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
1561e9257f5fSLen Brown int snb_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCL_6N, PCL_6R, PCL__7, PCL_7S, PCLRSV, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
1562e9257f5fSLen Brown int hsw_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCL__3, PCL__6, PCL__7, PCL_7S, PCL__8, PCL__9, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
15630539ba11SLen Brown int slv_pkg_cstate_limits[16] = {PCL__0, PCL__1, PCLRSV, PCLRSV, PCL__4, PCLRSV, PCL__6, PCL__7, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCL__6, PCL__7};
1564f2642888SLen Brown int amt_pkg_cstate_limits[16] = {PCLUNL, PCL__1, PCL__2, PCLRSV, PCLRSV, PCLRSV, PCL__6, PCL__7, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
1565e9257f5fSLen Brown int phi_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCL_6N, PCL_6R, PCLRSV, PCLRSV, PCLRSV, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
1566e4085d54SLen Brown int bxt_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
1567d8ebb442SLen Brown int skx_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCL_6N, PCL_6R, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
1568ee7e38e3SLen Brown 
1569a2b7b749SLen Brown 
1570a2b7b749SLen Brown static void
1571a2b7b749SLen Brown calculate_tsc_tweak()
1572a2b7b749SLen Brown {
1573a2b7b749SLen Brown 	tsc_tweak = base_hz / tsc_hz;
1574a2b7b749SLen Brown }
1575a2b7b749SLen Brown 
1576fcd17211SLen Brown static void
1577fcd17211SLen Brown dump_nhm_platform_info(void)
1578103a8feaSLen Brown {
1579103a8feaSLen Brown 	unsigned long long msr;
1580103a8feaSLen Brown 	unsigned int ratio;
1581103a8feaSLen Brown 
1582ec0adc53SLen Brown 	get_msr(base_cpu, MSR_PLATFORM_INFO, &msr);
1583103a8feaSLen Brown 
1584b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_PLATFORM_INFO: 0x%08llx\n", base_cpu, msr);
15856574a5d5SLen Brown 
1586103a8feaSLen Brown 	ratio = (msr >> 40) & 0xFF;
1587710f273bSLen Brown 	fprintf(outf, "%d * %.1f = %.1f MHz max efficiency frequency\n",
1588103a8feaSLen Brown 		ratio, bclk, ratio * bclk);
1589103a8feaSLen Brown 
1590103a8feaSLen Brown 	ratio = (msr >> 8) & 0xFF;
1591710f273bSLen Brown 	fprintf(outf, "%d * %.1f = %.1f MHz base frequency\n",
1592103a8feaSLen Brown 		ratio, bclk, ratio * bclk);
1593103a8feaSLen Brown 
15947ce7d5deSPrarit Bhargava 	get_msr(base_cpu, MSR_IA32_POWER_CTL, &msr);
1595b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_IA32_POWER_CTL: 0x%08llx (C1E auto-promotion: %sabled)\n",
1596bfae2052SLen Brown 		base_cpu, msr, msr & 0x2 ? "EN" : "DIS");
159767920418SLen Brown 
1598fcd17211SLen Brown 	return;
1599fcd17211SLen Brown }
1600fcd17211SLen Brown 
1601fcd17211SLen Brown static void
1602fcd17211SLen Brown dump_hsw_turbo_ratio_limits(void)
1603fcd17211SLen Brown {
1604fcd17211SLen Brown 	unsigned long long msr;
1605fcd17211SLen Brown 	unsigned int ratio;
1606fcd17211SLen Brown 
16077ce7d5deSPrarit Bhargava 	get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT2, &msr);
1608fcd17211SLen Brown 
1609b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT2: 0x%08llx\n", base_cpu, msr);
1610fcd17211SLen Brown 
1611fcd17211SLen Brown 	ratio = (msr >> 8) & 0xFF;
1612fcd17211SLen Brown 	if (ratio)
1613710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 18 active cores\n",
1614fcd17211SLen Brown 			ratio, bclk, ratio * bclk);
1615fcd17211SLen Brown 
1616fcd17211SLen Brown 	ratio = (msr >> 0) & 0xFF;
1617fcd17211SLen Brown 	if (ratio)
1618710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 17 active cores\n",
1619fcd17211SLen Brown 			ratio, bclk, ratio * bclk);
1620fcd17211SLen Brown 	return;
1621fcd17211SLen Brown }
1622fcd17211SLen Brown 
1623fcd17211SLen Brown static void
1624fcd17211SLen Brown dump_ivt_turbo_ratio_limits(void)
1625fcd17211SLen Brown {
1626fcd17211SLen Brown 	unsigned long long msr;
1627fcd17211SLen Brown 	unsigned int ratio;
16286574a5d5SLen Brown 
16297ce7d5deSPrarit Bhargava 	get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT1, &msr);
16306574a5d5SLen Brown 
1631b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT1: 0x%08llx\n", base_cpu, msr);
16326574a5d5SLen Brown 
16336574a5d5SLen Brown 	ratio = (msr >> 56) & 0xFF;
16346574a5d5SLen Brown 	if (ratio)
1635710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 16 active cores\n",
16366574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16376574a5d5SLen Brown 
16386574a5d5SLen Brown 	ratio = (msr >> 48) & 0xFF;
16396574a5d5SLen Brown 	if (ratio)
1640710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 15 active cores\n",
16416574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16426574a5d5SLen Brown 
16436574a5d5SLen Brown 	ratio = (msr >> 40) & 0xFF;
16446574a5d5SLen Brown 	if (ratio)
1645710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 14 active cores\n",
16466574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16476574a5d5SLen Brown 
16486574a5d5SLen Brown 	ratio = (msr >> 32) & 0xFF;
16496574a5d5SLen Brown 	if (ratio)
1650710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 13 active cores\n",
16516574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16526574a5d5SLen Brown 
16536574a5d5SLen Brown 	ratio = (msr >> 24) & 0xFF;
16546574a5d5SLen Brown 	if (ratio)
1655710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 12 active cores\n",
16566574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16576574a5d5SLen Brown 
16586574a5d5SLen Brown 	ratio = (msr >> 16) & 0xFF;
16596574a5d5SLen Brown 	if (ratio)
1660710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 11 active cores\n",
16616574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16626574a5d5SLen Brown 
16636574a5d5SLen Brown 	ratio = (msr >> 8) & 0xFF;
16646574a5d5SLen Brown 	if (ratio)
1665710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 10 active cores\n",
16666574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16676574a5d5SLen Brown 
16686574a5d5SLen Brown 	ratio = (msr >> 0) & 0xFF;
16696574a5d5SLen Brown 	if (ratio)
1670710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 9 active cores\n",
16716574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
1672103a8feaSLen Brown 	return;
1673fcd17211SLen Brown }
1674fcd17211SLen Brown 
1675fcd17211SLen Brown static void
1676fcd17211SLen Brown dump_nhm_turbo_ratio_limits(void)
1677fcd17211SLen Brown {
1678fcd17211SLen Brown 	unsigned long long msr;
1679fcd17211SLen Brown 	unsigned int ratio;
1680103a8feaSLen Brown 
16817ce7d5deSPrarit Bhargava 	get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT, &msr);
1682103a8feaSLen Brown 
1683b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT: 0x%08llx\n", base_cpu, msr);
16846574a5d5SLen Brown 
16856574a5d5SLen Brown 	ratio = (msr >> 56) & 0xFF;
16866574a5d5SLen Brown 	if (ratio)
1687710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 8 active cores\n",
16886574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16896574a5d5SLen Brown 
16906574a5d5SLen Brown 	ratio = (msr >> 48) & 0xFF;
16916574a5d5SLen Brown 	if (ratio)
1692710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 7 active cores\n",
16936574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16946574a5d5SLen Brown 
16956574a5d5SLen Brown 	ratio = (msr >> 40) & 0xFF;
16966574a5d5SLen Brown 	if (ratio)
1697710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 6 active cores\n",
16986574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16996574a5d5SLen Brown 
17006574a5d5SLen Brown 	ratio = (msr >> 32) & 0xFF;
17016574a5d5SLen Brown 	if (ratio)
1702710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 5 active cores\n",
17036574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
17046574a5d5SLen Brown 
1705103a8feaSLen Brown 	ratio = (msr >> 24) & 0xFF;
1706103a8feaSLen Brown 	if (ratio)
1707710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 4 active cores\n",
1708103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1709103a8feaSLen Brown 
1710103a8feaSLen Brown 	ratio = (msr >> 16) & 0xFF;
1711103a8feaSLen Brown 	if (ratio)
1712710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 3 active cores\n",
1713103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1714103a8feaSLen Brown 
1715103a8feaSLen Brown 	ratio = (msr >> 8) & 0xFF;
1716103a8feaSLen Brown 	if (ratio)
1717710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 2 active cores\n",
1718103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1719103a8feaSLen Brown 
1720103a8feaSLen Brown 	ratio = (msr >> 0) & 0xFF;
1721103a8feaSLen Brown 	if (ratio)
1722710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 1 active cores\n",
1723103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1724fcd17211SLen Brown 	return;
1725fcd17211SLen Brown }
17263a9a941dSLen Brown 
1727fcd17211SLen Brown static void
17280f7887c4SLen Brown dump_atom_turbo_ratio_limits(void)
17290f7887c4SLen Brown {
17300f7887c4SLen Brown 	unsigned long long msr;
17310f7887c4SLen Brown 	unsigned int ratio;
17320f7887c4SLen Brown 
17330f7887c4SLen Brown 	get_msr(base_cpu, MSR_ATOM_CORE_RATIOS, &msr);
17340f7887c4SLen Brown 	fprintf(outf, "cpu%d: MSR_ATOM_CORE_RATIOS: 0x%08llx\n", base_cpu, msr & 0xFFFFFFFF);
17350f7887c4SLen Brown 
17360f7887c4SLen Brown 	ratio = (msr >> 0) & 0x3F;
17370f7887c4SLen Brown 	if (ratio)
17380f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz minimum operating frequency\n",
17390f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17400f7887c4SLen Brown 
17410f7887c4SLen Brown 	ratio = (msr >> 8) & 0x3F;
17420f7887c4SLen Brown 	if (ratio)
17430f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz low frequency mode (LFM)\n",
17440f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17450f7887c4SLen Brown 
17460f7887c4SLen Brown 	ratio = (msr >> 16) & 0x3F;
17470f7887c4SLen Brown 	if (ratio)
17480f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz base frequency\n",
17490f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17500f7887c4SLen Brown 
17510f7887c4SLen Brown 	get_msr(base_cpu, MSR_ATOM_CORE_TURBO_RATIOS, &msr);
17520f7887c4SLen Brown 	fprintf(outf, "cpu%d: MSR_ATOM_CORE_TURBO_RATIOS: 0x%08llx\n", base_cpu, msr & 0xFFFFFFFF);
17530f7887c4SLen Brown 
17540f7887c4SLen Brown 	ratio = (msr >> 24) & 0x3F;
17550f7887c4SLen Brown 	if (ratio)
17560f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 4 active cores\n",
17570f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17580f7887c4SLen Brown 
17590f7887c4SLen Brown 	ratio = (msr >> 16) & 0x3F;
17600f7887c4SLen Brown 	if (ratio)
17610f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 3 active cores\n",
17620f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17630f7887c4SLen Brown 
17640f7887c4SLen Brown 	ratio = (msr >> 8) & 0x3F;
17650f7887c4SLen Brown 	if (ratio)
17660f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 2 active cores\n",
17670f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17680f7887c4SLen Brown 
17690f7887c4SLen Brown 	ratio = (msr >> 0) & 0x3F;
17700f7887c4SLen Brown 	if (ratio)
17710f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 1 active core\n",
17720f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17730f7887c4SLen Brown }
17740f7887c4SLen Brown 
17750f7887c4SLen Brown static void
1776fb5d4327SDasaratharaman Chandramouli dump_knl_turbo_ratio_limits(void)
1777fb5d4327SDasaratharaman Chandramouli {
1778cbf97abaSHubert Chrzaniuk 	const unsigned int buckets_no = 7;
1779cbf97abaSHubert Chrzaniuk 
1780fb5d4327SDasaratharaman Chandramouli 	unsigned long long msr;
1781cbf97abaSHubert Chrzaniuk 	int delta_cores, delta_ratio;
1782cbf97abaSHubert Chrzaniuk 	int i, b_nr;
1783cbf97abaSHubert Chrzaniuk 	unsigned int cores[buckets_no];
1784cbf97abaSHubert Chrzaniuk 	unsigned int ratio[buckets_no];
1785fb5d4327SDasaratharaman Chandramouli 
1786ebf5926aSSrinivas Pandruvada 	get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT, &msr);
1787fb5d4327SDasaratharaman Chandramouli 
1788b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT: 0x%08llx\n",
1789bfae2052SLen Brown 		base_cpu, msr);
1790fb5d4327SDasaratharaman Chandramouli 
1791fb5d4327SDasaratharaman Chandramouli 	/**
1792fb5d4327SDasaratharaman Chandramouli 	 * Turbo encoding in KNL is as follows:
1793cbf97abaSHubert Chrzaniuk 	 * [0] -- Reserved
1794cbf97abaSHubert Chrzaniuk 	 * [7:1] -- Base value of number of active cores of bucket 1.
1795fb5d4327SDasaratharaman Chandramouli 	 * [15:8] -- Base value of freq ratio of bucket 1.
1796fb5d4327SDasaratharaman Chandramouli 	 * [20:16] -- +ve delta of number of active cores of bucket 2.
1797fb5d4327SDasaratharaman Chandramouli 	 * i.e. active cores of bucket 2 =
1798fb5d4327SDasaratharaman Chandramouli 	 * active cores of bucket 1 + delta
1799fb5d4327SDasaratharaman Chandramouli 	 * [23:21] -- Negative delta of freq ratio of bucket 2.
1800fb5d4327SDasaratharaman Chandramouli 	 * i.e. freq ratio of bucket 2 =
1801fb5d4327SDasaratharaman Chandramouli 	 * freq ratio of bucket 1 - delta
1802fb5d4327SDasaratharaman Chandramouli 	 * [28:24]-- +ve delta of number of active cores of bucket 3.
1803fb5d4327SDasaratharaman Chandramouli 	 * [31:29]-- -ve delta of freq ratio of bucket 3.
1804fb5d4327SDasaratharaman Chandramouli 	 * [36:32]-- +ve delta of number of active cores of bucket 4.
1805fb5d4327SDasaratharaman Chandramouli 	 * [39:37]-- -ve delta of freq ratio of bucket 4.
1806fb5d4327SDasaratharaman Chandramouli 	 * [44:40]-- +ve delta of number of active cores of bucket 5.
1807fb5d4327SDasaratharaman Chandramouli 	 * [47:45]-- -ve delta of freq ratio of bucket 5.
1808fb5d4327SDasaratharaman Chandramouli 	 * [52:48]-- +ve delta of number of active cores of bucket 6.
1809fb5d4327SDasaratharaman Chandramouli 	 * [55:53]-- -ve delta of freq ratio of bucket 6.
1810fb5d4327SDasaratharaman Chandramouli 	 * [60:56]-- +ve delta of number of active cores of bucket 7.
1811fb5d4327SDasaratharaman Chandramouli 	 * [63:61]-- -ve delta of freq ratio of bucket 7.
1812fb5d4327SDasaratharaman Chandramouli 	 */
1813fb5d4327SDasaratharaman Chandramouli 
1814cbf97abaSHubert Chrzaniuk 	b_nr = 0;
1815cbf97abaSHubert Chrzaniuk 	cores[b_nr] = (msr & 0xFF) >> 1;
1816cbf97abaSHubert Chrzaniuk 	ratio[b_nr] = (msr >> 8) & 0xFF;
1817cbf97abaSHubert Chrzaniuk 
1818cbf97abaSHubert Chrzaniuk 	for (i = 16; i < 64; i += 8) {
1819fb5d4327SDasaratharaman Chandramouli 		delta_cores = (msr >> i) & 0x1F;
1820cbf97abaSHubert Chrzaniuk 		delta_ratio = (msr >> (i + 5)) & 0x7;
1821fb5d4327SDasaratharaman Chandramouli 
1822cbf97abaSHubert Chrzaniuk 		cores[b_nr + 1] = cores[b_nr] + delta_cores;
1823cbf97abaSHubert Chrzaniuk 		ratio[b_nr + 1] = ratio[b_nr] - delta_ratio;
1824cbf97abaSHubert Chrzaniuk 		b_nr++;
1825fb5d4327SDasaratharaman Chandramouli 	}
1826cbf97abaSHubert Chrzaniuk 
1827cbf97abaSHubert Chrzaniuk 	for (i = buckets_no - 1; i >= 0; i--)
1828cbf97abaSHubert Chrzaniuk 		if (i > 0 ? ratio[i] != ratio[i - 1] : 1)
1829b7d8c148SLen Brown 			fprintf(outf,
1830710f273bSLen Brown 				"%d * %.1f = %.1f MHz max turbo %d active cores\n",
1831cbf97abaSHubert Chrzaniuk 				ratio[i], bclk, ratio[i] * bclk, cores[i]);
1832fb5d4327SDasaratharaman Chandramouli }
1833fb5d4327SDasaratharaman Chandramouli 
1834fb5d4327SDasaratharaman Chandramouli static void
1835fcd17211SLen Brown dump_nhm_cst_cfg(void)
1836fcd17211SLen Brown {
1837fcd17211SLen Brown 	unsigned long long msr;
1838fcd17211SLen Brown 
18391df2e55aSLen Brown 	get_msr(base_cpu, MSR_PKG_CST_CONFIG_CONTROL, &msr);
1840fcd17211SLen Brown 
1841fcd17211SLen Brown #define SNB_C1_AUTO_UNDEMOTE              (1UL << 27)
1842fcd17211SLen Brown #define SNB_C3_AUTO_UNDEMOTE              (1UL << 28)
1843fcd17211SLen Brown 
18441df2e55aSLen Brown 	fprintf(outf, "cpu%d: MSR_PKG_CST_CONFIG_CONTROL: 0x%08llx", base_cpu, msr);
1845fcd17211SLen Brown 
1846b7d8c148SLen Brown 	fprintf(outf, " (%s%s%s%s%slocked: pkg-cstate-limit=%d: %s)\n",
1847fcd17211SLen Brown 		(msr & SNB_C3_AUTO_UNDEMOTE) ? "UNdemote-C3, " : "",
1848fcd17211SLen Brown 		(msr & SNB_C1_AUTO_UNDEMOTE) ? "UNdemote-C1, " : "",
1849fcd17211SLen Brown 		(msr & NHM_C3_AUTO_DEMOTE) ? "demote-C3, " : "",
1850fcd17211SLen Brown 		(msr & NHM_C1_AUTO_DEMOTE) ? "demote-C1, " : "",
1851fcd17211SLen Brown 		(msr & (1 << 15)) ? "" : "UN",
18526c34f160SLen Brown 		(unsigned int)msr & 0xF,
1853fcd17211SLen Brown 		pkg_cstate_limit_strings[pkg_cstate_limit]);
1854fcd17211SLen Brown 	return;
1855103a8feaSLen Brown }
1856103a8feaSLen Brown 
18576fb3143bSLen Brown static void
18586fb3143bSLen Brown dump_config_tdp(void)
18596fb3143bSLen Brown {
18606fb3143bSLen Brown 	unsigned long long msr;
18616fb3143bSLen Brown 
18626fb3143bSLen Brown 	get_msr(base_cpu, MSR_CONFIG_TDP_NOMINAL, &msr);
1863b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_CONFIG_TDP_NOMINAL: 0x%08llx", base_cpu, msr);
1864685b535bSChen Yu 	fprintf(outf, " (base_ratio=%d)\n", (unsigned int)msr & 0xFF);
18656fb3143bSLen Brown 
18666fb3143bSLen Brown 	get_msr(base_cpu, MSR_CONFIG_TDP_LEVEL_1, &msr);
1867b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_CONFIG_TDP_LEVEL_1: 0x%08llx (", base_cpu, msr);
18686fb3143bSLen Brown 	if (msr) {
1869685b535bSChen Yu 		fprintf(outf, "PKG_MIN_PWR_LVL1=%d ", (unsigned int)(msr >> 48) & 0x7FFF);
1870685b535bSChen Yu 		fprintf(outf, "PKG_MAX_PWR_LVL1=%d ", (unsigned int)(msr >> 32) & 0x7FFF);
1871685b535bSChen Yu 		fprintf(outf, "LVL1_RATIO=%d ", (unsigned int)(msr >> 16) & 0xFF);
1872685b535bSChen Yu 		fprintf(outf, "PKG_TDP_LVL1=%d", (unsigned int)(msr) & 0x7FFF);
18736fb3143bSLen Brown 	}
1874b7d8c148SLen Brown 	fprintf(outf, ")\n");
18756fb3143bSLen Brown 
18766fb3143bSLen Brown 	get_msr(base_cpu, MSR_CONFIG_TDP_LEVEL_2, &msr);
1877b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_CONFIG_TDP_LEVEL_2: 0x%08llx (", base_cpu, msr);
18786fb3143bSLen Brown 	if (msr) {
1879685b535bSChen Yu 		fprintf(outf, "PKG_MIN_PWR_LVL2=%d ", (unsigned int)(msr >> 48) & 0x7FFF);
1880685b535bSChen Yu 		fprintf(outf, "PKG_MAX_PWR_LVL2=%d ", (unsigned int)(msr >> 32) & 0x7FFF);
1881685b535bSChen Yu 		fprintf(outf, "LVL2_RATIO=%d ", (unsigned int)(msr >> 16) & 0xFF);
1882685b535bSChen Yu 		fprintf(outf, "PKG_TDP_LVL2=%d", (unsigned int)(msr) & 0x7FFF);
18836fb3143bSLen Brown 	}
1884b7d8c148SLen Brown 	fprintf(outf, ")\n");
18856fb3143bSLen Brown 
18866fb3143bSLen Brown 	get_msr(base_cpu, MSR_CONFIG_TDP_CONTROL, &msr);
1887b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_CONFIG_TDP_CONTROL: 0x%08llx (", base_cpu, msr);
18886fb3143bSLen Brown 	if ((msr) & 0x3)
1889b7d8c148SLen Brown 		fprintf(outf, "TDP_LEVEL=%d ", (unsigned int)(msr) & 0x3);
1890b7d8c148SLen Brown 	fprintf(outf, " lock=%d", (unsigned int)(msr >> 31) & 1);
1891b7d8c148SLen Brown 	fprintf(outf, ")\n");
18926fb3143bSLen Brown 
18936fb3143bSLen Brown 	get_msr(base_cpu, MSR_TURBO_ACTIVATION_RATIO, &msr);
1894b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_ACTIVATION_RATIO: 0x%08llx (", base_cpu, msr);
1895685b535bSChen Yu 	fprintf(outf, "MAX_NON_TURBO_RATIO=%d", (unsigned int)(msr) & 0xFF);
1896b7d8c148SLen Brown 	fprintf(outf, " lock=%d", (unsigned int)(msr >> 31) & 1);
1897b7d8c148SLen Brown 	fprintf(outf, ")\n");
18986fb3143bSLen Brown }
18995a63426eSLen Brown 
19005a63426eSLen Brown unsigned int irtl_time_units[] = {1, 32, 1024, 32768, 1048576, 33554432, 0, 0 };
19015a63426eSLen Brown 
19025a63426eSLen Brown void print_irtl(void)
19035a63426eSLen Brown {
19045a63426eSLen Brown 	unsigned long long msr;
19055a63426eSLen Brown 
19065a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC3_IRTL, &msr);
19075a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC3_IRTL: 0x%08llx (", base_cpu, msr);
19085a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19095a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19105a63426eSLen Brown 
19115a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC6_IRTL, &msr);
19125a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC6_IRTL: 0x%08llx (", base_cpu, msr);
19135a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19145a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19155a63426eSLen Brown 
19165a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC7_IRTL, &msr);
19175a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC7_IRTL: 0x%08llx (", base_cpu, msr);
19185a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19195a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19205a63426eSLen Brown 
19215a63426eSLen Brown 	if (!do_irtl_hsw)
19225a63426eSLen Brown 		return;
19235a63426eSLen Brown 
19245a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC8_IRTL, &msr);
19255a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC8_IRTL: 0x%08llx (", base_cpu, msr);
19265a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19275a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19285a63426eSLen Brown 
19295a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC9_IRTL, &msr);
19305a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC9_IRTL: 0x%08llx (", base_cpu, msr);
19315a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19325a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19335a63426eSLen Brown 
19345a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC10_IRTL, &msr);
19355a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC10_IRTL: 0x%08llx (", base_cpu, msr);
19365a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19375a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19385a63426eSLen Brown 
19395a63426eSLen Brown }
194036229897SLen Brown void free_fd_percpu(void)
194136229897SLen Brown {
194236229897SLen Brown 	int i;
194336229897SLen Brown 
194401a67adfSMika Westerberg 	for (i = 0; i < topo.max_cpu_num + 1; ++i) {
194536229897SLen Brown 		if (fd_percpu[i] != 0)
194636229897SLen Brown 			close(fd_percpu[i]);
194736229897SLen Brown 	}
194836229897SLen Brown 
194936229897SLen Brown 	free(fd_percpu);
19506fb3143bSLen Brown }
19516fb3143bSLen Brown 
1952c98d5d94SLen Brown void free_all_buffers(void)
1953103a8feaSLen Brown {
1954c98d5d94SLen Brown 	CPU_FREE(cpu_present_set);
1955c98d5d94SLen Brown 	cpu_present_set = NULL;
195636229897SLen Brown 	cpu_present_setsize = 0;
1957103a8feaSLen Brown 
1958c98d5d94SLen Brown 	CPU_FREE(cpu_affinity_set);
1959c98d5d94SLen Brown 	cpu_affinity_set = NULL;
1960c98d5d94SLen Brown 	cpu_affinity_setsize = 0;
1961103a8feaSLen Brown 
1962c98d5d94SLen Brown 	free(thread_even);
1963c98d5d94SLen Brown 	free(core_even);
1964c98d5d94SLen Brown 	free(package_even);
1965103a8feaSLen Brown 
1966c98d5d94SLen Brown 	thread_even = NULL;
1967c98d5d94SLen Brown 	core_even = NULL;
1968c98d5d94SLen Brown 	package_even = NULL;
1969103a8feaSLen Brown 
1970c98d5d94SLen Brown 	free(thread_odd);
1971c98d5d94SLen Brown 	free(core_odd);
1972c98d5d94SLen Brown 	free(package_odd);
1973103a8feaSLen Brown 
1974c98d5d94SLen Brown 	thread_odd = NULL;
1975c98d5d94SLen Brown 	core_odd = NULL;
1976c98d5d94SLen Brown 	package_odd = NULL;
1977103a8feaSLen Brown 
1978c98d5d94SLen Brown 	free(output_buffer);
1979c98d5d94SLen Brown 	output_buffer = NULL;
1980c98d5d94SLen Brown 	outp = NULL;
198136229897SLen Brown 
198236229897SLen Brown 	free_fd_percpu();
1983562a2d37SLen Brown 
1984562a2d37SLen Brown 	free(irq_column_2_cpu);
1985562a2d37SLen Brown 	free(irqs_per_cpu);
1986103a8feaSLen Brown }
1987103a8feaSLen Brown 
1988103a8feaSLen Brown /*
198957a42a34SJosh Triplett  * Open a file, and exit on failure
199057a42a34SJosh Triplett  */
199157a42a34SJosh Triplett FILE *fopen_or_die(const char *path, const char *mode)
199257a42a34SJosh Triplett {
1993b7d8c148SLen Brown 	FILE *filep = fopen(path, mode);
1994b2c95d90SJosh Triplett 	if (!filep)
1995b2c95d90SJosh Triplett 		err(1, "%s: open failed", path);
199657a42a34SJosh Triplett 	return filep;
199757a42a34SJosh Triplett }
199857a42a34SJosh Triplett 
199957a42a34SJosh Triplett /*
200095aebc44SJosh Triplett  * Parse a file containing a single int.
200195aebc44SJosh Triplett  */
200295aebc44SJosh Triplett int parse_int_file(const char *fmt, ...)
200395aebc44SJosh Triplett {
200495aebc44SJosh Triplett 	va_list args;
200595aebc44SJosh Triplett 	char path[PATH_MAX];
200695aebc44SJosh Triplett 	FILE *filep;
200795aebc44SJosh Triplett 	int value;
200895aebc44SJosh Triplett 
200995aebc44SJosh Triplett 	va_start(args, fmt);
201095aebc44SJosh Triplett 	vsnprintf(path, sizeof(path), fmt, args);
201195aebc44SJosh Triplett 	va_end(args);
201257a42a34SJosh Triplett 	filep = fopen_or_die(path, "r");
2013b2c95d90SJosh Triplett 	if (fscanf(filep, "%d", &value) != 1)
2014b2c95d90SJosh Triplett 		err(1, "%s: failed to parse number from file", path);
201595aebc44SJosh Triplett 	fclose(filep);
201695aebc44SJosh Triplett 	return value;
201795aebc44SJosh Triplett }
201895aebc44SJosh Triplett 
201995aebc44SJosh Triplett /*
2020e275b388SDasaratharaman Chandramouli  * get_cpu_position_in_core(cpu)
2021e275b388SDasaratharaman Chandramouli  * return the position of the CPU among its HT siblings in the core
2022e275b388SDasaratharaman Chandramouli  * return -1 if the sibling is not in list
2023103a8feaSLen Brown  */
2024e275b388SDasaratharaman Chandramouli int get_cpu_position_in_core(int cpu)
2025103a8feaSLen Brown {
2026e275b388SDasaratharaman Chandramouli 	char path[64];
2027e275b388SDasaratharaman Chandramouli 	FILE *filep;
2028e275b388SDasaratharaman Chandramouli 	int this_cpu;
2029e275b388SDasaratharaman Chandramouli 	char character;
2030e275b388SDasaratharaman Chandramouli 	int i;
2031e275b388SDasaratharaman Chandramouli 
2032e275b388SDasaratharaman Chandramouli 	sprintf(path,
2033e275b388SDasaratharaman Chandramouli 		"/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list",
2034e275b388SDasaratharaman Chandramouli 		cpu);
2035e275b388SDasaratharaman Chandramouli 	filep = fopen(path, "r");
2036e275b388SDasaratharaman Chandramouli 	if (filep == NULL) {
2037e275b388SDasaratharaman Chandramouli 		perror(path);
2038e275b388SDasaratharaman Chandramouli 		exit(1);
2039e275b388SDasaratharaman Chandramouli 	}
2040e275b388SDasaratharaman Chandramouli 
2041e275b388SDasaratharaman Chandramouli 	for (i = 0; i < topo.num_threads_per_core; i++) {
2042e275b388SDasaratharaman Chandramouli 		fscanf(filep, "%d", &this_cpu);
2043e275b388SDasaratharaman Chandramouli 		if (this_cpu == cpu) {
2044e275b388SDasaratharaman Chandramouli 			fclose(filep);
2045e275b388SDasaratharaman Chandramouli 			return i;
2046e275b388SDasaratharaman Chandramouli 		}
2047e275b388SDasaratharaman Chandramouli 
2048e275b388SDasaratharaman Chandramouli 		/* Account for no separator after last thread*/
2049e275b388SDasaratharaman Chandramouli 		if (i != (topo.num_threads_per_core - 1))
2050e275b388SDasaratharaman Chandramouli 			fscanf(filep, "%c", &character);
2051e275b388SDasaratharaman Chandramouli 	}
2052e275b388SDasaratharaman Chandramouli 
2053e275b388SDasaratharaman Chandramouli 	fclose(filep);
2054e275b388SDasaratharaman Chandramouli 	return -1;
2055c98d5d94SLen Brown }
2056103a8feaSLen Brown 
2057c98d5d94SLen Brown /*
2058c98d5d94SLen Brown  * cpu_is_first_core_in_package(cpu)
2059c98d5d94SLen Brown  * return 1 if given CPU is 1st core in package
2060c98d5d94SLen Brown  */
2061c98d5d94SLen Brown int cpu_is_first_core_in_package(int cpu)
2062c98d5d94SLen Brown {
206395aebc44SJosh Triplett 	return cpu == parse_int_file("/sys/devices/system/cpu/cpu%d/topology/core_siblings_list", cpu);
2064103a8feaSLen Brown }
2065103a8feaSLen Brown 
2066103a8feaSLen Brown int get_physical_package_id(int cpu)
2067103a8feaSLen Brown {
206895aebc44SJosh Triplett 	return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/physical_package_id", cpu);
2069103a8feaSLen Brown }
2070103a8feaSLen Brown 
2071103a8feaSLen Brown int get_core_id(int cpu)
2072103a8feaSLen Brown {
207395aebc44SJosh Triplett 	return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/core_id", cpu);
2074103a8feaSLen Brown }
2075103a8feaSLen Brown 
2076c98d5d94SLen Brown int get_num_ht_siblings(int cpu)
2077c98d5d94SLen Brown {
2078c98d5d94SLen Brown 	char path[80];
2079c98d5d94SLen Brown 	FILE *filep;
2080e275b388SDasaratharaman Chandramouli 	int sib1;
2081e275b388SDasaratharaman Chandramouli 	int matches = 0;
2082c98d5d94SLen Brown 	char character;
2083e275b388SDasaratharaman Chandramouli 	char str[100];
2084e275b388SDasaratharaman Chandramouli 	char *ch;
2085c98d5d94SLen Brown 
2086c98d5d94SLen Brown 	sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", cpu);
208757a42a34SJosh Triplett 	filep = fopen_or_die(path, "r");
2088e275b388SDasaratharaman Chandramouli 
2089103a8feaSLen Brown 	/*
2090c98d5d94SLen Brown 	 * file format:
2091e275b388SDasaratharaman Chandramouli 	 * A ',' separated or '-' separated set of numbers
2092e275b388SDasaratharaman Chandramouli 	 * (eg 1-2 or 1,3,4,5)
2093c98d5d94SLen Brown 	 */
2094e275b388SDasaratharaman Chandramouli 	fscanf(filep, "%d%c\n", &sib1, &character);
2095e275b388SDasaratharaman Chandramouli 	fseek(filep, 0, SEEK_SET);
2096e275b388SDasaratharaman Chandramouli 	fgets(str, 100, filep);
2097e275b388SDasaratharaman Chandramouli 	ch = strchr(str, character);
2098e275b388SDasaratharaman Chandramouli 	while (ch != NULL) {
2099e275b388SDasaratharaman Chandramouli 		matches++;
2100e275b388SDasaratharaman Chandramouli 		ch = strchr(ch+1, character);
2101e275b388SDasaratharaman Chandramouli 	}
2102c98d5d94SLen Brown 
2103c98d5d94SLen Brown 	fclose(filep);
2104e275b388SDasaratharaman Chandramouli 	return matches+1;
2105c98d5d94SLen Brown }
2106c98d5d94SLen Brown 
2107c98d5d94SLen Brown /*
2108c98d5d94SLen Brown  * run func(thread, core, package) in topology order
2109c98d5d94SLen Brown  * skip non-present cpus
2110103a8feaSLen Brown  */
2111103a8feaSLen Brown 
2112c98d5d94SLen Brown int for_all_cpus_2(int (func)(struct thread_data *, struct core_data *,
2113c98d5d94SLen Brown 	struct pkg_data *, struct thread_data *, struct core_data *,
2114c98d5d94SLen Brown 	struct pkg_data *), struct thread_data *thread_base,
2115c98d5d94SLen Brown 	struct core_data *core_base, struct pkg_data *pkg_base,
2116c98d5d94SLen Brown 	struct thread_data *thread_base2, struct core_data *core_base2,
2117c98d5d94SLen Brown 	struct pkg_data *pkg_base2)
2118c98d5d94SLen Brown {
2119c98d5d94SLen Brown 	int retval, pkg_no, core_no, thread_no;
2120c98d5d94SLen Brown 
2121c98d5d94SLen Brown 	for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
2122c98d5d94SLen Brown 		for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
2123c98d5d94SLen Brown 			for (thread_no = 0; thread_no <
2124c98d5d94SLen Brown 				topo.num_threads_per_core; ++thread_no) {
2125c98d5d94SLen Brown 				struct thread_data *t, *t2;
2126c98d5d94SLen Brown 				struct core_data *c, *c2;
2127c98d5d94SLen Brown 				struct pkg_data *p, *p2;
2128c98d5d94SLen Brown 
2129c98d5d94SLen Brown 				t = GET_THREAD(thread_base, thread_no, core_no, pkg_no);
2130c98d5d94SLen Brown 
2131c98d5d94SLen Brown 				if (cpu_is_not_present(t->cpu_id))
2132c98d5d94SLen Brown 					continue;
2133c98d5d94SLen Brown 
2134c98d5d94SLen Brown 				t2 = GET_THREAD(thread_base2, thread_no, core_no, pkg_no);
2135c98d5d94SLen Brown 
2136c98d5d94SLen Brown 				c = GET_CORE(core_base, core_no, pkg_no);
2137c98d5d94SLen Brown 				c2 = GET_CORE(core_base2, core_no, pkg_no);
2138c98d5d94SLen Brown 
2139c98d5d94SLen Brown 				p = GET_PKG(pkg_base, pkg_no);
2140c98d5d94SLen Brown 				p2 = GET_PKG(pkg_base2, pkg_no);
2141c98d5d94SLen Brown 
2142c98d5d94SLen Brown 				retval = func(t, c, p, t2, c2, p2);
2143c98d5d94SLen Brown 				if (retval)
2144c98d5d94SLen Brown 					return retval;
2145c98d5d94SLen Brown 			}
2146c98d5d94SLen Brown 		}
2147c98d5d94SLen Brown 	}
2148c98d5d94SLen Brown 	return 0;
2149c98d5d94SLen Brown }
2150c98d5d94SLen Brown 
2151c98d5d94SLen Brown /*
2152c98d5d94SLen Brown  * run func(cpu) on every cpu in /proc/stat
2153c98d5d94SLen Brown  * return max_cpu number
2154c98d5d94SLen Brown  */
2155c98d5d94SLen Brown int for_all_proc_cpus(int (func)(int))
2156103a8feaSLen Brown {
2157103a8feaSLen Brown 	FILE *fp;
2158c98d5d94SLen Brown 	int cpu_num;
2159103a8feaSLen Brown 	int retval;
2160103a8feaSLen Brown 
216157a42a34SJosh Triplett 	fp = fopen_or_die(proc_stat, "r");
2162103a8feaSLen Brown 
2163103a8feaSLen Brown 	retval = fscanf(fp, "cpu %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n");
2164b2c95d90SJosh Triplett 	if (retval != 0)
2165b2c95d90SJosh Triplett 		err(1, "%s: failed to parse format", proc_stat);
2166103a8feaSLen Brown 
2167c98d5d94SLen Brown 	while (1) {
2168c98d5d94SLen Brown 		retval = fscanf(fp, "cpu%u %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n", &cpu_num);
2169103a8feaSLen Brown 		if (retval != 1)
2170103a8feaSLen Brown 			break;
2171103a8feaSLen Brown 
2172c98d5d94SLen Brown 		retval = func(cpu_num);
2173c98d5d94SLen Brown 		if (retval) {
2174c98d5d94SLen Brown 			fclose(fp);
2175c98d5d94SLen Brown 			return(retval);
2176c98d5d94SLen Brown 		}
2177103a8feaSLen Brown 	}
2178103a8feaSLen Brown 	fclose(fp);
2179c98d5d94SLen Brown 	return 0;
2180103a8feaSLen Brown }
2181103a8feaSLen Brown 
2182103a8feaSLen Brown void re_initialize(void)
2183103a8feaSLen Brown {
2184c98d5d94SLen Brown 	free_all_buffers();
2185c98d5d94SLen Brown 	setup_all_buffers();
2186c98d5d94SLen Brown 	printf("turbostat: re-initialized with num_cpus %d\n", topo.num_cpus);
2187103a8feaSLen Brown }
2188103a8feaSLen Brown 
2189c98d5d94SLen Brown 
2190103a8feaSLen Brown /*
2191c98d5d94SLen Brown  * count_cpus()
2192c98d5d94SLen Brown  * remember the last one seen, it will be the max
2193103a8feaSLen Brown  */
2194c98d5d94SLen Brown int count_cpus(int cpu)
2195103a8feaSLen Brown {
2196c98d5d94SLen Brown 	if (topo.max_cpu_num < cpu)
2197c98d5d94SLen Brown 		topo.max_cpu_num = cpu;
2198103a8feaSLen Brown 
2199c98d5d94SLen Brown 	topo.num_cpus += 1;
2200c98d5d94SLen Brown 	return 0;
2201103a8feaSLen Brown }
2202c98d5d94SLen Brown int mark_cpu_present(int cpu)
2203c98d5d94SLen Brown {
2204c98d5d94SLen Brown 	CPU_SET_S(cpu, cpu_present_setsize, cpu_present_set);
220515aaa346SLen Brown 	return 0;
2206103a8feaSLen Brown }
2207103a8feaSLen Brown 
2208562a2d37SLen Brown /*
2209562a2d37SLen Brown  * snapshot_proc_interrupts()
2210562a2d37SLen Brown  *
2211562a2d37SLen Brown  * read and record summary of /proc/interrupts
2212562a2d37SLen Brown  *
2213562a2d37SLen Brown  * return 1 if config change requires a restart, else return 0
2214562a2d37SLen Brown  */
2215562a2d37SLen Brown int snapshot_proc_interrupts(void)
2216562a2d37SLen Brown {
2217562a2d37SLen Brown 	static FILE *fp;
2218562a2d37SLen Brown 	int column, retval;
2219562a2d37SLen Brown 
2220562a2d37SLen Brown 	if (fp == NULL)
2221562a2d37SLen Brown 		fp = fopen_or_die("/proc/interrupts", "r");
2222562a2d37SLen Brown 	else
2223562a2d37SLen Brown 		rewind(fp);
2224562a2d37SLen Brown 
2225562a2d37SLen Brown 	/* read 1st line of /proc/interrupts to get cpu* name for each column */
2226562a2d37SLen Brown 	for (column = 0; column < topo.num_cpus; ++column) {
2227562a2d37SLen Brown 		int cpu_number;
2228562a2d37SLen Brown 
2229562a2d37SLen Brown 		retval = fscanf(fp, " CPU%d", &cpu_number);
2230562a2d37SLen Brown 		if (retval != 1)
2231562a2d37SLen Brown 			break;
2232562a2d37SLen Brown 
2233562a2d37SLen Brown 		if (cpu_number > topo.max_cpu_num) {
2234562a2d37SLen Brown 			warn("/proc/interrupts: cpu%d: > %d", cpu_number, topo.max_cpu_num);
2235562a2d37SLen Brown 			return 1;
2236562a2d37SLen Brown 		}
2237562a2d37SLen Brown 
2238562a2d37SLen Brown 		irq_column_2_cpu[column] = cpu_number;
2239562a2d37SLen Brown 		irqs_per_cpu[cpu_number] = 0;
2240562a2d37SLen Brown 	}
2241562a2d37SLen Brown 
2242562a2d37SLen Brown 	/* read /proc/interrupt count lines and sum up irqs per cpu */
2243562a2d37SLen Brown 	while (1) {
2244562a2d37SLen Brown 		int column;
2245562a2d37SLen Brown 		char buf[64];
2246562a2d37SLen Brown 
2247562a2d37SLen Brown 		retval = fscanf(fp, " %s:", buf);	/* flush irq# "N:" */
2248562a2d37SLen Brown 		if (retval != 1)
2249562a2d37SLen Brown 			break;
2250562a2d37SLen Brown 
2251562a2d37SLen Brown 		/* read the count per cpu */
2252562a2d37SLen Brown 		for (column = 0; column < topo.num_cpus; ++column) {
2253562a2d37SLen Brown 
2254562a2d37SLen Brown 			int cpu_number, irq_count;
2255562a2d37SLen Brown 
2256562a2d37SLen Brown 			retval = fscanf(fp, " %d", &irq_count);
2257562a2d37SLen Brown 			if (retval != 1)
2258562a2d37SLen Brown 				break;
2259562a2d37SLen Brown 
2260562a2d37SLen Brown 			cpu_number = irq_column_2_cpu[column];
2261562a2d37SLen Brown 			irqs_per_cpu[cpu_number] += irq_count;
2262562a2d37SLen Brown 
2263562a2d37SLen Brown 		}
2264562a2d37SLen Brown 
2265562a2d37SLen Brown 		while (getc(fp) != '\n')
2266562a2d37SLen Brown 			;	/* flush interrupt description */
2267562a2d37SLen Brown 
2268562a2d37SLen Brown 	}
2269562a2d37SLen Brown 	return 0;
2270562a2d37SLen Brown }
227127d47356SLen Brown /*
2272fdf676e5SLen Brown  * snapshot_gfx_rc6_ms()
2273fdf676e5SLen Brown  *
2274fdf676e5SLen Brown  * record snapshot of
2275fdf676e5SLen Brown  * /sys/class/drm/card0/power/rc6_residency_ms
2276fdf676e5SLen Brown  *
2277fdf676e5SLen Brown  * return 1 if config change requires a restart, else return 0
2278fdf676e5SLen Brown  */
2279fdf676e5SLen Brown int snapshot_gfx_rc6_ms(void)
2280fdf676e5SLen Brown {
2281fdf676e5SLen Brown 	FILE *fp;
2282fdf676e5SLen Brown 	int retval;
2283fdf676e5SLen Brown 
2284fdf676e5SLen Brown 	fp = fopen_or_die("/sys/class/drm/card0/power/rc6_residency_ms", "r");
2285fdf676e5SLen Brown 
2286fdf676e5SLen Brown 	retval = fscanf(fp, "%lld", &gfx_cur_rc6_ms);
2287fdf676e5SLen Brown 	if (retval != 1)
2288fdf676e5SLen Brown 		err(1, "GFX rc6");
2289fdf676e5SLen Brown 
2290fdf676e5SLen Brown 	fclose(fp);
2291fdf676e5SLen Brown 
2292fdf676e5SLen Brown 	return 0;
2293fdf676e5SLen Brown }
2294fdf676e5SLen Brown /*
229527d47356SLen Brown  * snapshot_gfx_mhz()
229627d47356SLen Brown  *
229727d47356SLen Brown  * record snapshot of
229827d47356SLen Brown  * /sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz
229927d47356SLen Brown  *
230027d47356SLen Brown  * return 1 if config change requires a restart, else return 0
230127d47356SLen Brown  */
230227d47356SLen Brown int snapshot_gfx_mhz(void)
230327d47356SLen Brown {
230427d47356SLen Brown 	static FILE *fp;
230527d47356SLen Brown 	int retval;
230627d47356SLen Brown 
230727d47356SLen Brown 	if (fp == NULL)
230827d47356SLen Brown 		fp = fopen_or_die("/sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz", "r");
230927d47356SLen Brown 	else
231027d47356SLen Brown 		rewind(fp);
231127d47356SLen Brown 
231227d47356SLen Brown 	retval = fscanf(fp, "%d", &gfx_cur_mhz);
231327d47356SLen Brown 	if (retval != 1)
231427d47356SLen Brown 		err(1, "GFX MHz");
231527d47356SLen Brown 
231627d47356SLen Brown 	return 0;
231727d47356SLen Brown }
2318562a2d37SLen Brown 
2319562a2d37SLen Brown /*
2320562a2d37SLen Brown  * snapshot /proc and /sys files
2321562a2d37SLen Brown  *
2322562a2d37SLen Brown  * return 1 if configuration restart needed, else return 0
2323562a2d37SLen Brown  */
2324562a2d37SLen Brown int snapshot_proc_sysfs_files(void)
2325562a2d37SLen Brown {
2326562a2d37SLen Brown 	if (snapshot_proc_interrupts())
2327562a2d37SLen Brown 		return 1;
2328562a2d37SLen Brown 
2329812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_rc6))
2330fdf676e5SLen Brown 		snapshot_gfx_rc6_ms();
2331fdf676e5SLen Brown 
2332812db3f7SLen Brown 	if (DO_BIC(BIC_GFXMHz))
233327d47356SLen Brown 		snapshot_gfx_mhz();
233427d47356SLen Brown 
2335562a2d37SLen Brown 	return 0;
2336562a2d37SLen Brown }
2337562a2d37SLen Brown 
2338103a8feaSLen Brown void turbostat_loop()
2339103a8feaSLen Brown {
2340c98d5d94SLen Brown 	int retval;
2341e52966c0SLen Brown 	int restarted = 0;
2342c98d5d94SLen Brown 
2343103a8feaSLen Brown restart:
2344e52966c0SLen Brown 	restarted++;
2345e52966c0SLen Brown 
2346562a2d37SLen Brown 	snapshot_proc_sysfs_files();
2347c98d5d94SLen Brown 	retval = for_all_cpus(get_counters, EVEN_COUNTERS);
2348d91bb17cSLen Brown 	if (retval < -1) {
2349d91bb17cSLen Brown 		exit(retval);
2350d91bb17cSLen Brown 	} else if (retval == -1) {
2351e52966c0SLen Brown 		if (restarted > 1) {
2352e52966c0SLen Brown 			exit(retval);
2353e52966c0SLen Brown 		}
2354c98d5d94SLen Brown 		re_initialize();
2355c98d5d94SLen Brown 		goto restart;
2356c98d5d94SLen Brown 	}
2357e52966c0SLen Brown 	restarted = 0;
2358103a8feaSLen Brown 	gettimeofday(&tv_even, (struct timezone *)NULL);
2359103a8feaSLen Brown 
2360103a8feaSLen Brown 	while (1) {
2361c98d5d94SLen Brown 		if (for_all_proc_cpus(cpu_is_not_present)) {
2362103a8feaSLen Brown 			re_initialize();
2363103a8feaSLen Brown 			goto restart;
2364103a8feaSLen Brown 		}
23652a0609c0SLen Brown 		nanosleep(&interval_ts, NULL);
2366562a2d37SLen Brown 		if (snapshot_proc_sysfs_files())
2367562a2d37SLen Brown 			goto restart;
2368c98d5d94SLen Brown 		retval = for_all_cpus(get_counters, ODD_COUNTERS);
2369d91bb17cSLen Brown 		if (retval < -1) {
2370d91bb17cSLen Brown 			exit(retval);
2371d91bb17cSLen Brown 		} else if (retval == -1) {
237215aaa346SLen Brown 			re_initialize();
237315aaa346SLen Brown 			goto restart;
237415aaa346SLen Brown 		}
2375103a8feaSLen Brown 		gettimeofday(&tv_odd, (struct timezone *)NULL);
2376103a8feaSLen Brown 		timersub(&tv_odd, &tv_even, &tv_delta);
2377ba3dec99SLen Brown 		if (for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS)) {
2378ba3dec99SLen Brown 			re_initialize();
2379ba3dec99SLen Brown 			goto restart;
2380ba3dec99SLen Brown 		}
2381c98d5d94SLen Brown 		compute_average(EVEN_COUNTERS);
2382c98d5d94SLen Brown 		format_all_counters(EVEN_COUNTERS);
2383b7d8c148SLen Brown 		flush_output_stdout();
23842a0609c0SLen Brown 		nanosleep(&interval_ts, NULL);
2385562a2d37SLen Brown 		if (snapshot_proc_sysfs_files())
2386562a2d37SLen Brown 			goto restart;
2387c98d5d94SLen Brown 		retval = for_all_cpus(get_counters, EVEN_COUNTERS);
2388d91bb17cSLen Brown 		if (retval < -1) {
2389d91bb17cSLen Brown 			exit(retval);
2390d91bb17cSLen Brown 		} else if (retval == -1) {
2391103a8feaSLen Brown 			re_initialize();
2392103a8feaSLen Brown 			goto restart;
2393103a8feaSLen Brown 		}
2394103a8feaSLen Brown 		gettimeofday(&tv_even, (struct timezone *)NULL);
2395103a8feaSLen Brown 		timersub(&tv_even, &tv_odd, &tv_delta);
2396ba3dec99SLen Brown 		if (for_all_cpus_2(delta_cpu, EVEN_COUNTERS, ODD_COUNTERS)) {
2397ba3dec99SLen Brown 			re_initialize();
2398ba3dec99SLen Brown 			goto restart;
2399ba3dec99SLen Brown 		}
2400c98d5d94SLen Brown 		compute_average(ODD_COUNTERS);
2401c98d5d94SLen Brown 		format_all_counters(ODD_COUNTERS);
2402b7d8c148SLen Brown 		flush_output_stdout();
2403103a8feaSLen Brown 	}
2404103a8feaSLen Brown }
2405103a8feaSLen Brown 
2406103a8feaSLen Brown void check_dev_msr()
2407103a8feaSLen Brown {
2408103a8feaSLen Brown 	struct stat sb;
24097ce7d5deSPrarit Bhargava 	char pathname[32];
2410103a8feaSLen Brown 
24117ce7d5deSPrarit Bhargava 	sprintf(pathname, "/dev/cpu/%d/msr", base_cpu);
24127ce7d5deSPrarit Bhargava 	if (stat(pathname, &sb))
2413a21d38c8SLen Brown  		if (system("/sbin/modprobe msr > /dev/null 2>&1"))
2414d7899447SLen Brown 			err(-5, "no /dev/cpu/0/msr, Try \"# modprobe msr\" ");
2415103a8feaSLen Brown }
2416103a8feaSLen Brown 
241798481e79SLen Brown void check_permissions()
2418103a8feaSLen Brown {
241998481e79SLen Brown 	struct __user_cap_header_struct cap_header_data;
242098481e79SLen Brown 	cap_user_header_t cap_header = &cap_header_data;
242198481e79SLen Brown 	struct __user_cap_data_struct cap_data_data;
242298481e79SLen Brown 	cap_user_data_t cap_data = &cap_data_data;
242398481e79SLen Brown 	extern int capget(cap_user_header_t hdrp, cap_user_data_t datap);
242498481e79SLen Brown 	int do_exit = 0;
24257ce7d5deSPrarit Bhargava 	char pathname[32];
242698481e79SLen Brown 
242798481e79SLen Brown 	/* check for CAP_SYS_RAWIO */
242898481e79SLen Brown 	cap_header->pid = getpid();
242998481e79SLen Brown 	cap_header->version = _LINUX_CAPABILITY_VERSION;
243098481e79SLen Brown 	if (capget(cap_header, cap_data) < 0)
243198481e79SLen Brown 		err(-6, "capget(2) failed");
243298481e79SLen Brown 
243398481e79SLen Brown 	if ((cap_data->effective & (1 << CAP_SYS_RAWIO)) == 0) {
243498481e79SLen Brown 		do_exit++;
243598481e79SLen Brown 		warnx("capget(CAP_SYS_RAWIO) failed,"
243698481e79SLen Brown 			" try \"# setcap cap_sys_rawio=ep %s\"", progname);
243798481e79SLen Brown 	}
243898481e79SLen Brown 
243998481e79SLen Brown 	/* test file permissions */
24407ce7d5deSPrarit Bhargava 	sprintf(pathname, "/dev/cpu/%d/msr", base_cpu);
24417ce7d5deSPrarit Bhargava 	if (euidaccess(pathname, R_OK)) {
244298481e79SLen Brown 		do_exit++;
244398481e79SLen Brown 		warn("/dev/cpu/0/msr open failed, try chown or chmod +r /dev/cpu/*/msr");
244498481e79SLen Brown 	}
244598481e79SLen Brown 
244698481e79SLen Brown 	/* if all else fails, thell them to be root */
244798481e79SLen Brown 	if (do_exit)
2448b2c95d90SJosh Triplett 		if (getuid() != 0)
2449d7899447SLen Brown 			warnx("... or simply run as root");
245098481e79SLen Brown 
245198481e79SLen Brown 	if (do_exit)
245298481e79SLen Brown 		exit(-6);
2453103a8feaSLen Brown }
2454103a8feaSLen Brown 
2455d7899447SLen Brown /*
2456d7899447SLen Brown  * NHM adds support for additional MSRs:
2457d7899447SLen Brown  *
2458d7899447SLen Brown  * MSR_SMI_COUNT                   0x00000034
2459d7899447SLen Brown  *
2460ec0adc53SLen Brown  * MSR_PLATFORM_INFO               0x000000ce
24611df2e55aSLen Brown  * MSR_PKG_CST_CONFIG_CONTROL     0x000000e2
2462d7899447SLen Brown  *
2463cf4cbe53SLen Brown  * MSR_MISC_PWR_MGMT               0x000001aa
2464cf4cbe53SLen Brown  *
2465d7899447SLen Brown  * MSR_PKG_C3_RESIDENCY            0x000003f8
2466d7899447SLen Brown  * MSR_PKG_C6_RESIDENCY            0x000003f9
2467d7899447SLen Brown  * MSR_CORE_C3_RESIDENCY           0x000003fc
2468d7899447SLen Brown  * MSR_CORE_C6_RESIDENCY           0x000003fd
2469d7899447SLen Brown  *
2470ee7e38e3SLen Brown  * Side effect:
24711df2e55aSLen Brown  * sets global pkg_cstate_limit to decode MSR_PKG_CST_CONFIG_CONTROL
247233148d67SLen Brown  * sets has_misc_feature_control
2473d7899447SLen Brown  */
2474ee7e38e3SLen Brown int probe_nhm_msrs(unsigned int family, unsigned int model)
2475103a8feaSLen Brown {
2476ee7e38e3SLen Brown 	unsigned long long msr;
247721ed5574SLen Brown 	unsigned int base_ratio;
2478ee7e38e3SLen Brown 	int *pkg_cstate_limits;
2479ee7e38e3SLen Brown 
2480103a8feaSLen Brown 	if (!genuine_intel)
2481103a8feaSLen Brown 		return 0;
2482103a8feaSLen Brown 
2483103a8feaSLen Brown 	if (family != 6)
2484103a8feaSLen Brown 		return 0;
2485103a8feaSLen Brown 
248621ed5574SLen Brown 	bclk = discover_bclk(family, model);
248721ed5574SLen Brown 
2488103a8feaSLen Brown 	switch (model) {
2489869ce69eSLen Brown 	case INTEL_FAM6_NEHALEM_EP:	/* Core i7, Xeon 5500 series - Bloomfield, Gainstown NHM-EP */
2490869ce69eSLen Brown 	case INTEL_FAM6_NEHALEM:	/* Core i7 and i5 Processor - Clarksfield, Lynnfield, Jasper Forest */
2491103a8feaSLen Brown 	case 0x1F:	/* Core i7 and i5 Processor - Nehalem */
2492869ce69eSLen Brown 	case INTEL_FAM6_WESTMERE:	/* Westmere Client - Clarkdale, Arrandale */
2493869ce69eSLen Brown 	case INTEL_FAM6_WESTMERE_EP:	/* Westmere EP - Gulftown */
2494869ce69eSLen Brown 	case INTEL_FAM6_NEHALEM_EX:	/* Nehalem-EX Xeon - Beckton */
2495869ce69eSLen Brown 	case INTEL_FAM6_WESTMERE_EX:	/* Westmere-EX Xeon - Eagleton */
2496ee7e38e3SLen Brown 		pkg_cstate_limits = nhm_pkg_cstate_limits;
2497ee7e38e3SLen Brown 		break;
2498869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE:	/* SNB */
2499869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE_X:	/* SNB Xeon */
2500869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE:	/* IVB */
2501869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE_X:	/* IVB Xeon */
2502ee7e38e3SLen Brown 		pkg_cstate_limits = snb_pkg_cstate_limits;
250333148d67SLen Brown 		has_misc_feature_control = 1;
2504ee7e38e3SLen Brown 		break;
2505869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
2506869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
2507869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
2508869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
2509869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
2510869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_GT3E:	/* BDW */
2511869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
2512869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
2513869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
2514869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
2515869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
2516869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
2517ee7e38e3SLen Brown 		pkg_cstate_limits = hsw_pkg_cstate_limits;
251833148d67SLen Brown 		has_misc_feature_control = 1;
2519ee7e38e3SLen Brown 		break;
2520d8ebb442SLen Brown 	case INTEL_FAM6_SKYLAKE_X:	/* SKX */
2521d8ebb442SLen Brown 		pkg_cstate_limits = skx_pkg_cstate_limits;
252233148d67SLen Brown 		has_misc_feature_control = 1;
2523d8ebb442SLen Brown 		break;
2524869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:	/* BYT */
2525cf4cbe53SLen Brown 		no_MSR_MISC_PWR_MGMT = 1;
2526869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT2:	/* AVN */
2527ee7e38e3SLen Brown 		pkg_cstate_limits = slv_pkg_cstate_limits;
2528ee7e38e3SLen Brown 		break;
2529869ce69eSLen Brown 	case INTEL_FAM6_ATOM_AIRMONT:	/* AMT */
2530ee7e38e3SLen Brown 		pkg_cstate_limits = amt_pkg_cstate_limits;
2531cf4cbe53SLen Brown 		no_MSR_MISC_PWR_MGMT = 1;
2532ee7e38e3SLen Brown 		break;
2533869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* PHI */
2534005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
2535ee7e38e3SLen Brown 		pkg_cstate_limits = phi_pkg_cstate_limits;
2536ee7e38e3SLen Brown 		break;
2537869ce69eSLen Brown 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
2538ac01ac13SLen Brown 	case INTEL_FAM6_ATOM_GEMINI_LAKE:
2539869ce69eSLen Brown 	case INTEL_FAM6_ATOM_DENVERTON:	/* DNV */
2540e4085d54SLen Brown 		pkg_cstate_limits = bxt_pkg_cstate_limits;
2541e4085d54SLen Brown 		break;
2542103a8feaSLen Brown 	default:
2543103a8feaSLen Brown 		return 0;
2544103a8feaSLen Brown 	}
25451df2e55aSLen Brown 	get_msr(base_cpu, MSR_PKG_CST_CONFIG_CONTROL, &msr);
2546e9257f5fSLen Brown 	pkg_cstate_limit = pkg_cstate_limits[msr & 0xF];
2547ee7e38e3SLen Brown 
2548ec0adc53SLen Brown 	get_msr(base_cpu, MSR_PLATFORM_INFO, &msr);
254921ed5574SLen Brown 	base_ratio = (msr >> 8) & 0xFF;
255021ed5574SLen Brown 
255121ed5574SLen Brown 	base_hz = base_ratio * bclk * 1000000;
255221ed5574SLen Brown 	has_base_hz = 1;
2553ee7e38e3SLen Brown 	return 1;
2554103a8feaSLen Brown }
25550f7887c4SLen Brown /*
25560f7887c4SLen Brown  * SLV client has supporet for unique MSRs:
25570f7887c4SLen Brown  *
25580f7887c4SLen Brown  * MSR_CC6_DEMOTION_POLICY_CONFIG
25590f7887c4SLen Brown  * MSR_MC6_DEMOTION_POLICY_CONFIG
25600f7887c4SLen Brown  */
25610f7887c4SLen Brown 
25620f7887c4SLen Brown int has_slv_msrs(unsigned int family, unsigned int model)
25630f7887c4SLen Brown {
25640f7887c4SLen Brown 	if (!genuine_intel)
25650f7887c4SLen Brown 		return 0;
25660f7887c4SLen Brown 
25670f7887c4SLen Brown 	switch (model) {
25680f7887c4SLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:
25690f7887c4SLen Brown 	case INTEL_FAM6_ATOM_MERRIFIELD:
25700f7887c4SLen Brown 	case INTEL_FAM6_ATOM_MOOREFIELD:
25710f7887c4SLen Brown 		return 1;
25720f7887c4SLen Brown 	}
25730f7887c4SLen Brown 	return 0;
25740f7887c4SLen Brown }
25750f7887c4SLen Brown 
2576d7899447SLen Brown int has_nhm_turbo_ratio_limit(unsigned int family, unsigned int model)
2577d7899447SLen Brown {
25780f7887c4SLen Brown 	if (has_slv_msrs(family, model))
25790f7887c4SLen Brown 		return 0;
25800f7887c4SLen Brown 
2581d7899447SLen Brown 	switch (model) {
2582d7899447SLen Brown 	/* Nehalem compatible, but do not include turbo-ratio limit support */
2583869ce69eSLen Brown 	case INTEL_FAM6_NEHALEM_EX:	/* Nehalem-EX Xeon - Beckton */
2584869ce69eSLen Brown 	case INTEL_FAM6_WESTMERE_EX:	/* Westmere-EX Xeon - Eagleton */
2585869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* PHI - Knights Landing (different MSR definition) */
2586005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
2587d7899447SLen Brown 		return 0;
2588d7899447SLen Brown 	default:
2589d7899447SLen Brown 		return 1;
2590d7899447SLen Brown 	}
2591d7899447SLen Brown }
25920f7887c4SLen Brown int has_atom_turbo_ratio_limit(unsigned int family, unsigned int model)
25930f7887c4SLen Brown {
25940f7887c4SLen Brown 	if (has_slv_msrs(family, model))
25950f7887c4SLen Brown 		return 1;
25960f7887c4SLen Brown 
25970f7887c4SLen Brown 	return 0;
25980f7887c4SLen Brown }
25996574a5d5SLen Brown int has_ivt_turbo_ratio_limit(unsigned int family, unsigned int model)
26006574a5d5SLen Brown {
26016574a5d5SLen Brown 	if (!genuine_intel)
26026574a5d5SLen Brown 		return 0;
26036574a5d5SLen Brown 
26046574a5d5SLen Brown 	if (family != 6)
26056574a5d5SLen Brown 		return 0;
26066574a5d5SLen Brown 
26076574a5d5SLen Brown 	switch (model) {
2608869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE_X:	/* IVB Xeon */
2609869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSW Xeon */
26106574a5d5SLen Brown 		return 1;
26116574a5d5SLen Brown 	default:
26126574a5d5SLen Brown 		return 0;
26136574a5d5SLen Brown 	}
26146574a5d5SLen Brown }
2615fcd17211SLen Brown int has_hsw_turbo_ratio_limit(unsigned int family, unsigned int model)
2616fcd17211SLen Brown {
2617fcd17211SLen Brown 	if (!genuine_intel)
2618fcd17211SLen Brown 		return 0;
2619fcd17211SLen Brown 
2620fcd17211SLen Brown 	if (family != 6)
2621fcd17211SLen Brown 		return 0;
2622fcd17211SLen Brown 
2623fcd17211SLen Brown 	switch (model) {
2624869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSW Xeon */
2625fcd17211SLen Brown 		return 1;
2626fcd17211SLen Brown 	default:
2627fcd17211SLen Brown 		return 0;
2628fcd17211SLen Brown 	}
2629fcd17211SLen Brown }
2630fcd17211SLen Brown 
2631fb5d4327SDasaratharaman Chandramouli int has_knl_turbo_ratio_limit(unsigned int family, unsigned int model)
2632fb5d4327SDasaratharaman Chandramouli {
2633fb5d4327SDasaratharaman Chandramouli 	if (!genuine_intel)
2634fb5d4327SDasaratharaman Chandramouli 		return 0;
2635fb5d4327SDasaratharaman Chandramouli 
2636fb5d4327SDasaratharaman Chandramouli 	if (family != 6)
2637fb5d4327SDasaratharaman Chandramouli 		return 0;
2638fb5d4327SDasaratharaman Chandramouli 
2639fb5d4327SDasaratharaman Chandramouli 	switch (model) {
2640869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* Knights Landing */
2641005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
2642fb5d4327SDasaratharaman Chandramouli 		return 1;
2643fb5d4327SDasaratharaman Chandramouli 	default:
2644fb5d4327SDasaratharaman Chandramouli 		return 0;
2645fb5d4327SDasaratharaman Chandramouli 	}
2646fb5d4327SDasaratharaman Chandramouli }
26476fb3143bSLen Brown int has_config_tdp(unsigned int family, unsigned int model)
26486fb3143bSLen Brown {
26496fb3143bSLen Brown 	if (!genuine_intel)
26506fb3143bSLen Brown 		return 0;
26516fb3143bSLen Brown 
26526fb3143bSLen Brown 	if (family != 6)
26536fb3143bSLen Brown 		return 0;
26546fb3143bSLen Brown 
26556fb3143bSLen Brown 	switch (model) {
2656869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE:	/* IVB */
2657869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
2658869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
2659869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
2660869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
2661869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
2662869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_GT3E:	/* BDW */
2663869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
2664869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
2665869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
2666869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
2667869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
2668869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
2669869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_X:	/* SKX */
26706fb3143bSLen Brown 
2671869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* Knights Landing */
2672005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
26736fb3143bSLen Brown 		return 1;
26746fb3143bSLen Brown 	default:
26756fb3143bSLen Brown 		return 0;
26766fb3143bSLen Brown 	}
26776fb3143bSLen Brown }
26786fb3143bSLen Brown 
2679fcd17211SLen Brown static void
26801b69317dSColin Ian King dump_cstate_pstate_config_info(unsigned int family, unsigned int model)
2681fcd17211SLen Brown {
2682fcd17211SLen Brown 	if (!do_nhm_platform_info)
2683fcd17211SLen Brown 		return;
2684fcd17211SLen Brown 
2685fcd17211SLen Brown 	dump_nhm_platform_info();
2686fcd17211SLen Brown 
2687fcd17211SLen Brown 	if (has_hsw_turbo_ratio_limit(family, model))
2688fcd17211SLen Brown 		dump_hsw_turbo_ratio_limits();
2689fcd17211SLen Brown 
2690fcd17211SLen Brown 	if (has_ivt_turbo_ratio_limit(family, model))
2691fcd17211SLen Brown 		dump_ivt_turbo_ratio_limits();
2692fcd17211SLen Brown 
2693fcd17211SLen Brown 	if (has_nhm_turbo_ratio_limit(family, model))
2694fcd17211SLen Brown 		dump_nhm_turbo_ratio_limits();
2695fcd17211SLen Brown 
26960f7887c4SLen Brown 	if (has_atom_turbo_ratio_limit(family, model))
26970f7887c4SLen Brown 		dump_atom_turbo_ratio_limits();
26980f7887c4SLen Brown 
2699fb5d4327SDasaratharaman Chandramouli 	if (has_knl_turbo_ratio_limit(family, model))
2700fb5d4327SDasaratharaman Chandramouli 		dump_knl_turbo_ratio_limits();
2701fb5d4327SDasaratharaman Chandramouli 
27026fb3143bSLen Brown 	if (has_config_tdp(family, model))
27036fb3143bSLen Brown 		dump_config_tdp();
27046fb3143bSLen Brown 
2705fcd17211SLen Brown 	dump_nhm_cst_cfg();
2706fcd17211SLen Brown }
2707fcd17211SLen Brown 
27086574a5d5SLen Brown 
2709889facbeSLen Brown /*
2710889facbeSLen Brown  * print_epb()
2711889facbeSLen Brown  * Decode the ENERGY_PERF_BIAS MSR
2712889facbeSLen Brown  */
2713889facbeSLen Brown int print_epb(struct thread_data *t, struct core_data *c, struct pkg_data *p)
2714889facbeSLen Brown {
2715889facbeSLen Brown 	unsigned long long msr;
2716889facbeSLen Brown 	char *epb_string;
2717889facbeSLen Brown 	int cpu;
2718889facbeSLen Brown 
2719889facbeSLen Brown 	if (!has_epb)
2720889facbeSLen Brown 		return 0;
2721889facbeSLen Brown 
2722889facbeSLen Brown 	cpu = t->cpu_id;
2723889facbeSLen Brown 
2724889facbeSLen Brown 	/* EPB is per-package */
2725889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
2726889facbeSLen Brown 		return 0;
2727889facbeSLen Brown 
2728889facbeSLen Brown 	if (cpu_migrate(cpu)) {
2729b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
2730889facbeSLen Brown 		return -1;
2731889facbeSLen Brown 	}
2732889facbeSLen Brown 
2733889facbeSLen Brown 	if (get_msr(cpu, MSR_IA32_ENERGY_PERF_BIAS, &msr))
2734889facbeSLen Brown 		return 0;
2735889facbeSLen Brown 
2736e9be7dd6SLen Brown 	switch (msr & 0xF) {
2737889facbeSLen Brown 	case ENERGY_PERF_BIAS_PERFORMANCE:
2738889facbeSLen Brown 		epb_string = "performance";
2739889facbeSLen Brown 		break;
2740889facbeSLen Brown 	case ENERGY_PERF_BIAS_NORMAL:
2741889facbeSLen Brown 		epb_string = "balanced";
2742889facbeSLen Brown 		break;
2743889facbeSLen Brown 	case ENERGY_PERF_BIAS_POWERSAVE:
2744889facbeSLen Brown 		epb_string = "powersave";
2745889facbeSLen Brown 		break;
2746889facbeSLen Brown 	default:
2747889facbeSLen Brown 		epb_string = "custom";
2748889facbeSLen Brown 		break;
2749889facbeSLen Brown 	}
2750b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_IA32_ENERGY_PERF_BIAS: 0x%08llx (%s)\n", cpu, msr, epb_string);
2751889facbeSLen Brown 
2752889facbeSLen Brown 	return 0;
2753889facbeSLen Brown }
27547f5c258eSLen Brown /*
27557f5c258eSLen Brown  * print_hwp()
27567f5c258eSLen Brown  * Decode the MSR_HWP_CAPABILITIES
27577f5c258eSLen Brown  */
27587f5c258eSLen Brown int print_hwp(struct thread_data *t, struct core_data *c, struct pkg_data *p)
27597f5c258eSLen Brown {
27607f5c258eSLen Brown 	unsigned long long msr;
27617f5c258eSLen Brown 	int cpu;
27627f5c258eSLen Brown 
27637f5c258eSLen Brown 	if (!has_hwp)
27647f5c258eSLen Brown 		return 0;
27657f5c258eSLen Brown 
27667f5c258eSLen Brown 	cpu = t->cpu_id;
27677f5c258eSLen Brown 
27687f5c258eSLen Brown 	/* MSR_HWP_CAPABILITIES is per-package */
27697f5c258eSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
27707f5c258eSLen Brown 		return 0;
27717f5c258eSLen Brown 
27727f5c258eSLen Brown 	if (cpu_migrate(cpu)) {
2773b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
27747f5c258eSLen Brown 		return -1;
27757f5c258eSLen Brown 	}
27767f5c258eSLen Brown 
27777f5c258eSLen Brown 	if (get_msr(cpu, MSR_PM_ENABLE, &msr))
27787f5c258eSLen Brown 		return 0;
27797f5c258eSLen Brown 
2780b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_PM_ENABLE: 0x%08llx (%sHWP)\n",
27817f5c258eSLen Brown 		cpu, msr, (msr & (1 << 0)) ? "" : "No-");
27827f5c258eSLen Brown 
27837f5c258eSLen Brown 	/* MSR_PM_ENABLE[1] == 1 if HWP is enabled and MSRs visible */
27847f5c258eSLen Brown 	if ((msr & (1 << 0)) == 0)
27857f5c258eSLen Brown 		return 0;
27867f5c258eSLen Brown 
27877f5c258eSLen Brown 	if (get_msr(cpu, MSR_HWP_CAPABILITIES, &msr))
27887f5c258eSLen Brown 		return 0;
27897f5c258eSLen Brown 
2790b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_HWP_CAPABILITIES: 0x%08llx "
27917f5c258eSLen Brown 			"(high 0x%x guar 0x%x eff 0x%x low 0x%x)\n",
27927f5c258eSLen Brown 			cpu, msr,
27937f5c258eSLen Brown 			(unsigned int)HWP_HIGHEST_PERF(msr),
27947f5c258eSLen Brown 			(unsigned int)HWP_GUARANTEED_PERF(msr),
27957f5c258eSLen Brown 			(unsigned int)HWP_MOSTEFFICIENT_PERF(msr),
27967f5c258eSLen Brown 			(unsigned int)HWP_LOWEST_PERF(msr));
27977f5c258eSLen Brown 
27987f5c258eSLen Brown 	if (get_msr(cpu, MSR_HWP_REQUEST, &msr))
27997f5c258eSLen Brown 		return 0;
28007f5c258eSLen Brown 
2801b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_HWP_REQUEST: 0x%08llx "
28027f5c258eSLen Brown 			"(min 0x%x max 0x%x des 0x%x epp 0x%x window 0x%x pkg 0x%x)\n",
28037f5c258eSLen Brown 			cpu, msr,
28047f5c258eSLen Brown 			(unsigned int)(((msr) >> 0) & 0xff),
28057f5c258eSLen Brown 			(unsigned int)(((msr) >> 8) & 0xff),
28067f5c258eSLen Brown 			(unsigned int)(((msr) >> 16) & 0xff),
28077f5c258eSLen Brown 			(unsigned int)(((msr) >> 24) & 0xff),
28087f5c258eSLen Brown 			(unsigned int)(((msr) >> 32) & 0xff3),
28097f5c258eSLen Brown 			(unsigned int)(((msr) >> 42) & 0x1));
28107f5c258eSLen Brown 
28117f5c258eSLen Brown 	if (has_hwp_pkg) {
28127f5c258eSLen Brown 		if (get_msr(cpu, MSR_HWP_REQUEST_PKG, &msr))
28137f5c258eSLen Brown 			return 0;
28147f5c258eSLen Brown 
2815b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_HWP_REQUEST_PKG: 0x%08llx "
28167f5c258eSLen Brown 			"(min 0x%x max 0x%x des 0x%x epp 0x%x window 0x%x)\n",
28177f5c258eSLen Brown 			cpu, msr,
28187f5c258eSLen Brown 			(unsigned int)(((msr) >> 0) & 0xff),
28197f5c258eSLen Brown 			(unsigned int)(((msr) >> 8) & 0xff),
28207f5c258eSLen Brown 			(unsigned int)(((msr) >> 16) & 0xff),
28217f5c258eSLen Brown 			(unsigned int)(((msr) >> 24) & 0xff),
28227f5c258eSLen Brown 			(unsigned int)(((msr) >> 32) & 0xff3));
28237f5c258eSLen Brown 	}
28247f5c258eSLen Brown 	if (has_hwp_notify) {
28257f5c258eSLen Brown 		if (get_msr(cpu, MSR_HWP_INTERRUPT, &msr))
28267f5c258eSLen Brown 			return 0;
28277f5c258eSLen Brown 
2828b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_HWP_INTERRUPT: 0x%08llx "
28297f5c258eSLen Brown 			"(%s_Guaranteed_Perf_Change, %s_Excursion_Min)\n",
28307f5c258eSLen Brown 			cpu, msr,
28317f5c258eSLen Brown 			((msr) & 0x1) ? "EN" : "Dis",
28327f5c258eSLen Brown 			((msr) & 0x2) ? "EN" : "Dis");
28337f5c258eSLen Brown 	}
28347f5c258eSLen Brown 	if (get_msr(cpu, MSR_HWP_STATUS, &msr))
28357f5c258eSLen Brown 		return 0;
28367f5c258eSLen Brown 
2837b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_HWP_STATUS: 0x%08llx "
28387f5c258eSLen Brown 			"(%sGuaranteed_Perf_Change, %sExcursion_Min)\n",
28397f5c258eSLen Brown 			cpu, msr,
28407f5c258eSLen Brown 			((msr) & 0x1) ? "" : "No-",
28417f5c258eSLen Brown 			((msr) & 0x2) ? "" : "No-");
2842889facbeSLen Brown 
2843889facbeSLen Brown 	return 0;
2844889facbeSLen Brown }
2845889facbeSLen Brown 
28463a9a941dSLen Brown /*
28473a9a941dSLen Brown  * print_perf_limit()
28483a9a941dSLen Brown  */
28493a9a941dSLen Brown int print_perf_limit(struct thread_data *t, struct core_data *c, struct pkg_data *p)
28503a9a941dSLen Brown {
28513a9a941dSLen Brown 	unsigned long long msr;
28523a9a941dSLen Brown 	int cpu;
28533a9a941dSLen Brown 
28543a9a941dSLen Brown 	cpu = t->cpu_id;
28553a9a941dSLen Brown 
28563a9a941dSLen Brown 	/* per-package */
28573a9a941dSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
28583a9a941dSLen Brown 		return 0;
28593a9a941dSLen Brown 
28603a9a941dSLen Brown 	if (cpu_migrate(cpu)) {
2861b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
28623a9a941dSLen Brown 		return -1;
28633a9a941dSLen Brown 	}
28643a9a941dSLen Brown 
28653a9a941dSLen Brown 	if (do_core_perf_limit_reasons) {
28663a9a941dSLen Brown 		get_msr(cpu, MSR_CORE_PERF_LIMIT_REASONS, &msr);
2867b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_CORE_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
2868b7d8c148SLen Brown 		fprintf(outf, " (Active: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)",
2869e33cbe85SLen Brown 			(msr & 1 << 15) ? "bit15, " : "",
28703a9a941dSLen Brown 			(msr & 1 << 14) ? "bit14, " : "",
2871e33cbe85SLen Brown 			(msr & 1 << 13) ? "Transitions, " : "",
2872e33cbe85SLen Brown 			(msr & 1 << 12) ? "MultiCoreTurbo, " : "",
2873e33cbe85SLen Brown 			(msr & 1 << 11) ? "PkgPwrL2, " : "",
2874e33cbe85SLen Brown 			(msr & 1 << 10) ? "PkgPwrL1, " : "",
2875e33cbe85SLen Brown 			(msr & 1 << 9) ? "CorePwr, " : "",
2876e33cbe85SLen Brown 			(msr & 1 << 8) ? "Amps, " : "",
2877e33cbe85SLen Brown 			(msr & 1 << 6) ? "VR-Therm, " : "",
2878e33cbe85SLen Brown 			(msr & 1 << 5) ? "Auto-HWP, " : "",
2879e33cbe85SLen Brown 			(msr & 1 << 4) ? "Graphics, " : "",
2880e33cbe85SLen Brown 			(msr & 1 << 2) ? "bit2, " : "",
2881e33cbe85SLen Brown 			(msr & 1 << 1) ? "ThermStatus, " : "",
2882e33cbe85SLen Brown 			(msr & 1 << 0) ? "PROCHOT, " : "");
2883b7d8c148SLen Brown 		fprintf(outf, " (Logged: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
2884e33cbe85SLen Brown 			(msr & 1 << 31) ? "bit31, " : "",
28853a9a941dSLen Brown 			(msr & 1 << 30) ? "bit30, " : "",
2886e33cbe85SLen Brown 			(msr & 1 << 29) ? "Transitions, " : "",
2887e33cbe85SLen Brown 			(msr & 1 << 28) ? "MultiCoreTurbo, " : "",
2888e33cbe85SLen Brown 			(msr & 1 << 27) ? "PkgPwrL2, " : "",
2889e33cbe85SLen Brown 			(msr & 1 << 26) ? "PkgPwrL1, " : "",
2890e33cbe85SLen Brown 			(msr & 1 << 25) ? "CorePwr, " : "",
2891e33cbe85SLen Brown 			(msr & 1 << 24) ? "Amps, " : "",
2892e33cbe85SLen Brown 			(msr & 1 << 22) ? "VR-Therm, " : "",
2893e33cbe85SLen Brown 			(msr & 1 << 21) ? "Auto-HWP, " : "",
2894e33cbe85SLen Brown 			(msr & 1 << 20) ? "Graphics, " : "",
2895e33cbe85SLen Brown 			(msr & 1 << 18) ? "bit18, " : "",
2896e33cbe85SLen Brown 			(msr & 1 << 17) ? "ThermStatus, " : "",
2897e33cbe85SLen Brown 			(msr & 1 << 16) ? "PROCHOT, " : "");
28983a9a941dSLen Brown 
28993a9a941dSLen Brown 	}
29003a9a941dSLen Brown 	if (do_gfx_perf_limit_reasons) {
29013a9a941dSLen Brown 		get_msr(cpu, MSR_GFX_PERF_LIMIT_REASONS, &msr);
2902b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_GFX_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
2903b7d8c148SLen Brown 		fprintf(outf, " (Active: %s%s%s%s%s%s%s%s)",
29043a9a941dSLen Brown 			(msr & 1 << 0) ? "PROCHOT, " : "",
29053a9a941dSLen Brown 			(msr & 1 << 1) ? "ThermStatus, " : "",
29063a9a941dSLen Brown 			(msr & 1 << 4) ? "Graphics, " : "",
29073a9a941dSLen Brown 			(msr & 1 << 6) ? "VR-Therm, " : "",
29083a9a941dSLen Brown 			(msr & 1 << 8) ? "Amps, " : "",
29093a9a941dSLen Brown 			(msr & 1 << 9) ? "GFXPwr, " : "",
29103a9a941dSLen Brown 			(msr & 1 << 10) ? "PkgPwrL1, " : "",
29113a9a941dSLen Brown 			(msr & 1 << 11) ? "PkgPwrL2, " : "");
2912b7d8c148SLen Brown 		fprintf(outf, " (Logged: %s%s%s%s%s%s%s%s)\n",
29133a9a941dSLen Brown 			(msr & 1 << 16) ? "PROCHOT, " : "",
29143a9a941dSLen Brown 			(msr & 1 << 17) ? "ThermStatus, " : "",
29153a9a941dSLen Brown 			(msr & 1 << 20) ? "Graphics, " : "",
29163a9a941dSLen Brown 			(msr & 1 << 22) ? "VR-Therm, " : "",
29173a9a941dSLen Brown 			(msr & 1 << 24) ? "Amps, " : "",
29183a9a941dSLen Brown 			(msr & 1 << 25) ? "GFXPwr, " : "",
29193a9a941dSLen Brown 			(msr & 1 << 26) ? "PkgPwrL1, " : "",
29203a9a941dSLen Brown 			(msr & 1 << 27) ? "PkgPwrL2, " : "");
29213a9a941dSLen Brown 	}
29223a9a941dSLen Brown 	if (do_ring_perf_limit_reasons) {
29233a9a941dSLen Brown 		get_msr(cpu, MSR_RING_PERF_LIMIT_REASONS, &msr);
2924b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_RING_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
2925b7d8c148SLen Brown 		fprintf(outf, " (Active: %s%s%s%s%s%s)",
29263a9a941dSLen Brown 			(msr & 1 << 0) ? "PROCHOT, " : "",
29273a9a941dSLen Brown 			(msr & 1 << 1) ? "ThermStatus, " : "",
29283a9a941dSLen Brown 			(msr & 1 << 6) ? "VR-Therm, " : "",
29293a9a941dSLen Brown 			(msr & 1 << 8) ? "Amps, " : "",
29303a9a941dSLen Brown 			(msr & 1 << 10) ? "PkgPwrL1, " : "",
29313a9a941dSLen Brown 			(msr & 1 << 11) ? "PkgPwrL2, " : "");
2932b7d8c148SLen Brown 		fprintf(outf, " (Logged: %s%s%s%s%s%s)\n",
29333a9a941dSLen Brown 			(msr & 1 << 16) ? "PROCHOT, " : "",
29343a9a941dSLen Brown 			(msr & 1 << 17) ? "ThermStatus, " : "",
29353a9a941dSLen Brown 			(msr & 1 << 22) ? "VR-Therm, " : "",
29363a9a941dSLen Brown 			(msr & 1 << 24) ? "Amps, " : "",
29373a9a941dSLen Brown 			(msr & 1 << 26) ? "PkgPwrL1, " : "",
29383a9a941dSLen Brown 			(msr & 1 << 27) ? "PkgPwrL2, " : "");
29393a9a941dSLen Brown 	}
29403a9a941dSLen Brown 	return 0;
29413a9a941dSLen Brown }
29423a9a941dSLen Brown 
2943889facbeSLen Brown #define	RAPL_POWER_GRANULARITY	0x7FFF	/* 15 bit power granularity */
2944889facbeSLen Brown #define	RAPL_TIME_GRANULARITY	0x3F /* 6 bit time granularity */
2945889facbeSLen Brown 
29461b69317dSColin Ian King double get_tdp(unsigned int model)
2947144b44b1SLen Brown {
2948144b44b1SLen Brown 	unsigned long long msr;
2949144b44b1SLen Brown 
2950144b44b1SLen Brown 	if (do_rapl & RAPL_PKG_POWER_INFO)
29517ce7d5deSPrarit Bhargava 		if (!get_msr(base_cpu, MSR_PKG_POWER_INFO, &msr))
2952144b44b1SLen Brown 			return ((msr >> 0) & RAPL_POWER_GRANULARITY) * rapl_power_units;
2953144b44b1SLen Brown 
2954144b44b1SLen Brown 	switch (model) {
2955869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:
2956869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT2:
2957144b44b1SLen Brown 		return 30.0;
2958144b44b1SLen Brown 	default:
2959144b44b1SLen Brown 		return 135.0;
2960144b44b1SLen Brown 	}
2961144b44b1SLen Brown }
2962144b44b1SLen Brown 
296340ee8e3bSAndrey Semin /*
296440ee8e3bSAndrey Semin  * rapl_dram_energy_units_probe()
296540ee8e3bSAndrey Semin  * Energy units are either hard-coded, or come from RAPL Energy Unit MSR.
296640ee8e3bSAndrey Semin  */
296740ee8e3bSAndrey Semin static double
296840ee8e3bSAndrey Semin rapl_dram_energy_units_probe(int  model, double rapl_energy_units)
296940ee8e3bSAndrey Semin {
297040ee8e3bSAndrey Semin 	/* only called for genuine_intel, family 6 */
297140ee8e3bSAndrey Semin 
297240ee8e3bSAndrey Semin 	switch (model) {
2973869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
2974869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
2975869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
2976869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* KNL */
2977005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
297840ee8e3bSAndrey Semin 		return (rapl_dram_energy_units = 15.3 / 1000000);
297940ee8e3bSAndrey Semin 	default:
298040ee8e3bSAndrey Semin 		return (rapl_energy_units);
298140ee8e3bSAndrey Semin 	}
298240ee8e3bSAndrey Semin }
298340ee8e3bSAndrey Semin 
2984144b44b1SLen Brown 
2985889facbeSLen Brown /*
2986889facbeSLen Brown  * rapl_probe()
2987889facbeSLen Brown  *
2988144b44b1SLen Brown  * sets do_rapl, rapl_power_units, rapl_energy_units, rapl_time_units
2989889facbeSLen Brown  */
2990889facbeSLen Brown void rapl_probe(unsigned int family, unsigned int model)
2991889facbeSLen Brown {
2992889facbeSLen Brown 	unsigned long long msr;
2993144b44b1SLen Brown 	unsigned int time_unit;
2994889facbeSLen Brown 	double tdp;
2995889facbeSLen Brown 
2996889facbeSLen Brown 	if (!genuine_intel)
2997889facbeSLen Brown 		return;
2998889facbeSLen Brown 
2999889facbeSLen Brown 	if (family != 6)
3000889facbeSLen Brown 		return;
3001889facbeSLen Brown 
3002889facbeSLen Brown 	switch (model) {
3003869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE:
3004869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE:
3005869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
3006869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
3007869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
3008869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
3009869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_GT3E:	/* BDW */
3010144b44b1SLen Brown 		do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_GFX | RAPL_PKG_POWER_INFO;
3011812db3f7SLen Brown 		if (rapl_joules) {
3012812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3013812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3014812db3f7SLen Brown 			BIC_PRESENT(BIC_GFX_J);
3015812db3f7SLen Brown 		} else {
3016812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3017812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3018812db3f7SLen Brown 			BIC_PRESENT(BIC_GFXWatt);
3019812db3f7SLen Brown 		}
3020889facbeSLen Brown 		break;
3021869ce69eSLen Brown 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
3022ac01ac13SLen Brown 	case INTEL_FAM6_ATOM_GEMINI_LAKE:
3023e4085d54SLen Brown 		do_rapl = RAPL_PKG | RAPL_PKG_POWER_INFO;
3024812db3f7SLen Brown 		if (rapl_joules)
3025812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3026812db3f7SLen Brown 		else
3027812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3028e4085d54SLen Brown 		break;
3029869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3030869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3031869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3032869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
30330b2bb692SLen Brown 		do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO;
3034812db3f7SLen Brown 		BIC_PRESENT(BIC_PKG__);
3035812db3f7SLen Brown 		BIC_PRESENT(BIC_RAM__);
3036812db3f7SLen Brown 		if (rapl_joules) {
3037812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3038812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3039812db3f7SLen Brown 			BIC_PRESENT(BIC_RAM_J);
3040812db3f7SLen Brown 		} else {
3041812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3042812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3043812db3f7SLen Brown 			BIC_PRESENT(BIC_RAMWatt);
3044812db3f7SLen Brown 		}
30450b2bb692SLen Brown 		break;
3046869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
3047869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
3048869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
3049869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_X:	/* SKX */
3050869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* KNL */
3051005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
30520b2bb692SLen Brown 		do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_POWER_INFO | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO;
3053812db3f7SLen Brown 		BIC_PRESENT(BIC_PKG__);
3054812db3f7SLen Brown 		BIC_PRESENT(BIC_RAM__);
3055812db3f7SLen Brown 		if (rapl_joules) {
3056812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3057812db3f7SLen Brown 			BIC_PRESENT(BIC_RAM_J);
3058812db3f7SLen Brown 		} else {
3059812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3060812db3f7SLen Brown 			BIC_PRESENT(BIC_RAMWatt);
3061812db3f7SLen Brown 		}
3062e6f9bb3cSLen Brown 		break;
3063869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE_X:
3064869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE_X:
30650b2bb692SLen Brown 		do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_DRAM | RAPL_DRAM_POWER_INFO | RAPL_PKG_PERF_STATUS | RAPL_DRAM_PERF_STATUS | RAPL_PKG_POWER_INFO;
3066812db3f7SLen Brown 		BIC_PRESENT(BIC_PKG__);
3067812db3f7SLen Brown 		BIC_PRESENT(BIC_RAM__);
3068812db3f7SLen Brown 		if (rapl_joules) {
3069812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3070812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3071812db3f7SLen Brown 			BIC_PRESENT(BIC_RAM_J);
3072812db3f7SLen Brown 		} else {
3073812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3074812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3075812db3f7SLen Brown 			BIC_PRESENT(BIC_RAMWatt);
3076812db3f7SLen Brown 		}
3077144b44b1SLen Brown 		break;
3078869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:	/* BYT */
3079869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT2:	/* AVN */
3080144b44b1SLen Brown 		do_rapl = RAPL_PKG | RAPL_CORES;
3081812db3f7SLen Brown 		if (rapl_joules) {
3082812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3083812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3084812db3f7SLen Brown 		} else {
3085812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3086812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3087812db3f7SLen Brown 		}
3088889facbeSLen Brown 		break;
3089869ce69eSLen Brown 	case INTEL_FAM6_ATOM_DENVERTON:	/* DNV */
30900f644909SJacob Pan 		do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_POWER_INFO | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO | RAPL_CORES_ENERGY_STATUS;
3091812db3f7SLen Brown 		BIC_PRESENT(BIC_PKG__);
3092812db3f7SLen Brown 		BIC_PRESENT(BIC_RAM__);
3093812db3f7SLen Brown 		if (rapl_joules) {
3094812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3095812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3096812db3f7SLen Brown 			BIC_PRESENT(BIC_RAM_J);
3097812db3f7SLen Brown 		} else {
3098812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3099812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3100812db3f7SLen Brown 			BIC_PRESENT(BIC_RAMWatt);
3101812db3f7SLen Brown 		}
31020f644909SJacob Pan 		break;
3103889facbeSLen Brown 	default:
3104889facbeSLen Brown 		return;
3105889facbeSLen Brown 	}
3106889facbeSLen Brown 
3107889facbeSLen Brown 	/* units on package 0, verify later other packages match */
31087ce7d5deSPrarit Bhargava 	if (get_msr(base_cpu, MSR_RAPL_POWER_UNIT, &msr))
3109889facbeSLen Brown 		return;
3110889facbeSLen Brown 
3111889facbeSLen Brown 	rapl_power_units = 1.0 / (1 << (msr & 0xF));
3112869ce69eSLen Brown 	if (model == INTEL_FAM6_ATOM_SILVERMONT1)
3113144b44b1SLen Brown 		rapl_energy_units = 1.0 * (1 << (msr >> 8 & 0x1F)) / 1000000;
3114144b44b1SLen Brown 	else
3115889facbeSLen Brown 		rapl_energy_units = 1.0 / (1 << (msr >> 8 & 0x1F));
3116889facbeSLen Brown 
311740ee8e3bSAndrey Semin 	rapl_dram_energy_units = rapl_dram_energy_units_probe(model, rapl_energy_units);
311840ee8e3bSAndrey Semin 
3119144b44b1SLen Brown 	time_unit = msr >> 16 & 0xF;
3120144b44b1SLen Brown 	if (time_unit == 0)
3121144b44b1SLen Brown 		time_unit = 0xA;
3122889facbeSLen Brown 
3123144b44b1SLen Brown 	rapl_time_units = 1.0 / (1 << (time_unit));
3124144b44b1SLen Brown 
3125144b44b1SLen Brown 	tdp = get_tdp(model);
3126889facbeSLen Brown 
3127889facbeSLen Brown 	rapl_joule_counter_range = 0xFFFFFFFF * rapl_energy_units / tdp;
312896e47158SLen Brown 	if (!quiet)
3129b7d8c148SLen Brown 		fprintf(outf, "RAPL: %.0f sec. Joule Counter Range, at %.0f Watts\n", rapl_joule_counter_range, tdp);
3130889facbeSLen Brown 
3131889facbeSLen Brown 	return;
3132889facbeSLen Brown }
3133889facbeSLen Brown 
31341b69317dSColin Ian King void perf_limit_reasons_probe(unsigned int family, unsigned int model)
31353a9a941dSLen Brown {
31363a9a941dSLen Brown 	if (!genuine_intel)
31373a9a941dSLen Brown 		return;
31383a9a941dSLen Brown 
31393a9a941dSLen Brown 	if (family != 6)
31403a9a941dSLen Brown 		return;
31413a9a941dSLen Brown 
31423a9a941dSLen Brown 	switch (model) {
3143869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
3144869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
3145869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
31463a9a941dSLen Brown 		do_gfx_perf_limit_reasons = 1;
3147869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
31483a9a941dSLen Brown 		do_core_perf_limit_reasons = 1;
31493a9a941dSLen Brown 		do_ring_perf_limit_reasons = 1;
31503a9a941dSLen Brown 	default:
31513a9a941dSLen Brown 		return;
31523a9a941dSLen Brown 	}
31533a9a941dSLen Brown }
31543a9a941dSLen Brown 
3155889facbeSLen Brown int print_thermal(struct thread_data *t, struct core_data *c, struct pkg_data *p)
3156889facbeSLen Brown {
3157889facbeSLen Brown 	unsigned long long msr;
3158889facbeSLen Brown 	unsigned int dts;
3159889facbeSLen Brown 	int cpu;
3160889facbeSLen Brown 
3161889facbeSLen Brown 	if (!(do_dts || do_ptm))
3162889facbeSLen Brown 		return 0;
3163889facbeSLen Brown 
3164889facbeSLen Brown 	cpu = t->cpu_id;
3165889facbeSLen Brown 
3166889facbeSLen Brown 	/* DTS is per-core, no need to print for each thread */
3167889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
3168889facbeSLen Brown 		return 0;
3169889facbeSLen Brown 
3170889facbeSLen Brown 	if (cpu_migrate(cpu)) {
3171b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
3172889facbeSLen Brown 		return -1;
3173889facbeSLen Brown 	}
3174889facbeSLen Brown 
3175889facbeSLen Brown 	if (do_ptm && (t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)) {
3176889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_STATUS, &msr))
3177889facbeSLen Brown 			return 0;
3178889facbeSLen Brown 
3179889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
3180b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_PACKAGE_THERM_STATUS: 0x%08llx (%d C)\n",
3181889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts);
3182889facbeSLen Brown 
3183889facbeSLen Brown #ifdef	THERM_DEBUG
3184889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT, &msr))
3185889facbeSLen Brown 			return 0;
3186889facbeSLen Brown 
3187889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
3188889facbeSLen Brown 		dts2 = (msr >> 8) & 0x7F;
3189b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_PACKAGE_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
3190889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
3191889facbeSLen Brown #endif
3192889facbeSLen Brown 	}
3193889facbeSLen Brown 
3194889facbeSLen Brown 
3195889facbeSLen Brown 	if (do_dts) {
3196889facbeSLen Brown 		unsigned int resolution;
3197889facbeSLen Brown 
3198889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_THERM_STATUS, &msr))
3199889facbeSLen Brown 			return 0;
3200889facbeSLen Brown 
3201889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
3202889facbeSLen Brown 		resolution = (msr >> 27) & 0xF;
3203b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_THERM_STATUS: 0x%08llx (%d C +/- %d)\n",
3204889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts, resolution);
3205889facbeSLen Brown 
3206889facbeSLen Brown #ifdef THERM_DEBUG
3207889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_THERM_INTERRUPT, &msr))
3208889facbeSLen Brown 			return 0;
3209889facbeSLen Brown 
3210889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
3211889facbeSLen Brown 		dts2 = (msr >> 8) & 0x7F;
3212b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
3213889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
3214889facbeSLen Brown #endif
3215889facbeSLen Brown 	}
3216889facbeSLen Brown 
3217889facbeSLen Brown 	return 0;
3218889facbeSLen Brown }
3219889facbeSLen Brown 
3220889facbeSLen Brown void print_power_limit_msr(int cpu, unsigned long long msr, char *label)
3221889facbeSLen Brown {
3222b7d8c148SLen Brown 	fprintf(outf, "cpu%d: %s: %sabled (%f Watts, %f sec, clamp %sabled)\n",
3223889facbeSLen Brown 		cpu, label,
3224889facbeSLen Brown 		((msr >> 15) & 1) ? "EN" : "DIS",
3225889facbeSLen Brown 		((msr >> 0) & 0x7FFF) * rapl_power_units,
3226889facbeSLen Brown 		(1.0 + (((msr >> 22) & 0x3)/4.0)) * (1 << ((msr >> 17) & 0x1F)) * rapl_time_units,
3227889facbeSLen Brown 		(((msr >> 16) & 1) ? "EN" : "DIS"));
3228889facbeSLen Brown 
3229889facbeSLen Brown 	return;
3230889facbeSLen Brown }
3231889facbeSLen Brown 
3232889facbeSLen Brown int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
3233889facbeSLen Brown {
3234889facbeSLen Brown 	unsigned long long msr;
3235889facbeSLen Brown 	int cpu;
3236889facbeSLen Brown 
3237889facbeSLen Brown 	if (!do_rapl)
3238889facbeSLen Brown 		return 0;
3239889facbeSLen Brown 
3240889facbeSLen Brown 	/* RAPL counters are per package, so print only for 1st thread/package */
3241889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
3242889facbeSLen Brown 		return 0;
3243889facbeSLen Brown 
3244889facbeSLen Brown 	cpu = t->cpu_id;
3245889facbeSLen Brown 	if (cpu_migrate(cpu)) {
3246b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
3247889facbeSLen Brown 		return -1;
3248889facbeSLen Brown 	}
3249889facbeSLen Brown 
3250889facbeSLen Brown 	if (get_msr(cpu, MSR_RAPL_POWER_UNIT, &msr))
3251889facbeSLen Brown 		return -1;
3252889facbeSLen Brown 
325396e47158SLen Brown 	fprintf(outf, "cpu%d: MSR_RAPL_POWER_UNIT: 0x%08llx (%f Watts, %f Joules, %f sec.)\n", cpu, msr,
3254144b44b1SLen Brown 		rapl_power_units, rapl_energy_units, rapl_time_units);
325596e47158SLen Brown 
3256144b44b1SLen Brown 	if (do_rapl & RAPL_PKG_POWER_INFO) {
3257144b44b1SLen Brown 
3258889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_POWER_INFO, &msr))
3259889facbeSLen Brown                 	return -5;
3260889facbeSLen Brown 
3261889facbeSLen Brown 
3262b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PKG_POWER_INFO: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
3263889facbeSLen Brown 			cpu, msr,
3264889facbeSLen Brown 			((msr >>  0) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3265889facbeSLen Brown 			((msr >> 16) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3266889facbeSLen Brown 			((msr >> 32) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3267889facbeSLen Brown 			((msr >> 48) & RAPL_TIME_GRANULARITY) * rapl_time_units);
3268889facbeSLen Brown 
3269144b44b1SLen Brown 	}
3270144b44b1SLen Brown 	if (do_rapl & RAPL_PKG) {
3271144b44b1SLen Brown 
3272889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_POWER_LIMIT, &msr))
3273889facbeSLen Brown 			return -9;
3274889facbeSLen Brown 
3275b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PKG_POWER_LIMIT: 0x%08llx (%slocked)\n",
3276889facbeSLen Brown 			cpu, msr, (msr >> 63) & 1 ? "" : "UN");
3277889facbeSLen Brown 
3278889facbeSLen Brown 		print_power_limit_msr(cpu, msr, "PKG Limit #1");
3279b7d8c148SLen Brown 		fprintf(outf, "cpu%d: PKG Limit #2: %sabled (%f Watts, %f* sec, clamp %sabled)\n",
3280889facbeSLen Brown 			cpu,
3281889facbeSLen Brown 			((msr >> 47) & 1) ? "EN" : "DIS",
3282889facbeSLen Brown 			((msr >> 32) & 0x7FFF) * rapl_power_units,
3283889facbeSLen Brown 			(1.0 + (((msr >> 54) & 0x3)/4.0)) * (1 << ((msr >> 49) & 0x1F)) * rapl_time_units,
3284889facbeSLen Brown 			((msr >> 48) & 1) ? "EN" : "DIS");
3285889facbeSLen Brown 	}
3286889facbeSLen Brown 
32870b2bb692SLen Brown 	if (do_rapl & RAPL_DRAM_POWER_INFO) {
3288889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_POWER_INFO, &msr))
3289889facbeSLen Brown                 	return -6;
3290889facbeSLen Brown 
3291b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_DRAM_POWER_INFO,: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
3292889facbeSLen Brown 			cpu, msr,
3293889facbeSLen Brown 			((msr >>  0) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3294889facbeSLen Brown 			((msr >> 16) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3295889facbeSLen Brown 			((msr >> 32) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3296889facbeSLen Brown 			((msr >> 48) & RAPL_TIME_GRANULARITY) * rapl_time_units);
32970b2bb692SLen Brown 	}
32980b2bb692SLen Brown 	if (do_rapl & RAPL_DRAM) {
3299889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_POWER_LIMIT, &msr))
3300889facbeSLen Brown 			return -9;
3301b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_DRAM_POWER_LIMIT: 0x%08llx (%slocked)\n",
3302889facbeSLen Brown 				cpu, msr, (msr >> 31) & 1 ? "" : "UN");
3303889facbeSLen Brown 
3304889facbeSLen Brown 		print_power_limit_msr(cpu, msr, "DRAM Limit");
3305889facbeSLen Brown 	}
3306144b44b1SLen Brown 	if (do_rapl & RAPL_CORE_POLICY) {
3307889facbeSLen Brown 		if (get_msr(cpu, MSR_PP0_POLICY, &msr))
3308889facbeSLen Brown 			return -7;
3309889facbeSLen Brown 
3310b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PP0_POLICY: %lld\n", cpu, msr & 0xF);
3311144b44b1SLen Brown 	}
33129148494cSJacob Pan 	if (do_rapl & RAPL_CORES_POWER_LIMIT) {
3313889facbeSLen Brown 		if (get_msr(cpu, MSR_PP0_POWER_LIMIT, &msr))
3314889facbeSLen Brown 			return -9;
3315b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PP0_POWER_LIMIT: 0x%08llx (%slocked)\n",
3316889facbeSLen Brown 				cpu, msr, (msr >> 31) & 1 ? "" : "UN");
3317889facbeSLen Brown 		print_power_limit_msr(cpu, msr, "Cores Limit");
3318889facbeSLen Brown 	}
3319889facbeSLen Brown 	if (do_rapl & RAPL_GFX) {
3320889facbeSLen Brown 		if (get_msr(cpu, MSR_PP1_POLICY, &msr))
3321889facbeSLen Brown 			return -8;
3322889facbeSLen Brown 
3323b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PP1_POLICY: %lld\n", cpu, msr & 0xF);
3324889facbeSLen Brown 
3325889facbeSLen Brown 		if (get_msr(cpu, MSR_PP1_POWER_LIMIT, &msr))
3326889facbeSLen Brown 			return -9;
3327b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PP1_POWER_LIMIT: 0x%08llx (%slocked)\n",
3328889facbeSLen Brown 				cpu, msr, (msr >> 31) & 1 ? "" : "UN");
3329889facbeSLen Brown 		print_power_limit_msr(cpu, msr, "GFX Limit");
3330889facbeSLen Brown 	}
3331889facbeSLen Brown 	return 0;
3332889facbeSLen Brown }
3333889facbeSLen Brown 
3334d7899447SLen Brown /*
3335d7899447SLen Brown  * SNB adds support for additional MSRs:
3336d7899447SLen Brown  *
3337d7899447SLen Brown  * MSR_PKG_C7_RESIDENCY            0x000003fa
3338d7899447SLen Brown  * MSR_CORE_C7_RESIDENCY           0x000003fe
3339d7899447SLen Brown  * MSR_PKG_C2_RESIDENCY            0x0000060d
3340d7899447SLen Brown  */
3341103a8feaSLen Brown 
3342d7899447SLen Brown int has_snb_msrs(unsigned int family, unsigned int model)
3343103a8feaSLen Brown {
3344103a8feaSLen Brown 	if (!genuine_intel)
3345103a8feaSLen Brown 		return 0;
3346103a8feaSLen Brown 
3347103a8feaSLen Brown 	switch (model) {
3348869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE:
3349869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE_X:
3350869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE:	/* IVB */
3351869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE_X:	/* IVB Xeon */
3352869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
3353869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSW */
3354869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
3355869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
3356869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
3357869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_GT3E:	/* BDW */
3358869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
3359869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
3360869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3361869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3362869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3363869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
3364869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_X:	/* SKX */
3365869ce69eSLen Brown 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
3366ac01ac13SLen Brown 	case INTEL_FAM6_ATOM_GEMINI_LAKE:
33675bbac26eSXiaolong Wang 	case INTEL_FAM6_ATOM_DENVERTON:	/* DNV */
3368103a8feaSLen Brown 		return 1;
3369103a8feaSLen Brown 	}
3370103a8feaSLen Brown 	return 0;
3371103a8feaSLen Brown }
3372103a8feaSLen Brown 
3373d7899447SLen Brown /*
3374d7899447SLen Brown  * HSW adds support for additional MSRs:
3375d7899447SLen Brown  *
3376d7899447SLen Brown  * MSR_PKG_C8_RESIDENCY		0x00000630
3377d7899447SLen Brown  * MSR_PKG_C9_RESIDENCY		0x00000631
3378d7899447SLen Brown  * MSR_PKG_C10_RESIDENCY	0x00000632
33795a63426eSLen Brown  *
33805a63426eSLen Brown  * MSR_PKGC8_IRTL		0x00000633
33815a63426eSLen Brown  * MSR_PKGC9_IRTL		0x00000634
33825a63426eSLen Brown  * MSR_PKGC10_IRTL		0x00000635
33835a63426eSLen Brown  *
3384d7899447SLen Brown  */
3385d7899447SLen Brown int has_hsw_msrs(unsigned int family, unsigned int model)
3386ca58710fSKristen Carlson Accardi {
3387ca58710fSKristen Carlson Accardi 	if (!genuine_intel)
3388ca58710fSKristen Carlson Accardi 		return 0;
3389ca58710fSKristen Carlson Accardi 
3390ca58710fSKristen Carlson Accardi 	switch (model) {
3391869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
3392869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
3393869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3394869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3395869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3396869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
3397869ce69eSLen Brown 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
3398ac01ac13SLen Brown 	case INTEL_FAM6_ATOM_GEMINI_LAKE:
3399ca58710fSKristen Carlson Accardi 		return 1;
3400ca58710fSKristen Carlson Accardi 	}
3401ca58710fSKristen Carlson Accardi 	return 0;
3402ca58710fSKristen Carlson Accardi }
3403ca58710fSKristen Carlson Accardi 
34040b2bb692SLen Brown /*
34050b2bb692SLen Brown  * SKL adds support for additional MSRS:
34060b2bb692SLen Brown  *
34070b2bb692SLen Brown  * MSR_PKG_WEIGHTED_CORE_C0_RES    0x00000658
34080b2bb692SLen Brown  * MSR_PKG_ANY_CORE_C0_RES         0x00000659
34090b2bb692SLen Brown  * MSR_PKG_ANY_GFXE_C0_RES         0x0000065A
34100b2bb692SLen Brown  * MSR_PKG_BOTH_CORE_GFXE_C0_RES   0x0000065B
34110b2bb692SLen Brown  */
34120b2bb692SLen Brown int has_skl_msrs(unsigned int family, unsigned int model)
34130b2bb692SLen Brown {
34140b2bb692SLen Brown 	if (!genuine_intel)
34150b2bb692SLen Brown 		return 0;
34160b2bb692SLen Brown 
34170b2bb692SLen Brown 	switch (model) {
3418869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3419869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3420869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3421869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
34220b2bb692SLen Brown 		return 1;
34230b2bb692SLen Brown 	}
34240b2bb692SLen Brown 	return 0;
34250b2bb692SLen Brown }
34260b2bb692SLen Brown 
3427144b44b1SLen Brown int is_slm(unsigned int family, unsigned int model)
3428144b44b1SLen Brown {
3429144b44b1SLen Brown 	if (!genuine_intel)
3430144b44b1SLen Brown 		return 0;
3431144b44b1SLen Brown 	switch (model) {
3432869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:	/* BYT */
3433869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT2:	/* AVN */
3434144b44b1SLen Brown 		return 1;
3435144b44b1SLen Brown 	}
3436144b44b1SLen Brown 	return 0;
3437144b44b1SLen Brown }
3438144b44b1SLen Brown 
3439fb5d4327SDasaratharaman Chandramouli int is_knl(unsigned int family, unsigned int model)
3440fb5d4327SDasaratharaman Chandramouli {
3441fb5d4327SDasaratharaman Chandramouli 	if (!genuine_intel)
3442fb5d4327SDasaratharaman Chandramouli 		return 0;
3443fb5d4327SDasaratharaman Chandramouli 	switch (model) {
3444869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* KNL */
3445005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
3446fb5d4327SDasaratharaman Chandramouli 		return 1;
3447fb5d4327SDasaratharaman Chandramouli 	}
3448fb5d4327SDasaratharaman Chandramouli 	return 0;
3449fb5d4327SDasaratharaman Chandramouli }
3450fb5d4327SDasaratharaman Chandramouli 
3451b2b34dfeSHubert Chrzaniuk unsigned int get_aperf_mperf_multiplier(unsigned int family, unsigned int model)
3452b2b34dfeSHubert Chrzaniuk {
3453b2b34dfeSHubert Chrzaniuk 	if (is_knl(family, model))
3454b2b34dfeSHubert Chrzaniuk 		return 1024;
3455b2b34dfeSHubert Chrzaniuk 	return 1;
3456b2b34dfeSHubert Chrzaniuk }
3457b2b34dfeSHubert Chrzaniuk 
3458144b44b1SLen Brown #define SLM_BCLK_FREQS 5
3459144b44b1SLen Brown double slm_freq_table[SLM_BCLK_FREQS] = { 83.3, 100.0, 133.3, 116.7, 80.0};
3460144b44b1SLen Brown 
3461144b44b1SLen Brown double slm_bclk(void)
3462144b44b1SLen Brown {
3463144b44b1SLen Brown 	unsigned long long msr = 3;
3464144b44b1SLen Brown 	unsigned int i;
3465144b44b1SLen Brown 	double freq;
3466144b44b1SLen Brown 
34677ce7d5deSPrarit Bhargava 	if (get_msr(base_cpu, MSR_FSB_FREQ, &msr))
3468b7d8c148SLen Brown 		fprintf(outf, "SLM BCLK: unknown\n");
3469144b44b1SLen Brown 
3470144b44b1SLen Brown 	i = msr & 0xf;
3471144b44b1SLen Brown 	if (i >= SLM_BCLK_FREQS) {
3472b7d8c148SLen Brown 		fprintf(outf, "SLM BCLK[%d] invalid\n", i);
34730a91e551SColin Ian King 		i = 3;
3474144b44b1SLen Brown 	}
3475144b44b1SLen Brown 	freq = slm_freq_table[i];
3476144b44b1SLen Brown 
347796e47158SLen Brown 	if (!quiet)
3478b7d8c148SLen Brown 		fprintf(outf, "SLM BCLK: %.1f Mhz\n", freq);
3479144b44b1SLen Brown 
3480144b44b1SLen Brown 	return freq;
3481144b44b1SLen Brown }
3482144b44b1SLen Brown 
3483103a8feaSLen Brown double discover_bclk(unsigned int family, unsigned int model)
3484103a8feaSLen Brown {
3485121b48bbSChrzaniuk, Hubert 	if (has_snb_msrs(family, model) || is_knl(family, model))
3486103a8feaSLen Brown 		return 100.00;
3487144b44b1SLen Brown 	else if (is_slm(family, model))
3488144b44b1SLen Brown 		return slm_bclk();
3489103a8feaSLen Brown 	else
3490103a8feaSLen Brown 		return 133.33;
3491103a8feaSLen Brown }
3492103a8feaSLen Brown 
3493889facbeSLen Brown /*
3494889facbeSLen Brown  * MSR_IA32_TEMPERATURE_TARGET indicates the temperature where
3495889facbeSLen Brown  * the Thermal Control Circuit (TCC) activates.
3496889facbeSLen Brown  * This is usually equal to tjMax.
3497889facbeSLen Brown  *
3498889facbeSLen Brown  * Older processors do not have this MSR, so there we guess,
3499889facbeSLen Brown  * but also allow cmdline over-ride with -T.
3500889facbeSLen Brown  *
3501889facbeSLen Brown  * Several MSR temperature values are in units of degrees-C
3502889facbeSLen Brown  * below this value, including the Digital Thermal Sensor (DTS),
3503889facbeSLen Brown  * Package Thermal Management Sensor (PTM), and thermal event thresholds.
3504889facbeSLen Brown  */
3505889facbeSLen Brown int set_temperature_target(struct thread_data *t, struct core_data *c, struct pkg_data *p)
3506889facbeSLen Brown {
3507889facbeSLen Brown 	unsigned long long msr;
3508889facbeSLen Brown 	unsigned int target_c_local;
3509889facbeSLen Brown 	int cpu;
3510889facbeSLen Brown 
3511889facbeSLen Brown 	/* tcc_activation_temp is used only for dts or ptm */
3512889facbeSLen Brown 	if (!(do_dts || do_ptm))
3513889facbeSLen Brown 		return 0;
3514889facbeSLen Brown 
3515889facbeSLen Brown 	/* this is a per-package concept */
3516889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
3517889facbeSLen Brown 		return 0;
3518889facbeSLen Brown 
3519889facbeSLen Brown 	cpu = t->cpu_id;
3520889facbeSLen Brown 	if (cpu_migrate(cpu)) {
3521b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
3522889facbeSLen Brown 		return -1;
3523889facbeSLen Brown 	}
3524889facbeSLen Brown 
3525889facbeSLen Brown 	if (tcc_activation_temp_override != 0) {
3526889facbeSLen Brown 		tcc_activation_temp = tcc_activation_temp_override;
3527b7d8c148SLen Brown 		fprintf(outf, "cpu%d: Using cmdline TCC Target (%d C)\n",
3528889facbeSLen Brown 			cpu, tcc_activation_temp);
3529889facbeSLen Brown 		return 0;
3530889facbeSLen Brown 	}
3531889facbeSLen Brown 
3532889facbeSLen Brown 	/* Temperature Target MSR is Nehalem and newer only */
3533d7899447SLen Brown 	if (!do_nhm_platform_info)
3534889facbeSLen Brown 		goto guess;
3535889facbeSLen Brown 
35367ce7d5deSPrarit Bhargava 	if (get_msr(base_cpu, MSR_IA32_TEMPERATURE_TARGET, &msr))
3537889facbeSLen Brown 		goto guess;
3538889facbeSLen Brown 
35393482124aSJean Delvare 	target_c_local = (msr >> 16) & 0xFF;
3540889facbeSLen Brown 
354196e47158SLen Brown 	if (!quiet)
3542b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_TEMPERATURE_TARGET: 0x%08llx (%d C)\n",
3543889facbeSLen Brown 			cpu, msr, target_c_local);
3544889facbeSLen Brown 
35453482124aSJean Delvare 	if (!target_c_local)
3546889facbeSLen Brown 		goto guess;
3547889facbeSLen Brown 
3548889facbeSLen Brown 	tcc_activation_temp = target_c_local;
3549889facbeSLen Brown 
3550889facbeSLen Brown 	return 0;
3551889facbeSLen Brown 
3552889facbeSLen Brown guess:
3553889facbeSLen Brown 	tcc_activation_temp = TJMAX_DEFAULT;
3554b7d8c148SLen Brown 	fprintf(outf, "cpu%d: Guessing tjMax %d C, Please use -T to specify\n",
3555889facbeSLen Brown 		cpu, tcc_activation_temp);
3556889facbeSLen Brown 
3557889facbeSLen Brown 	return 0;
3558889facbeSLen Brown }
355969807a63SLen Brown 
3560aa8d8cc7SLen Brown void decode_feature_control_msr(void)
3561aa8d8cc7SLen Brown {
3562aa8d8cc7SLen Brown 	unsigned long long msr;
3563aa8d8cc7SLen Brown 
3564aa8d8cc7SLen Brown 	if (!get_msr(base_cpu, MSR_IA32_FEATURE_CONTROL, &msr))
3565aa8d8cc7SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_FEATURE_CONTROL: 0x%08llx (%sLocked %s)\n",
3566aa8d8cc7SLen Brown 			base_cpu, msr,
3567aa8d8cc7SLen Brown 			msr & FEATURE_CONTROL_LOCKED ? "" : "UN-",
3568aa8d8cc7SLen Brown 			msr & (1 << 18) ? "SGX" : "");
3569aa8d8cc7SLen Brown }
3570aa8d8cc7SLen Brown 
357169807a63SLen Brown void decode_misc_enable_msr(void)
357269807a63SLen Brown {
357369807a63SLen Brown 	unsigned long long msr;
357469807a63SLen Brown 
357569807a63SLen Brown 	if (!get_msr(base_cpu, MSR_IA32_MISC_ENABLE, &msr))
3576e6512624SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_MISC_ENABLE: 0x%08llx (%sTCC %sEIST %sMWAIT %sPREFETCH %sTURBO)\n",
357769807a63SLen Brown 			base_cpu, msr,
3578e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_TM1 ? "" : "No-",
3579e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP ? "" : "No-",
3580e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_MWAIT ? "No-" : "",
3581e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_PREFETCH_DISABLE ? "No-" : "",
3582e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_TURBO_DISABLE ? "No-" : "");
358369807a63SLen Brown }
358469807a63SLen Brown 
358533148d67SLen Brown void decode_misc_feature_control(void)
358633148d67SLen Brown {
358733148d67SLen Brown 	unsigned long long msr;
358833148d67SLen Brown 
358933148d67SLen Brown 	if (!has_misc_feature_control)
359033148d67SLen Brown 		return;
359133148d67SLen Brown 
359233148d67SLen Brown 	if (!get_msr(base_cpu, MSR_MISC_FEATURE_CONTROL, &msr))
359333148d67SLen Brown 		fprintf(outf, "cpu%d: MSR_MISC_FEATURE_CONTROL: 0x%08llx (%sL2-Prefetch %sL2-Prefetch-pair %sL1-Prefetch %sL1-IP-Prefetch)\n",
359433148d67SLen Brown 			base_cpu, msr,
359533148d67SLen Brown 			msr & (0 << 0) ? "No-" : "",
359633148d67SLen Brown 			msr & (1 << 0) ? "No-" : "",
359733148d67SLen Brown 			msr & (2 << 0) ? "No-" : "",
359833148d67SLen Brown 			msr & (3 << 0) ? "No-" : "");
359933148d67SLen Brown }
3600f0057310SLen Brown /*
3601f0057310SLen Brown  * Decode MSR_MISC_PWR_MGMT
3602f0057310SLen Brown  *
3603f0057310SLen Brown  * Decode the bits according to the Nehalem documentation
3604f0057310SLen Brown  * bit[0] seems to continue to have same meaning going forward
3605f0057310SLen Brown  * bit[1] less so...
3606f0057310SLen Brown  */
3607f0057310SLen Brown void decode_misc_pwr_mgmt_msr(void)
3608f0057310SLen Brown {
3609f0057310SLen Brown 	unsigned long long msr;
3610f0057310SLen Brown 
3611f0057310SLen Brown 	if (!do_nhm_platform_info)
3612f0057310SLen Brown 		return;
3613f0057310SLen Brown 
3614cf4cbe53SLen Brown 	if (no_MSR_MISC_PWR_MGMT)
3615cf4cbe53SLen Brown 		return;
3616cf4cbe53SLen Brown 
3617f0057310SLen Brown 	if (!get_msr(base_cpu, MSR_MISC_PWR_MGMT, &msr))
3618ddadb8adSSrinivas Pandruvada 		fprintf(outf, "cpu%d: MSR_MISC_PWR_MGMT: 0x%08llx (%sable-EIST_Coordination %sable-EPB %sable-OOB)\n",
3619f0057310SLen Brown 			base_cpu, msr,
3620f0057310SLen Brown 			msr & (1 << 0) ? "DIS" : "EN",
3621ddadb8adSSrinivas Pandruvada 			msr & (1 << 1) ? "EN" : "DIS",
3622ddadb8adSSrinivas Pandruvada 			msr & (1 << 8) ? "EN" : "DIS");
3623f0057310SLen Brown }
362471616c8eSLen Brown /*
362571616c8eSLen Brown  * Decode MSR_CC6_DEMOTION_POLICY_CONFIG, MSR_MC6_DEMOTION_POLICY_CONFIG
362671616c8eSLen Brown  *
362771616c8eSLen Brown  * This MSRs are present on Silvermont processors,
362871616c8eSLen Brown  * Intel Atom processor E3000 series (Baytrail), and friends.
362971616c8eSLen Brown  */
363071616c8eSLen Brown void decode_c6_demotion_policy_msr(void)
363171616c8eSLen Brown {
363271616c8eSLen Brown 	unsigned long long msr;
363371616c8eSLen Brown 
363471616c8eSLen Brown 	if (!get_msr(base_cpu, MSR_CC6_DEMOTION_POLICY_CONFIG, &msr))
363571616c8eSLen Brown 		fprintf(outf, "cpu%d: MSR_CC6_DEMOTION_POLICY_CONFIG: 0x%08llx (%sable-CC6-Demotion)\n",
363671616c8eSLen Brown 			base_cpu, msr, msr & (1 << 0) ? "EN" : "DIS");
363771616c8eSLen Brown 
363871616c8eSLen Brown 	if (!get_msr(base_cpu, MSR_MC6_DEMOTION_POLICY_CONFIG, &msr))
363971616c8eSLen Brown 		fprintf(outf, "cpu%d: MSR_MC6_DEMOTION_POLICY_CONFIG: 0x%08llx (%sable-MC6-Demotion)\n",
364071616c8eSLen Brown 			base_cpu, msr, msr & (1 << 0) ? "EN" : "DIS");
364171616c8eSLen Brown }
36427f5c258eSLen Brown 
3643fcd17211SLen Brown void process_cpuid()
3644103a8feaSLen Brown {
364561a87ba7SLen Brown 	unsigned int eax, ebx, ecx, edx, max_level, max_extended_level;
3646103a8feaSLen Brown 	unsigned int fms, family, model, stepping;
3647b3a34e93SLen Brown 	unsigned int has_turbo;
3648103a8feaSLen Brown 
3649103a8feaSLen Brown 	eax = ebx = ecx = edx = 0;
3650103a8feaSLen Brown 
36515aea2f7fSLen Brown 	__cpuid(0, max_level, ebx, ecx, edx);
3652103a8feaSLen Brown 
3653103a8feaSLen Brown 	if (ebx == 0x756e6547 && edx == 0x49656e69 && ecx == 0x6c65746e)
3654103a8feaSLen Brown 		genuine_intel = 1;
3655103a8feaSLen Brown 
365696e47158SLen Brown 	if (!quiet)
3657b7d8c148SLen Brown 		fprintf(outf, "CPUID(0): %.4s%.4s%.4s ",
3658103a8feaSLen Brown 			(char *)&ebx, (char *)&edx, (char *)&ecx);
3659103a8feaSLen Brown 
36605aea2f7fSLen Brown 	__cpuid(1, fms, ebx, ecx, edx);
3661103a8feaSLen Brown 	family = (fms >> 8) & 0xf;
3662103a8feaSLen Brown 	model = (fms >> 4) & 0xf;
3663103a8feaSLen Brown 	stepping = fms & 0xf;
3664103a8feaSLen Brown 	if (family == 6 || family == 0xf)
3665103a8feaSLen Brown 		model += ((fms >> 16) & 0xf) << 4;
3666103a8feaSLen Brown 
366796e47158SLen Brown 	if (!quiet) {
3668b7d8c148SLen Brown 		fprintf(outf, "%d CPUID levels; family:model:stepping 0x%x:%x:%x (%d:%d:%d)\n",
3669103a8feaSLen Brown 			max_level, family, model, stepping, family, model, stepping);
3670aa8d8cc7SLen Brown 		fprintf(outf, "CPUID(1): %s %s %s %s %s %s %s %s %s\n",
367169807a63SLen Brown 			ecx & (1 << 0) ? "SSE3" : "-",
367269807a63SLen Brown 			ecx & (1 << 3) ? "MONITOR" : "-",
3673aa8d8cc7SLen Brown 			ecx & (1 << 6) ? "SMX" : "-",
367469807a63SLen Brown 			ecx & (1 << 7) ? "EIST" : "-",
367569807a63SLen Brown 			ecx & (1 << 8) ? "TM2" : "-",
367669807a63SLen Brown 			edx & (1 << 4) ? "TSC" : "-",
367769807a63SLen Brown 			edx & (1 << 5) ? "MSR" : "-",
367869807a63SLen Brown 			edx & (1 << 22) ? "ACPI-TM" : "-",
367969807a63SLen Brown 			edx & (1 << 29) ? "TM" : "-");
368069807a63SLen Brown 	}
3681103a8feaSLen Brown 
3682b2c95d90SJosh Triplett 	if (!(edx & (1 << 5)))
3683b2c95d90SJosh Triplett 		errx(1, "CPUID: no MSR");
3684103a8feaSLen Brown 
3685103a8feaSLen Brown 	/*
3686103a8feaSLen Brown 	 * check max extended function levels of CPUID.
3687103a8feaSLen Brown 	 * This is needed to check for invariant TSC.
3688103a8feaSLen Brown 	 * This check is valid for both Intel and AMD.
3689103a8feaSLen Brown 	 */
3690103a8feaSLen Brown 	ebx = ecx = edx = 0;
36915aea2f7fSLen Brown 	__cpuid(0x80000000, max_extended_level, ebx, ecx, edx);
3692103a8feaSLen Brown 
369361a87ba7SLen Brown 	if (max_extended_level >= 0x80000007) {
3694103a8feaSLen Brown 
3695103a8feaSLen Brown 		/*
3696103a8feaSLen Brown 		 * Non-Stop TSC is advertised by CPUID.EAX=0x80000007: EDX.bit8
3697103a8feaSLen Brown 		 * this check is valid for both Intel and AMD
3698103a8feaSLen Brown 		 */
36995aea2f7fSLen Brown 		__cpuid(0x80000007, eax, ebx, ecx, edx);
37008209e054SThomas Renninger 		has_invariant_tsc = edx & (1 << 8);
3701d7899447SLen Brown 	}
3702103a8feaSLen Brown 
3703103a8feaSLen Brown 	/*
3704103a8feaSLen Brown 	 * APERF/MPERF is advertised by CPUID.EAX=0x6: ECX.bit0
3705103a8feaSLen Brown 	 * this check is valid for both Intel and AMD
3706103a8feaSLen Brown 	 */
3707103a8feaSLen Brown 
37085aea2f7fSLen Brown 	__cpuid(0x6, eax, ebx, ecx, edx);
37098209e054SThomas Renninger 	has_aperf = ecx & (1 << 0);
3710812db3f7SLen Brown 	if (has_aperf) {
3711812db3f7SLen Brown 		BIC_PRESENT(BIC_Avg_MHz);
3712812db3f7SLen Brown 		BIC_PRESENT(BIC_Busy);
3713812db3f7SLen Brown 		BIC_PRESENT(BIC_Bzy_MHz);
3714812db3f7SLen Brown 	}
3715889facbeSLen Brown 	do_dts = eax & (1 << 0);
3716812db3f7SLen Brown 	if (do_dts)
3717812db3f7SLen Brown 		BIC_PRESENT(BIC_CoreTmp);
3718b3a34e93SLen Brown 	has_turbo = eax & (1 << 1);
3719889facbeSLen Brown 	do_ptm = eax & (1 << 6);
3720812db3f7SLen Brown 	if (do_ptm)
3721812db3f7SLen Brown 		BIC_PRESENT(BIC_PkgTmp);
37227f5c258eSLen Brown 	has_hwp = eax & (1 << 7);
37237f5c258eSLen Brown 	has_hwp_notify = eax & (1 << 8);
37247f5c258eSLen Brown 	has_hwp_activity_window = eax & (1 << 9);
37257f5c258eSLen Brown 	has_hwp_epp = eax & (1 << 10);
37267f5c258eSLen Brown 	has_hwp_pkg = eax & (1 << 11);
3727889facbeSLen Brown 	has_epb = ecx & (1 << 3);
3728889facbeSLen Brown 
372996e47158SLen Brown 	if (!quiet)
3730b3a34e93SLen Brown 		fprintf(outf, "CPUID(6): %sAPERF, %sTURBO, %sDTS, %sPTM, %sHWP, "
37317f5c258eSLen Brown 			"%sHWPnotify, %sHWPwindow, %sHWPepp, %sHWPpkg, %sEPB\n",
37327f5c258eSLen Brown 			has_aperf ? "" : "No-",
3733b3a34e93SLen Brown 			has_turbo ? "" : "No-",
37347f5c258eSLen Brown 			do_dts ? "" : "No-",
37357f5c258eSLen Brown 			do_ptm ? "" : "No-",
37367f5c258eSLen Brown 			has_hwp ? "" : "No-",
37377f5c258eSLen Brown 			has_hwp_notify ? "" : "No-",
37387f5c258eSLen Brown 			has_hwp_activity_window ? "" : "No-",
37397f5c258eSLen Brown 			has_hwp_epp ? "" : "No-",
37407f5c258eSLen Brown 			has_hwp_pkg ? "" : "No-",
37417f5c258eSLen Brown 			has_epb ? "" : "No-");
3742103a8feaSLen Brown 
374396e47158SLen Brown 	if (!quiet)
374469807a63SLen Brown 		decode_misc_enable_msr();
374569807a63SLen Brown 
374633148d67SLen Brown 
374796e47158SLen Brown 	if (max_level >= 0x7 && !quiet) {
3748aa8d8cc7SLen Brown 		int has_sgx;
3749aa8d8cc7SLen Brown 
3750aa8d8cc7SLen Brown 		ecx = 0;
3751aa8d8cc7SLen Brown 
3752aa8d8cc7SLen Brown 		__cpuid_count(0x7, 0, eax, ebx, ecx, edx);
3753aa8d8cc7SLen Brown 
3754aa8d8cc7SLen Brown 		has_sgx = ebx & (1 << 2);
3755aa8d8cc7SLen Brown 		fprintf(outf, "CPUID(7): %sSGX\n", has_sgx ? "" : "No-");
3756aa8d8cc7SLen Brown 
3757aa8d8cc7SLen Brown 		if (has_sgx)
3758aa8d8cc7SLen Brown 			decode_feature_control_msr();
3759aa8d8cc7SLen Brown 	}
3760aa8d8cc7SLen Brown 
376161a87ba7SLen Brown 	if (max_level >= 0x15) {
37628a5bdf41SLen Brown 		unsigned int eax_crystal;
37638a5bdf41SLen Brown 		unsigned int ebx_tsc;
37648a5bdf41SLen Brown 
37658a5bdf41SLen Brown 		/*
37668a5bdf41SLen Brown 		 * CPUID 15H TSC/Crystal ratio, possibly Crystal Hz
37678a5bdf41SLen Brown 		 */
37688a5bdf41SLen Brown 		eax_crystal = ebx_tsc = crystal_hz = edx = 0;
37695aea2f7fSLen Brown 		__cpuid(0x15, eax_crystal, ebx_tsc, crystal_hz, edx);
37708a5bdf41SLen Brown 
37718a5bdf41SLen Brown 		if (ebx_tsc != 0) {
37728a5bdf41SLen Brown 
377396e47158SLen Brown 			if (!quiet && (ebx != 0))
3774b7d8c148SLen Brown 				fprintf(outf, "CPUID(0x15): eax_crystal: %d ebx_tsc: %d ecx_crystal_hz: %d\n",
37758a5bdf41SLen Brown 					eax_crystal, ebx_tsc, crystal_hz);
37768a5bdf41SLen Brown 
37778a5bdf41SLen Brown 			if (crystal_hz == 0)
37788a5bdf41SLen Brown 				switch(model) {
3779869ce69eSLen Brown 				case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3780869ce69eSLen Brown 				case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3781869ce69eSLen Brown 				case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3782869ce69eSLen Brown 				case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
3783e8efbc80SLen Brown 					crystal_hz = 24000000;	/* 24.0 MHz */
3784e8efbc80SLen Brown 					break;
3785869ce69eSLen Brown 				case INTEL_FAM6_SKYLAKE_X:	/* SKX */
37867268d407SLen Brown 				case INTEL_FAM6_ATOM_DENVERTON:	/* DNV */
3787ec53e594SLen Brown 					crystal_hz = 25000000;	/* 25.0 MHz */
3788ec53e594SLen Brown 					break;
3789869ce69eSLen Brown 				case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
3790ac01ac13SLen Brown 				case INTEL_FAM6_ATOM_GEMINI_LAKE:
3791e8efbc80SLen Brown 					crystal_hz = 19200000;	/* 19.2 MHz */
37928a5bdf41SLen Brown 					break;
37938a5bdf41SLen Brown 				default:
37948a5bdf41SLen Brown 					crystal_hz = 0;
37958a5bdf41SLen Brown 			}
37968a5bdf41SLen Brown 
37978a5bdf41SLen Brown 			if (crystal_hz) {
37988a5bdf41SLen Brown 				tsc_hz =  (unsigned long long) crystal_hz * ebx_tsc / eax_crystal;
379996e47158SLen Brown 				if (!quiet)
3800b7d8c148SLen Brown 					fprintf(outf, "TSC: %lld MHz (%d Hz * %d / %d / 1000000)\n",
38018a5bdf41SLen Brown 						tsc_hz / 1000000, crystal_hz, ebx_tsc,  eax_crystal);
38028a5bdf41SLen Brown 			}
38038a5bdf41SLen Brown 		}
38048a5bdf41SLen Brown 	}
380561a87ba7SLen Brown 	if (max_level >= 0x16) {
380661a87ba7SLen Brown 		unsigned int base_mhz, max_mhz, bus_mhz, edx;
380761a87ba7SLen Brown 
380861a87ba7SLen Brown 		/*
380961a87ba7SLen Brown 		 * CPUID 16H Base MHz, Max MHz, Bus MHz
381061a87ba7SLen Brown 		 */
381161a87ba7SLen Brown 		base_mhz = max_mhz = bus_mhz = edx = 0;
381261a87ba7SLen Brown 
38135aea2f7fSLen Brown 		__cpuid(0x16, base_mhz, max_mhz, bus_mhz, edx);
381496e47158SLen Brown 		if (!quiet)
3815b7d8c148SLen Brown 			fprintf(outf, "CPUID(0x16): base_mhz: %d max_mhz: %d bus_mhz: %d\n",
381661a87ba7SLen Brown 				base_mhz, max_mhz, bus_mhz);
381761a87ba7SLen Brown 	}
38188a5bdf41SLen Brown 
3819b2b34dfeSHubert Chrzaniuk 	if (has_aperf)
3820b2b34dfeSHubert Chrzaniuk 		aperf_mperf_multiplier = get_aperf_mperf_multiplier(family, model);
3821b2b34dfeSHubert Chrzaniuk 
3822812db3f7SLen Brown 	BIC_PRESENT(BIC_IRQ);
3823812db3f7SLen Brown 	BIC_PRESENT(BIC_TSC_MHz);
3824812db3f7SLen Brown 
3825812db3f7SLen Brown 	if (probe_nhm_msrs(family, model)) {
3826812db3f7SLen Brown 		do_nhm_platform_info = 1;
3827812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU_c1);
3828812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU_c3);
3829812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU_c6);
3830812db3f7SLen Brown 		BIC_PRESENT(BIC_SMI);
3831812db3f7SLen Brown 	}
3832d7899447SLen Brown 	do_snb_cstates = has_snb_msrs(family, model);
3833812db3f7SLen Brown 
3834812db3f7SLen Brown 	if (do_snb_cstates)
3835812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU_c7);
3836812db3f7SLen Brown 
38375a63426eSLen Brown 	do_irtl_snb = has_snb_msrs(family, model);
38380f47c08dSLen Brown 	if (do_snb_cstates && (pkg_cstate_limit >= PCL__2))
38390f47c08dSLen Brown 		BIC_PRESENT(BIC_Pkgpc2);
38400f47c08dSLen Brown 	if (pkg_cstate_limit >= PCL__3)
38410f47c08dSLen Brown 		BIC_PRESENT(BIC_Pkgpc3);
38420f47c08dSLen Brown 	if (pkg_cstate_limit >= PCL__6)
38430f47c08dSLen Brown 		BIC_PRESENT(BIC_Pkgpc6);
38440f47c08dSLen Brown 	if (do_snb_cstates && (pkg_cstate_limit >= PCL__7))
38450f47c08dSLen Brown 		BIC_PRESENT(BIC_Pkgpc7);
38460539ba11SLen Brown 	if (has_slv_msrs(family, model)) {
38470f47c08dSLen Brown 		BIC_NOT_PRESENT(BIC_Pkgpc2);
38480f47c08dSLen Brown 		BIC_NOT_PRESENT(BIC_Pkgpc3);
38490f47c08dSLen Brown 		BIC_PRESENT(BIC_Pkgpc6);
38500f47c08dSLen Brown 		BIC_NOT_PRESENT(BIC_Pkgpc7);
38510539ba11SLen Brown 		BIC_PRESENT(BIC_Mod_c6);
38520539ba11SLen Brown 		use_c1_residency_msr = 1;
38530539ba11SLen Brown 	}
38540f47c08dSLen Brown 	if (has_hsw_msrs(family, model)) {
38550f47c08dSLen Brown 		BIC_PRESENT(BIC_Pkgpc8);
38560f47c08dSLen Brown 		BIC_PRESENT(BIC_Pkgpc9);
38570f47c08dSLen Brown 		BIC_PRESENT(BIC_Pkgpc10);
38580f47c08dSLen Brown 	}
38595a63426eSLen Brown 	do_irtl_hsw = has_hsw_msrs(family, model);
38600b2bb692SLen Brown 	do_skl_residency = has_skl_msrs(family, model);
3861144b44b1SLen Brown 	do_slm_cstates = is_slm(family, model);
3862fb5d4327SDasaratharaman Chandramouli 	do_knl_cstates  = is_knl(family, model);
3863103a8feaSLen Brown 
386496e47158SLen Brown 	if (!quiet)
3865f0057310SLen Brown 		decode_misc_pwr_mgmt_msr();
3866f0057310SLen Brown 
386796e47158SLen Brown 	if (!quiet && has_slv_msrs(family, model))
386871616c8eSLen Brown 		decode_c6_demotion_policy_msr();
386971616c8eSLen Brown 
3870889facbeSLen Brown 	rapl_probe(family, model);
38713a9a941dSLen Brown 	perf_limit_reasons_probe(family, model);
3872889facbeSLen Brown 
387396e47158SLen Brown 	if (!quiet)
38741b69317dSColin Ian King 		dump_cstate_pstate_config_info(family, model);
3875fcd17211SLen Brown 
3876a2b7b749SLen Brown 	if (has_skl_msrs(family, model))
3877a2b7b749SLen Brown 		calculate_tsc_tweak();
3878a2b7b749SLen Brown 
3879812db3f7SLen Brown 	if (!access("/sys/class/drm/card0/power/rc6_residency_ms", R_OK))
3880812db3f7SLen Brown 		BIC_PRESENT(BIC_GFX_rc6);
3881fdf676e5SLen Brown 
3882812db3f7SLen Brown 	if (!access("/sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz", R_OK))
3883812db3f7SLen Brown 		BIC_PRESENT(BIC_GFXMHz);
388427d47356SLen Brown 
388596e47158SLen Brown 	if (!quiet)
388633148d67SLen Brown 		decode_misc_feature_control();
388733148d67SLen Brown 
3888889facbeSLen Brown 	return;
3889103a8feaSLen Brown }
3890103a8feaSLen Brown 
3891d8af6f5fSLen Brown void help()
3892103a8feaSLen Brown {
3893b7d8c148SLen Brown 	fprintf(outf,
3894d8af6f5fSLen Brown 	"Usage: turbostat [OPTIONS][(--interval seconds) | COMMAND ...]\n"
3895d8af6f5fSLen Brown 	"\n"
3896d8af6f5fSLen Brown 	"Turbostat forks the specified COMMAND and prints statistics\n"
3897d8af6f5fSLen Brown 	"when COMMAND completes.\n"
3898d8af6f5fSLen Brown 	"If no COMMAND is specified, turbostat wakes every 5-seconds\n"
3899d8af6f5fSLen Brown 	"to print statistics, until interrupted.\n"
3900388e9c81SLen Brown 	"--add		add a counter\n"
3901388e9c81SLen Brown 	"		eg. --add msr0x10,u64,cpu,delta,MY_TSC\n"
390296e47158SLen Brown 	"--quiet	skip decoding system configuration header\n"
3903d8af6f5fSLen Brown 	"--interval sec	Override default 5-second measurement interval\n"
3904d8af6f5fSLen Brown 	"--help		print this help message\n"
3905b7d8c148SLen Brown 	"--out file	create or truncate \"file\" for all output\n"
3906d8af6f5fSLen Brown 	"--version	print version information\n"
3907d8af6f5fSLen Brown 	"\n"
3908d8af6f5fSLen Brown 	"For more help, run \"man turbostat\"\n");
3909103a8feaSLen Brown }
3910103a8feaSLen Brown 
3911103a8feaSLen Brown 
3912103a8feaSLen Brown /*
3913103a8feaSLen Brown  * in /dev/cpu/ return success for names that are numbers
3914103a8feaSLen Brown  * ie. filter out ".", "..", "microcode".
3915103a8feaSLen Brown  */
3916103a8feaSLen Brown int dir_filter(const struct dirent *dirp)
3917103a8feaSLen Brown {
3918103a8feaSLen Brown 	if (isdigit(dirp->d_name[0]))
3919103a8feaSLen Brown 		return 1;
3920103a8feaSLen Brown 	else
3921103a8feaSLen Brown 		return 0;
3922103a8feaSLen Brown }
3923103a8feaSLen Brown 
3924103a8feaSLen Brown int open_dev_cpu_msr(int dummy1)
3925103a8feaSLen Brown {
3926103a8feaSLen Brown 	return 0;
3927103a8feaSLen Brown }
3928103a8feaSLen Brown 
3929c98d5d94SLen Brown void topology_probe()
3930c98d5d94SLen Brown {
3931c98d5d94SLen Brown 	int i;
3932c98d5d94SLen Brown 	int max_core_id = 0;
3933c98d5d94SLen Brown 	int max_package_id = 0;
3934c98d5d94SLen Brown 	int max_siblings = 0;
3935c98d5d94SLen Brown 	struct cpu_topology {
3936c98d5d94SLen Brown 		int core_id;
3937c98d5d94SLen Brown 		int physical_package_id;
3938c98d5d94SLen Brown 	} *cpus;
3939c98d5d94SLen Brown 
3940c98d5d94SLen Brown 	/* Initialize num_cpus, max_cpu_num */
3941c98d5d94SLen Brown 	topo.num_cpus = 0;
3942c98d5d94SLen Brown 	topo.max_cpu_num = 0;
3943c98d5d94SLen Brown 	for_all_proc_cpus(count_cpus);
3944c98d5d94SLen Brown 	if (!summary_only && topo.num_cpus > 1)
3945812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU);
3946c98d5d94SLen Brown 
3947d8af6f5fSLen Brown 	if (debug > 1)
3948b7d8c148SLen Brown 		fprintf(outf, "num_cpus %d max_cpu_num %d\n", topo.num_cpus, topo.max_cpu_num);
3949c98d5d94SLen Brown 
3950c98d5d94SLen Brown 	cpus = calloc(1, (topo.max_cpu_num  + 1) * sizeof(struct cpu_topology));
3951b2c95d90SJosh Triplett 	if (cpus == NULL)
3952b2c95d90SJosh Triplett 		err(1, "calloc cpus");
3953c98d5d94SLen Brown 
3954c98d5d94SLen Brown 	/*
3955c98d5d94SLen Brown 	 * Allocate and initialize cpu_present_set
3956c98d5d94SLen Brown 	 */
3957c98d5d94SLen Brown 	cpu_present_set = CPU_ALLOC((topo.max_cpu_num + 1));
3958b2c95d90SJosh Triplett 	if (cpu_present_set == NULL)
3959b2c95d90SJosh Triplett 		err(3, "CPU_ALLOC");
3960c98d5d94SLen Brown 	cpu_present_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
3961c98d5d94SLen Brown 	CPU_ZERO_S(cpu_present_setsize, cpu_present_set);
3962c98d5d94SLen Brown 	for_all_proc_cpus(mark_cpu_present);
3963c98d5d94SLen Brown 
3964c98d5d94SLen Brown 	/*
3965c98d5d94SLen Brown 	 * Allocate and initialize cpu_affinity_set
3966c98d5d94SLen Brown 	 */
3967c98d5d94SLen Brown 	cpu_affinity_set = CPU_ALLOC((topo.max_cpu_num + 1));
3968b2c95d90SJosh Triplett 	if (cpu_affinity_set == NULL)
3969b2c95d90SJosh Triplett 		err(3, "CPU_ALLOC");
3970c98d5d94SLen Brown 	cpu_affinity_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
3971c98d5d94SLen Brown 	CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
3972c98d5d94SLen Brown 
3973c98d5d94SLen Brown 
3974c98d5d94SLen Brown 	/*
3975c98d5d94SLen Brown 	 * For online cpus
3976c98d5d94SLen Brown 	 * find max_core_id, max_package_id
3977c98d5d94SLen Brown 	 */
3978c98d5d94SLen Brown 	for (i = 0; i <= topo.max_cpu_num; ++i) {
3979c98d5d94SLen Brown 		int siblings;
3980c98d5d94SLen Brown 
3981c98d5d94SLen Brown 		if (cpu_is_not_present(i)) {
3982d8af6f5fSLen Brown 			if (debug > 1)
3983b7d8c148SLen Brown 				fprintf(outf, "cpu%d NOT PRESENT\n", i);
3984c98d5d94SLen Brown 			continue;
3985c98d5d94SLen Brown 		}
3986c98d5d94SLen Brown 		cpus[i].core_id = get_core_id(i);
3987c98d5d94SLen Brown 		if (cpus[i].core_id > max_core_id)
3988c98d5d94SLen Brown 			max_core_id = cpus[i].core_id;
3989c98d5d94SLen Brown 
3990c98d5d94SLen Brown 		cpus[i].physical_package_id = get_physical_package_id(i);
3991c98d5d94SLen Brown 		if (cpus[i].physical_package_id > max_package_id)
3992c98d5d94SLen Brown 			max_package_id = cpus[i].physical_package_id;
3993c98d5d94SLen Brown 
3994c98d5d94SLen Brown 		siblings = get_num_ht_siblings(i);
3995c98d5d94SLen Brown 		if (siblings > max_siblings)
3996c98d5d94SLen Brown 			max_siblings = siblings;
3997d8af6f5fSLen Brown 		if (debug > 1)
3998b7d8c148SLen Brown 			fprintf(outf, "cpu %d pkg %d core %d\n",
3999c98d5d94SLen Brown 				i, cpus[i].physical_package_id, cpus[i].core_id);
4000c98d5d94SLen Brown 	}
4001c98d5d94SLen Brown 	topo.num_cores_per_pkg = max_core_id + 1;
4002d8af6f5fSLen Brown 	if (debug > 1)
4003b7d8c148SLen Brown 		fprintf(outf, "max_core_id %d, sizing for %d cores per package\n",
4004c98d5d94SLen Brown 			max_core_id, topo.num_cores_per_pkg);
40050f47c08dSLen Brown 	if (!summary_only && topo.num_cores_per_pkg > 1)
4006812db3f7SLen Brown 		BIC_PRESENT(BIC_Core);
4007c98d5d94SLen Brown 
4008c98d5d94SLen Brown 	topo.num_packages = max_package_id + 1;
4009d8af6f5fSLen Brown 	if (debug > 1)
4010b7d8c148SLen Brown 		fprintf(outf, "max_package_id %d, sizing for %d packages\n",
4011c98d5d94SLen Brown 			max_package_id, topo.num_packages);
40121cc21f7bSLen Brown 	if (debug && !summary_only && topo.num_packages > 1)
4013812db3f7SLen Brown 		BIC_PRESENT(BIC_Package);
4014c98d5d94SLen Brown 
4015c98d5d94SLen Brown 	topo.num_threads_per_core = max_siblings;
4016d8af6f5fSLen Brown 	if (debug > 1)
4017b7d8c148SLen Brown 		fprintf(outf, "max_siblings %d\n", max_siblings);
4018c98d5d94SLen Brown 
4019c98d5d94SLen Brown 	free(cpus);
4020c98d5d94SLen Brown }
4021c98d5d94SLen Brown 
4022c98d5d94SLen Brown void
4023c98d5d94SLen Brown allocate_counters(struct thread_data **t, struct core_data **c, struct pkg_data **p)
4024c98d5d94SLen Brown {
4025c98d5d94SLen Brown 	int i;
4026c98d5d94SLen Brown 
4027c98d5d94SLen Brown 	*t = calloc(topo.num_threads_per_core * topo.num_cores_per_pkg *
4028678a3bd1SLen Brown 		topo.num_packages, sizeof(struct thread_data));
4029c98d5d94SLen Brown 	if (*t == NULL)
4030c98d5d94SLen Brown 		goto error;
4031c98d5d94SLen Brown 
4032c98d5d94SLen Brown 	for (i = 0; i < topo.num_threads_per_core *
4033c98d5d94SLen Brown 		topo.num_cores_per_pkg * topo.num_packages; i++)
4034c98d5d94SLen Brown 		(*t)[i].cpu_id = -1;
4035c98d5d94SLen Brown 
4036c98d5d94SLen Brown 	*c = calloc(topo.num_cores_per_pkg * topo.num_packages,
4037678a3bd1SLen Brown 		sizeof(struct core_data));
4038c98d5d94SLen Brown 	if (*c == NULL)
4039c98d5d94SLen Brown 		goto error;
4040c98d5d94SLen Brown 
4041c98d5d94SLen Brown 	for (i = 0; i < topo.num_cores_per_pkg * topo.num_packages; i++)
4042c98d5d94SLen Brown 		(*c)[i].core_id = -1;
4043c98d5d94SLen Brown 
4044678a3bd1SLen Brown 	*p = calloc(topo.num_packages, sizeof(struct pkg_data));
4045c98d5d94SLen Brown 	if (*p == NULL)
4046c98d5d94SLen Brown 		goto error;
4047c98d5d94SLen Brown 
4048c98d5d94SLen Brown 	for (i = 0; i < topo.num_packages; i++)
4049c98d5d94SLen Brown 		(*p)[i].package_id = i;
4050c98d5d94SLen Brown 
4051c98d5d94SLen Brown 	return;
4052c98d5d94SLen Brown error:
4053b2c95d90SJosh Triplett 	err(1, "calloc counters");
4054c98d5d94SLen Brown }
4055c98d5d94SLen Brown /*
4056c98d5d94SLen Brown  * init_counter()
4057c98d5d94SLen Brown  *
4058c98d5d94SLen Brown  * set cpu_id, core_num, pkg_num
4059c98d5d94SLen Brown  * set FIRST_THREAD_IN_CORE and FIRST_CORE_IN_PACKAGE
4060c98d5d94SLen Brown  *
4061c98d5d94SLen Brown  * increment topo.num_cores when 1st core in pkg seen
4062c98d5d94SLen Brown  */
4063c98d5d94SLen Brown void init_counter(struct thread_data *thread_base, struct core_data *core_base,
4064c98d5d94SLen Brown 	struct pkg_data *pkg_base, int thread_num, int core_num,
4065c98d5d94SLen Brown 	int pkg_num, int cpu_id)
4066c98d5d94SLen Brown {
4067c98d5d94SLen Brown 	struct thread_data *t;
4068c98d5d94SLen Brown 	struct core_data *c;
4069c98d5d94SLen Brown 	struct pkg_data *p;
4070c98d5d94SLen Brown 
4071c98d5d94SLen Brown 	t = GET_THREAD(thread_base, thread_num, core_num, pkg_num);
4072c98d5d94SLen Brown 	c = GET_CORE(core_base, core_num, pkg_num);
4073c98d5d94SLen Brown 	p = GET_PKG(pkg_base, pkg_num);
4074c98d5d94SLen Brown 
4075c98d5d94SLen Brown 	t->cpu_id = cpu_id;
4076c98d5d94SLen Brown 	if (thread_num == 0) {
4077c98d5d94SLen Brown 		t->flags |= CPU_IS_FIRST_THREAD_IN_CORE;
4078c98d5d94SLen Brown 		if (cpu_is_first_core_in_package(cpu_id))
4079c98d5d94SLen Brown 			t->flags |= CPU_IS_FIRST_CORE_IN_PACKAGE;
4080c98d5d94SLen Brown 	}
4081c98d5d94SLen Brown 
4082c98d5d94SLen Brown 	c->core_id = core_num;
4083c98d5d94SLen Brown 	p->package_id = pkg_num;
4084c98d5d94SLen Brown }
4085c98d5d94SLen Brown 
4086c98d5d94SLen Brown 
4087c98d5d94SLen Brown int initialize_counters(int cpu_id)
4088c98d5d94SLen Brown {
4089c98d5d94SLen Brown 	int my_thread_id, my_core_id, my_package_id;
4090c98d5d94SLen Brown 
4091c98d5d94SLen Brown 	my_package_id = get_physical_package_id(cpu_id);
4092c98d5d94SLen Brown 	my_core_id = get_core_id(cpu_id);
4093e275b388SDasaratharaman Chandramouli 	my_thread_id = get_cpu_position_in_core(cpu_id);
4094e275b388SDasaratharaman Chandramouli 	if (!my_thread_id)
4095c98d5d94SLen Brown 		topo.num_cores++;
4096c98d5d94SLen Brown 
4097c98d5d94SLen Brown 	init_counter(EVEN_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
4098c98d5d94SLen Brown 	init_counter(ODD_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
4099c98d5d94SLen Brown 	return 0;
4100c98d5d94SLen Brown }
4101c98d5d94SLen Brown 
4102c98d5d94SLen Brown void allocate_output_buffer()
4103c98d5d94SLen Brown {
41043b4d5c7fSAndy Shevchenko 	output_buffer = calloc(1, (1 + topo.num_cpus) * 1024);
4105c98d5d94SLen Brown 	outp = output_buffer;
4106b2c95d90SJosh Triplett 	if (outp == NULL)
4107b2c95d90SJosh Triplett 		err(-1, "calloc output buffer");
4108c98d5d94SLen Brown }
410936229897SLen Brown void allocate_fd_percpu(void)
411036229897SLen Brown {
411101a67adfSMika Westerberg 	fd_percpu = calloc(topo.max_cpu_num + 1, sizeof(int));
411236229897SLen Brown 	if (fd_percpu == NULL)
411336229897SLen Brown 		err(-1, "calloc fd_percpu");
411436229897SLen Brown }
4115562a2d37SLen Brown void allocate_irq_buffers(void)
4116562a2d37SLen Brown {
4117562a2d37SLen Brown 	irq_column_2_cpu = calloc(topo.num_cpus, sizeof(int));
4118562a2d37SLen Brown 	if (irq_column_2_cpu == NULL)
4119562a2d37SLen Brown 		err(-1, "calloc %d", topo.num_cpus);
4120c98d5d94SLen Brown 
412101a67adfSMika Westerberg 	irqs_per_cpu = calloc(topo.max_cpu_num + 1, sizeof(int));
4122562a2d37SLen Brown 	if (irqs_per_cpu == NULL)
412301a67adfSMika Westerberg 		err(-1, "calloc %d", topo.max_cpu_num + 1);
4124562a2d37SLen Brown }
4125c98d5d94SLen Brown void setup_all_buffers(void)
4126c98d5d94SLen Brown {
4127c98d5d94SLen Brown 	topology_probe();
4128562a2d37SLen Brown 	allocate_irq_buffers();
412936229897SLen Brown 	allocate_fd_percpu();
4130c98d5d94SLen Brown 	allocate_counters(&thread_even, &core_even, &package_even);
4131c98d5d94SLen Brown 	allocate_counters(&thread_odd, &core_odd, &package_odd);
4132c98d5d94SLen Brown 	allocate_output_buffer();
4133c98d5d94SLen Brown 	for_all_proc_cpus(initialize_counters);
4134c98d5d94SLen Brown }
41353b4d5c7fSAndy Shevchenko 
41367ce7d5deSPrarit Bhargava void set_base_cpu(void)
41377ce7d5deSPrarit Bhargava {
41387ce7d5deSPrarit Bhargava 	base_cpu = sched_getcpu();
41397ce7d5deSPrarit Bhargava 	if (base_cpu < 0)
41407ce7d5deSPrarit Bhargava 		err(-ENODEV, "No valid cpus found");
41417ce7d5deSPrarit Bhargava 
41427ce7d5deSPrarit Bhargava 	if (debug > 1)
4143b7d8c148SLen Brown 		fprintf(outf, "base_cpu = %d\n", base_cpu);
41447ce7d5deSPrarit Bhargava }
41457ce7d5deSPrarit Bhargava 
4146103a8feaSLen Brown void turbostat_init()
4147103a8feaSLen Brown {
41487ce7d5deSPrarit Bhargava 	setup_all_buffers();
41497ce7d5deSPrarit Bhargava 	set_base_cpu();
4150103a8feaSLen Brown 	check_dev_msr();
415198481e79SLen Brown 	check_permissions();
4152fcd17211SLen Brown 	process_cpuid();
4153103a8feaSLen Brown 
4154103a8feaSLen Brown 
415596e47158SLen Brown 	if (!quiet)
41567f5c258eSLen Brown 		for_all_cpus(print_hwp, ODD_COUNTERS);
41577f5c258eSLen Brown 
415896e47158SLen Brown 	if (!quiet)
4159889facbeSLen Brown 		for_all_cpus(print_epb, ODD_COUNTERS);
4160889facbeSLen Brown 
416196e47158SLen Brown 	if (!quiet)
41623a9a941dSLen Brown 		for_all_cpus(print_perf_limit, ODD_COUNTERS);
41633a9a941dSLen Brown 
416496e47158SLen Brown 	if (!quiet)
4165889facbeSLen Brown 		for_all_cpus(print_rapl, ODD_COUNTERS);
4166889facbeSLen Brown 
4167889facbeSLen Brown 	for_all_cpus(set_temperature_target, ODD_COUNTERS);
4168889facbeSLen Brown 
416996e47158SLen Brown 	if (!quiet)
4170889facbeSLen Brown 		for_all_cpus(print_thermal, ODD_COUNTERS);
41715a63426eSLen Brown 
417296e47158SLen Brown 	if (!quiet && do_irtl_snb)
41735a63426eSLen Brown 		print_irtl();
4174103a8feaSLen Brown }
4175103a8feaSLen Brown 
4176103a8feaSLen Brown int fork_it(char **argv)
4177103a8feaSLen Brown {
4178103a8feaSLen Brown 	pid_t child_pid;
4179d91bb17cSLen Brown 	int status;
4180d15cf7c1SLen Brown 
4181d91bb17cSLen Brown 	status = for_all_cpus(get_counters, EVEN_COUNTERS);
4182d91bb17cSLen Brown 	if (status)
4183d91bb17cSLen Brown 		exit(status);
4184d15cf7c1SLen Brown 	/* clear affinity side-effect of get_counters() */
4185d15cf7c1SLen Brown 	sched_setaffinity(0, cpu_present_setsize, cpu_present_set);
4186103a8feaSLen Brown 	gettimeofday(&tv_even, (struct timezone *)NULL);
4187103a8feaSLen Brown 
4188103a8feaSLen Brown 	child_pid = fork();
4189103a8feaSLen Brown 	if (!child_pid) {
4190103a8feaSLen Brown 		/* child */
4191103a8feaSLen Brown 		execvp(argv[0], argv);
4192103a8feaSLen Brown 	} else {
4193103a8feaSLen Brown 
4194103a8feaSLen Brown 		/* parent */
4195b2c95d90SJosh Triplett 		if (child_pid == -1)
4196b2c95d90SJosh Triplett 			err(1, "fork");
4197103a8feaSLen Brown 
4198103a8feaSLen Brown 		signal(SIGINT, SIG_IGN);
4199103a8feaSLen Brown 		signal(SIGQUIT, SIG_IGN);
4200b2c95d90SJosh Triplett 		if (waitpid(child_pid, &status, 0) == -1)
4201b2c95d90SJosh Triplett 			err(status, "waitpid");
4202103a8feaSLen Brown 	}
4203c98d5d94SLen Brown 	/*
4204c98d5d94SLen Brown 	 * n.b. fork_it() does not check for errors from for_all_cpus()
4205c98d5d94SLen Brown 	 * because re-starting is problematic when forking
4206c98d5d94SLen Brown 	 */
4207c98d5d94SLen Brown 	for_all_cpus(get_counters, ODD_COUNTERS);
4208103a8feaSLen Brown 	gettimeofday(&tv_odd, (struct timezone *)NULL);
4209103a8feaSLen Brown 	timersub(&tv_odd, &tv_even, &tv_delta);
4210ba3dec99SLen Brown 	if (for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS))
4211ba3dec99SLen Brown 		fprintf(outf, "%s: Counter reset detected\n", progname);
4212ba3dec99SLen Brown 	else {
4213c98d5d94SLen Brown 		compute_average(EVEN_COUNTERS);
4214c98d5d94SLen Brown 		format_all_counters(EVEN_COUNTERS);
4215ba3dec99SLen Brown 	}
4216103a8feaSLen Brown 
4217b7d8c148SLen Brown 	fprintf(outf, "%.6f sec\n", tv_delta.tv_sec + tv_delta.tv_usec/1000000.0);
4218b7d8c148SLen Brown 
4219b7d8c148SLen Brown 	flush_output_stderr();
4220103a8feaSLen Brown 
4221d91bb17cSLen Brown 	return status;
4222103a8feaSLen Brown }
4223103a8feaSLen Brown 
42243b4d5c7fSAndy Shevchenko int get_and_dump_counters(void)
42253b4d5c7fSAndy Shevchenko {
42263b4d5c7fSAndy Shevchenko 	int status;
42273b4d5c7fSAndy Shevchenko 
42283b4d5c7fSAndy Shevchenko 	status = for_all_cpus(get_counters, ODD_COUNTERS);
42293b4d5c7fSAndy Shevchenko 	if (status)
42303b4d5c7fSAndy Shevchenko 		return status;
42313b4d5c7fSAndy Shevchenko 
42323b4d5c7fSAndy Shevchenko 	status = for_all_cpus(dump_counters, ODD_COUNTERS);
42333b4d5c7fSAndy Shevchenko 	if (status)
42343b4d5c7fSAndy Shevchenko 		return status;
42353b4d5c7fSAndy Shevchenko 
4236b7d8c148SLen Brown 	flush_output_stdout();
42373b4d5c7fSAndy Shevchenko 
42383b4d5c7fSAndy Shevchenko 	return status;
42393b4d5c7fSAndy Shevchenko }
42403b4d5c7fSAndy Shevchenko 
4241d8af6f5fSLen Brown void print_version() {
42420539ba11SLen Brown 	fprintf(outf, "turbostat version 4.17 10 Jan 2017"
4243d8af6f5fSLen Brown 		" - Len Brown <lenb@kernel.org>\n");
4244d8af6f5fSLen Brown }
4245d8af6f5fSLen Brown 
4246388e9c81SLen Brown int add_counter(unsigned int msr_num, char *name, unsigned int width,
4247388e9c81SLen Brown 	enum counter_scope scope, enum counter_type type,
4248388e9c81SLen Brown 	enum counter_format format)
4249388e9c81SLen Brown {
4250388e9c81SLen Brown 	struct msr_counter *msrp;
4251388e9c81SLen Brown 
4252388e9c81SLen Brown 	msrp = calloc(1, sizeof(struct msr_counter));
4253388e9c81SLen Brown 	if (msrp == NULL) {
4254388e9c81SLen Brown 		perror("calloc");
4255388e9c81SLen Brown 		exit(1);
4256388e9c81SLen Brown 	}
4257388e9c81SLen Brown 
4258388e9c81SLen Brown 	msrp->msr_num = msr_num;
4259388e9c81SLen Brown 	strncpy(msrp->name, name, NAME_BYTES);
4260388e9c81SLen Brown 	msrp->width = width;
4261388e9c81SLen Brown 	msrp->type = type;
4262388e9c81SLen Brown 	msrp->format = format;
4263388e9c81SLen Brown 
4264388e9c81SLen Brown 	switch (scope) {
4265388e9c81SLen Brown 
4266388e9c81SLen Brown 	case SCOPE_CPU:
4267388e9c81SLen Brown 		msrp->next = sys.tp;
4268388e9c81SLen Brown 		sys.tp = msrp;
4269678a3bd1SLen Brown 		sys.added_thread_counters++;
4270678a3bd1SLen Brown 		if (sys.added_thread_counters > MAX_ADDED_COUNTERS) {
4271678a3bd1SLen Brown 			fprintf(stderr, "exceeded max %d added thread counters\n",
4272678a3bd1SLen Brown 				MAX_ADDED_COUNTERS);
4273678a3bd1SLen Brown 			exit(-1);
4274678a3bd1SLen Brown 		}
4275388e9c81SLen Brown 		break;
4276388e9c81SLen Brown 
4277388e9c81SLen Brown 	case SCOPE_CORE:
4278388e9c81SLen Brown 		msrp->next = sys.cp;
4279388e9c81SLen Brown 		sys.cp = msrp;
4280678a3bd1SLen Brown 		sys.added_core_counters++;
4281678a3bd1SLen Brown 		if (sys.added_core_counters > MAX_ADDED_COUNTERS) {
4282678a3bd1SLen Brown 			fprintf(stderr, "exceeded max %d added core counters\n",
4283678a3bd1SLen Brown 				MAX_ADDED_COUNTERS);
4284678a3bd1SLen Brown 			exit(-1);
4285678a3bd1SLen Brown 		}
4286388e9c81SLen Brown 		break;
4287388e9c81SLen Brown 
4288388e9c81SLen Brown 	case SCOPE_PACKAGE:
4289388e9c81SLen Brown 		msrp->next = sys.pp;
4290388e9c81SLen Brown 		sys.pp = msrp;
4291678a3bd1SLen Brown 		sys.added_package_counters++;
4292678a3bd1SLen Brown 		if (sys.added_package_counters > MAX_ADDED_COUNTERS) {
4293678a3bd1SLen Brown 			fprintf(stderr, "exceeded max %d added package counters\n",
4294678a3bd1SLen Brown 				MAX_ADDED_COUNTERS);
4295678a3bd1SLen Brown 			exit(-1);
4296678a3bd1SLen Brown 		}
4297388e9c81SLen Brown 		break;
4298388e9c81SLen Brown 	}
4299388e9c81SLen Brown 
4300388e9c81SLen Brown 	return 0;
4301388e9c81SLen Brown }
4302388e9c81SLen Brown 
4303388e9c81SLen Brown void parse_add_command(char *add_command)
4304388e9c81SLen Brown {
4305388e9c81SLen Brown 	int msr_num = 0;
43060f47c08dSLen Brown 	char name_buffer[NAME_BYTES] = "";
4307388e9c81SLen Brown 	int width = 64;
4308388e9c81SLen Brown 	int fail = 0;
4309388e9c81SLen Brown 	enum counter_scope scope = SCOPE_CPU;
4310388e9c81SLen Brown 	enum counter_type type = COUNTER_CYCLES;
4311388e9c81SLen Brown 	enum counter_format format = FORMAT_DELTA;
4312388e9c81SLen Brown 
4313388e9c81SLen Brown 	while (add_command) {
4314388e9c81SLen Brown 
4315388e9c81SLen Brown 		if (sscanf(add_command, "msr0x%x", &msr_num) == 1)
4316388e9c81SLen Brown 			goto next;
4317388e9c81SLen Brown 
4318388e9c81SLen Brown 		if (sscanf(add_command, "msr%d", &msr_num) == 1)
4319388e9c81SLen Brown 			goto next;
4320388e9c81SLen Brown 
4321388e9c81SLen Brown 		if (sscanf(add_command, "u%d", &width) == 1) {
4322388e9c81SLen Brown 			if ((width == 32) || (width == 64))
4323388e9c81SLen Brown 				goto next;
4324388e9c81SLen Brown 			width = 64;
4325388e9c81SLen Brown 		}
4326388e9c81SLen Brown 		if (!strncmp(add_command, "cpu", strlen("cpu"))) {
4327388e9c81SLen Brown 			scope = SCOPE_CPU;
4328388e9c81SLen Brown 			goto next;
4329388e9c81SLen Brown 		}
4330388e9c81SLen Brown 		if (!strncmp(add_command, "core", strlen("core"))) {
4331388e9c81SLen Brown 			scope = SCOPE_CORE;
4332388e9c81SLen Brown 			goto next;
4333388e9c81SLen Brown 		}
4334388e9c81SLen Brown 		if (!strncmp(add_command, "package", strlen("package"))) {
4335388e9c81SLen Brown 			scope = SCOPE_PACKAGE;
4336388e9c81SLen Brown 			goto next;
4337388e9c81SLen Brown 		}
4338388e9c81SLen Brown 		if (!strncmp(add_command, "cycles", strlen("cycles"))) {
4339388e9c81SLen Brown 			type = COUNTER_CYCLES;
4340388e9c81SLen Brown 			goto next;
4341388e9c81SLen Brown 		}
4342388e9c81SLen Brown 		if (!strncmp(add_command, "seconds", strlen("seconds"))) {
4343388e9c81SLen Brown 			type = COUNTER_SECONDS;
4344388e9c81SLen Brown 			goto next;
4345388e9c81SLen Brown 		}
4346388e9c81SLen Brown 		if (!strncmp(add_command, "raw", strlen("raw"))) {
4347388e9c81SLen Brown 			format = FORMAT_RAW;
4348388e9c81SLen Brown 			goto next;
4349388e9c81SLen Brown 		}
4350388e9c81SLen Brown 		if (!strncmp(add_command, "delta", strlen("delta"))) {
4351388e9c81SLen Brown 			format = FORMAT_DELTA;
4352388e9c81SLen Brown 			goto next;
4353388e9c81SLen Brown 		}
4354388e9c81SLen Brown 		if (!strncmp(add_command, "percent", strlen("percent"))) {
4355388e9c81SLen Brown 			format = FORMAT_PERCENT;
4356388e9c81SLen Brown 			goto next;
4357388e9c81SLen Brown 		}
4358388e9c81SLen Brown 
4359388e9c81SLen Brown 		if (sscanf(add_command, "%18s,%*s", name_buffer) == 1) {	/* 18 < NAME_BYTES */
4360388e9c81SLen Brown 			char *eos;
4361388e9c81SLen Brown 
4362388e9c81SLen Brown 			eos = strchr(name_buffer, ',');
4363388e9c81SLen Brown 			if (eos)
4364388e9c81SLen Brown 				*eos = '\0';
4365388e9c81SLen Brown 			goto next;
4366388e9c81SLen Brown 		}
4367388e9c81SLen Brown 
4368388e9c81SLen Brown next:
4369388e9c81SLen Brown 		add_command = strchr(add_command, ',');
4370388e9c81SLen Brown 		if (add_command)
4371388e9c81SLen Brown 			add_command++;
4372388e9c81SLen Brown 
4373388e9c81SLen Brown 	}
4374388e9c81SLen Brown 	if (msr_num == 0) {
4375388e9c81SLen Brown 		fprintf(stderr, "--add: (msrDDD | msr0xXXX) required\n");
4376388e9c81SLen Brown 		fail++;
4377388e9c81SLen Brown 	}
4378388e9c81SLen Brown 
4379388e9c81SLen Brown 	/* generate default column header */
4380388e9c81SLen Brown 	if (*name_buffer == '\0') {
4381388e9c81SLen Brown 		if (format == FORMAT_RAW) {
4382388e9c81SLen Brown 			if (width == 32)
4383388e9c81SLen Brown 				sprintf(name_buffer, "msr%d", msr_num);
4384388e9c81SLen Brown 			else
4385388e9c81SLen Brown 				sprintf(name_buffer, "MSR%d", msr_num);
4386388e9c81SLen Brown 		} else if (format == FORMAT_DELTA) {
4387388e9c81SLen Brown 			if (width == 32)
4388388e9c81SLen Brown 				sprintf(name_buffer, "cnt%d", msr_num);
4389388e9c81SLen Brown 			else
4390388e9c81SLen Brown 				sprintf(name_buffer, "CNT%d", msr_num);
4391388e9c81SLen Brown 		} else if (format == FORMAT_PERCENT) {
4392388e9c81SLen Brown 			if (width == 32)
4393388e9c81SLen Brown 				sprintf(name_buffer, "msr%d%%", msr_num);
4394388e9c81SLen Brown 			else
4395388e9c81SLen Brown 				sprintf(name_buffer, "MSR%d%%", msr_num);
4396388e9c81SLen Brown 		}
4397388e9c81SLen Brown 	}
4398388e9c81SLen Brown 
4399388e9c81SLen Brown 	if (add_counter(msr_num, name_buffer, width, scope, type, format))
4400388e9c81SLen Brown 		fail++;
4401388e9c81SLen Brown 
4402388e9c81SLen Brown 	if (fail) {
4403388e9c81SLen Brown 		help();
4404388e9c81SLen Brown 		exit(1);
4405388e9c81SLen Brown 	}
4406388e9c81SLen Brown }
4407812db3f7SLen Brown /*
4408812db3f7SLen Brown  * HIDE_LIST - hide this list of counters, show the rest [default]
4409812db3f7SLen Brown  * SHOW_LIST - show this list of counters, hide the rest
4410812db3f7SLen Brown  */
4411812db3f7SLen Brown enum show_hide_mode { SHOW_LIST, HIDE_LIST } global_show_hide_mode = HIDE_LIST;
4412812db3f7SLen Brown 
4413812db3f7SLen Brown int shown;
4414812db3f7SLen Brown /*
4415812db3f7SLen Brown  * parse_show_hide() - process cmdline to set default counter action
4416812db3f7SLen Brown  */
4417812db3f7SLen Brown void parse_show_hide(char *optarg, enum show_hide_mode new_mode)
4418812db3f7SLen Brown {
4419812db3f7SLen Brown 	/*
4420812db3f7SLen Brown 	 * --show: show only those specified
4421812db3f7SLen Brown 	 *  The 1st invocation will clear and replace the enabled mask
4422812db3f7SLen Brown 	 *  subsequent invocations can add to it.
4423812db3f7SLen Brown 	 */
4424812db3f7SLen Brown 	if (new_mode == SHOW_LIST) {
4425812db3f7SLen Brown 		if (shown == 0)
4426812db3f7SLen Brown 			bic_enabled = bic_lookup(optarg);
4427812db3f7SLen Brown 		else
4428812db3f7SLen Brown 			bic_enabled |= bic_lookup(optarg);
4429812db3f7SLen Brown 		shown = 1;
4430812db3f7SLen Brown 
4431812db3f7SLen Brown 		return;
4432812db3f7SLen Brown 	}
4433812db3f7SLen Brown 
4434812db3f7SLen Brown 	/*
4435812db3f7SLen Brown 	 * --hide: do not show those specified
4436812db3f7SLen Brown 	 *  multiple invocations simply clear more bits in enabled mask
4437812db3f7SLen Brown 	 */
4438812db3f7SLen Brown 	bic_enabled &= ~bic_lookup(optarg);
4439812db3f7SLen Brown }
4440812db3f7SLen Brown 
4441103a8feaSLen Brown void cmdline(int argc, char **argv)
4442103a8feaSLen Brown {
4443103a8feaSLen Brown 	int opt;
4444d8af6f5fSLen Brown 	int option_index = 0;
4445d8af6f5fSLen Brown 	static struct option long_options[] = {
4446388e9c81SLen Brown 		{"add",		required_argument,	0, 'a'},
4447d8af6f5fSLen Brown 		{"Dump",	no_argument,		0, 'D'},
444896e47158SLen Brown 		{"debug",	no_argument,		0, 'd'},	/* internal, not documented */
4449d8af6f5fSLen Brown 		{"interval",	required_argument,	0, 'i'},
4450d8af6f5fSLen Brown 		{"help",	no_argument,		0, 'h'},
4451812db3f7SLen Brown 		{"hide",	required_argument,	0, 'H'},	// meh, -h taken by --help
4452d8af6f5fSLen Brown 		{"Joules",	no_argument,		0, 'J'},
4453b7d8c148SLen Brown 		{"out",		required_argument,	0, 'o'},
4454d8af6f5fSLen Brown 		{"Package",	no_argument,		0, 'p'},
4455d8af6f5fSLen Brown 		{"processor",	no_argument,		0, 'p'},
445696e47158SLen Brown 		{"quiet",	no_argument,		0, 'q'},
4457812db3f7SLen Brown 		{"show",	required_argument,	0, 's'},
4458d8af6f5fSLen Brown 		{"Summary",	no_argument,		0, 'S'},
4459d8af6f5fSLen Brown 		{"TCC",		required_argument,	0, 'T'},
4460d8af6f5fSLen Brown 		{"version",	no_argument,		0, 'v' },
4461d8af6f5fSLen Brown 		{0,		0,			0,  0 }
4462d8af6f5fSLen Brown 	};
4463103a8feaSLen Brown 
4464103a8feaSLen Brown 	progname = argv[0];
4465103a8feaSLen Brown 
446696e47158SLen Brown 	while ((opt = getopt_long_only(argc, argv, "+C:c:Ddhi:JM:m:o:PpqST:v",
4467d8af6f5fSLen Brown 				long_options, &option_index)) != -1) {
4468103a8feaSLen Brown 		switch (opt) {
4469388e9c81SLen Brown 		case 'a':
4470388e9c81SLen Brown 			parse_add_command(optarg);
4471388e9c81SLen Brown 			break;
4472d8af6f5fSLen Brown 		case 'D':
4473d8af6f5fSLen Brown 			dump_only++;
44748e180f3cSLen Brown 			break;
4475d8af6f5fSLen Brown 		case 'd':
4476d8af6f5fSLen Brown 			debug++;
44772f32edf1SLen Brown 			break;
4478812db3f7SLen Brown 		case 'H':
4479812db3f7SLen Brown 			parse_show_hide(optarg, HIDE_LIST);
4480812db3f7SLen Brown 			break;
4481d8af6f5fSLen Brown 		case 'h':
4482d8af6f5fSLen Brown 		default:
4483d8af6f5fSLen Brown 			help();
4484d8af6f5fSLen Brown 			exit(1);
4485d8af6f5fSLen Brown 		case 'i':
44862a0609c0SLen Brown 			{
44872a0609c0SLen Brown 				double interval = strtod(optarg, NULL);
44882a0609c0SLen Brown 
44892a0609c0SLen Brown 				if (interval < 0.001) {
4490b7d8c148SLen Brown 					fprintf(outf, "interval %f seconds is too small\n",
44912a0609c0SLen Brown 						interval);
44922a0609c0SLen Brown 					exit(2);
44932a0609c0SLen Brown 				}
44942a0609c0SLen Brown 
44952a0609c0SLen Brown 				interval_ts.tv_sec = interval;
44962a0609c0SLen Brown 				interval_ts.tv_nsec = (interval - interval_ts.tv_sec) * 1000000000;
44972a0609c0SLen Brown 			}
4498889facbeSLen Brown 			break;
44995c56be9aSDirk Brandewie 		case 'J':
45005c56be9aSDirk Brandewie 			rapl_joules++;
45015c56be9aSDirk Brandewie 			break;
4502b7d8c148SLen Brown 		case 'o':
4503b7d8c148SLen Brown 			outf = fopen_or_die(optarg, "w");
4504b7d8c148SLen Brown 			break;
4505d8af6f5fSLen Brown 		case 'P':
4506d8af6f5fSLen Brown 			show_pkg_only++;
4507d8af6f5fSLen Brown 			break;
4508d8af6f5fSLen Brown 		case 'p':
4509d8af6f5fSLen Brown 			show_core_only++;
4510d8af6f5fSLen Brown 			break;
451196e47158SLen Brown 		case 'q':
451296e47158SLen Brown 			quiet = 1;
451396e47158SLen Brown 			break;
4514812db3f7SLen Brown 		case 's':
4515812db3f7SLen Brown 			parse_show_hide(optarg, SHOW_LIST);
4516812db3f7SLen Brown 			break;
4517d8af6f5fSLen Brown 		case 'S':
4518d8af6f5fSLen Brown 			summary_only++;
4519d8af6f5fSLen Brown 			break;
4520d8af6f5fSLen Brown 		case 'T':
4521d8af6f5fSLen Brown 			tcc_activation_temp_override = atoi(optarg);
4522d8af6f5fSLen Brown 			break;
4523d8af6f5fSLen Brown 		case 'v':
4524d8af6f5fSLen Brown 			print_version();
4525d8af6f5fSLen Brown 			exit(0);
4526d8af6f5fSLen Brown 			break;
4527103a8feaSLen Brown 		}
4528103a8feaSLen Brown 	}
4529103a8feaSLen Brown }
4530103a8feaSLen Brown 
4531103a8feaSLen Brown int main(int argc, char **argv)
4532103a8feaSLen Brown {
4533b7d8c148SLen Brown 	outf = stderr;
4534b7d8c148SLen Brown 
4535103a8feaSLen Brown 	cmdline(argc, argv);
4536103a8feaSLen Brown 
453796e47158SLen Brown 	if (!quiet)
4538d8af6f5fSLen Brown 		print_version();
4539103a8feaSLen Brown 
4540103a8feaSLen Brown 	turbostat_init();
4541103a8feaSLen Brown 
45423b4d5c7fSAndy Shevchenko 	/* dump counters and exit */
45433b4d5c7fSAndy Shevchenko 	if (dump_only)
45443b4d5c7fSAndy Shevchenko 		return get_and_dump_counters();
45453b4d5c7fSAndy Shevchenko 
4546103a8feaSLen Brown 	/*
4547103a8feaSLen Brown 	 * if any params left, it must be a command to fork
4548103a8feaSLen Brown 	 */
4549103a8feaSLen Brown 	if (argc - optind)
4550103a8feaSLen Brown 		return fork_it(argv + optind);
4551103a8feaSLen Brown 	else
4552103a8feaSLen Brown 		turbostat_loop();
4553103a8feaSLen Brown 
4554103a8feaSLen Brown 	return 0;
4555103a8feaSLen Brown }
4556