VirtualBox

Changeset 91887 in vbox


Ignore:
Timestamp:
Oct 20, 2021 12:02:36 PM (3 years ago)
Author:
vboxsync
Message:

Devices/VMMDev: Access SSM API only through the device helper callbacks, bugref:10074

Location:
trunk/src/VBox/Devices/VMMDev
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r91548 r91887  
    39573957{
    39583958    RT_NOREF(uPass);
    3959     PVMMDEV pThis = PDMDEVINS_2_DATA(pDevIns, PVMMDEV);
    3960 
    3961     SSMR3PutBool(pSSM, pThis->fGetHostTimeDisabled);
    3962     SSMR3PutBool(pSSM, pThis->fBackdoorLogDisabled);
    3963     SSMR3PutBool(pSSM, pThis->fKeepCredentials);
    3964     SSMR3PutBool(pSSM, pThis->fHeapEnabled);
     3959    PVMMDEV         pThis = PDMDEVINS_2_DATA(pDevIns, PVMMDEV);
     3960    PCPDMDEVHLPR3   pHlp  = pDevIns->pHlpR3;
     3961
     3962    pHlp->pfnSSMPutBool(pSSM, pThis->fGetHostTimeDisabled);
     3963    pHlp->pfnSSMPutBool(pSSM, pThis->fBackdoorLogDisabled);
     3964    pHlp->pfnSSMPutBool(pSSM, pThis->fKeepCredentials);
     3965    pHlp->pfnSSMPutBool(pSSM, pThis->fHeapEnabled);
    39653966
    39663967    return VINF_SSM_DONT_CALL_AGAIN;

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

    r90447 r91887  
    19451945int vmmdevR3HgcmSaveState(PVMMDEVCC pThisCC, PSSMHANDLE pSSM)
    19461946{
     1947    PCPDMDEVHLPR3 pHlp = pThisCC->pDevIns->pHlpR3;
     1948
    19471949    LogFlowFunc(("\n"));
    19481950
    … …  
    19581960
    19591961    /* Save number of commands. */
    1960     int rc = SSMR3PutU32(pSSM, cCmds);
     1962    int rc = pHlp->pfnSSMPutU32(pSSM, cCmds);
    19611963    AssertRCReturn(rc, rc);
    19621964
    … …  
    19691971            /** @todo Don't save cancelled requests! It serves no purpose.  See restore and
    19701972             *        @bugref{4032#c4} for details. */
    1971             SSMR3PutU32     (pSSM, (uint32_t)pCmd->enmCmdType);
    1972             SSMR3PutBool    (pSSM, pCmd->fCancelled);
    1973             SSMR3PutGCPhys  (pSSM, pCmd->GCPhys);
    1974             SSMR3PutU32     (pSSM, pCmd->cbRequest);
    1975             SSMR3PutU32     (pSSM, (uint32_t)pCmd->enmRequestType);
     1973            pHlp->pfnSSMPutU32     (pSSM, (uint32_t)pCmd->enmCmdType);
     1974            pHlp->pfnSSMPutBool    (pSSM, pCmd->fCancelled);
     1975            pHlp->pfnSSMPutGCPhys  (pSSM, pCmd->GCPhys);
     1976            pHlp->pfnSSMPutU32     (pSSM, pCmd->cbRequest);
     1977            pHlp->pfnSSMPutU32     (pSSM, (uint32_t)pCmd->enmRequestType);
    19761978            const uint32_t cParms = pCmd->enmCmdType == VBOXHGCMCMDTYPE_CALL ? pCmd->u.call.cParms : 0;
    1977             rc = SSMR3PutU32(pSSM, cParms);
     1979            rc = pHlp->pfnSSMPutU32(pSSM, cParms);
    19781980            AssertRCReturn(rc, rc);
    19791981
    19801982            if (pCmd->enmCmdType == VBOXHGCMCMDTYPE_CALL)
    19811983            {
    1982                 SSMR3PutU32     (pSSM, pCmd->u.call.u32ClientID);
    1983                 rc = SSMR3PutU32(pSSM, pCmd->u.call.u32Function);
     1984                pHlp->pfnSSMPutU32     (pSSM, pCmd->u.call.u32ClientID);
     1985                rc = pHlp->pfnSSMPutU32(pSSM, pCmd->u.call.u32Function);
    19841986                AssertRCReturn(rc, rc);
    19851987
    … …  
    19901992                    VBOXHGCMGUESTPARM * const pGuestParm = &pCmd->u.call.paGuestParms[i];
    19911993
    1992                     rc = SSMR3PutU32(pSSM, (uint32_t)pGuestParm->enmType);
     1994                    rc = pHlp->pfnSSMPutU32(pSSM, (uint32_t)pGuestParm->enmType);
    19931995                    AssertRCReturn(rc, rc);
    19941996
    … …  
    19971999                    {
    19982000                        const VBOXHGCMPARMVAL * const pVal = &pGuestParm->u.val;
    1999                         SSMR3PutU64     (pSSM, pVal->u64Value);
    2000                         SSMR3PutU32     (pSSM, pVal->offValue);
    2001                         rc = SSMR3PutU32(pSSM, pVal->cbValue);
     2001                        pHlp->pfnSSMPutU64     (pSSM, pVal->u64Value);
     2002                        pHlp->pfnSSMPutU32     (pSSM, pVal->offValue);
     2003                        rc = pHlp->pfnSSMPutU32(pSSM, pVal->cbValue);
    20022004                    }
    20032005                    else if (   pGuestParm->enmType == VMMDevHGCMParmType_LinAddr_In
    … …  
    20092011                    {
    20102012                        const VBOXHGCMPARMPTR * const pPtr = &pGuestParm->u.ptr;
    2011                         SSMR3PutU32     (pSSM, pPtr->cbData);
    2012                         SSMR3PutU32     (pSSM, pPtr->offFirstPage);
    2013                         SSMR3PutU32     (pSSM, pPtr->cPages);
    2014                         rc = SSMR3PutU32(pSSM, pPtr->fu32Direction);
     2013                        pHlp->pfnSSMPutU32     (pSSM, pPtr->cbData);
     2014                        pHlp->pfnSSMPutU32     (pSSM, pPtr->offFirstPage);
     2015                        pHlp->pfnSSMPutU32     (pSSM, pPtr->cPages);
     2016                        rc = pHlp->pfnSSMPutU32(pSSM, pPtr->fu32Direction);
    20152017
    20162018                        uint32_t iPage;
    20172019                        for (iPage = 0; RT_SUCCESS(rc) && iPage < pPtr->cPages; ++iPage)
    2018                             rc = SSMR3PutGCPhys(pSSM, pPtr->paPages[iPage]);
     2020                            rc = pHlp->pfnSSMPutGCPhys(pSSM, pPtr->paPages[iPage]);
    20192021                    }
    20202022                    else if (pGuestParm->enmType == VMMDevHGCMParmType_NoBouncePageList)
    … …  
    20332035            else if (pCmd->enmCmdType == VBOXHGCMCMDTYPE_CONNECT)
    20342036            {
    2035                 SSMR3PutU32(pSSM, pCmd->u.connect.u32ClientID);
    2036                 SSMR3PutMem(pSSM, pCmd->u.connect.pLoc, sizeof(*pCmd->u.connect.pLoc));
     2037                pHlp->pfnSSMPutU32(pSSM, pCmd->u.connect.u32ClientID);
     2038                pHlp->pfnSSMPutMem(pSSM, pCmd->u.connect.pLoc, sizeof(*pCmd->u.connect.pLoc));
    20372039            }
    20382040            else if (pCmd->enmCmdType == VBOXHGCMCMDTYPE_DISCONNECT)
    20392041            {
    2040                 SSMR3PutU32(pSSM, pCmd->u.disconnect.u32ClientID);
     2042                pHlp->pfnSSMPutU32(pSSM, pCmd->u.disconnect.u32ClientID);
    20412043            }
    20422044            else
    … …  
    20462048
    20472049            /* A reserved field, will allow to extend saved data for a command. */
    2048             rc = SSMR3PutU32(pSSM, 0);
     2050            rc = pHlp->pfnSSMPutU32(pSSM, 0);
    20492051            AssertRCReturn(rc, rc);
    20502052        }
    … …  
    20522054
    20532055    /* A reserved field, will allow to extend saved data for VMMDevHGCM. */
    2054     rc = SSMR3PutU32(pSSM, 0);
     2056    rc = pHlp->pfnSSMPutU32(pSSM, 0);
    20552057    AssertRCReturn(rc, rc);
    20562058
    … …  
    20752077int vmmdevR3HgcmLoadState(PPDMDEVINS pDevIns, PVMMDEV pThis, PVMMDEVCC pThisCC, PSSMHANDLE pSSM, uint32_t uVersion)
    20762078{
     2079    PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
     2080
    20772081    LogFlowFunc(("\n"));
    20782082
    … …  
    20812085    /* Read how many commands were pending. */
    20822086    uint32_t cCmds = 0;
    2083     int rc = SSMR3GetU32(pSSM, &cCmds);
     2087    int rc = pHlp->pfnSSMGetU32(pSSM, &cCmds);
    20842088    AssertRCReturn(rc, rc);
    20852089
    … …  
    21022106            uint32_t          cParms;
    21032107
    2104             SSMR3GetU32     (pSSM, &u32);
     2108            pHlp->pfnSSMGetU32     (pSSM, &u32);
    21052109            enmCmdType = (VBOXHGCMCMDTYPE)u32;
    2106             SSMR3GetBool    (pSSM, &fCancelled);
    2107             SSMR3GetGCPhys  (pSSM, &GCPhys);
    2108             SSMR3GetU32     (pSSM, &cbRequest);
    2109             SSMR3GetU32     (pSSM, &u32);
     2110            pHlp->pfnSSMGetBool    (pSSM, &fCancelled);
     2111            pHlp->pfnSSMGetGCPhys  (pSSM, &GCPhys);
     2112            pHlp->pfnSSMGetU32     (pSSM, &cbRequest);
     2113            pHlp->pfnSSMGetU32     (pSSM, &u32);
    21102114            enmRequestType = (VMMDevRequestType)u32;
    2111             rc = SSMR3GetU32(pSSM, &cParms);
     2115            rc = pHlp->pfnSSMGetU32(pSSM, &cParms);
    21122116            AssertRCReturn(rc, rc);
    21132117
    … …  
    21222126            if (enmCmdType == VBOXHGCMCMDTYPE_CALL)
    21232127            {
    2124                 SSMR3GetU32     (pSSM, &pCmd->u.call.u32ClientID);
    2125                 rc = SSMR3GetU32(pSSM, &pCmd->u.call.u32Function);
     2128                pHlp->pfnSSMGetU32     (pSSM, &pCmd->u.call.u32ClientID);
     2129                rc = pHlp->pfnSSMGetU32(pSSM, &pCmd->u.call.u32Function);
    21262130                AssertRCReturn(rc, rc);
    21272131
    … …  
    21322136                    VBOXHGCMGUESTPARM * const pGuestParm = &pCmd->u.call.paGuestParms[i];
    21332137
    2134                     rc = SSMR3GetU32(pSSM, &u32);
     2138                    rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    21352139                    AssertRCReturn(rc, rc);
    21362140                    pGuestParm->enmType = (HGCMFunctionParameterType)u32;
    … …  
    21402144                    {
    21412145                        VBOXHGCMPARMVAL * const pVal = &pGuestParm->u.val;
    2142                         SSMR3GetU64     (pSSM, &pVal->u64Value);
    2143                         SSMR3GetU32     (pSSM, &pVal->offValue);
    2144                         rc = SSMR3GetU32(pSSM, &pVal->cbValue);
     2146                        pHlp->pfnSSMGetU64     (pSSM, &pVal->u64Value);
     2147                        pHlp->pfnSSMGetU32     (pSSM, &pVal->offValue);
     2148                        rc = pHlp->pfnSSMGetU32(pSSM, &pVal->cbValue);
    21452149                    }
    21462150                    else if (   pGuestParm->enmType == VMMDevHGCMParmType_LinAddr_In
    … …  
    21522156                    {
    21532157                        VBOXHGCMPARMPTR * const pPtr = &pGuestParm->u.ptr;
    2154                         SSMR3GetU32     (pSSM, &pPtr->cbData);
    2155                         SSMR3GetU32     (pSSM, &pPtr->offFirstPage);
    2156                         SSMR3GetU32     (pSSM, &pPtr->cPages);
    2157                         rc = SSMR3GetU32(pSSM, &pPtr->fu32Direction);
     2158                        pHlp->pfnSSMGetU32     (pSSM, &pPtr->cbData);
     2159                        pHlp->pfnSSMGetU32     (pSSM, &pPtr->offFirstPage);
     2160                        pHlp->pfnSSMGetU32     (pSSM, &pPtr->cPages);
     2161                        rc = pHlp->pfnSSMGetU32(pSSM, &pPtr->fu32Direction);
    21582162                        if (RT_SUCCESS(rc))
    21592163                        {
    … …  
    21732177                                uint32_t iPage;
    21742178                                for (iPage = 0; iPage < pPtr->cPages; ++iPage)
    2175                                     rc = SSMR3GetGCPhys(pSSM, &pPtr->paPages[iPage]);
     2179                                    rc = pHlp->pfnSSMGetGCPhys(pSSM, &pPtr->paPages[iPage]);
    21762180                            }
    21772181                        }
    … …  
    21912195            else if (enmCmdType == VBOXHGCMCMDTYPE_CONNECT)
    21922196            {
    2193                 SSMR3GetU32(pSSM, &pCmd->u.connect.u32ClientID);
    2194                 rc = SSMR3GetMem(pSSM, pCmd->u.connect.pLoc, sizeof(*pCmd->u.connect.pLoc));
     2197                pHlp->pfnSSMGetU32(pSSM, &pCmd->u.connect.u32ClientID);
     2198                rc = pHlp->pfnSSMGetMem(pSSM, pCmd->u.connect.pLoc, sizeof(*pCmd->u.connect.pLoc));
    21952199                AssertRCReturn(rc, rc);
    21962200            }
    21972201            else if (enmCmdType == VBOXHGCMCMDTYPE_DISCONNECT)
    21982202            {
    2199                 rc = SSMR3GetU32(pSSM, &pCmd->u.disconnect.u32ClientID);
     2203                rc = pHlp->pfnSSMGetU32(pSSM, &pCmd->u.disconnect.u32ClientID);
    22002204                AssertRCReturn(rc, rc);
    22012205            }
    … …  
    22062210
    22072211            /* A reserved field, will allow to extend saved data for a command. */
    2208             rc = SSMR3GetU32(pSSM, &u32);
     2212            rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    22092213            AssertRCReturn(rc, rc);
    22102214
    … …  
    22302234
    22312235        /* A reserved field, will allow to extend saved data for VMMDevHGCM. */
    2232         rc = SSMR3GetU32(pSSM, &u32);
     2236        rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    22332237        AssertRCReturn(rc, rc);
    22342238    }
    … …  
    22472251            uint32_t          cLinAddrs;
    22482252
    2249             SSMR3GetGCPhys  (pSSM, &GCPhys);
    2250             rc = SSMR3GetU32(pSSM, &cbRequest);
     2253            pHlp->pfnSSMGetGCPhys  (pSSM, &GCPhys);
     2254            rc = pHlp->pfnSSMGetU32(pSSM, &cbRequest);
    22512255            AssertRCReturn(rc, rc);
    22522256
    … …  
    22572261             */
    22582262            if (uVersion <= 12)
    2259                 SSMR3Skip(pSSM, sizeof (uint32_t));
    2260 
    2261             SSMR3GetU32     (pSSM, &u32);
     2263                pHlp->pfnSSMSkip(pSSM, sizeof (uint32_t));
     2264
     2265            pHlp->pfnSSMGetU32     (pSSM, &u32);
    22622266            enmCmdType = (VBOXHGCMCMDTYPE)u32;
    2263             SSMR3GetBool    (pSSM, &fCancelled);
     2267            pHlp->pfnSSMGetBool    (pSSM, &fCancelled);
    22642268            /* How many linear pointers. Always 0 if not a call command. */
    2265             rc = SSMR3GetU32(pSSM, &cLinAddrs);
     2269            rc = pHlp->pfnSSMGetU32(pSSM, &cLinAddrs);
    22662270            AssertRCReturn(rc, rc);
    22672271
    … …  
    22762280            {
    22772281                /* Skip number of pages for all LinAddrs in this command. */
    2278                 SSMR3Skip(pSSM, sizeof(uint32_t));
     2282                pHlp->pfnSSMSkip(pSSM, sizeof(uint32_t));
    22792283
    22802284                uint32_t i;
    … …  
    22842288
    22852289                    /* Index of the parameter. Use cbData field to store the index. */
    2286                     SSMR3GetU32     (pSSM, &pPtr->cbData);
    2287                     SSMR3GetU32     (pSSM, &pPtr->offFirstPage);
    2288                     rc = SSMR3GetU32(pSSM, &pPtr->cPages);
     2290                    pHlp->pfnSSMGetU32     (pSSM, &pPtr->cbData);
     2291                    pHlp->pfnSSMGetU32     (pSSM, &pPtr->offFirstPage);
     2292                    rc = pHlp->pfnSSMGetU32(pSSM, &pPtr->cPages);
    22892293                    AssertRCReturn(rc, rc);
    22902294
    … …  
    22942298                    uint32_t iPage;
    22952299                    for (iPage = 0; iPage < pPtr->cPages; ++iPage)
    2296                         rc = SSMR3GetGCPhys(pSSM, &pPtr->paPages[iPage]);
     2300                        rc = pHlp->pfnSSMGetGCPhys(pSSM, &pPtr->paPages[iPage]);
    22972301                }
    22982302            }
    22992303
    23002304            /* A reserved field, will allow to extend saved data for a command. */
    2301             rc = SSMR3GetU32(pSSM, &u32);
     2305            rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    23022306            AssertRCReturn(rc, rc);
    23032307
    … …  
    23142318
    23152319        /* A reserved field, will allow to extend saved data for VMMDevHGCM. */
    2316         rc = SSMR3GetU32(pSSM, &u32);
     2320        rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    23172321        AssertRCReturn(rc, rc);
    23182322    }
    … …  
    23262330            uint32_t cbRequest;
    23272331
    2328             SSMR3GetGCPhys(pSSM, &GCPhys);
    2329             rc = SSMR3GetU32(pSSM, &cbRequest);
     2332            pHlp->pfnSSMGetGCPhys(pSSM, &GCPhys);
     2333            rc = pHlp->pfnSSMGetU32(pSSM, &cbRequest);
    23302334            AssertRCReturn(rc, rc);
    23312335
Note: See TracChangeset for help on using the changeset viewer.

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