tstDevicePdmDevHlp.cpp@ 84067

Last change on this file since 84067 was 83296, checked in by vboxsync, 5 years ago
Devices/tstDevice: Copy over and modify PDMThread* API so we can fuzz saved states of device s which delegate some parts of the saved state loading to workers
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 183.2 KB

Line
1	/* $Id: tstDevicePdmDevHlp.cpp 83296 2020-03-16 11:43:32Z 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	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
2710	int rc = VERR_NOT_IMPLEMENTED;
2711	AssertFailed();
2712	#else
2713	int rc = VINF_SUCCESS;
2714	#endif
2715
2716	LogRel(("pdmR3DevHlp_PGMHandlerPhysicalTypeRegister: caller='%s'/%d: returns %Rrc\n",
2717	pDevIns->pReg->szName, pDevIns->iInstance, rc));
2718	return rc;
2719	}
2720
2721
2722	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysRead} */
2723	static DECLCALLBACK(int) pdmR3DevHlp_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
2724	{
2725	PDMDEV_ASSERT_DEVINS(pDevIns);
2726	LogFlow(("pdmR3DevHlp_PhysRead: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbRead=%#x\n",
2727	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
2728
2729	VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;;
2730	AssertFailed();
2731
2732	Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
2733	return VBOXSTRICTRC_VAL(rcStrict);
2734	}
2735
2736
2737	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWrite} */
2738	static DECLCALLBACK(int) pdmR3DevHlp_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
2739	{
2740	PDMDEV_ASSERT_DEVINS(pDevIns);
2741	LogFlow(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbWrite=%#x\n",
2742	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
2743
2744	VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;;
2745	AssertFailed();
2746
2747	Log(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
2748	return VBOXSTRICTRC_VAL(rcStrict);
2749	}
2750
2751
2752	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtr} */
2753	static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtr(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, void **ppv, PPGMPAGEMAPLOCK pLock)
2754	{
2755	PDMDEV_ASSERT_DEVINS(pDevIns);
2756	LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
2757	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
2758	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
2759
2760	int rc = VERR_NOT_IMPLEMENTED;;
2761	AssertFailed();
2762
2763	Log(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2764	return rc;
2765	}
2766
2767
2768	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtrReadOnly} */
2769	static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, const void **ppv, PPGMPAGEMAPLOCK pLock)
2770	{
2771	PDMDEV_ASSERT_DEVINS(pDevIns);
2772	LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
2773	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
2774	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
2775
2776	int rc = VERR_NOT_IMPLEMENTED;;
2777	AssertFailed();
2778
2779	Log(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2780	return rc;
2781	}
2782
2783
2784	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReleasePageMappingLock} */
2785	static DECLCALLBACK(void) pdmR3DevHlp_PhysReleasePageMappingLock(PPDMDEVINS pDevIns, PPGMPAGEMAPLOCK pLock)
2786	{
2787	PDMDEV_ASSERT_DEVINS(pDevIns);
2788	LogFlow(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: pLock=%p\n",
2789	pDevIns->pReg->szName, pDevIns->iInstance, pLock));
2790
2791	AssertFailed();
2792
2793	Log(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
2794	}
2795
2796
2797	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysBulkGCPhys2CCPtr} */
2798	static DECLCALLBACK(int) pdmR3DevHlp_PhysBulkGCPhys2CCPtr(PPDMDEVINS pDevIns, uint32_t cPages, PCRTGCPHYS paGCPhysPages,
2799	uint32_t fFlags, void **papvPages, PPGMPAGEMAPLOCK paLocks)
2800	{
2801	PDMDEV_ASSERT_DEVINS(pDevIns);
2802	LogFlow(("pdmR3DevHlp_PhysBulkGCPhys2CCPtr: caller='%s'/%d: cPages=%#x paGCPhysPages=%p (%RGp,..) fFlags=%#x papvPages=%p paLocks=%p\n",
2803	pDevIns->pReg->szName, pDevIns->iInstance, cPages, paGCPhysPages, paGCPhysPages[0], fFlags, papvPages, paLocks));
2804	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
2805	AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
2806
2807	int rc = VERR_NOT_IMPLEMENTED;;
2808	AssertFailed();
2809
2810	Log(("pdmR3DevHlp_PhysBulkGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2811	return rc;
2812	}
2813
2814
2815	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysBulkGCPhys2CCPtrReadOnly} */
2816	static DECLCALLBACK(int) pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, uint32_t cPages, PCRTGCPHYS paGCPhysPages,
2817	uint32_t fFlags, const void **papvPages, PPGMPAGEMAPLOCK paLocks)
2818	{
2819	PDMDEV_ASSERT_DEVINS(pDevIns);
2820	LogFlow(("pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly: caller='%s'/%d: cPages=%#x paGCPhysPages=%p (%RGp,...) fFlags=%#x papvPages=%p paLocks=%p\n",
2821	pDevIns->pReg->szName, pDevIns->iInstance, cPages, paGCPhysPages, paGCPhysPages[0], fFlags, papvPages, paLocks));
2822	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
2823	AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
2824
2825	int rc = VERR_NOT_IMPLEMENTED;;
2826	AssertFailed();
2827
2828	Log(("pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2829	return rc;
2830	}
2831
2832
2833	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysBulkReleasePageMappingLocks} */
2834	static DECLCALLBACK(void) pdmR3DevHlp_PhysBulkReleasePageMappingLocks(PPDMDEVINS pDevIns, uint32_t cPages, PPGMPAGEMAPLOCK paLocks)
2835	{
2836	PDMDEV_ASSERT_DEVINS(pDevIns);
2837	LogFlow(("pdmR3DevHlp_PhysBulkReleasePageMappingLocks: caller='%s'/%d: cPages=%#x paLocks=%p\n",
2838	pDevIns->pReg->szName, pDevIns->iInstance, cPages, paLocks));
2839	Assert(cPages > 0);
2840
2841	AssertFailed();
2842
2843	Log(("pdmR3DevHlp_PhysBulkReleasePageMappingLocks: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
2844	}
2845
2846
2847	/** @interface_method_impl{PDMDEVHLPR3,pfnCpuGetGuestMicroarch} */
2848	static DECLCALLBACK(CPUMMICROARCH) pdmR3DevHlp_CpuGetGuestMicroarch(PPDMDEVINS pDevIns)
2849	{
2850	PDMDEV_ASSERT_DEVINS(pDevIns);
2851	LogFlow(("pdmR3DevHlp_CpuGetGuestMicroarch: caller='%s'/%d\n",
2852	pDevIns->pReg->szName, pDevIns->iInstance));
2853
2854	CPUMMICROARCH enmMicroarch = kCpumMicroarch_Intel_P6;
2855
2856	Log(("pdmR3DevHlp_CpuGetGuestMicroarch: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, enmMicroarch));
2857	return enmMicroarch;
2858	}
2859
2860
2861	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReadGCVirt} */
2862	static DECLCALLBACK(int) pdmR3DevHlp_PhysReadGCVirt(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb)
2863	{
2864	PDMDEV_ASSERT_DEVINS(pDevIns);
2865	LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: pvDst=%p GCVirt=%RGv cb=%#x\n",
2866	pDevIns->pReg->szName, pDevIns->iInstance, pvDst, GCVirtSrc, cb));
2867
2868	int rc = VERR_NOT_IMPLEMENTED;;
2869	AssertFailed();
2870
2871	LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2872
2873	return rc;
2874	}
2875
2876
2877	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWriteGCVirt} */
2878	static DECLCALLBACK(int) pdmR3DevHlp_PhysWriteGCVirt(PPDMDEVINS pDevIns, RTGCPTR GCVirtDst, const void *pvSrc, size_t cb)
2879	{
2880	PDMDEV_ASSERT_DEVINS(pDevIns);
2881	LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: GCVirtDst=%RGv pvSrc=%p cb=%#x\n",
2882	pDevIns->pReg->szName, pDevIns->iInstance, GCVirtDst, pvSrc, cb));
2883
2884	int rc = VERR_NOT_IMPLEMENTED;;
2885	AssertFailed();
2886
2887	LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
2888
2889	return rc;
2890	}
2891
2892
2893	/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPtr2GCPhys} */
2894	static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPtr2GCPhys(PPDMDEVINS pDevIns, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
2895	{
2896	PDMDEV_ASSERT_DEVINS(pDevIns);
2897	LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: GCPtr=%RGv pGCPhys=%p\n",
2898	pDevIns->pReg->szName, pDevIns->iInstance, GCPtr, pGCPhys));
2899
2900	int rc = VERR_NOT_IMPLEMENTED;
2901	AssertFailed();
2902
2903	LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: returns %Rrc pGCPhys=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, pGCPhys));
2904
2905	return rc;
2906	}
2907
2908
2909	/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAlloc} */
2910	static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAlloc(PPDMDEVINS pDevIns, size_t cb)
2911	{
2912	PDMDEV_ASSERT_DEVINS(pDevIns);
2913	LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
2914
2915	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
2916	void *pv = NULL;
2917	AssertFailed();
2918	#else
2919	void *pv = RTMemAlloc(cb);
2920	#endif
2921
2922	LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
2923	return pv;
2924	}
2925
2926
2927	/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAllocZ} */
2928	static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAllocZ(PPDMDEVINS pDevIns, size_t cb)
2929	{
2930	PDMDEV_ASSERT_DEVINS(pDevIns);
2931	LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
2932
2933	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
2934	void *pv = NULL;
2935	AssertFailed();
2936	#else
2937	void *pv = RTMemAllocZ(cb);
2938	#endif
2939
2940	LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
2941	return pv;
2942	}
2943
2944
2945	/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapFree} */
2946	static DECLCALLBACK(void) pdmR3DevHlp_MMHeapFree(PPDMDEVINS pDevIns, void *pv)
2947	{
2948	PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
2949	LogFlow(("pdmR3DevHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
2950
2951	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
2952	PTSTDEVMMHEAPALLOC pHeapAlloc = (PTSTDEVMMHEAPALLOC)((uint8_t *)pv - RT_UOFFSETOF(TSTDEVMMHEAPALLOC, abAlloc[0]));
2953	PTSTDEVDUTINT pThis = pHeapAlloc->pDut;
2954
2955	tstDevDutLockExcl(pThis);
2956	RTListNodeRemove(&pHeapAlloc->NdMmHeap);
2957	tstDevDutUnlockExcl(pThis);
2958
2959	/* Poison */
2960	memset(&pHeapAlloc->abAlloc[0], 0xfc, pHeapAlloc->cbAlloc);
2961	RTMemFree(pHeapAlloc);
2962	#else
2963	RTMemFree(pv);
2964	#endif
2965
2966	LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
2967	}
2968
2969
2970	/** @interface_method_impl{PDMDEVHLPR3,pfnVMState} */
2971	static DECLCALLBACK(VMSTATE) pdmR3DevHlp_VMState(PPDMDEVINS pDevIns)
2972	{
2973	PDMDEV_ASSERT_DEVINS(pDevIns);
2974
2975	VMSTATE enmVMState = VMSTATE_CREATING;
2976	AssertFailed();
2977
2978	LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %d\n", pDevIns->pReg->szName, pDevIns->iInstance,
2979	enmVMState));
2980	return enmVMState;
2981	}
2982
2983
2984	/** @interface_method_impl{PDMDEVHLPR3,pfnVMTeleportedAndNotFullyResumedYet} */
2985	static DECLCALLBACK(bool) pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet(PPDMDEVINS pDevIns)
2986	{
2987	PDMDEV_ASSERT_DEVINS(pDevIns);
2988
2989	bool fRc = false;
2990
2991	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
2992	AssertFailed();
2993	#endif
2994
2995	LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szName, pDevIns->iInstance,
2996	fRc));
2997	return fRc;
2998	}
2999
3000
3001	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetError} */
3002	static DECLCALLBACK(int) pdmR3DevHlp_VMSetError(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
3003	{
3004	PDMDEV_ASSERT_DEVINS(pDevIns);
3005
3006	RT_NOREF(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat);
3007	AssertFailed();
3008
3009	return VERR_NOT_IMPLEMENTED;
3010	}
3011
3012
3013	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetErrorV} */
3014	static DECLCALLBACK(int) pdmR3DevHlp_VMSetErrorV(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
3015	{
3016	PDMDEV_ASSERT_DEVINS(pDevIns);
3017
3018	RT_NOREF(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
3019	AssertFailed();
3020
3021	return VERR_NOT_IMPLEMENTED;
3022	}
3023
3024
3025	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeError} */
3026	static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeError(PPDMDEVINS pDevIns, uint32_t fFlags, const char pszErrorId, const char pszFormat, ...)
3027	{
3028	PDMDEV_ASSERT_DEVINS(pDevIns);
3029
3030	RT_NOREF(pDevIns, fFlags, pszErrorId, pszFormat);
3031	int rc = VERR_NOT_IMPLEMENTED;
3032	AssertFailed();
3033
3034	return rc;
3035	}
3036
3037
3038	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeErrorV} */
3039	static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeErrorV(PPDMDEVINS pDevIns, uint32_t fFlags, const char pszErrorId, const char pszFormat, va_list va)
3040	{
3041	PDMDEV_ASSERT_DEVINS(pDevIns);
3042
3043	RT_NOREF(pDevIns, fFlags, pszErrorId, pszFormat, va);
3044	int rc = VERR_NOT_IMPLEMENTED;
3045	AssertFailed();
3046
3047	return rc;
3048	}
3049
3050
3051	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFStopV} */
3052	static DECLCALLBACK(int) pdmR3DevHlp_DBGFStopV(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction, const char *pszFormat, va_list args)
3053	{
3054	PDMDEV_ASSERT_DEVINS(pDevIns);
3055	#ifdef LOG_ENABLED
3056	va_list va2;
3057	va_copy(va2, args);
3058	LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: pszFile=%p:{%s} iLine=%d pszFunction=%p:{%s} pszFormat=%p:{%s} (%N)\n",
3059	pDevIns->pReg->szName, pDevIns->iInstance, pszFile, pszFile, iLine, pszFunction, pszFunction, pszFormat, pszFormat, pszFormat, &va2));
3060	va_end(va2);
3061	#endif
3062
3063	int rc = VERR_NOT_IMPLEMENTED;
3064	AssertFailed();
3065
3066	LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3067	return rc;
3068	}
3069
3070
3071	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFInfoRegister} */
3072	static DECLCALLBACK(int) pdmR3DevHlp_DBGFInfoRegister(PPDMDEVINS pDevIns, const char pszName, const char pszDesc, PFNDBGFHANDLERDEV pfnHandler)
3073	{
3074	PDMDEV_ASSERT_DEVINS(pDevIns);
3075	LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
3076	pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
3077
3078	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3079	int rc = VERR_NOT_IMPLEMENTED;
3080	AssertFailed();
3081	#else
3082	int rc = VINF_SUCCESS;
3083	#endif
3084
3085
3086	LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3087	return rc;
3088	}
3089
3090
3091	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFInfoRegisterArgv} */
3092	static DECLCALLBACK(int) pdmR3DevHlp_DBGFInfoRegisterArgv(PPDMDEVINS pDevIns, const char pszName, const char pszDesc, PFNDBGFINFOARGVDEV pfnHandler)
3093	{
3094	PDMDEV_ASSERT_DEVINS(pDevIns);
3095	LogFlow(("pdmR3DevHlp_DBGFInfoRegisterArgv: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
3096	pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
3097
3098	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3099	int rc = VERR_NOT_IMPLEMENTED;
3100	AssertFailed();
3101	#else
3102	int rc = VINF_SUCCESS;
3103	#endif
3104
3105	LogFlow(("pdmR3DevHlp_DBGFInfoRegisterArgv: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3106	return rc;
3107	}
3108
3109
3110	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFRegRegister} */
3111	static DECLCALLBACK(int) pdmR3DevHlp_DBGFRegRegister(PPDMDEVINS pDevIns, PCDBGFREGDESC paRegisters)
3112	{
3113	PDMDEV_ASSERT_DEVINS(pDevIns);
3114	LogFlow(("pdmR3DevHlp_DBGFRegRegister: caller='%s'/%d: paRegisters=%p\n",
3115	pDevIns->pReg->szName, pDevIns->iInstance, paRegisters));
3116
3117	int rc = VERR_NOT_IMPLEMENTED;
3118	AssertFailed();
3119
3120	LogFlow(("pdmR3DevHlp_DBGFRegRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3121	return rc;
3122	}
3123
3124
3125	/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFTraceBuf} */
3126	static DECLCALLBACK(RTTRACEBUF) pdmR3DevHlp_DBGFTraceBuf(PPDMDEVINS pDevIns)
3127	{
3128	PDMDEV_ASSERT_DEVINS(pDevIns);
3129	RTTRACEBUF hTraceBuf = NIL_RTTRACEBUF;
3130	AssertFailed();
3131	LogFlow(("pdmR3DevHlp_DBGFTraceBuf: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, hTraceBuf));
3132	return hTraceBuf;
3133	}
3134
3135
3136	/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegister} */
3137	static DECLCALLBACK(void) pdmR3DevHlp_STAMRegister(PPDMDEVINS pDevIns, void pvSample, STAMTYPE enmType, const char pszName,
3138	STAMUNIT enmUnit, const char *pszDesc)
3139	{
3140	PDMDEV_ASSERT_DEVINS(pDevIns);
3141
3142	RT_NOREF(pDevIns, pvSample, enmType, pszName, enmUnit, pszDesc);
3143
3144	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3145	AssertFailed();
3146	#endif
3147	}
3148
3149
3150	/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegisterV} */
3151	static DECLCALLBACK(void) pdmR3DevHlp_STAMRegisterV(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
3152	STAMUNIT enmUnit, const char pszDesc, const char pszName, va_list args)
3153	{
3154	PDMDEV_ASSERT_DEVINS(pDevIns);
3155
3156	RT_NOREF(pDevIns, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
3157
3158	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3159	AssertFailed();
3160	#endif
3161	}
3162
3163
3164	/**
3165	* @interface_method_impl{PDMDEVHLPR3,pfnPCIRegister}
3166	*/
3167	static DECLCALLBACK(int) pdmR3DevHlp_PCIRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t fFlags,
3168	uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName)
3169	{
3170	PDMDEV_ASSERT_DEVINS(pDevIns);
3171	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: pPciDev=%p:{.config={%#.256Rhxs} fFlags=%#x uPciDevNo=%#x uPciFunNo=%#x pszName=%p:{%s}\n",
3172	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->abConfig, fFlags, uPciDevNo, uPciFunNo, pszName, pszName ? pszName : ""));
3173
3174	/*
3175	* Validate input.
3176	*/
3177	AssertLogRelMsgReturn(pDevIns->pReg->cMaxPciDevices > 0,
3178	("'%s'/%d: cMaxPciDevices is 0\n", pDevIns->pReg->szName, pDevIns->iInstance),
3179	VERR_WRONG_ORDER);
3180	AssertLogRelMsgReturn(RT_VALID_PTR(pPciDev),
3181	("'%s'/%d: Invalid pPciDev value: %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pPciDev),
3182	VERR_INVALID_POINTER);
3183	AssertLogRelMsgReturn(PDMPciDevGetVendorId(pPciDev),
3184	("'%s'/%d: Vendor ID is not set!\n", pDevIns->pReg->szName, pDevIns->iInstance),
3185	VERR_INVALID_POINTER);
3186	AssertLogRelMsgReturn( uPciDevNo < 32
3187	\|\| uPciDevNo == PDMPCIDEVREG_DEV_NO_FIRST_UNUSED
3188	\|\| uPciDevNo == PDMPCIDEVREG_DEV_NO_SAME_AS_PREV,
3189	("'%s'/%d: Invalid PCI device number: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, uPciDevNo),
3190	VERR_INVALID_PARAMETER);
3191	AssertLogRelMsgReturn( uPciFunNo < 8
3192	\|\| uPciFunNo == PDMPCIDEVREG_FUN_NO_FIRST_UNUSED,
3193	("'%s'/%d: Invalid PCI funcion number: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, uPciFunNo),
3194	VERR_INVALID_PARAMETER);
3195	AssertLogRelMsgReturn(!(fFlags & ~PDMPCIDEVREG_F_VALID_MASK),
3196	("'%s'/%d: Invalid flags: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, fFlags),
3197	VERR_INVALID_FLAGS);
3198	if (!pszName)
3199	pszName = pDevIns->pReg->szName;
3200
3201	#if 0
3202	AssertLogRelReturn(RT_VALID_PTR(pszName), VERR_INVALID_POINTER);
3203	AssertLogRelReturn(!pPciDev->Int.s.fRegistered, VERR_PDM_NOT_PCI_DEVICE);
3204	AssertLogRelReturn(pPciDev == PDMDEV_GET_PPCIDEV(pDevIns, pPciDev->Int.s.idxSubDev), VERR_PDM_NOT_PCI_DEVICE);
3205	AssertLogRelReturn(pPciDev == PDMDEV_CALC_PPCIDEV(pDevIns, pPciDev->Int.s.idxSubDev), VERR_PDM_NOT_PCI_DEVICE);
3206	AssertMsgReturn(pPciDev->u32Magic == PDMPCIDEV_MAGIC, ("%#x\n", pPciDev->u32Magic), VERR_PDM_NOT_PCI_DEVICE);
3207	#endif
3208
3209	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3210	int rc = VERR_NOT_IMPLEMENTED;
3211	AssertFailed();
3212	#else
3213	int rc = VINF_SUCCESS;
3214	#endif
3215
3216	LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3217	return rc;
3218	}
3219
3220
3221	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIRegisterMsi} */
3222	static DECLCALLBACK(int) pdmR3DevHlp_PCIRegisterMsi(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, PPDMMSIREG pMsiReg)
3223	{
3224	PDMDEV_ASSERT_DEVINS(pDevIns);
3225	if (!pPciDev) /* NULL is an alias for the default PCI device. */
3226	pPciDev = pDevIns->apPciDevs[0];
3227	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3228	LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: pPciDev=%p:{%#x} pMsgReg=%p:{cMsiVectors=%d, cMsixVectors=%d}\n",
3229	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, pMsiReg, pMsiReg->cMsiVectors, pMsiReg->cMsixVectors));
3230	PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
3231
3232	AssertLogRelMsgReturn(pDevIns->pReg->cMaxPciDevices > 0,
3233	("'%s'/%d: cMaxPciDevices is 0\n", pDevIns->pReg->szName, pDevIns->iInstance),
3234	VERR_WRONG_ORDER);
3235	AssertLogRelMsgReturn(pMsiReg->cMsixVectors <= pDevIns->pReg->cMaxMsixVectors,
3236	("'%s'/%d: cMsixVectors=%u cMaxMsixVectors=%u\n",
3237	pDevIns->pReg->szName, pDevIns->iInstance, pMsiReg->cMsixVectors, pDevIns->pReg->cMaxMsixVectors),
3238	VERR_INVALID_FLAGS);
3239
3240	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3241	int rc = VERR_NOT_IMPLEMENTED;
3242	AssertFailed();
3243	#else
3244	int rc = VINF_SUCCESS;
3245	#endif
3246
3247
3248	LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3249	return rc;
3250	}
3251
3252
3253	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIIORegionRegister} */
3254	static DECLCALLBACK(int) pdmR3DevHlp_PCIIORegionRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
3255	RTGCPHYS cbRegion, PCIADDRESSSPACE enmType, uint32_t fFlags,
3256	uint64_t hHandle, PFNPCIIOREGIONMAP pfnMapUnmap)
3257	{
3258	PDMDEV_ASSERT_DEVINS(pDevIns);
3259	if (!pPciDev) /* NULL is an alias for the default PCI device. */
3260	pPciDev = pDevIns->apPciDevs[0];
3261	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3262	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%d cbRegion=%RGp enmType=%d fFlags=%#x, hHandle=%#RX64 pfnMapUnmap=%p\n",
3263	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iRegion, cbRegion, enmType, fFlags, hHandle, pfnMapUnmap));
3264
3265	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3266	PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
3267	#endif
3268
3269	/*
3270	* Validate input.
3271	*/
3272	if (iRegion >= VBOX_PCI_NUM_REGIONS)
3273	{
3274	Assert(iRegion < VBOX_PCI_NUM_REGIONS);
3275	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (iRegion)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3276	return VERR_INVALID_PARAMETER;
3277	}
3278
3279	switch ((int)enmType)
3280	{
3281	case PCI_ADDRESS_SPACE_IO:
3282	/*
3283	* Sanity check: don't allow to register more than 32K of the PCI I/O space.
3284	*/
3285	AssertLogRelMsgReturn(cbRegion <= _32K,
3286	("caller='%s'/%d: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cbRegion),
3287	VERR_INVALID_PARAMETER);
3288	break;
3289
3290	case PCI_ADDRESS_SPACE_MEM:
3291	case PCI_ADDRESS_SPACE_MEM_PREFETCH:
3292	/*
3293	* Sanity check: Don't allow to register more than 2GB of the PCI MMIO space.
3294	*/
3295	AssertLogRelMsgReturn(cbRegion <= MM_MMIO_32_MAX,
3296	("caller='%s'/%d: %RGp (max %RGp)\n",
3297	pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, (RTGCPHYS)MM_MMIO_32_MAX),
3298	VERR_OUT_OF_RANGE);
3299	break;
3300
3301	case PCI_ADDRESS_SPACE_BAR64 \| PCI_ADDRESS_SPACE_MEM:
3302	case PCI_ADDRESS_SPACE_BAR64 \| PCI_ADDRESS_SPACE_MEM_PREFETCH:
3303	/*
3304	* Sanity check: Don't allow to register more than 64GB of the 64-bit PCI MMIO space.
3305	*/
3306	AssertLogRelMsgReturn(cbRegion <= MM_MMIO_64_MAX,
3307	("caller='%s'/%d: %RGp (max %RGp)\n",
3308	pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, MM_MMIO_64_MAX),
3309	VERR_OUT_OF_RANGE);
3310	break;
3311
3312	default:
3313	AssertMsgFailed(("enmType=%#x is unknown\n", enmType));
3314	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (enmType)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
3315	return VERR_INVALID_PARAMETER;
3316	}
3317
3318	AssertMsgReturn( pfnMapUnmap
3319	\|\| ( hHandle != UINT64_MAX
3320	&& (fFlags & PDMPCIDEV_IORGN_F_HANDLE_MASK) != PDMPCIDEV_IORGN_F_NO_HANDLE),
3321	("caller='%s'/%d: fFlags=%#x hHandle=%#RX64\n", pDevIns->pReg->szName, pDevIns->iInstance, fFlags, hHandle),
3322	VERR_INVALID_PARAMETER);
3323
3324	AssertMsgReturn(!(fFlags & ~PDMPCIDEV_IORGN_F_VALID_MASK), ("fFlags=%#x\n", fFlags), VERR_INVALID_FLAGS);
3325	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3326	int rc = VERR_NOT_IMPLEMENTED;
3327	AssertFailed();
3328	#else
3329	int rc = VINF_SUCCESS;
3330	#endif
3331
3332	LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3333	return rc;
3334	}
3335
3336
3337	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIInterceptConfigAccesses} */
3338	static DECLCALLBACK(int) pdmR3DevHlp_PCIInterceptConfigAccesses(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev,
3339	PFNPCICONFIGREAD pfnRead, PFNPCICONFIGWRITE pfnWrite)
3340	{
3341	PDMDEV_ASSERT_DEVINS(pDevIns);
3342	if (!pPciDev) /* NULL is an alias for the default PCI device. */
3343	pPciDev = pDevIns->apPciDevs[0];
3344	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3345	LogFlow(("pdmR3DevHlp_PCIInterceptConfigAccesses: caller='%s'/%d: pPciDev=%p pfnRead=%p pfnWrite=%p\n",
3346	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pfnRead, pfnWrite));
3347
3348	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3349	PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
3350
3351	int rc = VERR_NOT_IMPLEMENTED;
3352	AssertFailed();
3353	#else
3354	int rc = VINF_SUCCESS;
3355	#endif
3356
3357	LogFlow(("pdmR3DevHlp_PCIInterceptConfigAccesses: caller='%s'/%d: returns %Rrc\n",
3358	pDevIns->pReg->szName, pDevIns->iInstance, rc));
3359	return rc;
3360	}
3361
3362
3363	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIConfigWrite} */
3364	static DECLCALLBACK(VBOXSTRICTRC)
3365	pdmR3DevHlp_PCIConfigWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t uAddress, unsigned cb, uint32_t u32Value)
3366	{
3367	PDMDEV_ASSERT_DEVINS(pDevIns);
3368	AssertPtrReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3369	LogFlow(("pdmR3DevHlp_PCIConfigWrite: caller='%s'/%d: pPciDev=%p uAddress=%#x cd=%d u32Value=%#x\n",
3370	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, uAddress, cb, u32Value));
3371
3372	VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
3373	AssertFailed();
3374
3375	LogFlow(("pdmR3DevHlp_PCIConfigWrite: caller='%s'/%d: returns %Rrc\n",
3376	pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict)));
3377	return rcStrict;
3378	}
3379
3380
3381	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIConfigRead} */
3382	static DECLCALLBACK(VBOXSTRICTRC)
3383	pdmR3DevHlp_PCIConfigRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t uAddress, unsigned cb, uint32_t *pu32Value)
3384	{
3385	PDMDEV_ASSERT_DEVINS(pDevIns);
3386	AssertPtrReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3387	LogFlow(("pdmR3DevHlp_PCIConfigRead: caller='%s'/%d: pPciDev=%p uAddress=%#x cd=%d pu32Value=%p:{%#x}\n",
3388	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, uAddress, cb, pu32Value, *pu32Value));
3389
3390	VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
3391	AssertFailed();
3392
3393	LogFlow(("pdmR3DevHlp_PCIConfigRead: caller='%s'/%d: returns %Rrc (*pu32Value=%#x)\n",
3394	pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict), *pu32Value));
3395	return rcStrict;
3396	}
3397
3398
3399	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysRead} */
3400	static DECLCALLBACK(int)
3401	pdmR3DevHlp_PCIPhysRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
3402	{
3403	PDMDEV_ASSERT_DEVINS(pDevIns);
3404	if (!pPciDev) /* NULL is an alias for the default PCI device. */
3405	pPciDev = pDevIns->apPciDevs[0];
3406	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3407	PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
3408
3409	#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
3410	/*
3411	* Just check the busmaster setting here and forward the request to the generic read helper.
3412	*/
3413	if (PCIDevIsBusmaster(pPciDev))
3414	{ /* likely */ }
3415	else
3416	{
3417	Log(("pdmR3DevHlp_PCIPhysRead: caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbRead=%#zx\n",
3418	pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbRead));
3419	memset(pvBuf, 0xff, cbRead);
3420	return VERR_PDM_NOT_PCI_BUS_MASTER;
3421	}
3422	#endif
3423
3424	int rc = VERR_NOT_IMPLEMENTED;
3425	AssertFailed();
3426	return rc;
3427	}
3428
3429
3430	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysWrite} */
3431	static DECLCALLBACK(int)
3432	pdmR3DevHlp_PCIPhysWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
3433	{
3434	PDMDEV_ASSERT_DEVINS(pDevIns);
3435	if (!pPciDev) /* NULL is an alias for the default PCI device. */
3436	pPciDev = pDevIns->apPciDevs[0];
3437	AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
3438	PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
3439
3440	#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
3441	/*
3442	* Just check the busmaster setting here and forward the request to the generic read helper.
3443	*/
3444	if (PCIDevIsBusmaster(pPciDev))
3445	{ /* likely */ }
3446	else
3447	{
3448	Log(("pdmR3DevHlp_PCIPhysWrite: caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbWrite=%#zx\n",
3449	pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbWrite));
3450	return VERR_PDM_NOT_PCI_BUS_MASTER;
3451	}
3452	#endif
3453
3454	RT_NOREF(GCPhys, pvBuf, cbWrite);
3455	int rc = VERR_NOT_IMPLEMENTED;
3456	AssertFailed();
3457	return rc;
3458	}
3459
3460
3461	/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrq} */
3462	static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrq(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
3463	{
3464	PDMDEV_ASSERT_DEVINS(pDevIns);
3465	if (!pPciDev) /* NULL is an alias for the default PCI device. */
3466	pPciDev = pDevIns->apPciDevs[0];
3467	AssertReturnVoid(pPciDev);
3468	LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: pPciDev=%p:{%#x} iIrq=%d iLevel=%d\n",
3469	pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iIrq, iLevel));
3470	PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
3471
3472	RT_NOREF(iIrq, iLevel);
3473	AssertFailed();
3474
3475	LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
3476	}
3477
3478
3479	/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrqNoWait} */
3480	static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrqNoWait(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
3481	{
3482	pdmR3DevHlp_PCISetIrq(pDevIns, pPciDev, iIrq, iLevel);
3483	}
3484
3485
3486	/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrq} */
3487	static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
3488	{
3489	PDMDEV_ASSERT_DEVINS(pDevIns);
3490	LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, iIrq, iLevel));
3491
3492	/*
3493	* Validate input.
3494	*/
3495	Assert(iIrq < 16);
3496	Assert((uint32_t)iLevel <= PDM_IRQ_LEVEL_FLIP_FLOP);
3497
3498	AssertFailed();
3499
3500	LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
3501	}
3502
3503
3504	/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrqNoWait} */
3505	static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
3506	{
3507	pdmR3DevHlp_ISASetIrq(pDevIns, iIrq, iLevel);
3508	}
3509
3510
3511	/** @interface_method_impl{PDMDEVHLPR3,pfnIoApicSendMsi} */
3512	static DECLCALLBACK(void) pdmR3DevHlp_IoApicSendMsi(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t uValue)
3513	{
3514	PDMDEV_ASSERT_DEVINS(pDevIns);
3515	LogFlow(("pdmR3DevHlp_IoApicSendMsi: caller='%s'/%d: GCPhys=%RGp uValue=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, uValue));
3516
3517	/*
3518	* Validate input.
3519	*/
3520	Assert(GCPhys != 0);
3521	Assert(uValue != 0);
3522
3523	AssertFailed();
3524
3525	LogFlow(("pdmR3DevHlp_IoApicSendMsi: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
3526	}
3527
3528
3529	/** @interface_method_impl{PDMDEVHLPR3,pfnDriverAttach} */
3530	static DECLCALLBACK(int) pdmR3DevHlp_DriverAttach(PPDMDEVINS pDevIns, uint32_t iLun, PPDMIBASE pBaseInterface, PPDMIBASE ppBaseInterface, const char pszDesc)
3531	{
3532	PDMDEV_ASSERT_DEVINS(pDevIns);
3533	LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: iLun=%d pBaseInterface=%p ppBaseInterface=%p pszDesc=%p:{%s}\n",
3534	pDevIns->pReg->szName, pDevIns->iInstance, iLun, pBaseInterface, ppBaseInterface, pszDesc, pszDesc));
3535
3536	#if 1
3537	int rc = VINF_SUCCESS;
3538	if (iLun == PDM_STATUS_LUN)
3539	*ppBaseInterface = &pDevIns->Internal.s.pDut->IBaseSts;
3540	else
3541	rc = VERR_PDM_NO_ATTACHED_DRIVER;
3542	#else
3543	int rc = VERR_NOT_IMPLEMENTED;
3544	AssertFailed();
3545	#endif
3546
3547	LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3548	return rc;
3549	}
3550
3551
3552	/** @interface_method_impl{PDMDEVHLPR3,pfnDriverDetach} */
3553	static DECLCALLBACK(int) pdmR3DevHlp_DriverDetach(PPDMDEVINS pDevIns, PPDMDRVINS pDrvIns, uint32_t fFlags)
3554	{
3555	PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
3556	LogFlow(("pdmR3DevHlp_DriverDetach: caller='%s'/%d: pDrvIns=%p\n",
3557	pDevIns->pReg->szName, pDevIns->iInstance, pDrvIns));
3558
3559	RT_NOREF(fFlags);
3560	int rc = VERR_NOT_IMPLEMENTED;
3561	AssertFailed();
3562
3563	LogFlow(("pdmR3DevHlp_DriverDetach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3564	return rc;
3565	}
3566
3567
3568	/** @interface_method_impl{PDMDEVHLPR3,pfnDriverReconfigure} */
3569	static DECLCALLBACK(int) pdmR3DevHlp_DriverReconfigure(PPDMDEVINS pDevIns, uint32_t iLun, uint32_t cDepth,
3570	const char * const papszDrivers, PCFGMNODE papConfigs, uint32_t fFlags)
3571	{
3572	PDMDEV_ASSERT_DEVINS(pDevIns);
3573	LogFlow(("pdmR3DevHlp_DriverReconfigure: caller='%s'/%d: iLun=%u cDepth=%u fFlags=%#x\n",
3574	pDevIns->pReg->szName, pDevIns->iInstance, iLun, cDepth, fFlags));
3575
3576	/*
3577	* Validate input.
3578	*/
3579	AssertReturn(cDepth <= 8, VERR_INVALID_PARAMETER);
3580	AssertPtrReturn(papszDrivers, VERR_INVALID_POINTER);
3581	AssertPtrNullReturn(papConfigs, VERR_INVALID_POINTER);
3582	for (uint32_t i = 0; i < cDepth; i++)
3583	{
3584	AssertPtrReturn(papszDrivers[i], VERR_INVALID_POINTER);
3585	size_t cchDriver = strlen(papszDrivers[i]);
3586	AssertPtrReturn(cchDriver > 0 && cchDriver < RT_SIZEOFMEMB(PDMDRVREG, szName), VERR_OUT_OF_RANGE);
3587
3588	if (papConfigs)
3589	AssertPtrNullReturn(papConfigs[i], VERR_INVALID_POINTER);
3590	}
3591	AssertReturn(fFlags == 0, VERR_INVALID_FLAGS);
3592
3593	int rc = VERR_NOT_IMPLEMENTED;
3594	AssertFailed();
3595
3596	LogFlow(("pdmR3DevHlp_DriverReconfigure: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3597	return rc;
3598	}
3599
3600
3601	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueCreatePtr} */
3602	static DECLCALLBACK(int) pdmR3DevHlp_QueueCreatePtr(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
3603	PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char pszName, PPDMQUEUE ppQueue)
3604	{
3605	PDMDEV_ASSERT_DEVINS(pDevIns);
3606	LogFlow(("pdmR3DevHlp_QueueCreatePtr: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fRZEnabled=%RTbool pszName=%p:{%s} ppQueue=%p\n",
3607	pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, pszName, ppQueue));
3608
3609	int rc = VERR_NOT_IMPLEMENTED;
3610	AssertFailed();
3611
3612	LogFlow(("pdmR3DevHlp_QueueCreatePtr: caller='%s'/%d: returns %Rrc ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, ppQueue));
3613	return rc;
3614	}
3615
3616
3617	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueCreate} */
3618	static DECLCALLBACK(int) pdmR3DevHlp_QueueCreate(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
3619	PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char *pszName,
3620	PDMQUEUEHANDLE *phQueue)
3621	{
3622	PDMDEV_ASSERT_DEVINS(pDevIns);
3623	LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fRZEnabled=%RTbool pszName=%p:{%s} phQueue=%p\n",
3624	pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, pszName, phQueue));
3625
3626	int rc = VERR_NOT_IMPLEMENTED;
3627	AssertFailed();
3628
3629	LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: returns %Rrc ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, phQueue));
3630	return rc;
3631	}
3632
3633
3634	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueToPtr} */
3635	static DECLCALLBACK(PPDMQUEUE) pdmR3DevHlp_QueueToPtr(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
3636	{
3637	PDMDEV_ASSERT_DEVINS(pDevIns);
3638	RT_NOREF(pDevIns);
3639	return (PPDMQUEUE)hQueue;
3640	}
3641
3642
3643	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueAlloc} */
3644	static DECLCALLBACK(PPDMQUEUEITEMCORE) pdmR3DevHlp_QueueAlloc(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
3645	{
3646	RT_NOREF(pDevIns, hQueue);
3647	AssertFailed();
3648	return NULL;
3649	}
3650
3651
3652	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueInsert} */
3653	static DECLCALLBACK(void) pdmR3DevHlp_QueueInsert(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem)
3654	{
3655	RT_NOREF(pDevIns, hQueue, pItem);
3656	AssertFailed();
3657	}
3658
3659
3660	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueInsertEx} */
3661	static DECLCALLBACK(void) pdmR3DevHlp_QueueInsertEx(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem,
3662	uint64_t cNanoMaxDelay)
3663	{
3664	RT_NOREF(pDevIns, hQueue, pItem, cNanoMaxDelay);
3665	AssertFailed();
3666	}
3667
3668
3669	/** @interface_method_impl{PDMDEVHLPR3,pfnQueueFlushIfNecessary} */
3670	static DECLCALLBACK(bool) pdmR3DevHlp_QueueFlushIfNecessary(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
3671	{
3672	RT_NOREF(pDevIns, hQueue);
3673	AssertFailed();
3674	return false;
3675	}
3676
3677
3678	/** @interface_method_impl{PDMDEVHLPR3,pfnTaskCreate} */
3679	static DECLCALLBACK(int) pdmR3DevHlp_TaskCreate(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszName,
3680	PFNPDMTASKDEV pfnCallback, void pvUser, PDMTASKHANDLE phTask)
3681	{
3682	PDMDEV_ASSERT_DEVINS(pDevIns);
3683	LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: pfnCallback=%p fFlags=%#x pszName=%p:{%s} phTask=%p\n",
3684	pDevIns->pReg->szName, pDevIns->iInstance, pfnCallback, fFlags, pszName, pszName, phTask));
3685
3686	RT_NOREF(pDevIns, fFlags, pszName, pfnCallback, pvUser, phTask);
3687	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3688	int rc = VERR_NOT_IMPLEMENTED;
3689	AssertFailed();
3690	#else
3691	int rc = VINF_SUCCESS;
3692	#endif
3693
3694	LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3695	return rc;
3696	}
3697
3698
3699	/** @interface_method_impl{PDMDEVHLPR3,pfnTaskTrigger} */
3700	static DECLCALLBACK(int) pdmR3DevHlp_TaskTrigger(PPDMDEVINS pDevIns, PDMTASKHANDLE hTask)
3701	{
3702	PDMDEV_ASSERT_DEVINS(pDevIns);
3703	LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: hTask=%RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, hTask));
3704
3705	RT_NOREF(pDevIns, hTask);
3706	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3707	int rc = VERR_NOT_IMPLEMENTED;
3708	AssertFailed();
3709	#else
3710	int rc = VINF_SUCCESS;
3711	#endif
3712
3713	LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3714	return rc;
3715	}
3716
3717
3718	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventCreate} */
3719	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventCreate(PPDMDEVINS pDevIns, PSUPSEMEVENT phEvent)
3720	{
3721	PDMDEV_ASSERT_DEVINS(pDevIns);
3722	LogFlow(("pdmR3DevHlp_SUPSemEventCreate: caller='%s'/%d: phEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, phEvent));
3723
3724	RT_NOREF(pDevIns, phEvent);
3725	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3726	int rc = VERR_NOT_IMPLEMENTED;
3727	AssertFailed();
3728	#else
3729	int rc = VINF_SUCCESS;
3730	#endif
3731
3732	LogFlow(("pdmR3DevHlp_SUPSemEventCreate: caller='%s'/%d: returns %Rrc phEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, phEvent));
3733	return rc;
3734	}
3735
3736
3737	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventClose} */
3738	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventClose(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent)
3739	{
3740	PDMDEV_ASSERT_DEVINS(pDevIns);
3741	LogFlow(("pdmR3DevHlp_SUPSemEventClose: caller='%s'/%d: hEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEvent));
3742
3743	RT_NOREF(pDevIns, hEvent);
3744	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3745	int rc = VERR_NOT_IMPLEMENTED;
3746	AssertFailed();
3747	#else
3748	int rc = VINF_SUCCESS;
3749	#endif
3750
3751	LogFlow(("pdmR3DevHlp_SUPSemEventClose: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3752	return rc;
3753	}
3754
3755
3756	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventSignal} */
3757	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventSignal(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent)
3758	{
3759	PDMDEV_ASSERT_DEVINS(pDevIns);
3760	LogFlow(("pdmR3DevHlp_SUPSemEventSignal: caller='%s'/%d: hEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEvent));
3761
3762	RT_NOREF(pDevIns, hEvent);
3763	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3764	int rc = VERR_NOT_IMPLEMENTED;
3765	AssertFailed();
3766	#else
3767	int rc = VINF_SUCCESS;
3768	#endif
3769
3770	LogFlow(("pdmR3DevHlp_SUPSemEventSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3771	return rc;
3772	}
3773
3774
3775	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventWaitNoResume} */
3776	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint32_t cMillies)
3777	{
3778	PDMDEV_ASSERT_DEVINS(pDevIns);
3779	LogFlow(("pdmR3DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: hEvent=%p cNsTimeout=%RU32\n",
3780	pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cMillies));
3781
3782	RT_NOREF(pDevIns, hEvent, cMillies);
3783	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3784	int rc = VERR_NOT_IMPLEMENTED;
3785	AssertFailed();
3786	#else
3787	int rc = VINF_SUCCESS;
3788	#endif
3789
3790	LogFlow(("pdmR3DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3791	return rc;
3792	}
3793
3794
3795	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventWaitNsAbsIntr} */
3796	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t uNsTimeout)
3797	{
3798	PDMDEV_ASSERT_DEVINS(pDevIns);
3799	LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: hEvent=%p uNsTimeout=%RU64\n",
3800	pDevIns->pReg->szName, pDevIns->iInstance, hEvent, uNsTimeout));
3801
3802	RT_NOREF(pDevIns, hEvent, uNsTimeout);
3803	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3804	int rc = VERR_NOT_IMPLEMENTED;
3805	AssertFailed();
3806	#else
3807	int rc = VINF_SUCCESS;
3808	#endif
3809
3810	LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3811	return rc;
3812	}
3813
3814
3815	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventWaitNsRelIntr} */
3816	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t cNsTimeout)
3817	{
3818	PDMDEV_ASSERT_DEVINS(pDevIns);
3819	LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: hEvent=%p cNsTimeout=%RU64\n",
3820	pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cNsTimeout));
3821
3822	RT_NOREF(pDevIns, hEvent, cNsTimeout);
3823	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3824	int rc = VERR_NOT_IMPLEMENTED;
3825	AssertFailed();
3826	#else
3827	int rc = VINF_SUCCESS;
3828	#endif
3829
3830	LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3831	return rc;
3832	}
3833
3834
3835	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventGetResolution} */
3836	static DECLCALLBACK(uint32_t) pdmR3DevHlp_SUPSemEventGetResolution(PPDMDEVINS pDevIns)
3837	{
3838	PDMDEV_ASSERT_DEVINS(pDevIns);
3839	LogFlow(("pdmR3DevHlp_SUPSemEventGetResolution: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
3840
3841	RT_NOREF(pDevIns);
3842	uint32_t cNsResolution = 0;
3843	AssertFailed();
3844
3845	LogFlow(("pdmR3DevHlp_SUPSemEventGetResolution: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, cNsResolution));
3846	return cNsResolution;
3847	}
3848
3849
3850	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiCreate} */
3851	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiCreate(PPDMDEVINS pDevIns, PSUPSEMEVENTMULTI phEventMulti)
3852	{
3853	PDMDEV_ASSERT_DEVINS(pDevIns);
3854	LogFlow(("pdmR3DevHlp_SUPSemEventMultiCreate: caller='%s'/%d: phEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, phEventMulti));
3855
3856	RT_NOREF(pDevIns, phEventMulti);
3857	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3858	int rc = VERR_NOT_IMPLEMENTED;
3859	AssertFailed();
3860	#else
3861	int rc = VINF_SUCCESS;
3862	#endif
3863
3864	LogFlow(("pdmR3DevHlp_SUPSemEventMultiCreate: caller='%s'/%d: returns %Rrc phEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, phEventMulti));
3865	return rc;
3866	}
3867
3868
3869	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiClose} */
3870	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiClose(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
3871	{
3872	PDMDEV_ASSERT_DEVINS(pDevIns);
3873	LogFlow(("pdmR3DevHlp_SUPSemEventMultiClose: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
3874
3875	RT_NOREF(pDevIns, hEventMulti);
3876	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3877	int rc = VERR_NOT_IMPLEMENTED;
3878	AssertFailed();
3879	#else
3880	int rc = VINF_SUCCESS;
3881	#endif
3882
3883	LogFlow(("pdmR3DevHlp_SUPSemEventMultiClose: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3884	return rc;
3885	}
3886
3887
3888	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiSignal} */
3889	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiSignal(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
3890	{
3891	PDMDEV_ASSERT_DEVINS(pDevIns);
3892	LogFlow(("pdmR3DevHlp_SUPSemEventMultiSignal: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
3893
3894	RT_NOREF(pDevIns, hEventMulti);
3895	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3896	int rc = VERR_NOT_IMPLEMENTED;
3897	AssertFailed();
3898	#else
3899	int rc = VINF_SUCCESS;
3900	#endif
3901
3902	LogFlow(("pdmR3DevHlp_SUPSemEventMultiSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3903	return rc;
3904	}
3905
3906
3907	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiReset} */
3908	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiReset(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
3909	{
3910	PDMDEV_ASSERT_DEVINS(pDevIns);
3911	LogFlow(("pdmR3DevHlp_SUPSemEventMultiReset: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
3912
3913	RT_NOREF(pDevIns, hEventMulti);
3914	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3915	int rc = VERR_NOT_IMPLEMENTED;
3916	AssertFailed();
3917	#else
3918	int rc = VINF_SUCCESS;
3919	#endif
3920
3921	LogFlow(("pdmR3DevHlp_SUPSemEventMultiReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3922	return rc;
3923	}
3924
3925
3926	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiWaitNoResume} */
3927	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
3928	uint32_t cMillies)
3929	{
3930	PDMDEV_ASSERT_DEVINS(pDevIns);
3931	LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNoResume: caller='%s'/%d: hEventMulti=%p cMillies=%RU32\n",
3932	pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, cMillies));
3933
3934	RT_NOREF(pDevIns, hEventMulti, cMillies);
3935	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3936	int rc = VERR_NOT_IMPLEMENTED;
3937	AssertFailed();
3938	#else
3939	int rc = VINF_SUCCESS;
3940	#endif
3941	LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3942	return rc;
3943	}
3944
3945
3946	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiWaitNsAbsIntr} */
3947	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
3948	uint64_t uNsTimeout)
3949	{
3950	PDMDEV_ASSERT_DEVINS(pDevIns);
3951	LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr: caller='%s'/%d: hEventMulti=%p uNsTimeout=%RU64\n",
3952	pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, uNsTimeout));
3953
3954	RT_NOREF(pDevIns, hEventMulti, uNsTimeout);
3955	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3956	int rc = VERR_NOT_IMPLEMENTED;
3957	AssertFailed();
3958	#else
3959	int rc = VINF_SUCCESS;
3960	#endif
3961
3962	LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3963	return rc;
3964	}
3965
3966
3967	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiWaitNsRelIntr} */
3968	static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
3969	uint64_t cNsTimeout)
3970	{
3971	PDMDEV_ASSERT_DEVINS(pDevIns);
3972	LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr: caller='%s'/%d: hEventMulti=%p cNsTimeout=%RU64\n",
3973	pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, cNsTimeout));
3974
3975	RT_NOREF(pDevIns, hEventMulti, cNsTimeout);
3976	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
3977	int rc = VERR_NOT_IMPLEMENTED;
3978	AssertFailed();
3979	#else
3980	int rc = VINF_SUCCESS;
3981	#endif
3982
3983	LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
3984	return rc;
3985	}
3986
3987
3988	/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiGetResolution} */
3989	static DECLCALLBACK(uint32_t) pdmR3DevHlp_SUPSemEventMultiGetResolution(PPDMDEVINS pDevIns)
3990	{
3991	PDMDEV_ASSERT_DEVINS(pDevIns);
3992	LogFlow(("pdmR3DevHlp_SUPSemEventMultiGetResolution: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
3993
3994	uint32_t cNsResolution = 0;
3995	AssertFailed();
3996
3997	LogFlow(("pdmR3DevHlp_SUPSemEventMultiGetResolution: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, cNsResolution));
3998	return cNsResolution;
3999	}
4000
4001
4002	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectInit} */
4003	static DECLCALLBACK(int) pdmR3DevHlp_CritSectInit(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RT_SRC_POS_DECL,
4004	const char *pszNameFmt, va_list va)
4005	{
4006	PDMDEV_ASSERT_DEVINS(pDevIns);
4007	LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: pCritSect=%p pszNameFmt=%p:{%s}\n",
4008	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
4009
4010	RT_NOREF(RT_SRC_POS_ARGS, pszNameFmt, va);
4011	int rc = RTCritSectInit(&pCritSect->s.CritSect);
4012
4013	LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4014	return rc;
4015	}
4016
4017
4018	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNop} */
4019	static DECLCALLBACK(PPDMCRITSECT) pdmR3DevHlp_CritSectGetNop(PPDMDEVINS pDevIns)
4020	{
4021	PDMDEV_ASSERT_DEVINS(pDevIns);
4022
4023	PPDMCRITSECT pCritSect = &pDevIns->Internal.s.pDut->CritSectNop;
4024
4025	LogFlow(("pdmR3DevHlp_CritSectGetNop: caller='%s'/%d: return %p\n",
4026	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
4027	return pCritSect;
4028	}
4029
4030
4031	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNopR0} */
4032	static DECLCALLBACK(R0PTRTYPE(PPDMCRITSECT)) pdmR3DevHlp_CritSectGetNopR0(PPDMDEVINS pDevIns)
4033	{
4034	PDMDEV_ASSERT_DEVINS(pDevIns);
4035
4036	R0PTRTYPE(PPDMCRITSECT) pCritSect = 0;
4037	LogFlow(("pdmR3DevHlp_CritSectGetNopR0: caller='%s'/%d: return %RHv\n",
4038	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
4039	return pCritSect;
4040	}
4041
4042
4043	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNopRC} */
4044	static DECLCALLBACK(RCPTRTYPE(PPDMCRITSECT)) pdmR3DevHlp_CritSectGetNopRC(PPDMDEVINS pDevIns)
4045	{
4046	PDMDEV_ASSERT_DEVINS(pDevIns);
4047
4048	RCPTRTYPE(PPDMCRITSECT) pCritSect = 0;
4049	LogFlow(("pdmR3DevHlp_CritSectGetNopRC: caller='%s'/%d: return %RRv\n",
4050	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
4051	return pCritSect;
4052	}
4053
4054
4055	/** @interface_method_impl{PDMDEVHLPR3,pfnSetDeviceCritSect} */
4056	static DECLCALLBACK(int) pdmR3DevHlp_SetDeviceCritSect(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
4057	{
4058	/*
4059	* Validate input.
4060	*/
4061	PDMDEV_ASSERT_DEVINS(pDevIns);
4062	AssertPtrReturn(pCritSect, VERR_INVALID_POINTER);
4063
4064	LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: pCritSect=%p\n",
4065	pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
4066
4067	pDevIns->pCritSectRoR3 = pCritSect;
4068	LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
4069	return VINF_SUCCESS;
4070	}
4071
4072
4073	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectYield} */
4074	static DECLCALLBACK(bool) pdmR3DevHlp_CritSectYield(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
4075	{
4076	PDMDEV_ASSERT_DEVINS(pDevIns);
4077
4078	RT_NOREF(pDevIns, pCritSect);
4079	AssertFailed();
4080	return false;
4081	}
4082
4083
4084	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectEnter} */
4085	static DECLCALLBACK(int) pdmR3DevHlp_CritSectEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy)
4086	{
4087	PDMDEV_ASSERT_DEVINS(pDevIns);
4088
4089	RT_NOREF(pDevIns, pCritSect, rcBusy);
4090	int rc = VERR_NOT_IMPLEMENTED;
4091	AssertFailed();
4092	return rc;
4093	}
4094
4095
4096	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectEnterDebug} */
4097	static DECLCALLBACK(int) pdmR3DevHlp_CritSectEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
4098	{
4099	PDMDEV_ASSERT_DEVINS(pDevIns);
4100
4101	RT_NOREF(pDevIns, rcBusy, uId, RT_SRC_POS_ARGS);
4102	return RTCritSectEnter(&pCritSect->s.CritSect);
4103	}
4104
4105
4106	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectTryEnter} */
4107	static DECLCALLBACK(int) pdmR3DevHlp_CritSectTryEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
4108	{
4109	PDMDEV_ASSERT_DEVINS(pDevIns);
4110
4111	RT_NOREF(pDevIns, pCritSect);
4112	int rc = VERR_NOT_IMPLEMENTED;
4113	AssertFailed();
4114	return rc;
4115	}
4116
4117
4118	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectTryEnterDebug} */
4119	static DECLCALLBACK(int) pdmR3DevHlp_CritSectTryEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
4120	{
4121	PDMDEV_ASSERT_DEVINS(pDevIns);
4122
4123	RT_NOREF(pDevIns, pCritSect, uId, RT_SRC_POS_ARGS);
4124	int rc = VERR_NOT_IMPLEMENTED;
4125	AssertFailed();
4126	return rc;
4127	}
4128
4129
4130	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectLeave} */
4131	static DECLCALLBACK(int) pdmR3DevHlp_CritSectLeave(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
4132	{
4133	PDMDEV_ASSERT_DEVINS(pDevIns);
4134
4135	return RTCritSectLeave(&pCritSect->s.CritSect);
4136	}
4137
4138
4139	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectIsOwner} */
4140	static DECLCALLBACK(bool) pdmR3DevHlp_CritSectIsOwner(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
4141	{
4142	PDMDEV_ASSERT_DEVINS(pDevIns);
4143
4144	return RTCritSectIsOwner(&pCritSect->s.CritSect);
4145	}
4146
4147
4148	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectIsInitialized} */
4149	static DECLCALLBACK(bool) pdmR3DevHlp_CritSectIsInitialized(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
4150	{
4151	PDMDEV_ASSERT_DEVINS(pDevIns);
4152
4153	RT_NOREF(pDevIns, pCritSect);
4154	#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
4155	AssertFailed();
4156	return false;
4157	#else
4158	return true;
4159	#endif
4160	}
4161
4162
4163	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectHasWaiters} */
4164	static DECLCALLBACK(bool) pdmR3DevHlp_CritSectHasWaiters(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
4165	{
4166	PDMDEV_ASSERT_DEVINS(pDevIns);
4167	RT_NOREF(pDevIns, pCritSect);
4168	AssertFailed();
4169	return false;
4170	}
4171
4172
4173	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetRecursion} */
4174	static DECLCALLBACK(uint32_t) pdmR3DevHlp_CritSectGetRecursion(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
4175	{
4176	PDMDEV_ASSERT_DEVINS(pDevIns);
4177
4178	RT_NOREF(pDevIns, pCritSect);
4179	AssertFailed();
4180	return 0;
4181	}
4182
4183
4184	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectScheduleExitEvent} */
4185	static DECLCALLBACK(int) pdmR3DevHlp_CritSectScheduleExitEvent(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect,
4186	SUPSEMEVENT hEventToSignal)
4187	{
4188	PDMDEV_ASSERT_DEVINS(pDevIns);
4189
4190	RT_NOREF(pDevIns, pCritSect, hEventToSignal);
4191	int rc = VERR_NOT_IMPLEMENTED;
4192	AssertFailed();
4193	return rc;
4194	}
4195
4196
4197	/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectDelete} */
4198	static DECLCALLBACK(int) pdmR3DevHlp_CritSectDelete(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
4199	{
4200	PDMDEV_ASSERT_DEVINS(pDevIns);
4201
4202	RT_NOREF(pDevIns, pCritSect);
4203	int rc = VERR_NOT_IMPLEMENTED;
4204	AssertFailed();
4205	return rc;
4206	}
4207
4208
4209	static DECLCALLBACK(int) pdmR3DevHlp_ThreadCreate(PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
4210	PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
4211	{
4212	PDMDEV_ASSERT_DEVINS(pDevIns);
4213	LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: ppThread=%p pvUser=%p pfnThread=%p pfnWakeup=%p cbStack=%#zx enmType=%d pszName=%p:{%s}\n",
4214	pDevIns->pReg->szName, pDevIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
4215
4216	int rc = tstDevPdmR3ThreadCreateDevice(pDevIns->Internal.s.pDut, pDevIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
4217
4218	LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pDevIns->pReg->szName, pDevIns->iInstance,
4219	rc, *ppThread));
4220	return rc;
4221	}
4222
4223
4224	static DECLCALLBACK(int) pdmR3DevHlp_ThreadDestroy(PPDMTHREAD pThread, int *pRcThread)
4225	{
4226	return tstDevPdmR3ThreadDestroy(pThread, pRcThread);
4227	}
4228
4229
4230	static DECLCALLBACK(int) pdmR3DevHlp_ThreadIAmSuspending(PPDMTHREAD pThread)
4231	{
4232	return tstDevPdmR3ThreadIAmSuspending(pThread);
4233	}
4234
4235
4236	static DECLCALLBACK(int) pdmR3DevHlp_ThreadIamRunning(PPDMTHREAD pThread)
4237	{
4238	return tstDevPdmR3ThreadIAmRunning(pThread);
4239	}
4240
4241
4242	static DECLCALLBACK(int) pdmR3DevHlp_ThreadSleep(PPDMTHREAD pThread, RTMSINTERVAL cMillies)
4243	{
4244	return tstDevPdmR3ThreadSleep(pThread, cMillies);
4245	}
4246
4247
4248	static DECLCALLBACK(int) pdmR3DevHlp_ThreadSuspend(PPDMTHREAD pThread)
4249	{
4250	return tstDevPdmR3ThreadSuspend(pThread);
4251	}
4252
4253
4254	static DECLCALLBACK(int) pdmR3DevHlp_ThreadResume(PPDMTHREAD pThread)
4255	{
4256	return tstDevPdmR3ThreadResume(pThread);
4257	}
4258
4259
4260	/** @interface_method_impl{PDMDEVHLPR3,pfnSetAsyncNotification} */
4261	static DECLCALLBACK(int) pdmR3DevHlp_SetAsyncNotification(PPDMDEVINS pDevIns, PFNPDMDEVASYNCNOTIFY pfnAsyncNotify)
4262	{
4263	PDMDEV_ASSERT_DEVINS(pDevIns);
4264	LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pfnAsyncNotify));
4265
4266	int rc = VERR_NOT_IMPLEMENTED;
4267	AssertStmt(pfnAsyncNotify, rc = VERR_INVALID_PARAMETER);
4268	#if 0
4269	AssertStmt(!pDevIns->Internal.s.pfnAsyncNotify, rc = VERR_WRONG_ORDER);
4270	AssertStmt(pDevIns->Internal.s.fIntFlags & (PDMDEVINSINT_FLAGS_SUSPENDED \| PDMDEVINSINT_FLAGS_RESET), rc = VERR_WRONG_ORDER);
4271	#endif
4272
4273	AssertFailed();
4274
4275	LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4276	return rc;
4277	}
4278
4279
4280	/** @interface_method_impl{PDMDEVHLPR3,pfnAsyncNotificationCompleted} */
4281	static DECLCALLBACK(void) pdmR3DevHlp_AsyncNotificationCompleted(PPDMDEVINS pDevIns)
4282	{
4283	PDMDEV_ASSERT_DEVINS(pDevIns);
4284
4285	AssertFailed();
4286	}
4287
4288
4289	/** @interface_method_impl{PDMDEVHLPR3,pfnRTCRegister} */
4290	static DECLCALLBACK(int) pdmR3DevHlp_RTCRegister(PPDMDEVINS pDevIns, PCPDMRTCREG pRtcReg, PCPDMRTCHLP *ppRtcHlp)
4291	{
4292	PDMDEV_ASSERT_DEVINS(pDevIns);
4293	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: pRtcReg=%p:{.u32Version=%#x, .pfnWrite=%p, .pfnRead=%p} ppRtcHlp=%p\n",
4294	pDevIns->pReg->szName, pDevIns->iInstance, pRtcReg, pRtcReg->u32Version, pRtcReg->pfnWrite,
4295	pRtcReg->pfnWrite, ppRtcHlp));
4296
4297	/*
4298	* Validate input.
4299	*/
4300	if (pRtcReg->u32Version != PDM_RTCREG_VERSION)
4301	{
4302	AssertMsgFailed(("u32Version=%#x expected %#x\n", pRtcReg->u32Version,
4303	PDM_RTCREG_VERSION));
4304	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (version)\n",
4305	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4306	return VERR_INVALID_PARAMETER;
4307	}
4308	if ( !pRtcReg->pfnWrite
4309	\|\| !pRtcReg->pfnRead)
4310	{
4311	Assert(pRtcReg->pfnWrite);
4312	Assert(pRtcReg->pfnRead);
4313	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
4314	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4315	return VERR_INVALID_PARAMETER;
4316	}
4317
4318	if (!ppRtcHlp)
4319	{
4320	Assert(ppRtcHlp);
4321	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (ppRtcHlp)\n",
4322	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4323	return VERR_INVALID_PARAMETER;
4324	}
4325
4326	int rc = VERR_NOT_IMPLEMENTED;
4327	AssertFailed();
4328
4329	LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc\n",
4330	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4331	return rc;
4332	}
4333
4334
4335	/** @interface_method_impl{PDMDEVHLPR3,pfnDMARegister} */
4336	static DECLCALLBACK(int) pdmR3DevHlp_DMARegister(PPDMDEVINS pDevIns, unsigned uChannel, PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser)
4337	{
4338	PDMDEV_ASSERT_DEVINS(pDevIns);
4339	LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: uChannel=%d pfnTransferHandler=%p pvUser=%p\n",
4340	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pfnTransferHandler, pvUser));
4341
4342	int rc = VERR_NOT_IMPLEMENTED;
4343	AssertFailed();
4344
4345	LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: returns %Rrc\n",
4346	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4347	return rc;
4348	}
4349
4350
4351	/** @interface_method_impl{PDMDEVHLPR3,pfnDMAReadMemory} */
4352	static DECLCALLBACK(int) pdmR3DevHlp_DMAReadMemory(PPDMDEVINS pDevIns, unsigned uChannel, void pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t pcbRead)
4353	{
4354	PDMDEV_ASSERT_DEVINS(pDevIns);
4355	LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbRead=%p\n",
4356	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbRead));
4357
4358	int rc = VERR_NOT_IMPLEMENTED;
4359	AssertFailed();
4360
4361	LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: returns %Rrc\n",
4362	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4363	return rc;
4364	}
4365
4366
4367	/** @interface_method_impl{PDMDEVHLPR3,pfnDMAWriteMemory} */
4368	static DECLCALLBACK(int) pdmR3DevHlp_DMAWriteMemory(PPDMDEVINS pDevIns, unsigned uChannel, const void pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t pcbWritten)
4369	{
4370	PDMDEV_ASSERT_DEVINS(pDevIns);
4371	LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbWritten=%p\n",
4372	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbWritten));
4373
4374	int rc = VERR_NOT_IMPLEMENTED;
4375	AssertFailed();
4376
4377	LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: returns %Rrc\n",
4378	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4379	return rc;
4380	}
4381
4382
4383	/** @interface_method_impl{PDMDEVHLPR3,pfnDMASetDREQ} */
4384	static DECLCALLBACK(int) pdmR3DevHlp_DMASetDREQ(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel)
4385	{
4386	PDMDEV_ASSERT_DEVINS(pDevIns);
4387	LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: uChannel=%d uLevel=%d\n",
4388	pDevIns->pReg->szName, pDevIns->iInstance, uChannel, uLevel));
4389
4390	int rc = VERR_NOT_IMPLEMENTED;
4391	AssertFailed();
4392
4393	LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: returns %Rrc\n",
4394	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4395	return rc;
4396	}
4397
4398	/** @interface_method_impl{PDMDEVHLPR3,pfnDMAGetChannelMode} */
4399	static DECLCALLBACK(uint8_t) pdmR3DevHlp_DMAGetChannelMode(PPDMDEVINS pDevIns, unsigned uChannel)
4400	{
4401	PDMDEV_ASSERT_DEVINS(pDevIns);
4402	LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: uChannel=%d\n",
4403	pDevIns->pReg->szName, pDevIns->iInstance, uChannel));
4404
4405	uint8_t u8Mode = (3 << 2); /* Invalid mode. */
4406	AssertFailed();
4407
4408	LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: returns %#04x\n",
4409	pDevIns->pReg->szName, pDevIns->iInstance, u8Mode));
4410	return u8Mode;
4411	}
4412
4413	/** @interface_method_impl{PDMDEVHLPR3,pfnDMASchedule} */
4414	static DECLCALLBACK(void) pdmR3DevHlp_DMASchedule(PPDMDEVINS pDevIns)
4415	{
4416	PDMDEV_ASSERT_DEVINS(pDevIns);
4417	LogFlow(("pdmR3DevHlp_DMASchedule: caller='%s'/%d\n",
4418	pDevIns->pReg->szName, pDevIns->iInstance));
4419
4420	AssertFailed();
4421	}
4422
4423
4424	/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSWrite} */
4425	static DECLCALLBACK(int) pdmR3DevHlp_CMOSWrite(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value)
4426	{
4427	PDMDEV_ASSERT_DEVINS(pDevIns);
4428	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x u8Value=%#04x\n",
4429	pDevIns->pReg->szName, pDevIns->iInstance, iReg, u8Value));
4430
4431	int rc = VERR_NOT_IMPLEMENTED;
4432	AssertFailed();
4433
4434	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
4435	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4436	return rc;
4437	}
4438
4439
4440	/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSRead} */
4441	static DECLCALLBACK(int) pdmR3DevHlp_CMOSRead(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value)
4442	{
4443	PDMDEV_ASSERT_DEVINS(pDevIns);
4444	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x pu8Value=%p\n",
4445	pDevIns->pReg->szName, pDevIns->iInstance, iReg, pu8Value));
4446
4447	int rc = VERR_NOT_IMPLEMENTED;
4448	AssertFailed();
4449
4450	LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
4451	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4452	return rc;
4453	}
4454
4455
4456	/** @interface_method_impl{PDMDEVHLPR3,pfnAssertEMT} */
4457	static DECLCALLBACK(bool) pdmR3DevHlp_AssertEMT(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction)
4458	{
4459	PDMDEV_ASSERT_DEVINS(pDevIns);
4460
4461	char szMsg[100];
4462	RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
4463	RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
4464	AssertBreakpoint();
4465	return false;
4466	}
4467
4468
4469	/** @interface_method_impl{PDMDEVHLPR3,pfnAssertOther} */
4470	static DECLCALLBACK(bool) pdmR3DevHlp_AssertOther(PPDMDEVINS pDevIns, const char pszFile, unsigned iLine, const char pszFunction)
4471	{
4472	PDMDEV_ASSERT_DEVINS(pDevIns);
4473
4474	char szMsg[100];
4475	RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
4476	RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
4477	AssertBreakpoint();
4478	return false;
4479	}
4480
4481
4482	/** @interface_method_impl{PDMDEVHLPR3,pfnLdrGetRCInterfaceSymbols} */
4483	static DECLCALLBACK(int) pdmR3DevHlp_LdrGetRCInterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
4484	const char pszSymPrefix, const char pszSymList)
4485	{
4486	PDMDEV_ASSERT_DEVINS(pDevIns);
4487	LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
4488	pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
4489
4490	int rc = VERR_NOT_IMPLEMENTED;
4491	AssertFailed();
4492
4493	LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
4494	pDevIns->iInstance, rc));
4495	return rc;
4496	}
4497
4498
4499	/** @interface_method_impl{PDMDEVHLPR3,pfnLdrGetR0InterfaceSymbols} */
4500	static DECLCALLBACK(int) pdmR3DevHlp_LdrGetR0InterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
4501	const char pszSymPrefix, const char pszSymList)
4502	{
4503	PDMDEV_ASSERT_DEVINS(pDevIns);
4504	LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
4505	pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
4506
4507	int rc = VERR_NOT_IMPLEMENTED;
4508	AssertFailed();
4509
4510	LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
4511	pDevIns->iInstance, rc));
4512	return rc;
4513	}
4514
4515
4516	/** @interface_method_impl{PDMDEVHLPR3,pfnCallR0} */
4517	static DECLCALLBACK(int) pdmR3DevHlp_CallR0(PPDMDEVINS pDevIns, uint32_t uOperation, uint64_t u64Arg)
4518	{
4519	PDMDEV_ASSERT_DEVINS(pDevIns);
4520	LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: uOperation=%#x u64Arg=%#RX64\n",
4521	pDevIns->pReg->szName, pDevIns->iInstance, uOperation, u64Arg));
4522
4523	int rc = VERR_NOT_IMPLEMENTED;
4524	AssertFailed();
4525
4526	LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
4527	pDevIns->iInstance, rc));
4528	return rc;
4529	}
4530
4531
4532	/** @interface_method_impl{PDMDEVHLPR3,pfnVMGetSuspendReason} */
4533	static DECLCALLBACK(VMSUSPENDREASON) pdmR3DevHlp_VMGetSuspendReason(PPDMDEVINS pDevIns)
4534	{
4535	PDMDEV_ASSERT_DEVINS(pDevIns);
4536
4537	VMSUSPENDREASON enmReason = VMSUSPENDREASON_INVALID;
4538	AssertFailed();
4539
4540	LogFlow(("pdmR3DevHlp_VMGetSuspendReason: caller='%s'/%d: returns %d\n",
4541	pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
4542	return enmReason;
4543	}
4544
4545
4546	/** @interface_method_impl{PDMDEVHLPR3,pfnVMGetResumeReason} */
4547	static DECLCALLBACK(VMRESUMEREASON) pdmR3DevHlp_VMGetResumeReason(PPDMDEVINS pDevIns)
4548	{
4549	PDMDEV_ASSERT_DEVINS(pDevIns);
4550
4551	VMRESUMEREASON enmReason = VMRESUMEREASON_INVALID;
4552	AssertFailed();
4553
4554	LogFlow(("pdmR3DevHlp_VMGetResumeReason: caller='%s'/%d: returns %d\n",
4555	pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
4556	return enmReason;
4557	}
4558
4559
4560	/** @interface_method_impl{PDMDEVHLPR3,pfnGetUVM} */
4561	static DECLCALLBACK(PUVM) pdmR3DevHlp_GetUVM(PPDMDEVINS pDevIns)
4562	{
4563	PDMDEV_ASSERT_DEVINS(pDevIns);
4564
4565	AssertFailed();
4566	LogFlow(("pdmR3DevHlp_GetUVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
4567	return NULL;
4568	}
4569
4570
4571	/** @interface_method_impl{PDMDEVHLPR3,pfnGetVM} */
4572	static DECLCALLBACK(PVMCC) pdmR3DevHlp_GetVM(PPDMDEVINS pDevIns)
4573	{
4574	PDMDEV_ASSERT_DEVINS(pDevIns);
4575
4576	LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns->Internal.s.pDut->pVm));
4577	return pDevIns->Internal.s.pDut->pVm;
4578	}
4579
4580
4581	/** @interface_method_impl{PDMDEVHLPR3,pfnGetVMCPU} */
4582	static DECLCALLBACK(PVMCPU) pdmR3DevHlp_GetVMCPU(PPDMDEVINS pDevIns)
4583	{
4584	PDMDEV_ASSERT_DEVINS(pDevIns);
4585
4586	AssertFailed();
4587	LogFlow(("pdmR3DevHlp_GetVMCPU: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
4588	return NULL;
4589	}
4590
4591
4592	/** @interface_method_impl{PDMDEVHLPR3,pfnGetCurrentCpuId} */
4593	static DECLCALLBACK(VMCPUID) pdmR3DevHlp_GetCurrentCpuId(PPDMDEVINS pDevIns)
4594	{
4595	PDMDEV_ASSERT_DEVINS(pDevIns);
4596
4597	VMCPUID idCpu = 0;
4598	AssertFailed();
4599
4600	LogFlow(("pdmR3DevHlp_GetCurrentCpuId: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, idCpu));
4601	return idCpu;
4602	}
4603
4604
4605	/** @interface_method_impl{PDMDEVHLPR3,pfnPCIBusRegister} */
4606	static DECLCALLBACK(int) pdmR3DevHlp_PCIBusRegister(PPDMDEVINS pDevIns, PPDMPCIBUSREGR3 pPciBusReg,
4607	PCPDMPCIHLPR3 ppPciHlp, uint32_t piBus)
4608	{
4609	PDMDEV_ASSERT_DEVINS(pDevIns);
4610	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: pPciBusReg=%p:{.u32Version=%#x, .pfnRegisterR3=%p, .pfnIORegionRegisterR3=%p, "
4611	".pfnInterceptConfigAccesses=%p, pfnConfigRead=%p, pfnConfigWrite=%p, .pfnSetIrqR3=%p, .u32EndVersion=%#x} ppPciHlpR3=%p piBus=%p\n",
4612	pDevIns->pReg->szName, pDevIns->iInstance, pPciBusReg, pPciBusReg->u32Version, pPciBusReg->pfnRegisterR3,
4613	pPciBusReg->pfnIORegionRegisterR3, pPciBusReg->pfnInterceptConfigAccesses, pPciBusReg->pfnConfigRead,
4614	pPciBusReg->pfnConfigWrite, pPciBusReg->pfnSetIrqR3, pPciBusReg->u32EndVersion, ppPciHlp, piBus));
4615
4616	/*
4617	* Validate the structure and output parameters.
4618	*/
4619	AssertLogRelMsgReturn(pPciBusReg->u32Version == PDM_PCIBUSREGR3_VERSION,
4620	("u32Version=%#x expected %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREGR3_VERSION),
4621	VERR_INVALID_PARAMETER);
4622	AssertPtrReturn(pPciBusReg->pfnRegisterR3, VERR_INVALID_PARAMETER);
4623	AssertPtrNullReturn(pPciBusReg->pfnRegisterMsiR3, VERR_INVALID_POINTER);
4624	AssertPtrReturn(pPciBusReg->pfnIORegionRegisterR3, VERR_INVALID_POINTER);
4625	AssertPtrReturn(pPciBusReg->pfnInterceptConfigAccesses, VERR_INVALID_POINTER);
4626	AssertPtrReturn(pPciBusReg->pfnConfigWrite, VERR_INVALID_POINTER);
4627	AssertPtrReturn(pPciBusReg->pfnConfigRead, VERR_INVALID_POINTER);
4628	AssertPtrReturn(pPciBusReg->pfnSetIrqR3, VERR_INVALID_POINTER);
4629	AssertLogRelMsgReturn(pPciBusReg->u32EndVersion == PDM_PCIBUSREGR3_VERSION,
4630	("u32Version=%#x expected %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREGR3_VERSION),
4631	VERR_INVALID_PARAMETER);
4632	AssertPtrReturn(ppPciHlp, VERR_INVALID_POINTER);
4633	AssertPtrNullReturn(piBus, VERR_INVALID_POINTER);
4634
4635	int rc = VERR_NOT_IMPLEMENTED;
4636	AssertFailed();
4637
4638	Log(("PDM: Registered PCI bus device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
4639
4640	LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc piBus=%u\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, piBus));
4641	return rc;
4642	}
4643
4644
4645	/** @interface_method_impl{PDMDEVHLPR3,pfnIommuRegister} */
4646	static DECLCALLBACK(int) pdmR3DevHlp_IommuRegister(PPDMDEVINS pDevIns, PPDMIOMMUREGR3 pIommuReg, PCPDMIOMMUHLPR3 *ppIommuHlp)
4647	{
4648	PDMDEV_ASSERT_DEVINS(pDevIns);
4649	LogFlow(("pdmR3DevHlp_IommuRegister: caller='%s'/%d: pIommuReg=%p:{.u32Version=%#x, .u32TheEnd=%#x } ppIommuHlp=%p\n",
4650	pDevIns->pReg->szName, pDevIns->iInstance, pIommuReg, pIommuReg->u32Version, pIommuReg->u32TheEnd, ppIommuHlp));
4651
4652	/*
4653	* Validate input.
4654	*/
4655	AssertMsgReturn(pIommuReg->u32Version == PDM_IOMMUREGR3_VERSION,
4656	("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIommuReg->u32Version, PDM_IOMMUREGR3_VERSION),
4657	VERR_INVALID_PARAMETER);
4658
4659	/** @todo IOMMU: Validate other parameters */
4660
4661	AssertMsgReturn(pIommuReg->u32TheEnd == PDM_IOMMUREGR3_VERSION,
4662	("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIommuReg->u32TheEnd, PDM_IOMMUREGR3_VERSION),
4663	VERR_INVALID_PARAMETER);
4664	AssertPtrReturn(ppIommuHlp, VERR_INVALID_POINTER);
4665
4666	int rc = VERR_NOT_IMPLEMENTED;
4667	AssertFailed();
4668	Log(("PDM: Registered IOMMU device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
4669
4670	LogFlow(("pdmR3DevHlp_IommuRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4671	return rc;
4672	}
4673
4674
4675	/** @interface_method_impl{PDMDEVHLPR3,pfnPICRegister} */
4676	static DECLCALLBACK(int) pdmR3DevHlp_PICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp)
4677	{
4678	PDMDEV_ASSERT_DEVINS(pDevIns);
4679	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrq=%p, .pfnGetInterrupt=%p, .u32TheEnd=%#x } ppPicHlp=%p\n",
4680	pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrq, pPicReg->pfnGetInterrupt, pPicReg->u32TheEnd, ppPicHlp));
4681
4682	/*
4683	* Validate input.
4684	*/
4685	AssertMsgReturn(pPicReg->u32Version == PDM_PICREG_VERSION,
4686	("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32Version, PDM_PICREG_VERSION),
4687	VERR_INVALID_PARAMETER);
4688	AssertPtrReturn(pPicReg->pfnSetIrq, VERR_INVALID_POINTER);
4689	AssertPtrReturn(pPicReg->pfnGetInterrupt, VERR_INVALID_POINTER);
4690	AssertMsgReturn(pPicReg->u32TheEnd == PDM_PICREG_VERSION,
4691	("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32TheEnd, PDM_PICREG_VERSION),
4692	VERR_INVALID_PARAMETER);
4693	AssertPtrReturn(ppPicHlp, VERR_INVALID_POINTER);
4694
4695	int rc = VERR_NOT_IMPLEMENTED;
4696	AssertFailed();
4697	Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
4698
4699	LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4700	return rc;
4701	}
4702
4703
4704	/** @interface_method_impl{PDMDEVHLPR3,pfnApicRegister} */
4705	static DECLCALLBACK(int) pdmR3DevHlp_ApicRegister(PPDMDEVINS pDevIns)
4706	{
4707	PDMDEV_ASSERT_DEVINS(pDevIns);
4708
4709	int rc = VERR_NOT_IMPLEMENTED;
4710	AssertFailed();
4711
4712	LogFlow(("pdmR3DevHlp_ApicRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4713	return rc;
4714	}
4715
4716
4717	/** @interface_method_impl{PDMDEVHLPR3,pfnIoApicRegister} */
4718	static DECLCALLBACK(int) pdmR3DevHlp_IoApicRegister(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp)
4719	{
4720	PDMDEV_ASSERT_DEVINS(pDevIns);
4721	LogFlow(("pdmR3DevHlp_IoApicRegister: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrq=%p, .pfnSendMsi=%p, .pfnSetEoi=%p, .u32TheEnd=%#x } ppIoApicHlp=%p\n",
4722	pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrq, pIoApicReg->pfnSendMsi, pIoApicReg->pfnSetEoi, pIoApicReg->u32TheEnd, ppIoApicHlp));
4723
4724	/*
4725	* Validate input.
4726	*/
4727	AssertMsgReturn(pIoApicReg->u32Version == PDM_IOAPICREG_VERSION,
4728	("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg->u32Version, PDM_IOAPICREG_VERSION),
4729	VERR_VERSION_MISMATCH);
4730	AssertPtrReturn(pIoApicReg->pfnSetIrq, VERR_INVALID_POINTER);
4731	AssertPtrReturn(pIoApicReg->pfnSendMsi, VERR_INVALID_POINTER);
4732	AssertPtrReturn(pIoApicReg->pfnSetEoi, VERR_INVALID_POINTER);
4733	AssertMsgReturn(pIoApicReg->u32TheEnd == PDM_IOAPICREG_VERSION,
4734	("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg->u32TheEnd, PDM_IOAPICREG_VERSION),
4735	VERR_VERSION_MISMATCH);
4736	AssertPtrReturn(ppIoApicHlp, VERR_INVALID_POINTER);
4737
4738	int rc = VERR_NOT_IMPLEMENTED;
4739	AssertFailed();
4740
4741	LogFlow(("pdmR3DevHlp_IoApicRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4742	return rc;
4743	}
4744
4745
4746	/** @interface_method_impl{PDMDEVHLPR3,pfnHpetRegister} */
4747	static DECLCALLBACK(int) pdmR3DevHlp_HpetRegister(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3)
4748	{
4749	PDMDEV_ASSERT_DEVINS(pDevIns);
4750	LogFlow(("pdmR3DevHlp_HpetRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
4751
4752	/*
4753	* Validate input.
4754	*/
4755	AssertMsgReturn(pHpetReg->u32Version == PDM_HPETREG_VERSION,
4756	("%s/%u: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pHpetReg->u32Version, PDM_HPETREG_VERSION),
4757	VERR_VERSION_MISMATCH);
4758	AssertPtrReturn(ppHpetHlpR3, VERR_INVALID_POINTER);
4759
4760	int rc = VERR_NOT_IMPLEMENTED;
4761	AssertFailed();
4762
4763	LogFlow(("pdmR3DevHlp_HpetRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4764	return rc;
4765	}
4766
4767
4768	/** @interface_method_impl{PDMDEVHLPR3,pfnPciRawRegister} */
4769	static DECLCALLBACK(int) pdmR3DevHlp_PciRawRegister(PPDMDEVINS pDevIns, PPDMPCIRAWREG pPciRawReg, PCPDMPCIRAWHLPR3 *ppPciRawHlpR3)
4770	{
4771	PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
4772	LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
4773
4774	/*
4775	* Validate input.
4776	*/
4777	if (pPciRawReg->u32Version != PDM_PCIRAWREG_VERSION)
4778	{
4779	AssertMsgFailed(("u32Version=%#x expected %#x\n", pPciRawReg->u32Version, PDM_PCIRAWREG_VERSION));
4780	LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4781	return VERR_INVALID_PARAMETER;
4782	}
4783
4784	if (!ppPciRawHlpR3)
4785	{
4786	Assert(ppPciRawHlpR3);
4787	LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc (ppPciRawHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4788	return VERR_INVALID_PARAMETER;
4789	}
4790
4791	int rc = VERR_NOT_IMPLEMENTED;
4792	AssertFailed();
4793
4794	LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4795	return rc;
4796	}
4797
4798
4799	/** @interface_method_impl{PDMDEVHLPR3,pfnDMACRegister} */
4800	static DECLCALLBACK(int) pdmR3DevHlp_DMACRegister(PPDMDEVINS pDevIns, PPDMDMACREG pDmacReg, PCPDMDMACHLP *ppDmacHlp)
4801	{
4802	PDMDEV_ASSERT_DEVINS(pDevIns);
4803	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",
4804	pDevIns->pReg->szName, pDevIns->iInstance, pDmacReg, pDmacReg->u32Version, pDmacReg->pfnRun, pDmacReg->pfnRegister,
4805	pDmacReg->pfnReadMemory, pDmacReg->pfnWriteMemory, pDmacReg->pfnSetDREQ, pDmacReg->pfnGetChannelMode, ppDmacHlp));
4806
4807	/*
4808	* Validate input.
4809	*/
4810	if (pDmacReg->u32Version != PDM_DMACREG_VERSION)
4811	{
4812	AssertMsgFailed(("u32Version=%#x expected %#x\n", pDmacReg->u32Version,
4813	PDM_DMACREG_VERSION));
4814	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (version)\n",
4815	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4816	return VERR_INVALID_PARAMETER;
4817	}
4818	if ( !pDmacReg->pfnRun
4819	\|\| !pDmacReg->pfnRegister
4820	\|\| !pDmacReg->pfnReadMemory
4821	\|\| !pDmacReg->pfnWriteMemory
4822	\|\| !pDmacReg->pfnSetDREQ
4823	\|\| !pDmacReg->pfnGetChannelMode)
4824	{
4825	Assert(pDmacReg->pfnRun);
4826	Assert(pDmacReg->pfnRegister);
4827	Assert(pDmacReg->pfnReadMemory);
4828	Assert(pDmacReg->pfnWriteMemory);
4829	Assert(pDmacReg->pfnSetDREQ);
4830	Assert(pDmacReg->pfnGetChannelMode);
4831	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
4832	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4833	return VERR_INVALID_PARAMETER;
4834	}
4835
4836	if (!ppDmacHlp)
4837	{
4838	Assert(ppDmacHlp);
4839	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (ppDmacHlp)\n",
4840	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4841	return VERR_INVALID_PARAMETER;
4842	}
4843
4844	int rc = VERR_NOT_IMPLEMENTED;
4845	AssertFailed();
4846
4847	LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc\n",
4848	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4849	return rc;
4850	}
4851
4852
4853	/**
4854	* @copydoc PDMDEVHLPR3::pfnRegisterVMMDevHeap
4855	*/
4856	static DECLCALLBACK(int) pdmR3DevHlp_RegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbHeap)
4857	{
4858	PDMDEV_ASSERT_DEVINS(pDevIns);
4859	LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: GCPhys=%RGp pvHeap=%p cbHeap=%#x\n",
4860	pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvHeap, cbHeap));
4861
4862	int rc = VERR_NOT_IMPLEMENTED;
4863	AssertFailed();
4864
4865	LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: returns %Rrc\n",
4866	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4867	return rc;
4868	}
4869
4870
4871	/**
4872	* @interface_method_impl{PDMDEVHLPR3,pfnFirmwareRegister}
4873	*/
4874	static DECLCALLBACK(int) pdmR3DevHlp_FirmwareRegister(PPDMDEVINS pDevIns, PCPDMFWREG pFwReg, PCPDMFWHLPR3 *ppFwHlp)
4875	{
4876	PDMDEV_ASSERT_DEVINS(pDevIns);
4877	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: pFWReg=%p:{.u32Version=%#x, .pfnIsHardReset=%p, .u32TheEnd=%#x} ppFwHlp=%p\n",
4878	pDevIns->pReg->szName, pDevIns->iInstance, pFwReg, pFwReg->u32Version, pFwReg->pfnIsHardReset, pFwReg->u32TheEnd, ppFwHlp));
4879
4880	/*
4881	* Validate input.
4882	*/
4883	if (pFwReg->u32Version != PDM_FWREG_VERSION)
4884	{
4885	AssertMsgFailed(("u32Version=%#x expected %#x\n", pFwReg->u32Version, PDM_FWREG_VERSION));
4886	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (version)\n",
4887	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4888	return VERR_INVALID_PARAMETER;
4889	}
4890	if (!pFwReg->pfnIsHardReset)
4891	{
4892	Assert(pFwReg->pfnIsHardReset);
4893	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
4894	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4895	return VERR_INVALID_PARAMETER;
4896	}
4897
4898	if (!ppFwHlp)
4899	{
4900	Assert(ppFwHlp);
4901	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (ppFwHlp)\n",
4902	pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
4903	return VERR_INVALID_PARAMETER;
4904	}
4905
4906	int rc = VERR_NOT_IMPLEMENTED;
4907	AssertFailed();
4908
4909	LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc\n",
4910	pDevIns->pReg->szName, pDevIns->iInstance, rc));
4911	return rc;
4912	}
4913
4914
4915	/** @interface_method_impl{PDMDEVHLPR3,pfnVMReset} */
4916	static DECLCALLBACK(int) pdmR3DevHlp_VMReset(PPDMDEVINS pDevIns, uint32_t fFlags)
4917	{
4918	PDMDEV_ASSERT_DEVINS(pDevIns);
4919	LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: fFlags=%#x\n",
4920	pDevIns->pReg->szName, pDevIns->iInstance, fFlags));
4921
4922	int rc = VERR_NOT_IMPLEMENTED;
4923	AssertFailed();
4924
4925	LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4926	return rc;
4927	}
4928
4929
4930	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspend} */
4931	static DECLCALLBACK(int) pdmR3DevHlp_VMSuspend(PPDMDEVINS pDevIns)
4932	{
4933	PDMDEV_ASSERT_DEVINS(pDevIns);
4934	LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d:\n",
4935	pDevIns->pReg->szName, pDevIns->iInstance));
4936
4937	int rc = VERR_NOT_IMPLEMENTED;
4938	AssertFailed();
4939
4940	LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4941	return rc;
4942	}
4943
4944
4945	/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspendSaveAndPowerOff} */
4946	static DECLCALLBACK(int) pdmR3DevHlp_VMSuspendSaveAndPowerOff(PPDMDEVINS pDevIns)
4947	{
4948	PDMDEV_ASSERT_DEVINS(pDevIns);
4949	LogFlow(("pdmR3DevHlp_VMSuspendSaveAndPowerOff: caller='%s'/%d:\n",
4950	pDevIns->pReg->szName, pDevIns->iInstance));
4951
4952	int rc = VERR_NOT_IMPLEMENTED;
4953	AssertFailed();
4954
4955	LogFlow(("pdmR3DevHlp_VMSuspendSaveAndPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4956	return rc;
4957	}
4958
4959
4960	/** @interface_method_impl{PDMDEVHLPR3,pfnVMPowerOff} */
4961	static DECLCALLBACK(int) pdmR3DevHlp_VMPowerOff(PPDMDEVINS pDevIns)
4962	{
4963	PDMDEV_ASSERT_DEVINS(pDevIns);
4964	LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d:\n",
4965	pDevIns->pReg->szName, pDevIns->iInstance));
4966
4967	int rc = VERR_NOT_IMPLEMENTED;
4968	AssertFailed();
4969
4970	LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
4971	return rc;
4972	}
4973
4974
4975	/** @interface_method_impl{PDMDEVHLPR3,pfnA20IsEnabled} */
4976	static DECLCALLBACK(bool) pdmR3DevHlp_A20IsEnabled(PPDMDEVINS pDevIns)
4977	{
4978	PDMDEV_ASSERT_DEVINS(pDevIns);
4979
4980	bool fRc = false;
4981	AssertFailed();
4982
4983	LogFlow(("pdmR3DevHlp_A20IsEnabled: caller='%s'/%d: returns %d\n", pDevIns->pReg->szName, pDevIns->iInstance, fRc));
4984	return fRc;
4985	}
4986
4987
4988	/** @interface_method_impl{PDMDEVHLPR3,pfnA20Set} */
4989	static DECLCALLBACK(void) pdmR3DevHlp_A20Set(PPDMDEVINS pDevIns, bool fEnable)
4990	{
4991	PDMDEV_ASSERT_DEVINS(pDevIns);
4992	LogFlow(("pdmR3DevHlp_A20Set: caller='%s'/%d: fEnable=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, fEnable));
4993	AssertFailed();
4994	}
4995
4996
4997	/** @interface_method_impl{PDMDEVHLPR3,pfnGetCpuId} */
4998	static DECLCALLBACK(void) pdmR3DevHlp_GetCpuId(PPDMDEVINS pDevIns, uint32_t iLeaf,
4999	uint32_t pEax, uint32_t pEbx, uint32_t pEcx, uint32_t pEdx)
5000	{
5001	PDMDEV_ASSERT_DEVINS(pDevIns);
5002	LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: iLeaf=%d pEax=%p pEbx=%p pEcx=%p pEdx=%p\n",
5003	pDevIns->pReg->szName, pDevIns->iInstance, iLeaf, pEax, pEbx, pEcx, pEdx));
5004	AssertPtr(pEax); AssertPtr(pEbx); AssertPtr(pEcx); AssertPtr(pEdx);
5005
5006	AssertFailed();
5007
5008	LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: returns void - pEax=%#x pEbx=%#x pEcx=%#x pEdx=%#x\n",
5009	pDevIns->pReg->szName, pDevIns->iInstance, pEax, pEbx, pEcx, pEdx));
5010	}
5011
5012	const PDMDEVHLPR3 g_tstDevPdmDevHlpR3 =
5013	{
5014	PDM_DEVHLPR3_VERSION,
5015	pdmR3DevHlp_IoPortCreateEx,
5016	pdmR3DevHlp_IoPortMap,
5017	pdmR3DevHlp_IoPortUnmap,
5018	pdmR3DevHlp_IoPortGetMappingAddress,
5019	pdmR3DevHlp_MmioCreateEx,
5020	pdmR3DevHlp_MmioMap,
5021	pdmR3DevHlp_MmioUnmap,
5022	pdmR3DevHlp_MmioReduce,
5023	pdmR3DevHlp_MmioGetMappingAddress,
5024	pdmR3DevHlp_Mmio2Create,
5025	pdmR3DevHlp_Mmio2Destroy,
5026	pdmR3DevHlp_Mmio2Map,
5027	pdmR3DevHlp_Mmio2Unmap,
5028	pdmR3DevHlp_Mmio2Reduce,
5029	pdmR3DevHlp_Mmio2GetMappingAddress,
5030	pdmR3DevHlp_Mmio2ChangeRegionNo,
5031	pdmR3DevHlp_ROMRegister,
5032	pdmR3DevHlp_ROMProtectShadow,
5033	pdmR3DevHlp_SSMRegister,
5034	pdmR3DevHlp_SSMPutStruct,
5035	pdmR3DevHlp_SSMPutStructEx,
5036	pdmR3DevHlp_SSMPutBool,
5037	pdmR3DevHlp_SSMPutU8,
5038	pdmR3DevHlp_SSMPutS8,
5039	pdmR3DevHlp_SSMPutU16,
5040	pdmR3DevHlp_SSMPutS16,
5041	pdmR3DevHlp_SSMPutU32,
5042	pdmR3DevHlp_SSMPutS32,
5043	pdmR3DevHlp_SSMPutU64,
5044	pdmR3DevHlp_SSMPutS64,
5045	pdmR3DevHlp_SSMPutU128,
5046	pdmR3DevHlp_SSMPutS128,
5047	pdmR3DevHlp_SSMPutUInt,
5048	pdmR3DevHlp_SSMPutSInt,
5049	pdmR3DevHlp_SSMPutGCUInt,
5050	pdmR3DevHlp_SSMPutGCUIntReg,
5051	pdmR3DevHlp_SSMPutGCPhys32,
5052	pdmR3DevHlp_SSMPutGCPhys64,
5053	pdmR3DevHlp_SSMPutGCPhys,
5054	pdmR3DevHlp_SSMPutGCPtr,
5055	pdmR3DevHlp_SSMPutGCUIntPtr,
5056	pdmR3DevHlp_SSMPutRCPtr,
5057	pdmR3DevHlp_SSMPutIOPort,
5058	pdmR3DevHlp_SSMPutSel,
5059	pdmR3DevHlp_SSMPutMem,
5060	pdmR3DevHlp_SSMPutStrZ,
5061	pdmR3DevHlp_SSMGetStruct,
5062	pdmR3DevHlp_SSMGetStructEx,
5063	pdmR3DevHlp_SSMGetBool,
5064	pdmR3DevHlp_SSMGetBoolV,
5065	pdmR3DevHlp_SSMGetU8,
5066	pdmR3DevHlp_SSMGetU8V,
5067	pdmR3DevHlp_SSMGetS8,
5068	pdmR3DevHlp_SSMGetS8V,
5069	pdmR3DevHlp_SSMGetU16,
5070	pdmR3DevHlp_SSMGetU16V,
5071	pdmR3DevHlp_SSMGetS16,
5072	pdmR3DevHlp_SSMGetS16V,
5073	pdmR3DevHlp_SSMGetU32,
5074	pdmR3DevHlp_SSMGetU32V,
5075	pdmR3DevHlp_SSMGetS32,
5076	pdmR3DevHlp_SSMGetS32V,
5077	pdmR3DevHlp_SSMGetU64,
5078	pdmR3DevHlp_SSMGetU64V,
5079	pdmR3DevHlp_SSMGetS64,
5080	pdmR3DevHlp_SSMGetS64V,
5081	pdmR3DevHlp_SSMGetU128,
5082	pdmR3DevHlp_SSMGetU128V,
5083	pdmR3DevHlp_SSMGetS128,
5084	pdmR3DevHlp_SSMGetS128V,
5085	pdmR3DevHlp_SSMGetGCPhys32,
5086	pdmR3DevHlp_SSMGetGCPhys32V,
5087	pdmR3DevHlp_SSMGetGCPhys64,
5088	pdmR3DevHlp_SSMGetGCPhys64V,
5089	pdmR3DevHlp_SSMGetGCPhys,
5090	pdmR3DevHlp_SSMGetGCPhysV,
5091	pdmR3DevHlp_SSMGetUInt,
5092	pdmR3DevHlp_SSMGetSInt,
5093	pdmR3DevHlp_SSMGetGCUInt,
5094	pdmR3DevHlp_SSMGetGCUIntReg,
5095	pdmR3DevHlp_SSMGetGCPtr,
5096	pdmR3DevHlp_SSMGetGCUIntPtr,
5097	pdmR3DevHlp_SSMGetRCPtr,
5098	pdmR3DevHlp_SSMGetIOPort,
5099	pdmR3DevHlp_SSMGetSel,
5100	pdmR3DevHlp_SSMGetMem,
5101	pdmR3DevHlp_SSMGetStrZ,
5102	pdmR3DevHlp_SSMGetStrZEx,
5103	pdmR3DevHlp_SSMSkip,
5104	pdmR3DevHlp_SSMSkipToEndOfUnit,
5105	pdmR3DevHlp_SSMSetLoadError,
5106	pdmR3DevHlp_SSMSetLoadErrorV,
5107	pdmR3DevHlp_SSMSetCfgError,
5108	pdmR3DevHlp_SSMSetCfgErrorV,
5109	pdmR3DevHlp_SSMHandleGetStatus,
5110	pdmR3DevHlp_SSMHandleGetAfter,
5111	pdmR3DevHlp_SSMHandleIsLiveSave,
5112	pdmR3DevHlp_SSMHandleMaxDowntime,
5113	pdmR3DevHlp_SSMHandleHostBits,
5114	pdmR3DevHlp_SSMHandleRevision,
5115	pdmR3DevHlp_SSMHandleVersion,
5116	pdmR3DevHlp_SSMHandleHostOSAndArch,
5117	pdmR3DevHlp_TMTimerCreate,
5118	pdmR3DevHlp_TimerCreate,
5119	pdmR3DevHlp_TimerToPtr,
5120	pdmR3DevHlp_TimerFromMicro,
5121	pdmR3DevHlp_TimerFromMilli,
5122	pdmR3DevHlp_TimerFromNano,
5123	pdmR3DevHlp_TimerGet,
5124	pdmR3DevHlp_TimerGetFreq,
5125	pdmR3DevHlp_TimerGetNano,
5126	pdmR3DevHlp_TimerIsActive,
5127	pdmR3DevHlp_TimerIsLockOwner,
5128	pdmR3DevHlp_TimerLockClock,
5129	pdmR3DevHlp_TimerLockClock2,
5130	pdmR3DevHlp_TimerSet,
5131	pdmR3DevHlp_TimerSetFrequencyHint,
5132	pdmR3DevHlp_TimerSetMicro,
5133	pdmR3DevHlp_TimerSetMillies,
5134	pdmR3DevHlp_TimerSetNano,
5135	pdmR3DevHlp_TimerSetRelative,
5136	pdmR3DevHlp_TimerStop,
5137	pdmR3DevHlp_TimerUnlockClock,
5138	pdmR3DevHlp_TimerUnlockClock2,
5139	pdmR3DevHlp_TimerSetCritSect,
5140	pdmR3DevHlp_TimerSave,
5141	pdmR3DevHlp_TimerLoad,
5142	pdmR3DevHlp_TimerDestroy,
5143	pdmR3DevHlp_TimerSkipLoad,
5144	pdmR3DevHlp_TMUtcNow,
5145	pdmR3DevHlp_CFGMExists,
5146	pdmR3DevHlp_CFGMQueryType,
5147	pdmR3DevHlp_CFGMQuerySize,
5148	pdmR3DevHlp_CFGMQueryInteger,
5149	pdmR3DevHlp_CFGMQueryIntegerDef,
5150	pdmR3DevHlp_CFGMQueryString,
5151	pdmR3DevHlp_CFGMQueryStringDef,
5152	pdmR3DevHlp_CFGMQueryBytes,
5153	pdmR3DevHlp_CFGMQueryU64,
5154	pdmR3DevHlp_CFGMQueryU64Def,
5155	pdmR3DevHlp_CFGMQueryS64,
5156	pdmR3DevHlp_CFGMQueryS64Def,
5157	pdmR3DevHlp_CFGMQueryU32,
5158	pdmR3DevHlp_CFGMQueryU32Def,
5159	pdmR3DevHlp_CFGMQueryS32,
5160	pdmR3DevHlp_CFGMQueryS32Def,
5161	pdmR3DevHlp_CFGMQueryU16,
5162	pdmR3DevHlp_CFGMQueryU16Def,
5163	pdmR3DevHlp_CFGMQueryS16,
5164	pdmR3DevHlp_CFGMQueryS16Def,
5165	pdmR3DevHlp_CFGMQueryU8,
5166	pdmR3DevHlp_CFGMQueryU8Def,
5167	pdmR3DevHlp_CFGMQueryS8,
5168	pdmR3DevHlp_CFGMQueryS8Def,
5169	pdmR3DevHlp_CFGMQueryBool,
5170	pdmR3DevHlp_CFGMQueryBoolDef,
5171	pdmR3DevHlp_CFGMQueryPort,
5172	pdmR3DevHlp_CFGMQueryPortDef,
5173	pdmR3DevHlp_CFGMQueryUInt,
5174	pdmR3DevHlp_CFGMQueryUIntDef,
5175	pdmR3DevHlp_CFGMQuerySInt,
5176	pdmR3DevHlp_CFGMQuerySIntDef,
5177	pdmR3DevHlp_CFGMQueryPtr,
5178	pdmR3DevHlp_CFGMQueryPtrDef,
5179	pdmR3DevHlp_CFGMQueryGCPtr,
5180	pdmR3DevHlp_CFGMQueryGCPtrDef,
5181	pdmR3DevHlp_CFGMQueryGCPtrU,
5182	pdmR3DevHlp_CFGMQueryGCPtrUDef,
5183	pdmR3DevHlp_CFGMQueryGCPtrS,
5184	pdmR3DevHlp_CFGMQueryGCPtrSDef,
5185	pdmR3DevHlp_CFGMQueryStringAlloc,
5186	pdmR3DevHlp_CFGMQueryStringAllocDef,
5187	pdmR3DevHlp_CFGMGetParent,
5188	pdmR3DevHlp_CFGMGetChild,
5189	pdmR3DevHlp_CFGMGetChildF,
5190	pdmR3DevHlp_CFGMGetChildFV,
5191	pdmR3DevHlp_CFGMGetFirstChild,
5192	pdmR3DevHlp_CFGMGetNextChild,
5193	pdmR3DevHlp_CFGMGetName,
5194	pdmR3DevHlp_CFGMGetNameLen,
5195	pdmR3DevHlp_CFGMAreChildrenValid,
5196	pdmR3DevHlp_CFGMGetFirstValue,
5197	pdmR3DevHlp_CFGMGetNextValue,
5198	pdmR3DevHlp_CFGMGetValueName,
5199	pdmR3DevHlp_CFGMGetValueNameLen,
5200	pdmR3DevHlp_CFGMGetValueType,
5201	pdmR3DevHlp_CFGMAreValuesValid,
5202	pdmR3DevHlp_CFGMValidateConfig,
5203	pdmR3DevHlp_PhysRead,
5204	pdmR3DevHlp_PhysWrite,
5205	pdmR3DevHlp_PhysGCPhys2CCPtr,
5206	pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly,
5207	pdmR3DevHlp_PhysReleasePageMappingLock,
5208	pdmR3DevHlp_PhysReadGCVirt,
5209	pdmR3DevHlp_PhysWriteGCVirt,
5210	pdmR3DevHlp_PhysGCPtr2GCPhys,
5211	pdmR3DevHlp_MMHeapAlloc,
5212	pdmR3DevHlp_MMHeapAllocZ,
5213	pdmR3DevHlp_MMHeapFree,
5214	pdmR3DevHlp_VMState,
5215	pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet,
5216	pdmR3DevHlp_VMSetError,
5217	pdmR3DevHlp_VMSetErrorV,
5218	pdmR3DevHlp_VMSetRuntimeError,
5219	pdmR3DevHlp_VMSetRuntimeErrorV,
5220	pdmR3DevHlp_DBGFStopV,
5221	pdmR3DevHlp_DBGFInfoRegister,
5222	pdmR3DevHlp_DBGFInfoRegisterArgv,
5223	pdmR3DevHlp_DBGFRegRegister,
5224	pdmR3DevHlp_DBGFTraceBuf,
5225	pdmR3DevHlp_STAMRegister,
5226	pdmR3DevHlp_STAMRegisterV,
5227	pdmR3DevHlp_PCIRegister,
5228	pdmR3DevHlp_PCIRegisterMsi,
5229	pdmR3DevHlp_PCIIORegionRegister,
5230	pdmR3DevHlp_PCIInterceptConfigAccesses,
5231	pdmR3DevHlp_PCIConfigWrite,
5232	pdmR3DevHlp_PCIConfigRead,
5233	pdmR3DevHlp_PCIPhysRead,
5234	pdmR3DevHlp_PCIPhysWrite,
5235	pdmR3DevHlp_PCISetIrq,
5236	pdmR3DevHlp_PCISetIrqNoWait,
5237	pdmR3DevHlp_ISASetIrq,
5238	pdmR3DevHlp_ISASetIrqNoWait,
5239	pdmR3DevHlp_IoApicSendMsi,
5240	pdmR3DevHlp_DriverAttach,
5241	pdmR3DevHlp_DriverDetach,
5242	pdmR3DevHlp_DriverReconfigure,
5243	pdmR3DevHlp_QueueCreatePtr,
5244	pdmR3DevHlp_QueueCreate,
5245	pdmR3DevHlp_QueueToPtr,
5246	pdmR3DevHlp_QueueAlloc,
5247	pdmR3DevHlp_QueueInsert,
5248	pdmR3DevHlp_QueueInsertEx,
5249	pdmR3DevHlp_QueueFlushIfNecessary,
5250	pdmR3DevHlp_TaskCreate,
5251	pdmR3DevHlp_TaskTrigger,
5252	pdmR3DevHlp_SUPSemEventCreate,
5253	pdmR3DevHlp_SUPSemEventClose,
5254	pdmR3DevHlp_SUPSemEventSignal,
5255	pdmR3DevHlp_SUPSemEventWaitNoResume,
5256	pdmR3DevHlp_SUPSemEventWaitNsAbsIntr,
5257	pdmR3DevHlp_SUPSemEventWaitNsRelIntr,
5258	pdmR3DevHlp_SUPSemEventGetResolution,
5259	pdmR3DevHlp_SUPSemEventMultiCreate,
5260	pdmR3DevHlp_SUPSemEventMultiClose,
5261	pdmR3DevHlp_SUPSemEventMultiSignal,
5262	pdmR3DevHlp_SUPSemEventMultiReset,
5263	pdmR3DevHlp_SUPSemEventMultiWaitNoResume,
5264	pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr,
5265	pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr,
5266	pdmR3DevHlp_SUPSemEventMultiGetResolution,
5267	pdmR3DevHlp_CritSectInit,
5268	pdmR3DevHlp_CritSectGetNop,
5269	pdmR3DevHlp_CritSectGetNopR0,
5270	pdmR3DevHlp_CritSectGetNopRC,
5271	pdmR3DevHlp_SetDeviceCritSect,
5272	pdmR3DevHlp_CritSectYield,
5273	pdmR3DevHlp_CritSectEnter,
5274	pdmR3DevHlp_CritSectEnterDebug,
5275	pdmR3DevHlp_CritSectTryEnter,
5276	pdmR3DevHlp_CritSectTryEnterDebug,
5277	pdmR3DevHlp_CritSectLeave,
5278	pdmR3DevHlp_CritSectIsOwner,
5279	pdmR3DevHlp_CritSectIsInitialized,
5280	pdmR3DevHlp_CritSectHasWaiters,
5281	pdmR3DevHlp_CritSectGetRecursion,
5282	pdmR3DevHlp_CritSectScheduleExitEvent,
5283	pdmR3DevHlp_CritSectDelete,
5284	pdmR3DevHlp_ThreadCreate,
5285	pdmR3DevHlp_ThreadDestroy,
5286	pdmR3DevHlp_ThreadIAmSuspending,
5287	pdmR3DevHlp_ThreadIamRunning,
5288	pdmR3DevHlp_ThreadSleep,
5289	pdmR3DevHlp_ThreadSuspend,
5290	pdmR3DevHlp_ThreadResume,
5291	pdmR3DevHlp_SetAsyncNotification,
5292	pdmR3DevHlp_AsyncNotificationCompleted,
5293	pdmR3DevHlp_RTCRegister,
5294	pdmR3DevHlp_PCIBusRegister,
5295	pdmR3DevHlp_IommuRegister,
5296	pdmR3DevHlp_PICRegister,
5297	pdmR3DevHlp_ApicRegister,
5298	pdmR3DevHlp_IoApicRegister,
5299	pdmR3DevHlp_HpetRegister,
5300	pdmR3DevHlp_PciRawRegister,
5301	pdmR3DevHlp_DMACRegister,
5302	pdmR3DevHlp_DMARegister,
5303	pdmR3DevHlp_DMAReadMemory,
5304	pdmR3DevHlp_DMAWriteMemory,
5305	pdmR3DevHlp_DMASetDREQ,
5306	pdmR3DevHlp_DMAGetChannelMode,
5307	pdmR3DevHlp_DMASchedule,
5308	pdmR3DevHlp_CMOSWrite,
5309	pdmR3DevHlp_CMOSRead,
5310	pdmR3DevHlp_AssertEMT,
5311	pdmR3DevHlp_AssertOther,
5312	pdmR3DevHlp_LdrGetRCInterfaceSymbols,
5313	pdmR3DevHlp_LdrGetR0InterfaceSymbols,
5314	pdmR3DevHlp_CallR0,
5315	pdmR3DevHlp_VMGetSuspendReason,
5316	pdmR3DevHlp_VMGetResumeReason,
5317	pdmR3DevHlp_PhysBulkGCPhys2CCPtr,
5318	pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly,
5319	pdmR3DevHlp_PhysBulkReleasePageMappingLocks,
5320	pdmR3DevHlp_CpuGetGuestMicroarch,
5321	NULL,
5322	NULL,
5323	NULL,
5324	NULL,
5325	NULL,
5326	NULL,
5327	NULL,
5328	NULL,
5329	NULL,
5330	NULL,
5331	pdmR3DevHlp_GetUVM,
5332	pdmR3DevHlp_GetVM,
5333	pdmR3DevHlp_GetVMCPU,
5334	pdmR3DevHlp_GetCurrentCpuId,
5335	pdmR3DevHlp_RegisterVMMDevHeap,
5336	pdmR3DevHlp_FirmwareRegister,
5337	pdmR3DevHlp_VMReset,
5338	pdmR3DevHlp_VMSuspend,
5339	pdmR3DevHlp_VMSuspendSaveAndPowerOff,
5340	pdmR3DevHlp_VMPowerOff,
5341	pdmR3DevHlp_A20IsEnabled,
5342	pdmR3DevHlp_A20Set,
5343	pdmR3DevHlp_GetCpuId,
5344	pdmR3DevHlp_TMTimeVirtGet,
5345	pdmR3DevHlp_TMTimeVirtGetFreq,
5346	pdmR3DevHlp_TMTimeVirtGetNano,
5347	pdmR3DevHlp_GetSupDrvSession,
5348	pdmR3DevHlp_QueryGenericUserObject,
5349	pdmR3DevHlp_PGMHandlerPhysicalTypeRegister,
5350	PDM_DEVHLPR3_VERSION /* the end */
5351	};
5352

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

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

Download in other formats: