Changeset 24558 in vbox for trunk/src/VBox/Main

Timestamp:

Nov 10, 2009 3:59:07 PM (15 years ago)

Author:

vboxsync

Message:

Main: Teleport to local process with disks attached. Delays the LockMedia call till after the source machine has unlocked them.

Location:

trunk/src/VBox/Main

Files:

• ConsoleImpl.cpp (modified) (1 diff)
• ConsoleImplTeleporter.cpp (modified) (15 diffs)
• idl/VirtualBox.xidl (modified) (3 diffs)
• include/MachineImpl.h (modified) (1 diff)

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -6686 +6686 @@
         }
 
-        /* lock attached media. This method will also check their
-         * accessibility. Note that the media will be unlocked automatically
-         * by SessionMachine::setMachineState() when the VM is powered down. */
-        rc = console->mControl->LockMedia();
-        CheckComRCThrowRC(rc);
+        /*
+         * Lock attached media. This method will also check their accessibility.
+         * If we're a teleporter, we'll have to postpone this action so we can
+         * migrate between local processes.
+         *
+         * Note! The media will be unlocked automatically by
+         *       SessionMachine::setMachineState() when the VM is powered down.
+         */
+        if (!task->mTeleporterEnabled)
+        {
+            rc = console->mControl->LockMedia();
+            CheckComRCThrowRC(rc);
+        }
 
 #ifdef VBOX_WITH_VRDP

trunk/src/VBox/Main/ConsoleImplTeleporter.cpp

@@ -94 +94 @@
     MachineState_T      menmOldMachineState;
     bool                mfSuspendedByUs;
+    bool                mfUnlockedMedia;
 
     TeleporterStateSrc(Console *pConsole, PVM pVM, Progress *pProgress, MachineState_T enmOldMachineState)
@@ -100 +101 @@
         , menmOldMachineState(enmOldMachineState)
         , mfSuspendedByUs(false)
+        , mfUnlockedMedia(false)
     {
     }
@@ -111 +113 @@
 {
 public:
-    IMachine           *mpMachine;
-    PRTTCPSERVER        mhServer;
-    PRTTIMERLR          mphTimerLR;
-    bool                mfStartPaused;
-    int                 mRc;
+    IMachine                   *mpMachine;
+    IInternalMachineControl    *mpControl;
+    PRTTCPSERVER                mhServer;
+    PRTTIMERLR                  mphTimerLR;
+    bool                        mfStartPaused;
+    bool                        mfLockedMedia;
+    int                         mRc;
 
     TeleporterStateTrg(Console *pConsole, PVM pVM, Progress *pProgress,
-                       IMachine *pMachine, PRTTIMERLR phTimerLR, bool fStartPaused)
+                       IMachine *pMachine, IInternalMachineControl *pControl,
+                       PRTTIMERLR phTimerLR, bool fStartPaused)
         : TeleporterState(pConsole, pVM, pProgress, false /*fIsSource*/)
         , mpMachine(pMachine)
+        , mpControl(pControl)
         , mhServer(NULL)
         , mphTimerLR(phTimerLR)
         , mfStartPaused(false)
+        , mfLockedMedia(false)
         , mRc(VINF_SUCCESS)
     {
@@ -651 +658 @@
         return E_FAIL;
     }
+
+    /*
+     * The last thing we do is to hand over any media we might have locked.
+     */
+    /** @todo Maybe we should only do this if it's a local teleportation... */
+    hrc = mControl->UnlockMedia();
+    if (FAILED(hrc))
+        return hrc;
+    pState->mfUnlockedMedia = true;
+
+    hrc = teleporterSrcSubmitCommand(pState, "lock-media");
+    if (FAILED(hrc))
+        return hrc;
+
     hrc = teleporterSrcSubmitCommand(pState, "done");
     if (FAILED(hrc))
