VirtualBox

Changeset 91998 in vbox for trunk/src


Ignore:
Timestamp:
Oct 22, 2021 8:58:44 AM (3 years ago)
Author:
vboxsync
Message:

Devices/testcase: Some fun with the device fuzzing framework, bugref:9006

Location:
trunk/src/VBox/Devices
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Makefile.kmk

    r91970 r91998  
    15081508        testcase/tstDevicePdmDevHlp.cpp \
    15091509        testcase/tstDevicePdmThread.cpp \
    1510         testcase/tstDeviceSsmFuzz.cpp
     1510        testcase/tstDeviceSsmFuzz.cpp \
     1511        testcase/tstDeviceIoFuzz.cpp
    15111512 endif
    15121513

  • trunk/src/VBox/Devices/testcase/tstDevice.cpp

    r83261 r91998  
    193193typedef const TSTDEVPDMR0IMPORTS *PCTSTDEVPDMR0IMPORTS;
    194194
     195typedef DECLCALLBACKTYPE(int, FNR0MODULEINIT,(void *hMod));
     196typedef FNR0MODULEINIT *PFNR0MODULEINIT;
     197
    195198
    196199/*********************************************************************************************************************************
    … …  
    206209RTLISTANCHOR g_LstPdmDevs;
    207210
     211static int tstDevPdmR0RegisterModule(void *hMod, PPDMDEVMODREGR0 pModReg);
     212
    208213/**
    209214 * PDM R0 imports we implement.
    … …  
    211216static const TSTDEVPDMR0IMPORTS g_aPdmR0Imports[] =
    212217{
    213 #if 0
    214     {"IOMMMIOMapMMIO2Page",            (PFNRT)IOMMMIOMapMMIO2Page},
    215     {"IOMMMIOResetRegion",             (PFNRT)IOMMMIOResetRegion},
     218    {"SUPR0TracerFireProbe",           (PFNRT)NULL},
     219    {"SUPSemEventSignal",              (PFNRT)NULL},
     220    {"PDMR0DeviceRegisterModule",      (PFNRT)tstDevPdmR0RegisterModule},
     221    {"PDMR0DeviceDeregisterModule",    (PFNRT)NULL},
     222    {"PGMShwMakePageWritable",         (PFNRT)NULL},
    216223    {"IntNetR0IfSend",                 (PFNRT)/*IntNetR0IfSend*/NULL},
    217224    {"IntNetR0IfSetPromiscuousMode",   (PFNRT)/*IntNetR0IfSetPromiscuousMode*/NULL},
    218     {"PDMCritSectEnterDebug",          (PFNRT)PDMCritSectEnterDebug},
    219     {"PDMCritSectIsOwner",             (PFNRT)PDMCritSectIsOwner},
    220     {"PDMCritSectLeave",               (PFNRT)PDMCritSectLeave},
    221     {"PDMCritSectTryEnterDebug",       (PFNRT)PDMCritSectTryEnterDebug},
    222     {"PDMHCCritSectScheduleExitEvent", (PFNRT)PDMHCCritSectScheduleExitEvent},
    223     {"PDMNsAllocateBandwidth",         (PFNRT)PDMNsAllocateBandwidth},
    224     {"PDMQueueAlloc",                  (PFNRT)PDMQueueAlloc},
    225     {"PDMQueueInsert",                 (PFNRT)PDMQueueInsert},
    226     {"PGMHandlerPhysicalPageTempOff",  (PFNRT)PGMHandlerPhysicalPageTempOff},
    227     {"PGMShwMakePageWritable",         (PFNRT)PGMShwMakePageWritable},
    228225    {"RTAssertMsg1Weak",               (PFNRT)RTAssertMsg1Weak},
    229226    {"RTAssertMsg2Weak",               (PFNRT)RTAssertMsg2Weak},
    … …  
    238235    {"RTTimeNanoTS",                   (PFNRT)RTTimeNanoTS},
    239236    {"RTTraceBufAddMsgF",              (PFNRT)RTTraceBufAddMsgF},
    240     {"SUPSemEventSignal",              (PFNRT)SUPSemEventSignal},
    241     {"TMTimerGet",                     (PFNRT)TMTimerGet},
    242     {"TMTimerGetFreq",                 (PFNRT)TMTimerGetFreq},
    243     {"TMTimerIsActive",                (PFNRT)TMTimerIsActive},
    244     {"TMTimerIsLockOwner",             (PFNRT)TMTimerIsLockOwner},
    245     {"TMTimerLock",                    (PFNRT)TMTimerLock},
    246     {"TMTimerSet",                     (PFNRT)TMTimerSet},
    247     {"TMTimerSetFrequencyHint",        (PFNRT)TMTimerSetFrequencyHint},
    248     {"TMTimerSetMicro",                (PFNRT)TMTimerSetMicro},
    249     {"TMTimerSetMillies",              (PFNRT)TMTimerSetMillies},
    250     {"TMTimerSetNano",                 (PFNRT)TMTimerSetNano},
    251     {"TMTimerStop",                    (PFNRT)TMTimerStop},
    252     {"TMTimerUnlock",                  (PFNRT)TMTimerUnlock},
     237    {"RTMemAllocZTag",                 (PFNRT)RTMemAllocZTag},
     238    {"RTMemFree",                      (PFNRT)RTMemFree},
     239    {"RTStrPrintf",                    (PFNRT)RTStrPrintf},
    253240    {"nocrt_memcmp",                   (PFNRT)memcmp},
    254241    {"nocrt_memcpy",                   (PFNRT)memcpy},
    … …  
    256243    {"nocrt_memset",                   (PFNRT)memset},
    257244    {"nocrt_strlen",                   (PFNRT)strlen},
    258 #else
    259     { NULL, NULL }
    260 #endif
    261245};
    262246
    … …  
    573557    PTSTDEVPDMMOD pMod = (PTSTDEVPDMMOD)pvUser;
    574558
     559    RTPrintf("Looking for %s\n", pszSymbol);
     560
    575561    /* Resolve the import. */
    576562    PCTSTDEVPDMR0IMPORTS pImpDesc = NULL;
    … …  
    631617
    632618    return rc;
     619}
     620
     621
     622static int tstDevPdmR0RegisterModule(void *hMod, PPDMDEVMODREGR0 pModReg)
     623{
     624    /*AssertFailed();*/ RT_NOREF(hMod, pModReg);
     625    return VINF_SUCCESS;
    633626}
    634627
    … …  
    678671                rc = RTLdrGetBits(pMod->hLdrMod, pMod->R0Rc.pvBits, (uintptr_t)pMod->R0Rc.pvBits,
    679672                                  tstDevPdmLoadR0RcModGetImport, pMod);
    680                 if (RT_FAILURE(rc))
     673                if (RT_SUCCESS(rc))
     674                {
     675                    /* Resolve module init entry and call it. */
     676                    PFNR0MODULEINIT pfnR0ModuleInit;
     677                    rc = RTLdrGetSymbolEx(pMod->hLdrMod, pMod->R0Rc.pvBits, (uintptr_t)pMod->R0Rc.pvBits,
     678                                          UINT32_MAX, "ModuleInit", (PRTLDRADDR)&pfnR0ModuleInit);
     679                    if (RT_SUCCESS(rc))
     680                        rc = pfnR0ModuleInit(pMod);
     681                }
     682                else
    681683                    RTMemFreeEx(pMod->R0Rc.pbTrampoline, pMod->R0Rc.cbBits);
    682684            }
    … …  
    865867        }
    866868
     869        RTCritSectInit(&pCritSect->s.CritSect);
    867870        rc = pPdmDev->pReg->pfnConstruct(pDevIns, 0, pDevIns->pCfg);
    868871        if (RT_SUCCESS(rc))
    … …  
    959962        /* Register builtin tests. */
    960963        tstDevRegisterTestcase(NULL, &g_TestcaseSsmFuzz);
     964        tstDevRegisterTestcase(NULL, &g_TestcaseIoFuzz);
    961965
    962966        PCTSTDEVCFG pDevTstCfg = NULL;

  • trunk/src/VBox/Devices/testcase/tstDeviceBuiltin.h

    r83261 r91998  
    3030
    3131extern const TSTDEVTESTCASEREG g_TestcaseSsmFuzz;
     32extern const TSTDEVTESTCASEREG g_TestcaseIoFuzz;
    3233
    3334RT_C_DECLS_END

  • trunk/src/VBox/Devices/testcase/tstDevicePdmDevHlp.cpp

    r90199 r91998  
    2727#include <iprt/assert.h>
    2828#include <iprt/mem.h>
     29#include <iprt/rand.h>
    2930
    3031#include "tstDeviceInternal.h"
    … …  
    178179    LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: hIoPorts=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hIoPorts));
    179180
    180     int rc = VERR_NOT_IMPLEMENTED;
    181     AssertFailed();
     181    PRTDEVDUTIOPORT pIoPort = (PRTDEVDUTIOPORT)hIoPorts;
     182    pIoPort->PortStart = 0;
     183    int rc = VINF_SUCCESS;
    182184
    183185    LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    192194    LogFlow(("pdmR3DevHlp_IoPortGetMappingAddress: caller='%s'/%d: hIoPorts=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hIoPorts));
    193195
    194     uint32_t uAddress = 0;
    195     AssertFailed();
     196    PRTDEVDUTIOPORT pIoPort = (PRTDEVDUTIOPORT)hIoPorts;
     197    uint32_t uAddress = pIoPort->PortStart;
    196198
    197199    LogFlow(("pdmR3DevHlp_IoPortGetMappingAddress: caller='%s'/%d: returns %#RX32\n", pDevIns->pReg->szName, pDevIns->iInstance, uAddress));
    198200    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;
    199217}
    200218
    … …  
    214232    AssertFailed();
    215233#else
     234    *phRegion = 1;
    216235    int rc = VINF_SUCCESS;
    217236#endif
    … …  
    308327#else
    309328    int rc = VINF_SUCCESS;
     329    *phRegion   = 0;
    310330    *ppvMapping = RTMemAllocZ(cbRegion);
    311331    if (!*ppvMapping)
    … …  
    387407    return GCPhys;
    388408}
     409
    389410
    390411/**
    … …  
    400421
    401422    LogFlow(("pdmR3DevHlp_Mmio2ChangeRegionNo: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
     423    return rc;
     424}
     425
     426
     427/** @interface_method_impl{PDMDEVHLPR3,pfnMmioMapMmio2Page} */
     428static DECLCALLBACK(int) pdmR3DevHlp_MmioMapMmio2Page(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS offRegion,
     429                                                      uint64_t hMmio2, RTGCPHYS offMmio2, uint64_t fPageFlags)
     430{
     431    PDMDEV_ASSERT_DEVINS(pDevIns);
     432    LogFlow(("pdmR3DevHlp_MmioMapMmio2Page: caller='%s'/%d: hRegion=%RX64 offRegion=%RGp hMmio2=%RX64 offMmio2=%RGp fPageFlags=%RX64\n",
     433             pDevIns->pReg->szName, pDevIns->iInstance, hRegion, offRegion, hMmio2, offMmio2, fPageFlags));
     434
     435    int rc = VERR_NOT_IMPLEMENTED;
     436    AssertFailed();
     437
     438    Log(("pdmR3DevHlp_MmioMapMmio2Page: caller='%s'/%d: returns %Rrc\n",
     439         pDevIns->pReg->szName, pDevIns->iInstance, rc));
     440    return rc;
     441}
     442
     443
     444/** @interface_method_impl{PDMDEVHLPR3,pfnMmioResetRegion} */
     445static DECLCALLBACK(int) pdmR3DevHlp_MmioResetRegion(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion)
     446{
     447    PDMDEV_ASSERT_DEVINS(pDevIns);
     448    LogFlow(("pdmR3DevHlp_MmioResetRegion: caller='%s'/%d: hRegion=%RX64\n",
     449             pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
     450
     451    int rc = VERR_NOT_IMPLEMENTED;
     452    AssertFailed();
     453
     454    Log(("pdmR3DevHlp_MmioResetRegion: caller='%s'/%d: returns %Rrc\n",
     455         pDevIns->pReg->szName, pDevIns->iInstance, rc));
    402456    return rc;
    403457}
    … …  
    15491603
    15501604
    1551 /** @interface_method_impl{PDMDEVHLPR3,pfnTMTimerCreate} */
    1552 static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
    1553 {
    1554     PDMDEV_ASSERT_DEVINS(pDevIns);
    1555     LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} ppTimer=%p\n",
    1556              pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
    1557 
    1558     int rc = VERR_NOT_IMPLEMENTED;
    1559     AssertFailed();
    1560 
    1561     LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    1562     return rc;
    1563 }
    1564 
    1565 
    1566 
    15671605/** @interface_method_impl{PDMDEVHLPR3,pfnTimerCreate} */
    15681606static DECLCALLBACK(int) pdmR3DevHlp_TimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback,
    … …  
    15921630
    15931631
    1594 /** @interface_method_impl{PDMDEVHLPR3,pfnTimerToPtr} */
    1595 static DECLCALLBACK(PTMTIMERR3) pdmR3DevHlp_TimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    1596 {
    1597     PDMDEV_ASSERT_DEVINS(pDevIns);
    1598     RT_NOREF(pDevIns);
    1599     return (PTMTIMERR3)hTimer;
    1600 }
    1601 
    1602 
    16031632/** @interface_method_impl{PDMDEVHLPR3,pfnTimerFromMicro} */
    16041633static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
    … …  
    16311660{
    16321661    RT_NOREF(pDevIns, hTimer);
     1662#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    16331663    AssertFailed();
    16341664    return 0;
     1665#else
     1666    static uint64_t cCnt = 0;
     1667    return cCnt++;
     1668#endif
    16351669}
    16361670
    … …  
    16711705{
    16721706    RT_NOREF(pDevIns, hTimer);
     1707#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    16731708    AssertFailed();
    16741709    return false;
     1710#else
     1711    return true;
     1712#endif
    16751713}
    16761714
    … …  
    24302468static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryStringAlloc(PCFGMNODE pNode, const char *pszName, char **ppszString)
    24312469{
    2432     RT_NOREF(pNode, pszName, ppszString);
    2433 #ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    2434     AssertFailed();
    2435     return VERR_NOT_IMPLEMENTED;
    2436 #else
    2437     return VERR_CFGM_VALUE_NOT_FOUND;
    2438 #endif
     2470    if (!pNode)
     2471        return VERR_CFGM_NO_PARENT;
     2472
     2473    PCTSTDEVCFGITEM pCfgItem;
     2474    int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTest->paCfgItems, pNode->pDut->pTest->cCfgItems, pszName, &pCfgItem);
     2475    if (RT_SUCCESS(rc))
     2476    {
     2477        switch (pCfgItem->enmType)
     2478        {
     2479            case TSTDEVCFGITEMTYPE_STRING:
     2480            {
     2481                *ppszString = (char *)RTMemDup(pCfgItem->u.psz, strlen(pCfgItem->u.psz) + 1);
     2482                if (RT_LIKELY(*ppszString))
     2483                    rc = VINF_SUCCESS;
     2484                else
     2485                    rc = VERR_NO_STR_MEMORY;
     2486                break;
     2487            }
     2488            case TSTDEVCFGITEMTYPE_INTEGER:
     2489            case TSTDEVCFGITEMTYPE_BYTES:
     2490            default:
     2491                rc = VERR_CFGM_IPE_1;
     2492                AssertMsgFailed(("Invalid value type %d\n", pCfgItem->enmType));
     2493                break;
     2494        }
     2495    }
     2496    else
     2497        rc = VERR_CFGM_VALUE_NOT_FOUND;
     2498
     2499    return rc;
    24392500}
    24402501
    … …  
    24422503static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryStringAllocDef(PCFGMNODE pNode, const char *pszName, char **ppszString, const char *pszDef)
    24432504{
    2444     RT_NOREF(pNode, pszName, ppszString, pszDef);
    2445 #ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    2446     AssertFailed();
    2447     return VERR_NOT_IMPLEMENTED;
    2448 #else
    2449     return VERR_CFGM_VALUE_NOT_FOUND;
    2450 #endif
     2505    if (!pNode)
     2506        return VERR_CFGM_NO_PARENT;
     2507
     2508    PCTSTDEVCFGITEM pCfgItem;
     2509    int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTest->paCfgItems, pNode->pDut->pTest->cCfgItems, pszName, &pCfgItem);
     2510    if (RT_SUCCESS(rc))
     2511    {
     2512        switch (pCfgItem->enmType)
     2513        {
     2514            case TSTDEVCFGITEMTYPE_STRING:
     2515            {
     2516                *ppszString = (char *)RTMemDup(pCfgItem->u.psz, strlen(pCfgItem->u.psz) + 1);
     2517                if (RT_LIKELY(*ppszString))
     2518                    rc = VINF_SUCCESS;
     2519                else
     2520                    rc = VERR_NO_STR_MEMORY;
     2521                break;
     2522            }
     2523            case TSTDEVCFGITEMTYPE_INTEGER:
     2524            case TSTDEVCFGITEMTYPE_BYTES:
     2525            default:
     2526                rc = VERR_CFGM_IPE_1;
     2527                AssertMsgFailed(("Invalid value type %d\n", pCfgItem->enmType));
     2528                break;
     2529        }
     2530    }
     2531    else
     2532    {
     2533        if (pszDef)
     2534        {
     2535            *ppszString = (char *)RTMemDup(pszDef, strlen(pszDef) + 1);
     2536            if (RT_LIKELY(*ppszString))
     2537                rc = VINF_SUCCESS;
     2538            else
     2539                rc = VERR_NO_STR_MEMORY;
     2540        }
     2541        else
     2542        {
     2543            *ppszString = NULL;
     2544            rc = VINF_SUCCESS;
     2545        }
     2546    }
     2547
     2548    return rc;
    24512549}
    24522550
    … …  
    26492747             pDevIns->pReg->szName, pDevIns->iInstance));
    26502748
    2651     uint64_t u64Nano = 0;
    2652     AssertFailed();
     2749    uint64_t u64Nano = RTTimeNanoTS();
    26532750
    26542751    LogFlow(("pdmR3DevHlp_TMTimeVirtGetNano: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Nano));
    26552752    return u64Nano;
     2753}
     2754
     2755
     2756/** @interface_method_impl{PDMDEVHLPR3,pfnTMCpuTicksPerSecond} */
     2757static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMCpuTicksPerSecond(PPDMDEVINS pDevIns)
     2758{
     2759    PDMDEV_ASSERT_DEVINS(pDevIns);
     2760    LogFlow(("pdmR3DevHlp_TMCpuTicksPerSecond: caller='%s'/%d\n",
     2761             pDevIns->pReg->szName, pDevIns->iInstance));
     2762
     2763    AssertFailed();
     2764    uint64_t u64CpuTicksPerSec = 0;
     2765
     2766    LogFlow(("pdmR3DevHlp_TMCpuTicksPerSecond: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64CpuTicksPerSec));
     2767    return u64CpuTicksPerSec;
    26562768}
    26572769
    … …  
    27212833
    27222834/** @interface_method_impl{PDMDEVHLPR3,pfnPhysRead} */
    2723 static DECLCALLBACK(int) pdmR3DevHlp_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
    2724 {
    2725     PDMDEV_ASSERT_DEVINS(pDevIns);
    2726     LogFlow(("pdmR3DevHlp_PhysRead: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbRead=%#x\n",
    2727              pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
    2728 
    2729     VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;;
    2730     AssertFailed();
     2835static DECLCALLBACK(int) pdmR3DevHlp_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, uint32_t fFlags)
     2836{
     2837    PDMDEV_ASSERT_DEVINS(pDevIns);
     2838    LogFlow(("pdmR3DevHlp_PhysRead: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbRead=%#x fFlags=%#x\n",
     2839             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbRead, fFlags));
     2840
     2841#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     2842    VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
     2843    AssertFailed();
     2844#else
     2845    RTRandBytes(pvBuf, cbRead);
     2846    VBOXSTRICTRC rcStrict = VINF_SUCCESS;
     2847#endif
    27312848
    27322849    Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
    … …  
    27362853
    27372854/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWrite} */
    2738 static DECLCALLBACK(int) pdmR3DevHlp_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
    2739 {
    2740     PDMDEV_ASSERT_DEVINS(pDevIns);
    2741     LogFlow(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbWrite=%#x\n",
    2742              pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
     2855static DECLCALLBACK(int) pdmR3DevHlp_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, uint32_t fFlags)
     2856{
     2857    PDMDEV_ASSERT_DEVINS(pDevIns);
     2858    LogFlow(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbWrite=%#xfFlags=%#x\n",
     2859             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite, fFlags));
    27432860
    27442861    VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;;
    … …  
    28452962
    28462963
     2964/** @interface_method_impl{PDMDEVHLPR3,pfnPhysIsGCPhysNormal} */
     2965static DECLCALLBACK(bool) pdmR3DevHlp_PhysIsGCPhysNormal(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
     2966{
     2967    PDMDEV_ASSERT_DEVINS(pDevIns);
     2968    LogFlow(("pdmR3DevHlp_PhysIsGCPhysNormal: caller='%s'/%d: GCPhys=%RGp\n",
     2969             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys));
     2970
     2971    bool fNormal = true;
     2972    AssertFailed();
     2973
     2974    Log(("pdmR3DevHlp_PhysIsGCPhysNormal: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szName, pDevIns->iInstance, fNormal));
     2975    return fNormal;
     2976}
     2977
     2978
     2979/** @interface_method_impl{PDMDEVHLPR3,pfnPhysChangeMemBalloon} */
     2980static DECLCALLBACK(int) pdmR3DevHlp_PhysChangeMemBalloon(PPDMDEVINS pDevIns, bool fInflate, unsigned cPages, RTGCPHYS *paPhysPage)
     2981{
     2982    PDMDEV_ASSERT_DEVINS(pDevIns);
     2983    LogFlow(("pdmR3DevHlp_PhysChangeMemBalloon: caller='%s'/%d: fInflate=%RTbool cPages=%u paPhysPage=%p\n",
     2984             pDevIns->pReg->szName, pDevIns->iInstance, fInflate, cPages, paPhysPage));
     2985
     2986    int rc = VERR_NOT_IMPLEMENTED;;
     2987    AssertFailed();
     2988
     2989    Log(("pdmR3DevHlp_PhysChangeMemBalloon: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
     2990    return rc;
     2991}
     2992
     2993
    28472994/** @interface_method_impl{PDMDEVHLPR3,pfnCpuGetGuestMicroarch} */
    28482995static DECLCALLBACK(CPUMMICROARCH) pdmR3DevHlp_CpuGetGuestMicroarch(PPDMDEVINS pDevIns)
    … …  
    28593006
    28603007
     3008/** @interface_method_impl{PDMDEVHLPR3,pfnCpuGetGuestAddrWidths} */
     3009static DECLCALLBACK(void) pdmR3DevHlp_CpuGetGuestAddrWidths(PPDMDEVINS pDevIns, uint8_t *pcPhysAddrWidth,
     3010                                                            uint8_t *pcLinearAddrWidth)
     3011{
     3012    PDMDEV_ASSERT_DEVINS(pDevIns);
     3013    LogFlow(("pdmR3DevHlp_CpuGetGuestAddrWidths: caller='%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
     3014    AssertPtrReturnVoid(pcPhysAddrWidth);
     3015    AssertPtrReturnVoid(pcLinearAddrWidth);
     3016
     3017    AssertFailed();
     3018
     3019    Log(("pdmR3DevHlp_CpuGetGuestAddrWidths: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
     3020}
     3021
     3022
     3023/** @interface_method_impl{PDMDEVHLPR3,pfnCpuGetGuestScalableBusFrequency} */
     3024static DECLCALLBACK(uint64_t) pdmR3DevHlp_CpuGetGuestScalableBusFrequency(PPDMDEVINS pDevIns)
     3025{
     3026    PDMDEV_ASSERT_DEVINS(pDevIns);
     3027    LogFlow(("pdmR3DevHlp_CpuGetGuestScalableBusFrequency: caller='%s'/%d\n",
     3028             pDevIns->pReg->szName, pDevIns->iInstance));
     3029
     3030    AssertFailed();
     3031    uint64_t u64Fsb = 0;
     3032
     3033    Log(("pdmR3DevHlp_CpuGetGuestScalableBusFrequency: caller='%s'/%d: returns %#RX64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Fsb));
     3034    return u64Fsb;
     3035}
     3036
     3037
    28613038/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReadGCVirt} */
    28623039static DECLCALLBACK(int) pdmR3DevHlp_PhysReadGCVirt(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb)
    … …  
    29403117    LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
    29413118    return pv;
     3119}
     3120
     3121
     3122/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAPrintfV} */
     3123static DECLCALLBACK(char *) pdmR3DevHlp_MMHeapAPrintfV(PPDMDEVINS pDevIns, MMTAG enmTag, const char *pszFormat, va_list va)
     3124{
     3125    PDMDEV_ASSERT_DEVINS(pDevIns);
     3126    LogFlow(("pdmR3DevHlp_MMHeapAPrintfV: caller='%s'/%d: enmTag=%u pszFormat=%p:{%s}\n",
     3127             pDevIns->pReg->szName, pDevIns->iInstance, enmTag, pszFormat, pszFormat));
     3128
     3129    RT_NOREF(va);
     3130    AssertFailed();
     3131    char *psz = NULL;
     3132
     3133    LogFlow(("pdmR3DevHlp_MMHeapAPrintfV: caller='%s'/%d: returns %p:{%s}\n",
     3134             pDevIns->pReg->szName, pDevIns->iInstance, psz, psz));
     3135    return psz;
    29423136}
    29433137
    … …  
    29683162
    29693163
     3164/** @interface_method_impl{PDMDEVHLPR3,pfnMMPhysGetRamSize} */
     3165static DECLCALLBACK(uint64_t) pdmR3DevHlp_MMPhysGetRamSize(PPDMDEVINS pDevIns)
     3166{
     3167    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
     3168    LogFlow(("pdmR3DevHlp_MMPhysGetRamSize: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
     3169
     3170#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3171    AssertFailed();
     3172    uint64_t cb = 0;
     3173#else
     3174    uint64_t cb = _4G;
     3175#endif
     3176
     3177    LogFlow(("pdmR3DevHlp_MMPhysGetRamSize: caller='%s'/%d: returns %RU64\n",
     3178             pDevIns->pReg->szName, pDevIns->iInstance, cb));
     3179    return cb;
     3180}
     3181
     3182
     3183/** @interface_method_impl{PDMDEVHLPR3,pfnMMPhysGetRamSizeBelow4GB} */
     3184static DECLCALLBACK(uint32_t) pdmR3DevHlp_MMPhysGetRamSizeBelow4GB(PPDMDEVINS pDevIns)
     3185{
     3186    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
     3187    LogFlow(("pdmR3DevHlp_MMPhysGetRamSizeBelow4GB: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
     3188
     3189    AssertFailed();
     3190    uint32_t cb = 0;
     3191
     3192    LogFlow(("pdmR3DevHlp_MMPhysGetRamSizeBelow4GB: caller='%s'/%d: returns %RU32\n",
     3193             pDevIns->pReg->szName, pDevIns->iInstance, cb));
     3194    return cb;
     3195}
     3196
     3197
     3198/** @interface_method_impl{PDMDEVHLPR3,pfnMMPhysGetRamSizeAbove4GB} */
     3199static DECLCALLBACK(uint64_t) pdmR3DevHlp_MMPhysGetRamSizeAbove4GB(PPDMDEVINS pDevIns)
     3200{
     3201    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
     3202    LogFlow(("pdmR3DevHlp_MMPhysGetRamSizeAbove4GB: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
     3203
     3204    AssertFailed();
     3205    uint64_t cb = 0;
     3206
     3207    LogFlow(("pdmR3DevHlp_MMPhysGetRamSizeAbove4GB: caller='%s'/%d: returns %RU64\n",
     3208             pDevIns->pReg->szName, pDevIns->iInstance, cb));
     3209    return cb;
     3210}
     3211
     3212
    29703213/** @interface_method_impl{PDMDEVHLPR3,pfnVMState} */
    29713214static DECLCALLBACK(VMSTATE) pdmR3DevHlp_VMState(PPDMDEVINS pDevIns)
    … …  
    29993242
    30003243
    3001 /** @interface_method_impl{PDMDEVHLPR3,pfnVMSetError} */
    3002 static DECLCALLBACK(int) pdmR3DevHlp_VMSetError(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
    3003 {
    3004     PDMDEV_ASSERT_DEVINS(pDevIns);
    3005 
    3006     RT_NOREF(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat);
    3007     AssertFailed();
    3008 
    3009     return VERR_NOT_IMPLEMENTED;
    3010 }
    3011 
    3012 
    30133244/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetErrorV} */
    30143245static DECLCALLBACK(int) pdmR3DevHlp_VMSetErrorV(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
    … …  
    30233254
    30243255
    3025 /** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeError} */
    3026 static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeError(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, ...)
    3027 {
    3028     PDMDEV_ASSERT_DEVINS(pDevIns);
    3029 
    3030     RT_NOREF(pDevIns, fFlags, pszErrorId, pszFormat);
    3031     int rc = VERR_NOT_IMPLEMENTED;
    3032     AssertFailed();
    3033 
    3034     return rc;
    3035 }
    3036 
    3037 
    30383256/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeErrorV} */
    30393257static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeErrorV(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list va)
    … …  
    30453263    AssertFailed();
    30463264
     3265    return rc;
     3266}
     3267
     3268
     3269/** @interface_method_impl{PDMDEVHLPR3,pfnVMWaitForDeviceReady} */
     3270static DECLCALLBACK(int) pdmR3DevHlp_VMWaitForDeviceReady(PPDMDEVINS pDevIns, VMCPUID idCpu)
     3271{
     3272    PDMDEV_ASSERT_DEVINS(pDevIns);
     3273    LogFlow(("pdmR3DevHlp_VMWaitForDeviceReady: caller='%s'/%d: idCpu=%u\n", pDevIns->pReg->szName, pDevIns->iInstance, idCpu));
     3274
     3275    int rc = VERR_NOT_IMPLEMENTED;
     3276    AssertFailed();
     3277
     3278    LogFlow(("pdmR3DevHlp_VMWaitForDeviceReady: caller='%s'/%d: returns %Rrc\n",
     3279             pDevIns->pReg->szName, pDevIns->iInstance, rc));
     3280    return rc;
     3281}
     3282
     3283
     3284/** @interface_method_impl{PDMDEVHLPR3,pfnVMNotifyCpuDeviceReady} */
     3285static DECLCALLBACK(int) pdmR3DevHlp_VMNotifyCpuDeviceReady(PPDMDEVINS pDevIns, VMCPUID idCpu)
     3286{
     3287    PDMDEV_ASSERT_DEVINS(pDevIns);
     3288    LogFlow(("pdmR3DevHlp_VMNotifyCpuDeviceReady: caller='%s'/%d: idCpu=%u\n", pDevIns->pReg->szName, pDevIns->iInstance, idCpu));
     3289
     3290    int rc = VERR_NOT_IMPLEMENTED;
     3291    AssertFailed();
     3292
     3293    LogFlow(("pdmR3DevHlp_VMNotifyCpuDeviceReady: caller='%s'/%d: returns %Rrc\n",
     3294             pDevIns->pReg->szName, pDevIns->iInstance, rc));
     3295    return rc;
     3296}
     3297
     3298
     3299/** @interface_method_impl{PDMDEVHLPR3,pfnVMReqCallNoWaitV} */
     3300static DECLCALLBACK(int) pdmR3DevHlp_VMReqCallNoWaitV(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, va_list Args)
     3301{
     3302    PDMDEV_ASSERT_DEVINS(pDevIns);
     3303    LogFlow(("pdmR3DevHlp_VMReqCallNoWaitV: caller='%s'/%d: idDstCpu=%u pfnFunction=%p cArgs=%u\n",
     3304             pDevIns->pReg->szName, pDevIns->iInstance, idDstCpu, pfnFunction, cArgs));
     3305
     3306    int rc = VERR_NOT_IMPLEMENTED;
     3307    AssertFailed(); RT_NOREF(Args);
     3308
     3309    LogFlow(("pdmR3DevHlp_VMReqCallNoWaitV: caller='%s'/%d: returns %Rrc\n",
     3310             pDevIns->pReg->szName, pDevIns->iInstance, rc));
     3311    return rc;
     3312}
     3313
     3314
     3315/** @interface_method_impl{PDMDEVHLPR3,pfnVMReqPriorityCallWaitV} */
     3316static DECLCALLBACK(int) pdmR3DevHlp_VMReqPriorityCallWaitV(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, va_list Args)
     3317{
     3318    PDMDEV_ASSERT_DEVINS(pDevIns);
     3319    LogFlow(("pdmR3DevHlp_VMReqCallNoWaitV: caller='%s'/%d: idDstCpu=%u pfnFunction=%p cArgs=%u\n",
     3320             pDevIns->pReg->szName, pDevIns->iInstance, idDstCpu, pfnFunction, cArgs));
     3321
     3322    int rc = VERR_NOT_IMPLEMENTED;
     3323    AssertFailed(); RT_NOREF(Args);
     3324
     3325    LogFlow(("pdmR3DevHlp_VMReqCallNoWaitV: caller='%s'/%d: returns %Rrc\n",
     3326             pDevIns->pReg->szName, pDevIns->iInstance, rc));
    30473327    return rc;
    30483328}
    … …  
    31313411    LogFlow(("pdmR3DevHlp_DBGFTraceBuf: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, hTraceBuf));
    31323412    return hTraceBuf;
     3413}
     3414
     3415
     3416/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFReportBugCheck} */
     3417static DECLCALLBACK(VBOXSTRICTRC) pdmR3DevHlp_DBGFReportBugCheck(PPDMDEVINS pDevIns, DBGFEVENTTYPE enmEvent, uint64_t uBugCheck,
     3418                                                                 uint64_t uP1, uint64_t uP2, uint64_t uP3, uint64_t uP4)
     3419{
     3420    PDMDEV_ASSERT_DEVINS(pDevIns);
     3421    LogFlow(("pdmR3DevHlp_DBGFReportBugCheck: caller='%s'/%d: enmEvent=%u uBugCheck=%#x uP1=%#x uP2=%#x uP3=%#x uP4=%#x\n",
     3422             pDevIns->pReg->szName, pDevIns->iInstance, enmEvent, uBugCheck, uP1, uP2, uP3, uP4));
     3423
     3424    AssertFailed();
     3425    VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
     3426
     3427    LogFlow(("pdmR3DevHlp_DBGFReportBugCheck: caller='%s'/%d: returns %Rrc\n",
     3428             pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict)));
     3429    return rcStrict;
     3430}
     3431
     3432
     3433/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFCoreWrite} */
     3434static DECLCALLBACK(int) pdmR3DevHlp_DBGFCoreWrite(PPDMDEVINS pDevIns, const char *pszFilename, bool fReplaceFile)
     3435{
     3436    PDMDEV_ASSERT_DEVINS(pDevIns);
     3437    LogFlow(("pdmR3DevHlp_DBGFCoreWrite: caller='%s'/%d: pszFilename=%p:{%s} fReplaceFile=%RTbool\n",
     3438             pDevIns->pReg->szName, pDevIns->iInstance, pszFilename, pszFilename, fReplaceFile));
     3439
     3440    AssertFailed();
     3441    int rc = VERR_NOT_IMPLEMENTED;
     3442
     3443    LogFlow(("pdmR3DevHlp_DBGFCoreWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
     3444    return rc;
     3445}
     3446
     3447
     3448/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFInfoLogHlp} */
     3449static DECLCALLBACK(PCDBGFINFOHLP) pdmR3DevHlp_DBGFInfoLogHlp(PPDMDEVINS pDevIns)
     3450{
     3451    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF(pDevIns);
     3452    LogFlow(("pdmR3DevHlp_DBGFInfoLogHlp: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
     3453
     3454    AssertFailed();
     3455    PCDBGFINFOHLP pHlp = NULL;
     3456
     3457    LogFlow(("pdmR3DevHlp_DBGFInfoLogHlp: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pHlp));
     3458    return pHlp;
     3459}
     3460
     3461
     3462/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFRegNmQueryU64} */
     3463static DECLCALLBACK(int) pdmR3DevHlp_DBGFRegNmQueryU64(PPDMDEVINS pDevIns, VMCPUID idDefCpu, const char *pszReg, uint64_t *pu64)
     3464{
     3465    PDMDEV_ASSERT_DEVINS(pDevIns);
     3466    LogFlow(("pdmR3DevHlp_DBGFRegNmQueryU64: caller='%s'/%d: idDefCpu=%u pszReg=%p:{%s} pu64=%p\n",
     3467             pDevIns->pReg->szName, pDevIns->iInstance, idDefCpu, pszReg, pszReg, pu64));
     3468
     3469    AssertFailed();
     3470    int rc = VERR_NOT_IMPLEMENTED;
     3471
     3472    LogFlow(("pdmR3DevHlp_DBGFRegNmQueryU64: caller='%s'/%d: returns %Rrc *pu64=%#RX64\n",
     3473             pDevIns->pReg->szName, pDevIns->iInstance, rc, *pu64));
     3474    return rc;
     3475}
     3476
     3477
     3478/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFRegPrintfV} */
     3479static DECLCALLBACK(int) pdmR3DevHlp_DBGFRegPrintfV(PPDMDEVINS pDevIns, VMCPUID idCpu, char *pszBuf, size_t cbBuf,
     3480                                                    const char *pszFormat, va_list va)
     3481{
     3482    PDMDEV_ASSERT_DEVINS(pDevIns);
     3483    LogFlow(("pdmR3DevHlp_DBGFRegPrintfV: caller='%s'/%d: idCpu=%u pszBuf=%p cbBuf=%u pszFormat=%p:{%s}\n",
     3484             pDevIns->pReg->szName, pDevIns->iInstance, idCpu, pszBuf, cbBuf, pszFormat, pszFormat));
     3485
     3486    AssertFailed();
     3487    RT_NOREF(va);
     3488    int rc = VERR_NOT_IMPLEMENTED;
     3489
     3490    LogFlow(("pdmR3DevHlp_DBGFRegPrintfV: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
     3491    return rc;
    31333492}
    31343493
    … …  
    33993758/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysRead} */
    34003759static DECLCALLBACK(int)
    3401 pdmR3DevHlp_PCIPhysRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
     3760pdmR3DevHlp_PCIPhysRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, uint32_t fFlags)
    34023761{
    34033762    PDMDEV_ASSERT_DEVINS(pDevIns);
    … …  
    34053764        pPciDev = pDevIns->apPciDevs[0];
    34063765    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
    3407     PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
     3766    //PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
    34083767
    34093768#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
    … …  
    34223781#endif
    34233782
    3424     int rc = VERR_NOT_IMPLEMENTED;
    3425     AssertFailed();
     3783    RT_NOREF(fFlags);
     3784#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3785    int rc = VERR_NOT_IMPLEMENTED;
     3786    AssertFailed();
     3787#else
     3788    RTRandBytes(pvBuf, cbRead);
     3789    int rc = VINF_SUCCESS;
     3790#endif
     3791
    34263792    return rc;
    34273793}
    … …  
    34303796/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysWrite} */
    34313797static DECLCALLBACK(int)
    3432 pdmR3DevHlp_PCIPhysWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
     3798pdmR3DevHlp_PCIPhysWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, uint32_t fFlags)
    34333799{
    34343800    PDMDEV_ASSERT_DEVINS(pDevIns);
    … …  
    34363802        pPciDev = pDevIns->apPciDevs[0];
    34373803    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
    3438     PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
     3804    //PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
    34393805
    34403806#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
    … …  
    34523818#endif
    34533819
    3454     RT_NOREF(GCPhys, pvBuf, cbWrite);
    3455     int rc = VERR_NOT_IMPLEMENTED;
    3456     AssertFailed();
    3457     return rc;
     3820    RT_NOREF(GCPhys, pvBuf, cbWrite, fFlags);
     3821#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3822    int rc = VERR_NOT_IMPLEMENTED;
     3823    AssertFailed();
     3824#else
     3825    int rc = VINF_SUCCESS;
     3826#endif
     3827    return rc;
     3828}
     3829
     3830
     3831/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysGCPhys2CCPtr} */
     3832static DECLCALLBACK(int) pdmR3DevHlp_PCIPhysGCPhys2CCPtr(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys,
     3833                                                         uint32_t fFlags, void **ppv, PPGMPAGEMAPLOCK pLock)
     3834{
     3835    PDMDEV_ASSERT_DEVINS(pDevIns);
     3836    if (!pPciDev) /* NULL is an alias for the default PCI device. */
     3837        pPciDev = pDevIns->apPciDevs[0];
     3838    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
     3839    PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
     3840
     3841#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
     3842    if (PCIDevIsBusmaster(pPciDev))
     3843    { /* likely */ }
     3844    else
     3845    {
     3846        LogFunc(("caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp fFlags=%#RX32\n",
     3847                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, fFlags));
     3848        return VERR_PDM_NOT_PCI_BUS_MASTER;
     3849    }
     3850#endif
     3851
     3852    AssertFailed(); RT_NOREF(ppv, pLock);
     3853    return VERR_NOT_IMPLEMENTED;
     3854}
     3855
     3856
     3857/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysGCPhys2CCPtrReadOnly} */
     3858static DECLCALLBACK(int) pdmR3DevHlp_PCIPhysGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys,
     3859                                                                 uint32_t fFlags, void const **ppv, PPGMPAGEMAPLOCK pLock)
     3860{
     3861    PDMDEV_ASSERT_DEVINS(pDevIns);
     3862    if (!pPciDev) /* NULL is an alias for the default PCI device. */
     3863        pPciDev = pDevIns->apPciDevs[0];
     3864    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
     3865    PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
     3866
     3867#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
     3868    if (PCIDevIsBusmaster(pPciDev))
     3869    { /* likely */ }
     3870    else
     3871    {
     3872        LogFunc(("caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp fFlags=%#RX32\n",
     3873                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, fFlags));
     3874        return VERR_PDM_NOT_PCI_BUS_MASTER;
     3875    }
     3876#endif
     3877
     3878    AssertFailed(); RT_NOREF(ppv, pLock);
     3879    return VERR_NOT_IMPLEMENTED;
     3880}
     3881
     3882
     3883/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysBulkGCPhys2CCPtr} */
     3884static DECLCALLBACK(int) pdmR3DevHlp_PCIPhysBulkGCPhys2CCPtr(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t cPages,
     3885                                                             PCRTGCPHYS paGCPhysPages, uint32_t fFlags, void **papvPages,
     3886                                                             PPGMPAGEMAPLOCK paLocks)
     3887{
     3888    PDMDEV_ASSERT_DEVINS(pDevIns);
     3889    if (!pPciDev) /* NULL is an alias for the default PCI device. */
     3890        pPciDev = pDevIns->apPciDevs[0];
     3891    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
     3892    PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
     3893
     3894#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
     3895    if (PCIDevIsBusmaster(pPciDev))
     3896    { /* likely */ }
     3897    else
     3898    {
     3899        LogFunc(("caller='%s'/%d: returns %Rrc - Not bus master! cPages=%zu fFlags=%#RX32\n",
     3900                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, cPages, fFlags));
     3901        return VERR_PDM_NOT_PCI_BUS_MASTER;
     3902    }
     3903#endif
     3904
     3905    AssertFailed(); RT_NOREF(paGCPhysPages, fFlags, papvPages, paLocks);
     3906    return VERR_NOT_IMPLEMENTED;
     3907}
     3908
     3909
     3910/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysBulkGCPhys2CCPtrReadOnly} */
     3911static DECLCALLBACK(int) pdmR3DevHlp_PCIPhysBulkGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t cPages,
     3912                                                                     PCRTGCPHYS paGCPhysPages, uint32_t fFlags,
     3913                                                                     const void **papvPages, PPGMPAGEMAPLOCK paLocks)
     3914{
     3915    PDMDEV_ASSERT_DEVINS(pDevIns);
     3916    if (!pPciDev) /* NULL is an alias for the default PCI device. */
     3917        pPciDev = pDevIns->apPciDevs[0];
     3918    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
     3919    PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
     3920
     3921#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
     3922    if (PCIDevIsBusmaster(pPciDev))
     3923    { /* likely */ }
     3924    else
     3925    {
     3926        LogFunc(("caller='%s'/%d: returns %Rrc - Not bus master! cPages=%zu fFlags=%#RX32\n",
     3927                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, cPages, fFlags));
     3928        return VERR_PDM_NOT_PCI_BUS_MASTER;
     3929    }
     3930#endif
     3931
     3932    AssertFailed(); RT_NOREF(paGCPhysPages, fFlags, papvPages, paLocks);
     3933    return VERR_NOT_IMPLEMENTED;
    34583934}
    34593935
    … …  
    34683944    LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: pPciDev=%p:{%#x} iIrq=%d iLevel=%d\n",
    34693945             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iIrq, iLevel));
    3470     PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
    3471 
     3946    //PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
     3947
     3948#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    34723949    RT_NOREF(iIrq, iLevel);
    34733950    AssertFailed();
     3951#endif
    34743952
    34753953    LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
    … …  
    34963974    Assert((uint32_t)iLevel <= PDM_IRQ_LEVEL_FLIP_FLOP);
    34973975
    3498     AssertFailed();
     3976#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3977    AssertFailed();
     3978#endif
    34993979
    35003980    LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
    … …  
    35814061
    35824062
    3583 /** @interface_method_impl{PDMDEVHLPR3,pfnQueueCreatePtr} */
    3584 static DECLCALLBACK(int) pdmR3DevHlp_QueueCreatePtr(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
    3585                                                     PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char *pszName, PPDMQUEUE *ppQueue)
    3586 {
    3587     PDMDEV_ASSERT_DEVINS(pDevIns);
    3588     LogFlow(("pdmR3DevHlp_QueueCreatePtr: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fRZEnabled=%RTbool pszName=%p:{%s} ppQueue=%p\n",
    3589              pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, pszName, ppQueue));
    3590 
    3591     int rc = VERR_NOT_IMPLEMENTED;
    3592     AssertFailed();
    3593 
    3594     LogFlow(("pdmR3DevHlp_QueueCreatePtr: caller='%s'/%d: returns %Rrc *ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *ppQueue));
    3595     return rc;
    3596 }
    3597 
    3598 
    35994063/** @interface_method_impl{PDMDEVHLPR3,pfnQueueCreate} */
    36004064static DECLCALLBACK(int) pdmR3DevHlp_QueueCreate(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
    … …  
    36144078
    36154079
    3616 /** @interface_method_impl{PDMDEVHLPR3,pfnQueueToPtr} */
    3617 static DECLCALLBACK(PPDMQUEUE)  pdmR3DevHlp_QueueToPtr(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
    3618 {
    3619     PDMDEV_ASSERT_DEVINS(pDevIns);
    3620     RT_NOREF(pDevIns);
    3621     return (PPDMQUEUE)hQueue;
    3622 }
    3623 
    3624 
    36254080/** @interface_method_impl{PDMDEVHLPR3,pfnQueueAlloc} */
    36264081static DECLCALLBACK(PPDMQUEUEITEMCORE) pdmR3DevHlp_QueueAlloc(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
    … …  
    36364091{
    36374092    RT_NOREF(pDevIns, hQueue, pItem);
    3638     AssertFailed();
    3639 }
    3640 
    3641 
    3642 /** @interface_method_impl{PDMDEVHLPR3,pfnQueueInsertEx} */
    3643 static DECLCALLBACK(void) pdmR3DevHlp_QueueInsertEx(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem,
    3644                                                     uint64_t cNanoMaxDelay)
    3645 {
    3646     RT_NOREF(pDevIns, hQueue, pItem, cNanoMaxDelay);
    36474093    AssertFailed();
    36484094}
    … …  
    37044150    LogFlow(("pdmR3DevHlp_SUPSemEventCreate: caller='%s'/%d: phEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, phEvent));
    37054151
    3706     RT_NOREF(pDevIns, phEvent);
    3707 #ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    3708     int rc = VERR_NOT_IMPLEMENTED;
    3709     AssertFailed();
    3710 #else
    3711     int rc = VINF_SUCCESS;
    3712 #endif
     4152    RTSEMEVENT hEvt;
     4153    int rc = RTSemEventCreate(&hEvt);
     4154    if (RT_SUCCESS(rc))
     4155        *phEvent = (SUPSEMEVENT)hEvt;
    37134156
    37144157    LogFlow(("pdmR3DevHlp_SUPSemEventCreate: caller='%s'/%d: returns %Rrc *phEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *phEvent));
    … …  
    37234166    LogFlow(("pdmR3DevHlp_SUPSemEventClose: caller='%s'/%d: hEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEvent));
    37244167
    3725     RT_NOREF(pDevIns, hEvent);
    3726 #ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    3727     int rc = VERR_NOT_IMPLEMENTED;
    3728     AssertFailed();
    3729 #else
    3730     int rc = VINF_SUCCESS;
    3731 #endif
     4168    int rc = RTSemEventDestroy((RTSEMEVENT)hEvent);
    37324169
    37334170    LogFlow(("pdmR3DevHlp_SUPSemEventClose: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    37424179    LogFlow(("pdmR3DevHlp_SUPSemEventSignal: caller='%s'/%d: hEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEvent));
    37434180
    3744     RT_NOREF(pDevIns, hEvent);
    3745 #ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    3746     int rc = VERR_NOT_IMPLEMENTED;
    3747     AssertFailed();
    3748 #else
    3749     int rc = VINF_SUCCESS;
    3750 #endif
     4181    int rc = RTSemEventSignal((RTSEMEVENT)hEvent);
    37514182
    37524183    LogFlow(("pdmR3DevHlp_SUPSemEventSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    37624193             pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cMillies));
    37634194
    3764     RT_NOREF(pDevIns, hEvent, cMillies);
    3765 #ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    3766     int rc = VERR_NOT_IMPLEMENTED;
    3767     AssertFailed();
    3768 #else
    3769     int rc = VINF_SUCCESS;
    3770 #endif
     4195    int rc = RTSemEventWaitNoResume((RTSEMEVENT)hEvent, cMillies);
    37714196
    37724197    LogFlow(("pdmR3DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    37824207             pDevIns->pReg->szName, pDevIns->iInstance, hEvent, uNsTimeout));
    37834208
    3784     RT_NOREF(pDevIns, hEvent, uNsTimeout);
    3785 #ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    3786     int rc = VERR_NOT_IMPLEMENTED;
    3787     AssertFailed();
    3788 #else
    3789     int rc = VINF_SUCCESS;
    3790 #endif
     4209    int rc = RTSemEventWait((RTSEMEVENT)hEvent, uNsTimeout / RT_NS_1MS);
    37914210
    37924211    LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    38024221             pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cNsTimeout));
    38034222
    3804     RT_NOREF(pDevIns, hEvent, cNsTimeout);
    3805 #ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    3806     int rc = VERR_NOT_IMPLEMENTED;
    3807     AssertFailed();
    3808 #else
    3809     int rc = VINF_SUCCESS;
    3810 #endif
     4223    int rc = RTSemEventWait((RTSEMEVENT)hEvent, cNsTimeout / RT_NS_1MS);
    38114224
    38124225    LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    40114424
    40124425
    4013 /** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNopR0} */
    4014 static DECLCALLBACK(R0PTRTYPE(PPDMCRITSECT)) pdmR3DevHlp_CritSectGetNopR0(PPDMDEVINS pDevIns)
    4015 {
    4016     PDMDEV_ASSERT_DEVINS(pDevIns);
    4017 
    4018     R0PTRTYPE(PPDMCRITSECT) pCritSect = 0;
    4019     LogFlow(("pdmR3DevHlp_CritSectGetNopR0: caller='%s'/%d: return %RHv\n",
    4020              pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
    4021     return pCritSect;
    4022 }
    4023 
    4024 
    4025 /** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNopRC} */
    4026 static DECLCALLBACK(RCPTRTYPE(PPDMCRITSECT)) pdmR3DevHlp_CritSectGetNopRC(PPDMDEVINS pDevIns)
    4027 {
    4028     PDMDEV_ASSERT_DEVINS(pDevIns);
    4029 
    4030     RCPTRTYPE(PPDMCRITSECT) pCritSect = 0;
    4031     LogFlow(("pdmR3DevHlp_CritSectGetNopRC: caller='%s'/%d: return %RRv\n",
    4032              pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
    4033     return pCritSect;
    4034 }
    4035 
    4036 
    40374426/** @interface_method_impl{PDMDEVHLPR3,pfnSetDeviceCritSect} */
    40384427static DECLCALLBACK(int) pdmR3DevHlp_SetDeviceCritSect(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
    … …  
    40694458    PDMDEV_ASSERT_DEVINS(pDevIns);
    40704459
    4071     RT_NOREF(pDevIns, pCritSect, rcBusy);
    4072     int rc = VERR_NOT_IMPLEMENTED;
    4073     AssertFailed();
    4074     return rc;
     4460    RT_NOREF(pDevIns, rcBusy);
     4461    return RTCritSectEnter(&pCritSect->s.CritSect);
    40754462}
    40764463
    … …  
    41864573    AssertFailed();
    41874574    return rc;
     4575}
     4576
     4577
     4578/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwInit} */
     4579static DECLCALLBACK(int) pdmR3DevHlp_CritSectRwInit(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RT_SRC_POS_DECL,
     4580                                                    const char *pszNameFmt, va_list va)
     4581{
     4582    PDMDEV_ASSERT_DEVINS(pDevIns);
     4583    LogFlow(("pdmR3DevHlp_CritSectRwInit: caller='%s'/%d: pCritSect=%p pszNameFmt=%p:{%s}\n",
     4584             pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
     4585
     4586    int rc = VERR_NOT_IMPLEMENTED;
     4587    AssertFailed(); RT_NOREF(RT_SRC_POS_ARGS, va);
     4588
     4589    LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
     4590    return rc;
     4591}
     4592
     4593
     4594/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwDelete} */
     4595static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwDelete(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
     4596{
     4597    PDMDEV_ASSERT_DEVINS(pDevIns);
     4598    AssertFailed(); RT_NOREF(pCritSect);
     4599    return VERR_NOT_IMPLEMENTED;
     4600}
     4601
     4602
     4603/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwEnterShared} */
     4604static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwEnterShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy)
     4605{
     4606    PDMDEV_ASSERT_DEVINS(pDevIns);
     4607    AssertFailed(); RT_NOREF(pCritSect, rcBusy);
     4608    return VERR_NOT_IMPLEMENTED;
     4609}
     4610
     4611
     4612/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwEnterSharedDebug} */
     4613static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwEnterSharedDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy,
     4614                                                                     RTHCUINTPTR uId, RT_SRC_POS_DECL)
     4615{
     4616    PDMDEV_ASSERT_DEVINS(pDevIns);
     4617    AssertFailed(); RT_NOREF(pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
     4618    return VERR_NOT_IMPLEMENTED;
     4619}
     4620
     4621
     4622/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwTryEnterShared} */
     4623static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwTryEnterShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
     4624{
     4625    PDMDEV_ASSERT_DEVINS(pDevIns);
     4626    AssertFailed(); RT_NOREF(pCritSect);
     4627    return VERR_NOT_IMPLEMENTED;
     4628}
     4629
     4630
     4631/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwTryEnterSharedDebug} */
     4632static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwTryEnterSharedDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect,
     4633                                                                        RTHCUINTPTR uId, RT_SRC_POS_DECL)
     4634{
     4635    PDMDEV_ASSERT_DEVINS(pDevIns);
     4636    AssertFailed(); RT_NOREF(pCritSect, uId, RT_SRC_POS_ARGS);
     4637    return VERR_NOT_IMPLEMENTED;
     4638}
     4639
     4640
     4641/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwLeaveShared} */
     4642static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwLeaveShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
     4643{
     4644    PDMDEV_ASSERT_DEVINS(pDevIns);
     4645    AssertFailed(); RT_NOREF(pCritSect);
     4646    return VERR_NOT_IMPLEMENTED;
     4647}
     4648
     4649
     4650/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwEnterExcl} */
     4651static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwEnterExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy)
     4652{
     4653    PDMDEV_ASSERT_DEVINS(pDevIns);
     4654    AssertFailed(); RT_NOREF(pCritSect, rcBusy);
     4655    return VERR_NOT_IMPLEMENTED;
     4656}
     4657
     4658
     4659/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwEnterExclDebug} */
     4660static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwEnterExclDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy,
     4661                                                                   RTHCUINTPTR uId, RT_SRC_POS_DECL)
     4662{
     4663    PDMDEV_ASSERT_DEVINS(pDevIns);
     4664    AssertFailed(); RT_NOREF(pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
     4665    return VERR_NOT_IMPLEMENTED;
     4666}
     4667
     4668
     4669/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwTryEnterExcl} */
     4670static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwTryEnterExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
     4671{
     4672    PDMDEV_ASSERT_DEVINS(pDevIns);
     4673    AssertFailed(); RT_NOREF(pCritSect);
     4674    return VERR_NOT_IMPLEMENTED;
     4675}
     4676
     4677
     4678/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwTryEnterExclDebug} */
     4679static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwTryEnterExclDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect,
     4680                                                                      RTHCUINTPTR uId, RT_SRC_POS_DECL)
     4681{
     4682    PDMDEV_ASSERT_DEVINS(pDevIns);
     4683    AssertFailed(); RT_NOREF(pCritSect, uId, RT_SRC_POS_ARGS);
     4684    return VERR_NOT_IMPLEMENTED;
     4685}
     4686
     4687
     4688/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwLeaveExcl} */
     4689static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwLeaveExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
     4690{
     4691    PDMDEV_ASSERT_DEVINS(pDevIns);
     4692    AssertFailed(); RT_NOREF(pCritSect);
     4693    return VERR_NOT_IMPLEMENTED;
     4694}
     4695
     4696
     4697/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwIsWriteOwner} */
     4698static DECLCALLBACK(bool)     pdmR3DevHlp_CritSectRwIsWriteOwner(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
     4699{
     4700    PDMDEV_ASSERT_DEVINS(pDevIns);
     4701    AssertFailed(); RT_NOREF(pCritSect);
     4702    return VERR_NOT_IMPLEMENTED;
     4703}
     4704
     4705
     4706/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwIsReadOwner} */
     4707static DECLCALLBACK(bool)     pdmR3DevHlp_CritSectRwIsReadOwner(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, bool fWannaHear)
     4708{
     4709    PDMDEV_ASSERT_DEVINS(pDevIns);
     4710    AssertFailed(); RT_NOREF(pCritSect, fWannaHear);
     4711    return VERR_NOT_IMPLEMENTED;
     4712}
     4713
     4714
     4715/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwGetWriteRecursion} */
     4716static DECLCALLBACK(uint32_t) pdmR3DevHlp_CritSectRwGetWriteRecursion(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
     4717{
     4718    PDMDEV_ASSERT_DEVINS(pDevIns);
     4719    RT_NOREF(pDevIns, pCritSect);
     4720    AssertFailed();
     4721    return VERR_NOT_IMPLEMENTED;
     4722}
     4723
     4724
     4725/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwGetWriterReadRecursion} */
     4726static DECLCALLBACK(uint32_t) pdmR3DevHlp_CritSectRwGetWriterReadRecursion(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
     4727{
     4728    PDMDEV_ASSERT_DEVINS(pDevIns);
     4729    RT_NOREF(pDevIns, pCritSect);
     4730    AssertFailed();
     4731    return VERR_NOT_IMPLEMENTED;
     4732}
     4733
     4734
     4735/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwGetReadCount} */
     4736static DECLCALLBACK(uint32_t) pdmR3DevHlp_CritSectRwGetReadCount(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
     4737{
     4738    PDMDEV_ASSERT_DEVINS(pDevIns);
     4739    RT_NOREF(pDevIns, pCritSect);
     4740    AssertFailed();
     4741    return VERR_NOT_IMPLEMENTED;
     4742}
     4743
     4744
     4745/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwIsInitialized} */
     4746static DECLCALLBACK(bool)     pdmR3DevHlp_CritSectRwIsInitialized(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
     4747{
     4748    PDMDEV_ASSERT_DEVINS(pDevIns);
     4749    RT_NOREF(pDevIns, pCritSect);
     4750    AssertFailed();
     4751    return VERR_NOT_IMPLEMENTED;
    41884752}
    41894753
    … …  
    46265190
    46275191/** @interface_method_impl{PDMDEVHLPR3,pfnIommuRegister} */
    4628 static DECLCALLBACK(int) pdmR3DevHlp_IommuRegister(PPDMDEVINS pDevIns, PPDMIOMMUREGR3 pIommuReg, PCPDMIOMMUHLPR3 *ppIommuHlp)
     5192static DECLCALLBACK(int) pdmR3DevHlp_IommuRegister(PPDMDEVINS pDevIns, PPDMIOMMUREGR3 pIommuReg, PCPDMIOMMUHLPR3 *ppIommuHlp,
     5193                                                   uint32_t *pidxIommu)
    46295194{
    46305195    PDMDEV_ASSERT_DEVINS(pDevIns);
    … …  
    46385203                    ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIommuReg->u32Version, PDM_IOMMUREGR3_VERSION),
    46395204                    VERR_INVALID_PARAMETER);
    4640     AssertPtrReturn(pIommuReg->pfnMemRead, VERR_INVALID_POINTER);
    4641     AssertPtrReturn(pIommuReg->pfnMemWrite, VERR_INVALID_POINTER);
    46425205    AssertPtrReturn(pIommuReg->pfnMsiRemap, VERR_INVALID_POINTER);
    46435206    AssertMsgReturn(pIommuReg->u32TheEnd == PDM_IOMMUREGR3_VERSION,
    … …  
    46475210
    46485211    int rc = VERR_NOT_IMPLEMENTED;
    4649     AssertFailed();
     5212    AssertFailed(); RT_NOREF(pidxIommu);
    46505213    Log(("PDM: Registered IOMMU device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
    46515214
    … …  
    48425405             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvHeap, cbHeap));
    48435406
    4844     int rc = VERR_NOT_IMPLEMENTED;
    4845     AssertFailed();
     5407#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     5408    int rc = VERR_NOT_IMPLEMENTED;
     5409    AssertFailed();
     5410#else
     5411    int rc = VINF_SUCCESS;
     5412#endif
    48465413
    48475414    LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: returns %Rrc\n",
    … …  
    49925559}
    49935560
     5561/** @interface_method_impl{PDMDEVHLPR3,pfnPGMHandlerPhysicalRegister} */
     5562static DECLCALLBACK(int) pdmR3DevHlp_PGMHandlerPhysicalRegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast,
     5563                                                                PGMPHYSHANDLERTYPE hType, RTR3PTR pvUserR3, RTR0PTR pvUserR0,
     5564                                                                RTRCPTR pvUserRC, R3PTRTYPE(const char *) pszDesc)
     5565{
     5566    PDMDEV_ASSERT_DEVINS(pDevIns);
     5567    RT_NOREF(GCPhys, GCPhysLast, hType, pvUserR3, pvUserR0, pvUserRC, pszDesc);
     5568    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5569                            pDevIns->pReg->szName, pDevIns->iInstance));
     5570    return VERR_ACCESS_DENIED;
     5571}
     5572
     5573
     5574/** @interface_method_impl{PDMDEVHLPR3,pfnPGMHandlerPhysicalDeregister} */
     5575static DECLCALLBACK(int) pdmR3DevHlp_PGMHandlerPhysicalDeregister(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
     5576{
     5577    PDMDEV_ASSERT_DEVINS(pDevIns);
     5578    RT_NOREF(GCPhys);
     5579    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5580                            pDevIns->pReg->szName, pDevIns->iInstance));
     5581    return VERR_ACCESS_DENIED;
     5582}
     5583
     5584
     5585/** @interface_method_impl{PDMDEVHLPR3,pfnPGMHandlerPhysicalPageTempOff} */
     5586static DECLCALLBACK(int) pdmR3DevHlp_PGMHandlerPhysicalPageTempOff(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage)
     5587{
     5588    PDMDEV_ASSERT_DEVINS(pDevIns);
     5589    RT_NOREF(GCPhys, GCPhysPage);
     5590    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5591                            pDevIns->pReg->szName, pDevIns->iInstance));
     5592    return VERR_ACCESS_DENIED;
     5593}
     5594
     5595
     5596/** @interface_method_impl{PDMDEVHLPR3,pfnPGMHandlerPhysicalReset} */
     5597static DECLCALLBACK(int) pdmR3DevHlp_PGMHandlerPhysicalReset(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
     5598{
     5599    PDMDEV_ASSERT_DEVINS(pDevIns);
     5600    RT_NOREF(GCPhys);
     5601    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5602                            pDevIns->pReg->szName, pDevIns->iInstance));
     5603    return VERR_ACCESS_DENIED;
     5604}
     5605
     5606
     5607/** @interface_method_impl{PDMDEVHLPR3,pfnVMMRegisterPatchMemory} */
     5608static DECLCALLBACK(int) pdmR3DevHlp_VMMRegisterPatchMemory(PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem)
     5609{
     5610    PDMDEV_ASSERT_DEVINS(pDevIns);
     5611    RT_NOREF(GCPtrPatchMem, cbPatchMem);
     5612    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5613                            pDevIns->pReg->szName, pDevIns->iInstance));
     5614    return VERR_ACCESS_DENIED;
     5615}
     5616
     5617
     5618/** @interface_method_impl{PDMDEVHLPR3,pfnVMMDeregisterPatchMemory} */
     5619static DECLCALLBACK(int) pdmR3DevHlp_VMMDeregisterPatchMemory(PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem)
     5620{
     5621    PDMDEV_ASSERT_DEVINS(pDevIns);
     5622    RT_NOREF(GCPtrPatchMem, cbPatchMem);
     5623    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5624                            pDevIns->pReg->szName, pDevIns->iInstance));
     5625    return VERR_ACCESS_DENIED;
     5626}
     5627
     5628
     5629/** @interface_method_impl{PDMDEVHLPR3,pfnSharedModuleRegister} */
     5630static DECLCALLBACK(int) pdmR3DevHlp_SharedModuleRegister(PPDMDEVINS pDevIns, VBOXOSFAMILY enmGuestOS, char *pszModuleName, char *pszVersion,
     5631                                                                    RTGCPTR GCBaseAddr, uint32_t cbModule,
     5632                                                                    uint32_t cRegions, VMMDEVSHAREDREGIONDESC const *paRegions)
     5633{
     5634    PDMDEV_ASSERT_DEVINS(pDevIns);
     5635    RT_NOREF(enmGuestOS, pszModuleName, pszVersion, GCBaseAddr, cbModule, cRegions, paRegions);
     5636    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5637                            pDevIns->pReg->szName, pDevIns->iInstance));
     5638    return VERR_ACCESS_DENIED;
     5639}
     5640
     5641
     5642/** @interface_method_impl{PDMDEVHLPR3,pfnSharedModuleUnregister} */
     5643static DECLCALLBACK(int) pdmR3DevHlp_SharedModuleUnregister(PPDMDEVINS pDevIns, char *pszModuleName, char *pszVersion,
     5644                                                                      RTGCPTR GCBaseAddr, uint32_t cbModule)
     5645{
     5646    PDMDEV_ASSERT_DEVINS(pDevIns);
     5647    RT_NOREF(pszModuleName, pszVersion, GCBaseAddr, cbModule);
     5648    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5649                            pDevIns->pReg->szName, pDevIns->iInstance));
     5650    return VERR_ACCESS_DENIED;
     5651}
     5652
     5653
     5654/** @interface_method_impl{PDMDEVHLPR3,pfnSharedModuleGetPageState} */
     5655static DECLCALLBACK(int) pdmR3DevHlp_SharedModuleGetPageState(PPDMDEVINS pDevIns, RTGCPTR GCPtrPage, bool *pfShared, uint64_t *pfPageFlags)
     5656{
     5657    PDMDEV_ASSERT_DEVINS(pDevIns);
     5658    RT_NOREF(GCPtrPage, pfShared, pfPageFlags);
     5659    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5660                            pDevIns->pReg->szName, pDevIns->iInstance));
     5661    return VERR_ACCESS_DENIED;
     5662}
     5663
     5664
     5665/** @interface_method_impl{PDMDEVHLPR3,pfnSharedModuleCheckAll} */
     5666static DECLCALLBACK(int) pdmR3DevHlp_SharedModuleCheckAll(PPDMDEVINS pDevIns)
     5667{
     5668    PDMDEV_ASSERT_DEVINS(pDevIns);
     5669    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5670                            pDevIns->pReg->szName, pDevIns->iInstance));
     5671    return VERR_ACCESS_DENIED;
     5672}
     5673
     5674
     5675/** @interface_method_impl{PDMDEVHLPR3,pfnQueryLun} */
     5676static DECLCALLBACK(int) pdmR3DevHlp_QueryLun(PPDMDEVINS pDevIns, const char *pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE *ppBase)
     5677{
     5678    PDMDEV_ASSERT_DEVINS(pDevIns);
     5679    RT_NOREF(pszDevice, iInstance, iLun, ppBase);
     5680    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5681                            pDevIns->pReg->szName, pDevIns->iInstance));
     5682    return VERR_ACCESS_DENIED;
     5683}
     5684
     5685
     5686/** @interface_method_impl{PDMDEVHLPR3,pfnGIMDeviceRegister} */
     5687static DECLCALLBACK(void) pdmR3DevHlp_GIMDeviceRegister(PPDMDEVINS pDevIns, PGIMDEBUG pDbg)
     5688{
     5689    PDMDEV_ASSERT_DEVINS(pDevIns);
     5690    RT_NOREF(pDbg);
     5691    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5692                            pDevIns->pReg->szName, pDevIns->iInstance));
     5693}
     5694
     5695
     5696/** @interface_method_impl{PDMDEVHLPR3,pfnGIMGetDebugSetup} */
     5697static DECLCALLBACK(int) pdmR3DevHlp_GIMGetDebugSetup(PPDMDEVINS pDevIns, PGIMDEBUGSETUP pDbgSetup)
     5698{
     5699    PDMDEV_ASSERT_DEVINS(pDevIns);
     5700    RT_NOREF(pDbgSetup);
     5701    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5702                            pDevIns->pReg->szName, pDevIns->iInstance));
     5703    return VERR_ACCESS_DENIED;
     5704}
     5705
     5706
     5707/** @interface_method_impl{PDMDEVHLPR3,pfnGIMGetMmio2Regions} */
     5708static DECLCALLBACK(PGIMMMIO2REGION) pdmR3DevHlp_GIMGetMmio2Regions(PPDMDEVINS pDevIns, uint32_t *pcRegions)
     5709{
     5710    PDMDEV_ASSERT_DEVINS(pDevIns);
     5711    RT_NOREF(pcRegions);
     5712    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5713                            pDevIns->pReg->szName, pDevIns->iInstance));
     5714    return NULL;
     5715}
     5716
    49945717const PDMDEVHLPR3 g_tstDevPdmDevHlpR3 =
    49955718{
    … …  
    49995722    pdmR3DevHlp_IoPortUnmap,
    50005723    pdmR3DevHlp_IoPortGetMappingAddress,
     5724    pdmR3DevHlp_IoPortWrite,
    50015725    pdmR3DevHlp_MmioCreateEx,
    50025726    pdmR3DevHlp_MmioMap,
    … …  
    50115735    pdmR3DevHlp_Mmio2GetMappingAddress,
    50125736    pdmR3DevHlp_Mmio2ChangeRegionNo,
     5737    pdmR3DevHlp_MmioMapMmio2Page,
     5738    pdmR3DevHlp_MmioResetRegion,
    50135739    pdmR3DevHlp_ROMRegister,
    50145740    pdmR3DevHlp_ROMProtectShadow,
    … …  
    50975823    pdmR3DevHlp_SSMHandleVersion,
    50985824    pdmR3DevHlp_SSMHandleHostOSAndArch,
    5099     pdmR3DevHlp_TMTimerCreate,
    51005825    pdmR3DevHlp_TimerCreate,
    5101     pdmR3DevHlp_TimerToPtr,
    51025826    pdmR3DevHlp_TimerFromMicro,
    51035827    pdmR3DevHlp_TimerFromMilli,
    … …  
    51915915    pdmR3DevHlp_PhysWriteGCVirt,
    51925916    pdmR3DevHlp_PhysGCPtr2GCPhys,
     5917    pdmR3DevHlp_PhysIsGCPhysNormal,
     5918    pdmR3DevHlp_PhysChangeMemBalloon,
    51935919    pdmR3DevHlp_MMHeapAlloc,
    51945920    pdmR3DevHlp_MMHeapAllocZ,
     5921    pdmR3DevHlp_MMHeapAPrintfV,
    51955922    pdmR3DevHlp_MMHeapFree,
     5923    pdmR3DevHlp_MMPhysGetRamSize,
     5924    pdmR3DevHlp_MMPhysGetRamSizeBelow4GB,
     5925    pdmR3DevHlp_MMPhysGetRamSizeAbove4GB,
    51965926    pdmR3DevHlp_VMState,
    51975927    pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet,
    5198     pdmR3DevHlp_VMSetError,
    51995928    pdmR3DevHlp_VMSetErrorV,
    5200     pdmR3DevHlp_VMSetRuntimeError,
    52015929    pdmR3DevHlp_VMSetRuntimeErrorV,
     5930    pdmR3DevHlp_VMWaitForDeviceReady,
     5931    pdmR3DevHlp_VMNotifyCpuDeviceReady,
     5932    pdmR3DevHlp_VMReqCallNoWaitV,
     5933    pdmR3DevHlp_VMReqPriorityCallWaitV,
    52025934    pdmR3DevHlp_DBGFStopV,
    52035935    pdmR3DevHlp_DBGFInfoRegister,
    … …  
    52055937    pdmR3DevHlp_DBGFRegRegister,
    52065938    pdmR3DevHlp_DBGFTraceBuf,
     5939    pdmR3DevHlp_DBGFReportBugCheck,
     5940    pdmR3DevHlp_DBGFCoreWrite,
     5941    pdmR3DevHlp_DBGFInfoLogHlp,
     5942    pdmR3DevHlp_DBGFRegNmQueryU64,
     5943    pdmR3DevHlp_DBGFRegPrintfV,
    52075944    pdmR3DevHlp_STAMRegister,
    52085945    pdmR3DevHlp_STAMRegisterV,
    … …  
    52155952    pdmR3DevHlp_PCIPhysRead,
    52165953    pdmR3DevHlp_PCIPhysWrite,
     5954    pdmR3DevHlp_PCIPhysGCPhys2CCPtr,
     5955    pdmR3DevHlp_PCIPhysGCPhys2CCPtrReadOnly,
     5956    pdmR3DevHlp_PCIPhysBulkGCPhys2CCPtr,
     5957    pdmR3DevHlp_PCIPhysBulkGCPhys2CCPtrReadOnly,
    52175958    pdmR3DevHlp_PCISetIrq,
    52185959    pdmR3DevHlp_PCISetIrqNoWait,
    52195960    pdmR3DevHlp_ISASetIrq,
    52205961    pdmR3DevHlp_ISASetIrqNoWait,
    5221     pdmR3DevHlp_IoApicSendMsi,
    52225962    pdmR3DevHlp_DriverAttach,
    52235963    pdmR3DevHlp_DriverDetach,
    52245964    pdmR3DevHlp_DriverReconfigure,
    5225     pdmR3DevHlp_QueueCreatePtr,
    52265965    pdmR3DevHlp_QueueCreate,
    5227     pdmR3DevHlp_QueueToPtr,
    52285966    pdmR3DevHlp_QueueAlloc,
    52295967    pdmR3DevHlp_QueueInsert,
    5230     pdmR3DevHlp_QueueInsertEx,
    52315968    pdmR3DevHlp_QueueFlushIfNecessary,
    52325969    pdmR3DevHlp_TaskCreate,
    … …  
    52495986    pdmR3DevHlp_CritSectInit,
    52505987    pdmR3DevHlp_CritSectGetNop,
    5251     pdmR3DevHlp_CritSectGetNopR0,
    5252     pdmR3DevHlp_CritSectGetNopRC,
    52535988    pdmR3DevHlp_SetDeviceCritSect,
    52545989    pdmR3DevHlp_CritSectYield,
    … …  
    52645999    pdmR3DevHlp_CritSectScheduleExitEvent,
    52656000    pdmR3DevHlp_CritSectDelete,
     6001    pdmR3DevHlp_CritSectRwInit,
     6002    pdmR3DevHlp_CritSectRwDelete,
     6003    pdmR3DevHlp_CritSectRwEnterShared,
     6004    pdmR3DevHlp_CritSectRwEnterSharedDebug,
     6005    pdmR3DevHlp_CritSectRwTryEnterShared,
     6006    pdmR3DevHlp_CritSectRwTryEnterSharedDebug,
     6007    pdmR3DevHlp_CritSectRwLeaveShared,
     6008    pdmR3DevHlp_CritSectRwEnterExcl,
     6009    pdmR3DevHlp_CritSectRwEnterExclDebug,
     6010    pdmR3DevHlp_CritSectRwTryEnterExcl,
     6011    pdmR3DevHlp_CritSectRwTryEnterExclDebug,
     6012    pdmR3DevHlp_CritSectRwLeaveExcl,
     6013    pdmR3DevHlp_CritSectRwIsWriteOwner,
     6014    pdmR3DevHlp_CritSectRwIsReadOwner,
     6015    pdmR3DevHlp_CritSectRwGetWriteRecursion,
     6016    pdmR3DevHlp_CritSectRwGetWriterReadRecursion,
     6017    pdmR3DevHlp_CritSectRwGetReadCount,
     6018    pdmR3DevHlp_CritSectRwIsInitialized,
    52666019    pdmR3DevHlp_ThreadCreate,
    52676020    pdmR3DevHlp_ThreadDestroy,
    … …  
    53016054    pdmR3DevHlp_PhysBulkReleasePageMappingLocks,
    53026055    pdmR3DevHlp_CpuGetGuestMicroarch,
     6056    pdmR3DevHlp_CpuGetGuestAddrWidths,
     6057    pdmR3DevHlp_CpuGetGuestScalableBusFrequency,
    53036058    NULL,
    53046059    NULL,
    … …  
    53276082    pdmR3DevHlp_TMTimeVirtGetFreq,
    53286083    pdmR3DevHlp_TMTimeVirtGetNano,
     6084    pdmR3DevHlp_TMCpuTicksPerSecond,
    53296085    pdmR3DevHlp_GetSupDrvSession,
    53306086    pdmR3DevHlp_QueryGenericUserObject,
    53316087    pdmR3DevHlp_PGMHandlerPhysicalTypeRegister,
     6088    pdmR3DevHlp_PGMHandlerPhysicalRegister,
     6089    pdmR3DevHlp_PGMHandlerPhysicalDeregister,
     6090    pdmR3DevHlp_PGMHandlerPhysicalPageTempOff,
     6091    pdmR3DevHlp_PGMHandlerPhysicalReset,
     6092    pdmR3DevHlp_VMMRegisterPatchMemory,
     6093    pdmR3DevHlp_VMMDeregisterPatchMemory,
     6094    pdmR3DevHlp_SharedModuleRegister,
     6095    pdmR3DevHlp_SharedModuleUnregister,
     6096    pdmR3DevHlp_SharedModuleGetPageState,
     6097    pdmR3DevHlp_SharedModuleCheckAll,
     6098    pdmR3DevHlp_QueryLun,
     6099    pdmR3DevHlp_GIMDeviceRegister,
     6100    pdmR3DevHlp_GIMGetDebugSetup,
     6101    pdmR3DevHlp_GIMGetMmio2Regions,
    53326102    PDM_DEVHLPR3_VERSION /* the end */
    53336103};

  • trunk/src/VBox/Devices/testcase/tstDeviceSsmFuzz.cpp

    r83427 r91998  
    9898static DECLCALLBACK(int) tstDevSsmFuzzEntry(TSTDEVDUT hDut, PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems)
    9999{
    100     RT_NOREF(hDut, paCfg);
    101 
    102100    RTFUZZCTX hFuzzCtx;
    103101    int rc = RTFuzzCtxCreate(&hFuzzCtx, RTFUZZCTXTYPE_BLOB);
Note: See TracChangeset for help on using the changeset viewer.

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