GIM.cpp@ 58393

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

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

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

Download in other formats: