Changeset 75853 in vbox for trunk/src/VBox/HostServices

Timestamp:

Nov 30, 2018 7:26:42 PM (6 years ago)

Author:

vboxsync

Message:

GuestControl,HGCM,VBoxService: Save/restore related optimizations and changes. bugref:9313

Location:

trunk/src/VBox/HostServices

Files:

• GuestControl/service.cpp (modified) (17 diffs)
• GuestControl/testcase/Makefile.kmk (modified) (1 diff)
• SharedClipboard/service.cpp (modified) (2 diffs)
• SharedFolders/service.cpp (modified) (2 diffs)
• SharedOpenGL/crserver/crservice.cpp (modified) (1 diff)

trunk/src/VBox/HostServices/GuestControl/service.cpp

@@ -67 +67 @@
 #include <VBox/AssertGuest.h>
 #include <VBox/VMMDev.h>
+#include <VBox/vmm/ssm.h>
 #include <iprt/assert.h>
 #include <iprt/cpp/autores.h>
@@ -139 +140 @@
     }
 
+
     /**
      * Retains a reference to the command.
@@ -149 +151 @@
         return cRefs;
     }
+
 
     /**
@@ -180 +183 @@
     }
 
+
     /**
      * Initializes the command.
@@ -269 +273 @@
     }
 
+
+    /**
+     * Sets the GUEST_MSG_PEEK_WAIT GUEST_MSG_PEEK_NOWAIT return parameters.
+     *
+     * @param   paDstParms  The peek parameter vector.
+     * @param   cDstParms   The number of peek parameters (at least two).
+     * @remarks ASSUMES the parameters has been cleared by clientMsgPeek.
+     */
+    inline void setPeekReturn(PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
+    {
+        Assert(cDstParms >= 2);
+        if (paDstParms[0].type == VBOX_HGCM_SVC_PARM_32BIT)
+            paDstParms[0].u.uint32 = mMsgType;
+        else
+            paDstParms[0].u.uint64 = mMsgType;
+        paDstParms[1].u.uint32 = mParmCount;
+
+        uint32_t i = RT_MIN(cDstParms, mParmCount + 2);
+        while (i-- > 2)
+            switch (mpParms[i - 2].type)
+            {
+                case VBOX_HGCM_SVC_PARM_32BIT: paDstParms[i].u.uint32 = ~(uint32_t)sizeof(uint32_t); break;
+                case VBOX_HGCM_SVC_PARM_64BIT: paDstParms[i].u.uint32 = ~(uint32_t)sizeof(uint64_t); break;
+                case VBOX_HGCM_SVC_PARM_PTR:   paDstParms[i].u.uint32 = mpParms[i - 2].u.pointer.size; break;
+            }
+    }
+
+
+    /** @name Support for old-style (GUEST_MSG_WAIT) operation.
+     * @{
+     */
 
     /**
@@ -421 +456 @@
         return VERR_TOO_MUCH_DATA;
     }
+
+    /** @} */
 } HostCommand;
 typedef std::list< HostCommand *> HostCmdList;
@@ -527 +564 @@
             rc = VINF_SUCCESS;
 
-            HostCmdListIter curCmd = mHostCmdList.begin();
-            if (curCmd != mHostCmdList.end())
+            HostCmdListIter ItFirstCmd = mHostCmdList.begin();
+            if (ItFirstCmd != mHostCmdList.end())
             {
-                HostCommand *pHostCmd = (*curCmd);
-                AssertPtrReturn(pHostCmd, VERR_INVALID_POINTER);
+                HostCommand *pFirstCmd = (*ItFirstCmd);
+                AssertPtrReturn(pFirstCmd, VERR_INVALID_POINTER);
 
                 LogFlowThisFunc(("[Client %RU32] Current host command is %RU32 (CID=%RU32, cParms=%RU32, m_cRefs=%RU32)\n",
-                                 mID, pHostCmd->mMsgType, pHostCmd->m_idContext, pHostCmd->mParmCount, pHostCmd->m_cRefs));
+                                 mID, pFirstCmd->mMsgType, pFirstCmd->m_idContext, pFirstCmd->mParmCount, pFirstCmd->m_cRefs));
 
                 if (mIsPending == GUEST_MSG_PEEK_WAIT)
                 {
-                    HGCMSvcSetU32(&mPendingCon.mParms[0], pHostCmd->mMsgType);
-                    HGCMSvcSetU32(&mPendingCon.mParms[1], pHostCmd->mParmCount);
-                    uint32_t i = RT_MIN(mPendingCon.mNumParms, pHostCmd->mParmCount + 2);
-                    while (i-- > 2)
-                        switch (pHostCmd->mpParms[i - 2].type)
-                        {
-                            case VBOX_HGCM_SVC_PARM_32BIT: mPendingCon.mParms[i].u.uint32 = ~(uint32_t)sizeof(uint32_t); break;
-                            case VBOX_HGCM_SVC_PARM_64BIT: mPendingCon.mParms[i].u.uint32 = ~(uint32_t)sizeof(uint64_t); break;
-                            case VBOX_HGCM_SVC_PARM_PTR:   mPendingCon.mParms[i].u.uint32 = pHostCmd->mpParms[i - 2].u.pointer.size; break;
-                        }
-
+                    pFirstCmd->setPeekReturn(mPendingCon.mParms, mPendingCon.mNumParms);
                     rc = mSvcHelpers->pfnCallComplete(mPendingCon.mHandle, VINF_SUCCESS);
 
@@ -557 +584 @@
                 }
                 else if (mIsPending == GUEST_MSG_WAIT)
-                    rc = OldRun(&mPendingCon, pHostCmd);
+                    rc = OldRun(&mPendingCon, pFirstCmd);
                 else
                     AssertMsgFailed(("mIsPending=%d\n", mIsPending));
@@ -654 +681 @@
     {
         Assert(!mHostCmdList.empty());
-        HostCommand *pHostCmd = *mHostCmdList.begin();
-        AssertPtr(pHostCmd);
-        pHostCmd->SaneRelease();
+        HostCommand *pFirstCmd = *mHostCmdList.begin();
+        AssertPtr(pFirstCmd);
+        pFirstCmd->SaneRelease();
         mHostCmdList.pop_front();
 
@@ -879 +906 @@
     RTLISTANCHOR mHostCmdList;
     /** Map containing all connected clients, key is HGCM client ID. */
-    ClientStateMap  mClientStateMap;
+    ClientStateMap  mClientStateMap; /**< @todo Use VBOXHGCMSVCFNTABLE::cbClient for this! */
     /** The master HGCM client ID, UINT32_MAX if none. */
     uint32_t        m_idMasterClient;
@@ -909 +936 @@
                                       uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival);
     static DECLCALLBACK(int)  svcHostCall(void *pvService, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
+    static DECLCALLBACK(int)  svcSaveState(void *pvService, uint32_t idClient, void *pvClient, PSSMHANDLE pSSM);
+    static DECLCALLBACK(int)  svcLoadState(void *pvService, uint32_t idClient, void *pvClient, PSSMHANDLE pSSM, uint32_t uVersion);
     static DECLCALLBACK(int)  svcRegisterExtension(void *pvService, PFNHGCMSVCEXT pfnExtension, void *pvExtension);
 
@@ -1199 +1228 @@
      */
     ASSERT_GUEST_MSG_RETURN(cParms >= 2, ("cParms=%u!\n", cParms), VERR_WRONG_PARAMETER_COUNT);
-    for (uint32_t i = 0; i < cParms; i++)
+
+    uint64_t idRestoreCheck = 0;
+    uint32_t i              = 0;
+    if (paParms[i].type == VBOX_HGCM_SVC_PARM_64BIT)
+    {
+        idRestoreCheck = paParms[0].u.uint64;
+        paParms[0].u.uint64 = 0;
+        i++;
+    }
+    for (; i < cParms; i++)
     {
         ASSERT_GUEST_MSG_RETURN(paParms[i].type == VBOX_HGCM_SVC_PARM_32BIT, ("#%u type=%u\n", i, paParms[i].type),
@@ -1211 +1249 @@
 
     /*
+     * Check restore session ID.
+     */
+    if (idRestoreCheck != 0)
+    {
+        uint64_t idRestore = mpHelpers->pfnGetVMMDevSessionId(mpHelpers);
+        if (idRestoreCheck != idRestore)
+        {
+            paParms[0].u.uint32 = idRestore;
+            LogFlowFunc(("[Client %RU32] GUEST_MSG_PEEK_XXXX -> VERR_VM_RESTORED (%#RX64 -> %#RX64)\n",
+                         idClient, idRestoreCheck, idRestore));
+            return VERR_VM_RESTORED;
+        }
+        Assert(!mpHelpers->pfnIsCallRestored(hCall));
+    }
+
+    /*
      * Return information about the first command if one is pending in the list.
      */
@@ -1217 +1271 @@
     {
         HostCommand *pFirstCmd = *itFirstCmd;
-        paParms[0].u.uint32 = pFirstCmd->mMsgType;
-        paParms[1].u.uint32 = pFirstCmd->mParmCount;
-        uint32_t i = RT_MIN(cParms, pFirstCmd->mParmCount + 2);
-        while (i-- > 2)
-            switch (pFirstCmd->mpParms[i - 2].type)
-            {
-                case VBOX_HGCM_SVC_PARM_32BIT: paParms[i].u.uint32 = ~(uint32_t)sizeof(uint32_t); break;
-                case VBOX_HGCM_SVC_PARM_64BIT: paParms[i].u.uint32 = ~(uint32_t)sizeof(uint64_t); break;
-                case VBOX_HGCM_SVC_PARM_PTR:   paParms[i].u.uint32 = pFirstCmd->mpParms[i - 2].u.pointer.size; break;
-            }
-
+        pFirstCmd->setPeekReturn(paParms, cParms);
         LogFlowFunc(("[Client %RU32] GUEST_MSG_PEEK_XXXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
                      idClient, pFirstCmd->mMsgType, GstCtrlHostFnName((eHostFn)pFirstCmd->mMsgType), pFirstCmd->mParmCount));
@@ -2197 +2241 @@
 
 /**
+ * @interface_method_impl{VBOXHGCMSVCFNTABLE,pfnSaveState}
+ */
+/*static*/ DECLCALLBACK(int)
+GstCtrlService::svcSaveState(void *pvService, uint32_t idClient, void *pvClient, PSSMHANDLE pSSM)
+{
+    RT_NOREF(pvClient);
+    AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
+    SELF *pThis = reinterpret_cast<SELF *>(pvService);
+    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+
+    SSMR3PutU32(pSSM, 1);
+    SSMR3PutBool(pSSM, idClient == pThis->m_idMasterClient);
+    return SSMR3PutBool(pSSM, pThis->m_fLegacyMode);
+}
+
+
+/**
+ * @interface_method_impl{VBOXHGCMSVCFNTABLE,pfnLoadState}
+ */
+/*static*/ DECLCALLBACK(int)
+GstCtrlService::svcLoadState(void *pvService, uint32_t idClient, void *pvClient, PSSMHANDLE pSSM, uint32_t uVersion)
+{
+    RT_NOREF(pvClient);
+    AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
+    SELF *pThis = reinterpret_cast<SELF *>(pvService);
+    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+
+    if (uVersion >= HGCM_SAVED_STATE_VERSION)
+    {
+        uint32_t uSubVersion;
+        int rc = SSMR3GetU32(pSSM, &uSubVersion);
+        AssertRCReturn(rc, rc);
+        if (uSubVersion != 1)
+            return SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS,
+                                     "sub version %u, expected 1\n", uSubVersion);
+        bool fLegacyMode;
+        rc = SSMR3GetBool(pSSM, &fLegacyMode);
+        AssertRCReturn(rc, rc);
+        pThis->m_fLegacyMode = fLegacyMode;
+
+        bool fIsMaster;
+        rc = SSMR3GetBool(pSSM, &fIsMaster);
+        AssertRCReturn(rc, rc);
+        if (fIsMaster)
+            pThis->m_idMasterClient = idClient;
+        ClientStateMapIter It = pThis->mClientStateMap.find(idClient);
+        if (It != pThis->mClientStateMap.end())
+            It->second.m_fIsMaster = fIsMaster;
+        else
+            AssertFailed();
+    }
+    else
+    {
+        /*
+         * For old saved states we have to guess at who should be the master.
+         * Given how HGCMService::CreateAndConnectClient and associates manage
+         * and saves the client, the first client connecting will be restored
+         * first.  The only time this might go wrong if the there are zombie
+         * VBoxService session processes in the restored guest, and I don't
+         * we need to care too much about that scenario.
+         *
+         * Given how HGCM first re-connects the clients before this function
+         * gets called, there isn't anything we need to do here it turns out. :-)
+         */
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
  * @interface_method_impl{VBOXHGCMSVCFNTABLE,pfnRegisterExtension,
  *  Installs a host callback for notifications of property changes.}
@@ -2203 +2317 @@
 {
     AssertLogRelReturn(VALID_PTR(pvService), VERR_INVALID_PARAMETER);
-    SELF *pSelf = reinterpret_cast<SELF *>(pvService);
-    AssertPtrReturn(pSelf, VERR_INVALID_POINTER);
-    pSelf->mpfnHostCallback = pfnExtension;
-    pSelf->mpvHostData = pvExtension;
+    SELF *pThis = reinterpret_cast<SELF *>(pvService);
+    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+
+    pThis->mpfnHostCallback = pfnExtension;
+    pThis->mpvHostData = pvExtension;
     return VINF_SUCCESS;
 }
@@ -2256 +2371 @@
                  * because we're a class which can have members for that :-).
                  */
-                pTable->cbClient = 0;
+                pTable->cbClient = 0;  /** @todo this is where ClientState should live, isn't it? */
 
                 /* Register functions. */
-                pTable->pfnUnload             = GstCtrlService::svcUnload;
-                pTable->pfnConnect            = GstCtrlService::svcConnect;
-                pTable->pfnDisconnect         = GstCtrlService::svcDisconnect;
-                pTable->pfnCall               = GstCtrlService::svcCall;
-                pTable->pfnHostCall           = GstCtrlService::svcHostCall;
-                pTable->pfnSaveState          = NULL;  /* The GstCtrlService is stateless, so the normal */
-                pTable->pfnLoadState          = NULL;  /* construction done before restoring suffices */
-                pTable->pfnRegisterExtension  = GstCtrlService::svcRegisterExtension;
+                pTable->pfnUnload               = GstCtrlService::svcUnload;
+                pTable->pfnConnect              = GstCtrlService::svcConnect;
+                pTable->pfnDisconnect           = GstCtrlService::svcDisconnect;
+                pTable->pfnCall                 = GstCtrlService::svcCall;
+                pTable->pfnHostCall             = GstCtrlService::svcHostCall;
+                pTable->pfnSaveState            = GstCtrlService::svcSaveState;
+                pTable->pfnLoadState            = GstCtrlService::svcLoadState;
+                pTable->pfnRegisterExtension    = GstCtrlService::svcRegisterExtension;
 
                 /* Service specific initialization. */

trunk/src/VBox/HostServices/GuestControl/testcase/Makefile.kmk

@@ -35 +35 @@
         ../service.cpp \
         tstGuestControlSvc.cpp
- tstGuestControlSvc_LIBS     = $(LIB_RUNTIME)
+ tstGuestControlSvc_LIBS     = $(LIB_RUNTIME) $(LIB_VMM)
 
 $$(tstGuestControlSvc_0_OUTDIR)/tstGuestControlSvc.run: $$(tstGuestControlSvc_1_STAGE_TARGET)

trunk/src/VBox/HostServices/SharedClipboard/service.cpp

@@ -857 +857 @@
 } CLIPSAVEDSTATEDATA;
 
-static DECLCALLBACK(int) svcLoadState(void *, uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM)
+static DECLCALLBACK(int) svcLoadState(void *, uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM, uint32_t uVersion)
 {
 #ifndef UNIT_TEST
+    RT_NOREF(uVersion);
     LogRel2 (("svcLoadState: u32ClientID = %d\n", u32ClientID));
 
@@ -931 +932 @@
 
 #else  /* UNIT_TEST*/
-    RT_NOREF3(u32ClientID, pvClient, pSSM);
+    RT_NOREF(u32ClientID, pvClient, pSSM, uVersion);
 #endif /* UNIT_TEST */
     return VINF_SUCCESS;

trunk/src/VBox/HostServices/SharedFolders/service.cpp

@@ -242 +242 @@
 }
 
-static DECLCALLBACK(int) svcLoadState(void *, uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM)
+static DECLCALLBACK(int) svcLoadState(void *, uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM, uint32_t uVersion)
 {
 #ifndef UNITTEST  /* Read this as not yet tested */
-    RT_NOREF1(u32ClientID);
+    RT_NOREF(u32ClientID, uVersion);
     uint32_t        nrMappings;
     SHFLCLIENTDATA *pClient = (SHFLCLIENTDATA *)pvClient;
@@ -395 +395 @@
     Log(("SharedFolders host service: successfully loaded state\n"));
 #else
-    RT_NOREF3(u32ClientID, pvClient, pSSM);
+    RT_NOREF(u32ClientID, pvClient, pSSM, uVersion);
 #endif
     return VINF_SUCCESS;

trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp

@@ -199 +199 @@
 }
 
-static DECLCALLBACK(int) svcLoadState(void *, uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM)
+static DECLCALLBACK(int) svcLoadState(void *, uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM, uint32_t uVersion)
 {
+    RT_NOREF(pvClient, uVersion);
     int rc = VINF_SUCCESS;
-
-    NOREF(pvClient);
 
     Log(("SHARED_CROPENGL svcLoadState: u32ClientID = %d\n", u32ClientID));