VirtualBox

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

Last change on this file since 93110 was 93110, checked in by vboxsync, 3 years ago

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

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