VirtualBox

Changeset 82048 in vbox for trunk/src/VBox/Devices


Ignore:
Timestamp:
Nov 20, 2019 8:30:15 PM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
134852
Message:

DevVGA: SSMR3 -> pHlp->pfnSSM. bugref:9218

Location:
trunk/src/VBox/Devices/Graphics
Files:
10 edited

Legend:

Unmodified
Added
Removed

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

    r82047 r82048  
    29512951# ifdef VBOX_WITH_VMSVGA3D
    29522952            if (pThis->svga.f3DEnabled)
    2953                 vmsvga3dSaveExec(pThis, pSSM);
     2953                vmsvga3dSaveExec(pThis->pDevInsR3, pThis, pSSM);
    29542954# endif
    29552955            break;
    … …  
    29642964# ifdef VBOX_WITH_VMSVGA3D
    29652965            if (pThis->svga.f3DEnabled)
    2966                 vmsvga3dLoadExec(pThis, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
     2966                vmsvga3dLoadExec(pThis->pDevInsR3, pThis, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
    29672967# endif
    29682968            break;

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-savedstate.cpp

    r77114 r82048  
    147147}
    148148
    149 int vmsvga3dLoadExec(PVGASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
     149int vmsvga3dLoadExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    150150{
    151151    RT_NOREF(uPass);
    152     PVMSVGA3DSTATE pState = pThis->svga.p3dState;
     152    PVMSVGA3DSTATE  pState = pThis->svga.p3dState;
    153153    AssertReturn(pState, VERR_NO_MEMORY);
    154     int            rc;
     154    PCPDMDEVHLPR3   pHlp = pDevIns->pHlpR3;
     155    int             rc;
    155156    uint32_t       cContexts, cSurfaces;
    156157    LogFlow(("vmsvga3dLoadExec:\n"));
    … …  
    162163
    163164    /* Get the generic 3d state first. */
    164     rc = SSMR3GetStructEx(pSSM, pState, sizeof(*pState), 0, g_aVMSVGA3DSTATEFields, NULL);
     165    rc = pHlp->pfnSSMGetStructEx(pSSM, pState, sizeof(*pState), 0, g_aVMSVGA3DSTATEFields, NULL);
    165166    AssertRCReturn(rc, rc);
    166167
    … …  
    177178
    178179        /* Get the context id */
    179         rc = SSMR3GetU32(pSSM, &cid);
     180        rc = pHlp->pfnSSMGetU32(pSSM, &cid);
    180181        AssertRCReturn(rc, rc);
    181182
    … …  
    206207            AssertReturn(pContext->id == cid, VERR_INTERNAL_ERROR);
    207208
    208             rc = SSMR3GetStructEx(pSSM, pContext, sizeof(*pContext), 0, g_aVMSVGA3DCONTEXTFields, NULL);
     209            rc = pHlp->pfnSSMGetStructEx(pSSM, pContext, sizeof(*pContext), 0, g_aVMSVGA3DCONTEXTFields, NULL);
    209210            AssertRCReturn(rc, rc);
    210211
    … …  
    225226
    226227                /* Fetch the id first. */
    227                 rc = SSMR3GetU32(pSSM, &shid);
     228                rc = pHlp->pfnSSMGetU32(pSSM, &shid);
    228229                AssertRCReturn(rc, rc);
    229230
    … …  
    233234
    234235                    /* Fetch a copy of the shader struct. */
    235                     rc = SSMR3GetStructEx(pSSM, &shader, sizeof(shader), 0, g_aVMSVGA3DSHADERFields, NULL);
     236                    rc = pHlp->pfnSSMGetStructEx(pSSM, &shader, sizeof(shader), 0, g_aVMSVGA3DSHADERFields, NULL);
    236237                    AssertRCReturn(rc, rc);
    237238
    … …  
    239240                    AssertReturn(pData, VERR_NO_MEMORY);
    240241
    241                     rc = SSMR3GetMem(pSSM, pData, shader.cbData);
     242                    rc = pHlp->pfnSSMGetMem(pSSM, pData, shader.cbData);
    242243                    AssertRCReturn(rc, rc);
    243244
    … …  
    256257
    257258                /* Fetch the id first. */
    258                 rc = SSMR3GetU32(pSSM, &shid);
     259                rc = pHlp->pfnSSMGetU32(pSSM, &shid);
    259260                AssertRCReturn(rc, rc);
    260261
    … …  
    264265
    265266                    /* Fetch a copy of the shader struct. */
    266                     rc = SSMR3GetStructEx(pSSM, &shader, sizeof(shader), 0, g_aVMSVGA3DSHADERFields, NULL);
     267                    rc = pHlp->pfnSSMGetStructEx(pSSM, &shader, sizeof(shader), 0, g_aVMSVGA3DSHADERFields, NULL);
    267268                    AssertRCReturn(rc, rc);
    268269
    … …  
    270271                    AssertReturn(pData, VERR_NO_MEMORY);
    271272
    272                     rc = SSMR3GetMem(pSSM, pData, shader.cbData);
     273                    rc = pHlp->pfnSSMGetMem(pSSM, pData, shader.cbData);
    273274                    AssertRCReturn(rc, rc);
    274275
    … …  
    285286                VMSVGASHADERCONST ShaderConst;
    286287
    287                 rc = SSMR3GetStructEx(pSSM, &ShaderConst, sizeof(ShaderConst), 0, g_aVMSVGASHADERCONSTFields, NULL);
     288                rc = pHlp->pfnSSMGetStructEx(pSSM, &ShaderConst, sizeof(ShaderConst), 0, g_aVMSVGASHADERCONSTFields, NULL);
    288289                AssertRCReturn(rc, rc);
    289290
    … …  
    300301                VMSVGASHADERCONST ShaderConst;
    301302
    302                 rc = SSMR3GetStructEx(pSSM, &ShaderConst, sizeof(ShaderConst), 0, g_aVMSVGASHADERCONSTFields, NULL);
     303                rc = pHlp->pfnSSMGetStructEx(pSSM, &ShaderConst, sizeof(ShaderConst), 0, g_aVMSVGASHADERCONSTFields, NULL);
    303304                AssertRCReturn(rc, rc);
    304305
    … …  
    316317                /* Number of stages/samplers. */
    317318                uint32_t cStages;
    318                 rc = SSMR3GetU32(pSSM, &cStages);
     319                rc = pHlp->pfnSSMGetU32(pSSM, &cStages);
    319320                AssertRCReturn(rc, rc);
    320321
    321322                /* Number of states. */
    322323                uint32_t cTextureStates;
    323                 rc = SSMR3GetU32(pSSM, &cTextureStates);
     324                rc = pHlp->pfnSSMGetU32(pSSM, &cTextureStates);
    324325                AssertRCReturn(rc, rc);
    325326
    … …  
    329330                    {
    330331                        SVGA3dTextureState textureState;
    331                         SSMR3GetU32(pSSM, &textureState.stage);
     332                        pHlp->pfnSSMGetU32(pSSM, &textureState.stage);
    332333                        uint32_t u32Name;
    333                         SSMR3GetU32(pSSM, &u32Name);
     334                        pHlp->pfnSSMGetU32(pSSM, &u32Name);
    334335                        textureState.name = (SVGA3dTextureStateName)u32Name;
    335                         rc = SSMR3GetU32(pSSM, &textureState.value);
     336                        rc = pHlp->pfnSSMGetU32(pSSM, &textureState.value);
    336337                        AssertRCReturn(rc, rc);
    337338
    … …  
    350351                RT_ZERO(query);
    351352
    352                 rc = SSMR3GetStructEx(pSSM, &query, sizeof(query), 0, g_aVMSVGA3DQUERYFields, NULL);
     353                rc = pHlp->pfnSSMGetStructEx(pSSM, &query, sizeof(query), 0, g_aVMSVGA3DQUERYFields, NULL);
    353354                AssertRCReturn(rc, rc);
    354355
    … …  
    398399
    399400        /* Fetch the id first. */
    400         rc = SSMR3GetU32(pSSM, &sid);
     401        rc = pHlp->pfnSSMGetU32(pSSM, &sid);
    401402        AssertRCReturn(rc, rc);
    402403
    … …  
    407408
    408409            /* Fetch the surface structure first. */
    409             rc = SSMR3GetStructEx(pSSM, &surface, sizeof(surface), 0, g_aVMSVGA3DSURFACEFields, NULL);
     410            rc = pHlp->pfnSSMGetStructEx(pSSM, &surface, sizeof(surface), 0, g_aVMSVGA3DSURFACEFields, NULL);
    410411            AssertRCReturn(rc, rc);
    411412
    … …  
    424425                        uint32_t idx = j + face * surface.faces[0].numMipLevels;
    425426                        /* Load the mip map level struct. */
    426                         rc = SSMR3GetStructEx(pSSM, &pMipmapLevel[idx], sizeof(pMipmapLevel[idx]), 0, g_aVMSVGA3DMIPMAPLEVELFields, NULL);
     427                        rc = pHlp->pfnSSMGetStructEx(pSSM, &pMipmapLevel[idx], sizeof(pMipmapLevel[idx]), 0, g_aVMSVGA3DMIPMAPLEVELFields, NULL);
    427428                        AssertRCReturn(rc, rc);
    428429
    … …  
    454455
    455456                /* Fetch the data present boolean first. */
    456                 rc = SSMR3GetBool(pSSM, &fDataPresent);
     457                rc = pHlp->pfnSSMGetBool(pSSM, &fDataPresent);
    457458                AssertRCReturn(rc, rc);
    458459
    … …  
    461462                if (fDataPresent)
    462463                {
    463                     rc = SSMR3GetMem(pSSM, pMipmapLevel->pSurfaceData, pMipmapLevel->cbSurface);
     464                    rc = pHlp->pfnSSMGetMem(pSSM, pMipmapLevel->pSurfaceData, pMipmapLevel->cbSurface);
    464465                    AssertRCReturn(rc, rc);
    465466                    pMipmapLevel->fDirty = true;
    … …  
    500501
    501502
    502 static int vmsvga3dSaveContext(PVGASTATE pThis, PSSMHANDLE pSSM, PVMSVGA3DCONTEXT pContext)
     503static int vmsvga3dSaveContext(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PSSMHANDLE pSSM, PVMSVGA3DCONTEXT pContext)
    503504{
    504505    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
    … …  
    506507
    507508    /* Save the id first. */
    508     int rc = SSMR3PutU32(pSSM, cid);
     509    int rc = pHlp->pfnSSMPutU32(pSSM, cid);
    509510    AssertRCReturn(rc, rc);
    510511
    … …  
    512513    {
    513514        /* Save a copy of the context structure first. */
    514         rc = SSMR3PutStructEx(pSSM, pContext, sizeof(*pContext), 0, g_aVMSVGA3DCONTEXTFields, NULL);
     515        rc = pHlp->pfnSSMPutStructEx(pSSM, pContext, sizeof(*pContext), 0, g_aVMSVGA3DCONTEXTFields, NULL);
    515516        AssertRCReturn(rc, rc);
    516517
    … …  
    521522
    522523            /* Save the id first. */
    523             rc = SSMR3PutU32(pSSM, pShader->id);
     524            rc = pHlp->pfnSSMPutU32(pSSM, pShader->id);
    524525            AssertRCReturn(rc, rc);
    525526
    … …  
    529530
    530531                /* Save a copy of the shader struct. */
    531                 rc = SSMR3PutStructEx(pSSM, pShader, sizeof(*pShader), 0, g_aVMSVGA3DSHADERFields, NULL);
     532                rc = pHlp->pfnSSMPutStructEx(pSSM, pShader, sizeof(*pShader), 0, g_aVMSVGA3DSHADERFields, NULL);
    532533                AssertRCReturn(rc, rc);
    533534
    534535                Log(("Save pixelshader shid=%d with %x bytes code.\n", pShader->id, cbData));
    535                 rc = SSMR3PutMem(pSSM, pShader->pShaderProgram, cbData);
     536                rc = pHlp->pfnSSMPutMem(pSSM, pShader->pShaderProgram, cbData);
    536537                AssertRCReturn(rc, rc);
    537538            }
    … …  
    544545
    545546            /* Save the id first. */
    546             rc = SSMR3PutU32(pSSM, pShader->id);
     547            rc = pHlp->pfnSSMPutU32(pSSM, pShader->id);
    547548            AssertRCReturn(rc, rc);
    548549
    … …  
    552553
    553554                /* Save a copy of the shader struct. */
    554                 rc = SSMR3PutStructEx(pSSM, pShader, sizeof(*pShader), 0, g_aVMSVGA3DSHADERFields, NULL);
     555                rc = pHlp->pfnSSMPutStructEx(pSSM, pShader, sizeof(*pShader), 0, g_aVMSVGA3DSHADERFields, NULL);
    555556                AssertRCReturn(rc, rc);
    556557
    557558                Log(("Save vertex shader shid=%d with %x bytes code.\n", pShader->id, cbData));
    558559                /* Fetch the shader code and save it. */
    559                 rc = SSMR3PutMem(pSSM, pShader->pShaderProgram, cbData);
     560                rc = pHlp->pfnSSMPutMem(pSSM, pShader->pShaderProgram, cbData);
    560561                AssertRCReturn(rc, rc);
    561562            }
    … …  
    565566        for (uint32_t j = 0; j < pContext->state.cPixelShaderConst; j++)
    566567        {
    567             rc = SSMR3PutStructEx(pSSM, &pContext->state.paPixelShaderConst[j], sizeof(pContext->state.paPixelShaderConst[j]), 0, g_aVMSVGASHADERCONSTFields, NULL);
     568            rc = pHlp->pfnSSMPutStructEx(pSSM, &pContext->state.paPixelShaderConst[j], sizeof(pContext->state.paPixelShaderConst[j]), 0, g_aVMSVGASHADERCONSTFields, NULL);
    568569            AssertRCReturn(rc, rc);
    569570        }
    … …  
    572573        for (uint32_t j = 0; j < pContext->state.cVertexShaderConst; j++)
    573574        {
    574             rc = SSMR3PutStructEx(pSSM, &pContext->state.paVertexShaderConst[j], sizeof(pContext->state.paVertexShaderConst[j]), 0, g_aVMSVGASHADERCONSTFields, NULL);
     575            rc = pHlp->pfnSSMPutStructEx(pSSM, &pContext->state.paVertexShaderConst[j], sizeof(pContext->state.paVertexShaderConst[j]), 0, g_aVMSVGASHADERCONSTFields, NULL);
    575576            AssertRCReturn(rc, rc);
    576577        }
    … …  
    579580
    580581        /* Number of stages/samplers. */
    581         rc = SSMR3PutU32(pSSM, RT_ELEMENTS(pContext->state.aTextureStates));
     582        rc = pHlp->pfnSSMPutU32(pSSM, RT_ELEMENTS(pContext->state.aTextureStates));
    582583        AssertRCReturn(rc, rc);
    583584
    584585        /* Number of texture states. */
    585         rc = SSMR3PutU32(pSSM, RT_ELEMENTS(pContext->state.aTextureStates[0]));
     586        rc = pHlp->pfnSSMPutU32(pSSM, RT_ELEMENTS(pContext->state.aTextureStates[0]));
    586587        AssertRCReturn(rc, rc);
    587588
    … …  
    592593                SVGA3dTextureState *pTextureState = &pContext->state.aTextureStates[iStage][j];
    593594
    594                 SSMR3PutU32(pSSM, pTextureState->stage);
    595                 SSMR3PutU32(pSSM, pTextureState->name);
    596                 rc = SSMR3PutU32(pSSM, pTextureState->value);
     595                pHlp->pfnSSMPutU32(pSSM, pTextureState->stage);
     596                pHlp->pfnSSMPutU32(pSSM, pTextureState->name);
     597                rc = pHlp->pfnSSMPutU32(pSSM, pTextureState->value);
    597598                AssertRCReturn(rc, rc);
    598599            }
    … …  
    629630        }
    630631
    631         rc = SSMR3PutStructEx(pSSM, &pContext->occlusion, sizeof(pContext->occlusion), 0, g_aVMSVGA3DQUERYFields, NULL);
     632        rc = pHlp->pfnSSMPutStructEx(pSSM, &pContext->occlusion, sizeof(pContext->occlusion), 0, g_aVMSVGA3DQUERYFields, NULL);
    632633        AssertRCReturn(rc, rc);
    633634    }
    … …  
    636637}
    637638
    638 int vmsvga3dSaveExec(PVGASTATE pThis, PSSMHANDLE pSSM)
     639int vmsvga3dSaveExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PSSMHANDLE pSSM)
    639640{
    640     PVMSVGA3DSTATE pState = pThis->svga.p3dState;
     641    PVMSVGA3DSTATE  pState = pThis->svga.p3dState;
    641642    AssertReturn(pState, VERR_NO_MEMORY);
    642     int            rc;
     643    PCPDMDEVHLPR3   pHlp   = pDevIns->pHlpR3;
     644    int             rc;
    643645
    644646    /* Save a copy of the generic 3d state first. */
    645     rc = SSMR3PutStructEx(pSSM, pState, sizeof(*pState), 0, g_aVMSVGA3DSTATEFields, NULL);
     647    rc = pHlp->pfnSSMPutStructEx(pSSM, pState, sizeof(*pState), 0, g_aVMSVGA3DSTATEFields, NULL);
    646648    AssertRCReturn(rc, rc);
    647649
    … …  
    650652    if (pState->SharedCtx.id == VMSVGA3D_SHARED_CTX_ID)
    651653    {
    652         rc = vmsvga3dSaveContext(pThis, pSSM, &pState->SharedCtx);
     654        rc = vmsvga3dSaveContext(pHlp, pThis, pSSM, &pState->SharedCtx);
    653655        AssertRCReturn(rc, rc);
    654656    }
    … …  
    658660    for (uint32_t i = 0; i < pState->cContexts; i++)
    659661    {
    660         rc = vmsvga3dSaveContext(pThis, pSSM, pState->papContexts[i]);
     662        rc = vmsvga3dSaveContext(pHlp, pThis, pSSM, pState->papContexts[i]);
    661663        AssertRCReturn(rc, rc);
    662664    }
    … …  
    668670
    669671        /* Save the id first. */
    670         rc = SSMR3PutU32(pSSM, pSurface->id);
     672        rc = pHlp->pfnSSMPutU32(pSSM, pSurface->id);
    671673        AssertRCReturn(rc, rc);
    672674
    … …  
    674676        {
    675677            /* Save a copy of the surface structure first. */
    676             rc = SSMR3PutStructEx(pSSM, pSurface, sizeof(*pSurface), 0, g_aVMSVGA3DSURFACEFields, NULL);
     678            rc = pHlp->pfnSSMPutStructEx(pSSM, pSurface, sizeof(*pSurface), 0, g_aVMSVGA3DSURFACEFields, NULL);
    677679            AssertRCReturn(rc, rc);
    678680
    … …  
    686688
    687689                    /* Save a copy of the mip map level struct. */
    688                     rc = SSMR3PutStructEx(pSSM, pMipmapLevel, sizeof(*pMipmapLevel), 0, g_aVMSVGA3DMIPMAPLEVELFields, NULL);
     690                    rc = pHlp->pfnSSMPutStructEx(pSSM, pMipmapLevel, sizeof(*pMipmapLevel), 0, g_aVMSVGA3DMIPMAPLEVELFields, NULL);
    689691                    AssertRCReturn(rc, rc);
    690692                }
    … …  
    706708                        {
    707709                            /* Data follows */
    708                             rc = SSMR3PutBool(pSSM, true);
     710                            rc = pHlp->pfnSSMPutBool(pSSM, true);
    709711                            AssertRCReturn(rc, rc);
    710712
    711713                            Assert(pMipmapLevel->cbSurface);
    712                             rc = SSMR3PutMem(pSSM, pMipmapLevel->pSurfaceData, pMipmapLevel->cbSurface);
     714                            rc = pHlp->pfnSSMPutMem(pSSM, pMipmapLevel->pSurfaceData, pMipmapLevel->cbSurface);
    713715                            AssertRCReturn(rc, rc);
    714716                        }
    … …  
    716718                        {
    717719                            /* No data follows */
    718                             rc = SSMR3PutBool(pSSM, false);
     720                            rc = pHlp->pfnSSMPutBool(pSSM, false);
    719721                            AssertRCReturn(rc, rc);
    720722                        }
    … …  
    861863                        {
    862864                            /* Data follows */
    863                             rc = SSMR3PutBool(pSSM, true);
     865                            rc = pHlp->pfnSSMPutBool(pSSM, true);
    864866                            AssertRCReturn(rc, rc);
    865867
    866868                            /* And write the surface data. */
    867                             rc = SSMR3PutMem(pSSM, pData, pMipmapLevel->cbSurface);
     869                            rc = pHlp->pfnSSMPutMem(pSSM, pData, pMipmapLevel->cbSurface);
    868870                            AssertRCReturn(rc, rc);
    869871                        }
    … …  
    871873                        {
    872874                            /* No data follows */
    873                             rc = SSMR3PutBool(pSSM, false);
     875                            rc = pHlp->pfnSSMPutBool(pSSM, false);
    874876                            AssertRCReturn(rc, rc);
    875877                        }
    … …  
    892894                            /** @todo fetch data from the renderbuffer. Not used currently. */
    893895                            /* No data follows */
    894                             rc = SSMR3PutBool(pSSM, false);
     896                            rc = pHlp->pfnSSMPutBool(pSSM, false);
    895897                            AssertRCReturn(rc, rc);
    896898                            break;
    … …  
    923925
    924926                            /* Data follows */
    925                             rc = SSMR3PutBool(pSSM, true);
     927                            rc = pHlp->pfnSSMPutBool(pSSM, true);
    926928                            AssertRCReturn(rc, rc);
    927929
    928930                            /* And write the surface data. */
    929                             rc = SSMR3PutMem(pSSM, pData, pMipmapLevel->cbSurface);
     931                            rc = pHlp->pfnSSMPutMem(pSSM, pData, pMipmapLevel->cbSurface);
    930932                            AssertRCReturn(rc, rc);
    931933
    … …  
    948950
    949951                            /* Data follows */
    950                             rc = SSMR3PutBool(pSSM, true);
     952                            rc = pHlp->pfnSSMPutBool(pSSM, true);
    951953                            AssertRCReturn(rc, rc);
    952954
    953955                            /* And write the surface data. */
    954                             rc = SSMR3PutMem(pSSM, pBufferData, pMipmapLevel->cbSurface);
     956                            rc = pHlp->pfnSSMPutMem(pSSM, pBufferData, pMipmapLevel->cbSurface);
    955957                            AssertRCReturn(rc, rc);
    956958

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d.h

    r81980 r82048  
    5858int vmsvga3dInit(PVGASTATE pThis);
    5959int vmsvga3dPowerOn(PVGASTATE pThis);
    60 int vmsvga3dLoadExec(PVGASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    61 int vmsvga3dSaveExec(PVGASTATE pThis, PSSMHANDLE pSSM);
     60int vmsvga3dLoadExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
     61int vmsvga3dSaveExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PSSMHANDLE pSSM);
    6262int vmsvga3dTerminate(PVGASTATE pThis);
    6363int vmsvga3dReset(PVGASTATE pThis);

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

    r82043 r82048  
    27302730}
    27312731
    2732 static void vga_save(PSSMHANDLE pSSM, PVGASTATE pThis)
     2732static void vga_save(PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM, PVGASTATE pThis)
    27332733{
    27342734    int i;
    27352735
    2736     SSMR3PutU32(pSSM, pThis->latch);
    2737     SSMR3PutU8(pSSM, pThis->sr_index);
    2738     SSMR3PutMem(pSSM, pThis->sr, 8);
    2739     SSMR3PutU8(pSSM, pThis->gr_index);
    2740     SSMR3PutMem(pSSM, pThis->gr, 16);
    2741     SSMR3PutU8(pSSM, pThis->ar_index);
    2742     SSMR3PutMem(pSSM, pThis->ar, 21);
    2743     SSMR3PutU32(pSSM, pThis->ar_flip_flop);
    2744     SSMR3PutU8(pSSM, pThis->cr_index);
    2745     SSMR3PutMem(pSSM, pThis->cr, 256);
    2746     SSMR3PutU8(pSSM, pThis->msr);
    2747     SSMR3PutU8(pSSM, pThis->fcr);
    2748     SSMR3PutU8(pSSM, pThis->st00);
    2749     SSMR3PutU8(pSSM, pThis->st01);
    2750 
    2751     SSMR3PutU8(pSSM, pThis->dac_state);
    2752     SSMR3PutU8(pSSM, pThis->dac_sub_index);
    2753     SSMR3PutU8(pSSM, pThis->dac_read_index);
    2754     SSMR3PutU8(pSSM, pThis->dac_write_index);
    2755     SSMR3PutMem(pSSM, pThis->dac_cache, 3);
    2756     SSMR3PutMem(pSSM, pThis->palette, 768);
    2757 
    2758     SSMR3PutU32(pSSM, pThis->bank_offset);
     2736    pHlp->pfnSSMPutU32(pSSM, pThis->latch);
     2737    pHlp->pfnSSMPutU8(pSSM, pThis->sr_index);
     2738    pHlp->pfnSSMPutMem(pSSM, pThis->sr, 8);
     2739    pHlp->pfnSSMPutU8(pSSM, pThis->gr_index);
     2740    pHlp->pfnSSMPutMem(pSSM, pThis->gr, 16);
     2741    pHlp->pfnSSMPutU8(pSSM, pThis->ar_index);
     2742    pHlp->pfnSSMPutMem(pSSM, pThis->ar, 21);
     2743    pHlp->pfnSSMPutU32(pSSM, pThis->ar_flip_flop);
     2744    pHlp->pfnSSMPutU8(pSSM, pThis->cr_index);
     2745    pHlp->pfnSSMPutMem(pSSM, pThis->cr, 256);
     2746    pHlp->pfnSSMPutU8(pSSM, pThis->msr);
     2747    pHlp->pfnSSMPutU8(pSSM, pThis->fcr);
     2748    pHlp->pfnSSMPutU8(pSSM, pThis->st00);
     2749    pHlp->pfnSSMPutU8(pSSM, pThis->st01);
     2750
     2751    pHlp->pfnSSMPutU8(pSSM, pThis->dac_state);
     2752    pHlp->pfnSSMPutU8(pSSM, pThis->dac_sub_index);
     2753    pHlp->pfnSSMPutU8(pSSM, pThis->dac_read_index);
     2754    pHlp->pfnSSMPutU8(pSSM, pThis->dac_write_index);
     2755    pHlp->pfnSSMPutMem(pSSM, pThis->dac_cache, 3);
     2756    pHlp->pfnSSMPutMem(pSSM, pThis->palette, 768);
     2757
     2758    pHlp->pfnSSMPutU32(pSSM, pThis->bank_offset);
    27592759#ifdef CONFIG_BOCHS_VBE
    27602760    AssertCompile(RT_ELEMENTS(pThis->vbe_regs) < 256);
    2761     SSMR3PutU8(pSSM, (uint8_t)RT_ELEMENTS(pThis->vbe_regs));
    2762     SSMR3PutU16(pSSM, pThis->vbe_index);
     2761    pHlp->pfnSSMPutU8(pSSM, (uint8_t)RT_ELEMENTS(pThis->vbe_regs));
     2762    pHlp->pfnSSMPutU16(pSSM, pThis->vbe_index);
    27632763    for(i = 0; i < (int)RT_ELEMENTS(pThis->vbe_regs); i++)
    2764         SSMR3PutU16(pSSM, pThis->vbe_regs[i]);
    2765     SSMR3PutU32(pSSM, pThis->vbe_start_addr);
    2766     SSMR3PutU32(pSSM, pThis->vbe_line_offset);
     2764        pHlp->pfnSSMPutU16(pSSM, pThis->vbe_regs[i]);
     2765    pHlp->pfnSSMPutU32(pSSM, pThis->vbe_start_addr);
     2766    pHlp->pfnSSMPutU32(pSSM, pThis->vbe_line_offset);
    27672767#else
    2768     SSMR3PutU8(pSSM, 0);
    2769 #endif
    2770 }
    2771 
    2772 static int vga_load(PSSMHANDLE pSSM, PVGASTATE pThis, int version_id)
     2768    pHlp->pfnSSMPutU8(pSSM, 0);
     2769#endif
     2770}
     2771
     2772static int vga_load(PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM, PVGASTATE pThis, int version_id)
    27732773{
    27742774    int is_vbe, i;
    … …  
    27762776    uint8_t u8;
    27772777
    2778     SSMR3GetU32(pSSM, &pThis->latch);
    2779     SSMR3GetU8(pSSM, &pThis->sr_index);
    2780     SSMR3GetMem(pSSM, pThis->sr, 8);
    2781     SSMR3GetU8(pSSM, &pThis->gr_index);
    2782     SSMR3GetMem(pSSM, pThis->gr, 16);
    2783     SSMR3GetU8(pSSM, &pThis->ar_index);
    2784     SSMR3GetMem(pSSM, pThis->ar, 21);
    2785     SSMR3GetS32(pSSM, &pThis->ar_flip_flop);
    2786     SSMR3GetU8(pSSM, &pThis->cr_index);
    2787     SSMR3GetMem(pSSM, pThis->cr, 256);
    2788     SSMR3GetU8(pSSM, &pThis->msr);
    2789     SSMR3GetU8(pSSM, &pThis->fcr);
    2790     SSMR3GetU8(pSSM, &pThis->st00);
    2791     SSMR3GetU8(pSSM, &pThis->st01);
    2792 
    2793     SSMR3GetU8(pSSM, &pThis->dac_state);
    2794     SSMR3GetU8(pSSM, &pThis->dac_sub_index);
    2795     SSMR3GetU8(pSSM, &pThis->dac_read_index);
    2796     SSMR3GetU8(pSSM, &pThis->dac_write_index);
    2797     SSMR3GetMem(pSSM, pThis->dac_cache, 3);
    2798     SSMR3GetMem(pSSM, pThis->palette, 768);
    2799 
    2800     SSMR3GetS32(pSSM, &pThis->bank_offset);
    2801     SSMR3GetU8(pSSM, &u8);
     2778    pHlp->pfnSSMGetU32(pSSM, &pThis->latch);
     2779    pHlp->pfnSSMGetU8(pSSM, &pThis->sr_index);
     2780    pHlp->pfnSSMGetMem(pSSM, pThis->sr, 8);
     2781    pHlp->pfnSSMGetU8(pSSM, &pThis->gr_index);
     2782    pHlp->pfnSSMGetMem(pSSM, pThis->gr, 16);
     2783    pHlp->pfnSSMGetU8(pSSM, &pThis->ar_index);
     2784    pHlp->pfnSSMGetMem(pSSM, pThis->ar, 21);
     2785    pHlp->pfnSSMGetS32(pSSM, &pThis->ar_flip_flop);
     2786    pHlp->pfnSSMGetU8(pSSM, &pThis->cr_index);
     2787    pHlp->pfnSSMGetMem(pSSM, pThis->cr, 256);
     2788    pHlp->pfnSSMGetU8(pSSM, &pThis->msr);
     2789    pHlp->pfnSSMGetU8(pSSM, &pThis->fcr);
     2790    pHlp->pfnSSMGetU8(pSSM, &pThis->st00);
     2791    pHlp->pfnSSMGetU8(pSSM, &pThis->st01);
     2792
     2793    pHlp->pfnSSMGetU8(pSSM, &pThis->dac_state);
     2794    pHlp->pfnSSMGetU8(pSSM, &pThis->dac_sub_index);
     2795    pHlp->pfnSSMGetU8(pSSM, &pThis->dac_read_index);
     2796    pHlp->pfnSSMGetU8(pSSM, &pThis->dac_write_index);
     2797    pHlp->pfnSSMGetMem(pSSM, pThis->dac_cache, 3);
     2798    pHlp->pfnSSMGetMem(pSSM, pThis->palette, 768);
     2799
     2800    pHlp->pfnSSMGetS32(pSSM, &pThis->bank_offset);
     2801    pHlp->pfnSSMGetU8(pSSM, &u8);
    28022802    is_vbe = !!u8;
    28032803#ifdef CONFIG_BOCHS_VBE
    … …  
    28162816    }
    28172817
    2818     SSMR3GetU16(pSSM, &pThis->vbe_index);
     2818    pHlp->pfnSSMGetU16(pSSM, &pThis->vbe_index);
    28192819    for(i = 0; i < (int)u8; i++)
    2820         SSMR3GetU16(pSSM, &pThis->vbe_regs[i]);
     2820        pHlp->pfnSSMGetU16(pSSM, &pThis->vbe_regs[i]);
    28212821    if (version_id <= VGA_SAVEDSTATE_VERSION_INV_VHEIGHT)
    28222822        recalculate_data(pThis);    /* <- re-calculate the pThis->vbe_regs[VBE_DISPI_INDEX_VIRT_HEIGHT] since it might be invalid */
    2823     SSMR3GetU32(pSSM, &pThis->vbe_start_addr);
    2824     SSMR3GetU32(pSSM, &pThis->vbe_line_offset);
     2823    pHlp->pfnSSMGetU32(pSSM, &pThis->vbe_start_addr);
     2824    pHlp->pfnSSMGetU32(pSSM, &pThis->vbe_line_offset);
    28252825    if (version_id < 2)
    2826         SSMR3GetU32(pSSM, &u32Dummy);
     2826        pHlp->pfnSSMGetU32(pSSM, &u32Dummy);
    28272827    pThis->vbe_bank_max = (pThis->vram_size >> 16) - 1;
    28282828#else
    … …  
    56545654 * Saves a important bits of the VGA device config.
    56555655 *
     5656 * @param   pHlp        The device helpers (for SSM functions).
    56565657 * @param   pThis       The VGA instance data.
    56575658 * @param   pSSM        The saved state handle.
    56585659 */
    5659 static void vgaR3SaveConfig(PVGASTATE pThis, PSSMHANDLE pSSM)
    5660 {
    5661     SSMR3PutU32(pSSM, pThis->vram_size);
    5662     SSMR3PutU32(pSSM, pThis->cMonitors);
     5660static void vgaR3SaveConfig(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PSSMHANDLE pSSM)
     5661{
     5662    pHlp->pfnSSMPutU32(pSSM, pThis->vram_size);
     5663    pHlp->pfnSSMPutU32(pSSM, pThis->cMonitors);
    56635664}
    56645665
    … …  
    56715672    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
    56725673    Assert(uPass == 0); NOREF(uPass);
    5673     vgaR3SaveConfig(pThis, pSSM);
     5674    vgaR3SaveConfig(pDevIns->pHlpR3, pThis, pSSM);
    56745675    return VINF_SSM_DONT_CALL_AGAIN;
    56755676}
    … …  
    57095710static DECLCALLBACK(int) vgaR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    57105711{
    5711     PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     5712    PVGASTATE       pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     5713    PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
    57125714
    57135715#ifdef VBOX_WITH_VDMA
    … …  
    57155717#endif
    57165718
    5717     vgaR3SaveConfig(pThis, pSSM);
    5718     vga_save(pSSM, PDMDEVINS_2_DATA(pDevIns, PVGASTATE));
     5719    vgaR3SaveConfig(pHlp, pThis, pSSM);
     5720    vga_save(pHlp, pSSM, PDMDEVINS_2_DATA(pDevIns, PVGASTATE));
    57195721
    57205722    VGA_SAVED_STATE_PUT_MARKER(pSSM, 1);
    57215723#ifdef VBOX_WITH_HGSMI
    5722     SSMR3PutBool(pSSM, true);
     5724    pHlp->pfnSSMPutBool(pSSM, true);
    57235725    int rc = vboxVBVASaveStateExec(pDevIns, pSSM);
    57245726#else
    5725     int rc = SSMR3PutBool(pSSM, false);
     5727    int rc = pHlp->pfnSSMPutBool(pSSM, false);
    57265728#endif
    57275729
    … …  
    57305732    VGA_SAVED_STATE_PUT_MARKER(pSSM, 3);
    57315733#ifdef VBOX_WITH_VDMA
    5732     rc = SSMR3PutU32(pSSM, 1);
     5734    rc = pHlp->pfnSSMPutU32(pSSM, 1);
    57335735    AssertRCReturn(rc, rc);
    5734     rc = vboxVDMASaveStateExecPerform(pThis->pVdma, pSSM);
     5736    rc = vboxVDMASaveStateExecPerform(pHlp, pThis->pVdma, pSSM);
    57355737#else
    5736     rc = SSMR3PutU32(pSSM, 0);
     5738    rc = pHlp->pfnSSMPutU32(pSSM, 0);
    57375739#endif
    57385740    AssertRCReturn(rc, rc);
    … …  
    57615763static DECLCALLBACK(int) vgaR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    57625764{
    5763     PVGASTATE   pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
    5764     int         rc;
     5765    PVGASTATE       pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     5766    PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
     5767    int             rc;
    57655768
    57665769    if (uVersion < VGA_SAVEDSTATE_VERSION_ANCIENT || uVersion > VGA_SAVEDSTATE_VERSION)
    … …  
    57715774        /* Check the config */
    57725775        uint32_t cbVRam;
    5773         rc = SSMR3GetU32(pSSM, &cbVRam);
     5776        rc = pHlp->pfnSSMGetU32(pSSM, &cbVRam);
    57745777        AssertRCReturn(rc, rc);
    57755778        if (pThis->vram_size != cbVRam)
    5776             return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("VRAM size changed: config=%#x state=%#x"), pThis->vram_size, cbVRam);
     5779            return pHlp->pfnSSMSetCfgError(pSSM, RT_SRC_POS, N_("VRAM size changed: config=%#x state=%#x"), pThis->vram_size, cbVRam);
    57775780
    57785781        uint32_t cMonitors;
    5779         rc = SSMR3GetU32(pSSM, &cMonitors);
     5782        rc = pHlp->pfnSSMGetU32(pSSM, &cMonitors);
    57805783        AssertRCReturn(rc, rc);
    57815784        if (pThis->cMonitors != cMonitors)
    5782             return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Monitor count changed: config=%u state=%u"), pThis->cMonitors, cMonitors);
     5785            return pHlp->pfnSSMSetCfgError(pSSM, RT_SRC_POS, N_("Monitor count changed: config=%u state=%u"), pThis->cMonitors, cMonitors);
    57835786    }
    57845787
    57855788    if (uPass == SSM_PASS_FINAL)
    57865789    {
    5787         rc = vga_load(pSSM, pThis, uVersion);
     5790        rc = vga_load(pHlp, pSSM, pThis, uVersion);
    57885791        if (RT_FAILURE(rc))
    57895792            return rc;
    … …  
    57965799        if (uVersion > VGA_SAVEDSTATE_VERSION_HGSMI)
    57975800        {
    5798             rc = SSMR3GetBool(pSSM, &fWithHgsmi);
     5801            rc = pHlp->pfnSSMGetBool(pSSM, &fWithHgsmi);
    57995802            AssertRCReturn(rc, rc);
    58005803        }
    … …  
    58055808            AssertRCReturn(rc, rc);
    58065809#else
    5807             return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("HGSMI is not compiled in, but it is present in the saved state"));
     5810            return pHlp->pfnSSMSetCfgError(pSSM, RT_SRC_POS, N_("HGSMI is not compiled in, but it is present in the saved state"));
    58085811#endif
    58095812        }
    … …  
    58135816        {
    58145817            uint32_t u32;
    5815             rc = SSMR3GetU32(pSSM, &u32);
     5818            rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    58165819            if (u32)
    58175820            {
    … …  
    58195822                if (u32 == 1)
    58205823                {
    5821                     rc = vboxVDMASaveLoadExecPerform(pThis->pVdma, pSSM, uVersion);
     5824                    rc = vboxVDMASaveLoadExecPerform(pHlp, pThis->pVdma, pSSM, uVersion);
    58225825                    AssertRCReturn(rc, rc);
    58235826                }

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

    r82043 r82048  
    576576int vboxVDMASaveStateExecPrep(struct VBOXVDMAHOST *pVdma);
    577577int vboxVDMASaveStateExecDone(struct VBOXVDMAHOST *pVdma);
    578 int vboxVDMASaveStateExecPerform(struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM);
    579 int vboxVDMASaveLoadExecPerform(struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM, uint32_t u32Version);
     578int vboxVDMASaveStateExecPerform(PCPDMDEVHLPR3 pHlp, struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM);
     579int vboxVDMASaveLoadExecPerform(PCPDMDEVHLPR3 pHlp, struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM, uint32_t u32Version);
    580580int vboxVDMASaveLoadDone(struct VBOXVDMAHOST *pVdma);
    581581# endif /* VBOX_WITH_VDMA */

  • trunk/src/VBox/Devices/Graphics/DevVGASavedState.h

    r76565 r82048  
    3030/** Puts a marker. Status code is not checked. */
    3131#define VGA_SAVED_STATE_PUT_MARKER(pSSM, uSub) \
    32     do { SSMR3PutU64(pSSM, VGA_SAVED_STATE_MAKE_MARKER(uSub)); } while (0)
     32    do { pHlp->pfnSSMPutU64(pSSM, VGA_SAVED_STATE_MAKE_MARKER(uSub)); } while (0)
    3333
    3434/** Retrieves a VGA saved state marker and checks that it matches, if it
    … …  
    3939        { \
    4040            uint64_t uMarker; \
    41             int rcMarker = SSMR3GetU64(pSSM, &uMarker); \
     41            int rcMarker = pHlp->pfnSSMGetU64(pSSM, &uMarker); \
    4242            AssertLogRelRCReturn(rcMarker, rcMarker); \
    4343            AssertLogRelMsgReturn(uMarker == VGA_SAVED_STATE_MAKE_MARKER(uSub), \

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

    r80872 r82048  
    993993}
    994994
    995 static int vbvaVHWACommandSavePending(PVGASTATE pVGAState, PSSMHANDLE pSSM)
    996 {
    997     int rc = SSMR3PutU32(pSSM, pVGAState->pendingVhwaCommands.cPending);
     995static int vbvaVHWACommandSavePending(PCPDMDEVHLPR3 pHlp, PVGASTATE pVGAState, PSSMHANDLE pSSM)
     996{
     997    int rc = pHlp->pfnSSMPutU32(pSSM, pVGAState->pendingVhwaCommands.cPending);
    998998    AssertRCReturn(rc, rc);
    999999
    … …  
    10021002    {
    10031003        AssertContinue((uintptr_t)pIter->pCommand - (uintptr_t)pVGAState->vram_ptrR3 < pVGAState->vram_size);
    1004         rc = SSMR3PutU32(pSSM, (uint32_t)(((uint8_t *)pIter->pCommand) - ((uint8_t *)pVGAState->vram_ptrR3)));
     1004        rc = pHlp->pfnSSMPutU32(pSSM, (uint32_t)(((uint8_t *)pIter->pCommand) - ((uint8_t *)pVGAState->vram_ptrR3)));
    10051005        AssertRCReturn(rc, rc);
    10061006    }
    … …  
    10081008}
    10091009
    1010 static int vbvaVHWACommandLoadPending(PVGASTATE pVGAState, PSSMHANDLE pSSM, uint32_t u32Version)
     1010static int vbvaVHWACommandLoadPending(PCPDMDEVHLPR3 pHlp, PVGASTATE pVGAState, PSSMHANDLE pSSM, uint32_t u32Version)
    10111011{
    10121012    if (u32Version < VGA_SAVEDSTATE_VERSION_WITH_PENDVHWA)
    … …  
    10141014
    10151015    uint32_t u32;
    1016     int rc = SSMR3GetU32(pSSM, &u32);
     1016    int rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    10171017    AssertRCReturn(rc, rc);
    10181018    for (uint32_t i = 0; i < u32; ++i)
    10191019    {
    10201020        uint32_t off32;
    1021         rc = SSMR3GetU32(pSSM, &off32);
     1021        rc = pHlp->pfnSSMGetU32(pSSM, &off32);
    10221022        AssertRCReturn(rc, rc);
    10231023        VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand
    … …  
    14981498
    14991499    int rc;
     1500    PCPDMDEVHLPR3 pHlp = pVGAState->pDevInsR3->pHlpR3;
    15001501
    15011502    if (pData->ab2DOn[iDisplay])
    15021503    {
    1503         rc = SSMR3PutU32 (pData->pSSM, VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC); AssertRC(rc);
     1504        rc = pHlp->pfnSSMPutU32(pData->pSSM, VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC); AssertRC(rc);
    15041505        if (RT_FAILURE(rc))
    15051506        {
    … …  
    15101511    }
    15111512
    1512     rc = SSMR3PutU32 (pData->pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC); AssertRC(rc);
     1513    rc = pHlp->pfnSSMPutU32(pData->pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC); AssertRC(rc);
    15131514    if (RT_FAILURE(rc))
    15141515    {
    … …  
    15531554    }
    15541555
     1556    PCPDMDEVHLPR3 pHlp = pVGAState->pDevInsR3->pHlpR3;
    15551557    Assert(RT_SUCCESS(pCmd->rc) || pCmd->rc == VERR_NOT_IMPLEMENTED);
    15561558    if (pCmd->rc == VERR_NOT_IMPLEMENTED)
    15571559    {
    1558         pData->rc = SSMR3SkipToEndOfUnit(pData->pSSM);
     1560        pData->rc = pHlp->pfnSSMSkipToEndOfUnit(pData->pSSM);
    15591561        AssertRC(pData->rc);
    15601562        return false;
    … …  
    15841586    }
    15851587
     1588    PCPDMDEVHLPR3 pHlp = pVGAState->pDevInsR3->pHlpR3;
    15861589    int rc;
    15871590    uint32_t u32;
    1588     rc = SSMR3GetU32(pData->pSSM, &u32); AssertRC(rc);
     1591    rc = pHlp->pfnSSMGetU32(pData->pSSM, &u32); AssertRC(rc);
    15891592    if (RT_FAILURE(rc))
    15901593    {
    … …  
    16081611#endif /* #ifdef VBOX_WITH_VIDEOHWACCEL */
    16091612
    1610 int vboxVBVASaveDevStateExec (PVGASTATE pVGAState, PSSMHANDLE pSSM)
     1613int vboxVBVASaveDevStateExec(PCPDMDEVHLPR3 pHlp, PVGASTATE pVGAState, PSSMHANDLE pSSM)
    16111614{
    16121615    PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
    1613     int rc = HGSMIHostSaveStateExec (pIns, pSSM);
     1616    int rc = HGSMIHostSaveStateExec(pHlp, pIns, pSSM);
    16141617    if (RT_SUCCESS(rc))
    16151618    {
    … …  
    16241627
    16251628            /* Still write a valid value to the SSM. */
    1626             rc = SSMR3PutU32 (pSSM, 0);
     1629            rc = pHlp->pfnSSMPutU32 (pSSM, 0);
    16271630            AssertRCReturn(rc, rc);
    16281631        }
    … …  
    16331636#endif
    16341637
    1635             rc = SSMR3PutU32 (pSSM, pCtx->cViews);
     1638            rc = pHlp->pfnSSMPutU32 (pSSM, pCtx->cViews);
    16361639            AssertRCReturn(rc, rc);
    16371640
    … …  
    16411644                VBVAVIEW *pView = &pCtx->aViews[iView];
    16421645
    1643                 rc = SSMR3PutU32 (pSSM, pView->view.u32ViewIndex);
    1644                 AssertRCReturn(rc, rc);
    1645                 rc = SSMR3PutU32 (pSSM, pView->view.u32ViewOffset);
    1646                 AssertRCReturn(rc, rc);
    1647                 rc = SSMR3PutU32 (pSSM, pView->view.u32ViewSize);
    1648                 AssertRCReturn(rc, rc);
    1649                 rc = SSMR3PutU32 (pSSM, pView->view.u32MaxScreenSize);
    1650                 AssertRCReturn(rc, rc);
    1651 
    1652                 rc = SSMR3PutU32 (pSSM, pView->screen.u32ViewIndex);
    1653                 AssertRCReturn(rc, rc);
    1654                 rc = SSMR3PutS32 (pSSM, pView->screen.i32OriginX);
    1655                 AssertRCReturn(rc, rc);
    1656                 rc = SSMR3PutS32 (pSSM, pView->screen.i32OriginY);
    1657                 AssertRCReturn(rc, rc);
    1658                 rc = SSMR3PutU32 (pSSM, pView->screen.u32StartOffset);
    1659                 AssertRCReturn(rc, rc);
    1660                 rc = SSMR3PutU32 (pSSM, pView->screen.u32LineSize);
    1661                 AssertRCReturn(rc, rc);
    1662                 rc = SSMR3PutU32 (pSSM, pView->screen.u32Width);
    1663                 AssertRCReturn(rc, rc);
    1664                 rc = SSMR3PutU32 (pSSM, pView->screen.u32Height);
    1665                 AssertRCReturn(rc, rc);
    1666                 rc = SSMR3PutU16 (pSSM, pView->screen.u16BitsPerPixel);
    1667                 AssertRCReturn(rc, rc);
    1668                 rc = SSMR3PutU16 (pSSM, pView->screen.u16Flags);
    1669                 AssertRCReturn(rc, rc);
    1670 
    1671                 rc = SSMR3PutU32 (pSSM, pView->vbva.guest.pVBVA? pView->vbva.u32VBVAOffset: HGSMIOFFSET_VOID);
    1672                 AssertRCReturn(rc, rc);
    1673 
    1674                 rc = SSMR3PutU32 (pSSM, pView->vbva.partialRecord.cb);
     1646                rc = pHlp->pfnSSMPutU32(pSSM, pView->view.u32ViewIndex);
     1647                AssertRCReturn(rc, rc);
     1648                rc = pHlp->pfnSSMPutU32(pSSM, pView->view.u32ViewOffset);
     1649                AssertRCReturn(rc, rc);
     1650                rc = pHlp->pfnSSMPutU32(pSSM, pView->view.u32ViewSize);
     1651                AssertRCReturn(rc, rc);
     1652                rc = pHlp->pfnSSMPutU32(pSSM, pView->view.u32MaxScreenSize);
     1653                AssertRCReturn(rc, rc);
     1654
     1655                rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32ViewIndex);
     1656                AssertRCReturn(rc, rc);
     1657                rc = pHlp->pfnSSMPutS32(pSSM, pView->screen.i32OriginX);
     1658                AssertRCReturn(rc, rc);
     1659                rc = pHlp->pfnSSMPutS32(pSSM, pView->screen.i32OriginY);
     1660                AssertRCReturn(rc, rc);
     1661                rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32StartOffset);
     1662                AssertRCReturn(rc, rc);
     1663                rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32LineSize);
     1664                AssertRCReturn(rc, rc);
     1665                rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32Width);
     1666                AssertRCReturn(rc, rc);
     1667                rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32Height);
     1668                AssertRCReturn(rc, rc);
     1669                rc = pHlp->pfnSSMPutU16(pSSM, pView->screen.u16BitsPerPixel);
     1670                AssertRCReturn(rc, rc);
     1671                rc = pHlp->pfnSSMPutU16(pSSM, pView->screen.u16Flags);
     1672                AssertRCReturn(rc, rc);
     1673
     1674                rc = pHlp->pfnSSMPutU32(pSSM, pView->vbva.guest.pVBVA? pView->vbva.u32VBVAOffset: HGSMIOFFSET_VOID);
     1675                AssertRCReturn(rc, rc);
     1676
     1677                rc = pHlp->pfnSSMPutU32(pSSM, pView->vbva.partialRecord.cb);
    16751678                AssertRCReturn(rc, rc);
    16761679
    16771680                if (pView->vbva.partialRecord.cb > 0)
    16781681                {
    1679                     rc = SSMR3PutMem (pSSM, pView->vbva.partialRecord.pu8, pView->vbva.partialRecord.cb);
     1682                    rc = pHlp->pfnSSMPutMem(pSSM, pView->vbva.partialRecord.pu8, pView->vbva.partialRecord.cb);
    16801683                    AssertRCReturn(rc, rc);
    16811684                }
    … …  
    16831686
    16841687            /* Save mouse pointer shape information. */
    1685             rc = SSMR3PutBool (pSSM, pCtx->mouseShapeInfo.fSet);
     1688            rc = pHlp->pfnSSMPutBool(pSSM, pCtx->mouseShapeInfo.fSet);
    16861689            AssertRCReturn(rc, rc);
    1687             rc = SSMR3PutBool (pSSM, pCtx->mouseShapeInfo.fVisible);
     1690            rc = pHlp->pfnSSMPutBool(pSSM, pCtx->mouseShapeInfo.fVisible);
    16881691            AssertRCReturn(rc, rc);
    1689             rc = SSMR3PutBool (pSSM, pCtx->mouseShapeInfo.fAlpha);
     1692            rc = pHlp->pfnSSMPutBool(pSSM, pCtx->mouseShapeInfo.fAlpha);
    16901693            AssertRCReturn(rc, rc);
    1691             rc = SSMR3PutU32 (pSSM, pCtx->mouseShapeInfo.u32HotX);
     1694            rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.u32HotX);
    16921695            AssertRCReturn(rc, rc);
    1693             rc = SSMR3PutU32 (pSSM, pCtx->mouseShapeInfo.u32HotY);
     1696            rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.u32HotY);
    16941697            AssertRCReturn(rc, rc);
    1695             rc = SSMR3PutU32 (pSSM, pCtx->mouseShapeInfo.u32Width);
     1698            rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.u32Width);
    16961699            AssertRCReturn(rc, rc);
    1697             rc = SSMR3PutU32 (pSSM, pCtx->mouseShapeInfo.u32Height);
     1700            rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.u32Height);
    16981701            AssertRCReturn(rc, rc);
    1699             rc = SSMR3PutU32 (pSSM, pCtx->mouseShapeInfo.cbShape);
     1702            rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.cbShape);
    17001703            AssertRCReturn(rc, rc);
    17011704            if (pCtx->mouseShapeInfo.cbShape)
    17021705            {
    1703                 rc = SSMR3PutMem (pSSM, pCtx->mouseShapeInfo.pu8Shape, pCtx->mouseShapeInfo.cbShape);
     1706                rc = pHlp->pfnSSMPutMem(pSSM, pCtx->mouseShapeInfo.pu8Shape, pCtx->mouseShapeInfo.cbShape);
    17041707                AssertRCReturn(rc, rc);
    17051708            }
    … …  
    17071710#ifdef VBOX_WITH_WDDM
    17081711            /* Size of some additional data. For future extensions. */
    1709             rc = SSMR3PutU32 (pSSM, 4);
     1712            rc = pHlp->pfnSSMPutU32(pSSM, 4);
    17101713            AssertRCReturn(rc, rc);
    1711             rc = SSMR3PutU32 (pSSM, pVGAState->fGuestCaps);
     1714            rc = pHlp->pfnSSMPutU32(pSSM, pVGAState->fGuestCaps);
    17121715            AssertRCReturn(rc, rc);
    17131716#else
    17141717            /* Size of some additional data. For future extensions. */
    1715             rc = SSMR3PutU32 (pSSM, 0);
     1718            rc = pHlp->pfnSSMPutU32(pSSM, 0);
    17161719            AssertRCReturn(rc, rc);
    17171720#endif
    1718             rc = SSMR3PutU32 (pSSM, RT_ELEMENTS(pCtx->aModeHints));
     1721            rc = pHlp->pfnSSMPutU32(pSSM, RT_ELEMENTS(pCtx->aModeHints));
    17191722            AssertRCReturn(rc, rc);
    1720             rc = SSMR3PutU32 (pSSM, sizeof(VBVAMODEHINT));
     1723            rc = pHlp->pfnSSMPutU32(pSSM, sizeof(VBVAMODEHINT));
    17211724            AssertRCReturn(rc, rc);
    17221725            for (unsigned i = 0; i < RT_ELEMENTS(pCtx->aModeHints); ++i)
    17231726            {
    1724                 rc = SSMR3PutMem (pSSM, &pCtx->aModeHints[i],
    1725                                   sizeof(VBVAMODEHINT));
     1727                rc = pHlp->pfnSSMPutMem(pSSM, &pCtx->aModeHints[i], sizeof(VBVAMODEHINT));
    17261728                AssertRCReturn(rc, rc);
    17271729            }
    … …  
    17321734}
    17331735
    1734 int vboxVBVASaveStateExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    1735 {
    1736     PVGASTATE pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
     1736int vboxVBVASaveStateExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
     1737{
     1738    PVGASTATE       pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
     1739    PCPDMDEVHLPR3   pHlp      = pDevIns->pHlpR3;
    17371740    int rc;
    17381741#ifdef VBOX_WITH_VIDEOHWACCEL
    … …  
    17441747    if(pCmd)
    17451748    {
    1746         vbvaVHWAHHPost (pVGAState, pCmd, NULL, vboxVBVASaveStateBeginPostCb, &VhwaData);
     1749        vbvaVHWAHHPost(pVGAState, pCmd, NULL, vboxVBVASaveStateBeginPostCb, &VhwaData);
    17471750        rc = VhwaData.rc;
    17481751        AssertRC(rc);
    … …  
    17501753        {
    17511754#endif
    1752             rc = vboxVBVASaveDevStateExec (pVGAState, pSSM);
     1755            rc = vboxVBVASaveDevStateExec(pHlp, pVGAState, pSSM);
    17531756            AssertRC(rc);
    17541757#ifdef VBOX_WITH_VIDEOHWACCEL
    … …  
    17581761                VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM *pSave = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM);
    17591762                pSave->pSSM = pSSM;
    1760                 vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVASaveStatePerformPreCb, NULL, &VhwaData);
     1763                vbvaVHWAHHPost(pVGAState, pCmd, vboxVBVASaveStatePerformPreCb, NULL, &VhwaData);
    17611764                rc = VhwaData.rc;
    17621765                AssertRC(rc);
    17631766                if (RT_SUCCESS(rc))
    17641767                {
    1765                     rc = vbvaVHWACommandSavePending(pVGAState, pSSM);
     1768                    rc = vbvaVHWACommandSavePending(pHlp, pVGAState, pSSM);
    17661769                    AssertRCReturn(rc, rc);
    17671770
    17681771                    vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND, 0);
    1769                     vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVASaveStateEndPreCb, NULL, &VhwaData);
     1772                    vbvaVHWAHHPost(pVGAState, pCmd, vboxVBVASaveStateEndPreCb, NULL, &VhwaData);
    17701773                    rc = VhwaData.rc;
    17711774                    AssertRC(rc);
    … …  
    17831786        for (uint32_t i = 0; i < pVGAState->cMonitors; ++i)
    17841787        {
    1785             rc = SSMR3PutU32 (pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC);
     1788            rc = pHlp->pfnSSMPutU32(pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC);
    17861789            AssertRCReturn(rc, rc);
    17871790        }
    … …  
    17891792
    17901793    /* no pending commands */
    1791     SSMR3PutU32(pSSM, 0);
     1794    pHlp->pfnSSMPutU32(pSSM, 0);
    17921795#endif
    17931796    return rc;
    17941797}
    17951798
    1796 int vboxVBVALoadStateExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion)
     1799int vboxVBVALoadStateExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion)
    17971800{
    17981801    if (uVersion < VGA_SAVEDSTATE_VERSION_HGSMI)
    … …  
    18021805    }
    18031806
    1804     PVGASTATE pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
    1805     PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
    1806     int rc = HGSMIHostLoadStateExec (pIns, pSSM, uVersion);
     1807    PVGASTATE       pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
     1808    PHGSMIINSTANCE  pIns      = pVGAState->pHGSMI;
     1809    PCPDMDEVHLPR3   pHlp      = pDevIns->pHlpR3;
     1810    int rc = HGSMIHostLoadStateExec(pHlp, pIns, pSSM, uVersion);
    18071811    if (RT_SUCCESS(rc))
    18081812    {
    … …  
    18211825        {
    18221826            uint32_t cViews = 0;
    1823             rc = SSMR3GetU32 (pSSM, &cViews);
     1827            rc = pHlp->pfnSSMGetU32 (pSSM, &cViews);
    18241828            AssertRCReturn(rc, rc);
    18251829
    … …  
    18291833                VBVAVIEW *pView = &pCtx->aViews[iView];
    18301834
    1831                 rc = SSMR3GetU32 (pSSM, &pView->view.u32ViewIndex);
    1832                 AssertRCReturn(rc, rc);
    1833                 rc = SSMR3GetU32 (pSSM, &pView->view.u32ViewOffset);
    1834                 AssertRCReturn(rc, rc);
    1835                 rc = SSMR3GetU32 (pSSM, &pView->view.u32ViewSize);
    1836                 AssertRCReturn(rc, rc);
    1837                 rc = SSMR3GetU32 (pSSM, &pView->view.u32MaxScreenSize);
    1838                 AssertRCReturn(rc, rc);
    1839 
    1840                 rc = SSMR3GetU32 (pSSM, &pView->screen.u32ViewIndex);
    1841                 AssertRCReturn(rc, rc);
    1842                 rc = SSMR3GetS32 (pSSM, &pView->screen.i32OriginX);
    1843                 AssertRCReturn(rc, rc);
    1844                 rc = SSMR3GetS32 (pSSM, &pView->screen.i32OriginY);
    1845                 AssertRCReturn(rc, rc);
    1846                 rc = SSMR3GetU32 (pSSM, &pView->screen.u32StartOffset);
    1847                 AssertRCReturn(rc, rc);
    1848                 rc = SSMR3GetU32 (pSSM, &pView->screen.u32LineSize);
    1849                 AssertRCReturn(rc, rc);
    1850                 rc = SSMR3GetU32 (pSSM, &pView->screen.u32Width);
    1851                 AssertRCReturn(rc, rc);
    1852                 rc = SSMR3GetU32 (pSSM, &pView->screen.u32Height);
    1853                 AssertRCReturn(rc, rc);
    1854                 rc = SSMR3GetU16 (pSSM, &pView->screen.u16BitsPerPixel);
    1855                 AssertRCReturn(rc, rc);
    1856                 rc = SSMR3GetU16 (pSSM, &pView->screen.u16Flags);
    1857                 AssertRCReturn(rc, rc);
    1858 
    1859                 rc = SSMR3GetU32 (pSSM, &pView->vbva.u32VBVAOffset);
    1860                 AssertRCReturn(rc, rc);
    1861 
    1862                 rc = SSMR3GetU32 (pSSM, &pView->vbva.partialRecord.cb);
     1835                rc = pHlp->pfnSSMGetU32 (pSSM, &pView->view.u32ViewIndex);
     1836                AssertRCReturn(rc, rc);
     1837                rc = pHlp->pfnSSMGetU32 (pSSM, &pView->view.u32ViewOffset);
     1838                AssertRCReturn(rc, rc);
     1839                rc = pHlp->pfnSSMGetU32 (pSSM, &pView->view.u32ViewSize);
     1840                AssertRCReturn(rc, rc);
     1841                rc = pHlp->pfnSSMGetU32 (pSSM, &pView->view.u32MaxScreenSize);
     1842                AssertRCReturn(rc, rc);
     1843
     1844                rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32ViewIndex);
     1845                AssertRCReturn(rc, rc);
     1846                rc = pHlp->pfnSSMGetS32 (pSSM, &pView->screen.i32OriginX);
     1847                AssertRCReturn(rc, rc);
     1848                rc = pHlp->pfnSSMGetS32 (pSSM, &pView->screen.i32OriginY);
     1849                AssertRCReturn(rc, rc);
     1850                rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32StartOffset);
     1851                AssertRCReturn(rc, rc);
     1852                rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32LineSize);
     1853                AssertRCReturn(rc, rc);
     1854                rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32Width);
     1855                AssertRCReturn(rc, rc);
     1856                rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32Height);
     1857                AssertRCReturn(rc, rc);
     1858                rc = pHlp->pfnSSMGetU16 (pSSM, &pView->screen.u16BitsPerPixel);
     1859                AssertRCReturn(rc, rc);
     1860                rc = pHlp->pfnSSMGetU16 (pSSM, &pView->screen.u16Flags);
     1861                AssertRCReturn(rc, rc);
     1862
     1863                rc = pHlp->pfnSSMGetU32 (pSSM, &pView->vbva.u32VBVAOffset);
     1864                AssertRCReturn(rc, rc);
     1865
     1866                rc = pHlp->pfnSSMGetU32 (pSSM, &pView->vbva.partialRecord.cb);
    18631867                AssertRCReturn(rc, rc);
    18641868
    … …  
    18801884                    pView->vbva.partialRecord.pu8 = pu8;
    18811885
    1882                     rc = SSMR3GetMem (pSSM, pView->vbva.partialRecord.pu8, pView->vbva.partialRecord.cb);
     1886                    rc = pHlp->pfnSSMGetMem (pSSM, pView->vbva.partialRecord.pu8, pView->vbva.partialRecord.cb);
    18831887                    AssertRCReturn(rc, rc);
    18841888                }
    … …  
    18971901            {
    18981902                /* Read mouse pointer shape information. */
    1899                 rc = SSMR3GetBool (pSSM, &pCtx->mouseShapeInfo.fSet);
    1900                 AssertRCReturn(rc, rc);
    1901                 rc = SSMR3GetBool (pSSM, &pCtx->mouseShapeInfo.fVisible);
    1902                 AssertRCReturn(rc, rc);
    1903                 rc = SSMR3GetBool (pSSM, &pCtx->mouseShapeInfo.fAlpha);
    1904                 AssertRCReturn(rc, rc);
    1905                 rc = SSMR3GetU32 (pSSM, &pCtx->mouseShapeInfo.u32HotX);
    1906                 AssertRCReturn(rc, rc);
    1907                 rc = SSMR3GetU32 (pSSM, &pCtx->mouseShapeInfo.u32HotY);
    1908                 AssertRCReturn(rc, rc);
    1909                 rc = SSMR3GetU32 (pSSM, &pCtx->mouseShapeInfo.u32Width);
    1910                 AssertRCReturn(rc, rc);
    1911                 rc = SSMR3GetU32 (pSSM, &pCtx->mouseShapeInfo.u32Height);
    1912                 AssertRCReturn(rc, rc);
    1913                 rc = SSMR3GetU32 (pSSM, &pCtx->mouseShapeInfo.cbShape);
     1903                rc = pHlp->pfnSSMGetBool (pSSM, &pCtx->mouseShapeInfo.fSet);
     1904                AssertRCReturn(rc, rc);
     1905                rc = pHlp->pfnSSMGetBool (pSSM, &pCtx->mouseShapeInfo.fVisible);
     1906                AssertRCReturn(rc, rc);
     1907                rc = pHlp->pfnSSMGetBool (pSSM, &pCtx->mouseShapeInfo.fAlpha);
     1908                AssertRCReturn(rc, rc);
     1909                rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.u32HotX);
     1910                AssertRCReturn(rc, rc);
     1911                rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.u32HotY);
     1912                AssertRCReturn(rc, rc);
     1913                rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.u32Width);
     1914                AssertRCReturn(rc, rc);
     1915                rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.u32Height);
     1916                AssertRCReturn(rc, rc);
     1917                rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.cbShape);
    19141918                AssertRCReturn(rc, rc);
    19151919                if (pCtx->mouseShapeInfo.cbShape)
    … …  
    19211925                    }
    19221926                    pCtx->mouseShapeInfo.cbAllocated = pCtx->mouseShapeInfo.cbShape;
    1923                     rc = SSMR3GetMem (pSSM, pCtx->mouseShapeInfo.pu8Shape, pCtx->mouseShapeInfo.cbShape);
     1927                    rc = pHlp->pfnSSMGetMem (pSSM, pCtx->mouseShapeInfo.pu8Shape, pCtx->mouseShapeInfo.cbShape);
    19241928                    AssertRCReturn(rc, rc);
    19251929                }
    … …  
    19311935                /* Size of some additional data. For future extensions. */
    19321936                uint32_t cbExtra = 0;
    1933                 rc = SSMR3GetU32 (pSSM, &cbExtra);
     1937                rc = pHlp->pfnSSMGetU32 (pSSM, &cbExtra);
    19341938                AssertRCReturn(rc, rc);
    19351939#ifdef VBOX_WITH_WDDM
    19361940                if (cbExtra >= 4)
    19371941                {
    1938                     rc = SSMR3GetU32 (pSSM, &pVGAState->fGuestCaps);
     1942                    rc = pHlp->pfnSSMGetU32 (pSSM, &pVGAState->fGuestCaps);
    19391943                    AssertRCReturn(rc, rc);
    19401944                    pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
    … …  
    19441948                if (cbExtra > 0)
    19451949                {
    1946                     rc = SSMR3Skip(pSSM, cbExtra);
     1950                    rc = pHlp->pfnSSMSkip(pSSM, cbExtra);
    19471951                    AssertRCReturn(rc, rc);
    19481952                }
    … …  
    19511955                {
    19521956                    uint32_t cModeHints, cbModeHints;
    1953                     rc = SSMR3GetU32 (pSSM, &cModeHints);
     1957                    rc = pHlp->pfnSSMGetU32 (pSSM, &cModeHints);
    19541958                    AssertRCReturn(rc, rc);
    1955                     rc = SSMR3GetU32 (pSSM, &cbModeHints);
     1959                    rc = pHlp->pfnSSMGetU32 (pSSM, &cbModeHints);
    19561960                    AssertRCReturn(rc, rc);
    19571961                    memset(&pCtx->aModeHints, ~0, sizeof(pCtx->aModeHints));
    … …  
    19611965                        if (   cbModeHints <= sizeof(VBVAMODEHINT)
    19621966                            && iHint < RT_ELEMENTS(pCtx->aModeHints))
    1963                             rc = SSMR3GetMem(pSSM, &pCtx->aModeHints[iHint],
     1967                            rc = pHlp->pfnSSMGetMem(pSSM, &pCtx->aModeHints[iHint],
    19641968                                             cbModeHints);
    19651969                        else
    1966                             rc = SSMR3Skip(pSSM, cbModeHints);
     1970                            rc = pHlp->pfnSSMSkip(pSSM, cbModeHints);
    19671971                        AssertRCReturn(rc, rc);
    19681972                    }
    … …  
    19791983                if (uVersion < VGA_SAVEDSTATE_VERSION_FIXED_PENDVHWA)
    19801984                {
    1981                     const char *pcszOsArch = SSMR3HandleHostOSAndArch(pSSM);
     1985                    const char *pcszOsArch = pHlp->pfnSSMHandleHostOSAndArch(pSSM);
    19821986                    Assert(pcszOsArch);
    19831987                    fLoadCommands = !pcszOsArch || RTStrNCmp(pcszOsArch, RT_STR_TUPLE("solaris"));
    … …  
    20032007                    if (fLoadCommands)
    20042008                    {
    2005                         rc = vbvaVHWACommandLoadPending(pVGAState, pSSM, uVersion);
     2009                        rc = vbvaVHWACommandLoadPending(pHlp, pVGAState, pSSM, uVersion);
    20062010                        AssertRCReturn(rc, rc);
    20072011                    }
    … …  
    20162020                for (uint32_t i = 0; i < pVGAState->cMonitors; ++i)
    20172021                {
    2018                     rc = SSMR3GetU32(pSSM, &u32);
     2022                    rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    20192023                    AssertRCReturn(rc, rc);
    20202024
    … …  
    20282032                if (fLoadCommands)
    20292033                {
    2030                     rc = SSMR3GetU32(pSSM, &u32);
     2034                    rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    20312035                    AssertRCReturn(rc, rc);
    20322036

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

    r80872 r82048  
    342342}
    343343
    344 int vboxVDMASaveStateExecPerform(struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM)
     344int vboxVDMASaveStateExecPerform(PCPDMDEVHLPR3 pHlp, struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM)
    345345{
    346346    int rc;
    347347    RT_NOREF(pVdma);
    348348
    349     rc = SSMR3PutU32(pSSM, UINT32_MAX);
     349    rc = pHlp->pfnSSMPutU32(pSSM, UINT32_MAX);
    350350    AssertRCReturn(rc, rc);
    351351    return VINF_SUCCESS;
    352352}
    353353
    354 int vboxVDMASaveLoadExecPerform(struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM, uint32_t u32Version)
     354int vboxVDMASaveLoadExecPerform(PCPDMDEVHLPR3 pHlp, struct VBOXVDMAHOST *pVdma, PSSMHANDLE pSSM, uint32_t u32Version)
    355355{
    356356    uint32_t u32;
    357     int rc = SSMR3GetU32(pSSM, &u32);
     357    int rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    358358    AssertLogRelRCReturn(rc, rc);
    359359

  • trunk/src/VBox/Devices/Graphics/HGSMI/HGSMIHost.cpp

    r80295 r82048  
    7070#include <iprt/errcore.h>
    7171#include <VBox/log.h>
     72#include <VBox/vmm/pdmdev.h>
    7273#include <VBox/vmm/ssm.h>
    7374#include <VBox/vmm/vmm.h>
    … …  
    9293# define VBOXHGSMI_STATE_FIFOSTOP_MAGIC  UINT32_C(0x1fedcba9)
    9394
    94 # define VBOXHGSMI_SAVE_START(_pSSM)     do{ int rc2 = SSMR3PutU32(_pSSM, VBOXHGSMI_STATE_START_MAGIC);     AssertRC(rc2); }while(0)
    95 # define VBOXHGSMI_SAVE_STOP(_pSSM)      do{ int rc2 = SSMR3PutU32(_pSSM, VBOXHGSMI_STATE_STOP_MAGIC);      AssertRC(rc2); }while(0)
    96 # define VBOXHGSMI_SAVE_FIFOSTART(_pSSM) do{ int rc2 = SSMR3PutU32(_pSSM, VBOXHGSMI_STATE_FIFOSTART_MAGIC); AssertRC(rc2); }while(0)
    97 # define VBOXHGSMI_SAVE_FIFOSTOP(_pSSM)  do{ int rc2 = SSMR3PutU32(_pSSM, VBOXHGSMI_STATE_FIFOSTOP_MAGIC);  AssertRC(rc2); }while(0)
     95# define VBOXHGSMI_SAVE_START(_pSSM)     do{ int rc2 = pHlp->pfnSSMPutU32(_pSSM, VBOXHGSMI_STATE_START_MAGIC);     AssertRC(rc2); }while(0)
     96# define VBOXHGSMI_SAVE_STOP(_pSSM)      do{ int rc2 = pHlp->pfnSSMPutU32(_pSSM, VBOXHGSMI_STATE_STOP_MAGIC);      AssertRC(rc2); }while(0)
     97# define VBOXHGSMI_SAVE_FIFOSTART(_pSSM) do{ int rc2 = pHlp->pfnSSMPutU32(_pSSM, VBOXHGSMI_STATE_FIFOSTART_MAGIC); AssertRC(rc2); }while(0)
     98# define VBOXHGSMI_SAVE_FIFOSTOP(_pSSM)  do{ int rc2 = pHlp->pfnSSMPutU32(_pSSM, VBOXHGSMI_STATE_FIFOSTOP_MAGIC);  AssertRC(rc2); }while(0)
    9899
    99100# define VBOXHGSMI_LOAD_CHECK(_pSSM, _v) \
    100101    do { \
    101102        uint32_t u32; \
    102         int rc2 = SSMR3GetU32(_pSSM, &u32); AssertRC(rc2); \
     103        int rc2 = pHlp->pfnSSMGetU32(_pSSM, &u32); AssertRC(rc2); \
    103104        Assert(u32 == (_v)); \
    104105    } while(0)
    … …  
    960961}
    961962
    962 static int hgsmiHostSaveFifoLocked(RTLISTANCHOR *pList, PSSMHANDLE pSSM)
     963static int hgsmiHostSaveFifoLocked(PCPDMDEVHLPR3 pHlp, RTLISTANCHOR *pList, PSSMHANDLE pSSM)
    963964{
    964965    VBOXHGSMI_SAVE_FIFOSTART(pSSM);
    … …  
    972973    }
    973974
    974     int rc = SSMR3PutU32(pSSM, cEntries);
     975    int rc = pHlp->pfnSSMPutU32(pSSM, cEntries);
    975976    if (RT_SUCCESS(rc))
    976977    {
    977978        RTListForEach(pList, pIter, HGSMIHOSTFIFOENTRY, nodeEntry)
    978979        {
    979             SSMR3PutU32(pSSM, pIter->fl);
    980             rc = SSMR3PutU32(pSSM, pIter->offBuffer);
     980            pHlp->pfnSSMPutU32(pSSM, pIter->fl);
     981            rc = pHlp->pfnSSMPutU32(pSSM, pIter->offBuffer);
    981982            if (RT_FAILURE(rc))
    982983                break;
    … …  
    989990}
    990991
    991 static int hgsmiHostSaveGuestCmdCompletedFifoLocked(RTLISTANCHOR *pList, PSSMHANDLE pSSM)
     992static int hgsmiHostSaveGuestCmdCompletedFifoLocked(PCPDMDEVHLPR3 pHlp, RTLISTANCHOR *pList, PSSMHANDLE pSSM)
    992993{
    993994    VBOXHGSMI_SAVE_FIFOSTART(pSSM);
    … …  
    10001001        ++cEntries;
    10011002    }
    1002     int rc = SSMR3PutU32(pSSM, cEntries);
     1003    int rc = pHlp->pfnSSMPutU32(pSSM, cEntries);
    10031004    if (RT_SUCCESS(rc))
    10041005    {
    10051006        RTListForEach(pList, pIter, HGSMIGUESTCOMPLENTRY, nodeEntry)
    10061007        {
    1007             rc = SSMR3PutU32(pSSM, pIter->offBuffer);
     1008            rc = pHlp->pfnSSMPutU32(pSSM, pIter->offBuffer);
    10081009            if (RT_FAILURE(rc))
    10091010                break;
    … …  
    10161017}
    10171018
    1018 static int hgsmiHostLoadFifoEntryLocked(PHGSMIINSTANCE pIns, HGSMIHOSTFIFOENTRY **ppEntry, PSSMHANDLE pSSM)
     1019static int hgsmiHostLoadFifoEntryLocked(PCPDMDEVHLPR3 pHlp, PHGSMIINSTANCE pIns, HGSMIHOSTFIFOENTRY **ppEntry, PSSMHANDLE pSSM)
    10191020{
    10201021    HGSMIHOSTFIFOENTRY *pEntry;
    … …  
    10241025        uint32_t u32;
    10251026        pEntry->pIns = pIns;
    1026         rc = SSMR3GetU32(pSSM, &u32); AssertRC(rc);
     1027        rc = pHlp->pfnSSMGetU32(pSSM, &u32); AssertRC(rc);
    10271028        pEntry->fl = u32;
    1028         rc = SSMR3GetU32(pSSM, &pEntry->offBuffer); AssertRC(rc);
     1029        rc = pHlp->pfnSSMGetU32(pSSM, &pEntry->offBuffer); AssertRC(rc);
    10291030        if (RT_SUCCESS(rc))
    10301031            *ppEntry = pEntry;
    … …  
    10361037}
    10371038
    1038 static int hgsmiHostLoadFifoLocked(PHGSMIINSTANCE pIns, RTLISTANCHOR *pList, PSSMHANDLE pSSM)
     1039static int hgsmiHostLoadFifoLocked(PCPDMDEVHLPR3 pHlp, PHGSMIINSTANCE pIns, RTLISTANCHOR *pList, PSSMHANDLE pSSM)
    10391040{
    10401041    VBOXHGSMI_LOAD_FIFOSTART(pSSM);
    10411042
    10421043    uint32_t cEntries = 0;
    1043     int rc = SSMR3GetU32(pSSM, &cEntries);
     1044    int rc = pHlp->pfnSSMGetU32(pSSM, &cEntries);
    10441045    if (RT_SUCCESS(rc) && cEntries)
    10451046    {
    … …  
    10481049        {
    10491050            HGSMIHOSTFIFOENTRY *pEntry = NULL;
    1050             rc = hgsmiHostLoadFifoEntryLocked(pIns, &pEntry, pSSM);
     1051            rc = hgsmiHostLoadFifoEntryLocked(pHlp, pIns, &pEntry, pSSM);
    10511052            AssertRCBreak(rc);
    10521053
    … …  
    10601061}
    10611062
    1062 static int hgsmiHostLoadGuestCmdCompletedFifoEntryLocked (PHGSMIINSTANCE pIns, HGSMIGUESTCOMPLENTRY **ppEntry, PSSMHANDLE pSSM)
     1063static int hgsmiHostLoadGuestCmdCompletedFifoEntryLocked(PCPDMDEVHLPR3 pHlp, PHGSMIINSTANCE pIns,
     1064                                                         HGSMIGUESTCOMPLENTRY **ppEntry, PSSMHANDLE pSSM)
    10631065{
    10641066    HGSMIGUESTCOMPLENTRY *pEntry;
    … …  
    10661068    if (RT_SUCCESS (rc))
    10671069    {
    1068         rc = SSMR3GetU32(pSSM, &pEntry->offBuffer); AssertRC(rc);
     1070        rc = pHlp->pfnSSMGetU32(pSSM, &pEntry->offBuffer); AssertRC(rc);
    10691071        if (RT_SUCCESS(rc))
    10701072            *ppEntry = pEntry;
    … …  
    10751077}
    10761078
    1077 static int hgsmiHostLoadGuestCmdCompletedFifoLocked(PHGSMIINSTANCE pIns, RTLISTANCHOR *pList, PSSMHANDLE pSSM, uint32_t u32Version)
     1079static int hgsmiHostLoadGuestCmdCompletedFifoLocked(PCPDMDEVHLPR3 pHlp, PHGSMIINSTANCE pIns, RTLISTANCHOR *pList,
     1080                                                    PSSMHANDLE pSSM, uint32_t u32Version)
    10781081{
    10791082    VBOXHGSMI_LOAD_FIFOSTART(pSSM);
    … …  
    10821085
    10831086    uint32_t cEntries = 0;
    1084     int rc = SSMR3GetU32(pSSM, &cEntries);
     1087    int rc = pHlp->pfnSSMGetU32(pSSM, &cEntries);
    10851088    if (RT_SUCCESS(rc) && cEntries)
    10861089    {
    … …  
    10901093            {
    10911094                HGSMIGUESTCOMPLENTRY *pEntry = NULL;
    1092                 rc = hgsmiHostLoadGuestCmdCompletedFifoEntryLocked(pIns, &pEntry, pSSM);
     1095                rc = hgsmiHostLoadGuestCmdCompletedFifoEntryLocked(pHlp, pIns, &pEntry, pSSM);
    10931096                AssertRCBreak(rc);
    10941097
    … …  
    11051108            {
    11061109                HGSMIHOSTFIFOENTRY *pEntry = NULL;
    1107                 rc = hgsmiHostLoadFifoEntryLocked(pIns, &pEntry, pSSM);
     1110                rc = hgsmiHostLoadFifoEntryLocked(pHlp, pIns, &pEntry, pSSM);
    11081111                AssertRCBreak(rc);
    11091112
    … …  
    11181121}
    11191122
    1120 static int hgsmiHostSaveMA(PSSMHANDLE pSSM, HGSMIMADATA *pMA)
    1121 {
    1122     int rc = SSMR3PutU32(pSSM, pMA->cBlocks);
     1123static int hgsmiHostSaveMA(PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM, HGSMIMADATA *pMA)
     1124{
     1125    int rc = pHlp->pfnSSMPutU32(pSSM, pMA->cBlocks);
    11231126    if (RT_SUCCESS(rc))
    11241127    {
    … …  
    11261129        RTListForEach(&pMA->listBlocks, pIter, HGSMIMABLOCK, nodeBlock)
    11271130        {
    1128             SSMR3PutU32(pSSM, pIter->descriptor);
    1129         }
    1130 
    1131         rc = SSMR3PutU32(pSSM, pMA->cbMaxBlock);
    1132     }
    1133 
    1134     return rc;
    1135 }
    1136 
    1137 static int hgsmiHostLoadMA(PSSMHANDLE pSSM, uint32_t *pcBlocks, HGSMIOFFSET **ppaDescriptors, HGSMISIZE *pcbMaxBlock)
    1138 {
    1139     int rc = SSMR3GetU32(pSSM, pcBlocks);
     1131            pHlp->pfnSSMPutU32(pSSM, pIter->descriptor);
     1132        }
     1133
     1134        rc = pHlp->pfnSSMPutU32(pSSM, pMA->cbMaxBlock);
     1135    }
     1136
     1137    return rc;
     1138}
     1139
     1140static int hgsmiHostLoadMA(PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM, uint32_t *pcBlocks,
     1141                           HGSMIOFFSET **ppaDescriptors, HGSMISIZE *pcbMaxBlock)
     1142{
     1143    int rc = pHlp->pfnSSMGetU32(pSSM, pcBlocks);
    11401144    if (RT_SUCCESS(rc))
    11411145    {
    … …  
    11481152                uint32_t i;
    11491153                for (i = 0; i < *pcBlocks; ++i)
    1150                     SSMR3GetU32(pSSM, &paDescriptors[i]);
     1154                    pHlp->pfnSSMGetU32(pSSM, &paDescriptors[i]);
    11511155            }
    11521156            else
    … …  
    11551159
    11561160        if (RT_SUCCESS(rc))
    1157             rc = SSMR3GetU32(pSSM, pcbMaxBlock);
     1161            rc = pHlp->pfnSSMGetU32(pSSM, pcbMaxBlock);
    11581162        if (RT_SUCCESS(rc))
    11591163            *ppaDescriptors = paDescriptors;
    … …  
    11651169}
    11661170
    1167 int HGSMIHostSaveStateExec(PHGSMIINSTANCE pIns, PSSMHANDLE pSSM)
     1171int HGSMIHostSaveStateExec(PCPDMDEVHLPR3 pHlp, PHGSMIINSTANCE pIns, PSSMHANDLE pSSM)
    11681172{
    11691173    VBOXHGSMI_SAVE_START(pSSM);
    … …  
    11711175    int rc;
    11721176
    1173     SSMR3PutU32(pSSM, pIns->hostHeap.u32HeapType);
     1177    pHlp->pfnSSMPutU32(pSSM, pIns->hostHeap.u32HeapType);
    11741178
    11751179    HGSMIOFFSET off = pIns->pHGFlags ? HGSMIPointerToOffset(&pIns->area, (const HGSMIBUFFERHEADER *)pIns->pHGFlags)
    11761180                                     : HGSMIOFFSET_VOID;
    1177     SSMR3PutU32(pSSM, off);
     1181    pHlp->pfnSSMPutU32(pSSM, off);
    11781182
    11791183    off = pIns->hostHeap.u32HeapType == HGSMI_HEAP_TYPE_MA ? 0 : hgsmiHostHeapHandleLocationOffset(&pIns->hostHeap);
    1180     rc = SSMR3PutU32 (pSSM, off);
     1184    rc = pHlp->pfnSSMPutU32 (pSSM, off);
    11811185    if (off != HGSMIOFFSET_VOID)
    11821186    {
    1183         SSMR3PutU32(pSSM, hgsmiHostHeapOffset(&pIns->hostHeap));
    1184         SSMR3PutU32(pSSM, hgsmiHostHeapSize(&pIns->hostHeap));
     1187        pHlp->pfnSSMPutU32(pSSM, hgsmiHostHeapOffset(&pIns->hostHeap));
     1188        pHlp->pfnSSMPutU32(pSSM, hgsmiHostHeapSize(&pIns->hostHeap));
    11851189        /* need save mem pointer to calculate offset on restore */
    1186         SSMR3PutU64(pSSM, (uint64_t)(uintptr_t)pIns->area.pu8Base);
     1190        pHlp->pfnSSMPutU64(pSSM, (uint64_t)(uintptr_t)pIns->area.pu8Base);
    11871191        rc = hgsmiFIFOLock (pIns);
    11881192        if (RT_SUCCESS(rc))
    11891193        {
    1190             rc = hgsmiHostSaveFifoLocked(&pIns->hostFIFO, pSSM); AssertRC(rc);
    1191             rc = hgsmiHostSaveFifoLocked(&pIns->hostFIFORead, pSSM); AssertRC(rc);
    1192             rc = hgsmiHostSaveFifoLocked(&pIns->hostFIFOProcessed, pSSM); AssertRC(rc);
     1194            rc = hgsmiHostSaveFifoLocked(pHlp, &pIns->hostFIFO, pSSM); AssertRC(rc);
     1195            rc = hgsmiHostSaveFifoLocked(pHlp, &pIns->hostFIFORead, pSSM); AssertRC(rc);
     1196            rc = hgsmiHostSaveFifoLocked(pHlp, &pIns->hostFIFOProcessed, pSSM); AssertRC(rc);
    11931197#ifdef VBOX_WITH_WDDM
    1194             rc = hgsmiHostSaveGuestCmdCompletedFifoLocked(&pIns->guestCmdCompleted, pSSM); AssertRC(rc);
     1198            rc = hgsmiHostSaveGuestCmdCompletedFifoLocked(pHlp, &pIns->guestCmdCompleted, pSSM); AssertRC(rc);
    11951199#endif
    11961200
    … …  
    12001204        if (RT_SUCCESS(rc))
    12011205            if (pIns->hostHeap.u32HeapType == HGSMI_HEAP_TYPE_MA)
    1202                 rc = hgsmiHostSaveMA(pSSM, &pIns->hostHeap.u.ma);
     1206                rc = hgsmiHostSaveMA(pHlp, pSSM, &pIns->hostHeap.u.ma);
    12031207    }
    12041208
    … …  
    12081212}
    12091213
    1210 int HGSMIHostLoadStateExec(PHGSMIINSTANCE pIns, PSSMHANDLE pSSM, uint32_t u32Version)
     1214int HGSMIHostLoadStateExec(PCPDMDEVHLPR3 pHlp, PHGSMIINSTANCE pIns, PSSMHANDLE pSSM, uint32_t u32Version)
    12111215{
    12121216    if (u32Version < VGA_SAVEDSTATE_VERSION_HGSMI)
    … …  
    12191223    if (u32Version >= VGA_SAVEDSTATE_VERSION_HGSMIMA)
    12201224    {
    1221         rc = SSMR3GetU32(pSSM, &u32HeapType);
     1225        rc = pHlp->pfnSSMGetU32(pSSM, &u32HeapType);
    12221226        AssertRCReturn(rc, rc);
    12231227    }
    12241228
    12251229    HGSMIOFFSET off;
    1226     rc = SSMR3GetU32(pSSM, &off);
     1230    rc = pHlp->pfnSSMGetU32(pSSM, &off);
    12271231    AssertLogRelRCReturn(rc, rc);
    12281232    pIns->pHGFlags = off != HGSMIOFFSET_VOID ? (HGSMIHOSTFLAGS *)HGSMIOffsetToPointer(&pIns->area, off) : NULL;
    12291233
    1230     rc = SSMR3GetU32(pSSM, &off);
     1234    rc = pHlp->pfnSSMGetU32(pSSM, &off);
    12311235    AssertLogRelRCReturn(rc, rc);
    12321236    if (off != HGSMIOFFSET_VOID)
    … …  
    12381242
    12391243        HGSMIOFFSET offHeap;
    1240         SSMR3GetU32(pSSM, &offHeap);
     1244        pHlp->pfnSSMGetU32(pSSM, &offHeap);
    12411245        uint32_t cbHeap;
    1242         SSMR3GetU32(pSSM, &cbHeap);
     1246        pHlp->pfnSSMGetU32(pSSM, &cbHeap);
    12431247        uint64_t oldMem;
    1244         rc = SSMR3GetU64(pSSM, &oldMem);
     1248        rc = pHlp->pfnSSMGetU64(pSSM, &oldMem);
    12451249        AssertLogRelRCReturn(rc, rc);
    12461250
    … …  
    12501254            if (RT_SUCCESS(rc))
    12511255            {
    1252                 rc = hgsmiHostLoadFifoLocked(pIns, &pIns->hostFIFO, pSSM);
     1256                rc = hgsmiHostLoadFifoLocked(pHlp, pIns, &pIns->hostFIFO, pSSM);
    12531257                if (RT_SUCCESS(rc))
    1254                     rc = hgsmiHostLoadFifoLocked(pIns, &pIns->hostFIFORead, pSSM);
     1258                    rc = hgsmiHostLoadFifoLocked(pHlp, pIns, &pIns->hostFIFORead, pSSM);
    12551259                if (RT_SUCCESS(rc))
    1256                     rc = hgsmiHostLoadFifoLocked(pIns, &pIns->hostFIFOProcessed, pSSM);
     1260                    rc = hgsmiHostLoadFifoLocked(pHlp, pIns, &pIns->hostFIFOProcessed, pSSM);
    12571261#ifdef VBOX_WITH_WDDM
    12581262                if (RT_SUCCESS(rc) && u32Version > VGA_SAVEDSTATE_VERSION_PRE_WDDM)
    1259                     rc = hgsmiHostLoadGuestCmdCompletedFifoLocked(pIns, &pIns->guestCmdCompleted, pSSM, u32Version);
     1263                    rc = hgsmiHostLoadGuestCmdCompletedFifoLocked(pHlp, pIns, &pIns->guestCmdCompleted, pSSM, u32Version);
    12601264#endif
    12611265
    … …  
    12711275                HGSMISIZE cbMaxBlock = 0;
    12721276                HGSMIOFFSET *paDescriptors = NULL;
    1273                 rc = hgsmiHostLoadMA(pSSM, &cBlocks, &paDescriptors, &cbMaxBlock);
     1277                rc = hgsmiHostLoadMA(pHlp, pSSM, &cBlocks, &paDescriptors, &cbMaxBlock);
    12741278                if (RT_SUCCESS(rc))
    12751279                {

  • trunk/src/VBox/Devices/Graphics/HGSMI/HGSMIHost.h

    r80295 r82048  
    102102int HGSMIHostCommandFree(PHGSMIINSTANCE pIns, void RT_UNTRUSTED_VOLATILE_GUEST *pvData);
    103103
    104 int HGSMIHostLoadStateExec(PHGSMIINSTANCE pIns, PSSMHANDLE pSSM, uint32_t u32Version);
    105 int HGSMIHostSaveStateExec(PHGSMIINSTANCE pIns, PSSMHANDLE pSSM);
     104int HGSMIHostLoadStateExec(const struct PDMDEVHLPR3 *pHlp, PHGSMIINSTANCE pIns, PSSMHANDLE pSSM, uint32_t u32Version);
     105int HGSMIHostSaveStateExec(const struct PDMDEVHLPR3 *pHlp, PHGSMIINSTANCE pIns, PSSMHANDLE pSSM);
    106106
    107107#ifdef VBOX_WITH_WDDM
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