Changeset 14275 in vbox

Timestamp:

Nov 18, 2008 3:44:28 AM (16 years ago)

Author:

vboxsync

Message:

TCP reassembling (compilable, but not working version)

Location:

trunk/src/VBox/Devices

Files:

• Makefile.kmk (modified) (1 diff)
• Network/slirp/slirp.h (modified) (1 diff)
• Network/slirp/slirp_state.h (modified) (2 diffs)
• Network/slirp/tcp_input.c (modified) (6 diffs)
• Network/slirp/tcp_subr.c (modified) (3 diffs)
• Network/slirp/tcp_var.h (modified) (4 diffs)

trunk/src/VBox/Devices/Makefile.kmk

@@ -537 +537 @@
 ifdef VBOX_WITH_BSD_REASS
 Drivers_DEFS       = VBOX_WITH_BSD_REASS
+endif
+ifdef VBOX_WITH_BSD_TCP_REASS
+Drivers_DEFS       = VBOX_WITH_BSD_TCP_REASS
 endif
 Drivers_INCS      := \

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

@@ -349 +349 @@
 
 /* tcp_input.c */
+#ifndef VBOX_WITH_BSD_TCP_REASS
 int tcp_reass _P((PNATState, register struct tcpcb *, register struct tcpiphdr *, struct mbuf *));
+#else /* !VBOX_WITH_BSD_TCP_REASS */
+int tcp_reass _P((PNATState, struct tcpcb *, struct tcphdr *, int *, struct mbuf *));
+#endif /* VBOX_WITH_BSD_TCP_REASS */
 void tcp_input _P((PNATState, register struct mbuf *, int, struct socket *));
 void tcp_dooptions _P((PNATState, struct tcpcb *, u_char *, int, struct tcpiphdr *));

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

@@ -116 +116 @@
     struct tcpstat_t tcpstat;
     uint32_t tcp_now;
+#ifdef VBOX_WITH_BSD_TCP_REASS
+    int tcp_reass_qsize;
+    int tcp_reass_maxqlen;
+    int tcp_reass_maxseg;
+    int tcp_reass_overflows;
+#endif /* VBOX_WITH_BSD_TCP_REASS */
     /* Stuff from tftp.c */
     struct tftp_session tftp_sessions[TFTP_SESSIONS_MAX];
@@ -237 +243 @@
 #endif /* VBOX_WITH_BSD_REASS */
 
+#ifdef VBOX_WITH_BSD_TCP_REASS
+#define tcp_reass_qsize pData->tcp_reass_qsize
+#define tcp_reass_maxqlen pData->tcp_reass_maxqlen
+#define tcp_reass_maxseg pData->tcp_reass_maxseg
+#define tcp_reass_overflows pData->tcp_reass_overflows
+#endif /* VBOX_WITH_BSD_TCP_REASS */
 
 #if SIZEOF_CHAR_P != 4

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

@@ -53 +53 @@
 #define TSTMP_GEQ(a,b)  ((int)((a)-(b)) >= 0)
 
