VirtualBox

Changeset 83261 in vbox for trunk/src/VBox/Devices/testcase


Ignore:
Timestamp:
Mar 11, 2020 4:10:11 PM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
136412
Message:

Devices/tstDevice: Testbench updates, work in progress

Location:
trunk/src/VBox/Devices/testcase
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed

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

    r83062 r83261  
    4040#include "tstDeviceInternal.h"
    4141#include "tstDeviceCfg.h"
     42#include "tstDeviceBuiltin.h"
    4243
    4344
    … …  
    330331        {
    331332            pTestcase->pPlugin = pPlugin;
    332             pPlugin->cRefs++;
     333            if (pPlugin)
     334                pPlugin->cRefs++;
    333335            pTestcase->pTestcaseReg = pTestcaseReg;
    334336            RTListAppend(&g_LstTestcases, &pTestcase->NdTestcases);
    … …  
    879881
    880882
     883DECLCALLBACK(void *) tstDevTestsRun_QueryInterface(PPDMIBASE pInterface, const char *pszIID)
     884{
     885    RT_NOREF(pInterface, pszIID);
     886#if 0
     887    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
     888    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDCONNECTORS, &pThis->ILedConnectors);
     889    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIANOTIFY, &pThis->IMediaNotify);
     890#endif
     891    return NULL;
     892}
     893
    881894/**
    882895 * Run a given test config.
    … …  
    896909        Dut.pTest           = pTest;
    897910        Dut.enmCtx          = TSTDEVDUTCTX_R3;
    898         Dut.pVm             = NULL;
     911        Dut.pVm             = (PVM)0x1000;
    899912        Dut.SupSession.pDut = &Dut;
    900913        Dut.Cfg.pDut        = &Dut;
     914
     915        Dut.IBaseSts.pfnQueryInterface = tstDevTestsRun_QueryInterface;
     916
    901917        RTListInit(&Dut.LstIoPorts);
    902918        RTListInit(&Dut.LstTimers);
    … …  
    915931        if (RT_SUCCESS(rc))
    916932        {
    917             /** @todo Next */
     933            PCTSTDEVTESTCASE pTestcase = tstDevTestcaseFind(pTest->papszTestcaseIds[i]);
     934            if (pTestcase)
     935                rc = pTestcase->pTestcaseReg->pfnTestEntry(&Dut, pTest->papTestcaseCfg[i], pTest->pacTestcaseCfgItems[i]);
     936            else
     937                rc = VERR_NOT_FOUND;
    918938        }
    919939    }
    … …  
    936956        RTListInit(&g_LstPdmMods);
    937957        RTListInit(&g_LstPdmDevs);
     958
     959        /* Register builtin tests. */
     960        tstDevRegisterTestcase(NULL, &g_TestcaseSsmFuzz);
    938961
    939962        PCTSTDEVCFG pDevTstCfg = NULL;

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

    r83062 r83261  
    310310                        rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to allocate %zu bytes for the test config structure", cbCfg);
    311311                }
     312                else
     313                {
     314                    *ppszTestcaseId     = pszTestcaseId;
     315                    *pcTestcaseCfgItems = 0;
     316                    *ppTestcaseCfg      = NULL;
     317                }
    312318            }
    313319            else

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

    r83062 r83261  
    9797} PDMCRITSECTINT;
    9898AssertCompile(sizeof(PDMCRITSECTINT) <= (HC_ARCH_BITS == 32 ? 0x80 : 0xc0));
     99
     100
     101/**
     102 * SSM handle state.
     103 */
     104typedef struct SSMHANDLE
     105{
     106    /** Pointer to the device under test the handle is for. */
     107    PTSTDEVDUTINT                   pDut;
     108    /** The saved state data buffer. */
     109    uint8_t                         *pbSavedState;
     110    /** Size of the saved state. */
     111    size_t                          cbSavedState;
     112    /** Current offset into the data buffer. */
     113    uint32_t                        offDataBuffer;
     114    /** Current unit version. */
     115    uint32_t                        uCurUnitVer;
     116    /** Status code. */
     117    int                             rc;
     118} SSMHANDLE;
    99119
    100120
    … …  
    363383    /** PCI Region descriptors. */
    364384    TSTDEVDUTPCIREGION              aPciRegions[VBOX_PCI_NUM_REGIONS];
     385    /** The status port interface we implement. */
     386    PDMIBASE                        IBaseSts;
     387    /**  */
    365388} TSTDEVDUTINT;
    366389

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

    r83062 r83261  
    3434*   Defined Constants And Macros                                                                                                 *
    3535*********************************************************************************************************************************/
     36
     37/* Temporarily until the stubs got implemented. */
     38#define VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS 1
    3639
    3740/** @def PDMDEV_ASSERT_DEVINS
    … …  
    5457/** Frequency of the virtual clock. */
    5558#define TMCLOCK_FREQ_VIRTUAL    UINT32_C(1000000000)
     59
     60
     61/** Start structure magic. (Isaac Asimov) */
     62#define SSMR3STRUCT_BEGIN                       UINT32_C(0x19200102)
     63/** End structure magic. (Isaac Asimov) */
     64#define SSMR3STRUCT_END                         UINT32_C(0x19920406)
    5665
    5766
    … …  
    201210             pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, fFlags, pPciDev, iPciRegion, pfnWrite, pfnRead, pfnFill, pvUser, pszDesc, pszDesc, phRegion));
    202211
    203     int rc = VERR_NOT_IMPLEMENTED;
    204     AssertFailed();
     212#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     213    int rc = VERR_NOT_IMPLEMENTED;
     214    AssertFailed();
     215#else
     216    int rc = VINF_SUCCESS;
     217#endif
    205218
    206219    LogFlow(("pdmR3DevHlp_MmioCreateEx: caller='%s'/%d: returns %Rrc (*phRegion=%#x)\n",
    … …  
    216229    LogFlow(("pdmR3DevHlp_MmioMap: caller='%s'/%d: hRegion=%#x GCPhys=%#RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, GCPhys));
    217230
    218     int rc = VERR_NOT_IMPLEMENTED;
    219     AssertFailed();
     231#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     232    int rc = VERR_NOT_IMPLEMENTED;
     233    AssertFailed();
     234#else
     235    int rc = VINF_SUCCESS;
     236#endif
    220237
    221238    LogFlow(("pdmR3DevHlp_MmioMap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    230247    LogFlow(("pdmR3DevHlp_MmioUnmap: caller='%s'/%d: hRegion=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
    231248
    232     int rc = VERR_NOT_IMPLEMENTED;
    233     AssertFailed();
     249#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     250    int rc = VERR_NOT_IMPLEMENTED;
     251    AssertFailed();
     252#else
     253    int rc = VINF_SUCCESS;
     254#endif
    234255
    235256    LogFlow(("pdmR3DevHlp_MmioUnmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    244265    LogFlow(("pdmR3DevHlp_MmioReduce: caller='%s'/%d: hRegion=%#x cbRegion=%#RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, cbRegion));
    245266
    246     int rc = VERR_NOT_IMPLEMENTED;
    247     AssertFailed();
    248 
     267#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     268    int rc = VERR_NOT_IMPLEMENTED;
     269    AssertFailed();
     270#else
     271    int rc = VINF_SUCCESS;
     272#endif
    249273    LogFlow(("pdmR3DevHlp_MmioReduce: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    250274    return rc;
    … …  
    258282    LogFlow(("pdmR3DevHlp_MmioGetMappingAddress: caller='%s'/%d: hRegion=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
    259283
     284#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    260285    RTGCPHYS GCPhys = NIL_RTGCPHYS;
    261286    AssertFailed();
     287#else
     288    RTGCPHYS GCPhys = 0x1000;
     289#endif
    262290
    263291    LogFlow(("pdmR3DevHlp_MmioGetMappingAddress: caller='%s'/%d: returns %RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys));
    … …  
    275303             fFlags, pszDesc, pszDesc, ppvMapping, phRegion));
    276304
    277     int rc = VERR_NOT_IMPLEMENTED;
    278     AssertFailed();
     305#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     306    int rc = VERR_NOT_IMPLEMENTED;
     307    AssertFailed();
     308#else
     309    int rc = VINF_SUCCESS;
     310    *ppvMapping = RTMemAllocZ(cbRegion);
     311    if (!*ppvMapping)
     312        rc = VERR_NO_MEMORY;
     313#endif
    279314
    280315    LogFlow(("pdmR3DevHlp_Mmio2Create: caller='%s'/%d: returns %Rrc *ppvMapping=%p phRegion=%#RX64\n",
    … …  
    377412             pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvBinary, cbBinary, fFlags, pszDesc, pszDesc));
    378413
    379     int rc = VERR_NOT_IMPLEMENTED;
    380     AssertFailed();
     414#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     415    int rc = VERR_NOT_IMPLEMENTED;
     416    AssertFailed();
     417#else
     418    int rc = VINF_SUCCESS;
     419#endif
    381420
    382421    LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    654693
    655694
     695/**
     696 * Gets the host bit count of the saved state.
     697 *
     698 * Works for on both save and load handles.
     699 *
     700 * @returns 32 or 64.
     701 * @param   pSSM                The saved state handle.
     702 */
     703DECLINLINE(uint32_t) ssmR3GetHostBits(PSSMHANDLE pSSM)
     704{
     705    /** @todo Don't care about 32bit saved states for now (VBox is 64bit only as of 6.0). */
     706    RT_NOREF(pSSM);
     707    return HC_ARCH_BITS;
     708}
     709
     710
     711/**
     712 * Saved state origins on a host using 32-bit MSC?
     713 *
     714 * Works for on both save and load handles.
     715 *
     716 * @returns true/false.
     717 * @param   pSSM                The saved state handle.
     718 */
     719DECLINLINE(bool) ssmR3IsHostMsc32(PSSMHANDLE pSSM)
     720{
     721    /** @todo Don't care about 32bit saved states for now (VBox is 64bit only as of 6.0). */
     722    RT_NOREF(pSSM);
     723    return false;
     724}
     725
     726
     727/**
     728 * Inlined worker that handles format checks and buffered reads.
     729 *
     730 * @param   pSSM            The saved state handle.
     731 * @param   pvBuf           Where to store the read data.
     732 * @param   cbBuf           Number of bytes to read.
     733 */
     734DECLINLINE(int) tstDevSsmR3DataRead(PSSMHANDLE pSSM, void *pvBuf, size_t cbBuf)
     735{
     736    /*
     737     * Fend off previous errors and V1 data units.
     738     */
     739    if (RT_SUCCESS(pSSM->rc))
     740    {
     741        /** @todo Don't care about version 1 saved states (long obsolete). */
     742        uint32_t off = pSSM->offDataBuffer;
     743        if (   cbBuf <= pSSM->cbSavedState
     744            && pSSM->cbSavedState - cbBuf >= off)
     745        {
     746            memcpy(pvBuf, &pSSM->pbSavedState[off], cbBuf);
     747            pSSM->offDataBuffer = off + (uint32_t)cbBuf;
     748            return VINF_SUCCESS;
     749        }
     750        else
     751            pSSM->rc = VERR_BUFFER_OVERFLOW;
     752    }
     753    return pSSM->rc;
     754}
     755
     756
     757static DECLCALLBACK(int) pdmR3DevHlp_SSMGetBool(PSSMHANDLE pSSM, bool *pfBool)
     758{
     759    uint8_t u8; /* see SSMR3PutBool */
     760    int rc = tstDevSsmR3DataRead(pSSM, &u8, sizeof(u8));
     761    if (RT_SUCCESS(rc))
     762    {
     763        Assert(u8 <= 1);
     764        *pfBool = RT_BOOL(u8);
     765    }
     766    return rc;
     767}
     768
     769
     770static DECLCALLBACK(int) pdmR3DevHlp_SSMGetBoolV(PSSMHANDLE pSSM, bool volatile *pfBool)
     771{
     772    uint8_t u8; /* see SSMR3PutBool */
     773    int rc = tstDevSsmR3DataRead(pSSM, &u8, sizeof(u8));
     774    if (RT_SUCCESS(rc))
     775    {
     776        Assert(u8 <= 1);
     777        *pfBool = RT_BOOL(u8);
     778    }
     779    return rc;
     780}
     781
     782
     783static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU8(PSSMHANDLE pSSM, uint8_t *pu8)
     784{
     785    return tstDevSsmR3DataRead(pSSM, pu8, sizeof(*pu8));
     786}
     787
     788
     789static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU8V(PSSMHANDLE pSSM, uint8_t volatile *pu8)
     790{
     791    return tstDevSsmR3DataRead(pSSM, (void *)pu8, sizeof(*pu8));
     792}
     793
     794
     795static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS8(PSSMHANDLE pSSM, int8_t *pi8)
     796{
     797    return tstDevSsmR3DataRead(pSSM, pi8, sizeof(*pi8));
     798}
     799
     800
     801static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS8V(PSSMHANDLE pSSM, int8_t volatile *pi8)
     802{
     803    return tstDevSsmR3DataRead(pSSM, (void *)pi8, sizeof(*pi8));
     804}
     805
     806
     807static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU16(PSSMHANDLE pSSM, uint16_t *pu16)
     808{
     809    return tstDevSsmR3DataRead(pSSM, pu16, sizeof(*pu16));
     810}
     811
     812
     813static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU16V(PSSMHANDLE pSSM, uint16_t volatile *pu16)
     814{
     815    return tstDevSsmR3DataRead(pSSM, (void *)pu16, sizeof(*pu16));
     816}
     817
     818
     819static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS16(PSSMHANDLE pSSM, int16_t *pi16)
     820{
     821    return tstDevSsmR3DataRead(pSSM, pi16, sizeof(*pi16));
     822}
     823
     824
     825static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS16V(PSSMHANDLE pSSM, int16_t volatile *pi16)
     826{
     827    return tstDevSsmR3DataRead(pSSM, (void *)pi16, sizeof(*pi16));
     828}
     829
     830
     831static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU32(PSSMHANDLE pSSM, uint32_t *pu32)
     832{
     833    return tstDevSsmR3DataRead(pSSM, pu32, sizeof(*pu32));
     834}
     835
     836
     837static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU32V(PSSMHANDLE pSSM, uint32_t volatile *pu32)
     838{
     839    return tstDevSsmR3DataRead(pSSM, (void *)pu32, sizeof(*pu32));
     840}
     841
     842
     843static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS32(PSSMHANDLE pSSM, int32_t *pi32)
     844{
     845    return tstDevSsmR3DataRead(pSSM, pi32, sizeof(*pi32));
     846}
     847
     848
     849static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS32V(PSSMHANDLE pSSM, int32_t volatile *pi32)
     850{
     851    return tstDevSsmR3DataRead(pSSM, (void *)pi32, sizeof(*pi32));
     852}
     853
     854
     855static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU64(PSSMHANDLE pSSM, uint64_t *pu64)
     856{
     857    return tstDevSsmR3DataRead(pSSM, pu64, sizeof(*pu64));
     858}
     859
     860
     861static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU64V(PSSMHANDLE pSSM, uint64_t volatile *pu64)
     862{
     863    return tstDevSsmR3DataRead(pSSM, (void *)pu64, sizeof(*pu64));
     864}
     865
     866
     867static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS64(PSSMHANDLE pSSM, int64_t *pi64)
     868{
     869    return tstDevSsmR3DataRead(pSSM, pi64, sizeof(*pi64));
     870}
     871
     872
     873static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS64V(PSSMHANDLE pSSM, int64_t volatile *pi64)
     874{
     875    return tstDevSsmR3DataRead(pSSM, (void *)pi64, sizeof(*pi64));
     876}
     877
     878
     879static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU128(PSSMHANDLE pSSM, uint128_t *pu128)
     880{
     881    return tstDevSsmR3DataRead(pSSM, pu128, sizeof(*pu128));
     882}
     883
     884
     885static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU128V(PSSMHANDLE pSSM, uint128_t volatile *pu128)
     886{
     887    return tstDevSsmR3DataRead(pSSM, (void *)pu128, sizeof(*pu128));
     888}
     889
     890
     891static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS128(PSSMHANDLE pSSM, int128_t *pi128)
     892{
     893    return tstDevSsmR3DataRead(pSSM, pi128, sizeof(*pi128));
     894}
     895
     896
     897static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS128V(PSSMHANDLE pSSM, int128_t  volatile *pi128)
     898{
     899    return tstDevSsmR3DataRead(pSSM, (void *)pi128, sizeof(*pi128));
     900}
     901
     902
     903static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys32(PSSMHANDLE pSSM, PRTGCPHYS32 pGCPhys)
     904{
     905    return tstDevSsmR3DataRead(pSSM, pGCPhys, sizeof(*pGCPhys));
     906}
     907
     908
     909static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys32V(PSSMHANDLE pSSM, RTGCPHYS32 volatile *pGCPhys)
     910{
     911    return tstDevSsmR3DataRead(pSSM, (void *)pGCPhys, sizeof(*pGCPhys));
     912}
     913
     914
     915static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys64(PSSMHANDLE pSSM, PRTGCPHYS64 pGCPhys)
     916{
     917    return tstDevSsmR3DataRead(pSSM, pGCPhys, sizeof(*pGCPhys));
     918}
     919
     920
     921static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys64V(PSSMHANDLE pSSM, RTGCPHYS64 volatile *pGCPhys)
     922{
     923    return tstDevSsmR3DataRead(pSSM, (void *)pGCPhys, sizeof(*pGCPhys));
     924}
     925
     926
     927static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys(PSSMHANDLE pSSM, PRTGCPHYS pGCPhys)
     928{
     929    /*
     930     * Default size?
     931     */
     932    if (RT_LIKELY(/*sizeof(*pGCPhys) == pSSM->u.Read.cbGCPhys*/true))
     933        return tstDevSsmR3DataRead(pSSM, pGCPhys, sizeof(*pGCPhys));
     934
     935#if 0 /** @todo Later if necessary (only very old saved states). */
     936    /*
     937     * Fiddly.
     938     */
     939    Assert(sizeof(*pGCPhys)      == sizeof(uint64_t) || sizeof(*pGCPhys)      == sizeof(uint32_t));
     940    Assert(pSSM->u.Read.cbGCPhys == sizeof(uint64_t) || pSSM->u.Read.cbGCPhys == sizeof(uint32_t));
     941    if (pSSM->u.Read.cbGCPhys == sizeof(uint64_t))
     942    {
     943        /* 64-bit saved, 32-bit load: try truncate it. */
     944        uint64_t u64;
     945        int rc = tstDevSsmR3DataRead(pSSM, &u64, sizeof(uint64_t));
     946        if (RT_FAILURE(rc))
     947            return rc;
     948        if (u64 >= _4G)
     949            return VERR_SSM_GCPHYS_OVERFLOW;
     950        *pGCPhys = (RTGCPHYS)u64;
     951        return rc;
     952    }
     953
     954    /* 32-bit saved, 64-bit load: clear the high part. */
     955    *pGCPhys = 0;
     956    return tstDevSsmR3DataRead(pSSM, pGCPhys, sizeof(uint32_t));
     957#endif
     958}
     959
     960
     961static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhysV(PSSMHANDLE pSSM, RTGCPHYS volatile *pGCPhys)
     962{
     963    return pdmR3DevHlp_SSMGetGCPhys(pSSM, (PRTGCPHYS)pGCPhys);
     964}
     965
     966
     967static DECLCALLBACK(int) pdmR3DevHlp_SSMGetUInt(PSSMHANDLE pSSM, PRTUINT pu)
     968{
     969    return tstDevSsmR3DataRead(pSSM, pu, sizeof(*pu));
     970}
     971
     972
     973static DECLCALLBACK(int) pdmR3DevHlp_SSMGetSInt(PSSMHANDLE pSSM, PRTINT pi)
     974{
     975    return tstDevSsmR3DataRead(pSSM, pi, sizeof(*pi));
     976}
     977
     978
     979static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPtr(PSSMHANDLE pSSM, PRTGCPTR pGCPtr)
     980{
     981    return tstDevSsmR3DataRead(pSSM, pGCPtr, sizeof(*pGCPtr));
     982}
     983
     984
     985static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUInt(PSSMHANDLE pSSM, PRTGCUINT pu)
     986{
     987    return pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pu);
     988}
     989
     990
     991static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUIntReg(PSSMHANDLE pSSM, PRTGCUINTREG pu)
     992{
     993    AssertCompile(sizeof(RTGCPTR) == sizeof(*pu));
     994    return pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pu);
     995}
     996
     997
     998static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUIntPtr(PSSMHANDLE pSSM, PRTGCUINTPTR pGCPtr)
     999{
     1000    return pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pGCPtr);
     1001}
     1002
     1003
     1004static DECLCALLBACK(int) pdmR3DevHlp_SSMGetRCPtr(PSSMHANDLE pSSM, PRTRCPTR pRCPtr)
     1005{
     1006    return tstDevSsmR3DataRead(pSSM, pRCPtr, sizeof(*pRCPtr));
     1007}
     1008
     1009
     1010static DECLCALLBACK(int) pdmR3DevHlp_SSMGetIOPort(PSSMHANDLE pSSM, PRTIOPORT pIOPort)
     1011{
     1012    return tstDevSsmR3DataRead(pSSM, pIOPort, sizeof(*pIOPort));
     1013}
     1014
     1015
     1016static DECLCALLBACK(int) pdmR3DevHlp_SSMGetSel(PSSMHANDLE pSSM, PRTSEL pSel)
     1017{
     1018    return tstDevSsmR3DataRead(pSSM, pSel, sizeof(*pSel));
     1019}
     1020
     1021
     1022static DECLCALLBACK(int) pdmR3DevHlp_SSMGetMem(PSSMHANDLE pSSM, void *pv, size_t cb)
     1023{
     1024    return tstDevSsmR3DataRead(pSSM, pv, cb);
     1025}
     1026
     1027
     1028static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStrZEx(PSSMHANDLE pSSM, char *psz, size_t cbMax, size_t *pcbStr)
     1029{
     1030    /* read size prefix. */
     1031    uint32_t u32;
     1032    int rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32);
     1033    if (RT_SUCCESS(rc))
     1034    {
     1035        if (pcbStr)
     1036            *pcbStr = u32;
     1037        if (u32 < cbMax)
     1038        {
     1039            /* terminate and read string content. */
     1040            psz[u32] = '\0';
     1041            return tstDevSsmR3DataRead(pSSM, psz, u32);
     1042        }
     1043        return VERR_TOO_MUCH_DATA;
     1044    }
     1045    return rc;
     1046}
     1047
     1048
     1049static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStrZ(PSSMHANDLE pSSM, char *psz, size_t cbMax)
     1050{
     1051    return pdmR3DevHlp_SSMGetStrZEx(pSSM, psz, cbMax, NULL);
     1052}
     1053
     1054
     1055static DECLCALLBACK(int) pdmR3DevHlp_SSMSkip(PSSMHANDLE pSSM, size_t cb)
     1056{
     1057    while (cb > 0)
     1058    {
     1059        uint8_t abBuf[8192];
     1060        size_t  cbCur = RT_MIN(sizeof(abBuf), cb);
     1061        cb -= cbCur;
     1062        int rc = tstDevSsmR3DataRead(pSSM, abBuf, cbCur);
     1063        if (RT_FAILURE(rc))
     1064            return rc;
     1065    }
     1066
     1067    return VINF_SUCCESS;
     1068}
     1069
     1070
    6561071static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStruct(PSSMHANDLE pSSM, void *pvStruct, PCSSMFIELD paFields)
    6571072{
    658     RT_NOREF(pSSM, pvStruct, paFields);
    659     AssertFailed();
    660     return VERR_NOT_IMPLEMENTED;
     1073    AssertPtr(pvStruct);
     1074    AssertPtr(paFields);
     1075
     1076    /* begin marker. */
     1077    uint32_t u32Magic;
     1078    int rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32Magic);
     1079    if (RT_FAILURE(rc))
     1080        return rc;
     1081    AssertMsgReturn(u32Magic == SSMR3STRUCT_BEGIN, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
     1082
     1083    /* get the fields */
     1084    for (PCSSMFIELD pCur = paFields;
     1085         pCur->cb != UINT32_MAX && pCur->off != UINT32_MAX;
     1086         pCur++)
     1087    {
     1088        if (pCur->uFirstVer <= pSSM->uCurUnitVer)
     1089        {
     1090            uint8_t *pbField = (uint8_t *)pvStruct + pCur->off;
     1091            switch ((uintptr_t)pCur->pfnGetPutOrTransformer)
     1092            {
     1093                case SSMFIELDTRANS_NO_TRANSFORMATION:
     1094                    rc = tstDevSsmR3DataRead(pSSM, pbField, pCur->cb);
     1095                    break;
     1096
     1097                case SSMFIELDTRANS_GCPTR:
     1098                    AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1099                    rc = pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pbField);
     1100                    break;
     1101
     1102                case SSMFIELDTRANS_GCPHYS:
     1103                    AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPHYS), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1104                    rc = pdmR3DevHlp_SSMGetGCPhys(pSSM, (PRTGCPHYS)pbField);
     1105                    break;
     1106
     1107                case SSMFIELDTRANS_RCPTR:
     1108                    AssertMsgBreakStmt(pCur->cb == sizeof(RTRCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1109                    rc = pdmR3DevHlp_SSMGetRCPtr(pSSM, (PRTRCPTR)pbField);
     1110                    break;
     1111
     1112                case SSMFIELDTRANS_RCPTR_ARRAY:
     1113                {
     1114                    uint32_t const cEntries = pCur->cb / sizeof(RTRCPTR);
     1115                    AssertMsgBreakStmt(pCur->cb == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1116                    rc = VINF_SUCCESS;
     1117                    for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
     1118                        rc = pdmR3DevHlp_SSMGetRCPtr(pSSM, &((PRTRCPTR)pbField)[i]);
     1119                    break;
     1120                }
     1121
     1122                default:
     1123                    AssertMsgFailedBreakStmt(("%#x\n", pCur->pfnGetPutOrTransformer), rc = VERR_SSM_FIELD_COMPLEX);
     1124            }
     1125            if (RT_FAILURE(rc))
     1126            {
     1127                if (RT_SUCCESS(pSSM->rc))
     1128                    pSSM->rc = rc;
     1129                return rc;
     1130            }
     1131        }
     1132    }
     1133
     1134    /* end marker */
     1135    rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32Magic);
     1136    if (RT_FAILURE(rc))
     1137        return rc;
     1138    AssertMsgReturn(u32Magic == SSMR3STRUCT_END, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
     1139    return rc;
     1140}
     1141
     1142
     1143/**
     1144 * SSMR3GetStructEx helper that gets a HCPTR that is used as a NULL indicator.
     1145 *
     1146 * @returns VBox status code.
     1147 *
     1148 * @param   pSSM            The saved state handle.
     1149 * @param   ppv             Where to return the value (0/1).
     1150 * @param   fFlags          SSMSTRUCT_FLAGS_XXX.
     1151 */
     1152DECLINLINE(int) ssmR3GetHCPtrNI(PSSMHANDLE pSSM, void **ppv, uint32_t fFlags)
     1153{
     1154    uintptr_t uPtrNI;
     1155    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
     1156    {
     1157        if (ssmR3GetHostBits(pSSM) == 64)
     1158        {
     1159            uint64_t u;
     1160            int rc = tstDevSsmR3DataRead(pSSM, &u, sizeof(u));
     1161            if (RT_FAILURE(rc))
     1162                return rc;
     1163            uPtrNI = u ? 1 : 0;
     1164        }
     1165        else
     1166        {
     1167            uint32_t u;
     1168            int rc = tstDevSsmR3DataRead(pSSM, &u, sizeof(u));
     1169            if (RT_FAILURE(rc))
     1170                return rc;
     1171            uPtrNI = u ? 1 : 0;
     1172        }
     1173    }
     1174    else
     1175    {
     1176        bool f;
     1177        int rc = pdmR3DevHlp_SSMGetBool(pSSM, &f);
     1178        if (RT_FAILURE(rc))
     1179            return rc;
     1180        uPtrNI = f ? 1 : 0;
     1181    }
     1182    *ppv = (void *)uPtrNI;
     1183    return VINF_SUCCESS;
    6611184}
    6621185
    … …  
    6641187static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStructEx(PSSMHANDLE pSSM, void *pvStruct, size_t cbStruct, uint32_t fFlags, PCSSMFIELD paFields, void *pvUser)
    6651188{
    666     RT_NOREF(pSSM, pvStruct, cbStruct, fFlags, paFields, pvUser);
    667     AssertFailed();
    668     return VERR_NOT_IMPLEMENTED;
    669 }
    670 
    671 
    672 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetBool(PSSMHANDLE pSSM, bool *pfBool)
    673 {
    674     RT_NOREF(pSSM, pfBool);
    675     AssertFailed();
    676     return VERR_NOT_IMPLEMENTED;
    677 }
    678 
    679 
    680 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetBoolV(PSSMHANDLE pSSM, bool volatile *pfBool)
    681 {
    682     RT_NOREF(pSSM, pfBool);
    683     AssertFailed();
    684     return VERR_NOT_IMPLEMENTED;
    685 }
    686 
    687 
    688 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU8(PSSMHANDLE pSSM, uint8_t *pu8)
    689 {
    690     RT_NOREF(pSSM, pu8);
    691     AssertFailed();
    692     return VERR_NOT_IMPLEMENTED;
    693 }
    694 
    695 
    696 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU8V(PSSMHANDLE pSSM, uint8_t volatile *pu8)
    697 {
    698     RT_NOREF(pSSM, pu8);
    699     AssertFailed();
    700     return VERR_NOT_IMPLEMENTED;
    701 }
    702 
    703 
    704 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS8(PSSMHANDLE pSSM, int8_t *pi8)
    705 {
    706     RT_NOREF(pSSM, pi8);
    707     AssertFailed();
    708     return VERR_NOT_IMPLEMENTED;
    709 }
    710 
    711 
    712 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS8V(PSSMHANDLE pSSM, int8_t volatile *pi8)
    713 {
    714     RT_NOREF(pSSM, pi8);
    715     AssertFailed();
    716     return VERR_NOT_IMPLEMENTED;
    717 }
    718 
    719 
    720 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU16(PSSMHANDLE pSSM, uint16_t *pu16)
    721 {
    722     RT_NOREF(pSSM, pu16);
    723     AssertFailed();
    724     return VERR_NOT_IMPLEMENTED;
    725 }
    726 
    727 
    728 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU16V(PSSMHANDLE pSSM, uint16_t volatile *pu16)
    729 {
    730     RT_NOREF(pSSM, pu16);
    731     AssertFailed();
    732     return VERR_NOT_IMPLEMENTED;
    733 }
    734 
    735 
    736 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS16(PSSMHANDLE pSSM, int16_t *pi16)
    737 {
    738     RT_NOREF(pSSM, pi16);
    739     AssertFailed();
    740     return VERR_NOT_IMPLEMENTED;
    741 }
    742 
    743 
    744 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS16V(PSSMHANDLE pSSM, int16_t volatile *pi16)
    745 {
    746     RT_NOREF(pSSM, pi16);
    747     AssertFailed();
    748     return VERR_NOT_IMPLEMENTED;
    749 }
    750 
    751 
    752 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU32(PSSMHANDLE pSSM, uint32_t *pu32)
    753 {
    754     RT_NOREF(pSSM, pu32);
    755     AssertFailed();
    756     return VERR_NOT_IMPLEMENTED;
    757 }
    758 
    759 
    760 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU32V(PSSMHANDLE pSSM, uint32_t volatile *pu32)
    761 {
    762     RT_NOREF(pSSM, pu32);
    763     AssertFailed();
    764     return VERR_NOT_IMPLEMENTED;
    765 }
    766 
    767 
    768 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS32(PSSMHANDLE pSSM, int32_t *pi32)
    769 {
    770     RT_NOREF(pSSM, pi32);
    771     AssertFailed();
    772     return VERR_NOT_IMPLEMENTED;
    773 }
    774 
    775 
    776 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS32V(PSSMHANDLE pSSM, int32_t volatile *pi32)
    777 {
    778     RT_NOREF(pSSM, pi32);
    779     AssertFailed();
    780     return VERR_NOT_IMPLEMENTED;
    781 }
    782 
    783 
    784 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU64(PSSMHANDLE pSSM, uint64_t *pu64)
    785 {
    786     RT_NOREF(pSSM, pu64);
    787     AssertFailed();
    788     return VERR_NOT_IMPLEMENTED;
    789 }
    790 
    791 
    792 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU64V(PSSMHANDLE pSSM, uint64_t volatile *pu64)
    793 {
    794     RT_NOREF(pSSM, pu64);
    795     AssertFailed();
    796     return VERR_NOT_IMPLEMENTED;
    797 }
    798 
    799 
    800 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS64(PSSMHANDLE pSSM, int64_t *pi64)
    801 {
    802     RT_NOREF(pSSM, pi64);
    803     AssertFailed();
    804     return VERR_NOT_IMPLEMENTED;
    805 }
    806 
    807 
    808 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS64V(PSSMHANDLE pSSM, int64_t volatile *pi64)
    809 {
    810     RT_NOREF(pSSM, pi64);
    811     AssertFailed();
    812     return VERR_NOT_IMPLEMENTED;
    813 }
    814 
    815 
    816 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU128(PSSMHANDLE pSSM, uint128_t *pu128)
    817 {
    818     RT_NOREF(pSSM, pu128);
    819     AssertFailed();
    820     return VERR_NOT_IMPLEMENTED;
    821 }
    822 
    823 
    824 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU128V(PSSMHANDLE pSSM, uint128_t volatile *pu128)
    825 {
    826     RT_NOREF(pSSM, pu128);
    827     AssertFailed();
    828     return VERR_NOT_IMPLEMENTED;
    829 }
    830 
    831 
    832 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS128(PSSMHANDLE pSSM, int128_t *pi128)
    833 {
    834     RT_NOREF(pSSM, pi128);
    835     AssertFailed();
    836     return VERR_NOT_IMPLEMENTED;
    837 }
    838 
    839 
    840 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS128V(PSSMHANDLE pSSM, int128_t  volatile *pi128)
    841 {
    842     RT_NOREF(pSSM, pi128);
    843     AssertFailed();
    844     return VERR_NOT_IMPLEMENTED;
    845 }
    846 
    847 
    848 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys32(PSSMHANDLE pSSM, PRTGCPHYS32 pGCPhys)
    849 {
    850     RT_NOREF(pSSM, pGCPhys);
    851     AssertFailed();
    852     return VERR_NOT_IMPLEMENTED;
    853 }
    854 
    855 
    856 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys32V(PSSMHANDLE pSSM, RTGCPHYS32 volatile *pGCPhys)
    857 {
    858     RT_NOREF(pSSM, pGCPhys);
    859     AssertFailed();
    860     return VERR_NOT_IMPLEMENTED;
    861 }
    862 
    863 
    864 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys64(PSSMHANDLE pSSM, PRTGCPHYS64 pGCPhys)
    865 {
    866     RT_NOREF(pSSM, pGCPhys);
    867     AssertFailed();
    868     return VERR_NOT_IMPLEMENTED;
    869 }
    870 
    871 
    872 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys64V(PSSMHANDLE pSSM, RTGCPHYS64 volatile *pGCPhys)
    873 {
    874     RT_NOREF(pSSM, pGCPhys);
    875     AssertFailed();
    876     return VERR_NOT_IMPLEMENTED;
    877 }
    878 
    879 
    880 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys(PSSMHANDLE pSSM, PRTGCPHYS pGCPhys)
    881 {
    882     RT_NOREF(pSSM, pGCPhys);
    883     AssertFailed();
    884     return VERR_NOT_IMPLEMENTED;
    885 }
    886 
    887 
    888 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhysV(PSSMHANDLE pSSM, RTGCPHYS volatile *pGCPhys)
    889 {
    890     RT_NOREF(pSSM, pGCPhys);
    891     AssertFailed();
    892     return VERR_NOT_IMPLEMENTED;
    893 }
    894 
    895 
    896 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetUInt(PSSMHANDLE pSSM, PRTUINT pu)
    897 {
    898     RT_NOREF(pSSM, pu);
    899     AssertFailed();
    900     return VERR_NOT_IMPLEMENTED;
    901 }
    902 
    903 
    904 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetSInt(PSSMHANDLE pSSM, PRTINT pi)
    905 {
    906     RT_NOREF(pSSM, pi);
    907     AssertFailed();
    908     return VERR_NOT_IMPLEMENTED;
    909 }
    910 
    911 
    912 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUInt(PSSMHANDLE pSSM, PRTGCUINT pu)
    913 {
    914     RT_NOREF(pSSM, pu);
    915     AssertFailed();
    916     return VERR_NOT_IMPLEMENTED;
    917 }
    918 
    919 
    920 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUIntReg(PSSMHANDLE pSSM, PRTGCUINTREG pu)
    921 {
    922     RT_NOREF(pSSM, pu);
    923     AssertFailed();
    924     return VERR_NOT_IMPLEMENTED;
    925 }
    926 
    927 
    928 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPtr(PSSMHANDLE pSSM, PRTGCPTR pGCPtr)
    929 {
    930     RT_NOREF(pSSM, pGCPtr);
    931     AssertFailed();
    932     return VERR_NOT_IMPLEMENTED;
    933 }
    934 
    935 
    936 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUIntPtr(PSSMHANDLE pSSM, PRTGCUINTPTR pGCPtr)
    937 {
    938     RT_NOREF(pSSM, pGCPtr);
    939     AssertFailed();
    940     return VERR_NOT_IMPLEMENTED;
    941 }
    942 
    943 
    944 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetRCPtr(PSSMHANDLE pSSM, PRTRCPTR pRCPtr)
    945 {
    946     RT_NOREF(pSSM, pRCPtr);
    947     AssertFailed();
    948     return VERR_NOT_IMPLEMENTED;
    949 }
    950 
    951 
    952 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetIOPort(PSSMHANDLE pSSM, PRTIOPORT pIOPort)
    953 {
    954     RT_NOREF(pSSM, pIOPort);
    955     AssertFailed();
    956     return VERR_NOT_IMPLEMENTED;
    957 }
    958 
    959 
    960 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetSel(PSSMHANDLE pSSM, PRTSEL pSel)
    961 {
    962     RT_NOREF(pSSM, pSel);
    963     AssertFailed();
    964     return VERR_NOT_IMPLEMENTED;
    965 }
    966 
    967 
    968 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetMem(PSSMHANDLE pSSM, void *pv, size_t cb)
    969 {
    970     RT_NOREF(pSSM, pv, cb);
    971     AssertFailed();
    972     return VERR_NOT_IMPLEMENTED;
    973 }
    974 
    975 
    976 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStrZ(PSSMHANDLE pSSM, char *psz, size_t cbMax)
    977 {
    978     RT_NOREF(pSSM, psz, cbMax);
    979     AssertFailed();
    980     return VERR_NOT_IMPLEMENTED;
    981 }
    982 
    983 
    984 static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStrZEx(PSSMHANDLE pSSM, char *psz, size_t cbMax, size_t *pcbStr)
    985 {
    986     RT_NOREF(pSSM, psz,cbMax, pcbStr);
    987     AssertFailed();
    988     return VERR_NOT_IMPLEMENTED;
    989 }
    990 
    991 
    992 static DECLCALLBACK(int) pdmR3DevHlp_SSMSkip(PSSMHANDLE pSSM, size_t cb)
    993 {
    994     RT_NOREF(pSSM, cb);
    995     AssertFailed();
    996     return VERR_NOT_IMPLEMENTED;
     1189    int         rc;
     1190    uint32_t    u32Magic;
     1191
     1192    /*
     1193     * Validation.
     1194     */
     1195    AssertMsgReturn(!(fFlags & ~SSMSTRUCT_FLAGS_VALID_MASK), ("%#x\n", fFlags), pSSM->rc = VERR_INVALID_PARAMETER);
     1196    AssertPtr(pvStruct);
     1197    AssertPtr(paFields);
     1198
     1199    /*
     1200     * Begin marker.
     1201     */
     1202    if (!(fFlags & (SSMSTRUCT_FLAGS_NO_MARKERS | SSMSTRUCT_FLAGS_NO_LEAD_MARKER)))
     1203    {
     1204        rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32Magic);
     1205        if (RT_FAILURE(rc))
     1206            return rc;
     1207        AssertMsgReturn(u32Magic == SSMR3STRUCT_BEGIN, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
     1208    }
     1209
     1210    /*
     1211     * Put the fields
     1212     */
     1213    rc = VINF_SUCCESS;
     1214    uint32_t off = 0;
     1215    for (PCSSMFIELD pCur = paFields;
     1216         pCur->cb != UINT32_MAX && pCur->off != UINT32_MAX;
     1217         pCur++)
     1218    {
     1219        uint32_t const offField =    (!SSMFIELDTRANS_IS_PADDING(pCur->pfnGetPutOrTransformer) || pCur->off != UINT32_MAX / 2)
     1220                                  &&  !SSMFIELDTRANS_IS_OLD(pCur->pfnGetPutOrTransformer)
     1221                                ? pCur->off
     1222                                : off;
     1223        uint32_t const cbField  = SSMFIELDTRANS_IS_OLD(pCur->pfnGetPutOrTransformer)
     1224                                ? 0
     1225                                : SSMFIELDTRANS_IS_PADDING(pCur->pfnGetPutOrTransformer)
     1226                                ? RT_HIWORD(pCur->cb)
     1227                                : pCur->cb;
     1228        AssertMsgReturn(   cbField            <= cbStruct
     1229                        && offField + cbField <= cbStruct
     1230                        && offField + cbField >= offField,
     1231                        ("off=%#x cb=%#x cbStruct=%#x (%s)\n", cbField, offField, cbStruct, pCur->pszName),
     1232                        pSSM->rc = VERR_SSM_FIELD_OUT_OF_BOUNDS);
     1233        AssertMsgReturn(    !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
     1234                        || off == offField,
     1235                        ("off=%#x offField=%#x (%s)\n", off, offField, pCur->pszName),
     1236                        pSSM->rc = VERR_SSM_FIELD_NOT_CONSECUTIVE);
     1237
     1238        if (pCur->uFirstVer <= pSSM->uCurUnitVer)
     1239        {
     1240            rc = VINF_SUCCESS;
     1241            uint8_t       *pbField  = (uint8_t *)pvStruct + offField;
     1242            switch ((uintptr_t)pCur->pfnGetPutOrTransformer)
     1243            {
     1244                case SSMFIELDTRANS_NO_TRANSFORMATION:
     1245                    rc = tstDevSsmR3DataRead(pSSM, pbField, cbField);
     1246                    break;
     1247
     1248                case SSMFIELDTRANS_GCPHYS:
     1249                    AssertMsgBreakStmt(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1250                    rc = pdmR3DevHlp_SSMGetGCPhys(pSSM, (PRTGCPHYS)pbField);
     1251                    break;
     1252
     1253                case SSMFIELDTRANS_GCPTR:
     1254                    AssertMsgBreakStmt(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1255                    rc = pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pbField);
     1256                    break;
     1257
     1258                case SSMFIELDTRANS_RCPTR:
     1259                    AssertMsgBreakStmt(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1260                    rc = pdmR3DevHlp_SSMGetRCPtr(pSSM, (PRTRCPTR)pbField);
     1261                    break;
     1262
     1263                case SSMFIELDTRANS_RCPTR_ARRAY:
     1264                {
     1265                    uint32_t const cEntries = cbField / sizeof(RTRCPTR);
     1266                    AssertMsgBreakStmt(cbField == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1267                    rc = VINF_SUCCESS;
     1268                    for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
     1269                        rc = pdmR3DevHlp_SSMGetRCPtr(pSSM, &((PRTRCPTR)pbField)[i]);
     1270                    break;
     1271                }
     1272
     1273                case SSMFIELDTRANS_HCPTR_NI:
     1274                    AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1275                    rc = ssmR3GetHCPtrNI(pSSM, (void **)pbField, fFlags);
     1276                    break;
     1277
     1278                case SSMFIELDTRANS_HCPTR_NI_ARRAY:
     1279                {
     1280                    uint32_t const cEntries = cbField / sizeof(void *);
     1281                    AssertMsgBreakStmt(cbField == cEntries * sizeof(void *) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1282                    rc = VINF_SUCCESS;
     1283                    for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
     1284                        rc = ssmR3GetHCPtrNI(pSSM, &((void **)pbField)[i], fFlags);
     1285                    break;
     1286                }
     1287
     1288                case SSMFIELDTRANS_HCPTR_HACK_U32:
     1289                    AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1290                    *(uintptr_t *)pbField = 0;
     1291                    rc = tstDevSsmR3DataRead(pSSM, pbField, sizeof(uint32_t));
     1292                    if ((fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE) && ssmR3GetHostBits(pSSM) == 64)
     1293                    {
     1294                        uint32_t u32;
     1295                        rc = tstDevSsmR3DataRead(pSSM, &u32, sizeof(uint32_t));
     1296                        AssertMsgBreakStmt(RT_FAILURE(rc) || u32 == 0 || (fFlags & SSMSTRUCT_FLAGS_SAVED_AS_MEM),
     1297                                           ("high=%#x low=%#x (%s)\n", u32, *(uint32_t *)pbField, pCur->pszName),
     1298                                           rc = VERR_SSM_FIELD_INVALID_VALUE);
     1299                    }
     1300                    break;
     1301
     1302                case SSMFIELDTRANS_U32_ZX_U64:
     1303                    AssertMsgBreakStmt(cbField == sizeof(uint64_t), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1304                    ((uint32_t *)pbField)[1] = 0;
     1305                    rc = pdmR3DevHlp_SSMGetU32(pSSM, (uint32_t *)pbField);
     1306                    break;
     1307
     1308
     1309                case SSMFIELDTRANS_IGNORE:
     1310                    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
     1311                        rc = pdmR3DevHlp_SSMSkip(pSSM, cbField);
     1312                    break;
     1313
     1314                case SSMFIELDTRANS_IGN_GCPHYS:
     1315                    AssertMsgBreakStmt(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1316                    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
     1317                        rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTGCPHYS));
     1318                    break;
     1319
     1320                case SSMFIELDTRANS_IGN_GCPTR:
     1321                    AssertMsgBreakStmt(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1322                    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
     1323                        rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTGCPTR));
     1324                    break;
     1325
     1326                case SSMFIELDTRANS_IGN_RCPTR:
     1327                    AssertMsgBreakStmt(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1328                    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
     1329                        rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTRCPTR));
     1330                    break;
     1331
     1332                case SSMFIELDTRANS_IGN_HCPTR:
     1333                    AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1334                    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
     1335                        rc = pdmR3DevHlp_SSMSkip(pSSM, ssmR3GetHostBits(pSSM) / 8);
     1336                    break;
     1337
     1338
     1339                case SSMFIELDTRANS_OLD:
     1340                    AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1341                    rc = pdmR3DevHlp_SSMSkip(pSSM, pCur->cb);
     1342                    break;
     1343
     1344                case SSMFIELDTRANS_OLD_GCPHYS:
     1345                    AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPHYS) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1346                    rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTGCPHYS));
     1347                    break;
     1348
     1349                case SSMFIELDTRANS_OLD_GCPTR:
     1350                    AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPTR) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1351                    rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTGCPTR));
     1352                    break;
     1353
     1354                case SSMFIELDTRANS_OLD_RCPTR:
     1355                    AssertMsgBreakStmt(pCur->cb == sizeof(RTRCPTR) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1356                    rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTRCPTR));
     1357                    break;
     1358
     1359                case SSMFIELDTRANS_OLD_HCPTR:
     1360                    AssertMsgBreakStmt(pCur->cb == sizeof(void *) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1361                    rc = pdmR3DevHlp_SSMSkip(pSSM, ssmR3GetHostBits(pSSM) / 8);
     1362                    break;
     1363
     1364                case SSMFIELDTRANS_OLD_PAD_HC:
     1365                    AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1366                    rc = pdmR3DevHlp_SSMSkip(pSSM, ssmR3GetHostBits(pSSM) == 64 ? RT_HIWORD(pCur->cb) : RT_LOWORD(pCur->cb));
     1367                    break;
     1368
     1369                case SSMFIELDTRANS_OLD_PAD_MSC32:
     1370                    AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
     1371                    if (ssmR3IsHostMsc32(pSSM))
     1372                        rc = pdmR3DevHlp_SSMSkip(pSSM, pCur->cb);
     1373                    break;
     1374
     1375
     1376                case SSMFIELDTRANS_PAD_HC:
     1377                case SSMFIELDTRANS_PAD_HC32:
     1378                case SSMFIELDTRANS_PAD_HC64:
     1379                case SSMFIELDTRANS_PAD_HC_AUTO:
     1380                case SSMFIELDTRANS_PAD_MSC32_AUTO:
     1381                {
     1382                    uint32_t cb32    = RT_BYTE1(pCur->cb);
     1383                    uint32_t cb64    = RT_BYTE2(pCur->cb);
     1384                    uint32_t cbCtx   =    HC_ARCH_BITS == 64
     1385                                       || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_MSC32_AUTO
     1386                                     ? cb64 : cb32;
     1387                    uint32_t cbSaved =    ssmR3GetHostBits(pSSM) == 64
     1388                                       || (   (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_MSC32_AUTO
     1389                                           && !ssmR3IsHostMsc32(pSSM))
     1390                                     ? cb64 : cb32;
     1391                    AssertMsgBreakStmt(    cbField == cbCtx
     1392                                       &&  (   (   pCur->off == UINT32_MAX / 2
     1393                                                && (   cbField == 0
     1394                                                    || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_HC_AUTO
     1395                                                    || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_MSC32_AUTO
     1396                                                   )
     1397                                               )
     1398                                            || (pCur->off != UINT32_MAX / 2 && cbField != 0)
     1399                                            )
     1400                                       , ("cbField=%#x cb32=%#x cb64=%#x HC_ARCH_BITS=%u cbCtx=%#x cbSaved=%#x off=%#x\n",
     1401                                          cbField, cb32, cb64, HC_ARCH_BITS, cbCtx, cbSaved, pCur->off),
     1402                                       rc = VERR_SSM_FIELD_INVALID_PADDING_SIZE);
     1403                    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
     1404                        rc = pdmR3DevHlp_SSMSkip(pSSM, cbSaved);
     1405                    break;
     1406                }
     1407
     1408                default:
     1409                    AssertBreakStmt(pCur->pfnGetPutOrTransformer, rc = VERR_SSM_FIELD_INVALID_CALLBACK);
     1410                    rc = pCur->pfnGetPutOrTransformer(pSSM, pCur, pvStruct, fFlags, true /*fGetOrPut*/, pvUser);
     1411                    break;
     1412            }
     1413            if (RT_FAILURE(rc))
     1414                break;
     1415        }
     1416
     1417        off = offField + cbField;
     1418    }
     1419
     1420    if (RT_SUCCESS(rc))
     1421        AssertMsgStmt(   !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
     1422                      || off == cbStruct,
     1423                      ("off=%#x cbStruct=%#x\n", off, cbStruct),
     1424                      rc = VERR_SSM_FIELD_NOT_CONSECUTIVE);
     1425
     1426    if (RT_FAILURE(rc))
     1427    {
     1428        if (RT_SUCCESS(pSSM->rc))
     1429            pSSM->rc = rc;
     1430        return rc;
     1431    }
     1432
     1433    /*
     1434     * End marker
     1435     */
     1436    if (!(fFlags & (SSMSTRUCT_FLAGS_NO_MARKERS | SSMSTRUCT_FLAGS_NO_TAIL_MARKER)))
     1437    {
     1438        rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32Magic);
     1439        if (RT_FAILURE(rc))
     1440            return rc;
     1441        AssertMsgReturn(u32Magic == SSMR3STRUCT_END, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
     1442    }
     1443
     1444    return VINF_SUCCESS;
    9971445}
    9981446
    … …  
    10251473{
    10261474    RT_NOREF(pSSM, RT_SRC_POS_ARGS, pszFormat);
    1027     AssertFailed();
    1028     return VERR_NOT_IMPLEMENTED;
     1475    pSSM->rc = VERR_SSM_LOAD_CONFIG_MISMATCH;
     1476    return pSSM->rc;
    10291477}
    10301478
    … …  
    10331481{
    10341482    RT_NOREF(pSSM, RT_SRC_POS_ARGS, pszFormat, va);
    1035     AssertFailed();
    1036     return VERR_NOT_IMPLEMENTED;
     1483    pSSM->rc = VERR_SSM_LOAD_CONFIG_MISMATCH;
     1484    return pSSM->rc;
    10371485}
    10381486
    … …  
    10411489{
    10421490    RT_NOREF(pSSM);
    1043     AssertFailed();
    1044     return VERR_NOT_IMPLEMENTED;
     1491    return pSSM->rc;
    10451492}
    10461493
    … …  
    12421689{
    12431690    RT_NOREF(pDevIns, hTimer, rcBusy);
    1244     int rc = VERR_NOT_IMPLEMENTED;
    1245     AssertFailed();
     1691
     1692#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     1693    int rc = VERR_NOT_IMPLEMENTED;
     1694    AssertFailed();
     1695#else
     1696    int rc = VINF_SUCCESS;
     1697#endif
    12461698    return rc;
    12471699}
    … …  
    12531705{
    12541706    RT_NOREF(pDevIns, hTimer, pCritSect, rcBusy);
    1255     int rc = VERR_NOT_IMPLEMENTED;
    1256     AssertFailed();
     1707
     1708#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     1709    int rc = VERR_NOT_IMPLEMENTED;
     1710    AssertFailed();
     1711#else
     1712    int rc = VINF_SUCCESS;
     1713#endif
    12571714    return rc;
    12581715}
    … …  
    12631720{
    12641721    RT_NOREF(pDevIns, hTimer, uExpire);
    1265     int rc = VERR_NOT_IMPLEMENTED;
    1266     AssertFailed();
     1722
     1723#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     1724    int rc = VERR_NOT_IMPLEMENTED;
     1725    AssertFailed();
     1726#else
     1727    int rc = VINF_SUCCESS;
     1728#endif
     1729
    12671730    return rc;
    12681731}
    … …  
    12731736{
    12741737    RT_NOREF(pDevIns, hTimer, uHz);
    1275     int rc = VERR_NOT_IMPLEMENTED;
    1276     AssertFailed();
     1738
     1739#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     1740    int rc = VERR_NOT_IMPLEMENTED;
     1741    AssertFailed();
     1742#else
     1743    int rc = VINF_SUCCESS;
     1744#endif
     1745
    12771746    return rc;
    12781747}
    … …  
    12831752{
    12841753    RT_NOREF(pDevIns, hTimer, cMicrosToNext);
    1285     int rc = VERR_NOT_IMPLEMENTED;
    1286     AssertFailed();
     1754
     1755#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     1756    int rc = VERR_NOT_IMPLEMENTED;
     1757    AssertFailed();
     1758#else
     1759    int rc = VINF_SUCCESS;
     1760#endif
    12871761    return rc;
    12881762}
    … …  
    12931767{
    12941768    RT_NOREF(pDevIns, hTimer, cMilliesToNext);
    1295     int rc = VERR_NOT_IMPLEMENTED;
    1296     AssertFailed();
     1769
     1770#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     1771    int rc = VERR_NOT_IMPLEMENTED;
     1772    AssertFailed();
     1773#else
     1774    int rc = VINF_SUCCESS;
     1775#endif
    12971776    return rc;
    12981777}
    … …  
    13031782{
    13041783    RT_NOREF(pDevIns, hTimer, cNanosToNext);
    1305     int rc = VERR_NOT_IMPLEMENTED;
    1306     AssertFailed();
     1784
     1785#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     1786    int rc = VERR_NOT_IMPLEMENTED;
     1787    AssertFailed();
     1788#else
     1789    int rc = VINF_SUCCESS;
     1790#endif
     1791
    13071792    return rc;
    13081793}
    … …  
    13131798{
    13141799    RT_NOREF(pDevIns, hTimer, cTicksToNext, pu64Now);
    1315     int rc = VERR_NOT_IMPLEMENTED;
    1316     AssertFailed();
     1800
     1801#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     1802    int rc = VERR_NOT_IMPLEMENTED;
     1803    AssertFailed();
     1804#else
     1805    int rc = VINF_SUCCESS;
     1806#endif
     1807
    13171808    return rc;
    13181809}
    … …  
    13751866static DECLCALLBACK(int) pdmR3DevHlp_TimerLoad(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
    13761867{
    1377     RT_NOREF(pDevIns, hTimer, pSSM);
    1378     int rc = VERR_NOT_IMPLEMENTED;
    1379     AssertFailed();
    1380     return rc;
     1868    RT_NOREF(pDevIns, hTimer);
     1869
     1870/** @name Saved state values (comes directly from TM.cpp)
     1871 * @{ */
     1872#define TMTIMERSTATE_SAVED_PENDING_STOP         4
     1873#define TMTIMERSTATE_SAVED_PENDING_SCHEDULE     7
     1874/** @}  */
     1875
     1876    /*
     1877     * Load the state and validate it.
     1878     */
     1879    uint8_t u8State;
     1880    int rc = pdmR3DevHlp_SSMGetU8(pSSM, &u8State);
     1881    if (RT_FAILURE(rc))
     1882        return rc;
     1883
     1884    /* TMTIMERSTATE_SAVED_XXX: Workaround for accidental state shift in r47786 (2009-05-26 19:12:12). */
     1885    if (    u8State == TMTIMERSTATE_SAVED_PENDING_STOP + 1
     1886        ||  u8State == TMTIMERSTATE_SAVED_PENDING_SCHEDULE + 1)
     1887        u8State--;
     1888
     1889    if (    u8State != TMTIMERSTATE_SAVED_PENDING_STOP
     1890        &&  u8State != TMTIMERSTATE_SAVED_PENDING_SCHEDULE)
     1891    {
     1892        /*AssertLogRelMsgFailed(("u8State=%d\n", u8State));*/
     1893        return VERR_TM_LOAD_STATE;
     1894    }
     1895
     1896    if (u8State == TMTIMERSTATE_SAVED_PENDING_SCHEDULE)
     1897    {
     1898        /*
     1899         * Load the expire time.
     1900         */
     1901        uint64_t u64Expire;
     1902        rc = pdmR3DevHlp_SSMGetU64(pSSM, &u64Expire);
     1903        if (RT_FAILURE(rc))
     1904            return rc;
     1905
     1906        /*
     1907         * Set it.
     1908         */
     1909        Log(("u8State=%d u64Expire=%llu\n", u8State, u64Expire));
     1910    }
     1911
     1912    return VINF_SUCCESS;
    13811913}
    13821914
    … …  
    15572089{
    15582090    RT_NOREF(pNode, pszName, pvData, cbData);
    1559     AssertFailed();
    1560     return VERR_NOT_IMPLEMENTED;
     2091
     2092#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     2093    AssertFailed();
     2094    return VERR_NOT_IMPLEMENTED;
     2095#else
     2096    memset(pvData, 0, cbData);
     2097    return VINF_SUCCESS;
     2098#endif
    15612099}
    15622100
    … …  
    18932431{
    18942432    RT_NOREF(pNode, pszName, ppszString);
    1895     AssertFailed();
    1896     return VERR_NOT_IMPLEMENTED;
     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
    18972439}
    18982440
    … …  
    19012443{
    19022444    RT_NOREF(pNode, pszName, ppszString, pszDef);
    1903     AssertFailed();
    1904     return VERR_NOT_IMPLEMENTED;
     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
    19052451}
    19062452
    … …  
    23252871    LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
    23262872
     2873#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    23272874    void *pv = NULL;
    23282875    AssertFailed();
     2876#else
     2877    void *pv = RTMemAlloc(cb);
     2878#endif
    23292879
    23302880    LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
    … …  
    23392889    LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
    23402890
     2891#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    23412892    void *pv = NULL;
    23422893    AssertFailed();
     2894#else
     2895    void *pv = RTMemAllocZ(cb);
     2896#endif
    23432897
    23442898    LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
    … …  
    23532907    LogFlow(("pdmR3DevHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
    23542908
     2909#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    23552910    PTSTDEVMMHEAPALLOC pHeapAlloc = (PTSTDEVMMHEAPALLOC)((uint8_t *)pv - RT_UOFFSETOF(TSTDEVMMHEAPALLOC, abAlloc[0]));
    23562911    PTSTDEVDUTINT pThis = pHeapAlloc->pDut;
    … …  
    23632918    memset(&pHeapAlloc->abAlloc[0], 0xfc, pHeapAlloc->cbAlloc);
    23642919    RTMemFree(pHeapAlloc);
     2920#else
     2921    RTMemFree(pv);
     2922#endif
    23652923
    23662924    LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
    … …  
    23882946
    23892947    bool fRc = false;
    2390     AssertFailed();
     2948
     2949#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     2950    AssertFailed();
     2951#endif
    23912952
    23922953    LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szName, pDevIns->iInstance,
    … …  
    24733034             pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
    24743035
    2475     int rc = VERR_NOT_IMPLEMENTED;
    2476     AssertFailed();
     3036#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3037    int rc = VERR_NOT_IMPLEMENTED;
     3038    AssertFailed();
     3039#else
     3040    int rc = VINF_SUCCESS;
     3041#endif
     3042
    24773043
    24783044    LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    24883054             pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
    24893055
    2490     int rc = VERR_NOT_IMPLEMENTED;
    2491     AssertFailed();
     3056#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3057    int rc = VERR_NOT_IMPLEMENTED;
     3058    AssertFailed();
     3059#else
     3060    int rc = VINF_SUCCESS;
     3061#endif
    24923062
    24933063    LogFlow(("pdmR3DevHlp_DBGFInfoRegisterArgv: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    25293099
    25303100    RT_NOREF(pDevIns, pvSample, enmType, pszName, enmUnit, pszDesc);
    2531     AssertFailed();
     3101
     3102#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3103    AssertFailed();
     3104#endif
    25323105}
    25333106
    … …  
    25403113
    25413114    RT_NOREF(pDevIns, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
    2542     AssertFailed();
     3115
     3116#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3117    AssertFailed();
     3118#endif
    25433119}
    25443120
    … …  
    25893165#endif
    25903166
    2591     int rc = VERR_NOT_IMPLEMENTED;
    2592     AssertFailed();
     3167#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3168    int rc = VERR_NOT_IMPLEMENTED;
     3169    AssertFailed();
     3170#else
     3171    int rc = VINF_SUCCESS;
     3172#endif
    25933173
    25943174    LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    26163196                          VERR_INVALID_FLAGS);
    26173197
    2618     int rc = VERR_NOT_IMPLEMENTED;
    2619     AssertFailed();
     3198#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3199    int rc = VERR_NOT_IMPLEMENTED;
     3200    AssertFailed();
     3201#else
     3202    int rc = VINF_SUCCESS;
     3203#endif
     3204
    26203205
    26213206    LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    26353220    LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%d cbRegion=%RGp enmType=%d fFlags=%#x, hHandle=%#RX64 pfnMapUnmap=%p\n",
    26363221             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iRegion, cbRegion, enmType, fFlags, hHandle, pfnMapUnmap));
     3222
     3223#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    26373224    PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
     3225#endif
    26383226
    26393227    /*
    … …  
    26933281
    26943282    AssertMsgReturn(!(fFlags & ~PDMPCIDEV_IORGN_F_VALID_MASK), ("fFlags=%#x\n", fFlags), VERR_INVALID_FLAGS);
    2695     int rc = VERR_NOT_IMPLEMENTED;
    2696     AssertFailed();
     3283#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3284    int rc = VERR_NOT_IMPLEMENTED;
     3285    AssertFailed();
     3286#else
     3287    int rc = VINF_SUCCESS;
     3288#endif
    26973289
    26983290    LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    27113303    LogFlow(("pdmR3DevHlp_PCIInterceptConfigAccesses: caller='%s'/%d: pPciDev=%p pfnRead=%p pfnWrite=%p\n",
    27123304             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pfnRead, pfnWrite));
     3305
     3306#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    27133307    PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
    27143308
    27153309    int rc = VERR_NOT_IMPLEMENTED;
    27163310    AssertFailed();
     3311#else
     3312    int rc = VINF_SUCCESS;
     3313#endif
    27173314
    27183315    LogFlow(("pdmR3DevHlp_PCIInterceptConfigAccesses: caller='%s'/%d: returns %Rrc\n",
    … …  
    28963493
    28973494#if 1
    2898     int rc = VERR_PDM_NO_ATTACHED_DRIVER;
     3495    int rc = VINF_SUCCESS;
     3496    if (iLun == PDM_STATUS_LUN)
     3497        *ppBaseInterface = &pDevIns->Internal.s.pDut->IBaseSts;
     3498    else
     3499        rc = VERR_PDM_NO_ATTACHED_DRIVER;
    28993500#else
    29003501    int rc = VERR_NOT_IMPLEMENTED;
    … …  
    30423643
    30433644    RT_NOREF(pDevIns, fFlags, pszName, pfnCallback, pvUser, phTask);
    3044     int rc = VERR_NOT_IMPLEMENTED;
    3045     AssertFailed();
     3645#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3646    int rc = VERR_NOT_IMPLEMENTED;
     3647    AssertFailed();
     3648#else
     3649    int rc = VINF_SUCCESS;
     3650#endif
    30463651
    30473652    LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    30573662
    30583663    RT_NOREF(pDevIns, hTask);
    3059     int rc = VERR_NOT_IMPLEMENTED;
    3060     AssertFailed();
     3664#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3665    int rc = VERR_NOT_IMPLEMENTED;
     3666    AssertFailed();
     3667#else
     3668    int rc = VINF_SUCCESS;
     3669#endif
    30613670
    30623671    LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    30723681
    30733682    RT_NOREF(pDevIns, phEvent);
    3074     int rc = VERR_NOT_IMPLEMENTED;
    3075     AssertFailed();
     3683#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3684    int rc = VERR_NOT_IMPLEMENTED;
     3685    AssertFailed();
     3686#else
     3687    int rc = VINF_SUCCESS;
     3688#endif
    30763689
    30773690    LogFlow(("pdmR3DevHlp_SUPSemEventCreate: caller='%s'/%d: returns %Rrc *phEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *phEvent));
    … …  
    30873700
    30883701    RT_NOREF(pDevIns, hEvent);
    3089     int rc = VERR_NOT_IMPLEMENTED;
    3090     AssertFailed();
     3702#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3703    int rc = VERR_NOT_IMPLEMENTED;
     3704    AssertFailed();
     3705#else
     3706    int rc = VINF_SUCCESS;
     3707#endif
    30913708
    30923709    LogFlow(("pdmR3DevHlp_SUPSemEventClose: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    31023719
    31033720    RT_NOREF(pDevIns, hEvent);
    3104     int rc = VERR_NOT_IMPLEMENTED;
    3105     AssertFailed();
     3721#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3722    int rc = VERR_NOT_IMPLEMENTED;
     3723    AssertFailed();
     3724#else
     3725    int rc = VINF_SUCCESS;
     3726#endif
    31063727
    31073728    LogFlow(("pdmR3DevHlp_SUPSemEventSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    31183739
    31193740    RT_NOREF(pDevIns, hEvent, cMillies);
    3120     int rc = VERR_NOT_IMPLEMENTED;
    3121     AssertFailed();
     3741#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3742    int rc = VERR_NOT_IMPLEMENTED;
     3743    AssertFailed();
     3744#else
     3745    int rc = VINF_SUCCESS;
     3746#endif
    31223747
    31233748    LogFlow(("pdmR3DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    31343759
    31353760    RT_NOREF(pDevIns, hEvent, uNsTimeout);
    3136     int rc = VERR_NOT_IMPLEMENTED;
    3137     AssertFailed();
     3761#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3762    int rc = VERR_NOT_IMPLEMENTED;
     3763    AssertFailed();
     3764#else
     3765    int rc = VINF_SUCCESS;
     3766#endif
    31383767
    31393768    LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    31503779
    31513780    RT_NOREF(pDevIns, hEvent, cNsTimeout);
    3152     int rc = VERR_NOT_IMPLEMENTED;
    3153     AssertFailed();
     3781#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3782    int rc = VERR_NOT_IMPLEMENTED;
     3783    AssertFailed();
     3784#else
     3785    int rc = VINF_SUCCESS;
     3786#endif
    31543787
    31553788    LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    31803813
    31813814    RT_NOREF(pDevIns, phEventMulti);
    3182     int rc = VERR_NOT_IMPLEMENTED;
    3183     AssertFailed();
     3815#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3816    int rc = VERR_NOT_IMPLEMENTED;
     3817    AssertFailed();
     3818#else
     3819    int rc = VINF_SUCCESS;
     3820#endif
    31843821
    31853822    LogFlow(("pdmR3DevHlp_SUPSemEventMultiCreate: caller='%s'/%d: returns %Rrc *phEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *phEventMulti));
    … …  
    31953832
    31963833    RT_NOREF(pDevIns, hEventMulti);
    3197     int rc = VERR_NOT_IMPLEMENTED;
    3198     AssertFailed();
     3834#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3835    int rc = VERR_NOT_IMPLEMENTED;
     3836    AssertFailed();
     3837#else
     3838    int rc = VINF_SUCCESS;
     3839#endif
    31993840
    32003841    LogFlow(("pdmR3DevHlp_SUPSemEventMultiClose: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    32103851
    32113852    RT_NOREF(pDevIns, hEventMulti);
    3212     int rc = VERR_NOT_IMPLEMENTED;
    3213     AssertFailed();
     3853#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3854    int rc = VERR_NOT_IMPLEMENTED;
     3855    AssertFailed();
     3856#else
     3857    int rc = VINF_SUCCESS;
     3858#endif
    32143859
    32153860    LogFlow(("pdmR3DevHlp_SUPSemEventMultiSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    32253870
    32263871    RT_NOREF(pDevIns, hEventMulti);
    3227     int rc = VERR_NOT_IMPLEMENTED;
    3228     AssertFailed();
     3872#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3873    int rc = VERR_NOT_IMPLEMENTED;
     3874    AssertFailed();
     3875#else
     3876    int rc = VINF_SUCCESS;
     3877#endif
    32293878
    32303879    LogFlow(("pdmR3DevHlp_SUPSemEventMultiReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    32423891
    32433892    RT_NOREF(pDevIns, hEventMulti, cMillies);
    3244     int rc = VERR_NOT_IMPLEMENTED;
    3245     AssertFailed();
    3246 
     3893#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3894    int rc = VERR_NOT_IMPLEMENTED;
     3895    AssertFailed();
     3896#else
     3897    int rc = VINF_SUCCESS;
     3898#endif
    32473899    LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    32483900    return rc;
    … …  
    32593911
    32603912    RT_NOREF(pDevIns, hEventMulti, uNsTimeout);
    3261     int rc = VERR_NOT_IMPLEMENTED;
    3262     AssertFailed();
     3913#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3914    int rc = VERR_NOT_IMPLEMENTED;
     3915    AssertFailed();
     3916#else
     3917    int rc = VINF_SUCCESS;
     3918#endif
    32633919
    32643920    LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    32763932
    32773933    RT_NOREF(pDevIns, hEventMulti, cNsTimeout);
    3278     int rc = VERR_NOT_IMPLEMENTED;
    3279     AssertFailed();
     3934#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     3935    int rc = VERR_NOT_IMPLEMENTED;
     3936    AssertFailed();
     3937#else
     3938    int rc = VINF_SUCCESS;
     3939#endif
    32803940
    32813941    LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    … …  
    34504110
    34514111    RT_NOREF(pDevIns, pCritSect);
     4112#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
    34524113    AssertFailed();
    34534114    return false;
     4115#else
     4116    return true;
     4117#endif
    34544118}
    34554119
    … …  
    35094173
    35104174    RT_NOREF(ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
    3511     int rc = VERR_NOT_IMPLEMENTED;
    3512     AssertFailed();
     4175
     4176#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
     4177    int rc = VERR_NOT_IMPLEMENTED;
     4178    AssertFailed();
     4179#else
     4180    int rc = VINF_SUCCESS;
     4181#endif
    35134182
    35144183    LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pDevIns->pReg->szName, pDevIns->iInstance,
    … …  
    38884557    PDMDEV_ASSERT_DEVINS(pDevIns);
    38894558
    3890     AssertFailed();
    3891     LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
    3892     return NULL;
     4559    LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns->Internal.s.pDut->pVm));
     4560    return pDevIns->Internal.s.pDut->pVm;
    38934561}
    38944562

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

    r83062 r83261  
    2323#include <VBox/types.h>
    2424
     25#include "tstDeviceCfg.h"
     26
     27
    2528/** Device under test handle. */
    2629typedef struct TSTDEVDUTINT *TSTDEVDUT;
    … …  
    3538    /** Testcase description. */
    3639    const char          *pszDesc;
    37     /** The device name the testcase handles. */
    38     char                szDevName[16];
    3940    /** Flags for this testcase. */
    4041    uint32_t            fFlags;
    41     /** CFGM configuration for the device to be instantiated. */
    42     PCTSTDEVCFGITEM     paDevCfg;
    4342
    4443    /**
    … …  
    4746     * @returns VBox status code.
    4847     * @param   hDut      Handle of the device under test.
     48     * @param   paCfg     Pointer to the testcase config.
     49     * @param   cCfgItems Number of config items.
    4950     */
    50     DECLR3CALLBACKMEMBER(int, pfnTestEntry, (TSTDEVDUT hDut));
     51    DECLR3CALLBACKMEMBER(int, pfnTestEntry, (TSTDEVDUT hDut, PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems));
    5152} TSTDEVTESTCASEREG;
    5253/** Pointer to a testcase registration structure. */
Note: See TracChangeset for help on using the changeset viewer.

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