VirtualBox

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

Last change on this file since 87765 was 86123, checked in by vboxsync, 4 years ago

VMM/GIM: Comment.
  • 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 86123 2020-09-14 17:11:45Z vboxsync $ */
2/** @file
3 * GIM - Guest Interface Manager, KVM implementation.
4 */
5
6/*
7 * Copyright (C) 2015-2020 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 */
56typedef 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. */
62typedef 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 */
79static 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 */
96static 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 */
218VMMR3_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 */
308VMMR3_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 */
341VMMR3_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 */
357VMMR3_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 */
387VMMR3_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 */
425VMMR3_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 */
488VMMR3_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 */
499static 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 */
574VMMR3_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 */
596VMMR3_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.

© 2023 Oracle
Contact – Privacy policy – Terms of Use