Changeset 23462 in vbox for trunk/src

Timestamp:

Oct 1, 2009 5:42:19 AM (15 years ago)

Author:

vboxsync

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

53061

Message:

NAT: Big changeset:

1. mbuf_zone has been inroduced.
2. IPRT timers replaces Slirp's one making poll/WSAWaitForMultipleEvents blocking.
3. UrgRecv(Thread,Req) introduced for transfering ICMP errors/ARP with highter priority.

Location:

trunk/src/VBox/Devices/Network

Files:

• DrvNAT.cpp (modified) (14 diffs)
• slirp/counters.h (modified) (1 diff)
• slirp/if.c (modified) (1 diff)
• slirp/ip_icmp.c (modified) (3 diffs)
• slirp/ip_output.c (modified) (3 diffs)
• slirp/libslirp.h (modified) (2 diffs)
• slirp/main.h (modified) (1 diff)
• slirp/mbuf.c (modified) (10 diffs)
• slirp/mbuf.h (modified) (4 diffs)
• slirp/slirp.c (modified) (21 diffs)
• slirp/slirp.h (modified) (1 diff)
• slirp/slirp_state.h (modified) (3 diffs)
• slirp/tcp_output.c (modified) (1 diff)

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

@@ -166 +166 @@
     /** thread delivering packets for receiving by the guest */
     PPDMTHREAD              pRecvThread;
+    /** thread delivering urg packets for receiving by the guest */
+    PPDMTHREAD              pUrgRecvThread;
     /** event to wakeup the guest receive thread */
     RTSEMEVENT              EventRecv;
+    /** event to wakeup the guest urgent receive thread */
+    RTSEMEVENT              EventUrgRecv;
     /** Receive Req queue (deliver packets to the guest) */
     PRTREQQUEUE             pRecvReqQueue;
+    /** Receive Urgent Req queue (deliver packets to the guest) */
+    PRTREQQUEUE             pUrgRecvReqQueue;
+
+    /* makes access to device func RecvAvail and Recv atomical */
+    RTCRITSECT                csDevAccess;
+    volatile uint32_t cUrgPkt;
+    volatile uint32_t cPkt;
+    PTMTIMERR3 pTmrSlow;
+    PTMTIMERR3 pTmrFast;
 } DRVNAT;
 AssertCompileMemberAlignment(DRVNAT, StatNATRecvWakeups, 8);
@@ -193 +206 @@
 
 static void drvNATNotifyNATThread(PDRVNAT pThis);
+static DECLCALLBACK(void) drvNATSlowTimer(PPDMDRVINS pDrvIns, PTMTIMER pTimer, void *pvUser);
+static DECLCALLBACK(void) drvNATFast(PPDMDRVINS pDrvIns, PTMTIMER pTimer, void *pvUser);
 
 
@@ -198 +213 @@
 #define PDMINETWORKCONNECTOR_2_DRVNAT(pInterface)   ( (PDRVNAT)((uintptr_t)pInterface - RT_OFFSETOF(DRVNAT, INetworkConnector)) )
 
+static DECLCALLBACK(void) drvNATSlowTimer(PPDMDRVINS pDrvIns, PTMTIMER pTimer, void *pvUser)
+{
+    Assert(pvUser);
+    PDRVNAT pThis = (PDRVNAT)pvUser;
+    drvNATNotifyNATThread(pThis);
+}
+
+static DECLCALLBACK(void) drvNATFastTimer(PPDMDRVINS pDrvIns, PTMTIMER pTimer, void *pvUser)
+{
+    Assert(pvUser);
+    PDRVNAT pThis = (PDRVNAT)pvUser;
+    drvNATNotifyNATThread(pThis);
+}
 
 
 static DECLCALLBACK(int) drvNATRecv(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
- {
+{
     PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
 
@@ -210 +238 @@
     {
         RTReqProcess(pThis->pRecvReqQueue, 0);
-        RTSemEventWait(pThis->EventRecv, RT_INDEFINITE_WAIT);
+        if (ASMAtomicReadU32(&pThis->cPkt) == 0) 
+            RTSemEventWait(pThis->EventRecv, RT_INDEFINITE_WAIT);
     }
     return VINF_SUCCESS;
@@ -226 +255 @@
 }
 
-
-static DECLCALLBACK(void) drvNATRecvWorker(PDRVNAT pThis, uint8_t *pu8Buf, int cb)
+static DECLCALLBACK(int) drvNATUrgRecv(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
+{
+    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
+
+    if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
+        return VINF_SUCCESS;
+
+    while (pThread->enmState == PDMTHREADSTATE_RUNNING)
+    {
+        RTReqProcess(pThis->pUrgRecvReqQueue, 0);
+        if (ASMAtomicReadU32(&pThis->cUrgPkt) == 0) 
+            RTSemEventWait(pThis->EventUrgRecv, RT_INDEFINITE_WAIT);
+    }
+    return VINF_SUCCESS;
+}
+static DECLCALLBACK(int) drvNATUrgRecvWakeup(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
+{
+    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
+    int rc = RTSemEventSignal(pThis->EventUrgRecv);
+
+    AssertReleaseRC(rc);
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(void) drvNATUrgRecvWorker(PDRVNAT pThis, uint8_t *pu8Buf, int cb, void *pvArg)
+{
+    int rc = RTCritSectEnter(&pThis->csDevAccess);
+    AssertReleaseRC(rc);
+    rc = pThis->pPort->pfnWaitReceiveAvail(pThis->pPort, RT_INDEFINITE_WAIT);
+    if (RT_SUCCESS(rc))
+    {
+        rc = pThis->pPort->pfnReceive(pThis->pPort, pu8Buf, cb);
+        rc = RTCritSectLeave(&pThis->csDevAccess);
+        AssertReleaseRC(rc);
+        slirp_ext_m_free(pThis->pNATState, pvArg);
+    }
+    else if (   RT_FAILURE(rc) 
+             && (  rc == VERR_TIMEOUT
+                || rc == VERR_INTERRUPTED))
+    {
+        rc = RTCritSectLeave(&pThis->csDevAccess);
+        slirp_ext_m_free(pThis->pNATState, pvArg);
+    } 
+    else
+    {
+        rc = RTCritSectLeave(&pThis->csDevAccess);
+        slirp_ext_m_free(pThis->pNATState, pvArg);
+        AssertReleaseRC(rc);
+    }
+    if (ASMAtomicDecU32(&pThis->cUrgPkt) == 0) 
+    {
+        drvNATRecvWakeup(pThis->pDrvIns, pThis->pRecvThread);
+        drvNATNotifyNATThread(pThis);
+    }
+}
+
+
+static DECLCALLBACK(void) drvNATRecvWorker(PDRVNAT pThis, uint8_t *pu8Buf, int cb, void *pvArg)
 {
     STAM_PROFILE_START(&pThis->StatNATRecv, a);
 
     STAM_PROFILE_START(&pThis->StatNATRecvWait, b);
-    int rc = pThis->pPort->pfnWaitReceiveAvail(pThis->pPort, RT_INDEFINITE_WAIT);
-    AssertMsgRC(rc, ("NAT: No RX available even on indefinite wait; rc=%Rrc", rc));
+
+    while(ASMAtomicReadU32(&pThis->cUrgPkt) != 0)
+        RTSemEventWait(pThis->EventRecv, RT_INDEFINITE_WAIT);
+
+    int rc = RTCritSectEnter(&pThis->csDevAccess);
+    rc = pThis->pPort->pfnWaitReceiveAvail(pThis->pPort, RT_INDEFINITE_WAIT);
+    if (RT_SUCCESS(rc))
+    {
+        rc = pThis->pPort->pfnReceive(pThis->pPort, pu8Buf, cb);
+        AssertReleaseRC(rc);
+        rc = RTCritSectLeave(&pThis->csDevAccess);
+        AssertReleaseRC(rc);
+        slirp_ext_m_free(pThis->pNATState, pvArg);
+    } 
+    else if (   RT_FAILURE(rc) 
+             && (  rc == VERR_TIMEOUT
+                || rc == VERR_INTERRUPTED))
+    {
+        rc = RTCritSectLeave(&pThis->csDevAccess);
+        AssertReleaseRC(rc);
+        slirp_ext_m_free(pThis->pNATState, pvArg);
+    }
+    else
+    {
+        rc = RTCritSectLeave(&pThis->csDevAccess);
+        slirp_ext_m_free(pThis->pNATState, pvArg);
+        AssertReleaseRC(rc);
+    }
+    ASMAtomicDecU32(&pThis->cPkt);
+
+    drvNATNotifyNATThread(pThis);
 
     STAM_PROFILE_STOP(&pThis->StatNATRecvWait, b);
-
-    rc = pThis->pPort->pfnReceive(pThis->pPort, pu8Buf, cb);
-    AssertRC(rc);
-    RTMemFree(pu8Buf);
-
     STAM_PROFILE_STOP(&pThis->StatNATRecv, a);
 }
@@ -248 +357 @@
  * @thread "NAT" thread.
  */
-static void drvNATSendWorker(PDRVNAT pThis, const void *pvBuf, size_t cb)
+static void drvNATSendWorker(PDRVNAT pThis, void *pvBuf, size_t cb)
 {
     Assert(pThis->enmLinkState == PDMNETWORKLINKSTATE_UP);
     if (pThis->enmLinkState == PDMNETWORKLINKSTATE_UP)
-        slirp_input(pThis->pNATState, (uint8_t *)pvBuf, cb);
+        slirp_input(pThis->pNATState, pvBuf);
 }
 
@@ -288 +397 @@
 
     /* @todo: Here we should get mbuf instead temporal buffer */
+#if 0
     buf = RTMemAlloc(cb);
     if (buf == NULL)
@@ -295 +405 @@
     }
     memcpy(buf, pvBuf, cb);
+#else
+    void *pvmBuf = slirp_ext_m_get(pThis->pNATState);
+    Assert(pvmBuf);
+    slirp_ext_m_append(pThis->pNATState, pvmBuf, (uint8_t *)pvBuf, cb);
+#endif
 
     pReq->u.Internal.pfn      = (PFNRT)drvNATSendWorker;
-    pReq->u.Internal.cArgs    = 3;
+    pReq->u.Internal.cArgs    = 2;
     pReq->u.Internal.aArgs[0] = (uintptr_t)pThis;
-    pReq->u.Internal.aArgs[1] = (uintptr_t)buf;
-    pReq->u.Internal.aArgs[2] = (uintptr_t)cb;
+    pReq->u.Internal.aArgs[1] = (uintptr_t)pvmBuf;
     pReq->fFlags              = RTREQFLAGS_VOID|RTREQFLAGS_NO_WAIT;
 
@@ -459 +573 @@
         /* don't pass the managemant pipe */
         slirp_select_fill(pThis->pNATState, &nFDs, &polls[1]);
+#if 0
         ms = slirp_get_timeout_ms(pThis->pNATState);
+#else
+        ms = 0;
+#endif
 
         polls[0].fd = pThis->PipeRead;
@@ -509 +627 @@
 #else /* RT_OS_WINDOWS */
         slirp_select_fill(pThis->pNATState, &nFDs);
+#if 0
         ms = slirp_get_timeout_ms(pThis->pNATState);
+#else
+        ms = 0;
+#endif
         struct timeval tv = { 0, ms*1000 };
         event = WSAWaitForMultipleEvents(nFDs, phEvents, FALSE, ms ? ms : WSA_INFINITE, FALSE);
@@ -585 +707 @@
 #endif /* VBOX_WITH_SLIRP_MT */
 
+void slirp_arm_fast_timer(void *pvUser)
+{
+    PDRVNAT pThis = (PDRVNAT)pvUser;
+    Assert(pThis);
+    TMTimerSetMillies(pThis->pTmrFast, 2);
+}
+
+void slirp_arm_slow_timer(void *pvUser)
+{
+    PDRVNAT pThis = (PDRVNAT)pvUser;
+    Assert(pThis);
+    TMTimerSetMillies(pThis->pTmrSlow, 500);
+}
 
 /**
@@ -596 +731 @@
 }
 
-/**
- * Function called by slirp to feed incoming data to the network port.
- */
-void slirp_output(void *pvUser, void *pvArg, const uint8_t *pu8Buf, int cb)
+void slirp_push_recv_thread(void *pvUser)
 {
     PDRVNAT pThis = (PDRVNAT)pvUser;
     Assert(pThis);
-
-    LogFlow(("slirp_output BEGIN %x %d\n", pu8Buf, cb));
-    Log2(("slirp_output: pu8Buf=%p cb=%#x (pThis=%p)\n%.*Rhxd\n", pu8Buf, cb, pThis, cb, pu8Buf));
+    drvNATUrgRecvWakeup(pThis->pDrvIns, pThis->pUrgRecvThread);
+}
+
+void slirp_urg_output(void *pvUser, void *pvArg, const uint8_t *pu8Buf, int cb)
+{
+    PDRVNAT pThis = (PDRVNAT)pvUser;
+    Assert(pThis);
+    ASMAtomicIncU32(&pThis->cUrgPkt);
 
     PRTREQ pReq = NULL;
@@ -613 +750 @@
         return;
 
-    int rc = RTReqAlloc(pThis->pRecvReqQueue, &pReq, RTREQTYPE_INTERNAL);
+    int rc = RTReqAlloc(pThis->pUrgRecvReqQueue, &pReq, RTREQTYPE_INTERNAL);
     AssertReleaseRC(rc);
-    pReq->u.Internal.pfn      = (PFNRT)drvNATRecvWorker;
-    pReq->u.Internal.cArgs    = 3;
+    pReq->u.Internal.pfn      = (PFNRT)drvNATUrgRecvWorker;
+    pReq->u.Internal.cArgs    = 4;
     pReq->u.Internal.aArgs[0] = (uintptr_t)pThis;
     pReq->u.Internal.aArgs[1] = (uintptr_t)pu8Buf;
     pReq->u.Internal.aArgs[2] = (uintptr_t)cb;
+    pReq->u.Internal.aArgs[3] = (uintptr_t)pvArg;
+    pReq->fFlags              = RTREQFLAGS_VOID|RTREQFLAGS_NO_WAIT;
+    rc = RTReqQueue(pReq, 0);
+    AssertReleaseRC(rc);
+    drvNATUrgRecvWakeup(pThis->pDrvIns, pThis->pUrgRecvThread);
+}
+
+/**
+ * Function called by slirp to feed incoming data to the network port.
+ */
+void slirp_output(void *pvUser, void *pvArg, const uint8_t *pu8Buf, int cb)
+{
+    PDRVNAT pThis = (PDRVNAT)pvUser;
+    Assert(pThis);
+
+    LogFlow(("slirp_output BEGIN %x %d\n", pu8Buf, cb));
+    Log2(("slirp_output: pu8Buf=%p cb=%#x (pThis=%p)\n%.*Rhxd\n", pu8Buf, cb, pThis, cb, pu8Buf));
+
+    PRTREQ pReq = NULL;
+
+    /* don't queue new requests when the NAT thread is about to stop */
+    if (pThis->pSlirpThread->enmState != PDMTHREADSTATE_RUNNING)
+        return;
+
+    int rc = RTReqAlloc(pThis->pRecvReqQueue, &pReq, RTREQTYPE_INTERNAL);
+    AssertReleaseRC(rc);
+    ASMAtomicIncU32(&pThis->cPkt);
+    pReq->u.Internal.pfn      = (PFNRT)drvNATRecvWorker;
+    pReq->u.Internal.cArgs    = 4;
+    pReq->u.Internal.aArgs[0] = (uintptr_t)pThis;
+    pReq->u.Internal.aArgs[1] = (uintptr_t)pu8Buf;
+    pReq->u.Internal.aArgs[2] = (uintptr_t)cb;
+    pReq->u.Internal.aArgs[3] = (uintptr_t)pvArg;
     pReq->fFlags              = RTREQFLAGS_VOID|RTREQFLAGS_NO_WAIT;
     rc = RTReqQueue(pReq, 0);
@@ -951 +1121 @@
                 return rc;
             }
+            rc = RTReqCreateQueue(&pThis->pUrgRecvReqQueue);
+            if (RT_FAILURE(rc))
+            {
+                LogRel(("NAT: Can't create request queue\n"));
+                return rc;
+            }
             rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pRecvThread, pThis, drvNATRecv,
                                           drvNATRecvWakeup, 128 * _1K, RTTHREADTYPE_IO, "NATRX");
             AssertReleaseRC(rc);
             rc = RTSemEventCreate(&pThis->EventRecv);
+
+            rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pUrgRecvThread, pThis, drvNATUrgRecv,
+                                          drvNATUrgRecvWakeup, 128 * _1K, RTTHREADTYPE_IO, "NATURGRX");
+            AssertReleaseRC(rc);
+            rc = RTSemEventCreate(&pThis->EventRecv);
+            rc = RTSemEventCreate(&pThis->EventUrgRecv);
+            rc = RTCritSectInit(&pThis->csDevAccess);
+            rc = PDMDrvHlpTMTimerCreate(pThis->pDrvIns, TMCLOCK_REAL/*enmClock*/, drvNATSlowTimer, 
+                    pThis, TMTIMER_FLAGS_NO_CRIT_SECT/*flags*/, "NATSlowTmr", &pThis->pTmrSlow);
+            rc = PDMDrvHlpTMTimerCreate(pThis->pDrvIns, TMCLOCK_REAL/*enmClock*/, drvNATFastTimer, 
+                    pThis, TMTIMER_FLAGS_NO_CRIT_SECT/*flags*/, "NATFastTmr", &pThis->pTmrFast);
 
 #ifndef RT_OS_WINDOWS

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

@@ -104 +104 @@
 COUNTING_COUNTER(IOSBAppendSB_w_ge_r, "SB: AppendSB (sb_wptr >= sb_rptr)");
 COUNTING_COUNTER(IOSBAppendSB_w_alter, "SB: AppendSB (altering of sb_wptr)");
+COUNTING_COUNTER(MBufAllocation,"MBUF::shows number of mbufs in used list");
 
 COUNTING_COUNTER(TCP_retransmit, "TCP::retransmit");

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

@@ -280 +280 @@
         }
 
-        if_encap(pData, ETH_P_IP, ifm);
+        if_encap(pData, ETH_P_IP, ifm, 0);
 
         if (!if_queued)

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

@@ -515 +515 @@
 #endif
 
-    if (type!=ICMP_UNREACH && type!=ICMP_TIMXCEED)
+    if (type!=ICMP_UNREACH && type!=ICMP_TIMXCEED && type != ICMP_SOURCEQUENCH)
         goto end_error;
 
@@ -531 +531 @@
     }
 #endif
-    if (ip->ip_off & IP_OFFMASK)
+    if (ip->ip_off & IP_OFFMASK && type != ICMP_SOURCEQUENCH)
         goto end_error;    /* Only reply to fragment 0 */
 
@@ -657 +657 @@
     ip->ip_src = alias_addr;
 
-    (void ) ip_output(pData, (struct socket *)NULL, m);
+    (void ) ip_output0(pData, (struct socket *)NULL, m, 1);
 
     icmpstat.icps_reflect++;

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

@@ -81 +81 @@
 ip_output(PNATState pData, struct socket *so, struct mbuf *m0)
 {
+    return ip_output0(pData, so, m0, 0);
+}
+
+int
+ip_output0(PNATState pData, struct socket *so, struct mbuf *m0, int urg)
+{
     register struct ip *ip;
     register struct mbuf *m = m0;
@@ -200 +206 @@
         memcpy(eh->h_source, eth_dst, ETH_ALEN);
 
+#ifdef VBOX_WITH_SLIRP_BSD_MBUF
         if_output(pData, so, m);
+#else
+        if_encap(pData, ETH_P_IP, m, urg? ETH_ENCAP_URG : 0);
+#endif
         goto done;
      }
@@ -381 +391 @@
                 memcpy(eh->h_source, eth_dst, ETH_ALEN);
 
