VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMR3/GIM.cpp@ 74795

Last change on this file since 74795 was 72460, checked in by vboxsync, 6 years ago

GIM/Hv: Need to restore hypercall instruction enable state on load. (KVM always enables hypercall instructions, so nothing to do there.) bugref:9044
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 23.1 KB
Line 
1/* $Id: GIM.cpp 72460 2018-06-06 11:16:12Z vboxsync $ */
2/** @file
3 * GIM - Guest Interface Manager.
4 */
5
6/*
7 * Copyright (C) 2014-2017 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/** @page pg_gim GIM - The Guest Interface Manager
19 *
20 * The Guest Interface Manager abstracts an interface provider through which
21 * guests may interact with the hypervisor.
22 *
23 * @see grp_gim
24 *
25 *
26 * @section sec_gim_provider Providers
27 *
28 * A GIM provider implements a particular hypervisor interface such as Microsoft
29 * Hyper-V, Linux KVM and so on. It hooks into various components in the VMM to
30 * ease the guest in running under a recognized, virtualized environment.
31 *
32 * The GIM provider configured for the VM needs to be recognized by the guest OS
33 * in order to make use of features supported by the interface. Since it
34 * requires co-operation from the guest OS, a GIM provider may also referred to
35 * as a paravirtualization interface.
36 *
37 * One of the goals of having a paravirtualized interface is for enabling guests
38 * to be more accurate and efficient when operating in a virtualized
39 * environment. For instance, a guest OS which interfaces to VirtualBox through
40 * a GIM provider may rely on the provider for supplying the correct TSC
41 * frequency of the host processor. The guest can then avoid caliberating the
42 * TSC itself, resulting in higher accuracy and better performance.
43 *
44 * At most, only one GIM provider can be active for a running VM and cannot be
45 * changed during the lifetime of the VM.
46 */
47
48
49/*********************************************************************************************************************************
50* Header Files *
51*********************************************************************************************************************************/
52#define LOG_GROUP LOG_GROUP_GIM
53#include <VBox/vmm/gim.h>
54#include <VBox/vmm/hm.h>
55#include <VBox/vmm/ssm.h>
56#include <VBox/vmm/pdmdev.h>
57#include "GIMInternal.h"
58#include <VBox/vmm/vm.h>
59
60#include <VBox/log.h>
61
62#include <iprt/err.h>
63#include <iprt/semaphore.h>
64#include <iprt/string.h>
65
66/* Include all GIM providers. */
67#include "GIMMinimalInternal.h"
68#include "GIMHvInternal.h"
69#include "GIMKvmInternal.h"
70
71
72/*********************************************************************************************************************************
73* Internal Functions *
74*********************************************************************************************************************************/
75static FNSSMINTSAVEEXEC gimR3Save;
76static FNSSMINTLOADEXEC gimR3Load;
77static FNSSMINTLOADDONE gimR3LoadDone;
78
79
80/**
81 * Initializes the GIM.
82 *
83 * @returns VBox status code.
84 * @param pVM The cross context VM structure.
85 */
86VMMR3_INT_DECL(int) GIMR3Init(PVM pVM)
87{
88 LogFlow(("GIMR3Init\n"));
89
90 /*
91 * Assert alignment and sizes.
92 */
93 AssertCompile(sizeof(pVM->gim.s) <= sizeof(pVM->gim.padding));
94 AssertCompile(sizeof(pVM->aCpus[0].gim.s) <= sizeof(pVM->aCpus[0].gim.padding));
95
96 /*
97 * Initialize members.
98 */
99 pVM->gim.s.hSemiReadOnlyMmio2Handler = NIL_PGMPHYSHANDLERTYPE;
100
101 /*
102 * Register the saved state data unit.
103 */
104 int rc = SSMR3RegisterInternal(pVM, "GIM", 0 /* uInstance */, GIM_SAVED_STATE_VERSION, sizeof(GIM),
105 NULL /* pfnLivePrep */, NULL /* pfnLiveExec */, NULL /* pfnLiveVote*/,
106 NULL /* pfnSavePrep */, gimR3Save, NULL /* pfnSaveDone */,
107 NULL /* pfnLoadPrep */, gimR3Load, gimR3LoadDone);
108 if (RT_FAILURE(rc))
109 return rc;
110
111 /*
112 * Read configuration.
113 */
114 PCFGMNODE pCfgNode = CFGMR3GetChild(CFGMR3GetRoot(pVM), "GIM/");
115
116 /*
117 * Validate the GIM settings.
118 */
119 rc = CFGMR3ValidateConfig(pCfgNode, "/GIM/", /* pszNode */
120 "Provider" /* pszValidValues */
121 "|Version",
122 "HyperV", /* pszValidNodes */
123 "GIM", /* pszWho */
124 0); /* uInstance */
125 if (RT_FAILURE(rc))
126 return rc;
127
128 /** @cfgm{/GIM/Provider, string}
129 * The name of the GIM provider. The default is "none". */
130 char szProvider[64];
131 rc = CFGMR3QueryStringDef(pCfgNode, "Provider", szProvider, sizeof(szProvider), "None");
132 AssertLogRelRCReturn(rc, rc);
133
134 /** @cfgm{/GIM/Version, uint32_t}
135 * The interface version. The default is 0, which means "provide the most
136 * up-to-date implementation". */
137 uint32_t uVersion;
138 rc = CFGMR3QueryU32Def(pCfgNode, "Version", &uVersion, 0 /* default */);
139 AssertLogRelRCReturn(rc, rc);
140
141 /*
142 * Setup the GIM provider for this VM.
143 */
144 LogRel(("GIM: Using provider '%s' (Implementation version: %u)\n", szProvider, uVersion));
145 if (!RTStrCmp(szProvider, "None"))
146 pVM->gim.s.enmProviderId = GIMPROVIDERID_NONE;
147 else
148 {
149 pVM->gim.s.u32Version = uVersion;
150 /** @todo r=bird: Because u32Version is saved, it should be translated to the
151 * 'most up-to-date implementation' version number when 0. Otherwise,
152 * we'll have abiguities when loading the state of older VMs. */
153 if (!RTStrCmp(szProvider, "Minimal"))
154 {
155 pVM->gim.s.enmProviderId = GIMPROVIDERID_MINIMAL;
156 rc = gimR3MinimalInit(pVM);
157 }
158 else if (!RTStrCmp(szProvider, "HyperV"))
159 {
160 pVM->gim.s.enmProviderId = GIMPROVIDERID_HYPERV;
161 rc = gimR3HvInit(pVM, pCfgNode);
162 }
163 else if (!RTStrCmp(szProvider, "KVM"))
164 {
165 pVM->gim.s.enmProviderId = GIMPROVIDERID_KVM;
166 rc = gimR3KvmInit(pVM);
167 }
168 else
169 rc = VMR3SetError(pVM->pUVM, VERR_GIM_INVALID_PROVIDER, RT_SRC_POS, "Provider '%s' unknown.", szProvider);
170 }
171
172 /*
173 * Statistics.
174 */
175 STAM_REL_REG_USED(pVM, &pVM->gim.s.StatDbgXmit, STAMTYPE_COUNTER, "/GIM/Debug/Transmit", STAMUNIT_OCCURENCES, "Debug packets sent.");
176 STAM_REL_REG_USED(pVM, &pVM->gim.s.StatDbgXmitBytes, STAMTYPE_COUNTER, "/GIM/Debug/TransmitBytes", STAMUNIT_OCCURENCES, "Debug bytes sent.");
177 STAM_REL_REG_USED(pVM, &pVM->gim.s.StatDbgRecv, STAMTYPE_COUNTER, "/GIM/Debug/Receive", STAMUNIT_OCCURENCES, "Debug packets received.");
178 STAM_REL_REG_USED(pVM, &pVM->gim.s.StatDbgRecvBytes, STAMTYPE_COUNTER, "/GIM/Debug/ReceiveBytes", STAMUNIT_OCCURENCES, "Debug bytes received.");
179
180 STAM_REL_REG_USED(pVM, &pVM->gim.s.StatHypercalls, STAMTYPE_COUNTER, "/GIM/Hypercalls", STAMUNIT_OCCURENCES, "Number of hypercalls initiated.");
181 return rc;
182}
183
184
185/**
186 * Initializes the remaining bits of the GIM provider.
187 *
188 * This is called after initializing HM and most other VMM components.
189 *
190 * @returns VBox status code.
191 * @param pVM The cross context VM structure.
192 * @thread EMT(0)
193 */
194VMMR3_INT_DECL(int) GIMR3InitCompleted(PVM pVM)
195{
196 switch (pVM->gim.s.enmProviderId)
197 {
198 case GIMPROVIDERID_MINIMAL:
199 return gimR3MinimalInitCompleted(pVM);
200
201 case GIMPROVIDERID_HYPERV:
202 return gimR3HvInitCompleted(pVM);
203
204 case GIMPROVIDERID_KVM:
205 return gimR3KvmInitCompleted(pVM);
206
207 default:
208 break;
209 }
210
211 if (!TMR3CpuTickIsFixedRateMonotonic(pVM, true /* fWithParavirtEnabled */))
212 LogRel(("GIM: Warning!!! Host TSC is unstable. The guest may behave unpredictably with a paravirtualized clock.\n"));
213
214 return VINF_SUCCESS;
215}
216
217
218/**
219 * @callback_method_impl{FNSSMINTSAVEEXEC}
220 */
221static DECLCALLBACK(int) gimR3Save(PVM pVM, PSSMHANDLE pSSM)
222{
223 AssertReturn(pVM, VERR_INVALID_PARAMETER);
224 AssertReturn(pSSM, VERR_SSM_INVALID_STATE);
225
226 int rc = VINF_SUCCESS;
227#if 0
228 /* Save per-CPU data. */
229 SSMR3PutU32(pSSM, pVM->cCpus);
230 for (VMCPUID i = 0; i < pVM->cCpus; i++)
231 {
232 rc = SSMR3PutXYZ(pSSM, pVM->aCpus[i].gim.s.XYZ);
233 }
234#endif
235
236 /*
237 * Save per-VM data.
238 */
239 SSMR3PutU32(pSSM, pVM->gim.s.enmProviderId);
240 SSMR3PutU32(pSSM, pVM->gim.s.u32Version);
241
242 /*
243 * Save provider-specific data.
244 */
245 switch (pVM->gim.s.enmProviderId)
246 {
247 case GIMPROVIDERID_HYPERV:
248 rc = gimR3HvSave(pVM, pSSM);
249 AssertRCReturn(rc, rc);
250 break;
251
252 case GIMPROVIDERID_KVM:
253 rc = gimR3KvmSave(pVM, pSSM);
254 AssertRCReturn(rc, rc);
255 break;
256
257 default:
258 break;
259 }
260
261 return rc;
262}
263
264
265/**
266 * @callback_method_impl{FNSSMINTLOADEXEC}
267 */
268static DECLCALLBACK(int) gimR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
269{
270 if (uPass != SSM_PASS_FINAL)
271 return VINF_SUCCESS;
272 if (uVersion != GIM_SAVED_STATE_VERSION)
273 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
274
275 int rc;
276#if 0
277 /* Load per-CPU data. */
278 for (VMCPUID i = 0; i < pVM->cCpus; i++)
279 {
280 rc = SSMR3PutXYZ(pSSM, pVM->aCpus[i].gim.s.XYZ);
281 }
282#endif
283
284 /*
285 * Load per-VM data.
286 */
287 uint32_t uProviderId;
288 uint32_t uProviderVersion;
289
290 rc = SSMR3GetU32(pSSM, &uProviderId); AssertRCReturn(rc, rc);
291 rc = SSMR3GetU32(pSSM, &uProviderVersion); AssertRCReturn(rc, rc);
292
293 if ((GIMPROVIDERID)uProviderId != pVM->gim.s.enmProviderId)
294 return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Saved GIM provider %u differs from the configured one (%u)."),
295 uProviderId, pVM->gim.s.enmProviderId);
296#if 0 /** @todo r=bird: Figure out what you mean to do here with the version. */
297 if (uProviderVersion != pVM->gim.s.u32Version)
298 return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Saved GIM provider version %u differs from the configured one (%u)."),
299 uProviderVersion, pVM->gim.s.u32Version);
300#else
301 pVM->gim.s.u32Version = uProviderVersion;
302#endif
303
304 /*
305 * Load provider-specific data.
306 */
307 switch (pVM->gim.s.enmProviderId)
308 {
309 case GIMPROVIDERID_HYPERV:
310 rc = gimR3HvLoad(pVM, pSSM);
311 AssertRCReturn(rc, rc);
312 break;
313
314 case GIMPROVIDERID_KVM:
315 rc = gimR3KvmLoad(pVM, pSSM);
316 AssertRCReturn(rc, rc);
317 break;
318
319 default:
320 break;
321 }
322
323 return VINF_SUCCESS;
324}
325
326
327/**
328 * @callback_method_impl{FNSSMINTLOADDONE}
329 */
330static DECLCALLBACK(int) gimR3LoadDone(PVM pVM, PSSMHANDLE pSSM)
331{
332 switch (pVM->gim.s.enmProviderId)
333 {
334 case GIMPROVIDERID_HYPERV:
335 return gimR3HvLoadDone(pVM, pSSM);
336
337 default:
338 return VINF_SUCCESS;
339 }
340}
341
342
343/**
344 * Terminates the GIM.
345 *
346 * Termination means cleaning up and freeing all resources,
347 * the VM itself is, at this point, powered off or suspended.
348 *
349 * @returns VBox status code.
350 * @param pVM The cross context VM structure.
351 */
352VMMR3_INT_DECL(int) GIMR3Term(PVM pVM)
353{
354 switch (pVM->gim.s.enmProviderId)
355 {
356 case GIMPROVIDERID_HYPERV:
357 return gimR3HvTerm(pVM);
358
359 case GIMPROVIDERID_KVM:
360 return gimR3KvmTerm(pVM);
361
362 default:
363 break;
364 }
365 return VINF_SUCCESS;
366}
367
368
369/**
370 * Applies relocations to data and code managed by this
371 * component. This function will be called at init and
372 * whenever the VMM need to relocate it self inside the GC.
373 *
374 * @param pVM The cross context VM structure.
375 * @param offDelta Relocation delta relative to old location.
376 */
377VMMR3_INT_DECL(void) GIMR3Relocate(PVM pVM, RTGCINTPTR offDelta)
378{
379 switch (pVM->gim.s.enmProviderId)
380 {
381 case GIMPROVIDERID_HYPERV:
382 gimR3HvRelocate(pVM, offDelta);
383 break;
384
385 default:
386 break;
387 }
388}
389
390
391/**
392 * The VM is being reset.
393 *
394 * For the GIM component this means unmapping and unregistering MMIO2 regions
395 * and other provider-specific resets.
396 *
397 * @returns VBox status code.
398 * @param pVM The cross context VM structure.
399 */
400VMMR3_INT_DECL(void) GIMR3Reset(PVM pVM)
401{
402 switch (pVM->gim.s.enmProviderId)
403 {
404 case GIMPROVIDERID_HYPERV:
405 return gimR3HvReset(pVM);
406
407 case GIMPROVIDERID_KVM:
408 return gimR3KvmReset(pVM);
409
410 default:
411 break;
412 }
413}
414
415
416/**
417 * Registers the GIM device with VMM.
418 *
419 * @param pVM The cross context VM structure.
420 * @param pDevIns Pointer to the GIM device instance.
421 * @param pDbg Pointer to the GIM device debug structure, can be
422 * NULL.
423 */
424VMMR3DECL(void) GIMR3GimDeviceRegister(PVM pVM, PPDMDEVINS pDevIns, PGIMDEBUG pDbg)
425{
426 pVM->gim.s.pDevInsR3 = pDevIns;
427 pVM->gim.s.pDbgR3 = pDbg;
428}
429
430
431/**
432 * Gets debug setup specified by the provider.
433 *
434 * @returns VBox status code.
435 * @param pVM The cross context VM structure.
436 * @param pDbgSetup Where to store the debug setup details.
437 */
438VMMR3DECL(int) GIMR3GetDebugSetup(PVM pVM, PGIMDEBUGSETUP pDbgSetup)
439{
440 AssertReturn(pVM, VERR_INVALID_PARAMETER);
441 AssertReturn(pDbgSetup, VERR_INVALID_PARAMETER);
442
443 switch (pVM->gim.s.enmProviderId)
444 {
445 case GIMPROVIDERID_HYPERV:
446 return gimR3HvGetDebugSetup(pVM, pDbgSetup);
447 default:
448 break;
449 }
450 return VERR_GIM_NO_DEBUG_CONNECTION;
451}
452
453
454/**
455 * Read data from a host debug session.
456 *
457 * @returns VBox status code.
458 *
459 * @param pVM The cross context VM structure.
460 * @param pvRead The read buffer.
461 * @param pcbRead The size of the read buffer as well as where to store
462 * the number of bytes read.
463 * @param pfnReadComplete Callback when the buffer has been read and
464 * before signaling reading of the next buffer.
465 * Optional, can be NULL.
466 * @thread EMT.
467 */
468VMMR3_INT_DECL(int) gimR3DebugRead(PVM pVM, void *pvRead, size_t *pcbRead, PFNGIMDEBUGBUFREADCOMPLETED pfnReadComplete)
469{
470 PGIMDEBUG pDbg = pVM->gim.s.pDbgR3;
471 if (pDbg)
472 {
473 if (ASMAtomicReadBool(&pDbg->fDbgRecvBufRead) == true)
474 {
475 STAM_REL_COUNTER_INC(&pVM->gim.s.StatDbgRecv);
476 STAM_REL_COUNTER_ADD(&pVM->gim.s.StatDbgRecvBytes, pDbg->cbDbgRecvBufRead);
477
478 memcpy(pvRead, pDbg->pvDbgRecvBuf, pDbg->cbDbgRecvBufRead);
479 *pcbRead = pDbg->cbDbgRecvBufRead;
480 if (pfnReadComplete)
481 pfnReadComplete(pVM);
482 RTSemEventMultiSignal(pDbg->hDbgRecvThreadSem);
483 ASMAtomicWriteBool(&pDbg->fDbgRecvBufRead, false);
484 return VINF_SUCCESS;
485 }
486 else
487 *pcbRead = 0;
488 return VERR_NO_DATA;
489 }
490 return VERR_GIM_NO_DEBUG_CONNECTION;
491}
492
493
494/**
495 * Write data to a host debug session.
496 *
497 * @returns VBox status code.
498 *
499 * @param pVM The cross context VM structure.
500 * @param pvWrite The write buffer.
501 * @param pcbWrite The size of the write buffer as well as where to store
502 * the number of bytes written.
503 * @thread EMT.
504 */
505VMMR3_INT_DECL(int) gimR3DebugWrite(PVM pVM, void *pvWrite, size_t *pcbWrite)
506{
507 PGIMDEBUG pDbg = pVM->gim.s.pDbgR3;
508 if (pDbg)
509 {
510 PPDMISTREAM pDbgStream = pDbg->pDbgDrvStream;
511 if (pDbgStream)
512 {
513 size_t cbWrite = *pcbWrite;
514 int rc = pDbgStream->pfnWrite(pDbgStream, pvWrite, pcbWrite);
515 if ( RT_SUCCESS(rc)
516 && *pcbWrite == cbWrite)
517 {
518 STAM_REL_COUNTER_INC(&pVM->gim.s.StatDbgXmit);
519 STAM_REL_COUNTER_ADD(&pVM->gim.s.StatDbgXmitBytes, *pcbWrite);
520 }
521 return rc;
522 }
523 }
524 return VERR_GIM_NO_DEBUG_CONNECTION;
525}
526
527
528/**
529 * Returns the array of MMIO2 regions that are expected to be registered and
530 * later mapped into the guest-physical address space for the GIM provider
531 * configured for the VM.
532 *
533 * @returns Pointer to an array of GIM MMIO2 regions, may return NULL.
534 * @param pVM The cross context VM structure.
535 * @param pcRegions Where to store the number of items in the array.
536 *
537 * @remarks The caller does not own and therefore must -NOT- try to free the
538 * returned pointer.
539 */
540VMMR3DECL(PGIMMMIO2REGION) GIMR3GetMmio2Regions(PVM pVM, uint32_t *pcRegions)
541{
542 Assert(pVM);
543 Assert(pcRegions);
544
545 *pcRegions = 0;
546 switch (pVM->gim.s.enmProviderId)
547 {
548 case GIMPROVIDERID_HYPERV:
549 return gimR3HvGetMmio2Regions(pVM, pcRegions);
550
551 default:
552 break;
553 }
554
555 return NULL;
556}
557
558#if 0 /* ??? */
559
560/**
561 * @callback_method_impl{FNPGMPHYSHANDLER,
562 * Write access handler for mapped MMIO2 pages. Currently ignores writes.}
563 *
564 * @todo In the future we might want to let the GIM provider decide what the
565 * handler should do (like throwing \#GP faults).
566 */
567static DECLCALLBACK(VBOXSTRICTRC) gimR3Mmio2WriteHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf,
568 size_t cbBuf, PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin,
569 void *pvUser)
570{
571 RT_NOREF6(pVM, pVCpu, GCPhys, pvPhys, pvBuf, cbBuf);
572 RT_NOREF3(enmAccessType, enmOrigin, pvUser);
573
574 /*
575 * Ignore writes to the mapped MMIO2 page.
576 */
577 Assert(enmAccessType == PGMACCESSTYPE_WRITE);
578 return VINF_SUCCESS; /** @todo Hyper-V says we should \#GP(0) fault for writes to the Hypercall and TSC page. */
579}
580
581
582/**
583 * Unmaps a registered MMIO2 region in the guest address space and removes any
584 * access handlers for it.
585 *
586 * @returns VBox status code.
587 * @param pVM The cross context VM structure.
588 * @param pRegion Pointer to the GIM MMIO2 region.
589 */
590VMMR3_INT_DECL(int) gimR3Mmio2Unmap(PVM pVM, PGIMMMIO2REGION pRegion)
591{
592 AssertPtr(pVM);
593 AssertPtr(pRegion);
594
595 PPDMDEVINS pDevIns = pVM->gim.s.pDevInsR3;
596 AssertPtr(pDevIns);
597 if (pRegion->fMapped)
598 {
599 int rc = PGMHandlerPhysicalDeregister(pVM, pRegion->GCPhysPage);
600 AssertRC(rc);
601
602 rc = PDMDevHlpMMIO2Unmap(pDevIns, pRegion->iRegion, pRegion->GCPhysPage);
603 if (RT_SUCCESS(rc))
604 {
605 pRegion->fMapped = false;
606 pRegion->GCPhysPage = NIL_RTGCPHYS;
607 }
608 }
609 return VINF_SUCCESS;
610}
611
612
613/**
614 * Maps a registered MMIO2 region in the guest address space.
615 *
616 * The region will be made read-only and writes from the guest will be ignored.
617 *
618 * @returns VBox status code.
619 * @param pVM The cross context VM structure.
620 * @param pRegion Pointer to the GIM MMIO2 region.
621 * @param GCPhysRegion Where in the guest address space to map the region.
622 */
623VMMR3_INT_DECL(int) GIMR3Mmio2Map(PVM pVM, PGIMMMIO2REGION pRegion, RTGCPHYS GCPhysRegion)
624{
625 PPDMDEVINS pDevIns = pVM->gim.s.pDevInsR3;
626 AssertPtr(pDevIns);
627
628 /* The guest-physical address must be page-aligned. */
629 if (GCPhysRegion & PAGE_OFFSET_MASK)
630 {
631 LogFunc(("%s: %#RGp not paging aligned\n", pRegion->szDescription, GCPhysRegion));
632 return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
633 }
634
635 /* Allow only normal pages to be overlaid using our MMIO2 pages (disallow MMIO, ROM, reserved pages). */
636 /** @todo Hyper-V doesn't seem to be very strict about this, may be relax
637 * later if some guest really requires it. */
638 if (!PGMPhysIsGCPhysNormal(pVM, GCPhysRegion))
639 {
640 LogFunc(("%s: %#RGp is not normal memory\n", pRegion->szDescription, GCPhysRegion));
641 return VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
642 }
643
644 if (!pRegion->fRegistered)
645 {
646 LogFunc(("%s: Region has not been registered.\n", pRegion->szDescription));
647 return VERR_GIM_IPE_1;
648 }
649
650 /*
651 * Map the MMIO2 region over the specified guest-physical address.
652 */
653 int rc = PDMDevHlpMMIOExMap(pDevIns, NULL, pRegion->iRegion, GCPhysRegion);
654 if (RT_SUCCESS(rc))
655 {
656 /*
657 * Install access-handlers for the mapped page to prevent (ignore) writes to it
658 * from the guest.
659 */
660 if (pVM->gim.s.hSemiReadOnlyMmio2Handler == NIL_PGMPHYSHANDLERTYPE)
661 rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_WRITE,
662 gimR3Mmio2WriteHandler,
663 NULL /* pszModR0 */, NULL /* pszHandlerR0 */, NULL /* pszPfHandlerR0 */,
664 NULL /* pszModRC */, NULL /* pszHandlerRC */, NULL /* pszPfHandlerRC */,
665 "GIM read-only MMIO2 handler",
666 &pVM->gim.s.hSemiReadOnlyMmio2Handler);
667 if (RT_SUCCESS(rc))
668 {
669 rc = PGMHandlerPhysicalRegister(pVM, GCPhysRegion, GCPhysRegion + (pRegion->cbRegion - 1),
670 pVM->gim.s.hSemiReadOnlyMmio2Handler,
671 NULL /* pvUserR3 */, NIL_RTR0PTR /* pvUserR0 */, NIL_RTRCPTR /* pvUserRC */,
672 pRegion->szDescription);
673 if (RT_SUCCESS(rc))
674 {
675 pRegion->fMapped = true;
676 pRegion->GCPhysPage = GCPhysRegion;
677 return rc;
678 }
679 }
680
681 PDMDevHlpMMIO2Unmap(pDevIns, pRegion->iRegion, GCPhysRegion);
682 }
683
684 return rc;
685}
686
687
688/**
689 * Registers the physical handler for the registered and mapped MMIO2 region.
690 *
691 * @returns VBox status code.
692 * @param pVM The cross context VM structure.
693 * @param pRegion Pointer to the GIM MMIO2 region.
694 */
695VMMR3_INT_DECL(int) gimR3Mmio2HandlerPhysicalRegister(PVM pVM, PGIMMMIO2REGION pRegion)
696{
697 AssertPtr(pRegion);
698 AssertReturn(pRegion->fRegistered, VERR_GIM_IPE_2);
699 AssertReturn(pRegion->fMapped, VERR_GIM_IPE_3);
700
701 return PGMR3HandlerPhysicalRegister(pVM,
702 PGMPHYSHANDLERKIND_WRITE,
703 pRegion->GCPhysPage, pRegion->GCPhysPage + (pRegion->cbRegion - 1),
704 gimR3Mmio2WriteHandler, NULL /* pvUserR3 */,
705 NULL /* pszModR0 */, NULL /* pszHandlerR0 */, NIL_RTR0PTR /* pvUserR0 */,
706 NULL /* pszModRC */, NULL /* pszHandlerRC */, NIL_RTRCPTR /* pvUserRC */,
707 pRegion->szDescription);
708}
709
710
711/**
712 * Deregisters the physical handler for the MMIO2 region.
713 *
714 * @returns VBox status code.
715 * @param pVM The cross context VM structure.
716 * @param pRegion Pointer to the GIM MMIO2 region.
717 */
718VMMR3_INT_DECL(int) gimR3Mmio2HandlerPhysicalDeregister(PVM pVM, PGIMMMIO2REGION pRegion)
719{
720 return PGMHandlerPhysicalDeregister(pVM, pRegion->GCPhysPage);
721}
722
723#endif
724
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use