Changeset 39498 in vbox for trunk/src/VBox/Devices/Network

Timestamp:

Dec 1, 2011 7:59:21 PM (13 years ago)

Author:

vboxsync

Message:

RTReq refactoring.

Location:

trunk/src/VBox/Devices/Network

Files:

• DrvNAT.cpp (modified) (15 diffs)
• slirp/slirp.c (modified) (2 diffs)
• slirp/slirp_state.h (modified) (8 diffs)

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

@@ -154 +154 @@
     PPDMTHREAD              pSlirpThread;
     /** Queue for NAT-thread-external events. */
-    PRTREQQUEUE             pSlirpReqQueue;
+    RTREQQUEUE              hSlirpReqQueue;
     /** The guest IP for port-forwarding. */
     uint32_t                GuestIP;
@@ -185 +185 @@
     RTSEMEVENT              EventUrgRecv;
     /** Receive Req queue (deliver packets to the guest) */
-    PRTREQQUEUE             pRecvReqQueue;
+    RTREQQUEUE              hRecvReqQueue;
     /** Receive Urgent Req queue (deliver packets to the guest). */
-    PRTREQQUEUE             pUrgRecvReqQueue;
+    RTREQQUEUE              hUrgRecvReqQueue;
 
     /** makes access to device func RecvAvail and Recv atomical. */
