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

Timestamp:

Feb 2, 2009 3:52:54 AM (16 years ago)

Author:

vboxsync

Message:

NAT:MT improvements

Location:

trunk/src/VBox/Devices/Network

Files:

• DrvNAT.cpp (modified) (3 diffs)
• slirp/debug.c (modified) (1 diff)
• slirp/slirp.c (modified) (2 diffs)
• slirp/slirp_state.h (modified) (4 diffs)
• slirp/socket.c (modified) (2 diffs)
• slirp/tcp_input.c (modified) (1 diff)
• slirp/tcp_subr.c (modified) (2 diffs)
• slirp/udp.c (modified) (1 diff)

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

@@ -152 +152 @@
     PRTREQ pReq = NULL;
     int rc;
+    const void *buf;
     /* don't queue new requests when the NAT thread is about to stop */
     if (pThis->pThread->enmState != PDMTHREADSTATE_RUNNING)
         return VINF_SUCCESS;
-#ifndef VBOX_WITH_SLIRP_MT
+# ifndef VBOX_WITH_SLIRP_MT
     rc = RTReqAlloc(pThis->pReqQueue, &pReq, RTREQTYPE_INTERNAL);
-#else
+    buf = pvBuf;
+# else
+    buf = (const void *)RTMemAlloc(cb); 
+    memcpy((void *)buf, pvBuf, cb);
     rc = RTReqAlloc((PRTREQQUEUE)slirp_get_queue(pThis->pNATState), &pReq, RTREQTYPE_INTERNAL);
-#endif
+# endif
     AssertReleaseRC(rc);
     pReq->u.Internal.pfn      = (PFNRT)drvNATSendWorker;
     pReq->u.Internal.cArgs    = 3;
     pReq->u.Internal.aArgs[0] = (uintptr_t)pThis;
-    pReq->u.Internal.aArgs[1] = (uintptr_t)pvBuf;
+    pReq->u.Internal.aArgs[1] = (uintptr_t)buf;
     pReq->u.Internal.aArgs[2] = (uintptr_t)cb;
+# ifndef VBOX_WITH_SLIRP_MT
     pReq->fFlags              = RTREQFLAGS_VOID;
+# else
+    pReq->fFlags              = RTREQFLAGS_VOID|RTREQFLAGS_NO_WAIT;
+# endif
 
     rc = RTReqQueue(pReq, 0); /* don't wait, we have to wakeup the NAT thread fist */
+#ifndef VBOX_WITH_SLIRP_MT
     if (RT_LIKELY(rc == VERR_TIMEOUT))
     {
@@ -186 +195 @@
         AssertReleaseRC(rc);
     RTReqFree(pReq);
+#else
+# ifndef RT_OS_WINDOWS
+        /* kick select() */
+    rc = RTFileWrite(pThis->PipeWrite, "", 1, NULL);
+    AssertRC(rc);
+# else
+    /* kick WSAWaitForMultipleEvents */
+    rc = WSASetEvent(pThis->hWakeupEvent);
+    AssertRelease(rc == TRUE);
+# endif
+    AssertReleaseRC(rc);
+#endif
 
 #else /* !VBOX_WITH_SIMPLIFIED_SLIRP_SYNC */
@@ -896 +917 @@
 
 #ifdef VBOX_WITH_SLIRP_MT
-            rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pGuestThread, pThis, drvNATAsyncIoGuest, drvNATAsyncIoGuestWakeup, 128 * _1K, RTTHREADTYPE_EMULATION, "NAT");
+            rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pGuestThread, pThis, drvNATAsyncIoGuest, drvNATAsyncIoGuestWakeup, 128 * _1K, RTTHREADTYPE_IO, "NATGUEST");
             AssertReleaseRC(rc);
 #endif

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

@@ -253 +253 @@
         return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "socket is null");
     if (so->so_state == SS_NOFDREF || so->s == -1) 
-        return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "socket SS_NODREF");
+        return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "socket(%d) SS_NODREF",so->s);
     status = getsockname(so->s, &addr, &socklen);
 
-    Assert(status == 0 && addr.sa_family == AF_INET);
+    if(status != 0 || addr.sa_family != AF_INET)
+    {
+        return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "socket(%d) is invalid(probably closed)",so->s);
+    }
 
     ip = ntohl(so->so_faddr.s_addr);

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

@@ -622 +622 @@
              * See if we need a tcp_fasttimo
              */
-            if (time_fasttimo == 0 && so->so_tcpcb->t_flags & TF_DELACK)
+            if (    time_fasttimo == 0 
+                    && so->so_tcpcb != NULL
+                    && so->so_tcpcb->t_flags & TF_DELACK)
                 time_fasttimo = curtime; /* Flag when we want a fasttimo */
 
@@ -692 +694 @@
                 if (so->so_expire <= curtime)
                 {
-                    QSOCKET_LOCK(udb);
 #ifdef VBOX_WITH_SLIRP_MT
-                    /*we can determinate the next item after udb_detach*/
-                    if (so->so_next != &tcb) 
-                    {
-                        SOCKET_LOCK(so->so_next);
-                        so_next = so->so_next;
-                    }
-#endif
-                    QSOCKET_UNLOCK(udb);
-                    udp_detach(pData, so);
+                    /* we need so_next for continue our cycle*/
+                    so_next = so->so_next;
+#endif
+                    UDP_DETACH(pData, so, so_next);
                     CONTINUE_NO_UNLOCK(udp);
                 }

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

@@ -382 +382 @@
     pReq->u.Internal.aArgs[2] = (uintptr_t)(size);                      \
     pReq->u.Internal.aArgs[3] = (uintptr_t)(so);                        \
-    pReq->fFlags              = RTREQFLAGS_VOID;                        \
+    pReq->fFlags              = RTREQFLAGS_VOID|RTREQFLAGS_NO_WAIT;     \
     rc = RTReqQueue(pReq, 0);                                           \
-    if (RT_LIKELY(rc) == VERR_TIMEOUT)                                  \
-    {                                                                   \
-        SOCKET_UNLOCK(so);                                               \
-        rc = RTReqWait(pReq, RT_INDEFINITE_WAIT);                       \
-        AssertReleaseRC(rc);                                            \
-        SOCKET_LOCK(so);                                                \
-        RTReqFree(pReq);                                                \
-    }                                                                   \
-    else                                                                \
-        AssertReleaseRC(rc);                                            \
+    AssertReleaseRC(rc);                                                \
 } while(0)
 
@@ -488 +479 @@
         AssertReleaseRC(rc);                                            \
         SOCKET_LOCK(so);                                                \
