tstDevicePdmDevHlp.cpp@ 91998

最後變更在這個檔案從91998是 91998,由 vboxsync 提交於 3 年前
Devices/testcase: Some fun with the device fuzzing framework, bugref:9006
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 212.7 KB

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

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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

以其他格式下載: