tstDevicePdmDevHlp.cpp@ 83281

Last change on this file since 83281 was 83281, checked in by vboxsync, 5 years ago
PDMDevHlp,tstDevice: Create two more wrappers used by the graphics device to eliminate direct imports from the VMM library
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 183.5 KB

Line
1	/* $Id: tstDevicePdmDevHlp.cpp 83281 2020-03-13 13:02:08Z vboxsync $ */
2	/** @file
3	* tstDevice - Test framework for PDM devices/drivers, PDM helper implementation.
4	*/
5
6	/*
7	* Copyright (C) 2017-2020 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
23	#include <VBox/types.h>
24	#include <VBox/version.h>
25	#include <VBox/vmm/pdmpci.h>
26
27	#include <iprt/assert.h>
28	#include <iprt/mem.h>
29
30	#include "tstDeviceInternal.h"
31
32
33	/*********************************************************************************************************************************
34	* Defined Constants And Macros *
35	*********************************************************************************************************************************/
36
37	/* Temporarily until the stubs got implemented. */
38	#define VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS 1
39
40	/** @def PDMDEV_ASSERT_DEVINS
41	* Asserts the validity of the device instance.
42	*/
43	#ifdef VBOX_STRICT
44	# define PDMDEV_ASSERT_DEVINS(pDevIns) \
45	do { \
46	AssertPtr(pDevIns); \
47	Assert(pDevIns->u32Version == PDM_DEVINS_VERSION); \
48	Assert(pDevIns->CTX_SUFF(pvInstanceDataFor) == (void *)&pDevIns->achInstanceData[0]); \
49	} while (0)
50	#else
51	# define PDMDEV_ASSERT_DEVINS(pDevIns) do { } while (0)
52	#endif
53
54
55	/** Frequency of the real clock. */
56	#define TMCLOCK_FREQ_REAL UINT32_C(1000)
57	/** Frequency of the virtual clock. */
58	#define TMCLOCK_FREQ_VIRTUAL UINT32_C(1000000000)
59
60
61	/** Start structure magic. (Isaac Asimov) */
62	#define SSMR3STRUCT_BEGIN UINT32_C(0x19200102)
63	/** End structure magic. (Isaac Asimov) */
64	#define SSMR3STRUCT_END UINT32_C(0x19920406)
65
66
67	/*********************************************************************************************************************************
68	* Structures and Typedefs *
69	*********************************************************************************************************************************/
70
71
72
73	/*********************************************************************************************************************************
74	* Global Variables *
75	*********************************************************************************************************************************/
76
77
78
79	/*********************************************************************************************************************************
80	* Internal Functions *
81	*********************************************************************************************************************************/
82
83
84	/**
85	* Resolves a path reference to a configuration item.
86	*
87	* @returns VBox status code.
88	* @param paDevCfg The array of config items.
89	* @param cCfgItems Number of config items in the array.
90	* @param pszName Name of a byte string value.
91	* @param ppItem Where to store the pointer to the item.
92	*/
93	static int tstDev_CfgmR3ResolveItem(PCTSTDEVCFGITEM paDevCfg, uint32_t cCfgItems, const char pszName, PCTSTDEVCFGITEM ppItem)
94	{
95	*ppItem = NULL;
96	if (!paDevCfg)
97	return VERR_CFGM_VALUE_NOT_FOUND;
98
99	size_t cchName = strlen(pszName);
100	PCTSTDEVCFGITEM pDevCfgItem = paDevCfg;
101
102	for (uint32_t i = 0; i < cCfgItems; i++)
103	{
104	size_t cchKey = strlen(pDevCfgItem->pszKey);
105	if (cchName == cchKey)
106	{
107	int iDiff = memcmp(pszName, pDevCfgItem->pszKey, cchName);
108	if (iDiff <= 0)
109	{
110	if (iDiff != 0)
111	break;
112	*ppItem = pDevCfgItem;
113	return VINF_SUCCESS;
114	}
115	}
116
117	/* next */
118	pDevCfgItem++;
119	}
120	return VERR_CFGM_VALUE_NOT_FOUND;
121	}
122
123
124	/** @interface_method_impl{PDMDEVHLPR3,pfnIoPortCreateEx} */
125	static DECLCALLBACK(int) pdmR3DevHlp_IoPortCreateEx(PPDMDEVINS pDevIns, RTIOPORT cPorts, uint32_t fFlags, PPDMPCIDEV pPciDev,
126	uint32_t iPciRegion, PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
127	PFNIOMIOPORTNEWOUTSTRING pfnOutStr, PFNIOMIOPORTNEWINSTRING pfnInStr, RTR3PTR pvUser,
128	const char *pszDesc, PCIOMIOPORTDESC paExtDescs, PIOMIOPORTHANDLE phIoPorts)
129	{
130	PDMDEV_ASSERT_DEVINS(pDevIns);
131	LogFlow(("pdmR3DevHlp_IoPortCreateEx: caller='%s'/%d: cPorts=%#x fFlags=%#x pPciDev=%p iPciRegion=%#x pfnOut=%p pfnIn=%p pfnOutStr=%p pfnInStr=%p pvUser=%p pszDesc=%p:{%s} paExtDescs=%p phIoPorts=%p\n",
132	pDevIns->pReg->szName, pDevIns->iInstance, cPorts, fFlags, pPciDev, iPciRegion, pfnOut, pfnIn, pfnOutStr, pfnInStr,
133	pvUser, pszDesc, pszDesc, paExtDescs, phIoPorts));
134
135	/** @todo Verify there is no overlapping. */
136
137	RT_NOREF(pszDesc);
138	int rc = VINF_SUCCESS;
139	PRTDEVDUTIOPORT pIoPort = (PRTDEVDUTIOPORT)RTMemAllocZ(sizeof(RTDEVDUTIOPORT));
140	if (RT_LIKELY(pIoPort))
141	{
142	pIoPort->cPorts = cPorts;
143	pIoPort->pvUserR3 = pvUser;
144	pIoPort->pfnOutR3 = pfnOut;
145	pIoPort->pfnInR3 = pfnIn;
146	pIoPort->pfnOutStrR3 = pfnOutStr;
147	pIoPort->pfnInStrR3 = pfnInStr;
148	RTListAppend(&pDevIns->Internal.s.pDut->LstIoPorts, &pIoPort->NdIoPorts);
149	*phIoPorts = (IOMIOPORTHANDLE)pIoPort;
150	}
151	else
152	rc = VERR_NO_MEMORY;
153
154	LogFlow(("pdmR3DevHlp_IoPortCreateEx: caller='%s'/%d: returns %Rrc (*phIoPorts=%#x)\n",
155	pDevIns->pReg->szName, pDevIns->iInstance, rc, *phIoPorts));
156	return rc;
157	}
158
159
160	/** @interface_method_impl{PDMDEVHLPR3,pfnIoPortMap} */
161	static DECLCALLBACK(int) pdmR3DevHlp_IoPortMap(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts, RTIOPORT Port)
162	{
163	PDMDEV_ASSERT_DEVINS(pDevIns);
164	LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: hIoPorts=%#x Port=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hIoPorts, Port));
165
166	PRTDEVDUTIOPORT pIoPort = (PRTDEVDUTIOPORT)hIoPorts;
167	pIoPort->PortStart = Port;
168
169	LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: returns VINF_SUCCESS\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
170	return VINF_SUCCESS;
171	}
172
173
174	/** @interface_method_impl{PDMDEVHLPR3,pfnIoPortUnmap} */
175	static DECLCALLBACK(int) pdmR3DevHlp_IoPortUnmap(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts)
176	{
177	PDMDEV_ASSERT_DEVINS(pDevIns);
178	LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: hIoPorts=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hIoPorts));
179
180	int rc = VERR_NOT_IMPLEMENTED;
181	AssertFailed();
182
183	LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
184	return rc;
185	}
186
187
188	/** @interface_method_impl{PDMDEVHLPR3,pfnIoPortGetMappingAddress} */
189	static DECLCALLBACK(uint32_t) pdmR3DevHlp_IoPortGetMappingAddress(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts)
190	{
191	PDMDEV_ASSERT_DEVINS(pDevIns);
192	LogFlow(("pdmR3DevHlp_IoPortGetMappingAddress: caller='%s'/%d: hIoPorts=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hIoPorts));
193
194	uint32_t uAddress = 0;
195	AssertFailed();
196
197	LogFlow(("pdmR3DevHlp_IoPortGetMappingAddress: caller='%s'/%d: returns %#RX32\n", pDevIns->pReg->szName, pDevIns->iInstance, uAddress));
198	return uAddress;
199	}
200
201
202	/** @interface_method_impl{PDMDEVHLPR3,pfnMmioCreateEx} */
203	static DECLCALLBACK(int) pdmR3DevHlp_MmioCreateEx(PPDMDEVINS pDevIns, RTGCPHYS cbRegion,
204	uint32_t fFlags, PPDMPCIDEV pPciDev, uint32_t iPciRegion,
205	PFNIOMMMIONEWWRITE pfnWrite, PFNIOMMMIONEWREAD pfnRead, PFNIOMMMIONEWFILL pfnFill,
206	void pvUser, const char pszDesc, PIOMMMIOHANDLE phRegion)
207	{
208	PDMDEV_ASSERT_DEVINS(pDevIns);
209	LogFlow(("pdmR3DevHlp_MmioCreateEx: caller='%s'/%d: cbRegion=%#RGp fFlags=%#x pPciDev=%p iPciRegion=%#x pfnWrite=%p pfnRead=%p pfnFill=%p pvUser=%p pszDesc=%p:{%s} phRegion=%p\n",
210	pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, fFlags, pPciDev, iPciRegion, pfnWrite, pfnRead, pfnFill, pvUser, pszDesc, pszDesc, phRegion));
211
212	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
213	int rc = VERR_NOT_IMPLEMENTED;
214	AssertFailed();
215	#else
216	int rc = VINF_SUCCESS;
217	#endif
218
219	LogFlow(("pdmR3DevHlp_MmioCreateEx: caller='%s'/%d: returns %Rrc (*phRegion=%#x)\n",
220	pDevIns->pReg->szName, pDevIns->iInstance, rc, *phRegion));
221	return rc;
222	}
223
224
225	/** @interface_method_impl{PDMDEVHLPR3,pfnMmioMap} */
226	static DECLCALLBACK(int) pdmR3DevHlp_MmioMap(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS GCPhys)
227	{
228	PDMDEV_ASSERT_DEVINS(pDevIns);
229	LogFlow(("pdmR3DevHlp_MmioMap: caller='%s'/%d: hRegion=%#x GCPhys=%#RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, GCPhys));
230
231	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
232	int rc = VERR_NOT_IMPLEMENTED;
233	AssertFailed();
234	#else
235	int rc = VINF_SUCCESS;
236	#endif
237
238	LogFlow(("pdmR3DevHlp_MmioMap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
239	return rc;
240	}
241
242
243	/** @interface_method_impl{PDMDEVHLPR3,pfnMmioUnmap} */
244	static DECLCALLBACK(int) pdmR3DevHlp_MmioUnmap(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion)
245	{
246	PDMDEV_ASSERT_DEVINS(pDevIns);
247	LogFlow(("pdmR3DevHlp_MmioUnmap: caller='%s'/%d: hRegion=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
248
249	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
250	int rc = VERR_NOT_IMPLEMENTED;
251	AssertFailed();
252	#else
253	int rc = VINF_SUCCESS;
254	#endif
255
256	LogFlow(("pdmR3DevHlp_MmioUnmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
257	return rc;
258	}
259
260
261	/** @interface_method_impl{PDMDEVHLPR3,pfnMmioReduce} */
262	static DECLCALLBACK(int) pdmR3DevHlp_MmioReduce(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS cbRegion)
263	{
264	PDMDEV_ASSERT_DEVINS(pDevIns);
265	LogFlow(("pdmR3DevHlp_MmioReduce: caller='%s'/%d: hRegion=%#x cbRegion=%#RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, cbRegion));
266
267	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
268	int rc = VERR_NOT_IMPLEMENTED;
269	AssertFailed();
270	#else
271	int rc = VINF_SUCCESS;
272	#endif
273	LogFlow(("pdmR3DevHlp_MmioReduce: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
274	return rc;
275	}
276
277
278	/** @interface_method_impl{PDMDEVHLPR3,pfnMmioGetMappingAddress} */
279	static DECLCALLBACK(RTGCPHYS) pdmR3DevHlp_MmioGetMappingAddress(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion)
280	{
281	PDMDEV_ASSERT_DEVINS(pDevIns);
282	LogFlow(("pdmR3DevHlp_MmioGetMappingAddress: caller='%s'/%d: hRegion=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
283
284	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
285	RTGCPHYS GCPhys = NIL_RTGCPHYS;
286	AssertFailed();
287	#else
288	RTGCPHYS GCPhys = 0x1000;
289	#endif
290
291	LogFlow(("pdmR3DevHlp_MmioGetMappingAddress: caller='%s'/%d: returns %RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys));
292	return GCPhys;
293	}
294
295
296	/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Create} */
297	static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Create(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iPciRegion, RTGCPHYS cbRegion,
298	uint32_t fFlags, const char pszDesc, void *ppvMapping, PPGMMMIO2HANDLE phRegion)
299	{
300	PDMDEV_ASSERT_DEVINS(pDevIns);
301	LogFlow(("pdmR3DevHlp_Mmio2Create: caller='%s'/%d: pPciDev=%p (%#x) iPciRegion=%#x cbRegion=%#RGp fFlags=%RX32 pszDesc=%p:{%s} ppvMapping=%p phRegion=%p\n",
302	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iPciRegion, cbRegion,
303	fFlags, pszDesc, pszDesc, ppvMapping, phRegion));
304
305	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
306	int rc = VERR_NOT_IMPLEMENTED;
307	AssertFailed();
308	#else
309	int rc = VINF_SUCCESS;
310	*ppvMapping = RTMemAllocZ(cbRegion);
311	if (!*ppvMapping)
312	rc = VERR_NO_MEMORY;
313	#endif
314
315	LogFlow(("pdmR3DevHlp_Mmio2Create: caller='%s'/%d: returns %Rrc *ppvMapping=%p phRegion=%#RX64\n",
316	pDevIns->pReg->szName, pDevIns->iInstance, rc, ppvMapping, phRegion));
317	return rc;
318	}
319
320
321	/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Destroy} */
322	static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Destroy(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion)
323	{
324	PDMDEV_ASSERT_DEVINS(pDevIns);
325	LogFlow(("pdmR3DevHlp_Mmio2Destroy: caller='%s'/%d: hRegion=%#RX64\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
326
327	int rc = VERR_NOT_IMPLEMENTED;
328	AssertFailed();
329
330	LogFlow(("pdmR3DevHlp_Mmio2Destroy: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
331	return rc;
332	}
333
334
335	/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Map} */
336	static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Map(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, RTGCPHYS GCPhys)
337	{
338	PDMDEV_ASSERT_DEVINS(pDevIns);
339	LogFlow(("pdmR3DevHlp_Mmio2Map: caller='%s'/%d: hRegion=%#RX64 GCPhys=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, GCPhys));
340
341	int rc = VERR_NOT_IMPLEMENTED;
342	AssertFailed();
343
344	LogFlow(("pdmR3DevHlp_Mmio2Map: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
345	return rc;
346	}
347
348
349	/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Unmap} */
350	static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Unmap(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion)
351	{
352	PDMDEV_ASSERT_DEVINS(pDevIns);
353	LogFlow(("pdmR3DevHlp_Mmio2Unmap: caller='%s'/%d: hRegion=%#RX64\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
354
355	int rc = VERR_NOT_IMPLEMENTED;
356	AssertFailed();
357
358	LogFlow(("pdmR3DevHlp_Mmio2Unmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
359	return rc;
360	}
361
362
363	/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Reduce} */
364	static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Reduce(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, RTGCPHYS cbRegion)
365	{
366	PDMDEV_ASSERT_DEVINS(pDevIns);
367	LogFlow(("pdmR3DevHlp_Mmio2Reduce: caller='%s'/%d: hRegion=%#RX64 cbRegion=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, cbRegion));
368
369	int rc = VERR_NOT_IMPLEMENTED;
370	AssertFailed();
371
372	LogFlow(("pdmR3DevHlp_Mmio2Reduce: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
373	return rc;
374	}
375
376
377	/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2GetMappingAddress} */
378	static DECLCALLBACK(RTGCPHYS) pdmR3DevHlp_Mmio2GetMappingAddress(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion)
379	{
380	PDMDEV_ASSERT_DEVINS(pDevIns);
381	LogFlow(("pdmR3DevHlp_Mmio2GetMappingAddress: caller='%s'/%d: hRegion=%#RX6r\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
382
383	RTGCPHYS GCPhys = NIL_RTGCPHYS;
384	AssertFailed();
385
386	LogFlow(("pdmR3DevHlp_Mmio2GetMappingAddress: caller='%s'/%d: returns %RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys));
387	return GCPhys;
388	}
389
390	/**
391	* @copydoc PDMDEVHLPR3::pfnMmio2ChangeRegionNo
392	*/
393	static DECLCALLBACK(int) pdmR3DevHlp_Mmio2ChangeRegionNo(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, uint32_t iNewRegion)
394	{
395	PDMDEV_ASSERT_DEVINS(pDevIns);
396	LogFlow(("pdmR3DevHlp_Mmio2ChangeRegionNo: caller='%s'/%d: hRegion=%#RX6r iNewRegion=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, iNewRegion));
397
398	int rc = VERR_NOT_IMPLEMENTED;
399	AssertFailed();
400
401	LogFlow(("pdmR3DevHlp_Mmio2ChangeRegionNo: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
402	return rc;
403	}
404
405
406	/** @interface_method_impl{PDMDEVHLPR3,pfnROMRegister} */
407	static DECLCALLBACK(int) pdmR3DevHlp_ROMRegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange,
408	const void pvBinary, uint32_t cbBinary, uint32_t fFlags, const char pszDesc)
409	{
410	PDMDEV_ASSERT_DEVINS(pDevIns);
411	LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvBinary=%p cbBinary=%#x fFlags=%#RX32 pszDesc=%p:{%s}\n",
412	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvBinary, cbBinary, fFlags, pszDesc, pszDesc));
413
414	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
415	int rc = VERR_NOT_IMPLEMENTED;
416	AssertFailed();
417	#else
418	int rc = VINF_SUCCESS;
419	#endif
420
421	LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
422	return rc;
423	}
424
425
426	/** @interface_method_impl{PDMDEVHLPR3,pfnROMProtectShadow} */
427	static DECLCALLBACK(int) pdmR3DevHlp_ROMProtectShadow(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange, PGMROMPROT enmProt)
428	{
429	PDMDEV_ASSERT_DEVINS(pDevIns);
430	LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x enmProt=%d\n",
431	pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, enmProt));
432
433	int rc = VERR_NOT_IMPLEMENTED;
434	AssertFailed();
435
436	LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
437	return rc;
438	}
439
440
441	static DECLCALLBACK(int) pdmR3DevHlp_SSMRegister(PPDMDEVINS pDevIns, uint32_t uVersion, size_t cbGuess, const char *pszBefore,
442	PFNSSMDEVLIVEPREP pfnLivePrep, PFNSSMDEVLIVEEXEC pfnLiveExec, PFNSSMDEVLIVEVOTE pfnLiveVote,
443	PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone,
444	PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone)
445	{
446	PDMDEV_ASSERT_DEVINS(pDevIns);
447	LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: uVersion=%#x cbGuess=%#x pszBefore=%p:{%s}\n"
448	" pfnLivePrep=%p pfnLiveExec=%p pfnLiveVote=%p pfnSavePrep=%p pfnSaveExec=%p pfnSaveDone=%p pszLoadPrep=%p pfnLoadExec=%p pfnLoadDone=%p\n",
449	pDevIns->pReg->szName, pDevIns->iInstance, uVersion, cbGuess, pszBefore, pszBefore,
450	pfnLivePrep, pfnLiveExec, pfnLiveVote,
451	pfnSavePrep, pfnSaveExec, pfnSaveDone,
452	pfnLoadPrep, pfnLoadExec, pfnLoadDone));
453
454	RT_NOREF(cbGuess, pszBefore);
455	int rc = VINF_SUCCESS;
456	PTSTDEVDUTSSM pSsm = (PTSTDEVDUTSSM)RTMemAllocZ(sizeof(*pSsm));
457	if (RT_LIKELY(pSsm))
458	{
459	pSsm->uVersion = uVersion;
460	pSsm->pfnLivePrep = pfnLivePrep;
461	pSsm->pfnLiveExec = pfnLiveExec;
462	pSsm->pfnLiveVote = pfnLiveVote;
463	pSsm->pfnSavePrep = pfnSavePrep;
464	pSsm->pfnSaveExec = pfnSaveExec;
465	pSsm->pfnSaveDone = pfnSaveDone;
466	pSsm->pfnLoadPrep = pfnLoadPrep;
467	pSsm->pfnLoadExec = pfnLoadExec;
468	pSsm->pfnLoadDone = pfnLoadDone;
469	RTListAppend(&pDevIns->Internal.s.pDut->LstSsmHandlers, &pSsm->NdSsm);
470	}
471	else
472	rc = VERR_NO_MEMORY;
473
474	LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
475	return rc;
476	}
477
478
479	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutStruct(PSSMHANDLE pSSM, const void *pvStruct, PCSSMFIELD paFields)
480	{
481	RT_NOREF(pSSM, pvStruct, paFields);
482	AssertFailed();
483	return VERR_NOT_IMPLEMENTED;
484	}
485
486
487	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutStructEx(PSSMHANDLE pSSM, const void pvStruct, size_t cbStruct, uint32_t fFlags, PCSSMFIELD paFields, void pvUser)
488	{
489	RT_NOREF(pSSM, pvStruct, cbStruct, fFlags, paFields, pvUser);
490	AssertFailed();
491	return VERR_NOT_IMPLEMENTED;
492	}
493
494
495	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutBool(PSSMHANDLE pSSM, bool fBool)
496	{
497	RT_NOREF(pSSM, fBool);
498	AssertFailed();
499	return VERR_NOT_IMPLEMENTED;
500	}
501
502
503	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU8(PSSMHANDLE pSSM, uint8_t u8)
504	{
505	RT_NOREF(pSSM, u8);
506	AssertFailed();
507	return VERR_NOT_IMPLEMENTED;
508	}
509
510
511	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS8(PSSMHANDLE pSSM, int8_t i8)
512	{
513	RT_NOREF(pSSM, i8);
514	AssertFailed();
515	return VERR_NOT_IMPLEMENTED;
516	}
517
518
519	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU16(PSSMHANDLE pSSM, uint16_t u16)
520	{
521	RT_NOREF(pSSM, u16);
522	AssertFailed();
523	return VERR_NOT_IMPLEMENTED;
524	}
525
526
527	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS16(PSSMHANDLE pSSM, int16_t i16)
528	{
529	RT_NOREF(pSSM, i16);
530	AssertFailed();
531	return VERR_NOT_IMPLEMENTED;
532	}
533
534
535	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU32(PSSMHANDLE pSSM, uint32_t u32)
536	{
537	RT_NOREF(pSSM, u32);
538	AssertFailed();
539	return VERR_NOT_IMPLEMENTED;
540	}
541
542
543	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS32(PSSMHANDLE pSSM, int32_t i32)
544	{
545	RT_NOREF(pSSM, i32);
546	AssertFailed();
547	return VERR_NOT_IMPLEMENTED;
548	}
549
550
551	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU64(PSSMHANDLE pSSM, uint64_t u64)
552	{
553	RT_NOREF(pSSM, u64);
554	AssertFailed();
555	return VERR_NOT_IMPLEMENTED;
556	}
557
558
559	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS64(PSSMHANDLE pSSM, int64_t i64)
560	{
561	RT_NOREF(pSSM, i64);
562	AssertFailed();
563	return VERR_NOT_IMPLEMENTED;
564	}
565
566
567	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU128(PSSMHANDLE pSSM, uint128_t u128)
568	{
569	RT_NOREF(pSSM, u128);
570	AssertFailed();
571	return VERR_NOT_IMPLEMENTED;
572	}
573
574
575	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS128(PSSMHANDLE pSSM, int128_t i128)
576	{
577	RT_NOREF(pSSM, i128);
578	AssertFailed();
579	return VERR_NOT_IMPLEMENTED;
580	}
581
582
583	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutUInt(PSSMHANDLE pSSM, RTUINT u)
584	{
585	RT_NOREF(pSSM, u);
586	AssertFailed();
587	return VERR_NOT_IMPLEMENTED;
588	}
589
590
591	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutSInt(PSSMHANDLE pSSM, RTINT i)
592	{
593	RT_NOREF(pSSM, i);
594	AssertFailed();
595	return VERR_NOT_IMPLEMENTED;
596	}
597
598
599	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCUInt(PSSMHANDLE pSSM, RTGCUINT u)
600	{
601	RT_NOREF(pSSM, u);
602	AssertFailed();
603	return VERR_NOT_IMPLEMENTED;
604	}
605
606
607	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCUIntReg(PSSMHANDLE pSSM, RTGCUINTREG u)
608	{
609	RT_NOREF(pSSM, u);
610	AssertFailed();
611	return VERR_NOT_IMPLEMENTED;
612	}
613
614
615	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCPhys32(PSSMHANDLE pSSM, RTGCPHYS32 GCPhys)
616	{
617	RT_NOREF(pSSM, GCPhys);
618	AssertFailed();
619	return VERR_NOT_IMPLEMENTED;
620	}
621
622
623	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCPhys64(PSSMHANDLE pSSM, RTGCPHYS64 GCPhys)
624	{
625	RT_NOREF(pSSM, GCPhys);
626	AssertFailed();
627	return VERR_NOT_IMPLEMENTED;
628	}
629
630
631	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCPhys(PSSMHANDLE pSSM, RTGCPHYS GCPhys)
632	{
633	RT_NOREF(pSSM, GCPhys);
634	AssertFailed();
635	return VERR_NOT_IMPLEMENTED;
636	}
637
638
639	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCPtr(PSSMHANDLE pSSM, RTGCPTR GCPtr)
640	{
641	RT_NOREF(pSSM, GCPtr);
642	AssertFailed();
643	return VERR_NOT_IMPLEMENTED;
644	}
645
646
647	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCUIntPtr(PSSMHANDLE pSSM, RTGCUINTPTR GCPtr)
648	{
649	RT_NOREF(pSSM, GCPtr);
650	AssertFailed();
651	return VERR_NOT_IMPLEMENTED;
652	}
653
654
655	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutRCPtr(PSSMHANDLE pSSM, RTRCPTR RCPtr)
656	{
657	RT_NOREF(pSSM, RCPtr);
658	AssertFailed();
659	return VERR_NOT_IMPLEMENTED;
660	}
661
662
663	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutIOPort(PSSMHANDLE pSSM, RTIOPORT IOPort)
664	{
665	RT_NOREF(pSSM, IOPort);
666	AssertFailed();
667	return VERR_NOT_IMPLEMENTED;
668	}
669
670
671	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutSel(PSSMHANDLE pSSM, RTSEL Sel)
672	{
673	RT_NOREF(pSSM, Sel);
674	AssertFailed();
675	return VERR_NOT_IMPLEMENTED;
676	}
677
678
679	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutMem(PSSMHANDLE pSSM, const void *pv, size_t cb)
680	{
681	RT_NOREF(pSSM, pv, cb);
682	AssertFailed();
683	return VERR_NOT_IMPLEMENTED;
684	}
685
686
687	static DECLCALLBACK(int) pdmR3DevHlp_SSMPutStrZ(PSSMHANDLE pSSM, const char *psz)
688	{
689	RT_NOREF(pSSM, psz);
690	AssertFailed();
691	return VERR_NOT_IMPLEMENTED;
692	}
693
694
695	/**
696	* Gets the host bit count of the saved state.
697	*
698	* Works for on both save and load handles.
699	*
700	* @returns 32 or 64.
701	* @param pSSM The saved state handle.
702	*/
703	DECLINLINE(uint32_t) ssmR3GetHostBits(PSSMHANDLE pSSM)
704	{
705	/** @todo Don't care about 32bit saved states for now (VBox is 64bit only as of 6.0). */
706	RT_NOREF(pSSM);
707	return HC_ARCH_BITS;
708	}
709
710
711	/**
712	* Saved state origins on a host using 32-bit MSC?
713	*
714	* Works for on both save and load handles.
715	*
716	* @returns true/false.
717	* @param pSSM The saved state handle.
718	*/
719	DECLINLINE(bool) ssmR3IsHostMsc32(PSSMHANDLE pSSM)
720	{
721	/** @todo Don't care about 32bit saved states for now (VBox is 64bit only as of 6.0). */
722	RT_NOREF(pSSM);
723	return false;
724	}
725
726
727	/**
728	* Inlined worker that handles format checks and buffered reads.
729	*
730	* @param pSSM The saved state handle.
731	* @param pvBuf Where to store the read data.
732	* @param cbBuf Number of bytes to read.
733	*/
734	DECLINLINE(int) tstDevSsmR3DataRead(PSSMHANDLE pSSM, void *pvBuf, size_t cbBuf)
735	{
736	/*
737	* Fend off previous errors and V1 data units.
738	*/
739	if (RT_SUCCESS(pSSM->rc))
740	{
741	/** @todo Don't care about version 1 saved states (long obsolete). */
742	uint32_t off = pSSM->offDataBuffer;
743	if ( cbBuf <= pSSM->cbSavedState
744	&& pSSM->cbSavedState - cbBuf >= off)
745	{
746	memcpy(pvBuf, &pSSM->pbSavedState[off], cbBuf);
747	pSSM->offDataBuffer = off + (uint32_t)cbBuf;
748	return VINF_SUCCESS;
749	}
750	else
751	pSSM->rc = VERR_BUFFER_OVERFLOW;
752	}
753	return pSSM->rc;
754	}
755
756
757	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetBool(PSSMHANDLE pSSM, bool *pfBool)
758	{
759	uint8_t u8; /* see SSMR3PutBool */
760	int rc = tstDevSsmR3DataRead(pSSM, &u8, sizeof(u8));
761	if (RT_SUCCESS(rc))
762	{
763	Assert(u8 <= 1);
764	*pfBool = RT_BOOL(u8);
765	}
766	return rc;
767	}
768
769
770	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetBoolV(PSSMHANDLE pSSM, bool volatile *pfBool)
771	{
772	uint8_t u8; /* see SSMR3PutBool */
773	int rc = tstDevSsmR3DataRead(pSSM, &u8, sizeof(u8));
774	if (RT_SUCCESS(rc))
775	{
776	Assert(u8 <= 1);
777	*pfBool = RT_BOOL(u8);
778	}
779	return rc;
780	}
781
782
783	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU8(PSSMHANDLE pSSM, uint8_t *pu8)
784	{
785	return tstDevSsmR3DataRead(pSSM, pu8, sizeof(*pu8));
786	}
787
788
789	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU8V(PSSMHANDLE pSSM, uint8_t volatile *pu8)
790	{
791	return tstDevSsmR3DataRead(pSSM, (void )pu8, sizeof(pu8));
792	}
793
794
795	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS8(PSSMHANDLE pSSM, int8_t *pi8)
796	{
797	return tstDevSsmR3DataRead(pSSM, pi8, sizeof(*pi8));
798	}
799
800
801	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS8V(PSSMHANDLE pSSM, int8_t volatile *pi8)
802	{
803	return tstDevSsmR3DataRead(pSSM, (void )pi8, sizeof(pi8));
804	}
805
806
807	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU16(PSSMHANDLE pSSM, uint16_t *pu16)
808	{
809	return tstDevSsmR3DataRead(pSSM, pu16, sizeof(*pu16));
810	}
811
812
813	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU16V(PSSMHANDLE pSSM, uint16_t volatile *pu16)
814	{
815	return tstDevSsmR3DataRead(pSSM, (void )pu16, sizeof(pu16));
816	}
817
818
819	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS16(PSSMHANDLE pSSM, int16_t *pi16)
820	{
821	return tstDevSsmR3DataRead(pSSM, pi16, sizeof(*pi16));
822	}
823
824
825	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS16V(PSSMHANDLE pSSM, int16_t volatile *pi16)
826	{
827	return tstDevSsmR3DataRead(pSSM, (void )pi16, sizeof(pi16));
828	}
829
830
831	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU32(PSSMHANDLE pSSM, uint32_t *pu32)
832	{
833	return tstDevSsmR3DataRead(pSSM, pu32, sizeof(*pu32));
834	}
835
836
837	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU32V(PSSMHANDLE pSSM, uint32_t volatile *pu32)
838	{
839	return tstDevSsmR3DataRead(pSSM, (void )pu32, sizeof(pu32));
840	}
841
842
843	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS32(PSSMHANDLE pSSM, int32_t *pi32)
844	{
845	return tstDevSsmR3DataRead(pSSM, pi32, sizeof(*pi32));
846	}
847
848
849	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS32V(PSSMHANDLE pSSM, int32_t volatile *pi32)
850	{
851	return tstDevSsmR3DataRead(pSSM, (void )pi32, sizeof(pi32));
852	}
853
854
855	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU64(PSSMHANDLE pSSM, uint64_t *pu64)
856	{
857	return tstDevSsmR3DataRead(pSSM, pu64, sizeof(*pu64));
858	}
859
860
861	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU64V(PSSMHANDLE pSSM, uint64_t volatile *pu64)
862	{
863	return tstDevSsmR3DataRead(pSSM, (void )pu64, sizeof(pu64));
864	}
865
866
867	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS64(PSSMHANDLE pSSM, int64_t *pi64)
868	{
869	return tstDevSsmR3DataRead(pSSM, pi64, sizeof(*pi64));
870	}
871
872
873	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS64V(PSSMHANDLE pSSM, int64_t volatile *pi64)
874	{
875	return tstDevSsmR3DataRead(pSSM, (void )pi64, sizeof(pi64));
876	}
877
878
879	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU128(PSSMHANDLE pSSM, uint128_t *pu128)
880	{
881	return tstDevSsmR3DataRead(pSSM, pu128, sizeof(*pu128));
882	}
883
884
885	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU128V(PSSMHANDLE pSSM, uint128_t volatile *pu128)
886	{
887	return tstDevSsmR3DataRead(pSSM, (void )pu128, sizeof(pu128));
888	}
889
890
891	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS128(PSSMHANDLE pSSM, int128_t *pi128)
892	{
893	return tstDevSsmR3DataRead(pSSM, pi128, sizeof(*pi128));
894	}
895
896
897	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS128V(PSSMHANDLE pSSM, int128_t volatile *pi128)
898	{
899	return tstDevSsmR3DataRead(pSSM, (void )pi128, sizeof(pi128));
900	}
901
902
903	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys32(PSSMHANDLE pSSM, PRTGCPHYS32 pGCPhys)
904	{
905	return tstDevSsmR3DataRead(pSSM, pGCPhys, sizeof(*pGCPhys));
906	}
907
908
909	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys32V(PSSMHANDLE pSSM, RTGCPHYS32 volatile *pGCPhys)
910	{
911	return tstDevSsmR3DataRead(pSSM, (void )pGCPhys, sizeof(pGCPhys));
912	}
913
914
915	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys64(PSSMHANDLE pSSM, PRTGCPHYS64 pGCPhys)
916	{
917	return tstDevSsmR3DataRead(pSSM, pGCPhys, sizeof(*pGCPhys));
918	}
919
920
921	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys64V(PSSMHANDLE pSSM, RTGCPHYS64 volatile *pGCPhys)
922	{
923	return tstDevSsmR3DataRead(pSSM, (void )pGCPhys, sizeof(pGCPhys));
924	}
925
926
927	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys(PSSMHANDLE pSSM, PRTGCPHYS pGCPhys)
928	{
929	/*
930	* Default size?
931	*/
932	if (RT_LIKELY(/sizeof(pGCPhys) == pSSM->u.Read.cbGCPhys*/true))
933	return tstDevSsmR3DataRead(pSSM, pGCPhys, sizeof(*pGCPhys));
934
935	#if 0 /** @todo Later if necessary (only very old saved states). */
936	/*
937	* Fiddly.
938	*/
939	Assert(sizeof(pGCPhys) == sizeof(uint64_t) \|\| sizeof(pGCPhys) == sizeof(uint32_t));
940	Assert(pSSM->u.Read.cbGCPhys == sizeof(uint64_t) \|\| pSSM->u.Read.cbGCPhys == sizeof(uint32_t));
941	if (pSSM->u.Read.cbGCPhys == sizeof(uint64_t))
942	{
943	/* 64-bit saved, 32-bit load: try truncate it. */
944	uint64_t u64;
945	int rc = tstDevSsmR3DataRead(pSSM, &u64, sizeof(uint64_t));
946	if (RT_FAILURE(rc))
947	return rc;
948	if (u64 >= _4G)
949	return VERR_SSM_GCPHYS_OVERFLOW;
950	*pGCPhys = (RTGCPHYS)u64;
951	return rc;
952	}
953
954	/* 32-bit saved, 64-bit load: clear the high part. */
955	*pGCPhys = 0;
956	return tstDevSsmR3DataRead(pSSM, pGCPhys, sizeof(uint32_t));
957	#endif
958	}
959
960
961	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhysV(PSSMHANDLE pSSM, RTGCPHYS volatile *pGCPhys)
962	{
963	return pdmR3DevHlp_SSMGetGCPhys(pSSM, (PRTGCPHYS)pGCPhys);
964	}
965
966
967	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetUInt(PSSMHANDLE pSSM, PRTUINT pu)
968	{
969	return tstDevSsmR3DataRead(pSSM, pu, sizeof(*pu));
970	}
971
972
973	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetSInt(PSSMHANDLE pSSM, PRTINT pi)
974	{
975	return tstDevSsmR3DataRead(pSSM, pi, sizeof(*pi));
976	}
977
978
979	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPtr(PSSMHANDLE pSSM, PRTGCPTR pGCPtr)
980	{
981	return tstDevSsmR3DataRead(pSSM, pGCPtr, sizeof(*pGCPtr));
982	}
983
984
985	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUInt(PSSMHANDLE pSSM, PRTGCUINT pu)
986	{
987	return pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pu);
988	}
989
990
991	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUIntReg(PSSMHANDLE pSSM, PRTGCUINTREG pu)
992	{
993	AssertCompile(sizeof(RTGCPTR) == sizeof(*pu));
994	return pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pu);
995	}
996
997
998	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUIntPtr(PSSMHANDLE pSSM, PRTGCUINTPTR pGCPtr)
999	{
1000	return pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pGCPtr);
1001	}
1002
1003
1004	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetRCPtr(PSSMHANDLE pSSM, PRTRCPTR pRCPtr)
1005	{
1006	return tstDevSsmR3DataRead(pSSM, pRCPtr, sizeof(*pRCPtr));
1007	}
1008
1009
1010	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetIOPort(PSSMHANDLE pSSM, PRTIOPORT pIOPort)
1011	{
1012	return tstDevSsmR3DataRead(pSSM, pIOPort, sizeof(*pIOPort));
1013	}
1014
1015
1016	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetSel(PSSMHANDLE pSSM, PRTSEL pSel)
1017	{
1018	return tstDevSsmR3DataRead(pSSM, pSel, sizeof(*pSel));
1019	}
1020
1021
1022	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetMem(PSSMHANDLE pSSM, void *pv, size_t cb)
1023	{
1024	return tstDevSsmR3DataRead(pSSM, pv, cb);
1025	}
1026
1027
1028	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStrZEx(PSSMHANDLE pSSM, char psz, size_t cbMax, size_t pcbStr)
1029	{
1030	/* read size prefix. */
1031	uint32_t u32;
1032	int rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32);
1033	if (RT_SUCCESS(rc))
1034	{
1035	if (pcbStr)
1036	*pcbStr = u32;
1037	if (u32 < cbMax)
1038	{
1039	/* terminate and read string content. */
1040	psz[u32] = '\0';
1041	return tstDevSsmR3DataRead(pSSM, psz, u32);
1042	}
1043	return VERR_TOO_MUCH_DATA;
1044	}
1045	return rc;
1046	}
1047
1048
1049	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStrZ(PSSMHANDLE pSSM, char *psz, size_t cbMax)
1050	{
1051	return pdmR3DevHlp_SSMGetStrZEx(pSSM, psz, cbMax, NULL);
1052	}
1053
1054
1055	static DECLCALLBACK(int) pdmR3DevHlp_SSMSkip(PSSMHANDLE pSSM, size_t cb)
1056	{
1057	while (cb > 0)
1058	{
1059	uint8_t abBuf[8192];
1060	size_t cbCur = RT_MIN(sizeof(abBuf), cb);
1061	cb -= cbCur;
1062	int rc = tstDevSsmR3DataRead(pSSM, abBuf, cbCur);
1063	if (RT_FAILURE(rc))
1064	return rc;
1065	}
1066
1067	return VINF_SUCCESS;
1068	}
1069
1070
1071	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStruct(PSSMHANDLE pSSM, void *pvStruct, PCSSMFIELD paFields)
1072	{
1073	AssertPtr(pvStruct);
1074	AssertPtr(paFields);
1075
1076	/* begin marker. */
1077	uint32_t u32Magic;
1078	int rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32Magic);
1079	if (RT_FAILURE(rc))
1080	return rc;
1081	AssertMsgReturn(u32Magic == SSMR3STRUCT_BEGIN, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
1082
1083	/* get the fields */
1084	for (PCSSMFIELD pCur = paFields;
1085	pCur->cb != UINT32_MAX && pCur->off != UINT32_MAX;
1086	pCur++)
1087	{
1088	if (pCur->uFirstVer <= pSSM->uCurUnitVer)
1089	{
1090	uint8_t pbField = (uint8_t )pvStruct + pCur->off;
1091	switch ((uintptr_t)pCur->pfnGetPutOrTransformer)
1092	{
1093	case SSMFIELDTRANS_NO_TRANSFORMATION:
1094	rc = tstDevSsmR3DataRead(pSSM, pbField, pCur->cb);
1095	break;
1096
1097	case SSMFIELDTRANS_GCPTR:
1098	AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1099	rc = pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pbField);
1100	break;
1101
1102	case SSMFIELDTRANS_GCPHYS:
1103	AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPHYS), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1104	rc = pdmR3DevHlp_SSMGetGCPhys(pSSM, (PRTGCPHYS)pbField);
1105	break;
1106
1107	case SSMFIELDTRANS_RCPTR:
1108	AssertMsgBreakStmt(pCur->cb == sizeof(RTRCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1109	rc = pdmR3DevHlp_SSMGetRCPtr(pSSM, (PRTRCPTR)pbField);
1110	break;
1111
1112	case SSMFIELDTRANS_RCPTR_ARRAY:
1113	{
1114	uint32_t const cEntries = pCur->cb / sizeof(RTRCPTR);
1115	AssertMsgBreakStmt(pCur->cb == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1116	rc = VINF_SUCCESS;
1117	for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
1118	rc = pdmR3DevHlp_SSMGetRCPtr(pSSM, &((PRTRCPTR)pbField)[i]);
1119	break;
1120	}
1121
1122	default:
1123	AssertMsgFailedBreakStmt(("%#x\n", pCur->pfnGetPutOrTransformer), rc = VERR_SSM_FIELD_COMPLEX);
1124	}
1125	if (RT_FAILURE(rc))
1126	{
1127	if (RT_SUCCESS(pSSM->rc))
1128	pSSM->rc = rc;
1129	return rc;
1130	}
1131	}
1132	}
1133
1134	/* end marker */
1135	rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32Magic);
1136	if (RT_FAILURE(rc))
1137	return rc;
1138	AssertMsgReturn(u32Magic == SSMR3STRUCT_END, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
1139	return rc;
1140	}
1141
1142
1143	/**
1144	* SSMR3GetStructEx helper that gets a HCPTR that is used as a NULL indicator.
1145	*
1146	* @returns VBox status code.
1147	*
1148	* @param pSSM The saved state handle.
1149	* @param ppv Where to return the value (0/1).
1150	* @param fFlags SSMSTRUCT_FLAGS_XXX.
1151	*/
1152	DECLINLINE(int) ssmR3GetHCPtrNI(PSSMHANDLE pSSM, void **ppv, uint32_t fFlags)
1153	{
1154	uintptr_t uPtrNI;
1155	if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
1156	{
1157	if (ssmR3GetHostBits(pSSM) == 64)
1158	{
1159	uint64_t u;
1160	int rc = tstDevSsmR3DataRead(pSSM, &u, sizeof(u));
1161	if (RT_FAILURE(rc))
1162	return rc;
1163	uPtrNI = u ? 1 : 0;
1164	}
1165	else
1166	{
1167	uint32_t u;
1168	int rc = tstDevSsmR3DataRead(pSSM, &u, sizeof(u));
1169	if (RT_FAILURE(rc))
1170	return rc;
1171	uPtrNI = u ? 1 : 0;
1172	}
1173	}
1174	else
1175	{
1176	bool f;
1177	int rc = pdmR3DevHlp_SSMGetBool(pSSM, &f);
1178	if (RT_FAILURE(rc))
1179	return rc;
1180	uPtrNI = f ? 1 : 0;
1181	}
1182	ppv = (void )uPtrNI;
1183	return VINF_SUCCESS;
1184	}
1185
1186
1187	static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStructEx(PSSMHANDLE pSSM, void pvStruct, size_t cbStruct, uint32_t fFlags, PCSSMFIELD paFields, void pvUser)
1188	{
1189	int rc;
1190	uint32_t u32Magic;
1191
1192	/*
1193	* Validation.
1194	*/
1195	AssertMsgReturn(!(fFlags & ~SSMSTRUCT_FLAGS_VALID_MASK), ("%#x\n", fFlags), pSSM->rc = VERR_INVALID_PARAMETER);
1196	AssertPtr(pvStruct);
1197	AssertPtr(paFields);
1198
1199	/*
1200	* Begin marker.
1201	*/
1202	if (!(fFlags & (SSMSTRUCT_FLAGS_NO_MARKERS \| SSMSTRUCT_FLAGS_NO_LEAD_MARKER)))
1203	{
1204	rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32Magic);
1205	if (RT_FAILURE(rc))
1206	return rc;
1207	AssertMsgReturn(u32Magic == SSMR3STRUCT_BEGIN, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
1208	}
1209
1210	/*
1211	* Put the fields
1212	*/
1213	rc = VINF_SUCCESS;
1214	uint32_t off = 0;
1215	for (PCSSMFIELD pCur = paFields;
1216	pCur->cb != UINT32_MAX && pCur->off != UINT32_MAX;
1217	pCur++)
1218	{
1219	uint32_t const offField = (!SSMFIELDTRANS_IS_PADDING(pCur->pfnGetPutOrTransformer) \|\| pCur->off != UINT32_MAX / 2)
1220	&& !SSMFIELDTRANS_IS_OLD(pCur->pfnGetPutOrTransformer)
1221	? pCur->off
1222	: off;
1223	uint32_t const cbField = SSMFIELDTRANS_IS_OLD(pCur->pfnGetPutOrTransformer)
1224	? 0
1225	: SSMFIELDTRANS_IS_PADDING(pCur->pfnGetPutOrTransformer)
1226	? RT_HIWORD(pCur->cb)
1227	: pCur->cb;
1228	AssertMsgReturn( cbField <= cbStruct
1229	&& offField + cbField <= cbStruct
1230	&& offField + cbField >= offField,
1231	("off=%#x cb=%#x cbStruct=%#x (%s)\n", cbField, offField, cbStruct, pCur->pszName),
1232	pSSM->rc = VERR_SSM_FIELD_OUT_OF_BOUNDS);
1233	AssertMsgReturn( !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
1234	\|\| off == offField,
1235	("off=%#x offField=%#x (%s)\n", off, offField, pCur->pszName),
1236	pSSM->rc = VERR_SSM_FIELD_NOT_CONSECUTIVE);
1237
1238	if (pCur->uFirstVer <= pSSM->uCurUnitVer)
1239	{
1240	rc = VINF_SUCCESS;
1241	uint8_t pbField = (uint8_t )pvStruct + offField;
1242	switch ((uintptr_t)pCur->pfnGetPutOrTransformer)
1243	{
1244	case SSMFIELDTRANS_NO_TRANSFORMATION:
1245	rc = tstDevSsmR3DataRead(pSSM, pbField, cbField);
1246	break;
1247
1248	case SSMFIELDTRANS_GCPHYS:
1249	AssertMsgBreakStmt(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1250	rc = pdmR3DevHlp_SSMGetGCPhys(pSSM, (PRTGCPHYS)pbField);
1251	break;
1252
1253	case SSMFIELDTRANS_GCPTR:
1254	AssertMsgBreakStmt(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1255	rc = pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pbField);
1256	break;
1257
1258	case SSMFIELDTRANS_RCPTR:
1259	AssertMsgBreakStmt(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1260	rc = pdmR3DevHlp_SSMGetRCPtr(pSSM, (PRTRCPTR)pbField);
1261	break;
1262
1263	case SSMFIELDTRANS_RCPTR_ARRAY:
1264	{
1265	uint32_t const cEntries = cbField / sizeof(RTRCPTR);
1266	AssertMsgBreakStmt(cbField == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1267	rc = VINF_SUCCESS;
1268	for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
1269	rc = pdmR3DevHlp_SSMGetRCPtr(pSSM, &((PRTRCPTR)pbField)[i]);
1270	break;
1271	}
1272
1273	case SSMFIELDTRANS_HCPTR_NI:
1274	AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1275	rc = ssmR3GetHCPtrNI(pSSM, (void **)pbField, fFlags);
1276	break;
1277
1278	case SSMFIELDTRANS_HCPTR_NI_ARRAY:
1279	{
1280	uint32_t const cEntries = cbField / sizeof(void *);
1281	AssertMsgBreakStmt(cbField == cEntries * sizeof(void *) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1282	rc = VINF_SUCCESS;
1283	for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
1284	rc = ssmR3GetHCPtrNI(pSSM, &((void **)pbField)[i], fFlags);
1285	break;
1286	}
1287
1288	case SSMFIELDTRANS_HCPTR_HACK_U32:
1289	AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1290	(uintptr_t )pbField = 0;
1291	rc = tstDevSsmR3DataRead(pSSM, pbField, sizeof(uint32_t));
1292	if ((fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE) && ssmR3GetHostBits(pSSM) == 64)
1293	{
1294	uint32_t u32;
1295	rc = tstDevSsmR3DataRead(pSSM, &u32, sizeof(uint32_t));
1296	AssertMsgBreakStmt(RT_FAILURE(rc) \|\| u32 == 0 \|\| (fFlags & SSMSTRUCT_FLAGS_SAVED_AS_MEM),
1297	("high=%#x low=%#x (%s)\n", u32, (uint32_t )pbField, pCur->pszName),
1298	rc = VERR_SSM_FIELD_INVALID_VALUE);
1299	}
1300	break;
1301
1302	case SSMFIELDTRANS_U32_ZX_U64:
1303	AssertMsgBreakStmt(cbField == sizeof(uint64_t), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1304	((uint32_t *)pbField)[1] = 0;
1305	rc = pdmR3DevHlp_SSMGetU32(pSSM, (uint32_t *)pbField);
1306	break;
1307
1308
1309	case SSMFIELDTRANS_IGNORE:
1310	if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
1311	rc = pdmR3DevHlp_SSMSkip(pSSM, cbField);
1312	break;
1313
1314	case SSMFIELDTRANS_IGN_GCPHYS:
1315	AssertMsgBreakStmt(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1316	if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
1317	rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTGCPHYS));
1318	break;
1319
1320	case SSMFIELDTRANS_IGN_GCPTR:
1321	AssertMsgBreakStmt(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1322	if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
1323	rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTGCPTR));
1324	break;
1325
1326	case SSMFIELDTRANS_IGN_RCPTR:
1327	AssertMsgBreakStmt(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1328	if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
1329	rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTRCPTR));
1330	break;
1331
1332	case SSMFIELDTRANS_IGN_HCPTR:
1333	AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1334	if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
1335	rc = pdmR3DevHlp_SSMSkip(pSSM, ssmR3GetHostBits(pSSM) / 8);
1336	break;
1337
1338
1339	case SSMFIELDTRANS_OLD:
1340	AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1341	rc = pdmR3DevHlp_SSMSkip(pSSM, pCur->cb);
1342	break;
1343
1344	case SSMFIELDTRANS_OLD_GCPHYS:
1345	AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPHYS) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1346	rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTGCPHYS));
1347	break;
1348
1349	case SSMFIELDTRANS_OLD_GCPTR:
1350	AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPTR) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1351	rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTGCPTR));
1352	break;
1353
1354	case SSMFIELDTRANS_OLD_RCPTR:
1355	AssertMsgBreakStmt(pCur->cb == sizeof(RTRCPTR) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1356	rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTRCPTR));
1357	break;
1358
1359	case SSMFIELDTRANS_OLD_HCPTR:
1360	AssertMsgBreakStmt(pCur->cb == sizeof(void *) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1361	rc = pdmR3DevHlp_SSMSkip(pSSM, ssmR3GetHostBits(pSSM) / 8);
1362	break;
1363
1364	case SSMFIELDTRANS_OLD_PAD_HC:
1365	AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1366	rc = pdmR3DevHlp_SSMSkip(pSSM, ssmR3GetHostBits(pSSM) == 64 ? RT_HIWORD(pCur->cb) : RT_LOWORD(pCur->cb));
1367	break;
1368
1369	case SSMFIELDTRANS_OLD_PAD_MSC32:
1370	AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
1371	if (ssmR3IsHostMsc32(pSSM))
1372	rc = pdmR3DevHlp_SSMSkip(pSSM, pCur->cb);
1373	break;
1374
1375
1376	case SSMFIELDTRANS_PAD_HC:
1377	case SSMFIELDTRANS_PAD_HC32:
1378	case SSMFIELDTRANS_PAD_HC64:
1379	case SSMFIELDTRANS_PAD_HC_AUTO:
1380	case SSMFIELDTRANS_PAD_MSC32_AUTO:
1381	{
1382	uint32_t cb32 = RT_BYTE1(pCur->cb);
1383	uint32_t cb64 = RT_BYTE2(pCur->cb);
1384	uint32_t cbCtx = HC_ARCH_BITS == 64
1385	\|\| (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_MSC32_AUTO
1386	? cb64 : cb32;
1387	uint32_t cbSaved = ssmR3GetHostBits(pSSM) == 64
1388	\|\| ( (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_MSC32_AUTO
1389	&& !ssmR3IsHostMsc32(pSSM))
1390	? cb64 : cb32;
1391	AssertMsgBreakStmt( cbField == cbCtx
1392	&& ( ( pCur->off == UINT32_MAX / 2
1393	&& ( cbField == 0
1394	\|\| (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_HC_AUTO
1395	\|\| (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_MSC32_AUTO
1396	)
1397	)
1398	\|\| (pCur->off != UINT32_MAX / 2 && cbField != 0)
1399	)
1400	, ("cbField=%#x cb32=%#x cb64=%#x HC_ARCH_BITS=%u cbCtx=%#x cbSaved=%#x off=%#x\n",
1401	cbField, cb32, cb64, HC_ARCH_BITS, cbCtx, cbSaved, pCur->off),
1402	rc = VERR_SSM_FIELD_INVALID_PADDING_SIZE);
1403	if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
1404	rc = pdmR3DevHlp_SSMSkip(pSSM, cbSaved);
1405	break;
1406	}
1407
1408	default:
1409	AssertBreakStmt(pCur->pfnGetPutOrTransformer, rc = VERR_SSM_FIELD_INVALID_CALLBACK);
1410	rc = pCur->pfnGetPutOrTransformer(pSSM, pCur, pvStruct, fFlags, true /fGetOrPut/, pvUser);
1411	break;
1412	}
1413	if (RT_FAILURE(rc))
1414	break;
1415	}
1416
1417	off = offField + cbField;
1418	}
1419
1420	if (RT_SUCCESS(rc))
1421	AssertMsgStmt( !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
1422	\|\| off == cbStruct,
1423	("off=%#x cbStruct=%#x\n", off, cbStruct),
1424	rc = VERR_SSM_FIELD_NOT_CONSECUTIVE);
1425
1426	if (RT_FAILURE(rc))
1427	{
1428	if (RT_SUCCESS(pSSM->rc))
1429	pSSM->rc = rc;
1430	return rc;
1431	}
1432
1433	/*
1434	* End marker
1435	*/
1436	if (!(fFlags & (SSMSTRUCT_FLAGS_NO_MARKERS \| SSMSTRUCT_FLAGS_NO_TAIL_MARKER)))
1437	{
1438	rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32Magic);
1439	if (RT_FAILURE(rc))
1440	return rc;
1441	AssertMsgReturn(u32Magic == SSMR3STRUCT_END, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
1442	}
1443
1444	return VINF_SUCCESS;
1445	}
1446
1447
1448	static DECLCALLBACK(int) pdmR3DevHlp_SSMSkipToEndOfUnit(PSSMHANDLE pSSM)
1449	{
1450	RT_NOREF(pSSM);
1451	AssertFailed();
1452	return VERR_NOT_IMPLEMENTED;
1453	}
1454
1455
1456	static DECLCALLBACK(int) pdmR3DevHlp_SSMSetLoadError(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(6, 7)
1457	{
1458	RT_NOREF(pSSM, rc, RT_SRC_POS_ARGS, pszFormat);
1459	AssertFailed();
1460	return VERR_NOT_IMPLEMENTED;
1461	}
1462
1463
1464	static DECLCALLBACK(int) pdmR3DevHlp_SSMSetLoadErrorV(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(6, 0)
1465	{
1466	RT_NOREF(pSSM, rc, RT_SRC_POS_ARGS, pszFormat, va);
1467	AssertFailed();
1468	return VERR_NOT_IMPLEMENTED;
1469	}
1470
1471
1472	static DECLCALLBACK(int) pdmR3DevHlp_SSMSetCfgError(PSSMHANDLE pSSM, RT_SRC_POS_DECL, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(5, 6)
1473	{
1474	RT_NOREF(pSSM, RT_SRC_POS_ARGS, pszFormat);
1475	pSSM->rc = VERR_SSM_LOAD_CONFIG_MISMATCH;
1476	return pSSM->rc;
1477	}
1478
1479
1480	static DECLCALLBACK(int) pdmR3DevHlp_SSMSetCfgErrorV(PSSMHANDLE pSSM, RT_SRC_POS_DECL, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(5, 0)
1481	{
1482	RT_NOREF(pSSM, RT_SRC_POS_ARGS, pszFormat, va);
1483	pSSM->rc = VERR_SSM_LOAD_CONFIG_MISMATCH;
1484	return pSSM->rc;
1485	}
1486
1487
1488	static DECLCALLBACK(int) pdmR3DevHlp_SSMHandleGetStatus(PSSMHANDLE pSSM)
1489	{
1490	RT_NOREF(pSSM);
1491	return pSSM->rc;
1492	}
1493
1494
1495	static DECLCALLBACK(SSMAFTER) pdmR3DevHlp_SSMHandleGetAfter(PSSMHANDLE pSSM)
1496	{
1497	RT_NOREF(pSSM);
1498	AssertFailed();
1499	return SSMAFTER_INVALID;
1500	}
1501
1502
1503	static DECLCALLBACK(bool) pdmR3DevHlp_SSMHandleIsLiveSave(PSSMHANDLE pSSM)
1504	{
1505	RT_NOREF(pSSM);
1506	AssertFailed();
1507	return false;
1508	}
1509
1510
1511	static DECLCALLBACK(uint32_t) pdmR3DevHlp_SSMHandleMaxDowntime(PSSMHANDLE pSSM)
1512	{
1513	RT_NOREF(pSSM);
1514	AssertFailed();
1515	return 0;
1516	}
1517
1518
1519	static DECLCALLBACK(uint32_t) pdmR3DevHlp_SSMHandleHostBits(PSSMHANDLE pSSM)
1520	{
1521	RT_NOREF(pSSM);
1522	AssertFailed();
1523	return 0;
1524	}
1525
1526
1527	static DECLCALLBACK(uint32_t) pdmR3DevHlp_SSMHandleRevision(PSSMHANDLE pSSM)
1528	{
1529	RT_NOREF(pSSM);
1530	AssertFailed();
1531	return 0;
1532	}
1533
1534
1535	static DECLCALLBACK(uint32_t) pdmR3DevHlp_SSMHandleVersion(PSSMHANDLE pSSM)
1536	{
1537	RT_NOREF(pSSM);
1538	AssertFailed();
1539	return 0;
1540	}
1541
1542
1543	static DECLCALLBACK(const char *) pdmR3DevHlp_SSMHandleHostOSAndArch(PSSMHANDLE pSSM)
1544	{
1545	RT_NOREF(pSSM);
1546	AssertFailed();
1547	return NULL;
1548	}
1549
1550
1551	/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimerCreate} */
1552	static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void pvUser, uint32_t fFlags, const char pszDesc, PPTMTIMERR3 ppTimer)
1553	{
1554	PDMDEV_ASSERT_DEVINS(pDevIns);
1555	LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} ppTimer=%p\n",
1556	pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
1557
1558	int rc = VERR_NOT_IMPLEMENTED;
1559	AssertFailed();
1560
1561	LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1562	return rc;
1563	}
1564
1565
1566
1567	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerCreate} */
1568	static DECLCALLBACK(int) pdmR3DevHlp_TimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback,
1569	void pvUser, uint32_t fFlags, const char pszDesc, PTMTIMERHANDLE phTimer)
1570	{
1571	PDMDEV_ASSERT_DEVINS(pDevIns);
1572	LogFlow(("pdmR3DevHlp_TimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} phTimer=%p\n",
1573	pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, phTimer));
1574
1575	int rc = VINF_SUCCESS;
1576	PTMTIMERR3 pTimer = (PTMTIMERR3)RTMemAllocZ(sizeof(TMTIMER));
1577	if (RT_LIKELY(pTimer))
1578	{
1579	pTimer->enmClock = enmClock;
1580	pTimer->pfnCallbackDev = pfnCallback;
1581	pTimer->pvUser = pvUser;
1582	pTimer->fFlags = fFlags;
1583	RTListAppend(&pDevIns->Internal.s.pDut->LstTimers, &pTimer->NdDevTimers);
1584	*phTimer = (TMTIMERHANDLE)pTimer;
1585	}
1586	else
1587	rc = VERR_NO_MEMORY;
1588
1589	LogFlow(("pdmR3DevHlp_TimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
1590	return rc;
1591	}
1592
1593
1594	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerToPtr} */
1595	static DECLCALLBACK(PTMTIMERR3) pdmR3DevHlp_TimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1596	{
1597	PDMDEV_ASSERT_DEVINS(pDevIns);
1598	RT_NOREF(pDevIns);
1599	return (PTMTIMERR3)hTimer;
1600	}
1601
1602
1603	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerFromMicro} */
1604	static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
1605	{
1606	RT_NOREF(pDevIns, hTimer, cMicroSecs);
1607	AssertFailed();
1608	return 0;
1609	}
1610
1611
1612	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerFromMilli} */
1613	static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromMilli(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliSecs)
1614	{
1615	RT_NOREF(pDevIns, hTimer, cMilliSecs);
1616	AssertFailed();
1617	return 0;
1618	}
1619
1620
1621	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerFromNano} */
1622	static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
1623	{
1624	RT_NOREF(pDevIns, hTimer, cNanoSecs);
1625	AssertFailed();
1626	return 0;
1627	}
1628
1629	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerGet} */
1630	static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1631	{
1632	RT_NOREF(pDevIns, hTimer);
1633	AssertFailed();
1634	return 0;
1635	}
1636
1637
1638	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerGetFreq} */
1639	static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGetFreq(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1640	{
1641	PDMDEV_ASSERT_DEVINS(pDevIns);
1642
1643	PTMTIMERR3 pTimer = (PTMTIMERR3)hTimer;
1644	switch (pTimer->enmClock)
1645	{
1646	case TMCLOCK_VIRTUAL:
1647	case TMCLOCK_VIRTUAL_SYNC:
1648	return TMCLOCK_FREQ_VIRTUAL;
1649
1650	case TMCLOCK_REAL:
1651	return TMCLOCK_FREQ_REAL;
1652
1653	default:
1654	AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
1655	return 0;
1656	}
1657	}
1658
1659
1660	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerGetNano} */
1661	static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1662	{
1663	RT_NOREF(pDevIns, hTimer);
1664	AssertFailed();
1665	return 0;
1666	}
1667
1668
1669	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerIsActive} */
1670	static DECLCALLBACK(bool) pdmR3DevHlp_TimerIsActive(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1671	{
1672	RT_NOREF(pDevIns, hTimer);
1673	AssertFailed();
1674	return false;
1675	}
1676
1677
1678	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerIsLockOwner} */
1679	static DECLCALLBACK(bool) pdmR3DevHlp_TimerIsLockOwner(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1680	{
1681	RT_NOREF(pDevIns, hTimer);
1682	AssertFailed();
1683	return false;
1684	}
1685
1686
1687	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerLockClock} */
1688	static DECLCALLBACK(VBOXSTRICTRC) pdmR3DevHlp_TimerLockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, int rcBusy)
1689	{
1690	RT_NOREF(pDevIns, hTimer, rcBusy);
1691
1692	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
1693	int rc = VERR_NOT_IMPLEMENTED;
1694	AssertFailed();
1695	#else
1696	int rc = VINF_SUCCESS;
1697	#endif
1698	return rc;
1699	}
1700
1701
1702	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerLockClock2} */
1703	static DECLCALLBACK(VBOXSTRICTRC) pdmR3DevHlp_TimerLockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer,
1704	PPDMCRITSECT pCritSect, int rcBusy)
1705	{
1706	RT_NOREF(pDevIns, hTimer, pCritSect, rcBusy);
1707
1708	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
1709	int rc = VERR_NOT_IMPLEMENTED;
1710	AssertFailed();
1711	#else
1712	int rc = VINF_SUCCESS;
1713	#endif
1714	return rc;
1715	}
1716
1717
1718	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSet} */
1719	static DECLCALLBACK(int) pdmR3DevHlp_TimerSet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire)
1720	{
1721	RT_NOREF(pDevIns, hTimer, uExpire);
1722
1723	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
1724	int rc = VERR_NOT_IMPLEMENTED;
1725	AssertFailed();
1726	#else
1727	int rc = VINF_SUCCESS;
1728	#endif
1729
1730	return rc;
1731	}
1732
1733
1734	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetFrequencyHint} */
1735	static DECLCALLBACK(int) pdmR3DevHlp_TimerSetFrequencyHint(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz)
1736	{
1737	RT_NOREF(pDevIns, hTimer, uHz);
1738
1739	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
1740	int rc = VERR_NOT_IMPLEMENTED;
1741	AssertFailed();
1742	#else
1743	int rc = VINF_SUCCESS;
1744	#endif
1745
1746	return rc;
1747	}
1748
1749
1750	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetMicro} */
1751	static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
1752	{
1753	RT_NOREF(pDevIns, hTimer, cMicrosToNext);
1754
1755	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
1756	int rc = VERR_NOT_IMPLEMENTED;
1757	AssertFailed();
1758	#else
1759	int rc = VINF_SUCCESS;
1760	#endif
1761	return rc;
1762	}
1763
1764
1765	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetMillies} */
1766	static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMillies(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext)
1767	{
1768	RT_NOREF(pDevIns, hTimer, cMilliesToNext);
1769
1770	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
1771	int rc = VERR_NOT_IMPLEMENTED;
1772	AssertFailed();
1773	#else
1774	int rc = VINF_SUCCESS;
1775	#endif
1776	return rc;
1777	}
1778
1779
1780	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetNano} */
1781	static DECLCALLBACK(int) pdmR3DevHlp_TimerSetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
1782	{
1783	RT_NOREF(pDevIns, hTimer, cNanosToNext);
1784
1785	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
1786	int rc = VERR_NOT_IMPLEMENTED;
1787	AssertFailed();
1788	#else
1789	int rc = VINF_SUCCESS;
1790	#endif
1791
1792	return rc;
1793	}
1794
1795
1796	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetRelative} */
1797	static DECLCALLBACK(int) pdmR3DevHlp_TimerSetRelative(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
1798	{
1799	RT_NOREF(pDevIns, hTimer, cTicksToNext, pu64Now);
1800
1801	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
1802	int rc = VERR_NOT_IMPLEMENTED;
1803	AssertFailed();
1804	#else
1805	int rc = VINF_SUCCESS;
1806	#endif
1807
1808	return rc;
1809	}
1810
1811
1812	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerStop} */
1813	static DECLCALLBACK(int) pdmR3DevHlp_TimerStop(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1814	{
1815	RT_NOREF(pDevIns, hTimer);
1816
1817	#if 1 /** @todo */
1818	int rc = VINF_SUCCESS;
1819	#else
1820	int rc = VERR_NOT_IMPLEMENTED;
1821	AssertFailed();
1822	#endif
1823
1824	return rc;
1825	}
1826
1827
1828	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerUnlockClock} */
1829	static DECLCALLBACK(void) pdmR3DevHlp_TimerUnlockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1830	{
1831	RT_NOREF(pDevIns, hTimer);
1832	AssertFailed();
1833	}
1834
1835
1836	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerUnlockClock2} */
1837	static DECLCALLBACK(void) pdmR3DevHlp_TimerUnlockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
1838	{
1839	RT_NOREF(pDevIns, hTimer, pCritSect);
1840	AssertFailed();
1841	}
1842
1843
1844	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetCritSect} */
1845	static DECLCALLBACK(int) pdmR3DevHlp_TimerSetCritSect(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
1846	{
1847	PDMDEV_ASSERT_DEVINS(pDevIns);
1848
1849	PTMTIMERR3 pTimer = (PTMTIMERR3)hTimer;
1850	pTimer->pCritSect = pCritSect;
1851	return VINF_SUCCESS;
1852	}
1853
1854
1855	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSave} */
1856	static DECLCALLBACK(int) pdmR3DevHlp_TimerSave(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
1857	{
1858	RT_NOREF(pDevIns, hTimer, pSSM);
1859	int rc = VERR_NOT_IMPLEMENTED;
1860	AssertFailed();
1861	return rc;
1862	}
1863
1864
1865	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerLoad} */
1866	static DECLCALLBACK(int) pdmR3DevHlp_TimerLoad(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
1867	{
1868	RT_NOREF(pDevIns, hTimer);
1869
1870	/** @name Saved state values (comes directly from TM.cpp)
1871	* @{ */
1872	#define TMTIMERSTATE_SAVED_PENDING_STOP 4
1873	#define TMTIMERSTATE_SAVED_PENDING_SCHEDULE 7
1874	/** @} */
1875
1876	/*
1877	* Load the state and validate it.
1878	*/
1879	uint8_t u8State;
1880	int rc = pdmR3DevHlp_SSMGetU8(pSSM, &u8State);
1881	if (RT_FAILURE(rc))
1882	return rc;
1883
1884	/* TMTIMERSTATE_SAVED_XXX: Workaround for accidental state shift in r47786 (2009-05-26 19:12:12). */
1885	if ( u8State == TMTIMERSTATE_SAVED_PENDING_STOP + 1
1886	\|\| u8State == TMTIMERSTATE_SAVED_PENDING_SCHEDULE + 1)
1887	u8State--;
1888
1889	if ( u8State != TMTIMERSTATE_SAVED_PENDING_STOP
1890	&& u8State != TMTIMERSTATE_SAVED_PENDING_SCHEDULE)
1891	{
1892	/AssertLogRelMsgFailed(("u8State=%d\n", u8State));/
1893	return VERR_TM_LOAD_STATE;
1894	}
1895
1896	if (u8State == TMTIMERSTATE_SAVED_PENDING_SCHEDULE)
1897	{
1898	/*
1899	* Load the expire time.
1900	*/
1901	uint64_t u64Expire;
1902	rc = pdmR3DevHlp_SSMGetU64(pSSM, &u64Expire);
1903	if (RT_FAILURE(rc))
1904	return rc;
1905
1906	/*
1907	* Set it.
1908	*/
1909	Log(("u8State=%d u64Expire=%llu\n", u8State, u64Expire));
1910	}
1911
1912	return VINF_SUCCESS;
1913	}
1914
1915
1916	/** @interface_method_impl{PDMDEVHLPR3,pfnTimerDestroy} */
1917	static DECLCALLBACK(int) pdmR3DevHlp_TimerDestroy(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
1918	{
1919	RT_NOREF(pDevIns, hTimer);
1920	int rc = VERR_NOT_IMPLEMENTED;
1921	AssertFailed();
1922	return rc;
1923	}
1924
1925
1926	static DECLCALLBACK(int) pdmR3DevHlp_TimerSkipLoad(PSSMHANDLE pSSM, bool *pfActive)
1927	{
1928	RT_NOREF(pSSM, pfActive);
1929	int rc = VERR_NOT_IMPLEMENTED;
1930	AssertFailed();
1931	return rc;
1932	}
1933
1934
1935	/** @interface_method_impl{PDMDEVHLPR3,pfnTMUtcNow} */
1936	static DECLCALLBACK(PRTTIMESPEC) pdmR3DevHlp_TMUtcNow(PPDMDEVINS pDevIns, PRTTIMESPEC pTime)
1937	{
1938	PDMDEV_ASSERT_DEVINS(pDevIns);
1939	LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: pTime=%p\n",
1940	pDevIns->pReg->szName, pDevIns->iInstance, pTime));
1941
1942	RT_NOREF(pDevIns, pTime);
1943	AssertFailed();
1944
1945	LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, RTTimeSpecGetNano(pTime)));
1946	return pTime;
1947	}
1948
1949
1950	static DECLCALLBACK(bool) pdmR3DevHlp_CFGMExists(PCFGMNODE pNode, const char *pszName)
1951	{
1952	RT_NOREF(pNode, pszName);
1953	AssertFailed();
1954	return false;
1955	}
1956
1957
1958	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryType(PCFGMNODE pNode, const char *pszName, PCFGMVALUETYPE penmType)
1959	{
1960	RT_NOREF(pNode, pszName, penmType);
1961	AssertFailed();
1962	return VERR_NOT_IMPLEMENTED;
1963	}
1964
1965
1966	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQuerySize(PCFGMNODE pNode, const char pszName, size_t pcb)
1967	{
1968	if (!pNode)
1969	return VERR_CFGM_NO_PARENT;
1970
1971	PCTSTDEVCFGITEM pCfgItem;
1972	int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTest->paCfgItems, pNode->pDut->pTest->cCfgItems, pszName, &pCfgItem);
1973	if (RT_SUCCESS(rc))
1974	{
1975	switch (pCfgItem->enmType)
1976	{
1977	case TSTDEVCFGITEMTYPE_INTEGER:
1978	*pcb = sizeof(uint64_t);
1979	break;
1980
1981	case TSTDEVCFGITEMTYPE_STRING:
1982	*pcb = strlen(pCfgItem->u.psz) + 1;
1983	break;
1984
1985	case TSTDEVCFGITEMTYPE_BYTES:
1986	AssertFailed();
1987	break;
1988
1989	default:
1990	rc = VERR_CFGM_IPE_1;
1991	AssertMsgFailed(("Invalid value type %d\n", pCfgItem->enmType));
1992	break;
1993	}
1994	}
1995	return rc;
1996	}
1997
1998
1999	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryInteger(PCFGMNODE pNode, const char pszName, uint64_t pu64)
2000	{
2001	if (!pNode)
2002	return VERR_CFGM_NO_PARENT;
2003
2004	PCTSTDEVCFGITEM pCfgItem;
2005	int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTest->paCfgItems, pNode->pDut->pTest->cCfgItems, pszName, &pCfgItem);
2006	if (RT_SUCCESS(rc))
2007	{
2008	if (pCfgItem->enmType == TSTDEVCFGITEMTYPE_INTEGER)
2009	*pu64 = (uint64_t)pCfgItem->u.i64;
2010	else
2011	rc = VERR_CFGM_NOT_INTEGER;
2012	}
2013
2014	return rc;
2015	}
2016
2017
2018	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryIntegerDef(PCFGMNODE pNode, const char pszName, uint64_t pu64, uint64_t u64Def)
2019	{
2020	int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, pu64);
2021	if (RT_FAILURE(rc))
2022	{
2023	*pu64 = u64Def;
2024	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
2025	rc = VINF_SUCCESS;
2026	}
2027
2028	return rc;
2029	}
2030
2031
2032	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryString(PCFGMNODE pNode, const char pszName, char pszString, size_t cchString)
2033	{
2034	if (!pNode)
2035	return VERR_CFGM_NO_PARENT;
2036
2037	PCTSTDEVCFGITEM pCfgItem;
2038	int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTest->paCfgItems, pNode->pDut->pTest->cCfgItems, pszName, &pCfgItem);
2039	if (RT_SUCCESS(rc))
2040	{
2041	switch (pCfgItem->enmType)
2042	{
2043	case TSTDEVCFGITEMTYPE_STRING:
2044	{
2045	size_t cchVal = strlen(pCfgItem->u.psz);
2046	if (cchString <= cchVal + 1)
2047	memcpy(pszString, pCfgItem->u.psz, cchVal);
2048	else
2049	rc = VERR_CFGM_NOT_ENOUGH_SPACE;
2050	break;
2051	}
2052	case TSTDEVCFGITEMTYPE_INTEGER:
2053	case TSTDEVCFGITEMTYPE_BYTES:
2054	default:
2055	rc = VERR_CFGM_IPE_1;
2056	AssertMsgFailed(("Invalid value type %d\n", pCfgItem->enmType));
2057	break;
2058	}
2059	}
2060	else
2061	rc = VERR_CFGM_VALUE_NOT_FOUND;
2062
2063	return rc;
2064	}
2065
2066
2067	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryStringDef(PCFGMNODE pNode, const char pszName, char pszString, size_t cchString, const char *pszDef)
2068	{
2069	int rc = pdmR3DevHlp_CFGMQueryString(pNode, pszName, pszString, cchString);
2070	if (RT_FAILURE(rc) && rc != VERR_CFGM_NOT_ENOUGH_SPACE)
2071	{
2072	size_t cchDef = strlen(pszDef);
2073	if (cchString > cchDef)
2074	{
2075	memcpy(pszString, pszDef, cchDef);
2076	memset(pszString + cchDef, 0, cchString - cchDef);
2077	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
2078	rc = VINF_SUCCESS;
2079	}
2080	else if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
2081	rc = VERR_CFGM_NOT_ENOUGH_SPACE;
2082	}
2083
2084	return rc;
2085	}
2086
2087
2088	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryBytes(PCFGMNODE pNode, const char pszName, void pvData, size_t cbData)
2089	{
2090	RT_NOREF(pNode, pszName, pvData, cbData);
2091
2092	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
2093	AssertFailed();
2094	return VERR_NOT_IMPLEMENTED;
2095	#else
2096	memset(pvData, 0, cbData);
2097	return VINF_SUCCESS;
2098	#endif
2099	}
2100
2101
2102	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU64(PCFGMNODE pNode, const char pszName, uint64_t pu64)
2103	{
2104	return pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, pu64);
2105	}
2106
2107
2108	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU64Def(PCFGMNODE pNode, const char pszName, uint64_t pu64, uint64_t u64Def)
2109	{
2110	return pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, pu64, u64Def);
2111	}
2112
2113
2114	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS64(PCFGMNODE pNode, const char pszName, int64_t pi64)
2115	{
2116	RT_NOREF(pNode, pszName, pi64);
2117	AssertFailed();
2118	return VERR_NOT_IMPLEMENTED;
2119	}
2120
2121
2122	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS64Def(PCFGMNODE pNode, const char pszName, int64_t pi64, int64_t i64Def)
2123	{
2124	RT_NOREF(pNode, pszName, pi64, i64Def);
2125	AssertFailed();
2126	return VERR_NOT_IMPLEMENTED;
2127	}
2128
2129
2130	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU32(PCFGMNODE pNode, const char pszName, uint32_t pu32)
2131	{
2132	uint64_t u64;
2133	int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
2134	if (RT_SUCCESS(rc))
2135	{
2136	if (!(u64 & UINT64_C(0xffffffff00000000)))
2137	*pu32 = (uint32_t)u64;
2138	else
2139	rc = VERR_CFGM_INTEGER_TOO_BIG;
2140	}
2141	return rc;
2142	}
2143
2144
2145	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU32Def(PCFGMNODE pNode, const char pszName, uint32_t pu32, uint32_t u32Def)
2146	{
2147	uint64_t u64;
2148	int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, u32Def);
2149	if (RT_SUCCESS(rc))
2150	{
2151	if (!(u64 & UINT64_C(0xffffffff00000000)))
2152	*pu32 = (uint32_t)u64;
2153	else
2154	rc = VERR_CFGM_INTEGER_TOO_BIG;
2155	}
2156	if (RT_FAILURE(rc))
2157	*pu32 = u32Def;
2158	return rc;
2159	}
2160
2161
2162	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS32(PCFGMNODE pNode, const char pszName, int32_t pi32)
2163	{
2164	uint64_t u64;
2165	int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
2166	if (RT_SUCCESS(rc))
2167	{
2168	if ( !(u64 & UINT64_C(0xffffffff80000000))
2169	\|\| (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
2170	*pi32 = (int32_t)u64;
2171	else
2172	rc = VERR_CFGM_INTEGER_TOO_BIG;
2173	}
2174	return rc;
2175	}
2176
2177
2178	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS32Def(PCFGMNODE pNode, const char pszName, int32_t pi32, int32_t i32Def)
2179	{
2180	uint64_t u64;
2181	int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, i32Def);
2182	if (RT_SUCCESS(rc))
2183	{
2184	if ( !(u64 & UINT64_C(0xffffffff80000000))
2185	\|\| (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
2186	*pi32 = (int32_t)u64;
2187	else
2188	rc = VERR_CFGM_INTEGER_TOO_BIG;
2189	}
2190	if (RT_FAILURE(rc))
2191	*pi32 = i32Def;
2192	return rc;
2193	}
2194
2195
2196	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU16(PCFGMNODE pNode, const char pszName, uint16_t pu16)
2197	{
2198	uint64_t u64;
2199	int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
2200	if (RT_SUCCESS(rc))
2201	{
2202	if (!(u64 & UINT64_C(0xffffffffffff0000)))
2203	*pu16 = (int16_t)u64;
2204	else
2205	rc = VERR_CFGM_INTEGER_TOO_BIG;
2206	}
2207	return rc;
2208	}
2209
2210
2211	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU16Def(PCFGMNODE pNode, const char pszName, uint16_t pu16, uint16_t u16Def)
2212	{
2213	uint64_t u64;
2214	int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, u16Def);
2215	if (RT_SUCCESS(rc))
2216	{
2217	if (!(u64 & UINT64_C(0xffffffffffff0000)))
2218	*pu16 = (int16_t)u64;
2219	else
2220	rc = VERR_CFGM_INTEGER_TOO_BIG;
2221	}
2222	if (RT_FAILURE(rc))
2223	*pu16 = u16Def;
2224	return rc;
2225	}
2226
2227
2228	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS16(PCFGMNODE pNode, const char pszName, int16_t pi16)
2229	{
2230	RT_NOREF(pNode, pszName, pi16);
2231	AssertFailed();
2232	return VERR_NOT_IMPLEMENTED;
2233	}
2234
2235
2236	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS16Def(PCFGMNODE pNode, const char pszName, int16_t pi16, int16_t i16Def)
2237	{
2238	RT_NOREF(pNode, pszName, pi16, i16Def);
2239	AssertFailed();
2240	return VERR_NOT_IMPLEMENTED;
2241	}
2242
2243
2244	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU8(PCFGMNODE pNode, const char pszName, uint8_t pu8)
2245	{
2246	uint64_t u64;
2247	int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
2248	if (RT_SUCCESS(rc))
2249	{
2250	if (!(u64 & UINT64_C(0xffffffffffffff00)))
2251	*pu8 = (uint8_t)u64;
2252	else
2253	rc = VERR_CFGM_INTEGER_TOO_BIG;
2254	}
2255	return rc;
2256	}
2257
2258
2259	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU8Def(PCFGMNODE pNode, const char pszName, uint8_t pu8, uint8_t u8Def)
2260	{
2261	uint64_t u64;
2262	int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, u8Def);
2263	if (RT_SUCCESS(rc))
2264	{
2265	if (!(u64 & UINT64_C(0xffffffffffffff00)))
2266	*pu8 = (uint8_t)u64;
2267	else
2268	rc = VERR_CFGM_INTEGER_TOO_BIG;
2269	}
2270	if (RT_FAILURE(rc))
2271	*pu8 = u8Def;
2272	return rc;
2273	}
2274
2275
2276	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS8(PCFGMNODE pNode, const char pszName, int8_t pi8)
2277	{
2278	RT_NOREF(pNode, pszName, pi8);
2279	AssertFailed();
2280	return VERR_NOT_IMPLEMENTED;
2281	}
2282
2283
2284	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS8Def(PCFGMNODE pNode, const char pszName, int8_t pi8, int8_t i8Def)
2285	{
2286	RT_NOREF(pNode, pszName, pi8, i8Def);
2287	AssertFailed();
2288	return VERR_NOT_IMPLEMENTED;
2289	}
2290
2291
2292	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryBool(PCFGMNODE pNode, const char pszName, bool pf)
2293	{
2294	uint64_t u64;
2295	int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
2296	if (RT_SUCCESS(rc))
2297	*pf = u64 ? true : false;
2298	return rc;
2299	}
2300
2301
2302	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryBoolDef(PCFGMNODE pNode, const char pszName, bool pf, bool fDef)
2303	{
2304	uint64_t u64;
2305	int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, fDef);
2306	*pf = u64 ? true : false;
2307	return rc;
2308	}
2309
2310
2311	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPort(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort)
2312	{
2313	RT_NOREF(pNode, pszName, pPort);
2314	AssertFailed();
2315	return VERR_NOT_IMPLEMENTED;
2316	}
2317
2318
2319	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPortDef(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort, RTIOPORT PortDef)
2320	{
2321	AssertCompileSize(RTIOPORT, 2);
2322	return pdmR3DevHlp_CFGMQueryU16Def(pNode, pszName, pPort, PortDef);
2323	}
2324
2325
2326	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryUInt(PCFGMNODE pNode, const char pszName, unsigned int pu)
2327	{
2328	RT_NOREF(pNode, pszName, pu);
2329	AssertFailed();
2330	return VERR_NOT_IMPLEMENTED;
2331	}
2332
2333
2334	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryUIntDef(PCFGMNODE pNode, const char pszName, unsigned int pu, unsigned int uDef)
2335	{
2336	RT_NOREF(pNode, pszName, pu, uDef);
2337	AssertFailed();
2338	return VERR_NOT_IMPLEMENTED;
2339	}
2340
2341
2342	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQuerySInt(PCFGMNODE pNode, const char pszName, signed int pi)
2343	{
2344	RT_NOREF(pNode, pszName, pi);
2345	AssertFailed();
2346	return VERR_NOT_IMPLEMENTED;
2347	}
2348
2349
2350	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQuerySIntDef(PCFGMNODE pNode, const char pszName, signed int pi, signed int iDef)
2351	{
2352	RT_NOREF(pNode, pszName, pi, iDef);
2353	AssertFailed();
2354	return VERR_NOT_IMPLEMENTED;
2355	}
2356
2357
2358	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPtr(PCFGMNODE pNode, const char pszName, void *ppv)
2359	{
2360	uint64_t u64;
2361	int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
2362	if (RT_SUCCESS(rc))
2363	{
2364	uintptr_t u = (uintptr_t)u64;
2365	if (u64 == u)
2366	ppv = (void )u;
2367	else
2368	rc = VERR_CFGM_INTEGER_TOO_BIG;
2369	}
2370	return rc;
2371	}
2372
2373
2374	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPtrDef(PCFGMNODE pNode, const char pszName, void ppv, void pvDef)
2375	{
2376	RT_NOREF(pNode, pszName, ppv, pvDef);
2377	AssertFailed();
2378	return VERR_NOT_IMPLEMENTED;
2379	}
2380
2381
2382	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtr(PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr)
2383	{
2384	RT_NOREF(pNode, pszName, pGCPtr);
2385	AssertFailed();
2386	return VERR_NOT_IMPLEMENTED;
2387	}
2388
2389
2390	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrDef(PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr, RTGCPTR GCPtrDef)
2391	{
2392	RT_NOREF(pNode, pszName, pGCPtr, GCPtrDef);
2393	AssertFailed();
2394	return VERR_NOT_IMPLEMENTED;
2395	}
2396
2397
2398	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrU(PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr)
2399	{
2400	RT_NOREF(pNode, pszName, pGCPtr);
2401	AssertFailed();
2402	return VERR_NOT_IMPLEMENTED;
2403	}
2404
2405
2406	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrUDef(PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr, RTGCUINTPTR GCPtrDef)
2407	{
2408	RT_NOREF(pNode, pszName, pGCPtr, GCPtrDef);
2409	AssertFailed();
2410	return VERR_NOT_IMPLEMENTED;
2411	}
2412
2413
2414	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrS(PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr)
2415	{
2416	RT_NOREF(pNode, pszName, pGCPtr);
2417	AssertFailed();
2418	return VERR_NOT_IMPLEMENTED;
2419	}
2420
2421
2422	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrSDef(PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr, RTGCINTPTR GCPtrDef)
2423	{
2424	RT_NOREF(pNode, pszName, pGCPtr, GCPtrDef);
2425	AssertFailed();
2426	return VERR_NOT_IMPLEMENTED;
2427	}
2428
2429
2430	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryStringAlloc(PCFGMNODE pNode, const char pszName, char *ppszString)
2431	{
2432	RT_NOREF(pNode, pszName, ppszString);
2433	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
2434	AssertFailed();
2435	return VERR_NOT_IMPLEMENTED;
2436	#else
2437	return VERR_CFGM_VALUE_NOT_FOUND;
2438	#endif
2439	}
2440
2441
2442	static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryStringAllocDef(PCFGMNODE pNode, const char pszName, char ppszString, const char pszDef)
2443	{
2444	RT_NOREF(pNode, pszName, ppszString, pszDef);
2445	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
2446	AssertFailed();
2447	return VERR_NOT_IMPLEMENTED;
2448	#else
2449	return VERR_CFGM_VALUE_NOT_FOUND;
2450	#endif
2451	}
2452
2453
2454	static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetParent(PCFGMNODE pNode)
2455	{
2456	RT_NOREF(pNode);
2457	AssertFailed();
2458	return NULL;
2459	}
2460
2461
2462	static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetChild(PCFGMNODE pNode, const char *pszPath)
2463	{
2464	RT_NOREF(pNode, pszPath);
2465	AssertFailed();
2466	return NULL;
2467	}
2468
2469
2470	static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetChildF(PCFGMNODE pNode, const char *pszPathFormat, ...) RT_IPRT_FORMAT_ATTR(2, 3)
2471	{
2472	RT_NOREF(pNode, pszPathFormat);
2473	AssertFailed();
2474	return NULL;
2475	}
2476
2477
2478	static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetChildFV(PCFGMNODE pNode, const char *pszPathFormat, va_list Args) RT_IPRT_FORMAT_ATTR(3, 0)
2479	{
2480	RT_NOREF(pNode, pszPathFormat, Args);
2481	AssertFailed();
2482	return NULL;
2483	}
2484
2485
2486	static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetFirstChild(PCFGMNODE pNode)
2487	{
2488	RT_NOREF(pNode);
2489	AssertFailed();
2490	return NULL;
2491	}
2492
2493
2494	static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetNextChild(PCFGMNODE pCur)
2495	{
2496	RT_NOREF(pCur);
2497	AssertFailed();
2498	return NULL;
2499	}
2500
2501
2502	static DECLCALLBACK(int) pdmR3DevHlp_CFGMGetName(PCFGMNODE pCur, char *pszName, size_t cchName)
2503	{
2504	RT_NOREF(pCur, pszName, cchName);
2505	AssertFailed();
2506	return VERR_NOT_IMPLEMENTED;
2507	}
2508
2509
2510	static DECLCALLBACK(size_t) pdmR3DevHlp_CFGMGetNameLen(PCFGMNODE pCur)
2511	{
2512	RT_NOREF(pCur);
2513	AssertFailed();
2514	return 0;
2515	}
2516
2517
2518	static DECLCALLBACK(bool) pdmR3DevHlp_CFGMAreChildrenValid(PCFGMNODE pNode, const char *pszzValid)
2519	{
2520	RT_NOREF(pNode, pszzValid);
2521	AssertFailed();
2522	return false;
2523	}
2524
2525
2526	static DECLCALLBACK(PCFGMLEAF) pdmR3DevHlp_CFGMGetFirstValue(PCFGMNODE pCur)
2527	{
2528	RT_NOREF(pCur);
2529	AssertFailed();
2530	return NULL;
2531	}
2532
2533
2534	static DECLCALLBACK(PCFGMLEAF) pdmR3DevHlp_CFGMGetNextValue(PCFGMLEAF pCur)
2535	{
2536	RT_NOREF(pCur);
2537	AssertFailed();
2538	return NULL;
2539	}
2540
2541
2542	static DECLCALLBACK(int) pdmR3DevHlp_CFGMGetValueName(PCFGMLEAF pCur, char *pszName, size_t cchName)
2543	{
2544	RT_NOREF(pCur, pszName, cchName);
2545	AssertFailed();
2546	return VERR_NOT_IMPLEMENTED;
2547	}
2548
2549
2550	static DECLCALLBACK(size_t) pdmR3DevHlp_CFGMGetValueNameLen(PCFGMLEAF pCur)
2551	{
2552	RT_NOREF(pCur);
2553	AssertFailed();
2554	return 0;
2555	}
2556
2557
2558	static DECLCALLBACK(CFGMVALUETYPE) pdmR3DevHlp_CFGMGetValueType(PCFGMLEAF pCur)
2559	{
2560	RT_NOREF(pCur);
2561	AssertFailed();
2562	return CFGMVALUETYPE_INTEGER;
2563	}
2564
2565
2566	static DECLCALLBACK(bool) pdmR3DevHlp_CFGMAreValuesValid(PCFGMNODE pNode, const char *pszzValid)
2567	{
2568	if (pNode && pNode->pDut->pTest->paCfgItems)
2569	{
2570	PCTSTDEVCFGITEM pDevCfgItem = pNode->pDut->pTest->paCfgItems;
2571	for (uint32_t i = 0; i < pNode->pDut->pTest->cCfgItems; i++)
2572	{
2573	size_t cchKey = strlen(pDevCfgItem->pszKey);
2574
2575	/* search pszzValid for the name */
2576	const char *psz = pszzValid;
2577	while (*psz)
2578	{
2579	size_t cch = strlen(psz);
2580	if ( cch == cchKey
2581	&& !memcmp(psz, pDevCfgItem->pszKey, cch))
2582	break;
2583
2584	/* next */
2585	psz += cch + 1;
2586	}
2587
2588	/* if at end of pszzValid we didn't find it => failure */
2589	if (!*psz)
2590	return false;
2591
2592	pDevCfgItem++;
2593	}
2594	}
2595
2596	return true;
2597	}
2598
2599
2600	static DECLCALLBACK(int) pdmR3DevHlp_CFGMValidateConfig(PCFGMNODE pNode, const char *pszNode,
2601	const char pszValidValues, const char pszValidNodes,
2602	const char *pszWho, uint32_t uInstance)
2603	{
2604	RT_NOREF(pNode, pszNode, pszValidValues, pszValidNodes, pszWho, uInstance);
2605	#if 1
2606	return VINF_SUCCESS;
2607	#else
2608	AssertFailed();
2609	return VERR_NOT_IMPLEMENTED;
2610	#endif
2611	}
2612
2613
2614	/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGet} */
2615	static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGet(PPDMDEVINS pDevIns)
2616	{
2617	PDMDEV_ASSERT_DEVINS(pDevIns);
2618	LogFlow(("pdmR3DevHlp_TMTimeVirtGet: caller='%s'/%d\n",
2619	pDevIns->pReg->szName, pDevIns->iInstance));
2620
2621	uint64_t u64Time = 0;
2622	AssertFailed();
2623
2624	LogFlow(("pdmR3DevHlp_TMTimeVirtGet: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Time));
2625	return u64Time;
2626	}
2627
2628
2629	/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGetFreq} */
2630	static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGetFreq(PPDMDEVINS pDevIns)
2631	{
2632	PDMDEV_ASSERT_DEVINS(pDevIns);
2633	LogFlow(("pdmR3DevHlp_TMTimeVirtGetFreq: caller='%s'/%d\n",
2634	pDevIns->pReg->szName, pDevIns->iInstance));
2635
2636	uint64_t u64Freq = 0;
2637	AssertFailed();
2638
2639	LogFlow(("pdmR3DevHlp_TMTimeVirtGetFreq: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Freq));
2640	return u64Freq;
2641	}
2642
2643
2644	/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGetNano} */
2645	static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGetNano(PPDMDEVINS pDevIns)
2646	{
2647	PDMDEV_ASSERT_DEVINS(pDevIns);
2648	LogFlow(("pdmR3DevHlp_TMTimeVirtGetNano: caller='%s'/%d\n",
2649	pDevIns->pReg->szName, pDevIns->iInstance));
2650
2651	uint64_t u64Nano = 0;
2652	AssertFailed();
2653
2654	LogFlow(("pdmR3DevHlp_TMTimeVirtGetNano: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Nano));
2655	return u64Nano;
2656	}
2657
2658
2659	/** @interface_method_impl{PDMDEVHLPR3,pfnGetSupDrvSession} */
2660	static DECLCALLBACK(PSUPDRVSESSION) pdmR3DevHlp_GetSupDrvSession(PPDMDEVINS pDevIns)
2661	{
2662	PDMDEV_ASSERT_DEVINS(pDevIns);
2663	LogFlow(("pdmR3DevHlp_GetSupDrvSession: caller='%s'/%d\n",
2664	pDevIns->pReg->szName, pDevIns->iInstance));
2665
2666	PSUPDRVSESSION pSession = NIL_RTR0PTR;
2667	AssertFailed();
2668
2669	LogFlow(("pdmR3DevHlp_GetSupDrvSession: caller='%s'/%d: returns %#p\n", pDevIns->pReg->szName, pDevIns->iInstance, pSession));
2670	return pSession;
2671	}
2672
2673
2674	/** @interface_method_impl{PDMDEVHLPR3,pfnQueryGenericUserObject} */
2675	static DECLCALLBACK(void *) pdmR3DevHlp_QueryGenericUserObject(PPDMDEVINS pDevIns, PCRTUUID pUuid)
2676	{
2677	PDMDEV_ASSERT_DEVINS(pDevIns);
2678	LogFlow(("pdmR3DevHlp_QueryGenericUserObject: caller='%s'/%d: pUuid=%p:%RTuuid\n",
2679	pDevIns->pReg->szName, pDevIns->iInstance, pUuid, pUuid));
2680
2681	#if defined(DEBUG_bird) \|\| defined(DEBUG_ramshankar) \|\| defined(DEBUG_sunlover) \|\| defined(DEBUG_michael) \|\| defined(DEBUG_andy)
2682	AssertMsgFailed(("'%s' wants %RTuuid - external only interface!\n", pDevIns->pReg->szName, pUuid));
2683	#endif
2684
2685	void *pvRet = NULL;
2686	AssertFailed();
2687
2688	LogRel(("pdmR3DevHlp_QueryGenericUserObject: caller='%s'/%d: returns %#p for %RTuuid\n",
2689	pDevIns->pReg->szName, pDevIns->iInstance, pvRet, pUuid));
2690	return pvRet;
2691	}
2692
2693
2694	/** @interface_method_impl{PDMDEVHLPR3,pfnPGMHandlerPhysicalTypeRegister} */
2695	static DECLCALLBACK(int) pdmR3DevHlp_PGMHandlerPhysicalTypeRegister(PPDMDEVINS pDevIns, PGMPHYSHANDLERKIND enmKind,
2696	R3PTRTYPE(PFNPGMPHYSHANDLER) pfnHandlerR3,
2697	const char pszHandlerR0, const char pszPfHandlerR0,
2698	const char pszHandlerRC, const char pszPfHandlerRC,
2699	const char *pszDesc, PPGMPHYSHANDLERTYPE phType)
2700	{
2701	PDMDEV_ASSERT_DEVINS(pDevIns);
2702	RT_NOREF(enmKind, pfnHandlerR3, pszHandlerR0, pszPfHandlerR0, pszHandlerRC, pszPfHandlerRC, pszDesc, phType);
2703	LogFlow(("pdmR3DevHlp_PGMHandlerPhysicalTypeRegister: caller='%s'/%d: enmKind=%d pfnHandlerR3=%p pszHandlerR0=%p:{%s} pszPfHandlerR0=%p:{%s} pszHandlerRC=%p:{%s} pszPfHandlerRC=%p:{%s} pszDesc=%p:{%s} phType=%p\n",
2704	pDevIns->pReg->szName, pDevIns->iInstance, pfnHandlerR3,
2705	pszHandlerR0, pszHandlerR0, pszPfHandlerR0, pszPfHandlerR0,
2706	pszHandlerRC, pszHandlerRC, pszPfHandlerRC, pszPfHandlerRC,
2707	pszDesc, pszDesc, phType));
2708
2709	int rc = VERR_NOT_IMPLEMENTED;
2710	AssertFailed();
2711
2712	LogRel(("pdmR3DevHlp_PGMHandlerPhysicalTypeRegister: caller='%s'/%d: returns %Rrc\n",
2713	pDevIns->pReg->szName, pDevIns->iInstance, rc));
2714	return rc;
2715	}
2716
2717
2718	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysRead} */
2719	static DECLCALLBACK(int) pdmR3DevHlp_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
2720	{
2721	PDMDEV_ASSERT_DEVINS(pDevIns);
2722	LogFlow(("pdmR3DevHlp_PhysRead: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbRead=%#x\n",
2723	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
2724
2725	VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;;
2726	AssertFailed();
2727
2728	Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
2729	return VBOXSTRICTRC_VAL(rcStrict);
2730	}
2731
2732
2733	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWrite} */
2734	static DECLCALLBACK(int) pdmR3DevHlp_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
2735	{
2736	PDMDEV_ASSERT_DEVINS(pDevIns);
2737	LogFlow(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbWrite=%#x\n",
2738	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
2739
2740	VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;;
2741	AssertFailed();
2742
2743	Log(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
2744	return VBOXSTRICTRC_VAL(rcStrict);
2745	}
2746
2747
2748	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtr} */
2749	static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtr(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, void **ppv, PPGMPAGEMAPLOCK pLock)
2750	{
2751	PDMDEV_ASSERT_DEVINS(pDevIns);
2752	LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
2753	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
2754	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
2755
2756	int rc = VERR_NOT_IMPLEMENTED;;
2757	AssertFailed();
2758
2759	Log(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2760	return rc;
2761	}
2762
2763
2764	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtrReadOnly} */
2765	static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, const void **ppv, PPGMPAGEMAPLOCK pLock)
2766	{
2767	PDMDEV_ASSERT_DEVINS(pDevIns);
2768	LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
2769	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
2770	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
2771
2772	int rc = VERR_NOT_IMPLEMENTED;;
2773	AssertFailed();
2774
2775	Log(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2776	return rc;
2777	}
2778
2779
2780	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReleasePageMappingLock} */
2781	static DECLCALLBACK(void) pdmR3DevHlp_PhysReleasePageMappingLock(PPDMDEVINS pDevIns, PPGMPAGEMAPLOCK pLock)
2782	{
2783	PDMDEV_ASSERT_DEVINS(pDevIns);
2784	LogFlow(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: pLock=%p\n",
2785	pDevIns->pReg->szName, pDevIns->iInstance, pLock));
2786
2787	AssertFailed();
2788
2789	Log(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
2790	}
2791
2792
2793	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysBulkGCPhys2CCPtr} */
2794	static DECLCALLBACK(int) pdmR3DevHlp_PhysBulkGCPhys2CCPtr(PPDMDEVINS pDevIns, uint32_t cPages, PCRTGCPHYS paGCPhysPages,
2795	uint32_t fFlags, void **papvPages, PPGMPAGEMAPLOCK paLocks)
2796	{
2797	PDMDEV_ASSERT_DEVINS(pDevIns);
2798	LogFlow(("pdmR3DevHlp_PhysBulkGCPhys2CCPtr: caller='%s'/%d: cPages=%#x paGCPhysPages=%p (%RGp,..) fFlags=%#x papvPages=%p paLocks=%p\n",
2799	pDevIns->pReg->szName, pDevIns->iInstance, cPages, paGCPhysPages, paGCPhysPages[0], fFlags, papvPages, paLocks));
2800	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
2801	AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
2802
2803	int rc = VERR_NOT_IMPLEMENTED;;
2804	AssertFailed();
2805
2806	Log(("pdmR3DevHlp_PhysBulkGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2807	return rc;
2808	}
2809
2810
2811	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysBulkGCPhys2CCPtrReadOnly} */
2812	static DECLCALLBACK(int) pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, uint32_t cPages, PCRTGCPHYS paGCPhysPages,
2813	uint32_t fFlags, const void **papvPages, PPGMPAGEMAPLOCK paLocks)
2814	{
2815	PDMDEV_ASSERT_DEVINS(pDevIns);
2816	LogFlow(("pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly: caller='%s'/%d: cPages=%#x paGCPhysPages=%p (%RGp,...) fFlags=%#x papvPages=%p paLocks=%p\n",
2817	pDevIns->pReg->szName, pDevIns->iInstance, cPages, paGCPhysPages, paGCPhysPages[0], fFlags, papvPages, paLocks));
2818	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
2819	AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
2820
2821	int rc = VERR_NOT_IMPLEMENTED;;
2822	AssertFailed();
2823
2824	Log(("pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2825	return rc;
2826	}
2827
2828
2829	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysBulkReleasePageMappingLocks} */
2830	static DECLCALLBACK(void) pdmR3DevHlp_PhysBulkReleasePageMappingLocks(PPDMDEVINS pDevIns, uint32_t cPages, PPGMPAGEMAPLOCK paLocks)
2831	{
2832	PDMDEV_ASSERT_DEVINS(pDevIns);
2833	LogFlow(("pdmR3DevHlp_PhysBulkReleasePageMappingLocks: caller='%s'/%d: cPages=%#x paLocks=%p\n",
2834	pDevIns->pReg->szName, pDevIns->iInstance, cPages, paLocks));
2835	Assert(cPages > 0);
2836
2837	AssertFailed();
2838
2839	Log(("pdmR3DevHlp_PhysBulkReleasePageMappingLocks: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
2840	}
2841
2842
2843	/** @interface_method_impl{PDMDEVHLPR3,pfnCpuGetGuestMicroarch} */
2844	static DECLCALLBACK(CPUMMICROARCH) pdmR3DevHlp_CpuGetGuestMicroarch(PPDMDEVINS pDevIns)
2845	{
2846	PDMDEV_ASSERT_DEVINS(pDevIns);
2847	LogFlow(("pdmR3DevHlp_CpuGetGuestMicroarch: caller='%s'/%d\n",
2848	pDevIns->pReg->szName, pDevIns->iInstance));
2849
2850	CPUMMICROARCH enmMicroarch = kCpumMicroarch_Intel_P6;
2851
2852	Log(("pdmR3DevHlp_CpuGetGuestMicroarch: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, enmMicroarch));
2853	return enmMicroarch;
2854	}
2855
2856
2857	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReadGCVirt} */
2858	static DECLCALLBACK(int) pdmR3DevHlp_PhysReadGCVirt(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb)
2859	{
2860	PDMDEV_ASSERT_DEVINS(pDevIns);
2861	LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: pvDst=%p GCVirt=%RGv cb=%#x\n",
2862	pDevIns->pReg->szName, pDevIns->iInstance, pvDst, GCVirtSrc, cb));
2863
2864	int rc = VERR_NOT_IMPLEMENTED;;
2865	AssertFailed();
2866
2867	LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2868
2869	return rc;
2870	}
2871
2872
2873	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWriteGCVirt} */
2874	static DECLCALLBACK(int) pdmR3DevHlp_PhysWriteGCVirt(PPDMDEVINS pDevIns, RTGCPTR GCVirtDst, const void *pvSrc, size_t cb)
2875	{
2876	PDMDEV_ASSERT_DEVINS(pDevIns);
2877	LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: GCVirtDst=%RGv pvSrc=%p cb=%#x\n",
2878	pDevIns->pReg->szName, pDevIns->iInstance, GCVirtDst, pvSrc, cb));
2879
2880	int rc = VERR_NOT_IMPLEMENTED;;
2881	AssertFailed();
2882
2883	LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2884
2885	return rc;
2886	}
2887
2888
2889	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPtr2GCPhys} */
2890	static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPtr2GCPhys(PPDMDEVINS pDevIns, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
2891	{
2892	PDMDEV_ASSERT_DEVINS(pDevIns);
2893	LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: GCPtr=%RGv pGCPhys=%p\n",
2894	pDevIns->pReg->szName, pDevIns->iInstance, GCPtr, pGCPhys));
2895
2896	int rc = VERR_NOT_IMPLEMENTED;
2897	AssertFailed();
2898
2899	LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: returns %Rrc pGCPhys=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, pGCPhys));
2900
2901	return rc;
2902	}
2903
2904
2905	/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAlloc} */
2906	static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAlloc(PPDMDEVINS pDevIns, size_t cb)
2907	{
2908	PDMDEV_ASSERT_DEVINS(pDevIns);
2909	LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
2910
2911	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
2912	void *pv = NULL;
2913	AssertFailed();
2914	#else
2915	void *pv = RTMemAlloc(cb);
2916	#endif
2917
2918	LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
2919	return pv;
2920	}
2921
2922
2923	/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAllocZ} */
2924	static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAllocZ(PPDMDEVINS pDevIns, size_t cb)
2925	{
2926	PDMDEV_ASSERT_DEVINS(pDevIns);
2927	LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
2928
2929	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
2930	void *pv = NULL;
2931	AssertFailed();
2932	#else
2933	void *pv = RTMemAllocZ(cb);
2934	#endif
2935
2936	LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
2937	return pv;
2938	}
2939
2940
2941	/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapFree} */
2942	static DECLCALLBACK(void) pdmR3DevHlp_MMHeapFree(PPDMDEVINS pDevIns, void *pv)
2943	{
2944	PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
2945	LogFlow(("pdmR3DevHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
2946
2947	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
2948	PTSTDEVMMHEAPALLOC pHeapAlloc = (PTSTDEVMMHEAPALLOC)((uint8_t *)pv - RT_UOFFSETOF(TSTDEVMMHEAPALLOC, abAlloc[0]));
2949	PTSTDEVDUTINT pThis = pHeapAlloc->pDut;
2950
2951	tstDevDutLockExcl(pThis);
2952	RTListNodeRemove(&pHeapAlloc->NdMmHeap);
2953	tstDevDutUnlockExcl(pThis);
2954
2955	/* Poison */
2956	memset(&pHeapAlloc->abAlloc[0], 0xfc, pHeapAlloc->cbAlloc);
2957	RTMemFree(pHeapAlloc);
2958	#else
2959	RTMemFree(pv);
2960	#endif
2961
2962	LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
2963	}
2964
2965
2966	/** @interface_method_impl{PDMDEVHLPR3,pfnVMState} */
2967	static DECLCALLBACK(VMSTATE) pdmR3DevHlp_VMState(PPDMDEVINS pDevIns)
2968	{
2969	PDMDEV_ASSERT_DEVINS(pDevIns);
2970
2971	VMSTATE enmVMState = VMSTATE_CREATING;
2972	AssertFailed();
2973
2974	LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %d\n", pDevIns->pReg->szName, pDevIns->iInstance,
2975	enmVMState));
2976	return enmVMState;
2977	}
2978
2979
2980	/** @interface_method_impl{PDMDEVHLPR3,pfnVMTeleportedAndNotFullyResumedYet} */
2981	static DECLCALLBACK(bool) pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet(PPDMDEVINS pDevIns)
2982	{
2983	PDMDEV_ASSERT_DEVINS(pDevIns);
2984
2985	bool fRc = false;
2986
2987	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
2988	AssertFailed();
2989	#endif
2990
2991	LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szName, pDevIns->iInstance,
2992	fRc));
2993	return fRc;
2994	}
2995
2996
2997	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetError} */
2998	static DECLCALLBACK(int) pdmR3DevHlp_VMSetError(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
2999	{
3000	PDMDEV_ASSERT_DEVINS(pDevIns);
3001
3002	RT_NOREF(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat);
3003	AssertFailed();
3004
3005	return VERR_NOT_IMPLEMENTED;
3006	}
3007
3008
3009	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetErrorV} */
3010	static DECLCALLBACK(int) pdmR3DevHlp_VMSetErrorV(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
3011	{
3012	PDMDEV_ASSERT_DEVINS(pDevIns);
3013
3014	RT_NOREF(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
3015	AssertFailed();
3016
3017	return VERR_NOT_IMPLEMENTED;
3018	}
3019
3020
3021	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeError} */
3022	static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeError(PPDMDEVINS pDevIns, uint32_t fFlags, const char pszErrorId, const char pszFormat, ...)
3023	{
3024	PDMDEV_ASSERT_DEVINS(pDevIns);
3025
3026	RT_NOREF(pDevIns, fFlags, pszErrorId, pszFormat);
3027	int rc = VERR_NOT_IMPLEMENTED;
3028	AssertFailed();
3029
3030	return rc;
3031	}
3032
3033
3034	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeErrorV} */
3035	static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeErrorV(PPDMDEVINS pDevIns, uint32_t fFlags, const char pszErrorId, const char pszFormat, va_list va)
3036	{
3037	PDMDEV_ASSERT_DEVINS(pDevIns);
3038
3039	RT_NOREF(pDevIns, fFlags, pszErrorId, pszFormat, va);
3040	int rc = VERR_NOT_IMPLEMENTED;
3041	AssertFailed();
3042
3043	return rc;
3044	}
3045
3046
3047	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFStopV} */
3048	static DECLCALLBACK(int) pdmR3DevHlp_DBGFStopV(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction, const char *pszFormat, va_list args)
3049	{
3050	PDMDEV_ASSERT_DEVINS(pDevIns);
3051	#ifdef LOG_ENABLED
3052	va_list va2;
3053	va_copy(va2, args);
3054	LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: pszFile=%p:{%s} iLine=%d pszFunction=%p:{%s} pszFormat=%p:{%s} (%N)\n",
3055	pDevIns->pReg->szName, pDevIns->iInstance, pszFile, pszFile, iLine, pszFunction, pszFunction, pszFormat, pszFormat, pszFormat, &va2));
3056	va_end(va2);
3057	#endif
3058
3059	int rc = VERR_NOT_IMPLEMENTED;
3060	AssertFailed();
3061
3062	LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3063	return rc;
3064	}
3065
3066
3067	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFInfoRegister} */
3068	static DECLCALLBACK(int) pdmR3DevHlp_DBGFInfoRegister(PPDMDEVINS pDevIns, const char pszName, const char pszDesc, PFNDBGFHANDLERDEV pfnHandler)
3069	{
3070	PDMDEV_ASSERT_DEVINS(pDevIns);
3071	LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
3072	pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
3073
3074	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3075	int rc = VERR_NOT_IMPLEMENTED;
3076	AssertFailed();
3077	#else
3078	int rc = VINF_SUCCESS;
3079	#endif
3080
3081
3082	LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3083	return rc;
3084	}
3085
3086
3087	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFInfoRegisterArgv} */
3088	static DECLCALLBACK(int) pdmR3DevHlp_DBGFInfoRegisterArgv(PPDMDEVINS pDevIns, const char pszName, const char pszDesc, PFNDBGFINFOARGVDEV pfnHandler)
3089	{
3090	PDMDEV_ASSERT_DEVINS(pDevIns);
3091	LogFlow(("pdmR3DevHlp_DBGFInfoRegisterArgv: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
3092	pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
3093
3094	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3095	int rc = VERR_NOT_IMPLEMENTED;
3096	AssertFailed();
3097	#else
3098	int rc = VINF_SUCCESS;
3099	#endif
3100
3101	LogFlow(("pdmR3DevHlp_DBGFInfoRegisterArgv: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3102	return rc;
3103	}
3104
3105
3106	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFRegRegister} */
3107	static DECLCALLBACK(int) pdmR3DevHlp_DBGFRegRegister(PPDMDEVINS pDevIns, PCDBGFREGDESC paRegisters)
3108	{
3109	PDMDEV_ASSERT_DEVINS(pDevIns);
3110	LogFlow(("pdmR3DevHlp_DBGFRegRegister: caller='%s'/%d: paRegisters=%p\n",
3111	pDevIns->pReg->szName, pDevIns->iInstance, paRegisters));
3112
3113	int rc = VERR_NOT_IMPLEMENTED;
3114	AssertFailed();
3115
3116	LogFlow(("pdmR3DevHlp_DBGFRegRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3117	return rc;
3118	}
3119
3120
3121	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFTraceBuf} */
3122	static DECLCALLBACK(RTTRACEBUF) pdmR3DevHlp_DBGFTraceBuf(PPDMDEVINS pDevIns)
3123	{
3124	PDMDEV_ASSERT_DEVINS(pDevIns);
3125	RTTRACEBUF hTraceBuf = NIL_RTTRACEBUF;
3126	AssertFailed();
3127	LogFlow(("pdmR3DevHlp_DBGFTraceBuf: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, hTraceBuf));
3128	return hTraceBuf;
3129	}
3130
3131
3132	/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegister} */
3133	static DECLCALLBACK(void) pdmR3DevHlp_STAMRegister(PPDMDEVINS pDevIns, void pvSample, STAMTYPE enmType, const char pszName,
3134	STAMUNIT enmUnit, const char *pszDesc)
3135	{
3136	PDMDEV_ASSERT_DEVINS(pDevIns);
3137
3138	RT_NOREF(pDevIns, pvSample, enmType, pszName, enmUnit, pszDesc);
3139
3140	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3141	AssertFailed();
3142	#endif
3143	}
3144
3145
3146	/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegisterV} */
3147	static DECLCALLBACK(void) pdmR3DevHlp_STAMRegisterV(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
3148	STAMUNIT enmUnit, const char pszDesc, const char pszName, va_list args)
3149	{
3150	PDMDEV_ASSERT_DEVINS(pDevIns);
3151
3152	RT_NOREF(pDevIns, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
3153
3154	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3155	AssertFailed();
3156	#endif
3157	}
3158
3159
3160	/**
3161	* @interface_method_impl{PDMDEVHLPR3,pfnPCIRegister}
3162	*/
3163	static DECLCALLBACK(int) pdmR3DevHlp_PCIRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t fFlags,
3164	uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName)
3165	{
3166	PDMDEV_ASSERT_DEVINS(pDevIns);
3167	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: pPciDev=%p:{.config={%#.256Rhxs} fFlags=%#x uPciDevNo=%#x uPciFunNo=%#x pszName=%p:{%s}\n",
3168	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->abConfig, fFlags, uPciDevNo, uPciFunNo, pszName, pszName ? pszName : ""));
3169
3170	/*
3171	* Validate input.
3172	*/
3173	AssertLogRelMsgReturn(pDevIns->pReg->cMaxPciDevices > 0,
3174	("'%s'/%d: cMaxPciDevices is 0\n", pDevIns->pReg->szName, pDevIns->iInstance),
3175	VERR_WRONG_ORDER);
3176	AssertLogRelMsgReturn(RT_VALID_PTR(pPciDev),
3177	("'%s'/%d: Invalid pPciDev value: %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pPciDev),
3178	VERR_INVALID_POINTER);
3179	AssertLogRelMsgReturn(PDMPciDevGetVendorId(pPciDev),
3180	("'%s'/%d: Vendor ID is not set!\n", pDevIns->pReg->szName, pDevIns->iInstance),
3181	VERR_INVALID_POINTER);
3182	AssertLogRelMsgReturn( uPciDevNo < 32
3183	\|\| uPciDevNo == PDMPCIDEVREG_DEV_NO_FIRST_UNUSED
3184	\|\| uPciDevNo == PDMPCIDEVREG_DEV_NO_SAME_AS_PREV,
3185	("'%s'/%d: Invalid PCI device number: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, uPciDevNo),
3186	VERR_INVALID_PARAMETER);
3187	AssertLogRelMsgReturn( uPciFunNo < 8
3188	\|\| uPciFunNo == PDMPCIDEVREG_FUN_NO_FIRST_UNUSED,
3189	("'%s'/%d: Invalid PCI funcion number: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, uPciFunNo),
3190	VERR_INVALID_PARAMETER);
3191	AssertLogRelMsgReturn(!(fFlags & ~PDMPCIDEVREG_F_VALID_MASK),
3192	("'%s'/%d: Invalid flags: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, fFlags),
3193	VERR_INVALID_FLAGS);
3194	if (!pszName)
3195	pszName = pDevIns->pReg->szName;
3196
3197	#if 0
3198	AssertLogRelReturn(RT_VALID_PTR(pszName), VERR_INVALID_POINTER);
3199	AssertLogRelReturn(!pPciDev->Int.s.fRegistered, VERR_PDM_NOT_PCI_DEVICE);
3200	AssertLogRelReturn(pPciDev == PDMDEV_GET_PPCIDEV(pDevIns, pPciDev->Int.s.idxSubDev), VERR_PDM_NOT_PCI_DEVICE);
3201	AssertLogRelReturn(pPciDev == PDMDEV_CALC_PPCIDEV(pDevIns, pPciDev->Int.s.idxSubDev), VERR_PDM_NOT_PCI_DEVICE);
3202	AssertMsgReturn(pPciDev->u32Magic == PDMPCIDEV_MAGIC, ("%#x\n", pPciDev->u32Magic), VERR_PDM_NOT_PCI_DEVICE);
3203	#endif
3204
3205	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3206	int rc = VERR_NOT_IMPLEMENTED;
3207	AssertFailed();
3208	#else
3209	int rc = VINF_SUCCESS;
3210	#endif
3211
3212	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3213	return rc;
3214	}
3215
3216
3217	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIRegisterMsi} */
3218	static DECLCALLBACK(int) pdmR3DevHlp_PCIRegisterMsi(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, PPDMMSIREG pMsiReg)
3219	{
3220	PDMDEV_ASSERT_DEVINS(pDevIns);
3221	if (!pPciDev) /* NULL is an alias for the default PCI device. */
3222	pPciDev = pDevIns->apPciDevs[0];
3223	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3224	LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: pPciDev=%p:{%#x} pMsgReg=%p:{cMsiVectors=%d, cMsixVectors=%d}\n",
3225	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, pMsiReg, pMsiReg->cMsiVectors, pMsiReg->cMsixVectors));
3226	PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
3227
3228	AssertLogRelMsgReturn(pDevIns->pReg->cMaxPciDevices > 0,
3229	("'%s'/%d: cMaxPciDevices is 0\n", pDevIns->pReg->szName, pDevIns->iInstance),
3230	VERR_WRONG_ORDER);
3231	AssertLogRelMsgReturn(pMsiReg->cMsixVectors <= pDevIns->pReg->cMaxMsixVectors,
3232	("'%s'/%d: cMsixVectors=%u cMaxMsixVectors=%u\n",
3233	pDevIns->pReg->szName, pDevIns->iInstance, pMsiReg->cMsixVectors, pDevIns->pReg->cMaxMsixVectors),
3234	VERR_INVALID_FLAGS);
3235
3236	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3237	int rc = VERR_NOT_IMPLEMENTED;
3238	AssertFailed();
3239	#else
3240	int rc = VINF_SUCCESS;
3241	#endif
3242
3243
3244	LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3245	return rc;
3246	}
3247
3248
3249	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIIORegionRegister} */
3250	static DECLCALLBACK(int) pdmR3DevHlp_PCIIORegionRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
3251	RTGCPHYS cbRegion, PCIADDRESSSPACE enmType, uint32_t fFlags,
3252	uint64_t hHandle, PFNPCIIOREGIONMAP pfnMapUnmap)
3253	{
3254	PDMDEV_ASSERT_DEVINS(pDevIns);
3255	if (!pPciDev) /* NULL is an alias for the default PCI device. */
3256	pPciDev = pDevIns->apPciDevs[0];
3257	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3258	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%d cbRegion=%RGp enmType=%d fFlags=%#x, hHandle=%#RX64 pfnMapUnmap=%p\n",
3259	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iRegion, cbRegion, enmType, fFlags, hHandle, pfnMapUnmap));
3260
3261	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3262	PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
3263	#endif
3264
3265	/*
3266	* Validate input.
3267	*/
3268	if (iRegion >= VBOX_PCI_NUM_REGIONS)
3269	{
3270	Assert(iRegion < VBOX_PCI_NUM_REGIONS);
3271	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (iRegion)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3272	return VERR_INVALID_PARAMETER;
3273	}
3274
3275	switch ((int)enmType)
3276	{
3277	case PCI_ADDRESS_SPACE_IO:
3278	/*
3279	* Sanity check: don't allow to register more than 32K of the PCI I/O space.
3280	*/
3281	AssertLogRelMsgReturn(cbRegion <= _32K,
3282	("caller='%s'/%d: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cbRegion),
3283	VERR_INVALID_PARAMETER);
3284	break;
3285
3286	case PCI_ADDRESS_SPACE_MEM:
3287	case PCI_ADDRESS_SPACE_MEM_PREFETCH:
3288	/*
3289	* Sanity check: Don't allow to register more than 2GB of the PCI MMIO space.
3290	*/
3291	AssertLogRelMsgReturn(cbRegion <= MM_MMIO_32_MAX,
3292	("caller='%s'/%d: %RGp (max %RGp)\n",
3293	pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, (RTGCPHYS)MM_MMIO_32_MAX),
3294	VERR_OUT_OF_RANGE);
3295	break;
3296
3297	case PCI_ADDRESS_SPACE_BAR64 \| PCI_ADDRESS_SPACE_MEM:
3298	case PCI_ADDRESS_SPACE_BAR64 \| PCI_ADDRESS_SPACE_MEM_PREFETCH:
3299	/*
3300	* Sanity check: Don't allow to register more than 64GB of the 64-bit PCI MMIO space.
3301	*/
3302	AssertLogRelMsgReturn(cbRegion <= MM_MMIO_64_MAX,
3303	("caller='%s'/%d: %RGp (max %RGp)\n",
3304	pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, MM_MMIO_64_MAX),
3305	VERR_OUT_OF_RANGE);
3306	break;
3307
3308	default:
3309	AssertMsgFailed(("enmType=%#x is unknown\n", enmType));
3310	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (enmType)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3311	return VERR_INVALID_PARAMETER;
3312	}
3313
3314	AssertMsgReturn( pfnMapUnmap
3315	\|\| ( hHandle != UINT64_MAX
3316	&& (fFlags & PDMPCIDEV_IORGN_F_HANDLE_MASK) != PDMPCIDEV_IORGN_F_NO_HANDLE),
3317	("caller='%s'/%d: fFlags=%#x hHandle=%#RX64\n", pDevIns->pReg->szName, pDevIns->iInstance, fFlags, hHandle),
3318	VERR_INVALID_PARAMETER);
3319
3320	AssertMsgReturn(!(fFlags & ~PDMPCIDEV_IORGN_F_VALID_MASK), ("fFlags=%#x\n", fFlags), VERR_INVALID_FLAGS);
3321	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3322	int rc = VERR_NOT_IMPLEMENTED;
3323	AssertFailed();
3324	#else
3325	int rc = VINF_SUCCESS;
3326	#endif
3327
3328	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3329	return rc;
3330	}
3331
3332
3333	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIInterceptConfigAccesses} */
3334	static DECLCALLBACK(int) pdmR3DevHlp_PCIInterceptConfigAccesses(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev,
3335	PFNPCICONFIGREAD pfnRead, PFNPCICONFIGWRITE pfnWrite)
3336	{
3337	PDMDEV_ASSERT_DEVINS(pDevIns);
3338	if (!pPciDev) /* NULL is an alias for the default PCI device. */
3339	pPciDev = pDevIns->apPciDevs[0];
3340	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3341	LogFlow(("pdmR3DevHlp_PCIInterceptConfigAccesses: caller='%s'/%d: pPciDev=%p pfnRead=%p pfnWrite=%p\n",
3342	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pfnRead, pfnWrite));
3343
3344	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3345	PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
3346
3347	int rc = VERR_NOT_IMPLEMENTED;
3348	AssertFailed();
3349	#else
3350	int rc = VINF_SUCCESS;
3351	#endif
3352
3353	LogFlow(("pdmR3DevHlp_PCIInterceptConfigAccesses: caller='%s'/%d: returns %Rrc\n",
3354	pDevIns->pReg->szName, pDevIns->iInstance, rc));
3355	return rc;
3356	}
3357
3358
3359	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIConfigWrite} */
3360	static DECLCALLBACK(VBOXSTRICTRC)
3361	pdmR3DevHlp_PCIConfigWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t uAddress, unsigned cb, uint32_t u32Value)
3362	{
3363	PDMDEV_ASSERT_DEVINS(pDevIns);
3364	AssertPtrReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3365	LogFlow(("pdmR3DevHlp_PCIConfigWrite: caller='%s'/%d: pPciDev=%p uAddress=%#x cd=%d u32Value=%#x\n",
3366	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, uAddress, cb, u32Value));
3367
3368	VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
3369	AssertFailed();
3370
3371	LogFlow(("pdmR3DevHlp_PCIConfigWrite: caller='%s'/%d: returns %Rrc\n",
3372	pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict)));
3373	return rcStrict;
3374	}
3375
3376
3377	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIConfigRead} */
3378	static DECLCALLBACK(VBOXSTRICTRC)
3379	pdmR3DevHlp_PCIConfigRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t uAddress, unsigned cb, uint32_t *pu32Value)
3380	{
3381	PDMDEV_ASSERT_DEVINS(pDevIns);
3382	AssertPtrReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3383	LogFlow(("pdmR3DevHlp_PCIConfigRead: caller='%s'/%d: pPciDev=%p uAddress=%#x cd=%d pu32Value=%p:{%#x}\n",
3384	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, uAddress, cb, pu32Value, *pu32Value));
3385
3386	VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
3387	AssertFailed();
3388
3389	LogFlow(("pdmR3DevHlp_PCIConfigRead: caller='%s'/%d: returns %Rrc (*pu32Value=%#x)\n",
3390	pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict), *pu32Value));
3391	return rcStrict;
3392	}
3393
3394
3395	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysRead} */
3396	static DECLCALLBACK(int)
3397	pdmR3DevHlp_PCIPhysRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
3398	{
3399	PDMDEV_ASSERT_DEVINS(pDevIns);
3400	if (!pPciDev) /* NULL is an alias for the default PCI device. */
3401	pPciDev = pDevIns->apPciDevs[0];
3402	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3403	PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
3404
3405	#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
3406	/*
3407	* Just check the busmaster setting here and forward the request to the generic read helper.
3408	*/
3409	if (PCIDevIsBusmaster(pPciDev))
3410	{ /* likely */ }
3411	else
3412	{
3413	Log(("pdmR3DevHlp_PCIPhysRead: caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbRead=%#zx\n",
3414	pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbRead));
3415	memset(pvBuf, 0xff, cbRead);
3416	return VERR_PDM_NOT_PCI_BUS_MASTER;
3417	}
3418	#endif
3419
3420	int rc = VERR_NOT_IMPLEMENTED;
3421	AssertFailed();
3422	return rc;
3423	}
3424
3425
3426	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysWrite} */
3427	static DECLCALLBACK(int)
3428	pdmR3DevHlp_PCIPhysWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
3429	{
3430	PDMDEV_ASSERT_DEVINS(pDevIns);
3431	if (!pPciDev) /* NULL is an alias for the default PCI device. */
3432	pPciDev = pDevIns->apPciDevs[0];
3433	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3434	PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
3435
3436	#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
3437	/*
3438	* Just check the busmaster setting here and forward the request to the generic read helper.
3439	*/
3440	if (PCIDevIsBusmaster(pPciDev))
3441	{ /* likely */ }
3442	else
3443	{
3444	Log(("pdmR3DevHlp_PCIPhysWrite: caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbWrite=%#zx\n",
3445	pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbWrite));
3446	return VERR_PDM_NOT_PCI_BUS_MASTER;
3447	}
3448	#endif
3449
3450	RT_NOREF(GCPhys, pvBuf, cbWrite);
3451	int rc = VERR_NOT_IMPLEMENTED;
3452	AssertFailed();
3453	return rc;
3454	}
3455
3456
3457	/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrq} */
3458	static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrq(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
3459	{
3460	PDMDEV_ASSERT_DEVINS(pDevIns);
3461	if (!pPciDev) /* NULL is an alias for the default PCI device. */
3462	pPciDev = pDevIns->apPciDevs[0];
3463	AssertReturnVoid(pPciDev);
3464	LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: pPciDev=%p:{%#x} iIrq=%d iLevel=%d\n",
3465	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iIrq, iLevel));
3466	PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
3467
3468	RT_NOREF(iIrq, iLevel);
3469	AssertFailed();
3470
3471	LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
3472	}
3473
3474
3475	/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrqNoWait} */
3476	static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrqNoWait(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
3477	{
3478	pdmR3DevHlp_PCISetIrq(pDevIns, pPciDev, iIrq, iLevel);
3479	}
3480
3481
3482	/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrq} */
3483	static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
3484	{
3485	PDMDEV_ASSERT_DEVINS(pDevIns);
3486	LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, iIrq, iLevel));
3487
3488	/*
3489	* Validate input.
3490	*/
3491	Assert(iIrq < 16);
3492	Assert((uint32_t)iLevel <= PDM_IRQ_LEVEL_FLIP_FLOP);
3493
3494	AssertFailed();
3495
3496	LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
3497	}
3498
3499
3500	/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrqNoWait} */
3501	static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
3502	{
3503	pdmR3DevHlp_ISASetIrq(pDevIns, iIrq, iLevel);
3504	}
3505
3506
3507	/** @interface_method_impl{PDMDEVHLPR3,pfnIoApicSendMsi} */
3508	static DECLCALLBACK(void) pdmR3DevHlp_IoApicSendMsi(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t uValue)
3509	{
3510	PDMDEV_ASSERT_DEVINS(pDevIns);
3511	LogFlow(("pdmR3DevHlp_IoApicSendMsi: caller='%s'/%d: GCPhys=%RGp uValue=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, uValue));
3512
3513	/*
3514	* Validate input.
3515	*/
3516	Assert(GCPhys != 0);
3517	Assert(uValue != 0);
3518
3519	AssertFailed();
3520
3521	LogFlow(("pdmR3DevHlp_IoApicSendMsi: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
3522	}
3523
3524
3525	/** @interface_method_impl{PDMDEVHLPR3,pfnDriverAttach} */
3526	static DECLCALLBACK(int) pdmR3DevHlp_DriverAttach(PPDMDEVINS pDevIns, uint32_t iLun, PPDMIBASE pBaseInterface, PPDMIBASE ppBaseInterface, const char pszDesc)
3527	{
3528	PDMDEV_ASSERT_DEVINS(pDevIns);
3529	LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: iLun=%d pBaseInterface=%p ppBaseInterface=%p pszDesc=%p:{%s}\n",
3530	pDevIns->pReg->szName, pDevIns->iInstance, iLun, pBaseInterface, ppBaseInterface, pszDesc, pszDesc));
3531
3532	#if 1
3533	int rc = VINF_SUCCESS;
3534	if (iLun == PDM_STATUS_LUN)
3535	*ppBaseInterface = &pDevIns->Internal.s.pDut->IBaseSts;
3536	else
3537	rc = VERR_PDM_NO_ATTACHED_DRIVER;
3538	#else
3539	int rc = VERR_NOT_IMPLEMENTED;
3540	AssertFailed();
3541	#endif
3542
3543	LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3544	return rc;
3545	}
3546
3547
3548	/** @interface_method_impl{PDMDEVHLPR3,pfnDriverDetach} */
3549	static DECLCALLBACK(int) pdmR3DevHlp_DriverDetach(PPDMDEVINS pDevIns, PPDMDRVINS pDrvIns, uint32_t fFlags)
3550	{
3551	PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
3552	LogFlow(("pdmR3DevHlp_DriverDetach: caller='%s'/%d: pDrvIns=%p\n",
3553	pDevIns->pReg->szName, pDevIns->iInstance, pDrvIns));
3554
3555	RT_NOREF(fFlags);
3556	int rc = VERR_NOT_IMPLEMENTED;
3557	AssertFailed();
3558
3559	LogFlow(("pdmR3DevHlp_DriverDetach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3560	return rc;
3561	}
3562
3563
3564	/** @interface_method_impl{PDMDEVHLPR3,pfnDriverReconfigure} */
3565	static DECLCALLBACK(int) pdmR3DevHlp_DriverReconfigure(PPDMDEVINS pDevIns, uint32_t iLun, uint32_t cDepth,
3566	const char * const papszDrivers, PCFGMNODE papConfigs, uint32_t fFlags)
3567	{
3568	PDMDEV_ASSERT_DEVINS(pDevIns);
3569	LogFlow(("pdmR3DevHlp_DriverReconfigure: caller='%s'/%d: iLun=%u cDepth=%u fFlags=%#x\n",
3570	pDevIns->pReg->szName, pDevIns->iInstance, iLun, cDepth, fFlags));
3571
3572	/*
3573	* Validate input.
3574	*/
3575	AssertReturn(cDepth <= 8, VERR_INVALID_PARAMETER);
3576	AssertPtrReturn(papszDrivers, VERR_INVALID_POINTER);
3577	AssertPtrNullReturn(papConfigs, VERR_INVALID_POINTER);
3578	for (uint32_t i = 0; i < cDepth; i++)
3579	{
3580	AssertPtrReturn(papszDrivers[i], VERR_INVALID_POINTER);
3581	size_t cchDriver = strlen(papszDrivers[i]);
3582	AssertPtrReturn(cchDriver > 0 && cchDriver < RT_SIZEOFMEMB(PDMDRVREG, szName), VERR_OUT_OF_RANGE);
3583
3584	if (papConfigs)
3585	AssertPtrNullReturn(papConfigs[i], VERR_INVALID_POINTER);
3586	}
3587	AssertReturn(fFlags == 0, VERR_INVALID_FLAGS);
3588
3589	int rc = VERR_NOT_IMPLEMENTED;
3590	AssertFailed();
3591
3592	LogFlow(("pdmR3DevHlp_DriverReconfigure: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3593	return rc;
3594	}
3595
3596
3597	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueCreatePtr} */
3598	static DECLCALLBACK(int) pdmR3DevHlp_QueueCreatePtr(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
3599	PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char pszName, PPDMQUEUE ppQueue)
3600	{
3601	PDMDEV_ASSERT_DEVINS(pDevIns);
3602	LogFlow(("pdmR3DevHlp_QueueCreatePtr: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fRZEnabled=%RTbool pszName=%p:{%s} ppQueue=%p\n",
3603	pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, pszName, ppQueue));
3604
3605	int rc = VERR_NOT_IMPLEMENTED;
3606	AssertFailed();
3607
3608	LogFlow(("pdmR3DevHlp_QueueCreatePtr: caller='%s'/%d: returns %Rrc ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, ppQueue));
3609	return rc;
3610	}
3611
3612
3613	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueCreate} */
3614	static DECLCALLBACK(int) pdmR3DevHlp_QueueCreate(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
3615	PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char *pszName,
3616	PDMQUEUEHANDLE *phQueue)
3617	{
3618	PDMDEV_ASSERT_DEVINS(pDevIns);
3619	LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fRZEnabled=%RTbool pszName=%p:{%s} phQueue=%p\n",
3620	pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, pszName, phQueue));
3621
3622	int rc = VERR_NOT_IMPLEMENTED;
3623	AssertFailed();
3624
3625	LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: returns %Rrc ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, phQueue));
3626	return rc;
3627	}
3628
3629
3630	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueToPtr} */
3631	static DECLCALLBACK(PPDMQUEUE) pdmR3DevHlp_QueueToPtr(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
3632	{
3633	PDMDEV_ASSERT_DEVINS(pDevIns);
3634	RT_NOREF(pDevIns);
3635	return (PPDMQUEUE)hQueue;
3636	}
3637
3638
3639	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueAlloc} */
3640	static DECLCALLBACK(PPDMQUEUEITEMCORE) pdmR3DevHlp_QueueAlloc(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
3641	{
3642	RT_NOREF(pDevIns, hQueue);
3643	AssertFailed();
3644	return NULL;
3645	}
3646
3647
3648	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueInsert} */
3649	static DECLCALLBACK(void) pdmR3DevHlp_QueueInsert(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem)
3650	{
3651	RT_NOREF(pDevIns, hQueue, pItem);
3652	AssertFailed();
3653	}
3654
3655
3656	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueInsertEx} */
3657	static DECLCALLBACK(void) pdmR3DevHlp_QueueInsertEx(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem,
3658	uint64_t cNanoMaxDelay)
3659	{
3660	RT_NOREF(pDevIns, hQueue, pItem, cNanoMaxDelay);
3661	AssertFailed();
3662	}
3663
3664
3665	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueFlushIfNecessary} */
3666	static DECLCALLBACK(bool) pdmR3DevHlp_QueueFlushIfNecessary(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
3667	{
3668	RT_NOREF(pDevIns, hQueue);
3669	AssertFailed();
3670	return false;
3671	}
3672
3673
3674	/** @interface_method_impl{PDMDEVHLPR3,pfnTaskCreate} */
3675	static DECLCALLBACK(int) pdmR3DevHlp_TaskCreate(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszName,
3676	PFNPDMTASKDEV pfnCallback, void pvUser, PDMTASKHANDLE phTask)
3677	{
3678	PDMDEV_ASSERT_DEVINS(pDevIns);
3679	LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: pfnCallback=%p fFlags=%#x pszName=%p:{%s} phTask=%p\n",
3680	pDevIns->pReg->szName, pDevIns->iInstance, pfnCallback, fFlags, pszName, pszName, phTask));
3681
3682	RT_NOREF(pDevIns, fFlags, pszName, pfnCallback, pvUser, phTask);
3683	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3684	int rc = VERR_NOT_IMPLEMENTED;
3685	AssertFailed();
3686	#else
3687	int rc = VINF_SUCCESS;
3688	#endif
3689
3690	LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3691	return rc;
3692	}
3693
3694
3695	/** @interface_method_impl{PDMDEVHLPR3,pfnTaskTrigger} */
3696	static DECLCALLBACK(int) pdmR3DevHlp_TaskTrigger(PPDMDEVINS pDevIns, PDMTASKHANDLE hTask)
3697	{
3698	PDMDEV_ASSERT_DEVINS(pDevIns);
3699	LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: hTask=%RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, hTask));
3700
3701	RT_NOREF(pDevIns, hTask);
3702	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3703	int rc = VERR_NOT_IMPLEMENTED;
3704	AssertFailed();
3705	#else
3706	int rc = VINF_SUCCESS;
3707	#endif
3708
3709	LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3710	return rc;
3711	}
3712
3713
3714	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventCreate} */
3715	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventCreate(PPDMDEVINS pDevIns, PSUPSEMEVENT phEvent)
3716	{
3717	PDMDEV_ASSERT_DEVINS(pDevIns);
3718	LogFlow(("pdmR3DevHlp_SUPSemEventCreate: caller='%s'/%d: phEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, phEvent));
3719
3720	RT_NOREF(pDevIns, phEvent);
3721	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3722	int rc = VERR_NOT_IMPLEMENTED;
3723	AssertFailed();
3724	#else
3725	int rc = VINF_SUCCESS;
3726	#endif
3727
3728	LogFlow(("pdmR3DevHlp_SUPSemEventCreate: caller='%s'/%d: returns %Rrc phEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, phEvent));
3729	return rc;
3730	}
3731
3732
3733	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventClose} */
3734	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventClose(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent)
3735	{
3736	PDMDEV_ASSERT_DEVINS(pDevIns);
3737	LogFlow(("pdmR3DevHlp_SUPSemEventClose: caller='%s'/%d: hEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEvent));
3738
3739	RT_NOREF(pDevIns, hEvent);
3740	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3741	int rc = VERR_NOT_IMPLEMENTED;
3742	AssertFailed();
3743	#else
3744	int rc = VINF_SUCCESS;
3745	#endif
3746
3747	LogFlow(("pdmR3DevHlp_SUPSemEventClose: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3748	return rc;
3749	}
3750
3751
3752	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventSignal} */
3753	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventSignal(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent)
3754	{
3755	PDMDEV_ASSERT_DEVINS(pDevIns);
3756	LogFlow(("pdmR3DevHlp_SUPSemEventSignal: caller='%s'/%d: hEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEvent));
3757
3758	RT_NOREF(pDevIns, hEvent);
3759	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3760	int rc = VERR_NOT_IMPLEMENTED;
3761	AssertFailed();
3762	#else
3763	int rc = VINF_SUCCESS;
3764	#endif
3765
3766	LogFlow(("pdmR3DevHlp_SUPSemEventSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3767	return rc;
3768	}
3769
3770
3771	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventWaitNoResume} */
3772	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint32_t cMillies)
3773	{
3774	PDMDEV_ASSERT_DEVINS(pDevIns);
3775	LogFlow(("pdmR3DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: hEvent=%p cNsTimeout=%RU32\n",
3776	pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cMillies));
3777
3778	RT_NOREF(pDevIns, hEvent, cMillies);
3779	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3780	int rc = VERR_NOT_IMPLEMENTED;
3781	AssertFailed();
3782	#else
3783	int rc = VINF_SUCCESS;
3784	#endif
3785
3786	LogFlow(("pdmR3DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3787	return rc;
3788	}
3789
3790
3791	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventWaitNsAbsIntr} */
3792	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t uNsTimeout)
3793	{
3794	PDMDEV_ASSERT_DEVINS(pDevIns);
3795	LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: hEvent=%p uNsTimeout=%RU64\n",
3796	pDevIns->pReg->szName, pDevIns->iInstance, hEvent, uNsTimeout));
3797
3798	RT_NOREF(pDevIns, hEvent, uNsTimeout);
3799	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3800	int rc = VERR_NOT_IMPLEMENTED;
3801	AssertFailed();
3802	#else
3803	int rc = VINF_SUCCESS;
3804	#endif
3805
3806	LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3807	return rc;
3808	}
3809
3810
3811	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventWaitNsRelIntr} */
3812	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t cNsTimeout)
3813	{
3814	PDMDEV_ASSERT_DEVINS(pDevIns);
3815	LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: hEvent=%p cNsTimeout=%RU64\n",
3816	pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cNsTimeout));
3817
3818	RT_NOREF(pDevIns, hEvent, cNsTimeout);
3819	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3820	int rc = VERR_NOT_IMPLEMENTED;
3821	AssertFailed();
3822	#else
3823	int rc = VINF_SUCCESS;
3824	#endif
3825
3826	LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3827	return rc;
3828	}
3829
3830
3831	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventGetResolution} */
3832	static DECLCALLBACK(uint32_t) pdmR3DevHlp_SUPSemEventGetResolution(PPDMDEVINS pDevIns)
3833	{
3834	PDMDEV_ASSERT_DEVINS(pDevIns);
3835	LogFlow(("pdmR3DevHlp_SUPSemEventGetResolution: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
3836
3837	RT_NOREF(pDevIns);
3838	uint32_t cNsResolution = 0;
3839	AssertFailed();
3840
3841	LogFlow(("pdmR3DevHlp_SUPSemEventGetResolution: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, cNsResolution));
3842	return cNsResolution;
3843	}
3844
3845
3846	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiCreate} */
3847	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiCreate(PPDMDEVINS pDevIns, PSUPSEMEVENTMULTI phEventMulti)
3848	{
3849	PDMDEV_ASSERT_DEVINS(pDevIns);
3850	LogFlow(("pdmR3DevHlp_SUPSemEventMultiCreate: caller='%s'/%d: phEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, phEventMulti));
3851
3852	RT_NOREF(pDevIns, phEventMulti);
3853	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3854	int rc = VERR_NOT_IMPLEMENTED;
3855	AssertFailed();
3856	#else
3857	int rc = VINF_SUCCESS;
3858	#endif
3859
3860	LogFlow(("pdmR3DevHlp_SUPSemEventMultiCreate: caller='%s'/%d: returns %Rrc phEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, phEventMulti));
3861	return rc;
3862	}
3863
3864
3865	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiClose} */
3866	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiClose(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
3867	{
3868	PDMDEV_ASSERT_DEVINS(pDevIns);
3869	LogFlow(("pdmR3DevHlp_SUPSemEventMultiClose: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
3870
3871	RT_NOREF(pDevIns, hEventMulti);
3872	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3873	int rc = VERR_NOT_IMPLEMENTED;
3874	AssertFailed();
3875	#else
3876	int rc = VINF_SUCCESS;
3877	#endif
3878
3879	LogFlow(("pdmR3DevHlp_SUPSemEventMultiClose: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3880	return rc;
3881	}
3882
3883
3884	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiSignal} */
3885	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiSignal(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
3886	{
3887	PDMDEV_ASSERT_DEVINS(pDevIns);
3888	LogFlow(("pdmR3DevHlp_SUPSemEventMultiSignal: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
3889
3890	RT_NOREF(pDevIns, hEventMulti);
3891	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3892	int rc = VERR_NOT_IMPLEMENTED;
3893	AssertFailed();
3894	#else
3895	int rc = VINF_SUCCESS;
3896	#endif
3897
3898	LogFlow(("pdmR3DevHlp_SUPSemEventMultiSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3899	return rc;
3900	}
3901
3902
3903	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiReset} */
3904	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiReset(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
3905	{
3906	PDMDEV_ASSERT_DEVINS(pDevIns);
3907	LogFlow(("pdmR3DevHlp_SUPSemEventMultiReset: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
3908
3909	RT_NOREF(pDevIns, hEventMulti);
3910	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3911	int rc = VERR_NOT_IMPLEMENTED;
3912	AssertFailed();
3913	#else
3914	int rc = VINF_SUCCESS;
3915	#endif
3916
3917	LogFlow(("pdmR3DevHlp_SUPSemEventMultiReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3918	return rc;
3919	}
3920
3921
3922	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiWaitNoResume} */
3923	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
3924	uint32_t cMillies)
3925	{
3926	PDMDEV_ASSERT_DEVINS(pDevIns);
3927	LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNoResume: caller='%s'/%d: hEventMulti=%p cMillies=%RU32\n",
3928	pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, cMillies));
3929
3930	RT_NOREF(pDevIns, hEventMulti, cMillies);
3931	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3932	int rc = VERR_NOT_IMPLEMENTED;
3933	AssertFailed();
3934	#else
3935	int rc = VINF_SUCCESS;
3936	#endif
3937	LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3938	return rc;
3939	}
3940
3941
3942	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiWaitNsAbsIntr} */
3943	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
3944	uint64_t uNsTimeout)
3945	{
3946	PDMDEV_ASSERT_DEVINS(pDevIns);
3947	LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr: caller='%s'/%d: hEventMulti=%p uNsTimeout=%RU64\n",
3948	pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, uNsTimeout));
3949
3950	RT_NOREF(pDevIns, hEventMulti, uNsTimeout);
3951	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3952	int rc = VERR_NOT_IMPLEMENTED;
3953	AssertFailed();
3954	#else
3955	int rc = VINF_SUCCESS;
3956	#endif
3957
3958	LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3959	return rc;
3960	}
3961
3962
3963	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiWaitNsRelIntr} */
3964	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
3965	uint64_t cNsTimeout)
3966	{
3967	PDMDEV_ASSERT_DEVINS(pDevIns);
3968	LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr: caller='%s'/%d: hEventMulti=%p cNsTimeout=%RU64\n",
3969	pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, cNsTimeout));
3970
3971	RT_NOREF(pDevIns, hEventMulti, cNsTimeout);
3972	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3973	int rc = VERR_NOT_IMPLEMENTED;
3974	AssertFailed();
3975	#else
3976	int rc = VINF_SUCCESS;
3977	#endif
3978
3979	LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3980	return rc;
3981	}
3982
3983
3984	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiGetResolution} */
3985	static DECLCALLBACK(uint32_t) pdmR3DevHlp_SUPSemEventMultiGetResolution(PPDMDEVINS pDevIns)
3986	{
3987	PDMDEV_ASSERT_DEVINS(pDevIns);
3988	LogFlow(("pdmR3DevHlp_SUPSemEventMultiGetResolution: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
3989
3990	uint32_t cNsResolution = 0;
3991	AssertFailed();
3992
3993	LogFlow(("pdmR3DevHlp_SUPSemEventMultiGetResolution: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, cNsResolution));
3994	return cNsResolution;
3995	}
3996
3997
3998	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectInit} */
3999	static DECLCALLBACK(int) pdmR3DevHlp_CritSectInit(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RT_SRC_POS_DECL,
4000	const char *pszNameFmt, va_list va)
4001	{
4002	PDMDEV_ASSERT_DEVINS(pDevIns);
4003	LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: pCritSect=%p pszNameFmt=%p:{%s}\n",
4004	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
4005
4006	RT_NOREF(RT_SRC_POS_ARGS, pszNameFmt, va);
4007	int rc = RTCritSectInit(&pCritSect->s.CritSect);
4008
4009	LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4010	return rc;
4011	}
4012
4013
4014	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNop} */
4015	static DECLCALLBACK(PPDMCRITSECT) pdmR3DevHlp_CritSectGetNop(PPDMDEVINS pDevIns)
4016	{
4017	PDMDEV_ASSERT_DEVINS(pDevIns);
4018
4019	PPDMCRITSECT pCritSect = &pDevIns->Internal.s.pDut->CritSectNop;
4020
4021	LogFlow(("pdmR3DevHlp_CritSectGetNop: caller='%s'/%d: return %p\n",
4022	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
4023	return pCritSect;
4024	}
4025
4026
4027	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNopR0} */
4028	static DECLCALLBACK(R0PTRTYPE(PPDMCRITSECT)) pdmR3DevHlp_CritSectGetNopR0(PPDMDEVINS pDevIns)
4029	{
4030	PDMDEV_ASSERT_DEVINS(pDevIns);
4031
4032	R0PTRTYPE(PPDMCRITSECT) pCritSect = 0;
4033	LogFlow(("pdmR3DevHlp_CritSectGetNopR0: caller='%s'/%d: return %RHv\n",
4034	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
4035	return pCritSect;
4036	}
4037
4038
4039	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNopRC} */
4040	static DECLCALLBACK(RCPTRTYPE(PPDMCRITSECT)) pdmR3DevHlp_CritSectGetNopRC(PPDMDEVINS pDevIns)
4041	{
4042	PDMDEV_ASSERT_DEVINS(pDevIns);
4043
4044	RCPTRTYPE(PPDMCRITSECT) pCritSect = 0;
4045	LogFlow(("pdmR3DevHlp_CritSectGetNopRC: caller='%s'/%d: return %RRv\n",
4046	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
4047	return pCritSect;
4048	}
4049
4050
4051	/** @interface_method_impl{PDMDEVHLPR3,pfnSetDeviceCritSect} */
4052	static DECLCALLBACK(int) pdmR3DevHlp_SetDeviceCritSect(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
4053	{
4054	/*
4055	* Validate input.
4056	*/
4057	PDMDEV_ASSERT_DEVINS(pDevIns);
4058	AssertPtrReturn(pCritSect, VERR_INVALID_POINTER);
4059
4060	LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: pCritSect=%p\n",
4061	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
4062
4063	pDevIns->pCritSectRoR3 = pCritSect;
4064	LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
4065	return VINF_SUCCESS;
4066	}
4067
4068
4069	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectYield} */
4070	static DECLCALLBACK(bool) pdmR3DevHlp_CritSectYield(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
4071	{
4072	PDMDEV_ASSERT_DEVINS(pDevIns);
4073
4074	RT_NOREF(pDevIns, pCritSect);
4075	AssertFailed();
4076	return false;
4077	}
4078
4079
4080	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectEnter} */
4081	static DECLCALLBACK(int) pdmR3DevHlp_CritSectEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy)
4082	{
4083	PDMDEV_ASSERT_DEVINS(pDevIns);
4084
4085	RT_NOREF(pDevIns, pCritSect, rcBusy);
4086	int rc = VERR_NOT_IMPLEMENTED;
4087	AssertFailed();
4088	return rc;
4089	}
4090
4091
4092	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectEnterDebug} */
4093	static DECLCALLBACK(int) pdmR3DevHlp_CritSectEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
4094	{
4095	PDMDEV_ASSERT_DEVINS(pDevIns);
4096
4097	RT_NOREF(pDevIns, rcBusy, uId, RT_SRC_POS_ARGS);
4098	return RTCritSectEnter(&pCritSect->s.CritSect);
4099	}
4100
4101
4102	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectTryEnter} */
4103	static DECLCALLBACK(int) pdmR3DevHlp_CritSectTryEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
4104	{
4105	PDMDEV_ASSERT_DEVINS(pDevIns);
4106
4107	RT_NOREF(pDevIns, pCritSect);
4108	int rc = VERR_NOT_IMPLEMENTED;
4109	AssertFailed();
4110	return rc;
4111	}
4112
4113
4114	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectTryEnterDebug} */
4115	static DECLCALLBACK(int) pdmR3DevHlp_CritSectTryEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
4116	{
4117	PDMDEV_ASSERT_DEVINS(pDevIns);
4118
4119	RT_NOREF(pDevIns, pCritSect, uId, RT_SRC_POS_ARGS);
4120	int rc = VERR_NOT_IMPLEMENTED;
4121	AssertFailed();
4122	return rc;
4123	}
4124
4125
4126	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectLeave} */
4127	static DECLCALLBACK(int) pdmR3DevHlp_CritSectLeave(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
4128	{
4129	PDMDEV_ASSERT_DEVINS(pDevIns);
4130
4131	return RTCritSectLeave(&pCritSect->s.CritSect);
4132	}
4133
4134
4135	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectIsOwner} */
4136	static DECLCALLBACK(bool) pdmR3DevHlp_CritSectIsOwner(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
4137	{
4138	PDMDEV_ASSERT_DEVINS(pDevIns);
4139
4140	return RTCritSectIsOwner(&pCritSect->s.CritSect);
4141	}
4142
4143
4144	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectIsInitialized} */
4145	static DECLCALLBACK(bool) pdmR3DevHlp_CritSectIsInitialized(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
4146	{
4147	PDMDEV_ASSERT_DEVINS(pDevIns);
4148
4149	RT_NOREF(pDevIns, pCritSect);
4150	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
4151	AssertFailed();
4152	return false;
4153	#else
4154	return true;
4155	#endif
4156	}
4157
4158
4159	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectHasWaiters} */
4160	static DECLCALLBACK(bool) pdmR3DevHlp_CritSectHasWaiters(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
4161	{
4162	PDMDEV_ASSERT_DEVINS(pDevIns);
4163	RT_NOREF(pDevIns, pCritSect);
4164	AssertFailed();
4165	return false;
4166	}
4167
4168
4169	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetRecursion} */
4170	static DECLCALLBACK(uint32_t) pdmR3DevHlp_CritSectGetRecursion(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
4171	{
4172	PDMDEV_ASSERT_DEVINS(pDevIns);
4173
4174	RT_NOREF(pDevIns, pCritSect);
4175	AssertFailed();
4176	return 0;
4177	}
4178
4179
4180	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectScheduleExitEvent} */
4181	static DECLCALLBACK(int) pdmR3DevHlp_CritSectScheduleExitEvent(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect,
4182	SUPSEMEVENT hEventToSignal)
4183	{
4184	PDMDEV_ASSERT_DEVINS(pDevIns);
4185
4186	RT_NOREF(pDevIns, pCritSect, hEventToSignal);
4187	int rc = VERR_NOT_IMPLEMENTED;
4188	AssertFailed();
4189	return rc;
4190	}
4191
4192
4193	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectDelete} */
4194	static DECLCALLBACK(int) pdmR3DevHlp_CritSectDelete(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
4195	{
4196	PDMDEV_ASSERT_DEVINS(pDevIns);
4197
4198	RT_NOREF(pDevIns, pCritSect);
4199	int rc = VERR_NOT_IMPLEMENTED;
4200	AssertFailed();
4201	return rc;
4202	}
4203
4204
4205	static DECLCALLBACK(int) pdmR3DevHlp_ThreadCreate(PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
4206	PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
4207	{
4208	PDMDEV_ASSERT_DEVINS(pDevIns);
4209	LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: ppThread=%p pvUser=%p pfnThread=%p pfnWakeup=%p cbStack=%#zx enmType=%d pszName=%p:{%s}\n",
4210	pDevIns->pReg->szName, pDevIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
4211
4212	RT_NOREF(ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
4213
4214	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
4215	int rc = VERR_NOT_IMPLEMENTED;
4216	AssertFailed();
4217	#else
4218	int rc = VINF_SUCCESS;
4219	#endif
4220
4221	LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pDevIns->pReg->szName, pDevIns->iInstance,
4222	rc, *ppThread));
4223	return rc;
4224	}
4225
4226
4227	static DECLCALLBACK(int) pdmR3DevHlp_ThreadDestroy(PPDMTHREAD pThread, int *pRcThread)
4228	{
4229	RT_NOREF(pThread, pRcThread);
4230	int rc = VERR_NOT_IMPLEMENTED;
4231	AssertFailed();
4232	return rc;
4233	}
4234
4235
4236	static DECLCALLBACK(int) pdmR3DevHlp_ThreadIAmSuspending(PPDMTHREAD pThread)
4237	{
4238	RT_NOREF(pThread);
4239	int rc = VERR_NOT_IMPLEMENTED;
4240	AssertFailed();
4241	return rc;
4242	}
4243
4244
4245	static DECLCALLBACK(int) pdmR3DevHlp_ThreadIamRunning(PPDMTHREAD pThread)
4246	{
4247	RT_NOREF(pThread);
4248	int rc = VERR_NOT_IMPLEMENTED;
4249	AssertFailed();
4250	return rc;
4251	}
4252
4253
4254	static DECLCALLBACK(int) pdmR3DevHlp_ThreadSleep(PPDMTHREAD pThread, RTMSINTERVAL cMillies)
4255	{
4256	RT_NOREF(pThread, cMillies);
4257	int rc = VERR_NOT_IMPLEMENTED;
4258	AssertFailed();
4259	return rc;
4260	}
4261
4262
4263	static DECLCALLBACK(int) pdmR3DevHlp_ThreadSuspend(PPDMTHREAD pThread)
4264	{
4265	RT_NOREF(pThread);
4266	int rc = VERR_NOT_IMPLEMENTED;
4267	AssertFailed();
4268	return rc;
4269	}
4270
4271
4272	static DECLCALLBACK(int) pdmR3DevHlp_ThreadResume(PPDMTHREAD pThread)
4273	{
4274	RT_NOREF(pThread);
4275	int rc = VERR_NOT_IMPLEMENTED;
4276	AssertFailed();
4277	return rc;
4278	}
4279
4280
4281	/** @interface_method_impl{PDMDEVHLPR3,pfnSetAsyncNotification} */
4282	static DECLCALLBACK(int) pdmR3DevHlp_SetAsyncNotification(PPDMDEVINS pDevIns, PFNPDMDEVASYNCNOTIFY pfnAsyncNotify)
4283	{
4284	PDMDEV_ASSERT_DEVINS(pDevIns);
4285	LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pfnAsyncNotify));
4286
4287	int rc = VERR_NOT_IMPLEMENTED;
4288	AssertStmt(pfnAsyncNotify, rc = VERR_INVALID_PARAMETER);
4289	#if 0
4290	AssertStmt(!pDevIns->Internal.s.pfnAsyncNotify, rc = VERR_WRONG_ORDER);
4291	AssertStmt(pDevIns->Internal.s.fIntFlags & (PDMDEVINSINT_FLAGS_SUSPENDED \| PDMDEVINSINT_FLAGS_RESET), rc = VERR_WRONG_ORDER);
4292	#endif
4293
4294	AssertFailed();
4295
4296	LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4297	return rc;
4298	}
4299
4300
4301	/** @interface_method_impl{PDMDEVHLPR3,pfnAsyncNotificationCompleted} */
4302	static DECLCALLBACK(void) pdmR3DevHlp_AsyncNotificationCompleted(PPDMDEVINS pDevIns)
4303	{
4304	PDMDEV_ASSERT_DEVINS(pDevIns);
4305
4306	AssertFailed();
4307	}
4308
4309
4310	/** @interface_method_impl{PDMDEVHLPR3,pfnRTCRegister} */
4311	static DECLCALLBACK(int) pdmR3DevHlp_RTCRegister(PPDMDEVINS pDevIns, PCPDMRTCREG pRtcReg, PCPDMRTCHLP *ppRtcHlp)
4312	{
4313	PDMDEV_ASSERT_DEVINS(pDevIns);
4314	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: pRtcReg=%p:{.u32Version=%#x, .pfnWrite=%p, .pfnRead=%p} ppRtcHlp=%p\n",
4315	pDevIns->pReg->szName, pDevIns->iInstance, pRtcReg, pRtcReg->u32Version, pRtcReg->pfnWrite,
4316	pRtcReg->pfnWrite, ppRtcHlp));
4317
4318	/*
4319	* Validate input.
4320	*/
4321	if (pRtcReg->u32Version != PDM_RTCREG_VERSION)
4322	{
4323	AssertMsgFailed(("u32Version=%#x expected %#x\n", pRtcReg->u32Version,
4324	PDM_RTCREG_VERSION));
4325	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (version)\n",
4326	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4327	return VERR_INVALID_PARAMETER;
4328	}
4329	if ( !pRtcReg->pfnWrite
4330	\|\| !pRtcReg->pfnRead)
4331	{
4332	Assert(pRtcReg->pfnWrite);
4333	Assert(pRtcReg->pfnRead);
4334	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
4335	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4336	return VERR_INVALID_PARAMETER;
4337	}
4338
4339	if (!ppRtcHlp)
4340	{
4341	Assert(ppRtcHlp);
4342	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (ppRtcHlp)\n",
4343	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4344	return VERR_INVALID_PARAMETER;
4345	}
4346
4347	int rc = VERR_NOT_IMPLEMENTED;
4348	AssertFailed();
4349
4350	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc\n",
4351	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4352	return rc;
4353	}
4354
4355
4356	/** @interface_method_impl{PDMDEVHLPR3,pfnDMARegister} */
4357	static DECLCALLBACK(int) pdmR3DevHlp_DMARegister(PPDMDEVINS pDevIns, unsigned uChannel, PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser)
4358	{
4359	PDMDEV_ASSERT_DEVINS(pDevIns);
4360	LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: uChannel=%d pfnTransferHandler=%p pvUser=%p\n",
4361	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pfnTransferHandler, pvUser));
4362
4363	int rc = VERR_NOT_IMPLEMENTED;
4364	AssertFailed();
4365
4366	LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: returns %Rrc\n",
4367	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4368	return rc;
4369	}
4370
4371
4372	/** @interface_method_impl{PDMDEVHLPR3,pfnDMAReadMemory} */
4373	static DECLCALLBACK(int) pdmR3DevHlp_DMAReadMemory(PPDMDEVINS pDevIns, unsigned uChannel, void pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t pcbRead)
4374	{
4375	PDMDEV_ASSERT_DEVINS(pDevIns);
4376	LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbRead=%p\n",
4377	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbRead));
4378
4379	int rc = VERR_NOT_IMPLEMENTED;
4380	AssertFailed();
4381
4382	LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: returns %Rrc\n",
4383	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4384	return rc;
4385	}
4386
4387
4388	/** @interface_method_impl{PDMDEVHLPR3,pfnDMAWriteMemory} */
4389	static DECLCALLBACK(int) pdmR3DevHlp_DMAWriteMemory(PPDMDEVINS pDevIns, unsigned uChannel, const void pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t pcbWritten)
4390	{
4391	PDMDEV_ASSERT_DEVINS(pDevIns);
4392	LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbWritten=%p\n",
4393	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbWritten));
4394
4395	int rc = VERR_NOT_IMPLEMENTED;
4396	AssertFailed();
4397
4398	LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: returns %Rrc\n",
4399	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4400	return rc;
4401	}
4402
4403
4404	/** @interface_method_impl{PDMDEVHLPR3,pfnDMASetDREQ} */
4405	static DECLCALLBACK(int) pdmR3DevHlp_DMASetDREQ(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel)
4406	{
4407	PDMDEV_ASSERT_DEVINS(pDevIns);
4408	LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: uChannel=%d uLevel=%d\n",
4409	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, uLevel));
4410
4411	int rc = VERR_NOT_IMPLEMENTED;
4412	AssertFailed();
4413
4414	LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: returns %Rrc\n",
4415	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4416	return rc;
4417	}
4418
4419	/** @interface_method_impl{PDMDEVHLPR3,pfnDMAGetChannelMode} */
4420	static DECLCALLBACK(uint8_t) pdmR3DevHlp_DMAGetChannelMode(PPDMDEVINS pDevIns, unsigned uChannel)
4421	{
4422	PDMDEV_ASSERT_DEVINS(pDevIns);
4423	LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: uChannel=%d\n",
4424	pDevIns->pReg->szName, pDevIns->iInstance, uChannel));
4425
4426	uint8_t u8Mode = (3 << 2); /* Invalid mode. */
4427	AssertFailed();
4428
4429	LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: returns %#04x\n",
4430	pDevIns->pReg->szName, pDevIns->iInstance, u8Mode));
4431	return u8Mode;
4432	}
4433
4434	/** @interface_method_impl{PDMDEVHLPR3,pfnDMASchedule} */
4435	static DECLCALLBACK(void) pdmR3DevHlp_DMASchedule(PPDMDEVINS pDevIns)
4436	{
4437	PDMDEV_ASSERT_DEVINS(pDevIns);
4438	LogFlow(("pdmR3DevHlp_DMASchedule: caller='%s'/%d\n",
4439	pDevIns->pReg->szName, pDevIns->iInstance));
4440
4441	AssertFailed();
4442	}
4443
4444
4445	/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSWrite} */
4446	static DECLCALLBACK(int) pdmR3DevHlp_CMOSWrite(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value)
4447	{
4448	PDMDEV_ASSERT_DEVINS(pDevIns);
4449	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x u8Value=%#04x\n",
4450	pDevIns->pReg->szName, pDevIns->iInstance, iReg, u8Value));
4451
4452	int rc = VERR_NOT_IMPLEMENTED;
4453	AssertFailed();
4454
4455	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
4456	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4457	return rc;
4458	}
4459
4460
4461	/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSRead} */
4462	static DECLCALLBACK(int) pdmR3DevHlp_CMOSRead(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value)
4463	{
4464	PDMDEV_ASSERT_DEVINS(pDevIns);
4465	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x pu8Value=%p\n",
4466	pDevIns->pReg->szName, pDevIns->iInstance, iReg, pu8Value));
4467
4468	int rc = VERR_NOT_IMPLEMENTED;
4469	AssertFailed();
4470
4471	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
4472	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4473	return rc;
4474	}
4475
4476
4477	/** @interface_method_impl{PDMDEVHLPR3,pfnAssertEMT} */
4478	static DECLCALLBACK(bool) pdmR3DevHlp_AssertEMT(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction)
4479	{
4480	PDMDEV_ASSERT_DEVINS(pDevIns);
4481
4482	char szMsg[100];
4483	RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
4484	RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
4485	AssertBreakpoint();
4486	return false;
4487	}
4488
4489
4490	/** @interface_method_impl{PDMDEVHLPR3,pfnAssertOther} */
4491	static DECLCALLBACK(bool) pdmR3DevHlp_AssertOther(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction)
4492	{
4493	PDMDEV_ASSERT_DEVINS(pDevIns);
4494
4495	char szMsg[100];
4496	RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
4497	RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
4498	AssertBreakpoint();
4499	return false;
4500	}
4501
4502
4503	/** @interface_method_impl{PDMDEVHLPR3,pfnLdrGetRCInterfaceSymbols} */
4504	static DECLCALLBACK(int) pdmR3DevHlp_LdrGetRCInterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
4505	const char pszSymPrefix, const char pszSymList)
4506	{
4507	PDMDEV_ASSERT_DEVINS(pDevIns);
4508	LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
4509	pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
4510
4511	int rc = VERR_NOT_IMPLEMENTED;
4512	AssertFailed();
4513
4514	LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
4515	pDevIns->iInstance, rc));
4516	return rc;
4517	}
4518
4519
4520	/** @interface_method_impl{PDMDEVHLPR3,pfnLdrGetR0InterfaceSymbols} */
4521	static DECLCALLBACK(int) pdmR3DevHlp_LdrGetR0InterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
4522	const char pszSymPrefix, const char pszSymList)
4523	{
4524	PDMDEV_ASSERT_DEVINS(pDevIns);
4525	LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
4526	pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
4527
4528	int rc = VERR_NOT_IMPLEMENTED;
4529	AssertFailed();
4530
4531	LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
4532	pDevIns->iInstance, rc));
4533	return rc;
4534	}
4535
4536
4537	/** @interface_method_impl{PDMDEVHLPR3,pfnCallR0} */
4538	static DECLCALLBACK(int) pdmR3DevHlp_CallR0(PPDMDEVINS pDevIns, uint32_t uOperation, uint64_t u64Arg)
4539	{
4540	PDMDEV_ASSERT_DEVINS(pDevIns);
4541	LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: uOperation=%#x u64Arg=%#RX64\n",
4542	pDevIns->pReg->szName, pDevIns->iInstance, uOperation, u64Arg));
4543
4544	int rc = VERR_NOT_IMPLEMENTED;
4545	AssertFailed();
4546
4547	LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
4548	pDevIns->iInstance, rc));
4549	return rc;
4550	}
4551
4552
4553	/** @interface_method_impl{PDMDEVHLPR3,pfnVMGetSuspendReason} */
4554	static DECLCALLBACK(VMSUSPENDREASON) pdmR3DevHlp_VMGetSuspendReason(PPDMDEVINS pDevIns)
4555	{
4556	PDMDEV_ASSERT_DEVINS(pDevIns);
4557
4558	VMSUSPENDREASON enmReason = VMSUSPENDREASON_INVALID;
4559	AssertFailed();
4560
4561	LogFlow(("pdmR3DevHlp_VMGetSuspendReason: caller='%s'/%d: returns %d\n",
4562	pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
4563	return enmReason;
4564	}
4565
4566
4567	/** @interface_method_impl{PDMDEVHLPR3,pfnVMGetResumeReason} */
4568	static DECLCALLBACK(VMRESUMEREASON) pdmR3DevHlp_VMGetResumeReason(PPDMDEVINS pDevIns)
4569	{
4570	PDMDEV_ASSERT_DEVINS(pDevIns);
4571
4572	VMRESUMEREASON enmReason = VMRESUMEREASON_INVALID;
4573	AssertFailed();
4574
4575	LogFlow(("pdmR3DevHlp_VMGetResumeReason: caller='%s'/%d: returns %d\n",
4576	pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
4577	return enmReason;
4578	}
4579
4580
4581	/** @interface_method_impl{PDMDEVHLPR3,pfnGetUVM} */
4582	static DECLCALLBACK(PUVM) pdmR3DevHlp_GetUVM(PPDMDEVINS pDevIns)
4583	{
4584	PDMDEV_ASSERT_DEVINS(pDevIns);
4585
4586	AssertFailed();
4587	LogFlow(("pdmR3DevHlp_GetUVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
4588	return NULL;
4589	}
4590
4591
4592	/** @interface_method_impl{PDMDEVHLPR3,pfnGetVM} */
4593	static DECLCALLBACK(PVMCC) pdmR3DevHlp_GetVM(PPDMDEVINS pDevIns)
4594	{
4595	PDMDEV_ASSERT_DEVINS(pDevIns);
4596
4597	LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns->Internal.s.pDut->pVm));
4598	return pDevIns->Internal.s.pDut->pVm;
4599	}
4600
4601
4602	/** @interface_method_impl{PDMDEVHLPR3,pfnGetVMCPU} */
4603	static DECLCALLBACK(PVMCPU) pdmR3DevHlp_GetVMCPU(PPDMDEVINS pDevIns)
4604	{
4605	PDMDEV_ASSERT_DEVINS(pDevIns);
4606
4607	AssertFailed();
4608	LogFlow(("pdmR3DevHlp_GetVMCPU: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
4609	return NULL;
4610	}
4611
4612
4613	/** @interface_method_impl{PDMDEVHLPR3,pfnGetCurrentCpuId} */
4614	static DECLCALLBACK(VMCPUID) pdmR3DevHlp_GetCurrentCpuId(PPDMDEVINS pDevIns)
4615	{
4616	PDMDEV_ASSERT_DEVINS(pDevIns);
4617
4618	VMCPUID idCpu = 0;
4619	AssertFailed();
4620
4621	LogFlow(("pdmR3DevHlp_GetCurrentCpuId: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, idCpu));
4622	return idCpu;
4623	}
4624
4625
4626	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIBusRegister} */
4627	static DECLCALLBACK(int) pdmR3DevHlp_PCIBusRegister(PPDMDEVINS pDevIns, PPDMPCIBUSREGR3 pPciBusReg,
4628	PCPDMPCIHLPR3 ppPciHlp, uint32_t piBus)
4629	{
4630	PDMDEV_ASSERT_DEVINS(pDevIns);
4631	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: pPciBusReg=%p:{.u32Version=%#x, .pfnRegisterR3=%p, .pfnIORegionRegisterR3=%p, "
4632	".pfnInterceptConfigAccesses=%p, pfnConfigRead=%p, pfnConfigWrite=%p, .pfnSetIrqR3=%p, .u32EndVersion=%#x} ppPciHlpR3=%p piBus=%p\n",
4633	pDevIns->pReg->szName, pDevIns->iInstance, pPciBusReg, pPciBusReg->u32Version, pPciBusReg->pfnRegisterR3,
4634	pPciBusReg->pfnIORegionRegisterR3, pPciBusReg->pfnInterceptConfigAccesses, pPciBusReg->pfnConfigRead,
4635	pPciBusReg->pfnConfigWrite, pPciBusReg->pfnSetIrqR3, pPciBusReg->u32EndVersion, ppPciHlp, piBus));
4636
4637	/*
4638	* Validate the structure and output parameters.
4639	*/
4640	AssertLogRelMsgReturn(pPciBusReg->u32Version == PDM_PCIBUSREGR3_VERSION,
4641	("u32Version=%#x expected %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREGR3_VERSION),
4642	VERR_INVALID_PARAMETER);
4643	AssertPtrReturn(pPciBusReg->pfnRegisterR3, VERR_INVALID_PARAMETER);
4644	AssertPtrNullReturn(pPciBusReg->pfnRegisterMsiR3, VERR_INVALID_POINTER);
4645	AssertPtrReturn(pPciBusReg->pfnIORegionRegisterR3, VERR_INVALID_POINTER);
4646	AssertPtrReturn(pPciBusReg->pfnInterceptConfigAccesses, VERR_INVALID_POINTER);
4647	AssertPtrReturn(pPciBusReg->pfnConfigWrite, VERR_INVALID_POINTER);
4648	AssertPtrReturn(pPciBusReg->pfnConfigRead, VERR_INVALID_POINTER);
4649	AssertPtrReturn(pPciBusReg->pfnSetIrqR3, VERR_INVALID_POINTER);
4650	AssertLogRelMsgReturn(pPciBusReg->u32EndVersion == PDM_PCIBUSREGR3_VERSION,
4651	("u32Version=%#x expected %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREGR3_VERSION),
4652	VERR_INVALID_PARAMETER);
4653	AssertPtrReturn(ppPciHlp, VERR_INVALID_POINTER);
4654	AssertPtrNullReturn(piBus, VERR_INVALID_POINTER);
4655
4656	int rc = VERR_NOT_IMPLEMENTED;
4657	AssertFailed();
4658
4659	Log(("PDM: Registered PCI bus device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
4660
4661	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc piBus=%u\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, piBus));
4662	return rc;
4663	}
4664
4665
4666	/** @interface_method_impl{PDMDEVHLPR3,pfnIommuRegister} */
4667	static DECLCALLBACK(int) pdmR3DevHlp_IommuRegister(PPDMDEVINS pDevIns, PPDMIOMMUREGR3 pIommuReg, PCPDMIOMMUHLPR3 *ppIommuHlp)
4668	{
4669	PDMDEV_ASSERT_DEVINS(pDevIns);
4670	LogFlow(("pdmR3DevHlp_IommuRegister: caller='%s'/%d: pIommuReg=%p:{.u32Version=%#x, .u32TheEnd=%#x } ppIommuHlp=%p\n",
4671	pDevIns->pReg->szName, pDevIns->iInstance, pIommuReg, pIommuReg->u32Version, pIommuReg->u32TheEnd, ppIommuHlp));
4672
4673	/*
4674	* Validate input.
4675	*/
4676	AssertMsgReturn(pIommuReg->u32Version == PDM_IOMMUREGR3_VERSION,
4677	("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIommuReg->u32Version, PDM_IOMMUREGR3_VERSION),
4678	VERR_INVALID_PARAMETER);
4679
4680	/** @todo IOMMU: Validate other parameters */
4681
4682	AssertMsgReturn(pIommuReg->u32TheEnd == PDM_IOMMUREGR3_VERSION,
4683	("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIommuReg->u32TheEnd, PDM_IOMMUREGR3_VERSION),
4684	VERR_INVALID_PARAMETER);
4685	AssertPtrReturn(ppIommuHlp, VERR_INVALID_POINTER);
4686
4687	int rc = VERR_NOT_IMPLEMENTED;
4688	AssertFailed();
4689	Log(("PDM: Registered IOMMU device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
4690
4691	LogFlow(("pdmR3DevHlp_IommuRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4692	return rc;
4693	}
4694
4695
4696	/** @interface_method_impl{PDMDEVHLPR3,pfnPICRegister} */
4697	static DECLCALLBACK(int) pdmR3DevHlp_PICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp)
4698	{
4699	PDMDEV_ASSERT_DEVINS(pDevIns);
4700	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrq=%p, .pfnGetInterrupt=%p, .u32TheEnd=%#x } ppPicHlp=%p\n",
4701	pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrq, pPicReg->pfnGetInterrupt, pPicReg->u32TheEnd, ppPicHlp));
4702
4703	/*
4704	* Validate input.
4705	*/
4706	AssertMsgReturn(pPicReg->u32Version == PDM_PICREG_VERSION,
4707	("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32Version, PDM_PICREG_VERSION),
4708	VERR_INVALID_PARAMETER);
4709	AssertPtrReturn(pPicReg->pfnSetIrq, VERR_INVALID_POINTER);
4710	AssertPtrReturn(pPicReg->pfnGetInterrupt, VERR_INVALID_POINTER);
4711	AssertMsgReturn(pPicReg->u32TheEnd == PDM_PICREG_VERSION,
4712	("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32TheEnd, PDM_PICREG_VERSION),
4713	VERR_INVALID_PARAMETER);
4714	AssertPtrReturn(ppPicHlp, VERR_INVALID_POINTER);
4715
4716	int rc = VERR_NOT_IMPLEMENTED;
4717	AssertFailed();
4718	Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
4719
4720	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4721	return rc;
4722	}
4723
4724
4725	/** @interface_method_impl{PDMDEVHLPR3,pfnApicRegister} */
4726	static DECLCALLBACK(int) pdmR3DevHlp_ApicRegister(PPDMDEVINS pDevIns)
4727	{
4728	PDMDEV_ASSERT_DEVINS(pDevIns);
4729
4730	int rc = VERR_NOT_IMPLEMENTED;
4731	AssertFailed();
4732
4733	LogFlow(("pdmR3DevHlp_ApicRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4734	return rc;
4735	}
4736
4737
4738	/** @interface_method_impl{PDMDEVHLPR3,pfnIoApicRegister} */
4739	static DECLCALLBACK(int) pdmR3DevHlp_IoApicRegister(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp)
4740	{
4741	PDMDEV_ASSERT_DEVINS(pDevIns);
4742	LogFlow(("pdmR3DevHlp_IoApicRegister: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrq=%p, .pfnSendMsi=%p, .pfnSetEoi=%p, .u32TheEnd=%#x } ppIoApicHlp=%p\n",
4743	pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrq, pIoApicReg->pfnSendMsi, pIoApicReg->pfnSetEoi, pIoApicReg->u32TheEnd, ppIoApicHlp));
4744
4745	/*
4746	* Validate input.
4747	*/
4748	AssertMsgReturn(pIoApicReg->u32Version == PDM_IOAPICREG_VERSION,
4749	("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg->u32Version, PDM_IOAPICREG_VERSION),
4750	VERR_VERSION_MISMATCH);
4751	AssertPtrReturn(pIoApicReg->pfnSetIrq, VERR_INVALID_POINTER);
4752	AssertPtrReturn(pIoApicReg->pfnSendMsi, VERR_INVALID_POINTER);
4753	AssertPtrReturn(pIoApicReg->pfnSetEoi, VERR_INVALID_POINTER);
4754	AssertMsgReturn(pIoApicReg->u32TheEnd == PDM_IOAPICREG_VERSION,
4755	("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg->u32TheEnd, PDM_IOAPICREG_VERSION),
4756	VERR_VERSION_MISMATCH);
4757	AssertPtrReturn(ppIoApicHlp, VERR_INVALID_POINTER);
4758
4759	int rc = VERR_NOT_IMPLEMENTED;
4760	AssertFailed();
4761
4762	LogFlow(("pdmR3DevHlp_IoApicRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4763	return rc;
4764	}
4765
4766
4767	/** @interface_method_impl{PDMDEVHLPR3,pfnHpetRegister} */
4768	static DECLCALLBACK(int) pdmR3DevHlp_HpetRegister(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3)
4769	{
4770	PDMDEV_ASSERT_DEVINS(pDevIns);
4771	LogFlow(("pdmR3DevHlp_HpetRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
4772
4773	/*
4774	* Validate input.
4775	*/
4776	AssertMsgReturn(pHpetReg->u32Version == PDM_HPETREG_VERSION,
4777	("%s/%u: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pHpetReg->u32Version, PDM_HPETREG_VERSION),
4778	VERR_VERSION_MISMATCH);
4779	AssertPtrReturn(ppHpetHlpR3, VERR_INVALID_POINTER);
4780
4781	int rc = VERR_NOT_IMPLEMENTED;
4782	AssertFailed();
4783
4784	LogFlow(("pdmR3DevHlp_HpetRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4785	return rc;
4786	}
4787
4788
4789	/** @interface_method_impl{PDMDEVHLPR3,pfnPciRawRegister} */
4790	static DECLCALLBACK(int) pdmR3DevHlp_PciRawRegister(PPDMDEVINS pDevIns, PPDMPCIRAWREG pPciRawReg, PCPDMPCIRAWHLPR3 *ppPciRawHlpR3)
4791	{
4792	PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
4793	LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
4794
4795	/*
4796	* Validate input.
4797	*/
4798	if (pPciRawReg->u32Version != PDM_PCIRAWREG_VERSION)
4799	{
4800	AssertMsgFailed(("u32Version=%#x expected %#x\n", pPciRawReg->u32Version, PDM_PCIRAWREG_VERSION));
4801	LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4802	return VERR_INVALID_PARAMETER;
4803	}
4804
4805	if (!ppPciRawHlpR3)
4806	{
4807	Assert(ppPciRawHlpR3);
4808	LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc (ppPciRawHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4809	return VERR_INVALID_PARAMETER;
4810	}
4811
4812	int rc = VERR_NOT_IMPLEMENTED;
4813	AssertFailed();
4814
4815	LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4816	return rc;
4817	}
4818
4819
4820	/** @interface_method_impl{PDMDEVHLPR3,pfnDMACRegister} */
4821	static DECLCALLBACK(int) pdmR3DevHlp_DMACRegister(PPDMDEVINS pDevIns, PPDMDMACREG pDmacReg, PCPDMDMACHLP *ppDmacHlp)
4822	{
4823	PDMDEV_ASSERT_DEVINS(pDevIns);
4824	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",
4825	pDevIns->pReg->szName, pDevIns->iInstance, pDmacReg, pDmacReg->u32Version, pDmacReg->pfnRun, pDmacReg->pfnRegister,
4826	pDmacReg->pfnReadMemory, pDmacReg->pfnWriteMemory, pDmacReg->pfnSetDREQ, pDmacReg->pfnGetChannelMode, ppDmacHlp));
4827
4828	/*
4829	* Validate input.
4830	*/
4831	if (pDmacReg->u32Version != PDM_DMACREG_VERSION)
4832	{
4833	AssertMsgFailed(("u32Version=%#x expected %#x\n", pDmacReg->u32Version,
4834	PDM_DMACREG_VERSION));
4835	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (version)\n",
4836	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4837	return VERR_INVALID_PARAMETER;
4838	}
4839	if ( !pDmacReg->pfnRun
4840	\|\| !pDmacReg->pfnRegister
4841	\|\| !pDmacReg->pfnReadMemory
4842	\|\| !pDmacReg->pfnWriteMemory
4843	\|\| !pDmacReg->pfnSetDREQ
4844	\|\| !pDmacReg->pfnGetChannelMode)
4845	{
4846	Assert(pDmacReg->pfnRun);
4847	Assert(pDmacReg->pfnRegister);
4848	Assert(pDmacReg->pfnReadMemory);
4849	Assert(pDmacReg->pfnWriteMemory);
4850	Assert(pDmacReg->pfnSetDREQ);
4851	Assert(pDmacReg->pfnGetChannelMode);
4852	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
4853	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4854	return VERR_INVALID_PARAMETER;
4855	}
4856
4857	if (!ppDmacHlp)
4858	{
4859	Assert(ppDmacHlp);
4860	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (ppDmacHlp)\n",
4861	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4862	return VERR_INVALID_PARAMETER;
4863	}
4864
4865	int rc = VERR_NOT_IMPLEMENTED;
4866	AssertFailed();
4867
4868	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc\n",
4869	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4870	return rc;
4871	}
4872
4873
4874	/**
4875	* @copydoc PDMDEVHLPR3::pfnRegisterVMMDevHeap
4876	*/
4877	static DECLCALLBACK(int) pdmR3DevHlp_RegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbHeap)
4878	{
4879	PDMDEV_ASSERT_DEVINS(pDevIns);
4880	LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: GCPhys=%RGp pvHeap=%p cbHeap=%#x\n",
4881	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvHeap, cbHeap));
4882
4883	int rc = VERR_NOT_IMPLEMENTED;
4884	AssertFailed();
4885
4886	LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: returns %Rrc\n",
4887	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4888	return rc;
4889	}
4890
4891
4892	/**
4893	* @interface_method_impl{PDMDEVHLPR3,pfnFirmwareRegister}
4894	*/
4895	static DECLCALLBACK(int) pdmR3DevHlp_FirmwareRegister(PPDMDEVINS pDevIns, PCPDMFWREG pFwReg, PCPDMFWHLPR3 *ppFwHlp)
4896	{
4897	PDMDEV_ASSERT_DEVINS(pDevIns);
4898	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: pFWReg=%p:{.u32Version=%#x, .pfnIsHardReset=%p, .u32TheEnd=%#x} ppFwHlp=%p\n",
4899	pDevIns->pReg->szName, pDevIns->iInstance, pFwReg, pFwReg->u32Version, pFwReg->pfnIsHardReset, pFwReg->u32TheEnd, ppFwHlp));
4900
4901	/*
4902	* Validate input.
4903	*/
4904	if (pFwReg->u32Version != PDM_FWREG_VERSION)
4905	{
4906	AssertMsgFailed(("u32Version=%#x expected %#x\n", pFwReg->u32Version, PDM_FWREG_VERSION));
4907	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (version)\n",
4908	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4909	return VERR_INVALID_PARAMETER;
4910	}
4911	if (!pFwReg->pfnIsHardReset)
4912	{
4913	Assert(pFwReg->pfnIsHardReset);
4914	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
4915	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4916	return VERR_INVALID_PARAMETER;
4917	}
4918
4919	if (!ppFwHlp)
4920	{
4921	Assert(ppFwHlp);
4922	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (ppFwHlp)\n",
4923	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4924	return VERR_INVALID_PARAMETER;
4925	}
4926
4927	int rc = VERR_NOT_IMPLEMENTED;
4928	AssertFailed();
4929
4930	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc\n",
4931	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4932	return rc;
4933	}
4934
4935
4936	/** @interface_method_impl{PDMDEVHLPR3,pfnVMReset} */
4937	static DECLCALLBACK(int) pdmR3DevHlp_VMReset(PPDMDEVINS pDevIns, uint32_t fFlags)
4938	{
4939	PDMDEV_ASSERT_DEVINS(pDevIns);
4940	LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: fFlags=%#x\n",
4941	pDevIns->pReg->szName, pDevIns->iInstance, fFlags));
4942
4943	int rc = VERR_NOT_IMPLEMENTED;
4944	AssertFailed();
4945
4946	LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4947	return rc;
4948	}
4949
4950
4951	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspend} */
4952	static DECLCALLBACK(int) pdmR3DevHlp_VMSuspend(PPDMDEVINS pDevIns)
4953	{
4954	PDMDEV_ASSERT_DEVINS(pDevIns);
4955	LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d:\n",
4956	pDevIns->pReg->szName, pDevIns->iInstance));
4957
4958	int rc = VERR_NOT_IMPLEMENTED;
4959	AssertFailed();
4960
4961	LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4962	return rc;
4963	}
4964
4965
4966	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspendSaveAndPowerOff} */
4967	static DECLCALLBACK(int) pdmR3DevHlp_VMSuspendSaveAndPowerOff(PPDMDEVINS pDevIns)
4968	{
4969	PDMDEV_ASSERT_DEVINS(pDevIns);
4970	LogFlow(("pdmR3DevHlp_VMSuspendSaveAndPowerOff: caller='%s'/%d:\n",
4971	pDevIns->pReg->szName, pDevIns->iInstance));
4972
4973	int rc = VERR_NOT_IMPLEMENTED;
4974	AssertFailed();
4975
4976	LogFlow(("pdmR3DevHlp_VMSuspendSaveAndPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4977	return rc;
4978	}
4979
4980
4981	/** @interface_method_impl{PDMDEVHLPR3,pfnVMPowerOff} */
4982	static DECLCALLBACK(int) pdmR3DevHlp_VMPowerOff(PPDMDEVINS pDevIns)
4983	{
4984	PDMDEV_ASSERT_DEVINS(pDevIns);
4985	LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d:\n",
4986	pDevIns->pReg->szName, pDevIns->iInstance));
4987
4988	int rc = VERR_NOT_IMPLEMENTED;
4989	AssertFailed();
4990
4991	LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4992	return rc;
4993	}
4994
4995
4996	/** @interface_method_impl{PDMDEVHLPR3,pfnA20IsEnabled} */
4997	static DECLCALLBACK(bool) pdmR3DevHlp_A20IsEnabled(PPDMDEVINS pDevIns)
4998	{
4999	PDMDEV_ASSERT_DEVINS(pDevIns);
5000
5001	bool fRc = false;
5002	AssertFailed();
5003
5004	LogFlow(("pdmR3DevHlp_A20IsEnabled: caller='%s'/%d: returns %d\n", pDevIns->pReg->szName, pDevIns->iInstance, fRc));
5005	return fRc;
5006	}
5007
5008
5009	/** @interface_method_impl{PDMDEVHLPR3,pfnA20Set} */
5010	static DECLCALLBACK(void) pdmR3DevHlp_A20Set(PPDMDEVINS pDevIns, bool fEnable)
5011	{
5012	PDMDEV_ASSERT_DEVINS(pDevIns);
5013	LogFlow(("pdmR3DevHlp_A20Set: caller='%s'/%d: fEnable=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, fEnable));
5014	AssertFailed();
5015	}
5016
5017
5018	/** @interface_method_impl{PDMDEVHLPR3,pfnGetCpuId} */
5019	static DECLCALLBACK(void) pdmR3DevHlp_GetCpuId(PPDMDEVINS pDevIns, uint32_t iLeaf,
5020	uint32_t pEax, uint32_t pEbx, uint32_t pEcx, uint32_t pEdx)
5021	{
5022	PDMDEV_ASSERT_DEVINS(pDevIns);
5023	LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: iLeaf=%d pEax=%p pEbx=%p pEcx=%p pEdx=%p\n",
5024	pDevIns->pReg->szName, pDevIns->iInstance, iLeaf, pEax, pEbx, pEcx, pEdx));
5025	AssertPtr(pEax); AssertPtr(pEbx); AssertPtr(pEcx); AssertPtr(pEdx);
5026
5027	AssertFailed();
5028
5029	LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: returns void - pEax=%#x pEbx=%#x pEcx=%#x pEdx=%#x\n",
5030	pDevIns->pReg->szName, pDevIns->iInstance, pEax, pEbx, pEcx, pEdx));
5031	}
5032
5033	const PDMDEVHLPR3 g_tstDevPdmDevHlpR3 =
5034	{
5035	PDM_DEVHLPR3_VERSION,
5036	pdmR3DevHlp_IoPortCreateEx,
5037	pdmR3DevHlp_IoPortMap,
5038	pdmR3DevHlp_IoPortUnmap,
5039	pdmR3DevHlp_IoPortGetMappingAddress,
5040	pdmR3DevHlp_MmioCreateEx,
5041	pdmR3DevHlp_MmioMap,
5042	pdmR3DevHlp_MmioUnmap,
5043	pdmR3DevHlp_MmioReduce,
5044	pdmR3DevHlp_MmioGetMappingAddress,
5045	pdmR3DevHlp_Mmio2Create,
5046	pdmR3DevHlp_Mmio2Destroy,
5047	pdmR3DevHlp_Mmio2Map,
5048	pdmR3DevHlp_Mmio2Unmap,
5049	pdmR3DevHlp_Mmio2Reduce,
5050	pdmR3DevHlp_Mmio2GetMappingAddress,
5051	pdmR3DevHlp_Mmio2ChangeRegionNo,
5052	pdmR3DevHlp_ROMRegister,
5053	pdmR3DevHlp_ROMProtectShadow,
5054	pdmR3DevHlp_SSMRegister,
5055	pdmR3DevHlp_SSMPutStruct,
5056	pdmR3DevHlp_SSMPutStructEx,
5057	pdmR3DevHlp_SSMPutBool,
5058	pdmR3DevHlp_SSMPutU8,
5059	pdmR3DevHlp_SSMPutS8,
5060	pdmR3DevHlp_SSMPutU16,
5061	pdmR3DevHlp_SSMPutS16,
5062	pdmR3DevHlp_SSMPutU32,
5063	pdmR3DevHlp_SSMPutS32,
5064	pdmR3DevHlp_SSMPutU64,
5065	pdmR3DevHlp_SSMPutS64,
5066	pdmR3DevHlp_SSMPutU128,
5067	pdmR3DevHlp_SSMPutS128,
5068	pdmR3DevHlp_SSMPutUInt,
5069	pdmR3DevHlp_SSMPutSInt,
5070	pdmR3DevHlp_SSMPutGCUInt,
5071	pdmR3DevHlp_SSMPutGCUIntReg,
5072	pdmR3DevHlp_SSMPutGCPhys32,
5073	pdmR3DevHlp_SSMPutGCPhys64,
5074	pdmR3DevHlp_SSMPutGCPhys,
5075	pdmR3DevHlp_SSMPutGCPtr,
5076	pdmR3DevHlp_SSMPutGCUIntPtr,
5077	pdmR3DevHlp_SSMPutRCPtr,
5078	pdmR3DevHlp_SSMPutIOPort,
5079	pdmR3DevHlp_SSMPutSel,
5080	pdmR3DevHlp_SSMPutMem,
5081	pdmR3DevHlp_SSMPutStrZ,
5082	pdmR3DevHlp_SSMGetStruct,
5083	pdmR3DevHlp_SSMGetStructEx,
5084	pdmR3DevHlp_SSMGetBool,
5085	pdmR3DevHlp_SSMGetBoolV,
5086	pdmR3DevHlp_SSMGetU8,
5087	pdmR3DevHlp_SSMGetU8V,
5088	pdmR3DevHlp_SSMGetS8,
5089	pdmR3DevHlp_SSMGetS8V,
5090	pdmR3DevHlp_SSMGetU16,
5091	pdmR3DevHlp_SSMGetU16V,
5092	pdmR3DevHlp_SSMGetS16,
5093	pdmR3DevHlp_SSMGetS16V,
5094	pdmR3DevHlp_SSMGetU32,
5095	pdmR3DevHlp_SSMGetU32V,
5096	pdmR3DevHlp_SSMGetS32,
5097	pdmR3DevHlp_SSMGetS32V,
5098	pdmR3DevHlp_SSMGetU64,
5099	pdmR3DevHlp_SSMGetU64V,
5100	pdmR3DevHlp_SSMGetS64,
5101	pdmR3DevHlp_SSMGetS64V,
5102	pdmR3DevHlp_SSMGetU128,
5103	pdmR3DevHlp_SSMGetU128V,
5104	pdmR3DevHlp_SSMGetS128,
5105	pdmR3DevHlp_SSMGetS128V,
5106	pdmR3DevHlp_SSMGetGCPhys32,
5107	pdmR3DevHlp_SSMGetGCPhys32V,
5108	pdmR3DevHlp_SSMGetGCPhys64,
5109	pdmR3DevHlp_SSMGetGCPhys64V,
5110	pdmR3DevHlp_SSMGetGCPhys,
5111	pdmR3DevHlp_SSMGetGCPhysV,
5112	pdmR3DevHlp_SSMGetUInt,
5113	pdmR3DevHlp_SSMGetSInt,
5114	pdmR3DevHlp_SSMGetGCUInt,
5115	pdmR3DevHlp_SSMGetGCUIntReg,
5116	pdmR3DevHlp_SSMGetGCPtr,
5117	pdmR3DevHlp_SSMGetGCUIntPtr,
5118	pdmR3DevHlp_SSMGetRCPtr,
5119	pdmR3DevHlp_SSMGetIOPort,
5120	pdmR3DevHlp_SSMGetSel,
5121	pdmR3DevHlp_SSMGetMem,
5122	pdmR3DevHlp_SSMGetStrZ,
5123	pdmR3DevHlp_SSMGetStrZEx,
5124	pdmR3DevHlp_SSMSkip,
5125	pdmR3DevHlp_SSMSkipToEndOfUnit,
5126	pdmR3DevHlp_SSMSetLoadError,
5127	pdmR3DevHlp_SSMSetLoadErrorV,
5128	pdmR3DevHlp_SSMSetCfgError,
5129	pdmR3DevHlp_SSMSetCfgErrorV,
5130	pdmR3DevHlp_SSMHandleGetStatus,
5131	pdmR3DevHlp_SSMHandleGetAfter,
5132	pdmR3DevHlp_SSMHandleIsLiveSave,
5133	pdmR3DevHlp_SSMHandleMaxDowntime,
5134	pdmR3DevHlp_SSMHandleHostBits,
5135	pdmR3DevHlp_SSMHandleRevision,
5136	pdmR3DevHlp_SSMHandleVersion,
5137	pdmR3DevHlp_SSMHandleHostOSAndArch,
5138	pdmR3DevHlp_TMTimerCreate,
5139	pdmR3DevHlp_TimerCreate,
5140	pdmR3DevHlp_TimerToPtr,
5141	pdmR3DevHlp_TimerFromMicro,
5142	pdmR3DevHlp_TimerFromMilli,
5143	pdmR3DevHlp_TimerFromNano,
5144	pdmR3DevHlp_TimerGet,
5145	pdmR3DevHlp_TimerGetFreq,
5146	pdmR3DevHlp_TimerGetNano,
5147	pdmR3DevHlp_TimerIsActive,
5148	pdmR3DevHlp_TimerIsLockOwner,
5149	pdmR3DevHlp_TimerLockClock,
5150	pdmR3DevHlp_TimerLockClock2,
5151	pdmR3DevHlp_TimerSet,
5152	pdmR3DevHlp_TimerSetFrequencyHint,
5153	pdmR3DevHlp_TimerSetMicro,
5154	pdmR3DevHlp_TimerSetMillies,
5155	pdmR3DevHlp_TimerSetNano,
5156	pdmR3DevHlp_TimerSetRelative,
5157	pdmR3DevHlp_TimerStop,
5158	pdmR3DevHlp_TimerUnlockClock,
5159	pdmR3DevHlp_TimerUnlockClock2,
5160	pdmR3DevHlp_TimerSetCritSect,
5161	pdmR3DevHlp_TimerSave,
5162	pdmR3DevHlp_TimerLoad,
5163	pdmR3DevHlp_TimerDestroy,
5164	pdmR3DevHlp_TimerSkipLoad,
5165	pdmR3DevHlp_TMUtcNow,
5166	pdmR3DevHlp_CFGMExists,
5167	pdmR3DevHlp_CFGMQueryType,
5168	pdmR3DevHlp_CFGMQuerySize,
5169	pdmR3DevHlp_CFGMQueryInteger,
5170	pdmR3DevHlp_CFGMQueryIntegerDef,
5171	pdmR3DevHlp_CFGMQueryString,
5172	pdmR3DevHlp_CFGMQueryStringDef,
5173	pdmR3DevHlp_CFGMQueryBytes,
5174	pdmR3DevHlp_CFGMQueryU64,
5175	pdmR3DevHlp_CFGMQueryU64Def,
5176	pdmR3DevHlp_CFGMQueryS64,
5177	pdmR3DevHlp_CFGMQueryS64Def,
5178	pdmR3DevHlp_CFGMQueryU32,
5179	pdmR3DevHlp_CFGMQueryU32Def,
5180	pdmR3DevHlp_CFGMQueryS32,
5181	pdmR3DevHlp_CFGMQueryS32Def,
5182	pdmR3DevHlp_CFGMQueryU16,
5183	pdmR3DevHlp_CFGMQueryU16Def,
5184	pdmR3DevHlp_CFGMQueryS16,
5185	pdmR3DevHlp_CFGMQueryS16Def,
5186	pdmR3DevHlp_CFGMQueryU8,
5187	pdmR3DevHlp_CFGMQueryU8Def,
5188	pdmR3DevHlp_CFGMQueryS8,
5189	pdmR3DevHlp_CFGMQueryS8Def,
5190	pdmR3DevHlp_CFGMQueryBool,
5191	pdmR3DevHlp_CFGMQueryBoolDef,
5192	pdmR3DevHlp_CFGMQueryPort,
5193	pdmR3DevHlp_CFGMQueryPortDef,
5194	pdmR3DevHlp_CFGMQueryUInt,
5195	pdmR3DevHlp_CFGMQueryUIntDef,
5196	pdmR3DevHlp_CFGMQuerySInt,
5197	pdmR3DevHlp_CFGMQuerySIntDef,
5198	pdmR3DevHlp_CFGMQueryPtr,
5199	pdmR3DevHlp_CFGMQueryPtrDef,
5200	pdmR3DevHlp_CFGMQueryGCPtr,
5201	pdmR3DevHlp_CFGMQueryGCPtrDef,
5202	pdmR3DevHlp_CFGMQueryGCPtrU,
5203	pdmR3DevHlp_CFGMQueryGCPtrUDef,
5204	pdmR3DevHlp_CFGMQueryGCPtrS,
5205	pdmR3DevHlp_CFGMQueryGCPtrSDef,
5206	pdmR3DevHlp_CFGMQueryStringAlloc,
5207	pdmR3DevHlp_CFGMQueryStringAllocDef,
5208	pdmR3DevHlp_CFGMGetParent,
5209	pdmR3DevHlp_CFGMGetChild,
5210	pdmR3DevHlp_CFGMGetChildF,
5211	pdmR3DevHlp_CFGMGetChildFV,
5212	pdmR3DevHlp_CFGMGetFirstChild,
5213	pdmR3DevHlp_CFGMGetNextChild,
5214	pdmR3DevHlp_CFGMGetName,
5215	pdmR3DevHlp_CFGMGetNameLen,
5216	pdmR3DevHlp_CFGMAreChildrenValid,
5217	pdmR3DevHlp_CFGMGetFirstValue,
5218	pdmR3DevHlp_CFGMGetNextValue,
5219	pdmR3DevHlp_CFGMGetValueName,
5220	pdmR3DevHlp_CFGMGetValueNameLen,
5221	pdmR3DevHlp_CFGMGetValueType,
5222	pdmR3DevHlp_CFGMAreValuesValid,
5223	pdmR3DevHlp_CFGMValidateConfig,
5224	pdmR3DevHlp_PhysRead,
5225	pdmR3DevHlp_PhysWrite,
5226	pdmR3DevHlp_PhysGCPhys2CCPtr,
5227	pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly,
5228	pdmR3DevHlp_PhysReleasePageMappingLock,
5229	pdmR3DevHlp_PhysReadGCVirt,
5230	pdmR3DevHlp_PhysWriteGCVirt,
5231	pdmR3DevHlp_PhysGCPtr2GCPhys,
5232	pdmR3DevHlp_MMHeapAlloc,
5233	pdmR3DevHlp_MMHeapAllocZ,
5234	pdmR3DevHlp_MMHeapFree,
5235	pdmR3DevHlp_VMState,
5236	pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet,
5237	pdmR3DevHlp_VMSetError,
5238	pdmR3DevHlp_VMSetErrorV,
5239	pdmR3DevHlp_VMSetRuntimeError,
5240	pdmR3DevHlp_VMSetRuntimeErrorV,
5241	pdmR3DevHlp_DBGFStopV,
5242	pdmR3DevHlp_DBGFInfoRegister,
5243	pdmR3DevHlp_DBGFInfoRegisterArgv,
5244	pdmR3DevHlp_DBGFRegRegister,
5245	pdmR3DevHlp_DBGFTraceBuf,
5246	pdmR3DevHlp_STAMRegister,
5247	pdmR3DevHlp_STAMRegisterV,
5248	pdmR3DevHlp_PCIRegister,
5249	pdmR3DevHlp_PCIRegisterMsi,
5250	pdmR3DevHlp_PCIIORegionRegister,
5251	pdmR3DevHlp_PCIInterceptConfigAccesses,
5252	pdmR3DevHlp_PCIConfigWrite,
5253	pdmR3DevHlp_PCIConfigRead,
5254	pdmR3DevHlp_PCIPhysRead,
5255	pdmR3DevHlp_PCIPhysWrite,
5256	pdmR3DevHlp_PCISetIrq,
5257	pdmR3DevHlp_PCISetIrqNoWait,
5258	pdmR3DevHlp_ISASetIrq,
5259	pdmR3DevHlp_ISASetIrqNoWait,
5260	pdmR3DevHlp_IoApicSendMsi,
5261	pdmR3DevHlp_DriverAttach,
5262	pdmR3DevHlp_DriverDetach,
5263	pdmR3DevHlp_DriverReconfigure,
5264	pdmR3DevHlp_QueueCreatePtr,
5265	pdmR3DevHlp_QueueCreate,
5266	pdmR3DevHlp_QueueToPtr,
5267	pdmR3DevHlp_QueueAlloc,
5268	pdmR3DevHlp_QueueInsert,
5269	pdmR3DevHlp_QueueInsertEx,
5270	pdmR3DevHlp_QueueFlushIfNecessary,
5271	pdmR3DevHlp_TaskCreate,
5272	pdmR3DevHlp_TaskTrigger,
5273	pdmR3DevHlp_SUPSemEventCreate,
5274	pdmR3DevHlp_SUPSemEventClose,
5275	pdmR3DevHlp_SUPSemEventSignal,
5276	pdmR3DevHlp_SUPSemEventWaitNoResume,
5277	pdmR3DevHlp_SUPSemEventWaitNsAbsIntr,
5278	pdmR3DevHlp_SUPSemEventWaitNsRelIntr,
5279	pdmR3DevHlp_SUPSemEventGetResolution,
5280	pdmR3DevHlp_SUPSemEventMultiCreate,
5281	pdmR3DevHlp_SUPSemEventMultiClose,
5282	pdmR3DevHlp_SUPSemEventMultiSignal,
5283	pdmR3DevHlp_SUPSemEventMultiReset,
5284	pdmR3DevHlp_SUPSemEventMultiWaitNoResume,
5285	pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr,
5286	pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr,
5287	pdmR3DevHlp_SUPSemEventMultiGetResolution,
5288	pdmR3DevHlp_CritSectInit,
5289	pdmR3DevHlp_CritSectGetNop,
5290	pdmR3DevHlp_CritSectGetNopR0,
5291	pdmR3DevHlp_CritSectGetNopRC,
5292	pdmR3DevHlp_SetDeviceCritSect,
5293	pdmR3DevHlp_CritSectYield,
5294	pdmR3DevHlp_CritSectEnter,
5295	pdmR3DevHlp_CritSectEnterDebug,
5296	pdmR3DevHlp_CritSectTryEnter,
5297	pdmR3DevHlp_CritSectTryEnterDebug,
5298	pdmR3DevHlp_CritSectLeave,
5299	pdmR3DevHlp_CritSectIsOwner,
5300	pdmR3DevHlp_CritSectIsInitialized,
5301	pdmR3DevHlp_CritSectHasWaiters,
5302	pdmR3DevHlp_CritSectGetRecursion,
5303	pdmR3DevHlp_CritSectScheduleExitEvent,
5304	pdmR3DevHlp_CritSectDelete,
5305	pdmR3DevHlp_ThreadCreate,
5306	pdmR3DevHlp_ThreadDestroy,
5307	pdmR3DevHlp_ThreadIAmSuspending,
5308	pdmR3DevHlp_ThreadIamRunning,
5309	pdmR3DevHlp_ThreadSleep,
5310	pdmR3DevHlp_ThreadSuspend,
5311	pdmR3DevHlp_ThreadResume,
5312	pdmR3DevHlp_SetAsyncNotification,
5313	pdmR3DevHlp_AsyncNotificationCompleted,
5314	pdmR3DevHlp_RTCRegister,
5315	pdmR3DevHlp_PCIBusRegister,
5316	pdmR3DevHlp_IommuRegister,
5317	pdmR3DevHlp_PICRegister,
5318	pdmR3DevHlp_ApicRegister,
5319	pdmR3DevHlp_IoApicRegister,
5320	pdmR3DevHlp_HpetRegister,
5321	pdmR3DevHlp_PciRawRegister,
5322	pdmR3DevHlp_DMACRegister,
5323	pdmR3DevHlp_DMARegister,
5324	pdmR3DevHlp_DMAReadMemory,
5325	pdmR3DevHlp_DMAWriteMemory,
5326	pdmR3DevHlp_DMASetDREQ,
5327	pdmR3DevHlp_DMAGetChannelMode,
5328	pdmR3DevHlp_DMASchedule,
5329	pdmR3DevHlp_CMOSWrite,
5330	pdmR3DevHlp_CMOSRead,
5331	pdmR3DevHlp_AssertEMT,
5332	pdmR3DevHlp_AssertOther,
5333	pdmR3DevHlp_LdrGetRCInterfaceSymbols,
5334	pdmR3DevHlp_LdrGetR0InterfaceSymbols,
5335	pdmR3DevHlp_CallR0,
5336	pdmR3DevHlp_VMGetSuspendReason,
5337	pdmR3DevHlp_VMGetResumeReason,
5338	pdmR3DevHlp_PhysBulkGCPhys2CCPtr,
5339	pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly,
5340	pdmR3DevHlp_PhysBulkReleasePageMappingLocks,
5341	pdmR3DevHlp_CpuGetGuestMicroarch,
5342	NULL,
5343	NULL,
5344	NULL,
5345	NULL,
5346	NULL,
5347	NULL,
5348	NULL,
5349	NULL,
5350	NULL,
5351	NULL,
5352	pdmR3DevHlp_GetUVM,
5353	pdmR3DevHlp_GetVM,
5354	pdmR3DevHlp_GetVMCPU,
5355	pdmR3DevHlp_GetCurrentCpuId,
5356	pdmR3DevHlp_RegisterVMMDevHeap,
5357	pdmR3DevHlp_FirmwareRegister,
5358	pdmR3DevHlp_VMReset,
5359	pdmR3DevHlp_VMSuspend,
5360	pdmR3DevHlp_VMSuspendSaveAndPowerOff,
5361	pdmR3DevHlp_VMPowerOff,
5362	pdmR3DevHlp_A20IsEnabled,
5363	pdmR3DevHlp_A20Set,
5364	pdmR3DevHlp_GetCpuId,
5365	pdmR3DevHlp_TMTimeVirtGet,
5366	pdmR3DevHlp_TMTimeVirtGetFreq,
5367	pdmR3DevHlp_TMTimeVirtGetNano,
5368	pdmR3DevHlp_GetSupDrvSession,
5369	pdmR3DevHlp_QueryGenericUserObject,
5370	pdmR3DevHlp_PGMHandlerPhysicalTypeRegister,
5371	PDM_DEVHLPR3_VERSION /* the end */
5372	};
5373

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

source: vbox/trunk/src/VBox/Devices/testcase/tstDevicePdmDevHlp.cpp@ 83281

Download in other formats: