GIMKvm.cpp@ 93115

Last change on this file since 93115 was 93115, checked in by vboxsync, 3 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.1 KB

Line
1	/* $Id: GIMKvm.cpp 93115 2022-01-01 11:31:46Z vboxsync $ */
2	/** @file
3	* GIM - Guest Interface Manager, KVM implementation.
4	*/
5
6	/*
7	* Copyright (C) 2015-2022 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_GIM
23	#include <VBox/vmm/gim.h>
24	#include <VBox/vmm/cpum.h>
25	#include <VBox/vmm/hm.h>
26	#include <VBox/vmm/pdmapi.h>
27	#include <VBox/vmm/ssm.h>
28	#include <VBox/vmm/em.h>
29	#include "GIMInternal.h"
30	#include <VBox/vmm/vm.h>
31
32	#include <VBox/disopcode.h>
33	#include <VBox/err.h>
34	#include <VBox/version.h>
35
36	#include <iprt/asm-math.h>
37	#include <iprt/assert.h>
38	#include <iprt/string.h>
39	#include <iprt/mem.h>
40
41
42
43	/*********************************************************************************************************************************
44	* Defined Constants And Macros *
45	*********************************************************************************************************************************/
46
47	/**
48	* GIM KVM saved-state version.
49	*/
50	#define GIM_KVM_SAVED_STATE_VERSION UINT32_C(1)
51
52	/**
53	* VBox internal struct. to passback to EMT rendezvous callback while enabling
54	* the KVM wall-clock.
55	*/
56	typedef struct KVMWALLCLOCKINFO
57	{
58	/** Guest physical address of the wall-clock struct. */
59	RTGCPHYS GCPhysWallClock;
60	} KVMWALLCLOCKINFO;
61	/** Pointer to the wall-clock info. struct. */
62	typedef KVMWALLCLOCKINFO *PKVMWALLCLOCKINFO;
63
64
65	/*********************************************************************************************************************************
66	* Global Variables *
67	*********************************************************************************************************************************/
68	#ifdef VBOX_WITH_STATISTICS
69	# define GIMKVM_MSRRANGE(a_uFirst, a_uLast, a_szName) \
70	{ (a_uFirst), (a_uLast), kCpumMsrRdFn_Gim, kCpumMsrWrFn_Gim, 0, 0, 0, 0, 0, a_szName, { 0 }, { 0 }, { 0 }, { 0 } }
71	#else
72	# define GIMKVM_MSRRANGE(a_uFirst, a_uLast, a_szName) \
73	{ (a_uFirst), (a_uLast), kCpumMsrRdFn_Gim, kCpumMsrWrFn_Gim, 0, 0, 0, 0, 0, a_szName }
74	#endif
75
76	/**
77	* Array of MSR ranges supported by KVM.
78	*/
79	static CPUMMSRRANGE const g_aMsrRanges_Kvm[] =
80	{
81	GIMKVM_MSRRANGE(MSR_GIM_KVM_RANGE0_FIRST, MSR_GIM_KVM_RANGE0_LAST, "KVM range 0"),
82	GIMKVM_MSRRANGE(MSR_GIM_KVM_RANGE1_FIRST, MSR_GIM_KVM_RANGE1_LAST, "KVM range 1")
83	};
84	#undef GIMKVM_MSRRANGE
85
86
87	/**
88	* Updates the KVM VCPU system-time structure in guest memory.
89	*
90	* @returns VBox status code.
91	* @param pVM The cross context VM structure.
92	* @param pVCpu The cross context virtual CPU structure.
93	*
94	* @remarks This must be called after the system time MSR value has been updated.
95	*/
96	static int gimR3KvmUpdateSystemTime(PVM pVM, PVMCPU pVCpu)
97	{
98	PGIMKVM pKvm = &pVM->gim.s.u.Kvm;
99	PGIMKVMCPU pKvmCpu = &pVCpu->gim.s.u.KvmCpu;
100
101	/*
102	* Validate the MSR has the enable bit and the guest's system time struct. address.
103	*/
104	MSR_GIM_KVM_SYSTEM_TIME_IS_ENABLED(pKvmCpu->u64SystemTimeMsr);
105	if (!PGMPhysIsGCPhysNormal(pVM, pKvmCpu->GCPhysSystemTime))
106	{
107	LogRel(("GIM: KVM: VCPU%3d: Invalid physical addr requested for mapping system-time struct. GCPhysSystemTime=%#RGp\n",
108	pVCpu->idCpu, pKvmCpu->GCPhysSystemTime));
109	return VERR_GIM_OPERATION_FAILED;
110	}
111
112	VMSTATE const enmVMState = pVM->enmVMState;
113	bool const fRunning = VMSTATE_IS_RUNNING(enmVMState);
114	Assert(!(pKvmCpu->u32SystemTimeVersion & UINT32_C(1)));
115
116	/*
117	* Construct a system-time struct.
118	*/
119	GIMKVMSYSTEMTIME SystemTime;
120	RT_ZERO(SystemTime);
121	SystemTime.u32Version = pKvmCpu->u32SystemTimeVersion + !!fRunning;
122	SystemTime.u64NanoTS = pKvmCpu->uVirtNanoTS;
123	SystemTime.u64Tsc = pKvmCpu->uTsc;
124	SystemTime.fFlags = pKvmCpu->fSystemTimeFlags \| GIM_KVM_SYSTEM_TIME_FLAGS_TSC_STABLE;
125
126	/*
127	* How the guest calculates the system time (nanoseconds):
128	*
129	* tsc = rdtsc - SysTime.u64Tsc
130	* if (SysTime.i8TscShift >= 0)
131	* tsc <<= i8TscShift;
132	* else
133	* tsc >>= -i8TscShift;
134	* time = ((tsc * SysTime.u32TscScale) >> 32) + SysTime.u64NanoTS
135	*/
136	uint64_t u64TscFreq = pKvm->cTscTicksPerSecond;
137	SystemTime.i8TscShift = 0;
138	while (u64TscFreq > 2 * RT_NS_1SEC_64)
139	{
140	u64TscFreq >>= 1;
141	SystemTime.i8TscShift--;
142	}
143	uint32_t uTscFreqLo = (uint32_t)u64TscFreq;
144	while (uTscFreqLo <= RT_NS_1SEC)
145	{
146	uTscFreqLo <<= 1;
147	SystemTime.i8TscShift++;
148	}
149	SystemTime.u32TscScale = ASMDivU64ByU32RetU32(RT_NS_1SEC_64 << 32, uTscFreqLo);
150
151	/*
152	* For informational purposes, back-calculate the exact TSC frequency the guest will see.
153	* Note that the frequency is in kHz, not Hz, since that's what Linux uses.
154	*/
155	uint64_t uTscKHz = (RT_NS_1MS_64 << 32) / SystemTime.u32TscScale;
156	if (SystemTime.i8TscShift < 0)
157	uTscKHz <<= -SystemTime.i8TscShift;
158	else
159	uTscKHz >>= SystemTime.i8TscShift;
160
161	/*
162	* Update guest memory with the system-time struct.
163	*
164	* We update the struct with an incremented, odd version field to indicate to the guest
165	* that the memory is being updated concurrently by the host and it should discard any
166	* data from this struct when it reads an odd version.
167	*
168	* When the VM is not running, we don't need to do this two step update for obvious
169	* reasons and so we skip it.
170	*/
171	if (fRunning)
172	Assert(SystemTime.u32Version & UINT32_C(1));
173	else
174	Assert(!(SystemTime.u32Version & UINT32_C(1)));
175
176	int rc = PGMPhysSimpleWriteGCPhys(pVM, pKvmCpu->GCPhysSystemTime, &SystemTime, sizeof(GIMKVMSYSTEMTIME));
177	if (RT_SUCCESS(rc))
178	{
179	LogRel(("GIM: KVM: VCPU%3d: Enabled system-time struct. at %#RGp - u32TscScale=%#RX32 i8TscShift=%d uVersion=%#RU32 "
180	"fFlags=%#x uTsc=%#RX64 uVirtNanoTS=%#RX64 TscKHz=%RU64\n", pVCpu->idCpu, pKvmCpu->GCPhysSystemTime,
181	SystemTime.u32TscScale, SystemTime.i8TscShift, SystemTime.u32Version + !!fRunning, SystemTime.fFlags,
182	pKvmCpu->uTsc, pKvmCpu->uVirtNanoTS, uTscKHz));
183	TMR3CpuTickParavirtEnable(pVM);
184	}
185	else
186	{
187	LogRel(("GIM: KVM: VCPU%3d: Failed to write system-time struct. at %#RGp. rc=%Rrc\n", pVCpu->idCpu,
188	pKvmCpu->GCPhysSystemTime, rc));
189	}
190
191	if (fRunning)
192	{
193	++SystemTime.u32Version;
194	Assert(!(SystemTime.u32Version & UINT32_C(1)));
195	rc = PGMPhysSimpleWriteGCPhys(pVM, pKvmCpu->GCPhysSystemTime + RT_UOFFSETOF(GIMKVMSYSTEMTIME, u32Version),
196	&SystemTime.u32Version, sizeof(SystemTime.u32Version));
197	if (RT_FAILURE(rc))
198	{
199	LogRel(("GIM: KVM: VCPU%3d: Failed to write system-time struct. while updating version field at %#RGp. rc=%Rrc\n",
200	pVCpu->idCpu, pKvmCpu->GCPhysSystemTime, rc));
201	return rc;
202	}
203
204	/* Update the version so our next write will start with an even value. */
205	pKvmCpu->u32SystemTimeVersion += 2;
206	}
207
208	return rc;
209	}
210
211
212	/**
213	* Initializes the KVM GIM provider.
214	*
215	* @returns VBox status code.
216	* @param pVM The cross context VM structure.
217	*/
218	VMMR3_INT_DECL(int) gimR3KvmInit(PVM pVM)
219	{
220	AssertReturn(pVM, VERR_INVALID_PARAMETER);
221	AssertReturn(pVM->gim.s.enmProviderId == GIMPROVIDERID_KVM, VERR_INTERNAL_ERROR_5);
222
223	int rc;
224	PGIMKVM pKvm = &pVM->gim.s.u.Kvm;
225
226	/*
227	* Determine interface capabilities based on the version.
228	*/
229	if (!pVM->gim.s.u32Version)
230	{
231	/* Basic features. */
232	pKvm->uBaseFeat = 0
233	\| GIM_KVM_BASE_FEAT_CLOCK_OLD
234	//\| GIM_KVM_BASE_FEAT_NOP_IO_DELAY
235	//\| GIM_KVM_BASE_FEAT_MMU_OP
236	\| GIM_KVM_BASE_FEAT_CLOCK
237	//\| GIM_KVM_BASE_FEAT_ASYNC_PF
238	//\| GIM_KVM_BASE_FEAT_STEAL_TIME
239	//\| GIM_KVM_BASE_FEAT_PV_EOI
240	\| GIM_KVM_BASE_FEAT_PV_UNHALT
241	;
242	/* Rest of the features are determined in gimR3KvmInitCompleted(). */
243	}
244
245	/*
246	* Expose HVP (Hypervisor Present) bit to the guest.
247	*/
248	CPUMR3SetGuestCpuIdFeature(pVM, CPUMCPUIDFEATURE_HVP);
249
250	/*
251	* Modify the standard hypervisor leaves for KVM.
252	*/
253	CPUMCPUIDLEAF HyperLeaf;
254	RT_ZERO(HyperLeaf);
255	HyperLeaf.uLeaf = UINT32_C(0x40000000);
256	HyperLeaf.uEax = UINT32_C(0x40000001); /* Minimum value for KVM is 0x40000001. */
257	HyperLeaf.uEbx = 0x4B4D564B; /* 'KVMK' */
258	HyperLeaf.uEcx = 0x564B4D56; /* 'VMKV' */
259	HyperLeaf.uEdx = 0x0000004D; /* 'M000' */
260	rc = CPUMR3CpuIdInsert(pVM, &HyperLeaf);
261	AssertLogRelRCReturn(rc, rc);
262
263	/*
264	* Add KVM specific leaves.
265	*/
266	HyperLeaf.uLeaf = UINT32_C(0x40000001);
267	HyperLeaf.uEax = pKvm->uBaseFeat;
268	HyperLeaf.uEbx = 0; /* Reserved */
269	HyperLeaf.uEcx = 0; /* Reserved */
270	HyperLeaf.uEdx = 0; /* Reserved */
271	rc = CPUMR3CpuIdInsert(pVM, &HyperLeaf);
272	AssertLogRelRCReturn(rc, rc);
273
274	/*
275	* Insert all MSR ranges of KVM.
276	*/
277	for (unsigned i = 0; i < RT_ELEMENTS(g_aMsrRanges_Kvm); i++)
278	{
279	rc = CPUMR3MsrRangesInsert(pVM, &g_aMsrRanges_Kvm[i]);
280	AssertLogRelRCReturn(rc, rc);
281	}
282
283	/*
284	* Setup hypercall and #UD handling.
285	* Note! We always need to trap VMCALL/VMMCALL hypercall using #UDs for raw-mode VMs.
286	*/
287	for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
288	EMSetHypercallInstructionsEnabled(pVM->apCpusR3[idCpu], true);
289
290	size_t cbHypercall = 0;
291	rc = GIMQueryHypercallOpcodeBytes(pVM, pKvm->abOpcodeNative, sizeof(pKvm->abOpcodeNative), &cbHypercall, &pKvm->uOpcodeNative);
292	AssertLogRelRCReturn(rc, rc);
293	AssertLogRelReturn(cbHypercall == sizeof(pKvm->abOpcodeNative), VERR_GIM_IPE_1);
294	pKvm->fTrapXcptUD = pKvm->uOpcodeNative != OP_VMCALL;
295
296	return VINF_SUCCESS;
297	}
298
299
300	/**
301	* Initializes remaining bits of the KVM provider.
302	*
303	* This is called after initializing HM and almost all other VMM components.
304	*
305	* @returns VBox status code.
306	* @param pVM The cross context VM structure.
307	*/
308	VMMR3_INT_DECL(int) gimR3KvmInitCompleted(PVM pVM)
309	{
310	PGIMKVM pKvm = &pVM->gim.s.u.Kvm;
311	pKvm->cTscTicksPerSecond = TMCpuTicksPerSecond(pVM);
312
313	if (TMR3CpuTickIsFixedRateMonotonic(pVM, true /* fWithParavirtEnabled */))
314	{
315	/** @todo We might want to consider just enabling this bit always. As far
316	* as I can see in the Linux guest, the "TSC_STABLE" bit is only
317	* translated as a "monotonic" bit which even in Async systems we
318	* -should- be reporting a strictly monotonic TSC to the guest. */
319	pKvm->uBaseFeat \|= GIM_KVM_BASE_FEAT_TSC_STABLE;
320
321	CPUMCPUIDLEAF HyperLeaf;
322	RT_ZERO(HyperLeaf);
323	HyperLeaf.uLeaf = UINT32_C(0x40000001);
324	HyperLeaf.uEax = pKvm->uBaseFeat;
325	HyperLeaf.uEbx = 0;
326	HyperLeaf.uEcx = 0;
327	HyperLeaf.uEdx = 0;
328	int rc = CPUMR3CpuIdInsert(pVM, &HyperLeaf);
329	AssertLogRelRCReturn(rc, rc);
330	}
331	return VINF_SUCCESS;
332	}
333
334
335	/**
336	* Terminates the KVM GIM provider.
337	*
338	* @returns VBox status code.
339	* @param pVM The cross context VM structure.
340	*/
341	VMMR3_INT_DECL(int) gimR3KvmTerm(PVM pVM)
342	{
343	gimR3KvmReset(pVM);
344	return VINF_SUCCESS;
345	}
346
347
348	/**
349	* This resets KVM provider MSRs and unmaps whatever KVM regions that
350	* the guest may have mapped.
351	*
352	* This is called when the VM is being reset.
353	*
354	* @param pVM The cross context VM structure.
355	* @thread EMT(0)
356	*/
357	VMMR3_INT_DECL(void) gimR3KvmReset(PVM pVM)
358	{
359	VM_ASSERT_EMT0(pVM);
360	LogRel(("GIM: KVM: Resetting MSRs\n"));
361
362	/*
363	* Reset MSRs.
364	*/
365	PGIMKVM pKvm = &pVM->gim.s.u.Kvm;
366	pKvm->u64WallClockMsr = 0;
367	for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
368	{
369	PGIMKVMCPU pKvmCpu = &pVM->apCpusR3[idCpu]->gim.s.u.KvmCpu;
370	pKvmCpu->u64SystemTimeMsr = 0;
371	pKvmCpu->u32SystemTimeVersion = 0;
372	pKvmCpu->fSystemTimeFlags = 0;
373	pKvmCpu->GCPhysSystemTime = 0;
374	pKvmCpu->uTsc = 0;
375	pKvmCpu->uVirtNanoTS = 0;
376	}
377	}
378
379
380	/**
381	* KVM state-save operation.
382	*
383	* @returns VBox status code.
384	* @param pVM The cross context VM structure.
385	* @param pSSM The saved state handle.
386	*/
387	VMMR3_INT_DECL(int) gimR3KvmSave(PVM pVM, PSSMHANDLE pSSM)
388	{
389	PCGIMKVM pKvm = &pVM->gim.s.u.Kvm;
390
391	/*
392	* Save the KVM SSM version.
393	*/
394	SSMR3PutU32(pSSM, GIM_KVM_SAVED_STATE_VERSION);
395
396	/*
397	* Save per-VCPU data.
398	*/
399	for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
400	{
401	PCGIMKVMCPU pKvmCpu = &pVM->apCpusR3[idCpu]->gim.s.u.KvmCpu;
402	SSMR3PutU64(pSSM, pKvmCpu->u64SystemTimeMsr);
403	SSMR3PutU64(pSSM, pKvmCpu->uTsc);
404	SSMR3PutU64(pSSM, pKvmCpu->uVirtNanoTS);
405	SSMR3PutGCPhys(pSSM, pKvmCpu->GCPhysSystemTime);
406	SSMR3PutU32(pSSM, pKvmCpu->u32SystemTimeVersion);
407	SSMR3PutU8(pSSM, pKvmCpu->fSystemTimeFlags);
408	}
409
410	/*
411	* Save per-VM data.
412	*/
413	SSMR3PutU64(pSSM, pKvm->u64WallClockMsr);
414	return SSMR3PutU32(pSSM, pKvm->uBaseFeat);
415	}
416
417
418	/**
419	* KVM state-load operation, final pass.
420	*
421	* @returns VBox status code.
422	* @param pVM The cross context VM structure.
423	* @param pSSM The saved state handle.
424	*/
425	VMMR3_INT_DECL(int) gimR3KvmLoad(PVM pVM, PSSMHANDLE pSSM)
426	{
427	/*
428	* Load the KVM SSM version first.
429	*/
430	uint32_t uKvmSavedStatVersion;
431	int rc = SSMR3GetU32(pSSM, &uKvmSavedStatVersion);
432	AssertRCReturn(rc, rc);
433	if (uKvmSavedStatVersion != GIM_KVM_SAVED_STATE_VERSION)
434	return SSMR3SetLoadError(pSSM, VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION, RT_SRC_POS,
435	N_("Unsupported KVM saved-state version %u (expected %u)."),
436	uKvmSavedStatVersion, GIM_KVM_SAVED_STATE_VERSION);
437
438	/*
439	* Update the TSC frequency from TM.
440	*/
441	PGIMKVM pKvm = &pVM->gim.s.u.Kvm;
442	pKvm->cTscTicksPerSecond = TMCpuTicksPerSecond(pVM);
443
444	/*
445	* Load per-VCPU data.
446	*/
447	for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
448	{
449	PVMCPU pVCpu = pVM->apCpusR3[idCpu];
450	PGIMKVMCPU pKvmCpu = &pVCpu->gim.s.u.KvmCpu;
451
452	SSMR3GetU64(pSSM, &pKvmCpu->u64SystemTimeMsr);
453	SSMR3GetU64(pSSM, &pKvmCpu->uTsc);
454	SSMR3GetU64(pSSM, &pKvmCpu->uVirtNanoTS);
455	SSMR3GetGCPhys(pSSM, &pKvmCpu->GCPhysSystemTime);
456	SSMR3GetU32(pSSM, &pKvmCpu->u32SystemTimeVersion);
457	rc = SSMR3GetU8(pSSM, &pKvmCpu->fSystemTimeFlags);
458	AssertRCReturn(rc, rc);
459
460	/* Enable the system-time struct. if necessary. */
461	/** @todo update guest struct only if cTscTicksPerSecond doesn't match host
462	* anymore. */
463	if (MSR_GIM_KVM_SYSTEM_TIME_IS_ENABLED(pKvmCpu->u64SystemTimeMsr))
464	{
465	Assert(!TMVirtualIsTicking(pVM)); /* paranoia. */
466	Assert(!TMCpuTickIsTicking(pVCpu));
467	gimR3KvmUpdateSystemTime(pVM, pVCpu);
468	}
469	}
470
471	/*
472	* Load per-VM data.
473	*/
474	SSMR3GetU64(pSSM, &pKvm->u64WallClockMsr);
475	rc = SSMR3GetU32(pSSM, &pKvm->uBaseFeat);
476	AssertRCReturn(rc, rc);
477
478	return VINF_SUCCESS;
479	}
480
481
482	/**
483	* Disables the KVM system-time struct.
484	*
485	* @returns VBox status code.
486	* @param pVM The cross context VM structure.
487	*/
488	VMMR3_INT_DECL(int) gimR3KvmDisableSystemTime(PVM pVM)
489	{
490	TMR3CpuTickParavirtDisable(pVM);
491	return VINF_SUCCESS;
492	}
493
494
495	/**
496	* @callback_method_impl{PFNVMMEMTRENDEZVOUS,
497	* Worker for gimR3KvmEnableWallClock}
498	*/
499	static DECLCALLBACK(VBOXSTRICTRC) gimR3KvmEnableWallClockCallback(PVM pVM, PVMCPU pVCpu, void *pvUser)
500	{
501	PKVMWALLCLOCKINFO pWallClockInfo = (PKVMWALLCLOCKINFO)pvUser; AssertPtr(pWallClockInfo);
502	RTGCPHYS GCPhysWallClock = pWallClockInfo->GCPhysWallClock;
503	RT_NOREF1(pVCpu);
504
505	/*
506	* Read the wall-clock version (sequence) from the guest.
507	*/
508	uint32_t uVersion;
509	Assert(PGMPhysIsGCPhysNormal(pVM, GCPhysWallClock));
510	int rc = PGMPhysSimpleReadGCPhys(pVM, &uVersion, GCPhysWallClock, sizeof(uVersion));
511	if (RT_FAILURE(rc))
512	{
513	LogRel(("GIM: KVM: Failed to read wall-clock struct. version at %#RGp. rc=%Rrc\n", GCPhysWallClock, rc));
514	return rc;
515	}
516
517	/*
518	* Ensure the version is incrementally even.
519	*/
520	/* faster: uVersion = (uVersion \| 1) + 1; */
521	if (!(uVersion & 1))
522	++uVersion;
523	++uVersion;
524
525	/*
526	* Update wall-clock guest struct. with UTC information.
527	*/
528	RTTIMESPEC TimeSpec;
529	int32_t iSec;
530	int32_t iNano;
531	TMR3UtcNow(pVM, &TimeSpec);
532	RTTimeSpecGetSecondsAndNano(&TimeSpec, &iSec, &iNano);
533
534	GIMKVMWALLCLOCK WallClock;
535	RT_ZERO(WallClock);
536	AssertCompile(sizeof(uVersion) == sizeof(WallClock.u32Version));
537	WallClock.u32Version = uVersion;
538	WallClock.u32Sec = iSec;
539	WallClock.u32Nano = iNano;
540
541	/*
542	* Write out the wall-clock struct. to guest memory.
543	*/
544	Assert(!(WallClock.u32Version & 1));
545	rc = PGMPhysSimpleWriteGCPhys(pVM, GCPhysWallClock, &WallClock, sizeof(GIMKVMWALLCLOCK));
546	if (RT_SUCCESS(rc))
547	LogRel(("GIM: KVM: Enabled wall-clock struct. at %#RGp - u32Sec=%u u32Nano=%u uVersion=%#RU32\n", GCPhysWallClock,
548	WallClock.u32Sec, WallClock.u32Nano, WallClock.u32Version));
549	else
550	LogRel(("GIM: KVM: Failed to write wall-clock struct. at %#RGp. rc=%Rrc\n", GCPhysWallClock, rc));
551	return rc;
552	}
553
554
555	/**
556	* Enables the KVM wall-clock structure.
557	*
558	* Since the wall-clock can be read by any VCPU but it is a global struct. in
559	* guest-memory, we do an EMT rendezvous here to be on the safe side. The
560	* alternative is to use an MMIO2 region and use the WallClock.u32Version field
561	* for transactional update. However, this MSR is rarely written to (typically
562	* once during bootup) it's currently not a performance issue especially since
563	* we're already in ring-3. If we really wanted better performance in this code
564	* path, we should be doing it in ring-0 with transactional update while make
565	* sure there is only 1 writer as well.
566	*
567	* @returns VBox status code.
568	* @param pVM The cross context VM structure.
569	* @param GCPhysWallClock Where the guest wall-clock structure is located.
570	*
571	* @remarks Don't do any release assertions here, these can be triggered by
572	* guest R0 code.
573	*/
574	VMMR3_INT_DECL(int) gimR3KvmEnableWallClock(PVM pVM, RTGCPHYS GCPhysWallClock)
575	{
576	KVMWALLCLOCKINFO WallClockInfo;
577	WallClockInfo.GCPhysWallClock = GCPhysWallClock;
578	return VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE, gimR3KvmEnableWallClockCallback, &WallClockInfo);
579	}
580
581
582	/**
583	* Enables the KVM system time structure.
584	*
585	* This can be done concurrently because the guest memory being updated is per-VCPU
586	* and the struct even has a "version" field which needs to be incremented
587	* before/after altering guest memory to allow concurrent updates from the host.
588	* Hence this is not being done in an EMT rendezvous. It -is- done in ring-3 since
589	* we call into ring-3 only TM code in the end.
590	*
591	* @returns VBox status code.
592	* @param pVM The cross context VM structure.
593	* @param pVCpu The cross context virtual CPU structure.
594	* @param uMsrSystemTime The system time MSR value being written.
595	*/
596	VMMR3_INT_DECL(int) gimR3KvmEnableSystemTime(PVMCC pVM, PVMCPUCC pVCpu, uint64_t uMsrSystemTime)
597	{
598	Assert(uMsrSystemTime & MSR_GIM_KVM_SYSTEM_TIME_ENABLE_BIT);
599	PGIMKVM pKvm = &pVM->gim.s.u.Kvm;
600	PGIMKVMCPU pKvmCpu = &pVCpu->gim.s.u.KvmCpu;
601
602	/*
603	* Update the system-time struct.
604	* The system-time structs are usually placed at a different guest address for each VCPU.
605	*/
606	pKvmCpu->uTsc = TMCpuTickGetNoCheck(pVCpu);
607	pKvmCpu->uVirtNanoTS = ASMMultU64ByU32DivByU32(pKvmCpu->uTsc, RT_NS_1SEC, pKvm->cTscTicksPerSecond);
608	pKvmCpu->u64SystemTimeMsr = uMsrSystemTime;
609	pKvmCpu->GCPhysSystemTime = MSR_GIM_KVM_SYSTEM_TIME_GUEST_GPA(uMsrSystemTime);
610
611	int rc = gimR3KvmUpdateSystemTime(pVM, pVCpu);
612	if (RT_FAILURE(rc))
613	{
614	pKvmCpu->u64SystemTimeMsr = 0;
615	/* We shouldn't throw a #GP(0) here for buggy guests (neither does KVM apparently), see @bugref{8627}. */
616	}
617
618	return rc;
619	}
620

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

source: vbox/trunk/src/VBox/VMM/VMMR3/GIMKvm.cpp@ 93115

Download in other formats: