VirtualBox

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

Last change on this file since 83261 was 83261, checked in by vboxsync, 5 years ago

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette