The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netinet/tcp_timer.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*
    2  * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
    3  *      The Regents of the University of California.  All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. All advertising materials mentioning features or use of this software
   14  *    must display the following acknowledgement:
   15  *      This product includes software developed by the University of
   16  *      California, Berkeley and its contributors.
   17  * 4. Neither the name of the University nor the names of its contributors
   18  *    may be used to endorse or promote products derived from this software
   19  *    without specific prior written permission.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   31  * SUCH DAMAGE.
   32  *
   33  *      @(#)tcp_timer.c 8.2 (Berkeley) 5/24/95
   34  * $FreeBSD: releng/5.2/sys/netinet/tcp_timer.c 122922 2003-11-20 20:07:39Z andre $
   35  */
   36 
   37 #include "opt_inet6.h"
   38 #include "opt_tcpdebug.h"
   39 
   40 #include <sys/param.h>
   41 #include <sys/kernel.h>
   42 #include <sys/lock.h>
   43 #include <sys/mbuf.h>
   44 #include <sys/mutex.h>
   45 #include <sys/protosw.h>
   46 #include <sys/socket.h>
   47 #include <sys/socketvar.h>
   48 #include <sys/sysctl.h>
   49 #include <sys/systm.h>
   50 
   51 #include <net/route.h>
   52 
   53 #include <netinet/in.h>
   54 #include <netinet/in_pcb.h>
   55 #include <netinet/in_systm.h>
   56 #ifdef INET6
   57 #include <netinet6/in6_pcb.h>
   58 #endif
   59 #include <netinet/ip_var.h>
   60 #include <netinet/tcp.h>
   61 #include <netinet/tcp_fsm.h>
   62 #include <netinet/tcp_timer.h>
   63 #include <netinet/tcp_var.h>
   64 #include <netinet/tcpip.h>
   65 #ifdef TCPDEBUG
   66 #include <netinet/tcp_debug.h>
   67 #endif
   68 
   69 static int
   70 sysctl_msec_to_ticks(SYSCTL_HANDLER_ARGS)
   71 {
   72         int error, s, tt;
   73 
   74         tt = *(int *)oidp->oid_arg1;
   75         s = (int)((int64_t)tt * 1000 / hz);
   76 
   77         error = sysctl_handle_int(oidp, &s, 0, req);
   78         if (error || !req->newptr)
   79                 return (error);
   80 
   81         tt = (int)((int64_t)s * hz / 1000);
   82         if (tt < 1)
   83                 return (EINVAL);
   84 
   85         *(int *)oidp->oid_arg1 = tt;
   86         return (0);
   87 }
   88 
   89 int     tcp_keepinit;
   90 SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPINIT, keepinit, CTLTYPE_INT|CTLFLAG_RW,
   91     &tcp_keepinit, 0, sysctl_msec_to_ticks, "I", "");
   92 
   93 int     tcp_keepidle;
   94 SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPIDLE, keepidle, CTLTYPE_INT|CTLFLAG_RW,
   95     &tcp_keepidle, 0, sysctl_msec_to_ticks, "I", "");
   96 
   97 int     tcp_keepintvl;
   98 SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPINTVL, keepintvl, CTLTYPE_INT|CTLFLAG_RW,
   99     &tcp_keepintvl, 0, sysctl_msec_to_ticks, "I", "");
  100 
  101 int     tcp_delacktime;
  102 SYSCTL_PROC(_net_inet_tcp, TCPCTL_DELACKTIME, delacktime,
  103     CTLTYPE_INT|CTLFLAG_RW, &tcp_delacktime, 0, sysctl_msec_to_ticks, "I",
  104     "Time before a delayed ACK is sent");
  105  
  106 int     tcp_msl;
  107 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, msl, CTLTYPE_INT|CTLFLAG_RW,
  108     &tcp_msl, 0, sysctl_msec_to_ticks, "I", "Maximum segment lifetime");
  109 
  110 int     tcp_rexmit_min;
  111 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, rexmit_min, CTLTYPE_INT|CTLFLAG_RW,
  112     &tcp_rexmit_min, 0, sysctl_msec_to_ticks, "I", "Minimum Retransmission Timeout");
  113 
  114 int     tcp_rexmit_slop;
  115 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, rexmit_slop, CTLTYPE_INT|CTLFLAG_RW,
  116     &tcp_rexmit_slop, 0, sysctl_msec_to_ticks, "I", "Retransmission Timer Slop");
  117 
  118 static int      always_keepalive = 1;
  119 SYSCTL_INT(_net_inet_tcp, OID_AUTO, always_keepalive, CTLFLAG_RW, 
  120     &always_keepalive , 0, "Assume SO_KEEPALIVE on all TCP connections");
  121 
  122 static int      tcp_keepcnt = TCPTV_KEEPCNT;
  123         /* max idle probes */
  124 int     tcp_maxpersistidle;
  125         /* max idle time in persist */
  126 int     tcp_maxidle;
  127 
  128 /*
  129  * Tcp protocol timeout routine called every 500 ms.
  130  * Updates timestamps used for TCP
  131  * causes finite state machine actions if timers expire.
  132  */
  133 void
  134 tcp_slowtimo()
  135 {
  136         int s;
  137 
  138         s = splnet();
  139         tcp_maxidle = tcp_keepcnt * tcp_keepintvl;
  140         splx(s);
  141         INP_INFO_WLOCK(&tcbinfo);
  142         (void) tcp_timer_2msl_tw(0);
  143         INP_INFO_WUNLOCK(&tcbinfo);
  144 }
  145 
  146 /*
  147  * Cancel all timers for TCP tp.
  148  */
  149 void
  150 tcp_canceltimers(tp)
  151         struct tcpcb *tp;
  152 {
  153         callout_stop(tp->tt_2msl);
  154         callout_stop(tp->tt_persist);
  155         callout_stop(tp->tt_keep);
  156         callout_stop(tp->tt_rexmt);
  157 }
  158 
  159 int     tcp_syn_backoff[TCP_MAXRXTSHIFT + 1] =
  160     { 1, 1, 1, 1, 1, 2, 4, 8, 16, 32, 64, 64, 64 };
  161 
  162 int     tcp_backoff[TCP_MAXRXTSHIFT + 1] =
  163     { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 512, 512, 512 };
  164 
  165 static int tcp_totbackoff = 2559;       /* sum of tcp_backoff[] */
  166 
  167 /*
  168  * TCP timer processing.
  169  */
  170 
  171 void
  172 tcp_timer_delack(xtp)
  173         void *xtp;
  174 {
  175         struct tcpcb *tp = xtp;
  176         int s;
  177         struct inpcb *inp;
  178 
  179         s = splnet();
  180         INP_INFO_RLOCK(&tcbinfo);
  181         inp = tp->t_inpcb;
  182         if (!inp) {
  183                 INP_INFO_RUNLOCK(&tcbinfo);
  184                 splx(s);
  185                 return;
  186         }
  187         INP_LOCK(inp);
  188         INP_INFO_RUNLOCK(&tcbinfo);
  189         if (callout_pending(tp->tt_delack) || !callout_active(tp->tt_delack)) {
  190                 INP_UNLOCK(inp);
  191                 splx(s);
  192                 return;
  193         }
  194         callout_deactivate(tp->tt_delack);
  195 
  196         tp->t_flags |= TF_ACKNOW;
  197         tcpstat.tcps_delack++;
  198         (void) tcp_output(tp);
  199         INP_UNLOCK(inp);
  200         splx(s);
  201 }
  202 
  203 void
  204 tcp_timer_2msl(xtp)
  205         void *xtp;
  206 {
  207         struct tcpcb *tp = xtp;
  208         int s;
  209         struct inpcb *inp;
  210 #ifdef TCPDEBUG
  211         int ostate;
  212 
  213         ostate = tp->t_state;
  214 #endif
  215         s = splnet();
  216         INP_INFO_WLOCK(&tcbinfo);
  217         inp = tp->t_inpcb;
  218         if (!inp) {
  219                 INP_INFO_WUNLOCK(&tcbinfo);
  220                 splx(s);
  221                 return;
  222         }
  223         INP_LOCK(inp);
  224         if (callout_pending(tp->tt_2msl) || !callout_active(tp->tt_2msl)) {
  225                 INP_UNLOCK(tp->t_inpcb);
  226                 INP_INFO_WUNLOCK(&tcbinfo);
  227                 splx(s);
  228                 return;
  229         }
  230         callout_deactivate(tp->tt_2msl);
  231         /*
  232          * 2 MSL timeout in shutdown went off.  If we're closed but
  233          * still waiting for peer to close and connection has been idle
  234          * too long, or if 2MSL time is up from TIME_WAIT, delete connection
  235          * control block.  Otherwise, check again in a bit.
  236          */
  237         if (tp->t_state != TCPS_TIME_WAIT &&
  238             (ticks - tp->t_rcvtime) <= tcp_maxidle)
  239                 callout_reset(tp->tt_2msl, tcp_keepintvl,
  240                               tcp_timer_2msl, tp);
  241         else
  242                 tp = tcp_close(tp);
  243 
  244 #ifdef TCPDEBUG
  245         if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
  246                 tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,
  247                           PRU_SLOWTIMO);
  248 #endif
  249         if (tp)
  250                 INP_UNLOCK(inp);
  251         INP_INFO_WUNLOCK(&tcbinfo);
  252         splx(s);
  253 }
  254 
  255 struct twlist {
  256         LIST_HEAD(, tcptw)      tw_list;
  257         struct tcptw    tw_tail;
  258 };
  259 #define TWLIST_NLISTS   2
  260 static struct twlist twl_2msl[TWLIST_NLISTS];
  261 static struct twlist *tw_2msl_list[] = { &twl_2msl[0], &twl_2msl[1], NULL };
  262 
  263 void
  264 tcp_timer_init(void)
  265 {
  266         int i;
  267         struct twlist *twl;
  268 
  269         for (i = 0; i < TWLIST_NLISTS; i++) {
  270                 twl = &twl_2msl[i];
  271                 LIST_INIT(&twl->tw_list);
  272                 LIST_INSERT_HEAD(&twl->tw_list, &twl->tw_tail, tw_2msl);
  273         }
  274 }
  275 
  276 void
  277 tcp_timer_2msl_reset(struct tcptw *tw, int timeo)
  278 {
  279         int i;
  280         struct tcptw *tw_tail;
  281 
  282         if (tw->tw_time != 0)
  283                 LIST_REMOVE(tw, tw_2msl);
  284         tw->tw_time = timeo + ticks;
  285         i = timeo > tcp_msl ? 1 : 0;
  286         tw_tail = &twl_2msl[i].tw_tail;
  287         LIST_INSERT_BEFORE(tw_tail, tw, tw_2msl);
  288 }
  289 
  290 void
  291 tcp_timer_2msl_stop(struct tcptw *tw)
  292 {
  293 
  294         if (tw->tw_time != 0)
  295                 LIST_REMOVE(tw, tw_2msl);
  296 }
  297 
  298 struct tcptw *
  299 tcp_timer_2msl_tw(int reuse)
  300 {
  301         struct tcptw *tw, *tw_tail;
  302         struct twlist *twl;
  303         int i;
  304         
  305         for (i = 0; i < 2; i++) {
  306                 twl = tw_2msl_list[i];
  307                 tw_tail = &twl->tw_tail;
  308                 for (;;) {
  309                         tw = LIST_FIRST(&twl->tw_list);
  310                         if (tw == tw_tail || (!reuse && tw->tw_time > ticks))
  311                                 break;
  312                         INP_LOCK(tw->tw_inpcb);
  313                         if (tcp_twclose(tw, reuse) != NULL)
  314                                 return (tw);
  315                 }
  316         }
  317         return (NULL);
  318 }
  319 
  320 void
  321 tcp_timer_keep(xtp)
  322         void *xtp;
  323 {
  324         struct tcpcb *tp = xtp;
  325         struct tcptemp *t_template;
  326         int s;
  327         struct inpcb *inp;
  328 #ifdef TCPDEBUG
  329         int ostate;
  330 
  331         ostate = tp->t_state;
  332 #endif
  333         s = splnet();
  334         INP_INFO_WLOCK(&tcbinfo);
  335         inp = tp->t_inpcb;
  336         if (!inp) {
  337                 INP_INFO_WUNLOCK(&tcbinfo);
  338                 splx(s);
  339                 return;
  340         }
  341         INP_LOCK(inp);
  342         if (callout_pending(tp->tt_keep) || !callout_active(tp->tt_keep)) {
  343                 INP_UNLOCK(inp);
  344                 INP_INFO_WUNLOCK(&tcbinfo);
  345                 splx(s);
  346                 return;
  347         }
  348         callout_deactivate(tp->tt_keep);
  349         /*
  350          * Keep-alive timer went off; send something
  351          * or drop connection if idle for too long.
  352          */
  353         tcpstat.tcps_keeptimeo++;
  354         if (tp->t_state < TCPS_ESTABLISHED)
  355                 goto dropit;
  356         if ((always_keepalive || inp->inp_socket->so_options & SO_KEEPALIVE) &&
  357             tp->t_state <= TCPS_CLOSING) {
  358                 if ((ticks - tp->t_rcvtime) >= tcp_keepidle + tcp_maxidle)
  359                         goto dropit;
  360                 /*
  361                  * Send a packet designed to force a response
  362                  * if the peer is up and reachable:
  363                  * either an ACK if the connection is still alive,
  364                  * or an RST if the peer has closed the connection
  365                  * due to timeout or reboot.
  366                  * Using sequence number tp->snd_una-1
  367                  * causes the transmitted zero-length segment
  368                  * to lie outside the receive window;
  369                  * by the protocol spec, this requires the
  370                  * correspondent TCP to respond.
  371                  */
  372                 tcpstat.tcps_keepprobe++;
  373                 t_template = tcpip_maketemplate(inp);
  374                 if (t_template) {
  375                         tcp_respond(tp, t_template->tt_ipgen,
  376                                     &t_template->tt_t, (struct mbuf *)NULL,
  377                                     tp->rcv_nxt, tp->snd_una - 1, 0);
  378                         (void) m_free(dtom(t_template));
  379                 }
  380                 callout_reset(tp->tt_keep, tcp_keepintvl, tcp_timer_keep, tp);
  381         } else
  382                 callout_reset(tp->tt_keep, tcp_keepidle, tcp_timer_keep, tp);
  383 
  384 #ifdef TCPDEBUG
  385         if (inp->inp_socket->so_options & SO_DEBUG)
  386                 tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,
  387                           PRU_SLOWTIMO);
  388 #endif
  389         INP_UNLOCK(inp);
  390         INP_INFO_WUNLOCK(&tcbinfo);
  391         splx(s);
  392         return;
  393 
  394 dropit:
  395         tcpstat.tcps_keepdrops++;
  396         tp = tcp_drop(tp, ETIMEDOUT);
  397 
  398 #ifdef TCPDEBUG
  399         if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
  400                 tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,
  401                           PRU_SLOWTIMO);
  402 #endif
  403         if (tp)
  404                 INP_UNLOCK(tp->t_inpcb);
  405         INP_INFO_WUNLOCK(&tcbinfo);
  406         splx(s);
  407 }
  408 
  409 void
  410 tcp_timer_persist(xtp)
  411         void *xtp;
  412 {
  413         struct tcpcb *tp = xtp;
  414         int s;
  415         struct inpcb *inp;
  416 #ifdef TCPDEBUG
  417         int ostate;
  418 
  419         ostate = tp->t_state;
  420 #endif
  421         s = splnet();
  422         INP_INFO_WLOCK(&tcbinfo);
  423         inp = tp->t_inpcb;
  424         if (!inp) {
  425                 INP_INFO_WUNLOCK(&tcbinfo);
  426                 splx(s);
  427                 return;
  428         }
  429         INP_LOCK(inp);
  430         if (callout_pending(tp->tt_persist) || !callout_active(tp->tt_persist)){
  431                 INP_UNLOCK(inp);
  432                 INP_INFO_WUNLOCK(&tcbinfo);
  433                 splx(s);
  434                 return;
  435         }
  436         callout_deactivate(tp->tt_persist);
  437         /*
  438          * Persistance timer into zero window.
  439          * Force a byte to be output, if possible.
  440          */
  441         tcpstat.tcps_persisttimeo++;
  442         /*
  443          * Hack: if the peer is dead/unreachable, we do not
  444          * time out if the window is closed.  After a full
  445          * backoff, drop the connection if the idle time
  446          * (no responses to probes) reaches the maximum
  447          * backoff that we would use if retransmitting.
  448          */
  449         if (tp->t_rxtshift == TCP_MAXRXTSHIFT &&
  450             ((ticks - tp->t_rcvtime) >= tcp_maxpersistidle ||
  451              (ticks - tp->t_rcvtime) >= TCP_REXMTVAL(tp) * tcp_totbackoff)) {
  452                 tcpstat.tcps_persistdrop++;
  453                 tp = tcp_drop(tp, ETIMEDOUT);
  454                 goto out;
  455         }
  456         tcp_setpersist(tp);
  457         tp->t_force = 1;
  458         (void) tcp_output(tp);
  459         tp->t_force = 0;
  460 
  461 out:
  462 #ifdef TCPDEBUG
  463         if (tp && tp->t_inpcb->inp_socket->so_options & SO_DEBUG)
  464                 tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,
  465                           PRU_SLOWTIMO);
  466 #endif
  467         if (tp)
  468                 INP_UNLOCK(inp);
  469         INP_INFO_WUNLOCK(&tcbinfo);
  470         splx(s);
  471 }
  472 
  473 void
  474 tcp_timer_rexmt(xtp)
  475         void *xtp;
  476 {
  477         struct tcpcb *tp = xtp;
  478         int s;
  479         int rexmt;
  480         int headlocked;
  481         struct inpcb *inp;
  482 #ifdef TCPDEBUG
  483         int ostate;
  484 
  485         ostate = tp->t_state;
  486 #endif
  487         s = splnet();
  488         INP_INFO_WLOCK(&tcbinfo);
  489         headlocked = 1;
  490         inp = tp->t_inpcb;
  491         if (!inp) {
  492                 INP_INFO_WUNLOCK(&tcbinfo);
  493                 splx(s);
  494                 return;
  495         }
  496         INP_LOCK(inp);
  497         if (callout_pending(tp->tt_rexmt) || !callout_active(tp->tt_rexmt)) {
  498                 INP_UNLOCK(inp);
  499                 INP_INFO_WUNLOCK(&tcbinfo);
  500                 splx(s);
  501                 return;
  502         }
  503         callout_deactivate(tp->tt_rexmt);
  504         /*
  505          * Retransmission timer went off.  Message has not
  506          * been acked within retransmit interval.  Back off
  507          * to a longer retransmit interval and retransmit one segment.
  508          */
  509         if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {
  510                 tp->t_rxtshift = TCP_MAXRXTSHIFT;
  511                 tcpstat.tcps_timeoutdrop++;
  512                 tp = tcp_drop(tp, tp->t_softerror ?
  513                               tp->t_softerror : ETIMEDOUT);
  514                 goto out;
  515         }
  516         INP_INFO_WUNLOCK(&tcbinfo);
  517         headlocked = 0;
  518         if (tp->t_rxtshift == 1) {
  519                 /*
  520                  * first retransmit; record ssthresh and cwnd so they can
  521                  * be recovered if this turns out to be a "bad" retransmit.
  522                  * A retransmit is considered "bad" if an ACK for this 
  523                  * segment is received within RTT/2 interval; the assumption
  524                  * here is that the ACK was already in flight.  See 
  525                  * "On Estimating End-to-End Network Path Properties" by
  526                  * Allman and Paxson for more details.
  527                  */
  528                 tp->snd_cwnd_prev = tp->snd_cwnd;
  529                 tp->snd_ssthresh_prev = tp->snd_ssthresh;
  530                 tp->snd_recover_prev = tp->snd_recover;
  531                 if (IN_FASTRECOVERY(tp))
  532                   tp->t_flags |= TF_WASFRECOVERY;
  533                 else
  534                   tp->t_flags &= ~TF_WASFRECOVERY;
  535                 tp->t_badrxtwin = ticks + (tp->t_srtt >> (TCP_RTT_SHIFT + 1));
  536         }
  537         tcpstat.tcps_rexmttimeo++;
  538         if (tp->t_state == TCPS_SYN_SENT)
  539                 rexmt = TCP_REXMTVAL(tp) * tcp_syn_backoff[tp->t_rxtshift];
  540         else
  541                 rexmt = TCP_REXMTVAL(tp) * tcp_backoff[tp->t_rxtshift];
  542         TCPT_RANGESET(tp->t_rxtcur, rexmt,
  543                       tp->t_rttmin, TCPTV_REXMTMAX);
  544         /*
  545          * Disable rfc1323 and rfc1644 if we havn't got any response to
  546          * our third SYN to work-around some broken terminal servers 
  547          * (most of which have hopefully been retired) that have bad VJ 
  548          * header compression code which trashes TCP segments containing 
  549          * unknown-to-them TCP options.
  550          */
  551         if ((tp->t_state == TCPS_SYN_SENT) && (tp->t_rxtshift == 3))
  552                 tp->t_flags &= ~(TF_REQ_SCALE|TF_REQ_TSTMP|TF_REQ_CC);
  553         /*
  554          * If we backed off this far, our srtt estimate is probably bogus.
  555          * Clobber it so we'll take the next rtt measurement as our srtt;
  556          * move the current srtt into rttvar to keep the current
  557          * retransmit times until then.
  558          */
  559         if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) {
  560 #ifdef INET6
  561                 if ((tp->t_inpcb->inp_vflag & INP_IPV6) != 0)
  562                         in6_losing(tp->t_inpcb);
  563                 else
  564 #endif
  565                 tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT);
  566                 tp->t_srtt = 0;
  567         }
  568         tp->snd_nxt = tp->snd_una;
  569         tp->snd_recover = tp->snd_max;
  570         /*
  571          * Force a segment to be sent.
  572          */
  573         tp->t_flags |= TF_ACKNOW;
  574         /*
  575          * If timing a segment in this window, stop the timer.
  576          */
  577         tp->t_rtttime = 0;
  578         /*
  579          * Close the congestion window down to one segment
  580          * (we'll open it by one segment for each ack we get).
  581          * Since we probably have a window's worth of unacked
  582          * data accumulated, this "slow start" keeps us from
  583          * dumping all that data as back-to-back packets (which
  584          * might overwhelm an intermediate gateway).
  585          *
  586          * There are two phases to the opening: Initially we
  587          * open by one mss on each ack.  This makes the window
  588          * size increase exponentially with time.  If the
  589          * window is larger than the path can handle, this
  590          * exponential growth results in dropped packet(s)
  591          * almost immediately.  To get more time between
  592          * drops but still "push" the network to take advantage
  593          * of improving conditions, we switch from exponential
  594          * to linear window opening at some threshhold size.
  595          * For a threshhold, we use half the current window
  596          * size, truncated to a multiple of the mss.
  597          *
  598          * (the minimum cwnd that will give us exponential
  599          * growth is 2 mss.  We don't allow the threshhold
  600          * to go below this.)
  601          */
  602         {
  603                 u_int win = min(tp->snd_wnd, tp->snd_cwnd) / 2 / tp->t_maxseg;
  604                 if (win < 2)
  605                         win = 2;
  606                 tp->snd_cwnd = tp->t_maxseg;
  607                 tp->snd_ssthresh = win * tp->t_maxseg;
  608                 tp->t_dupacks = 0;
  609         }
  610         EXIT_FASTRECOVERY(tp);
  611         (void) tcp_output(tp);
  612 
  613 out:
  614 #ifdef TCPDEBUG
  615         if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
  616                 tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,
  617                           PRU_SLOWTIMO);
  618 #endif
  619         if (tp)
  620                 INP_UNLOCK(inp);
  621         if (headlocked)
  622                 INP_INFO_WUNLOCK(&tcbinfo);
  623         splx(s);
  624 }

Cache object: bced541e63cb489c33d300498215b859


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.