VirtualBox

About
Screenshots
Downloads
Documentation
End-user docs
Technical docs
Contribute
Community

Browse Source

Context Navigation

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

Last change on this file since 74795 was 70948, checked in by vboxsync, 6 years ago
VMM: Added a bMainExecutionEngine member to the VM structure for use instead of fHMEnabled and fNEMEnabled. Changed a lot of HMIsEnabled invocations to use the new macros VM_IS_RAW_MODE_ENABLED and VM_IS_HM_OR_NEM_ENABLED. Eliminated fHMEnabledFixed. Fixed inverted test for raw-mode debug register sanity checking. Some other minor cleanups.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 162.3 KB

Line
1	/* $Id: PDMDevHlp.cpp 70948 2018-02-10 15:38:12Z vboxsync $ */
2	/** @file
3	* PDM - Pluggable Device and Driver Manager, Device Helpers.
4	*/
5
6	/*
7	* Copyright (C) 2006-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
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_PDM_DEVICE
23	#define PDMPCIDEV_INCLUDE_PRIVATE /* Hack to get pdmpcidevint.h included at the right point. */
24	#include "PDMInternal.h"
25	#include <VBox/vmm/pdm.h>
26	#include <VBox/vmm/mm.h>
27	#include <VBox/vmm/hm.h>
28	#include <VBox/vmm/pgm.h>
29	#include <VBox/vmm/iom.h>
30	#ifdef VBOX_WITH_REM
31	# include <VBox/vmm/rem.h>
32	#endif
33	#include <VBox/vmm/dbgf.h>
34	#include <VBox/vmm/vmapi.h>
35	#include <VBox/vmm/vm.h>
36	#include <VBox/vmm/uvm.h>
37	#include <VBox/vmm/vmm.h>
38
39	#include <VBox/version.h>
40	#include <VBox/log.h>
41	#include <VBox/err.h>
42	#include <iprt/asm.h>
43	#include <iprt/assert.h>
44	#include <iprt/ctype.h>
45	#include <iprt/string.h>
46	#include <iprt/thread.h>
47
48	#include "dtrace/VBoxVMM.h"
49	#include "PDMInline.h"
50
51
52	/*********************************************************************************************************************************
53	* Defined Constants And Macros *
54	*********************************************************************************************************************************/
55	/** @def PDM_DEVHLP_DEADLOCK_DETECTION
56	* Define this to enable the deadlock detection when accessing physical memory.
57	*/
58	#if /defined(DEBUG_bird) \|\|/ defined(DOXYGEN_RUNNING)
59	# define PDM_DEVHLP_DEADLOCK_DETECTION /*< @todo enable DevHlp deadlock detection! /
60	#endif
61
62
63
64	/**
65	* Wrapper around PDMR3LdrGetSymbolRCLazy.
66	*/
67	DECLINLINE(int) pdmR3DevGetSymbolRCLazy(PPDMDEVINS pDevIns, const char *pszSymbol, PRTRCPTR ppvValue)
68	{
69	PVM pVM = pDevIns->Internal.s.pVMR3;
70	if (!VM_IS_RAW_MODE_ENABLED(pVM))
71	{
72	*ppvValue = NIL_RTRCPTR;
73	return VINF_SUCCESS;
74	}
75	return PDMR3LdrGetSymbolRCLazy(pVM,
76	pDevIns->Internal.s.pDevR3->pReg->szRCMod,
77	pDevIns->Internal.s.pDevR3->pszRCSearchPath,
78	pszSymbol, ppvValue);
79	}
80
81
82	/**
83	* Wrapper around PDMR3LdrGetSymbolR0Lazy.
84	*/
85	DECLINLINE(int) pdmR3DevGetSymbolR0Lazy(PPDMDEVINS pDevIns, const char *pszSymbol, PRTR0PTR ppvValue)
86	{
87	return PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3,
88	pDevIns->Internal.s.pDevR3->pReg->szR0Mod,
89	pDevIns->Internal.s.pDevR3->pszR0SearchPath,
90	pszSymbol, ppvValue);
91	}
92
93
94	/** @name R3 DevHlp
95	* @{
96	*/
97
98
99	/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortRegister} */
100	static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegister(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts, RTHCPTR pvUser, PFNIOMIOPORTOUT pfnOut, PFNIOMIOPORTIN pfnIn,
101	PFNIOMIOPORTOUTSTRING pfnOutStr, PFNIOMIOPORTINSTRING pfnInStr, const char *pszDesc)
102	{
103	PDMDEV_ASSERT_DEVINS(pDevIns);
104	LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pfnOut=%p pfnIn=%p pfnOutStr=%p pfnInStr=%p p32_tszDesc=%p:{%s}\n", pDevIns->pReg->szName, pDevIns->iInstance,
105	Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc, pszDesc));
106	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
107
108	#if 0 /** @todo needs a real string cache for this */
109	if (pDevIns->iInstance > 0)
110	{
111	char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s [%u]", pszDesc, pDevIns->iInstance);
112	if (pszDesc2)
113	pszDesc = pszDesc2;
114	}
115	#endif
116
117	int rc = IOMR3IOPortRegisterR3(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts, pvUser,
118	pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc);
119
120	LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
121	return rc;
122	}
123
124
125	/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortRegisterRC} */
126	static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegisterRC(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts, RTRCPTR pvUser,
127	const char pszOut, const char pszIn,
128	const char pszOutStr, const char pszInStr, const char *pszDesc)
129	{
130	PDMDEV_ASSERT_DEVINS(pDevIns);
131	PVM pVM = pDevIns->Internal.s.pVMR3;
132	VM_ASSERT_EMT(pVM);
133	LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n", pDevIns->pReg->szName, pDevIns->iInstance,
134	Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
135
136	/*
137	* Resolve the functions (one of the can be NULL).
138	*/
139	int rc = VINF_SUCCESS;
140	if ( pDevIns->pReg->szRCMod[0]
141	&& (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
142	&& VM_IS_RAW_MODE_ENABLED(pVM))
143	{
144	RTRCPTR RCPtrIn = NIL_RTRCPTR;
145	if (pszIn)
146	{
147	rc = pdmR3DevGetSymbolRCLazy(pDevIns, pszIn, &RCPtrIn);
148	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszIn)\n", pDevIns->pReg->szRCMod, pszIn));
149	}
150	RTRCPTR RCPtrOut = NIL_RTRCPTR;
151	if (pszOut && RT_SUCCESS(rc))
152	{
153	rc = pdmR3DevGetSymbolRCLazy(pDevIns, pszOut, &RCPtrOut);
154	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOut)\n", pDevIns->pReg->szRCMod, pszOut));
155	}
156	RTRCPTR RCPtrInStr = NIL_RTRCPTR;
157	if (pszInStr && RT_SUCCESS(rc))
158	{
159	rc = pdmR3DevGetSymbolRCLazy(pDevIns, pszInStr, &RCPtrInStr);
160	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszInStr)\n", pDevIns->pReg->szRCMod, pszInStr));
161	}
162	RTRCPTR RCPtrOutStr = NIL_RTRCPTR;
163	if (pszOutStr && RT_SUCCESS(rc))
164	{
165	rc = pdmR3DevGetSymbolRCLazy(pDevIns, pszOutStr, &RCPtrOutStr);
166	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOutStr)\n", pDevIns->pReg->szRCMod, pszOutStr));
167	}
168
169	if (RT_SUCCESS(rc))
170	{
171	#if 0 /** @todo needs a real string cache for this */
172	if (pDevIns->iInstance > 0)
173	{
174	char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s [%u]", pszDesc, pDevIns->iInstance);
175	if (pszDesc2)
176	pszDesc = pszDesc2;
177	}
178	#endif
179
180	rc = IOMR3IOPortRegisterRC(pVM, pDevIns, Port, cPorts, pvUser, RCPtrOut, RCPtrIn, RCPtrOutStr, RCPtrInStr, pszDesc);
181	}
182	}
183	else if (VM_IS_RAW_MODE_ENABLED(pVM))
184	{
185	AssertMsgFailed(("No RC module for this driver!\n"));
186	rc = VERR_INVALID_PARAMETER;
187	}
188
189	LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
190	return rc;
191	}
192
193
194	/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortRegisterR0} */
195	static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegisterR0(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts, RTR0PTR pvUser,
196	const char pszOut, const char pszIn,
197	const char pszOutStr, const char pszInStr, const char *pszDesc)
198	{
199	PDMDEV_ASSERT_DEVINS(pDevIns);
200	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
201	LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n", pDevIns->pReg->szName, pDevIns->iInstance,
202	Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
203
204	/*
205	* Resolve the functions (one of the can be NULL).
206	*/
207	int rc = VINF_SUCCESS;
208	if ( pDevIns->pReg->szR0Mod[0]
209	&& (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0))
210	{
211	R0PTRTYPE(PFNIOMIOPORTIN) pfnR0PtrIn = 0;
212	if (pszIn)
213	{
214	rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pszIn, &pfnR0PtrIn);
215	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszIn)\n", pDevIns->pReg->szR0Mod, pszIn));
216	}
217	R0PTRTYPE(PFNIOMIOPORTOUT) pfnR0PtrOut = 0;
218	if (pszOut && RT_SUCCESS(rc))
219	{
220	rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pszOut, &pfnR0PtrOut);
221	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOut)\n", pDevIns->pReg->szR0Mod, pszOut));
222	}
223	R0PTRTYPE(PFNIOMIOPORTINSTRING) pfnR0PtrInStr = 0;
224	if (pszInStr && RT_SUCCESS(rc))
225	{
226	rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pszInStr, &pfnR0PtrInStr);
227	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszInStr)\n", pDevIns->pReg->szR0Mod, pszInStr));
228	}
229	R0PTRTYPE(PFNIOMIOPORTOUTSTRING) pfnR0PtrOutStr = 0;
230	if (pszOutStr && RT_SUCCESS(rc))
231	{
232	rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pszOutStr, &pfnR0PtrOutStr);
233	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOutStr)\n", pDevIns->pReg->szR0Mod, pszOutStr));
234	}
235
236	if (RT_SUCCESS(rc))
237	{
238	#if 0 /** @todo needs a real string cache for this */
239	if (pDevIns->iInstance > 0)
240	{
241	char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s [%u]", pszDesc, pDevIns->iInstance);
242	if (pszDesc2)
243	pszDesc = pszDesc2;
244	}
245	#endif
246
247	rc = IOMR3IOPortRegisterR0(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts, pvUser, pfnR0PtrOut, pfnR0PtrIn, pfnR0PtrOutStr, pfnR0PtrInStr, pszDesc);
248	}
249	}
250	else
251	{
252	AssertMsgFailed(("No R0 module for this driver!\n"));
253	rc = VERR_INVALID_PARAMETER;
254	}
255
256	LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
257	return rc;
258	}
259
260
261	/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortDeregister} */
262	static DECLCALLBACK(int) pdmR3DevHlp_IOPortDeregister(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts)
263	{
264	PDMDEV_ASSERT_DEVINS(pDevIns);
265	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
266	LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: Port=%#x cPorts=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance,
267	Port, cPorts));
268
269	int rc = IOMR3IOPortDeregister(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts);
270
271	LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
272	return rc;
273	}
274
275
276	/** @interface_method_impl{PDMDEVHLPR3,pfnMMIORegister} */
277	static DECLCALLBACK(int) pdmR3DevHlp_MMIORegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTGCPHYS cbRange, RTHCPTR pvUser,
278	PFNIOMMMIOWRITE pfnWrite, PFNIOMMMIOREAD pfnRead, PFNIOMMMIOFILL pfnFill,
279	uint32_t fFlags, const char *pszDesc)
280	{
281	PDMDEV_ASSERT_DEVINS(pDevIns);
282	PVM pVM = pDevIns->Internal.s.pVMR3;
283	VM_ASSERT_EMT(pVM);
284	LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%RGp pvUser=%p pfnWrite=%p pfnRead=%p pfnFill=%p fFlags=%#x pszDesc=%p:{%s}\n",
285	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc, fFlags, pszDesc));
286
287	if (pDevIns->iInstance > 0)
288	{
289	char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s [%u]", pszDesc, pDevIns->iInstance);
290	if (pszDesc2)
291	pszDesc = pszDesc2;
292	}
293
294	int rc = IOMR3MmioRegisterR3(pVM, pDevIns, GCPhysStart, cbRange, pvUser,
295	pfnWrite, pfnRead, pfnFill, fFlags, pszDesc);
296
297	LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
298	return rc;
299	}
300
301
302	/** @interface_method_impl{PDMDEVHLPR3,pfnMMIORegisterRC} */
303	static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterRC(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTGCPHYS cbRange, RTRCPTR pvUser,
304	const char pszWrite, const char pszRead, const char *pszFill)
305	{
306	PDMDEV_ASSERT_DEVINS(pDevIns);
307	PVM pVM = pDevIns->Internal.s.pVMR3;
308	VM_ASSERT_EMT(pVM);
309	LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: GCPhysStart=%RGp cbRange=%RGp pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
310	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
311
312
313	/*
314	* Resolve the functions.
315	* Not all function have to present, leave it to IOM to enforce this.
316	*/
317	int rc = VINF_SUCCESS;
318	if ( pDevIns->pReg->szRCMod[0]
319	&& (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
320	&& VM_IS_RAW_MODE_ENABLED(pVM))
321	{
322	RTRCPTR RCPtrWrite = NIL_RTRCPTR;
323	if (pszWrite)
324	rc = pdmR3DevGetSymbolRCLazy(pDevIns, pszWrite, &RCPtrWrite);
325
326	RTRCPTR RCPtrRead = NIL_RTRCPTR;
327	int rc2 = VINF_SUCCESS;
328	if (pszRead)
329	rc2 = pdmR3DevGetSymbolRCLazy(pDevIns, pszRead, &RCPtrRead);
330
331	RTRCPTR RCPtrFill = NIL_RTRCPTR;
332	int rc3 = VINF_SUCCESS;
333	if (pszFill)
334	rc3 = pdmR3DevGetSymbolRCLazy(pDevIns, pszFill, &RCPtrFill);
335
336	if (RT_SUCCESS(rc) && RT_SUCCESS(rc2) && RT_SUCCESS(rc3))
337	rc = IOMR3MmioRegisterRC(pVM, pDevIns, GCPhysStart, cbRange, pvUser, RCPtrWrite, RCPtrRead, RCPtrFill);
338	else
339	{
340	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszWrite)\n", pDevIns->pReg->szRCMod, pszWrite));
341	AssertMsgRC(rc2, ("Failed to resolve %s.%s (pszRead)\n", pDevIns->pReg->szRCMod, pszRead));
342	AssertMsgRC(rc3, ("Failed to resolve %s.%s (pszFill)\n", pDevIns->pReg->szRCMod, pszFill));
343	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
344	rc = rc2;
345	if (RT_FAILURE(rc3) && RT_SUCCESS(rc))
346	rc = rc3;
347	}
348	}
349	else if (VM_IS_RAW_MODE_ENABLED(pVM))
350	{
351	AssertMsgFailed(("No RC module for this driver!\n"));
352	rc = VERR_INVALID_PARAMETER;
353	}
354
355	LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
356	return rc;
357	}
358
359	/** @interface_method_impl{PDMDEVHLPR3,pfnMMIORegisterR0} */
360	static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterR0(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTGCPHYS cbRange, RTR0PTR pvUser,
361	const char pszWrite, const char pszRead, const char *pszFill)
362	{
363	PDMDEV_ASSERT_DEVINS(pDevIns);
364	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
365	LogFlow(("pdmR3DevHlp_MMIORegisterHC: caller='%s'/%d: GCPhysStart=%RGp cbRange=%RGp pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
366	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
367
368	/*
369	* Resolve the functions.
370	* Not all function have to present, leave it to IOM to enforce this.
371	*/
372	int rc = VINF_SUCCESS;
373	if ( pDevIns->pReg->szR0Mod[0]
374	&& (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0))
375	{
376	R0PTRTYPE(PFNIOMMMIOWRITE) pfnR0PtrWrite = 0;
377	if (pszWrite)
378	rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pszWrite, &pfnR0PtrWrite);
379	R0PTRTYPE(PFNIOMMMIOREAD) pfnR0PtrRead = 0;
380	int rc2 = VINF_SUCCESS;
381	if (pszRead)
382	rc2 = pdmR3DevGetSymbolR0Lazy(pDevIns, pszRead, &pfnR0PtrRead);
383	R0PTRTYPE(PFNIOMMMIOFILL) pfnR0PtrFill = 0;
384	int rc3 = VINF_SUCCESS;
385	if (pszFill)
386	rc3 = pdmR3DevGetSymbolR0Lazy(pDevIns, pszFill, &pfnR0PtrFill);
387	if (RT_SUCCESS(rc) && RT_SUCCESS(rc2) && RT_SUCCESS(rc3))
388	rc = IOMR3MmioRegisterR0(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvUser,
389	pfnR0PtrWrite, pfnR0PtrRead, pfnR0PtrFill);
390	else
391	{
392	AssertMsgRC(rc, ("Failed to resolve %s.%s (pszWrite)\n", pDevIns->pReg->szR0Mod, pszWrite));
393	AssertMsgRC(rc2, ("Failed to resolve %s.%s (pszRead)\n", pDevIns->pReg->szR0Mod, pszRead));
394	AssertMsgRC(rc3, ("Failed to resolve %s.%s (pszFill)\n", pDevIns->pReg->szR0Mod, pszFill));
395	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
396	rc = rc2;
397	if (RT_FAILURE(rc3) && RT_SUCCESS(rc))
398	rc = rc3;
399	}
400	}
401	else
402	{
403	AssertMsgFailed(("No R0 module for this driver!\n"));
404	rc = VERR_INVALID_PARAMETER;
405	}
406
407	LogFlow(("pdmR3DevHlp_MMIORegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
408	return rc;
409	}
410
411
412	/** @interface_method_impl{PDMDEVHLPR3,pfnMMIODeregister} */
413	static DECLCALLBACK(int) pdmR3DevHlp_MMIODeregister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTGCPHYS cbRange)
414	{
415	PDMDEV_ASSERT_DEVINS(pDevIns);
416	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
417	LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%RGp\n",
418	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange));
419
420	int rc = IOMR3MmioDeregister(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange);
421
422	LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
423	return rc;
424	}
425
426
427	/**
428	* @copydoc PDMDEVHLPR3::pfnMMIO2Register
429	*/
430	static DECLCALLBACK(int) pdmR3DevHlp_MMIO2Register(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS cb,
431	uint32_t fFlags, void *ppv, const char pszDesc)
432	{
433	PDMDEV_ASSERT_DEVINS(pDevIns);
434	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
435	LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: pPciDev=%p (%#x) iRegion=%#x cb=%#RGp fFlags=%RX32 ppv=%p pszDescp=%p:{%s}\n",
436	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion,
437	cb, fFlags, ppv, pszDesc, pszDesc));
438	AssertReturn(!pPciDev \|\| pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
439
440	/** @todo PGMR3PhysMMIO2Register mangles the description, move it here and
441	* use a real string cache. */
442	int rc = PGMR3PhysMMIO2Register(pDevIns->Internal.s.pVMR3, pDevIns, pPciDev ? pPciDev->Int.s.idxDevCfg : 254, iRegion,
443	cb, fFlags, ppv, pszDesc);
444
445	LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
446	return rc;
447	}
448
449
450	/**
451	* @interface_method_impl{PDMDEVHLPR3,pfnMMIOExPreRegister}
452	*/
453	static DECLCALLBACK(int)
454	pdmR3DevHlp_MMIOExPreRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS cbRegion, uint32_t fFlags,
455	const char *pszDesc,
456	RTHCPTR pvUser, PFNIOMMMIOWRITE pfnWrite, PFNIOMMMIOREAD pfnRead, PFNIOMMMIOFILL pfnFill,
457	RTR0PTR pvUserR0, const char pszWriteR0, const char pszReadR0, const char *pszFillR0,
458	RTRCPTR pvUserRC, const char pszWriteRC, const char pszReadRC, const char *pszFillRC)
459	{
460	PDMDEV_ASSERT_DEVINS(pDevIns);
461	PVM pVM = pDevIns->Internal.s.pVMR3;
462	VM_ASSERT_EMT(pVM);
463	LogFlow(("pdmR3DevHlp_MMIOExPreRegister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x cbRegion=%#RGp fFlags=%RX32 pszDesc=%p:{%s}\n"
464	" pvUser=%p pfnWrite=%p pfnRead=%p pfnFill=%p\n"
465	" pvUserR0=%p pszWriteR0=%s pszReadR0=%s pszFillR0=%s\n"
466	" pvUserRC=%p pszWriteRC=%s pszReadRC=%s pszFillRC=%s\n",
467	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, cbRegion,
468	fFlags, pszDesc, pszDesc,
469	pvUser, pfnWrite, pfnRead, pfnFill,
470	pvUserR0, pszWriteR0, pszReadR0, pszFillR0,
471	pvUserRC, pszWriteRC, pszReadRC, pszFillRC));
472	AssertReturn(!pPciDev \|\| pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
473
474	/*
475	* Resolve the functions.
476	*/
477	AssertLogRelReturn( (!pszWriteR0 && !pszReadR0 && !pszFillR0)
478	\|\| (pDevIns->pReg->szR0Mod[0] && (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)),
479	VERR_INVALID_PARAMETER);
480	AssertLogRelReturn( (!pszWriteRC && !pszReadRC && !pszFillRC)
481	\|\| (pDevIns->pReg->szRCMod[0] && (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)),
482	VERR_INVALID_PARAMETER);
483
484	/* Ring-0 */
485	int rc;
486	R0PTRTYPE(PFNIOMMMIOWRITE) pfnWriteR0 = 0;
487	if (pszWriteR0)
488	{
489	rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pszWriteR0, &pfnWriteR0);
490	AssertLogRelMsgRCReturn(rc, ("pszWriteR0=%s rc=%Rrc\n", pszWriteR0, rc), rc);
491	}
492
493	R0PTRTYPE(PFNIOMMMIOREAD) pfnReadR0 = 0;
494	if (pszReadR0)
495	{
496	rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pszReadR0, &pfnReadR0);
497	AssertLogRelMsgRCReturn(rc, ("pszReadR0=%s rc=%Rrc\n", pszReadR0, rc), rc);
498	}
499	R0PTRTYPE(PFNIOMMMIOFILL) pfnFillR0 = 0;
500	if (pszFillR0)
501	{
502	rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pszFillR0, &pfnFillR0);
503	AssertLogRelMsgRCReturn(rc, ("pszFillR0=%s rc=%Rrc\n", pszFillR0, rc), rc);
504	}
505
506	/* Raw-mode */
507	rc = VINF_SUCCESS;
508	RCPTRTYPE(PFNIOMMMIOWRITE) pfnWriteRC = 0;
509	if (pszWriteRC)
510	{
511	rc = pdmR3DevGetSymbolRCLazy(pDevIns, pszWriteRC, &pfnWriteRC);
512	AssertLogRelMsgRCReturn(rc, ("pszWriteRC=%s rc=%Rrc\n", pszWriteRC, rc), rc);
513	}
514
515	RCPTRTYPE(PFNIOMMMIOREAD) pfnReadRC = 0;
516	if (pszReadRC)
517	{
518	rc = pdmR3DevGetSymbolRCLazy(pDevIns, pszReadRC, &pfnReadRC);
519	AssertLogRelMsgRCReturn(rc, ("pszReadRC=%s rc=%Rrc\n", pszReadRC, rc), rc);
520	}
521	RCPTRTYPE(PFNIOMMMIOFILL) pfnFillRC = 0;
522	if (pszFillRC)
523	{
524	rc = pdmR3DevGetSymbolRCLazy(pDevIns, pszFillRC, &pfnFillRC);
525	AssertLogRelMsgRCReturn(rc, ("pszFillRC=%s rc=%Rrc\n", pszFillRC, rc), rc);
526	}
527
528	/*
529	* Call IOM to make the registration.
530	*/
531	rc = IOMR3MmioExPreRegister(pVM, pDevIns, pPciDev ? pPciDev->Int.s.idxDevCfg : 254, iRegion, cbRegion, fFlags, pszDesc,
532	pvUser, pfnWrite, pfnRead, pfnFill,
533	pvUserR0, pfnWriteR0, pfnReadR0, pfnFillR0,
534	pvUserRC, pfnWriteRC, pfnReadRC, pfnFillRC);
535
536	LogFlow(("pdmR3DevHlp_MMIOExPreRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
537	return rc;
538	}
539
540
541	/**
542	* @copydoc PDMDEVHLPR3::pfnMMIOExDeregister
543	*/
544	static DECLCALLBACK(int) pdmR3DevHlp_MMIOExDeregister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion)
545	{
546	PDMDEV_ASSERT_DEVINS(pDevIns);
547	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
548	LogFlow(("pdmR3DevHlp_MMIOExDeregister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x\n",
549	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion));
550
551	AssertReturn(iRegion <= UINT8_MAX \|\| iRegion == UINT32_MAX, VERR_INVALID_PARAMETER);
552	AssertReturn(!pPciDev \|\| pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
553
554	int rc = PGMR3PhysMMIOExDeregister(pDevIns->Internal.s.pVMR3, pDevIns, pPciDev ? pPciDev->Int.s.idxDevCfg : 254, iRegion);
555
556	LogFlow(("pdmR3DevHlp_MMIOExDeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
557	return rc;
558	}
559
560
561	/**
562	* @copydoc PDMDEVHLPR3::pfnMMIOExMap
563	*/
564	static DECLCALLBACK(int) pdmR3DevHlp_MMIOExMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS GCPhys)
565	{
566	PDMDEV_ASSERT_DEVINS(pDevIns);
567	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
568	LogFlow(("pdmR3DevHlp_MMIOExMap: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x GCPhys=%#RGp\n",
569	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, GCPhys));
570	AssertReturn(!pPciDev \|\| pPciDev->Int.s.pDevInsR3 != NULL, VERR_INVALID_PARAMETER);
571
572	int rc = PGMR3PhysMMIOExMap(pDevIns->Internal.s.pVMR3, pDevIns, pPciDev ? pPciDev->Int.s.idxDevCfg : 254, iRegion, GCPhys);
573
574	LogFlow(("pdmR3DevHlp_MMIOExMap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
575	return rc;
576	}
577
578
579	/**
580	* @copydoc PDMDEVHLPR3::pfnMMIOExUnmap
581	*/
582	static DECLCALLBACK(int) pdmR3DevHlp_MMIOExUnmap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS GCPhys)
583	{
584	PDMDEV_ASSERT_DEVINS(pDevIns);
585	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
586	LogFlow(("pdmR3DevHlp_MMIOExUnmap: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x GCPhys=%#RGp\n",
587	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, GCPhys));
588	AssertReturn(!pPciDev \|\| pPciDev->Int.s.pDevInsR3 != NULL, VERR_INVALID_PARAMETER);
589
590	int rc = PGMR3PhysMMIOExUnmap(pDevIns->Internal.s.pVMR3, pDevIns, pPciDev ? pPciDev->Int.s.idxDevCfg : 254, iRegion, GCPhys);
591
592	LogFlow(("pdmR3DevHlp_MMIOExUnmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
593	return rc;
594	}
595
596
597	/**
598	* @copydoc PDMDEVHLPR3::pfnMMIOExReduce
599	*/
600	static DECLCALLBACK(int) pdmR3DevHlp_MMIOExReduce(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS cbRegion)
601	{
602	PDMDEV_ASSERT_DEVINS(pDevIns);
603	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
604	LogFlow(("pdmR3DevHlp_MMIOExReduce: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x cbRegion=%RGp\n",
605	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, cbRegion));
606	AssertReturn(!pPciDev \|\| pPciDev->Int.s.pDevInsR3 != NULL, VERR_INVALID_PARAMETER);
607
608	int rc = PGMR3PhysMMIOExReduce(pDevIns->Internal.s.pVMR3, pDevIns, pPciDev ? pPciDev->Int.s.idxDevCfg : 254, iRegion, cbRegion);
609
610	LogFlow(("pdmR3DevHlp_MMIOExReduce: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
611	return rc;
612	}
613
614
615	/**
616	* @copydoc PDMDEVHLPR3::pfnMMHyperMapMMIO2
617	*/
618	static DECLCALLBACK(int) pdmR3DevHlp_MMHyperMapMMIO2(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS off,
619	RTGCPHYS cb, const char *pszDesc, PRTRCPTR pRCPtr)
620	{
621	PDMDEV_ASSERT_DEVINS(pDevIns);
622	PVM pVM = pDevIns->Internal.s.pVMR3;
623	VM_ASSERT_EMT(pVM);
624	LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x off=%RGp cb=%RGp pszDesc=%p:{%s} pRCPtr=%p\n",
625	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, off, cb, pszDesc, pszDesc, pRCPtr));
626	AssertReturn(!pPciDev \|\| pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
627
628	if (pDevIns->iInstance > 0)
629	{
630	char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s [%u]", pszDesc, pDevIns->iInstance);
631	if (pszDesc2)
632	pszDesc = pszDesc2;
633	}
634
635	int rc = MMR3HyperMapMMIO2(pVM, pDevIns, pPciDev ? pPciDev->Int.s.idxDevCfg : 254, iRegion, off, cb, pszDesc, pRCPtr);
636
637	LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: returns %Rrc pRCPtr=%RRv\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, pRCPtr));
638	return rc;
639	}
640
641
642	/**
643	* @copydoc PDMDEVHLPR3::pfnMMIO2MapKernel
644	*/
645	static DECLCALLBACK(int) pdmR3DevHlp_MMIO2MapKernel(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS off,
646	RTGCPHYS cb,const char *pszDesc, PRTR0PTR pR0Ptr)
647	{
648	PDMDEV_ASSERT_DEVINS(pDevIns);
649	PVM pVM = pDevIns->Internal.s.pVMR3;
650	VM_ASSERT_EMT(pVM);
651	LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x off=%RGp cb=%RGp pszDesc=%p:{%s} pR0Ptr=%p\n",
652	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, off, cb, pszDesc, pszDesc, pR0Ptr));
653	AssertReturn(!pPciDev \|\| pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
654
655	if (pDevIns->iInstance > 0)
656	{
657	char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s [%u]", pszDesc, pDevIns->iInstance);
658	if (pszDesc2)
659	pszDesc = pszDesc2;
660	}
661
662	int rc = PGMR3PhysMMIO2MapKernel(pVM, pDevIns, pPciDev ? pPciDev->Int.s.idxDevCfg : 254, iRegion, off, cb, pszDesc, pR0Ptr);
663
664	LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: returns %Rrc pR0Ptr=%RHv\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, pR0Ptr));
665	return rc;
666	}
667
668
669	/** @interface_method_impl{PDMDEVHLPR3,pfnROMRegister} */
670	static DECLCALLBACK(int) pdmR3DevHlp_ROMRegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange,
671	const void pvBinary, uint32_t cbBinary, uint32_t fFlags, const char pszDesc)
672	{
673	PDMDEV_ASSERT_DEVINS(pDevIns);
674	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
675	LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvBinary=%p cbBinary=%#x fFlags=%#RX32 pszDesc=%p:{%s}\n",
676	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvBinary, cbBinary, fFlags, pszDesc, pszDesc));
677
678	/** @todo can we mangle pszDesc? */
679	int rc = PGMR3PhysRomRegister(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvBinary, cbBinary, fFlags, pszDesc);
680
681	LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
682	return rc;
683	}
684
685
686	/** @interface_method_impl{PDMDEVHLPR3,pfnROMProtectShadow} */
687	static DECLCALLBACK(int) pdmR3DevHlp_ROMProtectShadow(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange, PGMROMPROT enmProt)
688	{
689	PDMDEV_ASSERT_DEVINS(pDevIns);
690	LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x enmProt=%d\n",
691	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, enmProt));
692
693	int rc = PGMR3PhysRomProtect(pDevIns->Internal.s.pVMR3, GCPhysStart, cbRange, enmProt);
694
695	LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
696	return rc;
697	}
698
699
700	/** @interface_method_impl{PDMDEVHLPR3,pfnSSMRegister} */
701	static DECLCALLBACK(int) pdmR3DevHlp_SSMRegister(PPDMDEVINS pDevIns, uint32_t uVersion, size_t cbGuess, const char *pszBefore,
702	PFNSSMDEVLIVEPREP pfnLivePrep, PFNSSMDEVLIVEEXEC pfnLiveExec, PFNSSMDEVLIVEVOTE pfnLiveVote,
703	PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone,
704	PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone)
705	{
706	PDMDEV_ASSERT_DEVINS(pDevIns);
707	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
708	LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: uVersion=%#x cbGuess=%#x pszBefore=%p:{%s}\n"
709	" pfnLivePrep=%p pfnLiveExec=%p pfnLiveVote=%p pfnSavePrep=%p pfnSaveExec=%p pfnSaveDone=%p pszLoadPrep=%p pfnLoadExec=%p pfnLoadDone=%p\n",
710	pDevIns->pReg->szName, pDevIns->iInstance, uVersion, cbGuess, pszBefore, pszBefore,
711	pfnLivePrep, pfnLiveExec, pfnLiveVote,
712	pfnSavePrep, pfnSaveExec, pfnSaveDone,
713	pfnLoadPrep, pfnLoadExec, pfnLoadDone));
714
715	int rc = SSMR3RegisterDevice(pDevIns->Internal.s.pVMR3, pDevIns, pDevIns->pReg->szName, pDevIns->iInstance,
716	uVersion, cbGuess, pszBefore,
717	pfnLivePrep, pfnLiveExec, pfnLiveVote,
718	pfnSavePrep, pfnSaveExec, pfnSaveDone,
719	pfnLoadPrep, pfnLoadExec, pfnLoadDone);
720
721	LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
722	return rc;
723	}
724
725
726	/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimerCreate} */
727	static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void pvUser, uint32_t fFlags, const char pszDesc, PPTMTIMERR3 ppTimer)
728	{
729	PDMDEV_ASSERT_DEVINS(pDevIns);
730	PVM pVM = pDevIns->Internal.s.pVMR3;
731	VM_ASSERT_EMT(pVM);
732	LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} ppTimer=%p\n",
733	pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
734
735	if (pDevIns->iInstance > 0) /** @todo use a string cache here later. */
736	{
737	char *pszDesc2 = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s [%u]", pszDesc, pDevIns->iInstance);
738	if (pszDesc2)
739	pszDesc = pszDesc2;
740	}
741
742	int rc = TMR3TimerCreateDevice(pVM, pDevIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, ppTimer);
743
744	LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
745	return rc;
746	}
747
748
749	/** @interface_method_impl{PDMDEVHLPR3,pfnTMUtcNow} */
750	static DECLCALLBACK(PRTTIMESPEC) pdmR3DevHlp_TMUtcNow(PPDMDEVINS pDevIns, PRTTIMESPEC pTime)
751	{
752	PDMDEV_ASSERT_DEVINS(pDevIns);
753	LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: pTime=%p\n",
754	pDevIns->pReg->szName, pDevIns->iInstance, pTime));
755
756	pTime = TMR3UtcNow(pDevIns->Internal.s.pVMR3, pTime);
757
758	LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, RTTimeSpecGetNano(pTime)));
759	return pTime;
760	}
761
762
763	/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGet} */
764	static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGet(PPDMDEVINS pDevIns)
765	{
766	PDMDEV_ASSERT_DEVINS(pDevIns);
767	LogFlow(("pdmR3DevHlp_TMTimeVirtGet: caller='%s'/%d\n",
768	pDevIns->pReg->szName, pDevIns->iInstance));
769
770	uint64_t u64Time = TMVirtualSyncGet(pDevIns->Internal.s.pVMR3);
771
772	LogFlow(("pdmR3DevHlp_TMTimeVirtGet: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Time));
773	return u64Time;
774	}
775
776
777	/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGetFreq} */
778	static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGetFreq(PPDMDEVINS pDevIns)
779	{
780	PDMDEV_ASSERT_DEVINS(pDevIns);
781	LogFlow(("pdmR3DevHlp_TMTimeVirtGetFreq: caller='%s'/%d\n",
782	pDevIns->pReg->szName, pDevIns->iInstance));
783
784	uint64_t u64Freq = TMVirtualGetFreq(pDevIns->Internal.s.pVMR3);
785
786	LogFlow(("pdmR3DevHlp_TMTimeVirtGetFreq: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Freq));
787	return u64Freq;
788	}
789
790
791	/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGetNano} */
792	static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGetNano(PPDMDEVINS pDevIns)
793	{
794	PDMDEV_ASSERT_DEVINS(pDevIns);
795	LogFlow(("pdmR3DevHlp_TMTimeVirtGetNano: caller='%s'/%d\n",
796	pDevIns->pReg->szName, pDevIns->iInstance));
797
798	uint64_t u64Time = TMVirtualGet(pDevIns->Internal.s.pVMR3);
799	uint64_t u64Nano = TMVirtualToNano(pDevIns->Internal.s.pVMR3, u64Time);
800
801	LogFlow(("pdmR3DevHlp_TMTimeVirtGetNano: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Nano));
802	return u64Nano;
803	}
804
805
806	/** @interface_method_impl{PDMDEVHLPR3,pfnGetSupDrvSession} */
807	static DECLCALLBACK(PSUPDRVSESSION) pdmR3DevHlp_GetSupDrvSession(PPDMDEVINS pDevIns)
808	{
809	PDMDEV_ASSERT_DEVINS(pDevIns);
810	LogFlow(("pdmR3DevHlp_GetSupDrvSession: caller='%s'/%d\n",
811	pDevIns->pReg->szName, pDevIns->iInstance));
812
813	PSUPDRVSESSION pSession = pDevIns->Internal.s.pVMR3->pSession;
814
815	LogFlow(("pdmR3DevHlp_GetSupDrvSession: caller='%s'/%d: returns %#p\n", pDevIns->pReg->szName, pDevIns->iInstance, pSession));
816	return pSession;
817	}
818
819
820	/** @interface_method_impl{PDMDEVHLPR3,pfnQueryGenericUserObject} */
821	static DECLCALLBACK(void *) pdmR3DevHlp_QueryGenericUserObject(PPDMDEVINS pDevIns, PCRTUUID pUuid)
822	{
823	PDMDEV_ASSERT_DEVINS(pDevIns);
824	LogFlow(("pdmR3DevHlp_QueryGenericUserObject: caller='%s'/%d: pUuid=%p:%RTuuid\n",
825	pDevIns->pReg->szName, pDevIns->iInstance, pUuid, pUuid));
826
827	#if defined(DEBUG_bird) \|\| defined(DEBUG_ramshankar) \|\| defined(DEBUG_sunlover) \|\| defined(DEBUG_michael) \|\| defined(DEBUG_andy)
828	AssertMsgFailed(("'%s' wants %RTuuid - external only interface!\n", pDevIns->pReg->szName, pUuid));
829	#endif
830
831	void *pvRet;
832	PUVM pUVM = pDevIns->Internal.s.pVMR3->pUVM;
833	if (pUVM->pVmm2UserMethods->pfnQueryGenericObject)
834	pvRet = pUVM->pVmm2UserMethods->pfnQueryGenericObject(pUVM->pVmm2UserMethods, pUVM, pUuid);
835	else
836	pvRet = NULL;
837
838	LogRel(("pdmR3DevHlp_QueryGenericUserObject: caller='%s'/%d: returns %#p for %RTuuid\n",
839	pDevIns->pReg->szName, pDevIns->iInstance, pvRet, pUuid));
840	return pvRet;
841	}
842
843
844	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysRead} */
845	static DECLCALLBACK(int) pdmR3DevHlp_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
846	{
847	PDMDEV_ASSERT_DEVINS(pDevIns);
848	PVM pVM = pDevIns->Internal.s.pVMR3;
849	LogFlow(("pdmR3DevHlp_PhysRead: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbRead=%#x\n",
850	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
851
852	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
853	if (!VM_IS_EMT(pVM))
854	{
855	char szNames[128];
856	uint32_t cLocks = PDMR3CritSectCountOwned(pVM, szNames, sizeof(szNames));
857	AssertMsg(cLocks == 0, ("cLocks=%u %s\n", cLocks, szNames));
858	}
859	#endif
860
861	VBOXSTRICTRC rcStrict;
862	if (VM_IS_EMT(pVM))
863	rcStrict = PGMPhysRead(pVM, GCPhys, pvBuf, cbRead, PGMACCESSORIGIN_DEVICE);
864	else
865	rcStrict = PGMR3PhysReadExternal(pVM, GCPhys, pvBuf, cbRead, PGMACCESSORIGIN_DEVICE);
866	AssertMsg(rcStrict == VINF_SUCCESS, ("%Rrc\n", VBOXSTRICTRC_VAL(rcStrict))); /** @todo track down the users for this bugger. */
867
868	Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
869	return VBOXSTRICTRC_VAL(rcStrict);
870	}
871
872
873	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWrite} */
874	static DECLCALLBACK(int) pdmR3DevHlp_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
875	{
876	PDMDEV_ASSERT_DEVINS(pDevIns);
877	PVM pVM = pDevIns->Internal.s.pVMR3;
878	LogFlow(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbWrite=%#x\n",
879	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
880
881	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
882	if (!VM_IS_EMT(pVM))
883	{
884	char szNames[128];
885	uint32_t cLocks = PDMR3CritSectCountOwned(pVM, szNames, sizeof(szNames));
886	AssertMsg(cLocks == 0, ("cLocks=%u %s\n", cLocks, szNames));
887	}
888	#endif
889
890	VBOXSTRICTRC rcStrict;
891	if (VM_IS_EMT(pVM))
892	rcStrict = PGMPhysWrite(pVM, GCPhys, pvBuf, cbWrite, PGMACCESSORIGIN_DEVICE);
893	else
894	rcStrict = PGMR3PhysWriteExternal(pVM, GCPhys, pvBuf, cbWrite, PGMACCESSORIGIN_DEVICE);
895	AssertMsg(rcStrict == VINF_SUCCESS, ("%Rrc\n", VBOXSTRICTRC_VAL(rcStrict))); /** @todo track down the users for this bugger. */
896
897	Log(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
898	return VBOXSTRICTRC_VAL(rcStrict);
899	}
900
901
902	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtr} */
903	static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtr(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, void **ppv, PPGMPAGEMAPLOCK pLock)
904	{
905	PDMDEV_ASSERT_DEVINS(pDevIns);
906	PVM pVM = pDevIns->Internal.s.pVMR3;
907	LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
908	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
909	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
910
911	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
912	if (!VM_IS_EMT(pVM))
913	{
914	char szNames[128];
915	uint32_t cLocks = PDMR3CritSectCountOwned(pVM, szNames, sizeof(szNames));
916	AssertMsg(cLocks == 0, ("cLocks=%u %s\n", cLocks, szNames));
917	}
918	#endif
919
920	int rc = PGMR3PhysGCPhys2CCPtrExternal(pVM, GCPhys, ppv, pLock);
921
922	Log(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
923	return rc;
924	}
925
926
927	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtrReadOnly} */
928	static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, const void **ppv, PPGMPAGEMAPLOCK pLock)
929	{
930	PDMDEV_ASSERT_DEVINS(pDevIns);
931	PVM pVM = pDevIns->Internal.s.pVMR3;
932	LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
933	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
934	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
935
936	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
937	if (!VM_IS_EMT(pVM))
938	{
939	char szNames[128];
940	uint32_t cLocks = PDMR3CritSectCountOwned(pVM, szNames, sizeof(szNames));
941	AssertMsg(cLocks == 0, ("cLocks=%u %s\n", cLocks, szNames));
942	}
943	#endif
944
945	int rc = PGMR3PhysGCPhys2CCPtrReadOnlyExternal(pVM, GCPhys, ppv, pLock);
946
947	Log(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
948	return rc;
949	}
950
951
952	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReleasePageMappingLock} */
953	static DECLCALLBACK(void) pdmR3DevHlp_PhysReleasePageMappingLock(PPDMDEVINS pDevIns, PPGMPAGEMAPLOCK pLock)
954	{
955	PDMDEV_ASSERT_DEVINS(pDevIns);
956	PVM pVM = pDevIns->Internal.s.pVMR3;
957	LogFlow(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: pLock=%p\n",
958	pDevIns->pReg->szName, pDevIns->iInstance, pLock));
959
960	PGMPhysReleasePageMappingLock(pVM, pLock);
961
962	Log(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
963	}
964
965
966	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReadGCVirt} */
967	static DECLCALLBACK(int) pdmR3DevHlp_PhysReadGCVirt(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb)
968	{
969	PDMDEV_ASSERT_DEVINS(pDevIns);
970	PVM pVM = pDevIns->Internal.s.pVMR3;
971	VM_ASSERT_EMT(pVM);
972	LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: pvDst=%p GCVirt=%RGv cb=%#x\n",
973	pDevIns->pReg->szName, pDevIns->iInstance, pvDst, GCVirtSrc, cb));
974
975	PVMCPU pVCpu = VMMGetCpu(pVM);
976	if (!pVCpu)
977	return VERR_ACCESS_DENIED;
978	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
979	/** @todo SMP. */
980	#endif
981
982	int rc = PGMPhysSimpleReadGCPtr(pVCpu, pvDst, GCVirtSrc, cb);
983
984	LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
985
986	return rc;
987	}
988
989
990	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWriteGCVirt} */
991	static DECLCALLBACK(int) pdmR3DevHlp_PhysWriteGCVirt(PPDMDEVINS pDevIns, RTGCPTR GCVirtDst, const void *pvSrc, size_t cb)
992	{
993	PDMDEV_ASSERT_DEVINS(pDevIns);
994	PVM pVM = pDevIns->Internal.s.pVMR3;
995	VM_ASSERT_EMT(pVM);
996	LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: GCVirtDst=%RGv pvSrc=%p cb=%#x\n",
997	pDevIns->pReg->szName, pDevIns->iInstance, GCVirtDst, pvSrc, cb));
998
999	PVMCPU pVCpu = VMMGetCpu(pVM);
1000	if (!pVCpu)
1001	return VERR_ACCESS_DENIED;
1002	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
1003	/** @todo SMP. */
1004	#endif
1005
1006	int rc = PGMPhysSimpleWriteGCPtr(pVCpu, GCVirtDst, pvSrc, cb);
1007
1008	LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1009
1010	return rc;
1011	}
1012
1013
1014	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPtr2GCPhys} */
1015	static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPtr2GCPhys(PPDMDEVINS pDevIns, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
1016	{
1017	PDMDEV_ASSERT_DEVINS(pDevIns);
1018	PVM pVM = pDevIns->Internal.s.pVMR3;
1019	VM_ASSERT_EMT(pVM);
1020	LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: GCPtr=%RGv pGCPhys=%p\n",
1021	pDevIns->pReg->szName, pDevIns->iInstance, GCPtr, pGCPhys));
1022
1023	PVMCPU pVCpu = VMMGetCpu(pVM);
1024	if (!pVCpu)
1025	return VERR_ACCESS_DENIED;
1026	#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
1027	/** @todo SMP. */
1028	#endif
1029
1030	int rc = PGMPhysGCPtr2GCPhys(pVCpu, GCPtr, pGCPhys);
1031
1032	LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: returns %Rrc pGCPhys=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, pGCPhys));
1033
1034	return rc;
1035	}
1036
1037
1038	/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAlloc} */
1039	static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAlloc(PPDMDEVINS pDevIns, size_t cb)
1040	{
1041	PDMDEV_ASSERT_DEVINS(pDevIns);
1042	LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
1043
1044	void *pv = MMR3HeapAlloc(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE_USER, cb);
1045
1046	LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
1047	return pv;
1048	}
1049
1050
1051	/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAllocZ} */
1052	static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAllocZ(PPDMDEVINS pDevIns, size_t cb)
1053	{
1054	PDMDEV_ASSERT_DEVINS(pDevIns);
1055	LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
1056
1057	void *pv = MMR3HeapAllocZ(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE_USER, cb);
1058
1059	LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
1060	return pv;
1061	}
1062
1063
1064	/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapFree} */
1065	static DECLCALLBACK(void) pdmR3DevHlp_MMHeapFree(PPDMDEVINS pDevIns, void *pv)
1066	{
1067	PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
1068	LogFlow(("pdmR3DevHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
1069
1070	MMR3HeapFree(pv);
1071
1072	LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
1073	}
1074
1075
1076	/** @interface_method_impl{PDMDEVHLPR3,pfnVMState} */
1077	static DECLCALLBACK(VMSTATE) pdmR3DevHlp_VMState(PPDMDEVINS pDevIns)
1078	{
1079	PDMDEV_ASSERT_DEVINS(pDevIns);
1080
1081	VMSTATE enmVMState = VMR3GetState(pDevIns->Internal.s.pVMR3);
1082
1083	LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %d (%s)\n", pDevIns->pReg->szName, pDevIns->iInstance,
1084	enmVMState, VMR3GetStateName(enmVMState)));
1085	return enmVMState;
1086	}
1087
1088
1089	/** @interface_method_impl{PDMDEVHLPR3,pfnVMTeleportedAndNotFullyResumedYet} */
1090	static DECLCALLBACK(bool) pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet(PPDMDEVINS pDevIns)
1091	{
1092	PDMDEV_ASSERT_DEVINS(pDevIns);
1093
1094	bool fRc = VMR3TeleportedAndNotFullyResumedYet(pDevIns->Internal.s.pVMR3);
1095
1096	LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szName, pDevIns->iInstance,
1097	fRc));
1098	return fRc;
1099	}
1100
1101
1102	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetError} */
1103	static DECLCALLBACK(int) pdmR3DevHlp_VMSetError(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
1104	{
1105	PDMDEV_ASSERT_DEVINS(pDevIns);
1106	va_list args;
1107	va_start(args, pszFormat);
1108	int rc2 = VMSetErrorV(pDevIns->Internal.s.pVMR3, rc, RT_SRC_POS_ARGS, pszFormat, args); Assert(rc2 == rc); NOREF(rc2);
1109	va_end(args);
1110	return rc;
1111	}
1112
1113
1114	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetErrorV} */
1115	static DECLCALLBACK(int) pdmR3DevHlp_VMSetErrorV(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
1116	{
1117	PDMDEV_ASSERT_DEVINS(pDevIns);
1118	int rc2 = VMSetErrorV(pDevIns->Internal.s.pVMR3, rc, RT_SRC_POS_ARGS, pszFormat, va); Assert(rc2 == rc); NOREF(rc2);
1119	return rc;
1120	}
1121
1122
1123	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeError} */
1124	static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeError(PPDMDEVINS pDevIns, uint32_t fFlags, const char pszErrorId, const char pszFormat, ...)
1125	{
1126	PDMDEV_ASSERT_DEVINS(pDevIns);
1127	va_list args;
1128	va_start(args, pszFormat);
1129	int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMR3, fFlags, pszErrorId, pszFormat, args);
1130	va_end(args);
1131	return rc;
1132	}
1133
1134
1135	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeErrorV} */
1136	static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeErrorV(PPDMDEVINS pDevIns, uint32_t fFlags, const char pszErrorId, const char pszFormat, va_list va)
1137	{
1138	PDMDEV_ASSERT_DEVINS(pDevIns);
1139	int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMR3, fFlags, pszErrorId, pszFormat, va);
1140	return rc;
1141	}
1142
1143
1144	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFStopV} */
1145	static DECLCALLBACK(int) pdmR3DevHlp_DBGFStopV(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction, const char *pszFormat, va_list args)
1146	{
1147	PDMDEV_ASSERT_DEVINS(pDevIns);
1148	#ifdef LOG_ENABLED
1149	va_list va2;
1150	va_copy(va2, args);
1151	LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: pszFile=%p:{%s} iLine=%d pszFunction=%p:{%s} pszFormat=%p:{%s} (%N)\n",
1152	pDevIns->pReg->szName, pDevIns->iInstance, pszFile, pszFile, iLine, pszFunction, pszFunction, pszFormat, pszFormat, pszFormat, &va2));
1153	va_end(va2);
1154	#endif
1155
1156	PVM pVM = pDevIns->Internal.s.pVMR3;
1157	VM_ASSERT_EMT(pVM);
1158	int rc = DBGFR3EventSrcV(pVM, DBGFEVENT_DEV_STOP, pszFile, iLine, pszFunction, pszFormat, args);
1159	if (rc == VERR_DBGF_NOT_ATTACHED)
1160	rc = VINF_SUCCESS;
1161
1162	LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1163	return rc;
1164	}
1165
1166
1167	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFInfoRegister} */
1168	static DECLCALLBACK(int) pdmR3DevHlp_DBGFInfoRegister(PPDMDEVINS pDevIns, const char pszName, const char pszDesc, PFNDBGFHANDLERDEV pfnHandler)
1169	{
1170	PDMDEV_ASSERT_DEVINS(pDevIns);
1171	LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
1172	pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
1173
1174	PVM pVM = pDevIns->Internal.s.pVMR3;
1175	VM_ASSERT_EMT(pVM);
1176	int rc = DBGFR3InfoRegisterDevice(pVM, pszName, pszDesc, pfnHandler, pDevIns);
1177
1178	LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1179	return rc;
1180	}
1181
1182
1183	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFRegRegister} */
1184	static DECLCALLBACK(int) pdmR3DevHlp_DBGFRegRegister(PPDMDEVINS pDevIns, PCDBGFREGDESC paRegisters)
1185	{
1186	PDMDEV_ASSERT_DEVINS(pDevIns);
1187	LogFlow(("pdmR3DevHlp_DBGFRegRegister: caller='%s'/%d: paRegisters=%p\n",
1188	pDevIns->pReg->szName, pDevIns->iInstance, paRegisters));
1189
1190	PVM pVM = pDevIns->Internal.s.pVMR3;
1191	VM_ASSERT_EMT(pVM);
1192	int rc = DBGFR3RegRegisterDevice(pVM, paRegisters, pDevIns, pDevIns->pReg->szName, pDevIns->iInstance);
1193
1194	LogFlow(("pdmR3DevHlp_DBGFRegRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1195	return rc;
1196	}
1197
1198
1199	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFTraceBuf} */
1200	static DECLCALLBACK(RTTRACEBUF) pdmR3DevHlp_DBGFTraceBuf(PPDMDEVINS pDevIns)
1201	{
1202	PDMDEV_ASSERT_DEVINS(pDevIns);
1203	RTTRACEBUF hTraceBuf = pDevIns->Internal.s.pVMR3->hTraceBufR3;
1204	LogFlow(("pdmR3DevHlp_DBGFTraceBuf: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, hTraceBuf));
1205	return hTraceBuf;
1206	}
1207
1208
1209	/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegister} */
1210	static DECLCALLBACK(void) pdmR3DevHlp_STAMRegister(PPDMDEVINS pDevIns, void pvSample, STAMTYPE enmType, const char pszName,
1211	STAMUNIT enmUnit, const char *pszDesc)
1212	{
1213	PDMDEV_ASSERT_DEVINS(pDevIns);
1214	PVM pVM = pDevIns->Internal.s.pVMR3;
1215	VM_ASSERT_EMT(pVM);
1216
1217	STAM_REG(pVM, pvSample, enmType, pszName, enmUnit, pszDesc);
1218	RT_NOREF_PV(pVM); RT_NOREF6(pDevIns, pvSample, enmType, pszName, enmUnit, pszDesc);
1219	}
1220
1221
1222
1223	/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegisterF} */
1224	static DECLCALLBACK(void) pdmR3DevHlp_STAMRegisterF(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
1225	STAMUNIT enmUnit, const char pszDesc, const char pszName, ...)
1226	{
1227	PDMDEV_ASSERT_DEVINS(pDevIns);
1228	PVM pVM = pDevIns->Internal.s.pVMR3;
1229	VM_ASSERT_EMT(pVM);
1230
1231	va_list args;
1232	va_start(args, pszName);
1233	int rc = STAMR3RegisterV(pVM, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
1234	va_end(args);
1235	AssertRC(rc);
1236
1237	NOREF(pVM);
1238	}
1239
1240
1241	/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegisterV} */
1242	static DECLCALLBACK(void) pdmR3DevHlp_STAMRegisterV(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
1243	STAMUNIT enmUnit, const char pszDesc, const char pszName, va_list args)
1244	{
1245	PDMDEV_ASSERT_DEVINS(pDevIns);
1246	PVM pVM = pDevIns->Internal.s.pVMR3;
1247	VM_ASSERT_EMT(pVM);
1248
1249	int rc = STAMR3RegisterV(pVM, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
1250	AssertRC(rc);
1251
1252	NOREF(pVM);
1253	}
1254
1255
1256	/**
1257	* @interface_method_impl{PDMDEVHLPR3,pfnPCIRegister}
1258	*/
1259	static DECLCALLBACK(int) pdmR3DevHlp_PCIRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t idxDevCfg, uint32_t fFlags,
1260	uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName)
1261	{
1262	PDMDEV_ASSERT_DEVINS(pDevIns);
1263	PVM pVM = pDevIns->Internal.s.pVMR3;
1264	VM_ASSERT_EMT(pVM);
1265	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: pPciDev=%p:{.config={%#.256Rhxs} idxDevCfg=%d fFlags=%#x uPciDevNo=%#x uPciFunNo=%#x pszName=%p:{%s}\n",
1266	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->abConfig, idxDevCfg, fFlags, uPciDevNo, uPciFunNo, pszName, pszName ? pszName : ""));
1267
1268	/*
1269	* Validate input.
1270	*/
1271	AssertLogRelMsgReturn(RT_VALID_PTR(pPciDev),
1272	("'%s'/%d: Invalid pPciDev value: %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pPciDev),
1273	VERR_INVALID_POINTER);
1274	AssertLogRelMsgReturn(PDMPciDevGetVendorId(pPciDev),
1275	("'%s'/%d: Vendor ID is not set!\n", pDevIns->pReg->szName, pDevIns->iInstance),
1276	VERR_INVALID_POINTER);
1277	AssertLogRelMsgReturn(idxDevCfg < 256 \|\| idxDevCfg == PDMPCIDEVREG_CFG_NEXT,
1278	("'%s'/%d: Invalid config selector: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, idxDevCfg),
1279	VERR_OUT_OF_RANGE);
1280	AssertLogRelMsgReturn( uPciDevNo < 32
1281	\|\| uPciDevNo == PDMPCIDEVREG_DEV_NO_FIRST_UNUSED
1282	\|\| uPciDevNo == PDMPCIDEVREG_DEV_NO_SAME_AS_PREV,
1283	("'%s'/%d: Invalid PCI device number: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, uPciDevNo),
1284	VERR_INVALID_PARAMETER);
1285	AssertLogRelMsgReturn( uPciFunNo < 8
1286	\|\| uPciFunNo == PDMPCIDEVREG_FUN_NO_FIRST_UNUSED,
1287	("'%s'/%d: Invalid PCI funcion number: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, uPciFunNo),
1288	VERR_INVALID_PARAMETER);
1289	AssertLogRelMsgReturn(!(fFlags & ~PDMPCIDEVREG_F_VALID_MASK),
1290	("'%s'/%d: Invalid flags: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, fFlags),
1291	VERR_INVALID_FLAGS);
1292	if (!pszName)
1293	pszName = pDevIns->pReg->szName;
1294	AssertLogRelReturn(RT_VALID_PTR(pszName), VERR_INVALID_POINTER);
1295
1296	/*
1297	* Find the last(/previous) registered PCI device (for linking and more),
1298	* checking for duplicate registration attempts while doing so.
1299	*/
1300	uint32_t idxDevCfgNext = 0;
1301	PPDMPCIDEV pPrevPciDev = pDevIns->Internal.s.pHeadPciDevR3;
1302	while (pPrevPciDev)
1303	{
1304	AssertLogRelMsgReturn(pPrevPciDev != pPciDev,
1305	("'%s'/%d attempted to register the same PCI device (%p) twice\n",
1306	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev),
1307	VERR_DUPLICATE);
1308	AssertLogRelMsgReturn(pPrevPciDev->Int.s.idxDevCfg != idxDevCfg,
1309	("'%s'/%d attempted to use the same device config index (%u) twice\n",
1310	pDevIns->pReg->szName, pDevIns->iInstance, idxDevCfg),
1311	VERR_ALREADY_LOADED);
1312	if (pPrevPciDev->Int.s.idxDevCfg >= idxDevCfgNext)
1313	idxDevCfgNext = pPrevPciDev->Int.s.idxDevCfg + 1;
1314
1315	if (!pPrevPciDev->Int.s.pNextR3)
1316	break;
1317	pPrevPciDev = pPrevPciDev->Int.s.pNextR3;
1318	}
1319
1320	/*
1321	* Resolve the PCI configuration node for the device. The default (zero'th)
1322	* is the same as the PDM device, the rest are "PciCfg1..255" CFGM sub-nodes.
1323	*/
1324	if (idxDevCfg == PDMPCIDEVREG_CFG_NEXT)
1325	{
1326	idxDevCfg = idxDevCfgNext;
1327	AssertLogRelMsgReturn(idxDevCfg < 256, ("'%s'/%d: PDMPCIDEVREG_IDX_DEV_CFG_NEXT ran out of valid indexes (ends at 255)\n",
1328	pDevIns->pReg->szName, pDevIns->iInstance),
1329	VERR_OUT_OF_RANGE);
1330	}
1331
1332	PCFGMNODE pCfg = pDevIns->Internal.s.pCfgHandle;
1333	if (idxDevCfg != 0)
1334	pCfg = CFGMR3GetChildF(pDevIns->Internal.s.pCfgHandle, "PciCfg%u", idxDevCfg);
1335
1336	/*
1337	* We resolve PDMPCIDEVREG_DEV_NO_SAME_AS_PREV, the PCI bus handles
1338	* PDMPCIDEVREG_DEV_NO_FIRST_UNUSED and PDMPCIDEVREG_FUN_NO_FIRST_UNUSED.
1339	*/
1340	uint8_t const uPciDevNoRaw = uPciDevNo;
1341	uint32_t uDefPciBusNo = 0;
1342	if (uPciDevNo == PDMPCIDEVREG_DEV_NO_SAME_AS_PREV)
1343	{
1344	if (pPrevPciDev)
1345	{
1346	uPciDevNo = pPrevPciDev->uDevFn >> 3;
1347	uDefPciBusNo = pPrevPciDev->Int.s.pPdmBusR3->iBus;
1348	}
1349	else
1350	{
1351	/* Look for PCI device registered with an earlier device instance so we can more
1352	easily have multiple functions spanning multiple PDM device instances. */
1353	PPDMPCIDEV pOtherPciDev = NULL;
1354	PPDMDEVINS pPrevIns = pDevIns->Internal.s.pDevR3->pInstances;
1355	while (pPrevIns != pDevIns && pPrevIns)
1356	{
1357	pOtherPciDev = pPrevIns->Internal.s.pHeadPciDevR3;
1358	pPrevIns = pPrevIns->Internal.s.pNextR3;
1359	}
1360	Assert(pPrevIns == pDevIns);
1361	AssertLogRelMsgReturn(pOtherPciDev,
1362	("'%s'/%d: Can't use PDMPCIDEVREG_DEV_NO_SAME_AS_PREV without a previously registered PCI device by the same or earlier PDM device instance!\n",
1363	pDevIns->pReg->szName, pDevIns->iInstance),
1364	VERR_WRONG_ORDER);
1365
1366	while (pOtherPciDev->Int.s.pNextR3)
1367	pOtherPciDev = pOtherPciDev->Int.s.pNextR3;
1368	uPciDevNo = pOtherPciDev->uDevFn >> 3;
1369	uDefPciBusNo = pOtherPciDev->Int.s.pPdmBusR3->iBus;
1370	}
1371	}
1372
1373	/*
1374	* Choose the PCI bus for the device.
1375	*
1376	* This is simple. If the device was configured for a particular bus, the PCIBusNo
1377	* configuration value will be set. If not the default bus is 0.
1378	*/
1379	/** @cfgm{/Devices/NAME/XX/[PciCfgYY/]PCIBusNo, uint8_t, 0, 7, 0}
1380	* Selects the PCI bus number of a device. The default value isn't necessarily
1381	* zero if the device is registered using PDMPCIDEVREG_DEV_NO_SAME_AS_PREV, it
1382	* will then also inherit the bus number from the previously registered device.
1383	*/
1384	uint8_t u8Bus;
1385	int rc = CFGMR3QueryU8Def(pCfg, "PCIBusNo", &u8Bus, (uint8_t)uDefPciBusNo);
1386	AssertLogRelMsgRCReturn(rc, ("Configuration error: PCIBusNo query failed with rc=%Rrc (%s/%d)\n",
1387	rc, pDevIns->pReg->szName, pDevIns->iInstance), rc);
1388	AssertLogRelMsgReturn(u8Bus < RT_ELEMENTS(pVM->pdm.s.aPciBuses),
1389	("Configuration error: PCIBusNo=%d, max is %d. (%s/%d)\n", u8Bus,
1390	RT_ELEMENTS(pVM->pdm.s.aPciBuses), pDevIns->pReg->szName, pDevIns->iInstance),
1391	VERR_PDM_NO_PCI_BUS);
1392	PPDMPCIBUS pBus = pPciDev->Int.s.pPdmBusR3 = &pVM->pdm.s.aPciBuses[u8Bus];
1393	if (pBus->pDevInsR3)
1394	{
1395	/*
1396	* Check the configuration for PCI device and function assignment.
1397	*/
1398	/** @cfgm{/Devices/NAME/XX/[PciCfgYY/]PCIDeviceNo, uint8_t, 0, 31}
1399	* Overrides the default PCI device number of a device.
1400	*/
1401	uint8_t uCfgDevice;
1402	rc = CFGMR3QueryU8(pCfg, "PCIDeviceNo", &uCfgDevice);
1403	if (RT_SUCCESS(rc))
1404	{
1405	AssertMsgReturn(uCfgDevice <= 31,
1406	("Configuration error: PCIDeviceNo=%d, max is 31. (%s/%d/%d)\n",
1407	uCfgDevice, pDevIns->pReg->szName, pDevIns->iInstance, idxDevCfg),
1408	VERR_PDM_BAD_PCI_CONFIG);
1409	uPciDevNo = uCfgDevice;
1410	}
1411	else
1412	AssertMsgReturn(rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT,
1413	("Configuration error: PCIDeviceNo query failed with rc=%Rrc (%s/%d/%d)\n",
1414	rc, pDevIns->pReg->szName, pDevIns->iInstance, idxDevCfg),
1415	rc);
1416
1417	/** @cfgm{/Devices/NAME/XX/[PciCfgYY/]PCIFunctionNo, uint8_t, 0, 7}
1418	* Overrides the default PCI function number of a device.
1419	*/
1420	uint8_t uCfgFunction;
1421	rc = CFGMR3QueryU8(pCfg, "PCIFunctionNo", &uCfgFunction);
1422	if (RT_SUCCESS(rc))
1423	{
1424	AssertMsgReturn(uCfgFunction <= 7,
1425	("Configuration error: PCIFunctionNo=%#x, max is 7. (%s/%d/%d)\n",
1426	uCfgFunction, pDevIns->pReg->szName, pDevIns->iInstance, idxDevCfg),
1427	VERR_PDM_BAD_PCI_CONFIG);
1428	uPciFunNo = uCfgFunction;
1429	}
1430	else
1431	AssertMsgReturn(rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT,
1432	("Configuration error: PCIFunctionNo query failed with rc=%Rrc (%s/%d/%d)\n",
1433	rc, pDevIns->pReg->szName, pDevIns->iInstance, idxDevCfg),
1434	rc);
1435
1436
1437	/*
1438	* Initialize the internal data. We only do the wipe and the members
1439	* owned by PDM, the PCI bus does the rest in the registration call.
1440	*/
1441	RT_ZERO(pPciDev->Int);
1442
1443	pPciDev->Int.s.idxDevCfg = idxDevCfg;
1444	pPciDev->Int.s.fReassignableDevNo = uPciDevNoRaw >= VBOX_PCI_MAX_DEVICES;
1445	pPciDev->Int.s.fReassignableFunNo = uPciFunNo >= VBOX_PCI_MAX_FUNCTIONS;
1446	pPciDev->Int.s.pDevInsR3 = pDevIns;
1447	pPciDev->Int.s.pPdmBusR3 = pBus;
1448	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)
1449	{
1450	pPciDev->Int.s.pDevInsR0 = MMHyperR3ToR0(pVM, pDevIns);
1451	pPciDev->Int.s.pPdmBusR0 = MMHyperR3ToR0(pVM, pBus);
1452	}
1453	else
1454	{
1455	pPciDev->Int.s.pDevInsR0 = NIL_RTR0PTR;
1456	pPciDev->Int.s.pPdmBusR0 = NIL_RTR0PTR;
1457	}
1458
1459	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
1460	{
1461	pPciDev->Int.s.pDevInsRC = MMHyperR3ToRC(pVM, pDevIns);
1462	pPciDev->Int.s.pPdmBusRC = MMHyperR3ToRC(pVM, pBus);
1463	}
1464	else
1465	{
1466	pPciDev->Int.s.pDevInsRC = NIL_RTRCPTR;
1467	pPciDev->Int.s.pPdmBusRC = NIL_RTRCPTR;
1468	}
1469
1470	/* Set some of the public members too. */
1471	pPciDev->pszNameR3 = pszName;
1472
1473	/*
1474	* Call the pci bus device to do the actual registration.
1475	*/
1476	pdmLock(pVM);
1477	rc = pBus->pfnRegisterR3(pBus->pDevInsR3, pPciDev, fFlags, uPciDevNo, uPciFunNo, pszName);
1478	pdmUnlock(pVM);
1479	if (RT_SUCCESS(rc))
1480	{
1481
1482	/*
1483	* Link it.
1484	*/
1485	if (pPrevPciDev)
1486	{
1487	Assert(!pPrevPciDev->Int.s.pNextR3);
1488	pPrevPciDev->Int.s.pNextR3 = pPciDev;
1489	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)
1490	pPrevPciDev->Int.s.pNextR0 = MMHyperR3ToR0(pVM, pPciDev);
1491	else
1492	pPrevPciDev->Int.s.pNextR0 = NIL_RTR0PTR;
1493	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
1494	pPrevPciDev->Int.s.pNextRC = MMHyperR3ToRC(pVM, pPciDev);
1495	else
1496	pPrevPciDev->Int.s.pNextRC = NIL_RTRCPTR;
1497	}
1498	else
1499	{
1500	Assert(!pDevIns->Internal.s.pHeadPciDevR3);
1501	pDevIns->Internal.s.pHeadPciDevR3 = pPciDev;
1502	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)
1503	pDevIns->Internal.s.pHeadPciDevR0 = MMHyperR3ToR0(pVM, pPciDev);
1504	else
1505	pDevIns->Internal.s.pHeadPciDevR0 = NIL_RTR0PTR;
1506	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
1507	pDevIns->Internal.s.pHeadPciDevRC = MMHyperR3ToRC(pVM, pPciDev);
1508	else
1509	pDevIns->Internal.s.pHeadPciDevRC = NIL_RTRCPTR;
1510	}
1511
1512	Log(("PDM: Registered device '%s'/%d as PCI device %d on bus %d\n",
1513	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev->uDevFn, pBus->iBus));
1514	}
1515	}
1516	else
1517	{
1518	AssertLogRelMsgFailed(("Configuration error: No PCI bus available. This could be related to init order too!\n"));
1519	rc = VERR_PDM_NO_PCI_BUS;
1520	}
1521
1522	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1523	return rc;
1524	}
1525
1526
1527	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIRegisterMsi} */
1528	static DECLCALLBACK(int) pdmR3DevHlp_PCIRegisterMsi(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, PPDMMSIREG pMsiReg)
1529	{
1530	PDMDEV_ASSERT_DEVINS(pDevIns);
1531	if (!pPciDev) /* NULL is an alias for the default PCI device. */
1532	pPciDev = pDevIns->Internal.s.pHeadPciDevR3;
1533	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
1534	LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: pPciDev=%p:{%#x} pMsgReg=%p:{cMsiVectors=%d, cMsixVectors=%d}\n",
1535	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, pMsiReg, pMsiReg->cMsiVectors, pMsiReg->cMsixVectors));
1536
1537	PPDMPCIBUS pBus = pPciDev->Int.s.pPdmBusR3; Assert(pBus);
1538	PVM pVM = pDevIns->Internal.s.pVMR3;
1539	pdmLock(pVM);
1540	int rc;
1541	if (pBus->pfnRegisterMsiR3)
1542	rc = pBus->pfnRegisterMsiR3(pBus->pDevInsR3, pPciDev, pMsiReg);
1543	else
1544	rc = VERR_NOT_IMPLEMENTED;
1545	pdmUnlock(pVM);
1546
1547	LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1548	return rc;
1549	}
1550
1551
1552	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIIORegionRegister} */
1553	static DECLCALLBACK(int) pdmR3DevHlp_PCIIORegionRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
1554	RTGCPHYS cbRegion, PCIADDRESSSPACE enmType, PFNPCIIOREGIONMAP pfnCallback)
1555	{
1556	PDMDEV_ASSERT_DEVINS(pDevIns);
1557	PVM pVM = pDevIns->Internal.s.pVMR3;
1558	VM_ASSERT_EMT(pVM);
1559	if (!pPciDev) /* NULL is an alias for the default PCI device. */
1560	pPciDev = pDevIns->Internal.s.pHeadPciDevR3;
1561	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
1562	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%d cbRegion=%RGp enmType=%d pfnCallback=%p\n",
1563	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iRegion, cbRegion, enmType, pfnCallback));
1564
1565	/*
1566	* Validate input.
1567	*/
1568	if (iRegion >= VBOX_PCI_NUM_REGIONS)
1569	{
1570	Assert(iRegion < VBOX_PCI_NUM_REGIONS);
1571	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (iRegion)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1572	return VERR_INVALID_PARAMETER;
1573	}
1574
1575	switch ((int)enmType)
1576	{
1577	case PCI_ADDRESS_SPACE_IO:
1578	/*
1579	* Sanity check: don't allow to register more than 32K of the PCI I/O space.
1580	*/
1581	AssertLogRelMsgReturn(cbRegion <= _32K,
1582	("caller='%s'/%d: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cbRegion),
1583	VERR_INVALID_PARAMETER);
1584	break;
1585
1586	case PCI_ADDRESS_SPACE_MEM:
1587	case PCI_ADDRESS_SPACE_MEM_PREFETCH:
1588	/*
1589	* Sanity check: Don't allow to register more than 2GB of the PCI MMIO space.
1590	*/
1591	AssertLogRelMsgReturn(cbRegion <= MM_MMIO_32_MAX,
1592	("caller='%s'/%d: %RGp (max %RGp)\n",
1593	pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, (RTGCPHYS)MM_MMIO_32_MAX),
1594	VERR_OUT_OF_RANGE);
1595	break;
1596
1597	case PCI_ADDRESS_SPACE_BAR64 \| PCI_ADDRESS_SPACE_MEM:
1598	case PCI_ADDRESS_SPACE_BAR64 \| PCI_ADDRESS_SPACE_MEM_PREFETCH:
1599	/*
1600	* Sanity check: Don't allow to register more than 64GB of the 64-bit PCI MMIO space.
1601	*/
1602	AssertLogRelMsgReturn(cbRegion <= MM_MMIO_64_MAX,
1603	("caller='%s'/%d: %RGp (max %RGp)\n",
1604	pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, MM_MMIO_64_MAX),
1605	VERR_OUT_OF_RANGE);
1606	break;
1607
1608	default:
1609	AssertMsgFailed(("enmType=%#x is unknown\n", enmType));
1610	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (enmType)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1611	return VERR_INVALID_PARAMETER;
1612	}
1613	if (!pfnCallback)
1614	{
1615	Assert(pfnCallback);
1616	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (callback)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
1617	return VERR_INVALID_PARAMETER;
1618	}
1619	AssertRelease(VMR3GetState(pVM) != VMSTATE_RUNNING);
1620
1621	/*
1622	* We're currently restricted to page aligned MMIO regions.
1623	*/
1624	if ( ((enmType & ~(PCI_ADDRESS_SPACE_BAR64 \| PCI_ADDRESS_SPACE_MEM_PREFETCH)) == PCI_ADDRESS_SPACE_MEM)
1625	&& cbRegion != RT_ALIGN_64(cbRegion, PAGE_SIZE))
1626	{
1627	Log(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: aligning cbRegion %RGp -> %RGp\n",
1628	pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, RT_ALIGN_64(cbRegion, PAGE_SIZE)));
1629	cbRegion = RT_ALIGN_64(cbRegion, PAGE_SIZE);
1630	}
1631
1632	/*
1633	* For registering PCI MMIO memory or PCI I/O memory, the size of the region must be a power of 2!
1634	*/
1635	int iLastSet = ASMBitLastSetU64(cbRegion);
1636	Assert(iLastSet > 0);
1637	uint64_t cbRegionAligned = RT_BIT_64(iLastSet - 1);
1638	if (cbRegion > cbRegionAligned)
1639	cbRegion = cbRegionAligned * 2; /* round up */
1640
1641	PPDMPCIBUS pBus = pPciDev->Int.s.pPdmBusR3;
1642	Assert(pBus);
1643	pdmLock(pVM);
1644	int rc = pBus->pfnIORegionRegisterR3(pBus->pDevInsR3, pPciDev, iRegion, cbRegion, enmType, pfnCallback);
1645	pdmUnlock(pVM);
1646
1647	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1648	return rc;
1649	}
1650
1651
1652	/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetConfigCallbacks} */
1653	static DECLCALLBACK(void) pdmR3DevHlp_PCISetConfigCallbacks(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, PFNPCICONFIGREAD pfnRead, PPFNPCICONFIGREAD ppfnReadOld,
1654	PFNPCICONFIGWRITE pfnWrite, PPFNPCICONFIGWRITE ppfnWriteOld)
1655	{
1656	PDMDEV_ASSERT_DEVINS(pDevIns);
1657	PVM pVM = pDevIns->Internal.s.pVMR3;
1658	VM_ASSERT_EMT(pVM);
1659	if (!pPciDev) /* NULL is an alias for the default PCI device. */
1660	pPciDev = pDevIns->Internal.s.pHeadPciDevR3;
1661	AssertReturnVoid(pPciDev);
1662	LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: pPciDev=%p pfnRead=%p ppfnReadOld=%p pfnWrite=%p ppfnWriteOld=%p\n",
1663	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pfnRead, ppfnReadOld, pfnWrite, ppfnWriteOld));
1664
1665	/*
1666	* Validate input and resolve defaults.
1667	*/
1668	AssertPtr(pfnRead);
1669	AssertPtr(pfnWrite);
1670	AssertPtrNull(ppfnReadOld);
1671	AssertPtrNull(ppfnWriteOld);
1672	AssertPtrNull(pPciDev);
1673
1674	PPDMPCIBUS pBus = pPciDev->Int.s.pPdmBusR3;
1675	AssertRelease(pBus);
1676	AssertRelease(VMR3GetState(pVM) != VMSTATE_RUNNING);
1677
1678	/*
1679	* Do the job.
1680	*/
1681	pdmLock(pVM);
1682	pBus->pfnSetConfigCallbacksR3(pBus->pDevInsR3, pPciDev, pfnRead, ppfnReadOld, pfnWrite, ppfnWriteOld);
1683	pdmUnlock(pVM);
1684
1685	LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
1686	}
1687
1688
1689	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysRead} */
1690	static DECLCALLBACK(int)
1691	pdmR3DevHlp_PCIPhysRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
1692	{
1693	PDMDEV_ASSERT_DEVINS(pDevIns);
1694	if (!pPciDev) /* NULL is an alias for the default PCI device. */
1695	pPciDev = pDevIns->Internal.s.pHeadPciDevR3;
1696	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
1697
1698	#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
1699	/*
1700	* Just check the busmaster setting here and forward the request to the generic read helper.
1701	*/
1702	if (PCIDevIsBusmaster(pPciDev))
1703	{ /* likely */ }
1704	else
1705	{
1706	Log(("pdmR3DevHlp_PCIPhysRead: caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbRead=%#zx\n",
1707	pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbRead));
1708	memset(pvBuf, 0xff, cbRead);
1709	return VERR_PDM_NOT_PCI_BUS_MASTER;
1710	}
1711	#endif
1712
1713	return pDevIns->pHlpR3->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead);
1714	}
1715
1716
1717	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysWrite} */
1718	static DECLCALLBACK(int)
1719	pdmR3DevHlp_PCIPhysWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
1720	{
1721	PDMDEV_ASSERT_DEVINS(pDevIns);
1722	if (!pPciDev) /* NULL is an alias for the default PCI device. */
1723	pPciDev = pDevIns->Internal.s.pHeadPciDevR3;
1724	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
1725
1726	#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
1727	/*
1728	* Just check the busmaster setting here and forward the request to the generic read helper.
1729	*/
1730	if (PCIDevIsBusmaster(pPciDev))
1731	{ /* likely */ }
1732	else
1733	{
1734	Log(("pdmR3DevHlp_PCIPhysWrite: caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbWrite=%#zx\n",
1735	pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbWrite));
1736	return VERR_PDM_NOT_PCI_BUS_MASTER;
1737	}
1738	#endif
1739
1740	return pDevIns->pHlpR3->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite);
1741	}
1742
1743
1744	/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrq} */
1745	static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrq(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
1746	{
1747	PDMDEV_ASSERT_DEVINS(pDevIns);
1748	if (!pPciDev) /* NULL is an alias for the default PCI device. */
1749	pPciDev = pDevIns->Internal.s.pHeadPciDevR3;
1750	AssertReturnVoid(pPciDev);
1751	LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: pPciDev=%p:{%#x} iIrq=%d iLevel=%d\n",
1752	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iIrq, iLevel));
1753
1754	/*
1755	* Validate input.
1756	*/
1757	Assert(iIrq == 0);
1758	Assert((uint32_t)iLevel <= PDM_IRQ_LEVEL_FLIP_FLOP);
1759
1760	/*
1761	* Must have a PCI device registered!
1762	*/
1763	PPDMPCIBUS pBus = pPciDev->Int.s.pPdmBusR3;
1764	Assert(pBus);
1765	PVM pVM = pDevIns->Internal.s.pVMR3;
1766
1767	pdmLock(pVM);
1768	uint32_t uTagSrc;
1769	if (iLevel & PDM_IRQ_LEVEL_HIGH)
1770	{
1771	pDevIns->Internal.s.uLastIrqTag = uTagSrc = pdmCalcIrqTag(pVM, pDevIns->idTracing);
1772	if (iLevel == PDM_IRQ_LEVEL_HIGH)
1773	VBOXVMM_PDM_IRQ_HIGH(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
1774	else
1775	VBOXVMM_PDM_IRQ_HILO(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
1776	}
1777	else
1778	uTagSrc = pDevIns->Internal.s.uLastIrqTag;
1779
1780	pBus->pfnSetIrqR3(pBus->pDevInsR3, pPciDev, iIrq, iLevel, uTagSrc);
1781
1782	if (iLevel == PDM_IRQ_LEVEL_LOW)
1783	VBOXVMM_PDM_IRQ_LOW(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
1784	pdmUnlock(pVM);
1785
1786	LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
1787	}
1788
1789
1790	/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrqNoWait} */
1791	static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrqNoWait(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
1792	{
1793	pdmR3DevHlp_PCISetIrq(pDevIns, pPciDev, iIrq, iLevel);
1794	}
1795
1796
1797	/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrq} */
1798	static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
1799	{
1800	PDMDEV_ASSERT_DEVINS(pDevIns);
1801	LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, iIrq, iLevel));
1802
1803	/*
1804	* Validate input.
1805	*/
1806	Assert(iIrq < 16);
1807	Assert((uint32_t)iLevel <= PDM_IRQ_LEVEL_FLIP_FLOP);
1808
1809	PVM pVM = pDevIns->Internal.s.pVMR3;
1810
1811	/*
1812	* Do the job.
1813	*/
1814	pdmLock(pVM);
1815	uint32_t uTagSrc;
1816	if (iLevel & PDM_IRQ_LEVEL_HIGH)
1817	{
1818	pDevIns->Internal.s.uLastIrqTag = uTagSrc = pdmCalcIrqTag(pVM, pDevIns->idTracing);
1819	if (iLevel == PDM_IRQ_LEVEL_HIGH)
1820	VBOXVMM_PDM_IRQ_HIGH(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
1821	else
1822	VBOXVMM_PDM_IRQ_HILO(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
1823	}
1824	else
1825	uTagSrc = pDevIns->Internal.s.uLastIrqTag;
1826
1827	PDMIsaSetIrq(pVM, iIrq, iLevel, uTagSrc); /* (The API takes the lock recursively.) */
1828
1829	if (iLevel == PDM_IRQ_LEVEL_LOW)
1830	VBOXVMM_PDM_IRQ_LOW(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
1831	pdmUnlock(pVM);
1832
1833	LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
1834	}
1835
1836
1837	/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrqNoWait} */
1838	static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
1839	{
1840	pdmR3DevHlp_ISASetIrq(pDevIns, iIrq, iLevel);
1841	}
1842
1843
1844	/** @interface_method_impl{PDMDEVHLPR3,pfnIoApicSendMsi} */
1845	static DECLCALLBACK(void) pdmR3DevHlp_IoApicSendMsi(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t uValue)
1846	{
1847	PDMDEV_ASSERT_DEVINS(pDevIns);
1848	LogFlow(("pdmR3DevHlp_IoApicSendMsi: caller='%s'/%d: GCPhys=%RGp uValue=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, uValue));
1849
1850	/*
1851	* Validate input.
1852	*/
1853	Assert(GCPhys != 0);
1854	Assert(uValue != 0);
1855
1856	PVM pVM = pDevIns->Internal.s.pVMR3;
1857
1858	/*
1859	* Do the job.
1860	*/
1861	pdmLock(pVM);
1862	uint32_t uTagSrc;
1863	pDevIns->Internal.s.uLastIrqTag = uTagSrc = pdmCalcIrqTag(pVM, pDevIns->idTracing);
1864	VBOXVMM_PDM_IRQ_HILO(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
1865
1866	PDMIoApicSendMsi(pVM, GCPhys, uValue, uTagSrc); /* (The API takes the lock recursively.) */
1867
1868	pdmUnlock(pVM);
1869
1870	LogFlow(("pdmR3DevHlp_IoApicSendMsi: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
1871	}
1872
1873
1874	/** @interface_method_impl{PDMDEVHLPR3,pfnDriverAttach} */
1875	static DECLCALLBACK(int) pdmR3DevHlp_DriverAttach(PPDMDEVINS pDevIns, uint32_t iLun, PPDMIBASE pBaseInterface, PPDMIBASE ppBaseInterface, const char pszDesc)
1876	{
1877	PDMDEV_ASSERT_DEVINS(pDevIns);
1878	PVM pVM = pDevIns->Internal.s.pVMR3;
1879	VM_ASSERT_EMT(pVM);
1880	LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: iLun=%d pBaseInterface=%p ppBaseInterface=%p pszDesc=%p:{%s}\n",
1881	pDevIns->pReg->szName, pDevIns->iInstance, iLun, pBaseInterface, ppBaseInterface, pszDesc, pszDesc));
1882
1883	/*
1884	* Lookup the LUN, it might already be registered.
1885	*/
1886	PPDMLUN pLunPrev = NULL;
1887	PPDMLUN pLun = pDevIns->Internal.s.pLunsR3;
1888	for (; pLun; pLunPrev = pLun, pLun = pLun->pNext)
1889	if (pLun->iLun == iLun)
1890	break;
1891
1892	/*
1893	* Create the LUN if if wasn't found, else check if driver is already attached to it.
1894	*/
1895	if (!pLun)
1896	{
1897	if ( !pBaseInterface
1898	\|\| !pszDesc
1899	\|\| !*pszDesc)
1900	{
1901	Assert(pBaseInterface);
1902	Assert(pszDesc \|\| *pszDesc);
1903	return VERR_INVALID_PARAMETER;
1904	}
1905
1906	pLun = (PPDMLUN)MMR3HeapAlloc(pVM, MM_TAG_PDM_LUN, sizeof(*pLun));
1907	if (!pLun)
1908	return VERR_NO_MEMORY;
1909
1910	pLun->iLun = iLun;
1911	pLun->pNext = pLunPrev ? pLunPrev->pNext : NULL;
1912	pLun->pTop = NULL;
1913	pLun->pBottom = NULL;
1914	pLun->pDevIns = pDevIns;
1915	pLun->pUsbIns = NULL;
1916	pLun->pszDesc = pszDesc;
1917	pLun->pBase = pBaseInterface;
1918	if (!pLunPrev)
1919	pDevIns->Internal.s.pLunsR3 = pLun;
1920	else
1921	pLunPrev->pNext = pLun;
1922	Log(("pdmR3DevHlp_DriverAttach: Registered LUN#%d '%s' with device '%s'/%d.\n",
1923	iLun, pszDesc, pDevIns->pReg->szName, pDevIns->iInstance));
1924	}
1925	else if (pLun->pTop)
1926	{
1927	AssertMsgFailed(("Already attached! The device should keep track of such things!\n"));
1928	LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_DRIVER_ALREADY_ATTACHED));
1929	return VERR_PDM_DRIVER_ALREADY_ATTACHED;
1930	}
1931	Assert(pLun->pBase == pBaseInterface);
1932
1933
1934	/*
1935	* Get the attached driver configuration.
1936	*/
1937	int rc;
1938	PCFGMNODE pNode = CFGMR3GetChildF(pDevIns->Internal.s.pCfgHandle, "LUN#%u", iLun);
1939	if (pNode)
1940	rc = pdmR3DrvInstantiate(pVM, pNode, pBaseInterface, NULL /pDrvAbove/, pLun, ppBaseInterface);
1941	else
1942	rc = VERR_PDM_NO_ATTACHED_DRIVER;
1943
1944	LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1945	return rc;
1946	}
1947
1948
1949	/** @interface_method_impl{PDMDEVHLPR3,pfnDriverDetach} */
1950	static DECLCALLBACK(int) pdmR3DevHlp_DriverDetach(PPDMDEVINS pDevIns, PPDMDRVINS pDrvIns, uint32_t fFlags)
1951	{
1952	PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
1953	LogFlow(("pdmR3DevHlp_DriverDetach: caller='%s'/%d: pDrvIns=%p\n",
1954	pDevIns->pReg->szName, pDevIns->iInstance, pDrvIns));
1955
1956	#ifdef VBOX_STRICT
1957	PVM pVM = pDevIns->Internal.s.pVMR3;
1958	VM_ASSERT_EMT(pVM);
1959	#endif
1960
1961	int rc = pdmR3DrvDetach(pDrvIns, fFlags);
1962
1963	LogFlow(("pdmR3DevHlp_DriverDetach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1964	return rc;
1965	}
1966
1967
1968	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueCreate} */
1969	static DECLCALLBACK(int) pdmR3DevHlp_QueueCreate(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
1970	PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char pszName, PPDMQUEUE ppQueue)
1971	{
1972	PDMDEV_ASSERT_DEVINS(pDevIns);
1973	LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fRZEnabled=%RTbool pszName=%p:{%s} ppQueue=%p\n",
1974	pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, pszName, ppQueue));
1975
1976	PVM pVM = pDevIns->Internal.s.pVMR3;
1977	VM_ASSERT_EMT(pVM);
1978
1979	if (pDevIns->iInstance > 0)
1980	{
1981	pszName = MMR3HeapAPrintf(pVM, MM_TAG_PDM_DEVICE_DESC, "%s_%u", pszName, pDevIns->iInstance);
1982	AssertLogRelReturn(pszName, VERR_NO_MEMORY);
1983	}
1984
1985	int rc = PDMR3QueueCreateDevice(pVM, pDevIns, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, ppQueue);
1986
1987	LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: returns %Rrc ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, ppQueue));
1988	return rc;
1989	}
1990
1991
1992	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectInit} */
1993	static DECLCALLBACK(int) pdmR3DevHlp_CritSectInit(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RT_SRC_POS_DECL,
1994	const char *pszNameFmt, va_list va)
1995	{
1996	PDMDEV_ASSERT_DEVINS(pDevIns);
1997	LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: pCritSect=%p pszNameFmt=%p:{%s}\n",
1998	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
1999
2000	PVM pVM = pDevIns->Internal.s.pVMR3;
2001	VM_ASSERT_EMT(pVM);
2002	int rc = pdmR3CritSectInitDevice(pVM, pDevIns, pCritSect, RT_SRC_POS_ARGS, pszNameFmt, va);
2003
2004	LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2005	return rc;
2006	}
2007
2008
2009	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNop} */
2010	static DECLCALLBACK(PPDMCRITSECT) pdmR3DevHlp_CritSectGetNop(PPDMDEVINS pDevIns)
2011	{
2012	PDMDEV_ASSERT_DEVINS(pDevIns);
2013	PVM pVM = pDevIns->Internal.s.pVMR3;
2014	VM_ASSERT_EMT(pVM);
2015
2016	PPDMCRITSECT pCritSect = PDMR3CritSectGetNop(pVM);
2017	LogFlow(("pdmR3DevHlp_CritSectGetNop: caller='%s'/%d: return %p\n",
2018	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
2019	return pCritSect;
2020	}
2021
2022
2023	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNopR0} */
2024	static DECLCALLBACK(R0PTRTYPE(PPDMCRITSECT)) pdmR3DevHlp_CritSectGetNopR0(PPDMDEVINS pDevIns)
2025	{
2026	PDMDEV_ASSERT_DEVINS(pDevIns);
2027	PVM pVM = pDevIns->Internal.s.pVMR3;
2028	VM_ASSERT_EMT(pVM);
2029
2030	R0PTRTYPE(PPDMCRITSECT) pCritSect = PDMR3CritSectGetNopR0(pVM);
2031	LogFlow(("pdmR3DevHlp_CritSectGetNopR0: caller='%s'/%d: return %RHv\n",
2032	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
2033	return pCritSect;
2034	}
2035
2036
2037	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNopRC} */
2038	static DECLCALLBACK(RCPTRTYPE(PPDMCRITSECT)) pdmR3DevHlp_CritSectGetNopRC(PPDMDEVINS pDevIns)
2039	{
2040	PDMDEV_ASSERT_DEVINS(pDevIns);
2041	PVM pVM = pDevIns->Internal.s.pVMR3;
2042	VM_ASSERT_EMT(pVM);
2043
2044	RCPTRTYPE(PPDMCRITSECT) pCritSect = PDMR3CritSectGetNopRC(pVM);
2045	LogFlow(("pdmR3DevHlp_CritSectGetNopRC: caller='%s'/%d: return %RRv\n",
2046	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
2047	return pCritSect;
2048	}
2049
2050
2051	/** @interface_method_impl{PDMDEVHLPR3,pfnSetDeviceCritSect} */
2052	static DECLCALLBACK(int) pdmR3DevHlp_SetDeviceCritSect(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
2053	{
2054	/*
2055	* Validate input.
2056	*
2057	* Note! We only allow the automatically created default critical section
2058	* to be replaced by this API.
2059	*/
2060	PDMDEV_ASSERT_DEVINS(pDevIns);
2061	AssertPtrReturn(pCritSect, VERR_INVALID_POINTER);
2062	LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: pCritSect=%p (%s)\n",
2063	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pCritSect->s.pszName));
2064	AssertReturn(PDMCritSectIsInitialized(pCritSect), VERR_INVALID_PARAMETER);
2065	PVM pVM = pDevIns->Internal.s.pVMR3;
2066	AssertReturn(pCritSect->s.pVMR3 == pVM, VERR_INVALID_PARAMETER);
2067
2068	VM_ASSERT_EMT(pVM);
2069	VM_ASSERT_STATE_RETURN(pVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
2070
2071	AssertReturn(pDevIns->pCritSectRoR3, VERR_PDM_DEV_IPE_1);
2072	AssertReturn(pDevIns->pCritSectRoR3->s.fAutomaticDefaultCritsect, VERR_WRONG_ORDER);
2073	AssertReturn(!pDevIns->pCritSectRoR3->s.fUsedByTimerOrSimilar, VERR_WRONG_ORDER);
2074	AssertReturn(pDevIns->pCritSectRoR3 != pCritSect, VERR_INVALID_PARAMETER);
2075
2076	/*
2077	* Replace the critical section and destroy the automatic default section.
2078	*/
2079	PPDMCRITSECT pOldCritSect = pDevIns->pCritSectRoR3;
2080	pDevIns->pCritSectRoR3 = pCritSect;
2081	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)
2082	pDevIns->pCritSectRoR0 = MMHyperCCToR0(pVM, pDevIns->pCritSectRoR3);
2083	else
2084	Assert(pDevIns->pCritSectRoR0 == NIL_RTRCPTR);
2085
2086	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
2087	pDevIns->pCritSectRoRC = MMHyperCCToRC(pVM, pDevIns->pCritSectRoR3);
2088	else
2089	Assert(pDevIns->pCritSectRoRC == NIL_RTRCPTR);
2090
2091	PDMR3CritSectDelete(pOldCritSect);
2092	if (pDevIns->pReg->fFlags & (PDM_DEVREG_FLAGS_RC \| PDM_DEVREG_FLAGS_R0))
2093	MMHyperFree(pVM, pOldCritSect);
2094	else
2095	MMR3HeapFree(pOldCritSect);
2096
2097	LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
2098	return VINF_SUCCESS;
2099	}
2100
2101
2102	/** @interface_method_impl{PDMDEVHLPR3,pfnThreadCreate} */
2103	static DECLCALLBACK(int) pdmR3DevHlp_ThreadCreate(PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
2104	PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
2105	{
2106	PDMDEV_ASSERT_DEVINS(pDevIns);
2107	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2108	LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: ppThread=%p pvUser=%p pfnThread=%p pfnWakeup=%p cbStack=%#zx enmType=%d pszName=%p:{%s}\n",
2109	pDevIns->pReg->szName, pDevIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
2110
2111	int rc = pdmR3ThreadCreateDevice(pDevIns->Internal.s.pVMR3, pDevIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
2112
2113	LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pDevIns->pReg->szName, pDevIns->iInstance,
2114	rc, *ppThread));
2115	return rc;
2116	}
2117
2118
2119	/** @interface_method_impl{PDMDEVHLPR3,pfnSetAsyncNotification} */
2120	static DECLCALLBACK(int) pdmR3DevHlp_SetAsyncNotification(PPDMDEVINS pDevIns, PFNPDMDEVASYNCNOTIFY pfnAsyncNotify)
2121	{
2122	PDMDEV_ASSERT_DEVINS(pDevIns);
2123	VM_ASSERT_EMT0(pDevIns->Internal.s.pVMR3);
2124	LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pfnAsyncNotify));
2125
2126	int rc = VINF_SUCCESS;
2127	AssertStmt(pfnAsyncNotify, rc = VERR_INVALID_PARAMETER);
2128	AssertStmt(!pDevIns->Internal.s.pfnAsyncNotify, rc = VERR_WRONG_ORDER);
2129	AssertStmt(pDevIns->Internal.s.fIntFlags & (PDMDEVINSINT_FLAGS_SUSPENDED \| PDMDEVINSINT_FLAGS_RESET), rc = VERR_WRONG_ORDER);
2130	VMSTATE enmVMState = VMR3GetState(pDevIns->Internal.s.pVMR3);
2131	AssertStmt( enmVMState == VMSTATE_SUSPENDING
2132	\|\| enmVMState == VMSTATE_SUSPENDING_EXT_LS
2133	\|\| enmVMState == VMSTATE_SUSPENDING_LS
2134	\|\| enmVMState == VMSTATE_RESETTING
2135	\|\| enmVMState == VMSTATE_RESETTING_LS
2136	\|\| enmVMState == VMSTATE_POWERING_OFF
2137	\|\| enmVMState == VMSTATE_POWERING_OFF_LS,
2138	rc = VERR_INVALID_STATE);
2139
2140	if (RT_SUCCESS(rc))
2141	pDevIns->Internal.s.pfnAsyncNotify = pfnAsyncNotify;
2142
2143	LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2144	return rc;
2145	}
2146
2147
2148	/** @interface_method_impl{PDMDEVHLPR3,pfnAsyncNotificationCompleted} */
2149	static DECLCALLBACK(void) pdmR3DevHlp_AsyncNotificationCompleted(PPDMDEVINS pDevIns)
2150	{
2151	PDMDEV_ASSERT_DEVINS(pDevIns);
2152	PVM pVM = pDevIns->Internal.s.pVMR3;
2153
2154	VMSTATE enmVMState = VMR3GetState(pVM);
2155	if ( enmVMState == VMSTATE_SUSPENDING
2156	\|\| enmVMState == VMSTATE_SUSPENDING_EXT_LS
2157	\|\| enmVMState == VMSTATE_SUSPENDING_LS
2158	\|\| enmVMState == VMSTATE_RESETTING
2159	\|\| enmVMState == VMSTATE_RESETTING_LS
2160	\|\| enmVMState == VMSTATE_POWERING_OFF
2161	\|\| enmVMState == VMSTATE_POWERING_OFF_LS)
2162	{
2163	LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
2164	VMR3AsyncPdmNotificationWakeupU(pVM->pUVM);
2165	}
2166	else
2167	LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d: enmVMState=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, enmVMState));
2168	}
2169
2170
2171	/** @interface_method_impl{PDMDEVHLPR3,pfnRTCRegister} */
2172	static DECLCALLBACK(int) pdmR3DevHlp_RTCRegister(PPDMDEVINS pDevIns, PCPDMRTCREG pRtcReg, PCPDMRTCHLP *ppRtcHlp)
2173	{
2174	PDMDEV_ASSERT_DEVINS(pDevIns);
2175	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2176	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: pRtcReg=%p:{.u32Version=%#x, .pfnWrite=%p, .pfnRead=%p} ppRtcHlp=%p\n",
2177	pDevIns->pReg->szName, pDevIns->iInstance, pRtcReg, pRtcReg->u32Version, pRtcReg->pfnWrite,
2178	pRtcReg->pfnWrite, ppRtcHlp));
2179
2180	/*
2181	* Validate input.
2182	*/
2183	if (pRtcReg->u32Version != PDM_RTCREG_VERSION)
2184	{
2185	AssertMsgFailed(("u32Version=%#x expected %#x\n", pRtcReg->u32Version,
2186	PDM_RTCREG_VERSION));
2187	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (version)\n",
2188	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2189	return VERR_INVALID_PARAMETER;
2190	}
2191	if ( !pRtcReg->pfnWrite
2192	\|\| !pRtcReg->pfnRead)
2193	{
2194	Assert(pRtcReg->pfnWrite);
2195	Assert(pRtcReg->pfnRead);
2196	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
2197	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2198	return VERR_INVALID_PARAMETER;
2199	}
2200
2201	if (!ppRtcHlp)
2202	{
2203	Assert(ppRtcHlp);
2204	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (ppRtcHlp)\n",
2205	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2206	return VERR_INVALID_PARAMETER;
2207	}
2208
2209	/*
2210	* Only one DMA device.
2211	*/
2212	PVM pVM = pDevIns->Internal.s.pVMR3;
2213	if (pVM->pdm.s.pRtc)
2214	{
2215	AssertMsgFailed(("Only one RTC device is supported!\n"));
2216	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc\n",
2217	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2218	return VERR_INVALID_PARAMETER;
2219	}
2220
2221	/*
2222	* Allocate and initialize pci bus structure.
2223	*/
2224	int rc = VINF_SUCCESS;
2225	PPDMRTC pRtc = (PPDMRTC)MMR3HeapAlloc(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE, sizeof(*pRtc));
2226	if (pRtc)
2227	{
2228	pRtc->pDevIns = pDevIns;
2229	pRtc->Reg = *pRtcReg;
2230	pVM->pdm.s.pRtc = pRtc;
2231
2232	/* set the helper pointer. */
2233	*ppRtcHlp = &g_pdmR3DevRtcHlp;
2234	Log(("PDM: Registered RTC device '%s'/%d pDevIns=%p\n",
2235	pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
2236	}
2237	else
2238	rc = VERR_NO_MEMORY;
2239
2240	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc\n",
2241	pDevIns->pReg->szName, pDevIns->iInstance, rc));
2242	return rc;
2243	}
2244
2245
2246	/** @interface_method_impl{PDMDEVHLPR3,pfnDMARegister} */
2247	static DECLCALLBACK(int) pdmR3DevHlp_DMARegister(PPDMDEVINS pDevIns, unsigned uChannel, PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser)
2248	{
2249	PDMDEV_ASSERT_DEVINS(pDevIns);
2250	PVM pVM = pDevIns->Internal.s.pVMR3;
2251	VM_ASSERT_EMT(pVM);
2252	LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: uChannel=%d pfnTransferHandler=%p pvUser=%p\n",
2253	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pfnTransferHandler, pvUser));
2254	int rc = VINF_SUCCESS;
2255	if (pVM->pdm.s.pDmac)
2256	pVM->pdm.s.pDmac->Reg.pfnRegister(pVM->pdm.s.pDmac->pDevIns, uChannel, pfnTransferHandler, pvUser);
2257	else
2258	{
2259	AssertMsgFailed(("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
2260	rc = VERR_PDM_NO_DMAC_INSTANCE;
2261	}
2262	LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: returns %Rrc\n",
2263	pDevIns->pReg->szName, pDevIns->iInstance, rc));
2264	return rc;
2265	}
2266
2267
2268	/** @interface_method_impl{PDMDEVHLPR3,pfnDMAReadMemory} */
2269	static DECLCALLBACK(int) pdmR3DevHlp_DMAReadMemory(PPDMDEVINS pDevIns, unsigned uChannel, void pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t pcbRead)
2270	{
2271	PDMDEV_ASSERT_DEVINS(pDevIns);
2272	PVM pVM = pDevIns->Internal.s.pVMR3;
2273	VM_ASSERT_EMT(pVM);
2274	LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbRead=%p\n",
2275	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbRead));
2276	int rc = VINF_SUCCESS;
2277	if (pVM->pdm.s.pDmac)
2278	{
2279	uint32_t cb = pVM->pdm.s.pDmac->Reg.pfnReadMemory(pVM->pdm.s.pDmac->pDevIns, uChannel, pvBuffer, off, cbBlock);
2280	if (pcbRead)
2281	*pcbRead = cb;
2282	}
2283	else
2284	{
2285	AssertMsgFailed(("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
2286	rc = VERR_PDM_NO_DMAC_INSTANCE;
2287	}
2288	LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: returns %Rrc\n",
2289	pDevIns->pReg->szName, pDevIns->iInstance, rc));
2290	return rc;
2291	}
2292
2293
2294	/** @interface_method_impl{PDMDEVHLPR3,pfnDMAWriteMemory} */
2295	static DECLCALLBACK(int) pdmR3DevHlp_DMAWriteMemory(PPDMDEVINS pDevIns, unsigned uChannel, const void pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t pcbWritten)
2296	{
2297	PDMDEV_ASSERT_DEVINS(pDevIns);
2298	PVM pVM = pDevIns->Internal.s.pVMR3;
2299	VM_ASSERT_EMT(pVM);
2300	LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbWritten=%p\n",
2301	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbWritten));
2302	int rc = VINF_SUCCESS;
2303	if (pVM->pdm.s.pDmac)
2304	{
2305	uint32_t cb = pVM->pdm.s.pDmac->Reg.pfnWriteMemory(pVM->pdm.s.pDmac->pDevIns, uChannel, pvBuffer, off, cbBlock);
2306	if (pcbWritten)
2307	*pcbWritten = cb;
2308	}
2309	else
2310	{
2311	AssertMsgFailed(("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
2312	rc = VERR_PDM_NO_DMAC_INSTANCE;
2313	}
2314	LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: returns %Rrc\n",
2315	pDevIns->pReg->szName, pDevIns->iInstance, rc));
2316	return rc;
2317	}
2318
2319
2320	/** @interface_method_impl{PDMDEVHLPR3,pfnDMASetDREQ} */
2321	static DECLCALLBACK(int) pdmR3DevHlp_DMASetDREQ(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel)
2322	{
2323	PDMDEV_ASSERT_DEVINS(pDevIns);
2324	PVM pVM = pDevIns->Internal.s.pVMR3;
2325	VM_ASSERT_EMT(pVM);
2326	LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: uChannel=%d uLevel=%d\n",
2327	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, uLevel));
2328	int rc = VINF_SUCCESS;
2329	if (pVM->pdm.s.pDmac)
2330	pVM->pdm.s.pDmac->Reg.pfnSetDREQ(pVM->pdm.s.pDmac->pDevIns, uChannel, uLevel);
2331	else
2332	{
2333	AssertMsgFailed(("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
2334	rc = VERR_PDM_NO_DMAC_INSTANCE;
2335	}
2336	LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: returns %Rrc\n",
2337	pDevIns->pReg->szName, pDevIns->iInstance, rc));
2338	return rc;
2339	}
2340
2341	/** @interface_method_impl{PDMDEVHLPR3,pfnDMAGetChannelMode} */
2342	static DECLCALLBACK(uint8_t) pdmR3DevHlp_DMAGetChannelMode(PPDMDEVINS pDevIns, unsigned uChannel)
2343	{
2344	PDMDEV_ASSERT_DEVINS(pDevIns);
2345	PVM pVM = pDevIns->Internal.s.pVMR3;
2346	VM_ASSERT_EMT(pVM);
2347	LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: uChannel=%d\n",
2348	pDevIns->pReg->szName, pDevIns->iInstance, uChannel));
2349	uint8_t u8Mode;
2350	if (pVM->pdm.s.pDmac)
2351	u8Mode = pVM->pdm.s.pDmac->Reg.pfnGetChannelMode(pVM->pdm.s.pDmac->pDevIns, uChannel);
2352	else
2353	{
2354	AssertMsgFailed(("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
2355	u8Mode = 3 << 2 /* illegal mode type */;
2356	}
2357	LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: returns %#04x\n",
2358	pDevIns->pReg->szName, pDevIns->iInstance, u8Mode));
2359	return u8Mode;
2360	}
2361
2362	/** @interface_method_impl{PDMDEVHLPR3,pfnDMASchedule} */
2363	static DECLCALLBACK(void) pdmR3DevHlp_DMASchedule(PPDMDEVINS pDevIns)
2364	{
2365	PDMDEV_ASSERT_DEVINS(pDevIns);
2366	PVM pVM = pDevIns->Internal.s.pVMR3;
2367	VM_ASSERT_EMT(pVM);
2368	LogFlow(("pdmR3DevHlp_DMASchedule: caller='%s'/%d: VM_FF_PDM_DMA %d -> 1\n",
2369	pDevIns->pReg->szName, pDevIns->iInstance, VM_FF_IS_SET(pVM, VM_FF_PDM_DMA)));
2370
2371	AssertMsg(pVM->pdm.s.pDmac, ("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
2372	VM_FF_SET(pVM, VM_FF_PDM_DMA);
2373	#ifdef VBOX_WITH_REM
2374	REMR3NotifyDmaPending(pVM);
2375	#endif
2376	VMR3NotifyGlobalFFU(pVM->pUVM, VMNOTIFYFF_FLAGS_DONE_REM);
2377	}
2378
2379
2380	/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSWrite} */
2381	static DECLCALLBACK(int) pdmR3DevHlp_CMOSWrite(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value)
2382	{
2383	PDMDEV_ASSERT_DEVINS(pDevIns);
2384	PVM pVM = pDevIns->Internal.s.pVMR3;
2385	VM_ASSERT_EMT(pVM);
2386
2387	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x u8Value=%#04x\n",
2388	pDevIns->pReg->szName, pDevIns->iInstance, iReg, u8Value));
2389	int rc;
2390	if (pVM->pdm.s.pRtc)
2391	{
2392	PPDMDEVINS pDevInsRtc = pVM->pdm.s.pRtc->pDevIns;
2393	rc = PDMCritSectEnter(pDevInsRtc->pCritSectRoR3, VERR_IGNORED);
2394	if (RT_SUCCESS(rc))
2395	{
2396	rc = pVM->pdm.s.pRtc->Reg.pfnWrite(pDevInsRtc, iReg, u8Value);
2397	PDMCritSectLeave(pDevInsRtc->pCritSectRoR3);
2398	}
2399	}
2400	else
2401	rc = VERR_PDM_NO_RTC_INSTANCE;
2402
2403	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
2404	pDevIns->pReg->szName, pDevIns->iInstance, rc));
2405	return rc;
2406	}
2407
2408
2409	/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSRead} */
2410	static DECLCALLBACK(int) pdmR3DevHlp_CMOSRead(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value)
2411	{
2412	PDMDEV_ASSERT_DEVINS(pDevIns);
2413	PVM pVM = pDevIns->Internal.s.pVMR3;
2414	VM_ASSERT_EMT(pVM);
2415
2416	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x pu8Value=%p\n",
2417	pDevIns->pReg->szName, pDevIns->iInstance, iReg, pu8Value));
2418	int rc;
2419	if (pVM->pdm.s.pRtc)
2420	{
2421	PPDMDEVINS pDevInsRtc = pVM->pdm.s.pRtc->pDevIns;
2422	rc = PDMCritSectEnter(pDevInsRtc->pCritSectRoR3, VERR_IGNORED);
2423	if (RT_SUCCESS(rc))
2424	{
2425	rc = pVM->pdm.s.pRtc->Reg.pfnRead(pDevInsRtc, iReg, pu8Value);
2426	PDMCritSectLeave(pDevInsRtc->pCritSectRoR3);
2427	}
2428	}
2429	else
2430	rc = VERR_PDM_NO_RTC_INSTANCE;
2431
2432	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
2433	pDevIns->pReg->szName, pDevIns->iInstance, rc));
2434	return rc;
2435	}
2436
2437
2438	/** @interface_method_impl{PDMDEVHLPR3,pfnAssertEMT} */
2439	static DECLCALLBACK(bool) pdmR3DevHlp_AssertEMT(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction)
2440	{
2441	PDMDEV_ASSERT_DEVINS(pDevIns);
2442	if (VM_IS_EMT(pDevIns->Internal.s.pVMR3))
2443	return true;
2444
2445	char szMsg[100];
2446	RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
2447	RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
2448	AssertBreakpoint();
2449	return false;
2450	}
2451
2452
2453	/** @interface_method_impl{PDMDEVHLPR3,pfnAssertOther} */
2454	static DECLCALLBACK(bool) pdmR3DevHlp_AssertOther(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction)
2455	{
2456	PDMDEV_ASSERT_DEVINS(pDevIns);
2457	if (!VM_IS_EMT(pDevIns->Internal.s.pVMR3))
2458	return true;
2459
2460	char szMsg[100];
2461	RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
2462	RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
2463	AssertBreakpoint();
2464	return false;
2465	}
2466
2467
2468	/** @interface_method_impl{PDMDEVHLPR3,pfnLdrGetRCInterfaceSymbols} */
2469	static DECLCALLBACK(int) pdmR3DevHlp_LdrGetRCInterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
2470	const char pszSymPrefix, const char pszSymList)
2471	{
2472	PDMDEV_ASSERT_DEVINS(pDevIns);
2473	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2474	LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
2475	pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
2476
2477	int rc;
2478	if ( strncmp(pszSymPrefix, "dev", 3) == 0
2479	&& RTStrIStr(pszSymPrefix + 3, pDevIns->pReg->szName) != NULL)
2480	{
2481	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
2482	rc = PDMR3LdrGetInterfaceSymbols(pDevIns->Internal.s.pVMR3,
2483	pvInterface, cbInterface,
2484	pDevIns->pReg->szRCMod, pDevIns->Internal.s.pDevR3->pszRCSearchPath,
2485	pszSymPrefix, pszSymList,
2486	false /fRing0OrRC/);
2487	else
2488	{
2489	AssertMsgFailed(("Not a raw-mode enabled driver\n"));
2490	rc = VERR_PERMISSION_DENIED;
2491	}
2492	}
2493	else
2494	{
2495	AssertMsgFailed(("Invalid prefix '%s' for '%s'; must start with 'dev' and contain the driver name!\n",
2496	pszSymPrefix, pDevIns->pReg->szName));
2497	rc = VERR_INVALID_NAME;
2498	}
2499
2500	LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
2501	pDevIns->iInstance, rc));
2502	return rc;
2503	}
2504
2505
2506	/** @interface_method_impl{PDMDEVHLPR3,pfnLdrGetR0InterfaceSymbols} */
2507	static DECLCALLBACK(int) pdmR3DevHlp_LdrGetR0InterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
2508	const char pszSymPrefix, const char pszSymList)
2509	{
2510	PDMDEV_ASSERT_DEVINS(pDevIns);
2511	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2512	LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
2513	pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
2514
2515	int rc;
2516	if ( strncmp(pszSymPrefix, "dev", 3) == 0
2517	&& RTStrIStr(pszSymPrefix + 3, pDevIns->pReg->szName) != NULL)
2518	{
2519	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)
2520	rc = PDMR3LdrGetInterfaceSymbols(pDevIns->Internal.s.pVMR3,
2521	pvInterface, cbInterface,
2522	pDevIns->pReg->szR0Mod, pDevIns->Internal.s.pDevR3->pszR0SearchPath,
2523	pszSymPrefix, pszSymList,
2524	true /fRing0OrRC/);
2525	else
2526	{
2527	AssertMsgFailed(("Not a ring-0 enabled driver\n"));
2528	rc = VERR_PERMISSION_DENIED;
2529	}
2530	}
2531	else
2532	{
2533	AssertMsgFailed(("Invalid prefix '%s' for '%s'; must start with 'dev' and contain the driver name!\n",
2534	pszSymPrefix, pDevIns->pReg->szName));
2535	rc = VERR_INVALID_NAME;
2536	}
2537
2538	LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
2539	pDevIns->iInstance, rc));
2540	return rc;
2541	}
2542
2543
2544	/** @interface_method_impl{PDMDEVHLPR3,pfnCallR0} */
2545	static DECLCALLBACK(int) pdmR3DevHlp_CallR0(PPDMDEVINS pDevIns, uint32_t uOperation, uint64_t u64Arg)
2546	{
2547	PDMDEV_ASSERT_DEVINS(pDevIns);
2548	PVM pVM = pDevIns->Internal.s.pVMR3;
2549	VM_ASSERT_EMT(pVM);
2550	LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: uOperation=%#x u64Arg=%#RX64\n",
2551	pDevIns->pReg->szName, pDevIns->iInstance, uOperation, u64Arg));
2552
2553	/*
2554	* Resolve the ring-0 entry point. There is not need to remember this like
2555	* we do for drivers since this is mainly for construction time hacks and
2556	* other things that aren't performance critical.
2557	*/
2558	int rc;
2559	if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)
2560	{
2561	char szSymbol[ sizeof("devR0") + sizeof(pDevIns->pReg->szName) + sizeof("ReqHandler")];
2562	strcat(strcat(strcpy(szSymbol, "devR0"), pDevIns->pReg->szName), "ReqHandler");
2563	szSymbol[sizeof("devR0") - 1] = RT_C_TO_UPPER(szSymbol[sizeof("devR0") - 1]);
2564
2565	PFNPDMDRVREQHANDLERR0 pfnReqHandlerR0;
2566	rc = pdmR3DevGetSymbolR0Lazy(pDevIns, szSymbol, &pfnReqHandlerR0);
2567	if (RT_SUCCESS(rc))
2568	{
2569	/*
2570	* Make the ring-0 call.
2571	*/
2572	PDMDEVICECALLREQHANDLERREQ Req;
2573	Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
2574	Req.Hdr.cbReq = sizeof(Req);
2575	Req.pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
2576	Req.pfnReqHandlerR0 = pfnReqHandlerR0;
2577	Req.uOperation = uOperation;
2578	Req.u32Alignment = 0;
2579	Req.u64Arg = u64Arg;
2580	rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_PDM_DEVICE_CALL_REQ_HANDLER, 0, &Req.Hdr);
2581	}
2582	else
2583	pfnReqHandlerR0 = NIL_RTR0PTR;
2584	}
2585	else
2586	rc = VERR_ACCESS_DENIED;
2587	LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
2588	pDevIns->iInstance, rc));
2589	return rc;
2590	}
2591
2592
2593	/** @interface_method_impl{PDMDEVHLPR3,pfnVMGetSuspendReason} */
2594	static DECLCALLBACK(VMSUSPENDREASON) pdmR3DevHlp_VMGetSuspendReason(PPDMDEVINS pDevIns)
2595	{
2596	PDMDEV_ASSERT_DEVINS(pDevIns);
2597	PVM pVM = pDevIns->Internal.s.pVMR3;
2598	VM_ASSERT_EMT(pVM);
2599	VMSUSPENDREASON enmReason = VMR3GetSuspendReason(pVM->pUVM);
2600	LogFlow(("pdmR3DevHlp_VMGetSuspendReason: caller='%s'/%d: returns %d\n",
2601	pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
2602	return enmReason;
2603	}
2604
2605
2606	/** @interface_method_impl{PDMDEVHLPR3,pfnVMGetResumeReason} */
2607	static DECLCALLBACK(VMRESUMEREASON) pdmR3DevHlp_VMGetResumeReason(PPDMDEVINS pDevIns)
2608	{
2609	PDMDEV_ASSERT_DEVINS(pDevIns);
2610	PVM pVM = pDevIns->Internal.s.pVMR3;
2611	VM_ASSERT_EMT(pVM);
2612	VMRESUMEREASON enmReason = VMR3GetResumeReason(pVM->pUVM);
2613	LogFlow(("pdmR3DevHlp_VMGetResumeReason: caller='%s'/%d: returns %d\n",
2614	pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
2615	return enmReason;
2616	}
2617
2618
2619	/** @interface_method_impl{PDMDEVHLPR3,pfnGetUVM} */
2620	static DECLCALLBACK(PUVM) pdmR3DevHlp_GetUVM(PPDMDEVINS pDevIns)
2621	{
2622	PDMDEV_ASSERT_DEVINS(pDevIns);
2623	LogFlow(("pdmR3DevHlp_GetUVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns->Internal.s.pVMR3));
2624	return pDevIns->Internal.s.pVMR3->pUVM;
2625	}
2626
2627
2628	/** @interface_method_impl{PDMDEVHLPR3,pfnGetVM} */
2629	static DECLCALLBACK(PVM) pdmR3DevHlp_GetVM(PPDMDEVINS pDevIns)
2630	{
2631	PDMDEV_ASSERT_DEVINS(pDevIns);
2632	LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns->Internal.s.pVMR3));
2633	return pDevIns->Internal.s.pVMR3;
2634	}
2635
2636
2637	/** @interface_method_impl{PDMDEVHLPR3,pfnGetVMCPU} */
2638	static DECLCALLBACK(PVMCPU) pdmR3DevHlp_GetVMCPU(PPDMDEVINS pDevIns)
2639	{
2640	PDMDEV_ASSERT_DEVINS(pDevIns);
2641	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2642	LogFlow(("pdmR3DevHlp_GetVMCPU: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, VMMGetCpuId(pDevIns->Internal.s.pVMR3)));
2643	return VMMGetCpu(pDevIns->Internal.s.pVMR3);
2644	}
2645
2646
2647	/** @interface_method_impl{PDMDEVHLPR3,pfnGetCurrentCpuId} */
2648	static DECLCALLBACK(VMCPUID) pdmR3DevHlp_GetCurrentCpuId(PPDMDEVINS pDevIns)
2649	{
2650	PDMDEV_ASSERT_DEVINS(pDevIns);
2651	VMCPUID idCpu = VMMGetCpuId(pDevIns->Internal.s.pVMR3);
2652	LogFlow(("pdmR3DevHlp_GetCurrentCpuId: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, idCpu));
2653	return idCpu;
2654	}
2655
2656
2657	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIBusRegister} */
2658	static DECLCALLBACK(int) pdmR3DevHlp_PCIBusRegister(PPDMDEVINS pDevIns, PPDMPCIBUSREG pPciBusReg,
2659	PCPDMPCIHLPR3 ppPciHlpR3, uint32_t piBus)
2660	{
2661	PDMDEV_ASSERT_DEVINS(pDevIns);
2662	PVM pVM = pDevIns->Internal.s.pVMR3;
2663	VM_ASSERT_EMT(pVM);
2664	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: pPciBusReg=%p:{.u32Version=%#x, .pfnRegisterR3=%p, .pfnIORegionRegisterR3=%p, "
2665	".pfnSetIrqR3=%p, .pszSetIrqRC=%p:{%s}, .pszSetIrqR0=%p:{%s}} ppPciHlpR3=%p piBus=%p\n",
2666	pDevIns->pReg->szName, pDevIns->iInstance, pPciBusReg, pPciBusReg->u32Version, pPciBusReg->pfnRegisterR3,
2667	pPciBusReg->pfnIORegionRegisterR3, pPciBusReg->pfnSetIrqR3, pPciBusReg->pszSetIrqRC, pPciBusReg->pszSetIrqRC,
2668	pPciBusReg->pszSetIrqR0, pPciBusReg->pszSetIrqR0, ppPciHlpR3, piBus));
2669
2670	/*
2671	* Validate the structure.
2672	*/
2673	if (pPciBusReg->u32Version != PDM_PCIBUSREG_VERSION)
2674	{
2675	AssertMsgFailed(("u32Version=%#x expected %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREG_VERSION));
2676	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2677	return VERR_INVALID_PARAMETER;
2678	}
2679	if ( !pPciBusReg->pfnRegisterR3
2680	\|\| !pPciBusReg->pfnIORegionRegisterR3
2681	\|\| !pPciBusReg->pfnSetIrqR3)
2682	{
2683	Assert(pPciBusReg->pfnRegisterR3);
2684	Assert(pPciBusReg->pfnIORegionRegisterR3);
2685	Assert(pPciBusReg->pfnSetIrqR3);
2686	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2687	return VERR_INVALID_PARAMETER;
2688	}
2689	if ( pPciBusReg->pszSetIrqRC
2690	&& !VALID_PTR(pPciBusReg->pszSetIrqRC))
2691	{
2692	Assert(VALID_PTR(pPciBusReg->pszSetIrqRC));
2693	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2694	return VERR_INVALID_PARAMETER;
2695	}
2696	if ( pPciBusReg->pszSetIrqR0
2697	&& !VALID_PTR(pPciBusReg->pszSetIrqR0))
2698	{
2699	Assert(VALID_PTR(pPciBusReg->pszSetIrqR0));
2700	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2701	return VERR_INVALID_PARAMETER;
2702	}
2703	if (!ppPciHlpR3)
2704	{
2705	Assert(ppPciHlpR3);
2706	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (ppPciHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2707	return VERR_INVALID_PARAMETER;
2708	}
2709	AssertLogRelMsgReturn(RT_VALID_PTR(piBus) \|\| !piBus,
2710	("caller='%s'/%d: piBus=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, piBus),
2711	VERR_INVALID_POINTER);
2712
2713	/*
2714	* Find free PCI bus entry.
2715	*/
2716	unsigned iBus = 0;
2717	for (iBus = 0; iBus < RT_ELEMENTS(pVM->pdm.s.aPciBuses); iBus++)
2718	if (!pVM->pdm.s.aPciBuses[iBus].pDevInsR3)
2719	break;
2720	if (iBus >= RT_ELEMENTS(pVM->pdm.s.aPciBuses))
2721	{
2722	AssertMsgFailed(("Too many PCI buses. Max=%u\n", RT_ELEMENTS(pVM->pdm.s.aPciBuses)));
2723	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (pci bus)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2724	return VERR_INVALID_PARAMETER;
2725	}
2726	PPDMPCIBUS pPciBus = &pVM->pdm.s.aPciBuses[iBus];
2727
2728	/*
2729	* Resolve and init the RC bits.
2730	*/
2731	if (pPciBusReg->pszSetIrqRC)
2732	{
2733	int rc = pdmR3DevGetSymbolRCLazy(pDevIns, pPciBusReg->pszSetIrqRC, &pPciBus->pfnSetIrqRC);
2734	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pPciBusReg->pszSetIrqRC, rc));
2735	if (RT_FAILURE(rc))
2736	{
2737	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2738	return rc;
2739	}
2740	pPciBus->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
2741	}
2742	else
2743	{
2744	pPciBus->pfnSetIrqRC = 0;
2745	pPciBus->pDevInsRC = 0;
2746	}
2747
2748	/*
2749	* Resolve and init the R0 bits.
2750	*/
2751	if (pPciBusReg->pszSetIrqR0)
2752	{
2753	int rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pPciBusReg->pszSetIrqR0, &pPciBus->pfnSetIrqR0);
2754	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pPciBusReg->pszSetIrqR0, rc));
2755	if (RT_FAILURE(rc))
2756	{
2757	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2758	return rc;
2759	}
2760	pPciBus->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
2761	}
2762	else
2763	{
2764	pPciBus->pfnSetIrqR0 = 0;
2765	pPciBus->pDevInsR0 = 0;
2766	}
2767
2768	/*
2769	* Init the R3 bits.
2770	*/
2771	pPciBus->iBus = iBus;
2772	pPciBus->pDevInsR3 = pDevIns;
2773	pPciBus->pfnRegisterR3 = pPciBusReg->pfnRegisterR3;
2774	pPciBus->pfnRegisterMsiR3 = pPciBusReg->pfnRegisterMsiR3;
2775	pPciBus->pfnIORegionRegisterR3 = pPciBusReg->pfnIORegionRegisterR3;
2776	pPciBus->pfnSetConfigCallbacksR3 = pPciBusReg->pfnSetConfigCallbacksR3;
2777	pPciBus->pfnSetIrqR3 = pPciBusReg->pfnSetIrqR3;
2778
2779	Log(("PDM: Registered PCI bus device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
2780
2781	/* set the helper pointer and return. */
2782	*ppPciHlpR3 = &g_pdmR3DevPciHlp;
2783	if (piBus)
2784	*piBus = iBus;
2785	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc *piBus=%u\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS, iBus));
2786	return VINF_SUCCESS;
2787	}
2788
2789
2790	/** @interface_method_impl{PDMDEVHLPR3,pfnPICRegister} */
2791	static DECLCALLBACK(int) pdmR3DevHlp_PICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLPR3 *ppPicHlpR3)
2792	{
2793	PDMDEV_ASSERT_DEVINS(pDevIns);
2794	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2795	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pfnGetInterruptR3=%p, .pszGetIrqRC=%p:{%s}, .pszGetInterruptRC=%p:{%s}, .pszGetIrqR0=%p:{%s}, .pszGetInterruptR0=%p:{%s} } ppPicHlpR3=%p\n",
2796	pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrqR3, pPicReg->pfnGetInterruptR3,
2797	pPicReg->pszSetIrqRC, pPicReg->pszSetIrqRC, pPicReg->pszGetInterruptRC, pPicReg->pszGetInterruptRC,
2798	pPicReg->pszSetIrqR0, pPicReg->pszSetIrqR0, pPicReg->pszGetInterruptR0, pPicReg->pszGetInterruptR0,
2799	ppPicHlpR3));
2800
2801	/*
2802	* Validate input.
2803	*/
2804	if (pPicReg->u32Version != PDM_PICREG_VERSION)
2805	{
2806	AssertMsgFailed(("u32Version=%#x expected %#x\n", pPicReg->u32Version, PDM_PICREG_VERSION));
2807	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2808	return VERR_INVALID_PARAMETER;
2809	}
2810	if ( !pPicReg->pfnSetIrqR3
2811	\|\| !pPicReg->pfnGetInterruptR3)
2812	{
2813	Assert(pPicReg->pfnSetIrqR3);
2814	Assert(pPicReg->pfnGetInterruptR3);
2815	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2816	return VERR_INVALID_PARAMETER;
2817	}
2818	if ( ( pPicReg->pszSetIrqRC
2819	\|\| pPicReg->pszGetInterruptRC)
2820	&& ( !VALID_PTR(pPicReg->pszSetIrqRC)
2821	\|\| !VALID_PTR(pPicReg->pszGetInterruptRC))
2822	)
2823	{
2824	Assert(VALID_PTR(pPicReg->pszSetIrqRC));
2825	Assert(VALID_PTR(pPicReg->pszGetInterruptRC));
2826	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2827	return VERR_INVALID_PARAMETER;
2828	}
2829	if ( pPicReg->pszSetIrqRC
2830	&& !(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC))
2831	{
2832	Assert(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC);
2833	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC flag)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2834	return VERR_INVALID_PARAMETER;
2835	}
2836	if ( pPicReg->pszSetIrqR0
2837	&& !(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0))
2838	{
2839	Assert(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0);
2840	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R0 flag)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2841	return VERR_INVALID_PARAMETER;
2842	}
2843	if (!ppPicHlpR3)
2844	{
2845	Assert(ppPicHlpR3);
2846	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (ppPicHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2847	return VERR_INVALID_PARAMETER;
2848	}
2849
2850	/*
2851	* Only one PIC device.
2852	*/
2853	PVM pVM = pDevIns->Internal.s.pVMR3;
2854	if (pVM->pdm.s.Pic.pDevInsR3)
2855	{
2856	AssertMsgFailed(("Only one pic device is supported!\n"));
2857	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2858	return VERR_INVALID_PARAMETER;
2859	}
2860
2861	/*
2862	* RC stuff.
2863	*/
2864	if (pPicReg->pszSetIrqRC)
2865	{
2866	int rc = pdmR3DevGetSymbolRCLazy(pDevIns, pPicReg->pszSetIrqRC, &pVM->pdm.s.Pic.pfnSetIrqRC);
2867	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pPicReg->pszSetIrqRC, rc));
2868	if (RT_SUCCESS(rc))
2869	{
2870	rc = pdmR3DevGetSymbolRCLazy(pDevIns, pPicReg->pszGetInterruptRC, &pVM->pdm.s.Pic.pfnGetInterruptRC);
2871	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pPicReg->pszGetInterruptRC, rc));
2872	}
2873	if (RT_FAILURE(rc))
2874	{
2875	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2876	return rc;
2877	}
2878	pVM->pdm.s.Pic.pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
2879	}
2880	else
2881	{
2882	pVM->pdm.s.Pic.pDevInsRC = 0;
2883	pVM->pdm.s.Pic.pfnSetIrqRC = 0;
2884	pVM->pdm.s.Pic.pfnGetInterruptRC = 0;
2885	}
2886
2887	/*
2888	* R0 stuff.
2889	*/
2890	if (pPicReg->pszSetIrqR0)
2891	{
2892	int rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pPicReg->pszSetIrqR0, &pVM->pdm.s.Pic.pfnSetIrqR0);
2893	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pPicReg->pszSetIrqR0, rc));
2894	if (RT_SUCCESS(rc))
2895	{
2896	rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pPicReg->pszGetInterruptR0, &pVM->pdm.s.Pic.pfnGetInterruptR0);
2897	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pPicReg->pszGetInterruptR0, rc));
2898	}
2899	if (RT_FAILURE(rc))
2900	{
2901	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2902	return rc;
2903	}
2904	pVM->pdm.s.Pic.pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
2905	Assert(pVM->pdm.s.Pic.pDevInsR0);
2906	}
2907	else
2908	{
2909	pVM->pdm.s.Pic.pfnSetIrqR0 = 0;
2910	pVM->pdm.s.Pic.pfnGetInterruptR0 = 0;
2911	pVM->pdm.s.Pic.pDevInsR0 = 0;
2912	}
2913
2914	/*
2915	* R3 stuff.
2916	*/
2917	pVM->pdm.s.Pic.pDevInsR3 = pDevIns;
2918	pVM->pdm.s.Pic.pfnSetIrqR3 = pPicReg->pfnSetIrqR3;
2919	pVM->pdm.s.Pic.pfnGetInterruptR3 = pPicReg->pfnGetInterruptR3;
2920	Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
2921
2922	/* set the helper pointer and return. */
2923	*ppPicHlpR3 = &g_pdmR3DevPicHlp;
2924	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
2925	return VINF_SUCCESS;
2926	}
2927
2928
2929	/** @interface_method_impl{PDMDEVHLPR3,pfnAPICRegister} */
2930	static DECLCALLBACK(int) pdmR3DevHlp_APICRegister(PPDMDEVINS pDevIns)
2931	{
2932	PDMDEV_ASSERT_DEVINS(pDevIns);
2933	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2934
2935	/*
2936	* Only one APIC device. On SMP we have single logical device covering all LAPICs,
2937	* as they need to communicate and share state easily.
2938	*/
2939	PVM pVM = pDevIns->Internal.s.pVMR3;
2940	if (pVM->pdm.s.Apic.pDevInsR3)
2941	{
2942	AssertMsgFailed(("Only one APIC device is supported!\n"));
2943	LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2944	return VERR_INVALID_PARAMETER;
2945	}
2946
2947	/*
2948	* Initialize the RC, R0 and HC bits.
2949	*/
2950	pVM->pdm.s.Apic.pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
2951	Assert(pVM->pdm.s.Apic.pDevInsRC);
2952
2953	pVM->pdm.s.Apic.pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
2954	Assert(pVM->pdm.s.Apic.pDevInsR0);
2955
2956	pVM->pdm.s.Apic.pDevInsR3 = pDevIns;
2957	LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
2958	return VINF_SUCCESS;
2959	}
2960
2961
2962	/** @interface_method_impl{PDMDEVHLPR3,pfnIOAPICRegister} */
2963	static DECLCALLBACK(int) pdmR3DevHlp_IOAPICRegister(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLPR3 *ppIoApicHlpR3)
2964	{
2965	PDMDEV_ASSERT_DEVINS(pDevIns);
2966	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
2967	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pszSetIrqRC=%p:{%s}, .pszSetIrqR0=%p:{%s}} ppIoApicHlpR3=%p\n",
2968	pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrqR3,
2969	pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqR0, pIoApicReg->pszSetIrqR0, ppIoApicHlpR3));
2970
2971	/*
2972	* Validate input.
2973	*/
2974	if (pIoApicReg->u32Version != PDM_IOAPICREG_VERSION)
2975	{
2976	AssertMsgFailed(("u32Version=%#x expected %#x\n", pIoApicReg->u32Version, PDM_IOAPICREG_VERSION));
2977	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2978	return VERR_INVALID_PARAMETER;
2979	}
2980	if (!pIoApicReg->pfnSetIrqR3 \|\| !pIoApicReg->pfnSendMsiR3 \|\| !pIoApicReg->pfnSetEoiR3)
2981	{
2982	Assert(pIoApicReg->pfnSetIrqR3);
2983	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2984	return VERR_INVALID_PARAMETER;
2985	}
2986	if ( pIoApicReg->pszSetIrqRC
2987	&& !VALID_PTR(pIoApicReg->pszSetIrqRC))
2988	{
2989	Assert(VALID_PTR(pIoApicReg->pszSetIrqRC));
2990	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2991	return VERR_INVALID_PARAMETER;
2992	}
2993	if ( pIoApicReg->pszSendMsiRC
2994	&& !VALID_PTR(pIoApicReg->pszSendMsiRC))
2995	{
2996	Assert(VALID_PTR(pIoApicReg->pszSendMsiRC));
2997	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
2998	return VERR_INVALID_PARAMETER;
2999	}
3000	if ( pIoApicReg->pszSetEoiRC
3001	&& !VALID_PTR(pIoApicReg->pszSetEoiRC))
3002	{
3003	Assert(VALID_PTR(pIoApicReg->pszSetEoiRC));
3004	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3005	return VERR_INVALID_PARAMETER;
3006	}
3007	if ( pIoApicReg->pszSetIrqR0
3008	&& !VALID_PTR(pIoApicReg->pszSetIrqR0))
3009	{
3010	Assert(VALID_PTR(pIoApicReg->pszSetIrqR0));
3011	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3012	return VERR_INVALID_PARAMETER;
3013	}
3014	if ( pIoApicReg->pszSendMsiR0
3015	&& !VALID_PTR(pIoApicReg->pszSendMsiR0))
3016	{
3017	Assert(VALID_PTR(pIoApicReg->pszSendMsiR0));
3018	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3019	return VERR_INVALID_PARAMETER;
3020	}
3021	if ( pIoApicReg->pszSetEoiR0
3022	&& !VALID_PTR(pIoApicReg->pszSetEoiR0))
3023	{
3024	Assert(VALID_PTR(pIoApicReg->pszSetEoiR0));
3025	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3026	return VERR_INVALID_PARAMETER;
3027	}
3028	if (!ppIoApicHlpR3)
3029	{
3030	Assert(ppIoApicHlpR3);
3031	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (ppApicHlp)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3032	return VERR_INVALID_PARAMETER;
3033	}
3034
3035	/*
3036	* The I/O APIC requires the APIC to be present (hacks++).
3037	* If the I/O APIC does GC stuff so must the APIC.
3038	*/
3039	PVM pVM = pDevIns->Internal.s.pVMR3;
3040	if (!pVM->pdm.s.Apic.pDevInsR3)
3041	{
3042	AssertMsgFailed(("Configuration error / Init order error! No APIC!\n"));
3043	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (no APIC)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3044	return VERR_INVALID_PARAMETER;
3045	}
3046	if ( pIoApicReg->pszSetIrqRC
3047	&& !pVM->pdm.s.Apic.pDevInsRC)
3048	{
3049	AssertMsgFailed(("Configuration error! APIC doesn't do GC, I/O APIC does!\n"));
3050	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (no GC APIC)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3051	return VERR_INVALID_PARAMETER;
3052	}
3053
3054	/*
3055	* Only one I/O APIC device.
3056	*/
3057	if (pVM->pdm.s.IoApic.pDevInsR3)
3058	{
3059	AssertMsgFailed(("Only one ioapic device is supported!\n"));
3060	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (only one)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3061	return VERR_INVALID_PARAMETER;
3062	}
3063
3064	/*
3065	* Resolve & initialize the GC bits.
3066	*/
3067	if (pIoApicReg->pszSetIrqRC)
3068	{
3069	int rc = pdmR3DevGetSymbolRCLazy(pDevIns, pIoApicReg->pszSetIrqRC, &pVM->pdm.s.IoApic.pfnSetIrqRC);
3070	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pIoApicReg->pszSetIrqRC, rc));
3071	if (RT_FAILURE(rc))
3072	{
3073	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3074	return rc;
3075	}
3076	pVM->pdm.s.IoApic.pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
3077	}
3078	else
3079	{
3080	pVM->pdm.s.IoApic.pDevInsRC = 0;
3081	pVM->pdm.s.IoApic.pfnSetIrqRC = 0;
3082	}
3083
3084	if (pIoApicReg->pszSendMsiRC)
3085	{
3086	int rc = pdmR3DevGetSymbolRCLazy(pDevIns, pIoApicReg->pszSendMsiRC, &pVM->pdm.s.IoApic.pfnSendMsiRC);
3087	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pIoApicReg->pszSendMsiRC, rc));
3088	if (RT_FAILURE(rc))
3089	{
3090	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3091	return rc;
3092	}
3093	}
3094	else
3095	{
3096	pVM->pdm.s.IoApic.pfnSendMsiRC = 0;
3097	}
3098
3099	if (pIoApicReg->pszSetEoiRC)
3100	{
3101	int rc = pdmR3DevGetSymbolRCLazy(pDevIns, pIoApicReg->pszSetEoiRC, &pVM->pdm.s.IoApic.pfnSetEoiRC);
3102	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pIoApicReg->pszSetEoiRC, rc));
3103	if (RT_FAILURE(rc))
3104	{
3105	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3106	return rc;
3107	}
3108	}
3109	else
3110	{
3111	pVM->pdm.s.IoApic.pfnSetEoiRC = 0;
3112	}
3113
3114	/*
3115	* Resolve & initialize the R0 bits.
3116	*/
3117	if (pIoApicReg->pszSetIrqR0)
3118	{
3119	int rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pIoApicReg->pszSetIrqR0, &pVM->pdm.s.IoApic.pfnSetIrqR0);
3120	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pIoApicReg->pszSetIrqR0, rc));
3121	if (RT_FAILURE(rc))
3122	{
3123	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3124	return rc;
3125	}
3126	pVM->pdm.s.IoApic.pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
3127	Assert(pVM->pdm.s.IoApic.pDevInsR0);
3128	}
3129	else
3130	{
3131	pVM->pdm.s.IoApic.pfnSetIrqR0 = 0;
3132	pVM->pdm.s.IoApic.pDevInsR0 = 0;
3133	}
3134
3135	if (pIoApicReg->pszSendMsiR0)
3136	{
3137	int rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pIoApicReg->pszSendMsiR0, &pVM->pdm.s.IoApic.pfnSendMsiR0);
3138	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pIoApicReg->pszSendMsiR0, rc));
3139	if (RT_FAILURE(rc))
3140	{
3141	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3142	return rc;
3143	}
3144	}
3145	else
3146	{
3147	pVM->pdm.s.IoApic.pfnSendMsiR0 = 0;
3148	}
3149
3150	if (pIoApicReg->pszSetEoiR0)
3151	{
3152	int rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pIoApicReg->pszSetEoiR0, &pVM->pdm.s.IoApic.pfnSetEoiR0);
3153	AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pIoApicReg->pszSetEoiR0, rc));
3154	if (RT_FAILURE(rc))
3155	{
3156	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3157	return rc;
3158	}
3159	}
3160	else
3161	{
3162	pVM->pdm.s.IoApic.pfnSetEoiR0 = 0;
3163	}
3164
3165
3166	/*
3167	* Initialize the R3 bits.
3168	*/
3169	pVM->pdm.s.IoApic.pDevInsR3 = pDevIns;
3170	pVM->pdm.s.IoApic.pfnSetIrqR3 = pIoApicReg->pfnSetIrqR3;
3171	pVM->pdm.s.IoApic.pfnSendMsiR3 = pIoApicReg->pfnSendMsiR3;
3172	pVM->pdm.s.IoApic.pfnSetEoiR3 = pIoApicReg->pfnSetEoiR3;
3173	Log(("PDM: Registered I/O APIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
3174
3175	/* set the helper pointer and return. */
3176	*ppIoApicHlpR3 = &g_pdmR3DevIoApicHlp;
3177	LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
3178	return VINF_SUCCESS;
3179	}
3180
3181
3182	/** @interface_method_impl{PDMDEVHLPR3,pfnHPETRegister} */
3183	static DECLCALLBACK(int) pdmR3DevHlp_HPETRegister(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3)
3184	{
3185	PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
3186	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
3187	LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
3188
3189	/*
3190	* Validate input.
3191	*/
3192	if (pHpetReg->u32Version != PDM_HPETREG_VERSION)
3193	{
3194	AssertMsgFailed(("u32Version=%#x expected %#x\n", pHpetReg->u32Version, PDM_HPETREG_VERSION));
3195	LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3196	return VERR_INVALID_PARAMETER;
3197	}
3198
3199	if (!ppHpetHlpR3)
3200	{
3201	Assert(ppHpetHlpR3);
3202	LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (ppApicHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3203	return VERR_INVALID_PARAMETER;
3204	}
3205
3206	/* set the helper pointer and return. */
3207	*ppHpetHlpR3 = &g_pdmR3DevHpetHlp;
3208	LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
3209	return VINF_SUCCESS;
3210	}
3211
3212
3213	/** @interface_method_impl{PDMDEVHLPR3,pfnPciRawRegister} */
3214	static DECLCALLBACK(int) pdmR3DevHlp_PciRawRegister(PPDMDEVINS pDevIns, PPDMPCIRAWREG pPciRawReg, PCPDMPCIRAWHLPR3 *ppPciRawHlpR3)
3215	{
3216	PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
3217	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
3218	LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
3219
3220	/*
3221	* Validate input.
3222	*/
3223	if (pPciRawReg->u32Version != PDM_PCIRAWREG_VERSION)
3224	{
3225	AssertMsgFailed(("u32Version=%#x expected %#x\n", pPciRawReg->u32Version, PDM_PCIRAWREG_VERSION));
3226	LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3227	return VERR_INVALID_PARAMETER;
3228	}
3229
3230	if (!ppPciRawHlpR3)
3231	{
3232	Assert(ppPciRawHlpR3);
3233	LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc (ppPciRawHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3234	return VERR_INVALID_PARAMETER;
3235	}
3236
3237	/* set the helper pointer and return. */
3238	*ppPciRawHlpR3 = &g_pdmR3DevPciRawHlp;
3239	LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
3240	return VINF_SUCCESS;
3241	}
3242
3243
3244	/** @interface_method_impl{PDMDEVHLPR3,pfnDMACRegister} */
3245	static DECLCALLBACK(int) pdmR3DevHlp_DMACRegister(PPDMDEVINS pDevIns, PPDMDMACREG pDmacReg, PCPDMDMACHLP *ppDmacHlp)
3246	{
3247	PDMDEV_ASSERT_DEVINS(pDevIns);
3248	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
3249	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: pDmacReg=%p:{.u32Version=%#x, .pfnRun=%p, .pfnRegister=%p, .pfnReadMemory=%p, .pfnWriteMemory=%p, .pfnSetDREQ=%p, .pfnGetChannelMode=%p} ppDmacHlp=%p\n",
3250	pDevIns->pReg->szName, pDevIns->iInstance, pDmacReg, pDmacReg->u32Version, pDmacReg->pfnRun, pDmacReg->pfnRegister,
3251	pDmacReg->pfnReadMemory, pDmacReg->pfnWriteMemory, pDmacReg->pfnSetDREQ, pDmacReg->pfnGetChannelMode, ppDmacHlp));
3252
3253	/*
3254	* Validate input.
3255	*/
3256	if (pDmacReg->u32Version != PDM_DMACREG_VERSION)
3257	{
3258	AssertMsgFailed(("u32Version=%#x expected %#x\n", pDmacReg->u32Version,
3259	PDM_DMACREG_VERSION));
3260	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (version)\n",
3261	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3262	return VERR_INVALID_PARAMETER;
3263	}
3264	if ( !pDmacReg->pfnRun
3265	\|\| !pDmacReg->pfnRegister
3266	\|\| !pDmacReg->pfnReadMemory
3267	\|\| !pDmacReg->pfnWriteMemory
3268	\|\| !pDmacReg->pfnSetDREQ
3269	\|\| !pDmacReg->pfnGetChannelMode)
3270	{
3271	Assert(pDmacReg->pfnRun);
3272	Assert(pDmacReg->pfnRegister);
3273	Assert(pDmacReg->pfnReadMemory);
3274	Assert(pDmacReg->pfnWriteMemory);
3275	Assert(pDmacReg->pfnSetDREQ);
3276	Assert(pDmacReg->pfnGetChannelMode);
3277	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
3278	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3279	return VERR_INVALID_PARAMETER;
3280	}
3281
3282	if (!ppDmacHlp)
3283	{
3284	Assert(ppDmacHlp);
3285	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (ppDmacHlp)\n",
3286	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3287	return VERR_INVALID_PARAMETER;
3288	}
3289
3290	/*
3291	* Only one DMA device.
3292	*/
3293	PVM pVM = pDevIns->Internal.s.pVMR3;
3294	if (pVM->pdm.s.pDmac)
3295	{
3296	AssertMsgFailed(("Only one DMA device is supported!\n"));
3297	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc\n",
3298	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3299	return VERR_INVALID_PARAMETER;
3300	}
3301
3302	/*
3303	* Allocate and initialize pci bus structure.
3304	*/
3305	int rc = VINF_SUCCESS;
3306	PPDMDMAC pDmac = (PPDMDMAC)MMR3HeapAlloc(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE, sizeof(*pDmac));
3307	if (pDmac)
3308	{
3309	pDmac->pDevIns = pDevIns;
3310	pDmac->Reg = *pDmacReg;
3311	pVM->pdm.s.pDmac = pDmac;
3312
3313	/* set the helper pointer. */
3314	*ppDmacHlp = &g_pdmR3DevDmacHlp;
3315	Log(("PDM: Registered DMAC device '%s'/%d pDevIns=%p\n",
3316	pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
3317	}
3318	else
3319	rc = VERR_NO_MEMORY;
3320
3321	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc\n",
3322	pDevIns->pReg->szName, pDevIns->iInstance, rc));
3323	return rc;
3324	}
3325
3326
3327	/**
3328	* @copydoc PDMDEVHLPR3::pfnRegisterVMMDevHeap
3329	*/
3330	static DECLCALLBACK(int) pdmR3DevHlp_RegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbHeap)
3331	{
3332	PDMDEV_ASSERT_DEVINS(pDevIns);
3333	PVM pVM = pDevIns->Internal.s.pVMR3;
3334	VM_ASSERT_EMT(pVM);
3335	LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: GCPhys=%RGp pvHeap=%p cbHeap=%#x\n",
3336	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvHeap, cbHeap));
3337
3338	if (pVM->pdm.s.pvVMMDevHeap == NULL)
3339	{
3340	pVM->pdm.s.pvVMMDevHeap = pvHeap;
3341	pVM->pdm.s.GCPhysVMMDevHeap = GCPhys;
3342	pVM->pdm.s.cbVMMDevHeap = cbHeap;
3343	pVM->pdm.s.cbVMMDevHeapLeft = cbHeap;
3344	}
3345	else
3346	{
3347	Assert(pVM->pdm.s.pvVMMDevHeap == pvHeap);
3348	Assert(pVM->pdm.s.cbVMMDevHeap == cbHeap);
3349	Assert(pVM->pdm.s.GCPhysVMMDevHeap != GCPhys \|\| GCPhys == NIL_RTGCPHYS);
3350	if (pVM->pdm.s.GCPhysVMMDevHeap != GCPhys)
3351	{
3352	pVM->pdm.s.GCPhysVMMDevHeap = GCPhys;
3353	if (pVM->pdm.s.pfnVMMDevHeapNotify)
3354	pVM->pdm.s.pfnVMMDevHeapNotify(pVM, pvHeap, GCPhys);
3355	}
3356	}
3357
3358	LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: returns %Rrc\n",
3359	pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
3360	return VINF_SUCCESS;
3361	}
3362
3363
3364	/**
3365	* @interface_method_impl{PDMDEVHLPR3,pfnFirmwareRegister}
3366	*/
3367	static DECLCALLBACK(int) pdmR3DevHlp_FirmwareRegister(PPDMDEVINS pDevIns, PCPDMFWREG pFwReg, PCPDMFWHLPR3 *ppFwHlp)
3368	{
3369	PDMDEV_ASSERT_DEVINS(pDevIns);
3370	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
3371	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: pFWReg=%p:{.u32Version=%#x, .pfnIsHardReset=%p, .u32TheEnd=%#x} ppFwHlp=%p\n",
3372	pDevIns->pReg->szName, pDevIns->iInstance, pFwReg, pFwReg->u32Version, pFwReg->pfnIsHardReset, pFwReg->u32TheEnd, ppFwHlp));
3373
3374	/*
3375	* Validate input.
3376	*/
3377	if (pFwReg->u32Version != PDM_FWREG_VERSION)
3378	{
3379	AssertMsgFailed(("u32Version=%#x expected %#x\n", pFwReg->u32Version, PDM_FWREG_VERSION));
3380	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (version)\n",
3381	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3382	return VERR_INVALID_PARAMETER;
3383	}
3384	if (!pFwReg->pfnIsHardReset)
3385	{
3386	Assert(pFwReg->pfnIsHardReset);
3387	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
3388	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3389	return VERR_INVALID_PARAMETER;
3390	}
3391
3392	if (!ppFwHlp)
3393	{
3394	Assert(ppFwHlp);
3395	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (ppFwHlp)\n",
3396	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3397	return VERR_INVALID_PARAMETER;
3398	}
3399
3400	/*
3401	* Only one DMA device.
3402	*/
3403	PVM pVM = pDevIns->Internal.s.pVMR3;
3404	if (pVM->pdm.s.pFirmware)
3405	{
3406	AssertMsgFailed(("Only one firmware device is supported!\n"));
3407	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc\n",
3408	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3409	return VERR_INVALID_PARAMETER;
3410	}
3411
3412	/*
3413	* Allocate and initialize pci bus structure.
3414	*/
3415	int rc = VINF_SUCCESS;
3416	PPDMFW pFirmware = (PPDMFW)MMR3HeapAlloc(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE, sizeof(*pFirmware));
3417	if (pFirmware)
3418	{
3419	pFirmware->pDevIns = pDevIns;
3420	pFirmware->Reg = *pFwReg;
3421	pVM->pdm.s.pFirmware = pFirmware;
3422
3423	/* set the helper pointer. */
3424	*ppFwHlp = &g_pdmR3DevFirmwareHlp;
3425	Log(("PDM: Registered firmware device '%s'/%d pDevIns=%p\n",
3426	pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
3427	}
3428	else
3429	rc = VERR_NO_MEMORY;
3430
3431	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc\n",
3432	pDevIns->pReg->szName, pDevIns->iInstance, rc));
3433	return rc;
3434	}
3435
3436
3437	/** @interface_method_impl{PDMDEVHLPR3,pfnVMReset} */
3438	static DECLCALLBACK(int) pdmR3DevHlp_VMReset(PPDMDEVINS pDevIns, uint32_t fFlags)
3439	{
3440	PDMDEV_ASSERT_DEVINS(pDevIns);
3441	PVM pVM = pDevIns->Internal.s.pVMR3;
3442	VM_ASSERT_EMT(pVM);
3443	LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: fFlags=%#x VM_FF_RESET %d -> 1\n",
3444	pDevIns->pReg->szName, pDevIns->iInstance, fFlags, VM_FF_IS_SET(pVM, VM_FF_RESET)));
3445
3446	/*
3447	* We postpone this operation because we're likely to be inside a I/O instruction
3448	* and the EIP will be updated when we return.
3449	* We still return VINF_EM_RESET to break out of any execution loops and force FF evaluation.
3450	*/
3451	bool fHaltOnReset;
3452	int rc = CFGMR3QueryBool(CFGMR3GetChild(CFGMR3GetRoot(pVM), "PDM"), "HaltOnReset", &fHaltOnReset);
3453	if (RT_SUCCESS(rc) && fHaltOnReset)
3454	{
3455	Log(("pdmR3DevHlp_VMReset: Halt On Reset!\n"));
3456	rc = VINF_EM_HALT;
3457	}
3458	else
3459	{
3460	pVM->pdm.s.fResetFlags = fFlags;
3461	VM_FF_SET(pVM, VM_FF_RESET);
3462	rc = VINF_EM_RESET;
3463	}
3464
3465	LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3466	return rc;
3467	}
3468
3469
3470	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspend} */
3471	static DECLCALLBACK(int) pdmR3DevHlp_VMSuspend(PPDMDEVINS pDevIns)
3472	{
3473	int rc;
3474	PDMDEV_ASSERT_DEVINS(pDevIns);
3475	PVM pVM = pDevIns->Internal.s.pVMR3;
3476	VM_ASSERT_EMT(pVM);
3477	LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d:\n",
3478	pDevIns->pReg->szName, pDevIns->iInstance));
3479
3480	/** @todo Always take the SMP path - fewer code paths. */
3481	if (pVM->cCpus > 1)
3482	{
3483	/* We own the IOM lock here and could cause a deadlock by waiting for a VCPU that is blocking on the IOM lock. */
3484	rc = VMR3ReqCallNoWait(pVM, VMCPUID_ANY_QUEUE, (PFNRT)VMR3Suspend, 2, pVM->pUVM, VMSUSPENDREASON_VM);
3485	AssertRC(rc);
3486	rc = VINF_EM_SUSPEND;
3487	}
3488	else
3489	rc = VMR3Suspend(pVM->pUVM, VMSUSPENDREASON_VM);
3490
3491	LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3492	return rc;
3493	}
3494
3495
3496	/**
3497	* Worker for pdmR3DevHlp_VMSuspendSaveAndPowerOff that is invoked via a queued
3498	* EMT request to avoid deadlocks.
3499	*
3500	* @returns VBox status code fit for scheduling.
3501	* @param pVM The cross context VM structure.
3502	* @param pDevIns The device that triggered this action.
3503	*/
3504	static DECLCALLBACK(int) pdmR3DevHlp_VMSuspendSaveAndPowerOffWorker(PVM pVM, PPDMDEVINS pDevIns)
3505	{
3506	/*
3507	* Suspend the VM first then do the saving.
3508	*/
3509	int rc = VMR3Suspend(pVM->pUVM, VMSUSPENDREASON_VM);
3510	if (RT_SUCCESS(rc))
3511	{
3512	PUVM pUVM = pVM->pUVM;
3513	rc = pUVM->pVmm2UserMethods->pfnSaveState(pVM->pUVM->pVmm2UserMethods, pUVM);
3514
3515	/*
3516	* On success, power off the VM, on failure we'll leave it suspended.
3517	*/
3518	if (RT_SUCCESS(rc))
3519	{
3520	rc = VMR3PowerOff(pVM->pUVM);
3521	if (RT_FAILURE(rc))
3522	LogRel(("%s/SSP: VMR3PowerOff failed: %Rrc\n", pDevIns->pReg->szName, rc));
3523	}
3524	else
3525	LogRel(("%s/SSP: pfnSaveState failed: %Rrc\n", pDevIns->pReg->szName, rc));
3526	}
3527	else
3528	LogRel(("%s/SSP: Suspend failed: %Rrc\n", pDevIns->pReg->szName, rc));
3529	return rc;
3530	}
3531
3532
3533	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspendSaveAndPowerOff} */
3534	static DECLCALLBACK(int) pdmR3DevHlp_VMSuspendSaveAndPowerOff(PPDMDEVINS pDevIns)
3535	{
3536	PDMDEV_ASSERT_DEVINS(pDevIns);
3537	PVM pVM = pDevIns->Internal.s.pVMR3;
3538	VM_ASSERT_EMT(pVM);
3539	LogFlow(("pdmR3DevHlp_VMSuspendSaveAndPowerOff: caller='%s'/%d:\n",
3540	pDevIns->pReg->szName, pDevIns->iInstance));
3541
3542	int rc;
3543	if ( pVM->pUVM->pVmm2UserMethods
3544	&& pVM->pUVM->pVmm2UserMethods->pfnSaveState)
3545	{
3546	rc = VMR3ReqCallNoWait(pVM, VMCPUID_ANY_QUEUE, (PFNRT)pdmR3DevHlp_VMSuspendSaveAndPowerOffWorker, 2, pVM, pDevIns);
3547	if (RT_SUCCESS(rc))
3548	{
3549	LogRel(("%s: Suspending, Saving and Powering Off the VM\n", pDevIns->pReg->szName));
3550	rc = VINF_EM_SUSPEND;
3551	}
3552	}
3553	else
3554	rc = VERR_NOT_SUPPORTED;
3555
3556	LogFlow(("pdmR3DevHlp_VMSuspendSaveAndPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3557	return rc;
3558	}
3559
3560
3561	/** @interface_method_impl{PDMDEVHLPR3,pfnVMPowerOff} */
3562	static DECLCALLBACK(int) pdmR3DevHlp_VMPowerOff(PPDMDEVINS pDevIns)
3563	{
3564	int rc;
3565	PDMDEV_ASSERT_DEVINS(pDevIns);
3566	PVM pVM = pDevIns->Internal.s.pVMR3;
3567	VM_ASSERT_EMT(pVM);
3568	LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d:\n",
3569	pDevIns->pReg->szName, pDevIns->iInstance));
3570
3571	/** @todo Always take the SMP path - fewer code paths. */
3572	if (pVM->cCpus > 1)
3573	{
3574	/* We might be holding locks here and could cause a deadlock since
3575	VMR3PowerOff rendezvous with the other CPUs. */
3576	rc = VMR3ReqCallNoWait(pVM, VMCPUID_ANY_QUEUE, (PFNRT)VMR3PowerOff, 1, pVM->pUVM);
3577	AssertRC(rc);
3578	/* Set the VCPU state to stopped here as well to make sure no
3579	inconsistency with the EM state occurs. */
3580	VMCPU_SET_STATE(VMMGetCpu(pVM), VMCPUSTATE_STOPPED);
3581	rc = VINF_EM_OFF;
3582	}
3583	else
3584	rc = VMR3PowerOff(pVM->pUVM);
3585
3586	LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3587	return rc;
3588	}
3589
3590
3591	/** @interface_method_impl{PDMDEVHLPR3,pfnA20IsEnabled} */
3592	static DECLCALLBACK(bool) pdmR3DevHlp_A20IsEnabled(PPDMDEVINS pDevIns)
3593	{
3594	PDMDEV_ASSERT_DEVINS(pDevIns);
3595	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
3596
3597	bool fRc = PGMPhysIsA20Enabled(VMMGetCpu(pDevIns->Internal.s.pVMR3));
3598
3599	LogFlow(("pdmR3DevHlp_A20IsEnabled: caller='%s'/%d: returns %d\n", pDevIns->pReg->szName, pDevIns->iInstance, fRc));
3600	return fRc;
3601	}
3602
3603
3604	/** @interface_method_impl{PDMDEVHLPR3,pfnA20Set} */
3605	static DECLCALLBACK(void) pdmR3DevHlp_A20Set(PPDMDEVINS pDevIns, bool fEnable)
3606	{
3607	PDMDEV_ASSERT_DEVINS(pDevIns);
3608	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
3609	LogFlow(("pdmR3DevHlp_A20Set: caller='%s'/%d: fEnable=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, fEnable));
3610	PGMR3PhysSetA20(VMMGetCpu(pDevIns->Internal.s.pVMR3), fEnable);
3611	}
3612
3613
3614	/** @interface_method_impl{PDMDEVHLPR3,pfnGetCpuId} */
3615	static DECLCALLBACK(void) pdmR3DevHlp_GetCpuId(PPDMDEVINS pDevIns, uint32_t iLeaf,
3616	uint32_t pEax, uint32_t pEbx, uint32_t pEcx, uint32_t pEdx)
3617	{
3618	PDMDEV_ASSERT_DEVINS(pDevIns);
3619	VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
3620
3621	LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: iLeaf=%d pEax=%p pEbx=%p pEcx=%p pEdx=%p\n",
3622	pDevIns->pReg->szName, pDevIns->iInstance, iLeaf, pEax, pEbx, pEcx, pEdx));
3623	AssertPtr(pEax); AssertPtr(pEbx); AssertPtr(pEcx); AssertPtr(pEdx);
3624
3625	CPUMGetGuestCpuId(VMMGetCpu(pDevIns->Internal.s.pVMR3), iLeaf, 0 /iSubLeaf/, pEax, pEbx, pEcx, pEdx);
3626
3627	LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: returns void - pEax=%#x pEbx=%#x pEcx=%#x pEdx=%#x\n",
3628	pDevIns->pReg->szName, pDevIns->iInstance, pEax, pEbx, pEcx, pEdx));
3629	}
3630
3631
3632	/**
3633	* The device helper structure for trusted devices.
3634	*/
3635	const PDMDEVHLPR3 g_pdmR3DevHlpTrusted =
3636	{
3637	PDM_DEVHLPR3_VERSION,
3638	pdmR3DevHlp_IOPortRegister,
3639	pdmR3DevHlp_IOPortRegisterRC,
3640	pdmR3DevHlp_IOPortRegisterR0,
3641	pdmR3DevHlp_IOPortDeregister,
3642	pdmR3DevHlp_MMIORegister,
3643	pdmR3DevHlp_MMIORegisterRC,
3644	pdmR3DevHlp_MMIORegisterR0,
3645	pdmR3DevHlp_MMIODeregister,
3646	pdmR3DevHlp_MMIO2Register,
3647	pdmR3DevHlp_MMIOExPreRegister,
3648	pdmR3DevHlp_MMIOExDeregister,
3649	pdmR3DevHlp_MMIOExMap,
3650	pdmR3DevHlp_MMIOExUnmap,
3651	pdmR3DevHlp_MMIOExReduce,
3652	pdmR3DevHlp_MMHyperMapMMIO2,
3653	pdmR3DevHlp_MMIO2MapKernel,
3654	pdmR3DevHlp_ROMRegister,
3655	pdmR3DevHlp_ROMProtectShadow,
3656	pdmR3DevHlp_SSMRegister,
3657	pdmR3DevHlp_TMTimerCreate,
3658	pdmR3DevHlp_TMUtcNow,
3659	pdmR3DevHlp_PhysRead,
3660	pdmR3DevHlp_PhysWrite,
3661	pdmR3DevHlp_PhysGCPhys2CCPtr,
3662	pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly,
3663	pdmR3DevHlp_PhysReleasePageMappingLock,
3664	pdmR3DevHlp_PhysReadGCVirt,
3665	pdmR3DevHlp_PhysWriteGCVirt,
3666	pdmR3DevHlp_PhysGCPtr2GCPhys,
3667	pdmR3DevHlp_MMHeapAlloc,
3668	pdmR3DevHlp_MMHeapAllocZ,
3669	pdmR3DevHlp_MMHeapFree,
3670	pdmR3DevHlp_VMState,
3671	pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet,
3672	pdmR3DevHlp_VMSetError,
3673	pdmR3DevHlp_VMSetErrorV,
3674	pdmR3DevHlp_VMSetRuntimeError,
3675	pdmR3DevHlp_VMSetRuntimeErrorV,
3676	pdmR3DevHlp_DBGFStopV,
3677	pdmR3DevHlp_DBGFInfoRegister,
3678	pdmR3DevHlp_DBGFRegRegister,
3679	pdmR3DevHlp_DBGFTraceBuf,
3680	pdmR3DevHlp_STAMRegister,
3681	pdmR3DevHlp_STAMRegisterF,
3682	pdmR3DevHlp_STAMRegisterV,
3683	pdmR3DevHlp_PCIRegister,
3684	pdmR3DevHlp_PCIRegisterMsi,
3685	pdmR3DevHlp_PCIIORegionRegister,
3686	pdmR3DevHlp_PCISetConfigCallbacks,
3687	pdmR3DevHlp_PCIPhysRead,
3688	pdmR3DevHlp_PCIPhysWrite,
3689	pdmR3DevHlp_PCISetIrq,
3690	pdmR3DevHlp_PCISetIrqNoWait,
3691	pdmR3DevHlp_ISASetIrq,
3692	pdmR3DevHlp_ISASetIrqNoWait,
3693	pdmR3DevHlp_IoApicSendMsi,
3694	pdmR3DevHlp_DriverAttach,
3695	pdmR3DevHlp_DriverDetach,
3696	pdmR3DevHlp_QueueCreate,
3697	pdmR3DevHlp_CritSectInit,
3698	pdmR3DevHlp_CritSectGetNop,
3699	pdmR3DevHlp_CritSectGetNopR0,
3700	pdmR3DevHlp_CritSectGetNopRC,
3701	pdmR3DevHlp_SetDeviceCritSect,
3702	pdmR3DevHlp_ThreadCreate,
3703	pdmR3DevHlp_SetAsyncNotification,
3704	pdmR3DevHlp_AsyncNotificationCompleted,
3705	pdmR3DevHlp_RTCRegister,
3706	pdmR3DevHlp_PCIBusRegister,
3707	pdmR3DevHlp_PICRegister,
3708	pdmR3DevHlp_APICRegister,
3709	pdmR3DevHlp_IOAPICRegister,
3710	pdmR3DevHlp_HPETRegister,
3711	pdmR3DevHlp_PciRawRegister,
3712	pdmR3DevHlp_DMACRegister,
3713	pdmR3DevHlp_DMARegister,
3714	pdmR3DevHlp_DMAReadMemory,
3715	pdmR3DevHlp_DMAWriteMemory,
3716	pdmR3DevHlp_DMASetDREQ,
3717	pdmR3DevHlp_DMAGetChannelMode,
3718	pdmR3DevHlp_DMASchedule,
3719	pdmR3DevHlp_CMOSWrite,
3720	pdmR3DevHlp_CMOSRead,
3721	pdmR3DevHlp_AssertEMT,
3722	pdmR3DevHlp_AssertOther,
3723	pdmR3DevHlp_LdrGetRCInterfaceSymbols,
3724	pdmR3DevHlp_LdrGetR0InterfaceSymbols,
3725	pdmR3DevHlp_CallR0,
3726	pdmR3DevHlp_VMGetSuspendReason,
3727	pdmR3DevHlp_VMGetResumeReason,
3728	0,
3729	0,
3730	0,
3731	0,
3732	0,
3733	0,
3734	0,
3735	0,
3736	0,
3737	0,
3738	pdmR3DevHlp_GetUVM,
3739	pdmR3DevHlp_GetVM,
3740	pdmR3DevHlp_GetVMCPU,
3741	pdmR3DevHlp_GetCurrentCpuId,
3742	pdmR3DevHlp_RegisterVMMDevHeap,
3743	pdmR3DevHlp_FirmwareRegister,
3744	pdmR3DevHlp_VMReset,
3745	pdmR3DevHlp_VMSuspend,
3746	pdmR3DevHlp_VMSuspendSaveAndPowerOff,
3747	pdmR3DevHlp_VMPowerOff,
3748	pdmR3DevHlp_A20IsEnabled,
3749	pdmR3DevHlp_A20Set,
3750	pdmR3DevHlp_GetCpuId,
3751	pdmR3DevHlp_TMTimeVirtGet,
3752	pdmR3DevHlp_TMTimeVirtGetFreq,
3753	pdmR3DevHlp_TMTimeVirtGetNano,
3754	pdmR3DevHlp_GetSupDrvSession,
3755	pdmR3DevHlp_QueryGenericUserObject,
3756	PDM_DEVHLPR3_VERSION /* the end */
3757	};
3758
3759
3760
3761
3762	/** @interface_method_impl{PDMDEVHLPR3,pfnGetUVM} */
3763	static DECLCALLBACK(PUVM) pdmR3DevHlp_Untrusted_GetUVM(PPDMDEVINS pDevIns)
3764	{
3765	PDMDEV_ASSERT_DEVINS(pDevIns);
3766	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3767	return NULL;
3768	}
3769
3770
3771	/** @interface_method_impl{PDMDEVHLPR3,pfnGetVM} */
3772	static DECLCALLBACK(PVM) pdmR3DevHlp_Untrusted_GetVM(PPDMDEVINS pDevIns)
3773	{
3774	PDMDEV_ASSERT_DEVINS(pDevIns);
3775	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3776	return NULL;
3777	}
3778
3779
3780	/** @interface_method_impl{PDMDEVHLPR3,pfnGetVMCPU} */
3781	static DECLCALLBACK(PVMCPU) pdmR3DevHlp_Untrusted_GetVMCPU(PPDMDEVINS pDevIns)
3782	{
3783	PDMDEV_ASSERT_DEVINS(pDevIns);
3784	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3785	return NULL;
3786	}
3787
3788
3789	/** @interface_method_impl{PDMDEVHLPR3,pfnGetCurrentCpuId} */
3790	static DECLCALLBACK(VMCPUID) pdmR3DevHlp_Untrusted_GetCurrentCpuId(PPDMDEVINS pDevIns)
3791	{
3792	PDMDEV_ASSERT_DEVINS(pDevIns);
3793	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3794	return NIL_VMCPUID;
3795	}
3796
3797
3798	/** @interface_method_impl{PDMDEVHLPR3,pfnRegisterVMMDevHeap} */
3799	static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_RegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys,
3800	RTR3PTR pvHeap, unsigned cbHeap)
3801	{
3802	PDMDEV_ASSERT_DEVINS(pDevIns);
3803	NOREF(GCPhys); NOREF(pvHeap); NOREF(cbHeap);
3804	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3805	return VERR_ACCESS_DENIED;
3806	}
3807
3808
3809	/** @interface_method_impl{PDMDEVHLPR3,pfnFirmwareRegister} */
3810	static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_FirmwareRegister(PPDMDEVINS pDevIns, PCPDMFWREG pFwReg, PCPDMFWHLPR3 *ppFwHlp)
3811	{
3812	PDMDEV_ASSERT_DEVINS(pDevIns);
3813	NOREF(pFwReg); NOREF(ppFwHlp);
3814	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3815	return VERR_ACCESS_DENIED;
3816	}
3817
3818
3819	/** @interface_method_impl{PDMDEVHLPR3,pfnVMReset} */
3820	static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_VMReset(PPDMDEVINS pDevIns, uint32_t fFlags)
3821	{
3822	PDMDEV_ASSERT_DEVINS(pDevIns); NOREF(fFlags);
3823	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3824	return VERR_ACCESS_DENIED;
3825	}
3826
3827
3828	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspend} */
3829	static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_VMSuspend(PPDMDEVINS pDevIns)
3830	{
3831	PDMDEV_ASSERT_DEVINS(pDevIns);
3832	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3833	return VERR_ACCESS_DENIED;
3834	}
3835
3836
3837	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspendSaveAndPowerOff} */
3838	static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_VMSuspendSaveAndPowerOff(PPDMDEVINS pDevIns)
3839	{
3840	PDMDEV_ASSERT_DEVINS(pDevIns);
3841	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3842	return VERR_ACCESS_DENIED;
3843	}
3844
3845
3846	/** @interface_method_impl{PDMDEVHLPR3,pfnVMPowerOff} */
3847	static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_VMPowerOff(PPDMDEVINS pDevIns)
3848	{
3849	PDMDEV_ASSERT_DEVINS(pDevIns);
3850	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3851	return VERR_ACCESS_DENIED;
3852	}
3853
3854
3855	/** @interface_method_impl{PDMDEVHLPR3,pfnA20IsEnabled} */
3856	static DECLCALLBACK(bool) pdmR3DevHlp_Untrusted_A20IsEnabled(PPDMDEVINS pDevIns)
3857	{
3858	PDMDEV_ASSERT_DEVINS(pDevIns);
3859	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3860	return false;
3861	}
3862
3863
3864	/** @interface_method_impl{PDMDEVHLPR3,pfnA20Set} */
3865	static DECLCALLBACK(void) pdmR3DevHlp_Untrusted_A20Set(PPDMDEVINS pDevIns, bool fEnable)
3866	{
3867	PDMDEV_ASSERT_DEVINS(pDevIns);
3868	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3869	NOREF(fEnable);
3870	}
3871
3872
3873	/** @interface_method_impl{PDMDEVHLPR3,pfnGetCpuId} */
3874	static DECLCALLBACK(void) pdmR3DevHlp_Untrusted_GetCpuId(PPDMDEVINS pDevIns, uint32_t iLeaf,
3875	uint32_t pEax, uint32_t pEbx, uint32_t pEcx, uint32_t pEdx)
3876	{
3877	PDMDEV_ASSERT_DEVINS(pDevIns);
3878	NOREF(iLeaf); NOREF(pEax); NOREF(pEbx); NOREF(pEcx); NOREF(pEdx);
3879	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3880	}
3881
3882
3883	/** @interface_method_impl{PDMDEVHLPR3,pfnGetSupDrvSession} */
3884	static DECLCALLBACK(PSUPDRVSESSION) pdmR3DevHlp_Untrusted_GetSupDrvSession(PPDMDEVINS pDevIns)
3885	{
3886	PDMDEV_ASSERT_DEVINS(pDevIns);
3887	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
3888	return (PSUPDRVSESSION)0;
3889	}
3890
3891
3892	/** @interface_method_impl{PDMDEVHLPR3,pfnQueryGenericUserObject} */
3893	static DECLCALLBACK(void *) pdmR3DevHlp_Untrusted_QueryGenericUserObject(PPDMDEVINS pDevIns, PCRTUUID pUuid)
3894	{
3895	PDMDEV_ASSERT_DEVINS(pDevIns);
3896	AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d %RTuuid\n",
3897	pDevIns->pReg->szName, pDevIns->iInstance, pUuid));
3898	return NULL;
3899	}
3900
3901
3902	/**
3903	* The device helper structure for non-trusted devices.
3904	*/
3905	const PDMDEVHLPR3 g_pdmR3DevHlpUnTrusted =
3906	{
3907	PDM_DEVHLPR3_VERSION,
3908	pdmR3DevHlp_IOPortRegister,
3909	pdmR3DevHlp_IOPortRegisterRC,
3910	pdmR3DevHlp_IOPortRegisterR0,
3911	pdmR3DevHlp_IOPortDeregister,
3912	pdmR3DevHlp_MMIORegister,
3913	pdmR3DevHlp_MMIORegisterRC,
3914	pdmR3DevHlp_MMIORegisterR0,
3915	pdmR3DevHlp_MMIODeregister,
3916	pdmR3DevHlp_MMIO2Register,
3917	pdmR3DevHlp_MMIOExPreRegister,
3918	pdmR3DevHlp_MMIOExDeregister,
3919	pdmR3DevHlp_MMIOExMap,
3920	pdmR3DevHlp_MMIOExUnmap,
3921	pdmR3DevHlp_MMIOExReduce,
3922	pdmR3DevHlp_MMHyperMapMMIO2,
3923	pdmR3DevHlp_MMIO2MapKernel,
3924	pdmR3DevHlp_ROMRegister,
3925	pdmR3DevHlp_ROMProtectShadow,
3926	pdmR3DevHlp_SSMRegister,
3927	pdmR3DevHlp_TMTimerCreate,
3928	pdmR3DevHlp_TMUtcNow,
3929	pdmR3DevHlp_PhysRead,
3930	pdmR3DevHlp_PhysWrite,
3931	pdmR3DevHlp_PhysGCPhys2CCPtr,
3932	pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly,
3933	pdmR3DevHlp_PhysReleasePageMappingLock,
3934	pdmR3DevHlp_PhysReadGCVirt,
3935	pdmR3DevHlp_PhysWriteGCVirt,
3936	pdmR3DevHlp_PhysGCPtr2GCPhys,
3937	pdmR3DevHlp_MMHeapAlloc,
3938	pdmR3DevHlp_MMHeapAllocZ,
3939	pdmR3DevHlp_MMHeapFree,
3940	pdmR3DevHlp_VMState,
3941	pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet,
3942	pdmR3DevHlp_VMSetError,
3943	pdmR3DevHlp_VMSetErrorV,
3944	pdmR3DevHlp_VMSetRuntimeError,
3945	pdmR3DevHlp_VMSetRuntimeErrorV,
3946	pdmR3DevHlp_DBGFStopV,
3947	pdmR3DevHlp_DBGFInfoRegister,
3948	pdmR3DevHlp_DBGFRegRegister,
3949	pdmR3DevHlp_DBGFTraceBuf,
3950	pdmR3DevHlp_STAMRegister,
3951	pdmR3DevHlp_STAMRegisterF,
3952	pdmR3DevHlp_STAMRegisterV,
3953	pdmR3DevHlp_PCIRegister,
3954	pdmR3DevHlp_PCIRegisterMsi,
3955	pdmR3DevHlp_PCIIORegionRegister,
3956	pdmR3DevHlp_PCISetConfigCallbacks,
3957	pdmR3DevHlp_PCIPhysRead,
3958	pdmR3DevHlp_PCIPhysWrite,
3959	pdmR3DevHlp_PCISetIrq,
3960	pdmR3DevHlp_PCISetIrqNoWait,
3961	pdmR3DevHlp_ISASetIrq,
3962	pdmR3DevHlp_ISASetIrqNoWait,
3963	pdmR3DevHlp_IoApicSendMsi,
3964	pdmR3DevHlp_DriverAttach,
3965	pdmR3DevHlp_DriverDetach,
3966	pdmR3DevHlp_QueueCreate,
3967	pdmR3DevHlp_CritSectInit,
3968	pdmR3DevHlp_CritSectGetNop,
3969	pdmR3DevHlp_CritSectGetNopR0,
3970	pdmR3DevHlp_CritSectGetNopRC,
3971	pdmR3DevHlp_SetDeviceCritSect,
3972	pdmR3DevHlp_ThreadCreate,
3973	pdmR3DevHlp_SetAsyncNotification,
3974	pdmR3DevHlp_AsyncNotificationCompleted,
3975	pdmR3DevHlp_RTCRegister,
3976	pdmR3DevHlp_PCIBusRegister,
3977	pdmR3DevHlp_PICRegister,
3978	pdmR3DevHlp_APICRegister,
3979	pdmR3DevHlp_IOAPICRegister,
3980	pdmR3DevHlp_HPETRegister,
3981	pdmR3DevHlp_PciRawRegister,
3982	pdmR3DevHlp_DMACRegister,
3983	pdmR3DevHlp_DMARegister,
3984	pdmR3DevHlp_DMAReadMemory,
3985	pdmR3DevHlp_DMAWriteMemory,
3986	pdmR3DevHlp_DMASetDREQ,
3987	pdmR3DevHlp_DMAGetChannelMode,
3988	pdmR3DevHlp_DMASchedule,
3989	pdmR3DevHlp_CMOSWrite,
3990	pdmR3DevHlp_CMOSRead,
3991	pdmR3DevHlp_AssertEMT,
3992	pdmR3DevHlp_AssertOther,
3993	pdmR3DevHlp_LdrGetRCInterfaceSymbols,
3994	pdmR3DevHlp_LdrGetR0InterfaceSymbols,
3995	pdmR3DevHlp_CallR0,
3996	pdmR3DevHlp_VMGetSuspendReason,
3997	pdmR3DevHlp_VMGetResumeReason,
3998	0,
3999	0,
4000	0,
4001	0,
4002	0,
4003	0,
4004	0,
4005	0,
4006	0,
4007	0,
4008	pdmR3DevHlp_Untrusted_GetUVM,
4009	pdmR3DevHlp_Untrusted_GetVM,
4010	pdmR3DevHlp_Untrusted_GetVMCPU,
4011	pdmR3DevHlp_Untrusted_GetCurrentCpuId,
4012	pdmR3DevHlp_Untrusted_RegisterVMMDevHeap,
4013	pdmR3DevHlp_Untrusted_FirmwareRegister,
4014	pdmR3DevHlp_Untrusted_VMReset,
4015	pdmR3DevHlp_Untrusted_VMSuspend,
4016	pdmR3DevHlp_Untrusted_VMSuspendSaveAndPowerOff,
4017	pdmR3DevHlp_Untrusted_VMPowerOff,
4018	pdmR3DevHlp_Untrusted_A20IsEnabled,
4019	pdmR3DevHlp_Untrusted_A20Set,
4020	pdmR3DevHlp_Untrusted_GetCpuId,
4021	pdmR3DevHlp_TMTimeVirtGet,
4022	pdmR3DevHlp_TMTimeVirtGetFreq,
4023	pdmR3DevHlp_TMTimeVirtGetNano,
4024	pdmR3DevHlp_Untrusted_GetSupDrvSession,
4025	pdmR3DevHlp_Untrusted_QueryGenericUserObject,
4026	PDM_DEVHLPR3_VERSION /* the end */
4027	};
4028
4029
4030
4031	/**
4032	* Queue consumer callback for internal component.
4033	*
4034	* @returns Success indicator.
4035	* If false the item will not be removed and the flushing will stop.
4036	* @param pVM The cross context VM structure.
4037	* @param pItem The item to consume. Upon return this item will be freed.
4038	*/
4039	DECLCALLBACK(bool) pdmR3DevHlpQueueConsumer(PVM pVM, PPDMQUEUEITEMCORE pItem)
4040	{
4041	PPDMDEVHLPTASK pTask = (PPDMDEVHLPTASK)pItem;
4042	LogFlow(("pdmR3DevHlpQueueConsumer: enmOp=%d pDevIns=%p\n", pTask->enmOp, pTask->pDevInsR3));
4043	switch (pTask->enmOp)
4044	{
4045	case PDMDEVHLPTASKOP_ISA_SET_IRQ:
4046	PDMIsaSetIrq(pVM, pTask->u.IsaSetIRQ.iIrq, pTask->u.IsaSetIRQ.iLevel, pTask->u.IsaSetIRQ.uTagSrc);
4047	break;
4048
4049	case PDMDEVHLPTASKOP_PCI_SET_IRQ:
4050	{
4051	/* Same as pdmR3DevHlp_PCISetIrq, except we've got a tag already. */
4052	PPDMPCIDEV pPciDev = pTask->u.PciSetIRQ.pPciDevR3;
4053	if (pPciDev)
4054	{
4055	PPDMPCIBUS pBus = pPciDev->Int.s.pPdmBusR3;
4056	Assert(pBus);
4057
4058	pdmLock(pVM);
4059	pBus->pfnSetIrqR3(pBus->pDevInsR3, pPciDev, pTask->u.PciSetIRQ.iIrq,
4060	pTask->u.PciSetIRQ.iLevel, pTask->u.PciSetIRQ.uTagSrc);
4061	pdmUnlock(pVM);
4062	}
4063	else
4064	AssertReleaseMsgFailed(("No PCI device registered!\n"));
4065	break;
4066	}
4067
4068	case PDMDEVHLPTASKOP_IOAPIC_SET_IRQ:
4069	PDMIoApicSetIrq(pVM, pTask->u.IoApicSetIRQ.iIrq, pTask->u.IoApicSetIRQ.iLevel, pTask->u.IoApicSetIRQ.uTagSrc);
4070	break;
4071
4072	default:
4073	AssertReleaseMsgFailed(("Invalid operation %d\n", pTask->enmOp));
4074	break;
4075	}
4076	return true;
4077	}
4078
4079	/** @} */
4080

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

Download in other formats:

© 2023 Oracle
Contact – Privacy policy – Terms of Use