@@ -727 +748 @@
            )
         {
+            if (pState->mfUnlockedMedia)
+            {
+                ErrorInfoKeeper Oak;
+                HRESULT hrc2 = pState->mptrConsole->mControl->LockMedia();
+                if (FAILED(hrc2))
+                {
+                    uint64_t StartMS = RTTimeMilliTS();
+                    do
+                    {
+                        RTThreadSleep(2);
+                        hrc2 = pState->mptrConsole->mControl->LockMedia();
+                    } while (   FAILED(hrc2)
+                             && RTTimeMilliTS() - StartMS < 2000);
+                }
+                if (SUCCEEDED(hrc2))
+                    pState->mfUnlockedMedia = true;
+                else
+                    LogRel(("FATAL ERROR: Failed to re-take the media locks. hrc2=%Rhrc\n", hrc2));
+            }
+
             switch (enmVMState)
             {
@@ -738 +779 @@
                 case VMSTATE_RESETTING_LS:
                     Assert(!pState->mfSuspendedByUs);
+                    Assert(!pState->mfUnlockedMedia);
                     pState->mptrConsole->setMachineState(MachineState_Running);
                     break;
@@ -758 +800 @@
                 case VMSTATE_SUSPENDING_LS:
                 case VMSTATE_SUSPENDING_EXT_LS:
-                    pState->mptrConsole->setMachineState(MachineState_Paused);
-                    if (pState->mfSuspendedByUs)
+                    if (!pState->mfUnlockedMedia)
                     {
-                        autoLock.leave();
-                        int rc = VMR3Resume(pState->mpVM);
-                        AssertLogRelMsgRC(rc, ("VMR3Resume -> %Rrc\n", rc));
-                        autoLock.enter();
+                        pState->mptrConsole->setMachineState(MachineState_Paused);
+                        if (pState->mfSuspendedByUs)
+                        {
+                            autoLock.leave();
+                            int rc = VMR3Resume(pState->mpVM);
+                            AssertLogRelMsgRC(rc, ("VMR3Resume -> %Rrc\n", rc));
+                            autoLock.enter();
+                        }
+                    }
+                    else
+                    {
+                        /* Faking a guru meditation is the best I can think of doing here... */
+                        pState->mptrConsole->setMachineState(MachineState_Stuck);
                     }
                     break;
@@ -956 +1006 @@
              * Do the job, when it returns we're done.
              */
-            TeleporterStateTrg State(this, pVM, pProgress, pMachine, &hTimerLR, fStartPaused);
+            TeleporterStateTrg State(this, pVM, pProgress, pMachine, mControl, &hTimerLR, fStartPaused);
             State.mstrPassword      = strPassword;
             State.mhServer          = hServer;
@@ -1036 +1086 @@
 
 
+/**
+ * Unlock the media.
+ *
+ * This is used in error paths.
+ *
+ * @param  pState           The teleporter state.
+ */
+static void teleporterTrgUnlockMedia(TeleporterStateTrg *pState)
+{
+    if (pState->mfLockedMedia)
+    {
+        pState->mpControl->UnlockMedia();
+        pState->mfLockedMedia = false;
+    }
+}
+
+
 static int teleporterTcpWriteACK(TeleporterStateTrg *pState)
 {
     int rc = RTTcpWrite(pState->mhSocket, "ACK\n", sizeof("ACK\n") - 1);
     if (RT_FAILURE(rc))
+    {
         LogRel(("Teleporter: RTTcpWrite(,ACK,) -> %Rrc\n", rc));
+        teleporterTrgUnlockMedia(pState);
+    }
     RTTcpFlush(pState->mhSocket);
     return rc;
@@ -1048 +1118 @@
 static int teleporterTcpWriteNACK(TeleporterStateTrg *pState, int32_t rc2)
 {
+    /*
+     * Unlock media sending the NACK. That way the other doesn't have to spin
+     * waiting to regain the locks.
+     */
+    teleporterTrgUnlockMedia(pState);
+
     char    szMsg[64];
     size_t  cch = RTStrPrintf(szMsg, sizeof(szMsg), "NACK=%d\n", rc2);
@@ -1117 +1193 @@
      * Command processing loop.
      */
+    bool fDone = false;
     for (;;)
     {
@@ -1154 +1231 @@
             vrc = teleporterTcpWriteACK(pState);
         }
-        /** @todo implement config verification and hardware compatability checks. Or
-         *        maybe leave part of these to the saved state machinery?
-         * Update: We're doing as much as possible in the first SSM pass. */
         else if (!strcmp(szCmd, "cancel"))
         {
@@ -1168 +1242 @@
             vrc = teleporterTcpWriteACK(pState);
         }
+        else if (!strcmp(szCmd, "lock-media"))
+        {
+            HRESULT hrc = pState->mpControl->LockMedia();
+            if (SUCCEEDED(hrc))
+            {
+                pState->mfLockedMedia = true;
+                vrc = teleporterTcpWriteACK(pState);
+            }
+            else
+            {
+                vrc = VERR_FILE_LOCK_FAILED;
+                teleporterTcpWriteNACK(pState, vrc);
+            }
+        }
         else if (!strcmp(szCmd, "done"))
         {
@@ -1173 +1261 @@
              * The ACK is the point of no return.
              */
-            if (pState->mptrProgress->notifyPointOfNoReturn())
+            if (   pState->mptrProgress->notifyPointOfNoReturn()
+                && pState->mfLockedMedia)
                 vrc = teleporterTcpWriteACK(pState);
             else
             {
-                vrc = VERR_SSM_CANCELLED;
+                vrc = pState->mfLockedMedia ? VERR_WRONG_ORDER : VERR_SSM_CANCELLED;
                 teleporterTcpWriteNACK(pState, vrc);
             }
+            fDone = true;
             break;
         }
@@ -1194 +1284 @@
     }
 
+    if (RT_SUCCESS(vrc) && !fDone)
+        vrc = VERR_WRONG_ORDER;
+    if (RT_FAILURE(vrc))
+        teleporterTrgUnlockMedia(pState);
+
     pState->mRc = vrc;
     pState->mhSocket = NIL_RTSOCKET;

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -3682 +3682 @@
   <interface
      name="IInternalMachineControl" extends="$unknown"
-     uuid="4e2b8f0f-6575-49d2-bb19-5cd15a6ca2f0"
+     uuid="35d8d838-d066-447d-927a-fd93afdbec90"
      internal="yes"
      wsmap="suppress"
@@ -4040 +4040 @@
         Restoring state. The locked media will be automatically unlocked when
         the machine is powered off or crashed.
+      </desc>
+    </method>
+    <method name="unlockMedia">
+      <desc>
+        Unlocks all media previously locked using
+        <link to="IInternalMachineControl::lockMedia"/>.
+
+        This method is intended to be used with teleportation so that it is
+        possible to teleport between processes on the same machine.
       </desc>
     </method>
@@ -5803 +5812 @@
         <desc>
           How to order bytes in the pixel. A pixel consists of 4 bytes. If this parameter is true, then
-          bytes order is: B, G, R, 0xFF. If this parameter is false, then bytes order is: R, G, B, 0xFF. 
+          bytes order is: B, G, R, 0xFF. If this parameter is false, then bytes order is: R, G, B, 0xFF.
         </desc>
       </param>

trunk/src/VBox/Main/include/MachineImpl.h

@@ -998 +998 @@
     STDMETHOD(PushGuestProperty)(IN_BSTR aName, IN_BSTR aValue,
                                   ULONG64 aTimestamp, IN_BSTR aFlags);
-    STDMETHOD(LockMedia)() { return lockMedia(); }
+    STDMETHOD(LockMedia)()   { return lockMedia(); }
+    STDMETHOD(UnlockMedia)() { unlockMedia(); return S_OK; }
 
     // public methods only for internal purposes