VirtualBox

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

最後變更 在這個檔案從92016是 92000,由 vboxsync 提交於 3 年 前

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

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