Changeset 4422 in vbox for trunk

Timestamp:

Aug 29, 2007 1:37:48 PM (17 years ago)

Author:

vboxsync

Message:

Tamed the send thread using PDMThread.

Location:

trunk/src/VBox/Devices

Files:

• Network/DevPCNet.cpp (modified) (10 diffs)
• testcase/tstDeviceStructSizeGC.cpp (modified) (1 diff)

trunk/src/VBox/Devices/Network/DevPCNet.cpp

@@ -47 +47 @@
  */
 
+/** To enable the PDMThread based send thread code. 
+ * This is just a emergency switch in case changes doesn't quite work and 
+ * we want to get 1.5 out.
+ * @todo cleanup after 1.5.  */
+#define USE_PDMTHREAD 1
+
 /*******************************************************************************
 *   Header Files                                                               *
@@ -198 +204 @@
     /** If set the link is temporarily down because of a saved state load. */
     bool                                fLinkTempDown;
-    /** This flag is set on SavePrep to prevent altering of memory after pgmR3Save() was called */
+    /** This flag is set on SavePrep to prevent altering of memory after pgmR3Save() was called 
+     * @todo r=bird: This is inadequate, we are not supposed to do anything at all while the VM 
+     *               isn't running. Naturally, the problem really lies with the driver and not
+     *               the pcnet code. We will have to address this properly at some time. */
     bool                                fSaving;
 
@@ -215 +224 @@
     /** Async send thread */
     RTSEMEVENT                          hSendEventSem;
+#ifdef USE_PDMTHREAD
+    /** The Async send thread. */
+    PPDMTHREAD                          pSendThread;
+#else
     RTTHREAD                            hSendThread;
+#endif 
 
     /** Access critical section. */
@@ -2053 +2067 @@
                     {
                         int rc = pcnetXmitCompleteFrame(pData);
+#ifdef USE_PDMTHREAD
+                        AssertRCReturn(rc, rc);
+#else
                         if (VBOX_FAILURE(rc))
                             return rc; /* can happen during termination */
+#endif 
                     }
                 }
@@ -2160 +2178 @@
                     {
                         int rc = pcnetXmitCompleteFrame(pData);
+#ifdef USE_PDMTHREAD
+                        AssertRCReturn(rc, rc);
+#else
                         if (VBOX_FAILURE(rc))
                             return rc; /* can happen during termination */
+#endif 
                     }
                     else if (CSR_LOOP(pData) && !fDropFrame)
@@ -2223 +2245 @@
 }
 
+
+#ifdef USE_PDMTHREAD
+/** 
+ * Async I/O thread for delayed sending of packets.
+ * 
+ * @returns VBox status code. Returning failure will naturally terminate the thread.
+ * @param   pDevIns     The pcnet device instance.
+ * @param   pThread     The thread.
+ */
+static DECLCALLBACK(int) pcnetAsyncSendThread(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
+{
+    PCNetState *pThis = PDMINS2DATA(pDevIns, PCNetState *);
+
+    /*
+     * We can enter this function in two states, initializing or resuming.
+     *
+     * The idea about the initializing bit is that we can do per-thread 
+     * initialization while the creator thread can still pick up errors.
+     * At present, there is nothing to init, or at least nothing that
+     * need initing in the thread.
+     */
+    if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
+        return VINF_SUCCESS;
+
+    /*
+     * Stay in the run-loop until we're supposed to leave the 
+     * running state. If something really bad happens, we'll
+     * quit the loop while in the running state and return
+     * an error status to PDM and let it terminate the thread.
+     */
+    while (pThread->enmState == PDMTHREADSTATE_RUNNING)
+    {
+        /*
+         * Block until we've got something to send or is supposed
+         * to leave the running state.
+         */
+        int rc = RTSemEventWait(pThis->hSendEventSem, RT_INDEFINITE_WAIT);
+        AssertRCReturn(rc, rc);
+        if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
+            break;
+
+        /*
+         * Perform async send. Mind that we might be requested to 
+         * suspended while waiting for the critical section.
+         */
+        rc = PDMCritSectEnter(&pThis->CritSect, VERR_PERMISSION_DENIED);
+        AssertReleaseRCReturn(rc, rc);
+
+        if (pThread->enmState == PDMTHREADSTATE_RUNNING)
+        {
+            rc = pcnetAsyncTransmit(pThis);
+            AssertReleaseRC(rc);
+        }
+
+        PDMCritSectLeave(&pThis->CritSect);
+    }
+
+    /* The thread is being suspended or terminated. */
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Unblock the send thread so it can respond to a state change.
+ * 
+ * @returns VBox status code.
+ * @param   pDevIns     The pcnet device instance.
+ * @param   pThread     The send thread.
+ */
+static DECLCALLBACK(int) pcnetAsyncSendThreadWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
+{
+    PCNetState *pThis = PDMINS2DATA(pDevIns, PCNetState *);
+    return RTSemEventSignal(pThis->hSendEventSem);
+}
+
+
+#else /* USE_PDMTHREAD */
 /**
  * Async I/O thread for delayed sending of packets.
@@ -2248 +2347 @@
     return VINF_SUCCESS;
 }
+#endif /* USE_PDMTHREAD */
 
 #endif /* IN_RING3 */
@@ -2263 +2363 @@
         pcnetTransmit(pData);
 }
+
 
 /**
@@ -3994 +4095 @@
     PCNetState *pData = PDMINS2DATA(pDevIns, PCNetState *);
 
-    PDMCritSectEnter(&pData->CritSect, VERR_ACCESS_DENIED);
-
-    RTSemEventDestroy(pData->hSendEventSem);
-    pData->hSendEventSem = 0;
-    PDMCritSectLeave(&pData->CritSect);
-
-    PDMR3CritSectDelete(&pData->CritSect);
+    if (PDMCritSectIsInitialized(&pData->CritSect))
+    {
+#ifdef USE_PDMTHREAD
+        /* 
+         * At this point the send thread is suspended and will not enter
+         * this module again. So, no coordination is needed here and PDM 
+         * will take care of terminating and cleaning up the thread.
+         */
+        RTSemEventDestroy(pData->hSendEventSem);
+        pData->hSendEventSem = NIL_RTSEMEVENT;
+        PDMR3CritSectDelete(&pData->CritSect);
+#else
+        PDMCritSectEnter(&pData->CritSect, VERR_ACCESS_DENIED);
+
+        RTSemEventDestroy(pData->hSendEventSem);
+        pData->hSendEventSem = 0;
+
+        PDMCritSectLeave(&pData->CritSect);
+        PDMR3CritSectDelete(&pData->CritSect);
+#endif 
+    }
     return VINF_SUCCESS;
 }
@@ -4270 +4385 @@
 
     /* Create asynchronous thread */
+#ifdef USE_PDMTHREAD
+    rc = PDMDevHlpPDMThreadCreate(pDevIns, &pData->pSendThread, pData, pcnetAsyncSendThread, pcnetAsyncSendThreadWakeUp, 0, RTTHREADTYPE_IO, "PCNET_SEND");
+    AssertRCReturn(rc, rc);
+#else
     rc = RTThreadCreate(&pData->hSendThread, pcnetAsyncSend, (void *)pData, 128*1024, RTTHREADTYPE_IO, 0, "PCNET_SEND");
     AssertRC(rc);
+#endif 
 
 #ifdef VBOX_WITH_STATISTICS

trunk/src/VBox/Devices/testcase/tstDeviceStructSizeGC.cpp

@@ -353 +353 @@
     GEN_CHECK_OFF(PCNetState, pLedsConnector);
     GEN_CHECK_OFF(PCNetState, hSendEventSem);
+#ifdef USE_PDMTHREAD
+    GEN_CHECK_OFF(PCNetState, pSendThread);
+#else
     GEN_CHECK_OFF(PCNetState, hSendThread);
+#endif 
     GEN_CHECK_OFF(PCNetState, CritSect);
     GEN_CHECK_OFF(PCNetState, cPendingSends);