+#ifdef VBOX_WITH_SLIRP_BSD_MBUF
                 if_output(pData, so, m);
+#else
+                if_encap(pData, ETH_P_IP, m, 0);
+#endif
             }
             else

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

@@ -48 +48 @@
 #endif /* !RT_OS_WINDOWS */
 
+#ifdef VBOX_WITH_SLIRP_BSD_MBUF
 void slirp_input(PNATState pData, const uint8_t *pkt, int pkt_len);
+#else
+void slirp_input(PNATState pData, void *pvData);
+#endif
 void slirp_set_ethaddr(PNATState pData, const uint8_t *ethaddr);
 
 /* you must provide the following functions: */
+void slirp_arm_fast_timer(void *pvUser);
+void slirp_arm_slow_timer(void *pvUser);
 int slirp_can_output(void * pvUser);
 void slirp_output(void * pvUser, void *pvArg, const uint8_t *pkt, int pkt_len);
+void slirp_urg_output(void *pvUser, void *pvArg, const uint8_t *pu8Buf, int cb);
 void slirp_post_sent(PNATState pData, void *pvArg);
 
@@ -111 +118 @@
 void *slirp_get_queue(PNATState pData);
 #endif
+#ifndef VBOX_WITH_SLIRP_BSD_MBUF
+void *slirp_ext_m_get(PNATState pData);
+void slirp_ext_m_free(PNATState pData, void *);
+void slirp_ext_m_append(PNATState pData, void *, uint8_t *, size_t);
+void slirp_push_recv_thread(void *pvUser);
+#endif
 
 /*

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

@@ -9 +9 @@
 #include <sys/select.h>
 #endif
-
-void if_encap(PNATState pData, uint16_t eth_proto, struct mbuf *m);
+#define ETH_ENCAP_URG 1
+void if_encap(PNATState pData, uint16_t eth_proto, struct mbuf *m, int flags);

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

@@ -15 +15 @@
  * the flags
  */
