Changeset 58390 in vbox for trunk/src/VBox/Devices/GIMDev

Timestamp:

Oct 23, 2015 12:35:35 PM (9 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

103627

Message:

VMM/GIM: Implement Hyper-V debug receive thread optimization. Added a few statistics to GIM.
Fixed a bug in Windows guests' debug DHCP handling.

Location:

trunk/src/VBox/Devices/GIMDev

Files:

• DrvUDP.cpp (modified) (3 diffs)
• GIMDev.cpp (modified) (5 diffs)

trunk/src/VBox/Devices/GIMDev/DrvUDP.cpp

@@ -80 +80 @@
     {
         size_t cbReallyRead = 0;
-        rc = RTSocketReadNB(pThis->hSocket, pvBuf, *pcbRead, &cbReallyRead);
+        rc = RTSocketRead(pThis->hSocket, pvBuf, *pcbRead, &cbReallyRead);
         if (RT_SUCCESS(rc))
             *pcbRead = cbReallyRead;
@@ -103 +103 @@
     if (pThis->hSocket != NIL_RTSOCKET)
     {
-        size_t cbReallyWritten = 0;
-        rc = RTSocketWriteNB(pThis->hSocket, pvBuf, *pcbWrite, &cbReallyWritten);
+        size_t cbBuf = *pcbWrite;
+        rc = RTSocketWriteToNB(pThis->hSocket, pvBuf, cbBuf, NULL /*pDstAddr*/);
         if (RT_SUCCESS(rc))
-            *pcbWrite = cbReallyWritten;
+            *pcbWrite = cbBuf;
     }
     else
@@ -147 +147 @@
     if (pThis->hSocket != NIL_RTSOCKET)
     {
+        RTSocketRetain(pThis->hSocket);
+        RTSocketShutdown(pThis->hSocket, true, true);
         RTSocketClose(pThis->hSocket);
         pThis->hSocket = NIL_RTSOCKET;

trunk/src/VBox/Devices/GIMDev/GIMDev.cpp

@@ -26 +26 @@
 
 #include "VBoxDD.h"
+#include <iprt/alloc.h>
+#include <iprt/semaphore.h>
 #include <iprt/uuid.h>
 
@@ -50 +52 @@
     /** Pointer to the attached base debug driver. */
     R3PTRTYPE(PPDMIBASE)            pDbgDrvBase;
-    /** Pointer to the attached debug stream driver. */
-    R3PTRTYPE(PPDMISTREAM)          pDbgDrvStream;
+    /** The debug receive thread. */
+    RTTHREAD                        hDbgRecvThread;
+    /** Flag to indicate shutdown of the debug receive thread. */
+    bool volatile                   fDbgRecvThreadShutdown;
+    /** The debug setup parameters. */
+    GIMDEBUGSETUP                   DbgSetup;
+    /** The debug transfer struct. */
+    GIMDEBUG                        Dbg;
 } GIMDEV;
 /** Pointer to the GIM device state. */
@@ -76 +84 @@
 
 
+static DECLCALLBACK(int) gimDevR3DbgRecvThread(RTTHREAD ThreadSelf, void *pvUser)
+{
+    /*
+     * Validate.
+     */
+    PPDMDEVINS pDevIns = (PPDMDEVINS)pvUser;
+    AssertReturn(pDevIns, VERR_INVALID_PARAMETER);
+    PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
+
+    PGIMDEV pThis = PDMINS_2_DATA(pDevIns, PGIMDEV);
+    AssertReturn(pThis, VERR_INVALID_POINTER);
+    AssertReturn(pThis->DbgSetup.cbDbgRecvBuf, VERR_INTERNAL_ERROR);
+    AssertReturn(pThis->Dbg.hDbgRecvThreadSem != NIL_RTSEMEVENTMULTI, VERR_INTERNAL_ERROR_2);
+    AssertReturn(pThis->Dbg.pvDbgRecvBuf, VERR_INTERNAL_ERROR_3);
+
+    PVM pVM = PDMDevHlpGetVM(pDevIns);
+    AssertReturn(pVM, VERR_INVALID_POINTER);
+
+    PPDMISTREAM pDbgDrvStream = pThis->Dbg.pDbgDrvStream;
+    AssertReturn(pDbgDrvStream, VERR_INVALID_POINTER);
+
+    for (;;)
+    {
+        /*
+         * Read incoming debug data.
+         */
+        size_t cbRead = pThis->DbgSetup.cbDbgRecvBuf;
+        int rc = pDbgDrvStream->pfnRead(pDbgDrvStream, pThis->Dbg.pvDbgRecvBuf, &cbRead);
+        if (   RT_SUCCESS(rc)
+            && cbRead > 0)
+        {
+            /*
+             * Notify the consumer thread.
+             */
+            if (ASMAtomicReadBool(&pThis->Dbg.fDbgRecvBufRead) == false)
+            {
+                if (pThis->DbgSetup.pfnDbgRecvBufAvail)
+                    pThis->DbgSetup.pfnDbgRecvBufAvail(pVM);
+                pThis->Dbg.cbDbgRecvBufRead = cbRead;
+                RTSemEventMultiReset(pThis->Dbg.hDbgRecvThreadSem);
+                ASMAtomicWriteBool(&pThis->Dbg.fDbgRecvBufRead, true);
+            }
+
+            /*
+             * Wait until the consumer thread has acknowledged reading of the
+             * current buffer or we're asked to shut down.
+             *
+             * It is important that we do NOT re-invoke 'pfnRead' before the
+             * current buffer is consumed, otherwise we risk data corruption.
+             */
+            while (   ASMAtomicReadBool(&pThis->Dbg.fDbgRecvBufRead) == true
+                   && !pThis->fDbgRecvThreadShutdown)
+            {
+                RTSemEventMultiWait(pThis->Dbg.hDbgRecvThreadSem, RT_INDEFINITE_WAIT);
+            }
+        }
+        else if (   rc != VINF_TRY_AGAIN
+                 && rc != VERR_TRY_AGAIN)
+        {
+            LogRel(("GIMDev: Debug thread terminating with rc=%Rrc\n", rc));
+            break;
+        }
+
+        if (pThis->fDbgRecvThreadShutdown)
+        {
+            LogRel(("GIMDev: Debug thread shutting down\n"));
+            break;
+        }
+    }
+
+    return VINF_SUCCESS;
+}
+
+
 /**
  * @interface_method_impl{PDMDEVREG,pfnConstruct}
@@ -93 +175 @@
 
     /*
-     * Attach the stream driver for the debug connection.
-     */
-    pThis->IDbgBase.pfnQueryInterface = gimdevR3QueryInterface;
-    int rc = PDMDevHlpDriverAttach(pDevIns, GIMDEV_DEBUG_LUN, &pThis->IDbgBase, &pThis->pDbgDrvBase, "GIM Debug Port");
-    if (RT_SUCCESS(rc))
-    {
-        pThis->pDbgDrvStream = PDMIBASE_QUERY_INTERFACE(pThis->pDbgDrvBase, PDMISTREAM);
-        if (pThis->pDbgDrvStream)
-            LogRel(("GIMDev: LUN#%u: Debug port configured\n", GIMDEV_DEBUG_LUN));
+     * Get debug setup requirements from GIM.
+     */
+    PVM pVM = PDMDevHlpGetVM(pDevIns);
+    int rc = GIMR3GetDebugSetup(pVM, &pThis->DbgSetup);
+    if (   RT_SUCCESS(rc)
+        && pThis->DbgSetup.cbDbgRecvBuf > 0)
+    {
+        /*
+         * Attach the stream driver for the debug connection.
+         */
+        PPDMISTREAM pDbgDrvStream = NULL;
+        pThis->IDbgBase.pfnQueryInterface = gimdevR3QueryInterface;
+        rc = PDMDevHlpDriverAttach(pDevIns, GIMDEV_DEBUG_LUN, &pThis->IDbgBase, &pThis->pDbgDrvBase, "GIM Debug Port");
+        if (RT_SUCCESS(rc))
+        {
+            pDbgDrvStream = PDMIBASE_QUERY_INTERFACE(pThis->pDbgDrvBase, PDMISTREAM);
+            if (pDbgDrvStream)
+                LogRel(("GIMDev: LUN#%u: Debug port configured\n", GIMDEV_DEBUG_LUN));
+            else
+                LogRel(("GIMDev: LUN#%u: No unit\n", GIMDEV_DEBUG_LUN));
+        }
+        else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
+        {
+            pThis->pDbgDrvBase = NULL;
+            LogRel(("GIMDev: LUN#%u: No debug port configured\n", GIMDEV_DEBUG_LUN));
+        }
         else
-            LogRel(("GIMDev: LUN#%u: No unit\n", GIMDEV_DEBUG_LUN));
-    }
-    else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
-    {
-        pThis->pDbgDrvBase   = NULL;
-        pThis->pDbgDrvStream = NULL;
-        LogRel(("GIMDev: LUN#%u: No debug port configured\n", GIMDEV_DEBUG_LUN));
-    }
-    else
-    {
-        AssertLogRelMsgFailed(("GIMDev: LUN#%u: Failed to attach to driver on debug port. rc=%Rrc\n", GIMDEV_DEBUG_LUN, rc));
-        /* Don't call VMSetError here as we assume that the driver already set an appropriate error */
-        return rc;
-    }
-
-    /*
-     * Register ourselves with the GIM VMM component.
-     */
-    PVM pVM = PDMDevHlpGetVM(pDevIns);
-    GIMR3GimDeviceRegister(pVM, pDevIns, pThis->pDbgDrvStream);
+        {
+            AssertLogRelMsgFailed(("GIMDev: LUN#%u: Failed to attach to driver on debug port. rc=%Rrc\n", GIMDEV_DEBUG_LUN, rc));
+            /* Don't call VMSetError here as we assume that the driver already set an appropriate error */
+            return rc;
+        }
+
+        void *pvDbgRecvBuf = RTMemAllocZ(pThis->DbgSetup.cbDbgRecvBuf);
+        if (RT_UNLIKELY(!pvDbgRecvBuf))
+        {
+            LogRel(("GIMDev: Failed to alloc %u bytes for debug receive buffer\n", pThis->DbgSetup.cbDbgRecvBuf));
+            return VERR_NO_MEMORY;
+        }
+
+        /*
+         * Update the shared debug struct.
+         */
+        pThis->Dbg.pDbgDrvStream    = pDbgDrvStream;
+        pThis->Dbg.pvDbgRecvBuf     = pvDbgRecvBuf;
+        pThis->Dbg.cbDbgRecvBufRead = 0;
+        pThis->Dbg.fDbgRecvBufRead  = false;
+
+        /*
+         * Create the sempahore and the debug receive thread itself.
+         */
+        rc = RTSemEventMultiCreate(&pThis->Dbg.hDbgRecvThreadSem);
+        if (RT_SUCCESS(rc))
+        {
+            rc = RTThreadCreate(&pThis->hDbgRecvThread, gimDevR3DbgRecvThread, pDevIns, 0 /*cbStack*/, RTTHREADTYPE_IO,
+                                RTTHREADFLAGS_WAITABLE, "GIMDebugRecv");
+            if (RT_FAILURE(rc))
+            {
+                RTSemEventMultiDestroy(pThis->Dbg.hDbgRecvThreadSem);
+                pThis->Dbg.hDbgRecvThreadSem = NIL_RTSEMEVENTMULTI;
+
+                RTMemFree(pThis->Dbg.pvDbgRecvBuf);
+                pThis->Dbg.pvDbgRecvBuf = NULL;
+                return rc;
+            }
+        }
+        else
+            return rc;
+    }
+
+    /*
+     * Register this device with the GIM component.
+     */
+    GIMR3GimDeviceRegister(pVM, pDevIns, pThis->DbgSetup.cbDbgRecvBuf ? &pThis->Dbg : NULL);
 
     /*
@@ -197 +323 @@
         if (RT_FAILURE(rc))
             return rc;
+    }
+
+    /*
+     * Signal and wait for the debug thread to terminate.
+     */
+    if (pThis->hDbgRecvThread != NIL_RTTHREAD)
+    {
+        pThis->fDbgRecvThreadShutdown = true;
+        if (pThis->Dbg.hDbgRecvThreadSem != NIL_RTSEMEVENT)
+            RTSemEventMultiSignal(pThis->Dbg.hDbgRecvThreadSem);
+
+        int rc = RTThreadWait(pThis->hDbgRecvThread, 20000, NULL /*prc*/);
+        if (RT_SUCCESS(rc))
+            pThis->hDbgRecvThread = NIL_RTTHREAD;
+        else
+        {
+            LogRel(("GIMDev: Debug thread did not terminate, rc=%Rrc!\n", rc));
+            return VERR_RESOURCE_BUSY;
+        }
+    }
+
+    /*
+     * Now clean up the semaphore & buffer now that the thread is gone.
+     */
+    if (pThis->Dbg.hDbgRecvThreadSem != NIL_RTSEMEVENT)
+    {
+        RTSemEventMultiDestroy(pThis->Dbg.hDbgRecvThreadSem);
+        pThis->Dbg.hDbgRecvThreadSem = NIL_RTSEMEVENTMULTI;
+    }
+    if (pThis->Dbg.pvDbgRecvBuf)
+    {
+        RTMemFree(pThis->Dbg.pvDbgRecvBuf);
+        pThis->Dbg.pvDbgRecvBuf = NULL;
     }