slirp: Prevent recursion of if_start

[qemu.git] / slirp / if.c

diff --git a/slirp/if.c b/slirp/if.c
index 1ef4bf963a7722ee35aadf425adc790dc4d0f0cc..f7aebe95572f5ec14b87750ee8de78e02b47f533 100644 (file)
--- a/slirp/if.c
+++ b/slirp/if.c
@@ -6,14 +6,7 @@
  */
 
 #include <slirp.h>
  */
 
 #include <slirp.h>

-
-int     if_queued = 0;                  /* Number of packets queued so far */
-
-struct  mbuf if_fastq;                  /* fast queue (for interactive data) */
-struct  mbuf if_batchq;                 /* queue for non-interactive data */
-struct mbuf *next_m;                   /* Pointer to next mbuf to output */
-
-#define ifs_init(ifm) ((ifm)->ifs_next = (ifm)->ifs_prev = (ifm))
+#include "qemu-timer.h"

 
 static void
 ifs_insque(struct mbuf *ifm, struct mbuf *ifmhead)
 
 static void
 ifs_insque(struct mbuf *ifm, struct mbuf *ifmhead)


@@ -32,11 +25,11 @@ ifs_remque(struct mbuf *ifm)
 }
 
 void
 }
 
 void

-if_init(void)
+if_init(Slirp *slirp)

 {
 {

-       if_fastq.ifq_next = if_fastq.ifq_prev = &if_fastq;
-       if_batchq.ifq_next = if_batchq.ifq_prev = &if_batchq;
-       next_m = &if_batchq;
+    slirp->if_fastq.ifq_next = slirp->if_fastq.ifq_prev = &slirp->if_fastq;
+    slirp->if_batchq.ifq_next = slirp->if_batchq.ifq_prev = &slirp->if_batchq;
+    slirp->next_m = &slirp->if_batchq;

 }
 
 /*
 }
 
 /*


@@ -55,6 +48,7 @@ if_init(void)
 void
 if_output(struct socket *so, struct mbuf *ifm)
 {
 void
 if_output(struct socket *so, struct mbuf *ifm)
 {

+       Slirp *slirp = ifm->slirp;

        struct mbuf *ifq;
        int on_fastq = 1;
 
        struct mbuf *ifq;
        int on_fastq = 1;
 


@@ -79,7 +73,8 @@ if_output(struct socket *so, struct mbuf *ifm)
         * We mustn't put this packet back on the fastq (or we'll send it out of order)
         * XXX add cache here?
         */
         * We mustn't put this packet back on the fastq (or we'll send it out of order)
         * XXX add cache here?
         */

-       for (ifq = if_batchq.ifq_prev; ifq != &if_batchq; ifq = ifq->ifq_prev) {
+       for (ifq = slirp->if_batchq.ifq_prev; ifq != &slirp->if_batchq;
+            ifq = ifq->ifq_prev) {

                if (so == ifq->ifq_so) {
                        /* A match! */
                        ifm->ifq_so = so;
                if (so == ifq->ifq_so) {
                        /* A match! */
                        ifm->ifq_so = so;


@@ -90,7 +85,7 @@ if_output(struct socket *so, struct mbuf *ifm)
 
        /* No match, check which queue to put it on */
        if (so && (so->so_iptos & IPTOS_LOWDELAY)) {
 
        /* No match, check which queue to put it on */
        if (so && (so->so_iptos & IPTOS_LOWDELAY)) {

-               ifq = if_fastq.ifq_prev;
+               ifq = slirp->if_fastq.ifq_prev;

                on_fastq = 1;
                /*
                 * Check if this packet is a part of the last
                on_fastq = 1;
                /*
                 * Check if this packet is a part of the last


@@ -101,8 +96,13 @@ if_output(struct socket *so, struct mbuf *ifm)
                        ifs_insque(ifm, ifq->ifs_prev);
                        goto diddit;
                }
                        ifs_insque(ifm, ifq->ifs_prev);
                        goto diddit;
                }

-       } else
-               ifq = if_batchq.ifq_prev;
+        } else {
+               ifq = slirp->if_batchq.ifq_prev;
+                /* Set next_m if the queue was empty so far */
+                if (slirp->next_m == &slirp->if_batchq) {
+                    slirp->next_m = ifm;
+                }
+        }

 
        /* Create a new doubly linked list for this session */
        ifm->ifq_so = so;
 
        /* Create a new doubly linked list for this session */
        ifm->ifq_so = so;


@@ -110,7 +110,7 @@ if_output(struct socket *so, struct mbuf *ifm)
        insque(ifm, ifq);
 
 diddit:
        insque(ifm, ifq);
 
 diddit:

-       ++if_queued;
+       slirp->if_queued++;

 
        if (so) {
                /* Update *_queued */
 
        if (so) {
                /* Update *_queued */


@@ -130,7 +130,7 @@ diddit:
                        remque(ifm->ifs_next);
 
                        /* ...And insert in the new.  That'll teach ya! */
                        remque(ifm->ifs_next);
 
                        /* ...And insert in the new.  That'll teach ya! */

-                       insque(ifm->ifs_next, &if_batchq);
+                       insque(ifm->ifs_next, &slirp->if_batchq);

                }
        }
 
                }
        }
 


@@ -138,10 +138,7 @@ diddit:
        /*
         * This prevents us from malloc()ing too many mbufs
         */
        /*
         * This prevents us from malloc()ing too many mbufs
         */

-       if (link_up) {
-               /* if_start will check towrite */
-               if_start();
-       }
+       if_start(ifm->slirp);

 #endif
 }
 
 #endif
 }
 


@@ -157,60 +154,80 @@ diddit:
  * from the second session, then one packet from the third, then back
  * to the first, etc. etc.
  */
  * from the second session, then one packet from the third, then back
  * to the first, etc. etc.
  */

-void
-if_start(void)
+void if_start(Slirp *slirp)

 {
 {

-       struct mbuf *ifm, *ifqt;
+    uint64_t now = qemu_get_clock_ns(rt_clock);
+    int requeued = 0;
+    bool from_batchq = false;
+    struct mbuf *ifm, *ifqt;

 
 

-       DEBUG_CALL("if_start");
+    DEBUG_CALL("if_start");

 
 

-       if (if_queued == 0)
-          return; /* Nothing to do */
+    if (slirp->if_start_busy) {
+        return;
+    }
+    slirp->if_start_busy = true;

 
 

- again:
+    while (slirp->if_queued) {

         /* check if we can really output */
         /* check if we can really output */

-        if (!slirp_can_output())
+        if (!slirp_can_output(slirp->opaque)) {
+            slirp->if_start_busy = false;

             return;
             return;

+        }
+
+        /*
+         * See which queue to get next packet from
+         * If there's something in the fastq, select it immediately
+         */
+        if (slirp->if_fastq.ifq_next != &slirp->if_fastq) {
+            ifm = slirp->if_fastq.ifq_next;
+        } else {
+            /* Nothing on fastq, pick up from batchq via next_m */
+            ifm = slirp->next_m;
+            from_batchq = true;
+        }
+
+        slirp->if_queued--;
+
+        /* Try to send packet unless it already expired */
+        if (ifm->expiration_date >= now && !if_encap(slirp, ifm)) {
+            /* Packet is delayed due to pending ARP resolution */
+            requeued++;
+            continue;
+        }
+
+        if (from_batchq) {
+            /* Set which packet to send on next iteration */
+            slirp->next_m = ifm->ifq_next;
+        }
+
+        /* Remove it from the queue */
+        ifqt = ifm->ifq_prev;
+        remque(ifm);
+
+        /* If there are more packets for this session, re-queue them */
+        if (ifm->ifs_next != ifm) {
+            insque(ifm->ifs_next, ifqt);
+            ifs_remque(ifm);
+            /* Set next_m if the session packet is now the only one on
+             * batchq */
+            if (ifqt == &slirp->if_batchq &&
+                slirp->next_m == &slirp->if_batchq) {
+                slirp->next_m = ifm->ifs_next;
+            }
+        }
+
+        /* Update so_queued */
+        if (ifm->ifq_so && --ifm->ifq_so->so_queued == 0) {
+            /* If there's no more queued, reset nqueued */
+            ifm->ifq_so->so_nqueued = 0;
+        }

 
 

-       /*
-        * See which queue to get next packet from
-        * If there's something in the fastq, select it immediately
-        */
-       if (if_fastq.ifq_next != &if_fastq) {
-               ifm = if_fastq.ifq_next;
-       } else {
-               /* Nothing on fastq, see if next_m is valid */
-               if (next_m != &if_batchq)
-                  ifm = next_m;
-               else
-                  ifm = if_batchq.ifq_next;
-
-               /* Set which packet to send on next iteration */
-               next_m = ifm->ifq_next;
-       }
-       /* Remove it from the queue */
-       ifqt = ifm->ifq_prev;
-       remque(ifm);
-       --if_queued;
-
-       /* If there are more packets for this session, re-queue them */
-       if (ifm->ifs_next != /* ifm->ifs_prev != */ ifm) {
-               insque(ifm->ifs_next, ifqt);
-               ifs_remque(ifm);
-       }
-
-       /* Update so_queued */
-       if (ifm->ifq_so) {
-               if (--ifm->ifq_so->so_queued == 0)
-                  /* If there's no more queued, reset nqueued */
-                  ifm->ifq_so->so_nqueued = 0;
-       }
+        m_free(ifm);

 
 

-       /* Encapsulate the packet for sending */
-        if_encap((uint8_t *)ifm->m_data, ifm->m_len);
+    }

 
 

-        m_free(ifm);
+    slirp->if_queued = requeued;

 
 

-       if (if_queued)
-          goto again;
+    slirp->if_start_busy = false;

 }
 }