VirtualBox

Changeset 82302 in vbox


Ignore:
Timestamp:
Nov 30, 2019 5:41:46 PM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
135126
Message:

DevHDA: SSMR3 -> devhlp. Left some comments about bad saved state practices. bugref:9218

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r82301 r82302  
    34523452static int hdaR3SaveStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PHDASTREAM pStream)
    34533453{
    3454     RT_NOREF(pDevIns);
     3454    PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
    34553455# ifdef LOG_ENABLED
    34563456    PHDASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
    … …  
    34603460
    34613461    /* Save stream ID. */
    3462     int rc = SSMR3PutU8(pSSM, pStream->u8SD);
     3462    int rc = pHlp->pfnSSMPutU8(pSSM, pStream->u8SD);
    34633463    AssertRCReturn(rc, rc);
    34643464    Assert(pStream->u8SD < HDA_MAX_STREAMS);
    34653465
    3466     rc = SSMR3PutStructEx(pSSM, &pStream->State, sizeof(HDASTREAMSTATE), 0 /*fFlags*/, g_aSSMStreamStateFields7, NULL);
     3466    rc = pHlp->pfnSSMPutStructEx(pSSM, &pStream->State, sizeof(HDASTREAMSTATE), 0 /*fFlags*/, g_aSSMStreamStateFields7, NULL);
    34673467    AssertRCReturn(rc, rc);
    34683468
    3469     rc = SSMR3PutStructEx(pSSM, &pStream->State.BDLE.Desc, sizeof(HDABDLEDESC), 0 /*fFlags*/, g_aSSMBDLEDescFields7, NULL);
     3469    rc = pHlp->pfnSSMPutStructEx(pSSM, &pStream->State.BDLE.Desc, sizeof(HDABDLEDESC), 0 /*fFlags*/, g_aSSMBDLEDescFields7, NULL);
    34703470    AssertRCReturn(rc, rc);
    34713471
    3472     rc = SSMR3PutStructEx(pSSM, &pStream->State.BDLE.State, sizeof(HDABDLESTATE), 0 /*fFlags*/, g_aSSMBDLEStateFields7, NULL);
     3472    rc = pHlp->pfnSSMPutStructEx(pSSM, &pStream->State.BDLE.State, sizeof(HDABDLESTATE), 0 /*fFlags*/, g_aSSMBDLEStateFields7, NULL);
    34733473    AssertRCReturn(rc, rc);
    34743474
    3475     rc = SSMR3PutStructEx(pSSM, &pStream->State.Period, sizeof(HDASTREAMPERIOD), 0 /* fFlags */, g_aSSMStreamPeriodFields7, NULL);
     3475    rc = pHlp->pfnSSMPutStructEx(pSSM, &pStream->State.Period, sizeof(HDASTREAMPERIOD), 0 /* fFlags */, g_aSSMStreamPeriodFields7, NULL);
    34763476    AssertRCReturn(rc, rc);
    34773477
    … …  
    34853485    }
    34863486
    3487     rc = SSMR3PutU32(pSSM, cbCircBufSize);
     3487    rc = pHlp->pfnSSMPutU32(pSSM, cbCircBufSize);
    34883488    AssertRCReturn(rc, rc);
    34893489
    3490     rc = SSMR3PutU32(pSSM, cbCircBufUsed);
     3490    rc = pHlp->pfnSSMPutU32(pSSM, cbCircBufUsed);
    34913491    AssertRCReturn(rc, rc);
    34923492
    … …  
    35073507        if (cbBuf)
    35083508        {
    3509             rc = SSMR3PutMem(pSSM, pvBuf, cbBuf);
     3509            rc = pHlp->pfnSSMPutMem(pSSM, pvBuf, cbBuf);
    35103510            AssertRC(rc);
    35113511            if (   RT_SUCCESS(rc)
    35123512                && cbBuf < cbCircBufUsed)
    35133513            {
    3514                 rc = SSMR3PutMem(pSSM, (uint8_t *)pvBuf - offBuf, cbCircBufUsed - cbBuf);
     3514                rc = pHlp->pfnSSMPutMem(pSSM, (uint8_t *)pvBuf - offBuf, cbCircBufUsed - cbBuf);
    35153515            }
    35163516        }
    … …  
    35343534static DECLCALLBACK(int) hdaR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    35353535{
    3536     PHDASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
     3536    PHDASTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
     3537    PCPDMDEVHLPR3 pHlp  = pDevIns->pHlpR3;
    35373538
    35383539    /* Save Codec nodes states. */
    … …  
    35403541
    35413542    /* Save MMIO registers. */
    3542     SSMR3PutU32(pSSM, RT_ELEMENTS(pThis->au32Regs));
    3543     SSMR3PutMem(pSSM, pThis->au32Regs, sizeof(pThis->au32Regs));
     3543    pHlp->pfnSSMPutU32(pSSM, RT_ELEMENTS(pThis->au32Regs));
     3544    pHlp->pfnSSMPutMem(pSSM, pThis->au32Regs, sizeof(pThis->au32Regs));
    35443545
    35453546    /* Save controller-specifc internals. */
    3546     SSMR3PutU64(pSSM, pThis->u64WalClk);
    3547     SSMR3PutU8(pSSM, pThis->u8IRQL);
     3547    pHlp->pfnSSMPutU64(pSSM, pThis->u64WalClk);
     3548    pHlp->pfnSSMPutU8(pSSM, pThis->u8IRQL);
    35483549
    35493550    /* Save number of streams. */
    3550     SSMR3PutU32(pSSM, HDA_MAX_STREAMS);
     3551    pHlp->pfnSSMPutU32(pSSM, HDA_MAX_STREAMS);
    35513552
    35523553    /* Save stream states. */
    … …  
    36223623 * Handles loading of all saved state versions older than the current one.
    36233624 *
    3624  * @param   pThis               Pointer to HDA state.
    3625  * @param   pSSM                Pointer to SSM handle.
    3626  * @param   uVersion            Saved state version to load.
    3627  * @param   uPass               Loading stage to handle.
    3628  */
    3629 static int hdaR3LoadExecLegacy(PHDASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    3630 {
    3631     RT_NOREF(uPass);
    3632 
    3633     int rc = VINF_SUCCESS;
     3625 * @param   pDevIns     The device instance.
     3626 * @param   pThis       Pointer to HDA state.
     3627 * @param   pSSM        Pointer to SSM handle.
     3628 * @param   uVersion    Saved state version to load.
     3629 */
     3630static int hdaR3LoadExecLegacy(PPDMDEVINS pDevIns, PHDASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion)
     3631{
     3632    PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
     3633    int           rc;
    36343634
    36353635    /*
    … …  
    36443644               builds in the 4.1 development period. */
    36453645            cRegs = 113;
    3646             if (SSMR3HandleRevision(pSSM) >= 71199)
     3646            if (pHlp->pfnSSMHandleRevision(pSSM) >= 71199)
    36473647            {
    3648                 uint32_t uVer = SSMR3HandleVersion(pSSM);
     3648                uint32_t uVer = pHlp->pfnSSMHandleVersion(pSSM);
    36493649                if (   VBOX_FULL_VERSION_GET_MAJOR(uVer) == 4
    36503650                    && VBOX_FULL_VERSION_GET_MINOR(uVer) == 0
    … …  
    36643664        case HDA_SSM_VERSION_5:
    36653665        case HDA_SSM_VERSION_6:
    3666             rc = SSMR3GetU32(pSSM, &cRegs); AssertRCReturn(rc, rc);
     3666            rc = pHlp->pfnSSMGetU32(pSSM, &cRegs); AssertRCReturn(rc, rc);
    36673667            if (cRegs != RT_ELEMENTS(pThis->au32Regs))
    36683668                LogRel(("HDA: SSM version cRegs is %RU32, expected %RU32\n", cRegs, RT_ELEMENTS(pThis->au32Regs)));
    … …  
    36763676    if (cRegs >= RT_ELEMENTS(pThis->au32Regs))
    36773677    {
    3678         SSMR3GetMem(pSSM, pThis->au32Regs, sizeof(pThis->au32Regs));
    3679         SSMR3Skip(pSSM, sizeof(uint32_t) * (cRegs - RT_ELEMENTS(pThis->au32Regs)));
     3678        pHlp->pfnSSMGetMem(pSSM, pThis->au32Regs, sizeof(pThis->au32Regs));
     3679        pHlp->pfnSSMSkip(pSSM, sizeof(uint32_t) * (cRegs - RT_ELEMENTS(pThis->au32Regs)));
    36803680    }
    36813681    else
    3682         SSMR3GetMem(pSSM, pThis->au32Regs, sizeof(uint32_t) * cRegs);
     3682        pHlp->pfnSSMGetMem(pSSM, pThis->au32Regs, sizeof(uint32_t) * cRegs);
    36833683
    36843684    /* Make sure to update the base addresses first before initializing any streams down below. */
    … …  
    37003700     *       according to the spec).
    37013701     */
    3702 #define HDA_SSM_LOAD_BDLE_STATE_PRE_V5(v, x)                                \
    3703     {                                                                       \
    3704         rc = SSMR3Skip(pSSM, sizeof(uint32_t));        /* Begin marker */   \
    3705         AssertRCReturn(rc, rc);                                             \
    3706         rc = SSMR3GetU64(pSSM, &x.Desc.u64BufAddr);     /* u64BdleCviAddr */ \
    3707         AssertRCReturn(rc, rc);                                             \
    3708         rc = SSMR3Skip(pSSM, sizeof(uint32_t));        /* u32BdleMaxCvi */  \
    3709         AssertRCReturn(rc, rc);                                             \
    3710         rc = SSMR3GetU32(pSSM, &x.State.u32BDLIndex);  /* u32BdleCvi */     \
    3711         AssertRCReturn(rc, rc);                                             \
    3712         rc = SSMR3GetU32(pSSM, &x.Desc.u32BufSize);    /* u32BdleCviLen */  \
    3713         AssertRCReturn(rc, rc);                                             \
    3714         rc = SSMR3GetU32(pSSM, &x.State.u32BufOff);    /* u32BdleCviPos */  \
    3715         AssertRCReturn(rc, rc);                                             \
    3716         bool fIOC;                                                          \
    3717         rc = SSMR3GetBool(pSSM, &fIOC);                /* fBdleCviIoc */    \
    3718         AssertRCReturn(rc, rc);                                             \
    3719         x.Desc.fFlags = fIOC ? HDA_BDLE_FLAG_IOC : 0;                       \
    3720         rc = SSMR3GetU32(pSSM, &x.State.cbBelowFIFOW); /* cbUnderFifoW */   \
    3721         AssertRCReturn(rc, rc);                                             \
    3722         rc = SSMR3Skip(pSSM, sizeof(uint8_t) * 256);   /* FIFO */           \
    3723         AssertRCReturn(rc, rc);                                             \
    3724         rc = SSMR3Skip(pSSM, sizeof(uint32_t));        /* End marker */     \
    3725         AssertRCReturn(rc, rc);                                             \
     3702#define HDA_SSM_LOAD_BDLE_STATE_PRE_V5(v, x) \
     3703    { \
     3704        pHlp->pfnSSMSkip(pSSM, sizeof(uint32_t));        /* Begin marker */  \
     3705        pHlp->pfnSSMGetU64(pSSM, &x.Desc.u64BufAddr);    /* u64BdleCviAddr */ \
     3706        pHlp->pfnSSMSkip(pSSM, sizeof(uint32_t));        /* u32BdleMaxCvi */ \
     3707        pHlp->pfnSSMGetU32(pSSM, &x.State.u32BDLIndex);  /* u32BdleCvi */ \
     3708        pHlp->pfnSSMGetU32(pSSM, &x.Desc.u32BufSize);    /* u32BdleCviLen */ \
     3709        pHlp->pfnSSMGetU32(pSSM, &x.State.u32BufOff);    /* u32BdleCviPos */ \
     3710        bool fIOC; \
     3711        rc = pHlp->pfnSSMGetBool(pSSM, &fIOC);           /* fBdleCviIoc */ \
     3712        AssertRCReturn(rc, rc); \
     3713        x.Desc.fFlags = fIOC ? HDA_BDLE_FLAG_IOC : 0; \
     3714        pHlp->pfnSSMGetU32(pSSM, &x.State.cbBelowFIFOW); /* cbUnderFifoW */ \
     3715        pHlp->pfnSSMSkip(pSSM, sizeof(uint8_t) * 256);   /* FIFO */ \
     3716        rc = pHlp->pfnSSMSkip(pSSM, sizeof(uint32_t));   /* End marker */ \
     3717        AssertRCReturn(rc, rc); \
    37263718    }
    37273719
    … …  
    37453737            PHDASTREAM pStream = &pThis->aStreams[4];
    37463738            rc = hdaR3StreamInit(pStream, 4 /* Stream descriptor, hardcoded */);
    3747             if (RT_FAILURE(rc))
    3748                 break;
     3739            AssertRCReturn(rc, rc);
    37493740            HDA_SSM_LOAD_BDLE_STATE_PRE_V5(uVersion, pStream->State.BDLE);
    37503741            pStream->State.uCurBDLE = pStream->State.BDLE.State.u32BDLIndex;
    … …  
    37533744            pStream = &pThis->aStreams[2];
    37543745            rc = hdaR3StreamInit(pStream, 2 /* Stream descriptor, hardcoded */);
    3755             if (RT_FAILURE(rc))
    3756                 break;
     3746            AssertRCReturn(rc, rc);
    37573747            HDA_SSM_LOAD_BDLE_STATE_PRE_V5(uVersion, pStream->State.BDLE);
    37583748            pStream->State.uCurBDLE = pStream->State.BDLE.State.u32BDLIndex;
    … …  
    37613751            pStream = &pThis->aStreams[0];
    37623752            rc = hdaR3StreamInit(pStream, 0 /* Stream descriptor, hardcoded */);
    3763             if (RT_FAILURE(rc))
    3764                 break;
     3753            AssertRCReturn(rc, rc);
    37653754            HDA_SSM_LOAD_BDLE_STATE_PRE_V5(uVersion, pStream->State.BDLE);
    37663755            pStream->State.uCurBDLE = pStream->State.BDLE.State.u32BDLIndex;
    … …  
    37733762        {
    37743763            uint32_t cStreams;
    3775             rc = SSMR3GetU32(pSSM, &cStreams);
    3776             if (RT_FAILURE(rc))
    3777                 break;
     3764            rc = pHlp->pfnSSMGetU32(pSSM, &cStreams);
     3765            AssertRCReturn(rc, rc);
    37783766
    37793767            if (cStreams > HDA_MAX_STREAMS)
    … …  
    37843772            {
    37853773                uint8_t uStreamID;
    3786                 rc = SSMR3GetU8(pSSM, &uStreamID);
    3787                 if (RT_FAILURE(rc))
    3788                     break;
     3774                rc = pHlp->pfnSSMGetU8(pSSM, &uStreamID);
     3775                AssertRCReturn(rc, rc);
    37893776
    37903777                PHDASTREAM pStream = hdaGetStreamFromSD(pThis, uStreamID);
    … …  
    38073794                 * Load BDLEs (Buffer Descriptor List Entries) and DMA counters.
    38083795                 */
    3809 
    38103796                if (uVersion == HDA_SSM_VERSION_5)
    38113797                {
    38123798                    /* Get the current BDLE entry and skip the rest. */
     3799                    pHlp->pfnSSMSkip(pSSM, sizeof(uint32_t));       /* Begin marker */
    38133800                    uint16_t cBDLE;
    3814 
    3815                     rc = SSMR3Skip(pSSM, sizeof(uint32_t));         /* Begin marker */
    3816                     AssertRC(rc);
    3817                     rc = SSMR3GetU16(pSSM, &cBDLE);                 /* cBDLE */
    3818                     AssertRC(rc);
    3819                     rc = SSMR3GetU16(pSSM, &pStream->State.uCurBDLE); /* uCurBDLE */
    3820                     AssertRC(rc);
    3821                     rc = SSMR3Skip(pSSM, sizeof(uint32_t));         /* End marker */
    3822                     AssertRC(rc);
    3823 
    3824                     uint32_t u32BDLEIndex;
     3801                    pHlp->pfnSSMGetU16(pSSM, &cBDLE);                      /* cBDLE */
     3802                    pHlp->pfnSSMGetU16(pSSM, &pStream->State.uCurBDLE);    /* uCurBDLE */
     3803                    rc = pHlp->pfnSSMSkip(pSSM, sizeof(uint32_t));         /* End marker */
     3804                    AssertRCReturn(rc, rc);
     3805
    38253806                    for (uint16_t a = 0; a < cBDLE; a++)
    38263807                    {
    3827                         rc = SSMR3Skip(pSSM, sizeof(uint32_t));     /* Begin marker */
    3828                         AssertRC(rc);
    3829                         rc = SSMR3GetU32(pSSM, &u32BDLEIndex);      /* u32BDLIndex */
    3830                         AssertRC(rc);
     3808                        pHlp->pfnSSMSkip(pSSM, sizeof(uint32_t));          /* Begin marker */
     3809                        uint32_t u32BDLEIndex;
     3810                        rc = pHlp->pfnSSMGetU32(pSSM, &u32BDLEIndex);      /* u32BDLIndex */
     3811                        AssertRCReturn(rc, rc);
    38313812
    38323813                        /* Does the current BDLE index match the current BDLE to process? */
    38333814                        if (u32BDLEIndex == pStream->State.uCurBDLE)
    38343815                        {
    3835                             rc = SSMR3GetU32(pSSM, &pStream->State.BDLE.State.cbBelowFIFOW); /* cbBelowFIFOW */
    3836                             AssertRC(rc);
    3837                             rc = SSMR3Skip(pSSM, sizeof(uint8_t) * 256);                   /* FIFO, deprecated */
    3838                             AssertRC(rc);
    3839                             rc = SSMR3GetU32(pSSM, &pStream->State.BDLE.State.u32BufOff);    /* u32BufOff */
    3840                             AssertRC(rc);
    3841                             rc = SSMR3Skip(pSSM, sizeof(uint32_t));                        /* End marker */
    3842                             AssertRC(rc);
     3816                            pHlp->pfnSSMGetU32(pSSM, &pStream->State.BDLE.State.cbBelowFIFOW);  /* cbBelowFIFOW */
     3817                            pHlp->pfnSSMSkip(pSSM, sizeof(uint8_t) * 256);                      /* FIFO, deprecated */
     3818                            pHlp->pfnSSMGetU32(pSSM, &pStream->State.BDLE.State.u32BufOff);     /* u32BufOff */
     3819                            rc = pHlp->pfnSSMSkip(pSSM, sizeof(uint32_t));                      /* End marker */
     3820                            AssertRCReturn(rc, rc);
    38433821                        }
    38443822                        else /* Skip not current BDLEs. */
    38453823                        {
    3846                             rc = SSMR3Skip(pSSM,   sizeof(uint32_t)      /* cbBelowFIFOW */
    3847                                                  + sizeof(uint8_t) * 256 /* au8FIFO */
    3848                                                  + sizeof(uint32_t)      /* u32BufOff */
    3849                                                  + sizeof(uint32_t));    /* End marker */
    3850                             AssertRC(rc);
     3824                            rc = pHlp->pfnSSMSkip(pSSM,   sizeof(uint32_t)      /* cbBelowFIFOW */
     3825                                                        + sizeof(uint8_t) * 256 /* au8FIFO */
     3826                                                        + sizeof(uint32_t)      /* u32BufOff */
     3827                                                        + sizeof(uint32_t));    /* End marker */
     3828                            AssertRCReturn(rc, rc);
    38513829                        }
    38523830                    }
    … …  
    38543832                else
    38553833                {
    3856                     rc = SSMR3GetStructEx(pSSM, &pStream->State, sizeof(HDASTREAMSTATE),
    3857                                           0 /* fFlags */, g_aSSMStreamStateFields6, NULL);
    3858                     if (RT_FAILURE(rc))
    3859                         break;
     3834                    rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State, sizeof(HDASTREAMSTATE),
     3835                                                 0 /* fFlags */, g_aSSMStreamStateFields6, NULL);
     3836                    AssertRCReturn(rc, rc);
    38603837
    38613838                    /* Get HDABDLEDESC. */
     3839                    /**
     3840                     *
     3841                     * @todo r=bird: This is all wrong. Appalling. There is no reason for anyone to
     3842                     * mess around with SSM internal magic values ever!  Define a structure and(/or)
     3843                     * associated SSM descriptor and let SSM keep its internals to itself.
     3844                     * struct { uint32_t cbBuf; bool fIoc; }
     3845                     *
     3846                     */
    38623847                    uint32_t uMarker;
    3863                     rc = SSMR3GetU32(pSSM, &uMarker);      /* Begin marker. */
    3864                     AssertRC(rc);
    3865                     Assert(uMarker == UINT32_C(0x19200102) /* SSMR3STRUCT_BEGIN */);
    3866                     rc = SSMR3GetU64(pSSM, &pStream->State.BDLE.Desc.u64BufAddr);
    3867                     AssertRC(rc);
    3868                     rc = SSMR3GetU32(pSSM, &pStream->State.BDLE.Desc.u32BufSize);
    3869                     AssertRC(rc);
     3848                    rc = pHlp->pfnSSMGetU32(pSSM, &uMarker);      /* Begin marker. */
     3849                    AssertRCReturn(rc, rc);
     3850                    AssertReturn(uMarker == UINT32_C(0x19200102) /* SSMR3STRUCT_BEGIN */, VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
     3851                    pHlp->pfnSSMGetU64(pSSM, &pStream->State.BDLE.Desc.u64BufAddr);
     3852                    rc = pHlp->pfnSSMGetU32(pSSM, &pStream->State.BDLE.Desc.u32BufSize);
     3853                    AssertRCReturn(rc, rc);
    38703854                    bool fFlags = false;
    3871                     rc = SSMR3GetBool(pSSM, &fFlags);      /* Saved states < v7 only stored the IOC as boolean flag. */
    3872                     AssertRC(rc);
     3855                    rc = pHlp->pfnSSMGetBool(pSSM, &fFlags);      /* Saved states < v7 only stored the IOC as boolean flag. */
     3856                    AssertRCReturn(rc, rc);
    38733857                    pStream->State.BDLE.Desc.fFlags = fFlags ? HDA_BDLE_FLAG_IOC : 0;
    3874                     rc = SSMR3GetU32(pSSM, &uMarker);      /* End marker. */
    3875                     AssertRC(rc);
    3876                     Assert(uMarker == UINT32_C(0x19920406) /* SSMR3STRUCT_END */);
    3877 
    3878                     rc = SSMR3GetStructEx(pSSM, &pStream->State.BDLE.State, sizeof(HDABDLESTATE),
    3879                                           0 /* fFlags */, g_aSSMBDLEStateFields6, NULL);
    3880                     if (RT_FAILURE(rc))
    3881                         break;
    3882 
    3883                     Log2Func(("[SD%RU8] LPIB=%RU32, CBL=%RU32, LVI=%RU32\n",
    3884                               uStreamID,
    3885                               HDA_STREAM_REG(pThis, LPIB, uStreamID), HDA_STREAM_REG(pThis, CBL, uStreamID), HDA_STREAM_REG(pThis, LVI, uStreamID)));
     3858                    rc = pHlp->pfnSSMGetU32(pSSM, &uMarker);      /* End marker. */
     3859                    AssertRCReturn(rc, rc);
     3860                    AssertReturn(uMarker == UINT32_C(0x19920406) /* SSMR3STRUCT_END */, VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
     3861
     3862                    rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.BDLE.State, sizeof(HDABDLESTATE),
     3863                                                 0 /* fFlags */, g_aSSMBDLEStateFields6, NULL);
     3864                    AssertRCReturn(rc, rc);
     3865
     3866                    Log2Func(("[SD%RU8] LPIB=%RU32, CBL=%RU32, LVI=%RU32\n", uStreamID, HDA_STREAM_REG(pThis, LPIB, uStreamID),
     3867                              HDA_STREAM_REG(pThis, CBL, uStreamID), HDA_STREAM_REG(pThis, LVI, uStreamID)));
    38863868#ifdef LOG_ENABLED
    38873869                    hdaR3BDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
    … …  
    39023884static DECLCALLBACK(int) hdaR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    39033885{
    3904     PHDASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
     3886    PHDASTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
     3887    PCPDMDEVHLPR3 pHlp  = pDevIns->pHlpR3;
    39053888
    39063889    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    … …  
    39203903    if (uVersion < HDA_SSM_VERSION) /* Handle older saved states? */
    39213904    {
    3922         rc = hdaR3LoadExecLegacy(pThis, pSSM, uVersion, uPass);
     3905        rc = hdaR3LoadExecLegacy(pDevIns, pThis, pSSM, uVersion);
    39233906        if (RT_SUCCESS(rc))
    39243907            rc = hdaR3LoadExecPost(pThis);
    3925 
    39263908        return rc;
    39273909    }
    … …  
    39313913     */
    39323914    uint32_t cRegs;
    3933     rc = SSMR3GetU32(pSSM, &cRegs); AssertRCReturn(rc, rc);
     3915    rc = pHlp->pfnSSMGetU32(pSSM, &cRegs); AssertRCReturn(rc, rc);
    39343916    if (cRegs != RT_ELEMENTS(pThis->au32Regs))
    39353917        LogRel(("HDA: SSM version cRegs is %RU32, expected %RU32\n", cRegs, RT_ELEMENTS(pThis->au32Regs)));
    … …  
    39373919    if (cRegs >= RT_ELEMENTS(pThis->au32Regs))
    39383920    {
    3939         SSMR3GetMem(pSSM, pThis->au32Regs, sizeof(pThis->au32Regs));
    3940         SSMR3Skip(pSSM, sizeof(uint32_t) * (cRegs - RT_ELEMENTS(pThis->au32Regs)));
     3921        pHlp->pfnSSMGetMem(pSSM, pThis->au32Regs, sizeof(pThis->au32Regs));
     3922        pHlp->pfnSSMSkip(pSSM, sizeof(uint32_t) * (cRegs - RT_ELEMENTS(pThis->au32Regs)));
    39413923    }
    39423924    else
    3943         SSMR3GetMem(pSSM, pThis->au32Regs, sizeof(uint32_t) * cRegs);
     3925        pHlp->pfnSSMGetMem(pSSM, pThis->au32Regs, sizeof(uint32_t) * cRegs);
    39443926
    39453927    /* Make sure to update the base addresses first before initializing any streams down below. */
    … …  
    39553937     * Don't annoy other team mates (forgot this for state v7).
    39563938     */
    3957     if (   SSMR3HandleRevision(pSSM) >= 116273
    3958         || SSMR3HandleVersion(pSSM)  >= VBOX_FULL_VERSION_MAKE(5, 2, 0))
    3959     {
    3960         rc = SSMR3GetU64(pSSM, &pThis->u64WalClk);
    3961         AssertRC(rc);
    3962 
    3963         rc = SSMR3GetU8(pSSM, &pThis->u8IRQL);
    3964         AssertRC(rc);
     3939    if (   pHlp->pfnSSMHandleRevision(pSSM) >= 116273
     3940        || pHlp->pfnSSMHandleVersion(pSSM)  >= VBOX_FULL_VERSION_MAKE(5, 2, 0))
     3941    {
     3942        rc = pHlp->pfnSSMGetU64(pSSM, &pThis->u64WalClk);
     3943        AssertRCReturn(rc, rc);
     3944        rc = pHlp->pfnSSMGetU8(pSSM, &pThis->u8IRQL);
     3945        AssertRCReturn(rc, rc);
    39653946    }
    39663947
    … …  
    39693950     */
    39703951    uint32_t cStreams;
    3971     rc = SSMR3GetU32(pSSM, &cStreams);
    3972     AssertRC(rc);
    3973 
     3952    rc = pHlp->pfnSSMGetU32(pSSM, &cStreams);
     3953    AssertRCReturn(rc, rc);
     3954
     3955    /** @todo r=bird: Sanity? No, insanity. You'll end up failing later on
     3956     *        because you don't load all your state, so what's the point.  Just
     3957     *        admit to a problem immediately, there is no hiding it! */
    39743958    if (cStreams > HDA_MAX_STREAMS)
    39753959        cStreams = HDA_MAX_STREAMS; /* Sanity. */
    … …  
    39803964    for (uint32_t i = 0; i < cStreams; i++)
    39813965    {
    3982         uint8_t uStreamID;
    3983         rc = SSMR3GetU8(pSSM, &uStreamID);
    3984         AssertRC(rc);
    3985 
    3986         PHDASTREAM pStream = hdaGetStreamFromSD(pThis, uStreamID);
     3966        uint8_t idStream;
     3967        rc = pHlp->pfnSSMGetU8(pSSM, &idStream);
     3968        AssertRCReturn(rc, rc);
     3969
     3970        PHDASTREAM pStream = hdaGetStreamFromSD(pThis, idStream);
    39873971        HDASTREAM  StreamDummy;
    39883972
    39893973        if (!pStream)
    39903974        {
     3975            RT_ZERO(StreamDummy);
    39913976            pStream = &StreamDummy;
    3992             LogRel2(("HDA: Warning: Loading of stream #%RU8 not supported, skipping to load ...\n", uStreamID));
    3993         }
    3994 
    3995         rc = hdaR3StreamInit(pStream, uStreamID);
     3977            LogRel2(("HDA: Warning: Loading of stream #%RU8 not supported, skipping to load ...\n", idStream));
     3978        }
     3979
     3980        rc = hdaR3StreamInit(pStream, idStream);
    39963981        if (RT_FAILURE(rc))
    39973982        {
    3998             LogRel(("HDA: Stream #%RU8: Loading initialization failed, rc=%Rrc\n", uStreamID, rc));
     3983            LogRel(("HDA: Stream #%RU8: Loading initialization failed, rc=%Rrc\n", idStream, rc));
    39993984            /* Continue. */
    40003985        }
    40013986
    4002         rc = SSMR3GetStructEx(pSSM, &pStream->State, sizeof(HDASTREAMSTATE),
    4003                               0 /* fFlags */, g_aSSMStreamStateFields7, NULL);
    4004         AssertRC(rc);
     3987        rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State, sizeof(HDASTREAMSTATE),
     3988                                     0 /* fFlags */, g_aSSMStreamStateFields7, NULL);
     3989        AssertRCReturn(rc, rc);
    40053990
    40063991        /*
    40073992         * Load BDLEs (Buffer Descriptor List Entries) and DMA counters.
    40083993         */
    4009         rc = SSMR3GetStructEx(pSSM, &pStream->State.BDLE.Desc, sizeof(HDABDLEDESC),
    4010                               0 /* fFlags */, g_aSSMBDLEDescFields7, NULL);
    4011         AssertRC(rc);
    4012 
    4013         rc = SSMR3GetStructEx(pSSM, &pStream->State.BDLE.State, sizeof(HDABDLESTATE),
    4014                               0 /* fFlags */, g_aSSMBDLEStateFields7, NULL);
    4015         AssertRC(rc);
     3994        rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.BDLE.Desc, sizeof(HDABDLEDESC),
     3995                                     0 /* fFlags */, g_aSSMBDLEDescFields7, NULL);
     3996        AssertRCReturn(rc, rc);
     3997
     3998        rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.BDLE.State, sizeof(HDABDLESTATE),
     3999                                     0 /* fFlags */, g_aSSMBDLEStateFields7, NULL);
     4000        AssertRCReturn(rc, rc);
    40164001
    40174002        Log2Func(("[SD%RU8] %R[bdle]\n", pStream->u8SD, &pStream->State.BDLE));
    … …  
    40234008                              pStream->u8SD, pStream->u16LVI, pStream->u32CBL, &pStream->State.Cfg);
    40244009
    4025         rc = SSMR3GetStructEx(pSSM, &pStream->State.Period, sizeof(HDASTREAMPERIOD),
    4026                               0 /* fFlags */, g_aSSMStreamPeriodFields7, NULL);
    4027         AssertRC(rc);
     4010        rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.Period, sizeof(HDASTREAMPERIOD),
     4011                                     0 /* fFlags */, g_aSSMStreamPeriodFields7, NULL);
     4012        AssertRCReturn(rc, rc);
    40284013
    40294014        /*
    … …  
    40314016         */
    40324017        uint32_t cbCircBufSize = 0;
    4033         rc = SSMR3GetU32(pSSM, &cbCircBufSize); /* cbCircBuf */
    4034         AssertRC(rc);
    4035 
     4018        rc = pHlp->pfnSSMGetU32(pSSM, &cbCircBufSize); /* cbCircBuf */
    40364019        uint32_t cbCircBufUsed = 0;
    4037         rc = SSMR3GetU32(pSSM, &cbCircBufUsed); /* cbCircBuf */
    4038         AssertRC(rc);
     4020        rc = pHlp->pfnSSMGetU32(pSSM, &cbCircBufUsed); /* cbCircBuf */
     4021        AssertRCReturn(rc, rc);
    40394022
    40404023        if (cbCircBufSize) /* If 0, skip the buffer. */
    40414024        {
    40424025            /* Paranoia. */
    4043             AssertReleaseMsg(cbCircBufSize <= _1M,
    4044                              ("HDA: Saved state contains bogus DMA buffer size (%RU32) for stream #%RU8",
    4045                               cbCircBufSize, uStreamID));
    4046             AssertReleaseMsg(cbCircBufUsed <= cbCircBufSize,
    4047                              ("HDA: Saved state contains invalid DMA buffer usage (%RU32/%RU32) for stream #%RU8",
    4048                               cbCircBufUsed, cbCircBufSize, uStreamID));
     4026            AssertLogRelMsgReturn(cbCircBufSize <= _1M,
     4027                                  ("HDA: Saved state contains bogus DMA buffer size (%RU32) for stream #%RU8",
     4028                                   cbCircBufSize, idStream),
     4029                                  VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
     4030            AssertLogRelMsgReturn(cbCircBufUsed <= cbCircBufSize,
     4031                                  ("HDA: Saved state contains invalid DMA buffer usage (%RU32/%RU32) for stream #%RU8",
     4032                                   cbCircBufUsed, cbCircBufSize, idStream),
     4033                                  VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
    40494034
    40504035            /* Do we need to cre-create the circular buffer do fit the data size? */
    … …  
    40574042
    40584043            rc = RTCircBufCreate(&pStream->State.pCircBuf, cbCircBufSize);
    4059             AssertRC(rc);
    4060 
    4061             if (   RT_SUCCESS(rc)
    4062                 && cbCircBufUsed)
     4044            AssertRCReturn(rc, rc);
     4045
     4046            if (cbCircBufUsed)
    40634047            {
    40644048                void  *pvBuf;
    40654049                size_t cbBuf;
    4066 
    40674050                RTCircBufAcquireWriteBlock(pStream->State.pCircBuf, cbCircBufUsed, &pvBuf, &cbBuf);
    40684051
    4069                 if (cbBuf)
    4070                 {
    4071                     rc = SSMR3GetMem(pSSM, pvBuf, cbBuf);
    4072                     AssertRC(rc);
    4073                 }
     4052                AssertLogRelMsgReturn(cbBuf == cbCircBufUsed, ("cbBuf=%zu cbCircBufUsed=%zu\n", cbBuf, cbCircBufUsed),
     4053                                      VERR_INTERNAL_ERROR_3);
     4054                rc = pHlp->pfnSSMGetMem(pSSM, pvBuf, cbBuf);
     4055                AssertRCReturn(rc, rc);
    40744056
    40754057                RTCircBufReleaseWriteBlock(pStream->State.pCircBuf, cbBuf);
    … …  
    40794061        }
    40804062
    4081         Log2Func(("[SD%RU8] LPIB=%RU32, CBL=%RU32, LVI=%RU32\n",
    4082                   uStreamID,
    4083                   HDA_STREAM_REG(pThis, LPIB, uStreamID), HDA_STREAM_REG(pThis, CBL, uStreamID), HDA_STREAM_REG(pThis, LVI, uStreamID)));
     4063        Log2Func(("[SD%RU8] LPIB=%RU32, CBL=%RU32, LVI=%RU32\n", idStream, HDA_STREAM_REG(pThis, LPIB, idStream),
     4064                  HDA_STREAM_REG(pThis, CBL, idStream), HDA_STREAM_REG(pThis, LVI, idStream)));
    40844065#ifdef LOG_ENABLED
    40854066        hdaR3BDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
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