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

Timestamp:

Nov 7, 2008 9:38:53 AM (16 years ago)

Author:

vboxsync

Message:

pseudo-timers moved to timers
polling select is notified via pipe (!!! on UNIX) about attaching new socket (to make it sleeping rather then polling)
writing part of slirp_select _fill/_poll are called on drvNATSend
pessimistic queue locking is in process to be tollerant to heavy model and to polling-less Slirp functioning

Location:

trunk/src/VBox/Devices/Network

Files:

• DrvNAT.cpp (modified) (7 diffs)
• slirp/libslirp.h (modified) (1 diff)
• slirp/mbuf.c (modified) (4 diffs)
• slirp/mbuf.h (modified) (1 diff)
• slirp/slirp.c (modified) (14 diffs)
• slirp/tcp_subr.c (modified) (1 diff)
• slirp/udp.c (modified) (2 diffs)

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

@@ -59 +59 @@
 
 #ifdef VBOX_WITH_SYNC_SLIRP
+#include <unistd.h> /* should be in UNix version only*/
 #include <iprt/semaphore.h>
+#include <errno.h>
 #endif
 
@@ -96 +98 @@
     /*used for wakep of poling thread*/
     RTSEMEVENT               semIOmutex;
+    PTMTIMER                 pNATFastTimer;
+    PTMTIMER                 pNATSlowTimer;
+    /** The write end of the control pipe. */
+    RTFILE                  PipeWrite;
+    /** The read end of the control pipe. */
+    RTFILE                  PipeRead;
 #endif
 } DRVNAT, *PDRVNAT;
@@ -168 +176 @@
 #ifndef VBOX_WITH_SYNC_SLIRP
     RTCritSectLeave(&pThis->CritSect);
+#else
+    int ndfds = 0;
+    fd_set writefds;
+    FD_ZERO(&writefds);
+    slirp_send_fill(pThis->pNATState, &ndfds, &writefds);
+    struct timeval tv = {0,0}; /* no wait */
+
+    int cWriteFDs = select(ndfds + 1, NULL, &writefds, NULL, &tv);
+    if (cWriteFDs >= 0)
+        slirp_send_trigger(pThis->pNATState, &ndfds, &writefds);
 #endif
     LogFlow(("drvNATSend: end\n"));
@@ -275 +293 @@
 #else
 
+static DECLCALLBACK(void) drvNATFastTimer(PPDMDRVINS pDrvIns, PTMTIMER pTimer)
+{
+    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
+    if (pThis->enmLinkState  == PDMNETWORKLINKSTATE_UP)
+        slirp_fasttmr(pThis->pNATState);
+    TMTimerSetMicro(pTimer, 2);
+}
+
+static DECLCALLBACK(void) drvNATSlowTimer(PPDMDRVINS pDrvIns, PTMTIMER pTimer)
+{
+    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
+    if (pThis->enmLinkState  == PDMNETWORKLINKSTATE_UP)
+        slirp_slowtmr(pThis->pNATState);
+    TMTimerSetMicro(pTimer, 500);
+}
 static DECLCALLBACK(int) drvNATAsyncIoThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
 {
@@ -301 +334 @@
         slirp_select_fill(pThis->pNATState, &cFDs, &ReadFDs, &WriteFDs, &XcptFDs);
 
-        struct timeval tv = {0, 0}; /* no wait */
-
-        int cReadFDs = select(cFDs + 1, &ReadFDs, &WriteFDs, &XcptFDs, &tv);
-
-        if (cReadFDs >= 0)
+        struct timeval tv = {1, 0}; /* no wait */
+
+        FD_SET(pThis->PipeRead, &ReadFDs); /*Linux only*/
+        cFDs = (pThis->PipeRead < cFDs ? cFDs:pThis->PipeRead);
+        int cReadFDs = select(cFDs + 1, &ReadFDs, NULL, &XcptFDs, &tv);
+
+        if (cReadFDs >= 0) {
             slirp_select_poll(pThis->pNATState, &ReadFDs, &WriteFDs, &XcptFDs);
 
+            if (FD_ISSET(pThis->PipeRead, &ReadFDs)) {
+                /* drain the pipe */
+                char ch;
+                size_t cbRead;
+                RTFileRead(pThis->PipeRead, &ch, 1, &cbRead);
+            }
+        }
 #if 0
         if (cReadFDs == 0) {
@@ -335 +377 @@
 }
 
+/*Callback from slirp to exit from select*/
+void slirp_socket_created(void* pvUser)
+{
+    PDRVNAT pThis = (PDRVNAT)pvUser;
+    int rc = RTFileWrite(pThis->PipeWrite, "", 1, NULL);
+    AssertRC(rc);
+}
 #endif
 
@@ -682 +731 @@
                     rc = RTSemEventCreate(&pThis->semIOmutex);
                     AssertReleaseRC(rc);
+
+                    /*
+                     * Create the control pipe.
+                     * XXX: Linux only
+                     */
+                    int fds[2];
+                    if (pipe(&fds[0]) != 0) /** @todo RTPipeCreate() or something... */
+                    {
+                        int rc = RTErrConvertFromErrno(errno);
+                        AssertRC(rc);
+                        return rc;
+                    }
+                    pThis->PipeRead = fds[0];
+                    pThis->PipeWrite = fds[1];
+
                     rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pThread, pThis, drvNATAsyncIoThread, drvNATAsyncIoWakeup, 128 * _1K, RTTHREADTYPE_IO, "NAT");
                     AssertReleaseRC(rc);
+                    rc = PDMDrvHlpTMTimerCreate(pDrvIns, TMCLOCK_REAL, drvNATFastTimer, "NAT_fast_timer", &pThis->pNATFastTimer);
+                    AssertReleaseRC(rc);
+                    TMTimerSetMicro(pThis->pNATFastTimer, 1);
+                    rc = PDMDrvHlpTMTimerCreate(pDrvIns, TMCLOCK_REAL, drvNATSlowTimer, "NAT_slow_timer", &pThis->pNATSlowTimer);
+                    AssertReleaseRC(rc);
+                    TMTimerSetMicro(pThis->pNATSlowTimer, 500);
 #endif
 

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

@@ -49 +49 @@
                    int guest_port);
 
-
+#ifdef VBOX_WITH_SYNC_SLIRP
+void slirp_fasttmr(PNATState pData);
+void slirp_slowtmr(PNATState pData);
+/*selects open and ready sockets for write*/
+void slirp_send_fill(PNATState pData, int *pnfds, fd_set *writeds);
+/*triggers socket output */
+void slirp_send_trigger(PNATState pData, int *pnfds, fd_set *writeds);
+/*should be implemented by client*/
+void slirp_socket_created(void* pvUser);
+#endif
 #ifdef __cplusplus
 }

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

@@ -80 +80 @@
                         mbuf_max = mbuf_alloced;
                 VBOX_SLIRP_UNLOCK(pData->mbuf_alloced_mutex);
+                VBOX_SLIRP_LOCK_CREATE(&m->m_mutex);
+                VBOX_SLIRP_LOCK(m->m_mutex);
         } else {
                 m = m_freelist.m_next;
+                VBOX_SLIRP_LOCK(m->m_mutex);
+                struct mbuf *n = m->m_next;
+                if (n != NULL)
+                    VBOX_SLIRP_LOCK(n->m_mutex);
                 remque(pData, m);
+                if (m->m_next != NULL)
+                    VBOX_SLIRP_UNLOCK(n->m_mutex);
         }
 
@@ -89 +97 @@
         VBOX_SLIRP_LOCK(pData->m_usedlist_mutex);
         /* Insert it in the used list */
+        struct mbuf *n = m_usedlist.m_next;
+        if (n != &m_usedlist)
+            VBOX_SLIRP_LOCK(n->m_mutex);
         insque(pData, m,&m_usedlist);
-        VBOX_SLIRP_UNLOCK(pData->m_usedlist_mutex);
+        if (n != &m_usedlist)
+            VBOX_SLIRP_LOCK(n->m_mutex);
+        VBOX_SLIRP_UNLOCK(m->m_mutex);
 
         m->m_flags = (flags | M_USEDLIST);
@@ -117 +130 @@
         if (m->m_flags & M_USEDLIST) {
            VBOX_SLIRP_LOCK(pData->m_usedlist_mutex);
+           struct mbuf *p, *n;
+           p = (m->m_prev);
+           n = (m->m_next);
+                VBOX_SLIRP_LOCK(m->m_next);
+           if (n != NULL)
+                VBOX_SLIRP_LOCK(n->m_next);
+           if (p != NULL)
+                VBOX_SLIRP_UNLOCK(p->m_next);
            remque(pData, m);
+           if (n != NULL)
+                VBOX_SLIRP_UNLOCK(n->m_next);
+           if (p != NULL)
+                VBOX_SLIRP_LOCK(p->m_next);
            VBOX_SLIRP_UNLOCK(pData->m_usedlist_mutex);
         }
@@ -130 +155 @@
         if (m->m_flags & M_DOFREE) {
                 u32ptr_done(pData, ptr_to_u32(pData, m), m);
+                VBOX_SLIRP_UNLOCK(m->m_mutex);
+                VBOX_SLIRP_LOCK_DESTROY(m->m_mutex);
                 free(m);
 #ifdef VBOX_WITH_SYNC_SLIRP

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

@@ -76 +76 @@
         caddr_t mh_data;                /* Location of data */
         int     mh_len;                 /* Amount of data in this mbuf */
+#ifdef VBOX_WITH_SYNC_SLIRP
+        RTSEMFASTMUTEX  mh_mutex;
+#endif
 };
 

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

@@ -362 +362 @@
          * First, TCP sockets
          */
+#ifndef VBOX_WITH_SYNC_SLIRP
         do_slowtimo = 0;
+#endif
         if (link_up) {
                 /*
@@ -369 +371 @@
                  */
                 VBOX_SLIRP_LOCK(pData->tcb_mutex);
+#ifndef VBOX_WITH_SYNC_SLIRP
                 do_slowtimo = ((tcb.so_next != &tcb) ||
                                ((struct ipasfrag *)&ipq != u32_to_ptr(pData, ipq.next, struct ipasfrag *)));
+#endif
 
                 so = tcb.so_next;
@@ -389 +393 @@
                          * See if we need a tcp_fasttimo
                          */
+#ifndef VBOX_SLIRP_UNLOCK
                         if (time_fasttimo == 0
                             && so->so_tcpcb
                             &&  so->so_tcpcb->t_flags & TF_DELACK)
                            time_fasttimo = curtime; /* Flag when we want a fasttimo */
+#endif
 
                         /*
@@ -409 +415 @@
                                 goto before_loop_ends;
                         }
-
+#ifndef VBOX_WITH_SYNC_SLIRP
                         /*
                          * Set for writing sockets which are connecting
@@ -427 +433 @@
                                 UPD_NFDS(so->s);
                         }
+#endif
 
                         /*
@@ -465 +472 @@
                          * See if it's timed out
                          */
+#ifndef VBOX_WITH_SYNC_SLIRP
                         if (so->so_expire) {
                                 if (so->so_expire <= curtime) {
@@ -472 +480 @@
                                         do_slowtimo = 1; /* Let socket expire */
                         }
+#endif
 
                         /*
@@ -499 +508 @@
          */
 
+#ifndef VBOX_WITH_SYNC_SLIRP
         /*
          * First, see the timeout needed by *timo
@@ -528 +538 @@
                 }
         }
+#endif
         *pnfds = nfds;
 }
@@ -542 +553 @@
          * See if anything has timed out
          */
+#ifndef VBOX_WITH_SYNC_SLIRP
         if (link_up) {
                 if (time_fasttimo && ((curtime - time_fasttimo) >= 2)) {
@@ -553 +565 @@
                 }
         }
+#endif
 
         /*
@@ -610 +623 @@
                         }
 
+#ifndef VBOX_WITH_SYNC_SLIRP
                         /*
                          * Check sockets for writing
@@ -655 +669 @@
                            */
                         }
+#endif
 
                         /*
@@ -914 +929 @@
     memcpy(client_ethaddr, ethaddr, ETH_ALEN);
 }
+
+#ifdef VBOX_WITH_SYNC_SLIRP
+void slirp_fasttmr(PNATState pData)
+{
+        struct socket *so, *so_next;
+        updtime(pData);
+        time_fasttimo = 0;
+#if 1
+        VBOX_SLIRP_LOCK(pData->tcb_mutex);
+        so = tcb.so_next;
+        while(1) {
+            if (so == &tcb) {
+                VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
+                break;
+            }
+            so_next = so->so_next;
+            VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
+                if (time_fasttimo == 0
+                    && so->so_tcpcb
+                    &&  so->so_tcpcb->t_flags & TF_DELACK)
+                   time_fasttimo = curtime; /* Flag when we want a fasttimo */
+            VBOX_SLIRP_LOCK(pData->tcb_mutex);
+            so = so_next;
+        }
+#endif
+        if (time_fasttimo) {
+            tcp_fasttimo(pData);
+            time_fasttimo = 0;
+        }
+}
+
+void slirp_slowtmr(PNATState pData)
+{
+        struct socket *so, *so_next;
+        updtime(pData);
+        do_slowtimo = 0;
+#if 1
+        VBOX_SLIRP_LOCK(pData->tcb_mutex);
+        do_slowtimo = ((tcb.so_next != &tcb) ||
+                               ((struct ipasfrag *)&ipq != u32_to_ptr(pData, ipq.next, struct ipasfrag *)));
+
+        VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
+
+        VBOX_SLIRP_LOCK(pData->udb_mutex);
+        so = udb.so_next;
+        while(1) {
+            if (so == &udb) {
+                VBOX_SLIRP_UNLOCK(pData->udb_mutex);
+                break;
+            }
+            so_next = so->so_next;
+            VBOX_SLIRP_UNLOCK(pData->udb_mutex);
+
+            if (so->so_expire) {
+                 if (so->so_expire <= curtime) {
+                    udp_detach(pData, so);
+                    goto before_loop_ends;
+                 }
+                do_slowtimo = 1;
+            }
+            before_loop_ends:
+            VBOX_SLIRP_LOCK(pData->udb_mutex);
+            so = so_next;
+        }
+#endif
+        if (do_slowtimo) {
+            tcp_slowtimo(pData);
+            ip_slowtimo(pData);
+            last_slowtimo = curtime;
+        }
+}
+
+/*selects open and ready sockets for write*/
+void slirp_send_fill(PNATState pData, int *pnfds, fd_set *writefds)
+{
+    struct socket *so, *so_next;
+    int nfds = *pnfds;
+
+    if (link_up == 0) return;
+
+    VBOX_SLIRP_LOCK(pData->tcb_mutex);
+    so = tcb.so_next;
+    while (1) {
+        if (so == &tcb) {
+            VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
+            break;
+        }
+        so_next = so->so_next;
+        VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
+
+        if (so->so_state & SS_NOFDREF || so->s == -1)
+               goto before_loop_ends;
+
+        if (so->so_state & SS_ISFCONNECTING) {
+                FD_SET(so->s, writefds);
+                UPD_NFDS(so->s);
+                goto before_loop_ends;
+        }
+
+        if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) {
+                FD_SET(so->s, writefds);
+                UPD_NFDS(so->s);
+        }
+
+        before_loop_ends:
+        VBOX_SLIRP_LOCK(pData->tcb_mutex);
+        so = so_next;
+    }
+    *pnfds = nfds;
+}
+/*triggers socket output */
+void slirp_send_trigger(PNATState pData, int *pnfds, fd_set *writefds)
+{
+    struct socket *so, *so_next;
+    int nfds = *pnfds;
+    int ret;
+
+    if (link_up == 0) return;
+
+    VBOX_SLIRP_LOCK(pData->tcb_mutex);
+    so = tcb.so_next;
+    while (1) {
+        if (so == &tcb) {
+            VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
+            break;
+        }
+        so_next = so->so_next;
+        VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
+        /*
+         * Check sockets for writing
+         */
+        if (FD_ISSET(so->s, writefds)) {
+          /*
+           * Check for non-blocking, still-connecting sockets
+           */
+          if (so->so_state & SS_ISFCONNECTING) {
+            /* Connected */
+            so->so_state &= ~SS_ISFCONNECTING;
+
+        /*
+         * This should be probably guarded by PROBE_CONN too. Anyway,
+         * we disable it on OS/2 because the below send call returns
+         * EFAULT which causes the opened TCP socket to close right
+         * after it has been opened and connected.
+         */
+#ifndef RT_OS_OS2
+        ret = send(so->s, (const char *)&ret, 0, 0);
+        if (ret < 0) {
+          /* XXXXX Must fix, zero bytes is a NOP */
+          if (errno == EAGAIN || errno == EWOULDBLOCK ||
+              errno == EINPROGRESS || errno == ENOTCONN)
+                    goto before_loop_ends;
+
+          /* else failed */
+          so->so_state = SS_NOFDREF;
+        }
+        /* else so->so_state &= ~SS_ISFCONNECTING; */
+#endif
+
+          /*
+           * Continue tcp_input
+           */
+          tcp_input(pData, (struct mbuf *)NULL, sizeof(struct ip), so);
+          /* continue; */
+        } else
+          ret = sowrite(pData, so);
+        /*
+         * XXXXX If we wrote something (a lot), there
+         * could be a need for a window update.
+         * In the worst case, the remote will send
+         * a window probe to get things going again
+         */
+        }
+
+        before_loop_ends:
+        VBOX_SLIRP_LOCK(pData->tcb_mutex);
+        so = so_next;
+    }
+}
+#endif

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

@@ -541 +541 @@
         /*we use this field to identify cache socket to lock/unlock*/
         so->so_type = IPPROTO_TCP;
+        slirp_socket_created(pData->pvUser);
 #endif
 

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

@@ -385 +385 @@
 #ifdef VBOX_WITH_SYNC_SLIRP
   so->so_type = IPPROTO_UDP;
+  slirp_socket_created(pData->pvUser);
 #endif
   return(so->s);
@@ -708 +709 @@
 
         so->so_state = SS_ISFCONNECTED;
-
+#ifdef VBOX_WITH_SYNC_SLIRP
+        slirp_socket_created(pData->pvUser);
+#endif
         return so;
 }