CPUMAllMsrs.cpp@ 60762

Last change on this file since 60762 was 60762, checked in by vboxsync, 9 years ago
CPUM: Added an atom silvermont CPU profile.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 190.6 KB

Line
1	/* $Id: CPUMAllMsrs.cpp 60762 2016-04-29 13:39:25Z vboxsync $ */
2	/** @file
3	* CPUM - CPU MSR Registers.
4	*/
5
6	/*
7	* Copyright (C) 2013-2015 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_CPUM
23	#include <VBox/vmm/cpum.h>
24	#include <VBox/vmm/pdmapi.h>
25	#include <VBox/vmm/hm.h>
26	#include <VBox/vmm/tm.h>
27	#include <VBox/vmm/gim.h>
28	#include "CPUMInternal.h"
29	#include <VBox/vmm/vm.h>
30	#include <VBox/err.h>
31
32
33	/*********************************************************************************************************************************
34	* Defined Constants And Macros *
35	*********************************************************************************************************************************/
36	/**
37	* Validates the CPUMMSRRANGE::offCpumCpu value and declares a local variable
38	* pointing to it.
39	*
40	* ASSUMES sizeof(a_Type) is a power of two and that the member is aligned
41	* correctly.
42	*/
43	#define CPUM_MSR_ASSERT_CPUMCPU_OFFSET_RETURN(a_pVCpu, a_pRange, a_Type, a_VarName) \
44	AssertMsgReturn( (a_pRange)->offCpumCpu >= 8 \
45	&& (a_pRange)->offCpumCpu < sizeof(CPUMCPU) \
46	&& !((a_pRange)->offCpumCpu & (RT_MIN(sizeof(a_Type), 8) - 1)) \
47	, ("offCpumCpu=%#x %s\n", (a_pRange)->offCpumCpu, (a_pRange)->szName), \
48	VERR_CPUM_MSR_BAD_CPUMCPU_OFFSET); \
49	a_Type a_VarName = (a_Type )((uintptr_t)&(a_pVCpu)->cpum.s + (a_pRange)->offCpumCpu)
50
51
52	/*********************************************************************************************************************************
53	* Structures and Typedefs *
54	*********************************************************************************************************************************/
55
56	/**
57	* Implements reading one or more MSRs.
58	*
59	* @returns VBox status code.
60	* @retval VINF_SUCCESS on success.
61	* @retval VINF_CPUM_R3_MSR_READ if the MSR read could not be serviced in the
62	* current context (raw-mode or ring-0).
63	* @retval VERR_CPUM_RAISE_GP_0 on failure (invalid MSR).
64	*
65	* @param pVCpu The cross context virtual CPU structure.
66	* @param idMsr The MSR we're reading.
67	* @param pRange The MSR range descriptor.
68	* @param puValue Where to return the value.
69	*/
70	typedef DECLCALLBACK(VBOXSTRICTRC) FNCPUMRDMSR(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue);
71	/** Pointer to a RDMSR worker for a specific MSR or range of MSRs. */
72	typedef FNCPUMRDMSR *PFNCPUMRDMSR;
73
74
75	/**
76	* Implements writing one or more MSRs.
77	*
78	* @retval VINF_SUCCESS on success.
79	* @retval VINF_CPUM_R3_MSR_WRITE if the MSR write could not be serviced in the
80	* current context (raw-mode or ring-0).
81	* @retval VERR_CPUM_RAISE_GP_0 on failure.
82	*
83	* @param pVCpu The cross context virtual CPU structure.
84	* @param idMsr The MSR we're writing.
85	* @param pRange The MSR range descriptor.
86	* @param uValue The value to set, ignored bits masked.
87	* @param uRawValue The raw value with the ignored bits not masked.
88	*/
89	typedef DECLCALLBACK(VBOXSTRICTRC) FNCPUMWRMSR(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue);
90	/** Pointer to a WRMSR worker for a specific MSR or range of MSRs. */
91	typedef FNCPUMWRMSR *PFNCPUMWRMSR;
92
93
94
95	/*
96	* Generic functions.
97	* Generic functions.
98	* Generic functions.
99	*/
100
101
102	/** @callback_method_impl{FNCPUMRDMSR} */
103	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_FixedValue(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
104	{
105	*puValue = pRange->uValue;
106	return VINF_SUCCESS;
107	}
108
109
110	/** @callback_method_impl{FNCPUMWRMSR} */
111	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IgnoreWrite(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
112	{
113	Log(("CPUM: Ignoring WRMSR %#x (%s), %#llx\n", idMsr, pRange->szName, uValue));
114	return VINF_SUCCESS;
115	}
116
117
118	/** @callback_method_impl{FNCPUMRDMSR} */
119	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_WriteOnly(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
120	{
121	return VERR_CPUM_RAISE_GP_0;
122	}
123
124
125	/** @callback_method_impl{FNCPUMWRMSR} */
126	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_ReadOnly(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
127	{
128	Assert(pRange->fWrGpMask == UINT64_MAX);
129	return VERR_CPUM_RAISE_GP_0;
130	}
131
132
133
134
135	/*
136	* IA32
137	* IA32
138	* IA32
139	*/
140
141	/** @callback_method_impl{FNCPUMRDMSR} */
142	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32P5McAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
143	{
144	puValue = 0; /* @todo implement machine check injection. */
145	return VINF_SUCCESS;
146	}
147
148
149	/** @callback_method_impl{FNCPUMWRMSR} */
150	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32P5McAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
151	{
152	/** @todo implement machine check injection. */
153	return VINF_SUCCESS;
154	}
155
156
157	/** @callback_method_impl{FNCPUMRDMSR} */
158	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32P5McType(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
159	{
160	puValue = 0; /* @todo implement machine check injection. */
161	return VINF_SUCCESS;
162	}
163
164
165	/** @callback_method_impl{FNCPUMWRMSR} */
166	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32P5McType(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
167	{
168	/** @todo implement machine check injection. */
169	return VINF_SUCCESS;
170	}
171
172
173	/** @callback_method_impl{FNCPUMRDMSR} */
174	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32TimestampCounter(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
175	{
176	*puValue = TMCpuTickGet(pVCpu);
177	return VINF_SUCCESS;
178	}
179
180
181	/** @callback_method_impl{FNCPUMWRMSR} */
182	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32TimestampCounter(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
183	{
184	TMCpuTickSet(pVCpu->CTX_SUFF(pVM), pVCpu, uValue);
185	return VINF_SUCCESS;
186	}
187
188
189	/** @callback_method_impl{FNCPUMRDMSR} */
190	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32PlatformId(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
191	{
192	uint64_t uValue = pRange->uValue;
193	if (uValue & 0x1f00)
194	{
195	/* Max allowed bus ratio present. */
196	/** @todo Implement scaled BUS frequency. */
197	}
198
199	*puValue = uValue;
200	return VINF_SUCCESS;
201	}
202
203
204	/** @callback_method_impl{FNCPUMRDMSR} */
205	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32ApicBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
206	{
207	return PDMApicGetBaseMsr(pVCpu, puValue, false /* fIgnoreErrors */);
208	}
209
210
211	/** @callback_method_impl{FNCPUMWRMSR} */
212	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32ApicBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
213	{
214	return PDMApicSetBaseMsr(pVCpu, uValue);
215	}
216
217
218	/** @callback_method_impl{FNCPUMRDMSR} */
219	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32FeatureControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
220	{
221	puValue = 1; / Locked, no VT-X, no SYSENTER micromanagement. */
222	return VINF_SUCCESS;
223	}
224
225
226	/** @callback_method_impl{FNCPUMWRMSR} */
227	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32FeatureControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
228	{
229	return VERR_CPUM_RAISE_GP_0;
230	}
231
232
233	/** @callback_method_impl{FNCPUMRDMSR} */
234	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32BiosSignId(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
235	{
236	/** @todo fake microcode update. */
237	*puValue = pRange->uValue;
238	return VINF_SUCCESS;
239	}
240
241
242	/** @callback_method_impl{FNCPUMWRMSR} */
243	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32BiosSignId(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
244	{
245	/* Normally, zero is written to Ia32BiosSignId before reading it in order
246	to select the signature instead of the BBL_CR_D3 behaviour. The GP mask
247	of the database entry should take care of most illegal writes for now, so
248	just ignore all writes atm. */
249	return VINF_SUCCESS;
250	}
251
252
253	/** @callback_method_impl{FNCPUMWRMSR} */
254	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32BiosUpdateTrigger(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
255	{
256	/** @todo Fake bios update trigger better. The value is the address to an
257	* update package, I think. We should probably GP if it's invalid. */
258	return VINF_SUCCESS;
259	}
260
261
262	/** @callback_method_impl{FNCPUMRDMSR} */
263	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32SmmMonitorCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
264	{
265	/** @todo SMM. */
266	*puValue = 0;
267	return VINF_SUCCESS;
268	}
269
270
271	/** @callback_method_impl{FNCPUMWRMSR} */
272	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32SmmMonitorCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
273	{
274	/** @todo SMM. */
275	return VINF_SUCCESS;
276	}
277
278
279	/** @callback_method_impl{FNCPUMRDMSR} */
280	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32PmcN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
281	{
282	/** @todo check CPUID leaf 0ah. */
283	*puValue = 0;
284	return VINF_SUCCESS;
285	}
286
287
288	/** @callback_method_impl{FNCPUMWRMSR} */
289	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32PmcN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
290	{
291	/** @todo check CPUID leaf 0ah. */
292	return VINF_SUCCESS;
293	}
294
295
296	/** @callback_method_impl{FNCPUMRDMSR} */
297	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32MonitorFilterLineSize(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
298	{
299	/** @todo return 0x1000 if we try emulate mwait 100% correctly. */
300	puValue = 0x40; /* @todo Change to CPU cache line size. */
301	return VINF_SUCCESS;
302	}
303
304
305	/** @callback_method_impl{FNCPUMWRMSR} */
306	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32MonitorFilterLineSize(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
307	{
308	/** @todo should remember writes, though it's supposedly something only a BIOS
309	* would write so, it's not extremely important. */
310	return VINF_SUCCESS;
311	}
312
313	/** @callback_method_impl{FNCPUMRDMSR} */
314	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32MPerf(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
315	{
316	/** @todo Read MPERF: Adjust against previously written MPERF value. Is TSC
317	* what we want? */
318	*puValue = TMCpuTickGet(pVCpu);
319	return VINF_SUCCESS;
320	}
321
322
323	/** @callback_method_impl{FNCPUMWRMSR} */
324	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32MPerf(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
325	{
326	/** @todo Write MPERF: Calc adjustment. */
327	return VINF_SUCCESS;
328	}
329
330
331	/** @callback_method_impl{FNCPUMRDMSR} */
332	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32APerf(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
333	{
334	/** @todo Read APERF: Adjust against previously written MPERF value. Is TSC
335	* what we want? */
336	*puValue = TMCpuTickGet(pVCpu);
337	return VINF_SUCCESS;
338	}
339
340
341	/** @callback_method_impl{FNCPUMWRMSR} */
342	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32APerf(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
343	{
344	/** @todo Write APERF: Calc adjustment. */
345	return VINF_SUCCESS;
346	}
347
348
349	/** @callback_method_impl{FNCPUMRDMSR} */
350	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32MtrrCap(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
351	{
352	/* This is currently a bit weird. :-) */
353	uint8_t const cVariableRangeRegs = 0;
354	bool const fSystemManagementRangeRegisters = false;
355	bool const fFixedRangeRegisters = false;
356	bool const fWriteCombiningType = false;
357	*puValue = cVariableRangeRegs
358	\| (fFixedRangeRegisters ? RT_BIT_64(8) : 0)
359	\| (fWriteCombiningType ? RT_BIT_64(10) : 0)
360	\| (fSystemManagementRangeRegisters ? RT_BIT_64(11) : 0);
361	return VINF_SUCCESS;
362	}
363
364
365	/** @callback_method_impl{FNCPUMRDMSR} */
366	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32MtrrPhysBaseN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
367	{
368	/** @todo Implement variable MTRR storage. */
369	Assert(pRange->uValue == (idMsr - 0x200) / 2);
370	*puValue = 0;
371	return VINF_SUCCESS;
372	}
373
374
375	/** @callback_method_impl{FNCPUMWRMSR} */
376	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32MtrrPhysBaseN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
377	{
378	/*
379	* Validate the value.
380	*/
381	Assert(pRange->uValue == (idMsr - 0x200) / 2);
382
383	if ((uValue & 0xff) >= 7)
384	{
385	Log(("CPUM: Invalid type set writing MTRR PhysBase MSR %#x: %#llx (%#llx)\n", idMsr, uValue, uValue & 0xff));
386	return VERR_CPUM_RAISE_GP_0;
387	}
388
389	uint64_t fInvPhysMask = ~(RT_BIT_64(pVCpu->CTX_SUFF(pVM)->cpum.s.GuestFeatures.cMaxPhysAddrWidth) - 1U);
390	if (fInvPhysMask & uValue)
391	{
392	Log(("CPUM: Invalid physical address bits set writing MTRR PhysBase MSR %#x: %#llx (%#llx)\n",
393	idMsr, uValue, uValue & fInvPhysMask));
394	return VERR_CPUM_RAISE_GP_0;
395	}
396
397	/*
398	* Store it.
399	*/
400	/** @todo Implement variable MTRR storage. */
401	return VINF_SUCCESS;
402	}
403
404
405	/** @callback_method_impl{FNCPUMRDMSR} */
406	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32MtrrPhysMaskN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
407	{
408	/** @todo Implement variable MTRR storage. */
409	Assert(pRange->uValue == (idMsr - 0x200) / 2);
410	*puValue = 0;
411	return VINF_SUCCESS;
412	}
413
414
415	/** @callback_method_impl{FNCPUMWRMSR} */
416	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32MtrrPhysMaskN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
417	{
418	/*
419	* Validate the value.
420	*/
421	Assert(pRange->uValue == (idMsr - 0x200) / 2);
422
423	uint64_t fInvPhysMask = ~(RT_BIT_64(pVCpu->CTX_SUFF(pVM)->cpum.s.GuestFeatures.cMaxPhysAddrWidth) - 1U);
424	if (fInvPhysMask & uValue)
425	{
426	Log(("CPUM: Invalid physical address bits set writing MTRR PhysMask MSR %#x: %#llx (%#llx)\n",
427	idMsr, uValue, uValue & fInvPhysMask));
428	return VERR_CPUM_RAISE_GP_0;
429	}
430
431	/*
432	* Store it.
433	*/
434	/** @todo Implement variable MTRR storage. */
435	return VINF_SUCCESS;
436	}
437
438
439	/** @callback_method_impl{FNCPUMRDMSR} */
440	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32MtrrFixed(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
441	{
442	CPUM_MSR_ASSERT_CPUMCPU_OFFSET_RETURN(pVCpu, pRange, uint64_t, puFixedMtrr);
443	puValue = puFixedMtrr;
444	return VINF_SUCCESS;
445	}
446
447
448	/** @callback_method_impl{FNCPUMWRMSR} */
449	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32MtrrFixed(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
450	{
451	CPUM_MSR_ASSERT_CPUMCPU_OFFSET_RETURN(pVCpu, pRange, uint64_t, puFixedMtrr);
452	for (uint32_t cShift = 0; cShift < 63; cShift += 8)
453	{
454	uint8_t uType = (uint8_t)(uValue >> cShift);
455	if (uType >= 7)
456	{
457	Log(("CPUM: Invalid MTRR type at %u:%u in fixed range (%#x/%s): %#llx (%#llx)\n",
458	cShift + 7, cShift, idMsr, pRange->szName, uValue, uType));
459	return VERR_CPUM_RAISE_GP_0;
460	}
461	}
462	*puFixedMtrr = uValue;
463	return VINF_SUCCESS;
464	}
465
466
467	/** @callback_method_impl{FNCPUMRDMSR} */
468	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32MtrrDefType(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
469	{
470	*puValue = pVCpu->cpum.s.GuestMsrs.msr.MtrrDefType;
471	return VINF_SUCCESS;
472	}
473
474
475	/** @callback_method_impl{FNCPUMWRMSR} */
476	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32MtrrDefType(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
477	{
478	if ((uValue & 0xff) >= 7)
479	{
480	Log(("CPUM: Invalid MTRR default type value on %s: %#llx (%#llx)\n", pRange->szName, uValue, uValue & 0xff));
481	return VERR_CPUM_RAISE_GP_0;
482	}
483
484	pVCpu->cpum.s.GuestMsrs.msr.MtrrDefType = uValue;
485	return VINF_SUCCESS;
486	}
487
488
489	/** @callback_method_impl{FNCPUMRDMSR} */
490	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32Pat(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
491	{
492	*puValue = pVCpu->cpum.s.Guest.msrPAT;
493	return VINF_SUCCESS;
494	}
495
496
497	/** @callback_method_impl{FNCPUMWRMSR} */
498	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32Pat(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
499	{
500	pVCpu->cpum.s.Guest.msrPAT = uValue;
501	return VINF_SUCCESS;
502	}
503
504
505	/** @callback_method_impl{FNCPUMRDMSR} */
506	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32SysEnterCs(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
507	{
508	*puValue = pVCpu->cpum.s.Guest.SysEnter.cs;
509	return VINF_SUCCESS;
510	}
511
512
513	/** @callback_method_impl{FNCPUMWRMSR} */
514	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32SysEnterCs(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
515	{
516	/* Note! We used to mask this by 0xffff, but turns out real HW doesn't and
517	there are generally 32-bit working bits backing this register. */
518	pVCpu->cpum.s.Guest.SysEnter.cs = uValue;
519	return VINF_SUCCESS;
520	}
521
522
523	/** @callback_method_impl{FNCPUMRDMSR} */
524	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32SysEnterEsp(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
525	{
526	*puValue = pVCpu->cpum.s.Guest.SysEnter.esp;
527	return VINF_SUCCESS;
528	}
529
530
531	/** @callback_method_impl{FNCPUMWRMSR} */
532	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32SysEnterEsp(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
533	{
534	if (X86_IS_CANONICAL(uValue))
535	{
536	pVCpu->cpum.s.Guest.SysEnter.esp = uValue;
537	return VINF_SUCCESS;
538	}
539	Log(("CPUM: IA32_SYSENTER_ESP not canonical! %#llx\n", uValue));
540	return VERR_CPUM_RAISE_GP_0;
541	}
542
543
544	/** @callback_method_impl{FNCPUMRDMSR} */
545	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32SysEnterEip(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
546	{
547	*puValue = pVCpu->cpum.s.Guest.SysEnter.eip;
548	return VINF_SUCCESS;
549	}
550
551
552	/** @callback_method_impl{FNCPUMWRMSR} */
553	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32SysEnterEip(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
554	{
555	if (X86_IS_CANONICAL(uValue))
556	{
557	pVCpu->cpum.s.Guest.SysEnter.eip = uValue;
558	return VINF_SUCCESS;
559	}
560	#ifdef IN_RING3
561	LogRel(("CPUM: IA32_SYSENTER_EIP not canonical! %#llx\n", uValue));
562	#else
563	Log(("CPUM: IA32_SYSENTER_EIP not canonical! %#llx\n", uValue));
564	#endif
565	return VERR_CPUM_RAISE_GP_0;
566	}
567
568
569	/** @callback_method_impl{FNCPUMRDMSR} */
570	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32McgCap(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
571	{
572	#if 0 /** @todo implement machine checks. */
573	*puValue = pRange->uValue & (RT_BIT_64(8) \| 0);
574	#else
575	*puValue = 0;
576	#endif
577	return VINF_SUCCESS;
578	}
579
580
581	/** @callback_method_impl{FNCPUMRDMSR} */
582	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32McgStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
583	{
584	/** @todo implement machine checks. */
585	*puValue = 0;
586	return VINF_SUCCESS;
587	}
588
589
590	/** @callback_method_impl{FNCPUMWRMSR} */
591	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32McgStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
592	{
593	/** @todo implement machine checks. */
594	return VINF_SUCCESS;
595	}
596
597
598	/** @callback_method_impl{FNCPUMRDMSR} */
599	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32McgCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
600	{
601	/** @todo implement machine checks. */
602	*puValue = 0;
603	return VINF_SUCCESS;
604	}
605
606
607	/** @callback_method_impl{FNCPUMWRMSR} */
608	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32McgCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
609	{
610	/** @todo implement machine checks. */
611	return VINF_SUCCESS;
612	}
613
614
615	/** @callback_method_impl{FNCPUMRDMSR} */
616	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32DebugCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
617	{
618	/** @todo implement IA32_DEBUGCTL. */
619	*puValue = 0;
620	return VINF_SUCCESS;
621	}
622
623
624	/** @callback_method_impl{FNCPUMWRMSR} */
625	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32DebugCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
626	{
627	/** @todo implement IA32_DEBUGCTL. */
628	return VINF_SUCCESS;
629	}
630
631
632	/** @callback_method_impl{FNCPUMRDMSR} */
633	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32SmrrPhysBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
634	{
635	/** @todo implement intel SMM. */
636	*puValue = 0;
637	return VINF_SUCCESS;
638	}
639
640
641	/** @callback_method_impl{FNCPUMWRMSR} */
642	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32SmrrPhysBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
643	{
644	/** @todo implement intel SMM. */
645	return VERR_CPUM_RAISE_GP_0;
646	}
647
648
649	/** @callback_method_impl{FNCPUMRDMSR} */
650	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32SmrrPhysMask(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
651	{
652	/** @todo implement intel SMM. */
653	*puValue = 0;
654	return VINF_SUCCESS;
655	}
656
657
658	/** @callback_method_impl{FNCPUMWRMSR} */
659	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32SmrrPhysMask(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
660	{
661	/** @todo implement intel SMM. */
662	return VERR_CPUM_RAISE_GP_0;
663	}
664
665
666	/** @callback_method_impl{FNCPUMRDMSR} */
667	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32PlatformDcaCap(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
668	{
669	/** @todo implement intel direct cache access (DCA)?? */
670	*puValue = 0;
671	return VINF_SUCCESS;
672	}
673
674
675	/** @callback_method_impl{FNCPUMWRMSR} */
676	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32PlatformDcaCap(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
677	{
678	/** @todo implement intel direct cache access (DCA)?? */
679	return VINF_SUCCESS;
680	}
681
682
683	/** @callback_method_impl{FNCPUMRDMSR} */
684	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32CpuDcaCap(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
685	{
686	/** @todo implement intel direct cache access (DCA)?? */
687	*puValue = 0;
688	return VINF_SUCCESS;
689	}
690
691
692	/** @callback_method_impl{FNCPUMRDMSR} */
693	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32Dca0Cap(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
694	{
695	/** @todo implement intel direct cache access (DCA)?? */
696	*puValue = 0;
697	return VINF_SUCCESS;
698	}
699
700
701	/** @callback_method_impl{FNCPUMWRMSR} */
702	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32Dca0Cap(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
703	{
704	/** @todo implement intel direct cache access (DCA)?? */
705	return VINF_SUCCESS;
706	}
707
708
709	/** @callback_method_impl{FNCPUMRDMSR} */
710	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32PerfEvtSelN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
711	{
712	/** @todo implement IA32_PERFEVTSEL0+. */
713	*puValue = 0;
714	return VINF_SUCCESS;
715	}
716
717
718	/** @callback_method_impl{FNCPUMWRMSR} */
719	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32PerfEvtSelN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
720	{
721	/** @todo implement IA32_PERFEVTSEL0+. */
722	return VINF_SUCCESS;
723	}
724
725
726	/** @callback_method_impl{FNCPUMRDMSR} */
727	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32PerfStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
728	{
729	uint64_t uValue = pRange->uValue;
730
731	/* Always provide the max bus ratio for now. XNU expects it. */
732	uValue &= ~((UINT64_C(0x1f) << 40) \| RT_BIT_64(46));
733
734	PVM pVM = pVCpu->CTX_SUFF(pVM);
735	uint64_t uScalableBusHz = CPUMGetGuestScalableBusFrequency(pVM);
736	uint64_t uTscHz = TMCpuTicksPerSecond(pVM);
737	uint8_t uTscRatio = (uint8_t)((uTscHz + uScalableBusHz / 2) / uScalableBusHz);
738	if (uTscRatio > 0x1f)
739	uTscRatio = 0x1f;
740	uValue \|= (uint64_t)uTscRatio << 40;
741
742	*puValue = uValue;
743	return VINF_SUCCESS;
744	}
745
746
747	/** @callback_method_impl{FNCPUMWRMSR} */
748	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32PerfStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
749	{
750	/* Pentium4 allows writing, but all bits are ignored. */
751	return VINF_SUCCESS;
752	}
753
754
755	/** @callback_method_impl{FNCPUMRDMSR} */
756	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32PerfCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
757	{
758	/** @todo implement IA32_PERFCTL. */
759	*puValue = 0;
760	return VINF_SUCCESS;
761	}
762
763
764	/** @callback_method_impl{FNCPUMWRMSR} */
765	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32PerfCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
766	{
767	/** @todo implement IA32_PERFCTL. */
768	return VINF_SUCCESS;
769	}
770
771
772	/** @callback_method_impl{FNCPUMRDMSR} */
773	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32FixedCtrN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
774	{
775	/** @todo implement IA32_FIXED_CTRn (fixed performance counters). */
776	*puValue = 0;
777	return VINF_SUCCESS;
778	}
779
780
781	/** @callback_method_impl{FNCPUMWRMSR} */
782	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32FixedCtrN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
783	{
784	/** @todo implement IA32_FIXED_CTRn (fixed performance counters). */
785	return VINF_SUCCESS;
786	}
787
788
789	/** @callback_method_impl{FNCPUMRDMSR} */
790	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32PerfCapabilities(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
791	{
792	/** @todo implement performance counters. */
793	*puValue = 0;
794	return VINF_SUCCESS;
795	}
796
797
798	/** @callback_method_impl{FNCPUMWRMSR} */
799	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32PerfCapabilities(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
800	{
801	/** @todo implement performance counters. */
802	return VINF_SUCCESS;
803	}
804
805
806	/** @callback_method_impl{FNCPUMRDMSR} */
807	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32FixedCtrCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
808	{
809	/** @todo implement performance counters. */
810	*puValue = 0;
811	return VINF_SUCCESS;
812	}
813
814
815	/** @callback_method_impl{FNCPUMWRMSR} */
816	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32FixedCtrCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
817	{
818	/** @todo implement performance counters. */
819	return VINF_SUCCESS;
820	}
821
822
823	/** @callback_method_impl{FNCPUMRDMSR} */
824	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32PerfGlobalStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
825	{
826	/** @todo implement performance counters. */
827	*puValue = 0;
828	return VINF_SUCCESS;
829	}
830
831
832	/** @callback_method_impl{FNCPUMWRMSR} */
833	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32PerfGlobalStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
834	{
835	/** @todo implement performance counters. */
836	return VINF_SUCCESS;
837	}
838
839
840	/** @callback_method_impl{FNCPUMRDMSR} */
841	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32PerfGlobalCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
842	{
843	/** @todo implement performance counters. */
844	*puValue = 0;
845	return VINF_SUCCESS;
846	}
847
848
849	/** @callback_method_impl{FNCPUMWRMSR} */
850	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32PerfGlobalCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
851	{
852	/** @todo implement performance counters. */
853	return VINF_SUCCESS;
854	}
855
856
857	/** @callback_method_impl{FNCPUMRDMSR} */
858	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32PerfGlobalOvfCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
859	{
860	/** @todo implement performance counters. */
861	*puValue = 0;
862	return VINF_SUCCESS;
863	}
864
865
866	/** @callback_method_impl{FNCPUMWRMSR} */
867	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32PerfGlobalOvfCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
868	{
869	/** @todo implement performance counters. */
870	return VINF_SUCCESS;
871	}
872
873
874	/** @callback_method_impl{FNCPUMRDMSR} */
875	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32PebsEnable(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
876	{
877	/** @todo implement performance counters. */
878	*puValue = 0;
879	return VINF_SUCCESS;
880	}
881
882
883	/** @callback_method_impl{FNCPUMWRMSR} */
884	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32PebsEnable(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
885	{
886	/** @todo implement performance counters. */
887	return VINF_SUCCESS;
888	}
889
890
891	/** @callback_method_impl{FNCPUMRDMSR} */
892	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32ClockModulation(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
893	{
894	/** @todo implement IA32_CLOCK_MODULATION. */
895	*puValue = 0;
896	return VINF_SUCCESS;
897	}
898
899
900	/** @callback_method_impl{FNCPUMWRMSR} */
901	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32ClockModulation(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
902	{
903	/** @todo implement IA32_CLOCK_MODULATION. */
904	return VINF_SUCCESS;
905	}
906
907
908	/** @callback_method_impl{FNCPUMRDMSR} */
909	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32ThermInterrupt(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
910	{
911	/** @todo implement IA32_THERM_INTERRUPT. */
912	*puValue = 0;
913	return VINF_SUCCESS;
914	}
915
916
917	/** @callback_method_impl{FNCPUMWRMSR} */
918	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32ThermInterrupt(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
919	{
920	/** @todo implement IA32_THERM_STATUS. */
921	return VINF_SUCCESS;
922	}
923
924
925	/** @callback_method_impl{FNCPUMRDMSR} */
926	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32ThermStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
927	{
928	/** @todo implement IA32_THERM_STATUS. */
929	*puValue = 0;
930	return VINF_SUCCESS;
931	}
932
933
934	/** @callback_method_impl{FNCPUMWRMSR} */
935	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32ThermStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
936	{
937	/** @todo implement IA32_THERM_INTERRUPT. */
938	return VINF_SUCCESS;
939	}
940
941
942	/** @callback_method_impl{FNCPUMRDMSR} */
943	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32Therm2Ctl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
944	{
945	/** @todo implement IA32_THERM2_CTL. */
946	*puValue = 0;
947	return VINF_SUCCESS;
948	}
949
950
951	/** @callback_method_impl{FNCPUMWRMSR} */
952	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32Therm2Ctl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
953	{
954	/** @todo implement IA32_THERM2_CTL. */
955	return VINF_SUCCESS;
956	}
957
958
959	/** @callback_method_impl{FNCPUMRDMSR} */
960	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32MiscEnable(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
961	{
962	*puValue = pVCpu->cpum.s.GuestMsrs.msr.MiscEnable;
963	return VINF_SUCCESS;
964	}
965
966
967	/** @callback_method_impl{FNCPUMWRMSR} */
968	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32MiscEnable(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
969	{
970	#ifdef LOG_ENABLED
971	uint64_t const uOld = pVCpu->cpum.s.GuestMsrs.msr.MiscEnable;
972	#endif
973
974	/* Unsupported bits are generally ignored and stripped by the MSR range
975	entry that got us here. So, we just need to preserve fixed bits. */
976	pVCpu->cpum.s.GuestMsrs.msr.MiscEnable = uValue
977	\| MSR_IA32_MISC_ENABLE_PEBS_UNAVAIL
978	\| MSR_IA32_MISC_ENABLE_BTS_UNAVAIL;
979
980	Log(("CPUM: IA32_MISC_ENABLE; old=%#llx written=%#llx => %#llx\n",
981	uOld, uValue, pVCpu->cpum.s.GuestMsrs.msr.MiscEnable));
982
983	/** @todo Wire IA32_MISC_ENABLE bit 22 to our NT 4 CPUID trick. */
984	/** @todo Wire up MSR_IA32_MISC_ENABLE_XD_DISABLE. */
985	return VINF_SUCCESS;
986	}
987
988
989	/** @callback_method_impl{FNCPUMRDMSR} */
990	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32McCtlStatusAddrMiscN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
991	{
992	/** @todo Implement machine check exception injection. */
993	switch (idMsr & 3)
994	{
995	case 0:
996	case 1:
997	*puValue = 0;
998	break;
999
1000	/* The ADDR and MISC registers aren't accessible since the
1001	corresponding STATUS bits are zero. */
1002	case 2:
1003	Log(("CPUM: Reading IA32_MCi_ADDR %#x -> #GP\n", idMsr));
1004	return VERR_CPUM_RAISE_GP_0;
1005	case 3:
1006	Log(("CPUM: Reading IA32_MCi_MISC %#x -> #GP\n", idMsr));
1007	return VERR_CPUM_RAISE_GP_0;
1008	}
1009	return VINF_SUCCESS;
1010	}
1011
1012
1013	/** @callback_method_impl{FNCPUMWRMSR} */
1014	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32McCtlStatusAddrMiscN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1015	{
1016	switch (idMsr & 3)
1017	{
1018	case 0:
1019	/* Ignore writes to the CTL register. */
1020	break;
1021
1022	case 1:
1023	/* According to specs, the STATUS register can only be written to
1024	with the value 0. VBoxCpuReport thinks different for a
1025	Pentium M Dothan, but implementing according to specs now. */
1026	if (uValue != 0)
1027	{
1028	Log(("CPUM: Writing non-zero value (%#llx) to IA32_MCi_STATUS %#x -> #GP\n", uValue, idMsr));
1029	return VERR_CPUM_RAISE_GP_0;
1030	}
1031	break;
1032
1033	/* Specs states that ADDR and MISC can be cleared by writing zeros.
1034	Writing 1s will GP. Need to figure out how this relates to the
1035	ADDRV and MISCV status flags. If writing is independent of those
1036	bits, we need to know whether the CPU really implements them since
1037	that is exposed by writing 0 to them.
1038	Implementing the solution with the fewer GPs for now. */
1039	case 2:
1040	if (uValue != 0)
1041	{
1042	Log(("CPUM: Writing non-zero value (%#llx) to IA32_MCi_ADDR %#x -> #GP\n", uValue, idMsr));
1043	return VERR_CPUM_RAISE_GP_0;
1044	}
1045	break;
1046	case 3:
1047	if (uValue != 0)
1048	{
1049	Log(("CPUM: Writing non-zero value (%#llx) to IA32_MCi_MISC %#x -> #GP\n", uValue, idMsr));
1050	return VERR_CPUM_RAISE_GP_0;
1051	}
1052	break;
1053	}
1054	return VINF_SUCCESS;
1055	}
1056
1057
1058	/** @callback_method_impl{FNCPUMRDMSR} */
1059	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32McNCtl2(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1060	{
1061	/** @todo Implement machine check exception injection. */
1062	*puValue = 0;
1063	return VINF_SUCCESS;
1064	}
1065
1066
1067	/** @callback_method_impl{FNCPUMWRMSR} */
1068	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32McNCtl2(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1069	{
1070	/** @todo Implement machine check exception injection. */
1071	return VINF_SUCCESS;
1072	}
1073
1074
1075	/** @callback_method_impl{FNCPUMRDMSR} */
1076	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32DsArea(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1077	{
1078	/** @todo implement IA32_DS_AREA. */
1079	*puValue = 0;
1080	return VINF_SUCCESS;
1081	}
1082
1083
1084	/** @callback_method_impl{FNCPUMWRMSR} */
1085	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32DsArea(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1086	{
1087	return VINF_SUCCESS;
1088	}
1089
1090
1091	/** @callback_method_impl{FNCPUMRDMSR} */
1092	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32TscDeadline(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1093	{
1094	/** @todo implement TSC deadline timer. */
1095	*puValue = 0;
1096	return VINF_SUCCESS;
1097	}
1098
1099
1100	/** @callback_method_impl{FNCPUMWRMSR} */
1101	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32TscDeadline(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1102	{
1103	/** @todo implement TSC deadline timer. */
1104	return VINF_SUCCESS;
1105	}
1106
1107
1108	/** @callback_method_impl{FNCPUMRDMSR} */
1109	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32X2ApicN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1110	{
1111	return PDMApicReadMsr(pVCpu, idMsr, puValue);
1112	}
1113
1114
1115	/** @callback_method_impl{FNCPUMWRMSR} */
1116	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32X2ApicN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1117	{
1118	return PDMApicWriteMsr(pVCpu, idMsr, uValue);
1119	}
1120
1121
1122	/** @callback_method_impl{FNCPUMRDMSR} */
1123	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32DebugInterface(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1124	{
1125	/** @todo IA32_DEBUG_INTERFACE (no docs) */
1126	*puValue = 0;
1127	return VINF_SUCCESS;
1128	}
1129
1130
1131	/** @callback_method_impl{FNCPUMWRMSR} */
1132	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Ia32DebugInterface(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1133	{
1134	/** @todo IA32_DEBUG_INTERFACE (no docs) */
1135	return VINF_SUCCESS;
1136	}
1137
1138
1139	/** @callback_method_impl{FNCPUMRDMSR} */
1140	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1141	{
1142	*puValue = 0;
1143	return VINF_SUCCESS;
1144	}
1145
1146
1147	/** @callback_method_impl{FNCPUMRDMSR} */
1148	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxPinbasedCtls(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1149	{
1150	*puValue = 0;
1151	return VINF_SUCCESS;
1152	}
1153
1154
1155	/** @callback_method_impl{FNCPUMRDMSR} */
1156	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxProcbasedCtls(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1157	{
1158	*puValue = 0;
1159	return VINF_SUCCESS;
1160	}
1161
1162
1163	/** @callback_method_impl{FNCPUMRDMSR} */
1164	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxExitCtls(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1165	{
1166	*puValue = 0;
1167	return VINF_SUCCESS;
1168	}
1169
1170
1171	/** @callback_method_impl{FNCPUMRDMSR} */
1172	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxEntryCtls(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1173	{
1174	*puValue = 0;
1175	return VINF_SUCCESS;
1176	}
1177
1178
1179	/** @callback_method_impl{FNCPUMRDMSR} */
1180	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxMisc(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1181	{
1182	*puValue = 0;
1183	return VINF_SUCCESS;
1184	}
1185
1186
1187	/** @callback_method_impl{FNCPUMRDMSR} */
1188	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxCr0Fixed0(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1189	{
1190	*puValue = 0;
1191	return VINF_SUCCESS;
1192	}
1193
1194
1195	/** @callback_method_impl{FNCPUMRDMSR} */
1196	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxCr0Fixed1(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1197	{
1198	*puValue = 0;
1199	return VINF_SUCCESS;
1200	}
1201
1202
1203	/** @callback_method_impl{FNCPUMRDMSR} */
1204	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxCr4Fixed0(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1205	{
1206	*puValue = 0;
1207	return VINF_SUCCESS;
1208	}
1209
1210
1211	/** @callback_method_impl{FNCPUMRDMSR} */
1212	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxCr4Fixed1(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1213	{
1214	*puValue = 0;
1215	return VINF_SUCCESS;
1216	}
1217
1218
1219	/** @callback_method_impl{FNCPUMRDMSR} */
1220	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxVmcsEnum(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1221	{
1222	*puValue = 0;
1223	return VINF_SUCCESS;
1224	}
1225
1226
1227	/** @callback_method_impl{FNCPUMRDMSR} */
1228	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxProcBasedCtls2(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1229	{
1230	*puValue = 0;
1231	return VINF_SUCCESS;
1232	}
1233
1234
1235	/** @callback_method_impl{FNCPUMRDMSR} */
1236	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxEptVpidCap(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1237	{
1238	*puValue = 0;
1239	return VINF_SUCCESS;
1240	}
1241
1242
1243	/** @callback_method_impl{FNCPUMRDMSR} */
1244	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxTruePinbasedCtls(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1245	{
1246	*puValue = 0;
1247	return VINF_SUCCESS;
1248	}
1249
1250
1251	/** @callback_method_impl{FNCPUMRDMSR} */
1252	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxTrueProcbasedCtls(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1253	{
1254	*puValue = 0;
1255	return VINF_SUCCESS;
1256	}
1257
1258
1259	/** @callback_method_impl{FNCPUMRDMSR} */
1260	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxTrueExitCtls(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1261	{
1262	*puValue = 0;
1263	return VINF_SUCCESS;
1264	}
1265
1266
1267	/** @callback_method_impl{FNCPUMRDMSR} */
1268	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxTrueEntryCtls(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1269	{
1270	*puValue = 0;
1271	return VINF_SUCCESS;
1272	}
1273
1274
1275	/** @callback_method_impl{FNCPUMRDMSR} */
1276	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxVmFunc(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1277	{
1278	*puValue = 0;
1279	return VINF_SUCCESS;
1280	}
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291	/*
1292	* AMD64
1293	* AMD64
1294	* AMD64
1295	*/
1296
1297
1298	/** @callback_method_impl{FNCPUMRDMSR} */
1299	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Amd64Efer(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1300	{
1301	*puValue = pVCpu->cpum.s.Guest.msrEFER;
1302	return VINF_SUCCESS;
1303	}
1304
1305
1306	/** @callback_method_impl{FNCPUMWRMSR} */
1307	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Amd64Efer(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1308	{
1309	PVM pVM = pVCpu->CTX_SUFF(pVM);
1310	uint64_t const uOldEfer = pVCpu->cpum.s.Guest.msrEFER;
1311	uint32_t const fExtFeatures = pVM->cpum.s.aGuestCpuIdPatmExt[0].uEax >= 0x80000001
1312	? pVM->cpum.s.aGuestCpuIdPatmExt[1].uEdx
1313	: 0;
1314	uint64_t fMask = 0;
1315	uint64_t fIgnoreMask = MSR_K6_EFER_LMA;
1316
1317	/* Filter out those bits the guest is allowed to change. (e.g. LMA is read-only) */
1318	if (fExtFeatures & X86_CPUID_EXT_FEATURE_EDX_NX)
1319	fMask \|= MSR_K6_EFER_NXE;
1320	if (fExtFeatures & X86_CPUID_EXT_FEATURE_EDX_LONG_MODE)
1321	fMask \|= MSR_K6_EFER_LME;
1322	if (fExtFeatures & X86_CPUID_EXT_FEATURE_EDX_SYSCALL)
1323	fMask \|= MSR_K6_EFER_SCE;
1324	if (fExtFeatures & X86_CPUID_AMD_FEATURE_EDX_FFXSR)
1325	fMask \|= MSR_K6_EFER_FFXSR;
1326
1327	/* #GP(0) If anything outside the allowed bits is set. */
1328	if (uValue & ~(fIgnoreMask \| fMask))
1329	{
1330	Log(("CPUM: Settings disallowed EFER bit. uValue=%#RX64 fAllowed=%#RX64 -> #GP(0)\n", uValue, fMask));
1331	return VERR_CPUM_RAISE_GP_0;
1332	}
1333
1334	/* Check for illegal MSR_K6_EFER_LME transitions: not allowed to change LME if
1335	paging is enabled. (AMD Arch. Programmer's Manual Volume 2: Table 14-5) */
1336	if ( (uOldEfer & MSR_K6_EFER_LME) != (uValue & fMask & MSR_K6_EFER_LME)
1337	&& (pVCpu->cpum.s.Guest.cr0 & X86_CR0_PG))
1338	{
1339	Log(("CPUM: Illegal MSR_K6_EFER_LME change: paging is enabled!!\n"));
1340	return VERR_CPUM_RAISE_GP_0;
1341	}
1342
1343	/* There are a few more: e.g. MSR_K6_EFER_LMSLE */
1344	AssertMsg(!(uValue & ~(MSR_K6_EFER_NXE \| MSR_K6_EFER_LME \| MSR_K6_EFER_LMA /* ignored anyway */ \| MSR_K6_EFER_SCE \| MSR_K6_EFER_FFXSR)),
1345	("Unexpected value %RX64\n", uValue));
1346	pVCpu->cpum.s.Guest.msrEFER = (uOldEfer & ~fMask) \| (uValue & fMask);
1347
1348	/* AMD64 Architecture Programmer's Manual: 15.15 TLB Control; flush the TLB
1349	if MSR_K6_EFER_NXE, MSR_K6_EFER_LME or MSR_K6_EFER_LMA are changed. */
1350	if ( (uOldEfer & (MSR_K6_EFER_NXE \| MSR_K6_EFER_LME \| MSR_K6_EFER_LMA))
1351	!= (pVCpu->cpum.s.Guest.msrEFER & (MSR_K6_EFER_NXE \| MSR_K6_EFER_LME \| MSR_K6_EFER_LMA)))
1352	{
1353	/// @todo PGMFlushTLB(pVCpu, cr3, true /fGlobal/);
1354	HMFlushTLB(pVCpu);
1355
1356	/* Notify PGM about NXE changes. */
1357	if ( (uOldEfer & MSR_K6_EFER_NXE)
1358	!= (pVCpu->cpum.s.Guest.msrEFER & MSR_K6_EFER_NXE))
1359	PGMNotifyNxeChanged(pVCpu, !(uOldEfer & MSR_K6_EFER_NXE));
1360	}
1361	return VINF_SUCCESS;
1362	}
1363
1364
1365	/** @callback_method_impl{FNCPUMRDMSR} */
1366	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Amd64SyscallTarget(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1367	{
1368	*puValue = pVCpu->cpum.s.Guest.msrSTAR;
1369	return VINF_SUCCESS;
1370	}
1371
1372
1373	/** @callback_method_impl{FNCPUMWRMSR} */
1374	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Amd64SyscallTarget(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1375	{
1376	pVCpu->cpum.s.Guest.msrSTAR = uValue;
1377	return VINF_SUCCESS;
1378	}
1379
1380
1381	/** @callback_method_impl{FNCPUMRDMSR} */
1382	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Amd64LongSyscallTarget(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1383	{
1384	*puValue = pVCpu->cpum.s.Guest.msrLSTAR;
1385	return VINF_SUCCESS;
1386	}
1387
1388
1389	/** @callback_method_impl{FNCPUMWRMSR} */
1390	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Amd64LongSyscallTarget(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1391	{
1392	if (!X86_IS_CANONICAL(uValue))
1393	{
1394	Log(("CPUM: wrmsr %s(%#x), %#llx -> #GP - not canonical\n", pRange->szName, idMsr, uValue));
1395	return VERR_CPUM_RAISE_GP_0;
1396	}
1397	pVCpu->cpum.s.Guest.msrLSTAR = uValue;
1398	return VINF_SUCCESS;
1399	}
1400
1401
1402	/** @callback_method_impl{FNCPUMRDMSR} */
1403	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Amd64CompSyscallTarget(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1404	{
1405	*puValue = pVCpu->cpum.s.Guest.msrCSTAR;
1406	return VINF_SUCCESS;
1407	}
1408
1409
1410	/** @callback_method_impl{FNCPUMWRMSR} */
1411	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Amd64CompSyscallTarget(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1412	{
1413	if (!X86_IS_CANONICAL(uValue))
1414	{
1415	Log(("CPUM: wrmsr %s(%#x), %#llx -> #GP - not canonical\n", pRange->szName, idMsr, uValue));
1416	return VERR_CPUM_RAISE_GP_0;
1417	}
1418	pVCpu->cpum.s.Guest.msrCSTAR = uValue;
1419	return VINF_SUCCESS;
1420	}
1421
1422
1423	/** @callback_method_impl{FNCPUMRDMSR} */
1424	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Amd64SyscallFlagMask(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1425	{
1426	*puValue = pVCpu->cpum.s.Guest.msrSFMASK;
1427	return VINF_SUCCESS;
1428	}
1429
1430
1431	/** @callback_method_impl{FNCPUMWRMSR} */
1432	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Amd64SyscallFlagMask(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1433	{
1434	pVCpu->cpum.s.Guest.msrSFMASK = uValue;
1435	return VINF_SUCCESS;
1436	}
1437
1438
1439	/** @callback_method_impl{FNCPUMRDMSR} */
1440	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Amd64FsBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1441	{
1442	*puValue = pVCpu->cpum.s.Guest.fs.u64Base;
1443	return VINF_SUCCESS;
1444	}
1445
1446
1447	/** @callback_method_impl{FNCPUMWRMSR} */
1448	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Amd64FsBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1449	{
1450	pVCpu->cpum.s.Guest.fs.u64Base = uValue;
1451	return VINF_SUCCESS;
1452	}
1453
1454
1455	/** @callback_method_impl{FNCPUMRDMSR} */
1456	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Amd64GsBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1457	{
1458	*puValue = pVCpu->cpum.s.Guest.gs.u64Base;
1459	return VINF_SUCCESS;
1460	}
1461
1462	/** @callback_method_impl{FNCPUMWRMSR} */
1463	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Amd64GsBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1464	{
1465	pVCpu->cpum.s.Guest.gs.u64Base = uValue;
1466	return VINF_SUCCESS;
1467	}
1468
1469
1470
1471	/** @callback_method_impl{FNCPUMRDMSR} */
1472	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Amd64KernelGsBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1473	{
1474	*puValue = pVCpu->cpum.s.Guest.msrKERNELGSBASE;
1475	return VINF_SUCCESS;
1476	}
1477
1478	/** @callback_method_impl{FNCPUMWRMSR} */
1479	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Amd64KernelGsBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1480	{
1481	pVCpu->cpum.s.Guest.msrKERNELGSBASE = uValue;
1482	return VINF_SUCCESS;
1483	}
1484
1485
1486	/** @callback_method_impl{FNCPUMRDMSR} */
1487	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Amd64TscAux(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1488	{
1489	*puValue = pVCpu->cpum.s.GuestMsrs.msr.TscAux;
1490	return VINF_SUCCESS;
1491	}
1492
1493	/** @callback_method_impl{FNCPUMWRMSR} */
1494	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Amd64TscAux(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1495	{
1496	pVCpu->cpum.s.GuestMsrs.msr.TscAux = uValue;
1497	return VINF_SUCCESS;
1498	}
1499
1500
1501	/*
1502	* Intel specific
1503	* Intel specific
1504	* Intel specific
1505	*/
1506
1507	/** @callback_method_impl{FNCPUMRDMSR} */
1508	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelEblCrPowerOn(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1509	{
1510	/** @todo recalc clock frequency ratio? */
1511	*puValue = pRange->uValue;
1512	return VINF_SUCCESS;
1513	}
1514
1515
1516	/** @callback_method_impl{FNCPUMWRMSR} */
1517	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelEblCrPowerOn(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1518	{
1519	/** @todo Write EBL_CR_POWERON: Remember written bits. */
1520	return VINF_SUCCESS;
1521	}
1522
1523
1524	/** @callback_method_impl{FNCPUMRDMSR} */
1525	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7CoreThreadCount(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1526	{
1527	/* Note! According to cpuid_set_info in XNU (10.7.0), Westmere CPU only
1528	have a 4-bit core count. */
1529	uint16_t cCores = pVCpu->CTX_SUFF(pVM)->cCpus;
1530	uint16_t cThreads = cCores; /** @todo hyper-threading. */
1531	*puValue = RT_MAKE_U32(cThreads, cCores);
1532	return VINF_SUCCESS;
1533	}
1534
1535
1536	/** @callback_method_impl{FNCPUMRDMSR} */
1537	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelP4EbcHardPowerOn(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1538	{
1539	/** @todo P4 hard power on config */
1540	*puValue = pRange->uValue;
1541	return VINF_SUCCESS;
1542	}
1543
1544
1545	/** @callback_method_impl{FNCPUMWRMSR} */
1546	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelP4EbcHardPowerOn(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1547	{
1548	/** @todo P4 hard power on config */
1549	return VINF_SUCCESS;
1550	}
1551
1552
1553	/** @callback_method_impl{FNCPUMRDMSR} */
1554	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelP4EbcSoftPowerOn(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1555	{
1556	/** @todo P4 soft power on config */
1557	*puValue = pRange->uValue;
1558	return VINF_SUCCESS;
1559	}
1560
1561
1562	/** @callback_method_impl{FNCPUMWRMSR} */
1563	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelP4EbcSoftPowerOn(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1564	{
1565	/** @todo P4 soft power on config */
1566	return VINF_SUCCESS;
1567	}
1568
1569
1570	/** @callback_method_impl{FNCPUMRDMSR} */
1571	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelP4EbcFrequencyId(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1572	{
1573	uint64_t uValue;
1574	PVM pVM = pVCpu->CTX_SUFF(pVM);
1575	uint64_t uScalableBusHz = CPUMGetGuestScalableBusFrequency(pVM);
1576	if (pVM->cpum.s.GuestFeatures.uModel >= 2)
1577	{
1578	if (uScalableBusHz <= CPUM_SBUSFREQ_100MHZ && pVM->cpum.s.GuestFeatures.uModel <= 2)
1579	{
1580	uScalableBusHz = CPUM_SBUSFREQ_100MHZ;
1581	uValue = 0;
1582	}
1583	else if (uScalableBusHz <= CPUM_SBUSFREQ_133MHZ)
1584	{
1585	uScalableBusHz = CPUM_SBUSFREQ_133MHZ;
1586	uValue = 1;
1587	}
1588	else if (uScalableBusHz <= CPUM_SBUSFREQ_167MHZ)
1589	{
1590	uScalableBusHz = CPUM_SBUSFREQ_167MHZ;
1591	uValue = 3;
1592	}
1593	else if (uScalableBusHz <= CPUM_SBUSFREQ_200MHZ)
1594	{
1595	uScalableBusHz = CPUM_SBUSFREQ_200MHZ;
1596	uValue = 2;
1597	}
1598	else if (uScalableBusHz <= CPUM_SBUSFREQ_267MHZ && pVM->cpum.s.GuestFeatures.uModel > 2)
1599	{
1600	uScalableBusHz = CPUM_SBUSFREQ_267MHZ;
1601	uValue = 0;
1602	}
1603	else
1604	{
1605	uScalableBusHz = CPUM_SBUSFREQ_333MHZ;
1606	uValue = 6;
1607	}
1608	uValue <<= 16;
1609
1610	uint64_t uTscHz = TMCpuTicksPerSecond(pVM);
1611	uint8_t uTscRatio = (uint8_t)((uTscHz + uScalableBusHz / 2) / uScalableBusHz);
1612	uValue \|= (uint32_t)uTscRatio << 24;
1613
1614	uValue \|= pRange->uValue & ~UINT64_C(0xff0f0000);
1615	}
1616	else
1617	{
1618	/* Probably more stuff here, but intel doesn't want to tell us. */
1619	uValue = pRange->uValue;
1620	uValue &= ~(RT_BIT_64(21) \| RT_BIT_64(22) \| RT_BIT_64(23)); /* 100 MHz is only documented value */
1621	}
1622
1623	*puValue = uValue;
1624	return VINF_SUCCESS;
1625	}
1626
1627
1628	/** @callback_method_impl{FNCPUMWRMSR} */
1629	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelP4EbcFrequencyId(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1630	{
1631	/** @todo P4 bus frequency config */
1632	return VINF_SUCCESS;
1633	}
1634
1635
1636	/** @callback_method_impl{FNCPUMRDMSR} */
1637	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelP6FsbFrequency(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1638	{
1639	/* Convert the scalable bus frequency to the encoding in the intel manual (for core+). */
1640	uint64_t uScalableBusHz = CPUMGetGuestScalableBusFrequency(pVCpu->CTX_SUFF(pVM));
1641	if (uScalableBusHz <= CPUM_SBUSFREQ_100MHZ)
1642	*puValue = 5;
1643	else if (uScalableBusHz <= CPUM_SBUSFREQ_133MHZ)
1644	*puValue = 1;
1645	else if (uScalableBusHz <= CPUM_SBUSFREQ_167MHZ)
1646	*puValue = 3;
1647	else if (uScalableBusHz <= CPUM_SBUSFREQ_200MHZ)
1648	*puValue = 2;
1649	else if (uScalableBusHz <= CPUM_SBUSFREQ_267MHZ)
1650	*puValue = 0;
1651	else if (uScalableBusHz <= CPUM_SBUSFREQ_333MHZ)
1652	*puValue = 4;
1653	else /if (uScalableBusHz <= CPUM_SBUSFREQ_400MHZ)/
1654	*puValue = 6;
1655
1656	*puValue \|= pRange->uValue & ~UINT64_C(0x7);
1657
1658	return VINF_SUCCESS;
1659	}
1660
1661
1662	/** @callback_method_impl{FNCPUMRDMSR} */
1663	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelPlatformInfo(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1664	{
1665	/* Just indicate a fixed TSC, no turbo boost, no programmable anything. */
1666	PVM pVM = pVCpu->CTX_SUFF(pVM);
1667	uint64_t uScalableBusHz = CPUMGetGuestScalableBusFrequency(pVM);
1668	uint64_t uTscHz = TMCpuTicksPerSecond(pVM);
1669	uint8_t uTscRatio = (uint8_t)((uTscHz + uScalableBusHz / 2) / uScalableBusHz);
1670	uint64_t uValue = ((uint32_t)uTscRatio << 8) /* TSC invariant frequency. */
1671	\| ((uint64_t)uTscRatio << 40); /* The max turbo frequency. */
1672
1673	/* Ivy bridge has a minimum operating ratio as well. */
1674	if (true) /** @todo detect sandy bridge. */
1675	uValue \|= (uint64_t)uTscRatio << 48;
1676
1677	*puValue = uValue;
1678	return VINF_SUCCESS;
1679	}
1680
1681
1682	/** @callback_method_impl{FNCPUMRDMSR} */
1683	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelFlexRatio(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1684	{
1685	uint64_t uValue = pRange->uValue & ~UINT64_C(0x1ff00);
1686
1687	PVM pVM = pVCpu->CTX_SUFF(pVM);
1688	uint64_t uScalableBusHz = CPUMGetGuestScalableBusFrequency(pVM);
1689	uint64_t uTscHz = TMCpuTicksPerSecond(pVM);
1690	uint8_t uTscRatio = (uint8_t)((uTscHz + uScalableBusHz / 2) / uScalableBusHz);
1691	uValue \|= (uint32_t)uTscRatio << 8;
1692
1693	*puValue = uValue;
1694	return VINF_SUCCESS;
1695	}
1696
1697
1698	/** @callback_method_impl{FNCPUMWRMSR} */
1699	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelFlexRatio(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1700	{
1701	/** @todo implement writing MSR_FLEX_RATIO. */
1702	return VINF_SUCCESS;
1703	}
1704
1705
1706	/** @callback_method_impl{FNCPUMRDMSR} */
1707	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelPkgCStConfigControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1708	{
1709	*puValue = pVCpu->cpum.s.GuestMsrs.msr.PkgCStateCfgCtrl;
1710	return VINF_SUCCESS;
1711	}
1712
1713
1714	/** @callback_method_impl{FNCPUMWRMSR} */
1715	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelPkgCStConfigControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1716	{
1717	if (pVCpu->cpum.s.GuestMsrs.msr.PkgCStateCfgCtrl & RT_BIT_64(15))
1718	{
1719	Log(("CPUM: WRMDR %#x (%s), %#llx: Write protected -> #GP\n", idMsr, pRange->szName, uValue));
1720	return VERR_CPUM_RAISE_GP_0;
1721	}
1722	#if 0 /** @todo check what real (old) hardware does. */
1723	if ((uValue & 7) >= 5)
1724	{
1725	Log(("CPUM: WRMDR %#x (%s), %#llx: Invalid limit (%d) -> #GP\n", idMsr, pRange->szName, uValue, (uint32_t)(uValue & 7)));
1726	return VERR_CPUM_RAISE_GP_0;
1727	}
1728	#endif
1729	pVCpu->cpum.s.GuestMsrs.msr.PkgCStateCfgCtrl = uValue;
1730	return VINF_SUCCESS;
1731	}
1732
1733
1734	/** @callback_method_impl{FNCPUMRDMSR} */
1735	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelPmgIoCaptureBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1736	{
1737	/** @todo implement I/O mwait wakeup. */
1738	*puValue = 0;
1739	return VINF_SUCCESS;
1740	}
1741
1742
1743	/** @callback_method_impl{FNCPUMWRMSR} */
1744	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelPmgIoCaptureBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1745	{
1746	/** @todo implement I/O mwait wakeup. */
1747	return VINF_SUCCESS;
1748	}
1749
1750
1751	/** @callback_method_impl{FNCPUMRDMSR} */
1752	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelLastBranchFromToN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1753	{
1754	/** @todo implement last branch records. */
1755	*puValue = 0;
1756	return VINF_SUCCESS;
1757	}
1758
1759
1760	/** @callback_method_impl{FNCPUMWRMSR} */
1761	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelLastBranchFromToN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1762	{
1763	/** @todo implement last branch records. */
1764	return VINF_SUCCESS;
1765	}
1766
1767
1768	/** @callback_method_impl{FNCPUMRDMSR} */
1769	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelLastBranchFromN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1770	{
1771	/** @todo implement last branch records. */
1772	*puValue = 0;
1773	return VINF_SUCCESS;
1774	}
1775
1776
1777	/** @callback_method_impl{FNCPUMWRMSR} */
1778	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelLastBranchFromN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1779	{
1780	/** @todo implement last branch records. */
1781	/** @todo Probing indicates that bit 63 is settable on SandyBridge, at least
1782	* if the rest of the bits are zero. Automatic sign extending?
1783	* Investigate! */
1784	if (!X86_IS_CANONICAL(uValue))
1785	{
1786	Log(("CPUM: wrmsr %s(%#x), %#llx -> #GP - not canonical\n", pRange->szName, idMsr, uValue));
1787	return VERR_CPUM_RAISE_GP_0;
1788	}
1789	return VINF_SUCCESS;
1790	}
1791
1792
1793	/** @callback_method_impl{FNCPUMRDMSR} */
1794	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelLastBranchToN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1795	{
1796	/** @todo implement last branch records. */
1797	*puValue = 0;
1798	return VINF_SUCCESS;
1799	}
1800
1801
1802	/** @callback_method_impl{FNCPUMWRMSR} */
1803	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelLastBranchToN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1804	{
1805	/** @todo implement last branch records. */
1806	/** @todo Probing indicates that bit 63 is settable on SandyBridge, at least
1807	* if the rest of the bits are zero. Automatic sign extending?
1808	* Investigate! */
1809	if (!X86_IS_CANONICAL(uValue))
1810	{
1811	Log(("CPUM: wrmsr %s(%#x), %#llx -> #GP - not canonical\n", pRange->szName, idMsr, uValue));
1812	return VERR_CPUM_RAISE_GP_0;
1813	}
1814	return VINF_SUCCESS;
1815	}
1816
1817
1818	/** @callback_method_impl{FNCPUMRDMSR} */
1819	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelLastBranchTos(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1820	{
1821	/** @todo implement last branch records. */
1822	*puValue = 0;
1823	return VINF_SUCCESS;
1824	}
1825
1826
1827	/** @callback_method_impl{FNCPUMWRMSR} */
1828	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelLastBranchTos(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1829	{
1830	/** @todo implement last branch records. */
1831	return VINF_SUCCESS;
1832	}
1833
1834
1835	/** @callback_method_impl{FNCPUMRDMSR} */
1836	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelBblCrCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1837	{
1838	*puValue = pRange->uValue;
1839	return VINF_SUCCESS;
1840	}
1841
1842
1843	/** @callback_method_impl{FNCPUMWRMSR} */
1844	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelBblCrCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1845	{
1846	return VINF_SUCCESS;
1847	}
1848
1849
1850	/** @callback_method_impl{FNCPUMRDMSR} */
1851	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelBblCrCtl3(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1852	{
1853	*puValue = pRange->uValue;
1854	return VINF_SUCCESS;
1855	}
1856
1857
1858	/** @callback_method_impl{FNCPUMWRMSR} */
1859	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelBblCrCtl3(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1860	{
1861	return VINF_SUCCESS;
1862	}
1863
1864
1865	/** @callback_method_impl{FNCPUMRDMSR} */
1866	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7TemperatureTarget(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1867	{
1868	*puValue = pRange->uValue;
1869	return VINF_SUCCESS;
1870	}
1871
1872
1873	/** @callback_method_impl{FNCPUMWRMSR} */
1874	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7TemperatureTarget(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1875	{
1876	return VINF_SUCCESS;
1877	}
1878
1879
1880	/** @callback_method_impl{FNCPUMRDMSR} */
1881	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7MsrOffCoreResponseN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1882	{
1883	/** @todo machine check. */
1884	*puValue = pRange->uValue;
1885	return VINF_SUCCESS;
1886	}
1887
1888
1889	/** @callback_method_impl{FNCPUMWRMSR} */
1890	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7MsrOffCoreResponseN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1891	{
1892	/** @todo machine check. */
1893	return VINF_SUCCESS;
1894	}
1895
1896
1897	/** @callback_method_impl{FNCPUMRDMSR} */
1898	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7MiscPwrMgmt(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1899	{
1900	*puValue = 0;
1901	return VINF_SUCCESS;
1902	}
1903
1904
1905	/** @callback_method_impl{FNCPUMWRMSR} */
1906	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7MiscPwrMgmt(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1907	{
1908	return VINF_SUCCESS;
1909	}
1910
1911
1912	/** @callback_method_impl{FNCPUMRDMSR} */
1913	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelP6CrN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1914	{
1915	int rc = CPUMGetGuestCRx(pVCpu, pRange->uValue, puValue);
1916	AssertRC(rc);
1917	return VINF_SUCCESS;
1918	}
1919
1920
1921	/** @callback_method_impl{FNCPUMWRMSR} */
1922	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelP6CrN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1923	{
1924	/* This CRx interface differs from the MOV CRx, GReg interface in that
1925	#GP(0) isn't raised if unsupported bits are written to. Instead they
1926	are simply ignored and masked off. (Pentium M Dothan) */
1927	/** @todo Implement MSR_P6_CRx writing. Too much effort for very little, if
1928	* any, gain. */
1929	return VINF_SUCCESS;
1930	}
1931
1932
1933	/** @callback_method_impl{FNCPUMRDMSR} */
1934	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelCpuId1FeatureMaskEcdx(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1935	{
1936	/** @todo implement CPUID masking. */
1937	*puValue = UINT64_MAX;
1938	return VINF_SUCCESS;
1939	}
1940
1941
1942	/** @callback_method_impl{FNCPUMWRMSR} */
1943	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelCpuId1FeatureMaskEcdx(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1944	{
1945	/** @todo implement CPUID masking. */
1946	return VINF_SUCCESS;
1947	}
1948
1949
1950	/** @callback_method_impl{FNCPUMRDMSR} */
1951	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelCpuId1FeatureMaskEax(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1952	{
1953	/** @todo implement CPUID masking. */
1954	return VINF_SUCCESS;
1955	}
1956
1957
1958	/** @callback_method_impl{FNCPUMWRMSR} */
1959	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelCpuId1FeatureMaskEax(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1960	{
1961	/** @todo implement CPUID masking. */
1962	return VINF_SUCCESS;
1963	}
1964
1965
1966
1967	/** @callback_method_impl{FNCPUMRDMSR} */
1968	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelCpuId80000001FeatureMaskEcdx(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1969	{
1970	/** @todo implement CPUID masking. */
1971	*puValue = UINT64_MAX;
1972	return VINF_SUCCESS;
1973	}
1974
1975
1976	/** @callback_method_impl{FNCPUMWRMSR} */
1977	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelCpuId80000001FeatureMaskEcdx(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1978	{
1979	/** @todo implement CPUID masking. */
1980	return VINF_SUCCESS;
1981	}
1982
1983
1984
1985	/** @callback_method_impl{FNCPUMRDMSR} */
1986	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7SandyAesNiCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
1987	{
1988	/** @todo implement AES-NI. */
1989	puValue = 3; / Bit 0 is lock bit, bit 1 disables AES-NI. That's what they say. */
1990	return VINF_SUCCESS;
1991	}
1992
1993
1994	/** @callback_method_impl{FNCPUMWRMSR} */
1995	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7SandyAesNiCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
1996	{
1997	/** @todo implement AES-NI. */
1998	return VERR_CPUM_RAISE_GP_0;
1999	}
2000
2001
2002	/** @callback_method_impl{FNCPUMRDMSR} */
2003	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7TurboRatioLimit(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2004	{
2005	/** @todo implement intel C states. */
2006	*puValue = pRange->uValue;
2007	return VINF_SUCCESS;
2008	}
2009
2010
2011	/** @callback_method_impl{FNCPUMWRMSR} */
2012	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7TurboRatioLimit(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2013	{
2014	/** @todo implement intel C states. */
2015	return VINF_SUCCESS;
2016	}
2017
2018
2019	/** @callback_method_impl{FNCPUMRDMSR} */
2020	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7LbrSelect(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2021	{
2022	/** @todo implement last-branch-records. */
2023	*puValue = 0;
2024	return VINF_SUCCESS;
2025	}
2026
2027
2028	/** @callback_method_impl{FNCPUMWRMSR} */
2029	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7LbrSelect(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2030	{
2031	/** @todo implement last-branch-records. */
2032	return VINF_SUCCESS;
2033	}
2034
2035
2036	/** @callback_method_impl{FNCPUMRDMSR} */
2037	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7SandyErrorControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2038	{
2039	/** @todo implement memory error injection (MSR_ERROR_CONTROL). */
2040	*puValue = 0;
2041	return VINF_SUCCESS;
2042	}
2043
2044
2045	/** @callback_method_impl{FNCPUMWRMSR} */
2046	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7SandyErrorControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2047	{
2048	/** @todo implement memory error injection (MSR_ERROR_CONTROL). */
2049	return VINF_SUCCESS;
2050	}
2051
2052
2053	/** @callback_method_impl{FNCPUMRDMSR} */
2054	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7VirtualLegacyWireCap(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2055	{
2056	/** @todo implement memory VLW? */
2057	*puValue = pRange->uValue;
2058	/* Note: A20M is known to be bit 1 as this was disclosed in spec update
2059	AAJ49/AAK51/????, which documents the inversion of this bit. The
2060	Sandy bridge CPU here has value 0x74, so it probably doesn't have a BIOS
2061	that correct things. Some guesses at the other bits:
2062	bit 2 = INTR
2063	bit 4 = SMI
2064	bit 5 = INIT
2065	bit 6 = NMI */
2066	return VINF_SUCCESS;
2067	}
2068
2069
2070	/** @callback_method_impl{FNCPUMRDMSR} */
2071	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7PowerCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2072	{
2073	/** @todo intel power management */
2074	*puValue = 0;
2075	return VINF_SUCCESS;
2076	}
2077
2078
2079	/** @callback_method_impl{FNCPUMWRMSR} */
2080	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7PowerCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2081	{
2082	/** @todo intel power management */
2083	return VINF_SUCCESS;
2084	}
2085
2086
2087	/** @callback_method_impl{FNCPUMRDMSR} */
2088	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7SandyPebsNumAlt(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2089	{
2090	/** @todo intel performance counters. */
2091	*puValue = 0;
2092	return VINF_SUCCESS;
2093	}
2094
2095
2096	/** @callback_method_impl{FNCPUMWRMSR} */
2097	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7SandyPebsNumAlt(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2098	{
2099	/** @todo intel performance counters. */
2100	return VINF_SUCCESS;
2101	}
2102
2103
2104	/** @callback_method_impl{FNCPUMRDMSR} */
2105	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7PebsLdLat(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2106	{
2107	/** @todo intel performance counters. */
2108	*puValue = 0;
2109	return VINF_SUCCESS;
2110	}
2111
2112
2113	/** @callback_method_impl{FNCPUMWRMSR} */
2114	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7PebsLdLat(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2115	{
2116	/** @todo intel performance counters. */
2117	return VINF_SUCCESS;
2118	}
2119
2120
2121	/** @callback_method_impl{FNCPUMRDMSR} */
2122	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7PkgCnResidencyN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2123	{
2124	/** @todo intel power management. */
2125	*puValue = 0;
2126	return VINF_SUCCESS;
2127	}
2128
2129
2130	/** @callback_method_impl{FNCPUMRDMSR} */
2131	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7CoreCnResidencyN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2132	{
2133	/** @todo intel power management. */
2134	*puValue = 0;
2135	return VINF_SUCCESS;
2136	}
2137
2138
2139	/** @callback_method_impl{FNCPUMRDMSR} */
2140	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7SandyVrCurrentConfig(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2141	{
2142	/** @todo Figure out what MSR_VR_CURRENT_CONFIG & MSR_VR_MISC_CONFIG are. */
2143	*puValue = 0;
2144	return VINF_SUCCESS;
2145	}
2146
2147
2148	/** @callback_method_impl{FNCPUMWRMSR} */
2149	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7SandyVrCurrentConfig(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2150	{
2151	/** @todo Figure out what MSR_VR_CURRENT_CONFIG & MSR_VR_MISC_CONFIG are. */
2152	return VINF_SUCCESS;
2153	}
2154
2155
2156	/** @callback_method_impl{FNCPUMRDMSR} */
2157	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7SandyVrMiscConfig(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2158	{
2159	/** @todo Figure out what MSR_VR_CURRENT_CONFIG & MSR_VR_MISC_CONFIG are. */
2160	*puValue = 0;
2161	return VINF_SUCCESS;
2162	}
2163
2164
2165	/** @callback_method_impl{FNCPUMWRMSR} */
2166	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7SandyVrMiscConfig(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2167	{
2168	/** @todo Figure out what MSR_VR_CURRENT_CONFIG & MSR_VR_MISC_CONFIG are. */
2169	return VINF_SUCCESS;
2170	}
2171
2172
2173	/** @callback_method_impl{FNCPUMRDMSR} */
2174	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7SandyRaplPowerUnit(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2175	{
2176	/** @todo intel RAPL. */
2177	*puValue = pRange->uValue;
2178	return VINF_SUCCESS;
2179	}
2180
2181
2182	/** @callback_method_impl{FNCPUMWRMSR} */
2183	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7SandyRaplPowerUnit(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2184	{
2185	/* Note! This is documented as read only and except for a Silvermont sample has
2186	always been classified as read only. This is just here to make it compile. */
2187	return VINF_SUCCESS;
2188	}
2189
2190
2191	/** @callback_method_impl{FNCPUMRDMSR} */
2192	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7SandyPkgCnIrtlN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2193	{
2194	/** @todo intel power management. */
2195	*puValue = 0;
2196	return VINF_SUCCESS;
2197	}
2198
2199
2200	/** @callback_method_impl{FNCPUMWRMSR} */
2201	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7SandyPkgCnIrtlN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2202	{
2203	/** @todo intel power management. */
2204	return VINF_SUCCESS;
2205	}
2206
2207
2208	/** @callback_method_impl{FNCPUMRDMSR} */
2209	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7SandyPkgC2Residency(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2210	{
2211	/** @todo intel power management. */
2212	*puValue = 0;
2213	return VINF_SUCCESS;
2214	}
2215
2216
2217	/** @callback_method_impl{FNCPUMWRMSR} */
2218	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7SandyPkgC2Residency(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2219	{
2220	/* Note! This is documented as read only and except for a Silvermont sample has
2221	always been classified as read only. This is just here to make it compile. */
2222	return VINF_SUCCESS;
2223	}
2224
2225
2226	/** @callback_method_impl{FNCPUMRDMSR} */
2227	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplPkgPowerLimit(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2228	{
2229	/** @todo intel RAPL. */
2230	*puValue = 0;
2231	return VINF_SUCCESS;
2232	}
2233
2234
2235	/** @callback_method_impl{FNCPUMWRMSR} */
2236	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7RaplPkgPowerLimit(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2237	{
2238	/** @todo intel RAPL. */
2239	return VINF_SUCCESS;
2240	}
2241
2242
2243	/** @callback_method_impl{FNCPUMRDMSR} */
2244	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplPkgEnergyStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2245	{
2246	/** @todo intel power management. */
2247	*puValue = 0;
2248	return VINF_SUCCESS;
2249	}
2250
2251
2252	/** @callback_method_impl{FNCPUMRDMSR} */
2253	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplPkgPerfStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2254	{
2255	/** @todo intel power management. */
2256	*puValue = 0;
2257	return VINF_SUCCESS;
2258	}
2259
2260
2261	/** @callback_method_impl{FNCPUMRDMSR} */
2262	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplPkgPowerInfo(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2263	{
2264	/** @todo intel power management. */
2265	*puValue = 0;
2266	return VINF_SUCCESS;
2267	}
2268
2269
2270	/** @callback_method_impl{FNCPUMRDMSR} */
2271	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplDramPowerLimit(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2272	{
2273	/** @todo intel RAPL. */
2274	*puValue = 0;
2275	return VINF_SUCCESS;
2276	}
2277
2278
2279	/** @callback_method_impl{FNCPUMWRMSR} */
2280	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7RaplDramPowerLimit(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2281	{
2282	/** @todo intel RAPL. */
2283	return VINF_SUCCESS;
2284	}
2285
2286
2287	/** @callback_method_impl{FNCPUMRDMSR} */
2288	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplDramEnergyStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2289	{
2290	/** @todo intel power management. */
2291	*puValue = 0;
2292	return VINF_SUCCESS;
2293	}
2294
2295
2296	/** @callback_method_impl{FNCPUMRDMSR} */
2297	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplDramPerfStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2298	{
2299	/** @todo intel power management. */
2300	*puValue = 0;
2301	return VINF_SUCCESS;
2302	}
2303
2304
2305	/** @callback_method_impl{FNCPUMRDMSR} */
2306	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplDramPowerInfo(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2307	{
2308	/** @todo intel power management. */
2309	*puValue = 0;
2310	return VINF_SUCCESS;
2311	}
2312
2313
2314	/** @callback_method_impl{FNCPUMRDMSR} */
2315	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplPp0PowerLimit(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2316	{
2317	/** @todo intel RAPL. */
2318	*puValue = 0;
2319	return VINF_SUCCESS;
2320	}
2321
2322
2323	/** @callback_method_impl{FNCPUMWRMSR} */
2324	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7RaplPp0PowerLimit(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2325	{
2326	/** @todo intel RAPL. */
2327	return VINF_SUCCESS;
2328	}
2329
2330
2331	/** @callback_method_impl{FNCPUMRDMSR} */
2332	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplPp0EnergyStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2333	{
2334	/** @todo intel power management. */
2335	*puValue = 0;
2336	return VINF_SUCCESS;
2337	}
2338
2339
2340	/** @callback_method_impl{FNCPUMRDMSR} */
2341	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplPp0Policy(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2342	{
2343	/** @todo intel RAPL. */
2344	*puValue = 0;
2345	return VINF_SUCCESS;
2346	}
2347
2348
2349	/** @callback_method_impl{FNCPUMWRMSR} */
2350	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7RaplPp0Policy(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2351	{
2352	/** @todo intel RAPL. */
2353	return VINF_SUCCESS;
2354	}
2355
2356
2357	/** @callback_method_impl{FNCPUMRDMSR} */
2358	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplPp0PerfStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2359	{
2360	/** @todo intel power management. */
2361	*puValue = 0;
2362	return VINF_SUCCESS;
2363	}
2364
2365
2366	/** @callback_method_impl{FNCPUMRDMSR} */
2367	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplPp1PowerLimit(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2368	{
2369	/** @todo intel RAPL. */
2370	*puValue = 0;
2371	return VINF_SUCCESS;
2372	}
2373
2374
2375	/** @callback_method_impl{FNCPUMWRMSR} */
2376	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7RaplPp1PowerLimit(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2377	{
2378	/** @todo intel RAPL. */
2379	return VINF_SUCCESS;
2380	}
2381
2382
2383	/** @callback_method_impl{FNCPUMRDMSR} */
2384	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplPp1EnergyStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2385	{
2386	/** @todo intel power management. */
2387	*puValue = 0;
2388	return VINF_SUCCESS;
2389	}
2390
2391
2392	/** @callback_method_impl{FNCPUMRDMSR} */
2393	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7RaplPp1Policy(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2394	{
2395	/** @todo intel RAPL. */
2396	*puValue = 0;
2397	return VINF_SUCCESS;
2398	}
2399
2400
2401	/** @callback_method_impl{FNCPUMWRMSR} */
2402	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7RaplPp1Policy(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2403	{
2404	/** @todo intel RAPL. */
2405	return VINF_SUCCESS;
2406	}
2407
2408
2409	/** @callback_method_impl{FNCPUMRDMSR} */
2410	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7IvyConfigTdpNominal(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2411	{
2412	/** @todo intel power management. */
2413	*puValue = pRange->uValue;
2414	return VINF_SUCCESS;
2415	}
2416
2417
2418	/** @callback_method_impl{FNCPUMRDMSR} */
2419	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7IvyConfigTdpLevel1(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2420	{
2421	/** @todo intel power management. */
2422	*puValue = pRange->uValue;
2423	return VINF_SUCCESS;
2424	}
2425
2426
2427	/** @callback_method_impl{FNCPUMRDMSR} */
2428	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7IvyConfigTdpLevel2(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2429	{
2430	/** @todo intel power management. */
2431	*puValue = pRange->uValue;
2432	return VINF_SUCCESS;
2433	}
2434
2435
2436	/** @callback_method_impl{FNCPUMRDMSR} */
2437	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7IvyConfigTdpControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2438	{
2439	/** @todo intel power management. */
2440	*puValue = 0;
2441	return VINF_SUCCESS;
2442	}
2443
2444
2445	/** @callback_method_impl{FNCPUMWRMSR} */
2446	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7IvyConfigTdpControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2447	{
2448	/** @todo intel power management. */
2449	return VINF_SUCCESS;
2450	}
2451
2452
2453	/** @callback_method_impl{FNCPUMRDMSR} */
2454	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7IvyTurboActivationRatio(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2455	{
2456	/** @todo intel power management. */
2457	*puValue = 0;
2458	return VINF_SUCCESS;
2459	}
2460
2461
2462	/** @callback_method_impl{FNCPUMWRMSR} */
2463	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7IvyTurboActivationRatio(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2464	{
2465	/** @todo intel power management. */
2466	return VINF_SUCCESS;
2467	}
2468
2469
2470	/** @callback_method_impl{FNCPUMRDMSR} */
2471	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7UncPerfGlobalCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2472	{
2473	/** @todo uncore msrs. */
2474	*puValue = 0;
2475	return VINF_SUCCESS;
2476	}
2477
2478
2479	/** @callback_method_impl{FNCPUMWRMSR} */
2480	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7UncPerfGlobalCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2481	{
2482	/** @todo uncore msrs. */
2483	return VINF_SUCCESS;
2484	}
2485
2486
2487	/** @callback_method_impl{FNCPUMRDMSR} */
2488	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7UncPerfGlobalStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2489	{
2490	/** @todo uncore msrs. */
2491	*puValue = 0;
2492	return VINF_SUCCESS;
2493	}
2494
2495
2496	/** @callback_method_impl{FNCPUMWRMSR} */
2497	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7UncPerfGlobalStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2498	{
2499	/** @todo uncore msrs. */
2500	return VINF_SUCCESS;
2501	}
2502
2503
2504	/** @callback_method_impl{FNCPUMRDMSR} */
2505	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7UncPerfGlobalOvfCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2506	{
2507	/** @todo uncore msrs. */
2508	*puValue = 0;
2509	return VINF_SUCCESS;
2510	}
2511
2512
2513	/** @callback_method_impl{FNCPUMWRMSR} */
2514	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7UncPerfGlobalOvfCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2515	{
2516	/** @todo uncore msrs. */
2517	return VINF_SUCCESS;
2518	}
2519
2520
2521	/** @callback_method_impl{FNCPUMRDMSR} */
2522	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7UncPerfFixedCtrCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2523	{
2524	/** @todo uncore msrs. */
2525	*puValue = 0;
2526	return VINF_SUCCESS;
2527	}
2528
2529
2530	/** @callback_method_impl{FNCPUMWRMSR} */
2531	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7UncPerfFixedCtrCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2532	{
2533	/** @todo uncore msrs. */
2534	return VINF_SUCCESS;
2535	}
2536
2537
2538	/** @callback_method_impl{FNCPUMRDMSR} */
2539	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7UncPerfFixedCtr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2540	{
2541	/** @todo uncore msrs. */
2542	*puValue = 0;
2543	return VINF_SUCCESS;
2544	}
2545
2546
2547	/** @callback_method_impl{FNCPUMWRMSR} */
2548	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7UncPerfFixedCtr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2549	{
2550	/** @todo uncore msrs. */
2551	return VINF_SUCCESS;
2552	}
2553
2554
2555	/** @callback_method_impl{FNCPUMRDMSR} */
2556	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7UncCBoxConfig(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2557	{
2558	/** @todo uncore msrs. */
2559	*puValue = 0;
2560	return VINF_SUCCESS;
2561	}
2562
2563
2564	/** @callback_method_impl{FNCPUMRDMSR} */
2565	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7UncArbPerfCtrN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2566	{
2567	/** @todo uncore msrs. */
2568	*puValue = 0;
2569	return VINF_SUCCESS;
2570	}
2571
2572
2573	/** @callback_method_impl{FNCPUMWRMSR} */
2574	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7UncArbPerfCtrN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2575	{
2576	/** @todo uncore msrs. */
2577	return VINF_SUCCESS;
2578	}
2579
2580
2581	/** @callback_method_impl{FNCPUMRDMSR} */
2582	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7UncArbPerfEvtSelN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2583	{
2584	/** @todo uncore msrs. */
2585	*puValue = 0;
2586	return VINF_SUCCESS;
2587	}
2588
2589
2590	/** @callback_method_impl{FNCPUMWRMSR} */
2591	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelI7UncArbPerfEvtSelN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2592	{
2593	/** @todo uncore msrs. */
2594	return VINF_SUCCESS;
2595	}
2596
2597
2598	/** @callback_method_impl{FNCPUMRDMSR} */
2599	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelI7SmiCount(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2600	{
2601	/*
2602	* 31:0 is SMI count (read only), 63:32 reserved.
2603	* Since we don't do SMI, the count is always zero.
2604	*/
2605	*puValue = 0;
2606	return VINF_SUCCESS;
2607	}
2608
2609
2610	/** @callback_method_impl{FNCPUMRDMSR} */
2611	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelCore2EmttmCrTablesN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2612	{
2613	/** @todo implement enhanced multi thread termal monitoring? */
2614	*puValue = pRange->uValue;
2615	return VINF_SUCCESS;
2616	}
2617
2618
2619	/** @callback_method_impl{FNCPUMWRMSR} */
2620	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelCore2EmttmCrTablesN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2621	{
2622	/** @todo implement enhanced multi thread termal monitoring? */
2623	return VINF_SUCCESS;
2624	}
2625
2626
2627	/** @callback_method_impl{FNCPUMRDMSR} */
2628	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelCore2SmmCStMiscInfo(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2629	{
2630	/** @todo SMM & C-states? */
2631	*puValue = 0;
2632	return VINF_SUCCESS;
2633	}
2634
2635
2636	/** @callback_method_impl{FNCPUMWRMSR} */
2637	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelCore2SmmCStMiscInfo(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2638	{
2639	/** @todo SMM & C-states? */
2640	return VINF_SUCCESS;
2641	}
2642
2643
2644	/** @callback_method_impl{FNCPUMRDMSR} */
2645	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelCore1ExtConfig(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2646	{
2647	/** @todo Core1&2 EXT_CONFIG (whatever that is)? */
2648	*puValue = 0;
2649	return VINF_SUCCESS;
2650	}
2651
2652
2653	/** @callback_method_impl{FNCPUMWRMSR} */
2654	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelCore1ExtConfig(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2655	{
2656	/** @todo Core1&2 EXT_CONFIG (whatever that is)? */
2657	return VINF_SUCCESS;
2658	}
2659
2660
2661	/** @callback_method_impl{FNCPUMRDMSR} */
2662	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelCore1DtsCalControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2663	{
2664	/** @todo Core1&2(?) DTS_CAL_CTRL (whatever that is)? */
2665	*puValue = 0;
2666	return VINF_SUCCESS;
2667	}
2668
2669
2670	/** @callback_method_impl{FNCPUMWRMSR} */
2671	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelCore1DtsCalControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2672	{
2673	/** @todo Core1&2(?) DTS_CAL_CTRL (whatever that is)? */
2674	return VINF_SUCCESS;
2675	}
2676
2677
2678	/** @callback_method_impl{FNCPUMRDMSR} */
2679	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelCore2PeciControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2680	{
2681	/** @todo Core2+ platform environment control interface control register? */
2682	*puValue = 0;
2683	return VINF_SUCCESS;
2684	}
2685
2686
2687	/** @callback_method_impl{FNCPUMWRMSR} */
2688	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_IntelCore2PeciControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2689	{
2690	/** @todo Core2+ platform environment control interface control register? */
2691	return VINF_SUCCESS;
2692	}
2693
2694
2695	/** @callback_method_impl{FNCPUMRDMSR} */
2696	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_IntelAtSilvCoreC1Recidency(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2697	{
2698	*puValue = 0;
2699	return VINF_SUCCESS;
2700	}
2701
2702
2703	/*
2704	* Multiple vendor P6 MSRs.
2705	* Multiple vendor P6 MSRs.
2706	* Multiple vendor P6 MSRs.
2707	*
2708	* These MSRs were introduced with the P6 but not elevated to architectural
2709	* MSRs, despite other vendors implementing them.
2710	*/
2711
2712
2713	/** @callback_method_impl{FNCPUMRDMSR} */
2714	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_P6LastBranchFromIp(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2715	{
2716	/* AMD seems to just record RIP, while intel claims to record RIP+CS.BASE
2717	if I read the docs correctly, thus the need for separate functions. */
2718	/** @todo implement last branch records. */
2719	*puValue = 0;
2720	return VINF_SUCCESS;
2721	}
2722
2723
2724	/** @callback_method_impl{FNCPUMRDMSR} */
2725	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_P6LastBranchToIp(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2726	{
2727	/** @todo implement last branch records. */
2728	*puValue = 0;
2729	return VINF_SUCCESS;
2730	}
2731
2732
2733	/** @callback_method_impl{FNCPUMRDMSR} */
2734	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_P6LastIntFromIp(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2735	{
2736	/** @todo implement last exception records. */
2737	*puValue = 0;
2738	return VINF_SUCCESS;
2739	}
2740
2741
2742	/** @callback_method_impl{FNCPUMWRMSR} */
2743	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_P6LastIntFromIp(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2744	{
2745	/** @todo implement last exception records. */
2746	/* Note! On many CPUs, the high bit of the 0x000001dd register is always writable, even when the result is
2747	a non-cannonical address. */
2748	return VINF_SUCCESS;
2749	}
2750
2751
2752	/** @callback_method_impl{FNCPUMRDMSR} */
2753	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_P6LastIntToIp(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2754	{
2755	/** @todo implement last exception records. */
2756	*puValue = 0;
2757	return VINF_SUCCESS;
2758	}
2759
2760
2761	/** @callback_method_impl{FNCPUMWRMSR} */
2762	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_P6LastIntToIp(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2763	{
2764	/** @todo implement last exception records. */
2765	return VINF_SUCCESS;
2766	}
2767
2768
2769
2770	/*
2771	* AMD specific
2772	* AMD specific
2773	* AMD specific
2774	*/
2775
2776
2777	/** @callback_method_impl{FNCPUMRDMSR} */
2778	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam15hTscRate(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2779	{
2780	/** @todo Implement TscRateMsr */
2781	puValue = RT_MAKE_U64(0, 1); / 1.0 = reset value. */
2782	return VINF_SUCCESS;
2783	}
2784
2785
2786	/** @callback_method_impl{FNCPUMWRMSR} */
2787	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam15hTscRate(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2788	{
2789	/** @todo Implement TscRateMsr */
2790	return VINF_SUCCESS;
2791	}
2792
2793
2794	/** @callback_method_impl{FNCPUMRDMSR} */
2795	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam15hLwpCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2796	{
2797	/** @todo Implement AMD LWP? (Instructions: LWPINS, LWPVAL, LLWPCB, SLWPCB) */
2798	/* Note: Only listes in BKDG for Family 15H. */
2799	*puValue = 0;
2800	return VINF_SUCCESS;
2801	}
2802
2803
2804	/** @callback_method_impl{FNCPUMWRMSR} */
2805	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam15hLwpCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2806	{
2807	/** @todo Implement AMD LWP? (Instructions: LWPINS, LWPVAL, LLWPCB, SLWPCB) */
2808	return VINF_SUCCESS;
2809	}
2810
2811
2812	/** @callback_method_impl{FNCPUMRDMSR} */
2813	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam15hLwpCbAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2814	{
2815	/** @todo Implement AMD LWP? (Instructions: LWPINS, LWPVAL, LLWPCB, SLWPCB) */
2816	/* Note: Only listes in BKDG for Family 15H. */
2817	*puValue = 0;
2818	return VINF_SUCCESS;
2819	}
2820
2821
2822	/** @callback_method_impl{FNCPUMWRMSR} */
2823	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam15hLwpCbAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2824	{
2825	/** @todo Implement AMD LWP? (Instructions: LWPINS, LWPVAL, LLWPCB, SLWPCB) */
2826	return VINF_SUCCESS;
2827	}
2828
2829
2830	/** @callback_method_impl{FNCPUMRDMSR} */
2831	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hMc4MiscN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2832	{
2833	/** @todo machine check. */
2834	*puValue = 0;
2835	return VINF_SUCCESS;
2836	}
2837
2838
2839	/** @callback_method_impl{FNCPUMWRMSR} */
2840	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hMc4MiscN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2841	{
2842	/** @todo machine check. */
2843	return VINF_SUCCESS;
2844	}
2845
2846
2847	/** @callback_method_impl{FNCPUMRDMSR} */
2848	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8PerfCtlN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2849	{
2850	/** @todo AMD performance events. */
2851	*puValue = 0;
2852	return VINF_SUCCESS;
2853	}
2854
2855
2856	/** @callback_method_impl{FNCPUMWRMSR} */
2857	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8PerfCtlN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2858	{
2859	/** @todo AMD performance events. */
2860	return VINF_SUCCESS;
2861	}
2862
2863
2864	/** @callback_method_impl{FNCPUMRDMSR} */
2865	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8PerfCtrN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2866	{
2867	/** @todo AMD performance events. */
2868	*puValue = 0;
2869	return VINF_SUCCESS;
2870	}
2871
2872
2873	/** @callback_method_impl{FNCPUMWRMSR} */
2874	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8PerfCtrN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2875	{
2876	/** @todo AMD performance events. */
2877	return VINF_SUCCESS;
2878	}
2879
2880
2881	/** @callback_method_impl{FNCPUMRDMSR} */
2882	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8SysCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2883	{
2884	/** @todo AMD SYS_CFG */
2885	*puValue = pRange->uValue;
2886	return VINF_SUCCESS;
2887	}
2888
2889
2890	/** @callback_method_impl{FNCPUMWRMSR} */
2891	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8SysCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2892	{
2893	/** @todo AMD SYS_CFG */
2894	return VINF_SUCCESS;
2895	}
2896
2897
2898	/** @callback_method_impl{FNCPUMRDMSR} */
2899	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8HwCr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2900	{
2901	/** @todo AMD HW_CFG */
2902	*puValue = 0;
2903	return VINF_SUCCESS;
2904	}
2905
2906
2907	/** @callback_method_impl{FNCPUMWRMSR} */
2908	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8HwCr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2909	{
2910	/** @todo AMD HW_CFG */
2911	return VINF_SUCCESS;
2912	}
2913
2914
2915	/** @callback_method_impl{FNCPUMRDMSR} */
2916	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8IorrBaseN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2917	{
2918	/** @todo AMD IorrMask/IorrBase */
2919	*puValue = 0;
2920	return VINF_SUCCESS;
2921	}
2922
2923
2924	/** @callback_method_impl{FNCPUMWRMSR} */
2925	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8IorrBaseN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2926	{
2927	/** @todo AMD IorrMask/IorrBase */
2928	return VINF_SUCCESS;
2929	}
2930
2931
2932	/** @callback_method_impl{FNCPUMRDMSR} */
2933	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8IorrMaskN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2934	{
2935	/** @todo AMD IorrMask/IorrBase */
2936	*puValue = 0;
2937	return VINF_SUCCESS;
2938	}
2939
2940
2941	/** @callback_method_impl{FNCPUMWRMSR} */
2942	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8IorrMaskN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2943	{
2944	/** @todo AMD IorrMask/IorrBase */
2945	return VINF_SUCCESS;
2946	}
2947
2948
2949	/** @callback_method_impl{FNCPUMRDMSR} */
2950	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8TopOfMemN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2951	{
2952	*puValue = 0;
2953	/** @todo return 4GB - RamHoleSize here for TOPMEM. Figure out what to return
2954	* for TOPMEM2. */
2955	//if (pRange->uValue == 0)
2956	// *puValue = _4G - RamHoleSize;
2957	return VINF_SUCCESS;
2958	}
2959
2960
2961	/** @callback_method_impl{FNCPUMWRMSR} */
2962	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8TopOfMemN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2963	{
2964	/** @todo AMD TOPMEM and TOPMEM2/TOM2. */
2965	return VINF_SUCCESS;
2966	}
2967
2968
2969	/** @callback_method_impl{FNCPUMRDMSR} */
2970	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8NbCfg1(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2971	{
2972	/** @todo AMD NB_CFG1 */
2973	*puValue = 0;
2974	return VINF_SUCCESS;
2975	}
2976
2977
2978	/** @callback_method_impl{FNCPUMWRMSR} */
2979	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8NbCfg1(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2980	{
2981	/** @todo AMD NB_CFG1 */
2982	return VINF_SUCCESS;
2983	}
2984
2985
2986	/** @callback_method_impl{FNCPUMRDMSR} */
2987	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8McXcptRedir(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
2988	{
2989	/** @todo machine check. */
2990	*puValue = 0;
2991	return VINF_SUCCESS;
2992	}
2993
2994
2995	/** @callback_method_impl{FNCPUMWRMSR} */
2996	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8McXcptRedir(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
2997	{
2998	/** @todo machine check. */
2999	return VINF_SUCCESS;
3000	}
3001
3002
3003	/** @callback_method_impl{FNCPUMRDMSR} */
3004	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8CpuNameN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3005	{
3006	PCPUMCPUIDLEAF pLeaf = cpumCpuIdGetLeaf(pVCpu->CTX_SUFF(pVM), pRange->uValue / 2 + 0x80000001);
3007	if (pLeaf)
3008	{
3009	if (!(pRange->uValue & 1))
3010	*puValue = RT_MAKE_U64(pLeaf->uEax, pLeaf->uEbx);
3011	else
3012	*puValue = RT_MAKE_U64(pLeaf->uEcx, pLeaf->uEdx);
3013	}
3014	else
3015	*puValue = 0;
3016	return VINF_SUCCESS;
3017	}
3018
3019
3020	/** @callback_method_impl{FNCPUMWRMSR} */
3021	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8CpuNameN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3022	{
3023	/** @todo Remember guest programmed CPU name. */
3024	return VINF_SUCCESS;
3025	}
3026
3027
3028	/** @callback_method_impl{FNCPUMRDMSR} */
3029	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8HwThermalCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3030	{
3031	/** @todo AMD HTC. */
3032	*puValue = pRange->uValue;
3033	return VINF_SUCCESS;
3034	}
3035
3036
3037	/** @callback_method_impl{FNCPUMWRMSR} */
3038	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8HwThermalCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3039	{
3040	/** @todo AMD HTC. */
3041	return VINF_SUCCESS;
3042	}
3043
3044
3045	/** @callback_method_impl{FNCPUMRDMSR} */
3046	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8SwThermalCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3047	{
3048	/** @todo AMD STC. */
3049	*puValue = 0;
3050	return VINF_SUCCESS;
3051	}
3052
3053
3054	/** @callback_method_impl{FNCPUMWRMSR} */
3055	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8SwThermalCtrl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3056	{
3057	/** @todo AMD STC. */
3058	return VINF_SUCCESS;
3059	}
3060
3061
3062	/** @callback_method_impl{FNCPUMRDMSR} */
3063	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8FidVidControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3064	{
3065	/** @todo AMD FIDVID_CTL. */
3066	*puValue = pRange->uValue;
3067	return VINF_SUCCESS;
3068	}
3069
3070
3071	/** @callback_method_impl{FNCPUMWRMSR} */
3072	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8FidVidControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3073	{
3074	/** @todo AMD FIDVID_CTL. */
3075	return VINF_SUCCESS;
3076	}
3077
3078
3079	/** @callback_method_impl{FNCPUMRDMSR} */
3080	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8FidVidStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3081	{
3082	/** @todo AMD FIDVID_STATUS. */
3083	*puValue = pRange->uValue;
3084	return VINF_SUCCESS;
3085	}
3086
3087
3088	/** @callback_method_impl{FNCPUMRDMSR} */
3089	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8McCtlMaskN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3090	{
3091	/** @todo AMD MC. */
3092	*puValue = 0;
3093	return VINF_SUCCESS;
3094	}
3095
3096
3097	/** @callback_method_impl{FNCPUMWRMSR} */
3098	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8McCtlMaskN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3099	{
3100	/** @todo AMD MC. */
3101	return VINF_SUCCESS;
3102	}
3103
3104
3105	/** @callback_method_impl{FNCPUMRDMSR} */
3106	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8SmiOnIoTrapN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3107	{
3108	/** @todo AMD SMM/SMI and I/O trap. */
3109	*puValue = 0;
3110	return VINF_SUCCESS;
3111	}
3112
3113
3114	/** @callback_method_impl{FNCPUMWRMSR} */
3115	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8SmiOnIoTrapN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3116	{
3117	/** @todo AMD SMM/SMI and I/O trap. */
3118	return VINF_SUCCESS;
3119	}
3120
3121
3122	/** @callback_method_impl{FNCPUMRDMSR} */
3123	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8SmiOnIoTrapCtlSts(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3124	{
3125	/** @todo AMD SMM/SMI and I/O trap. */
3126	*puValue = 0;
3127	return VINF_SUCCESS;
3128	}
3129
3130
3131	/** @callback_method_impl{FNCPUMWRMSR} */
3132	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8SmiOnIoTrapCtlSts(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3133	{
3134	/** @todo AMD SMM/SMI and I/O trap. */
3135	return VINF_SUCCESS;
3136	}
3137
3138
3139	/** @callback_method_impl{FNCPUMRDMSR} */
3140	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8IntPendingMessage(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3141	{
3142	/** @todo Interrupt pending message. */
3143	*puValue = 0;
3144	return VINF_SUCCESS;
3145	}
3146
3147
3148	/** @callback_method_impl{FNCPUMWRMSR} */
3149	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8IntPendingMessage(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3150	{
3151	/** @todo Interrupt pending message. */
3152	return VINF_SUCCESS;
3153	}
3154
3155
3156	/** @callback_method_impl{FNCPUMRDMSR} */
3157	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8SmiTriggerIoCycle(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3158	{
3159	/** @todo AMD SMM/SMI and trigger I/O cycle. */
3160	*puValue = 0;
3161	return VINF_SUCCESS;
3162	}
3163
3164
3165	/** @callback_method_impl{FNCPUMWRMSR} */
3166	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8SmiTriggerIoCycle(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3167	{
3168	/** @todo AMD SMM/SMI and trigger I/O cycle. */
3169	return VINF_SUCCESS;
3170	}
3171
3172
3173	/** @callback_method_impl{FNCPUMRDMSR} */
3174	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hMmioCfgBaseAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3175	{
3176	/** @todo AMD MMIO Configuration base address. */
3177	*puValue = 0;
3178	return VINF_SUCCESS;
3179	}
3180
3181
3182	/** @callback_method_impl{FNCPUMWRMSR} */
3183	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hMmioCfgBaseAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3184	{
3185	/** @todo AMD MMIO Configuration base address. */
3186	return VINF_SUCCESS;
3187	}
3188
3189
3190	/** @callback_method_impl{FNCPUMRDMSR} */
3191	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hTrapCtlMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3192	{
3193	/** @todo AMD 0xc0010059. */
3194	*puValue = 0;
3195	return VINF_SUCCESS;
3196	}
3197
3198
3199	/** @callback_method_impl{FNCPUMWRMSR} */
3200	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hTrapCtlMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3201	{
3202	/** @todo AMD 0xc0010059. */
3203	return VINF_SUCCESS;
3204	}
3205
3206
3207	/** @callback_method_impl{FNCPUMRDMSR} */
3208	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hPStateCurLimit(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3209	{
3210	/** @todo AMD P-states. */
3211	*puValue = pRange->uValue;
3212	return VINF_SUCCESS;
3213	}
3214
3215
3216	/** @callback_method_impl{FNCPUMRDMSR} */
3217	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hPStateControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3218	{
3219	/** @todo AMD P-states. */
3220	*puValue = pRange->uValue;
3221	return VINF_SUCCESS;
3222	}
3223
3224
3225	/** @callback_method_impl{FNCPUMWRMSR} */
3226	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hPStateControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3227	{
3228	/** @todo AMD P-states. */
3229	return VINF_SUCCESS;
3230	}
3231
3232
3233	/** @callback_method_impl{FNCPUMRDMSR} */
3234	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hPStateStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3235	{
3236	/** @todo AMD P-states. */
3237	*puValue = pRange->uValue;
3238	return VINF_SUCCESS;
3239	}
3240
3241
3242	/** @callback_method_impl{FNCPUMWRMSR} */
3243	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hPStateStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3244	{
3245	/** @todo AMD P-states. */
3246	return VINF_SUCCESS;
3247	}
3248
3249
3250	/** @callback_method_impl{FNCPUMRDMSR} */
3251	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hPStateN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3252	{
3253	/** @todo AMD P-states. */
3254	*puValue = pRange->uValue;
3255	return VINF_SUCCESS;
3256	}
3257
3258
3259	/** @callback_method_impl{FNCPUMWRMSR} */
3260	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hPStateN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3261	{
3262	/** @todo AMD P-states. */
3263	return VINF_SUCCESS;
3264	}
3265
3266
3267	/** @callback_method_impl{FNCPUMRDMSR} */
3268	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hCofVidControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3269	{
3270	/** @todo AMD P-states. */
3271	*puValue = pRange->uValue;
3272	return VINF_SUCCESS;
3273	}
3274
3275
3276	/** @callback_method_impl{FNCPUMWRMSR} */
3277	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hCofVidControl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3278	{
3279	/** @todo AMD P-states. */
3280	return VINF_SUCCESS;
3281	}
3282
3283
3284	/** @callback_method_impl{FNCPUMRDMSR} */
3285	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hCofVidStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3286	{
3287	/** @todo AMD P-states. */
3288	*puValue = pRange->uValue;
3289	return VINF_SUCCESS;
3290	}
3291
3292
3293	/** @callback_method_impl{FNCPUMWRMSR} */
3294	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hCofVidStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3295	{
3296	/* Note! Writing 0 seems to not GP, not sure if it does anything to the value... */
3297	/** @todo AMD P-states. */
3298	return VINF_SUCCESS;
3299	}
3300
3301
3302	/** @callback_method_impl{FNCPUMRDMSR} */
3303	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hCStateIoBaseAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3304	{
3305	/** @todo AMD C-states. */
3306	*puValue = 0;
3307	return VINF_SUCCESS;
3308	}
3309
3310
3311	/** @callback_method_impl{FNCPUMWRMSR} */
3312	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hCStateIoBaseAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3313	{
3314	/** @todo AMD C-states. */
3315	return VINF_SUCCESS;
3316	}
3317
3318
3319	/** @callback_method_impl{FNCPUMRDMSR} */
3320	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hCpuWatchdogTimer(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3321	{
3322	/** @todo AMD machine checks. */
3323	*puValue = 0;
3324	return VINF_SUCCESS;
3325	}
3326
3327
3328	/** @callback_method_impl{FNCPUMWRMSR} */
3329	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hCpuWatchdogTimer(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3330	{
3331	/** @todo AMD machine checks. */
3332	return VINF_SUCCESS;
3333	}
3334
3335
3336	/** @callback_method_impl{FNCPUMRDMSR} */
3337	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8SmmBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3338	{
3339	/** @todo AMD SMM. */
3340	*puValue = 0;
3341	return VINF_SUCCESS;
3342	}
3343
3344
3345	/** @callback_method_impl{FNCPUMWRMSR} */
3346	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8SmmBase(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3347	{
3348	/** @todo AMD SMM. */
3349	return VINF_SUCCESS;
3350	}
3351
3352
3353	/** @callback_method_impl{FNCPUMRDMSR} */
3354	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8SmmAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3355	{
3356	/** @todo AMD SMM. */
3357	*puValue = 0;
3358	return VINF_SUCCESS;
3359	}
3360
3361
3362	/** @callback_method_impl{FNCPUMWRMSR} */
3363	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8SmmAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3364	{
3365	/** @todo AMD SMM. */
3366	return VINF_SUCCESS;
3367	}
3368
3369
3370
3371	/** @callback_method_impl{FNCPUMRDMSR} */
3372	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8SmmMask(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3373	{
3374	/** @todo AMD SMM. */
3375	*puValue = 0;
3376	return VINF_SUCCESS;
3377	}
3378
3379
3380	/** @callback_method_impl{FNCPUMWRMSR} */
3381	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8SmmMask(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3382	{
3383	/** @todo AMD SMM. */
3384	return VINF_SUCCESS;
3385	}
3386
3387
3388	/** @callback_method_impl{FNCPUMRDMSR} */
3389	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8VmCr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3390	{
3391	/** @todo AMD SVM. */
3392	*puValue = 0;
3393	return VINF_SUCCESS;
3394	}
3395
3396
3397	/** @callback_method_impl{FNCPUMWRMSR} */
3398	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8VmCr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3399	{
3400	/** @todo AMD SVM. */
3401	return VINF_SUCCESS;
3402	}
3403
3404
3405	/** @callback_method_impl{FNCPUMRDMSR} */
3406	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8IgnNe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3407	{
3408	/** @todo AMD IGNNE\# control. */
3409	*puValue = 0;
3410	return VINF_SUCCESS;
3411	}
3412
3413
3414	/** @callback_method_impl{FNCPUMWRMSR} */
3415	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8IgnNe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3416	{
3417	/** @todo AMD IGNNE\# control. */
3418	return VINF_SUCCESS;
3419	}
3420
3421
3422	/** @callback_method_impl{FNCPUMRDMSR} */
3423	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8SmmCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3424	{
3425	/** @todo AMD SMM. */
3426	*puValue = 0;
3427	return VINF_SUCCESS;
3428	}
3429
3430
3431	/** @callback_method_impl{FNCPUMWRMSR} */
3432	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8SmmCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3433	{
3434	/** @todo AMD SMM. */
3435	return VINF_SUCCESS;
3436	}
3437
3438
3439	/** @callback_method_impl{FNCPUMRDMSR} */
3440	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8VmHSavePa(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3441	{
3442	/** @todo AMD SVM. */
3443	*puValue = 0;
3444	return VINF_SUCCESS;
3445	}
3446
3447
3448	/** @callback_method_impl{FNCPUMWRMSR} */
3449	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8VmHSavePa(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3450	{
3451	/** @todo AMD SVM. */
3452	return VINF_SUCCESS;
3453	}
3454
3455
3456	/** @callback_method_impl{FNCPUMRDMSR} */
3457	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hVmLockKey(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3458	{
3459	/** @todo AMD SVM. */
3460	puValue = 0; / RAZ */
3461	return VINF_SUCCESS;
3462	}
3463
3464
3465	/** @callback_method_impl{FNCPUMWRMSR} */
3466	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hVmLockKey(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3467	{
3468	/** @todo AMD SVM. */
3469	return VINF_SUCCESS;
3470	}
3471
3472
3473	/** @callback_method_impl{FNCPUMRDMSR} */
3474	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hSmmLockKey(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3475	{
3476	/** @todo AMD SMM. */
3477	puValue = 0; / RAZ */
3478	return VINF_SUCCESS;
3479	}
3480
3481
3482	/** @callback_method_impl{FNCPUMWRMSR} */
3483	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hSmmLockKey(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3484	{
3485	/** @todo AMD SMM. */
3486	return VINF_SUCCESS;
3487	}
3488
3489
3490	/** @callback_method_impl{FNCPUMRDMSR} */
3491	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hLocalSmiStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3492	{
3493	/** @todo AMD SMM/SMI. */
3494	*puValue = 0;
3495	return VINF_SUCCESS;
3496	}
3497
3498
3499	/** @callback_method_impl{FNCPUMWRMSR} */
3500	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hLocalSmiStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3501	{
3502	/** @todo AMD SMM/SMI. */
3503	return VINF_SUCCESS;
3504	}
3505
3506
3507	/** @callback_method_impl{FNCPUMRDMSR} */
3508	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hOsVisWrkIdLength(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3509	{
3510	/** @todo AMD OS visible workaround. */
3511	*puValue = pRange->uValue;
3512	return VINF_SUCCESS;
3513	}
3514
3515
3516	/** @callback_method_impl{FNCPUMWRMSR} */
3517	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hOsVisWrkIdLength(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3518	{
3519	/** @todo AMD OS visible workaround. */
3520	return VINF_SUCCESS;
3521	}
3522
3523
3524	/** @callback_method_impl{FNCPUMRDMSR} */
3525	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hOsVisWrkStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3526	{
3527	/** @todo AMD OS visible workaround. */
3528	*puValue = 0;
3529	return VINF_SUCCESS;
3530	}
3531
3532
3533	/** @callback_method_impl{FNCPUMWRMSR} */
3534	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hOsVisWrkStatus(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3535	{
3536	/** @todo AMD OS visible workaround. */
3537	return VINF_SUCCESS;
3538	}
3539
3540
3541	/** @callback_method_impl{FNCPUMRDMSR} */
3542	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam16hL2IPerfCtlN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3543	{
3544	/** @todo AMD L2I performance counters. */
3545	*puValue = 0;
3546	return VINF_SUCCESS;
3547	}
3548
3549
3550	/** @callback_method_impl{FNCPUMWRMSR} */
3551	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam16hL2IPerfCtlN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3552	{
3553	/** @todo AMD L2I performance counters. */
3554	return VINF_SUCCESS;
3555	}
3556
3557
3558	/** @callback_method_impl{FNCPUMRDMSR} */
3559	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam16hL2IPerfCtrN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3560	{
3561	/** @todo AMD L2I performance counters. */
3562	*puValue = 0;
3563	return VINF_SUCCESS;
3564	}
3565
3566
3567	/** @callback_method_impl{FNCPUMWRMSR} */
3568	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam16hL2IPerfCtrN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3569	{
3570	/** @todo AMD L2I performance counters. */
3571	return VINF_SUCCESS;
3572	}
3573
3574
3575	/** @callback_method_impl{FNCPUMRDMSR} */
3576	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam15hNorthbridgePerfCtlN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3577	{
3578	/** @todo AMD Northbridge performance counters. */
3579	*puValue = 0;
3580	return VINF_SUCCESS;
3581	}
3582
3583
3584	/** @callback_method_impl{FNCPUMWRMSR} */
3585	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam15hNorthbridgePerfCtlN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3586	{
3587	/** @todo AMD Northbridge performance counters. */
3588	return VINF_SUCCESS;
3589	}
3590
3591
3592	/** @callback_method_impl{FNCPUMRDMSR} */
3593	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam15hNorthbridgePerfCtrN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3594	{
3595	/** @todo AMD Northbridge performance counters. */
3596	*puValue = 0;
3597	return VINF_SUCCESS;
3598	}
3599
3600
3601	/** @callback_method_impl{FNCPUMWRMSR} */
3602	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam15hNorthbridgePerfCtrN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3603	{
3604	/** @todo AMD Northbridge performance counters. */
3605	return VINF_SUCCESS;
3606	}
3607
3608
3609	/** @callback_method_impl{FNCPUMRDMSR} */
3610	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7MicrocodeCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3611	{
3612	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3613	* cpus. Need to be explored and verify K7 presence. */
3614	/** @todo Undocumented register only seen mentioned in fam15h erratum \#608. */
3615	*puValue = pRange->uValue;
3616	return VINF_SUCCESS;
3617	}
3618
3619
3620	/** @callback_method_impl{FNCPUMWRMSR} */
3621	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7MicrocodeCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3622	{
3623	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3624	* cpus. Need to be explored and verify K7 presence. */
3625	/** @todo Undocumented register only seen mentioned in fam15h erratum \#608. */
3626	return VINF_SUCCESS;
3627	}
3628
3629
3630	/** @callback_method_impl{FNCPUMRDMSR} */
3631	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7ClusterIdMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3632	{
3633	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3634	* cpus. Need to be explored and verify K7 presence. */
3635	/** @todo Undocumented register only seen mentioned in fam16h BKDG r3.00 when
3636	* describing EBL_CR_POWERON. */
3637	*puValue = pRange->uValue;
3638	return VINF_SUCCESS;
3639	}
3640
3641
3642	/** @callback_method_impl{FNCPUMWRMSR} */
3643	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7ClusterIdMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3644	{
3645	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3646	* cpus. Need to be explored and verify K7 presence. */
3647	/** @todo Undocumented register only seen mentioned in fam16h BKDG r3.00 when
3648	* describing EBL_CR_POWERON. */
3649	return VINF_SUCCESS;
3650	}
3651
3652
3653	/** @callback_method_impl{FNCPUMRDMSR} */
3654	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8CpuIdCtlStd07hEbax(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3655	{
3656	bool fIgnored;
3657	PCPUMCPUIDLEAF pLeaf = cpumCpuIdGetLeafEx(pVCpu->CTX_SUFF(pVM), 0x00000007, 0, &fIgnored);
3658	if (pLeaf)
3659	*puValue = RT_MAKE_U64(pLeaf->uEbx, pLeaf->uEax);
3660	else
3661	*puValue = 0;
3662	return VINF_SUCCESS;
3663	}
3664
3665
3666	/** @callback_method_impl{FNCPUMWRMSR} */
3667	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8CpuIdCtlStd07hEbax(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3668	{
3669	/** @todo Changing CPUID leaf 7/0. */
3670	return VINF_SUCCESS;
3671	}
3672
3673
3674	/** @callback_method_impl{FNCPUMRDMSR} */
3675	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8CpuIdCtlStd06hEcx(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3676	{
3677	PCPUMCPUIDLEAF pLeaf = cpumCpuIdGetLeaf(pVCpu->CTX_SUFF(pVM), 0x00000006);
3678	if (pLeaf)
3679	*puValue = pLeaf->uEcx;
3680	else
3681	*puValue = 0;
3682	return VINF_SUCCESS;
3683	}
3684
3685
3686	/** @callback_method_impl{FNCPUMWRMSR} */
3687	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8CpuIdCtlStd06hEcx(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3688	{
3689	/** @todo Changing CPUID leaf 6. */
3690	return VINF_SUCCESS;
3691	}
3692
3693
3694	/** @callback_method_impl{FNCPUMRDMSR} */
3695	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8CpuIdCtlStd01hEdcx(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3696	{
3697	PCPUMCPUIDLEAF pLeaf = cpumCpuIdGetLeaf(pVCpu->CTX_SUFF(pVM), 0x00000001);
3698	if (pLeaf)
3699	*puValue = RT_MAKE_U64(pLeaf->uEdx, pLeaf->uEcx);
3700	else
3701	*puValue = 0;
3702	return VINF_SUCCESS;
3703	}
3704
3705
3706	/** @callback_method_impl{FNCPUMWRMSR} */
3707	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8CpuIdCtlStd01hEdcx(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3708	{
3709	/** @todo Changing CPUID leaf 0x80000001. */
3710	return VINF_SUCCESS;
3711	}
3712
3713
3714	/** @callback_method_impl{FNCPUMRDMSR} */
3715	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8CpuIdCtlExt01hEdcx(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3716	{
3717	PCPUMCPUIDLEAF pLeaf = cpumCpuIdGetLeaf(pVCpu->CTX_SUFF(pVM), 0x80000001);
3718	if (pLeaf)
3719	*puValue = RT_MAKE_U64(pLeaf->uEdx, pLeaf->uEcx);
3720	else
3721	*puValue = 0;
3722	return VINF_SUCCESS;
3723	}
3724
3725
3726	/** @callback_method_impl{FNCPUMWRMSR} */
3727	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8CpuIdCtlExt01hEdcx(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3728	{
3729	/** @todo Changing CPUID leaf 0x80000001. */
3730	return VINF_SUCCESS;
3731	}
3732
3733
3734	/** @callback_method_impl{FNCPUMRDMSR} */
3735	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK8PatchLevel(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3736	{
3737	/** @todo Fake AMD microcode patching. */
3738	*puValue = pRange->uValue;
3739	return VINF_SUCCESS;
3740	}
3741
3742
3743	/** @callback_method_impl{FNCPUMWRMSR} */
3744	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK8PatchLoader(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3745	{
3746	/** @todo Fake AMD microcode patching. */
3747	return VINF_SUCCESS;
3748	}
3749
3750
3751	/** @callback_method_impl{FNCPUMRDMSR} */
3752	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7DebugStatusMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3753	{
3754	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3755	* cpus. Need to be explored and verify K7 presence. */
3756	/** @todo undocumented */
3757	*puValue = 0;
3758	return VINF_SUCCESS;
3759	}
3760
3761
3762	/** @callback_method_impl{FNCPUMWRMSR} */
3763	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7DebugStatusMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3764	{
3765	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3766	* cpus. Need to be explored and verify K7 presence. */
3767	/** @todo undocumented */
3768	return VINF_SUCCESS;
3769	}
3770
3771
3772	/** @callback_method_impl{FNCPUMRDMSR} */
3773	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7BHTraceBaseMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3774	{
3775	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3776	* cpus. Need to be explored and verify K7 presence. */
3777	/** @todo undocumented */
3778	*puValue = 0;
3779	return VINF_SUCCESS;
3780	}
3781
3782
3783	/** @callback_method_impl{FNCPUMWRMSR} */
3784	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7BHTraceBaseMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3785	{
3786	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3787	* cpus. Need to be explored and verify K7 presence. */
3788	/** @todo undocumented */
3789	return VINF_SUCCESS;
3790	}
3791
3792
3793	/** @callback_method_impl{FNCPUMRDMSR} */
3794	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7BHTracePtrMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3795	{
3796	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3797	* cpus. Need to be explored and verify K7 presence. */
3798	/** @todo undocumented */
3799	*puValue = 0;
3800	return VINF_SUCCESS;
3801	}
3802
3803
3804	/** @callback_method_impl{FNCPUMWRMSR} */
3805	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7BHTracePtrMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3806	{
3807	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3808	* cpus. Need to be explored and verify K7 presence. */
3809	/** @todo undocumented */
3810	return VINF_SUCCESS;
3811	}
3812
3813
3814	/** @callback_method_impl{FNCPUMRDMSR} */
3815	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7BHTraceLimitMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3816	{
3817	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3818	* cpus. Need to be explored and verify K7 presence. */
3819	/** @todo undocumented */
3820	*puValue = 0;
3821	return VINF_SUCCESS;
3822	}
3823
3824
3825	/** @callback_method_impl{FNCPUMWRMSR} */
3826	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7BHTraceLimitMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3827	{
3828	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3829	* cpus. Need to be explored and verify K7 presence. */
3830	/** @todo undocumented */
3831	return VINF_SUCCESS;
3832	}
3833
3834
3835	/** @callback_method_impl{FNCPUMRDMSR} */
3836	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7HardwareDebugToolCfgMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3837	{
3838	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3839	* cpus. Need to be explored and verify K7 presence. */
3840	/** @todo undocumented */
3841	*puValue = 0;
3842	return VINF_SUCCESS;
3843	}
3844
3845
3846	/** @callback_method_impl{FNCPUMWRMSR} */
3847	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7HardwareDebugToolCfgMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3848	{
3849	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3850	* cpus. Need to be explored and verify K7 presence. */
3851	/** @todo undocumented */
3852	return VINF_SUCCESS;
3853	}
3854
3855
3856	/** @callback_method_impl{FNCPUMRDMSR} */
3857	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7FastFlushCountMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3858	{
3859	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3860	* cpus. Need to be explored and verify K7 presence. */
3861	/** @todo undocumented */
3862	*puValue = 0;
3863	return VINF_SUCCESS;
3864	}
3865
3866
3867	/** @callback_method_impl{FNCPUMWRMSR} */
3868	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7FastFlushCountMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3869	{
3870	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3871	* cpus. Need to be explored and verify K7 presence. */
3872	/** @todo undocumented */
3873	return VINF_SUCCESS;
3874	}
3875
3876
3877	/** @callback_method_impl{FNCPUMRDMSR} */
3878	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7NodeId(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3879	{
3880	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3881	* cpus. Need to be explored and verify K7 presence. */
3882	/** @todo AMD node ID and bios scratch. */
3883	puValue = 0; / nodeid = 0; nodes-per-cpu = 1 */
3884	return VINF_SUCCESS;
3885	}
3886
3887
3888	/** @callback_method_impl{FNCPUMWRMSR} */
3889	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7NodeId(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3890	{
3891	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3892	* cpus. Need to be explored and verify K7 presence. */
3893	/** @todo AMD node ID and bios scratch. */
3894	return VINF_SUCCESS;
3895	}
3896
3897
3898	/** @callback_method_impl{FNCPUMRDMSR} */
3899	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7DrXAddrMaskN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3900	{
3901	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3902	* cpus. Need to be explored and verify K7 presence. */
3903	/** @todo AMD DRx address masking (range breakpoints). */
3904	*puValue = 0;
3905	return VINF_SUCCESS;
3906	}
3907
3908
3909	/** @callback_method_impl{FNCPUMWRMSR} */
3910	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7DrXAddrMaskN(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3911	{
3912	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3913	* cpus. Need to be explored and verify K7 presence. */
3914	/** @todo AMD DRx address masking (range breakpoints). */
3915	return VINF_SUCCESS;
3916	}
3917
3918
3919	/** @callback_method_impl{FNCPUMRDMSR} */
3920	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7Dr0DataMatchMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3921	{
3922	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3923	* cpus. Need to be explored and verify K7 presence. */
3924	/** @todo AMD undocument debugging features. */
3925	*puValue = 0;
3926	return VINF_SUCCESS;
3927	}
3928
3929
3930	/** @callback_method_impl{FNCPUMWRMSR} */
3931	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7Dr0DataMatchMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3932	{
3933	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3934	* cpus. Need to be explored and verify K7 presence. */
3935	/** @todo AMD undocument debugging features. */
3936	return VINF_SUCCESS;
3937	}
3938
3939
3940	/** @callback_method_impl{FNCPUMRDMSR} */
3941	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7Dr0DataMaskMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3942	{
3943	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3944	* cpus. Need to be explored and verify K7 presence. */
3945	/** @todo AMD undocument debugging features. */
3946	*puValue = 0;
3947	return VINF_SUCCESS;
3948	}
3949
3950
3951	/** @callback_method_impl{FNCPUMWRMSR} */
3952	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7Dr0DataMaskMaybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3953	{
3954	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3955	* cpus. Need to be explored and verify K7 presence. */
3956	/** @todo AMD undocument debugging features. */
3957	return VINF_SUCCESS;
3958	}
3959
3960
3961	/** @callback_method_impl{FNCPUMRDMSR} */
3962	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7LoadStoreCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3963	{
3964	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3965	* cpus. Need to be explored and verify K7 presence. */
3966	/** @todo AMD load-store config. */
3967	*puValue = 0;
3968	return VINF_SUCCESS;
3969	}
3970
3971
3972	/** @callback_method_impl{FNCPUMWRMSR} */
3973	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7LoadStoreCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3974	{
3975	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3976	* cpus. Need to be explored and verify K7 presence. */
3977	/** @todo AMD load-store config. */
3978	return VINF_SUCCESS;
3979	}
3980
3981
3982	/** @callback_method_impl{FNCPUMRDMSR} */
3983	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7InstrCacheCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
3984	{
3985	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3986	* cpus. Need to be explored and verify K7 presence. */
3987	/** @todo AMD instruction cache config. */
3988	*puValue = 0;
3989	return VINF_SUCCESS;
3990	}
3991
3992
3993	/** @callback_method_impl{FNCPUMWRMSR} */
3994	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7InstrCacheCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
3995	{
3996	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
3997	* cpus. Need to be explored and verify K7 presence. */
3998	/** @todo AMD instruction cache config. */
3999	return VINF_SUCCESS;
4000	}
4001
4002
4003	/** @callback_method_impl{FNCPUMRDMSR} */
4004	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7DataCacheCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4005	{
4006	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
4007	* cpus. Need to be explored and verify K7 presence. */
4008	/** @todo AMD data cache config. */
4009	*puValue = 0;
4010	return VINF_SUCCESS;
4011	}
4012
4013
4014	/** @callback_method_impl{FNCPUMWRMSR} */
4015	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7DataCacheCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4016	{
4017	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
4018	* cpus. Need to be explored and verify K7 presence. */
4019	/** @todo AMD data cache config. */
4020	return VINF_SUCCESS;
4021	}
4022
4023
4024	/** @callback_method_impl{FNCPUMRDMSR} */
4025	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7BusUnitCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4026	{
4027	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
4028	* cpus. Need to be explored and verify K7 presence. */
4029	/** @todo AMD bus unit config. */
4030	*puValue = 0;
4031	return VINF_SUCCESS;
4032	}
4033
4034
4035	/** @callback_method_impl{FNCPUMWRMSR} */
4036	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7BusUnitCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4037	{
4038	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
4039	* cpus. Need to be explored and verify K7 presence. */
4040	/** @todo AMD bus unit config. */
4041	return VINF_SUCCESS;
4042	}
4043
4044
4045	/** @callback_method_impl{FNCPUMRDMSR} */
4046	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdK7DebugCtl2Maybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4047	{
4048	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
4049	* cpus. Need to be explored and verify K7 presence. */
4050	/** @todo Undocument AMD debug control register \#2. */
4051	*puValue = 0;
4052	return VINF_SUCCESS;
4053	}
4054
4055
4056	/** @callback_method_impl{FNCPUMWRMSR} */
4057	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdK7DebugCtl2Maybe(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4058	{
4059	/** @todo Allegedly requiring edi=0x9c5a203a when execuing rdmsr/wrmsr on older
4060	* cpus. Need to be explored and verify K7 presence. */
4061	/** @todo Undocument AMD debug control register \#2. */
4062	return VINF_SUCCESS;
4063	}
4064
4065
4066	/** @callback_method_impl{FNCPUMRDMSR} */
4067	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam15hFpuCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4068	{
4069	/** @todo AMD FPU config. */
4070	*puValue = 0;
4071	return VINF_SUCCESS;
4072	}
4073
4074
4075	/** @callback_method_impl{FNCPUMWRMSR} */
4076	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam15hFpuCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4077	{
4078	/** @todo AMD FPU config. */
4079	return VINF_SUCCESS;
4080	}
4081
4082
4083	/** @callback_method_impl{FNCPUMRDMSR} */
4084	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam15hDecoderCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4085	{
4086	/** @todo AMD decoder config. */
4087	*puValue = 0;
4088	return VINF_SUCCESS;
4089	}
4090
4091
4092	/** @callback_method_impl{FNCPUMWRMSR} */
4093	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam15hDecoderCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4094	{
4095	/** @todo AMD decoder config. */
4096	return VINF_SUCCESS;
4097	}
4098
4099
4100	/** @callback_method_impl{FNCPUMRDMSR} */
4101	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hBusUnitCfg2(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4102	{
4103	/* Note! 10h and 16h */
4104	/** @todo AMD bus unit config. */
4105	*puValue = 0;
4106	return VINF_SUCCESS;
4107	}
4108
4109
4110	/** @callback_method_impl{FNCPUMWRMSR} */
4111	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hBusUnitCfg2(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4112	{
4113	/* Note! 10h and 16h */
4114	/** @todo AMD bus unit config. */
4115	return VINF_SUCCESS;
4116	}
4117
4118
4119	/** @callback_method_impl{FNCPUMRDMSR} */
4120	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam15hCombUnitCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4121	{
4122	/** @todo AMD unit config. */
4123	*puValue = 0;
4124	return VINF_SUCCESS;
4125	}
4126
4127
4128	/** @callback_method_impl{FNCPUMWRMSR} */
4129	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam15hCombUnitCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4130	{
4131	/** @todo AMD unit config. */
4132	return VINF_SUCCESS;
4133	}
4134
4135
4136	/** @callback_method_impl{FNCPUMRDMSR} */
4137	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam15hCombUnitCfg2(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4138	{
4139	/** @todo AMD unit config 2. */
4140	*puValue = 0;
4141	return VINF_SUCCESS;
4142	}
4143
4144
4145	/** @callback_method_impl{FNCPUMWRMSR} */
4146	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam15hCombUnitCfg2(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4147	{
4148	/** @todo AMD unit config 2. */
4149	return VINF_SUCCESS;
4150	}
4151
4152
4153	/** @callback_method_impl{FNCPUMRDMSR} */
4154	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam15hCombUnitCfg3(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4155	{
4156	/** @todo AMD combined unit config 3. */
4157	*puValue = 0;
4158	return VINF_SUCCESS;
4159	}
4160
4161
4162	/** @callback_method_impl{FNCPUMWRMSR} */
4163	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam15hCombUnitCfg3(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4164	{
4165	/** @todo AMD combined unit config 3. */
4166	return VINF_SUCCESS;
4167	}
4168
4169
4170	/** @callback_method_impl{FNCPUMRDMSR} */
4171	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam15hExecUnitCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4172	{
4173	/** @todo AMD execution unit config. */
4174	*puValue = 0;
4175	return VINF_SUCCESS;
4176	}
4177
4178
4179	/** @callback_method_impl{FNCPUMWRMSR} */
4180	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam15hExecUnitCfg(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4181	{
4182	/** @todo AMD execution unit config. */
4183	return VINF_SUCCESS;
4184	}
4185
4186
4187	/** @callback_method_impl{FNCPUMRDMSR} */
4188	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam15hLoadStoreCfg2(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4189	{
4190	/** @todo AMD load-store config 2. */
4191	*puValue = 0;
4192	return VINF_SUCCESS;
4193	}
4194
4195
4196	/** @callback_method_impl{FNCPUMWRMSR} */
4197	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam15hLoadStoreCfg2(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4198	{
4199	/** @todo AMD load-store config 2. */
4200	return VINF_SUCCESS;
4201	}
4202
4203
4204	/** @callback_method_impl{FNCPUMRDMSR} */
4205	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hIbsFetchCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4206	{
4207	/** @todo AMD IBS. */
4208	*puValue = 0;
4209	return VINF_SUCCESS;
4210	}
4211
4212
4213	/** @callback_method_impl{FNCPUMWRMSR} */
4214	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hIbsFetchCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4215	{
4216	/** @todo AMD IBS. */
4217	return VINF_SUCCESS;
4218	}
4219
4220
4221	/** @callback_method_impl{FNCPUMRDMSR} */
4222	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hIbsFetchLinAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4223	{
4224	/** @todo AMD IBS. */
4225	*puValue = 0;
4226	return VINF_SUCCESS;
4227	}
4228
4229
4230	/** @callback_method_impl{FNCPUMWRMSR} */
4231	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hIbsFetchLinAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4232	{
4233	/** @todo AMD IBS. */
4234	return VINF_SUCCESS;
4235	}
4236
4237
4238	/** @callback_method_impl{FNCPUMRDMSR} */
4239	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hIbsFetchPhysAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4240	{
4241	/** @todo AMD IBS. */
4242	*puValue = 0;
4243	return VINF_SUCCESS;
4244	}
4245
4246
4247	/** @callback_method_impl{FNCPUMWRMSR} */
4248	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hIbsFetchPhysAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4249	{
4250	/** @todo AMD IBS. */
4251	return VINF_SUCCESS;
4252	}
4253
4254
4255	/** @callback_method_impl{FNCPUMRDMSR} */
4256	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hIbsOpExecCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4257	{
4258	/** @todo AMD IBS. */
4259	*puValue = 0;
4260	return VINF_SUCCESS;
4261	}
4262
4263
4264	/** @callback_method_impl{FNCPUMWRMSR} */
4265	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hIbsOpExecCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4266	{
4267	/** @todo AMD IBS. */
4268	return VINF_SUCCESS;
4269	}
4270
4271
4272	/** @callback_method_impl{FNCPUMRDMSR} */
4273	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hIbsOpRip(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4274	{
4275	/** @todo AMD IBS. */
4276	*puValue = 0;
4277	return VINF_SUCCESS;
4278	}
4279
4280
4281	/** @callback_method_impl{FNCPUMWRMSR} */
4282	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hIbsOpRip(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4283	{
4284	/** @todo AMD IBS. */
4285	if (!X86_IS_CANONICAL(uValue))
4286	{
4287	Log(("CPUM: wrmsr %s(%#x), %#llx -> #GP - not canonical\n", pRange->szName, idMsr, uValue));
4288	return VERR_CPUM_RAISE_GP_0;
4289	}
4290	return VINF_SUCCESS;
4291	}
4292
4293
4294	/** @callback_method_impl{FNCPUMRDMSR} */
4295	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hIbsOpData(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4296	{
4297	/** @todo AMD IBS. */
4298	*puValue = 0;
4299	return VINF_SUCCESS;
4300	}
4301
4302
4303	/** @callback_method_impl{FNCPUMWRMSR} */
4304	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hIbsOpData(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4305	{
4306	/** @todo AMD IBS. */
4307	return VINF_SUCCESS;
4308	}
4309
4310
4311	/** @callback_method_impl{FNCPUMRDMSR} */
4312	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hIbsOpData2(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4313	{
4314	/** @todo AMD IBS. */
4315	*puValue = 0;
4316	return VINF_SUCCESS;
4317	}
4318
4319
4320	/** @callback_method_impl{FNCPUMWRMSR} */
4321	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hIbsOpData2(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4322	{
4323	/** @todo AMD IBS. */
4324	return VINF_SUCCESS;
4325	}
4326
4327
4328	/** @callback_method_impl{FNCPUMRDMSR} */
4329	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hIbsOpData3(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4330	{
4331	/** @todo AMD IBS. */
4332	*puValue = 0;
4333	return VINF_SUCCESS;
4334	}
4335
4336
4337	/** @callback_method_impl{FNCPUMWRMSR} */
4338	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hIbsOpData3(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4339	{
4340	/** @todo AMD IBS. */
4341	return VINF_SUCCESS;
4342	}
4343
4344
4345	/** @callback_method_impl{FNCPUMRDMSR} */
4346	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hIbsDcLinAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4347	{
4348	/** @todo AMD IBS. */
4349	*puValue = 0;
4350	return VINF_SUCCESS;
4351	}
4352
4353
4354	/** @callback_method_impl{FNCPUMWRMSR} */
4355	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hIbsDcLinAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4356	{
4357	/** @todo AMD IBS. */
4358	if (!X86_IS_CANONICAL(uValue))
4359	{
4360	Log(("CPUM: wrmsr %s(%#x), %#llx -> #GP - not canonical\n", pRange->szName, idMsr, uValue));
4361	return VERR_CPUM_RAISE_GP_0;
4362	}
4363	return VINF_SUCCESS;
4364	}
4365
4366
4367	/** @callback_method_impl{FNCPUMRDMSR} */
4368	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hIbsDcPhysAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4369	{
4370	/** @todo AMD IBS. */
4371	*puValue = 0;
4372	return VINF_SUCCESS;
4373	}
4374
4375
4376	/** @callback_method_impl{FNCPUMWRMSR} */
4377	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hIbsDcPhysAddr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4378	{
4379	/** @todo AMD IBS. */
4380	return VINF_SUCCESS;
4381	}
4382
4383
4384	/** @callback_method_impl{FNCPUMRDMSR} */
4385	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam10hIbsCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4386	{
4387	/** @todo AMD IBS. */
4388	*puValue = 0;
4389	return VINF_SUCCESS;
4390	}
4391
4392
4393	/** @callback_method_impl{FNCPUMWRMSR} */
4394	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam10hIbsCtl(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4395	{
4396	/** @todo AMD IBS. */
4397	return VINF_SUCCESS;
4398	}
4399
4400
4401	/** @callback_method_impl{FNCPUMRDMSR} */
4402	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_AmdFam14hIbsBrTarget(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4403	{
4404	/** @todo AMD IBS. */
4405	*puValue = 0;
4406	return VINF_SUCCESS;
4407	}
4408
4409
4410	/** @callback_method_impl{FNCPUMWRMSR} */
4411	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_AmdFam14hIbsBrTarget(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4412	{
4413	/** @todo AMD IBS. */
4414	if (!X86_IS_CANONICAL(uValue))
4415	{
4416	Log(("CPUM: wrmsr %s(%#x), %#llx -> #GP - not canonical\n", pRange->szName, idMsr, uValue));
4417	return VERR_CPUM_RAISE_GP_0;
4418	}
4419	return VINF_SUCCESS;
4420	}
4421
4422
4423
4424	/*
4425	* GIM MSRs.
4426	* GIM MSRs.
4427	* GIM MSRs.
4428	*/
4429
4430
4431	/** @callback_method_impl{FNCPUMRDMSR} */
4432	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Gim(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
4433	{
4434	return GIMReadMsr(pVCpu, idMsr, pRange, puValue);
4435	}
4436
4437
4438	/** @callback_method_impl{FNCPUMWRMSR} */
4439	static DECLCALLBACK(VBOXSTRICTRC) cpumMsrWr_Gim(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
4440	{
4441	return GIMWriteMsr(pVCpu, idMsr, pRange, uValue, uRawValue);
4442	}
4443
4444
4445	/**
4446	* MSR read function table.
4447	*/
4448	static const PFNCPUMRDMSR g_aCpumRdMsrFns[kCpumMsrRdFn_End] =
4449	{
4450	NULL, /* Invalid */
4451	cpumMsrRd_FixedValue,
4452	NULL, /* Alias */
4453	cpumMsrRd_WriteOnly,
4454	cpumMsrRd_Ia32P5McAddr,
4455	cpumMsrRd_Ia32P5McType,
4456	cpumMsrRd_Ia32TimestampCounter,
4457	cpumMsrRd_Ia32PlatformId,
4458	cpumMsrRd_Ia32ApicBase,
4459	cpumMsrRd_Ia32FeatureControl,
4460	cpumMsrRd_Ia32BiosSignId,
4461	cpumMsrRd_Ia32SmmMonitorCtl,
4462	cpumMsrRd_Ia32PmcN,
4463	cpumMsrRd_Ia32MonitorFilterLineSize,
4464	cpumMsrRd_Ia32MPerf,
4465	cpumMsrRd_Ia32APerf,
4466	cpumMsrRd_Ia32MtrrCap,
4467	cpumMsrRd_Ia32MtrrPhysBaseN,
4468	cpumMsrRd_Ia32MtrrPhysMaskN,
4469	cpumMsrRd_Ia32MtrrFixed,
4470	cpumMsrRd_Ia32MtrrDefType,
4471	cpumMsrRd_Ia32Pat,
4472	cpumMsrRd_Ia32SysEnterCs,
4473	cpumMsrRd_Ia32SysEnterEsp,
4474	cpumMsrRd_Ia32SysEnterEip,
4475	cpumMsrRd_Ia32McgCap,
4476	cpumMsrRd_Ia32McgStatus,
4477	cpumMsrRd_Ia32McgCtl,
4478	cpumMsrRd_Ia32DebugCtl,
4479	cpumMsrRd_Ia32SmrrPhysBase,
4480	cpumMsrRd_Ia32SmrrPhysMask,
4481	cpumMsrRd_Ia32PlatformDcaCap,
4482	cpumMsrRd_Ia32CpuDcaCap,
4483	cpumMsrRd_Ia32Dca0Cap,
4484	cpumMsrRd_Ia32PerfEvtSelN,
4485	cpumMsrRd_Ia32PerfStatus,
4486	cpumMsrRd_Ia32PerfCtl,
4487	cpumMsrRd_Ia32FixedCtrN,
4488	cpumMsrRd_Ia32PerfCapabilities,
4489	cpumMsrRd_Ia32FixedCtrCtrl,
4490	cpumMsrRd_Ia32PerfGlobalStatus,
4491	cpumMsrRd_Ia32PerfGlobalCtrl,
4492	cpumMsrRd_Ia32PerfGlobalOvfCtrl,
4493	cpumMsrRd_Ia32PebsEnable,
4494	cpumMsrRd_Ia32ClockModulation,
4495	cpumMsrRd_Ia32ThermInterrupt,
4496	cpumMsrRd_Ia32ThermStatus,
4497	cpumMsrRd_Ia32Therm2Ctl,
4498	cpumMsrRd_Ia32MiscEnable,
4499	cpumMsrRd_Ia32McCtlStatusAddrMiscN,
4500	cpumMsrRd_Ia32McNCtl2,
4501	cpumMsrRd_Ia32DsArea,
4502	cpumMsrRd_Ia32TscDeadline,
4503	cpumMsrRd_Ia32X2ApicN,
4504	cpumMsrRd_Ia32DebugInterface,
4505	cpumMsrRd_Ia32VmxBase,
4506	cpumMsrRd_Ia32VmxPinbasedCtls,
4507	cpumMsrRd_Ia32VmxProcbasedCtls,
4508	cpumMsrRd_Ia32VmxExitCtls,
4509	cpumMsrRd_Ia32VmxEntryCtls,
4510	cpumMsrRd_Ia32VmxMisc,
4511	cpumMsrRd_Ia32VmxCr0Fixed0,
4512	cpumMsrRd_Ia32VmxCr0Fixed1,
4513	cpumMsrRd_Ia32VmxCr4Fixed0,
4514	cpumMsrRd_Ia32VmxCr4Fixed1,
4515	cpumMsrRd_Ia32VmxVmcsEnum,
4516	cpumMsrRd_Ia32VmxProcBasedCtls2,
4517	cpumMsrRd_Ia32VmxEptVpidCap,
4518	cpumMsrRd_Ia32VmxTruePinbasedCtls,
4519	cpumMsrRd_Ia32VmxTrueProcbasedCtls,
4520	cpumMsrRd_Ia32VmxTrueExitCtls,
4521	cpumMsrRd_Ia32VmxTrueEntryCtls,
4522	cpumMsrRd_Ia32VmxVmFunc,
4523
4524	cpumMsrRd_Amd64Efer,
4525	cpumMsrRd_Amd64SyscallTarget,
4526	cpumMsrRd_Amd64LongSyscallTarget,
4527	cpumMsrRd_Amd64CompSyscallTarget,
4528	cpumMsrRd_Amd64SyscallFlagMask,
4529	cpumMsrRd_Amd64FsBase,
4530	cpumMsrRd_Amd64GsBase,
4531	cpumMsrRd_Amd64KernelGsBase,
4532	cpumMsrRd_Amd64TscAux,
4533
4534	cpumMsrRd_IntelEblCrPowerOn,
4535	cpumMsrRd_IntelI7CoreThreadCount,
4536	cpumMsrRd_IntelP4EbcHardPowerOn,
4537	cpumMsrRd_IntelP4EbcSoftPowerOn,
4538	cpumMsrRd_IntelP4EbcFrequencyId,
4539	cpumMsrRd_IntelP6FsbFrequency,
4540	cpumMsrRd_IntelPlatformInfo,
4541	cpumMsrRd_IntelFlexRatio,
4542	cpumMsrRd_IntelPkgCStConfigControl,
4543	cpumMsrRd_IntelPmgIoCaptureBase,
4544	cpumMsrRd_IntelLastBranchFromToN,
4545	cpumMsrRd_IntelLastBranchFromN,
4546	cpumMsrRd_IntelLastBranchToN,
4547	cpumMsrRd_IntelLastBranchTos,
4548	cpumMsrRd_IntelBblCrCtl,
4549	cpumMsrRd_IntelBblCrCtl3,
4550	cpumMsrRd_IntelI7TemperatureTarget,
4551	cpumMsrRd_IntelI7MsrOffCoreResponseN,
4552	cpumMsrRd_IntelI7MiscPwrMgmt,
4553	cpumMsrRd_IntelP6CrN,
4554	cpumMsrRd_IntelCpuId1FeatureMaskEcdx,
4555	cpumMsrRd_IntelCpuId1FeatureMaskEax,
4556	cpumMsrRd_IntelCpuId80000001FeatureMaskEcdx,
4557	cpumMsrRd_IntelI7SandyAesNiCtl,
4558	cpumMsrRd_IntelI7TurboRatioLimit,
4559	cpumMsrRd_IntelI7LbrSelect,
4560	cpumMsrRd_IntelI7SandyErrorControl,
4561	cpumMsrRd_IntelI7VirtualLegacyWireCap,
4562	cpumMsrRd_IntelI7PowerCtl,
4563	cpumMsrRd_IntelI7SandyPebsNumAlt,
4564	cpumMsrRd_IntelI7PebsLdLat,
4565	cpumMsrRd_IntelI7PkgCnResidencyN,
4566	cpumMsrRd_IntelI7CoreCnResidencyN,
4567	cpumMsrRd_IntelI7SandyVrCurrentConfig,
4568	cpumMsrRd_IntelI7SandyVrMiscConfig,
4569	cpumMsrRd_IntelI7SandyRaplPowerUnit,
4570	cpumMsrRd_IntelI7SandyPkgCnIrtlN,
4571	cpumMsrRd_IntelI7SandyPkgC2Residency,
4572	cpumMsrRd_IntelI7RaplPkgPowerLimit,
4573	cpumMsrRd_IntelI7RaplPkgEnergyStatus,
4574	cpumMsrRd_IntelI7RaplPkgPerfStatus,
4575	cpumMsrRd_IntelI7RaplPkgPowerInfo,
4576	cpumMsrRd_IntelI7RaplDramPowerLimit,
4577	cpumMsrRd_IntelI7RaplDramEnergyStatus,
4578	cpumMsrRd_IntelI7RaplDramPerfStatus,
4579	cpumMsrRd_IntelI7RaplDramPowerInfo,
4580	cpumMsrRd_IntelI7RaplPp0PowerLimit,
4581	cpumMsrRd_IntelI7RaplPp0EnergyStatus,
4582	cpumMsrRd_IntelI7RaplPp0Policy,
4583	cpumMsrRd_IntelI7RaplPp0PerfStatus,
4584	cpumMsrRd_IntelI7RaplPp1PowerLimit,
4585	cpumMsrRd_IntelI7RaplPp1EnergyStatus,
4586	cpumMsrRd_IntelI7RaplPp1Policy,
4587	cpumMsrRd_IntelI7IvyConfigTdpNominal,
4588	cpumMsrRd_IntelI7IvyConfigTdpLevel1,
4589	cpumMsrRd_IntelI7IvyConfigTdpLevel2,
4590	cpumMsrRd_IntelI7IvyConfigTdpControl,
4591	cpumMsrRd_IntelI7IvyTurboActivationRatio,
4592	cpumMsrRd_IntelI7UncPerfGlobalCtrl,
4593	cpumMsrRd_IntelI7UncPerfGlobalStatus,
4594	cpumMsrRd_IntelI7UncPerfGlobalOvfCtrl,
4595	cpumMsrRd_IntelI7UncPerfFixedCtrCtrl,
4596	cpumMsrRd_IntelI7UncPerfFixedCtr,
4597	cpumMsrRd_IntelI7UncCBoxConfig,
4598	cpumMsrRd_IntelI7UncArbPerfCtrN,
4599	cpumMsrRd_IntelI7UncArbPerfEvtSelN,
4600	cpumMsrRd_IntelI7SmiCount,
4601	cpumMsrRd_IntelCore2EmttmCrTablesN,
4602	cpumMsrRd_IntelCore2SmmCStMiscInfo,
4603	cpumMsrRd_IntelCore1ExtConfig,
4604	cpumMsrRd_IntelCore1DtsCalControl,
4605	cpumMsrRd_IntelCore2PeciControl,
4606	cpumMsrRd_IntelAtSilvCoreC1Recidency,
4607
4608	cpumMsrRd_P6LastBranchFromIp,
4609	cpumMsrRd_P6LastBranchToIp,
4610	cpumMsrRd_P6LastIntFromIp,
4611	cpumMsrRd_P6LastIntToIp,
4612
4613	cpumMsrRd_AmdFam15hTscRate,
4614	cpumMsrRd_AmdFam15hLwpCfg,
4615	cpumMsrRd_AmdFam15hLwpCbAddr,
4616	cpumMsrRd_AmdFam10hMc4MiscN,
4617	cpumMsrRd_AmdK8PerfCtlN,
4618	cpumMsrRd_AmdK8PerfCtrN,
4619	cpumMsrRd_AmdK8SysCfg,
4620	cpumMsrRd_AmdK8HwCr,
4621	cpumMsrRd_AmdK8IorrBaseN,
4622	cpumMsrRd_AmdK8IorrMaskN,
4623	cpumMsrRd_AmdK8TopOfMemN,
4624	cpumMsrRd_AmdK8NbCfg1,
4625	cpumMsrRd_AmdK8McXcptRedir,
4626	cpumMsrRd_AmdK8CpuNameN,
4627	cpumMsrRd_AmdK8HwThermalCtrl,
4628	cpumMsrRd_AmdK8SwThermalCtrl,
4629	cpumMsrRd_AmdK8FidVidControl,
4630	cpumMsrRd_AmdK8FidVidStatus,
4631	cpumMsrRd_AmdK8McCtlMaskN,
4632	cpumMsrRd_AmdK8SmiOnIoTrapN,
4633	cpumMsrRd_AmdK8SmiOnIoTrapCtlSts,
4634	cpumMsrRd_AmdK8IntPendingMessage,
4635	cpumMsrRd_AmdK8SmiTriggerIoCycle,
4636	cpumMsrRd_AmdFam10hMmioCfgBaseAddr,
4637	cpumMsrRd_AmdFam10hTrapCtlMaybe,
4638	cpumMsrRd_AmdFam10hPStateCurLimit,
4639	cpumMsrRd_AmdFam10hPStateControl,
4640	cpumMsrRd_AmdFam10hPStateStatus,
4641	cpumMsrRd_AmdFam10hPStateN,
4642	cpumMsrRd_AmdFam10hCofVidControl,
4643	cpumMsrRd_AmdFam10hCofVidStatus,
4644	cpumMsrRd_AmdFam10hCStateIoBaseAddr,
4645	cpumMsrRd_AmdFam10hCpuWatchdogTimer,
4646	cpumMsrRd_AmdK8SmmBase,
4647	cpumMsrRd_AmdK8SmmAddr,
4648	cpumMsrRd_AmdK8SmmMask,
4649	cpumMsrRd_AmdK8VmCr,
4650	cpumMsrRd_AmdK8IgnNe,
4651	cpumMsrRd_AmdK8SmmCtl,
4652	cpumMsrRd_AmdK8VmHSavePa,
4653	cpumMsrRd_AmdFam10hVmLockKey,
4654	cpumMsrRd_AmdFam10hSmmLockKey,
4655	cpumMsrRd_AmdFam10hLocalSmiStatus,
4656	cpumMsrRd_AmdFam10hOsVisWrkIdLength,
4657	cpumMsrRd_AmdFam10hOsVisWrkStatus,
4658	cpumMsrRd_AmdFam16hL2IPerfCtlN,
4659	cpumMsrRd_AmdFam16hL2IPerfCtrN,
4660	cpumMsrRd_AmdFam15hNorthbridgePerfCtlN,
4661	cpumMsrRd_AmdFam15hNorthbridgePerfCtrN,
4662	cpumMsrRd_AmdK7MicrocodeCtl,
4663	cpumMsrRd_AmdK7ClusterIdMaybe,
4664	cpumMsrRd_AmdK8CpuIdCtlStd07hEbax,
4665	cpumMsrRd_AmdK8CpuIdCtlStd06hEcx,
4666	cpumMsrRd_AmdK8CpuIdCtlStd01hEdcx,
4667	cpumMsrRd_AmdK8CpuIdCtlExt01hEdcx,
4668	cpumMsrRd_AmdK8PatchLevel,
4669	cpumMsrRd_AmdK7DebugStatusMaybe,
4670	cpumMsrRd_AmdK7BHTraceBaseMaybe,
4671	cpumMsrRd_AmdK7BHTracePtrMaybe,
4672	cpumMsrRd_AmdK7BHTraceLimitMaybe,
4673	cpumMsrRd_AmdK7HardwareDebugToolCfgMaybe,
4674	cpumMsrRd_AmdK7FastFlushCountMaybe,
4675	cpumMsrRd_AmdK7NodeId,
4676	cpumMsrRd_AmdK7DrXAddrMaskN,
4677	cpumMsrRd_AmdK7Dr0DataMatchMaybe,
4678	cpumMsrRd_AmdK7Dr0DataMaskMaybe,
4679	cpumMsrRd_AmdK7LoadStoreCfg,
4680	cpumMsrRd_AmdK7InstrCacheCfg,
4681	cpumMsrRd_AmdK7DataCacheCfg,
4682	cpumMsrRd_AmdK7BusUnitCfg,
4683	cpumMsrRd_AmdK7DebugCtl2Maybe,
4684	cpumMsrRd_AmdFam15hFpuCfg,
4685	cpumMsrRd_AmdFam15hDecoderCfg,
4686	cpumMsrRd_AmdFam10hBusUnitCfg2,
4687	cpumMsrRd_AmdFam15hCombUnitCfg,
4688	cpumMsrRd_AmdFam15hCombUnitCfg2,
4689	cpumMsrRd_AmdFam15hCombUnitCfg3,
4690	cpumMsrRd_AmdFam15hExecUnitCfg,
4691	cpumMsrRd_AmdFam15hLoadStoreCfg2,
4692	cpumMsrRd_AmdFam10hIbsFetchCtl,
4693	cpumMsrRd_AmdFam10hIbsFetchLinAddr,
4694	cpumMsrRd_AmdFam10hIbsFetchPhysAddr,
4695	cpumMsrRd_AmdFam10hIbsOpExecCtl,
4696	cpumMsrRd_AmdFam10hIbsOpRip,
4697	cpumMsrRd_AmdFam10hIbsOpData,
4698	cpumMsrRd_AmdFam10hIbsOpData2,
4699	cpumMsrRd_AmdFam10hIbsOpData3,
4700	cpumMsrRd_AmdFam10hIbsDcLinAddr,
4701	cpumMsrRd_AmdFam10hIbsDcPhysAddr,
4702	cpumMsrRd_AmdFam10hIbsCtl,
4703	cpumMsrRd_AmdFam14hIbsBrTarget,
4704
4705	cpumMsrRd_Gim
4706	};
4707
4708
4709	/**
4710	* MSR write function table.
4711	*/
4712	static const PFNCPUMWRMSR g_aCpumWrMsrFns[kCpumMsrWrFn_End] =
4713	{
4714	NULL, /* Invalid */
4715	cpumMsrWr_IgnoreWrite,
4716	cpumMsrWr_ReadOnly,
4717	NULL, /* Alias */
4718	cpumMsrWr_Ia32P5McAddr,
4719	cpumMsrWr_Ia32P5McType,
4720	cpumMsrWr_Ia32TimestampCounter,
4721	cpumMsrWr_Ia32ApicBase,
4722	cpumMsrWr_Ia32FeatureControl,
4723	cpumMsrWr_Ia32BiosSignId,
4724	cpumMsrWr_Ia32BiosUpdateTrigger,
4725	cpumMsrWr_Ia32SmmMonitorCtl,
4726	cpumMsrWr_Ia32PmcN,
4727	cpumMsrWr_Ia32MonitorFilterLineSize,
4728	cpumMsrWr_Ia32MPerf,
4729	cpumMsrWr_Ia32APerf,
4730	cpumMsrWr_Ia32MtrrPhysBaseN,
4731	cpumMsrWr_Ia32MtrrPhysMaskN,
4732	cpumMsrWr_Ia32MtrrFixed,
4733	cpumMsrWr_Ia32MtrrDefType,
4734	cpumMsrWr_Ia32Pat,
4735	cpumMsrWr_Ia32SysEnterCs,
4736	cpumMsrWr_Ia32SysEnterEsp,
4737	cpumMsrWr_Ia32SysEnterEip,
4738	cpumMsrWr_Ia32McgStatus,
4739	cpumMsrWr_Ia32McgCtl,
4740	cpumMsrWr_Ia32DebugCtl,
4741	cpumMsrWr_Ia32SmrrPhysBase,
4742	cpumMsrWr_Ia32SmrrPhysMask,
4743	cpumMsrWr_Ia32PlatformDcaCap,
4744	cpumMsrWr_Ia32Dca0Cap,
4745	cpumMsrWr_Ia32PerfEvtSelN,
4746	cpumMsrWr_Ia32PerfStatus,
4747	cpumMsrWr_Ia32PerfCtl,
4748	cpumMsrWr_Ia32FixedCtrN,
4749	cpumMsrWr_Ia32PerfCapabilities,
4750	cpumMsrWr_Ia32FixedCtrCtrl,
4751	cpumMsrWr_Ia32PerfGlobalStatus,
4752	cpumMsrWr_Ia32PerfGlobalCtrl,
4753	cpumMsrWr_Ia32PerfGlobalOvfCtrl,
4754	cpumMsrWr_Ia32PebsEnable,
4755	cpumMsrWr_Ia32ClockModulation,
4756	cpumMsrWr_Ia32ThermInterrupt,
4757	cpumMsrWr_Ia32ThermStatus,
4758	cpumMsrWr_Ia32Therm2Ctl,
4759	cpumMsrWr_Ia32MiscEnable,
4760	cpumMsrWr_Ia32McCtlStatusAddrMiscN,
4761	cpumMsrWr_Ia32McNCtl2,
4762	cpumMsrWr_Ia32DsArea,
4763	cpumMsrWr_Ia32TscDeadline,
4764	cpumMsrWr_Ia32X2ApicN,
4765	cpumMsrWr_Ia32DebugInterface,
4766
4767	cpumMsrWr_Amd64Efer,
4768	cpumMsrWr_Amd64SyscallTarget,
4769	cpumMsrWr_Amd64LongSyscallTarget,
4770	cpumMsrWr_Amd64CompSyscallTarget,
4771	cpumMsrWr_Amd64SyscallFlagMask,
4772	cpumMsrWr_Amd64FsBase,
4773	cpumMsrWr_Amd64GsBase,
4774	cpumMsrWr_Amd64KernelGsBase,
4775	cpumMsrWr_Amd64TscAux,
4776
4777	cpumMsrWr_IntelEblCrPowerOn,
4778	cpumMsrWr_IntelP4EbcHardPowerOn,
4779	cpumMsrWr_IntelP4EbcSoftPowerOn,
4780	cpumMsrWr_IntelP4EbcFrequencyId,
4781	cpumMsrWr_IntelFlexRatio,
4782	cpumMsrWr_IntelPkgCStConfigControl,
4783	cpumMsrWr_IntelPmgIoCaptureBase,
4784	cpumMsrWr_IntelLastBranchFromToN,
4785	cpumMsrWr_IntelLastBranchFromN,
4786	cpumMsrWr_IntelLastBranchToN,
4787	cpumMsrWr_IntelLastBranchTos,
4788	cpumMsrWr_IntelBblCrCtl,
4789	cpumMsrWr_IntelBblCrCtl3,
4790	cpumMsrWr_IntelI7TemperatureTarget,
4791	cpumMsrWr_IntelI7MsrOffCoreResponseN,
4792	cpumMsrWr_IntelI7MiscPwrMgmt,
4793	cpumMsrWr_IntelP6CrN,
4794	cpumMsrWr_IntelCpuId1FeatureMaskEcdx,
4795	cpumMsrWr_IntelCpuId1FeatureMaskEax,
4796	cpumMsrWr_IntelCpuId80000001FeatureMaskEcdx,
4797	cpumMsrWr_IntelI7SandyAesNiCtl,
4798	cpumMsrWr_IntelI7TurboRatioLimit,
4799	cpumMsrWr_IntelI7LbrSelect,
4800	cpumMsrWr_IntelI7SandyErrorControl,
4801	cpumMsrWr_IntelI7PowerCtl,
4802	cpumMsrWr_IntelI7SandyPebsNumAlt,
4803	cpumMsrWr_IntelI7PebsLdLat,
4804	cpumMsrWr_IntelI7SandyVrCurrentConfig,
4805	cpumMsrWr_IntelI7SandyVrMiscConfig,
4806	cpumMsrWr_IntelI7SandyRaplPowerUnit,
4807	cpumMsrWr_IntelI7SandyPkgCnIrtlN,
4808	cpumMsrWr_IntelI7SandyPkgC2Residency,
4809	cpumMsrWr_IntelI7RaplPkgPowerLimit,
4810	cpumMsrWr_IntelI7RaplDramPowerLimit,
4811	cpumMsrWr_IntelI7RaplPp0PowerLimit,
4812	cpumMsrWr_IntelI7RaplPp0Policy,
4813	cpumMsrWr_IntelI7RaplPp1PowerLimit,
4814	cpumMsrWr_IntelI7RaplPp1Policy,
4815	cpumMsrWr_IntelI7IvyConfigTdpControl,
4816	cpumMsrWr_IntelI7IvyTurboActivationRatio,
4817	cpumMsrWr_IntelI7UncPerfGlobalCtrl,
4818	cpumMsrWr_IntelI7UncPerfGlobalStatus,
4819	cpumMsrWr_IntelI7UncPerfGlobalOvfCtrl,
4820	cpumMsrWr_IntelI7UncPerfFixedCtrCtrl,
4821	cpumMsrWr_IntelI7UncPerfFixedCtr,
4822	cpumMsrWr_IntelI7UncArbPerfCtrN,
4823	cpumMsrWr_IntelI7UncArbPerfEvtSelN,
4824	cpumMsrWr_IntelCore2EmttmCrTablesN,
4825	cpumMsrWr_IntelCore2SmmCStMiscInfo,
4826	cpumMsrWr_IntelCore1ExtConfig,
4827	cpumMsrWr_IntelCore1DtsCalControl,
4828	cpumMsrWr_IntelCore2PeciControl,
4829
4830	cpumMsrWr_P6LastIntFromIp,
4831	cpumMsrWr_P6LastIntToIp,
4832
4833	cpumMsrWr_AmdFam15hTscRate,
4834	cpumMsrWr_AmdFam15hLwpCfg,
4835	cpumMsrWr_AmdFam15hLwpCbAddr,
4836	cpumMsrWr_AmdFam10hMc4MiscN,
4837	cpumMsrWr_AmdK8PerfCtlN,
4838	cpumMsrWr_AmdK8PerfCtrN,
4839	cpumMsrWr_AmdK8SysCfg,
4840	cpumMsrWr_AmdK8HwCr,
4841	cpumMsrWr_AmdK8IorrBaseN,
4842	cpumMsrWr_AmdK8IorrMaskN,
4843	cpumMsrWr_AmdK8TopOfMemN,
4844	cpumMsrWr_AmdK8NbCfg1,
4845	cpumMsrWr_AmdK8McXcptRedir,
4846	cpumMsrWr_AmdK8CpuNameN,
4847	cpumMsrWr_AmdK8HwThermalCtrl,
4848	cpumMsrWr_AmdK8SwThermalCtrl,
4849	cpumMsrWr_AmdK8FidVidControl,
4850	cpumMsrWr_AmdK8McCtlMaskN,
4851	cpumMsrWr_AmdK8SmiOnIoTrapN,
4852	cpumMsrWr_AmdK8SmiOnIoTrapCtlSts,
4853	cpumMsrWr_AmdK8IntPendingMessage,
4854	cpumMsrWr_AmdK8SmiTriggerIoCycle,
4855	cpumMsrWr_AmdFam10hMmioCfgBaseAddr,
4856	cpumMsrWr_AmdFam10hTrapCtlMaybe,
4857	cpumMsrWr_AmdFam10hPStateControl,
4858	cpumMsrWr_AmdFam10hPStateStatus,
4859	cpumMsrWr_AmdFam10hPStateN,
4860	cpumMsrWr_AmdFam10hCofVidControl,
4861	cpumMsrWr_AmdFam10hCofVidStatus,
4862	cpumMsrWr_AmdFam10hCStateIoBaseAddr,
4863	cpumMsrWr_AmdFam10hCpuWatchdogTimer,
4864	cpumMsrWr_AmdK8SmmBase,
4865	cpumMsrWr_AmdK8SmmAddr,
4866	cpumMsrWr_AmdK8SmmMask,
4867	cpumMsrWr_AmdK8VmCr,
4868	cpumMsrWr_AmdK8IgnNe,
4869	cpumMsrWr_AmdK8SmmCtl,
4870	cpumMsrWr_AmdK8VmHSavePa,
4871	cpumMsrWr_AmdFam10hVmLockKey,
4872	cpumMsrWr_AmdFam10hSmmLockKey,
4873	cpumMsrWr_AmdFam10hLocalSmiStatus,
4874	cpumMsrWr_AmdFam10hOsVisWrkIdLength,
4875	cpumMsrWr_AmdFam10hOsVisWrkStatus,
4876	cpumMsrWr_AmdFam16hL2IPerfCtlN,
4877	cpumMsrWr_AmdFam16hL2IPerfCtrN,
4878	cpumMsrWr_AmdFam15hNorthbridgePerfCtlN,
4879	cpumMsrWr_AmdFam15hNorthbridgePerfCtrN,
4880	cpumMsrWr_AmdK7MicrocodeCtl,
4881	cpumMsrWr_AmdK7ClusterIdMaybe,
4882	cpumMsrWr_AmdK8CpuIdCtlStd07hEbax,
4883	cpumMsrWr_AmdK8CpuIdCtlStd06hEcx,
4884	cpumMsrWr_AmdK8CpuIdCtlStd01hEdcx,
4885	cpumMsrWr_AmdK8CpuIdCtlExt01hEdcx,
4886	cpumMsrWr_AmdK8PatchLoader,
4887	cpumMsrWr_AmdK7DebugStatusMaybe,
4888	cpumMsrWr_AmdK7BHTraceBaseMaybe,
4889	cpumMsrWr_AmdK7BHTracePtrMaybe,
4890	cpumMsrWr_AmdK7BHTraceLimitMaybe,
4891	cpumMsrWr_AmdK7HardwareDebugToolCfgMaybe,
4892	cpumMsrWr_AmdK7FastFlushCountMaybe,
4893	cpumMsrWr_AmdK7NodeId,
4894	cpumMsrWr_AmdK7DrXAddrMaskN,
4895	cpumMsrWr_AmdK7Dr0DataMatchMaybe,
4896	cpumMsrWr_AmdK7Dr0DataMaskMaybe,
4897	cpumMsrWr_AmdK7LoadStoreCfg,
4898	cpumMsrWr_AmdK7InstrCacheCfg,
4899	cpumMsrWr_AmdK7DataCacheCfg,
4900	cpumMsrWr_AmdK7BusUnitCfg,
4901	cpumMsrWr_AmdK7DebugCtl2Maybe,
4902	cpumMsrWr_AmdFam15hFpuCfg,
4903	cpumMsrWr_AmdFam15hDecoderCfg,
4904	cpumMsrWr_AmdFam10hBusUnitCfg2,
4905	cpumMsrWr_AmdFam15hCombUnitCfg,
4906	cpumMsrWr_AmdFam15hCombUnitCfg2,
4907	cpumMsrWr_AmdFam15hCombUnitCfg3,
4908	cpumMsrWr_AmdFam15hExecUnitCfg,
4909	cpumMsrWr_AmdFam15hLoadStoreCfg2,
4910	cpumMsrWr_AmdFam10hIbsFetchCtl,
4911	cpumMsrWr_AmdFam10hIbsFetchLinAddr,
4912	cpumMsrWr_AmdFam10hIbsFetchPhysAddr,
4913	cpumMsrWr_AmdFam10hIbsOpExecCtl,
4914	cpumMsrWr_AmdFam10hIbsOpRip,
4915	cpumMsrWr_AmdFam10hIbsOpData,
4916	cpumMsrWr_AmdFam10hIbsOpData2,
4917	cpumMsrWr_AmdFam10hIbsOpData3,
4918	cpumMsrWr_AmdFam10hIbsDcLinAddr,
4919	cpumMsrWr_AmdFam10hIbsDcPhysAddr,
4920	cpumMsrWr_AmdFam10hIbsCtl,
4921	cpumMsrWr_AmdFam14hIbsBrTarget,
4922
4923	cpumMsrWr_Gim
4924	};
4925
4926
4927	/**
4928	* Looks up the range for the given MSR.
4929	*
4930	* @returns Pointer to the range if found, NULL if not.
4931	* @param pVM The cross context VM structure.
4932	* @param idMsr The MSR to look up.
4933	*/
4934	# ifndef IN_RING3
4935	static
4936	# endif
4937	PCPUMMSRRANGE cpumLookupMsrRange(PVM pVM, uint32_t idMsr)
4938	{
4939	/*
4940	* Binary lookup.
4941	*/
4942	uint32_t cRanges = pVM->cpum.s.GuestInfo.cMsrRanges;
4943	if (!cRanges)
4944	return NULL;
4945	PCPUMMSRRANGE paRanges = pVM->cpum.s.GuestInfo.CTX_SUFF(paMsrRanges);
4946	for (;;)
4947	{
4948	uint32_t i = cRanges / 2;
4949	if (idMsr < paRanges[i].uFirst)
4950	{
4951	if (i == 0)
4952	break;
4953	cRanges = i;
4954	}
4955	else if (idMsr > paRanges[i].uLast)
4956	{
4957	i++;
4958	if (i >= cRanges)
4959	break;
4960	cRanges -= i;
4961	paRanges = &paRanges[i];
4962	}
4963	else
4964	{
4965	if (paRanges[i].enmRdFn == kCpumMsrRdFn_MsrAlias)
4966	return cpumLookupMsrRange(pVM, paRanges[i].uValue);
4967	return &paRanges[i];
4968	}
4969	}
4970
4971	# ifdef VBOX_STRICT
4972	/*
4973	* Linear lookup to verify the above binary search.
4974	*/
4975	uint32_t cLeft = pVM->cpum.s.GuestInfo.cMsrRanges;
4976	PCPUMMSRRANGE pCur = pVM->cpum.s.GuestInfo.CTX_SUFF(paMsrRanges);
4977	while (cLeft-- > 0)
4978	{
4979	if (idMsr >= pCur->uFirst && idMsr <= pCur->uLast)
4980	{
4981	AssertFailed();
4982	if (pCur->enmRdFn == kCpumMsrRdFn_MsrAlias)
4983	return cpumLookupMsrRange(pVM, pCur->uValue);
4984	return pCur;
4985	}
4986	pCur++;
4987	}
4988	# endif
4989	return NULL;
4990	}
4991
4992
4993	/**
4994	* Query a guest MSR.
4995	*
4996	* The caller is responsible for checking privilege if the call is the result of
4997	* a RDMSR instruction. We'll do the rest.
4998	*
4999	* @retval VINF_SUCCESS on success.
5000	* @retval VINF_CPUM_R3_MSR_READ if the MSR read could not be serviced in the
5001	* current context (raw-mode or ring-0).
5002	* @retval VERR_CPUM_RAISE_GP_0 on failure (invalid MSR), the caller is
5003	* expected to take the appropriate actions. @a *puValue is set to 0.
5004	* @param pVCpu The cross context virtual CPU structure.
5005	* @param idMsr The MSR.
5006	* @param puValue Where to return the value.
5007	*
5008	* @remarks This will always return the right values, even when we're in the
5009	* recompiler.
5010	*/
5011	VMMDECL(VBOXSTRICTRC) CPUMQueryGuestMsr(PVMCPU pVCpu, uint32_t idMsr, uint64_t *puValue)
5012	{
5013	*puValue = 0;
5014
5015	VBOXSTRICTRC rcStrict;
5016	PVM pVM = pVCpu->CTX_SUFF(pVM);
5017	PCPUMMSRRANGE pRange = cpumLookupMsrRange(pVM, idMsr);
5018	if (pRange)
5019	{
5020	CPUMMSRRDFN enmRdFn = (CPUMMSRRDFN)pRange->enmRdFn;
5021	AssertReturn(enmRdFn > kCpumMsrRdFn_Invalid && enmRdFn < kCpumMsrRdFn_End, VERR_CPUM_IPE_1);
5022
5023	PFNCPUMRDMSR pfnRdMsr = g_aCpumRdMsrFns[enmRdFn];
5024	AssertReturn(pfnRdMsr, VERR_CPUM_IPE_2);
5025
5026	STAM_COUNTER_INC(&pRange->cReads);
5027	STAM_REL_COUNTER_INC(&pVM->cpum.s.cMsrReads);
5028
5029	rcStrict = pfnRdMsr(pVCpu, idMsr, pRange, puValue);
5030	if (rcStrict == VINF_SUCCESS)
5031	Log2(("CPUM: RDMSR %#x (%s) -> %#llx\n", idMsr, pRange->szName, *puValue));
5032	else if (rcStrict == VERR_CPUM_RAISE_GP_0)
5033	{
5034	Log(("CPUM: RDMSR %#x (%s) -> #GP(0)\n", idMsr, pRange->szName));
5035	STAM_COUNTER_INC(&pRange->cGps);
5036	STAM_REL_COUNTER_INC(&pVM->cpum.s.cMsrReadsRaiseGp);
5037	}
5038	#ifndef IN_RING3
5039	else if (rcStrict == VINF_CPUM_R3_MSR_READ)
5040	Log(("CPUM: RDMSR %#x (%s) -> ring-3\n", idMsr, pRange->szName));
5041	#endif
5042	else
5043	{
5044	Log(("CPUM: RDMSR %#x (%s) -> rcStrict=%Rrc\n", idMsr, pRange->szName, VBOXSTRICTRC_VAL(rcStrict)));
5045	AssertMsgStmt(RT_FAILURE_NP(rcStrict), ("%Rrc idMsr=%#x\n", VBOXSTRICTRC_VAL(rcStrict), idMsr),
5046	rcStrict = VERR_IPE_UNEXPECTED_INFO_STATUS);
5047	Assert(rcStrict != VERR_EM_INTERPRETER);
5048	}
5049	}
5050	else
5051	{
5052	Log(("CPUM: Unknown RDMSR %#x -> #GP(0)\n", idMsr));
5053	STAM_REL_COUNTER_INC(&pVM->cpum.s.cMsrReads);
5054	STAM_REL_COUNTER_INC(&pVM->cpum.s.cMsrReadsUnknown);
5055	rcStrict = VERR_CPUM_RAISE_GP_0;
5056	}
5057	return rcStrict;
5058	}
5059
5060
5061	/**
5062	* Writes to a guest MSR.
5063	*
5064	* The caller is responsible for checking privilege if the call is the result of
5065	* a WRMSR instruction. We'll do the rest.
5066	*
5067	* @retval VINF_SUCCESS on success.
5068	* @retval VINF_CPUM_R3_MSR_WRITE if the MSR write could not be serviced in the
5069	* current context (raw-mode or ring-0).
5070	* @retval VERR_CPUM_RAISE_GP_0 on failure, the caller is expected to take the
5071	* appropriate actions.
5072	*
5073	* @param pVCpu The cross context virtual CPU structure.
5074	* @param idMsr The MSR id.
5075	* @param uValue The value to set.
5076	*
5077	* @remarks Everyone changing MSR values, including the recompiler, shall do it
5078	* by calling this method. This makes sure we have current values and
5079	* that we trigger all the right actions when something changes.
5080	*
5081	* For performance reasons, this actually isn't entirely true for some
5082	* MSRs when in HM mode. The code here and in HM must be aware of
5083	* this.
5084	*/
5085	VMMDECL(VBOXSTRICTRC) CPUMSetGuestMsr(PVMCPU pVCpu, uint32_t idMsr, uint64_t uValue)
5086	{
5087	VBOXSTRICTRC rcStrict;
5088	PVM pVM = pVCpu->CTX_SUFF(pVM);
5089	PCPUMMSRRANGE pRange = cpumLookupMsrRange(pVM, idMsr);
5090	if (pRange)
5091	{
5092	STAM_COUNTER_INC(&pRange->cWrites);
5093	STAM_REL_COUNTER_INC(&pVM->cpum.s.cMsrWrites);
5094
5095	if (!(uValue & pRange->fWrGpMask))
5096	{
5097	CPUMMSRWRFN enmWrFn = (CPUMMSRWRFN)pRange->enmWrFn;
5098	AssertReturn(enmWrFn > kCpumMsrWrFn_Invalid && enmWrFn < kCpumMsrWrFn_End, VERR_CPUM_IPE_1);
5099
5100	PFNCPUMWRMSR pfnWrMsr = g_aCpumWrMsrFns[enmWrFn];
5101	AssertReturn(pfnWrMsr, VERR_CPUM_IPE_2);
5102
5103	uint64_t uValueAdjusted = uValue & ~pRange->fWrIgnMask;
5104	if (uValueAdjusted != uValue)
5105	{
5106	STAM_COUNTER_INC(&pRange->cIgnoredBits);
5107	STAM_REL_COUNTER_INC(&pVM->cpum.s.cMsrWritesToIgnoredBits);
5108	}
5109
5110	rcStrict = pfnWrMsr(pVCpu, idMsr, pRange, uValueAdjusted, uValue);
5111	if (rcStrict == VINF_SUCCESS)
5112	Log2(("CPUM: WRMSR %#x (%s), %#llx [%#llx]\n", idMsr, pRange->szName, uValueAdjusted, uValue));
5113	else if (rcStrict == VERR_CPUM_RAISE_GP_0)
5114	{
5115	Log(("CPUM: WRMSR %#x (%s), %#llx [%#llx] -> #GP(0)\n", idMsr, pRange->szName, uValueAdjusted, uValue));
5116	STAM_COUNTER_INC(&pRange->cGps);
5117	STAM_REL_COUNTER_INC(&pVM->cpum.s.cMsrWritesRaiseGp);
5118	}
5119	#ifndef IN_RING3
5120	else if (rcStrict == VINF_CPUM_R3_MSR_WRITE)
5121	Log(("CPUM: WRMSR %#x (%s), %#llx [%#llx] -> ring-3\n", idMsr, pRange->szName, uValueAdjusted, uValue));
5122	#endif
5123	else
5124	{
5125	Log(("CPUM: WRMSR %#x (%s), %#llx [%#llx] -> rcStrict=%Rrc\n",
5126	idMsr, pRange->szName, uValueAdjusted, uValue, VBOXSTRICTRC_VAL(rcStrict)));
5127	AssertMsgStmt(RT_FAILURE_NP(rcStrict), ("%Rrc idMsr=%#x\n", VBOXSTRICTRC_VAL(rcStrict), idMsr),
5128	rcStrict = VERR_IPE_UNEXPECTED_INFO_STATUS);
5129	Assert(rcStrict != VERR_EM_INTERPRETER);
5130	}
5131	}
5132	else
5133	{
5134	Log(("CPUM: WRMSR %#x (%s), %#llx -> #GP(0) - invalid bits %#llx\n",
5135	idMsr, pRange->szName, uValue, uValue & pRange->fWrGpMask));
5136	STAM_COUNTER_INC(&pRange->cGps);
5137	STAM_REL_COUNTER_INC(&pVM->cpum.s.cMsrWritesRaiseGp);
5138	rcStrict = VERR_CPUM_RAISE_GP_0;
5139	}
5140	}
5141	else
5142	{
5143	Log(("CPUM: Unknown WRMSR %#x, %#llx -> #GP(0)\n", idMsr, uValue));
5144	STAM_REL_COUNTER_INC(&pVM->cpum.s.cMsrWrites);
5145	STAM_REL_COUNTER_INC(&pVM->cpum.s.cMsrWritesUnknown);
5146	rcStrict = VERR_CPUM_RAISE_GP_0;
5147	}
5148	return rcStrict;
5149	}
5150
5151
5152	#if defined(VBOX_STRICT) && defined(IN_RING3)
5153	/**
5154	* Performs some checks on the static data related to MSRs.
5155	*
5156	* @returns VINF_SUCCESS on success, error on failure.
5157	*/
5158	int cpumR3MsrStrictInitChecks(void)
5159	{
5160	#define CPUM_ASSERT_RD_MSR_FN(a_Register) \
5161	AssertReturn(g_aCpumRdMsrFns[kCpumMsrRdFn_##a_Register] == cpumMsrRd_##a_Register, VERR_CPUM_IPE_2);
5162	#define CPUM_ASSERT_WR_MSR_FN(a_Register) \
5163	AssertReturn(g_aCpumWrMsrFns[kCpumMsrWrFn_##a_Register] == cpumMsrWr_##a_Register, VERR_CPUM_IPE_2);
5164
5165	AssertReturn(g_aCpumRdMsrFns[kCpumMsrRdFn_Invalid] == NULL, VERR_CPUM_IPE_2);
5166	CPUM_ASSERT_RD_MSR_FN(FixedValue);
5167	CPUM_ASSERT_RD_MSR_FN(WriteOnly);
5168	CPUM_ASSERT_RD_MSR_FN(Ia32P5McAddr);
5169	CPUM_ASSERT_RD_MSR_FN(Ia32P5McType);
5170	CPUM_ASSERT_RD_MSR_FN(Ia32TimestampCounter);
5171	CPUM_ASSERT_RD_MSR_FN(Ia32PlatformId);
5172	CPUM_ASSERT_RD_MSR_FN(Ia32ApicBase);
5173	CPUM_ASSERT_RD_MSR_FN(Ia32FeatureControl);
5174	CPUM_ASSERT_RD_MSR_FN(Ia32BiosSignId);
5175	CPUM_ASSERT_RD_MSR_FN(Ia32SmmMonitorCtl);
5176	CPUM_ASSERT_RD_MSR_FN(Ia32PmcN);
5177	CPUM_ASSERT_RD_MSR_FN(Ia32MonitorFilterLineSize);
5178	CPUM_ASSERT_RD_MSR_FN(Ia32MPerf);
5179	CPUM_ASSERT_RD_MSR_FN(Ia32APerf);
5180	CPUM_ASSERT_RD_MSR_FN(Ia32MtrrCap);
5181	CPUM_ASSERT_RD_MSR_FN(Ia32MtrrPhysBaseN);
5182	CPUM_ASSERT_RD_MSR_FN(Ia32MtrrPhysMaskN);
5183	CPUM_ASSERT_RD_MSR_FN(Ia32MtrrFixed);
5184	CPUM_ASSERT_RD_MSR_FN(Ia32MtrrDefType);
5185	CPUM_ASSERT_RD_MSR_FN(Ia32Pat);
5186	CPUM_ASSERT_RD_MSR_FN(Ia32SysEnterCs);
5187	CPUM_ASSERT_RD_MSR_FN(Ia32SysEnterEsp);
5188	CPUM_ASSERT_RD_MSR_FN(Ia32SysEnterEip);
5189	CPUM_ASSERT_RD_MSR_FN(Ia32McgCap);
5190	CPUM_ASSERT_RD_MSR_FN(Ia32McgStatus);
5191	CPUM_ASSERT_RD_MSR_FN(Ia32McgCtl);
5192	CPUM_ASSERT_RD_MSR_FN(Ia32DebugCtl);
5193	CPUM_ASSERT_RD_MSR_FN(Ia32SmrrPhysBase);
5194	CPUM_ASSERT_RD_MSR_FN(Ia32SmrrPhysMask);
5195	CPUM_ASSERT_RD_MSR_FN(Ia32PlatformDcaCap);
5196	CPUM_ASSERT_RD_MSR_FN(Ia32CpuDcaCap);
5197	CPUM_ASSERT_RD_MSR_FN(Ia32Dca0Cap);
5198	CPUM_ASSERT_RD_MSR_FN(Ia32PerfEvtSelN);
5199	CPUM_ASSERT_RD_MSR_FN(Ia32PerfStatus);
5200	CPUM_ASSERT_RD_MSR_FN(Ia32PerfCtl);
5201	CPUM_ASSERT_RD_MSR_FN(Ia32FixedCtrN);
5202	CPUM_ASSERT_RD_MSR_FN(Ia32PerfCapabilities);
5203	CPUM_ASSERT_RD_MSR_FN(Ia32FixedCtrCtrl);
5204	CPUM_ASSERT_RD_MSR_FN(Ia32PerfGlobalStatus);
5205	CPUM_ASSERT_RD_MSR_FN(Ia32PerfGlobalCtrl);
5206	CPUM_ASSERT_RD_MSR_FN(Ia32PerfGlobalOvfCtrl);
5207	CPUM_ASSERT_RD_MSR_FN(Ia32PebsEnable);
5208	CPUM_ASSERT_RD_MSR_FN(Ia32ClockModulation);
5209	CPUM_ASSERT_RD_MSR_FN(Ia32ThermInterrupt);
5210	CPUM_ASSERT_RD_MSR_FN(Ia32ThermStatus);
5211	CPUM_ASSERT_RD_MSR_FN(Ia32MiscEnable);
5212	CPUM_ASSERT_RD_MSR_FN(Ia32McCtlStatusAddrMiscN);
5213	CPUM_ASSERT_RD_MSR_FN(Ia32McNCtl2);
5214	CPUM_ASSERT_RD_MSR_FN(Ia32DsArea);
5215	CPUM_ASSERT_RD_MSR_FN(Ia32TscDeadline);
5216	CPUM_ASSERT_RD_MSR_FN(Ia32X2ApicN);
5217	CPUM_ASSERT_RD_MSR_FN(Ia32DebugInterface);
5218	CPUM_ASSERT_RD_MSR_FN(Ia32VmxBase);
5219	CPUM_ASSERT_RD_MSR_FN(Ia32VmxPinbasedCtls);
5220	CPUM_ASSERT_RD_MSR_FN(Ia32VmxProcbasedCtls);
5221	CPUM_ASSERT_RD_MSR_FN(Ia32VmxExitCtls);
5222	CPUM_ASSERT_RD_MSR_FN(Ia32VmxEntryCtls);
5223	CPUM_ASSERT_RD_MSR_FN(Ia32VmxMisc);
5224	CPUM_ASSERT_RD_MSR_FN(Ia32VmxCr0Fixed0);
5225	CPUM_ASSERT_RD_MSR_FN(Ia32VmxCr0Fixed1);
5226	CPUM_ASSERT_RD_MSR_FN(Ia32VmxCr4Fixed0);
5227	CPUM_ASSERT_RD_MSR_FN(Ia32VmxCr4Fixed1);
5228	CPUM_ASSERT_RD_MSR_FN(Ia32VmxVmcsEnum);
5229	CPUM_ASSERT_RD_MSR_FN(Ia32VmxProcBasedCtls2);
5230	CPUM_ASSERT_RD_MSR_FN(Ia32VmxEptVpidCap);
5231	CPUM_ASSERT_RD_MSR_FN(Ia32VmxTruePinbasedCtls);
5232	CPUM_ASSERT_RD_MSR_FN(Ia32VmxTrueProcbasedCtls);
5233	CPUM_ASSERT_RD_MSR_FN(Ia32VmxTrueExitCtls);
5234	CPUM_ASSERT_RD_MSR_FN(Ia32VmxTrueEntryCtls);
5235	CPUM_ASSERT_RD_MSR_FN(Ia32VmxVmFunc);
5236
5237	CPUM_ASSERT_RD_MSR_FN(Amd64Efer);
5238	CPUM_ASSERT_RD_MSR_FN(Amd64SyscallTarget);
5239	CPUM_ASSERT_RD_MSR_FN(Amd64LongSyscallTarget);
5240	CPUM_ASSERT_RD_MSR_FN(Amd64CompSyscallTarget);
5241	CPUM_ASSERT_RD_MSR_FN(Amd64SyscallFlagMask);
5242	CPUM_ASSERT_RD_MSR_FN(Amd64FsBase);
5243	CPUM_ASSERT_RD_MSR_FN(Amd64GsBase);
5244	CPUM_ASSERT_RD_MSR_FN(Amd64KernelGsBase);
5245	CPUM_ASSERT_RD_MSR_FN(Amd64TscAux);
5246
5247	CPUM_ASSERT_RD_MSR_FN(IntelEblCrPowerOn);
5248	CPUM_ASSERT_RD_MSR_FN(IntelI7CoreThreadCount);
5249	CPUM_ASSERT_RD_MSR_FN(IntelP4EbcHardPowerOn);
5250	CPUM_ASSERT_RD_MSR_FN(IntelP4EbcSoftPowerOn);
5251	CPUM_ASSERT_RD_MSR_FN(IntelP4EbcFrequencyId);
5252	CPUM_ASSERT_RD_MSR_FN(IntelP6FsbFrequency);
5253	CPUM_ASSERT_RD_MSR_FN(IntelPlatformInfo);
5254	CPUM_ASSERT_RD_MSR_FN(IntelFlexRatio);
5255	CPUM_ASSERT_RD_MSR_FN(IntelPkgCStConfigControl);
5256	CPUM_ASSERT_RD_MSR_FN(IntelPmgIoCaptureBase);
5257	CPUM_ASSERT_RD_MSR_FN(IntelLastBranchFromToN);
5258	CPUM_ASSERT_RD_MSR_FN(IntelLastBranchFromN);
5259	CPUM_ASSERT_RD_MSR_FN(IntelLastBranchToN);
5260	CPUM_ASSERT_RD_MSR_FN(IntelLastBranchTos);
5261	CPUM_ASSERT_RD_MSR_FN(IntelBblCrCtl);
5262	CPUM_ASSERT_RD_MSR_FN(IntelBblCrCtl3);
5263	CPUM_ASSERT_RD_MSR_FN(IntelI7TemperatureTarget);
5264	CPUM_ASSERT_RD_MSR_FN(IntelI7MsrOffCoreResponseN);
5265	CPUM_ASSERT_RD_MSR_FN(IntelI7MiscPwrMgmt);
5266	CPUM_ASSERT_RD_MSR_FN(IntelP6CrN);
5267	CPUM_ASSERT_RD_MSR_FN(IntelCpuId1FeatureMaskEcdx);
5268	CPUM_ASSERT_RD_MSR_FN(IntelCpuId1FeatureMaskEax);
5269	CPUM_ASSERT_RD_MSR_FN(IntelCpuId80000001FeatureMaskEcdx);
5270	CPUM_ASSERT_RD_MSR_FN(IntelI7SandyAesNiCtl);
5271	CPUM_ASSERT_RD_MSR_FN(IntelI7TurboRatioLimit);
5272	CPUM_ASSERT_RD_MSR_FN(IntelI7LbrSelect);
5273	CPUM_ASSERT_RD_MSR_FN(IntelI7SandyErrorControl);
5274	CPUM_ASSERT_RD_MSR_FN(IntelI7VirtualLegacyWireCap);
5275	CPUM_ASSERT_RD_MSR_FN(IntelI7PowerCtl);
5276	CPUM_ASSERT_RD_MSR_FN(IntelI7SandyPebsNumAlt);
5277	CPUM_ASSERT_RD_MSR_FN(IntelI7PebsLdLat);
5278	CPUM_ASSERT_RD_MSR_FN(IntelI7PkgCnResidencyN);
5279	CPUM_ASSERT_RD_MSR_FN(IntelI7CoreCnResidencyN);
5280	CPUM_ASSERT_RD_MSR_FN(IntelI7SandyVrCurrentConfig);
5281	CPUM_ASSERT_RD_MSR_FN(IntelI7SandyVrMiscConfig);
5282	CPUM_ASSERT_RD_MSR_FN(IntelI7SandyRaplPowerUnit);
5283	CPUM_ASSERT_RD_MSR_FN(IntelI7SandyPkgCnIrtlN);
5284	CPUM_ASSERT_RD_MSR_FN(IntelI7SandyPkgC2Residency);
5285	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplPkgPowerLimit);
5286	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplPkgEnergyStatus);
5287	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplPkgPerfStatus);
5288	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplPkgPowerInfo);
5289	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplDramPowerLimit);
5290	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplDramEnergyStatus);
5291	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplDramPerfStatus);
5292	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplDramPowerInfo);
5293	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplPp0PowerLimit);
5294	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplPp0EnergyStatus);
5295	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplPp0Policy);
5296	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplPp0PerfStatus);
5297	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplPp1PowerLimit);
5298	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplPp1EnergyStatus);
5299	CPUM_ASSERT_RD_MSR_FN(IntelI7RaplPp1Policy);
5300	CPUM_ASSERT_RD_MSR_FN(IntelI7IvyConfigTdpNominal);
5301	CPUM_ASSERT_RD_MSR_FN(IntelI7IvyConfigTdpLevel1);
5302	CPUM_ASSERT_RD_MSR_FN(IntelI7IvyConfigTdpLevel2);
5303	CPUM_ASSERT_RD_MSR_FN(IntelI7IvyConfigTdpControl);
5304	CPUM_ASSERT_RD_MSR_FN(IntelI7IvyTurboActivationRatio);
5305	CPUM_ASSERT_RD_MSR_FN(IntelI7UncPerfGlobalCtrl);
5306	CPUM_ASSERT_RD_MSR_FN(IntelI7UncPerfGlobalStatus);
5307	CPUM_ASSERT_RD_MSR_FN(IntelI7UncPerfGlobalOvfCtrl);
5308	CPUM_ASSERT_RD_MSR_FN(IntelI7UncPerfFixedCtrCtrl);
5309	CPUM_ASSERT_RD_MSR_FN(IntelI7UncPerfFixedCtr);
5310	CPUM_ASSERT_RD_MSR_FN(IntelI7UncCBoxConfig);
5311	CPUM_ASSERT_RD_MSR_FN(IntelI7UncArbPerfCtrN);
5312	CPUM_ASSERT_RD_MSR_FN(IntelI7UncArbPerfEvtSelN);
5313	CPUM_ASSERT_RD_MSR_FN(IntelI7SmiCount);
5314	CPUM_ASSERT_RD_MSR_FN(IntelCore2EmttmCrTablesN);
5315	CPUM_ASSERT_RD_MSR_FN(IntelCore2SmmCStMiscInfo);
5316	CPUM_ASSERT_RD_MSR_FN(IntelCore1ExtConfig);
5317	CPUM_ASSERT_RD_MSR_FN(IntelCore1DtsCalControl);
5318	CPUM_ASSERT_RD_MSR_FN(IntelCore2PeciControl);
5319	CPUM_ASSERT_RD_MSR_FN(IntelAtSilvCoreC1Recidency);
5320
5321	CPUM_ASSERT_RD_MSR_FN(P6LastBranchFromIp);
5322	CPUM_ASSERT_RD_MSR_FN(P6LastBranchToIp);
5323	CPUM_ASSERT_RD_MSR_FN(P6LastIntFromIp);
5324	CPUM_ASSERT_RD_MSR_FN(P6LastIntToIp);
5325
5326	CPUM_ASSERT_RD_MSR_FN(AmdFam15hTscRate);
5327	CPUM_ASSERT_RD_MSR_FN(AmdFam15hLwpCfg);
5328	CPUM_ASSERT_RD_MSR_FN(AmdFam15hLwpCbAddr);
5329	CPUM_ASSERT_RD_MSR_FN(AmdFam10hMc4MiscN);
5330	CPUM_ASSERT_RD_MSR_FN(AmdK8PerfCtlN);
5331	CPUM_ASSERT_RD_MSR_FN(AmdK8PerfCtrN);
5332	CPUM_ASSERT_RD_MSR_FN(AmdK8SysCfg);
5333	CPUM_ASSERT_RD_MSR_FN(AmdK8HwCr);
5334	CPUM_ASSERT_RD_MSR_FN(AmdK8IorrBaseN);
5335	CPUM_ASSERT_RD_MSR_FN(AmdK8IorrMaskN);
5336	CPUM_ASSERT_RD_MSR_FN(AmdK8TopOfMemN);
5337	CPUM_ASSERT_RD_MSR_FN(AmdK8NbCfg1);
5338	CPUM_ASSERT_RD_MSR_FN(AmdK8McXcptRedir);
5339	CPUM_ASSERT_RD_MSR_FN(AmdK8CpuNameN);
5340	CPUM_ASSERT_RD_MSR_FN(AmdK8HwThermalCtrl);
5341	CPUM_ASSERT_RD_MSR_FN(AmdK8SwThermalCtrl);
5342	CPUM_ASSERT_RD_MSR_FN(AmdK8FidVidControl);
5343	CPUM_ASSERT_RD_MSR_FN(AmdK8FidVidStatus);
5344	CPUM_ASSERT_RD_MSR_FN(AmdK8McCtlMaskN);
5345	CPUM_ASSERT_RD_MSR_FN(AmdK8SmiOnIoTrapN);
5346	CPUM_ASSERT_RD_MSR_FN(AmdK8SmiOnIoTrapCtlSts);
5347	CPUM_ASSERT_RD_MSR_FN(AmdK8IntPendingMessage);
5348	CPUM_ASSERT_RD_MSR_FN(AmdK8SmiTriggerIoCycle);
5349	CPUM_ASSERT_RD_MSR_FN(AmdFam10hMmioCfgBaseAddr);
5350	CPUM_ASSERT_RD_MSR_FN(AmdFam10hTrapCtlMaybe);
5351	CPUM_ASSERT_RD_MSR_FN(AmdFam10hPStateCurLimit);
5352	CPUM_ASSERT_RD_MSR_FN(AmdFam10hPStateControl);
5353	CPUM_ASSERT_RD_MSR_FN(AmdFam10hPStateStatus);
5354	CPUM_ASSERT_RD_MSR_FN(AmdFam10hPStateN);
5355	CPUM_ASSERT_RD_MSR_FN(AmdFam10hCofVidControl);
5356	CPUM_ASSERT_RD_MSR_FN(AmdFam10hCofVidStatus);
5357	CPUM_ASSERT_RD_MSR_FN(AmdFam10hCStateIoBaseAddr);
5358	CPUM_ASSERT_RD_MSR_FN(AmdFam10hCpuWatchdogTimer);
5359	CPUM_ASSERT_RD_MSR_FN(AmdK8SmmBase);
5360	CPUM_ASSERT_RD_MSR_FN(AmdK8SmmAddr);
5361	CPUM_ASSERT_RD_MSR_FN(AmdK8SmmMask);
5362	CPUM_ASSERT_RD_MSR_FN(AmdK8VmCr);
5363	CPUM_ASSERT_RD_MSR_FN(AmdK8IgnNe);
5364	CPUM_ASSERT_RD_MSR_FN(AmdK8SmmCtl);
5365	CPUM_ASSERT_RD_MSR_FN(AmdK8VmHSavePa);
5366	CPUM_ASSERT_RD_MSR_FN(AmdFam10hVmLockKey);
5367	CPUM_ASSERT_RD_MSR_FN(AmdFam10hSmmLockKey);
5368	CPUM_ASSERT_RD_MSR_FN(AmdFam10hLocalSmiStatus);
5369	CPUM_ASSERT_RD_MSR_FN(AmdFam10hOsVisWrkIdLength);
5370	CPUM_ASSERT_RD_MSR_FN(AmdFam10hOsVisWrkStatus);
5371	CPUM_ASSERT_RD_MSR_FN(AmdFam16hL2IPerfCtlN);
5372	CPUM_ASSERT_RD_MSR_FN(AmdFam16hL2IPerfCtrN);
5373	CPUM_ASSERT_RD_MSR_FN(AmdFam15hNorthbridgePerfCtlN);
5374	CPUM_ASSERT_RD_MSR_FN(AmdFam15hNorthbridgePerfCtrN);
5375	CPUM_ASSERT_RD_MSR_FN(AmdK7MicrocodeCtl);
5376	CPUM_ASSERT_RD_MSR_FN(AmdK7ClusterIdMaybe);
5377	CPUM_ASSERT_RD_MSR_FN(AmdK8CpuIdCtlStd07hEbax);
5378	CPUM_ASSERT_RD_MSR_FN(AmdK8CpuIdCtlStd06hEcx);
5379	CPUM_ASSERT_RD_MSR_FN(AmdK8CpuIdCtlStd01hEdcx);
5380	CPUM_ASSERT_RD_MSR_FN(AmdK8CpuIdCtlExt01hEdcx);
5381	CPUM_ASSERT_RD_MSR_FN(AmdK8PatchLevel);
5382	CPUM_ASSERT_RD_MSR_FN(AmdK7DebugStatusMaybe);
5383	CPUM_ASSERT_RD_MSR_FN(AmdK7BHTraceBaseMaybe);
5384	CPUM_ASSERT_RD_MSR_FN(AmdK7BHTracePtrMaybe);
5385	CPUM_ASSERT_RD_MSR_FN(AmdK7BHTraceLimitMaybe);
5386	CPUM_ASSERT_RD_MSR_FN(AmdK7HardwareDebugToolCfgMaybe);
5387	CPUM_ASSERT_RD_MSR_FN(AmdK7FastFlushCountMaybe);
5388	CPUM_ASSERT_RD_MSR_FN(AmdK7NodeId);
5389	CPUM_ASSERT_RD_MSR_FN(AmdK7DrXAddrMaskN);
5390	CPUM_ASSERT_RD_MSR_FN(AmdK7Dr0DataMatchMaybe);
5391	CPUM_ASSERT_RD_MSR_FN(AmdK7Dr0DataMaskMaybe);
5392	CPUM_ASSERT_RD_MSR_FN(AmdK7LoadStoreCfg);
5393	CPUM_ASSERT_RD_MSR_FN(AmdK7InstrCacheCfg);
5394	CPUM_ASSERT_RD_MSR_FN(AmdK7DataCacheCfg);
5395	CPUM_ASSERT_RD_MSR_FN(AmdK7BusUnitCfg);
5396	CPUM_ASSERT_RD_MSR_FN(AmdK7DebugCtl2Maybe);
5397	CPUM_ASSERT_RD_MSR_FN(AmdFam15hFpuCfg);
5398	CPUM_ASSERT_RD_MSR_FN(AmdFam15hDecoderCfg);
5399	CPUM_ASSERT_RD_MSR_FN(AmdFam10hBusUnitCfg2);
5400	CPUM_ASSERT_RD_MSR_FN(AmdFam15hCombUnitCfg);
5401	CPUM_ASSERT_RD_MSR_FN(AmdFam15hCombUnitCfg2);
5402	CPUM_ASSERT_RD_MSR_FN(AmdFam15hCombUnitCfg3);
5403	CPUM_ASSERT_RD_MSR_FN(AmdFam15hExecUnitCfg);
5404	CPUM_ASSERT_RD_MSR_FN(AmdFam15hLoadStoreCfg2);
5405	CPUM_ASSERT_RD_MSR_FN(AmdFam10hIbsFetchCtl);
5406	CPUM_ASSERT_RD_MSR_FN(AmdFam10hIbsFetchLinAddr);
5407	CPUM_ASSERT_RD_MSR_FN(AmdFam10hIbsFetchPhysAddr);
5408	CPUM_ASSERT_RD_MSR_FN(AmdFam10hIbsOpExecCtl);
5409	CPUM_ASSERT_RD_MSR_FN(AmdFam10hIbsOpRip);
5410	CPUM_ASSERT_RD_MSR_FN(AmdFam10hIbsOpData);
5411	CPUM_ASSERT_RD_MSR_FN(AmdFam10hIbsOpData2);
5412	CPUM_ASSERT_RD_MSR_FN(AmdFam10hIbsOpData3);
5413	CPUM_ASSERT_RD_MSR_FN(AmdFam10hIbsDcLinAddr);
5414	CPUM_ASSERT_RD_MSR_FN(AmdFam10hIbsDcPhysAddr);
5415	CPUM_ASSERT_RD_MSR_FN(AmdFam10hIbsCtl);
5416	CPUM_ASSERT_RD_MSR_FN(AmdFam14hIbsBrTarget);
5417
5418	CPUM_ASSERT_RD_MSR_FN(Gim)
5419
5420	AssertReturn(g_aCpumWrMsrFns[kCpumMsrWrFn_Invalid] == NULL, VERR_CPUM_IPE_2);
5421	CPUM_ASSERT_WR_MSR_FN(Ia32P5McAddr);
5422	CPUM_ASSERT_WR_MSR_FN(Ia32P5McType);
5423	CPUM_ASSERT_WR_MSR_FN(Ia32TimestampCounter);
5424	CPUM_ASSERT_WR_MSR_FN(Ia32ApicBase);
5425	CPUM_ASSERT_WR_MSR_FN(Ia32FeatureControl);
5426	CPUM_ASSERT_WR_MSR_FN(Ia32BiosSignId);
5427	CPUM_ASSERT_WR_MSR_FN(Ia32BiosUpdateTrigger);
5428	CPUM_ASSERT_WR_MSR_FN(Ia32SmmMonitorCtl);
5429	CPUM_ASSERT_WR_MSR_FN(Ia32PmcN);
5430	CPUM_ASSERT_WR_MSR_FN(Ia32MonitorFilterLineSize);
5431	CPUM_ASSERT_WR_MSR_FN(Ia32MPerf);
5432	CPUM_ASSERT_WR_MSR_FN(Ia32APerf);
5433	CPUM_ASSERT_WR_MSR_FN(Ia32MtrrPhysBaseN);
5434	CPUM_ASSERT_WR_MSR_FN(Ia32MtrrPhysMaskN);
5435	CPUM_ASSERT_WR_MSR_FN(Ia32MtrrFixed);
5436	CPUM_ASSERT_WR_MSR_FN(Ia32MtrrDefType);
5437	CPUM_ASSERT_WR_MSR_FN(Ia32Pat);
5438	CPUM_ASSERT_WR_MSR_FN(Ia32SysEnterCs);
5439	CPUM_ASSERT_WR_MSR_FN(Ia32SysEnterEsp);
5440	CPUM_ASSERT_WR_MSR_FN(Ia32SysEnterEip);
5441	CPUM_ASSERT_WR_MSR_FN(Ia32McgStatus);
5442	CPUM_ASSERT_WR_MSR_FN(Ia32McgCtl);
5443	CPUM_ASSERT_WR_MSR_FN(Ia32DebugCtl);
5444	CPUM_ASSERT_WR_MSR_FN(Ia32SmrrPhysBase);
5445	CPUM_ASSERT_WR_MSR_FN(Ia32SmrrPhysMask);
5446	CPUM_ASSERT_WR_MSR_FN(Ia32PlatformDcaCap);
5447	CPUM_ASSERT_WR_MSR_FN(Ia32Dca0Cap);
5448	CPUM_ASSERT_WR_MSR_FN(Ia32PerfEvtSelN);
5449	CPUM_ASSERT_WR_MSR_FN(Ia32PerfStatus);
5450	CPUM_ASSERT_WR_MSR_FN(Ia32PerfCtl);
5451	CPUM_ASSERT_WR_MSR_FN(Ia32FixedCtrN);
5452	CPUM_ASSERT_WR_MSR_FN(Ia32PerfCapabilities);
5453	CPUM_ASSERT_WR_MSR_FN(Ia32FixedCtrCtrl);
5454	CPUM_ASSERT_WR_MSR_FN(Ia32PerfGlobalStatus);
5455	CPUM_ASSERT_WR_MSR_FN(Ia32PerfGlobalCtrl);
5456	CPUM_ASSERT_WR_MSR_FN(Ia32PerfGlobalOvfCtrl);
5457	CPUM_ASSERT_WR_MSR_FN(Ia32PebsEnable);
5458	CPUM_ASSERT_WR_MSR_FN(Ia32ClockModulation);
5459	CPUM_ASSERT_WR_MSR_FN(Ia32ThermInterrupt);
5460	CPUM_ASSERT_WR_MSR_FN(Ia32ThermStatus);
5461	CPUM_ASSERT_WR_MSR_FN(Ia32MiscEnable);
5462	CPUM_ASSERT_WR_MSR_FN(Ia32McCtlStatusAddrMiscN);
5463	CPUM_ASSERT_WR_MSR_FN(Ia32McNCtl2);
5464	CPUM_ASSERT_WR_MSR_FN(Ia32DsArea);
5465	CPUM_ASSERT_WR_MSR_FN(Ia32TscDeadline);
5466	CPUM_ASSERT_WR_MSR_FN(Ia32X2ApicN);
5467	CPUM_ASSERT_WR_MSR_FN(Ia32DebugInterface);
5468
5469	CPUM_ASSERT_WR_MSR_FN(Amd64Efer);
5470	CPUM_ASSERT_WR_MSR_FN(Amd64SyscallTarget);
5471	CPUM_ASSERT_WR_MSR_FN(Amd64LongSyscallTarget);
5472	CPUM_ASSERT_WR_MSR_FN(Amd64CompSyscallTarget);
5473	CPUM_ASSERT_WR_MSR_FN(Amd64SyscallFlagMask);
5474	CPUM_ASSERT_WR_MSR_FN(Amd64FsBase);
5475	CPUM_ASSERT_WR_MSR_FN(Amd64GsBase);
5476	CPUM_ASSERT_WR_MSR_FN(Amd64KernelGsBase);
5477	CPUM_ASSERT_WR_MSR_FN(Amd64TscAux);
5478
5479	CPUM_ASSERT_WR_MSR_FN(IntelEblCrPowerOn);
5480	CPUM_ASSERT_WR_MSR_FN(IntelP4EbcHardPowerOn);
5481	CPUM_ASSERT_WR_MSR_FN(IntelP4EbcSoftPowerOn);
5482	CPUM_ASSERT_WR_MSR_FN(IntelP4EbcFrequencyId);
5483	CPUM_ASSERT_WR_MSR_FN(IntelFlexRatio);
5484	CPUM_ASSERT_WR_MSR_FN(IntelPkgCStConfigControl);
5485	CPUM_ASSERT_WR_MSR_FN(IntelPmgIoCaptureBase);
5486	CPUM_ASSERT_WR_MSR_FN(IntelLastBranchFromToN);
5487	CPUM_ASSERT_WR_MSR_FN(IntelLastBranchFromN);
5488	CPUM_ASSERT_WR_MSR_FN(IntelLastBranchToN);
5489	CPUM_ASSERT_WR_MSR_FN(IntelLastBranchTos);
5490	CPUM_ASSERT_WR_MSR_FN(IntelBblCrCtl);
5491	CPUM_ASSERT_WR_MSR_FN(IntelBblCrCtl3);
5492	CPUM_ASSERT_WR_MSR_FN(IntelI7TemperatureTarget);
5493	CPUM_ASSERT_WR_MSR_FN(IntelI7MsrOffCoreResponseN);
5494	CPUM_ASSERT_WR_MSR_FN(IntelI7MiscPwrMgmt);
5495	CPUM_ASSERT_WR_MSR_FN(IntelP6CrN);
5496	CPUM_ASSERT_WR_MSR_FN(IntelCpuId1FeatureMaskEcdx);
5497	CPUM_ASSERT_WR_MSR_FN(IntelCpuId1FeatureMaskEax);
5498	CPUM_ASSERT_WR_MSR_FN(IntelCpuId80000001FeatureMaskEcdx);
5499	CPUM_ASSERT_WR_MSR_FN(IntelI7SandyAesNiCtl);
5500	CPUM_ASSERT_WR_MSR_FN(IntelI7TurboRatioLimit);
5501	CPUM_ASSERT_WR_MSR_FN(IntelI7LbrSelect);
5502	CPUM_ASSERT_WR_MSR_FN(IntelI7SandyErrorControl);
5503	CPUM_ASSERT_WR_MSR_FN(IntelI7PowerCtl);
5504	CPUM_ASSERT_WR_MSR_FN(IntelI7SandyPebsNumAlt);
5505	CPUM_ASSERT_WR_MSR_FN(IntelI7PebsLdLat);
5506	CPUM_ASSERT_WR_MSR_FN(IntelI7SandyVrCurrentConfig);
5507	CPUM_ASSERT_WR_MSR_FN(IntelI7SandyVrMiscConfig);
5508	CPUM_ASSERT_WR_MSR_FN(IntelI7SandyPkgCnIrtlN);
5509	CPUM_ASSERT_WR_MSR_FN(IntelI7SandyPkgC2Residency);
5510	CPUM_ASSERT_WR_MSR_FN(IntelI7RaplPkgPowerLimit);
5511	CPUM_ASSERT_WR_MSR_FN(IntelI7RaplDramPowerLimit);
5512	CPUM_ASSERT_WR_MSR_FN(IntelI7RaplPp0PowerLimit);
5513	CPUM_ASSERT_WR_MSR_FN(IntelI7RaplPp0Policy);
5514	CPUM_ASSERT_WR_MSR_FN(IntelI7RaplPp1PowerLimit);
5515	CPUM_ASSERT_WR_MSR_FN(IntelI7RaplPp1Policy);
5516	CPUM_ASSERT_WR_MSR_FN(IntelI7IvyConfigTdpControl);
5517	CPUM_ASSERT_WR_MSR_FN(IntelI7IvyTurboActivationRatio);
5518	CPUM_ASSERT_WR_MSR_FN(IntelI7UncPerfGlobalCtrl);
5519	CPUM_ASSERT_WR_MSR_FN(IntelI7UncPerfGlobalStatus);
5520	CPUM_ASSERT_WR_MSR_FN(IntelI7UncPerfGlobalOvfCtrl);
5521	CPUM_ASSERT_WR_MSR_FN(IntelI7UncPerfFixedCtrCtrl);
5522	CPUM_ASSERT_WR_MSR_FN(IntelI7UncPerfFixedCtr);
5523	CPUM_ASSERT_WR_MSR_FN(IntelI7UncArbPerfCtrN);
5524	CPUM_ASSERT_WR_MSR_FN(IntelI7UncArbPerfEvtSelN);
5525	CPUM_ASSERT_WR_MSR_FN(IntelCore2EmttmCrTablesN);
5526	CPUM_ASSERT_WR_MSR_FN(IntelCore2SmmCStMiscInfo);
5527	CPUM_ASSERT_WR_MSR_FN(IntelCore1ExtConfig);
5528	CPUM_ASSERT_WR_MSR_FN(IntelCore1DtsCalControl);
5529	CPUM_ASSERT_WR_MSR_FN(IntelCore2PeciControl);
5530
5531	CPUM_ASSERT_WR_MSR_FN(P6LastIntFromIp);
5532	CPUM_ASSERT_WR_MSR_FN(P6LastIntToIp);
5533
5534	CPUM_ASSERT_WR_MSR_FN(AmdFam15hTscRate);
5535	CPUM_ASSERT_WR_MSR_FN(AmdFam15hLwpCfg);
5536	CPUM_ASSERT_WR_MSR_FN(AmdFam15hLwpCbAddr);
5537	CPUM_ASSERT_WR_MSR_FN(AmdFam10hMc4MiscN);
5538	CPUM_ASSERT_WR_MSR_FN(AmdK8PerfCtlN);
5539	CPUM_ASSERT_WR_MSR_FN(AmdK8PerfCtrN);
5540	CPUM_ASSERT_WR_MSR_FN(AmdK8SysCfg);
5541	CPUM_ASSERT_WR_MSR_FN(AmdK8HwCr);
5542	CPUM_ASSERT_WR_MSR_FN(AmdK8IorrBaseN);
5543	CPUM_ASSERT_WR_MSR_FN(AmdK8IorrMaskN);
5544	CPUM_ASSERT_WR_MSR_FN(AmdK8TopOfMemN);
5545	CPUM_ASSERT_WR_MSR_FN(AmdK8NbCfg1);
5546	CPUM_ASSERT_WR_MSR_FN(AmdK8McXcptRedir);
5547	CPUM_ASSERT_WR_MSR_FN(AmdK8CpuNameN);
5548	CPUM_ASSERT_WR_MSR_FN(AmdK8HwThermalCtrl);
5549	CPUM_ASSERT_WR_MSR_FN(AmdK8SwThermalCtrl);
5550	CPUM_ASSERT_WR_MSR_FN(AmdK8FidVidControl);
5551	CPUM_ASSERT_WR_MSR_FN(AmdK8McCtlMaskN);
5552	CPUM_ASSERT_WR_MSR_FN(AmdK8SmiOnIoTrapN);
5553	CPUM_ASSERT_WR_MSR_FN(AmdK8SmiOnIoTrapCtlSts);
5554	CPUM_ASSERT_WR_MSR_FN(AmdK8IntPendingMessage);
5555	CPUM_ASSERT_WR_MSR_FN(AmdK8SmiTriggerIoCycle);
5556	CPUM_ASSERT_WR_MSR_FN(AmdFam10hMmioCfgBaseAddr);
5557	CPUM_ASSERT_WR_MSR_FN(AmdFam10hTrapCtlMaybe);
5558	CPUM_ASSERT_WR_MSR_FN(AmdFam10hPStateControl);
5559	CPUM_ASSERT_WR_MSR_FN(AmdFam10hPStateStatus);
5560	CPUM_ASSERT_WR_MSR_FN(AmdFam10hPStateN);
5561	CPUM_ASSERT_WR_MSR_FN(AmdFam10hCofVidControl);
5562	CPUM_ASSERT_WR_MSR_FN(AmdFam10hCofVidStatus);
5563	CPUM_ASSERT_WR_MSR_FN(AmdFam10hCStateIoBaseAddr);
5564	CPUM_ASSERT_WR_MSR_FN(AmdFam10hCpuWatchdogTimer);
5565	CPUM_ASSERT_WR_MSR_FN(AmdK8SmmBase);
5566	CPUM_ASSERT_WR_MSR_FN(AmdK8SmmAddr);
5567	CPUM_ASSERT_WR_MSR_FN(AmdK8SmmMask);
5568	CPUM_ASSERT_WR_MSR_FN(AmdK8VmCr);
5569	CPUM_ASSERT_WR_MSR_FN(AmdK8IgnNe);
5570	CPUM_ASSERT_WR_MSR_FN(AmdK8SmmCtl);
5571	CPUM_ASSERT_WR_MSR_FN(AmdK8VmHSavePa);
5572	CPUM_ASSERT_WR_MSR_FN(AmdFam10hVmLockKey);
5573	CPUM_ASSERT_WR_MSR_FN(AmdFam10hSmmLockKey);
5574	CPUM_ASSERT_WR_MSR_FN(AmdFam10hLocalSmiStatus);
5575	CPUM_ASSERT_WR_MSR_FN(AmdFam10hOsVisWrkIdLength);
5576	CPUM_ASSERT_WR_MSR_FN(AmdFam10hOsVisWrkStatus);
5577	CPUM_ASSERT_WR_MSR_FN(AmdFam16hL2IPerfCtlN);
5578	CPUM_ASSERT_WR_MSR_FN(AmdFam16hL2IPerfCtrN);
5579	CPUM_ASSERT_WR_MSR_FN(AmdFam15hNorthbridgePerfCtlN);
5580	CPUM_ASSERT_WR_MSR_FN(AmdFam15hNorthbridgePerfCtrN);
5581	CPUM_ASSERT_WR_MSR_FN(AmdK7MicrocodeCtl);
5582	CPUM_ASSERT_WR_MSR_FN(AmdK7ClusterIdMaybe);
5583	CPUM_ASSERT_WR_MSR_FN(AmdK8CpuIdCtlStd07hEbax);
5584	CPUM_ASSERT_WR_MSR_FN(AmdK8CpuIdCtlStd06hEcx);
5585	CPUM_ASSERT_WR_MSR_FN(AmdK8CpuIdCtlStd01hEdcx);
5586	CPUM_ASSERT_WR_MSR_FN(AmdK8CpuIdCtlExt01hEdcx);
5587	CPUM_ASSERT_WR_MSR_FN(AmdK8PatchLoader);
5588	CPUM_ASSERT_WR_MSR_FN(AmdK7DebugStatusMaybe);
5589	CPUM_ASSERT_WR_MSR_FN(AmdK7BHTraceBaseMaybe);
5590	CPUM_ASSERT_WR_MSR_FN(AmdK7BHTracePtrMaybe);
5591	CPUM_ASSERT_WR_MSR_FN(AmdK7BHTraceLimitMaybe);
5592	CPUM_ASSERT_WR_MSR_FN(AmdK7HardwareDebugToolCfgMaybe);
5593	CPUM_ASSERT_WR_MSR_FN(AmdK7FastFlushCountMaybe);
5594	CPUM_ASSERT_WR_MSR_FN(AmdK7NodeId);
5595	CPUM_ASSERT_WR_MSR_FN(AmdK7DrXAddrMaskN);
5596	CPUM_ASSERT_WR_MSR_FN(AmdK7Dr0DataMatchMaybe);
5597	CPUM_ASSERT_WR_MSR_FN(AmdK7Dr0DataMaskMaybe);
5598	CPUM_ASSERT_WR_MSR_FN(AmdK7LoadStoreCfg);
5599	CPUM_ASSERT_WR_MSR_FN(AmdK7InstrCacheCfg);
5600	CPUM_ASSERT_WR_MSR_FN(AmdK7DataCacheCfg);
5601	CPUM_ASSERT_WR_MSR_FN(AmdK7BusUnitCfg);
5602	CPUM_ASSERT_WR_MSR_FN(AmdK7DebugCtl2Maybe);
5603	CPUM_ASSERT_WR_MSR_FN(AmdFam15hFpuCfg);
5604	CPUM_ASSERT_WR_MSR_FN(AmdFam15hDecoderCfg);
5605	CPUM_ASSERT_WR_MSR_FN(AmdFam10hBusUnitCfg2);
5606	CPUM_ASSERT_WR_MSR_FN(AmdFam15hCombUnitCfg);
5607	CPUM_ASSERT_WR_MSR_FN(AmdFam15hCombUnitCfg2);
5608	CPUM_ASSERT_WR_MSR_FN(AmdFam15hCombUnitCfg3);
5609	CPUM_ASSERT_WR_MSR_FN(AmdFam15hExecUnitCfg);
5610	CPUM_ASSERT_WR_MSR_FN(AmdFam15hLoadStoreCfg2);
5611	CPUM_ASSERT_WR_MSR_FN(AmdFam10hIbsFetchCtl);
5612	CPUM_ASSERT_WR_MSR_FN(AmdFam10hIbsFetchLinAddr);
5613	CPUM_ASSERT_WR_MSR_FN(AmdFam10hIbsFetchPhysAddr);
5614	CPUM_ASSERT_WR_MSR_FN(AmdFam10hIbsOpExecCtl);
5615	CPUM_ASSERT_WR_MSR_FN(AmdFam10hIbsOpRip);
5616	CPUM_ASSERT_WR_MSR_FN(AmdFam10hIbsOpData);
5617	CPUM_ASSERT_WR_MSR_FN(AmdFam10hIbsOpData2);
5618	CPUM_ASSERT_WR_MSR_FN(AmdFam10hIbsOpData3);
5619	CPUM_ASSERT_WR_MSR_FN(AmdFam10hIbsDcLinAddr);
5620	CPUM_ASSERT_WR_MSR_FN(AmdFam10hIbsDcPhysAddr);
5621	CPUM_ASSERT_WR_MSR_FN(AmdFam10hIbsCtl);
5622	CPUM_ASSERT_WR_MSR_FN(AmdFam14hIbsBrTarget);
5623
5624	CPUM_ASSERT_WR_MSR_FN(Gim);
5625
5626	return VINF_SUCCESS;
5627	}
5628	#endif /* VBOX_STRICT && IN_RING3 */
5629
5630
5631	/**
5632	* Gets the scalable bus frequency.
5633	*
5634	* The bus frequency is used as a base in several MSRs that gives the CPU and
5635	* other frequency ratios.
5636	*
5637	* @returns Scalable bus frequency in Hz. Will not return CPUM_SBUSFREQ_UNKNOWN.
5638	* @param pVM The cross context VM structure.
5639	*/
5640	VMMDECL(uint64_t) CPUMGetGuestScalableBusFrequency(PVM pVM)
5641	{
5642	uint64_t uFreq = pVM->cpum.s.GuestInfo.uScalableBusFreq;
5643	if (uFreq == CPUM_SBUSFREQ_UNKNOWN)
5644	uFreq = CPUM_SBUSFREQ_100MHZ;
5645	return uFreq;
5646	}
5647
5648
5649	#ifdef IN_RING0
5650
5651	/**
5652	* Fast way for HM to access the MSR_K8_TSC_AUX register.
5653	*
5654	* @returns The register value.
5655	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
5656	* @thread EMT(pVCpu)
5657	*/
5658	VMMR0_INT_DECL(uint64_t) CPUMR0GetGuestTscAux(PVMCPU pVCpu)
5659	{
5660	return pVCpu->cpum.s.GuestMsrs.msr.TscAux;
5661	}
5662
5663
5664	/**
5665	* Fast way for HM to access the MSR_K8_TSC_AUX register.
5666	*
5667	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
5668	* @param uValue The new value.
5669	* @thread EMT(pVCpu)
5670	*/
5671	VMMR0_INT_DECL(void) CPUMR0SetGuestTscAux(PVMCPU pVCpu, uint64_t uValue)
5672	{
5673	pVCpu->cpum.s.GuestMsrs.msr.TscAux = uValue;
5674	}
5675
5676	#endif /* IN_RING0 */
5677

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/VMM/VMMAll/CPUMAllMsrs.cpp@ 60762

Download in other formats: