rng-egd: remove redundant free

[qemu.git] / slirp / mbuf.c

diff --git a/slirp/mbuf.c b/slirp/mbuf.c
index bcf71bc61691f18eb0834a2d12bcea2b747b254f..4fefb043bf882979ff2396e5bc1b4f5bbeb20aa4 100644 (file)
--- a/slirp/mbuf.c
+++ b/slirp/mbuf.c
@@ -17,31 +17,40 @@
 
 #include <slirp.h>
 
-struct mbuf *mbutl;
-char   *mclrefcnt;
-int mbuf_alloced = 0;
-struct mbuf m_freelist, m_usedlist;
-int mbuf_thresh = 30;
-int mbuf_max = 0;
-int msize;
+#define MBUF_THRESH 30
+
+/*
+ * Find a nice value for msize
+ * XXX if_maxlinkhdr already in mtu
+ */
+#define SLIRP_MSIZE (IF_MTU + IF_MAXLINKHDR + offsetof(struct mbuf, m_dat) + 6)
 
 void
-m_init()
+m_init(Slirp *slirp)
 {
-       m_freelist.m_next = m_freelist.m_prev = &m_freelist;
-       m_usedlist.m_next = m_usedlist.m_prev = &m_usedlist;
-       msize_init();
+    slirp->m_freelist.m_next = slirp->m_freelist.m_prev = &slirp->m_freelist;
+    slirp->m_usedlist.m_next = slirp->m_usedlist.m_prev = &slirp->m_usedlist;
 }
 
-void
-msize_init()
+void m_cleanup(Slirp *slirp)
 {
-       /*
-        * Find a nice value for msize
-        * XXX if_maxlinkhdr already in mtu
-        */
-       msize = (if_mtu>if_mru?if_mtu:if_mru) +
-                       if_maxlinkhdr + sizeof(struct m_hdr ) + 6;
+    struct mbuf *m, *next;
+
+    m = slirp->m_usedlist.m_next;
+    while (m != &slirp->m_usedlist) {
+        next = m->m_next;
+        if (m->m_flags & M_EXT) {
+            free(m->m_ext);
+        }
+        free(m);
+        m = next;
+    }
+    m = slirp->m_freelist.m_next;
+    while (m != &slirp->m_freelist) {
+        next = m->m_next;
+        free(m);
+        m = next;
+    }
 }
 
 /*
@@ -53,44 +62,44 @@ msize_init()
  * which tells m_free to actually free() it
  */
 struct mbuf *
-m_get()
+m_get(Slirp *slirp)
 {
        register struct mbuf *m;
        int flags = 0;
 
        DEBUG_CALL("m_get");
 
-       if (m_freelist.m_next == &m_freelist) {
-               m = (struct mbuf *)malloc(msize);
+       if (slirp->m_freelist.m_next == &slirp->m_freelist) {
+               m = (struct mbuf *)malloc(SLIRP_MSIZE);
                if (m == NULL) goto end_error;
-               mbuf_alloced++;
-               if (mbuf_alloced > mbuf_thresh)
+               slirp->mbuf_alloced++;
+               if (slirp->mbuf_alloced > MBUF_THRESH)
                        flags = M_DOFREE;
-               if (mbuf_alloced > mbuf_max)
-                       mbuf_max = mbuf_alloced;
+               m->slirp = slirp;
        } else {
-               m = m_freelist.m_next;
+               m = slirp->m_freelist.m_next;
                remque(m);
        }
 
        /* Insert it in the used list */
-       insque(m,&m_usedlist);
+       insque(m,&slirp->m_usedlist);
        m->m_flags = (flags | M_USEDLIST);
 
        /* Initialise it */
-       m->m_size = msize - sizeof(struct m_hdr);
+       m->m_size = SLIRP_MSIZE - offsetof(struct mbuf, m_dat);
        m->m_data = m->m_dat;
        m->m_len = 0;
-       m->m_nextpkt = 0;
-       m->m_prevpkt = 0;
+        m->m_nextpkt = NULL;
+        m->m_prevpkt = NULL;
+        m->arp_requested = false;
+        m->expiration_date = (uint64_t)-1;
 end_error:
        DEBUG_ARG("m = %lx", (long )m);
        return m;
 }
 
 void
-m_free(m)
-       struct mbuf *m;
+m_free(struct mbuf *m)
 {
 
   DEBUG_CALL("m_free");
@@ -109,10 +118,10 @@ m_free(m)
         * Either free() it or put it on the free list
         */
        if (m->m_flags & M_DOFREE) {
+               m->slirp->mbuf_alloced--;
                free(m);
-               mbuf_alloced--;
        } else if ((m->m_flags & M_FREELIST) == 0) {
-               insque(m,&m_freelist);
+               insque(m,&m->slirp->m_freelist);
                m->m_flags = M_FREELIST; /* Clobber other flags */
        }
   } /* if(m) */
@@ -124,8 +133,7 @@ m_free(m)
  * an M_EXT data segment
  */
 void
-m_cat(m, n)
-       register struct mbuf *m, *n;
+m_cat(struct mbuf *m, struct mbuf *n)
 {
        /*
         * If there's no room, realloc
@@ -142,9 +150,7 @@ m_cat(m, n)
 
 /* make m size bytes large */
 void
-m_inc(m, size)
-        struct mbuf *m;
-        int size;
+m_inc(struct mbuf *m, int size)
 {
        int datasize;
 
@@ -154,19 +160,13 @@ m_inc(m, size)
         if (m->m_flags & M_EXT) {
          datasize = m->m_data - m->m_ext;
          m->m_ext = (char *)realloc(m->m_ext,size);
-/*             if (m->m_ext == NULL)
- *                     return (struct mbuf *)NULL;
- */    
          m->m_data = m->m_ext + datasize;
         } else {
          char *dat;
          datasize = m->m_data - m->m_dat;
          dat = (char *)malloc(size);
-/*             if (dat == NULL)
- *                     return (struct mbuf *)NULL;
- */
          memcpy(dat, m->m_dat, m->m_size);
-        
+
          m->m_ext = dat;
          m->m_data = m->m_ext + datasize;
          m->m_flags |= M_EXT;
@@ -179,9 +179,7 @@ m_inc(m, size)
 
 
 void
-m_adj(m, len)
-       struct mbuf *m;
-       int len;
+m_adj(struct mbuf *m, int len)
 {
        if (m == NULL)
                return;
@@ -201,9 +199,7 @@ m_adj(m, len)
  * Copy len bytes from m, starting off bytes into n
  */
 int
-m_copy(n, m, off, len)
-       struct mbuf *n, *m;
-       int off, len;
+m_copy(struct mbuf *n, struct mbuf *m, int off, int len)
 {
        if (len > M_FREEROOM(n))
                return -1;
@@ -220,8 +216,7 @@ m_copy(n, m, off, len)
  * Fortunately, it's not used often
  */
 struct mbuf *
-dtom(dat)
-       void *dat;
+dtom(Slirp *slirp, void *dat)
 {
        struct mbuf *m;
 
@@ -229,7 +224,8 @@ dtom(dat)
        DEBUG_ARG("dat = %lx", (long )dat);
 
        /* bug corrected for M_EXT buffers */
-       for (m = m_usedlist.m_next; m != &m_usedlist; m = m->m_next) {
+       for (m = slirp->m_usedlist.m_next; m != &slirp->m_usedlist;
+            m = m->m_next) {
          if (m->m_flags & M_EXT) {
            if( (char *)dat>=m->m_ext && (char *)dat<(m->m_ext + m->m_size) )
              return m;
@@ -243,4 +239,3 @@ dtom(dat)
 
        return (struct mbuf *)0;
 }
-