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;
58ee7e38e3SLen Brown unsigned int do_pc2;
59ee7e38e3SLen Brown unsigned int do_pc3;
60ee7e38e3SLen Brown unsigned int do_pc6;
61ee7e38e3SLen Brown unsigned int do_pc7;
62ca58710fSKristen Carlson Accardi unsigned int do_c8_c9_c10;
630b2bb692SLen Brown unsigned int do_skl_residency;
64144b44b1SLen Brown unsigned int do_slm_cstates;
65144b44b1SLen Brown unsigned int use_c1_residency_msr;
66103a8feaSLen Brown unsigned int has_aperf;
67889facbeSLen Brown unsigned int has_epb;
685a63426eSLen Brown unsigned int do_irtl_snb;
695a63426eSLen Brown unsigned int do_irtl_hsw;
70fc04cc67SLen Brown unsigned int units = 1000000;	/* MHz etc */
71103a8feaSLen Brown unsigned int genuine_intel;
72103a8feaSLen Brown unsigned int has_invariant_tsc;
73d7899447SLen Brown unsigned int do_nhm_platform_info;
74cf4cbe53SLen Brown unsigned int no_MSR_MISC_PWR_MGMT;
75b2b34dfeSHubert Chrzaniuk unsigned int aperf_mperf_multiplier = 1;
76103a8feaSLen Brown double bclk;
77a2b7b749SLen Brown double base_hz;
7821ed5574SLen Brown unsigned int has_base_hz;
79a2b7b749SLen Brown double tsc_tweak = 1.0;
80c98d5d94SLen Brown unsigned int show_pkg_only;
81c98d5d94SLen Brown unsigned int show_core_only;
82c98d5d94SLen Brown char *output_buffer, *outp;
83889facbeSLen Brown unsigned int do_rapl;
84889facbeSLen Brown unsigned int do_dts;
85889facbeSLen Brown unsigned int do_ptm;
86fdf676e5SLen Brown unsigned long long  gfx_cur_rc6_ms;
8727d47356SLen Brown unsigned int gfx_cur_mhz;
88889facbeSLen Brown unsigned int tcc_activation_temp;
89889facbeSLen Brown unsigned int tcc_activation_temp_override;
9040ee8e3bSAndrey Semin double rapl_power_units, rapl_time_units;
9140ee8e3bSAndrey Semin double rapl_dram_energy_units, rapl_energy_units;
92889facbeSLen Brown double rapl_joule_counter_range;
933a9a941dSLen Brown unsigned int do_core_perf_limit_reasons;
943a9a941dSLen Brown unsigned int do_gfx_perf_limit_reasons;
953a9a941dSLen Brown unsigned int do_ring_perf_limit_reasons;
968a5bdf41SLen Brown unsigned int crystal_hz;
978a5bdf41SLen Brown unsigned long long tsc_hz;
987ce7d5deSPrarit Bhargava int base_cpu;
9921ed5574SLen Brown double discover_bclk(unsigned int family, unsigned int model);
1007f5c258eSLen Brown unsigned int has_hwp;	/* IA32_PM_ENABLE, IA32_HWP_CAPABILITIES */
1017f5c258eSLen Brown 			/* IA32_HWP_REQUEST, IA32_HWP_STATUS */
1027f5c258eSLen Brown unsigned int has_hwp_notify;		/* IA32_HWP_INTERRUPT */
1037f5c258eSLen Brown unsigned int has_hwp_activity_window;	/* IA32_HWP_REQUEST[bits 41:32] */
1047f5c258eSLen Brown unsigned int has_hwp_epp;		/* IA32_HWP_REQUEST[bits 31:24] */
1057f5c258eSLen Brown unsigned int has_hwp_pkg;		/* IA32_HWP_REQUEST_PKG */
10633148d67SLen Brown unsigned int has_misc_feature_control;
107889facbeSLen Brown 
108889facbeSLen Brown #define RAPL_PKG		(1 << 0)
109e6f9bb3cSLen Brown 					/* 0x610 MSR_PKG_POWER_LIMIT */
110e6f9bb3cSLen Brown 					/* 0x611 MSR_PKG_ENERGY_STATUS */
111e6f9bb3cSLen Brown #define RAPL_PKG_PERF_STATUS	(1 << 1)
112e6f9bb3cSLen Brown 					/* 0x613 MSR_PKG_PERF_STATUS */
113e6f9bb3cSLen Brown #define RAPL_PKG_POWER_INFO	(1 << 2)
114e6f9bb3cSLen Brown 					/* 0x614 MSR_PKG_POWER_INFO */
115e6f9bb3cSLen Brown 
116889facbeSLen Brown #define RAPL_DRAM		(1 << 3)
117e6f9bb3cSLen Brown 					/* 0x618 MSR_DRAM_POWER_LIMIT */
118e6f9bb3cSLen Brown 					/* 0x619 MSR_DRAM_ENERGY_STATUS */
119e6f9bb3cSLen Brown #define RAPL_DRAM_PERF_STATUS	(1 << 4)
120e6f9bb3cSLen Brown 					/* 0x61b MSR_DRAM_PERF_STATUS */
1210b2bb692SLen Brown #define RAPL_DRAM_POWER_INFO	(1 << 5)
1220b2bb692SLen Brown 					/* 0x61c MSR_DRAM_POWER_INFO */
123e6f9bb3cSLen Brown 
1249148494cSJacob Pan #define RAPL_CORES_POWER_LIMIT	(1 << 6)
125e6f9bb3cSLen Brown 					/* 0x638 MSR_PP0_POWER_LIMIT */
1260b2bb692SLen Brown #define RAPL_CORE_POLICY	(1 << 7)
127e6f9bb3cSLen Brown 					/* 0x63a MSR_PP0_POLICY */
128e6f9bb3cSLen Brown 
1290b2bb692SLen Brown #define RAPL_GFX		(1 << 8)
130e6f9bb3cSLen Brown 					/* 0x640 MSR_PP1_POWER_LIMIT */
131e6f9bb3cSLen Brown 					/* 0x641 MSR_PP1_ENERGY_STATUS */
132e6f9bb3cSLen Brown 					/* 0x642 MSR_PP1_POLICY */
1339148494cSJacob Pan 
1349148494cSJacob Pan #define RAPL_CORES_ENERGY_STATUS	(1 << 9)
1359148494cSJacob Pan 					/* 0x639 MSR_PP0_ENERGY_STATUS */
1369148494cSJacob Pan #define RAPL_CORES (RAPL_CORES_ENERGY_STATUS | RAPL_CORES_POWER_LIMIT)
137889facbeSLen Brown #define	TJMAX_DEFAULT	100
138889facbeSLen Brown 
139889facbeSLen Brown #define MAX(a, b) ((a) > (b) ? (a) : (b))
140103a8feaSLen Brown 
141388e9c81SLen Brown /*
142388e9c81SLen Brown  * buffer size used by sscanf() for added column names
143388e9c81SLen Brown  * Usually truncated to 7 characters, but also handles 18 columns for raw 64-bit counters
144388e9c81SLen Brown  */
145388e9c81SLen Brown #define	NAME_BYTES 20
146388e9c81SLen Brown 
147103a8feaSLen Brown int backwards_count;
148103a8feaSLen Brown char *progname;
149103a8feaSLen Brown 
150c98d5d94SLen Brown cpu_set_t *cpu_present_set, *cpu_affinity_set;
151c98d5d94SLen Brown size_t cpu_present_setsize, cpu_affinity_setsize;
152678a3bd1SLen Brown #define MAX_ADDED_COUNTERS 16
153c98d5d94SLen Brown 
154c98d5d94SLen Brown struct thread_data {
155c98d5d94SLen Brown 	unsigned long long tsc;
156c98d5d94SLen Brown 	unsigned long long aperf;
157c98d5d94SLen Brown 	unsigned long long mperf;
158144b44b1SLen Brown 	unsigned long long c1;
159562a2d37SLen Brown 	unsigned int irq_count;
1601ed51011SLen Brown 	unsigned int smi_count;
161c98d5d94SLen Brown 	unsigned int cpu_id;
162c98d5d94SLen Brown 	unsigned int flags;
163c98d5d94SLen Brown #define CPU_IS_FIRST_THREAD_IN_CORE	0x2
164c98d5d94SLen Brown #define CPU_IS_FIRST_CORE_IN_PACKAGE	0x4
165678a3bd1SLen Brown 	unsigned long long counter[MAX_ADDED_COUNTERS];
166c98d5d94SLen Brown } *thread_even, *thread_odd;
167c98d5d94SLen Brown 
168c98d5d94SLen Brown struct core_data {
169c98d5d94SLen Brown 	unsigned long long c3;
170c98d5d94SLen Brown 	unsigned long long c6;
171c98d5d94SLen Brown 	unsigned long long c7;
1720539ba11SLen Brown 	unsigned long long mc6_us;	/* duplicate as per-core for now, even though per module */
173889facbeSLen Brown 	unsigned int core_temp_c;
174c98d5d94SLen Brown 	unsigned int core_id;
175678a3bd1SLen Brown 	unsigned long long counter[MAX_ADDED_COUNTERS];
176c98d5d94SLen Brown } *core_even, *core_odd;
177c98d5d94SLen Brown 
178c98d5d94SLen Brown struct pkg_data {
179c98d5d94SLen Brown 	unsigned long long pc2;
180c98d5d94SLen Brown 	unsigned long long pc3;
181c98d5d94SLen Brown 	unsigned long long pc6;
182c98d5d94SLen Brown 	unsigned long long pc7;
183ca58710fSKristen Carlson Accardi 	unsigned long long pc8;
184ca58710fSKristen Carlson Accardi 	unsigned long long pc9;
185ca58710fSKristen Carlson Accardi 	unsigned long long pc10;
1860b2bb692SLen Brown 	unsigned long long pkg_wtd_core_c0;
1870b2bb692SLen Brown 	unsigned long long pkg_any_core_c0;
1880b2bb692SLen Brown 	unsigned long long pkg_any_gfxe_c0;
1890b2bb692SLen Brown 	unsigned long long pkg_both_core_gfxe_c0;
1909185e988SLen Brown 	long long gfx_rc6_ms;
19127d47356SLen Brown 	unsigned int gfx_mhz;
192c98d5d94SLen Brown 	unsigned int package_id;
193889facbeSLen Brown 	unsigned int energy_pkg;	/* MSR_PKG_ENERGY_STATUS */
194889facbeSLen Brown 	unsigned int energy_dram;	/* MSR_DRAM_ENERGY_STATUS */
195889facbeSLen Brown 	unsigned int energy_cores;	/* MSR_PP0_ENERGY_STATUS */
196889facbeSLen Brown 	unsigned int energy_gfx;	/* MSR_PP1_ENERGY_STATUS */
197889facbeSLen Brown 	unsigned int rapl_pkg_perf_status;	/* MSR_PKG_PERF_STATUS */
198889facbeSLen Brown 	unsigned int rapl_dram_perf_status;	/* MSR_DRAM_PERF_STATUS */
199889facbeSLen Brown 	unsigned int pkg_temp_c;
200678a3bd1SLen Brown 	unsigned long long counter[MAX_ADDED_COUNTERS];
201c98d5d94SLen Brown } *package_even, *package_odd;
202c98d5d94SLen Brown 
203c98d5d94SLen Brown #define ODD_COUNTERS thread_odd, core_odd, package_odd
204c98d5d94SLen Brown #define EVEN_COUNTERS thread_even, core_even, package_even
205c98d5d94SLen Brown 
206c98d5d94SLen Brown #define GET_THREAD(thread_base, thread_no, core_no, pkg_no) \
207c98d5d94SLen Brown 	(thread_base + (pkg_no) * topo.num_cores_per_pkg * \
208c98d5d94SLen Brown 		topo.num_threads_per_core + \
209c98d5d94SLen Brown 		(core_no) * topo.num_threads_per_core + (thread_no))
210c98d5d94SLen Brown #define GET_CORE(core_base, core_no, pkg_no) \
211c98d5d94SLen Brown 	(core_base + (pkg_no) * topo.num_cores_per_pkg + (core_no))
212c98d5d94SLen Brown #define GET_PKG(pkg_base, pkg_no) (pkg_base + pkg_no)
213c98d5d94SLen Brown 
214388e9c81SLen Brown enum counter_scope {SCOPE_CPU, SCOPE_CORE, SCOPE_PACKAGE};
215388e9c81SLen Brown enum counter_type {COUNTER_CYCLES, COUNTER_SECONDS};
216388e9c81SLen Brown enum counter_format {FORMAT_RAW, FORMAT_DELTA, FORMAT_PERCENT};
217388e9c81SLen Brown 
218388e9c81SLen Brown struct msr_counter {
219388e9c81SLen Brown 	unsigned int msr_num;
220388e9c81SLen Brown 	char name[NAME_BYTES];
221388e9c81SLen Brown 	unsigned int width;
222388e9c81SLen Brown 	enum counter_type type;
223388e9c81SLen Brown 	enum counter_format format;
224388e9c81SLen Brown 	struct msr_counter *next;
225812db3f7SLen Brown 	unsigned int flags;
226812db3f7SLen Brown #define	FLAGS_HIDE	(1 << 0)
227812db3f7SLen Brown #define	FLAGS_SHOW	(1 << 1)
228388e9c81SLen Brown };
229388e9c81SLen Brown 
230388e9c81SLen Brown struct sys_counters {
231678a3bd1SLen Brown 	unsigned int added_thread_counters;
232678a3bd1SLen Brown 	unsigned int added_core_counters;
233678a3bd1SLen Brown 	unsigned int added_package_counters;
234388e9c81SLen Brown 	struct msr_counter *tp;
235388e9c81SLen Brown 	struct msr_counter *cp;
236388e9c81SLen Brown 	struct msr_counter *pp;
237388e9c81SLen Brown } sys;
238388e9c81SLen Brown 
239c98d5d94SLen Brown struct system_summary {
240c98d5d94SLen Brown 	struct thread_data threads;
241c98d5d94SLen Brown 	struct core_data cores;
242c98d5d94SLen Brown 	struct pkg_data packages;
243388e9c81SLen Brown } average;
244c98d5d94SLen Brown 
245c98d5d94SLen Brown 
246c98d5d94SLen Brown struct topo_params {
247c98d5d94SLen Brown 	int num_packages;
248103a8feaSLen Brown 	int num_cpus;
249c98d5d94SLen Brown 	int num_cores;
250c98d5d94SLen Brown 	int max_cpu_num;
251c98d5d94SLen Brown 	int num_cores_per_pkg;
252c98d5d94SLen Brown 	int num_threads_per_core;
253c98d5d94SLen Brown } topo;
254103a8feaSLen Brown 
255c98d5d94SLen Brown struct timeval tv_even, tv_odd, tv_delta;
256103a8feaSLen Brown 
257562a2d37SLen Brown int *irq_column_2_cpu;	/* /proc/interrupts column numbers */
258562a2d37SLen Brown int *irqs_per_cpu;		/* indexed by cpu_num */
259562a2d37SLen Brown 
260c98d5d94SLen Brown void setup_all_buffers(void);
261103a8feaSLen Brown 
262c98d5d94SLen Brown int cpu_is_not_present(int cpu)
263d15cf7c1SLen Brown {
264c98d5d94SLen Brown 	return !CPU_ISSET_S(cpu, cpu_present_setsize, cpu_present_set);
265c98d5d94SLen Brown }
266c98d5d94SLen Brown /*
267c98d5d94SLen Brown  * run func(thread, core, package) in topology order
268c98d5d94SLen Brown  * skip non-present cpus
269c98d5d94SLen Brown  */
270c98d5d94SLen Brown 
271c98d5d94SLen Brown int for_all_cpus(int (func)(struct thread_data *, struct core_data *, struct pkg_data *),
272c98d5d94SLen Brown 	struct thread_data *thread_base, struct core_data *core_base, struct pkg_data *pkg_base)
273c98d5d94SLen Brown {
274c98d5d94SLen Brown 	int retval, pkg_no, core_no, thread_no;
275c98d5d94SLen Brown 
276c98d5d94SLen Brown 	for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
277c98d5d94SLen Brown 		for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
278c98d5d94SLen Brown 			for (thread_no = 0; thread_no <
279c98d5d94SLen Brown 				topo.num_threads_per_core; ++thread_no) {
280c98d5d94SLen Brown 				struct thread_data *t;
281c98d5d94SLen Brown 				struct core_data *c;
282c98d5d94SLen Brown 				struct pkg_data *p;
283c98d5d94SLen Brown 
284c98d5d94SLen Brown 				t = GET_THREAD(thread_base, thread_no, core_no, pkg_no);
285c98d5d94SLen Brown 
286c98d5d94SLen Brown 				if (cpu_is_not_present(t->cpu_id))
287c98d5d94SLen Brown 					continue;
288c98d5d94SLen Brown 
289c98d5d94SLen Brown 				c = GET_CORE(core_base, core_no, pkg_no);
290c98d5d94SLen Brown 				p = GET_PKG(pkg_base, pkg_no);
291c98d5d94SLen Brown 
292c98d5d94SLen Brown 				retval = func(t, c, p);
293c98d5d94SLen Brown 				if (retval)
294c98d5d94SLen Brown 					return retval;
295c98d5d94SLen Brown 			}
296c98d5d94SLen Brown 		}
297c98d5d94SLen Brown 	}
298d15cf7c1SLen Brown 	return 0;
299d15cf7c1SLen Brown }
300d15cf7c1SLen Brown 
30188c3281fSLen Brown int cpu_migrate(int cpu)
30288c3281fSLen Brown {
303c98d5d94SLen Brown 	CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
304c98d5d94SLen Brown 	CPU_SET_S(cpu, cpu_affinity_setsize, cpu_affinity_set);
305c98d5d94SLen Brown 	if (sched_setaffinity(0, cpu_affinity_setsize, cpu_affinity_set) == -1)
30688c3281fSLen Brown 		return -1;
30788c3281fSLen Brown 	else
30888c3281fSLen Brown 		return 0;
30988c3281fSLen Brown }
31036229897SLen Brown int get_msr_fd(int cpu)
311103a8feaSLen Brown {
312103a8feaSLen Brown 	char pathname[32];
313103a8feaSLen Brown 	int fd;
314103a8feaSLen Brown 
31536229897SLen Brown 	fd = fd_percpu[cpu];
31636229897SLen Brown 
31736229897SLen Brown 	if (fd)
31836229897SLen Brown 		return fd;
31936229897SLen Brown 
320103a8feaSLen Brown 	sprintf(pathname, "/dev/cpu/%d/msr", cpu);
321103a8feaSLen Brown 	fd = open(pathname, O_RDONLY);
32215aaa346SLen Brown 	if (fd < 0)
32398481e79SLen Brown 		err(-1, "%s open failed, try chown or chmod +r /dev/cpu/*/msr, or run as root", pathname);
324103a8feaSLen Brown 
32536229897SLen Brown 	fd_percpu[cpu] = fd;
32636229897SLen Brown 
32736229897SLen Brown 	return fd;
32836229897SLen Brown }
32936229897SLen Brown 
33036229897SLen Brown int get_msr(int cpu, off_t offset, unsigned long long *msr)
33136229897SLen Brown {
33236229897SLen Brown 	ssize_t retval;
33336229897SLen Brown 
33436229897SLen Brown 	retval = pread(get_msr_fd(cpu), msr, sizeof(*msr), offset);
33515aaa346SLen Brown 
33698481e79SLen Brown 	if (retval != sizeof *msr)
337cf4cbe53SLen Brown 		err(-1, "cpu%d: msr offset 0x%llx read failed", cpu, (unsigned long long)offset);
33815aaa346SLen Brown 
33915aaa346SLen Brown 	return 0;
340103a8feaSLen Brown }
341103a8feaSLen Brown 
342fc04cc67SLen Brown /*
343812db3f7SLen Brown  * Each string in this array is compared in --show and --hide cmdline.
344812db3f7SLen Brown  * Thus, strings that are proper sub-sets must follow their more specific peers.
345fc04cc67SLen Brown  */
346812db3f7SLen Brown struct msr_counter bic[] = {
347812db3f7SLen Brown 	{ 0x0, "Package" },
348812db3f7SLen Brown 	{ 0x0, "Avg_MHz" },
349812db3f7SLen Brown 	{ 0x0, "Bzy_MHz" },
350812db3f7SLen Brown 	{ 0x0, "TSC_MHz" },
351812db3f7SLen Brown 	{ 0x0, "IRQ" },
352812db3f7SLen Brown 	{ 0x0, "SMI", 32, 0, FORMAT_DELTA, NULL},
353812db3f7SLen Brown 	{ 0x0, "Busy%" },
354812db3f7SLen Brown 	{ 0x0, "CPU%c1" },
355812db3f7SLen Brown 	{ 0x0, "CPU%c3" },
356812db3f7SLen Brown 	{ 0x0, "CPU%c6" },
357812db3f7SLen Brown 	{ 0x0, "CPU%c7" },
358812db3f7SLen Brown 	{ 0x0, "ThreadC" },
359812db3f7SLen Brown 	{ 0x0, "CoreTmp" },
360812db3f7SLen Brown 	{ 0x0, "CoreCnt" },
361812db3f7SLen Brown 	{ 0x0, "PkgTmp" },
362812db3f7SLen Brown 	{ 0x0, "GFX%rc6" },
363812db3f7SLen Brown 	{ 0x0, "GFXMHz" },
364812db3f7SLen Brown 	{ 0x0, "Pkg%pc2" },
365812db3f7SLen Brown 	{ 0x0, "Pkg%pc3" },
366812db3f7SLen Brown 	{ 0x0, "Pkg%pc6" },
367812db3f7SLen Brown 	{ 0x0, "Pkg%pc7" },
368812db3f7SLen Brown 	{ 0x0, "PkgWatt" },
369812db3f7SLen Brown 	{ 0x0, "CorWatt" },
370812db3f7SLen Brown 	{ 0x0, "GFXWatt" },
371812db3f7SLen Brown 	{ 0x0, "PkgCnt" },
372812db3f7SLen Brown 	{ 0x0, "RAMWatt" },
373812db3f7SLen Brown 	{ 0x0, "PKG_%" },
374812db3f7SLen Brown 	{ 0x0, "RAM_%" },
375812db3f7SLen Brown 	{ 0x0, "Pkg_J" },
376812db3f7SLen Brown 	{ 0x0, "Cor_J" },
377812db3f7SLen Brown 	{ 0x0, "GFX_J" },
378812db3f7SLen Brown 	{ 0x0, "RAM_J" },
379812db3f7SLen Brown 	{ 0x0, "Core" },
380812db3f7SLen Brown 	{ 0x0, "CPU" },
3810539ba11SLen Brown 	{ 0x0, "Mod%c6" },
382812db3f7SLen Brown };
383812db3f7SLen Brown 
384812db3f7SLen Brown #define MAX_BIC (sizeof(bic) / sizeof(struct msr_counter))
385812db3f7SLen Brown #define	BIC_Package	(1ULL << 0)
386812db3f7SLen Brown #define	BIC_Avg_MHz	(1ULL << 1)
387812db3f7SLen Brown #define	BIC_Bzy_MHz	(1ULL << 2)
388812db3f7SLen Brown #define	BIC_TSC_MHz	(1ULL << 3)
389812db3f7SLen Brown #define	BIC_IRQ		(1ULL << 4)
390812db3f7SLen Brown #define	BIC_SMI		(1ULL << 5)
391812db3f7SLen Brown #define	BIC_Busy	(1ULL << 6)
392812db3f7SLen Brown #define	BIC_CPU_c1	(1ULL << 7)
393812db3f7SLen Brown #define	BIC_CPU_c3	(1ULL << 8)
394812db3f7SLen Brown #define	BIC_CPU_c6	(1ULL << 9)
395812db3f7SLen Brown #define	BIC_CPU_c7	(1ULL << 10)
396812db3f7SLen Brown #define	BIC_ThreadC	(1ULL << 11)
397812db3f7SLen Brown #define	BIC_CoreTmp	(1ULL << 12)
398812db3f7SLen Brown #define	BIC_CoreCnt	(1ULL << 13)
399812db3f7SLen Brown #define	BIC_PkgTmp	(1ULL << 14)
400812db3f7SLen Brown #define	BIC_GFX_rc6	(1ULL << 15)
401812db3f7SLen Brown #define	BIC_GFXMHz	(1ULL << 16)
402812db3f7SLen Brown #define	BIC_Pkgpc2	(1ULL << 17)
403812db3f7SLen Brown #define	BIC_Pkgpc3	(1ULL << 18)
404812db3f7SLen Brown #define	BIC_Pkgpc6	(1ULL << 19)
405812db3f7SLen Brown #define	BIC_Pkgpc7	(1ULL << 20)
406812db3f7SLen Brown #define	BIC_PkgWatt	(1ULL << 21)
407812db3f7SLen Brown #define	BIC_CorWatt	(1ULL << 22)
408812db3f7SLen Brown #define	BIC_GFXWatt	(1ULL << 23)
409812db3f7SLen Brown #define	BIC_PkgCnt	(1ULL << 24)
410812db3f7SLen Brown #define	BIC_RAMWatt	(1ULL << 27)
411812db3f7SLen Brown #define	BIC_PKG__	(1ULL << 28)
412812db3f7SLen Brown #define	BIC_RAM__	(1ULL << 29)
413812db3f7SLen Brown #define	BIC_Pkg_J	(1ULL << 30)
414812db3f7SLen Brown #define	BIC_Cor_J	(1ULL << 31)
415812db3f7SLen Brown #define	BIC_GFX_J	(1ULL << 30)
416812db3f7SLen Brown #define	BIC_RAM_J	(1ULL << 31)
417812db3f7SLen Brown #define	BIC_Core	(1ULL << 32)
418812db3f7SLen Brown #define	BIC_CPU		(1ULL << 33)
4190539ba11SLen Brown #define	BIC_Mod_c6	(1ULL << 34)
420812db3f7SLen Brown 
421812db3f7SLen Brown unsigned long long bic_enabled = 0xFFFFFFFFFFFFFFFFULL;
422812db3f7SLen Brown unsigned long long bic_present;
423812db3f7SLen Brown 
424812db3f7SLen Brown #define DO_BIC(COUNTER_NAME) (bic_enabled & bic_present & COUNTER_NAME)
425812db3f7SLen Brown #define BIC_PRESENT(COUNTER_BIT) (bic_present |= COUNTER_BIT)
426812db3f7SLen Brown 
427812db3f7SLen Brown /*
428812db3f7SLen Brown  * bic_lookup
429812db3f7SLen Brown  * for all the strings in comma separate name_list,
430812db3f7SLen Brown  * set the approprate bit in return value.
431812db3f7SLen Brown  */
432812db3f7SLen Brown unsigned long long bic_lookup(char *name_list)
433812db3f7SLen Brown {
434812db3f7SLen Brown 	int i;
435812db3f7SLen Brown 	unsigned long long retval = 0;
436812db3f7SLen Brown 
437812db3f7SLen Brown 	while (name_list) {
438812db3f7SLen Brown 		char *comma;
439812db3f7SLen Brown 
440812db3f7SLen Brown 		comma = strchr(name_list, ',');
441812db3f7SLen Brown 
442812db3f7SLen Brown 		if (comma)
443812db3f7SLen Brown 			*comma = '\0';
444812db3f7SLen Brown 
445812db3f7SLen Brown 		for (i = 0; i < MAX_BIC; ++i) {
446812db3f7SLen Brown 			if (!strcmp(name_list, bic[i].name)) {
447812db3f7SLen Brown 				retval |= (1ULL << i);
448812db3f7SLen Brown 				break;
449812db3f7SLen Brown 			}
450812db3f7SLen Brown 		}
451812db3f7SLen Brown 		if (i == MAX_BIC) {
452812db3f7SLen Brown 			fprintf(stderr, "Invalid counter name: %s\n", name_list);
453812db3f7SLen Brown 			exit(-1);
454812db3f7SLen Brown 		}
455812db3f7SLen Brown 
456812db3f7SLen Brown 		name_list = comma;
457812db3f7SLen Brown 		if (name_list)
458812db3f7SLen Brown 			name_list++;
459812db3f7SLen Brown 
460812db3f7SLen Brown 	}
461812db3f7SLen Brown 	return retval;
462812db3f7SLen Brown }
463fc04cc67SLen Brown 
464a829eb4dSLen Brown void print_header(void)
465103a8feaSLen Brown {
466388e9c81SLen Brown 	struct msr_counter *mp;
467388e9c81SLen Brown 
468812db3f7SLen Brown 	if (DO_BIC(BIC_Package))
4693d109de2SLen Brown 		outp += sprintf(outp, "\tPackage");
470812db3f7SLen Brown 	if (DO_BIC(BIC_Core))
4713d109de2SLen Brown 		outp += sprintf(outp, "\tCore");
472812db3f7SLen Brown 	if (DO_BIC(BIC_CPU))
4733d109de2SLen Brown 		outp += sprintf(outp, "\tCPU");
474812db3f7SLen Brown 	if (DO_BIC(BIC_Avg_MHz))
4753d109de2SLen Brown 		outp += sprintf(outp, "\tAvg_MHz");
476812db3f7SLen Brown 	if (DO_BIC(BIC_Busy))
4773d109de2SLen Brown 		outp += sprintf(outp, "\tBusy%%");
478812db3f7SLen Brown 	if (DO_BIC(BIC_Bzy_MHz))
4793d109de2SLen Brown 		outp += sprintf(outp, "\tBzy_MHz");
480812db3f7SLen Brown 	if (DO_BIC(BIC_TSC_MHz))
4813d109de2SLen Brown 		outp += sprintf(outp, "\tTSC_MHz");
4821cc21f7bSLen Brown 
483812db3f7SLen Brown 	if (DO_BIC(BIC_IRQ))
4843d109de2SLen Brown 		outp += sprintf(outp, "\tIRQ");
485812db3f7SLen Brown 	if (DO_BIC(BIC_SMI))
4863d109de2SLen Brown 		outp += sprintf(outp, "\tSMI");
4871cc21f7bSLen Brown 
488812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c1))
4893d109de2SLen Brown 		outp += sprintf(outp, "\tCPU%%c1");
490889facbeSLen Brown 
491388e9c81SLen Brown 	for (mp = sys.tp; mp; mp = mp->next) {
492388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
493388e9c81SLen Brown 			if (mp->width == 64)
494388e9c81SLen Brown 				outp += sprintf(outp, "\t%18.18s", mp->name);
495388e9c81SLen Brown 			else
496388e9c81SLen Brown 				outp += sprintf(outp, "\t%10.10s", mp->name);
497388e9c81SLen Brown 		} else {
498388e9c81SLen Brown 			outp += sprintf(outp, "\t%-7.7s", mp->name);
499388e9c81SLen Brown 		}
500388e9c81SLen Brown 	}
501388e9c81SLen Brown 
502812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c3) && !do_slm_cstates && !do_knl_cstates)
503678a3bd1SLen Brown 		outp += sprintf(outp, "\tCPU%%c3");
504812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c6))
505678a3bd1SLen Brown 		outp += sprintf(outp, "\tCPU%%c6");
506812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c7))
507678a3bd1SLen Brown 		outp += sprintf(outp, "\tCPU%%c7");
508678a3bd1SLen Brown 
5090539ba11SLen Brown 	if (DO_BIC(BIC_Mod_c6))
5100539ba11SLen Brown 		outp += sprintf(outp, "\tMod%%c6");
511678a3bd1SLen Brown 
512812db3f7SLen Brown 	if (DO_BIC(BIC_CoreTmp))
5133d109de2SLen Brown 		outp += sprintf(outp, "\tCoreTmp");
514388e9c81SLen Brown 
515388e9c81SLen Brown 	for (mp = sys.cp; mp; mp = mp->next) {
516388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
517388e9c81SLen Brown 			if (mp->width == 64)
518388e9c81SLen Brown 				outp += sprintf(outp, "\t%18.18s", mp->name);
519388e9c81SLen Brown 			else
520388e9c81SLen Brown 				outp += sprintf(outp, "\t%10.10s", mp->name);
521388e9c81SLen Brown 		} else {
522388e9c81SLen Brown 			outp += sprintf(outp, "\t%-7.7s", mp->name);
523388e9c81SLen Brown 		}
524388e9c81SLen Brown 	}
525388e9c81SLen Brown 
526812db3f7SLen Brown 	if (DO_BIC(BIC_PkgTmp))
5273d109de2SLen Brown 		outp += sprintf(outp, "\tPkgTmp");
528889facbeSLen Brown 
529812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_rc6))
5303d109de2SLen Brown 		outp += sprintf(outp, "\tGFX%%rc6");
531fdf676e5SLen Brown 
532812db3f7SLen Brown 	if (DO_BIC(BIC_GFXMHz))
5333d109de2SLen Brown 		outp += sprintf(outp, "\tGFXMHz");
53427d47356SLen Brown 
5350b2bb692SLen Brown 	if (do_skl_residency) {
5363d109de2SLen Brown 		outp += sprintf(outp, "\tTotl%%C0");
5373d109de2SLen Brown 		outp += sprintf(outp, "\tAny%%C0");
5383d109de2SLen Brown 		outp += sprintf(outp, "\tGFX%%C0");
5393d109de2SLen Brown 		outp += sprintf(outp, "\tCPUGFX%%");
5400b2bb692SLen Brown 	}
5410b2bb692SLen Brown 
542ee7e38e3SLen Brown 	if (do_pc2)
5433d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc2");
544ee7e38e3SLen Brown 	if (do_pc3)
5453d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc3");
546ee7e38e3SLen Brown 	if (do_pc6)
5473d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc6");
548ee7e38e3SLen Brown 	if (do_pc7)
5493d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc7");
550ca58710fSKristen Carlson Accardi 	if (do_c8_c9_c10) {
5513d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc8");
5523d109de2SLen Brown 		outp += sprintf(outp, "\tPkg%%pc9");
5533d109de2SLen Brown 		outp += sprintf(outp, "\tPk%%pc10");
554ca58710fSKristen Carlson Accardi 	}
555103a8feaSLen Brown 
5565c56be9aSDirk Brandewie 	if (do_rapl && !rapl_joules) {
557812db3f7SLen Brown 		if (DO_BIC(BIC_PkgWatt))
5583d109de2SLen Brown 			outp += sprintf(outp, "\tPkgWatt");
559812db3f7SLen Brown 		if (DO_BIC(BIC_CorWatt))
5603d109de2SLen Brown 			outp += sprintf(outp, "\tCorWatt");
561812db3f7SLen Brown 		if (DO_BIC(BIC_GFXWatt))
5623d109de2SLen Brown 			outp += sprintf(outp, "\tGFXWatt");
563812db3f7SLen Brown 		if (DO_BIC(BIC_RAMWatt))
5643d109de2SLen Brown 			outp += sprintf(outp, "\tRAMWatt");
565812db3f7SLen Brown 		if (DO_BIC(BIC_PKG__))
5663d109de2SLen Brown 			outp += sprintf(outp, "\tPKG_%%");
567812db3f7SLen Brown 		if (DO_BIC(BIC_RAM__))
5683d109de2SLen Brown 			outp += sprintf(outp, "\tRAM_%%");
569d7899447SLen Brown 	} else if (do_rapl && rapl_joules) {
570812db3f7SLen Brown 		if (DO_BIC(BIC_Pkg_J))
5713d109de2SLen Brown 			outp += sprintf(outp, "\tPkg_J");
572812db3f7SLen Brown 		if (DO_BIC(BIC_Cor_J))
5733d109de2SLen Brown 			outp += sprintf(outp, "\tCor_J");
574812db3f7SLen Brown 		if (DO_BIC(BIC_GFX_J))
5753d109de2SLen Brown 			outp += sprintf(outp, "\tGFX_J");
576812db3f7SLen Brown 		if (DO_BIC(BIC_RAM_J))
5773d109de2SLen Brown 			outp += sprintf(outp, "\tRAM_J");
578812db3f7SLen Brown 		if (DO_BIC(BIC_PKG__))
5793d109de2SLen Brown 			outp += sprintf(outp, "\tPKG_%%");
580812db3f7SLen Brown 		if (DO_BIC(BIC_RAM__))
5813d109de2SLen Brown 			outp += sprintf(outp, "\tRAM_%%");
5825c56be9aSDirk Brandewie 	}
583388e9c81SLen Brown 	for (mp = sys.pp; mp; mp = mp->next) {
584388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
585388e9c81SLen Brown 			if (mp->width == 64)
586388e9c81SLen Brown 				outp += sprintf(outp, "\t%18.18s", mp->name);
587388e9c81SLen Brown 			else
588388e9c81SLen Brown 				outp += sprintf(outp, "\t%10.10s", mp->name);
589388e9c81SLen Brown 		} else {
590388e9c81SLen Brown 			outp += sprintf(outp, "\t%-7.7s", mp->name);
591388e9c81SLen Brown 		}
592388e9c81SLen Brown 	}
593388e9c81SLen Brown 
594c98d5d94SLen Brown 	outp += sprintf(outp, "\n");
595103a8feaSLen Brown }
596103a8feaSLen Brown 
597c98d5d94SLen Brown int dump_counters(struct thread_data *t, struct core_data *c,
598c98d5d94SLen Brown 	struct pkg_data *p)
599103a8feaSLen Brown {
600388e9c81SLen Brown 	int i;
601388e9c81SLen Brown 	struct msr_counter *mp;
602388e9c81SLen Brown 
6033b4d5c7fSAndy Shevchenko 	outp += sprintf(outp, "t %p, c %p, p %p\n", t, c, p);
604c98d5d94SLen Brown 
605c98d5d94SLen Brown 	if (t) {
6063b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "CPU: %d flags 0x%x\n",
6073b4d5c7fSAndy Shevchenko 			t->cpu_id, t->flags);
6083b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "TSC: %016llX\n", t->tsc);
6093b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "aperf: %016llX\n", t->aperf);
6103b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "mperf: %016llX\n", t->mperf);
6113b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c1: %016llX\n", t->c1);
6126886fee4SLen Brown 
613812db3f7SLen Brown 		if (DO_BIC(BIC_IRQ))
614562a2d37SLen Brown 			outp += sprintf(outp, "IRQ: %08X\n", t->irq_count);
615812db3f7SLen Brown 		if (DO_BIC(BIC_SMI))
6163b4d5c7fSAndy Shevchenko 			outp += sprintf(outp, "SMI: %08X\n", t->smi_count);
617388e9c81SLen Brown 
618388e9c81SLen Brown 		for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
619388e9c81SLen Brown 			outp += sprintf(outp, "tADDED [%d] msr0x%x: %08llX\n",
620388e9c81SLen Brown 				i, mp->msr_num, t->counter[i]);
621388e9c81SLen Brown 		}
622103a8feaSLen Brown 	}
623103a8feaSLen Brown 
624c98d5d94SLen Brown 	if (c) {
6253b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "core: %d\n", c->core_id);
6263b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c3: %016llX\n", c->c3);
6273b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c6: %016llX\n", c->c6);
6283b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c7: %016llX\n", c->c7);
6293b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "DTS: %dC\n", c->core_temp_c);
630388e9c81SLen Brown 
631388e9c81SLen Brown 		for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
632388e9c81SLen Brown 			outp += sprintf(outp, "cADDED [%d] msr0x%x: %08llX\n",
633388e9c81SLen Brown 				i, mp->msr_num, c->counter[i]);
634388e9c81SLen Brown 		}
6350539ba11SLen Brown 		outp += sprintf(outp, "mc6_us: %016llX\n", c->mc6_us);
636c98d5d94SLen Brown 	}
637103a8feaSLen Brown 
638c98d5d94SLen Brown 	if (p) {
6393b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "package: %d\n", p->package_id);
6400b2bb692SLen Brown 
6410b2bb692SLen Brown 		outp += sprintf(outp, "Weighted cores: %016llX\n", p->pkg_wtd_core_c0);
6420b2bb692SLen Brown 		outp += sprintf(outp, "Any cores: %016llX\n", p->pkg_any_core_c0);
6430b2bb692SLen Brown 		outp += sprintf(outp, "Any GFX: %016llX\n", p->pkg_any_gfxe_c0);
6440b2bb692SLen Brown 		outp += sprintf(outp, "CPU + GFX: %016llX\n", p->pkg_both_core_gfxe_c0);
6450b2bb692SLen Brown 
6463b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc2: %016llX\n", p->pc2);
647ee7e38e3SLen Brown 		if (do_pc3)
6483b4d5c7fSAndy Shevchenko 			outp += sprintf(outp, "pc3: %016llX\n", p->pc3);
649ee7e38e3SLen Brown 		if (do_pc6)
6503b4d5c7fSAndy Shevchenko 			outp += sprintf(outp, "pc6: %016llX\n", p->pc6);
651ee7e38e3SLen Brown 		if (do_pc7)
6523b4d5c7fSAndy Shevchenko 			outp += sprintf(outp, "pc7: %016llX\n", p->pc7);
6533b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc8: %016llX\n", p->pc8);
6543b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc9: %016llX\n", p->pc9);
6553b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc10: %016llX\n", p->pc10);
6563b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules PKG: %0X\n", p->energy_pkg);
6573b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules COR: %0X\n", p->energy_cores);
6583b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules GFX: %0X\n", p->energy_gfx);
6593b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules RAM: %0X\n", p->energy_dram);
6603b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Throttle PKG: %0X\n",
6613b4d5c7fSAndy Shevchenko 			p->rapl_pkg_perf_status);
6623b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Throttle RAM: %0X\n",
6633b4d5c7fSAndy Shevchenko 			p->rapl_dram_perf_status);
6643b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "PTM: %dC\n", p->pkg_temp_c);
665388e9c81SLen Brown 
666388e9c81SLen Brown 		for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
667388e9c81SLen Brown 			outp += sprintf(outp, "pADDED [%d] msr0x%x: %08llX\n",
668388e9c81SLen Brown 				i, mp->msr_num, p->counter[i]);
669388e9c81SLen Brown 		}
670c98d5d94SLen Brown 	}
6713b4d5c7fSAndy Shevchenko 
6723b4d5c7fSAndy Shevchenko 	outp += sprintf(outp, "\n");
6733b4d5c7fSAndy Shevchenko 
674c98d5d94SLen Brown 	return 0;
675103a8feaSLen Brown }
676103a8feaSLen Brown 
677e23da037SLen Brown /*
678e23da037SLen Brown  * column formatting convention & formats
679e23da037SLen Brown  */
680c98d5d94SLen Brown int format_counters(struct thread_data *t, struct core_data *c,
681c98d5d94SLen Brown 	struct pkg_data *p)
682103a8feaSLen Brown {
683103a8feaSLen Brown 	double interval_float;
684fc04cc67SLen Brown 	char *fmt8;
685388e9c81SLen Brown 	int i;
686388e9c81SLen Brown 	struct msr_counter *mp;
687103a8feaSLen Brown 
688c98d5d94SLen Brown 	 /* if showing only 1st thread in core and this isn't one, bail out */
689c98d5d94SLen Brown 	if (show_core_only && !(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
690c98d5d94SLen Brown 		return 0;
691c98d5d94SLen Brown 
692c98d5d94SLen Brown 	 /* if showing only 1st thread in pkg and this isn't one, bail out */
693c98d5d94SLen Brown 	if (show_pkg_only && !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
694c98d5d94SLen Brown 		return 0;
695c98d5d94SLen Brown 
696103a8feaSLen Brown 	interval_float = tv_delta.tv_sec + tv_delta.tv_usec/1000000.0;
697103a8feaSLen Brown 
698c98d5d94SLen Brown 	/* topo columns, print blanks on 1st (average) line */
699c98d5d94SLen Brown 	if (t == &average.threads) {
700812db3f7SLen Brown 		if (DO_BIC(BIC_Package))
7013d109de2SLen Brown 			outp += sprintf(outp, "\t-");
702812db3f7SLen Brown 		if (DO_BIC(BIC_Core))
7033d109de2SLen Brown 			outp += sprintf(outp, "\t-");
704812db3f7SLen Brown 		if (DO_BIC(BIC_CPU))
7053d109de2SLen Brown 			outp += sprintf(outp, "\t-");
706103a8feaSLen Brown 	} else {
707812db3f7SLen Brown 		if (DO_BIC(BIC_Package)) {
708c98d5d94SLen Brown 			if (p)
7093d109de2SLen Brown 				outp += sprintf(outp, "\t%d", p->package_id);
710c98d5d94SLen Brown 			else
7113d109de2SLen Brown 				outp += sprintf(outp, "\t-");
712c98d5d94SLen Brown 		}
713812db3f7SLen Brown 		if (DO_BIC(BIC_Core)) {
714c98d5d94SLen Brown 			if (c)
7153d109de2SLen Brown 				outp += sprintf(outp, "\t%d", c->core_id);
716c98d5d94SLen Brown 			else
7173d109de2SLen Brown 				outp += sprintf(outp, "\t-");
718c98d5d94SLen Brown 		}
719812db3f7SLen Brown 		if (DO_BIC(BIC_CPU))
7203d109de2SLen Brown 			outp += sprintf(outp, "\t%d", t->cpu_id);
721103a8feaSLen Brown 	}
722fc04cc67SLen Brown 
723812db3f7SLen Brown 	if (DO_BIC(BIC_Avg_MHz))
7243d109de2SLen Brown 		outp += sprintf(outp, "\t%.0f",
725fc04cc67SLen Brown 			1.0 / units * t->aperf / interval_float);
726fc04cc67SLen Brown 
727812db3f7SLen Brown 	if (DO_BIC(BIC_Busy))
7283d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * t->mperf/t->tsc/tsc_tweak);
729103a8feaSLen Brown 
730812db3f7SLen Brown 	if (DO_BIC(BIC_Bzy_MHz)) {
73121ed5574SLen Brown 		if (has_base_hz)
7323d109de2SLen Brown 			outp += sprintf(outp, "\t%.0f", base_hz / units * t->aperf / t->mperf);
73321ed5574SLen Brown 		else
7343d109de2SLen Brown 			outp += sprintf(outp, "\t%.0f",
73521ed5574SLen Brown 				1.0 * t->tsc / units * t->aperf / t->mperf / interval_float);
73621ed5574SLen Brown 	}
737103a8feaSLen Brown 
738812db3f7SLen Brown 	if (DO_BIC(BIC_TSC_MHz))
7393d109de2SLen Brown 		outp += sprintf(outp, "\t%.0f", 1.0 * t->tsc/units/interval_float);
740103a8feaSLen Brown 
741562a2d37SLen Brown 	/* IRQ */
742812db3f7SLen Brown 	if (DO_BIC(BIC_IRQ))
7433d109de2SLen Brown 		outp += sprintf(outp, "\t%d", t->irq_count);
744562a2d37SLen Brown 
7451cc21f7bSLen Brown 	/* SMI */
746812db3f7SLen Brown 	if (DO_BIC(BIC_SMI))
7473d109de2SLen Brown 		outp += sprintf(outp, "\t%d", t->smi_count);
7481cc21f7bSLen Brown 
749678a3bd1SLen Brown 	/* C1 */
750812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c1))
7513d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * t->c1/t->tsc);
752c98d5d94SLen Brown 
753678a3bd1SLen Brown 	/* Added counters */
754678a3bd1SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
755678a3bd1SLen Brown 		if (mp->format == FORMAT_RAW) {
756678a3bd1SLen Brown 			if (mp->width == 32)
757678a3bd1SLen Brown 				outp += sprintf(outp, "\t0x%08lx", (unsigned long) t->counter[i]);
758678a3bd1SLen Brown 			else
759678a3bd1SLen Brown 				outp += sprintf(outp, "\t0x%016llx", t->counter[i]);
760678a3bd1SLen Brown 		} else if (mp->format == FORMAT_DELTA) {
761678a3bd1SLen Brown 			outp += sprintf(outp, "\t%lld", t->counter[i]);
762678a3bd1SLen Brown 		} else if (mp->format == FORMAT_PERCENT) {
763678a3bd1SLen Brown 			outp += sprintf(outp, "\t%.2f", 100.0 * t->counter[i]/t->tsc);
764678a3bd1SLen Brown 		}
765678a3bd1SLen Brown 	}
766678a3bd1SLen Brown 
767c98d5d94SLen Brown 	/* print per-core data only for 1st thread in core */
768c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
769c98d5d94SLen Brown 		goto done;
770c98d5d94SLen Brown 
771812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c3) && !do_slm_cstates && !do_knl_cstates)
7723d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * c->c3/t->tsc);
773812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c6))
7743d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * c->c6/t->tsc);
775812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c7))
7763d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * c->c7/t->tsc);
777c98d5d94SLen Brown 
7780539ba11SLen Brown 	/* Mod%c6 */
7790539ba11SLen Brown 	if (DO_BIC(BIC_Mod_c6))
7800539ba11SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * c->mc6_us / t->tsc);
7810539ba11SLen Brown 
782812db3f7SLen Brown 	if (DO_BIC(BIC_CoreTmp))
7833d109de2SLen Brown 		outp += sprintf(outp, "\t%d", c->core_temp_c);
784889facbeSLen Brown 
785388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
786388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
787388e9c81SLen Brown 			if (mp->width == 32)
788388e9c81SLen Brown 				outp += sprintf(outp, "\t0x%08lx", (unsigned long) c->counter[i]);
789388e9c81SLen Brown 			else
790388e9c81SLen Brown 				outp += sprintf(outp, "\t0x%016llx", c->counter[i]);
791388e9c81SLen Brown 		} else if (mp->format == FORMAT_DELTA) {
792678a3bd1SLen Brown 			outp += sprintf(outp, "\t%lld", c->counter[i]);
793388e9c81SLen Brown 		} else if (mp->format == FORMAT_PERCENT) {
794388e9c81SLen Brown 			outp += sprintf(outp, "\t%.2f", 100.0 * c->counter[i]/t->tsc);
795388e9c81SLen Brown 		}
796388e9c81SLen Brown 	}
797388e9c81SLen Brown 
798c98d5d94SLen Brown 	/* print per-package data only for 1st core in package */
799c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
800c98d5d94SLen Brown 		goto done;
801c98d5d94SLen Brown 
8020b2bb692SLen Brown 	/* PkgTmp */
803812db3f7SLen Brown 	if (DO_BIC(BIC_PkgTmp))
8043d109de2SLen Brown 		outp += sprintf(outp, "\t%d", p->pkg_temp_c);
805889facbeSLen Brown 
806fdf676e5SLen Brown 	/* GFXrc6 */
807812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_rc6)) {
808ba3dec99SLen Brown 		if (p->gfx_rc6_ms == -1) {	/* detect GFX counter reset */
8093d109de2SLen Brown 			outp += sprintf(outp, "\t**.**");
8109185e988SLen Brown 		} else {
8113d109de2SLen Brown 			outp += sprintf(outp, "\t%.2f",
8129185e988SLen Brown 				p->gfx_rc6_ms / 10.0 / interval_float);
8139185e988SLen Brown 		}
8149185e988SLen Brown 	}
815fdf676e5SLen Brown 
81627d47356SLen Brown 	/* GFXMHz */
817812db3f7SLen Brown 	if (DO_BIC(BIC_GFXMHz))
8183d109de2SLen Brown 		outp += sprintf(outp, "\t%d", p->gfx_mhz);
81927d47356SLen Brown 
8200b2bb692SLen Brown 	/* Totl%C0, Any%C0 GFX%C0 CPUGFX% */
8210b2bb692SLen Brown 	if (do_skl_residency) {
8223d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_wtd_core_c0/t->tsc);
8233d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_any_core_c0/t->tsc);
8243d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_any_gfxe_c0/t->tsc);
8253d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_both_core_gfxe_c0/t->tsc);
8260b2bb692SLen Brown 	}
8270b2bb692SLen Brown 
828ee7e38e3SLen Brown 	if (do_pc2)
8293d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc2/t->tsc);
830ee7e38e3SLen Brown 	if (do_pc3)
8313d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc3/t->tsc);
832ee7e38e3SLen Brown 	if (do_pc6)
8333d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc6/t->tsc);
834ee7e38e3SLen Brown 	if (do_pc7)
8353d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc7/t->tsc);
836ca58710fSKristen Carlson Accardi 	if (do_c8_c9_c10) {
8373d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc8/t->tsc);
8383d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc9/t->tsc);
8393d109de2SLen Brown 		outp += sprintf(outp, "\t%.2f", 100.0 * p->pc10/t->tsc);
840ca58710fSKristen Carlson Accardi 	}
841889facbeSLen Brown 
842889facbeSLen Brown 	/*
843889facbeSLen Brown  	 * If measurement interval exceeds minimum RAPL Joule Counter range,
844889facbeSLen Brown  	 * indicate that results are suspect by printing "**" in fraction place.
845889facbeSLen Brown  	 */
846fc04cc67SLen Brown 	if (interval_float < rapl_joule_counter_range)
8473d109de2SLen Brown 		fmt8 = "\t%.2f";
848fc04cc67SLen Brown 	else
849fc04cc67SLen Brown 		fmt8 = "%6.0f**";
850889facbeSLen Brown 
851812db3f7SLen Brown 	if (DO_BIC(BIC_PkgWatt))
852fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, p->energy_pkg * rapl_energy_units / interval_float);
853812db3f7SLen Brown 	if (DO_BIC(BIC_CorWatt))
854fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, p->energy_cores * rapl_energy_units / interval_float);
855812db3f7SLen Brown 	if (DO_BIC(BIC_GFXWatt))
856fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, p->energy_gfx * rapl_energy_units / interval_float);
857812db3f7SLen Brown 	if (DO_BIC(BIC_RAMWatt))
85840ee8e3bSAndrey Semin 		outp += sprintf(outp, fmt8, p->energy_dram * rapl_dram_energy_units / interval_float);
859812db3f7SLen Brown 	if (DO_BIC(BIC_Pkg_J))
860812db3f7SLen Brown 		outp += sprintf(outp, fmt8, p->energy_pkg * rapl_energy_units);
861812db3f7SLen Brown 	if (DO_BIC(BIC_Cor_J))
862812db3f7SLen Brown 		outp += sprintf(outp, fmt8, p->energy_cores * rapl_energy_units);
863812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_J))
864812db3f7SLen Brown 		outp += sprintf(outp, fmt8, p->energy_gfx * rapl_energy_units);
865812db3f7SLen Brown 	if (DO_BIC(BIC_RAM_J))
866812db3f7SLen Brown 		outp += sprintf(outp, fmt8, p->energy_dram * rapl_dram_energy_units);
867812db3f7SLen Brown 	if (DO_BIC(BIC_PKG__))
868fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, 100.0 * p->rapl_pkg_perf_status * rapl_time_units / interval_float);
869812db3f7SLen Brown 	if (DO_BIC(BIC_RAM__))
870fc04cc67SLen Brown 		outp += sprintf(outp, fmt8, 100.0 * p->rapl_dram_perf_status * rapl_time_units / interval_float);
871812db3f7SLen Brown 
872388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
873388e9c81SLen Brown 		if (mp->format == FORMAT_RAW) {
874388e9c81SLen Brown 			if (mp->width == 32)
875388e9c81SLen Brown 				outp += sprintf(outp, "\t0x%08lx", (unsigned long) p->counter[i]);
876388e9c81SLen Brown 			else
877388e9c81SLen Brown 				outp += sprintf(outp, "\t0x%016llx", p->counter[i]);
878388e9c81SLen Brown 		} else if (mp->format == FORMAT_DELTA) {
879678a3bd1SLen Brown 			outp += sprintf(outp, "\t%lld", p->counter[i]);
880388e9c81SLen Brown 		} else if (mp->format == FORMAT_PERCENT) {
881388e9c81SLen Brown 			outp += sprintf(outp, "\t%.2f", 100.0 * p->counter[i]/t->tsc);
882388e9c81SLen Brown 		}
883388e9c81SLen Brown 	}
884388e9c81SLen Brown 
885c98d5d94SLen Brown done:
886c98d5d94SLen Brown 	outp += sprintf(outp, "\n");
887c98d5d94SLen Brown 
888c98d5d94SLen Brown 	return 0;
889103a8feaSLen Brown }
890103a8feaSLen Brown 
891b7d8c148SLen Brown void flush_output_stdout(void)
892103a8feaSLen Brown {
893b7d8c148SLen Brown 	FILE *filep;
894b7d8c148SLen Brown 
895b7d8c148SLen Brown 	if (outf == stderr)
896b7d8c148SLen Brown 		filep = stdout;
897b7d8c148SLen Brown 	else
898b7d8c148SLen Brown 		filep = outf;
899b7d8c148SLen Brown 
900b7d8c148SLen Brown 	fputs(output_buffer, filep);
901b7d8c148SLen Brown 	fflush(filep);
902b7d8c148SLen Brown 
903c98d5d94SLen Brown 	outp = output_buffer;
904c98d5d94SLen Brown }
905b7d8c148SLen Brown void flush_output_stderr(void)
906c98d5d94SLen Brown {
907b7d8c148SLen Brown 	fputs(output_buffer, outf);
908b7d8c148SLen Brown 	fflush(outf);
909c98d5d94SLen Brown 	outp = output_buffer;
910c98d5d94SLen Brown }
911c98d5d94SLen Brown void format_all_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
912c98d5d94SLen Brown {
913e23da037SLen Brown 	static int printed;
914103a8feaSLen Brown 
915e23da037SLen Brown 	if (!printed || !summary_only)
916103a8feaSLen Brown 		print_header();
917103a8feaSLen Brown 
918c98d5d94SLen Brown 	if (topo.num_cpus > 1)
919c98d5d94SLen Brown 		format_counters(&average.threads, &average.cores,
920c98d5d94SLen Brown 			&average.packages);
921103a8feaSLen Brown 
922e23da037SLen Brown 	printed = 1;
923e23da037SLen Brown 
924e23da037SLen Brown 	if (summary_only)
925e23da037SLen Brown 		return;
926e23da037SLen Brown 
927c98d5d94SLen Brown 	for_all_cpus(format_counters, t, c, p);
928103a8feaSLen Brown }
929103a8feaSLen Brown 
930889facbeSLen Brown #define DELTA_WRAP32(new, old)			\
931889facbeSLen Brown 	if (new > old) {			\
932889facbeSLen Brown 		old = new - old;		\
933889facbeSLen Brown 	} else {				\
934889facbeSLen Brown 		old = 0x100000000 + new - old;	\
935889facbeSLen Brown 	}
936889facbeSLen Brown 
937ba3dec99SLen Brown int
938c98d5d94SLen Brown delta_package(struct pkg_data *new, struct pkg_data *old)
939103a8feaSLen Brown {
940388e9c81SLen Brown 	int i;
941388e9c81SLen Brown 	struct msr_counter *mp;
9420b2bb692SLen Brown 
9430b2bb692SLen Brown 	if (do_skl_residency) {
9440b2bb692SLen Brown 		old->pkg_wtd_core_c0 = new->pkg_wtd_core_c0 - old->pkg_wtd_core_c0;
9450b2bb692SLen Brown 		old->pkg_any_core_c0 = new->pkg_any_core_c0 - old->pkg_any_core_c0;
9460b2bb692SLen Brown 		old->pkg_any_gfxe_c0 = new->pkg_any_gfxe_c0 - old->pkg_any_gfxe_c0;
9470b2bb692SLen Brown 		old->pkg_both_core_gfxe_c0 = new->pkg_both_core_gfxe_c0 - old->pkg_both_core_gfxe_c0;
9480b2bb692SLen Brown 	}
949c98d5d94SLen Brown 	old->pc2 = new->pc2 - old->pc2;
950ee7e38e3SLen Brown 	if (do_pc3)
951c98d5d94SLen Brown 		old->pc3 = new->pc3 - old->pc3;
952ee7e38e3SLen Brown 	if (do_pc6)
953c98d5d94SLen Brown 		old->pc6 = new->pc6 - old->pc6;
954ee7e38e3SLen Brown 	if (do_pc7)
955c98d5d94SLen Brown 		old->pc7 = new->pc7 - old->pc7;
956ca58710fSKristen Carlson Accardi 	old->pc8 = new->pc8 - old->pc8;
957ca58710fSKristen Carlson Accardi 	old->pc9 = new->pc9 - old->pc9;
958ca58710fSKristen Carlson Accardi 	old->pc10 = new->pc10 - old->pc10;
959889facbeSLen Brown 	old->pkg_temp_c = new->pkg_temp_c;
960889facbeSLen Brown 
9619185e988SLen Brown 	/* flag an error when rc6 counter resets/wraps */
9629185e988SLen Brown 	if (old->gfx_rc6_ms >  new->gfx_rc6_ms)
9639185e988SLen Brown 		old->gfx_rc6_ms = -1;
9649185e988SLen Brown 	else
965fdf676e5SLen Brown 		old->gfx_rc6_ms = new->gfx_rc6_ms - old->gfx_rc6_ms;
9669185e988SLen Brown 
96727d47356SLen Brown 	old->gfx_mhz = new->gfx_mhz;
96827d47356SLen Brown 
969889facbeSLen Brown 	DELTA_WRAP32(new->energy_pkg, old->energy_pkg);
970889facbeSLen Brown 	DELTA_WRAP32(new->energy_cores, old->energy_cores);
971889facbeSLen Brown 	DELTA_WRAP32(new->energy_gfx, old->energy_gfx);
972889facbeSLen Brown 	DELTA_WRAP32(new->energy_dram, old->energy_dram);
973889facbeSLen Brown 	DELTA_WRAP32(new->rapl_pkg_perf_status, old->rapl_pkg_perf_status);
974889facbeSLen Brown 	DELTA_WRAP32(new->rapl_dram_perf_status, old->rapl_dram_perf_status);
975ba3dec99SLen Brown 
976388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
977388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
978388e9c81SLen Brown 			old->counter[i] = new->counter[i];
979388e9c81SLen Brown 		else
980388e9c81SLen Brown 			old->counter[i] = new->counter[i] - old->counter[i];
981388e9c81SLen Brown 	}
982388e9c81SLen Brown 
983ba3dec99SLen Brown 	return 0;
984103a8feaSLen Brown }
985103a8feaSLen Brown 
986c98d5d94SLen Brown void
987c98d5d94SLen Brown delta_core(struct core_data *new, struct core_data *old)
988c98d5d94SLen Brown {
989388e9c81SLen Brown 	int i;
990388e9c81SLen Brown 	struct msr_counter *mp;
991388e9c81SLen Brown 
992c98d5d94SLen Brown 	old->c3 = new->c3 - old->c3;
993c98d5d94SLen Brown 	old->c6 = new->c6 - old->c6;
994c98d5d94SLen Brown 	old->c7 = new->c7 - old->c7;
995889facbeSLen Brown 	old->core_temp_c = new->core_temp_c;
9960539ba11SLen Brown 	old->mc6_us = new->mc6_us - old->mc6_us;
997388e9c81SLen Brown 
998388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
999388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1000388e9c81SLen Brown 			old->counter[i] = new->counter[i];
1001388e9c81SLen Brown 		else
1002388e9c81SLen Brown 			old->counter[i] = new->counter[i] - old->counter[i];
1003388e9c81SLen Brown 	}
1004103a8feaSLen Brown }
1005c98d5d94SLen Brown 
1006c3ae331dSLen Brown /*
1007c3ae331dSLen Brown  * old = new - old
1008c3ae331dSLen Brown  */
1009ba3dec99SLen Brown int
1010c98d5d94SLen Brown delta_thread(struct thread_data *new, struct thread_data *old,
1011c98d5d94SLen Brown 	struct core_data *core_delta)
1012c98d5d94SLen Brown {
1013388e9c81SLen Brown 	int i;
1014388e9c81SLen Brown 	struct msr_counter *mp;
1015388e9c81SLen Brown 
1016c98d5d94SLen Brown 	old->tsc = new->tsc - old->tsc;
1017c98d5d94SLen Brown 
1018103a8feaSLen Brown 	/* check for TSC < 1 Mcycles over interval */
1019b2c95d90SJosh Triplett 	if (old->tsc < (1000 * 1000))
1020b2c95d90SJosh Triplett 		errx(-3, "Insanely slow TSC rate, TSC stops in idle?\n"
1021b2c95d90SJosh Triplett 		     "You can disable all c-states by booting with \"idle=poll\"\n"
1022b2c95d90SJosh Triplett 		     "or just the deep ones with \"processor.max_cstate=1\"");
1023103a8feaSLen Brown 
1024c98d5d94SLen Brown 	old->c1 = new->c1 - old->c1;
1025c98d5d94SLen Brown 
1026812db3f7SLen Brown 	if (DO_BIC(BIC_Avg_MHz) || DO_BIC(BIC_Busy) || DO_BIC(BIC_Bzy_MHz)) {
1027c98d5d94SLen Brown 		if ((new->aperf > old->aperf) && (new->mperf > old->mperf)) {
1028c98d5d94SLen Brown 			old->aperf = new->aperf - old->aperf;
1029c98d5d94SLen Brown 			old->mperf = new->mperf - old->mperf;
1030c98d5d94SLen Brown 		} else {
1031ba3dec99SLen Brown 			return -1;
1032103a8feaSLen Brown 		}
1033a729617cSLen Brown 	}
1034103a8feaSLen Brown 
1035c98d5d94SLen Brown 
1036144b44b1SLen Brown 	if (use_c1_residency_msr) {
1037144b44b1SLen Brown 		/*
1038144b44b1SLen Brown 		 * Some models have a dedicated C1 residency MSR,
1039144b44b1SLen Brown 		 * which should be more accurate than the derivation below.
1040144b44b1SLen Brown 		 */
1041144b44b1SLen Brown 	} else {
1042103a8feaSLen Brown 		/*
1043c3ae331dSLen Brown 		 * As counter collection is not atomic,
1044c3ae331dSLen Brown 		 * it is possible for mperf's non-halted cycles + idle states
1045103a8feaSLen Brown 		 * to exceed TSC's all cycles: show c1 = 0% in that case.
1046103a8feaSLen Brown 		 */
1047c3ae331dSLen Brown 		if ((old->mperf + core_delta->c3 + core_delta->c6 + core_delta->c7) > old->tsc)
1048c98d5d94SLen Brown 			old->c1 = 0;
1049c98d5d94SLen Brown 		else {
1050c98d5d94SLen Brown 			/* normal case, derive c1 */
1051c98d5d94SLen Brown 			old->c1 = old->tsc - old->mperf - core_delta->c3
1052c98d5d94SLen Brown 				- core_delta->c6 - core_delta->c7;
1053c98d5d94SLen Brown 		}
1054144b44b1SLen Brown 	}
1055c3ae331dSLen Brown 
1056c98d5d94SLen Brown 	if (old->mperf == 0) {
1057b7d8c148SLen Brown 		if (debug > 1)
1058b7d8c148SLen Brown 			fprintf(outf, "cpu%d MPERF 0!\n", old->cpu_id);
1059c98d5d94SLen Brown 		old->mperf = 1;	/* divide by 0 protection */
1060c98d5d94SLen Brown 	}
1061103a8feaSLen Brown 
1062812db3f7SLen Brown 	if (DO_BIC(BIC_IRQ))
1063562a2d37SLen Brown 		old->irq_count = new->irq_count - old->irq_count;
1064562a2d37SLen Brown 
1065812db3f7SLen Brown 	if (DO_BIC(BIC_SMI))
10661ed51011SLen Brown 		old->smi_count = new->smi_count - old->smi_count;
1067ba3dec99SLen Brown 
1068388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
1069388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1070388e9c81SLen Brown 			old->counter[i] = new->counter[i];
1071388e9c81SLen Brown 		else
1072388e9c81SLen Brown 			old->counter[i] = new->counter[i] - old->counter[i];
1073388e9c81SLen Brown 	}
1074ba3dec99SLen Brown 	return 0;
1075103a8feaSLen Brown }
1076c98d5d94SLen Brown 
1077c98d5d94SLen Brown int delta_cpu(struct thread_data *t, struct core_data *c,
1078c98d5d94SLen Brown 	struct pkg_data *p, struct thread_data *t2,
1079c98d5d94SLen Brown 	struct core_data *c2, struct pkg_data *p2)
1080c98d5d94SLen Brown {
1081ba3dec99SLen Brown 	int retval = 0;
1082ba3dec99SLen Brown 
1083c98d5d94SLen Brown 	/* calculate core delta only for 1st thread in core */
1084c98d5d94SLen Brown 	if (t->flags & CPU_IS_FIRST_THREAD_IN_CORE)
1085c98d5d94SLen Brown 		delta_core(c, c2);
1086c98d5d94SLen Brown 
1087c98d5d94SLen Brown 	/* always calculate thread delta */
1088ba3dec99SLen Brown 	retval = delta_thread(t, t2, c2);	/* c2 is core delta */
1089ba3dec99SLen Brown 	if (retval)
1090ba3dec99SLen Brown 		return retval;
1091c98d5d94SLen Brown 
1092c98d5d94SLen Brown 	/* calculate package delta only for 1st core in package */
1093c98d5d94SLen Brown 	if (t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)
1094ba3dec99SLen Brown 		retval = delta_package(p, p2);
1095c98d5d94SLen Brown 
1096ba3dec99SLen Brown 	return retval;
1097103a8feaSLen Brown }
1098103a8feaSLen Brown 
1099c98d5d94SLen Brown void clear_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
1100103a8feaSLen Brown {
1101388e9c81SLen Brown 	int i;
1102388e9c81SLen Brown 	struct msr_counter  *mp;
1103388e9c81SLen Brown 
1104c98d5d94SLen Brown 	t->tsc = 0;
1105c98d5d94SLen Brown 	t->aperf = 0;
1106c98d5d94SLen Brown 	t->mperf = 0;
1107c98d5d94SLen Brown 	t->c1 = 0;
1108103a8feaSLen Brown 
1109562a2d37SLen Brown 	t->irq_count = 0;
1110562a2d37SLen Brown 	t->smi_count = 0;
1111562a2d37SLen Brown 
1112c98d5d94SLen Brown 	/* tells format_counters to dump all fields from this set */
1113c98d5d94SLen Brown 	t->flags = CPU_IS_FIRST_THREAD_IN_CORE | CPU_IS_FIRST_CORE_IN_PACKAGE;
1114c98d5d94SLen Brown 
1115c98d5d94SLen Brown 	c->c3 = 0;
1116c98d5d94SLen Brown 	c->c6 = 0;
1117c98d5d94SLen Brown 	c->c7 = 0;
11180539ba11SLen Brown 	c->mc6_us = 0;
1119889facbeSLen Brown 	c->core_temp_c = 0;
1120c98d5d94SLen Brown 
11210b2bb692SLen Brown 	p->pkg_wtd_core_c0 = 0;
11220b2bb692SLen Brown 	p->pkg_any_core_c0 = 0;
11230b2bb692SLen Brown 	p->pkg_any_gfxe_c0 = 0;
11240b2bb692SLen Brown 	p->pkg_both_core_gfxe_c0 = 0;
11250b2bb692SLen Brown 
1126c98d5d94SLen Brown 	p->pc2 = 0;
1127ee7e38e3SLen Brown 	if (do_pc3)
1128c98d5d94SLen Brown 		p->pc3 = 0;
1129ee7e38e3SLen Brown 	if (do_pc6)
1130c98d5d94SLen Brown 		p->pc6 = 0;
1131ee7e38e3SLen Brown 	if (do_pc7)
1132c98d5d94SLen Brown 		p->pc7 = 0;
1133ca58710fSKristen Carlson Accardi 	p->pc8 = 0;
1134ca58710fSKristen Carlson Accardi 	p->pc9 = 0;
1135ca58710fSKristen Carlson Accardi 	p->pc10 = 0;
1136889facbeSLen Brown 
1137889facbeSLen Brown 	p->energy_pkg = 0;
1138889facbeSLen Brown 	p->energy_dram = 0;
1139889facbeSLen Brown 	p->energy_cores = 0;
1140889facbeSLen Brown 	p->energy_gfx = 0;
1141889facbeSLen Brown 	p->rapl_pkg_perf_status = 0;
1142889facbeSLen Brown 	p->rapl_dram_perf_status = 0;
1143889facbeSLen Brown 	p->pkg_temp_c = 0;
114427d47356SLen Brown 
1145fdf676e5SLen Brown 	p->gfx_rc6_ms = 0;
114627d47356SLen Brown 	p->gfx_mhz = 0;
1147388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next)
1148388e9c81SLen Brown 		t->counter[i] = 0;
1149388e9c81SLen Brown 
1150388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next)
1151388e9c81SLen Brown 		c->counter[i] = 0;
1152388e9c81SLen Brown 
1153388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next)
1154388e9c81SLen Brown 		p->counter[i] = 0;
1155103a8feaSLen Brown }
1156c98d5d94SLen Brown int sum_counters(struct thread_data *t, struct core_data *c,
1157c98d5d94SLen Brown 	struct pkg_data *p)
1158103a8feaSLen Brown {
1159388e9c81SLen Brown 	int i;
1160388e9c81SLen Brown 	struct msr_counter *mp;
1161388e9c81SLen Brown 
1162c98d5d94SLen Brown 	average.threads.tsc += t->tsc;
1163c98d5d94SLen Brown 	average.threads.aperf += t->aperf;
1164c98d5d94SLen Brown 	average.threads.mperf += t->mperf;
1165c98d5d94SLen Brown 	average.threads.c1 += t->c1;
116615aaa346SLen Brown 
1167562a2d37SLen Brown 	average.threads.irq_count += t->irq_count;
1168562a2d37SLen Brown 	average.threads.smi_count += t->smi_count;
1169562a2d37SLen Brown 
1170388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
1171388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1172388e9c81SLen Brown 			continue;
1173388e9c81SLen Brown 		average.threads.counter[i] += t->counter[i];
1174388e9c81SLen Brown 	}
1175388e9c81SLen Brown 
1176c98d5d94SLen Brown 	/* sum per-core values only for 1st thread in core */
1177c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
1178c98d5d94SLen Brown 		return 0;
1179c98d5d94SLen Brown 
1180c98d5d94SLen Brown 	average.cores.c3 += c->c3;
1181c98d5d94SLen Brown 	average.cores.c6 += c->c6;
1182c98d5d94SLen Brown 	average.cores.c7 += c->c7;
11830539ba11SLen Brown 	average.cores.mc6_us += c->mc6_us;
1184c98d5d94SLen Brown 
1185889facbeSLen Brown 	average.cores.core_temp_c = MAX(average.cores.core_temp_c, c->core_temp_c);
1186889facbeSLen Brown 
1187388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
1188388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1189388e9c81SLen Brown 			continue;
1190388e9c81SLen Brown 		average.cores.counter[i] += c->counter[i];
1191388e9c81SLen Brown 	}
1192388e9c81SLen Brown 
1193c98d5d94SLen Brown 	/* sum per-pkg values only for 1st core in pkg */
1194c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
1195c98d5d94SLen Brown 		return 0;
1196c98d5d94SLen Brown 
11970b2bb692SLen Brown 	if (do_skl_residency) {
11980b2bb692SLen Brown 		average.packages.pkg_wtd_core_c0 += p->pkg_wtd_core_c0;
11990b2bb692SLen Brown 		average.packages.pkg_any_core_c0 += p->pkg_any_core_c0;
12000b2bb692SLen Brown 		average.packages.pkg_any_gfxe_c0 += p->pkg_any_gfxe_c0;
12010b2bb692SLen Brown 		average.packages.pkg_both_core_gfxe_c0 += p->pkg_both_core_gfxe_c0;
12020b2bb692SLen Brown 	}
12030b2bb692SLen Brown 
1204c98d5d94SLen Brown 	average.packages.pc2 += p->pc2;
1205ee7e38e3SLen Brown 	if (do_pc3)
1206c98d5d94SLen Brown 		average.packages.pc3 += p->pc3;
1207ee7e38e3SLen Brown 	if (do_pc6)
1208c98d5d94SLen Brown 		average.packages.pc6 += p->pc6;
1209ee7e38e3SLen Brown 	if (do_pc7)
1210c98d5d94SLen Brown 		average.packages.pc7 += p->pc7;
1211ca58710fSKristen Carlson Accardi 	average.packages.pc8 += p->pc8;
1212ca58710fSKristen Carlson Accardi 	average.packages.pc9 += p->pc9;
1213ca58710fSKristen Carlson Accardi 	average.packages.pc10 += p->pc10;
1214c98d5d94SLen Brown 
1215889facbeSLen Brown 	average.packages.energy_pkg += p->energy_pkg;
1216889facbeSLen Brown 	average.packages.energy_dram += p->energy_dram;
1217889facbeSLen Brown 	average.packages.energy_cores += p->energy_cores;
1218889facbeSLen Brown 	average.packages.energy_gfx += p->energy_gfx;
1219889facbeSLen Brown 
1220fdf676e5SLen Brown 	average.packages.gfx_rc6_ms = p->gfx_rc6_ms;
122127d47356SLen Brown 	average.packages.gfx_mhz = p->gfx_mhz;
122227d47356SLen Brown 
1223889facbeSLen Brown 	average.packages.pkg_temp_c = MAX(average.packages.pkg_temp_c, p->pkg_temp_c);
1224889facbeSLen Brown 
1225889facbeSLen Brown 	average.packages.rapl_pkg_perf_status += p->rapl_pkg_perf_status;
1226889facbeSLen Brown 	average.packages.rapl_dram_perf_status += p->rapl_dram_perf_status;
1227388e9c81SLen Brown 
1228388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
1229388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1230388e9c81SLen Brown 			continue;
1231388e9c81SLen Brown 		average.packages.counter[i] += p->counter[i];
1232388e9c81SLen Brown 	}
1233c98d5d94SLen Brown 	return 0;
1234c98d5d94SLen Brown }
1235c98d5d94SLen Brown /*
1236c98d5d94SLen Brown  * sum the counters for all cpus in the system
1237c98d5d94SLen Brown  * compute the weighted average
1238c98d5d94SLen Brown  */
1239c98d5d94SLen Brown void compute_average(struct thread_data *t, struct core_data *c,
1240c98d5d94SLen Brown 	struct pkg_data *p)
1241c98d5d94SLen Brown {
1242388e9c81SLen Brown 	int i;
1243388e9c81SLen Brown 	struct msr_counter *mp;
1244388e9c81SLen Brown 
1245c98d5d94SLen Brown 	clear_counters(&average.threads, &average.cores, &average.packages);
1246c98d5d94SLen Brown 
1247c98d5d94SLen Brown 	for_all_cpus(sum_counters, t, c, p);
1248c98d5d94SLen Brown 
1249c98d5d94SLen Brown 	average.threads.tsc /= topo.num_cpus;
1250c98d5d94SLen Brown 	average.threads.aperf /= topo.num_cpus;
1251c98d5d94SLen Brown 	average.threads.mperf /= topo.num_cpus;
1252c98d5d94SLen Brown 	average.threads.c1 /= topo.num_cpus;
1253c98d5d94SLen Brown 
1254c98d5d94SLen Brown 	average.cores.c3 /= topo.num_cores;
1255c98d5d94SLen Brown 	average.cores.c6 /= topo.num_cores;
1256c98d5d94SLen Brown 	average.cores.c7 /= topo.num_cores;
12570539ba11SLen Brown 	average.cores.mc6_us /= topo.num_cores;
1258c98d5d94SLen Brown 
12590b2bb692SLen Brown 	if (do_skl_residency) {
12600b2bb692SLen Brown 		average.packages.pkg_wtd_core_c0 /= topo.num_packages;
12610b2bb692SLen Brown 		average.packages.pkg_any_core_c0 /= topo.num_packages;
12620b2bb692SLen Brown 		average.packages.pkg_any_gfxe_c0 /= topo.num_packages;
12630b2bb692SLen Brown 		average.packages.pkg_both_core_gfxe_c0 /= topo.num_packages;
12640b2bb692SLen Brown 	}
12650b2bb692SLen Brown 
1266c98d5d94SLen Brown 	average.packages.pc2 /= topo.num_packages;
1267ee7e38e3SLen Brown 	if (do_pc3)
1268c98d5d94SLen Brown 		average.packages.pc3 /= topo.num_packages;
1269ee7e38e3SLen Brown 	if (do_pc6)
1270c98d5d94SLen Brown 		average.packages.pc6 /= topo.num_packages;
1271ee7e38e3SLen Brown 	if (do_pc7)
1272c98d5d94SLen Brown 		average.packages.pc7 /= topo.num_packages;
1273ca58710fSKristen Carlson Accardi 
1274ca58710fSKristen Carlson Accardi 	average.packages.pc8 /= topo.num_packages;
1275ca58710fSKristen Carlson Accardi 	average.packages.pc9 /= topo.num_packages;
1276ca58710fSKristen Carlson Accardi 	average.packages.pc10 /= topo.num_packages;
1277388e9c81SLen Brown 
1278388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
1279388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1280388e9c81SLen Brown 			continue;
1281388e9c81SLen Brown 		average.threads.counter[i] /= topo.num_cpus;
1282388e9c81SLen Brown 	}
1283388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
1284388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1285388e9c81SLen Brown 			continue;
1286388e9c81SLen Brown 		average.cores.counter[i] /= topo.num_cores;
1287388e9c81SLen Brown 	}
1288388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
1289388e9c81SLen Brown 		if (mp->format == FORMAT_RAW)
1290388e9c81SLen Brown 			continue;
1291388e9c81SLen Brown 		average.packages.counter[i] /= topo.num_packages;
1292388e9c81SLen Brown 	}
1293c98d5d94SLen Brown }
1294c98d5d94SLen Brown 
1295c98d5d94SLen Brown static unsigned long long rdtsc(void)
1296c98d5d94SLen Brown {
1297c98d5d94SLen Brown 	unsigned int low, high;
1298c98d5d94SLen Brown 
1299c98d5d94SLen Brown 	asm volatile("rdtsc" : "=a" (low), "=d" (high));
1300c98d5d94SLen Brown 
1301c98d5d94SLen Brown 	return low | ((unsigned long long)high) << 32;
1302c98d5d94SLen Brown }
1303c98d5d94SLen Brown 
1304c98d5d94SLen Brown /*
1305c98d5d94SLen Brown  * get_counters(...)
1306c98d5d94SLen Brown  * migrate to cpu
1307c98d5d94SLen Brown  * acquire and record local counters for that cpu
1308c98d5d94SLen Brown  */
1309c98d5d94SLen Brown int get_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
1310c98d5d94SLen Brown {
1311c98d5d94SLen Brown 	int cpu = t->cpu_id;
1312889facbeSLen Brown 	unsigned long long msr;
13130102b067SLen Brown 	int aperf_mperf_retry_count = 0;
1314388e9c81SLen Brown 	struct msr_counter *mp;
1315388e9c81SLen Brown 	int i;
1316c98d5d94SLen Brown 
1317e52966c0SLen Brown 	if (cpu_migrate(cpu)) {
1318b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
131915aaa346SLen Brown 		return -1;
1320e52966c0SLen Brown 	}
132115aaa346SLen Brown 
13220102b067SLen Brown retry:
1323c98d5d94SLen Brown 	t->tsc = rdtsc();	/* we are running on local CPU of interest */
132415aaa346SLen Brown 
1325812db3f7SLen Brown 	if (DO_BIC(BIC_Avg_MHz) || DO_BIC(BIC_Busy) || DO_BIC(BIC_Bzy_MHz)) {
13260102b067SLen Brown 		unsigned long long tsc_before, tsc_between, tsc_after, aperf_time, mperf_time;
13270102b067SLen Brown 
13280102b067SLen Brown 		/*
13290102b067SLen Brown 		 * The TSC, APERF and MPERF must be read together for
13300102b067SLen Brown 		 * APERF/MPERF and MPERF/TSC to give accurate results.
13310102b067SLen Brown 		 *
13320102b067SLen Brown 		 * Unfortunately, APERF and MPERF are read by
13330102b067SLen Brown 		 * individual system call, so delays may occur
13340102b067SLen Brown 		 * between them.  If the time to read them
13350102b067SLen Brown 		 * varies by a large amount, we re-read them.
13360102b067SLen Brown 		 */
13370102b067SLen Brown 
13380102b067SLen Brown 		/*
13390102b067SLen Brown 		 * This initial dummy APERF read has been seen to
13400102b067SLen Brown 		 * reduce jitter in the subsequent reads.
13410102b067SLen Brown 		 */
13420102b067SLen Brown 
13439c63a650SLen Brown 		if (get_msr(cpu, MSR_IA32_APERF, &t->aperf))
1344c98d5d94SLen Brown 			return -3;
13450102b067SLen Brown 
13460102b067SLen Brown 		t->tsc = rdtsc();	/* re-read close to APERF */
13470102b067SLen Brown 
13480102b067SLen Brown 		tsc_before = t->tsc;
13490102b067SLen Brown 
13500102b067SLen Brown 		if (get_msr(cpu, MSR_IA32_APERF, &t->aperf))
13510102b067SLen Brown 			return -3;
13520102b067SLen Brown 
13530102b067SLen Brown 		tsc_between = rdtsc();
13540102b067SLen Brown 
13559c63a650SLen Brown 		if (get_msr(cpu, MSR_IA32_MPERF, &t->mperf))
1356c98d5d94SLen Brown 			return -4;
13570102b067SLen Brown 
13580102b067SLen Brown 		tsc_after = rdtsc();
13590102b067SLen Brown 
13600102b067SLen Brown 		aperf_time = tsc_between - tsc_before;
13610102b067SLen Brown 		mperf_time = tsc_after - tsc_between;
13620102b067SLen Brown 
13630102b067SLen Brown 		/*
13640102b067SLen Brown 		 * If the system call latency to read APERF and MPERF
13650102b067SLen Brown 		 * differ by more than 2x, then try again.
13660102b067SLen Brown 		 */
13670102b067SLen Brown 		if ((aperf_time > (2 * mperf_time)) || (mperf_time > (2 * aperf_time))) {
13680102b067SLen Brown 			aperf_mperf_retry_count++;
13690102b067SLen Brown 			if (aperf_mperf_retry_count < 5)
13700102b067SLen Brown 				goto retry;
13710102b067SLen Brown 			else
13720102b067SLen Brown 				warnx("cpu%d jitter %lld %lld",
13730102b067SLen Brown 					cpu, aperf_time, mperf_time);
13740102b067SLen Brown 		}
13750102b067SLen Brown 		aperf_mperf_retry_count = 0;
13760102b067SLen Brown 
1377b2b34dfeSHubert Chrzaniuk 		t->aperf = t->aperf * aperf_mperf_multiplier;
1378b2b34dfeSHubert Chrzaniuk 		t->mperf = t->mperf * aperf_mperf_multiplier;
137988c3281fSLen Brown 	}
138088c3281fSLen Brown 
1381812db3f7SLen Brown 	if (DO_BIC(BIC_IRQ))
1382562a2d37SLen Brown 		t->irq_count = irqs_per_cpu[cpu];
1383812db3f7SLen Brown 	if (DO_BIC(BIC_SMI)) {
13841ed51011SLen Brown 		if (get_msr(cpu, MSR_SMI_COUNT, &msr))
13851ed51011SLen Brown 			return -5;
13861ed51011SLen Brown 		t->smi_count = msr & 0xFFFFFFFF;
13871ed51011SLen Brown 	}
13880539ba11SLen Brown 	if (DO_BIC(BIC_CPU_c1) && use_c1_residency_msr) {
1389144b44b1SLen Brown 		if (get_msr(cpu, MSR_CORE_C1_RES, &t->c1))
1390144b44b1SLen Brown 			return -6;
1391144b44b1SLen Brown 	}
1392144b44b1SLen Brown 
1393388e9c81SLen Brown 	for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
1394388e9c81SLen Brown 		if (get_msr(cpu, mp->msr_num, &t->counter[i]))
1395388e9c81SLen Brown 			return -10;
1396388e9c81SLen Brown 	}
1397388e9c81SLen Brown 
1398388e9c81SLen Brown 
1399c98d5d94SLen Brown 	/* collect core counters only for 1st thread in core */
1400c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
1401c98d5d94SLen Brown 		return 0;
1402c98d5d94SLen Brown 
1403812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c3) && !do_slm_cstates && !do_knl_cstates) {
1404c98d5d94SLen Brown 		if (get_msr(cpu, MSR_CORE_C3_RESIDENCY, &c->c3))
1405c98d5d94SLen Brown 			return -6;
1406144b44b1SLen Brown 	}
1407144b44b1SLen Brown 
1408812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c6) && !do_knl_cstates) {
1409c98d5d94SLen Brown 		if (get_msr(cpu, MSR_CORE_C6_RESIDENCY, &c->c6))
1410c98d5d94SLen Brown 			return -7;
1411fb5d4327SDasaratharaman Chandramouli 	} else if (do_knl_cstates) {
1412fb5d4327SDasaratharaman Chandramouli 		if (get_msr(cpu, MSR_KNL_CORE_C6_RESIDENCY, &c->c6))
1413fb5d4327SDasaratharaman Chandramouli 			return -7;
1414103a8feaSLen Brown 	}
141515aaa346SLen Brown 
1416812db3f7SLen Brown 	if (DO_BIC(BIC_CPU_c7))
1417c98d5d94SLen Brown 		if (get_msr(cpu, MSR_CORE_C7_RESIDENCY, &c->c7))
1418c98d5d94SLen Brown 			return -8;
1419c98d5d94SLen Brown 
14200539ba11SLen Brown 	if (DO_BIC(BIC_Mod_c6))
14210539ba11SLen Brown 		if (get_msr(cpu, MSR_MODULE_C6_RES_MS, &c->mc6_us))
14220539ba11SLen Brown 			return -8;
14230539ba11SLen Brown 
1424812db3f7SLen Brown 	if (DO_BIC(BIC_CoreTmp)) {
1425889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_THERM_STATUS, &msr))
1426889facbeSLen Brown 			return -9;
1427889facbeSLen Brown 		c->core_temp_c = tcc_activation_temp - ((msr >> 16) & 0x7F);
1428889facbeSLen Brown 	}
1429889facbeSLen Brown 
1430388e9c81SLen Brown 	for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
1431388e9c81SLen Brown 		if (get_msr(cpu, mp->msr_num, &c->counter[i]))
1432388e9c81SLen Brown 			return -10;
1433388e9c81SLen Brown 	}
1434889facbeSLen Brown 
1435c98d5d94SLen Brown 	/* collect package counters only for 1st core in package */
1436c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
1437c98d5d94SLen Brown 		return 0;
143815aaa346SLen Brown 
14390b2bb692SLen Brown 	if (do_skl_residency) {
14400b2bb692SLen Brown 		if (get_msr(cpu, MSR_PKG_WEIGHTED_CORE_C0_RES, &p->pkg_wtd_core_c0))
14410b2bb692SLen Brown 			return -10;
14420b2bb692SLen Brown 		if (get_msr(cpu, MSR_PKG_ANY_CORE_C0_RES, &p->pkg_any_core_c0))
14430b2bb692SLen Brown 			return -11;
14440b2bb692SLen Brown 		if (get_msr(cpu, MSR_PKG_ANY_GFXE_C0_RES, &p->pkg_any_gfxe_c0))
14450b2bb692SLen Brown 			return -12;
14460b2bb692SLen Brown 		if (get_msr(cpu, MSR_PKG_BOTH_CORE_GFXE_C0_RES, &p->pkg_both_core_gfxe_c0))
14470b2bb692SLen Brown 			return -13;
14480b2bb692SLen Brown 	}
1449ee7e38e3SLen Brown 	if (do_pc3)
1450c98d5d94SLen Brown 		if (get_msr(cpu, MSR_PKG_C3_RESIDENCY, &p->pc3))
1451c98d5d94SLen Brown 			return -9;
14520539ba11SLen Brown 	if (do_pc6) {
14530539ba11SLen Brown 		if (do_slm_cstates) {
14540539ba11SLen Brown 			if (get_msr(cpu, MSR_ATOM_PKG_C6_RESIDENCY, &p->pc6))
14550539ba11SLen Brown 				return -10;
14560539ba11SLen Brown 		} else {
1457c98d5d94SLen Brown 			if (get_msr(cpu, MSR_PKG_C6_RESIDENCY, &p->pc6))
1458c98d5d94SLen Brown 				return -10;
14590539ba11SLen Brown 		}
14600539ba11SLen Brown 	}
14610539ba11SLen Brown 
1462ee7e38e3SLen Brown 	if (do_pc2)
1463c98d5d94SLen Brown 		if (get_msr(cpu, MSR_PKG_C2_RESIDENCY, &p->pc2))
1464c98d5d94SLen Brown 			return -11;
1465ee7e38e3SLen Brown 	if (do_pc7)
1466c98d5d94SLen Brown 		if (get_msr(cpu, MSR_PKG_C7_RESIDENCY, &p->pc7))
1467c98d5d94SLen Brown 			return -12;
1468ca58710fSKristen Carlson Accardi 	if (do_c8_c9_c10) {
1469ca58710fSKristen Carlson Accardi 		if (get_msr(cpu, MSR_PKG_C8_RESIDENCY, &p->pc8))
1470ca58710fSKristen Carlson Accardi 			return -13;
1471ca58710fSKristen Carlson Accardi 		if (get_msr(cpu, MSR_PKG_C9_RESIDENCY, &p->pc9))
1472ca58710fSKristen Carlson Accardi 			return -13;
1473ca58710fSKristen Carlson Accardi 		if (get_msr(cpu, MSR_PKG_C10_RESIDENCY, &p->pc10))
1474ca58710fSKristen Carlson Accardi 			return -13;
1475ca58710fSKristen Carlson Accardi 	}
1476889facbeSLen Brown 	if (do_rapl & RAPL_PKG) {
1477889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_ENERGY_STATUS, &msr))
1478889facbeSLen Brown 			return -13;
1479889facbeSLen Brown 		p->energy_pkg = msr & 0xFFFFFFFF;
1480889facbeSLen Brown 	}
14819148494cSJacob Pan 	if (do_rapl & RAPL_CORES_ENERGY_STATUS) {
1482889facbeSLen Brown 		if (get_msr(cpu, MSR_PP0_ENERGY_STATUS, &msr))
1483889facbeSLen Brown 			return -14;
1484889facbeSLen Brown 		p->energy_cores = msr & 0xFFFFFFFF;
1485889facbeSLen Brown 	}
1486889facbeSLen Brown 	if (do_rapl & RAPL_DRAM) {
1487889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_ENERGY_STATUS, &msr))
1488889facbeSLen Brown 			return -15;
1489889facbeSLen Brown 		p->energy_dram = msr & 0xFFFFFFFF;
1490889facbeSLen Brown 	}
1491889facbeSLen Brown 	if (do_rapl & RAPL_GFX) {
1492889facbeSLen Brown 		if (get_msr(cpu, MSR_PP1_ENERGY_STATUS, &msr))
1493889facbeSLen Brown 			return -16;
1494889facbeSLen Brown 		p->energy_gfx = msr & 0xFFFFFFFF;
1495889facbeSLen Brown 	}
1496889facbeSLen Brown 	if (do_rapl & RAPL_PKG_PERF_STATUS) {
1497889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_PERF_STATUS, &msr))
1498889facbeSLen Brown 			return -16;
1499889facbeSLen Brown 		p->rapl_pkg_perf_status = msr & 0xFFFFFFFF;
1500889facbeSLen Brown 	}
1501889facbeSLen Brown 	if (do_rapl & RAPL_DRAM_PERF_STATUS) {
1502889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_PERF_STATUS, &msr))
1503889facbeSLen Brown 			return -16;
1504889facbeSLen Brown 		p->rapl_dram_perf_status = msr & 0xFFFFFFFF;
1505889facbeSLen Brown 	}
1506812db3f7SLen Brown 	if (DO_BIC(BIC_PkgTmp)) {
1507889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_STATUS, &msr))
1508889facbeSLen Brown 			return -17;
1509889facbeSLen Brown 		p->pkg_temp_c = tcc_activation_temp - ((msr >> 16) & 0x7F);
1510889facbeSLen Brown 	}
1511fdf676e5SLen Brown 
1512812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_rc6))
1513fdf676e5SLen Brown 		p->gfx_rc6_ms = gfx_cur_rc6_ms;
1514fdf676e5SLen Brown 
1515812db3f7SLen Brown 	if (DO_BIC(BIC_GFXMHz))
151627d47356SLen Brown 		p->gfx_mhz = gfx_cur_mhz;
151727d47356SLen Brown 
1518388e9c81SLen Brown 	for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
1519388e9c81SLen Brown 		if (get_msr(cpu, mp->msr_num, &p->counter[i]))
1520388e9c81SLen Brown 			return -10;
1521388e9c81SLen Brown 	}
1522388e9c81SLen Brown 
152315aaa346SLen Brown 	return 0;
1524103a8feaSLen Brown }
1525103a8feaSLen Brown 
1526ee7e38e3SLen Brown /*
1527ee7e38e3SLen Brown  * MSR_PKG_CST_CONFIG_CONTROL decoding for pkg_cstate_limit:
1528ee7e38e3SLen Brown  * If you change the values, note they are used both in comparisons
1529ee7e38e3SLen Brown  * (>= PCL__7) and to index pkg_cstate_limit_strings[].
1530ee7e38e3SLen Brown  */
1531ee7e38e3SLen Brown 
1532ee7e38e3SLen Brown #define PCLUKN 0 /* Unknown */
1533ee7e38e3SLen Brown #define PCLRSV 1 /* Reserved */
1534ee7e38e3SLen Brown #define PCL__0 2 /* PC0 */
1535ee7e38e3SLen Brown #define PCL__1 3 /* PC1 */
1536ee7e38e3SLen Brown #define PCL__2 4 /* PC2 */
1537ee7e38e3SLen Brown #define PCL__3 5 /* PC3 */
1538ee7e38e3SLen Brown #define PCL__4 6 /* PC4 */
1539ee7e38e3SLen Brown #define PCL__6 7 /* PC6 */
1540ee7e38e3SLen Brown #define PCL_6N 8 /* PC6 No Retention */
1541ee7e38e3SLen Brown #define PCL_6R 9 /* PC6 Retention */
1542ee7e38e3SLen Brown #define PCL__7 10 /* PC7 */
1543ee7e38e3SLen Brown #define PCL_7S 11 /* PC7 Shrink */
15440b2bb692SLen Brown #define PCL__8 12 /* PC8 */
15450b2bb692SLen Brown #define PCL__9 13 /* PC9 */
15460b2bb692SLen Brown #define PCLUNL 14 /* Unlimited */
1547ee7e38e3SLen Brown 
1548ee7e38e3SLen Brown int pkg_cstate_limit = PCLUKN;
1549ee7e38e3SLen Brown char *pkg_cstate_limit_strings[] = { "reserved", "unknown", "pc0", "pc1", "pc2",
15500b2bb692SLen Brown 	"pc3", "pc4", "pc6", "pc6n", "pc6r", "pc7", "pc7s", "pc8", "pc9", "unlimited"};
1551ee7e38e3SLen Brown 
1552e9257f5fSLen 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};
1553e9257f5fSLen 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};
1554e9257f5fSLen 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};
15550539ba11SLen 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};
1556f2642888SLen 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};
1557e9257f5fSLen 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};
1558e4085d54SLen 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};
1559d8ebb442SLen 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};
1560ee7e38e3SLen Brown 
1561a2b7b749SLen Brown 
1562a2b7b749SLen Brown static void
1563a2b7b749SLen Brown calculate_tsc_tweak()
1564a2b7b749SLen Brown {
1565a2b7b749SLen Brown 	tsc_tweak = base_hz / tsc_hz;
1566a2b7b749SLen Brown }
1567a2b7b749SLen Brown 
1568fcd17211SLen Brown static void
1569fcd17211SLen Brown dump_nhm_platform_info(void)
1570103a8feaSLen Brown {
1571103a8feaSLen Brown 	unsigned long long msr;
1572103a8feaSLen Brown 	unsigned int ratio;
1573103a8feaSLen Brown 
1574ec0adc53SLen Brown 	get_msr(base_cpu, MSR_PLATFORM_INFO, &msr);
1575103a8feaSLen Brown 
1576b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_PLATFORM_INFO: 0x%08llx\n", base_cpu, msr);
15776574a5d5SLen Brown 
1578103a8feaSLen Brown 	ratio = (msr >> 40) & 0xFF;
1579710f273bSLen Brown 	fprintf(outf, "%d * %.1f = %.1f MHz max efficiency frequency\n",
1580103a8feaSLen Brown 		ratio, bclk, ratio * bclk);
1581103a8feaSLen Brown 
1582103a8feaSLen Brown 	ratio = (msr >> 8) & 0xFF;
1583710f273bSLen Brown 	fprintf(outf, "%d * %.1f = %.1f MHz base frequency\n",
1584103a8feaSLen Brown 		ratio, bclk, ratio * bclk);
1585103a8feaSLen Brown 
15867ce7d5deSPrarit Bhargava 	get_msr(base_cpu, MSR_IA32_POWER_CTL, &msr);
1587b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_IA32_POWER_CTL: 0x%08llx (C1E auto-promotion: %sabled)\n",
1588bfae2052SLen Brown 		base_cpu, msr, msr & 0x2 ? "EN" : "DIS");
158967920418SLen Brown 
1590fcd17211SLen Brown 	return;
1591fcd17211SLen Brown }
1592fcd17211SLen Brown 
1593fcd17211SLen Brown static void
1594fcd17211SLen Brown dump_hsw_turbo_ratio_limits(void)
1595fcd17211SLen Brown {
1596fcd17211SLen Brown 	unsigned long long msr;
1597fcd17211SLen Brown 	unsigned int ratio;
1598fcd17211SLen Brown 
15997ce7d5deSPrarit Bhargava 	get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT2, &msr);
1600fcd17211SLen Brown 
1601b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT2: 0x%08llx\n", base_cpu, msr);
1602fcd17211SLen Brown 
1603fcd17211SLen Brown 	ratio = (msr >> 8) & 0xFF;
1604fcd17211SLen Brown 	if (ratio)
1605710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 18 active cores\n",
1606fcd17211SLen Brown 			ratio, bclk, ratio * bclk);
1607fcd17211SLen Brown 
1608fcd17211SLen Brown 	ratio = (msr >> 0) & 0xFF;
1609fcd17211SLen Brown 	if (ratio)
1610710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 17 active cores\n",
1611fcd17211SLen Brown 			ratio, bclk, ratio * bclk);
1612fcd17211SLen Brown 	return;
1613fcd17211SLen Brown }
1614fcd17211SLen Brown 
1615fcd17211SLen Brown static void
1616fcd17211SLen Brown dump_ivt_turbo_ratio_limits(void)
1617fcd17211SLen Brown {
1618fcd17211SLen Brown 	unsigned long long msr;
1619fcd17211SLen Brown 	unsigned int ratio;
16206574a5d5SLen Brown 
16217ce7d5deSPrarit Bhargava 	get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT1, &msr);
16226574a5d5SLen Brown 
1623b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT1: 0x%08llx\n", base_cpu, msr);
16246574a5d5SLen Brown 
16256574a5d5SLen Brown 	ratio = (msr >> 56) & 0xFF;
16266574a5d5SLen Brown 	if (ratio)
1627710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 16 active cores\n",
16286574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16296574a5d5SLen Brown 
16306574a5d5SLen Brown 	ratio = (msr >> 48) & 0xFF;
16316574a5d5SLen Brown 	if (ratio)
1632710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 15 active cores\n",
16336574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16346574a5d5SLen Brown 
16356574a5d5SLen Brown 	ratio = (msr >> 40) & 0xFF;
16366574a5d5SLen Brown 	if (ratio)
1637710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 14 active cores\n",
16386574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16396574a5d5SLen Brown 
16406574a5d5SLen Brown 	ratio = (msr >> 32) & 0xFF;
16416574a5d5SLen Brown 	if (ratio)
1642710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 13 active cores\n",
16436574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16446574a5d5SLen Brown 
16456574a5d5SLen Brown 	ratio = (msr >> 24) & 0xFF;
16466574a5d5SLen Brown 	if (ratio)
1647710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 12 active cores\n",
16486574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16496574a5d5SLen Brown 
16506574a5d5SLen Brown 	ratio = (msr >> 16) & 0xFF;
16516574a5d5SLen Brown 	if (ratio)
1652710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 11 active cores\n",
16536574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16546574a5d5SLen Brown 
16556574a5d5SLen Brown 	ratio = (msr >> 8) & 0xFF;
16566574a5d5SLen Brown 	if (ratio)
1657710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 10 active cores\n",
16586574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16596574a5d5SLen Brown 
16606574a5d5SLen Brown 	ratio = (msr >> 0) & 0xFF;
16616574a5d5SLen Brown 	if (ratio)
1662710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 9 active cores\n",
16636574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
1664103a8feaSLen Brown 	return;
1665fcd17211SLen Brown }
1666fcd17211SLen Brown 
1667fcd17211SLen Brown static void
1668fcd17211SLen Brown dump_nhm_turbo_ratio_limits(void)
1669fcd17211SLen Brown {
1670fcd17211SLen Brown 	unsigned long long msr;
1671fcd17211SLen Brown 	unsigned int ratio;
1672103a8feaSLen Brown 
16737ce7d5deSPrarit Bhargava 	get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT, &msr);
1674103a8feaSLen Brown 
1675b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT: 0x%08llx\n", base_cpu, msr);
16766574a5d5SLen Brown 
16776574a5d5SLen Brown 	ratio = (msr >> 56) & 0xFF;
16786574a5d5SLen Brown 	if (ratio)
1679710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 8 active cores\n",
16806574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16816574a5d5SLen Brown 
16826574a5d5SLen Brown 	ratio = (msr >> 48) & 0xFF;
16836574a5d5SLen Brown 	if (ratio)
1684710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 7 active cores\n",
16856574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16866574a5d5SLen Brown 
16876574a5d5SLen Brown 	ratio = (msr >> 40) & 0xFF;
16886574a5d5SLen Brown 	if (ratio)
1689710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 6 active cores\n",
16906574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16916574a5d5SLen Brown 
16926574a5d5SLen Brown 	ratio = (msr >> 32) & 0xFF;
16936574a5d5SLen Brown 	if (ratio)
1694710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 5 active cores\n",
16956574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
16966574a5d5SLen Brown 
1697103a8feaSLen Brown 	ratio = (msr >> 24) & 0xFF;
1698103a8feaSLen Brown 	if (ratio)
1699710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 4 active cores\n",
1700103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1701103a8feaSLen Brown 
1702103a8feaSLen Brown 	ratio = (msr >> 16) & 0xFF;
1703103a8feaSLen Brown 	if (ratio)
1704710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 3 active cores\n",
1705103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1706103a8feaSLen Brown 
1707103a8feaSLen Brown 	ratio = (msr >> 8) & 0xFF;
1708103a8feaSLen Brown 	if (ratio)
1709710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 2 active cores\n",
1710103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1711103a8feaSLen Brown 
1712103a8feaSLen Brown 	ratio = (msr >> 0) & 0xFF;
1713103a8feaSLen Brown 	if (ratio)
1714710f273bSLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 1 active cores\n",
1715103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1716fcd17211SLen Brown 	return;
1717fcd17211SLen Brown }
17183a9a941dSLen Brown 
1719fcd17211SLen Brown static void
17200f7887c4SLen Brown dump_atom_turbo_ratio_limits(void)
17210f7887c4SLen Brown {
17220f7887c4SLen Brown 	unsigned long long msr;
17230f7887c4SLen Brown 	unsigned int ratio;
17240f7887c4SLen Brown 
17250f7887c4SLen Brown 	get_msr(base_cpu, MSR_ATOM_CORE_RATIOS, &msr);
17260f7887c4SLen Brown 	fprintf(outf, "cpu%d: MSR_ATOM_CORE_RATIOS: 0x%08llx\n", base_cpu, msr & 0xFFFFFFFF);
17270f7887c4SLen Brown 
17280f7887c4SLen Brown 	ratio = (msr >> 0) & 0x3F;
17290f7887c4SLen Brown 	if (ratio)
17300f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz minimum operating frequency\n",
17310f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17320f7887c4SLen Brown 
17330f7887c4SLen Brown 	ratio = (msr >> 8) & 0x3F;
17340f7887c4SLen Brown 	if (ratio)
17350f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz low frequency mode (LFM)\n",
17360f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17370f7887c4SLen Brown 
17380f7887c4SLen Brown 	ratio = (msr >> 16) & 0x3F;
17390f7887c4SLen Brown 	if (ratio)
17400f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz base frequency\n",
17410f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17420f7887c4SLen Brown 
17430f7887c4SLen Brown 	get_msr(base_cpu, MSR_ATOM_CORE_TURBO_RATIOS, &msr);
17440f7887c4SLen Brown 	fprintf(outf, "cpu%d: MSR_ATOM_CORE_TURBO_RATIOS: 0x%08llx\n", base_cpu, msr & 0xFFFFFFFF);
17450f7887c4SLen Brown 
17460f7887c4SLen Brown 	ratio = (msr >> 24) & 0x3F;
17470f7887c4SLen Brown 	if (ratio)
17480f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 4 active cores\n",
17490f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17500f7887c4SLen Brown 
17510f7887c4SLen Brown 	ratio = (msr >> 16) & 0x3F;
17520f7887c4SLen Brown 	if (ratio)
17530f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 3 active cores\n",
17540f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17550f7887c4SLen Brown 
17560f7887c4SLen Brown 	ratio = (msr >> 8) & 0x3F;
17570f7887c4SLen Brown 	if (ratio)
17580f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 2 active cores\n",
17590f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17600f7887c4SLen Brown 
17610f7887c4SLen Brown 	ratio = (msr >> 0) & 0x3F;
17620f7887c4SLen Brown 	if (ratio)
17630f7887c4SLen Brown 		fprintf(outf, "%d * %.1f = %.1f MHz max turbo 1 active core\n",
17640f7887c4SLen Brown 			ratio, bclk, ratio * bclk);
17650f7887c4SLen Brown }
17660f7887c4SLen Brown 
17670f7887c4SLen Brown static void
1768fb5d4327SDasaratharaman Chandramouli dump_knl_turbo_ratio_limits(void)
1769fb5d4327SDasaratharaman Chandramouli {
1770cbf97abaSHubert Chrzaniuk 	const unsigned int buckets_no = 7;
1771cbf97abaSHubert Chrzaniuk 
1772fb5d4327SDasaratharaman Chandramouli 	unsigned long long msr;
1773cbf97abaSHubert Chrzaniuk 	int delta_cores, delta_ratio;
1774cbf97abaSHubert Chrzaniuk 	int i, b_nr;
1775cbf97abaSHubert Chrzaniuk 	unsigned int cores[buckets_no];
1776cbf97abaSHubert Chrzaniuk 	unsigned int ratio[buckets_no];
1777fb5d4327SDasaratharaman Chandramouli 
1778ebf5926aSSrinivas Pandruvada 	get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT, &msr);
1779fb5d4327SDasaratharaman Chandramouli 
1780b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT: 0x%08llx\n",
1781bfae2052SLen Brown 		base_cpu, msr);
1782fb5d4327SDasaratharaman Chandramouli 
1783fb5d4327SDasaratharaman Chandramouli 	/**
1784fb5d4327SDasaratharaman Chandramouli 	 * Turbo encoding in KNL is as follows:
1785cbf97abaSHubert Chrzaniuk 	 * [0] -- Reserved
1786cbf97abaSHubert Chrzaniuk 	 * [7:1] -- Base value of number of active cores of bucket 1.
1787fb5d4327SDasaratharaman Chandramouli 	 * [15:8] -- Base value of freq ratio of bucket 1.
1788fb5d4327SDasaratharaman Chandramouli 	 * [20:16] -- +ve delta of number of active cores of bucket 2.
1789fb5d4327SDasaratharaman Chandramouli 	 * i.e. active cores of bucket 2 =
1790fb5d4327SDasaratharaman Chandramouli 	 * active cores of bucket 1 + delta
1791fb5d4327SDasaratharaman Chandramouli 	 * [23:21] -- Negative delta of freq ratio of bucket 2.
1792fb5d4327SDasaratharaman Chandramouli 	 * i.e. freq ratio of bucket 2 =
1793fb5d4327SDasaratharaman Chandramouli 	 * freq ratio of bucket 1 - delta
1794fb5d4327SDasaratharaman Chandramouli 	 * [28:24]-- +ve delta of number of active cores of bucket 3.
1795fb5d4327SDasaratharaman Chandramouli 	 * [31:29]-- -ve delta of freq ratio of bucket 3.
1796fb5d4327SDasaratharaman Chandramouli 	 * [36:32]-- +ve delta of number of active cores of bucket 4.
1797fb5d4327SDasaratharaman Chandramouli 	 * [39:37]-- -ve delta of freq ratio of bucket 4.
1798fb5d4327SDasaratharaman Chandramouli 	 * [44:40]-- +ve delta of number of active cores of bucket 5.
1799fb5d4327SDasaratharaman Chandramouli 	 * [47:45]-- -ve delta of freq ratio of bucket 5.
1800fb5d4327SDasaratharaman Chandramouli 	 * [52:48]-- +ve delta of number of active cores of bucket 6.
1801fb5d4327SDasaratharaman Chandramouli 	 * [55:53]-- -ve delta of freq ratio of bucket 6.
1802fb5d4327SDasaratharaman Chandramouli 	 * [60:56]-- +ve delta of number of active cores of bucket 7.
1803fb5d4327SDasaratharaman Chandramouli 	 * [63:61]-- -ve delta of freq ratio of bucket 7.
1804fb5d4327SDasaratharaman Chandramouli 	 */
1805fb5d4327SDasaratharaman Chandramouli 
1806cbf97abaSHubert Chrzaniuk 	b_nr = 0;
1807cbf97abaSHubert Chrzaniuk 	cores[b_nr] = (msr & 0xFF) >> 1;
1808cbf97abaSHubert Chrzaniuk 	ratio[b_nr] = (msr >> 8) & 0xFF;
1809cbf97abaSHubert Chrzaniuk 
1810cbf97abaSHubert Chrzaniuk 	for (i = 16; i < 64; i += 8) {
1811fb5d4327SDasaratharaman Chandramouli 		delta_cores = (msr >> i) & 0x1F;
1812cbf97abaSHubert Chrzaniuk 		delta_ratio = (msr >> (i + 5)) & 0x7;
1813fb5d4327SDasaratharaman Chandramouli 
1814cbf97abaSHubert Chrzaniuk 		cores[b_nr + 1] = cores[b_nr] + delta_cores;
1815cbf97abaSHubert Chrzaniuk 		ratio[b_nr + 1] = ratio[b_nr] - delta_ratio;
1816cbf97abaSHubert Chrzaniuk 		b_nr++;
1817fb5d4327SDasaratharaman Chandramouli 	}
1818cbf97abaSHubert Chrzaniuk 
1819cbf97abaSHubert Chrzaniuk 	for (i = buckets_no - 1; i >= 0; i--)
1820cbf97abaSHubert Chrzaniuk 		if (i > 0 ? ratio[i] != ratio[i - 1] : 1)
1821b7d8c148SLen Brown 			fprintf(outf,
1822710f273bSLen Brown 				"%d * %.1f = %.1f MHz max turbo %d active cores\n",
1823cbf97abaSHubert Chrzaniuk 				ratio[i], bclk, ratio[i] * bclk, cores[i]);
1824fb5d4327SDasaratharaman Chandramouli }
1825fb5d4327SDasaratharaman Chandramouli 
1826fb5d4327SDasaratharaman Chandramouli static void
1827fcd17211SLen Brown dump_nhm_cst_cfg(void)
1828fcd17211SLen Brown {
1829fcd17211SLen Brown 	unsigned long long msr;
1830fcd17211SLen Brown 
18311df2e55aSLen Brown 	get_msr(base_cpu, MSR_PKG_CST_CONFIG_CONTROL, &msr);
1832fcd17211SLen Brown 
1833fcd17211SLen Brown #define SNB_C1_AUTO_UNDEMOTE              (1UL << 27)
1834fcd17211SLen Brown #define SNB_C3_AUTO_UNDEMOTE              (1UL << 28)
1835fcd17211SLen Brown 
18361df2e55aSLen Brown 	fprintf(outf, "cpu%d: MSR_PKG_CST_CONFIG_CONTROL: 0x%08llx", base_cpu, msr);
1837fcd17211SLen Brown 
1838b7d8c148SLen Brown 	fprintf(outf, " (%s%s%s%s%slocked: pkg-cstate-limit=%d: %s)\n",
1839fcd17211SLen Brown 		(msr & SNB_C3_AUTO_UNDEMOTE) ? "UNdemote-C3, " : "",
1840fcd17211SLen Brown 		(msr & SNB_C1_AUTO_UNDEMOTE) ? "UNdemote-C1, " : "",
1841fcd17211SLen Brown 		(msr & NHM_C3_AUTO_DEMOTE) ? "demote-C3, " : "",
1842fcd17211SLen Brown 		(msr & NHM_C1_AUTO_DEMOTE) ? "demote-C1, " : "",
1843fcd17211SLen Brown 		(msr & (1 << 15)) ? "" : "UN",
18446c34f160SLen Brown 		(unsigned int)msr & 0xF,
1845fcd17211SLen Brown 		pkg_cstate_limit_strings[pkg_cstate_limit]);
1846fcd17211SLen Brown 	return;
1847103a8feaSLen Brown }
1848103a8feaSLen Brown 
18496fb3143bSLen Brown static void
18506fb3143bSLen Brown dump_config_tdp(void)
18516fb3143bSLen Brown {
18526fb3143bSLen Brown 	unsigned long long msr;
18536fb3143bSLen Brown 
18546fb3143bSLen Brown 	get_msr(base_cpu, MSR_CONFIG_TDP_NOMINAL, &msr);
1855b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_CONFIG_TDP_NOMINAL: 0x%08llx", base_cpu, msr);
1856685b535bSChen Yu 	fprintf(outf, " (base_ratio=%d)\n", (unsigned int)msr & 0xFF);
18576fb3143bSLen Brown 
18586fb3143bSLen Brown 	get_msr(base_cpu, MSR_CONFIG_TDP_LEVEL_1, &msr);
1859b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_CONFIG_TDP_LEVEL_1: 0x%08llx (", base_cpu, msr);
18606fb3143bSLen Brown 	if (msr) {
1861685b535bSChen Yu 		fprintf(outf, "PKG_MIN_PWR_LVL1=%d ", (unsigned int)(msr >> 48) & 0x7FFF);
1862685b535bSChen Yu 		fprintf(outf, "PKG_MAX_PWR_LVL1=%d ", (unsigned int)(msr >> 32) & 0x7FFF);
1863685b535bSChen Yu 		fprintf(outf, "LVL1_RATIO=%d ", (unsigned int)(msr >> 16) & 0xFF);
1864685b535bSChen Yu 		fprintf(outf, "PKG_TDP_LVL1=%d", (unsigned int)(msr) & 0x7FFF);
18656fb3143bSLen Brown 	}
1866b7d8c148SLen Brown 	fprintf(outf, ")\n");
18676fb3143bSLen Brown 
18686fb3143bSLen Brown 	get_msr(base_cpu, MSR_CONFIG_TDP_LEVEL_2, &msr);
1869b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_CONFIG_TDP_LEVEL_2: 0x%08llx (", base_cpu, msr);
18706fb3143bSLen Brown 	if (msr) {
1871685b535bSChen Yu 		fprintf(outf, "PKG_MIN_PWR_LVL2=%d ", (unsigned int)(msr >> 48) & 0x7FFF);
1872685b535bSChen Yu 		fprintf(outf, "PKG_MAX_PWR_LVL2=%d ", (unsigned int)(msr >> 32) & 0x7FFF);
1873685b535bSChen Yu 		fprintf(outf, "LVL2_RATIO=%d ", (unsigned int)(msr >> 16) & 0xFF);
1874685b535bSChen Yu 		fprintf(outf, "PKG_TDP_LVL2=%d", (unsigned int)(msr) & 0x7FFF);
18756fb3143bSLen Brown 	}
1876b7d8c148SLen Brown 	fprintf(outf, ")\n");
18776fb3143bSLen Brown 
18786fb3143bSLen Brown 	get_msr(base_cpu, MSR_CONFIG_TDP_CONTROL, &msr);
1879b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_CONFIG_TDP_CONTROL: 0x%08llx (", base_cpu, msr);
18806fb3143bSLen Brown 	if ((msr) & 0x3)
1881b7d8c148SLen Brown 		fprintf(outf, "TDP_LEVEL=%d ", (unsigned int)(msr) & 0x3);
1882b7d8c148SLen Brown 	fprintf(outf, " lock=%d", (unsigned int)(msr >> 31) & 1);
1883b7d8c148SLen Brown 	fprintf(outf, ")\n");
18846fb3143bSLen Brown 
18856fb3143bSLen Brown 	get_msr(base_cpu, MSR_TURBO_ACTIVATION_RATIO, &msr);
1886b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_TURBO_ACTIVATION_RATIO: 0x%08llx (", base_cpu, msr);
1887685b535bSChen Yu 	fprintf(outf, "MAX_NON_TURBO_RATIO=%d", (unsigned int)(msr) & 0xFF);
1888b7d8c148SLen Brown 	fprintf(outf, " lock=%d", (unsigned int)(msr >> 31) & 1);
1889b7d8c148SLen Brown 	fprintf(outf, ")\n");
18906fb3143bSLen Brown }
18915a63426eSLen Brown 
18925a63426eSLen Brown unsigned int irtl_time_units[] = {1, 32, 1024, 32768, 1048576, 33554432, 0, 0 };
18935a63426eSLen Brown 
18945a63426eSLen Brown void print_irtl(void)
18955a63426eSLen Brown {
18965a63426eSLen Brown 	unsigned long long msr;
18975a63426eSLen Brown 
18985a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC3_IRTL, &msr);
18995a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC3_IRTL: 0x%08llx (", base_cpu, msr);
19005a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19015a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19025a63426eSLen Brown 
19035a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC6_IRTL, &msr);
19045a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC6_IRTL: 0x%08llx (", base_cpu, msr);
19055a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19065a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19075a63426eSLen Brown 
19085a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC7_IRTL, &msr);
19095a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC7_IRTL: 0x%08llx (", base_cpu, msr);
19105a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19115a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19125a63426eSLen Brown 
19135a63426eSLen Brown 	if (!do_irtl_hsw)
19145a63426eSLen Brown 		return;
19155a63426eSLen Brown 
19165a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC8_IRTL, &msr);
19175a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC8_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 	get_msr(base_cpu, MSR_PKGC9_IRTL, &msr);
19225a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC9_IRTL: 0x%08llx (", base_cpu, msr);
19235a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19245a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19255a63426eSLen Brown 
19265a63426eSLen Brown 	get_msr(base_cpu, MSR_PKGC10_IRTL, &msr);
19275a63426eSLen Brown 	fprintf(outf, "cpu%d: MSR_PKGC10_IRTL: 0x%08llx (", base_cpu, msr);
19285a63426eSLen Brown 	fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
19295a63426eSLen Brown 		(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
19305a63426eSLen Brown 
19315a63426eSLen Brown }
193236229897SLen Brown void free_fd_percpu(void)
193336229897SLen Brown {
193436229897SLen Brown 	int i;
193536229897SLen Brown 
193601a67adfSMika Westerberg 	for (i = 0; i < topo.max_cpu_num + 1; ++i) {
193736229897SLen Brown 		if (fd_percpu[i] != 0)
193836229897SLen Brown 			close(fd_percpu[i]);
193936229897SLen Brown 	}
194036229897SLen Brown 
194136229897SLen Brown 	free(fd_percpu);
19426fb3143bSLen Brown }
19436fb3143bSLen Brown 
1944c98d5d94SLen Brown void free_all_buffers(void)
1945103a8feaSLen Brown {
1946c98d5d94SLen Brown 	CPU_FREE(cpu_present_set);
1947c98d5d94SLen Brown 	cpu_present_set = NULL;
194836229897SLen Brown 	cpu_present_setsize = 0;
1949103a8feaSLen Brown 
1950c98d5d94SLen Brown 	CPU_FREE(cpu_affinity_set);
1951c98d5d94SLen Brown 	cpu_affinity_set = NULL;
1952c98d5d94SLen Brown 	cpu_affinity_setsize = 0;
1953103a8feaSLen Brown 
1954c98d5d94SLen Brown 	free(thread_even);
1955c98d5d94SLen Brown 	free(core_even);
1956c98d5d94SLen Brown 	free(package_even);
1957103a8feaSLen Brown 
1958c98d5d94SLen Brown 	thread_even = NULL;
1959c98d5d94SLen Brown 	core_even = NULL;
1960c98d5d94SLen Brown 	package_even = NULL;
1961103a8feaSLen Brown 
1962c98d5d94SLen Brown 	free(thread_odd);
1963c98d5d94SLen Brown 	free(core_odd);
1964c98d5d94SLen Brown 	free(package_odd);
1965103a8feaSLen Brown 
1966c98d5d94SLen Brown 	thread_odd = NULL;
1967c98d5d94SLen Brown 	core_odd = NULL;
1968c98d5d94SLen Brown 	package_odd = NULL;
1969103a8feaSLen Brown 
1970c98d5d94SLen Brown 	free(output_buffer);
1971c98d5d94SLen Brown 	output_buffer = NULL;
1972c98d5d94SLen Brown 	outp = NULL;
197336229897SLen Brown 
197436229897SLen Brown 	free_fd_percpu();
1975562a2d37SLen Brown 
1976562a2d37SLen Brown 	free(irq_column_2_cpu);
1977562a2d37SLen Brown 	free(irqs_per_cpu);
1978103a8feaSLen Brown }
1979103a8feaSLen Brown 
1980103a8feaSLen Brown /*
198157a42a34SJosh Triplett  * Open a file, and exit on failure
198257a42a34SJosh Triplett  */
198357a42a34SJosh Triplett FILE *fopen_or_die(const char *path, const char *mode)
198457a42a34SJosh Triplett {
1985b7d8c148SLen Brown 	FILE *filep = fopen(path, mode);
1986b2c95d90SJosh Triplett 	if (!filep)
1987b2c95d90SJosh Triplett 		err(1, "%s: open failed", path);
198857a42a34SJosh Triplett 	return filep;
198957a42a34SJosh Triplett }
199057a42a34SJosh Triplett 
199157a42a34SJosh Triplett /*
199295aebc44SJosh Triplett  * Parse a file containing a single int.
199395aebc44SJosh Triplett  */
199495aebc44SJosh Triplett int parse_int_file(const char *fmt, ...)
199595aebc44SJosh Triplett {
199695aebc44SJosh Triplett 	va_list args;
199795aebc44SJosh Triplett 	char path[PATH_MAX];
199895aebc44SJosh Triplett 	FILE *filep;
199995aebc44SJosh Triplett 	int value;
200095aebc44SJosh Triplett 
200195aebc44SJosh Triplett 	va_start(args, fmt);
200295aebc44SJosh Triplett 	vsnprintf(path, sizeof(path), fmt, args);
200395aebc44SJosh Triplett 	va_end(args);
200457a42a34SJosh Triplett 	filep = fopen_or_die(path, "r");
2005b2c95d90SJosh Triplett 	if (fscanf(filep, "%d", &value) != 1)
2006b2c95d90SJosh Triplett 		err(1, "%s: failed to parse number from file", path);
200795aebc44SJosh Triplett 	fclose(filep);
200895aebc44SJosh Triplett 	return value;
200995aebc44SJosh Triplett }
201095aebc44SJosh Triplett 
201195aebc44SJosh Triplett /*
2012e275b388SDasaratharaman Chandramouli  * get_cpu_position_in_core(cpu)
2013e275b388SDasaratharaman Chandramouli  * return the position of the CPU among its HT siblings in the core
2014e275b388SDasaratharaman Chandramouli  * return -1 if the sibling is not in list
2015103a8feaSLen Brown  */
2016e275b388SDasaratharaman Chandramouli int get_cpu_position_in_core(int cpu)
2017103a8feaSLen Brown {
2018e275b388SDasaratharaman Chandramouli 	char path[64];
2019e275b388SDasaratharaman Chandramouli 	FILE *filep;
2020e275b388SDasaratharaman Chandramouli 	int this_cpu;
2021e275b388SDasaratharaman Chandramouli 	char character;
2022e275b388SDasaratharaman Chandramouli 	int i;
2023e275b388SDasaratharaman Chandramouli 
2024e275b388SDasaratharaman Chandramouli 	sprintf(path,
2025e275b388SDasaratharaman Chandramouli 		"/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list",
2026e275b388SDasaratharaman Chandramouli 		cpu);
2027e275b388SDasaratharaman Chandramouli 	filep = fopen(path, "r");
2028e275b388SDasaratharaman Chandramouli 	if (filep == NULL) {
2029e275b388SDasaratharaman Chandramouli 		perror(path);
2030e275b388SDasaratharaman Chandramouli 		exit(1);
2031e275b388SDasaratharaman Chandramouli 	}
2032e275b388SDasaratharaman Chandramouli 
2033e275b388SDasaratharaman Chandramouli 	for (i = 0; i < topo.num_threads_per_core; i++) {
2034e275b388SDasaratharaman Chandramouli 		fscanf(filep, "%d", &this_cpu);
2035e275b388SDasaratharaman Chandramouli 		if (this_cpu == cpu) {
2036e275b388SDasaratharaman Chandramouli 			fclose(filep);
2037e275b388SDasaratharaman Chandramouli 			return i;
2038e275b388SDasaratharaman Chandramouli 		}
2039e275b388SDasaratharaman Chandramouli 
2040e275b388SDasaratharaman Chandramouli 		/* Account for no separator after last thread*/
2041e275b388SDasaratharaman Chandramouli 		if (i != (topo.num_threads_per_core - 1))
2042e275b388SDasaratharaman Chandramouli 			fscanf(filep, "%c", &character);
2043e275b388SDasaratharaman Chandramouli 	}
2044e275b388SDasaratharaman Chandramouli 
2045e275b388SDasaratharaman Chandramouli 	fclose(filep);
2046e275b388SDasaratharaman Chandramouli 	return -1;
2047c98d5d94SLen Brown }
2048103a8feaSLen Brown 
2049c98d5d94SLen Brown /*
2050c98d5d94SLen Brown  * cpu_is_first_core_in_package(cpu)
2051c98d5d94SLen Brown  * return 1 if given CPU is 1st core in package
2052c98d5d94SLen Brown  */
2053c98d5d94SLen Brown int cpu_is_first_core_in_package(int cpu)
2054c98d5d94SLen Brown {
205595aebc44SJosh Triplett 	return cpu == parse_int_file("/sys/devices/system/cpu/cpu%d/topology/core_siblings_list", cpu);
2056103a8feaSLen Brown }
2057103a8feaSLen Brown 
2058103a8feaSLen Brown int get_physical_package_id(int cpu)
2059103a8feaSLen Brown {
206095aebc44SJosh Triplett 	return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/physical_package_id", cpu);
2061103a8feaSLen Brown }
2062103a8feaSLen Brown 
2063103a8feaSLen Brown int get_core_id(int cpu)
2064103a8feaSLen Brown {
206595aebc44SJosh Triplett 	return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/core_id", cpu);
2066103a8feaSLen Brown }
2067103a8feaSLen Brown 
2068c98d5d94SLen Brown int get_num_ht_siblings(int cpu)
2069c98d5d94SLen Brown {
2070c98d5d94SLen Brown 	char path[80];
2071c98d5d94SLen Brown 	FILE *filep;
2072e275b388SDasaratharaman Chandramouli 	int sib1;
2073e275b388SDasaratharaman Chandramouli 	int matches = 0;
2074c98d5d94SLen Brown 	char character;
2075e275b388SDasaratharaman Chandramouli 	char str[100];
2076e275b388SDasaratharaman Chandramouli 	char *ch;
2077c98d5d94SLen Brown 
2078c98d5d94SLen Brown 	sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", cpu);
207957a42a34SJosh Triplett 	filep = fopen_or_die(path, "r");
2080e275b388SDasaratharaman Chandramouli 
2081103a8feaSLen Brown 	/*
2082c98d5d94SLen Brown 	 * file format:
2083e275b388SDasaratharaman Chandramouli 	 * A ',' separated or '-' separated set of numbers
2084e275b388SDasaratharaman Chandramouli 	 * (eg 1-2 or 1,3,4,5)
2085c98d5d94SLen Brown 	 */
2086e275b388SDasaratharaman Chandramouli 	fscanf(filep, "%d%c\n", &sib1, &character);
2087e275b388SDasaratharaman Chandramouli 	fseek(filep, 0, SEEK_SET);
2088e275b388SDasaratharaman Chandramouli 	fgets(str, 100, filep);
2089e275b388SDasaratharaman Chandramouli 	ch = strchr(str, character);
2090e275b388SDasaratharaman Chandramouli 	while (ch != NULL) {
2091e275b388SDasaratharaman Chandramouli 		matches++;
2092e275b388SDasaratharaman Chandramouli 		ch = strchr(ch+1, character);
2093e275b388SDasaratharaman Chandramouli 	}
2094c98d5d94SLen Brown 
2095c98d5d94SLen Brown 	fclose(filep);
2096e275b388SDasaratharaman Chandramouli 	return matches+1;
2097c98d5d94SLen Brown }
2098c98d5d94SLen Brown 
2099c98d5d94SLen Brown /*
2100c98d5d94SLen Brown  * run func(thread, core, package) in topology order
2101c98d5d94SLen Brown  * skip non-present cpus
2102103a8feaSLen Brown  */
2103103a8feaSLen Brown 
2104c98d5d94SLen Brown int for_all_cpus_2(int (func)(struct thread_data *, struct core_data *,
2105c98d5d94SLen Brown 	struct pkg_data *, struct thread_data *, struct core_data *,
2106c98d5d94SLen Brown 	struct pkg_data *), struct thread_data *thread_base,
2107c98d5d94SLen Brown 	struct core_data *core_base, struct pkg_data *pkg_base,
2108c98d5d94SLen Brown 	struct thread_data *thread_base2, struct core_data *core_base2,
2109c98d5d94SLen Brown 	struct pkg_data *pkg_base2)
2110c98d5d94SLen Brown {
2111c98d5d94SLen Brown 	int retval, pkg_no, core_no, thread_no;
2112c98d5d94SLen Brown 
2113c98d5d94SLen Brown 	for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
2114c98d5d94SLen Brown 		for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
2115c98d5d94SLen Brown 			for (thread_no = 0; thread_no <
2116c98d5d94SLen Brown 				topo.num_threads_per_core; ++thread_no) {
2117c98d5d94SLen Brown 				struct thread_data *t, *t2;
2118c98d5d94SLen Brown 				struct core_data *c, *c2;
2119c98d5d94SLen Brown 				struct pkg_data *p, *p2;
2120c98d5d94SLen Brown 
2121c98d5d94SLen Brown 				t = GET_THREAD(thread_base, thread_no, core_no, pkg_no);
2122c98d5d94SLen Brown 
2123c98d5d94SLen Brown 				if (cpu_is_not_present(t->cpu_id))
2124c98d5d94SLen Brown 					continue;
2125c98d5d94SLen Brown 
2126c98d5d94SLen Brown 				t2 = GET_THREAD(thread_base2, thread_no, core_no, pkg_no);
2127c98d5d94SLen Brown 
2128c98d5d94SLen Brown 				c = GET_CORE(core_base, core_no, pkg_no);
2129c98d5d94SLen Brown 				c2 = GET_CORE(core_base2, core_no, pkg_no);
2130c98d5d94SLen Brown 
2131c98d5d94SLen Brown 				p = GET_PKG(pkg_base, pkg_no);
2132c98d5d94SLen Brown 				p2 = GET_PKG(pkg_base2, pkg_no);
2133c98d5d94SLen Brown 
2134c98d5d94SLen Brown 				retval = func(t, c, p, t2, c2, p2);
2135c98d5d94SLen Brown 				if (retval)
2136c98d5d94SLen Brown 					return retval;
2137c98d5d94SLen Brown 			}
2138c98d5d94SLen Brown 		}
2139c98d5d94SLen Brown 	}
2140c98d5d94SLen Brown 	return 0;
2141c98d5d94SLen Brown }
2142c98d5d94SLen Brown 
2143c98d5d94SLen Brown /*
2144c98d5d94SLen Brown  * run func(cpu) on every cpu in /proc/stat
2145c98d5d94SLen Brown  * return max_cpu number
2146c98d5d94SLen Brown  */
2147c98d5d94SLen Brown int for_all_proc_cpus(int (func)(int))
2148103a8feaSLen Brown {
2149103a8feaSLen Brown 	FILE *fp;
2150c98d5d94SLen Brown 	int cpu_num;
2151103a8feaSLen Brown 	int retval;
2152103a8feaSLen Brown 
215357a42a34SJosh Triplett 	fp = fopen_or_die(proc_stat, "r");
2154103a8feaSLen Brown 
2155103a8feaSLen Brown 	retval = fscanf(fp, "cpu %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n");
2156b2c95d90SJosh Triplett 	if (retval != 0)
2157b2c95d90SJosh Triplett 		err(1, "%s: failed to parse format", proc_stat);
2158103a8feaSLen Brown 
2159c98d5d94SLen Brown 	while (1) {
2160c98d5d94SLen Brown 		retval = fscanf(fp, "cpu%u %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n", &cpu_num);
2161103a8feaSLen Brown 		if (retval != 1)
2162103a8feaSLen Brown 			break;
2163103a8feaSLen Brown 
2164c98d5d94SLen Brown 		retval = func(cpu_num);
2165c98d5d94SLen Brown 		if (retval) {
2166c98d5d94SLen Brown 			fclose(fp);
2167c98d5d94SLen Brown 			return(retval);
2168c98d5d94SLen Brown 		}
2169103a8feaSLen Brown 	}
2170103a8feaSLen Brown 	fclose(fp);
2171c98d5d94SLen Brown 	return 0;
2172103a8feaSLen Brown }
2173103a8feaSLen Brown 
2174103a8feaSLen Brown void re_initialize(void)
2175103a8feaSLen Brown {
2176c98d5d94SLen Brown 	free_all_buffers();
2177c98d5d94SLen Brown 	setup_all_buffers();
2178c98d5d94SLen Brown 	printf("turbostat: re-initialized with num_cpus %d\n", topo.num_cpus);
2179103a8feaSLen Brown }
2180103a8feaSLen Brown 
2181c98d5d94SLen Brown 
2182103a8feaSLen Brown /*
2183c98d5d94SLen Brown  * count_cpus()
2184c98d5d94SLen Brown  * remember the last one seen, it will be the max
2185103a8feaSLen Brown  */
2186c98d5d94SLen Brown int count_cpus(int cpu)
2187103a8feaSLen Brown {
2188c98d5d94SLen Brown 	if (topo.max_cpu_num < cpu)
2189c98d5d94SLen Brown 		topo.max_cpu_num = cpu;
2190103a8feaSLen Brown 
2191c98d5d94SLen Brown 	topo.num_cpus += 1;
2192c98d5d94SLen Brown 	return 0;
2193103a8feaSLen Brown }
2194c98d5d94SLen Brown int mark_cpu_present(int cpu)
2195c98d5d94SLen Brown {
2196c98d5d94SLen Brown 	CPU_SET_S(cpu, cpu_present_setsize, cpu_present_set);
219715aaa346SLen Brown 	return 0;
2198103a8feaSLen Brown }
2199103a8feaSLen Brown 
2200562a2d37SLen Brown /*
2201562a2d37SLen Brown  * snapshot_proc_interrupts()
2202562a2d37SLen Brown  *
2203562a2d37SLen Brown  * read and record summary of /proc/interrupts
2204562a2d37SLen Brown  *
2205562a2d37SLen Brown  * return 1 if config change requires a restart, else return 0
2206562a2d37SLen Brown  */
2207562a2d37SLen Brown int snapshot_proc_interrupts(void)
2208562a2d37SLen Brown {
2209562a2d37SLen Brown 	static FILE *fp;
2210562a2d37SLen Brown 	int column, retval;
2211562a2d37SLen Brown 
2212562a2d37SLen Brown 	if (fp == NULL)
2213562a2d37SLen Brown 		fp = fopen_or_die("/proc/interrupts", "r");
2214562a2d37SLen Brown 	else
2215562a2d37SLen Brown 		rewind(fp);
2216562a2d37SLen Brown 
2217562a2d37SLen Brown 	/* read 1st line of /proc/interrupts to get cpu* name for each column */
2218562a2d37SLen Brown 	for (column = 0; column < topo.num_cpus; ++column) {
2219562a2d37SLen Brown 		int cpu_number;
2220562a2d37SLen Brown 
2221562a2d37SLen Brown 		retval = fscanf(fp, " CPU%d", &cpu_number);
2222562a2d37SLen Brown 		if (retval != 1)
2223562a2d37SLen Brown 			break;
2224562a2d37SLen Brown 
2225562a2d37SLen Brown 		if (cpu_number > topo.max_cpu_num) {
2226562a2d37SLen Brown 			warn("/proc/interrupts: cpu%d: > %d", cpu_number, topo.max_cpu_num);
2227562a2d37SLen Brown 			return 1;
2228562a2d37SLen Brown 		}
2229562a2d37SLen Brown 
2230562a2d37SLen Brown 		irq_column_2_cpu[column] = cpu_number;
2231562a2d37SLen Brown 		irqs_per_cpu[cpu_number] = 0;
2232562a2d37SLen Brown 	}
2233562a2d37SLen Brown 
2234562a2d37SLen Brown 	/* read /proc/interrupt count lines and sum up irqs per cpu */
2235562a2d37SLen Brown 	while (1) {
2236562a2d37SLen Brown 		int column;
2237562a2d37SLen Brown 		char buf[64];
2238562a2d37SLen Brown 
2239562a2d37SLen Brown 		retval = fscanf(fp, " %s:", buf);	/* flush irq# "N:" */
2240562a2d37SLen Brown 		if (retval != 1)
2241562a2d37SLen Brown 			break;
2242562a2d37SLen Brown 
2243562a2d37SLen Brown 		/* read the count per cpu */
2244562a2d37SLen Brown 		for (column = 0; column < topo.num_cpus; ++column) {
2245562a2d37SLen Brown 
2246562a2d37SLen Brown 			int cpu_number, irq_count;
2247562a2d37SLen Brown 
2248562a2d37SLen Brown 			retval = fscanf(fp, " %d", &irq_count);
2249562a2d37SLen Brown 			if (retval != 1)
2250562a2d37SLen Brown 				break;
2251562a2d37SLen Brown 
2252562a2d37SLen Brown 			cpu_number = irq_column_2_cpu[column];
2253562a2d37SLen Brown 			irqs_per_cpu[cpu_number] += irq_count;
2254562a2d37SLen Brown 
2255562a2d37SLen Brown 		}
2256562a2d37SLen Brown 
2257562a2d37SLen Brown 		while (getc(fp) != '\n')
2258562a2d37SLen Brown 			;	/* flush interrupt description */
2259562a2d37SLen Brown 
2260562a2d37SLen Brown 	}
2261562a2d37SLen Brown 	return 0;
2262562a2d37SLen Brown }
226327d47356SLen Brown /*
2264fdf676e5SLen Brown  * snapshot_gfx_rc6_ms()
2265fdf676e5SLen Brown  *
2266fdf676e5SLen Brown  * record snapshot of
2267fdf676e5SLen Brown  * /sys/class/drm/card0/power/rc6_residency_ms
2268fdf676e5SLen Brown  *
2269fdf676e5SLen Brown  * return 1 if config change requires a restart, else return 0
2270fdf676e5SLen Brown  */
2271fdf676e5SLen Brown int snapshot_gfx_rc6_ms(void)
2272fdf676e5SLen Brown {
2273fdf676e5SLen Brown 	FILE *fp;
2274fdf676e5SLen Brown 	int retval;
2275fdf676e5SLen Brown 
2276fdf676e5SLen Brown 	fp = fopen_or_die("/sys/class/drm/card0/power/rc6_residency_ms", "r");
2277fdf676e5SLen Brown 
2278fdf676e5SLen Brown 	retval = fscanf(fp, "%lld", &gfx_cur_rc6_ms);
2279fdf676e5SLen Brown 	if (retval != 1)
2280fdf676e5SLen Brown 		err(1, "GFX rc6");
2281fdf676e5SLen Brown 
2282fdf676e5SLen Brown 	fclose(fp);
2283fdf676e5SLen Brown 
2284fdf676e5SLen Brown 	return 0;
2285fdf676e5SLen Brown }
2286fdf676e5SLen Brown /*
228727d47356SLen Brown  * snapshot_gfx_mhz()
228827d47356SLen Brown  *
228927d47356SLen Brown  * record snapshot of
229027d47356SLen Brown  * /sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz
229127d47356SLen Brown  *
229227d47356SLen Brown  * return 1 if config change requires a restart, else return 0
229327d47356SLen Brown  */
229427d47356SLen Brown int snapshot_gfx_mhz(void)
229527d47356SLen Brown {
229627d47356SLen Brown 	static FILE *fp;
229727d47356SLen Brown 	int retval;
229827d47356SLen Brown 
229927d47356SLen Brown 	if (fp == NULL)
230027d47356SLen Brown 		fp = fopen_or_die("/sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz", "r");
230127d47356SLen Brown 	else
230227d47356SLen Brown 		rewind(fp);
230327d47356SLen Brown 
230427d47356SLen Brown 	retval = fscanf(fp, "%d", &gfx_cur_mhz);
230527d47356SLen Brown 	if (retval != 1)
230627d47356SLen Brown 		err(1, "GFX MHz");
230727d47356SLen Brown 
230827d47356SLen Brown 	return 0;
230927d47356SLen Brown }
2310562a2d37SLen Brown 
2311562a2d37SLen Brown /*
2312562a2d37SLen Brown  * snapshot /proc and /sys files
2313562a2d37SLen Brown  *
2314562a2d37SLen Brown  * return 1 if configuration restart needed, else return 0
2315562a2d37SLen Brown  */
2316562a2d37SLen Brown int snapshot_proc_sysfs_files(void)
2317562a2d37SLen Brown {
2318562a2d37SLen Brown 	if (snapshot_proc_interrupts())
2319562a2d37SLen Brown 		return 1;
2320562a2d37SLen Brown 
2321812db3f7SLen Brown 	if (DO_BIC(BIC_GFX_rc6))
2322fdf676e5SLen Brown 		snapshot_gfx_rc6_ms();
2323fdf676e5SLen Brown 
2324812db3f7SLen Brown 	if (DO_BIC(BIC_GFXMHz))
232527d47356SLen Brown 		snapshot_gfx_mhz();
232627d47356SLen Brown 
2327562a2d37SLen Brown 	return 0;
2328562a2d37SLen Brown }
2329562a2d37SLen Brown 
2330103a8feaSLen Brown void turbostat_loop()
2331103a8feaSLen Brown {
2332c98d5d94SLen Brown 	int retval;
2333e52966c0SLen Brown 	int restarted = 0;
2334c98d5d94SLen Brown 
2335103a8feaSLen Brown restart:
2336e52966c0SLen Brown 	restarted++;
2337e52966c0SLen Brown 
2338562a2d37SLen Brown 	snapshot_proc_sysfs_files();
2339c98d5d94SLen Brown 	retval = for_all_cpus(get_counters, EVEN_COUNTERS);
2340d91bb17cSLen Brown 	if (retval < -1) {
2341d91bb17cSLen Brown 		exit(retval);
2342d91bb17cSLen Brown 	} else if (retval == -1) {
2343e52966c0SLen Brown 		if (restarted > 1) {
2344e52966c0SLen Brown 			exit(retval);
2345e52966c0SLen Brown 		}
2346c98d5d94SLen Brown 		re_initialize();
2347c98d5d94SLen Brown 		goto restart;
2348c98d5d94SLen Brown 	}
2349e52966c0SLen Brown 	restarted = 0;
2350103a8feaSLen Brown 	gettimeofday(&tv_even, (struct timezone *)NULL);
2351103a8feaSLen Brown 
2352103a8feaSLen Brown 	while (1) {
2353c98d5d94SLen Brown 		if (for_all_proc_cpus(cpu_is_not_present)) {
2354103a8feaSLen Brown 			re_initialize();
2355103a8feaSLen Brown 			goto restart;
2356103a8feaSLen Brown 		}
23572a0609c0SLen Brown 		nanosleep(&interval_ts, NULL);
2358562a2d37SLen Brown 		if (snapshot_proc_sysfs_files())
2359562a2d37SLen Brown 			goto restart;
2360c98d5d94SLen Brown 		retval = for_all_cpus(get_counters, ODD_COUNTERS);
2361d91bb17cSLen Brown 		if (retval < -1) {
2362d91bb17cSLen Brown 			exit(retval);
2363d91bb17cSLen Brown 		} else if (retval == -1) {
236415aaa346SLen Brown 			re_initialize();
236515aaa346SLen Brown 			goto restart;
236615aaa346SLen Brown 		}
2367103a8feaSLen Brown 		gettimeofday(&tv_odd, (struct timezone *)NULL);
2368103a8feaSLen Brown 		timersub(&tv_odd, &tv_even, &tv_delta);
2369ba3dec99SLen Brown 		if (for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS)) {
2370ba3dec99SLen Brown 			re_initialize();
2371ba3dec99SLen Brown 			goto restart;
2372ba3dec99SLen Brown 		}
2373c98d5d94SLen Brown 		compute_average(EVEN_COUNTERS);
2374c98d5d94SLen Brown 		format_all_counters(EVEN_COUNTERS);
2375b7d8c148SLen Brown 		flush_output_stdout();
23762a0609c0SLen Brown 		nanosleep(&interval_ts, NULL);
2377562a2d37SLen Brown 		if (snapshot_proc_sysfs_files())
2378562a2d37SLen Brown 			goto restart;
2379c98d5d94SLen Brown 		retval = for_all_cpus(get_counters, EVEN_COUNTERS);
2380d91bb17cSLen Brown 		if (retval < -1) {
2381d91bb17cSLen Brown 			exit(retval);
2382d91bb17cSLen Brown 		} else if (retval == -1) {
2383103a8feaSLen Brown 			re_initialize();
2384103a8feaSLen Brown 			goto restart;
2385103a8feaSLen Brown 		}
2386103a8feaSLen Brown 		gettimeofday(&tv_even, (struct timezone *)NULL);
2387103a8feaSLen Brown 		timersub(&tv_even, &tv_odd, &tv_delta);
2388ba3dec99SLen Brown 		if (for_all_cpus_2(delta_cpu, EVEN_COUNTERS, ODD_COUNTERS)) {
2389ba3dec99SLen Brown 			re_initialize();
2390ba3dec99SLen Brown 			goto restart;
2391ba3dec99SLen Brown 		}
2392c98d5d94SLen Brown 		compute_average(ODD_COUNTERS);
2393c98d5d94SLen Brown 		format_all_counters(ODD_COUNTERS);
2394b7d8c148SLen Brown 		flush_output_stdout();
2395103a8feaSLen Brown 	}
2396103a8feaSLen Brown }
2397103a8feaSLen Brown 
2398103a8feaSLen Brown void check_dev_msr()
2399103a8feaSLen Brown {
2400103a8feaSLen Brown 	struct stat sb;
24017ce7d5deSPrarit Bhargava 	char pathname[32];
2402103a8feaSLen Brown 
24037ce7d5deSPrarit Bhargava 	sprintf(pathname, "/dev/cpu/%d/msr", base_cpu);
24047ce7d5deSPrarit Bhargava 	if (stat(pathname, &sb))
2405a21d38c8SLen Brown  		if (system("/sbin/modprobe msr > /dev/null 2>&1"))
2406d7899447SLen Brown 			err(-5, "no /dev/cpu/0/msr, Try \"# modprobe msr\" ");
2407103a8feaSLen Brown }
2408103a8feaSLen Brown 
240998481e79SLen Brown void check_permissions()
2410103a8feaSLen Brown {
241198481e79SLen Brown 	struct __user_cap_header_struct cap_header_data;
241298481e79SLen Brown 	cap_user_header_t cap_header = &cap_header_data;
241398481e79SLen Brown 	struct __user_cap_data_struct cap_data_data;
241498481e79SLen Brown 	cap_user_data_t cap_data = &cap_data_data;
241598481e79SLen Brown 	extern int capget(cap_user_header_t hdrp, cap_user_data_t datap);
241698481e79SLen Brown 	int do_exit = 0;
24177ce7d5deSPrarit Bhargava 	char pathname[32];
241898481e79SLen Brown 
241998481e79SLen Brown 	/* check for CAP_SYS_RAWIO */
242098481e79SLen Brown 	cap_header->pid = getpid();
242198481e79SLen Brown 	cap_header->version = _LINUX_CAPABILITY_VERSION;
242298481e79SLen Brown 	if (capget(cap_header, cap_data) < 0)
242398481e79SLen Brown 		err(-6, "capget(2) failed");
242498481e79SLen Brown 
242598481e79SLen Brown 	if ((cap_data->effective & (1 << CAP_SYS_RAWIO)) == 0) {
242698481e79SLen Brown 		do_exit++;
242798481e79SLen Brown 		warnx("capget(CAP_SYS_RAWIO) failed,"
242898481e79SLen Brown 			" try \"# setcap cap_sys_rawio=ep %s\"", progname);
242998481e79SLen Brown 	}
243098481e79SLen Brown 
243198481e79SLen Brown 	/* test file permissions */
24327ce7d5deSPrarit Bhargava 	sprintf(pathname, "/dev/cpu/%d/msr", base_cpu);
24337ce7d5deSPrarit Bhargava 	if (euidaccess(pathname, R_OK)) {
243498481e79SLen Brown 		do_exit++;
243598481e79SLen Brown 		warn("/dev/cpu/0/msr open failed, try chown or chmod +r /dev/cpu/*/msr");
243698481e79SLen Brown 	}
243798481e79SLen Brown 
243898481e79SLen Brown 	/* if all else fails, thell them to be root */
243998481e79SLen Brown 	if (do_exit)
2440b2c95d90SJosh Triplett 		if (getuid() != 0)
2441d7899447SLen Brown 			warnx("... or simply run as root");
244298481e79SLen Brown 
244398481e79SLen Brown 	if (do_exit)
244498481e79SLen Brown 		exit(-6);
2445103a8feaSLen Brown }
2446103a8feaSLen Brown 
2447d7899447SLen Brown /*
2448d7899447SLen Brown  * NHM adds support for additional MSRs:
2449d7899447SLen Brown  *
2450d7899447SLen Brown  * MSR_SMI_COUNT                   0x00000034
2451d7899447SLen Brown  *
2452ec0adc53SLen Brown  * MSR_PLATFORM_INFO               0x000000ce
24531df2e55aSLen Brown  * MSR_PKG_CST_CONFIG_CONTROL     0x000000e2
2454d7899447SLen Brown  *
2455cf4cbe53SLen Brown  * MSR_MISC_PWR_MGMT               0x000001aa
2456cf4cbe53SLen Brown  *
2457d7899447SLen Brown  * MSR_PKG_C3_RESIDENCY            0x000003f8
2458d7899447SLen Brown  * MSR_PKG_C6_RESIDENCY            0x000003f9
2459d7899447SLen Brown  * MSR_CORE_C3_RESIDENCY           0x000003fc
2460d7899447SLen Brown  * MSR_CORE_C6_RESIDENCY           0x000003fd
2461d7899447SLen Brown  *
2462ee7e38e3SLen Brown  * Side effect:
24631df2e55aSLen Brown  * sets global pkg_cstate_limit to decode MSR_PKG_CST_CONFIG_CONTROL
246433148d67SLen Brown  * sets has_misc_feature_control
2465d7899447SLen Brown  */
2466ee7e38e3SLen Brown int probe_nhm_msrs(unsigned int family, unsigned int model)
2467103a8feaSLen Brown {
2468ee7e38e3SLen Brown 	unsigned long long msr;
246921ed5574SLen Brown 	unsigned int base_ratio;
2470ee7e38e3SLen Brown 	int *pkg_cstate_limits;
2471ee7e38e3SLen Brown 
2472103a8feaSLen Brown 	if (!genuine_intel)
2473103a8feaSLen Brown 		return 0;
2474103a8feaSLen Brown 
2475103a8feaSLen Brown 	if (family != 6)
2476103a8feaSLen Brown 		return 0;
2477103a8feaSLen Brown 
247821ed5574SLen Brown 	bclk = discover_bclk(family, model);
247921ed5574SLen Brown 
2480103a8feaSLen Brown 	switch (model) {
2481869ce69eSLen Brown 	case INTEL_FAM6_NEHALEM_EP:	/* Core i7, Xeon 5500 series - Bloomfield, Gainstown NHM-EP */
2482869ce69eSLen Brown 	case INTEL_FAM6_NEHALEM:	/* Core i7 and i5 Processor - Clarksfield, Lynnfield, Jasper Forest */
2483103a8feaSLen Brown 	case 0x1F:	/* Core i7 and i5 Processor - Nehalem */
2484869ce69eSLen Brown 	case INTEL_FAM6_WESTMERE:	/* Westmere Client - Clarkdale, Arrandale */
2485869ce69eSLen Brown 	case INTEL_FAM6_WESTMERE_EP:	/* Westmere EP - Gulftown */
2486869ce69eSLen Brown 	case INTEL_FAM6_NEHALEM_EX:	/* Nehalem-EX Xeon - Beckton */
2487869ce69eSLen Brown 	case INTEL_FAM6_WESTMERE_EX:	/* Westmere-EX Xeon - Eagleton */
2488ee7e38e3SLen Brown 		pkg_cstate_limits = nhm_pkg_cstate_limits;
2489ee7e38e3SLen Brown 		break;
2490869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE:	/* SNB */
2491869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE_X:	/* SNB Xeon */
2492869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE:	/* IVB */
2493869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE_X:	/* IVB Xeon */
2494ee7e38e3SLen Brown 		pkg_cstate_limits = snb_pkg_cstate_limits;
249533148d67SLen Brown 		has_misc_feature_control = 1;
2496ee7e38e3SLen Brown 		break;
2497869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
2498869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
2499869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
2500869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
2501869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
2502869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_GT3E:	/* BDW */
2503869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
2504869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
2505869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
2506869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
2507869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
2508869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
2509ee7e38e3SLen Brown 		pkg_cstate_limits = hsw_pkg_cstate_limits;
251033148d67SLen Brown 		has_misc_feature_control = 1;
2511ee7e38e3SLen Brown 		break;
2512d8ebb442SLen Brown 	case INTEL_FAM6_SKYLAKE_X:	/* SKX */
2513d8ebb442SLen Brown 		pkg_cstate_limits = skx_pkg_cstate_limits;
251433148d67SLen Brown 		has_misc_feature_control = 1;
2515d8ebb442SLen Brown 		break;
2516869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:	/* BYT */
2517cf4cbe53SLen Brown 		no_MSR_MISC_PWR_MGMT = 1;
2518869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT2:	/* AVN */
2519ee7e38e3SLen Brown 		pkg_cstate_limits = slv_pkg_cstate_limits;
2520ee7e38e3SLen Brown 		break;
2521869ce69eSLen Brown 	case INTEL_FAM6_ATOM_AIRMONT:	/* AMT */
2522ee7e38e3SLen Brown 		pkg_cstate_limits = amt_pkg_cstate_limits;
2523cf4cbe53SLen Brown 		no_MSR_MISC_PWR_MGMT = 1;
2524ee7e38e3SLen Brown 		break;
2525869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* PHI */
2526005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
2527ee7e38e3SLen Brown 		pkg_cstate_limits = phi_pkg_cstate_limits;
2528ee7e38e3SLen Brown 		break;
2529869ce69eSLen Brown 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
2530869ce69eSLen Brown 	case INTEL_FAM6_ATOM_DENVERTON:	/* DNV */
2531e4085d54SLen Brown 		pkg_cstate_limits = bxt_pkg_cstate_limits;
2532e4085d54SLen Brown 		break;
2533103a8feaSLen Brown 	default:
2534103a8feaSLen Brown 		return 0;
2535103a8feaSLen Brown 	}
25361df2e55aSLen Brown 	get_msr(base_cpu, MSR_PKG_CST_CONFIG_CONTROL, &msr);
2537e9257f5fSLen Brown 	pkg_cstate_limit = pkg_cstate_limits[msr & 0xF];
2538ee7e38e3SLen Brown 
2539ec0adc53SLen Brown 	get_msr(base_cpu, MSR_PLATFORM_INFO, &msr);
254021ed5574SLen Brown 	base_ratio = (msr >> 8) & 0xFF;
254121ed5574SLen Brown 
254221ed5574SLen Brown 	base_hz = base_ratio * bclk * 1000000;
254321ed5574SLen Brown 	has_base_hz = 1;
2544ee7e38e3SLen Brown 	return 1;
2545103a8feaSLen Brown }
25460f7887c4SLen Brown /*
25470f7887c4SLen Brown  * SLV client has supporet for unique MSRs:
25480f7887c4SLen Brown  *
25490f7887c4SLen Brown  * MSR_CC6_DEMOTION_POLICY_CONFIG
25500f7887c4SLen Brown  * MSR_MC6_DEMOTION_POLICY_CONFIG
25510f7887c4SLen Brown  */
25520f7887c4SLen Brown 
25530f7887c4SLen Brown int has_slv_msrs(unsigned int family, unsigned int model)
25540f7887c4SLen Brown {
25550f7887c4SLen Brown 	if (!genuine_intel)
25560f7887c4SLen Brown 		return 0;
25570f7887c4SLen Brown 
25580f7887c4SLen Brown 	switch (model) {
25590f7887c4SLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:
25600f7887c4SLen Brown 	case INTEL_FAM6_ATOM_MERRIFIELD:
25610f7887c4SLen Brown 	case INTEL_FAM6_ATOM_MOOREFIELD:
25620f7887c4SLen Brown 		return 1;
25630f7887c4SLen Brown 	}
25640f7887c4SLen Brown 	return 0;
25650f7887c4SLen Brown }
25660f7887c4SLen Brown 
2567d7899447SLen Brown int has_nhm_turbo_ratio_limit(unsigned int family, unsigned int model)
2568d7899447SLen Brown {
25690f7887c4SLen Brown 	if (has_slv_msrs(family, model))
25700f7887c4SLen Brown 		return 0;
25710f7887c4SLen Brown 
2572d7899447SLen Brown 	switch (model) {
2573d7899447SLen Brown 	/* Nehalem compatible, but do not include turbo-ratio limit support */
2574869ce69eSLen Brown 	case INTEL_FAM6_NEHALEM_EX:	/* Nehalem-EX Xeon - Beckton */
2575869ce69eSLen Brown 	case INTEL_FAM6_WESTMERE_EX:	/* Westmere-EX Xeon - Eagleton */
2576869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* PHI - Knights Landing (different MSR definition) */
2577005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
2578d7899447SLen Brown 		return 0;
2579d7899447SLen Brown 	default:
2580d7899447SLen Brown 		return 1;
2581d7899447SLen Brown 	}
2582d7899447SLen Brown }
25830f7887c4SLen Brown int has_atom_turbo_ratio_limit(unsigned int family, unsigned int model)
25840f7887c4SLen Brown {
25850f7887c4SLen Brown 	if (has_slv_msrs(family, model))
25860f7887c4SLen Brown 		return 1;
25870f7887c4SLen Brown 
25880f7887c4SLen Brown 	return 0;
25890f7887c4SLen Brown }
25906574a5d5SLen Brown int has_ivt_turbo_ratio_limit(unsigned int family, unsigned int model)
25916574a5d5SLen Brown {
25926574a5d5SLen Brown 	if (!genuine_intel)
25936574a5d5SLen Brown 		return 0;
25946574a5d5SLen Brown 
25956574a5d5SLen Brown 	if (family != 6)
25966574a5d5SLen Brown 		return 0;
25976574a5d5SLen Brown 
25986574a5d5SLen Brown 	switch (model) {
2599869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE_X:	/* IVB Xeon */
2600869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSW Xeon */
26016574a5d5SLen Brown 		return 1;
26026574a5d5SLen Brown 	default:
26036574a5d5SLen Brown 		return 0;
26046574a5d5SLen Brown 	}
26056574a5d5SLen Brown }
2606fcd17211SLen Brown int has_hsw_turbo_ratio_limit(unsigned int family, unsigned int model)
2607fcd17211SLen Brown {
2608fcd17211SLen Brown 	if (!genuine_intel)
2609fcd17211SLen Brown 		return 0;
2610fcd17211SLen Brown 
2611fcd17211SLen Brown 	if (family != 6)
2612fcd17211SLen Brown 		return 0;
2613fcd17211SLen Brown 
2614fcd17211SLen Brown 	switch (model) {
2615869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSW Xeon */
2616fcd17211SLen Brown 		return 1;
2617fcd17211SLen Brown 	default:
2618fcd17211SLen Brown 		return 0;
2619fcd17211SLen Brown 	}
2620fcd17211SLen Brown }
2621fcd17211SLen Brown 
2622fb5d4327SDasaratharaman Chandramouli int has_knl_turbo_ratio_limit(unsigned int family, unsigned int model)
2623fb5d4327SDasaratharaman Chandramouli {
2624fb5d4327SDasaratharaman Chandramouli 	if (!genuine_intel)
2625fb5d4327SDasaratharaman Chandramouli 		return 0;
2626fb5d4327SDasaratharaman Chandramouli 
2627fb5d4327SDasaratharaman Chandramouli 	if (family != 6)
2628fb5d4327SDasaratharaman Chandramouli 		return 0;
2629fb5d4327SDasaratharaman Chandramouli 
2630fb5d4327SDasaratharaman Chandramouli 	switch (model) {
2631869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* Knights Landing */
2632005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
2633fb5d4327SDasaratharaman Chandramouli 		return 1;
2634fb5d4327SDasaratharaman Chandramouli 	default:
2635fb5d4327SDasaratharaman Chandramouli 		return 0;
2636fb5d4327SDasaratharaman Chandramouli 	}
2637fb5d4327SDasaratharaman Chandramouli }
26386fb3143bSLen Brown int has_config_tdp(unsigned int family, unsigned int model)
26396fb3143bSLen Brown {
26406fb3143bSLen Brown 	if (!genuine_intel)
26416fb3143bSLen Brown 		return 0;
26426fb3143bSLen Brown 
26436fb3143bSLen Brown 	if (family != 6)
26446fb3143bSLen Brown 		return 0;
26456fb3143bSLen Brown 
26466fb3143bSLen Brown 	switch (model) {
2647869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE:	/* IVB */
2648869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
2649869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
2650869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
2651869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
2652869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
2653869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_GT3E:	/* BDW */
2654869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
2655869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
2656869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
2657869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
2658869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
2659869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
2660869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_X:	/* SKX */
26616fb3143bSLen Brown 
2662869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* Knights Landing */
2663005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
26646fb3143bSLen Brown 		return 1;
26656fb3143bSLen Brown 	default:
26666fb3143bSLen Brown 		return 0;
26676fb3143bSLen Brown 	}
26686fb3143bSLen Brown }
26696fb3143bSLen Brown 
2670fcd17211SLen Brown static void
26711b69317dSColin Ian King dump_cstate_pstate_config_info(unsigned int family, unsigned int model)
2672fcd17211SLen Brown {
2673fcd17211SLen Brown 	if (!do_nhm_platform_info)
2674fcd17211SLen Brown 		return;
2675fcd17211SLen Brown 
2676fcd17211SLen Brown 	dump_nhm_platform_info();
2677fcd17211SLen Brown 
2678fcd17211SLen Brown 	if (has_hsw_turbo_ratio_limit(family, model))
2679fcd17211SLen Brown 		dump_hsw_turbo_ratio_limits();
2680fcd17211SLen Brown 
2681fcd17211SLen Brown 	if (has_ivt_turbo_ratio_limit(family, model))
2682fcd17211SLen Brown 		dump_ivt_turbo_ratio_limits();
2683fcd17211SLen Brown 
2684fcd17211SLen Brown 	if (has_nhm_turbo_ratio_limit(family, model))
2685fcd17211SLen Brown 		dump_nhm_turbo_ratio_limits();
2686fcd17211SLen Brown 
26870f7887c4SLen Brown 	if (has_atom_turbo_ratio_limit(family, model))
26880f7887c4SLen Brown 		dump_atom_turbo_ratio_limits();
26890f7887c4SLen Brown 
2690fb5d4327SDasaratharaman Chandramouli 	if (has_knl_turbo_ratio_limit(family, model))
2691fb5d4327SDasaratharaman Chandramouli 		dump_knl_turbo_ratio_limits();
2692fb5d4327SDasaratharaman Chandramouli 
26936fb3143bSLen Brown 	if (has_config_tdp(family, model))
26946fb3143bSLen Brown 		dump_config_tdp();
26956fb3143bSLen Brown 
2696fcd17211SLen Brown 	dump_nhm_cst_cfg();
2697fcd17211SLen Brown }
2698fcd17211SLen Brown 
26996574a5d5SLen Brown 
2700889facbeSLen Brown /*
2701889facbeSLen Brown  * print_epb()
2702889facbeSLen Brown  * Decode the ENERGY_PERF_BIAS MSR
2703889facbeSLen Brown  */
2704889facbeSLen Brown int print_epb(struct thread_data *t, struct core_data *c, struct pkg_data *p)
2705889facbeSLen Brown {
2706889facbeSLen Brown 	unsigned long long msr;
2707889facbeSLen Brown 	char *epb_string;
2708889facbeSLen Brown 	int cpu;
2709889facbeSLen Brown 
2710889facbeSLen Brown 	if (!has_epb)
2711889facbeSLen Brown 		return 0;
2712889facbeSLen Brown 
2713889facbeSLen Brown 	cpu = t->cpu_id;
2714889facbeSLen Brown 
2715889facbeSLen Brown 	/* EPB is per-package */
2716889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
2717889facbeSLen Brown 		return 0;
2718889facbeSLen Brown 
2719889facbeSLen Brown 	if (cpu_migrate(cpu)) {
2720b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
2721889facbeSLen Brown 		return -1;
2722889facbeSLen Brown 	}
2723889facbeSLen Brown 
2724889facbeSLen Brown 	if (get_msr(cpu, MSR_IA32_ENERGY_PERF_BIAS, &msr))
2725889facbeSLen Brown 		return 0;
2726889facbeSLen Brown 
2727e9be7dd6SLen Brown 	switch (msr & 0xF) {
2728889facbeSLen Brown 	case ENERGY_PERF_BIAS_PERFORMANCE:
2729889facbeSLen Brown 		epb_string = "performance";
2730889facbeSLen Brown 		break;
2731889facbeSLen Brown 	case ENERGY_PERF_BIAS_NORMAL:
2732889facbeSLen Brown 		epb_string = "balanced";
2733889facbeSLen Brown 		break;
2734889facbeSLen Brown 	case ENERGY_PERF_BIAS_POWERSAVE:
2735889facbeSLen Brown 		epb_string = "powersave";
2736889facbeSLen Brown 		break;
2737889facbeSLen Brown 	default:
2738889facbeSLen Brown 		epb_string = "custom";
2739889facbeSLen Brown 		break;
2740889facbeSLen Brown 	}
2741b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_IA32_ENERGY_PERF_BIAS: 0x%08llx (%s)\n", cpu, msr, epb_string);
2742889facbeSLen Brown 
2743889facbeSLen Brown 	return 0;
2744889facbeSLen Brown }
27457f5c258eSLen Brown /*
27467f5c258eSLen Brown  * print_hwp()
27477f5c258eSLen Brown  * Decode the MSR_HWP_CAPABILITIES
27487f5c258eSLen Brown  */
27497f5c258eSLen Brown int print_hwp(struct thread_data *t, struct core_data *c, struct pkg_data *p)
27507f5c258eSLen Brown {
27517f5c258eSLen Brown 	unsigned long long msr;
27527f5c258eSLen Brown 	int cpu;
27537f5c258eSLen Brown 
27547f5c258eSLen Brown 	if (!has_hwp)
27557f5c258eSLen Brown 		return 0;
27567f5c258eSLen Brown 
27577f5c258eSLen Brown 	cpu = t->cpu_id;
27587f5c258eSLen Brown 
27597f5c258eSLen Brown 	/* MSR_HWP_CAPABILITIES is per-package */
27607f5c258eSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
27617f5c258eSLen Brown 		return 0;
27627f5c258eSLen Brown 
27637f5c258eSLen Brown 	if (cpu_migrate(cpu)) {
2764b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
27657f5c258eSLen Brown 		return -1;
27667f5c258eSLen Brown 	}
27677f5c258eSLen Brown 
27687f5c258eSLen Brown 	if (get_msr(cpu, MSR_PM_ENABLE, &msr))
27697f5c258eSLen Brown 		return 0;
27707f5c258eSLen Brown 
2771b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_PM_ENABLE: 0x%08llx (%sHWP)\n",
27727f5c258eSLen Brown 		cpu, msr, (msr & (1 << 0)) ? "" : "No-");
27737f5c258eSLen Brown 
27747f5c258eSLen Brown 	/* MSR_PM_ENABLE[1] == 1 if HWP is enabled and MSRs visible */
27757f5c258eSLen Brown 	if ((msr & (1 << 0)) == 0)
27767f5c258eSLen Brown 		return 0;
27777f5c258eSLen Brown 
27787f5c258eSLen Brown 	if (get_msr(cpu, MSR_HWP_CAPABILITIES, &msr))
27797f5c258eSLen Brown 		return 0;
27807f5c258eSLen Brown 
2781b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_HWP_CAPABILITIES: 0x%08llx "
27827f5c258eSLen Brown 			"(high 0x%x guar 0x%x eff 0x%x low 0x%x)\n",
27837f5c258eSLen Brown 			cpu, msr,
27847f5c258eSLen Brown 			(unsigned int)HWP_HIGHEST_PERF(msr),
27857f5c258eSLen Brown 			(unsigned int)HWP_GUARANTEED_PERF(msr),
27867f5c258eSLen Brown 			(unsigned int)HWP_MOSTEFFICIENT_PERF(msr),
27877f5c258eSLen Brown 			(unsigned int)HWP_LOWEST_PERF(msr));
27887f5c258eSLen Brown 
27897f5c258eSLen Brown 	if (get_msr(cpu, MSR_HWP_REQUEST, &msr))
27907f5c258eSLen Brown 		return 0;
27917f5c258eSLen Brown 
2792b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_HWP_REQUEST: 0x%08llx "
27937f5c258eSLen Brown 			"(min 0x%x max 0x%x des 0x%x epp 0x%x window 0x%x pkg 0x%x)\n",
27947f5c258eSLen Brown 			cpu, msr,
27957f5c258eSLen Brown 			(unsigned int)(((msr) >> 0) & 0xff),
27967f5c258eSLen Brown 			(unsigned int)(((msr) >> 8) & 0xff),
27977f5c258eSLen Brown 			(unsigned int)(((msr) >> 16) & 0xff),
27987f5c258eSLen Brown 			(unsigned int)(((msr) >> 24) & 0xff),
27997f5c258eSLen Brown 			(unsigned int)(((msr) >> 32) & 0xff3),
28007f5c258eSLen Brown 			(unsigned int)(((msr) >> 42) & 0x1));
28017f5c258eSLen Brown 
28027f5c258eSLen Brown 	if (has_hwp_pkg) {
28037f5c258eSLen Brown 		if (get_msr(cpu, MSR_HWP_REQUEST_PKG, &msr))
28047f5c258eSLen Brown 			return 0;
28057f5c258eSLen Brown 
2806b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_HWP_REQUEST_PKG: 0x%08llx "
28077f5c258eSLen Brown 			"(min 0x%x max 0x%x des 0x%x epp 0x%x window 0x%x)\n",
28087f5c258eSLen Brown 			cpu, msr,
28097f5c258eSLen Brown 			(unsigned int)(((msr) >> 0) & 0xff),
28107f5c258eSLen Brown 			(unsigned int)(((msr) >> 8) & 0xff),
28117f5c258eSLen Brown 			(unsigned int)(((msr) >> 16) & 0xff),
28127f5c258eSLen Brown 			(unsigned int)(((msr) >> 24) & 0xff),
28137f5c258eSLen Brown 			(unsigned int)(((msr) >> 32) & 0xff3));
28147f5c258eSLen Brown 	}
28157f5c258eSLen Brown 	if (has_hwp_notify) {
28167f5c258eSLen Brown 		if (get_msr(cpu, MSR_HWP_INTERRUPT, &msr))
28177f5c258eSLen Brown 			return 0;
28187f5c258eSLen Brown 
2819b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_HWP_INTERRUPT: 0x%08llx "
28207f5c258eSLen Brown 			"(%s_Guaranteed_Perf_Change, %s_Excursion_Min)\n",
28217f5c258eSLen Brown 			cpu, msr,
28227f5c258eSLen Brown 			((msr) & 0x1) ? "EN" : "Dis",
28237f5c258eSLen Brown 			((msr) & 0x2) ? "EN" : "Dis");
28247f5c258eSLen Brown 	}
28257f5c258eSLen Brown 	if (get_msr(cpu, MSR_HWP_STATUS, &msr))
28267f5c258eSLen Brown 		return 0;
28277f5c258eSLen Brown 
2828b7d8c148SLen Brown 	fprintf(outf, "cpu%d: MSR_HWP_STATUS: 0x%08llx "
28297f5c258eSLen Brown 			"(%sGuaranteed_Perf_Change, %sExcursion_Min)\n",
28307f5c258eSLen Brown 			cpu, msr,
28317f5c258eSLen Brown 			((msr) & 0x1) ? "" : "No-",
28327f5c258eSLen Brown 			((msr) & 0x2) ? "" : "No-");
2833889facbeSLen Brown 
2834889facbeSLen Brown 	return 0;
2835889facbeSLen Brown }
2836889facbeSLen Brown 
28373a9a941dSLen Brown /*
28383a9a941dSLen Brown  * print_perf_limit()
28393a9a941dSLen Brown  */
28403a9a941dSLen Brown int print_perf_limit(struct thread_data *t, struct core_data *c, struct pkg_data *p)
28413a9a941dSLen Brown {
28423a9a941dSLen Brown 	unsigned long long msr;
28433a9a941dSLen Brown 	int cpu;
28443a9a941dSLen Brown 
28453a9a941dSLen Brown 	cpu = t->cpu_id;
28463a9a941dSLen Brown 
28473a9a941dSLen Brown 	/* per-package */
28483a9a941dSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
28493a9a941dSLen Brown 		return 0;
28503a9a941dSLen Brown 
28513a9a941dSLen Brown 	if (cpu_migrate(cpu)) {
2852b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
28533a9a941dSLen Brown 		return -1;
28543a9a941dSLen Brown 	}
28553a9a941dSLen Brown 
28563a9a941dSLen Brown 	if (do_core_perf_limit_reasons) {
28573a9a941dSLen Brown 		get_msr(cpu, MSR_CORE_PERF_LIMIT_REASONS, &msr);
2858b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_CORE_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
2859b7d8c148SLen Brown 		fprintf(outf, " (Active: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)",
2860e33cbe85SLen Brown 			(msr & 1 << 15) ? "bit15, " : "",
28613a9a941dSLen Brown 			(msr & 1 << 14) ? "bit14, " : "",
2862e33cbe85SLen Brown 			(msr & 1 << 13) ? "Transitions, " : "",
2863e33cbe85SLen Brown 			(msr & 1 << 12) ? "MultiCoreTurbo, " : "",
2864e33cbe85SLen Brown 			(msr & 1 << 11) ? "PkgPwrL2, " : "",
2865e33cbe85SLen Brown 			(msr & 1 << 10) ? "PkgPwrL1, " : "",
2866e33cbe85SLen Brown 			(msr & 1 << 9) ? "CorePwr, " : "",
2867e33cbe85SLen Brown 			(msr & 1 << 8) ? "Amps, " : "",
2868e33cbe85SLen Brown 			(msr & 1 << 6) ? "VR-Therm, " : "",
2869e33cbe85SLen Brown 			(msr & 1 << 5) ? "Auto-HWP, " : "",
2870e33cbe85SLen Brown 			(msr & 1 << 4) ? "Graphics, " : "",
2871e33cbe85SLen Brown 			(msr & 1 << 2) ? "bit2, " : "",
2872e33cbe85SLen Brown 			(msr & 1 << 1) ? "ThermStatus, " : "",
2873e33cbe85SLen Brown 			(msr & 1 << 0) ? "PROCHOT, " : "");
2874b7d8c148SLen Brown 		fprintf(outf, " (Logged: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
2875e33cbe85SLen Brown 			(msr & 1 << 31) ? "bit31, " : "",
28763a9a941dSLen Brown 			(msr & 1 << 30) ? "bit30, " : "",
2877e33cbe85SLen Brown 			(msr & 1 << 29) ? "Transitions, " : "",
2878e33cbe85SLen Brown 			(msr & 1 << 28) ? "MultiCoreTurbo, " : "",
2879e33cbe85SLen Brown 			(msr & 1 << 27) ? "PkgPwrL2, " : "",
2880e33cbe85SLen Brown 			(msr & 1 << 26) ? "PkgPwrL1, " : "",
2881e33cbe85SLen Brown 			(msr & 1 << 25) ? "CorePwr, " : "",
2882e33cbe85SLen Brown 			(msr & 1 << 24) ? "Amps, " : "",
2883e33cbe85SLen Brown 			(msr & 1 << 22) ? "VR-Therm, " : "",
2884e33cbe85SLen Brown 			(msr & 1 << 21) ? "Auto-HWP, " : "",
2885e33cbe85SLen Brown 			(msr & 1 << 20) ? "Graphics, " : "",
2886e33cbe85SLen Brown 			(msr & 1 << 18) ? "bit18, " : "",
2887e33cbe85SLen Brown 			(msr & 1 << 17) ? "ThermStatus, " : "",
2888e33cbe85SLen Brown 			(msr & 1 << 16) ? "PROCHOT, " : "");
28893a9a941dSLen Brown 
28903a9a941dSLen Brown 	}
28913a9a941dSLen Brown 	if (do_gfx_perf_limit_reasons) {
28923a9a941dSLen Brown 		get_msr(cpu, MSR_GFX_PERF_LIMIT_REASONS, &msr);
2893b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_GFX_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
2894b7d8c148SLen Brown 		fprintf(outf, " (Active: %s%s%s%s%s%s%s%s)",
28953a9a941dSLen Brown 			(msr & 1 << 0) ? "PROCHOT, " : "",
28963a9a941dSLen Brown 			(msr & 1 << 1) ? "ThermStatus, " : "",
28973a9a941dSLen Brown 			(msr & 1 << 4) ? "Graphics, " : "",
28983a9a941dSLen Brown 			(msr & 1 << 6) ? "VR-Therm, " : "",
28993a9a941dSLen Brown 			(msr & 1 << 8) ? "Amps, " : "",
29003a9a941dSLen Brown 			(msr & 1 << 9) ? "GFXPwr, " : "",
29013a9a941dSLen Brown 			(msr & 1 << 10) ? "PkgPwrL1, " : "",
29023a9a941dSLen Brown 			(msr & 1 << 11) ? "PkgPwrL2, " : "");
2903b7d8c148SLen Brown 		fprintf(outf, " (Logged: %s%s%s%s%s%s%s%s)\n",
29043a9a941dSLen Brown 			(msr & 1 << 16) ? "PROCHOT, " : "",
29053a9a941dSLen Brown 			(msr & 1 << 17) ? "ThermStatus, " : "",
29063a9a941dSLen Brown 			(msr & 1 << 20) ? "Graphics, " : "",
29073a9a941dSLen Brown 			(msr & 1 << 22) ? "VR-Therm, " : "",
29083a9a941dSLen Brown 			(msr & 1 << 24) ? "Amps, " : "",
29093a9a941dSLen Brown 			(msr & 1 << 25) ? "GFXPwr, " : "",
29103a9a941dSLen Brown 			(msr & 1 << 26) ? "PkgPwrL1, " : "",
29113a9a941dSLen Brown 			(msr & 1 << 27) ? "PkgPwrL2, " : "");
29123a9a941dSLen Brown 	}
29133a9a941dSLen Brown 	if (do_ring_perf_limit_reasons) {
29143a9a941dSLen Brown 		get_msr(cpu, MSR_RING_PERF_LIMIT_REASONS, &msr);
2915b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_RING_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
2916b7d8c148SLen Brown 		fprintf(outf, " (Active: %s%s%s%s%s%s)",
29173a9a941dSLen Brown 			(msr & 1 << 0) ? "PROCHOT, " : "",
29183a9a941dSLen Brown 			(msr & 1 << 1) ? "ThermStatus, " : "",
29193a9a941dSLen Brown 			(msr & 1 << 6) ? "VR-Therm, " : "",
29203a9a941dSLen Brown 			(msr & 1 << 8) ? "Amps, " : "",
29213a9a941dSLen Brown 			(msr & 1 << 10) ? "PkgPwrL1, " : "",
29223a9a941dSLen Brown 			(msr & 1 << 11) ? "PkgPwrL2, " : "");
2923b7d8c148SLen Brown 		fprintf(outf, " (Logged: %s%s%s%s%s%s)\n",
29243a9a941dSLen Brown 			(msr & 1 << 16) ? "PROCHOT, " : "",
29253a9a941dSLen Brown 			(msr & 1 << 17) ? "ThermStatus, " : "",
29263a9a941dSLen Brown 			(msr & 1 << 22) ? "VR-Therm, " : "",
29273a9a941dSLen Brown 			(msr & 1 << 24) ? "Amps, " : "",
29283a9a941dSLen Brown 			(msr & 1 << 26) ? "PkgPwrL1, " : "",
29293a9a941dSLen Brown 			(msr & 1 << 27) ? "PkgPwrL2, " : "");
29303a9a941dSLen Brown 	}
29313a9a941dSLen Brown 	return 0;
29323a9a941dSLen Brown }
29333a9a941dSLen Brown 
2934889facbeSLen Brown #define	RAPL_POWER_GRANULARITY	0x7FFF	/* 15 bit power granularity */
2935889facbeSLen Brown #define	RAPL_TIME_GRANULARITY	0x3F /* 6 bit time granularity */
2936889facbeSLen Brown 
29371b69317dSColin Ian King double get_tdp(unsigned int model)
2938144b44b1SLen Brown {
2939144b44b1SLen Brown 	unsigned long long msr;
2940144b44b1SLen Brown 
2941144b44b1SLen Brown 	if (do_rapl & RAPL_PKG_POWER_INFO)
29427ce7d5deSPrarit Bhargava 		if (!get_msr(base_cpu, MSR_PKG_POWER_INFO, &msr))
2943144b44b1SLen Brown 			return ((msr >> 0) & RAPL_POWER_GRANULARITY) * rapl_power_units;
2944144b44b1SLen Brown 
2945144b44b1SLen Brown 	switch (model) {
2946869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:
2947869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT2:
2948144b44b1SLen Brown 		return 30.0;
2949144b44b1SLen Brown 	default:
2950144b44b1SLen Brown 		return 135.0;
2951144b44b1SLen Brown 	}
2952144b44b1SLen Brown }
2953144b44b1SLen Brown 
295440ee8e3bSAndrey Semin /*
295540ee8e3bSAndrey Semin  * rapl_dram_energy_units_probe()
295640ee8e3bSAndrey Semin  * Energy units are either hard-coded, or come from RAPL Energy Unit MSR.
295740ee8e3bSAndrey Semin  */
295840ee8e3bSAndrey Semin static double
295940ee8e3bSAndrey Semin rapl_dram_energy_units_probe(int  model, double rapl_energy_units)
296040ee8e3bSAndrey Semin {
296140ee8e3bSAndrey Semin 	/* only called for genuine_intel, family 6 */
296240ee8e3bSAndrey Semin 
296340ee8e3bSAndrey Semin 	switch (model) {
2964869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
2965869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
2966869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
2967869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* KNL */
2968005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
296940ee8e3bSAndrey Semin 		return (rapl_dram_energy_units = 15.3 / 1000000);
297040ee8e3bSAndrey Semin 	default:
297140ee8e3bSAndrey Semin 		return (rapl_energy_units);
297240ee8e3bSAndrey Semin 	}
297340ee8e3bSAndrey Semin }
297440ee8e3bSAndrey Semin 
2975144b44b1SLen Brown 
2976889facbeSLen Brown /*
2977889facbeSLen Brown  * rapl_probe()
2978889facbeSLen Brown  *
2979144b44b1SLen Brown  * sets do_rapl, rapl_power_units, rapl_energy_units, rapl_time_units
2980889facbeSLen Brown  */
2981889facbeSLen Brown void rapl_probe(unsigned int family, unsigned int model)
2982889facbeSLen Brown {
2983889facbeSLen Brown 	unsigned long long msr;
2984144b44b1SLen Brown 	unsigned int time_unit;
2985889facbeSLen Brown 	double tdp;
2986889facbeSLen Brown 
2987889facbeSLen Brown 	if (!genuine_intel)
2988889facbeSLen Brown 		return;
2989889facbeSLen Brown 
2990889facbeSLen Brown 	if (family != 6)
2991889facbeSLen Brown 		return;
2992889facbeSLen Brown 
2993889facbeSLen Brown 	switch (model) {
2994869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE:
2995869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE:
2996869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
2997869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
2998869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
2999869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
3000869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_GT3E:	/* BDW */
3001144b44b1SLen Brown 		do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_GFX | RAPL_PKG_POWER_INFO;
3002812db3f7SLen Brown 		if (rapl_joules) {
3003812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3004812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3005812db3f7SLen Brown 			BIC_PRESENT(BIC_GFX_J);
3006812db3f7SLen Brown 		} else {
3007812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3008812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3009812db3f7SLen Brown 			BIC_PRESENT(BIC_GFXWatt);
3010812db3f7SLen Brown 		}
3011889facbeSLen Brown 		break;
3012869ce69eSLen Brown 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
3013e4085d54SLen Brown 		do_rapl = RAPL_PKG | RAPL_PKG_POWER_INFO;
3014812db3f7SLen Brown 		if (rapl_joules)
3015812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3016812db3f7SLen Brown 		else
3017812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3018e4085d54SLen Brown 		break;
3019869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3020869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3021869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3022869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
30230b2bb692SLen Brown 		do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO;
3024812db3f7SLen Brown 		BIC_PRESENT(BIC_PKG__);
3025812db3f7SLen Brown 		BIC_PRESENT(BIC_RAM__);
3026812db3f7SLen Brown 		if (rapl_joules) {
3027812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3028812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3029812db3f7SLen Brown 			BIC_PRESENT(BIC_RAM_J);
3030812db3f7SLen Brown 		} else {
3031812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3032812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3033812db3f7SLen Brown 			BIC_PRESENT(BIC_RAMWatt);
3034812db3f7SLen Brown 		}
30350b2bb692SLen Brown 		break;
3036869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
3037869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
3038869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
3039869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_X:	/* SKX */
3040869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* KNL */
3041005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
30420b2bb692SLen Brown 		do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_POWER_INFO | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO;
3043812db3f7SLen Brown 		BIC_PRESENT(BIC_PKG__);
3044812db3f7SLen Brown 		BIC_PRESENT(BIC_RAM__);
3045812db3f7SLen Brown 		if (rapl_joules) {
3046812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3047812db3f7SLen Brown 			BIC_PRESENT(BIC_RAM_J);
3048812db3f7SLen Brown 		} else {
3049812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3050812db3f7SLen Brown 			BIC_PRESENT(BIC_RAMWatt);
3051812db3f7SLen Brown 		}
3052e6f9bb3cSLen Brown 		break;
3053869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE_X:
3054869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE_X:
30550b2bb692SLen 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;
3056812db3f7SLen Brown 		BIC_PRESENT(BIC_PKG__);
3057812db3f7SLen Brown 		BIC_PRESENT(BIC_RAM__);
3058812db3f7SLen Brown 		if (rapl_joules) {
3059812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3060812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3061812db3f7SLen Brown 			BIC_PRESENT(BIC_RAM_J);
3062812db3f7SLen Brown 		} else {
3063812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3064812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3065812db3f7SLen Brown 			BIC_PRESENT(BIC_RAMWatt);
3066812db3f7SLen Brown 		}
3067144b44b1SLen Brown 		break;
3068869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:	/* BYT */
3069869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT2:	/* AVN */
3070144b44b1SLen Brown 		do_rapl = RAPL_PKG | RAPL_CORES;
3071812db3f7SLen Brown 		if (rapl_joules) {
3072812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3073812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3074812db3f7SLen Brown 		} else {
3075812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3076812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3077812db3f7SLen Brown 		}
3078889facbeSLen Brown 		break;
3079869ce69eSLen Brown 	case INTEL_FAM6_ATOM_DENVERTON:	/* DNV */
30800f644909SJacob 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;
3081812db3f7SLen Brown 		BIC_PRESENT(BIC_PKG__);
3082812db3f7SLen Brown 		BIC_PRESENT(BIC_RAM__);
3083812db3f7SLen Brown 		if (rapl_joules) {
3084812db3f7SLen Brown 			BIC_PRESENT(BIC_Pkg_J);
3085812db3f7SLen Brown 			BIC_PRESENT(BIC_Cor_J);
3086812db3f7SLen Brown 			BIC_PRESENT(BIC_RAM_J);
3087812db3f7SLen Brown 		} else {
3088812db3f7SLen Brown 			BIC_PRESENT(BIC_PkgWatt);
3089812db3f7SLen Brown 			BIC_PRESENT(BIC_CorWatt);
3090812db3f7SLen Brown 			BIC_PRESENT(BIC_RAMWatt);
3091812db3f7SLen Brown 		}
30920f644909SJacob Pan 		break;
3093889facbeSLen Brown 	default:
3094889facbeSLen Brown 		return;
3095889facbeSLen Brown 	}
3096889facbeSLen Brown 
3097889facbeSLen Brown 	/* units on package 0, verify later other packages match */
30987ce7d5deSPrarit Bhargava 	if (get_msr(base_cpu, MSR_RAPL_POWER_UNIT, &msr))
3099889facbeSLen Brown 		return;
3100889facbeSLen Brown 
3101889facbeSLen Brown 	rapl_power_units = 1.0 / (1 << (msr & 0xF));
3102869ce69eSLen Brown 	if (model == INTEL_FAM6_ATOM_SILVERMONT1)
3103144b44b1SLen Brown 		rapl_energy_units = 1.0 * (1 << (msr >> 8 & 0x1F)) / 1000000;
3104144b44b1SLen Brown 	else
3105889facbeSLen Brown 		rapl_energy_units = 1.0 / (1 << (msr >> 8 & 0x1F));
3106889facbeSLen Brown 
310740ee8e3bSAndrey Semin 	rapl_dram_energy_units = rapl_dram_energy_units_probe(model, rapl_energy_units);
310840ee8e3bSAndrey Semin 
3109144b44b1SLen Brown 	time_unit = msr >> 16 & 0xF;
3110144b44b1SLen Brown 	if (time_unit == 0)
3111144b44b1SLen Brown 		time_unit = 0xA;
3112889facbeSLen Brown 
3113144b44b1SLen Brown 	rapl_time_units = 1.0 / (1 << (time_unit));
3114144b44b1SLen Brown 
3115144b44b1SLen Brown 	tdp = get_tdp(model);
3116889facbeSLen Brown 
3117889facbeSLen Brown 	rapl_joule_counter_range = 0xFFFFFFFF * rapl_energy_units / tdp;
311896e47158SLen Brown 	if (!quiet)
3119b7d8c148SLen Brown 		fprintf(outf, "RAPL: %.0f sec. Joule Counter Range, at %.0f Watts\n", rapl_joule_counter_range, tdp);
3120889facbeSLen Brown 
3121889facbeSLen Brown 	return;
3122889facbeSLen Brown }
3123889facbeSLen Brown 
31241b69317dSColin Ian King void perf_limit_reasons_probe(unsigned int family, unsigned int model)
31253a9a941dSLen Brown {
31263a9a941dSLen Brown 	if (!genuine_intel)
31273a9a941dSLen Brown 		return;
31283a9a941dSLen Brown 
31293a9a941dSLen Brown 	if (family != 6)
31303a9a941dSLen Brown 		return;
31313a9a941dSLen Brown 
31323a9a941dSLen Brown 	switch (model) {
3133869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
3134869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
3135869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
31363a9a941dSLen Brown 		do_gfx_perf_limit_reasons = 1;
3137869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSX */
31383a9a941dSLen Brown 		do_core_perf_limit_reasons = 1;
31393a9a941dSLen Brown 		do_ring_perf_limit_reasons = 1;
31403a9a941dSLen Brown 	default:
31413a9a941dSLen Brown 		return;
31423a9a941dSLen Brown 	}
31433a9a941dSLen Brown }
31443a9a941dSLen Brown 
3145889facbeSLen Brown int print_thermal(struct thread_data *t, struct core_data *c, struct pkg_data *p)
3146889facbeSLen Brown {
3147889facbeSLen Brown 	unsigned long long msr;
3148889facbeSLen Brown 	unsigned int dts;
3149889facbeSLen Brown 	int cpu;
3150889facbeSLen Brown 
3151889facbeSLen Brown 	if (!(do_dts || do_ptm))
3152889facbeSLen Brown 		return 0;
3153889facbeSLen Brown 
3154889facbeSLen Brown 	cpu = t->cpu_id;
3155889facbeSLen Brown 
3156889facbeSLen Brown 	/* DTS is per-core, no need to print for each thread */
3157889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
3158889facbeSLen Brown 		return 0;
3159889facbeSLen Brown 
3160889facbeSLen Brown 	if (cpu_migrate(cpu)) {
3161b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
3162889facbeSLen Brown 		return -1;
3163889facbeSLen Brown 	}
3164889facbeSLen Brown 
3165889facbeSLen Brown 	if (do_ptm && (t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)) {
3166889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_STATUS, &msr))
3167889facbeSLen Brown 			return 0;
3168889facbeSLen Brown 
3169889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
3170b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_PACKAGE_THERM_STATUS: 0x%08llx (%d C)\n",
3171889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts);
3172889facbeSLen Brown 
3173889facbeSLen Brown #ifdef	THERM_DEBUG
3174889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT, &msr))
3175889facbeSLen Brown 			return 0;
3176889facbeSLen Brown 
3177889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
3178889facbeSLen Brown 		dts2 = (msr >> 8) & 0x7F;
3179b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_PACKAGE_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
3180889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
3181889facbeSLen Brown #endif
3182889facbeSLen Brown 	}
3183889facbeSLen Brown 
3184889facbeSLen Brown 
3185889facbeSLen Brown 	if (do_dts) {
3186889facbeSLen Brown 		unsigned int resolution;
3187889facbeSLen Brown 
3188889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_THERM_STATUS, &msr))
3189889facbeSLen Brown 			return 0;
3190889facbeSLen Brown 
3191889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
3192889facbeSLen Brown 		resolution = (msr >> 27) & 0xF;
3193b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_THERM_STATUS: 0x%08llx (%d C +/- %d)\n",
3194889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts, resolution);
3195889facbeSLen Brown 
3196889facbeSLen Brown #ifdef THERM_DEBUG
3197889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_THERM_INTERRUPT, &msr))
3198889facbeSLen Brown 			return 0;
3199889facbeSLen Brown 
3200889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
3201889facbeSLen Brown 		dts2 = (msr >> 8) & 0x7F;
3202b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
3203889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
3204889facbeSLen Brown #endif
3205889facbeSLen Brown 	}
3206889facbeSLen Brown 
3207889facbeSLen Brown 	return 0;
3208889facbeSLen Brown }
3209889facbeSLen Brown 
3210889facbeSLen Brown void print_power_limit_msr(int cpu, unsigned long long msr, char *label)
3211889facbeSLen Brown {
3212b7d8c148SLen Brown 	fprintf(outf, "cpu%d: %s: %sabled (%f Watts, %f sec, clamp %sabled)\n",
3213889facbeSLen Brown 		cpu, label,
3214889facbeSLen Brown 		((msr >> 15) & 1) ? "EN" : "DIS",
3215889facbeSLen Brown 		((msr >> 0) & 0x7FFF) * rapl_power_units,
3216889facbeSLen Brown 		(1.0 + (((msr >> 22) & 0x3)/4.0)) * (1 << ((msr >> 17) & 0x1F)) * rapl_time_units,
3217889facbeSLen Brown 		(((msr >> 16) & 1) ? "EN" : "DIS"));
3218889facbeSLen Brown 
3219889facbeSLen Brown 	return;
3220889facbeSLen Brown }
3221889facbeSLen Brown 
3222889facbeSLen Brown int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
3223889facbeSLen Brown {
3224889facbeSLen Brown 	unsigned long long msr;
3225889facbeSLen Brown 	int cpu;
3226889facbeSLen Brown 
3227889facbeSLen Brown 	if (!do_rapl)
3228889facbeSLen Brown 		return 0;
3229889facbeSLen Brown 
3230889facbeSLen Brown 	/* RAPL counters are per package, so print only for 1st thread/package */
3231889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
3232889facbeSLen Brown 		return 0;
3233889facbeSLen Brown 
3234889facbeSLen Brown 	cpu = t->cpu_id;
3235889facbeSLen Brown 	if (cpu_migrate(cpu)) {
3236b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
3237889facbeSLen Brown 		return -1;
3238889facbeSLen Brown 	}
3239889facbeSLen Brown 
3240889facbeSLen Brown 	if (get_msr(cpu, MSR_RAPL_POWER_UNIT, &msr))
3241889facbeSLen Brown 		return -1;
3242889facbeSLen Brown 
324396e47158SLen Brown 	fprintf(outf, "cpu%d: MSR_RAPL_POWER_UNIT: 0x%08llx (%f Watts, %f Joules, %f sec.)\n", cpu, msr,
3244144b44b1SLen Brown 		rapl_power_units, rapl_energy_units, rapl_time_units);
324596e47158SLen Brown 
3246144b44b1SLen Brown 	if (do_rapl & RAPL_PKG_POWER_INFO) {
3247144b44b1SLen Brown 
3248889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_POWER_INFO, &msr))
3249889facbeSLen Brown                 	return -5;
3250889facbeSLen Brown 
3251889facbeSLen Brown 
3252b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PKG_POWER_INFO: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
3253889facbeSLen Brown 			cpu, msr,
3254889facbeSLen Brown 			((msr >>  0) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3255889facbeSLen Brown 			((msr >> 16) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3256889facbeSLen Brown 			((msr >> 32) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3257889facbeSLen Brown 			((msr >> 48) & RAPL_TIME_GRANULARITY) * rapl_time_units);
3258889facbeSLen Brown 
3259144b44b1SLen Brown 	}
3260144b44b1SLen Brown 	if (do_rapl & RAPL_PKG) {
3261144b44b1SLen Brown 
3262889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_POWER_LIMIT, &msr))
3263889facbeSLen Brown 			return -9;
3264889facbeSLen Brown 
3265b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PKG_POWER_LIMIT: 0x%08llx (%slocked)\n",
3266889facbeSLen Brown 			cpu, msr, (msr >> 63) & 1 ? "" : "UN");
3267889facbeSLen Brown 
3268889facbeSLen Brown 		print_power_limit_msr(cpu, msr, "PKG Limit #1");
3269b7d8c148SLen Brown 		fprintf(outf, "cpu%d: PKG Limit #2: %sabled (%f Watts, %f* sec, clamp %sabled)\n",
3270889facbeSLen Brown 			cpu,
3271889facbeSLen Brown 			((msr >> 47) & 1) ? "EN" : "DIS",
3272889facbeSLen Brown 			((msr >> 32) & 0x7FFF) * rapl_power_units,
3273889facbeSLen Brown 			(1.0 + (((msr >> 54) & 0x3)/4.0)) * (1 << ((msr >> 49) & 0x1F)) * rapl_time_units,
3274889facbeSLen Brown 			((msr >> 48) & 1) ? "EN" : "DIS");
3275889facbeSLen Brown 	}
3276889facbeSLen Brown 
32770b2bb692SLen Brown 	if (do_rapl & RAPL_DRAM_POWER_INFO) {
3278889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_POWER_INFO, &msr))
3279889facbeSLen Brown                 	return -6;
3280889facbeSLen Brown 
3281b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_DRAM_POWER_INFO,: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
3282889facbeSLen Brown 			cpu, msr,
3283889facbeSLen Brown 			((msr >>  0) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3284889facbeSLen Brown 			((msr >> 16) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3285889facbeSLen Brown 			((msr >> 32) & RAPL_POWER_GRANULARITY) * rapl_power_units,
3286889facbeSLen Brown 			((msr >> 48) & RAPL_TIME_GRANULARITY) * rapl_time_units);
32870b2bb692SLen Brown 	}
32880b2bb692SLen Brown 	if (do_rapl & RAPL_DRAM) {
3289889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_POWER_LIMIT, &msr))
3290889facbeSLen Brown 			return -9;
3291b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_DRAM_POWER_LIMIT: 0x%08llx (%slocked)\n",
3292889facbeSLen Brown 				cpu, msr, (msr >> 31) & 1 ? "" : "UN");
3293889facbeSLen Brown 
3294889facbeSLen Brown 		print_power_limit_msr(cpu, msr, "DRAM Limit");
3295889facbeSLen Brown 	}
3296144b44b1SLen Brown 	if (do_rapl & RAPL_CORE_POLICY) {
3297889facbeSLen Brown 		if (get_msr(cpu, MSR_PP0_POLICY, &msr))
3298889facbeSLen Brown 			return -7;
3299889facbeSLen Brown 
3300b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PP0_POLICY: %lld\n", cpu, msr & 0xF);
3301144b44b1SLen Brown 	}
33029148494cSJacob Pan 	if (do_rapl & RAPL_CORES_POWER_LIMIT) {
3303889facbeSLen Brown 		if (get_msr(cpu, MSR_PP0_POWER_LIMIT, &msr))
3304889facbeSLen Brown 			return -9;
3305b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PP0_POWER_LIMIT: 0x%08llx (%slocked)\n",
3306889facbeSLen Brown 				cpu, msr, (msr >> 31) & 1 ? "" : "UN");
3307889facbeSLen Brown 		print_power_limit_msr(cpu, msr, "Cores Limit");
3308889facbeSLen Brown 	}
3309889facbeSLen Brown 	if (do_rapl & RAPL_GFX) {
3310889facbeSLen Brown 		if (get_msr(cpu, MSR_PP1_POLICY, &msr))
3311889facbeSLen Brown 			return -8;
3312889facbeSLen Brown 
3313b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PP1_POLICY: %lld\n", cpu, msr & 0xF);
3314889facbeSLen Brown 
3315889facbeSLen Brown 		if (get_msr(cpu, MSR_PP1_POWER_LIMIT, &msr))
3316889facbeSLen Brown 			return -9;
3317b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_PP1_POWER_LIMIT: 0x%08llx (%slocked)\n",
3318889facbeSLen Brown 				cpu, msr, (msr >> 31) & 1 ? "" : "UN");
3319889facbeSLen Brown 		print_power_limit_msr(cpu, msr, "GFX Limit");
3320889facbeSLen Brown 	}
3321889facbeSLen Brown 	return 0;
3322889facbeSLen Brown }
3323889facbeSLen Brown 
3324d7899447SLen Brown /*
3325d7899447SLen Brown  * SNB adds support for additional MSRs:
3326d7899447SLen Brown  *
3327d7899447SLen Brown  * MSR_PKG_C7_RESIDENCY            0x000003fa
3328d7899447SLen Brown  * MSR_CORE_C7_RESIDENCY           0x000003fe
3329d7899447SLen Brown  * MSR_PKG_C2_RESIDENCY            0x0000060d
3330d7899447SLen Brown  */
3331103a8feaSLen Brown 
3332d7899447SLen Brown int has_snb_msrs(unsigned int family, unsigned int model)
3333103a8feaSLen Brown {
3334103a8feaSLen Brown 	if (!genuine_intel)
3335103a8feaSLen Brown 		return 0;
3336103a8feaSLen Brown 
3337103a8feaSLen Brown 	switch (model) {
3338869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE:
3339869ce69eSLen Brown 	case INTEL_FAM6_SANDYBRIDGE_X:
3340869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE:	/* IVB */
3341869ce69eSLen Brown 	case INTEL_FAM6_IVYBRIDGE_X:	/* IVB Xeon */
3342869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_CORE:	/* HSW */
3343869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_X:	/* HSW */
3344869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
3345869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_GT3E:	/* HSW */
3346869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
3347869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_GT3E:	/* BDW */
3348869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_X:	/* BDX */
3349869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_XEON_D:	/* BDX-DE */
3350869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3351869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3352869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3353869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
3354869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_X:	/* SKX */
3355869ce69eSLen Brown 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
33565bbac26eSXiaolong Wang 	case INTEL_FAM6_ATOM_DENVERTON:	/* DNV */
3357103a8feaSLen Brown 		return 1;
3358103a8feaSLen Brown 	}
3359103a8feaSLen Brown 	return 0;
3360103a8feaSLen Brown }
3361103a8feaSLen Brown 
3362d7899447SLen Brown /*
3363d7899447SLen Brown  * HSW adds support for additional MSRs:
3364d7899447SLen Brown  *
3365d7899447SLen Brown  * MSR_PKG_C8_RESIDENCY		0x00000630
3366d7899447SLen Brown  * MSR_PKG_C9_RESIDENCY		0x00000631
3367d7899447SLen Brown  * MSR_PKG_C10_RESIDENCY	0x00000632
33685a63426eSLen Brown  *
33695a63426eSLen Brown  * MSR_PKGC8_IRTL		0x00000633
33705a63426eSLen Brown  * MSR_PKGC9_IRTL		0x00000634
33715a63426eSLen Brown  * MSR_PKGC10_IRTL		0x00000635
33725a63426eSLen Brown  *
3373d7899447SLen Brown  */
3374d7899447SLen Brown int has_hsw_msrs(unsigned int family, unsigned int model)
3375ca58710fSKristen Carlson Accardi {
3376ca58710fSKristen Carlson Accardi 	if (!genuine_intel)
3377ca58710fSKristen Carlson Accardi 		return 0;
3378ca58710fSKristen Carlson Accardi 
3379ca58710fSKristen Carlson Accardi 	switch (model) {
3380869ce69eSLen Brown 	case INTEL_FAM6_HASWELL_ULT:	/* HSW */
3381869ce69eSLen Brown 	case INTEL_FAM6_BROADWELL_CORE:	/* BDW */
3382869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3383869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3384869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3385869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
3386869ce69eSLen Brown 	case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
3387ca58710fSKristen Carlson Accardi 		return 1;
3388ca58710fSKristen Carlson Accardi 	}
3389ca58710fSKristen Carlson Accardi 	return 0;
3390ca58710fSKristen Carlson Accardi }
3391ca58710fSKristen Carlson Accardi 
33920b2bb692SLen Brown /*
33930b2bb692SLen Brown  * SKL adds support for additional MSRS:
33940b2bb692SLen Brown  *
33950b2bb692SLen Brown  * MSR_PKG_WEIGHTED_CORE_C0_RES    0x00000658
33960b2bb692SLen Brown  * MSR_PKG_ANY_CORE_C0_RES         0x00000659
33970b2bb692SLen Brown  * MSR_PKG_ANY_GFXE_C0_RES         0x0000065A
33980b2bb692SLen Brown  * MSR_PKG_BOTH_CORE_GFXE_C0_RES   0x0000065B
33990b2bb692SLen Brown  */
34000b2bb692SLen Brown int has_skl_msrs(unsigned int family, unsigned int model)
34010b2bb692SLen Brown {
34020b2bb692SLen Brown 	if (!genuine_intel)
34030b2bb692SLen Brown 		return 0;
34040b2bb692SLen Brown 
34050b2bb692SLen Brown 	switch (model) {
3406869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3407869ce69eSLen Brown 	case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3408869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3409869ce69eSLen Brown 	case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
34100b2bb692SLen Brown 		return 1;
34110b2bb692SLen Brown 	}
34120b2bb692SLen Brown 	return 0;
34130b2bb692SLen Brown }
34140b2bb692SLen Brown 
3415144b44b1SLen Brown int is_slm(unsigned int family, unsigned int model)
3416144b44b1SLen Brown {
3417144b44b1SLen Brown 	if (!genuine_intel)
3418144b44b1SLen Brown 		return 0;
3419144b44b1SLen Brown 	switch (model) {
3420869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT1:	/* BYT */
3421869ce69eSLen Brown 	case INTEL_FAM6_ATOM_SILVERMONT2:	/* AVN */
3422144b44b1SLen Brown 		return 1;
3423144b44b1SLen Brown 	}
3424144b44b1SLen Brown 	return 0;
3425144b44b1SLen Brown }
3426144b44b1SLen Brown 
3427fb5d4327SDasaratharaman Chandramouli int is_knl(unsigned int family, unsigned int model)
3428fb5d4327SDasaratharaman Chandramouli {
3429fb5d4327SDasaratharaman Chandramouli 	if (!genuine_intel)
3430fb5d4327SDasaratharaman Chandramouli 		return 0;
3431fb5d4327SDasaratharaman Chandramouli 	switch (model) {
3432869ce69eSLen Brown 	case INTEL_FAM6_XEON_PHI_KNL:	/* KNL */
3433005c82d6SLen Brown 	case INTEL_FAM6_XEON_PHI_KNM:
3434fb5d4327SDasaratharaman Chandramouli 		return 1;
3435fb5d4327SDasaratharaman Chandramouli 	}
3436fb5d4327SDasaratharaman Chandramouli 	return 0;
3437fb5d4327SDasaratharaman Chandramouli }
3438fb5d4327SDasaratharaman Chandramouli 
3439b2b34dfeSHubert Chrzaniuk unsigned int get_aperf_mperf_multiplier(unsigned int family, unsigned int model)
3440b2b34dfeSHubert Chrzaniuk {
3441b2b34dfeSHubert Chrzaniuk 	if (is_knl(family, model))
3442b2b34dfeSHubert Chrzaniuk 		return 1024;
3443b2b34dfeSHubert Chrzaniuk 	return 1;
3444b2b34dfeSHubert Chrzaniuk }
3445b2b34dfeSHubert Chrzaniuk 
3446144b44b1SLen Brown #define SLM_BCLK_FREQS 5
3447144b44b1SLen Brown double slm_freq_table[SLM_BCLK_FREQS] = { 83.3, 100.0, 133.3, 116.7, 80.0};
3448144b44b1SLen Brown 
3449144b44b1SLen Brown double slm_bclk(void)
3450144b44b1SLen Brown {
3451144b44b1SLen Brown 	unsigned long long msr = 3;
3452144b44b1SLen Brown 	unsigned int i;
3453144b44b1SLen Brown 	double freq;
3454144b44b1SLen Brown 
34557ce7d5deSPrarit Bhargava 	if (get_msr(base_cpu, MSR_FSB_FREQ, &msr))
3456b7d8c148SLen Brown 		fprintf(outf, "SLM BCLK: unknown\n");
3457144b44b1SLen Brown 
3458144b44b1SLen Brown 	i = msr & 0xf;
3459144b44b1SLen Brown 	if (i >= SLM_BCLK_FREQS) {
3460b7d8c148SLen Brown 		fprintf(outf, "SLM BCLK[%d] invalid\n", i);
34610a91e551SColin Ian King 		i = 3;
3462144b44b1SLen Brown 	}
3463144b44b1SLen Brown 	freq = slm_freq_table[i];
3464144b44b1SLen Brown 
346596e47158SLen Brown 	if (!quiet)
3466b7d8c148SLen Brown 		fprintf(outf, "SLM BCLK: %.1f Mhz\n", freq);
3467144b44b1SLen Brown 
3468144b44b1SLen Brown 	return freq;
3469144b44b1SLen Brown }
3470144b44b1SLen Brown 
3471103a8feaSLen Brown double discover_bclk(unsigned int family, unsigned int model)
3472103a8feaSLen Brown {
3473121b48bbSChrzaniuk, Hubert 	if (has_snb_msrs(family, model) || is_knl(family, model))
3474103a8feaSLen Brown 		return 100.00;
3475144b44b1SLen Brown 	else if (is_slm(family, model))
3476144b44b1SLen Brown 		return slm_bclk();
3477103a8feaSLen Brown 	else
3478103a8feaSLen Brown 		return 133.33;
3479103a8feaSLen Brown }
3480103a8feaSLen Brown 
3481889facbeSLen Brown /*
3482889facbeSLen Brown  * MSR_IA32_TEMPERATURE_TARGET indicates the temperature where
3483889facbeSLen Brown  * the Thermal Control Circuit (TCC) activates.
3484889facbeSLen Brown  * This is usually equal to tjMax.
3485889facbeSLen Brown  *
3486889facbeSLen Brown  * Older processors do not have this MSR, so there we guess,
3487889facbeSLen Brown  * but also allow cmdline over-ride with -T.
3488889facbeSLen Brown  *
3489889facbeSLen Brown  * Several MSR temperature values are in units of degrees-C
3490889facbeSLen Brown  * below this value, including the Digital Thermal Sensor (DTS),
3491889facbeSLen Brown  * Package Thermal Management Sensor (PTM), and thermal event thresholds.
3492889facbeSLen Brown  */
3493889facbeSLen Brown int set_temperature_target(struct thread_data *t, struct core_data *c, struct pkg_data *p)
3494889facbeSLen Brown {
3495889facbeSLen Brown 	unsigned long long msr;
3496889facbeSLen Brown 	unsigned int target_c_local;
3497889facbeSLen Brown 	int cpu;
3498889facbeSLen Brown 
3499889facbeSLen Brown 	/* tcc_activation_temp is used only for dts or ptm */
3500889facbeSLen Brown 	if (!(do_dts || do_ptm))
3501889facbeSLen Brown 		return 0;
3502889facbeSLen Brown 
3503889facbeSLen Brown 	/* this is a per-package concept */
3504889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
3505889facbeSLen Brown 		return 0;
3506889facbeSLen Brown 
3507889facbeSLen Brown 	cpu = t->cpu_id;
3508889facbeSLen Brown 	if (cpu_migrate(cpu)) {
3509b7d8c148SLen Brown 		fprintf(outf, "Could not migrate to CPU %d\n", cpu);
3510889facbeSLen Brown 		return -1;
3511889facbeSLen Brown 	}
3512889facbeSLen Brown 
3513889facbeSLen Brown 	if (tcc_activation_temp_override != 0) {
3514889facbeSLen Brown 		tcc_activation_temp = tcc_activation_temp_override;
3515b7d8c148SLen Brown 		fprintf(outf, "cpu%d: Using cmdline TCC Target (%d C)\n",
3516889facbeSLen Brown 			cpu, tcc_activation_temp);
3517889facbeSLen Brown 		return 0;
3518889facbeSLen Brown 	}
3519889facbeSLen Brown 
3520889facbeSLen Brown 	/* Temperature Target MSR is Nehalem and newer only */
3521d7899447SLen Brown 	if (!do_nhm_platform_info)
3522889facbeSLen Brown 		goto guess;
3523889facbeSLen Brown 
35247ce7d5deSPrarit Bhargava 	if (get_msr(base_cpu, MSR_IA32_TEMPERATURE_TARGET, &msr))
3525889facbeSLen Brown 		goto guess;
3526889facbeSLen Brown 
35273482124aSJean Delvare 	target_c_local = (msr >> 16) & 0xFF;
3528889facbeSLen Brown 
352996e47158SLen Brown 	if (!quiet)
3530b7d8c148SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_TEMPERATURE_TARGET: 0x%08llx (%d C)\n",
3531889facbeSLen Brown 			cpu, msr, target_c_local);
3532889facbeSLen Brown 
35333482124aSJean Delvare 	if (!target_c_local)
3534889facbeSLen Brown 		goto guess;
3535889facbeSLen Brown 
3536889facbeSLen Brown 	tcc_activation_temp = target_c_local;
3537889facbeSLen Brown 
3538889facbeSLen Brown 	return 0;
3539889facbeSLen Brown 
3540889facbeSLen Brown guess:
3541889facbeSLen Brown 	tcc_activation_temp = TJMAX_DEFAULT;
3542b7d8c148SLen Brown 	fprintf(outf, "cpu%d: Guessing tjMax %d C, Please use -T to specify\n",
3543889facbeSLen Brown 		cpu, tcc_activation_temp);
3544889facbeSLen Brown 
3545889facbeSLen Brown 	return 0;
3546889facbeSLen Brown }
354769807a63SLen Brown 
3548aa8d8cc7SLen Brown void decode_feature_control_msr(void)
3549aa8d8cc7SLen Brown {
3550aa8d8cc7SLen Brown 	unsigned long long msr;
3551aa8d8cc7SLen Brown 
3552aa8d8cc7SLen Brown 	if (!get_msr(base_cpu, MSR_IA32_FEATURE_CONTROL, &msr))
3553aa8d8cc7SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_FEATURE_CONTROL: 0x%08llx (%sLocked %s)\n",
3554aa8d8cc7SLen Brown 			base_cpu, msr,
3555aa8d8cc7SLen Brown 			msr & FEATURE_CONTROL_LOCKED ? "" : "UN-",
3556aa8d8cc7SLen Brown 			msr & (1 << 18) ? "SGX" : "");
3557aa8d8cc7SLen Brown }
3558aa8d8cc7SLen Brown 
355969807a63SLen Brown void decode_misc_enable_msr(void)
356069807a63SLen Brown {
356169807a63SLen Brown 	unsigned long long msr;
356269807a63SLen Brown 
356369807a63SLen Brown 	if (!get_msr(base_cpu, MSR_IA32_MISC_ENABLE, &msr))
3564e6512624SLen Brown 		fprintf(outf, "cpu%d: MSR_IA32_MISC_ENABLE: 0x%08llx (%sTCC %sEIST %sMWAIT %sPREFETCH %sTURBO)\n",
356569807a63SLen Brown 			base_cpu, msr,
3566e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_TM1 ? "" : "No-",
3567e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP ? "" : "No-",
3568e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_MWAIT ? "No-" : "",
3569e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_PREFETCH_DISABLE ? "No-" : "",
3570e6512624SLen Brown 			msr & MSR_IA32_MISC_ENABLE_TURBO_DISABLE ? "No-" : "");
357169807a63SLen Brown }
357269807a63SLen Brown 
357333148d67SLen Brown void decode_misc_feature_control(void)
357433148d67SLen Brown {
357533148d67SLen Brown 	unsigned long long msr;
357633148d67SLen Brown 
357733148d67SLen Brown 	if (!has_misc_feature_control)
357833148d67SLen Brown 		return;
357933148d67SLen Brown 
358033148d67SLen Brown 	if (!get_msr(base_cpu, MSR_MISC_FEATURE_CONTROL, &msr))
358133148d67SLen Brown 		fprintf(outf, "cpu%d: MSR_MISC_FEATURE_CONTROL: 0x%08llx (%sL2-Prefetch %sL2-Prefetch-pair %sL1-Prefetch %sL1-IP-Prefetch)\n",
358233148d67SLen Brown 			base_cpu, msr,
358333148d67SLen Brown 			msr & (0 << 0) ? "No-" : "",
358433148d67SLen Brown 			msr & (1 << 0) ? "No-" : "",
358533148d67SLen Brown 			msr & (2 << 0) ? "No-" : "",
358633148d67SLen Brown 			msr & (3 << 0) ? "No-" : "");
358733148d67SLen Brown }
3588f0057310SLen Brown /*
3589f0057310SLen Brown  * Decode MSR_MISC_PWR_MGMT
3590f0057310SLen Brown  *
3591f0057310SLen Brown  * Decode the bits according to the Nehalem documentation
3592f0057310SLen Brown  * bit[0] seems to continue to have same meaning going forward
3593f0057310SLen Brown  * bit[1] less so...
3594f0057310SLen Brown  */
3595f0057310SLen Brown void decode_misc_pwr_mgmt_msr(void)
3596f0057310SLen Brown {
3597f0057310SLen Brown 	unsigned long long msr;
3598f0057310SLen Brown 
3599f0057310SLen Brown 	if (!do_nhm_platform_info)
3600f0057310SLen Brown 		return;
3601f0057310SLen Brown 
3602cf4cbe53SLen Brown 	if (no_MSR_MISC_PWR_MGMT)
3603cf4cbe53SLen Brown 		return;
3604cf4cbe53SLen Brown 
3605f0057310SLen Brown 	if (!get_msr(base_cpu, MSR_MISC_PWR_MGMT, &msr))
3606ddadb8adSSrinivas Pandruvada 		fprintf(outf, "cpu%d: MSR_MISC_PWR_MGMT: 0x%08llx (%sable-EIST_Coordination %sable-EPB %sable-OOB)\n",
3607f0057310SLen Brown 			base_cpu, msr,
3608f0057310SLen Brown 			msr & (1 << 0) ? "DIS" : "EN",
3609ddadb8adSSrinivas Pandruvada 			msr & (1 << 1) ? "EN" : "DIS",
3610ddadb8adSSrinivas Pandruvada 			msr & (1 << 8) ? "EN" : "DIS");
3611f0057310SLen Brown }
361271616c8eSLen Brown /*
361371616c8eSLen Brown  * Decode MSR_CC6_DEMOTION_POLICY_CONFIG, MSR_MC6_DEMOTION_POLICY_CONFIG
361471616c8eSLen Brown  *
361571616c8eSLen Brown  * This MSRs are present on Silvermont processors,
361671616c8eSLen Brown  * Intel Atom processor E3000 series (Baytrail), and friends.
361771616c8eSLen Brown  */
361871616c8eSLen Brown void decode_c6_demotion_policy_msr(void)
361971616c8eSLen Brown {
362071616c8eSLen Brown 	unsigned long long msr;
362171616c8eSLen Brown 
362271616c8eSLen Brown 	if (!get_msr(base_cpu, MSR_CC6_DEMOTION_POLICY_CONFIG, &msr))
362371616c8eSLen Brown 		fprintf(outf, "cpu%d: MSR_CC6_DEMOTION_POLICY_CONFIG: 0x%08llx (%sable-CC6-Demotion)\n",
362471616c8eSLen Brown 			base_cpu, msr, msr & (1 << 0) ? "EN" : "DIS");
362571616c8eSLen Brown 
362671616c8eSLen Brown 	if (!get_msr(base_cpu, MSR_MC6_DEMOTION_POLICY_CONFIG, &msr))
362771616c8eSLen Brown 		fprintf(outf, "cpu%d: MSR_MC6_DEMOTION_POLICY_CONFIG: 0x%08llx (%sable-MC6-Demotion)\n",
362871616c8eSLen Brown 			base_cpu, msr, msr & (1 << 0) ? "EN" : "DIS");
362971616c8eSLen Brown }
36307f5c258eSLen Brown 
3631fcd17211SLen Brown void process_cpuid()
3632103a8feaSLen Brown {
363361a87ba7SLen Brown 	unsigned int eax, ebx, ecx, edx, max_level, max_extended_level;
3634103a8feaSLen Brown 	unsigned int fms, family, model, stepping;
3635b3a34e93SLen Brown 	unsigned int has_turbo;
3636103a8feaSLen Brown 
3637103a8feaSLen Brown 	eax = ebx = ecx = edx = 0;
3638103a8feaSLen Brown 
36395aea2f7fSLen Brown 	__cpuid(0, max_level, ebx, ecx, edx);
3640103a8feaSLen Brown 
3641103a8feaSLen Brown 	if (ebx == 0x756e6547 && edx == 0x49656e69 && ecx == 0x6c65746e)
3642103a8feaSLen Brown 		genuine_intel = 1;
3643103a8feaSLen Brown 
364496e47158SLen Brown 	if (!quiet)
3645b7d8c148SLen Brown 		fprintf(outf, "CPUID(0): %.4s%.4s%.4s ",
3646103a8feaSLen Brown 			(char *)&ebx, (char *)&edx, (char *)&ecx);
3647103a8feaSLen Brown 
36485aea2f7fSLen Brown 	__cpuid(1, fms, ebx, ecx, edx);
3649103a8feaSLen Brown 	family = (fms >> 8) & 0xf;
3650103a8feaSLen Brown 	model = (fms >> 4) & 0xf;
3651103a8feaSLen Brown 	stepping = fms & 0xf;
3652103a8feaSLen Brown 	if (family == 6 || family == 0xf)
3653103a8feaSLen Brown 		model += ((fms >> 16) & 0xf) << 4;
3654103a8feaSLen Brown 
365596e47158SLen Brown 	if (!quiet) {
3656b7d8c148SLen Brown 		fprintf(outf, "%d CPUID levels; family:model:stepping 0x%x:%x:%x (%d:%d:%d)\n",
3657103a8feaSLen Brown 			max_level, family, model, stepping, family, model, stepping);
3658aa8d8cc7SLen Brown 		fprintf(outf, "CPUID(1): %s %s %s %s %s %s %s %s %s\n",
365969807a63SLen Brown 			ecx & (1 << 0) ? "SSE3" : "-",
366069807a63SLen Brown 			ecx & (1 << 3) ? "MONITOR" : "-",
3661aa8d8cc7SLen Brown 			ecx & (1 << 6) ? "SMX" : "-",
366269807a63SLen Brown 			ecx & (1 << 7) ? "EIST" : "-",
366369807a63SLen Brown 			ecx & (1 << 8) ? "TM2" : "-",
366469807a63SLen Brown 			edx & (1 << 4) ? "TSC" : "-",
366569807a63SLen Brown 			edx & (1 << 5) ? "MSR" : "-",
366669807a63SLen Brown 			edx & (1 << 22) ? "ACPI-TM" : "-",
366769807a63SLen Brown 			edx & (1 << 29) ? "TM" : "-");
366869807a63SLen Brown 	}
3669103a8feaSLen Brown 
3670b2c95d90SJosh Triplett 	if (!(edx & (1 << 5)))
3671b2c95d90SJosh Triplett 		errx(1, "CPUID: no MSR");
3672103a8feaSLen Brown 
3673103a8feaSLen Brown 	/*
3674103a8feaSLen Brown 	 * check max extended function levels of CPUID.
3675103a8feaSLen Brown 	 * This is needed to check for invariant TSC.
3676103a8feaSLen Brown 	 * This check is valid for both Intel and AMD.
3677103a8feaSLen Brown 	 */
3678103a8feaSLen Brown 	ebx = ecx = edx = 0;
36795aea2f7fSLen Brown 	__cpuid(0x80000000, max_extended_level, ebx, ecx, edx);
3680103a8feaSLen Brown 
368161a87ba7SLen Brown 	if (max_extended_level >= 0x80000007) {
3682103a8feaSLen Brown 
3683103a8feaSLen Brown 		/*
3684103a8feaSLen Brown 		 * Non-Stop TSC is advertised by CPUID.EAX=0x80000007: EDX.bit8
3685103a8feaSLen Brown 		 * this check is valid for both Intel and AMD
3686103a8feaSLen Brown 		 */
36875aea2f7fSLen Brown 		__cpuid(0x80000007, eax, ebx, ecx, edx);
36888209e054SThomas Renninger 		has_invariant_tsc = edx & (1 << 8);
3689d7899447SLen Brown 	}
3690103a8feaSLen Brown 
3691103a8feaSLen Brown 	/*
3692103a8feaSLen Brown 	 * APERF/MPERF is advertised by CPUID.EAX=0x6: ECX.bit0
3693103a8feaSLen Brown 	 * this check is valid for both Intel and AMD
3694103a8feaSLen Brown 	 */
3695103a8feaSLen Brown 
36965aea2f7fSLen Brown 	__cpuid(0x6, eax, ebx, ecx, edx);
36978209e054SThomas Renninger 	has_aperf = ecx & (1 << 0);
3698812db3f7SLen Brown 	if (has_aperf) {
3699812db3f7SLen Brown 		BIC_PRESENT(BIC_Avg_MHz);
3700812db3f7SLen Brown 		BIC_PRESENT(BIC_Busy);
3701812db3f7SLen Brown 		BIC_PRESENT(BIC_Bzy_MHz);
3702812db3f7SLen Brown 	}
3703889facbeSLen Brown 	do_dts = eax & (1 << 0);
3704812db3f7SLen Brown 	if (do_dts)
3705812db3f7SLen Brown 		BIC_PRESENT(BIC_CoreTmp);
3706b3a34e93SLen Brown 	has_turbo = eax & (1 << 1);
3707889facbeSLen Brown 	do_ptm = eax & (1 << 6);
3708812db3f7SLen Brown 	if (do_ptm)
3709812db3f7SLen Brown 		BIC_PRESENT(BIC_PkgTmp);
37107f5c258eSLen Brown 	has_hwp = eax & (1 << 7);
37117f5c258eSLen Brown 	has_hwp_notify = eax & (1 << 8);
37127f5c258eSLen Brown 	has_hwp_activity_window = eax & (1 << 9);
37137f5c258eSLen Brown 	has_hwp_epp = eax & (1 << 10);
37147f5c258eSLen Brown 	has_hwp_pkg = eax & (1 << 11);
3715889facbeSLen Brown 	has_epb = ecx & (1 << 3);
3716889facbeSLen Brown 
371796e47158SLen Brown 	if (!quiet)
3718b3a34e93SLen Brown 		fprintf(outf, "CPUID(6): %sAPERF, %sTURBO, %sDTS, %sPTM, %sHWP, "
37197f5c258eSLen Brown 			"%sHWPnotify, %sHWPwindow, %sHWPepp, %sHWPpkg, %sEPB\n",
37207f5c258eSLen Brown 			has_aperf ? "" : "No-",
3721b3a34e93SLen Brown 			has_turbo ? "" : "No-",
37227f5c258eSLen Brown 			do_dts ? "" : "No-",
37237f5c258eSLen Brown 			do_ptm ? "" : "No-",
37247f5c258eSLen Brown 			has_hwp ? "" : "No-",
37257f5c258eSLen Brown 			has_hwp_notify ? "" : "No-",
37267f5c258eSLen Brown 			has_hwp_activity_window ? "" : "No-",
37277f5c258eSLen Brown 			has_hwp_epp ? "" : "No-",
37287f5c258eSLen Brown 			has_hwp_pkg ? "" : "No-",
37297f5c258eSLen Brown 			has_epb ? "" : "No-");
3730103a8feaSLen Brown 
373196e47158SLen Brown 	if (!quiet)
373269807a63SLen Brown 		decode_misc_enable_msr();
373369807a63SLen Brown 
373433148d67SLen Brown 
373596e47158SLen Brown 	if (max_level >= 0x7 && !quiet) {
3736aa8d8cc7SLen Brown 		int has_sgx;
3737aa8d8cc7SLen Brown 
3738aa8d8cc7SLen Brown 		ecx = 0;
3739aa8d8cc7SLen Brown 
3740aa8d8cc7SLen Brown 		__cpuid_count(0x7, 0, eax, ebx, ecx, edx);
3741aa8d8cc7SLen Brown 
3742aa8d8cc7SLen Brown 		has_sgx = ebx & (1 << 2);
3743aa8d8cc7SLen Brown 		fprintf(outf, "CPUID(7): %sSGX\n", has_sgx ? "" : "No-");
3744aa8d8cc7SLen Brown 
3745aa8d8cc7SLen Brown 		if (has_sgx)
3746aa8d8cc7SLen Brown 			decode_feature_control_msr();
3747aa8d8cc7SLen Brown 	}
3748aa8d8cc7SLen Brown 
374961a87ba7SLen Brown 	if (max_level >= 0x15) {
37508a5bdf41SLen Brown 		unsigned int eax_crystal;
37518a5bdf41SLen Brown 		unsigned int ebx_tsc;
37528a5bdf41SLen Brown 
37538a5bdf41SLen Brown 		/*
37548a5bdf41SLen Brown 		 * CPUID 15H TSC/Crystal ratio, possibly Crystal Hz
37558a5bdf41SLen Brown 		 */
37568a5bdf41SLen Brown 		eax_crystal = ebx_tsc = crystal_hz = edx = 0;
37575aea2f7fSLen Brown 		__cpuid(0x15, eax_crystal, ebx_tsc, crystal_hz, edx);
37588a5bdf41SLen Brown 
37598a5bdf41SLen Brown 		if (ebx_tsc != 0) {
37608a5bdf41SLen Brown 
376196e47158SLen Brown 			if (!quiet && (ebx != 0))
3762b7d8c148SLen Brown 				fprintf(outf, "CPUID(0x15): eax_crystal: %d ebx_tsc: %d ecx_crystal_hz: %d\n",
37638a5bdf41SLen Brown 					eax_crystal, ebx_tsc, crystal_hz);
37648a5bdf41SLen Brown 
37658a5bdf41SLen Brown 			if (crystal_hz == 0)
37668a5bdf41SLen Brown 				switch(model) {
3767869ce69eSLen Brown 				case INTEL_FAM6_SKYLAKE_MOBILE:	/* SKL */
3768869ce69eSLen Brown 				case INTEL_FAM6_SKYLAKE_DESKTOP:	/* SKL */
3769869ce69eSLen Brown 				case INTEL_FAM6_KABYLAKE_MOBILE:	/* KBL */
3770869ce69eSLen Brown 				case INTEL_FAM6_KABYLAKE_DESKTOP:	/* KBL */
3771e8efbc80SLen Brown 					crystal_hz = 24000000;	/* 24.0 MHz */
3772e8efbc80SLen Brown 					break;
3773869ce69eSLen Brown 				case INTEL_FAM6_SKYLAKE_X:	/* SKX */
37747268d407SLen Brown 				case INTEL_FAM6_ATOM_DENVERTON:	/* DNV */
3775ec53e594SLen Brown 					crystal_hz = 25000000;	/* 25.0 MHz */
3776ec53e594SLen Brown 					break;
3777869ce69eSLen Brown 				case INTEL_FAM6_ATOM_GOLDMONT:	/* BXT */
3778e8efbc80SLen Brown 					crystal_hz = 19200000;	/* 19.2 MHz */
37798a5bdf41SLen Brown 					break;
37808a5bdf41SLen Brown 				default:
37818a5bdf41SLen Brown 					crystal_hz = 0;
37828a5bdf41SLen Brown 			}
37838a5bdf41SLen Brown 
37848a5bdf41SLen Brown 			if (crystal_hz) {
37858a5bdf41SLen Brown 				tsc_hz =  (unsigned long long) crystal_hz * ebx_tsc / eax_crystal;
378696e47158SLen Brown 				if (!quiet)
3787b7d8c148SLen Brown 					fprintf(outf, "TSC: %lld MHz (%d Hz * %d / %d / 1000000)\n",
37888a5bdf41SLen Brown 						tsc_hz / 1000000, crystal_hz, ebx_tsc,  eax_crystal);
37898a5bdf41SLen Brown 			}
37908a5bdf41SLen Brown 		}
37918a5bdf41SLen Brown 	}
379261a87ba7SLen Brown 	if (max_level >= 0x16) {
379361a87ba7SLen Brown 		unsigned int base_mhz, max_mhz, bus_mhz, edx;
379461a87ba7SLen Brown 
379561a87ba7SLen Brown 		/*
379661a87ba7SLen Brown 		 * CPUID 16H Base MHz, Max MHz, Bus MHz
379761a87ba7SLen Brown 		 */
379861a87ba7SLen Brown 		base_mhz = max_mhz = bus_mhz = edx = 0;
379961a87ba7SLen Brown 
38005aea2f7fSLen Brown 		__cpuid(0x16, base_mhz, max_mhz, bus_mhz, edx);
380196e47158SLen Brown 		if (!quiet)
3802b7d8c148SLen Brown 			fprintf(outf, "CPUID(0x16): base_mhz: %d max_mhz: %d bus_mhz: %d\n",
380361a87ba7SLen Brown 				base_mhz, max_mhz, bus_mhz);
380461a87ba7SLen Brown 	}
38058a5bdf41SLen Brown 
3806b2b34dfeSHubert Chrzaniuk 	if (has_aperf)
3807b2b34dfeSHubert Chrzaniuk 		aperf_mperf_multiplier = get_aperf_mperf_multiplier(family, model);
3808b2b34dfeSHubert Chrzaniuk 
3809812db3f7SLen Brown 	BIC_PRESENT(BIC_IRQ);
3810812db3f7SLen Brown 	BIC_PRESENT(BIC_TSC_MHz);
3811812db3f7SLen Brown 
3812812db3f7SLen Brown 	if (probe_nhm_msrs(family, model)) {
3813812db3f7SLen Brown 		do_nhm_platform_info = 1;
3814812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU_c1);
3815812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU_c3);
3816812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU_c6);
3817812db3f7SLen Brown 		BIC_PRESENT(BIC_SMI);
3818812db3f7SLen Brown 	}
3819d7899447SLen Brown 	do_snb_cstates = has_snb_msrs(family, model);
3820812db3f7SLen Brown 
3821812db3f7SLen Brown 	if (do_snb_cstates)
3822812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU_c7);
3823812db3f7SLen Brown 
38245a63426eSLen Brown 	do_irtl_snb = has_snb_msrs(family, model);
3825ee7e38e3SLen Brown 	do_pc2 = do_snb_cstates && (pkg_cstate_limit >= PCL__2);
3826ee7e38e3SLen Brown 	do_pc3 = (pkg_cstate_limit >= PCL__3);
3827ee7e38e3SLen Brown 	do_pc6 = (pkg_cstate_limit >= PCL__6);
3828ee7e38e3SLen Brown 	do_pc7 = do_snb_cstates && (pkg_cstate_limit >= PCL__7);
38290539ba11SLen Brown 	if (has_slv_msrs(family, model)) {
38300539ba11SLen Brown 		do_pc2 = do_pc3 = do_pc7 = 0;
38310539ba11SLen Brown 		do_pc6 = 1;
38320539ba11SLen Brown 		BIC_PRESENT(BIC_Mod_c6);
38330539ba11SLen Brown 		use_c1_residency_msr = 1;
38340539ba11SLen Brown 	}
3835d7899447SLen Brown 	do_c8_c9_c10 = has_hsw_msrs(family, model);
38365a63426eSLen Brown 	do_irtl_hsw = has_hsw_msrs(family, model);
38370b2bb692SLen Brown 	do_skl_residency = has_skl_msrs(family, model);
3838144b44b1SLen Brown 	do_slm_cstates = is_slm(family, model);
3839fb5d4327SDasaratharaman Chandramouli 	do_knl_cstates  = is_knl(family, model);
3840103a8feaSLen Brown 
384196e47158SLen Brown 	if (!quiet)
3842f0057310SLen Brown 		decode_misc_pwr_mgmt_msr();
3843f0057310SLen Brown 
384496e47158SLen Brown 	if (!quiet && has_slv_msrs(family, model))
384571616c8eSLen Brown 		decode_c6_demotion_policy_msr();
384671616c8eSLen Brown 
3847889facbeSLen Brown 	rapl_probe(family, model);
38483a9a941dSLen Brown 	perf_limit_reasons_probe(family, model);
3849889facbeSLen Brown 
385096e47158SLen Brown 	if (!quiet)
38511b69317dSColin Ian King 		dump_cstate_pstate_config_info(family, model);
3852fcd17211SLen Brown 
3853a2b7b749SLen Brown 	if (has_skl_msrs(family, model))
3854a2b7b749SLen Brown 		calculate_tsc_tweak();
3855a2b7b749SLen Brown 
3856812db3f7SLen Brown 	if (!access("/sys/class/drm/card0/power/rc6_residency_ms", R_OK))
3857812db3f7SLen Brown 		BIC_PRESENT(BIC_GFX_rc6);
3858fdf676e5SLen Brown 
3859812db3f7SLen Brown 	if (!access("/sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz", R_OK))
3860812db3f7SLen Brown 		BIC_PRESENT(BIC_GFXMHz);
386127d47356SLen Brown 
386296e47158SLen Brown 	if (!quiet)
386333148d67SLen Brown 		decode_misc_feature_control();
386433148d67SLen Brown 
3865889facbeSLen Brown 	return;
3866103a8feaSLen Brown }
3867103a8feaSLen Brown 
3868d8af6f5fSLen Brown void help()
3869103a8feaSLen Brown {
3870b7d8c148SLen Brown 	fprintf(outf,
3871d8af6f5fSLen Brown 	"Usage: turbostat [OPTIONS][(--interval seconds) | COMMAND ...]\n"
3872d8af6f5fSLen Brown 	"\n"
3873d8af6f5fSLen Brown 	"Turbostat forks the specified COMMAND and prints statistics\n"
3874d8af6f5fSLen Brown 	"when COMMAND completes.\n"
3875d8af6f5fSLen Brown 	"If no COMMAND is specified, turbostat wakes every 5-seconds\n"
3876d8af6f5fSLen Brown 	"to print statistics, until interrupted.\n"
3877388e9c81SLen Brown 	"--add		add a counter\n"
3878388e9c81SLen Brown 	"		eg. --add msr0x10,u64,cpu,delta,MY_TSC\n"
387996e47158SLen Brown 	"--quiet	skip decoding system configuration header\n"
3880d8af6f5fSLen Brown 	"--interval sec	Override default 5-second measurement interval\n"
3881d8af6f5fSLen Brown 	"--help		print this help message\n"
3882b7d8c148SLen Brown 	"--out file	create or truncate \"file\" for all output\n"
3883d8af6f5fSLen Brown 	"--version	print version information\n"
3884d8af6f5fSLen Brown 	"\n"
3885d8af6f5fSLen Brown 	"For more help, run \"man turbostat\"\n");
3886103a8feaSLen Brown }
3887103a8feaSLen Brown 
3888103a8feaSLen Brown 
3889103a8feaSLen Brown /*
3890103a8feaSLen Brown  * in /dev/cpu/ return success for names that are numbers
3891103a8feaSLen Brown  * ie. filter out ".", "..", "microcode".
3892103a8feaSLen Brown  */
3893103a8feaSLen Brown int dir_filter(const struct dirent *dirp)
3894103a8feaSLen Brown {
3895103a8feaSLen Brown 	if (isdigit(dirp->d_name[0]))
3896103a8feaSLen Brown 		return 1;
3897103a8feaSLen Brown 	else
3898103a8feaSLen Brown 		return 0;
3899103a8feaSLen Brown }
3900103a8feaSLen Brown 
3901103a8feaSLen Brown int open_dev_cpu_msr(int dummy1)
3902103a8feaSLen Brown {
3903103a8feaSLen Brown 	return 0;
3904103a8feaSLen Brown }
3905103a8feaSLen Brown 
3906c98d5d94SLen Brown void topology_probe()
3907c98d5d94SLen Brown {
3908c98d5d94SLen Brown 	int i;
3909c98d5d94SLen Brown 	int max_core_id = 0;
3910c98d5d94SLen Brown 	int max_package_id = 0;
3911c98d5d94SLen Brown 	int max_siblings = 0;
3912c98d5d94SLen Brown 	struct cpu_topology {
3913c98d5d94SLen Brown 		int core_id;
3914c98d5d94SLen Brown 		int physical_package_id;
3915c98d5d94SLen Brown 	} *cpus;
3916c98d5d94SLen Brown 
3917c98d5d94SLen Brown 	/* Initialize num_cpus, max_cpu_num */
3918c98d5d94SLen Brown 	topo.num_cpus = 0;
3919c98d5d94SLen Brown 	topo.max_cpu_num = 0;
3920c98d5d94SLen Brown 	for_all_proc_cpus(count_cpus);
3921c98d5d94SLen Brown 	if (!summary_only && topo.num_cpus > 1)
3922812db3f7SLen Brown 		BIC_PRESENT(BIC_CPU);
3923c98d5d94SLen Brown 
3924d8af6f5fSLen Brown 	if (debug > 1)
3925b7d8c148SLen Brown 		fprintf(outf, "num_cpus %d max_cpu_num %d\n", topo.num_cpus, topo.max_cpu_num);
3926c98d5d94SLen Brown 
3927c98d5d94SLen Brown 	cpus = calloc(1, (topo.max_cpu_num  + 1) * sizeof(struct cpu_topology));
3928b2c95d90SJosh Triplett 	if (cpus == NULL)
3929b2c95d90SJosh Triplett 		err(1, "calloc cpus");
3930c98d5d94SLen Brown 
3931c98d5d94SLen Brown 	/*
3932c98d5d94SLen Brown 	 * Allocate and initialize cpu_present_set
3933c98d5d94SLen Brown 	 */
3934c98d5d94SLen Brown 	cpu_present_set = CPU_ALLOC((topo.max_cpu_num + 1));
3935b2c95d90SJosh Triplett 	if (cpu_present_set == NULL)
3936b2c95d90SJosh Triplett 		err(3, "CPU_ALLOC");
3937c98d5d94SLen Brown 	cpu_present_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
3938c98d5d94SLen Brown 	CPU_ZERO_S(cpu_present_setsize, cpu_present_set);
3939c98d5d94SLen Brown 	for_all_proc_cpus(mark_cpu_present);
3940c98d5d94SLen Brown 
3941c98d5d94SLen Brown 	/*
3942c98d5d94SLen Brown 	 * Allocate and initialize cpu_affinity_set
3943c98d5d94SLen Brown 	 */
3944c98d5d94SLen Brown 	cpu_affinity_set = CPU_ALLOC((topo.max_cpu_num + 1));
3945b2c95d90SJosh Triplett 	if (cpu_affinity_set == NULL)
3946b2c95d90SJosh Triplett 		err(3, "CPU_ALLOC");
3947c98d5d94SLen Brown 	cpu_affinity_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
3948c98d5d94SLen Brown 	CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
3949c98d5d94SLen Brown 
3950c98d5d94SLen Brown 
3951c98d5d94SLen Brown 	/*
3952c98d5d94SLen Brown 	 * For online cpus
3953c98d5d94SLen Brown 	 * find max_core_id, max_package_id
3954c98d5d94SLen Brown 	 */
3955c98d5d94SLen Brown 	for (i = 0; i <= topo.max_cpu_num; ++i) {
3956c98d5d94SLen Brown 		int siblings;
3957c98d5d94SLen Brown 
3958c98d5d94SLen Brown 		if (cpu_is_not_present(i)) {
3959d8af6f5fSLen Brown 			if (debug > 1)
3960b7d8c148SLen Brown 				fprintf(outf, "cpu%d NOT PRESENT\n", i);
3961c98d5d94SLen Brown 			continue;
3962c98d5d94SLen Brown 		}
3963c98d5d94SLen Brown 		cpus[i].core_id = get_core_id(i);
3964c98d5d94SLen Brown 		if (cpus[i].core_id > max_core_id)
3965c98d5d94SLen Brown 			max_core_id = cpus[i].core_id;
3966c98d5d94SLen Brown 
3967c98d5d94SLen Brown 		cpus[i].physical_package_id = get_physical_package_id(i);
3968c98d5d94SLen Brown 		if (cpus[i].physical_package_id > max_package_id)
3969c98d5d94SLen Brown 			max_package_id = cpus[i].physical_package_id;
3970c98d5d94SLen Brown 
3971c98d5d94SLen Brown 		siblings = get_num_ht_siblings(i);
3972c98d5d94SLen Brown 		if (siblings > max_siblings)
3973c98d5d94SLen Brown 			max_siblings = siblings;
3974d8af6f5fSLen Brown 		if (debug > 1)
3975b7d8c148SLen Brown 			fprintf(outf, "cpu %d pkg %d core %d\n",
3976c98d5d94SLen Brown 				i, cpus[i].physical_package_id, cpus[i].core_id);
3977c98d5d94SLen Brown 	}
3978c98d5d94SLen Brown 	topo.num_cores_per_pkg = max_core_id + 1;
3979d8af6f5fSLen Brown 	if (debug > 1)
3980b7d8c148SLen Brown 		fprintf(outf, "max_core_id %d, sizing for %d cores per package\n",
3981c98d5d94SLen Brown 			max_core_id, topo.num_cores_per_pkg);
39821cc21f7bSLen Brown 	if (debug && !summary_only && topo.num_cores_per_pkg > 1)
3983812db3f7SLen Brown 		BIC_PRESENT(BIC_Core);
3984c98d5d94SLen Brown 
3985c98d5d94SLen Brown 	topo.num_packages = max_package_id + 1;
3986d8af6f5fSLen Brown 	if (debug > 1)
3987b7d8c148SLen Brown 		fprintf(outf, "max_package_id %d, sizing for %d packages\n",
3988c98d5d94SLen Brown 			max_package_id, topo.num_packages);
39891cc21f7bSLen Brown 	if (debug && !summary_only && topo.num_packages > 1)
3990812db3f7SLen Brown 		BIC_PRESENT(BIC_Package);
3991c98d5d94SLen Brown 
3992c98d5d94SLen Brown 	topo.num_threads_per_core = max_siblings;
3993d8af6f5fSLen Brown 	if (debug > 1)
3994b7d8c148SLen Brown 		fprintf(outf, "max_siblings %d\n", max_siblings);
3995c98d5d94SLen Brown 
3996c98d5d94SLen Brown 	free(cpus);
3997c98d5d94SLen Brown }
3998c98d5d94SLen Brown 
3999c98d5d94SLen Brown void
4000c98d5d94SLen Brown allocate_counters(struct thread_data **t, struct core_data **c, struct pkg_data **p)
4001c98d5d94SLen Brown {
4002c98d5d94SLen Brown 	int i;
4003c98d5d94SLen Brown 
4004c98d5d94SLen Brown 	*t = calloc(topo.num_threads_per_core * topo.num_cores_per_pkg *
4005678a3bd1SLen Brown 		topo.num_packages, sizeof(struct thread_data));
4006c98d5d94SLen Brown 	if (*t == NULL)
4007c98d5d94SLen Brown 		goto error;
4008c98d5d94SLen Brown 
4009c98d5d94SLen Brown 	for (i = 0; i < topo.num_threads_per_core *
4010c98d5d94SLen Brown 		topo.num_cores_per_pkg * topo.num_packages; i++)
4011c98d5d94SLen Brown 		(*t)[i].cpu_id = -1;
4012c98d5d94SLen Brown 
4013c98d5d94SLen Brown 	*c = calloc(topo.num_cores_per_pkg * topo.num_packages,
4014678a3bd1SLen Brown 		sizeof(struct core_data));
4015c98d5d94SLen Brown 	if (*c == NULL)
4016c98d5d94SLen Brown 		goto error;
4017c98d5d94SLen Brown 
4018c98d5d94SLen Brown 	for (i = 0; i < topo.num_cores_per_pkg * topo.num_packages; i++)
4019c98d5d94SLen Brown 		(*c)[i].core_id = -1;
4020c98d5d94SLen Brown 
4021678a3bd1SLen Brown 	*p = calloc(topo.num_packages, sizeof(struct pkg_data));
4022c98d5d94SLen Brown 	if (*p == NULL)
4023c98d5d94SLen Brown 		goto error;
4024c98d5d94SLen Brown 
4025c98d5d94SLen Brown 	for (i = 0; i < topo.num_packages; i++)
4026c98d5d94SLen Brown 		(*p)[i].package_id = i;
4027c98d5d94SLen Brown 
4028c98d5d94SLen Brown 	return;
4029c98d5d94SLen Brown error:
4030b2c95d90SJosh Triplett 	err(1, "calloc counters");
4031c98d5d94SLen Brown }
4032c98d5d94SLen Brown /*
4033c98d5d94SLen Brown  * init_counter()
4034c98d5d94SLen Brown  *
4035c98d5d94SLen Brown  * set cpu_id, core_num, pkg_num
4036c98d5d94SLen Brown  * set FIRST_THREAD_IN_CORE and FIRST_CORE_IN_PACKAGE
4037c98d5d94SLen Brown  *
4038c98d5d94SLen Brown  * increment topo.num_cores when 1st core in pkg seen
4039c98d5d94SLen Brown  */
4040c98d5d94SLen Brown void init_counter(struct thread_data *thread_base, struct core_data *core_base,
4041c98d5d94SLen Brown 	struct pkg_data *pkg_base, int thread_num, int core_num,
4042c98d5d94SLen Brown 	int pkg_num, int cpu_id)
4043c98d5d94SLen Brown {
4044c98d5d94SLen Brown 	struct thread_data *t;
4045c98d5d94SLen Brown 	struct core_data *c;
4046c98d5d94SLen Brown 	struct pkg_data *p;
4047c98d5d94SLen Brown 
4048c98d5d94SLen Brown 	t = GET_THREAD(thread_base, thread_num, core_num, pkg_num);
4049c98d5d94SLen Brown 	c = GET_CORE(core_base, core_num, pkg_num);
4050c98d5d94SLen Brown 	p = GET_PKG(pkg_base, pkg_num);
4051c98d5d94SLen Brown 
4052c98d5d94SLen Brown 	t->cpu_id = cpu_id;
4053c98d5d94SLen Brown 	if (thread_num == 0) {
4054c98d5d94SLen Brown 		t->flags |= CPU_IS_FIRST_THREAD_IN_CORE;
4055c98d5d94SLen Brown 		if (cpu_is_first_core_in_package(cpu_id))
4056c98d5d94SLen Brown 			t->flags |= CPU_IS_FIRST_CORE_IN_PACKAGE;
4057c98d5d94SLen Brown 	}
4058c98d5d94SLen Brown 
4059c98d5d94SLen Brown 	c->core_id = core_num;
4060c98d5d94SLen Brown 	p->package_id = pkg_num;
4061c98d5d94SLen Brown }
4062c98d5d94SLen Brown 
4063c98d5d94SLen Brown 
4064c98d5d94SLen Brown int initialize_counters(int cpu_id)
4065c98d5d94SLen Brown {
4066c98d5d94SLen Brown 	int my_thread_id, my_core_id, my_package_id;
4067c98d5d94SLen Brown 
4068c98d5d94SLen Brown 	my_package_id = get_physical_package_id(cpu_id);
4069c98d5d94SLen Brown 	my_core_id = get_core_id(cpu_id);
4070e275b388SDasaratharaman Chandramouli 	my_thread_id = get_cpu_position_in_core(cpu_id);
4071e275b388SDasaratharaman Chandramouli 	if (!my_thread_id)
4072c98d5d94SLen Brown 		topo.num_cores++;
4073c98d5d94SLen Brown 
4074c98d5d94SLen Brown 	init_counter(EVEN_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
4075c98d5d94SLen Brown 	init_counter(ODD_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
4076c98d5d94SLen Brown 	return 0;
4077c98d5d94SLen Brown }
4078c98d5d94SLen Brown 
4079c98d5d94SLen Brown void allocate_output_buffer()
4080c98d5d94SLen Brown {
40813b4d5c7fSAndy Shevchenko 	output_buffer = calloc(1, (1 + topo.num_cpus) * 1024);
4082c98d5d94SLen Brown 	outp = output_buffer;
4083b2c95d90SJosh Triplett 	if (outp == NULL)
4084b2c95d90SJosh Triplett 		err(-1, "calloc output buffer");
4085c98d5d94SLen Brown }
408636229897SLen Brown void allocate_fd_percpu(void)
408736229897SLen Brown {
408801a67adfSMika Westerberg 	fd_percpu = calloc(topo.max_cpu_num + 1, sizeof(int));
408936229897SLen Brown 	if (fd_percpu == NULL)
409036229897SLen Brown 		err(-1, "calloc fd_percpu");
409136229897SLen Brown }
4092562a2d37SLen Brown void allocate_irq_buffers(void)
4093562a2d37SLen Brown {
4094562a2d37SLen Brown 	irq_column_2_cpu = calloc(topo.num_cpus, sizeof(int));
4095562a2d37SLen Brown 	if (irq_column_2_cpu == NULL)
4096562a2d37SLen Brown 		err(-1, "calloc %d", topo.num_cpus);
4097c98d5d94SLen Brown 
409801a67adfSMika Westerberg 	irqs_per_cpu = calloc(topo.max_cpu_num + 1, sizeof(int));
4099562a2d37SLen Brown 	if (irqs_per_cpu == NULL)
410001a67adfSMika Westerberg 		err(-1, "calloc %d", topo.max_cpu_num + 1);
4101562a2d37SLen Brown }
4102c98d5d94SLen Brown void setup_all_buffers(void)
4103c98d5d94SLen Brown {
4104c98d5d94SLen Brown 	topology_probe();
4105562a2d37SLen Brown 	allocate_irq_buffers();
410636229897SLen Brown 	allocate_fd_percpu();
4107c98d5d94SLen Brown 	allocate_counters(&thread_even, &core_even, &package_even);
4108c98d5d94SLen Brown 	allocate_counters(&thread_odd, &core_odd, &package_odd);
4109c98d5d94SLen Brown 	allocate_output_buffer();
4110c98d5d94SLen Brown 	for_all_proc_cpus(initialize_counters);
4111c98d5d94SLen Brown }
41123b4d5c7fSAndy Shevchenko 
41137ce7d5deSPrarit Bhargava void set_base_cpu(void)
41147ce7d5deSPrarit Bhargava {
41157ce7d5deSPrarit Bhargava 	base_cpu = sched_getcpu();
41167ce7d5deSPrarit Bhargava 	if (base_cpu < 0)
41177ce7d5deSPrarit Bhargava 		err(-ENODEV, "No valid cpus found");
41187ce7d5deSPrarit Bhargava 
41197ce7d5deSPrarit Bhargava 	if (debug > 1)
4120b7d8c148SLen Brown 		fprintf(outf, "base_cpu = %d\n", base_cpu);
41217ce7d5deSPrarit Bhargava }
41227ce7d5deSPrarit Bhargava 
4123103a8feaSLen Brown void turbostat_init()
4124103a8feaSLen Brown {
41257ce7d5deSPrarit Bhargava 	setup_all_buffers();
41267ce7d5deSPrarit Bhargava 	set_base_cpu();
4127103a8feaSLen Brown 	check_dev_msr();
412898481e79SLen Brown 	check_permissions();
4129fcd17211SLen Brown 	process_cpuid();
4130103a8feaSLen Brown 
4131103a8feaSLen Brown 
413296e47158SLen Brown 	if (!quiet)
41337f5c258eSLen Brown 		for_all_cpus(print_hwp, ODD_COUNTERS);
41347f5c258eSLen Brown 
413596e47158SLen Brown 	if (!quiet)
4136889facbeSLen Brown 		for_all_cpus(print_epb, ODD_COUNTERS);
4137889facbeSLen Brown 
413896e47158SLen Brown 	if (!quiet)
41393a9a941dSLen Brown 		for_all_cpus(print_perf_limit, ODD_COUNTERS);
41403a9a941dSLen Brown 
414196e47158SLen Brown 	if (!quiet)
4142889facbeSLen Brown 		for_all_cpus(print_rapl, ODD_COUNTERS);
4143889facbeSLen Brown 
4144889facbeSLen Brown 	for_all_cpus(set_temperature_target, ODD_COUNTERS);
4145889facbeSLen Brown 
414696e47158SLen Brown 	if (!quiet)
4147889facbeSLen Brown 		for_all_cpus(print_thermal, ODD_COUNTERS);
41485a63426eSLen Brown 
414996e47158SLen Brown 	if (!quiet && do_irtl_snb)
41505a63426eSLen Brown 		print_irtl();
4151103a8feaSLen Brown }
4152103a8feaSLen Brown 
4153103a8feaSLen Brown int fork_it(char **argv)
4154103a8feaSLen Brown {
4155103a8feaSLen Brown 	pid_t child_pid;
4156d91bb17cSLen Brown 	int status;
4157d15cf7c1SLen Brown 
4158d91bb17cSLen Brown 	status = for_all_cpus(get_counters, EVEN_COUNTERS);
4159d91bb17cSLen Brown 	if (status)
4160d91bb17cSLen Brown 		exit(status);
4161d15cf7c1SLen Brown 	/* clear affinity side-effect of get_counters() */
4162d15cf7c1SLen Brown 	sched_setaffinity(0, cpu_present_setsize, cpu_present_set);
4163103a8feaSLen Brown 	gettimeofday(&tv_even, (struct timezone *)NULL);
4164103a8feaSLen Brown 
4165103a8feaSLen Brown 	child_pid = fork();
4166103a8feaSLen Brown 	if (!child_pid) {
4167103a8feaSLen Brown 		/* child */
4168103a8feaSLen Brown 		execvp(argv[0], argv);
4169103a8feaSLen Brown 	} else {
4170103a8feaSLen Brown 
4171103a8feaSLen Brown 		/* parent */
4172b2c95d90SJosh Triplett 		if (child_pid == -1)
4173b2c95d90SJosh Triplett 			err(1, "fork");
4174103a8feaSLen Brown 
4175103a8feaSLen Brown 		signal(SIGINT, SIG_IGN);
4176103a8feaSLen Brown 		signal(SIGQUIT, SIG_IGN);
4177b2c95d90SJosh Triplett 		if (waitpid(child_pid, &status, 0) == -1)
4178b2c95d90SJosh Triplett 			err(status, "waitpid");
4179103a8feaSLen Brown 	}
4180c98d5d94SLen Brown 	/*
4181c98d5d94SLen Brown 	 * n.b. fork_it() does not check for errors from for_all_cpus()
4182c98d5d94SLen Brown 	 * because re-starting is problematic when forking
4183c98d5d94SLen Brown 	 */
4184c98d5d94SLen Brown 	for_all_cpus(get_counters, ODD_COUNTERS);
4185103a8feaSLen Brown 	gettimeofday(&tv_odd, (struct timezone *)NULL);
4186103a8feaSLen Brown 	timersub(&tv_odd, &tv_even, &tv_delta);
4187ba3dec99SLen Brown 	if (for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS))
4188ba3dec99SLen Brown 		fprintf(outf, "%s: Counter reset detected\n", progname);
4189ba3dec99SLen Brown 	else {
4190c98d5d94SLen Brown 		compute_average(EVEN_COUNTERS);
4191c98d5d94SLen Brown 		format_all_counters(EVEN_COUNTERS);
4192ba3dec99SLen Brown 	}
4193103a8feaSLen Brown 
4194b7d8c148SLen Brown 	fprintf(outf, "%.6f sec\n", tv_delta.tv_sec + tv_delta.tv_usec/1000000.0);
4195b7d8c148SLen Brown 
4196b7d8c148SLen Brown 	flush_output_stderr();
4197103a8feaSLen Brown 
4198d91bb17cSLen Brown 	return status;
4199103a8feaSLen Brown }
4200103a8feaSLen Brown 
42013b4d5c7fSAndy Shevchenko int get_and_dump_counters(void)
42023b4d5c7fSAndy Shevchenko {
42033b4d5c7fSAndy Shevchenko 	int status;
42043b4d5c7fSAndy Shevchenko 
42053b4d5c7fSAndy Shevchenko 	status = for_all_cpus(get_counters, ODD_COUNTERS);
42063b4d5c7fSAndy Shevchenko 	if (status)
42073b4d5c7fSAndy Shevchenko 		return status;
42083b4d5c7fSAndy Shevchenko 
42093b4d5c7fSAndy Shevchenko 	status = for_all_cpus(dump_counters, ODD_COUNTERS);
42103b4d5c7fSAndy Shevchenko 	if (status)
42113b4d5c7fSAndy Shevchenko 		return status;
42123b4d5c7fSAndy Shevchenko 
4213b7d8c148SLen Brown 	flush_output_stdout();
42143b4d5c7fSAndy Shevchenko 
42153b4d5c7fSAndy Shevchenko 	return status;
42163b4d5c7fSAndy Shevchenko }
42173b4d5c7fSAndy Shevchenko 
4218d8af6f5fSLen Brown void print_version() {
42190539ba11SLen Brown 	fprintf(outf, "turbostat version 4.17 10 Jan 2017"
4220d8af6f5fSLen Brown 		" - Len Brown <lenb@kernel.org>\n");
4221d8af6f5fSLen Brown }
4222d8af6f5fSLen Brown 
4223388e9c81SLen Brown int add_counter(unsigned int msr_num, char *name, unsigned int width,
4224388e9c81SLen Brown 	enum counter_scope scope, enum counter_type type,
4225388e9c81SLen Brown 	enum counter_format format)
4226388e9c81SLen Brown {
4227388e9c81SLen Brown 	struct msr_counter *msrp;
4228388e9c81SLen Brown 
4229388e9c81SLen Brown 	msrp = calloc(1, sizeof(struct msr_counter));
4230388e9c81SLen Brown 	if (msrp == NULL) {
4231388e9c81SLen Brown 		perror("calloc");
4232388e9c81SLen Brown 		exit(1);
4233388e9c81SLen Brown 	}
4234388e9c81SLen Brown 
4235388e9c81SLen Brown 	msrp->msr_num = msr_num;
4236388e9c81SLen Brown 	strncpy(msrp->name, name, NAME_BYTES);
4237388e9c81SLen Brown 	msrp->width = width;
4238388e9c81SLen Brown 	msrp->type = type;
4239388e9c81SLen Brown 	msrp->format = format;
4240388e9c81SLen Brown 
4241388e9c81SLen Brown 	switch (scope) {
4242388e9c81SLen Brown 
4243388e9c81SLen Brown 	case SCOPE_CPU:
4244388e9c81SLen Brown 		msrp->next = sys.tp;
4245388e9c81SLen Brown 		sys.tp = msrp;
4246678a3bd1SLen Brown 		sys.added_thread_counters++;
4247678a3bd1SLen Brown 		if (sys.added_thread_counters > MAX_ADDED_COUNTERS) {
4248678a3bd1SLen Brown 			fprintf(stderr, "exceeded max %d added thread counters\n",
4249678a3bd1SLen Brown 				MAX_ADDED_COUNTERS);
4250678a3bd1SLen Brown 			exit(-1);
4251678a3bd1SLen Brown 		}
4252388e9c81SLen Brown 		break;
4253388e9c81SLen Brown 
4254388e9c81SLen Brown 	case SCOPE_CORE:
4255388e9c81SLen Brown 		msrp->next = sys.cp;
4256388e9c81SLen Brown 		sys.cp = msrp;
4257678a3bd1SLen Brown 		sys.added_core_counters++;
4258678a3bd1SLen Brown 		if (sys.added_core_counters > MAX_ADDED_COUNTERS) {
4259678a3bd1SLen Brown 			fprintf(stderr, "exceeded max %d added core counters\n",
4260678a3bd1SLen Brown 				MAX_ADDED_COUNTERS);
4261678a3bd1SLen Brown 			exit(-1);
4262678a3bd1SLen Brown 		}
4263388e9c81SLen Brown 		break;
4264388e9c81SLen Brown 
4265388e9c81SLen Brown 	case SCOPE_PACKAGE:
4266388e9c81SLen Brown 		msrp->next = sys.pp;
4267388e9c81SLen Brown 		sys.pp = msrp;
4268678a3bd1SLen Brown 		sys.added_package_counters++;
4269678a3bd1SLen Brown 		if (sys.added_package_counters > MAX_ADDED_COUNTERS) {
4270678a3bd1SLen Brown 			fprintf(stderr, "exceeded max %d added package counters\n",
4271678a3bd1SLen Brown 				MAX_ADDED_COUNTERS);
4272678a3bd1SLen Brown 			exit(-1);
4273678a3bd1SLen Brown 		}
4274388e9c81SLen Brown 		break;
4275388e9c81SLen Brown 	}
4276388e9c81SLen Brown 
4277388e9c81SLen Brown 	return 0;
4278388e9c81SLen Brown }
4279388e9c81SLen Brown 
4280388e9c81SLen Brown void parse_add_command(char *add_command)
4281388e9c81SLen Brown {
4282388e9c81SLen Brown 	int msr_num = 0;
4283388e9c81SLen Brown 	char name_buffer[NAME_BYTES];
4284388e9c81SLen Brown 	int width = 64;
4285388e9c81SLen Brown 	int fail = 0;
4286388e9c81SLen Brown 	enum counter_scope scope = SCOPE_CPU;
4287388e9c81SLen Brown 	enum counter_type type = COUNTER_CYCLES;
4288388e9c81SLen Brown 	enum counter_format format = FORMAT_DELTA;
4289388e9c81SLen Brown 
4290388e9c81SLen Brown 	while (add_command) {
4291388e9c81SLen Brown 
4292388e9c81SLen Brown 		if (sscanf(add_command, "msr0x%x", &msr_num) == 1)
4293388e9c81SLen Brown 			goto next;
4294388e9c81SLen Brown 
4295388e9c81SLen Brown 		if (sscanf(add_command, "msr%d", &msr_num) == 1)
4296388e9c81SLen Brown 			goto next;
4297388e9c81SLen Brown 
4298388e9c81SLen Brown 		if (sscanf(add_command, "u%d", &width) == 1) {
4299388e9c81SLen Brown 			if ((width == 32) || (width == 64))
4300388e9c81SLen Brown 				goto next;
4301388e9c81SLen Brown 			width = 64;
4302388e9c81SLen Brown 		}
4303388e9c81SLen Brown 		if (!strncmp(add_command, "cpu", strlen("cpu"))) {
4304388e9c81SLen Brown 			scope = SCOPE_CPU;
4305388e9c81SLen Brown 			goto next;
4306388e9c81SLen Brown 		}
4307388e9c81SLen Brown 		if (!strncmp(add_command, "core", strlen("core"))) {
4308388e9c81SLen Brown 			scope = SCOPE_CORE;
4309388e9c81SLen Brown 			goto next;
4310388e9c81SLen Brown 		}
4311388e9c81SLen Brown 		if (!strncmp(add_command, "package", strlen("package"))) {
4312388e9c81SLen Brown 			scope = SCOPE_PACKAGE;
4313388e9c81SLen Brown 			goto next;
4314388e9c81SLen Brown 		}
4315388e9c81SLen Brown 		if (!strncmp(add_command, "cycles", strlen("cycles"))) {
4316388e9c81SLen Brown 			type = COUNTER_CYCLES;
4317388e9c81SLen Brown 			goto next;
4318388e9c81SLen Brown 		}
4319388e9c81SLen Brown 		if (!strncmp(add_command, "seconds", strlen("seconds"))) {
4320388e9c81SLen Brown 			type = COUNTER_SECONDS;
4321388e9c81SLen Brown 			goto next;
4322388e9c81SLen Brown 		}
4323388e9c81SLen Brown 		if (!strncmp(add_command, "raw", strlen("raw"))) {
4324388e9c81SLen Brown 			format = FORMAT_RAW;
4325388e9c81SLen Brown 			goto next;
4326388e9c81SLen Brown 		}
4327388e9c81SLen Brown 		if (!strncmp(add_command, "delta", strlen("delta"))) {
4328388e9c81SLen Brown 			format = FORMAT_DELTA;
4329388e9c81SLen Brown 			goto next;
4330388e9c81SLen Brown 		}
4331388e9c81SLen Brown 		if (!strncmp(add_command, "percent", strlen("percent"))) {
4332388e9c81SLen Brown 			format = FORMAT_PERCENT;
4333388e9c81SLen Brown 			goto next;
4334388e9c81SLen Brown 		}
4335388e9c81SLen Brown 
4336388e9c81SLen Brown 		if (sscanf(add_command, "%18s,%*s", name_buffer) == 1) {	/* 18 < NAME_BYTES */
4337388e9c81SLen Brown 			char *eos;
4338388e9c81SLen Brown 
4339388e9c81SLen Brown 			eos = strchr(name_buffer, ',');
4340388e9c81SLen Brown 			if (eos)
4341388e9c81SLen Brown 				*eos = '\0';
4342388e9c81SLen Brown 			goto next;
4343388e9c81SLen Brown 		}
4344388e9c81SLen Brown 
4345388e9c81SLen Brown next:
4346388e9c81SLen Brown 		add_command = strchr(add_command, ',');
4347388e9c81SLen Brown 		if (add_command)
4348388e9c81SLen Brown 			add_command++;
4349388e9c81SLen Brown 
4350388e9c81SLen Brown 	}
4351388e9c81SLen Brown 	if (msr_num == 0) {
4352388e9c81SLen Brown 		fprintf(stderr, "--add: (msrDDD | msr0xXXX) required\n");
4353388e9c81SLen Brown 		fail++;
4354388e9c81SLen Brown 	}
4355388e9c81SLen Brown 
4356388e9c81SLen Brown 	/* generate default column header */
4357388e9c81SLen Brown 	if (*name_buffer == '\0') {
4358388e9c81SLen Brown 		if (format == FORMAT_RAW) {
4359388e9c81SLen Brown 			if (width == 32)
4360388e9c81SLen Brown 				sprintf(name_buffer, "msr%d", msr_num);
4361388e9c81SLen Brown 			else
4362388e9c81SLen Brown 				sprintf(name_buffer, "MSR%d", msr_num);
4363388e9c81SLen Brown 		} else if (format == FORMAT_DELTA) {
4364388e9c81SLen Brown 			if (width == 32)
4365388e9c81SLen Brown 				sprintf(name_buffer, "cnt%d", msr_num);
4366388e9c81SLen Brown 			else
4367388e9c81SLen Brown 				sprintf(name_buffer, "CNT%d", msr_num);
4368388e9c81SLen Brown 		} else if (format == FORMAT_PERCENT) {
4369388e9c81SLen Brown 			if (width == 32)
4370388e9c81SLen Brown 				sprintf(name_buffer, "msr%d%%", msr_num);
4371388e9c81SLen Brown 			else
4372388e9c81SLen Brown 				sprintf(name_buffer, "MSR%d%%", msr_num);
4373388e9c81SLen Brown 		}
4374388e9c81SLen Brown 	}
4375388e9c81SLen Brown 
4376388e9c81SLen Brown 	if (add_counter(msr_num, name_buffer, width, scope, type, format))
4377388e9c81SLen Brown 		fail++;
4378388e9c81SLen Brown 
4379388e9c81SLen Brown 	if (fail) {
4380388e9c81SLen Brown 		help();
4381388e9c81SLen Brown 		exit(1);
4382388e9c81SLen Brown 	}
4383388e9c81SLen Brown }
4384812db3f7SLen Brown /*
4385812db3f7SLen Brown  * HIDE_LIST - hide this list of counters, show the rest [default]
4386812db3f7SLen Brown  * SHOW_LIST - show this list of counters, hide the rest
4387812db3f7SLen Brown  */
4388812db3f7SLen Brown enum show_hide_mode { SHOW_LIST, HIDE_LIST } global_show_hide_mode = HIDE_LIST;
4389812db3f7SLen Brown 
4390812db3f7SLen Brown int shown;
4391812db3f7SLen Brown /*
4392812db3f7SLen Brown  * parse_show_hide() - process cmdline to set default counter action
4393812db3f7SLen Brown  */
4394812db3f7SLen Brown void parse_show_hide(char *optarg, enum show_hide_mode new_mode)
4395812db3f7SLen Brown {
4396812db3f7SLen Brown 	/*
4397812db3f7SLen Brown 	 * --show: show only those specified
4398812db3f7SLen Brown 	 *  The 1st invocation will clear and replace the enabled mask
4399812db3f7SLen Brown 	 *  subsequent invocations can add to it.
4400812db3f7SLen Brown 	 */
4401812db3f7SLen Brown 	if (new_mode == SHOW_LIST) {
4402812db3f7SLen Brown 		if (shown == 0)
4403812db3f7SLen Brown 			bic_enabled = bic_lookup(optarg);
4404812db3f7SLen Brown 		else
4405812db3f7SLen Brown 			bic_enabled |= bic_lookup(optarg);
4406812db3f7SLen Brown 		shown = 1;
4407812db3f7SLen Brown 
4408812db3f7SLen Brown 		return;
4409812db3f7SLen Brown 	}
4410812db3f7SLen Brown 
4411812db3f7SLen Brown 	/*
4412812db3f7SLen Brown 	 * --hide: do not show those specified
4413812db3f7SLen Brown 	 *  multiple invocations simply clear more bits in enabled mask
4414812db3f7SLen Brown 	 */
4415812db3f7SLen Brown 	bic_enabled &= ~bic_lookup(optarg);
4416812db3f7SLen Brown }
4417812db3f7SLen Brown 
4418103a8feaSLen Brown void cmdline(int argc, char **argv)
4419103a8feaSLen Brown {
4420103a8feaSLen Brown 	int opt;
4421d8af6f5fSLen Brown 	int option_index = 0;
4422d8af6f5fSLen Brown 	static struct option long_options[] = {
4423388e9c81SLen Brown 		{"add",		required_argument,	0, 'a'},
4424d8af6f5fSLen Brown 		{"Dump",	no_argument,		0, 'D'},
442596e47158SLen Brown 		{"debug",	no_argument,		0, 'd'},	/* internal, not documented */
4426d8af6f5fSLen Brown 		{"interval",	required_argument,	0, 'i'},
4427d8af6f5fSLen Brown 		{"help",	no_argument,		0, 'h'},
4428812db3f7SLen Brown 		{"hide",	required_argument,	0, 'H'},	// meh, -h taken by --help
4429d8af6f5fSLen Brown 		{"Joules",	no_argument,		0, 'J'},
4430b7d8c148SLen Brown 		{"out",		required_argument,	0, 'o'},
4431d8af6f5fSLen Brown 		{"Package",	no_argument,		0, 'p'},
4432d8af6f5fSLen Brown 		{"processor",	no_argument,		0, 'p'},
443396e47158SLen Brown 		{"quiet",	no_argument,		0, 'q'},
4434812db3f7SLen Brown 		{"show",	required_argument,	0, 's'},
4435d8af6f5fSLen Brown 		{"Summary",	no_argument,		0, 'S'},
4436d8af6f5fSLen Brown 		{"TCC",		required_argument,	0, 'T'},
4437d8af6f5fSLen Brown 		{"version",	no_argument,		0, 'v' },
4438d8af6f5fSLen Brown 		{0,		0,			0,  0 }
4439d8af6f5fSLen Brown 	};
4440103a8feaSLen Brown 
4441103a8feaSLen Brown 	progname = argv[0];
4442103a8feaSLen Brown 
444396e47158SLen Brown 	while ((opt = getopt_long_only(argc, argv, "+C:c:Ddhi:JM:m:o:PpqST:v",
4444d8af6f5fSLen Brown 				long_options, &option_index)) != -1) {
4445103a8feaSLen Brown 		switch (opt) {
4446388e9c81SLen Brown 		case 'a':
4447388e9c81SLen Brown 			parse_add_command(optarg);
4448388e9c81SLen Brown 			break;
4449d8af6f5fSLen Brown 		case 'D':
4450d8af6f5fSLen Brown 			dump_only++;
44518e180f3cSLen Brown 			break;
4452d8af6f5fSLen Brown 		case 'd':
4453d8af6f5fSLen Brown 			debug++;
44542f32edf1SLen Brown 			break;
4455812db3f7SLen Brown 		case 'H':
4456812db3f7SLen Brown 			parse_show_hide(optarg, HIDE_LIST);
4457812db3f7SLen Brown 			break;
4458d8af6f5fSLen Brown 		case 'h':
4459d8af6f5fSLen Brown 		default:
4460d8af6f5fSLen Brown 			help();
4461d8af6f5fSLen Brown 			exit(1);
4462d8af6f5fSLen Brown 		case 'i':
44632a0609c0SLen Brown 			{
44642a0609c0SLen Brown 				double interval = strtod(optarg, NULL);
44652a0609c0SLen Brown 
44662a0609c0SLen Brown 				if (interval < 0.001) {
4467b7d8c148SLen Brown 					fprintf(outf, "interval %f seconds is too small\n",
44682a0609c0SLen Brown 						interval);
44692a0609c0SLen Brown 					exit(2);
44702a0609c0SLen Brown 				}
44712a0609c0SLen Brown 
44722a0609c0SLen Brown 				interval_ts.tv_sec = interval;
44732a0609c0SLen Brown 				interval_ts.tv_nsec = (interval - interval_ts.tv_sec) * 1000000000;
44742a0609c0SLen Brown 			}
4475889facbeSLen Brown 			break;
44765c56be9aSDirk Brandewie 		case 'J':
44775c56be9aSDirk Brandewie 			rapl_joules++;
44785c56be9aSDirk Brandewie 			break;
4479b7d8c148SLen Brown 		case 'o':
4480b7d8c148SLen Brown 			outf = fopen_or_die(optarg, "w");
4481b7d8c148SLen Brown 			break;
4482d8af6f5fSLen Brown 		case 'P':
4483d8af6f5fSLen Brown 			show_pkg_only++;
4484d8af6f5fSLen Brown 			break;
4485d8af6f5fSLen Brown 		case 'p':
4486d8af6f5fSLen Brown 			show_core_only++;
4487d8af6f5fSLen Brown 			break;
448896e47158SLen Brown 		case 'q':
448996e47158SLen Brown 			quiet = 1;
449096e47158SLen Brown 			break;
4491812db3f7SLen Brown 		case 's':
4492812db3f7SLen Brown 			parse_show_hide(optarg, SHOW_LIST);
4493812db3f7SLen Brown 			break;
4494d8af6f5fSLen Brown 		case 'S':
4495d8af6f5fSLen Brown 			summary_only++;
4496d8af6f5fSLen Brown 			break;
4497d8af6f5fSLen Brown 		case 'T':
4498d8af6f5fSLen Brown 			tcc_activation_temp_override = atoi(optarg);
4499d8af6f5fSLen Brown 			break;
4500d8af6f5fSLen Brown 		case 'v':
4501d8af6f5fSLen Brown 			print_version();
4502d8af6f5fSLen Brown 			exit(0);
4503d8af6f5fSLen Brown 			break;
4504103a8feaSLen Brown 		}
4505103a8feaSLen Brown 	}
4506103a8feaSLen Brown }
4507103a8feaSLen Brown 
4508103a8feaSLen Brown int main(int argc, char **argv)
4509103a8feaSLen Brown {
4510b7d8c148SLen Brown 	outf = stderr;
4511b7d8c148SLen Brown 
4512103a8feaSLen Brown 	cmdline(argc, argv);
4513103a8feaSLen Brown 
451496e47158SLen Brown 	if (!quiet)
4515d8af6f5fSLen Brown 		print_version();
4516103a8feaSLen Brown 
4517103a8feaSLen Brown 	turbostat_init();
4518103a8feaSLen Brown 
45193b4d5c7fSAndy Shevchenko 	/* dump counters and exit */
45203b4d5c7fSAndy Shevchenko 	if (dump_only)
45213b4d5c7fSAndy Shevchenko 		return get_and_dump_counters();
45223b4d5c7fSAndy Shevchenko 
4523103a8feaSLen Brown 	/*
4524103a8feaSLen Brown 	 * if any params left, it must be a command to fork
4525103a8feaSLen Brown 	 */
4526103a8feaSLen Brown 	if (argc - optind)
4527103a8feaSLen Brown 		return fork_it(argv + optind);
4528103a8feaSLen Brown 	else
4529103a8feaSLen Brown 		turbostat_loop();
4530103a8feaSLen Brown 
4531103a8feaSLen Brown 	return 0;
4532103a8feaSLen Brown }
4533