-
 #include <slirp.h>
 
+#define MBUF_ZONE_SIZE 100
+static int mbuf_zone_init(PNATState pData)
+{
+    int limit;
+    struct mbuf_zone *mzone;
+    int i;
+    struct mbuf *m;
+    uint8_t *zone = RTMemAlloc(msize * MBUF_ZONE_SIZE);  
+    if (zone == NULL)
+    {
+        LogRel(("NAT: can't allocate new zone\n"));
+        return -1;
+    }
+    mzone = RTMemAllocZ(sizeof (struct mbuf_zone));
+    if (mzone == NULL)
+    {
+        RTMemFree(zone);
+        LogRel(("NAT: can't allocate zone descriptor\n"));
+        return -1;
+    }
+
+    for(i = 0; i < MBUF_ZONE_SIZE; ++i)
+    {
+        m = (struct mbuf *)((char *)zone + i*msize);
+#ifdef M_BUF_DEBUG
+        m->m_hdr.mh_id = pData->mbuf_zone_count * MBUF_ZONE_SIZE + i;
+#endif
+        insque(pData, m, &m_freelist);
+    }
+    mzone->mbuf_zone_base_addr = zone;
+    LIST_INSERT_HEAD(&pData->mbuf_zone_head, mzone, list);
+    pData->mbuf_zone_count++;
+    pData->mbuf_water_line_limit = pData->mbuf_zone_count * MBUF_ZONE_SIZE;
+    return 0;
+} 
+
+void m_fini(PNATState pData)
+{
+    struct mbuf_zone *mz;
+    struct mbuf *m;
+    int i;
+    void *zone;
+    while(!LIST_EMPTY(&pData->mbuf_zone_head))
+    {
+        mz = LIST_FIRST(&pData->mbuf_zone_head);
+        zone = mz->mbuf_zone_base_addr;
+        for(i = 0; i < MBUF_ZONE_SIZE; ++i)
+        {
+            m = (struct mbuf *)((char *)zone + i*msize);
+            if (   (m->m_flags & M_EXT) 
+                && m->m_ext != NULL)
+                RTMemFree(m->m_ext);
+        }
+        RTMemFree(zone);
+        LIST_REMOVE(mz, list);
+        RTMemFree(mz);
+    }
+}
 
 void
 m_init(PNATState pData)
 {
+    int i;
+    struct mbuf *m;
+    int rc = 0;
     m_freelist.m_next = m_freelist.m_prev = &m_freelist;
     m_usedlist.m_next = m_usedlist.m_prev = &m_usedlist;
     mbuf_alloced = 0;
     msize_init(pData);
+#if 1
+    rc = RTCritSectInit(&pData->cs_mbuf_zone);
+    AssertReleaseRC(rc);
+    rc = mbuf_zone_init(pData);
+    Assert((rc == 0));
+#endif
 }
 
@@ -38 +104 @@
           + if_maxlinkhdr ;
 }
-
+#ifdef m_get
+# undef m_get
+#endif
+
+#ifdef m_free
+# undef m_free
+#endif
 /*
  * Get an mbuf from the free list, if there are none
@@ -52 +124 @@
     register struct mbuf *m;
     int flags = 0;
+    int rc = 0;
 
     DEBUG_CALL("m_get");
-
+    
+    rc = RTCritSectEnter(&pData->cs_mbuf_zone);
+    AssertReleaseRC(rc);
+
+recheck_zone:
     if (m_freelist.m_next == &m_freelist)
     {
+#if 1
+        int rc = mbuf_zone_init(pData);
+        if (rc == 0)
+            goto recheck_zone;
+        AssertMsgFailed(("No mbufs on free list\n"));
+        return NULL;
+#else
         m = (struct mbuf *)RTMemAlloc(msize);
         if (m == NULL)
@@ -65 +149 @@
         if (mbuf_alloced > mbuf_max)
             mbuf_max = mbuf_alloced;
+#endif
     }
     else
@@ -72 +157 @@
     }
 
+    STAM_COUNTER_INC(&pData->StatMBufAllocation);
     /* Insert it in the used list */
+    mbuf_alloced++;
+    if (mbuf_alloced >= MBUF_ZONE_SIZE/2)
+    {
+        pData->fmbuf_water_line = 1;
+    }
     insque(pData, m, &m_usedlist);
     m->m_flags = (flags | M_USEDLIST);
@@ -87 +178 @@
 end_error:
     DEBUG_ARG("m = %lx", (long )m);
+    rc = RTCritSectLeave(&pData->cs_mbuf_zone);
+    AssertReleaseRC(rc);
     return m;
 }
@@ -93 +186 @@
 m_free(PNATState pData, struct mbuf *m)
 {
-
+    int rc;
     DEBUG_CALL("m_free");
     DEBUG_ARG("m = %lx", (long )m);
 
+    rc = RTCritSectEnter(&pData->cs_mbuf_zone);
+    AssertReleaseRC(rc);
+    mbuf_alloced--;
     if(m)
     {
@@ -112 +208 @@
         if (m->m_flags & M_DOFREE)
         {
+#if 1
+            if ((m->m_flags & M_EXT) == 0)
+                memset(m->m_dat, 0, if_mtu);
+            insque(pData, m, &m_freelist);
+            m->m_flags = M_FREELIST; /* Clobber other flags */
+#else
             RTMemFree(m);
+#endif
             mbuf_alloced--;
         }
@@ -120 +223 @@
             m->m_flags = M_FREELIST; /* Clobber other flags */
         }
+        STAM_COUNTER_INC(&pData->StatMBufAllocation);
     } /* if(m) */
-}
+    rc = RTCritSectLeave(&pData->cs_mbuf_zone);
+    AssertReleaseRC(rc);
+}
+
+/* update macros for m_get/m_free*/
+#undef m_get
+#undef m_free
+#include "mbuf.h"
 
 /*
@@ -254 +365 @@
     return (struct mbuf *)0;
 }
+#ifndef VBOX_WITH_SLIRP_BSD_MBUF
+void *slirp_ext_m_get(PNATState pData)
+{
+    return (void *)m_get(pData);
+}
+
+void slirp_ext_m_free(PNATState pData, void *arg)
+{
+    struct mbuf *m = (struct mbuf *)arg;
+    m_free(pData, m);
+}
+void slirp_ext_m_append(PNATState pData, void *arg, uint8_t *pu8Buf, size_t cbBuf)
+{
+    char *c;
+    struct mbuf *m = (struct mbuf *)arg;
+    if (cbBuf > M_FREEROOM(m))
+    {
+        m_inc(m, cbBuf);
+    } 
+    c = mtod(m, char *);
+    memcpy(c, pu8Buf, cbBuf);
+    m->m_len = cbBuf;
+}
+#endif

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

@@ -38 +38 @@
 #define _MBUF_H_
 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
+/* #define M_BUF_DEBUG */
 
 #define m_freem m_free
@@ -76 +77 @@
     int     mh_len;            /* Amount of data in this mbuf */
     struct libalias *mh_la;     /*Real freebsd store hocksin similar way*/
+#ifdef M_BUF_DEBUG
+    int mh_id;
+    char *mh_allocation_at_file;
+    int mh_allocation_at_line;
+#endif
 };
 
@@ -135 +141 @@
 
 void m_init (PNATState);
+void m_fini(PNATState pData);
 void msize_init (PNATState);
 struct mbuf * m_get (PNATState);
@@ -150 +157 @@
 
 #define MBUF_IP_HEADER(m) (caddr_t)(MBUF_HEAD(m) + if_maxlinkhdr)
-
 #else
 # include "bsd/sys/mbuf.h"
 #endif
 #endif
+
+#if defined(M_BUF_DEBUG) && !defined(RT_OS_WINDOWS)
+# define m_get(x)                                                                                               \
+({                                                                                                              \
+    struct mbuf *mdb = m_get((x));                                                                              \
+    if(mdb)                                                                                                     \
+    {                                                                                                           \
+        mdb->m_hdr.mh_allocation_at_file = __FILE__;                                                            \
+        mdb->m_hdr.mh_allocation_at_line = __LINE__;                                                            \
+    }                                                                                                           \
+    LogRel(("NAT:m(id:%d, ptr: %p) allocated at: %s:%d\n", (mdb?mdb->m_hdr.mh_id:-1), mdb, __FILE__, __LINE__));\
+    mdb;                                                                                                        \
+})
+
+# define m_free(x, m)                                                                               \
+({                                                                                                  \
+    (m)->m_hdr.mh_allocation_at_file = NULL;                                                        \
+    (m)->m_hdr.mh_allocation_at_line = 0;                                                           \
+    LogRel(("NAT:m(id:%d, ptr: %p) freed at: %s:%d\n", (m)->m_hdr.mh_id, (m), __FILE__, __LINE__)); \
+    m_free((x),(m));                                                                                \
+})
+#endif

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

@@ -697 +697 @@
     }
     bootp_dhcp_fini(pData);
+    m_fini(pData);
 #ifdef RT_OS_WINDOWS
     WSACleanup();
@@ -770 +771 @@
     if (!link_up)
         goto done;
+    
     /*
      * *_slowtimo needs calling if there are IP fragments
@@ -785 +787 @@
             {
                 do_slowtimo = 1;
+                slirp_arm_slow_timer(pData->pvUser);
                 break;
             }
@@ -799 +802 @@
         so->so_poll_index = -1;
 #endif
+        if (pData->fmbuf_water_line == 1)
+        {
+            if (mbuf_alloced < pData->mbuf_water_line_limit/2) 
+            {
+                pData->fmbuf_water_warn_sent = 0;
+                pData->fmbuf_water_line = 0;
+            }
+#ifndef RT_OS_WINDOWS
+            poll_index = 0;
+#endif
+            goto done;
+        }
         STAM_COUNTER_INC(&pData->StatTCP);
 
@@ -807 +822 @@
                 && so->so_tcpcb != NULL
                 && so->so_tcpcb->t_flags & TF_DELACK)
+        {
             time_fasttimo = curtime; /* Flag when we want a fasttimo */
+            slirp_arm_fast_timer(pData->pvUser);
+        }
 
         /*
@@ -867 +885 @@
     /* { */
 
+        if (pData->fmbuf_water_line == 1)
+        {
+            if (mbuf_alloced < pData->mbuf_water_line_limit/2) 
+            {
+                pData->fmbuf_water_line = 0;
+                pData->fmbuf_water_warn_sent = 0;
+            }
+#ifndef RT_OS_WINDOWS
+            poll_index = 0;
+#endif
+            goto done;
+        }
         STAM_COUNTER_INC(&pData->StatUDP);
 #if !defined(RT_OS_WINDOWS)
@@ -892 +922 @@
             }
             else
+            {
                 do_slowtimo = 1; /* Let socket expire */
+                slirp_arm_slow_timer(pData->pvUser);
+            }
         }
 
@@ -992 +1025 @@
     QSOCKET_FOREACH(so, so_next, tcp)
     /* { */
+        if (pData->fmbuf_water_line == 1)
+        {
+            if (mbuf_alloced < pData->mbuf_water_line_limit/2) 
+            {
+                pData->fmbuf_water_line = 0;
+                pData->fmbuf_water_warn_sent = 0;
+            }
+            goto done;
+        }
 
 #ifdef VBOX_WITH_SLIRP_MT
@@ -1280 +1322 @@
      QSOCKET_FOREACH(so, so_next, udp)
      /* { */
+        if (pData->fmbuf_water_line == 1)
+        {
+            if (mbuf_alloced < pData->mbuf_water_line_limit/2) 
+            {
+                pData->fmbuf_water_line = 0;
+                pData->fmbuf_water_warn_sent = 0;
+            }
+            goto done;
+        }
 #ifdef VBOX_WITH_SLIRP_MT
         if (   so->so_state & SS_NOFDREF
@@ -1322 +1373 @@
 
 done:
-#ifndef VBOX_WITH_SLIRP_MT
+#if 0
     /*
      * See if we can start outputting
@@ -1410 +1461 @@
                     }
                 }
+                m_free(pData, m);
+                m_free(pData, mr);
                 return;
         arp_ok:
@@ -1431 +1484 @@
                 memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
                 memcpy(rah->ar_tip, ah->ar_sip, 4);
-                if_encap(pData, ETH_P_ARP, mr);
+                if_encap(pData, ETH_P_ARP, mr, ETH_ENCAP_URG);
                 m_free(pData, m);
             }
@@ -1472 +1525 @@
 }
 
+#ifdef VBOX_WITH_SLIRP_BSD_MBUF
 void slirp_input(PNATState pData, const uint8_t *pkt, int pkt_len)
+#else
+void slirp_input(PNATState pData, void *pvArg)
+#endif
 {
     struct mbuf *m;
     int proto;
     static bool fWarnedIpv6;
+#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     struct ethhdr *eh = (struct ethhdr*)pkt;
-#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     int size = 0;
-#endif
-
+#else
+    struct ethhdr *eh;
+#endif
+
+#ifndef VBOX_WITH_SLIRP_BSD_MBUF
+    m = (struct mbuf *)pvArg;
+    if (m->m_len < ETH_HLEN)
+    {
+        LogRel(("NAT: packet having size %d has been ingnored\n", m->m_len));
+        m_free(pData, m);
+        return;
+    }
+    eh = mtod(m, struct ethhdr *); 
+    proto = ntohs(eh->h_proto);
+#else
     Log2(("NAT: slirp_input %d\n", pkt_len));
     if (pkt_len < ETH_HLEN)
@@ -1498 +1568 @@
     }
 
-#ifndef VBOX_WITH_SLIRP_BSD_MBUF
-    m = m_get(pData);
-#else
     if (pkt_len < MSIZE)
     {
@@ -1522 +1589 @@
     }
     m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
-#endif
     if (!m)
     {
@@ -1530 +1596 @@
     }
 
-    /* Note: we add to align the IP header */
-
-#ifndef VBOX_WITH_SLIRP_BSD_MBUF
-    if (M_FREEROOM(m) < pkt_len)
-       m_inc(m, pkt_len);
-#endif
-
     m->m_len = pkt_len ;
     memcpy(m->m_data, pkt, pkt_len);
+    proto = ntohs(*(uint16_t *)(pkt + 12));
+#endif
+    /* Note: we add to align the IP header */
+
 
     if (pData->port_forwarding_activated == 0)
         activate_port_forwarding(pData, mtod(m, struct ethhdr *));
 
-    proto = ntohs(*(uint16_t *)(pkt + 12));
     switch(proto)
     {
@@ -1558 +1620 @@
             m->m_pkthdr.header = mtod(m, void *);
 #endif
+#if 1
+            if (   pData->fmbuf_water_line 
+                && pData->fmbuf_water_warn_sent == 0
+                && (curtime - pData->tsmbuf_water_warn_sent) > 500)
+            {
+                icmp_error(pData, m, ICMP_SOURCEQUENCH, 0, 0, "Out of resources!!!"); 
+                pData->fmbuf_water_warn_sent = 1;
+                pData->tsmbuf_water_warn_sent = curtime;
+            }
+#endif
             ip_input(pData, m);
             break;
@@ -1573 +1645 @@
             break;
     }
+#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     RTMemFree((void *)pkt);
+#endif
 }
 
 /* output the IP packet to the ethernet device */
-void if_encap(PNATState pData, uint16_t eth_proto, struct mbuf *m)
+void if_encap(PNATState pData, uint16_t eth_proto, struct mbuf *m, int flags)
 {
     struct ethhdr *eh;
@@ -1616 +1690 @@
 #else
     mlen = m_length(m, NULL);
-#endif
     buf = RTMemAlloc(mlen);
     if (buf == NULL)
@@ -1623 +1696 @@
         goto done;
     }
+#endif
     eh->h_proto = htons(eth_proto);
-#ifndef VBOX_WITH_SLIRP_BSD_MBUF
-    memcpy(buf, mtod(m, uint8_t *), mlen);
+#ifdef VBOX_WITH_SLIRP_BSD_MBUF
+    m_copydata(m, 0, mlen, (char *)buf);
 #else
-    m_copydata(m, 0, mlen, (char *)buf);
-#endif
-    slirp_output(pData->pvUser, NULL, buf, mlen);
+    if (flags & ETH_ENCAP_URG)
+        slirp_urg_output(pData->pvUser, m, mtod(m, char *), mlen);
+    else
+        slirp_output(pData->pvUser, m, mtod(m, char *), mlen);
+#endif
 done:
     STAM_PROFILE_STOP(&pData->StatIF_encap, a);
+#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     m_free(pData, m);
+#endif
 }
 
@@ -2028 +2106 @@
     m->m_len = sizeof(struct arphdr) + ETH_HLEN;
 #endif
-    if_encap(pData, ETH_P_ARP, m);
+    if_encap(pData, ETH_P_ARP, m, ETH_ENCAP_URG);
     Log(("NAT: ARP request sent\n"));
 }

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

@@ -286 +286 @@
 /* ip_output.c */
 int ip_output (PNATState, struct socket *, struct mbuf *);
+int ip_output0 (PNATState, struct socket *, struct mbuf *, int urg);
 
 /* tcp_input.c */

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

@@ -23 +23 @@
 
 #include <iprt/req.h>
+#include <iprt/critsect.h>
 
 #define COUNTERS_INIT
@@ -93 +94 @@
 };
 LIST_HEAD(port_forward_rule_list, port_forward_rule);
+
+#ifndef VBOX_WITH_SLIRP_BSD_MBUF
+struct mbuf_zone
+{
+    LIST_ENTRY(mbuf_zone) list;
+    uint8_t *mbuf_zone_base_addr;
+};
+LIST_HEAD(mbuf_zone_list, mbuf_zone);
+#endif
+
 
 /* forward declaration */
@@ -133 +144 @@
     int msize;
     struct mbuf m_freelist, m_usedlist;
+#ifndef VBOX_WITH_SLIRP_BSD_MBUF
+    struct mbuf_zone_list mbuf_zone_head;
+    RTCRITSECT cs_mbuf_zone;
+    int fmbuf_water_line;
+    int mbuf_water_line_limit;
+    int mbuf_zone_count;
+    int fmbuf_water_warn_sent; 
+    uint32_t tsmbuf_water_warn_sent;
+#endif
     /* Stuff from slirp.c */
     void *pvUser;

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

@@ -686 +686 @@
         }
 #endif
+        if (m != NULL)
+            m_free(pData, m);
         return (error);
     }