+#ifndef VBOX_WITH_BSD_TCP_REASS
 /*
  * Insert segment ti into reassembly queue of tcp with
@@ -220 +221 @@
 }
 
+#else /* !VBOX_WITH_BSD_TCP_REASS */
+
+#ifndef TCP_ACK_HACK
+#define DELAY_ACK(tp, ti)                           \
+               if (ti->ti_flags & TH_PUSH)          \
+                       tp->t_flags |= TF_ACKNOW;    \
+               else                                 \
+                       tp->t_flags |= TF_DELACK;
+#else /* !TCP_ACK_HACK */
+#define DELAY_ACK(tp, ign)                          \
+                tp->t_flags |= TF_DELACK;
+#endif /* TCP_ACK_HACK */
+
+
+/*
+ * deps: netinet/tcp_reass.c
+ *          tcp_reass_maxqlen = 48 (deafault)
+ *          tcp_reass_maxseg  = nmbclusters/16 (nmbclusters = 1024 + maxusers * 64 from kern/kern_mbuf.c let's say 256)
+ */
+int
+tcp_reass(PNATState pData, struct tcpcb *tp, struct tcphdr *th, int *tlenp, struct mbuf *m)
+{
+        struct tseg_qent *q;
+        struct tseg_qent *p = NULL;
+        struct tseg_qent *nq;
+        struct tseg_qent *te = NULL;
+        struct socket *so = tp->t_socket;
+        int flags;
+
+        /*
+         * XXX: tcp_reass() is rather inefficient with its data structures
+         * and should be rewritten (see NetBSD for optimizations).  While
+         * doing that it should move to its own file tcp_reass.c.
+         */
+
+        /*
+         * Call with th==NULL after become established to
+         * force pre-ESTABLISHED data up to user socket.
+         */
+        if (th == NULL)
+                goto present;
+
+        /*
+         * Limit the number of segments in the reassembly queue to prevent
+         * holding on to too many segments (and thus running out of mbufs).
+         * Make sure to let the missing segment through which caused this
+         * queue.  Always keep one global queue entry spare to be able to
+         * process the missing segment.
+         */
+        if (th->th_seq != tp->rcv_nxt &&
+            (tcp_reass_qsize + 1 >= tcp_reass_maxseg ||
+             tp->t_segqlen >= tcp_reass_maxqlen)) {
+                tcp_reass_overflows++;
+                tcpstat.tcps_rcvmemdrop++;
+                m_freem(pData, m);
+                *tlenp = 0;
+                return (0);
+        }
+
+        /*
+         * Allocate a new queue entry. If we can't, or hit the zone limit
+         * just drop the pkt.
+         */
+        te = malloc(sizeof(struct tseg_qent));
+        if (te == NULL) {
+                tcpstat.tcps_rcvmemdrop++;
+                m_freem(pData, m);
+                *tlenp = 0;
+                return (0);
+        }
+        tp->t_segqlen++;
+        tcp_reass_qsize++;
+
+        /*
+         * Find a segment which begins after this one does.
+         */
+        LIST_FOREACH(q, &tp->t_segq, tqe_q) {
+                if (SEQ_GT(q->tqe_th->th_seq, th->th_seq))
+                        break;
+                p = q;
+        }
+
+        /*
+         * If there is a preceding segment, it may provide some of
+         * our data already.  If so, drop the data from the incoming
+         * segment.  If it provides all of our data, drop us.
+         */
+        if (p != NULL) {
+                int i;
+                /* conversion to int (in i) handles seq wraparound */
+                i = p->tqe_th->th_seq + p->tqe_len - th->th_seq;
+                if (i > 0) {
+                        if (i >= *tlenp) {
+                                tcpstat.tcps_rcvduppack++;
+                                tcpstat.tcps_rcvdupbyte += *tlenp;
+                                m_freem(pData, m);
+                                free(te);
+                                tp->t_segqlen--;
+                                tcp_reass_qsize--;
+                                /*
+                                 * Try to present any queued data
+                                 * at the left window edge to the user.
+                                 * This is needed after the 3-WHS
+                                 * completes.
+                                 */
+                                goto present;   /* ??? */
+                        }
+                        m_adj(m, i);
+                        *tlenp -= i;
+                        th->th_seq += i;
+                }
+        }
+        tcpstat.tcps_rcvoopack++;
+        tcpstat.tcps_rcvoobyte += *tlenp;
+
+        /*
+         * While we overlap succeeding segments trim them or,
+         * if they are completely covered, dequeue them.
+         */
+        while (q) {
+                int i = (th->th_seq + *tlenp) - q->tqe_th->th_seq;
+                if (i <= 0)
+                        break;
+                if (i < q->tqe_len) {
+                        q->tqe_th->th_seq += i;
+                        q->tqe_len -= i;
+                        m_adj(q->tqe_m, i);
+                        break;
+                }
+
+                nq = LIST_NEXT(q, tqe_q);
+                LIST_REMOVE(q, tqe_q);
+                m_freem(pData, q->tqe_m);
+                free(q);
+                tp->t_segqlen--;
+                tcp_reass_qsize--;
+                q = nq;
+        }
+
+        /* Insert the new segment queue entry into place. */
+        te->tqe_m = m;
+        te->tqe_th = th;
+        te->tqe_len = *tlenp;
+
+        if (p == NULL) {
+                LIST_INSERT_HEAD(&tp->t_segq, te, tqe_q);
+        } else {
+                LIST_INSERT_AFTER(p, te, tqe_q);
+        }
+
+present:
+        /*
+         * Present data to user, advancing rcv_nxt through
+         * completed sequence space.
+         */
+        if (!TCPS_HAVEESTABLISHED(tp->t_state))
+                return (0);
+        q = LIST_FIRST(&tp->t_segq);
+        if (!q || q->tqe_th->th_seq != tp->rcv_nxt)
+                return (0);
+        do {
+                tp->rcv_nxt += q->tqe_len;
+                flags = q->tqe_th->th_flags & TH_FIN;
+                nq = LIST_NEXT(q, tqe_q);
+                LIST_REMOVE(q, tqe_q);
+                /* XXX: This place should be checked for the same code in
+                 * original BSD code for Slirp and current BSD used SS_FCANTRCVMORE
+                 */
+                if (so->so_state & SS_FCANTSENDMORE)
+                        m_freem(pData, q->tqe_m);
+                else
+                        sbappend(pData, so, q->tqe_m);
+                free(q);
+                tp->t_segqlen--;
+                tcp_reass_qsize--;
+                q = nq;
+        } while (q && q->tqe_th->th_seq == tp->rcv_nxt);
+        return (flags);
+}
+#endif /* VBOX_WITH_BSD_TCP_REASS */
+
 /*
  * TCP input routine, follows pages 65-76 of the
@@ -545 +727 @@
                         }
                 } else if (ti->ti_ack == tp->snd_una &&
+#ifndef VBOX_WITH_BSD_TCP_REASS
                     u32_to_ptr(pData, tp->seg_next, struct tcpcb *) == tp &&
+#else /* !VBOX_WITH_BSD_TCP_REASS */
+                    LIST_NEXT(tp, t_list) == tp &&
+#endif /* VBOX_WITH_BSD_TCP_REASS */
                     ti->ti_len <= sbspace(&so->so_rcv)) {
                         /*
@@ -774 +960 @@
  *                      }
  */
+#ifndef VBOX_WITH_BSD_TCP_REASS
                         (void) tcp_reass(pData, tp, (struct tcpiphdr *)0,
                                 (struct mbuf *)0);
+#else /* !VBOX_WITH_BSD_TCP_REASS */
+                        (void) tcp_reass(pData, tp, (struct tcphdr *)0, NULL, (struct mbuf *)0);
+#endif /* VBOX_WITH_BSD_TCP_REASS */
                         /*
                          * if we didn't have to retransmit the SYN,
@@ -1044 +1234 @@
  *              }
  */
+#ifndef VBOX_WITH_BSD_TCP_REASS
                 (void) tcp_reass(pData, tp, (struct tcpiphdr *)0, (struct mbuf *)0);
+#else /* !VBOX_WITH_BSD_TCP_REASS */
+                (void) tcp_reass(pData, tp, (struct tcpiphdr *)0, (int *)0, (struct mbuf *)0);
+#endif /*VBOX_WITH_BSD_TCP_REASS*/
                 tp->snd_wl1 = ti->ti_seq - 1;
                 /* Avoid ack processing; snd_una==ti_ack  =>  dup ack */
@@ -1346 +1540 @@
         if ((ti->ti_len || (tiflags&TH_FIN)) &&
             TCPS_HAVERCVDFIN(tp->t_state) == 0) {
+#ifndef VBOX_WITH_BSD_TCP_REASS
                 TCP_REASS(pData, tp, ti, m, so, tiflags);
+#else /* !VBOX_WITH_BSD_TCP_REASS */
+                DELAY_ACK(tp, ti); /* little bit different from BSD declaration see netinet/tcp_input.c */
+                tp->rcv_nxt += tlen;
+                tiflags = ti->ti_t.th_flags & TH_FIN;
+                tcpstat.tcps_rcvpack++;
+                tcpstat.tcps_rcvbyte += tlen;
+                if (so->so_state & SS_FCANTRCVMORE)
+                        m_freem(pData, m);
+                else
+                        sbappend(pData, so, m);
+                /* NB: sorwakeup_locked() does an implicit unlock. */
+                sorwakeup(so);
+#endif /* VBOX_WITH_BSD_TCP_REASS */
                 /*
                  * Note the amount of data that peer has sent into

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

@@ -189 +189 @@
 
         memset((char *) tp, 0, sizeof(struct tcpcb));
+#ifndef VBOX_WITH_BSD_TCP_REASS
         tp->seg_next = tp->seg_prev = ptr_to_u32(pData, (struct tcpiphdr *)tp);
+#else /* !VBOX_WITH_BSD_TCP_REASS */
+        /*XXX: inject initialization here*/
+#endif /* VBOX_WITH_BSD_TCP_REASS */
         tp->t_maxseg = tcp_mssdflt;
 
@@ -263 +267 @@
         DEBUG_ARG("tp = %lx", (long )tp);
 
+#ifndef VBOX_WITH_BSD_TCP_REASS
         /* free the reassembly queue, if any */
         t = u32_to_ptr(pData, tp->seg_next, struct tcpiphdr *);
@@ -271 +276 @@
                 m_freem(pData, m);
         }
+#else /* !VBOX_WITH_BSD_TCP_REASS */
+        /*XXX: freeing the reassembly queue */
+#endif /* VBOX_WITH_BSD_TCP_REASS */
         /* It's static */
 /*      if (tp->t_template)

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

@@ -38 +38 @@
 #define _TCP_VAR_H_
 
+#ifdef VBOX_WITH_BSD_TCP_REASS
+#include <sys/queue.h>
+#endif /* VBOX_WITH_BSD_TCP_REASS */
+
 #include "tcpip.h"
 #include "tcp_timer.h"
@@ -57 +61 @@
 #endif
 
+#ifdef VBOX_WITH_BSD_TCP_REASS
+/* TCP segment queue entry */
+struct tseg_qent {
+        LIST_ENTRY(tseg_qent) tqe_q;
+        int     tqe_len;                /* TCP segment data length */
+        struct  tcphdr *tqe_th;         /* a pointer to tcp header */
+        struct  mbuf    *tqe_m;         /* mbuf contains packet */
+};
+LIST_HEAD(tsegqe_head, tseg_qent);
+#endif
+
 /*
  * Tcp control block, one per tcp; fields:
  */
 struct tcpcb {
+#ifndef VBOX_WITH_BSD_TCP_REASS
         tcpiphdrp_32 seg_next;  /* sequencing queue */
         tcpiphdrp_32 seg_prev;
+#else /* !VBOX_WITH_BSD_TCP_REASS */
+        LIST_ENTRY(tcpcb) t_list;
+        struct  tsegqe_head t_segq;     /* segment reassembly queue */
+        int     t_segqlen;              /* segment reassembly queue length */
+#endif /* VBOX_WITH_BSD_TCP_REASS */
         short   t_state;                /* state of this connection */
         short   t_timer[TCPT_NTIMERS];  /* tcp timers */
@@ -148 +169 @@
 
 };
+
+#ifdef VBOX_WITH_BSD_TCP_REASS
+LIST_HEAD(tcpcbhead, tcpcb);
+#endif /*VBOX_WITH_BSD_TCP_REASS*/
 
 #define sototcpcb(so)   ((so)->so_tcpcb)
@@ -261 +286 @@
         u_long  tcps_socachemiss;       /* tcp_last_so misses */
         u_long  tcps_didnuttin;         /* Times tcp_output didn't do anything XXX */
+#ifdef VBOX_WITH_BSD_TCP_REASS
+        u_long tcps_rcvmemdrop;
+#endif /* VBOX_WITH_BSD_TCP_REASS */
 };