@@ -219 +219 @@
     while (pThread->enmState == PDMTHREADSTATE_RUNNING)
     {
-        RTReqProcess(pThis->pRecvReqQueue, 0);
+        RTReqQueueProcess(pThis->hRecvReqQueue, 0);
         if (ASMAtomicReadU32(&pThis->cPkts) == 0)
             RTSemEventWait(pThis->EventRecv, RT_INDEFINITE_WAIT);
@@ -246 +246 @@
     while (pThread->enmState == PDMTHREADSTATE_RUNNING)
     {
-        RTReqProcess(pThis->pUrgRecvReqQueue, 0);
+        RTReqQueueProcess(pThis->hUrgRecvReqQueue, 0);
         if (ASMAtomicReadU32(&pThis->cUrgPkts) == 0)
         {
@@ -535 +535 @@
 
 #ifdef VBOX_WITH_SLIRP_MT
-        PRTREQQUEUE pQueue = (PRTREQQUEUE)slirp_get_queue(pThis->pNATState);
+        RTREQQUEUE hQueue = (RTREQQUEUE)slirp_get_queue(pThis->pNATState);
 #else
-        PRTREQQUEUE pQueue = pThis->pSlirpReqQueue;
+        RTREQQUEUE hQueue = pThis->hSlirpReqQueue;
 #endif
-        rc = RTReqCallEx(pQueue, NULL /*ppReq*/, 0 /*cMillies*/, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
-                         (PFNRT)drvNATSendWorker, 2, pThis, pSgBuf);
+        rc = RTReqQueueCallEx(hQueue, NULL /*ppReq*/, 0 /*cMillies*/, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
+                              (PFNRT)drvNATSendWorker, 2, pThis, pSgBuf);
         if (RT_SUCCESS(rc))
         {
@@ -637 +637 @@
 
     PRTREQ pReq;
-    int rc = RTReqCallEx(pThis->pSlirpReqQueue, &pReq, 0 /*cMillies*/, RTREQFLAGS_VOID,
-                         (PFNRT)drvNATNotifyLinkChangedWorker, 2, pThis, enmLinkState);
+    int rc = RTReqQueueCallEx(pThis->hSlirpReqQueue, &pReq, 0 /*cMillies*/, RTREQFLAGS_VOID,
+                              (PFNRT)drvNATNotifyLinkChangedWorker, 2, pThis, enmLinkState);
     if (RT_LIKELY(rc == VERR_TIMEOUT))
     {
@@ -684 +684 @@
     PDRVNAT pThis = RT_FROM_MEMBER(pInterface, DRVNAT, INetworkNATCfg);
     PRTREQ pReq;
-    int rc = RTReqCallEx(pThis->pSlirpReqQueue, &pReq, 0 /*cMillies*/, RTREQFLAGS_VOID,
-                         (PFNRT)drvNATNotifyApplyPortForwardCommand, 7, pThis, fRemove,
-                         fUdp, pHostIp, u16HostPort, pGuestIp, u16GuestPort);
+    int rc = RTReqQueueCallEx(pThis->hSlirpReqQueue, &pReq, 0 /*cMillies*/, RTREQFLAGS_VOID,
+                              (PFNRT)drvNATNotifyApplyPortForwardCommand, 7, pThis, fRemove,
+                              fUdp, pHostIp, u16HostPort, pGuestIp, u16GuestPort);
     if (RT_LIKELY(rc == VERR_TIMEOUT))
     {
@@ -707 +707 @@
  * dedicated thread. We take care that this thread does not become the
  * bottleneck: If the guest wants to send, a request is enqueued into the
- * pSlirpReqQueue and handled asynchronously by this thread.  If this thread
+ * hSlirpReqQueue and handled asynchronously by this thread.  If this thread
  * wants to deliver packets to the guest, it enqueues a request into
- * pRecvReqQueue which is later handled by the Recv thread.
+ * hRecvReqQueue which is later handled by the Recv thread.
  */
 static DECLCALLBACK(int) drvNATAsyncIoThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
@@ -792 +792 @@
         }
         /* process _all_ outstanding requests but don't wait */
-        RTReqProcess(pThis->pSlirpReqQueue, 0);
+        RTReqQueueProcess(pThis->hSlirpReqQueue, 0);
         RTMemFree(polls);
 
@@ -819 +819 @@
         slirp_select_poll(pThis->pNATState, /* fTimeout=*/false, /* fIcmp=*/(dwEvent == WSA_WAIT_EVENT_0));
         /* process _all_ outstanding requests but don't wait */
-        RTReqProcess(pThis->pSlirpReqQueue, 0);
+        RTReqQueueProcess(pThis->hSlirpReqQueue, 0);
 # ifdef VBOX_NAT_DELAY_HACK
         if (cBreak++ > 128)
@@ -903 +903 @@
 
     ASMAtomicIncU32(&pThis->cUrgPkts);
-    int rc = RTReqCallEx(pThis->pUrgRecvReqQueue, NULL /*ppReq*/, 0 /*cMillies*/, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
-                         (PFNRT)drvNATUrgRecvWorker, 4, pThis, pu8Buf, cb, m);
+    int rc = RTReqQueueCallEx(pThis->hUrgRecvReqQueue, NULL /*ppReq*/, 0 /*cMillies*/, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
+                              (PFNRT)drvNATUrgRecvWorker, 4, pThis, pu8Buf, cb, m);
     AssertRC(rc);
     drvNATUrgRecvWakeup(pThis->pDrvIns, pThis->pUrgRecvThread);
@@ -937 +937 @@
 
     ASMAtomicIncU32(&pThis->cPkts);
-    int rc = RTReqCallEx(pThis->pRecvReqQueue, NULL /*ppReq*/, 0 /*cMillies*/, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
-                         (PFNRT)drvNATRecvWorker, 4, pThis, pu8Buf, cb, m);
+    int rc = RTReqQueueCallEx(pThis->hRecvReqQueue, NULL /*ppReq*/, 0 /*cMillies*/, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
+                              (PFNRT)drvNATRecvWorker, 4, pThis, pu8Buf, cb, m);
     AssertRC(rc);
     drvNATRecvWakeup(pThis->pDrvIns, pThis->pRecvThread);
@@ -1119 +1119 @@
     }
 
-    RTReqDestroyQueue(pThis->pSlirpReqQueue);
-    pThis->pSlirpReqQueue = NULL;
-
-    RTReqDestroyQueue(pThis->pUrgRecvReqQueue);
-    pThis->pUrgRecvReqQueue = NULL;
+    RTReqQueueDestroy(pThis->hSlirpReqQueue);
+    pThis->hSlirpReqQueue = NIL_RTREQQUEUE;
+
+    RTReqQueueDestroy(pThis->hUrgRecvReqQueue);
+    pThis->hUrgRecvReqQueue = NIL_RTREQQUEUE;
 
     RTSemEventDestroy(pThis->EventRecv);
@@ -1172 +1172 @@
     pThis->pszBootFile                  = NULL;
     pThis->pszNextServer                = NULL;
-    pThis->pSlirpReqQueue               = NULL;
-    pThis->pUrgRecvReqQueue             = NULL;
+    pThis->hSlirpReqQueue               = NIL_RTREQQUEUE;
+    pThis->hUrgRecvReqQueue             = NIL_RTREQQUEUE;
     pThis->EventRecv                    = NIL_RTSEMEVENT;
     pThis->EventUrgRecv                 = NIL_RTSEMEVENT;
@@ -1301 +1301 @@
              */
             rc = PDMDrvHlpSSMRegisterLoadDone(pDrvIns, drvNATLoadDone);
-            AssertRCReturn(rc, rc);
-
-            rc = RTReqCreateQueue(&pThis->pSlirpReqQueue);
-            if (RT_FAILURE(rc))
-            {
-                LogRel(("NAT: Can't create request queue\n"));
-                return rc;
-            }
-
-            rc = RTReqCreateQueue(&pThis->pRecvReqQueue);
-            if (RT_FAILURE(rc))
-            {
-                LogRel(("NAT: Can't create request queue\n"));
-                return rc;
-            }
-
-            rc = RTReqCreateQueue(&pThis->pUrgRecvReqQueue);
-            if (RT_FAILURE(rc))
-            {
-                LogRel(("NAT: Can't create request queue\n"));
-                return rc;
-            }
+            AssertLogRelRCReturn(rc, rc);
+
+            rc = RTReqQueueCreate(&pThis->hSlirpReqQueue);
+            AssertLogRelRCReturn(rc, rc);
+
+            rc = RTReqQueueCreate(&pThis->hRecvReqQueue);
+            AssertLogRelRCReturn(rc, rc);
+
+            rc = RTReqQueueCreate(&pThis->hUrgRecvReqQueue);
+            AssertLogRelRCReturn(rc, rc);
 
             rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pRecvThread, pThis, drvNATRecv,

trunk/src/VBox/Devices/Network/slirp/slirp.c

@@ -622 +622 @@
     QSOCKET_LOCK_CREATE(tcb);
     QSOCKET_LOCK_CREATE(udb);
-    rc = RTReqCreateQueue(&pData->pReqQueue);
+    rc = RTReqQueueCreate(&pData->pReqQueue);
     AssertReleaseRC(rc);
 #endif
@@ -1950 +1950 @@
 void slirp_process_queue(PNATState pData)
 {
-     RTReqProcess(pData->pReqQueue, RT_INDEFINITE_WAIT);
+     RTReqQueueProcess(pData->pReqQueue, RT_INDEFINITE_WAIT);
 }
 void *slirp_get_queue(PNATState pData)

trunk/src/VBox/Devices/Network/slirp/slirp_state.h

@@ -136 +136 @@
     int soMaxConn;
 #ifdef VBOX_WITH_SLIRP_MT
-    PRTREQQUEUE pReqQueue;
+    RTREQQUEUE hReqQueue;
 #endif
 #ifdef RT_OS_WINDOWS
@@ -474 +474 @@
         PRTREQ pReq;                                                    \
         int rc;                                                         \
-        rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /*cMillies*/,    \
-                           (PFNRT)tcp_output 2, data, sotcb);           \
+        rc = RTReqQueueCallVoid((data)->hReqQueue, &pReq, 0 /*cMillies*/, \
+                                (PFNRT)tcp_output 2, data, sotcb);      \
         if (RT_LIKELY(rc == VERR_TIMEOUT))                              \
         {                                                               \
@@ -491 +491 @@
     do {                                                                \
         int rc;                                                         \
-        rc = RTReqCallEx((data)->pReqQueue, NULL, 0 /*cMillies*/,       \
-                         RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,          \
-                         (PFNRT)tcp_input, 4, data, mbuf, size, so);    \
+        rc = RTReqQueueCallEx((data)->hReqQueue, NULL, 0 /*cMillies*/,  \
+                              RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,     \
+                              (PFNRT)tcp_input, 4, data, mbuf, size, so); \
         AssertReleaseRC(rc);                                            \
     } while(0)
@@ -501 +501 @@
         PRTREQ pReq;                                                    \
         int rc;                                                         \
-        rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /*cMillies*/,    \
-                           (PFNRT)tcp_connect, 2, data, so);            \
+        rc = RTReqQueueCallVoid((data)->hReqQueue, &pReq, 0 /*cMillies*/, \
+                                (PFNRT)tcp_connect, 2, data, so);       \
         if (RT_LIKELY(rc == VERR_TIMEOUT))                              \
         {                                                               \
@@ -519 +519 @@
         PRTREQ pReq;                                                    \
         int rc;                                                         \
-        rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /*cMillies*/,    \
-                           (PFNRT)soread_queue, 4,                      \
-                           data, so, ifclose, &(ret));                  \
+        rc = RTReqQueueCallVoid((data)->hReqQueue, &pReq, 0 /*cMillies*/, \
+                                (PFNRT)soread_queue, 4,                 \
+                                data, so, ifclose, &(ret));             \
         if (RT_LIKELY(rc == VERR_TIMEOUT))                              \
         {                                                               \
@@ -538 +538 @@
         PRTREQ pReq;                                                    \
         int rc;                                                         \
-        rc = RTReqCall((data)->pReqQueue, &pReq, 0 /*cMillies*/,        \
-                       (PFNRT)sowrite, 2, data, so);                    \
+        rc = RTReqQueueCall((data)->hReqQueue, &pReq, 0 /*cMillies*/,   \
+                            (PFNRT)sowrite, 2, data, so);               \
         if (RT_LIKELY(rc == VERR_TIMEOUT))                              \
         {                                                               \
@@ -556 +556 @@
         PRTREQ pReq;                                                    \
         int rc;                                                         \
-        rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /*cMillies */,   \
-                           (PFNRT)sorecvfrom, 2, data, so);             \
+        rc = RTReqQueueCallVoid((data)->hReqQueue, &pReq, 0 /*cMillies */, \
+                                (PFNRT)sorecvfrom, 2, data, so);        \
         if (RT_LIKELY(rc == VERR_TIMEOUT))                              \
         {                                                               \
@@ -574 +574 @@
         PRTREQ pReq;                                                    \
         int rc;                                                         \
-        rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /* cMillies*/,   \
-                           (PFNRT)udp_detach, 2, data, so);             \
+        rc = RTReqQueueCallVoid((data)->hReqQueue, &pReq, 0 /* cMillies*/, \
+                                (PFNRT)udp_detach, 2, data, so);        \
         if (RT_LIKELY(rc == VERR_TIMEOUT))                              \
         {                                                               \