VirtualBox

Changeset 81765 in vbox


Ignore:
Timestamp:
Nov 11, 2019 4:00:31 PM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
134555
Message:

Devices: Use new volatile SSM getters and enum macros. bugref:9218

Location:
trunk/src/VBox/Devices
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Audio/DevSB16.cpp

    r81591 r81765  
    18301830 * Worker for sb16LoadExec.
    18311831 */
    1832 static int sb16Load(PSSMHANDLE pSSM, PSB16STATE pThis)
     1832static int sb16Load(PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM, PSB16STATE pThis)
    18331833{
    18341834    SSMR3GetS32(pSSM, &pThis->irq);
    … …  
    18431843    SSMR3GetS32(pSSM, &pThis->fmt_bits);
    18441844
    1845     SSMR3GetU32(pSSM, (uint32_t *)&pThis->fmt);
     1845    PDMDEVHLP_SSM_GET_ENUM32_RET(pHlp, pSSM, pThis->fmt, PDMAUDIOFMT);
    18461846
    18471847    SSMR3GetS32(pSSM, &pThis->dma_auto);
    … …  
    19431943        return VINF_SUCCESS;
    19441944
    1945     return sb16Load(pSSM, pThis);
     1945    return sb16Load(pDevIns->pHlpR3, pSSM, pThis);
    19461946}
    19471947

  • trunk/src/VBox/Devices/Bus/DevPCI.cpp

    r81514 r81765  
    11571157    {
    11581158        for (uint8_t i = 0; i < RT_ELEMENTS(pThis->Piix3.auPciLegacyIrqLevels); i++)
    1159             pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->Piix3.auPciLegacyIrqLevels[i]);
     1159            pHlp->pfnSSMGetU32V(pSSM, &pThis->Piix3.auPciLegacyIrqLevels[i]);
    11601160        for (uint8_t i = 0; i < RT_ELEMENTS(pThis->auPciApicIrqLevels); i++)
    1161             pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->auPciApicIrqLevels[i]);
     1161            pHlp->pfnSSMGetU32V(pSSM, &pThis->auPciApicIrqLevels[i]);
    11621162
    11631163        pHlp->pfnSSMGetU32(pSSM, &pThis->Piix3.iAcpiIrqLevel);

  • trunk/src/VBox/Devices/Bus/DevPciIch9.cpp

    r81704 r81765  
    17681768     */
    17691769    for (unsigned i = 0; i < RT_ELEMENTS(pThis->auPciApicIrqLevels); i++)
    1770         SSMR3GetU32(pSSM, (uint32_t*)&pThis->auPciApicIrqLevels[i]);
     1770        SSMR3GetU32V(pSSM, &pThis->auPciApicIrqLevels[i]);
    17711771
    17721772    /* separator */

  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r81591 r81765  
    27832783    SSMR3GetU8(pSSM, &pThis->ar_index);
    27842784    SSMR3GetMem(pSSM, pThis->ar, 21);
    2785     SSMR3GetU32(pSSM, (uint32_t *)&pThis->ar_flip_flop);
     2785    SSMR3GetS32(pSSM, &pThis->ar_flip_flop);
    27862786    SSMR3GetU8(pSSM, &pThis->cr_index);
    27872787    SSMR3GetMem(pSSM, pThis->cr, 256);
    … …  
    27982798    SSMR3GetMem(pSSM, pThis->palette, 768);
    27992799
    2800     SSMR3GetU32(pSSM, (uint32_t *)&pThis->bank_offset);
     2800    SSMR3GetS32(pSSM, &pThis->bank_offset);
    28012801    SSMR3GetU8(pSSM, &u8);
    28022802    is_vbe = !!u8;

  • trunk/src/VBox/Devices/Input/DevPS2.cpp

    r81591 r81765  
    541541    if (version_id <= 5)
    542542    {
    543         SSMR3GetU32(pSSM, (uint32_t *)&u32Dummy);
    544         SSMR3GetU32(pSSM, (uint32_t *)&u32Dummy);
     543        SSMR3GetU32(pSSM, &u32Dummy);
     544        SSMR3GetU32(pSSM, &u32Dummy);
    545545    }
    546546    else

  • trunk/src/VBox/Devices/Network/DevEEPROM.cpp

    r81465 r81765  
    263263{
    264264    pHlp->pfnSSMPutU8(  pSSM, EEPROM93C46_SAVEDSTATE_VERSION);
     265    Assert((uint32_t)m_eState < UINT32_C(256));
    265266    pHlp->pfnSSMPutU8(  pSSM, m_eState);
     267    Assert((uint32_t)m_eOp < UINT32_C(256));
    266268    pHlp->pfnSSMPutU8(  pSSM, m_eOp);
    267269    pHlp->pfnSSMPutBool(pSSM, m_fWriteEnabled);
    … …  
    281283        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    282284
    283     pHlp->pfnSSMGetU8(  pSSM, (uint8_t*)&m_eState);
    284     pHlp->pfnSSMGetU8(  pSSM, (uint8_t*)&m_eOp);
     285    PDMDEVHLP_SSM_GET_ENUM8_RET(pHlp, pSSM, m_eState, EEPROM93C46::State);
     286    PDMDEVHLP_SSM_GET_ENUM8_RET(pHlp, pSSM, m_eOp, EEPROM93C46::OP);
    285287    pHlp->pfnSSMGetBool(pSSM, &m_fWriteEnabled);
    286288    pHlp->pfnSSMGetU32( pSSM, &m_u32InternalWires);

  • trunk/src/VBox/Devices/PC/DevIoApic.cpp

    r81591 r81765  
    10901090
    10911091    if (uVersion == IOAPIC_SAVED_STATE_VERSION)
    1092         SSMR3GetU32(pSSM, (uint32_t *)&pThis->uIrr);
    1093 
    1094     SSMR3GetU8(pSSM, (uint8_t *)&pThis->u8Id);
    1095     SSMR3GetU8(pSSM, (uint8_t *)&pThis->u8Index);
     1092        SSMR3GetU32(pSSM, &pThis->uIrr);
     1093
     1094    SSMR3GetU8V(pSSM, &pThis->u8Id);
     1095    SSMR3GetU8V(pSSM, &pThis->u8Index);
    10961096    for (uint8_t idxRte = 0; idxRte < RT_ELEMENTS(pThis->au64RedirTable); idxRte++)
    10971097        SSMR3GetU64(pSSM, &pThis->au64RedirTable[idxRte]);

  • trunk/src/VBox/Devices/Serial/DevSerial.cpp

    r81591 r81765  
    179179        SSMR3GetU8(    pSSM, &bIrq);
    180180        SSMR3GetIOPort(pSSM, &PortBase);
    181         rc = SSMR3GetU32(   pSSM, (uint32_t *)&enmType);
    182         AssertRCReturn(rc, rc);
     181        PDMDEVHLP_SSM_GET_ENUM32_RET(pDevIns->pHlpR3, pSSM, enmType, UARTTYPE);
    183182        if (uPass == SSM_PASS_FINAL)
    184183        {

  • trunk/src/VBox/Devices/Storage/DevAHCI.cpp

    r81591 r81765  
    51745174        SSMR3GetU32(pSSM, &pThis->uCccCurrentNr);
    51755175
    5176         SSMR3GetU32(pSSM, (uint32_t *)&pThis->u32PortsInterrupted);
     5176        SSMR3GetU32V(pSSM, &pThis->u32PortsInterrupted);
    51775177        SSMR3GetBool(pSSM, &pThis->fReset);
    51785178        SSMR3GetBool(pSSM, &pThis->f64BitAddr);
    … …  
    51915191            SSMR3GetU32(pSSM, &pThis->ahciPort[i].regFB);
    51925192            SSMR3GetU32(pSSM, &pThis->ahciPort[i].regFBU);
    5193             SSMR3GetGCPhys(pSSM, (RTGCPHYS *)&pThis->ahciPort[i].GCPhysAddrClb);
    5194             SSMR3GetGCPhys(pSSM, (RTGCPHYS *)&pThis->ahciPort[i].GCPhysAddrFb);
    5195             SSMR3GetU32(pSSM, (uint32_t *)&pThis->ahciPort[i].regIS);
     5193            SSMR3GetGCPhysV(pSSM, &pThis->ahciPort[i].GCPhysAddrClb);
     5194            SSMR3GetGCPhysV(pSSM, &pThis->ahciPort[i].GCPhysAddrFb);
     5195            SSMR3GetU32V(pSSM, &pThis->ahciPort[i].regIS);
    51965196            SSMR3GetU32(pSSM, &pThis->ahciPort[i].regIE);
    51975197            SSMR3GetU32(pSSM, &pThis->ahciPort[i].regCMD);
    … …  
    52015201            SSMR3GetU32(pSSM, &pThis->ahciPort[i].regSCTL);
    52025202            SSMR3GetU32(pSSM, &pThis->ahciPort[i].regSERR);
    5203             SSMR3GetU32(pSSM, (uint32_t *)&pThis->ahciPort[i].regSACT);
    5204             SSMR3GetU32(pSSM, (uint32_t *)&pThis->ahciPort[i].regCI);
     5203            SSMR3GetU32V(pSSM, &pThis->ahciPort[i].regSACT);
     5204            SSMR3GetU32V(pSSM, &pThis->ahciPort[i].regCI);
    52055205            SSMR3GetU32(pSSM, &pThis->ahciPort[i].PCHSGeometry.cCylinders);
    52065206            SSMR3GetU32(pSSM, &pThis->ahciPort[i].PCHSGeometry.cHeads);
    … …  
    52215221            SSMR3GetBool(pSSM, &pThis->ahciPort[i].fPoweredOn);
    52225222            SSMR3GetBool(pSSM, &pThis->ahciPort[i].fSpunUp);
    5223             SSMR3GetU32(pSSM, (uint32_t *)&pThis->ahciPort[i].u32TasksFinished);
    5224             SSMR3GetU32(pSSM, (uint32_t *)&pThis->ahciPort[i].u32QueuedTasksFinished);
     5223            SSMR3GetU32V(pSSM, &pThis->ahciPort[i].u32TasksFinished);
     5224            SSMR3GetU32V(pSSM, &pThis->ahciPort[i].u32QueuedTasksFinished);
    52255225
    52265226            if (uVersion >= AHCI_SAVED_STATE_VERSION_IDE_EMULATION)
    5227                 SSMR3GetU32(pSSM, (uint32_t *)&pThis->ahciPort[i].u32CurrentCommandSlot);
     5227                SSMR3GetU32V(pSSM, &pThis->ahciPort[i].u32CurrentCommandSlot);
    52285228
    52295229            if (uVersion > AHCI_SAVED_STATE_VERSION_PRE_ATAPI)

  • trunk/src/VBox/Devices/Storage/DevATA.cpp

    r81591 r81765  
    70677067        SSMR3GetU8(pSSM, &pThis->aCts[i].uAsyncIOState);
    70687068        SSMR3GetBool(pSSM, &pThis->aCts[i].fChainedTransfer);
    7069         SSMR3GetBool(pSSM, (bool *)&pThis->aCts[i].fReset);
    7070         SSMR3GetBool(pSSM, (bool *)&pThis->aCts[i].fRedo);
    7071         SSMR3GetBool(pSSM, (bool *)&pThis->aCts[i].fRedoIdle);
    7072         SSMR3GetBool(pSSM, (bool *)&pThis->aCts[i].fRedoDMALastDesc);
     7069        SSMR3GetBool(pSSM, &pThis->aCts[i].fReset);
     7070        SSMR3GetBool(pSSM, &pThis->aCts[i].fRedo);
     7071        SSMR3GetBool(pSSM, &pThis->aCts[i].fRedoIdle);
     7072        SSMR3GetBool(pSSM, &pThis->aCts[i].fRedoDMALastDesc);
    70737073        SSMR3GetMem(pSSM, &pThis->aCts[i].BmDma, sizeof(pThis->aCts[i].BmDma));
    70747074        SSMR3GetGCPhys32(pSSM, &pThis->aCts[i].GCPhysFirstDMADesc);
    … …  
    71427142            SSMR3GetU8(pSSM, &pThis->aCts[i].aIfs[j].cNotifiedMediaChange);
    71437143            if (uVersion > ATA_SAVED_STATE_VERSION_WITHOUT_EVENT_STATUS)
    7144                 SSMR3GetU32(pSSM, (uint32_t*)&pThis->aCts[i].aIfs[j].MediaEventStatus);
     7144                SSMR3GetU32V(pSSM, &pThis->aCts[i].aIfs[j].MediaEventStatus);
    71457145            else
    71467146                pThis->aCts[i].aIfs[j].MediaEventStatus = ATA_EVENT_STATUS_UNCHANGED;

  • trunk/src/VBox/Devices/Storage/DevBusLogic.cpp

    r81591 r81765  
    35143514    SSMR3PutBool  (pSSM, pBusLogic->fExtendedLunCCBFormat);
    35153515
    3516     vboxscsiR3SaveExec(&pBusLogic->VBoxSCSI, pSSM);
     3516    vboxscsiR3SaveExec(pDevIns->pHlpR3, &pBusLogic->VBoxSCSI, pSSM);
    35173517
    35183518    SSMR3PutU32(pSSM, cReqsSuspended);
    … …  
    36103610
    36113611        if (uPass == SSM_PASS_FINAL)
    3612             SSMR3GetU32(pSSM, (uint32_t *)&pDevice->cOutstandingRequests);
     3612            SSMR3GetU32V(pSSM, &pDevice->cOutstandingRequests);
    36133613    }
    36143614
    … …  
    36173617
    36183618    /* Now the main device state. */
    3619     SSMR3GetU8    (pSSM, (uint8_t *)&pBusLogic->regStatus);
    3620     SSMR3GetU8    (pSSM, (uint8_t *)&pBusLogic->regInterrupt);
    3621     SSMR3GetU8    (pSSM, (uint8_t *)&pBusLogic->regGeometry);
     3619    SSMR3GetU8V   (pSSM, &pBusLogic->regStatus);
     3620    SSMR3GetU8V   (pSSM, &pBusLogic->regInterrupt);
     3621    SSMR3GetU8V   (pSSM, &pBusLogic->regGeometry);
    36223622    SSMR3GetMem   (pSSM, &pBusLogic->LocalRam, sizeof(pBusLogic->LocalRam));
    36233623    SSMR3GetU8    (pSSM, &pBusLogic->uOperationCode);
    … …  
    36393639    SSMR3GetGCPhys(pSSM, &pBusLogic->GCPhysAddrMailboxOutgoingBase);
    36403640    SSMR3GetU32   (pSSM, &pBusLogic->uMailboxOutgoingPositionCurrent);
    3641     SSMR3GetU32   (pSSM, (uint32_t *)&pBusLogic->cMailboxesReady);
    3642     SSMR3GetBool  (pSSM, (bool *)&pBusLogic->fNotificationSent);
     3641    SSMR3GetU32V  (pSSM, &pBusLogic->cMailboxesReady);
     3642    SSMR3GetBoolV (pSSM, &pBusLogic->fNotificationSent);
    36433643    SSMR3GetGCPhys(pSSM, &pBusLogic->GCPhysAddrMailboxIncomingBase);
    36443644    SSMR3GetU32   (pSSM, &pBusLogic->uMailboxIncomingPositionCurrent);
    … …  
    36463646    SSMR3GetBool  (pSSM, &pBusLogic->fExtendedLunCCBFormat);
    36473647
    3648     rc = vboxscsiR3LoadExec(&pBusLogic->VBoxSCSI, pSSM);
     3648    rc = vboxscsiR3LoadExec(pDevIns->pHlpR3, &pBusLogic->VBoxSCSI, pSSM);
    36493649    if (RT_FAILURE(rc))
    36503650    {

  • trunk/src/VBox/Devices/Storage/DevLsiLogicSCSI.cpp

    r81752 r81765  
    45494549        AssertMsgFailed(("Invalid controller type %d\n", pThis->enmCtrlType));
    45504550
    4551     vboxscsiR3SaveExec(&pThis->VBoxSCSI, pSSM);
     4551    vboxscsiR3SaveExec(pHlp, &pThis->VBoxSCSI, pSSM);
    45524552    return pHlp->pfnSSMPutU32(pSSM, UINT32_MAX);
    45534553}
    … …  
    45874587        uint32_t cDeviceStates, cPorts;
    45884588
    4589         pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&enmCtrlType);
     4589        PDMDEVHLP_SSM_GET_ENUM32_RET(pHlp, pSSM, enmCtrlType, LSILOGICCTRLTYPE);
    45904590        pHlp->pfnSSMGetU32(pSSM, &cDeviceStates);
    45914591        rc = pHlp->pfnSSMGetU32(pSSM, &cPorts);
    … …  
    46244624        AssertMsg(!pDevice->cOutstandingRequests,
    46254625                  ("There are still outstanding requests on this device\n"));
    4626         pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pDevice->cOutstandingRequests);
     4626        pHlp->pfnSSMGetU32V(pSSM, &pDevice->cOutstandingRequests);
    46274627    }
    46284628    /* Now the main device state. */
    4629     pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->enmState);
    4630     pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->enmWhoInit);
     4629    PDMDEVHLP_SSM_GET_ENUM32_RET(pHlp, pSSM, pThis->enmState, LSILOGICSTATE);
     4630    PDMDEVHLP_SSM_GET_ENUM32_RET(pHlp, pSSM, pThis->enmWhoInit, LSILOGICWHOINIT);
    46314631    if (uVersion <= LSILOGIC_SAVED_STATE_VERSION_BOOL_DOORBELL)
    46324632    {
    4633         bool fDoorbellInProgress = false;
    4634 
    46354633        /*
    46364634         * The doorbell status flag distinguishes only between
    46374635         * doorbell not in use or a Function handshake is currently in progress.
    46384636         */
    4639         pHlp->pfnSSMGetBool  (pSSM, &fDoorbellInProgress);
     4637        bool fDoorbellInProgress = false;
     4638        rc = pHlp->pfnSSMGetBool(pSSM, &fDoorbellInProgress);
     4639        AssertRCReturn(rc, rc);
    46404640        if (fDoorbellInProgress)
    46414641            pThis->enmDoorbellState = LSILOGICDOORBELLSTATE_FN_HANDSHAKE;
    … …  
    46444644    }
    46454645    else
    4646         pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->enmDoorbellState);
     4646        PDMDEVHLP_SSM_GET_ENUM32_RET(pHlp, pSSM, pThis->enmDoorbellState, LSILOGICDOORBELLSTATE);
    46474647    pHlp->pfnSSMGetBool(pSSM, &pThis->fDiagnosticEnabled);
    46484648    pHlp->pfnSSMGetBool(pSSM, &pThis->fNotificationSent);
    46494649    pHlp->pfnSSMGetBool(pSSM, &pThis->fEventNotificationEnabled);
    4650     pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->uInterruptMask);
    4651     pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->uInterruptStatus);
     4650    pHlp->pfnSSMGetU32V(pSSM, &pThis->uInterruptMask);
     4651    pHlp->pfnSSMGetU32V(pSSM, &pThis->uInterruptStatus);
    46524652    for (unsigned i = 0; i < RT_ELEMENTS(pThis->aMessage); i++)
    4653         pHlp->pfnSSMGetU32   (pSSM, &pThis->aMessage[i]);
     4653        pHlp->pfnSSMGetU32(pSSM, &pThis->aMessage[i]);
    46544654    pHlp->pfnSSMGetU32(pSSM, &pThis->iMessage);
    46554655    pHlp->pfnSSMGetU32(pSSM, &pThis->cMessage);
    … …  
    46844684    }
    46854685
    4686     pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->uReplyFreeQueueNextEntryFreeWrite);
    4687     pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->uReplyFreeQueueNextAddressRead);
    4688     pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->uReplyPostQueueNextEntryFreeWrite);
    4689     pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->uReplyPostQueueNextAddressRead);
    4690     pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->uRequestQueueNextEntryFreeWrite);
    4691     pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->uRequestQueueNextAddressRead);
     4686    pHlp->pfnSSMGetU32V(pSSM, &pThis->uReplyFreeQueueNextEntryFreeWrite);
     4687    pHlp->pfnSSMGetU32V(pSSM, &pThis->uReplyFreeQueueNextAddressRead);
     4688    pHlp->pfnSSMGetU32V(pSSM, &pThis->uReplyPostQueueNextEntryFreeWrite);
     4689    pHlp->pfnSSMGetU32V(pSSM, &pThis->uReplyPostQueueNextAddressRead);
     4690    pHlp->pfnSSMGetU32V(pSSM, &pThis->uRequestQueueNextEntryFreeWrite);
     4691    pHlp->pfnSSMGetU32V(pSSM, &pThis->uRequestQueueNextAddressRead);
    46924692
    46934693    PMptConfigurationPagesSupported pPages = pThis->pConfigurationPages;
    … …  
    47354735        /* Queue content */
    47364736        for (unsigned i = 0; i < pThis->cReplyQueueEntries; i++)
    4737             pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->aReplyFreeQueue[i]);
     4737            pHlp->pfnSSMGetU32V(pSSM, &pThis->aReplyFreeQueue[i]);
    47384738        for (unsigned i = 0; i < pThis->cReplyQueueEntries; i++)
    4739             pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->aReplyPostQueue[i]);
     4739            pHlp->pfnSSMGetU32V(pSSM, &pThis->aReplyPostQueue[i]);
    47404740        for (unsigned i = 0; i < pThis->cRequestQueueEntries; i++)
    4741             pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->aRequestQueue[i]);
     4741            pHlp->pfnSSMGetU32V(pSSM, &pThis->aRequestQueue[i]);
    47424742
    47434743        pHlp->pfnSSMGetU16(pSSM, &pThis->u16NextHandle);
    … …  
    48854885    }
    48864886
    4887     rc = vboxscsiR3LoadExec(&pThis->VBoxSCSI, pSSM);
     4887    rc = vboxscsiR3LoadExec(pHlp, &pThis->VBoxSCSI, pSSM);
    48884888    if (RT_FAILURE(rc))
    48894889    {

  • trunk/src/VBox/Devices/Storage/DevVirtioSCSI.cpp

    r81689 r81765  
    20112011    pHlp->pfnSSMGetU32(pSSM, &pThis->virtioScsiConfig.uMaxLun);
    20122012    pHlp->pfnSSMGetU32(pSSM, &pThis->fAsyncEvtsEnabled);
    2013     pHlp->pfnSSMGetU32(pSSM, (uint32_t *)&pThis->cActiveReqs);
     2013    pHlp->pfnSSMGetU32V(pSSM, &pThis->cActiveReqs);
    20142014    pHlp->pfnSSMGetBool(pSSM, &pThis->fEventsMissed);
    20152015    pHlp->pfnSSMGetU32(pSSM, &pThis->fVirtioReady);

  • trunk/src/VBox/Devices/Storage/UsbMsd.cpp

    r81585 r81765  
    14311431            pThis->pReq = pReq;
    14321432
     1433            AssertCompile(sizeof(pReq->enmState) == sizeof(uint32_t));
    14331434            SSMR3GetU32(pSSM, (uint32_t *)&pReq->enmState);
     1435
    14341436            uint32_t cbBuf = 0;
    14351437            rc = SSMR3GetU32(pSSM, &cbBuf);

  • trunk/src/VBox/Devices/Storage/VBoxSCSI.cpp

    r76553 r81765  
    464464}
    465465
    466 DECLHIDDEN(int) vboxscsiR3LoadExec(PVBOXSCSI pVBoxSCSI, PSSMHANDLE pSSM)
     466DECLHIDDEN(int) vboxscsiR3LoadExec(PCPDMDEVHLPR3 pHlp, PVBOXSCSI pVBoxSCSI, PSSMHANDLE pSSM)
    467467{
    468468    SSMR3GetU8  (pSSM, &pVBoxSCSI->regIdentify);
    … …  
    491491    SSMR3GetU32 (pSSM, &pVBoxSCSI->cbBufLeft);
    492492    SSMR3GetU32 (pSSM, &pVBoxSCSI->iBuf);
    493     SSMR3GetBool(pSSM, (bool *)&pVBoxSCSI->fBusy);
    494     SSMR3GetU8  (pSSM, (uint8_t *)&pVBoxSCSI->enmState);
     493    SSMR3GetBoolV(pSSM, &pVBoxSCSI->fBusy);
     494    PDMDEVHLP_SSM_GET_ENUM8_RET(pHlp, pSSM, pVBoxSCSI->enmState, VBOXSCSISTATE);
    495495
    496496    /*
    … …  
    513513}
    514514
    515 DECLHIDDEN(int) vboxscsiR3SaveExec(PVBOXSCSI pVBoxSCSI, PSSMHANDLE pSSM)
    516 {
     515DECLHIDDEN(int) vboxscsiR3SaveExec(PCPDMDEVHLPR3 pHlp, PVBOXSCSI pVBoxSCSI, PSSMHANDLE pSSM)
     516{
     517    RT_NOREF(pHlp);
    517518    SSMR3PutU8    (pSSM, pVBoxSCSI->regIdentify);
    518519    SSMR3PutU8    (pSSM, pVBoxSCSI->uTargetDevice);

  • trunk/src/VBox/Devices/Storage/VBoxSCSI.h

    r76565 r81765  
    150150                       uint8_t *pbDst, uint32_t *pcTransfers, unsigned cb);
    151151
    152 DECLHIDDEN(int) vboxscsiR3LoadExec(PVBOXSCSI pVBoxSCSI, PSSMHANDLE pSSM);
    153 DECLHIDDEN(int) vboxscsiR3SaveExec(PVBOXSCSI pVBoxSCSI, PSSMHANDLE pSSM);
     152DECLHIDDEN(int) vboxscsiR3LoadExec(PCPDMDEVHLPR3 pHlp, PVBOXSCSI pVBoxSCSI, PSSMHANDLE pSSM);
     153DECLHIDDEN(int) vboxscsiR3SaveExec(PCPDMDEVHLPR3 pHlp, PVBOXSCSI pVBoxSCSI, PSSMHANDLE pSSM);
    154154RT_C_DECLS_END
    155155#endif /* IN_RING3 */

  • trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

    r81707 r81765  
    41024102    if (uVersion >= VMMDEV_SAVED_STATE_VERSION_HEARTBEAT)
    41034103    {
    4104         pHlp->pfnSSMGetBool(pSSM, (bool *)&pThis->fHeartbeatActive);
    4105         pHlp->pfnSSMGetBool(pSSM, (bool *)&pThis->fFlatlined);
    4106         pHlp->pfnSSMGetU64(pSSM, (uint64_t *)&pThis->nsLastHeartbeatTS);
     4104        pHlp->pfnSSMGetBoolV(pSSM, &pThis->fHeartbeatActive);
     4105        pHlp->pfnSSMGetBoolV(pSSM, &pThis->fFlatlined);
     4106        pHlp->pfnSSMGetU64V(pSSM, &pThis->nsLastHeartbeatTS);
    41074107        rc = PDMDevHlpTimerLoad(pDevIns, pThis->hFlatlinedTimer, pSSM);
    41084108        AssertRCReturn(rc, rc);
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