GIM.cpp@ 79538

Last change on this file since 79538 was 79264, checked in by vboxsync, 5 years ago
VMM: 'singaling' -> 'signalling' consistency.
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 79264 2019-06-21 05:43:43Z vboxsync $ */
2	/** @file
3	* GIM - Guest Interface Manager.
4	*/
5
6	/*
7	* Copyright (C) 2014-2019 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 be 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	*********************************************************************************************************************************/
75	static FNSSMINTSAVEEXEC gimR3Save;
76	static FNSSMINTLOADEXEC gimR3Load;
77	static FNSSMINTLOADDONE gimR3LoadDone;
78
79
80	/**
81	* Initializes the GIM.
82	*
83	* @returns VBox status code.
84	* @param pVM The cross context VM structure.
85	*/
86	VMMR3_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	*/
194	VMMR3_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	*/
221	static 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	*/
268	static 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	*/
330	static 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	*/
352	VMMR3_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	*/
377	VMMR3_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	*/
400	VMMR3_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	*/
424	VMMR3DECL(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	*/
438	VMMR3DECL(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 signalling reading of the next buffer.
465	* Optional, can be NULL.
466	* @thread EMT.
467	*/
468	VMMR3_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	*/
505	VMMR3_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	*/
540	VMMR3DECL(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	*/
567	static 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	*/
590	VMMR3_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	*/
623	VMMR3_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	*/
695	VMMR3_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	*/
718	VMMR3_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.

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

Download in other formats: