Diff for /qemu/slirp/tcp_timer.c between versions 1.1.1.1 and 1.1.1.4

version 1.1.1.1, 2018/04/24 16:37:52 version 1.1.1.4, 2018/04/24 17:25:33
Line 10 Line 10
  * 2. Redistributions in binary form must reproduce the above copyright   * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the   *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.   *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software   * 3. Neither the name of the University nor the names of its contributors
  *    must display the following acknowledgement:  
  *      This product includes software developed by the University of  
  *      California, Berkeley and its contributors.  
  * 4. Neither the name of the University nor the names of its contributors  
  *    may be used to endorse or promote products derived from this software   *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.   *    without specific prior written permission.
  *   *
Line 36 Line 32
   
 #include <slirp.h>  #include <slirp.h>
   
 int     tcp_keepidle = TCPTV_KEEP_IDLE;  static struct tcpcb *tcp_timers(register struct tcpcb *tp, int timer);
 int     tcp_keepintvl = TCPTV_KEEPINTVL;  
 int     tcp_maxidle;  
 int     so_options = DO_KEEPALIVE;  
   
 struct   tcpstat tcpstat;        /* tcp statistics */  
 u_int32_t        tcp_now;                /* for RFC 1323 timestamps */  
   
 /*  /*
  * Fast timeout routine for processing delayed acks   * Fast timeout routine for processing delayed acks
  */   */
 void  void
 tcp_fasttimo()  tcp_fasttimo(Slirp *slirp)
 {  {
         register struct socket *so;          register struct socket *so;
         register struct tcpcb *tp;          register struct tcpcb *tp;
   
         DEBUG_CALL("tcp_fasttimo");          DEBUG_CALL("tcp_fasttimo");
           
         so = tcb.so_next;          so = slirp->tcb.so_next;
         if (so)          if (so)
         for (; so != &tcb; so = so->so_next)          for (; so != &slirp->tcb; so = so->so_next)
                 if ((tp = (struct tcpcb *)so->so_tcpcb) &&                  if ((tp = (struct tcpcb *)so->so_tcpcb) &&
                     (tp->t_flags & TF_DELACK)) {                      (tp->t_flags & TF_DELACK)) {
                         tp->t_flags &= ~TF_DELACK;                          tp->t_flags &= ~TF_DELACK;
                         tp->t_flags |= TF_ACKNOW;                          tp->t_flags |= TF_ACKNOW;
                         tcpstat.tcps_delack++;  
                         (void) tcp_output(tp);                          (void) tcp_output(tp);
                 }                  }
 }  }
Line 73  tcp_fasttimo() Line 62  tcp_fasttimo()
  * causes finite state machine actions if timers expire.   * causes finite state machine actions if timers expire.
  */   */
 void  void
 tcp_slowtimo()  tcp_slowtimo(Slirp *slirp)
 {  {
         register struct socket *ip, *ipnxt;          register struct socket *ip, *ipnxt;
         register struct tcpcb *tp;          register struct tcpcb *tp;
         register int i;          register int i;
   
         DEBUG_CALL("tcp_slowtimo");          DEBUG_CALL("tcp_slowtimo");
           
         tcp_maxidle = TCPTV_KEEPCNT * tcp_keepintvl;  
         /*          /*
          * Search through tcb's and update active timers.           * Search through tcb's and update active timers.
          */           */
         ip = tcb.so_next;          ip = slirp->tcb.so_next;
         if (ip == 0)          if (ip == NULL) {
            return;              return;
         for (; ip != &tcb; ip = ipnxt) {          }
           for (; ip != &slirp->tcb; ip = ipnxt) {
                 ipnxt = ip->so_next;                  ipnxt = ip->so_next;
                 tp = sototcpcb(ip);                  tp = sototcpcb(ip);
                 if (tp == 0)                  if (tp == NULL) {
                         continue;                          continue;
                   }
                 for (i = 0; i < TCPT_NTIMERS; i++) {                  for (i = 0; i < TCPT_NTIMERS; i++) {
                         if (tp->t_timer[i] && --tp->t_timer[i] == 0) {                          if (tp->t_timer[i] && --tp->t_timer[i] == 0) {
                                 tcp_timers(tp,i);                                  tcp_timers(tp,i);
Line 106  tcp_slowtimo() Line 96  tcp_slowtimo()
 tpgone:  tpgone:
                 ;                  ;
         }          }
         tcp_iss += TCP_ISSINCR/PR_SLOWHZ;               /* increment iss */          slirp->tcp_iss += TCP_ISSINCR/PR_SLOWHZ;        /* increment iss */
 #ifdef TCP_COMPAT_42          slirp->tcp_now++;                               /* for timestamps */
         if ((int)tcp_iss < 0)  
                 tcp_iss = 0;                            /* XXX */  
 #endif  
         tcp_now++;                                      /* for timestamps */  
 }  }
   
 /*  /*
  * Cancel all timers for TCP tp.   * Cancel all timers for TCP tp.
  */   */
 void  void
 tcp_canceltimers(tp)  tcp_canceltimers(struct tcpcb *tp)
         struct tcpcb *tp;  
 {  {
         register int i;          register int i;
   
Line 127  tcp_canceltimers(tp) Line 112  tcp_canceltimers(tp)
                 tp->t_timer[i] = 0;                  tp->t_timer[i] = 0;
 }  }
   
 int     tcp_backoff[TCP_MAXRXTSHIFT + 1] =  const int tcp_backoff[TCP_MAXRXTSHIFT + 1] =
    { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };     { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };
   
 /*  /*
  * TCP timer processing.   * TCP timer processing.
  */   */
 struct tcpcb *  static struct tcpcb *
 tcp_timers(tp, timer)  tcp_timers(register struct tcpcb *tp, int timer)
         register struct tcpcb *tp;  
         int timer;  
 {  {
         register int rexmt;          register int rexmt;
           
         DEBUG_CALL("tcp_timers");          DEBUG_CALL("tcp_timers");
           
         switch (timer) {          switch (timer) {
   
         /*          /*
Line 152  tcp_timers(tp, timer) Line 135  tcp_timers(tp, timer)
          */           */
         case TCPT_2MSL:          case TCPT_2MSL:
                 if (tp->t_state != TCPS_TIME_WAIT &&                  if (tp->t_state != TCPS_TIME_WAIT &&
                     tp->t_idle <= tcp_maxidle)                      tp->t_idle <= TCP_MAXIDLE)
                         tp->t_timer[TCPT_2MSL] = tcp_keepintvl;                          tp->t_timer[TCPT_2MSL] = TCPTV_KEEPINTVL;
                 else                  else
                         tp = tcp_close(tp);                          tp = tcp_close(tp);
                 break;                  break;
Line 164  tcp_timers(tp, timer) Line 147  tcp_timers(tp, timer)
          * to a longer retransmit interval and retransmit one segment.           * to a longer retransmit interval and retransmit one segment.
          */           */
         case TCPT_REXMT:          case TCPT_REXMT:
                   
                 /*                  /*
                  * XXXXX If a packet has timed out, then remove all the queued                   * XXXXX If a packet has timed out, then remove all the queued
                  * packets for that session.                   * packets for that session.
                  */                   */
                   
                 if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {                  if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {
                         /*                          /*
                          * This is a hack to suit our terminal server here at the uni of canberra                           * This is a hack to suit our terminal server here at the uni of canberra
Line 178  tcp_timers(tp, timer) Line 161  tcp_timers(tp, timer)
                          * keep retransmitting it, it'll keep eating the zeroes, so we keep                           * keep retransmitting it, it'll keep eating the zeroes, so we keep
                          * retransmitting, and eventually the connection dies...                           * retransmitting, and eventually the connection dies...
                          * (this only happens on incoming data)                           * (this only happens on incoming data)
                          *                            *
                          * So, if we were gonna drop the connection from too many retransmits,                           * So, if we were gonna drop the connection from too many retransmits,
                          * don't... instead halve the t_maxseg, which might break up the NULLs and                           * don't... instead halve the t_maxseg, which might break up the NULLs and
                          * let them through                           * let them through
                          *                            *
                          * *sigh*                           * *sigh*
                          */                           */
                           
                         tp->t_maxseg >>= 1;                          tp->t_maxseg >>= 1;
                         if (tp->t_maxseg < 32) {                          if (tp->t_maxseg < 32) {
                                 /*                                  /*
                                  * We tried our best, now the connection must die!                                   * We tried our best, now the connection must die!
                                  */                                   */
                                 tp->t_rxtshift = TCP_MAXRXTSHIFT;                                  tp->t_rxtshift = TCP_MAXRXTSHIFT;
                                 tcpstat.tcps_timeoutdrop++;  
                                 tp = tcp_drop(tp, tp->t_softerror);                                  tp = tcp_drop(tp, tp->t_softerror);
                                 /* tp->t_softerror : ETIMEDOUT); */ /* XXX */                                  /* tp->t_softerror : ETIMEDOUT); */ /* XXX */
                                 return (tp); /* XXX */                                  return (tp); /* XXX */
                         }                          }
                           
                         /*                          /*
                          * Set rxtshift to 6, which is still at the maximum                           * Set rxtshift to 6, which is still at the maximum
                          * backoff time                           * backoff time
                          */                           */
                         tp->t_rxtshift = 6;                          tp->t_rxtshift = 6;
                 }                  }
                 tcpstat.tcps_rexmttimeo++;  
                 rexmt = TCP_REXMTVAL(tp) * tcp_backoff[tp->t_rxtshift];                  rexmt = TCP_REXMTVAL(tp) * tcp_backoff[tp->t_rxtshift];
                 TCPT_RANGESET(tp->t_rxtcur, rexmt,                  TCPT_RANGESET(tp->t_rxtcur, rexmt,
                     (short)tp->t_rttmin, TCPTV_REXMTMAX); /* XXX */                      (short)tp->t_rttmin, TCPTV_REXMTMAX); /* XXX */
Line 218  tcp_timers(tp, timer) Line 199  tcp_timers(tp, timer)
                  * retransmit times until then.                   * retransmit times until then.
                  */                   */
                 if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) {                  if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) {
 /*                      in_losing(tp->t_inpcb); */  
                         tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT);                          tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT);
                         tp->t_srtt = 0;                          tp->t_srtt = 0;
                 }                  }
Line 240  tcp_timers(tp, timer) Line 220  tcp_timers(tp, timer)
                  * size increase exponentially with time.  If the                   * size increase exponentially with time.  If the
                  * window is larger than the path can handle, this                   * window is larger than the path can handle, this
                  * exponential growth results in dropped packet(s)                   * exponential growth results in dropped packet(s)
                  * almost immediately.  To get more time between                    * almost immediately.  To get more time between
                  * drops but still "push" the network to take advantage                   * drops but still "push" the network to take advantage
                  * of improving conditions, we switch from exponential                   * of improving conditions, we switch from exponential
                  * to linear window opening at some threshold size.                   * to linear window opening at some threshold size.
Line 267  tcp_timers(tp, timer) Line 247  tcp_timers(tp, timer)
          * Force a byte to be output, if possible.           * Force a byte to be output, if possible.
          */           */
         case TCPT_PERSIST:          case TCPT_PERSIST:
                 tcpstat.tcps_persisttimeo++;  
                 tcp_setpersist(tp);                  tcp_setpersist(tp);
                 tp->t_force = 1;                  tp->t_force = 1;
                 (void) tcp_output(tp);                  (void) tcp_output(tp);
Line 279  tcp_timers(tp, timer) Line 258  tcp_timers(tp, timer)
          * or drop connection if idle for too long.           * or drop connection if idle for too long.
          */           */
         case TCPT_KEEP:          case TCPT_KEEP:
                 tcpstat.tcps_keeptimeo++;  
                 if (tp->t_state < TCPS_ESTABLISHED)                  if (tp->t_state < TCPS_ESTABLISHED)
                         goto dropit;                          goto dropit;
   
 /*              if (tp->t_socket->so_options & SO_KEEPALIVE && */                  if ((SO_OPTIONS) && tp->t_state <= TCPS_CLOSE_WAIT) {
                 if ((so_options) && tp->t_state <= TCPS_CLOSE_WAIT) {                          if (tp->t_idle >= TCPTV_KEEP_IDLE + TCP_MAXIDLE)
                         if (tp->t_idle >= tcp_keepidle + tcp_maxidle)  
                                 goto dropit;                                  goto dropit;
                         /*                          /*
                          * Send a packet designed to force a response                           * Send a packet designed to force a response
Line 299  tcp_timers(tp, timer) Line 276  tcp_timers(tp, timer)
                          * by the protocol spec, this requires the                           * by the protocol spec, this requires the
                          * correspondent TCP to respond.                           * correspondent TCP to respond.
                          */                           */
                         tcpstat.tcps_keepprobe++;  
 #ifdef TCP_COMPAT_42  
                         /*  
                          * The keepalive packet must have nonzero length  
                          * to get a 4.2 host to respond.  
                          */  
                         tcp_respond(tp, &tp->t_template, (struct mbuf *)NULL,  
                             tp->rcv_nxt - 1, tp->snd_una - 1, 0);  
 #else  
                         tcp_respond(tp, &tp->t_template, (struct mbuf *)NULL,                          tcp_respond(tp, &tp->t_template, (struct mbuf *)NULL,
                             tp->rcv_nxt, tp->snd_una - 1, 0);                              tp->rcv_nxt, tp->snd_una - 1, 0);
 #endif                          tp->t_timer[TCPT_KEEP] = TCPTV_KEEPINTVL;
                         tp->t_timer[TCPT_KEEP] = tcp_keepintvl;  
                 } else                  } else
                         tp->t_timer[TCPT_KEEP] = tcp_keepidle;                          tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_IDLE;
                 break;                  break;
   
         dropit:          dropit:
                 tcpstat.tcps_keepdrops++;                  tp = tcp_drop(tp, 0);
                 tp = tcp_drop(tp, 0); /* ETIMEDOUT); */  
                 break;                  break;
         }          }
   

Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.4


unix.superglobalmegacorp.com