+        RTReqFree(pReq);                                                \
+    }                                                                   \
+    else                                                                \
+        AssertReleaseRC(rc);                                            \
+} while(0)
+
+#define DO_UDP_DETACH(data, so, so_next)                                \
+do {                                                                    \
+    PRTREQ pReq = NULL;                                                 \
+    int rc;                                                             \
+    rc = RTReqAlloc((data)->pReqQueue, &pReq, RTREQTYPE_INTERNAL);      \
+    AssertReleaseRC(rc);                                                \
+    pReq->u.Internal.pfn      = (PFNRT)udp_detach;                      \
+    pReq->u.Internal.cArgs    = 2;                                      \
+    pReq->u.Internal.aArgs[0] = (uintptr_t)(data);                      \
+    pReq->u.Internal.aArgs[1] = (uintptr_t)(so);                        \
+    pReq->fFlags              = RTREQFLAGS_VOID;                        \
+    rc = RTReqQueue(pReq, 0); /* don't wait, we have to release lock before*/ \
+    if (RT_LIKELY(rc) == VERR_TIMEOUT)                                  \
+    {                                                                   \
+        SOCKET_UNLOCK(so);                                              \
+        rc = RTReqWait(pReq, RT_INDEFINITE_WAIT);                       \
+        AssertReleaseRC(rc);                                            \
+        if ((so_next) != &udb) SOCKET_LOCK((so_next));                                         \
         RTReqFree(pReq);                                                \
     }                                                                   \
@@ -536 +551 @@
     (so) = solookup(&__X(queue_ ## label ## _label), (src), (sport), (dst), (dport));   \
 } while (0)
+#define DO_UDP_DETACH(data, so, ignored) udp_detach((data), (so))
 #endif
 
@@ -544 +560 @@
 #define SOWRITE(ret, data, so) DO_SOWRITE((ret), (data), (so))
 #define SORECVFROM(data, so) DO_SORECFROM((data), (so))
+#define UDP_DETACH(data, so, so_next) DO_UDP_DETACH((data), (so), (so_next))
 #endif /* !_slirp_state_h_ */

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

@@ -88 +88 @@
         m_free(pData, so->so_m);
     if(so->so_next && so->so_prev)
-    {
-        if (   so->so_prev != NULL 
-            && so->so_prev != &udb
-            && so->so_prev != &tcb) 
-            {
-                SOCKET_LOCK(so->so_prev);
-                so_prev = so->so_prev;
-            }
         remque(pData, so);  /* crashes if so is not in a queue */
-        if (so_prev != NULL) 
-            SOCKET_UNLOCK(so_prev);
-    }
     so->so_state = SS_NOFDREF; /* for debugging purposes */
     SOCKET_UNLOCK(so);
@@ -105 +94 @@
 
     RTMemFree(so);
-    so = NULL;
 }
 

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

@@ -1654 +1654 @@
     m_free(pData, m);
 
-    SOCKET_UNLOCK(so);
+#ifdef VBOX_WITH_SLIRP_MT
+    /*socket should be killed atm*/
+    AssertRelease(!RTCritSectIsInitialized(&so->so_mutex));
+#endif    
     return;
 }

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

@@ -263 +263 @@
     struct socket *so = tp->t_socket;
     register struct mbuf *m;
+    struct socket *so_next, *so_prev;
 
     struct tseg_qent *te = NULL;
     DEBUG_CALL("tcp_close");
     DEBUG_ARG("tp = %lx", (long )tp);
+    so_next = so_prev = NULL;
     /*XXX: freeing the reassembly queue */
     while (!LIST_EMPTY(&tp->t_segq))
@@ -285 +287 @@
     sbfree(&so->so_rcv);
     sbfree(&so->so_snd);
+    QSOCKET_LOCK(tcb);
+    if (   so->so_next != &tcb
+        && so->so_next != NULL)
+    {
+        SOCKET_LOCK(so->so_next);
+        so_next = so->so_next;
+    }
+    if (   so->so_prev != &tcb
+        && so->so_prev != NULL)
+    {
+        SOCKET_LOCK(so->so_prev);
+        so_prev = so->so_prev;
+    }
+    QSOCKET_UNLOCK(tcb);
     sofree(pData, so);
+    if (so_next != NULL) SOCKET_UNLOCK(so_next);
+    if (so_prev != NULL) SOCKET_UNLOCK(so_prev);
     tcpstat.tcps_closed++;
     return ((struct tcpcb *)0);

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

@@ -400 +400 @@
 udp_detach(PNATState pData, struct socket *so)
 {
+    struct socket *so_next, *so_prev;
+    so_next = so_prev = NULL;
     if (so != &pData->icmp_socket)
     {
+        QSOCKET_LOCK(udb);
+        SOCKET_LOCK(so);
+        if (    so->so_next != &udb
+            && so->so_next != NULL)
+        {
+            SOCKET_LOCK(so->so_next);
+            so_next = so->so_next;
+        }
+        if (    so->so_prev != &udb
+            && so->so_prev != NULL)
+        {
+            SOCKET_LOCK(so->so_prev);
+            so_prev = so->so_prev;
+        }
+        QSOCKET_UNLOCK(udb);
         closesocket(so->s);
-        QSOCKET_LOCK(udb);
         sofree(pData, so);
-        QSOCKET_UNLOCK(udb);
+        if(so_prev != NULL)
+            SOCKET_UNLOCK(so_prev);
+        if(so_next != NULL)
+            SOCKET_UNLOCK(so_next);
     }
 }