sys/netinet/tcp_timer.c

   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$
  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 ||
 357              tp->t_inpcb->inp_socket->so_options & SO_KEEPALIVE) &&
 358             tp->t_state <= TCPS_CLOSING) {
 359                 if ((ticks - tp->t_rcvtime) >= tcp_keepidle + tcp_maxidle)
 360                         goto dropit;
 361                 /*
 362                  * Send a packet designed to force a response
 363                  * if the peer is up and reachable:
 364                  * either an ACK if the connection is still alive,
 365                  * or an RST if the peer has closed the connection
 366                  * due to timeout or reboot.
 367                  * Using sequence number tp->snd_una-1
 368                  * causes the transmitted zero-length segment
 369                  * to lie outside the receive window;
 370                  * by the protocol spec, this requires the
 371                  * correspondent TCP to respond.
 372                  */
 373                 tcpstat.tcps_keepprobe++;
 374                 t_template = tcpip_maketemplate(inp);
 375                 if (t_template) {
 376                         tcp_respond(tp, t_template->tt_ipgen,
 377                                     &t_template->tt_t, (struct mbuf *)NULL,
 378                                     tp->rcv_nxt, tp->snd_una - 1, 0);
 379                         (void) m_free(dtom(t_template));
 380                 }
 381                 callout_reset(tp->tt_keep, tcp_keepintvl, tcp_timer_keep, tp);
 382         } else
 383                 callout_reset(tp->tt_keep, tcp_keepidle, tcp_timer_keep, tp);
 384
 385 #ifdef TCPDEBUG
 386         if (tp->t_inpcb->inp_socket->so_options & SO_DEBUG)
 387                 tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,
 388                           PRU_SLOWTIMO);
 389 #endif
 390         INP_UNLOCK(inp);
 391         INP_INFO_WUNLOCK(&tcbinfo);
 392         splx(s);
 393         return;
 394
 395 dropit:
 396         tcpstat.tcps_keepdrops++;
 397         tp = tcp_drop(tp, ETIMEDOUT);
 398
 399 #ifdef TCPDEBUG
 400         if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
 401                 tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,
 402                           PRU_SLOWTIMO);
 403 #endif
 404         if (tp)
 405                 INP_UNLOCK(tp->t_inpcb);
 406         INP_INFO_WUNLOCK(&tcbinfo);
 407         splx(s);
 408 }
 409
 410 void
 411 tcp_timer_persist(xtp)
 412         void *xtp;
 413 {
 414         struct tcpcb *tp = xtp;
 415         int s;
 416         struct inpcb *inp;
 417 #ifdef TCPDEBUG
 418         int ostate;
 419
 420         ostate = tp->t_state;
 421 #endif
 422         s = splnet();
 423         INP_INFO_WLOCK(&tcbinfo);
 424         inp = tp->t_inpcb;
 425         if (!inp) {
 426                 INP_INFO_WUNLOCK(&tcbinfo);
 427                 splx(s);
 428                 return;
 429         }
 430         INP_LOCK(inp);
 431         if (callout_pending(tp->tt_persist) || !callout_active(tp->tt_persist)){
 432                 INP_UNLOCK(inp);
 433                 INP_INFO_WUNLOCK(&tcbinfo);
 434                 splx(s);
 435                 return;
 436         }
 437         callout_deactivate(tp->tt_persist);
 438         /*
 439          * Persistance timer into zero window.
 440          * Force a byte to be output, if possible.
 441          */
 442         tcpstat.tcps_persisttimeo++;
 443         /*
 444          * Hack: if the peer is dead/unreachable, we do not
 445          * time out if the window is closed.  After a full
 446          * backoff, drop the connection if the idle time
 447          * (no responses to probes) reaches the maximum
 448          * backoff that we would use if retransmitting.
 449          */
 450         if (tp->t_rxtshift == TCP_MAXRXTSHIFT &&
 451             ((ticks - tp->t_rcvtime) >= tcp_maxpersistidle ||
 452              (ticks - tp->t_rcvtime) >= TCP_REXMTVAL(tp) * tcp_totbackoff)) {
 453                 tcpstat.tcps_persistdrop++;
 454                 tp = tcp_drop(tp, ETIMEDOUT);
 455                 goto out;
 456         }
 457         tcp_setpersist(tp);
 458         tp->t_force = 1;
 459         (void) tcp_output(tp);
 460         tp->t_force = 0;
 461
 462 out:
 463 #ifdef TCPDEBUG
 464         if (tp && tp->t_inpcb->inp_socket->so_options & SO_DEBUG)
 465                 tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,
 466                           PRU_SLOWTIMO);
 467 #endif
 468         if (tp)
 469                 INP_UNLOCK(inp);
 470         INP_INFO_WUNLOCK(&tcbinfo);
 471         splx(s);
 472 }
 473
 474 void
 475 tcp_timer_rexmt(xtp)
 476         void *xtp;
 477 {
 478         struct tcpcb *tp = xtp;
 479         int s;
 480         int rexmt;
 481         int headlocked;
 482         struct inpcb *inp;
 483 #ifdef TCPDEBUG
 484         int ostate;
 485
 486         ostate = tp->t_state;
 487 #endif
 488         s = splnet();
 489         INP_INFO_WLOCK(&tcbinfo);
 490         headlocked = 1;
 491         inp = tp->t_inpcb;
 492         if (!inp) {
 493                 INP_INFO_WUNLOCK(&tcbinfo);
 494                 splx(s);
 495                 return;
 496         }
 497         INP_LOCK(inp);
 498         if (callout_pending(tp->tt_rexmt) || !callout_active(tp->tt_rexmt)) {
 499                 INP_UNLOCK(inp);
 500                 INP_INFO_WUNLOCK(&tcbinfo);
 501                 splx(s);
 502                 return;
 503         }
 504         callout_deactivate(tp->tt_rexmt);
 505         /*
 506          * Retransmission timer went off.  Message has not
 507          * been acked within retransmit interval.  Back off
 508          * to a longer retransmit interval and retransmit one segment.
 509          */
 510         if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {
 511                 tp->t_rxtshift = TCP_MAXRXTSHIFT;
 512                 tcpstat.tcps_timeoutdrop++;
 513                 tp = tcp_drop(tp, tp->t_softerror ?
 514                               tp->t_softerror : ETIMEDOUT);
 515                 goto out;
 516         }
 517         INP_INFO_WUNLOCK(&tcbinfo);
 518         headlocked = 0;
 519         if (tp->t_rxtshift == 1) {
 520                 /*
 521                  * first retransmit; record ssthresh and cwnd so they can
 522                  * be recovered if this turns out to be a "bad" retransmit.
 523                  * A retransmit is considered "bad" if an ACK for this
 524                  * segment is received within RTT/2 interval; the assumption
 525                  * here is that the ACK was already in flight.  See
 526                  * "On Estimating End-to-End Network Path Properties" by
 527                  * Allman and Paxson for more details.
 528                  */
 529                 tp->snd_cwnd_prev = tp->snd_cwnd;
 530                 tp->snd_ssthresh_prev = tp->snd_ssthresh;
 531                 tp->snd_recover_prev = tp->snd_recover;
 532                 if (IN_FASTRECOVERY(tp))
 533                   tp->t_flags |= TF_WASFRECOVERY;
 534                 else
 535                   tp->t_flags &= ~TF_WASFRECOVERY;
 536                 tp->t_badrxtwin = ticks + (tp->t_srtt >> (TCP_RTT_SHIFT + 1));
 537         }
 538         tcpstat.tcps_rexmttimeo++;
 539         if (tp->t_state == TCPS_SYN_SENT)
 540                 rexmt = TCP_REXMTVAL(tp) * tcp_syn_backoff[tp->t_rxtshift];
 541         else
 542                 rexmt = TCP_REXMTVAL(tp) * tcp_backoff[tp->t_rxtshift];
 543         TCPT_RANGESET(tp->t_rxtcur, rexmt,
 544                       tp->t_rttmin, TCPTV_REXMTMAX);
 545         /*
 546          * Disable rfc1323 and rfc1644 if we havn't got any response to
 547          * our third SYN to work-around some broken terminal servers
 548          * (most of which have hopefully been retired) that have bad VJ
 549          * header compression code which trashes TCP segments containing
 550          * unknown-to-them TCP options.
 551          */
 552         if ((tp->t_state == TCPS_SYN_SENT) && (tp->t_rxtshift == 3))
 553                 tp->t_flags &= ~(TF_REQ_SCALE|TF_REQ_TSTMP|TF_REQ_CC);
 554         /*
 555          * If losing, let the lower level know and try for
 556          * a better route.  Also, if we backed off this far,
 557          * our srtt estimate is probably bogus.  Clobber it
 558          * so we'll take the next rtt measurement as our srtt;
 559          * move the current srtt into rttvar to keep the current
 560          * retransmit times until then.
 561          */
 562         if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) {
 563 #ifdef INET6
 564                 if ((tp->t_inpcb->inp_vflag & INP_IPV6) != 0)
 565                         in6_losing(tp->t_inpcb);
 566                 else
 567 #endif
 568                 in_losing(tp->t_inpcb);
 569                 tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT);
 570                 tp->t_srtt = 0;
 571         }
 572         tp->snd_nxt = tp->snd_una;
 573         tp->snd_recover = tp->snd_max;
 574         /*
 575          * Force a segment to be sent.
 576          */
 577         tp->t_flags |= TF_ACKNOW;
 578         /*
 579          * If timing a segment in this window, stop the timer.
 580          */
 581         tp->t_rtttime = 0;
 582         /*
 583          * Close the congestion window down to one segment
 584          * (we'll open it by one segment for each ack we get).
 585          * Since we probably have a window's worth of unacked
 586          * data accumulated, this "slow start" keeps us from
 587          * dumping all that data as back-to-back packets (which
 588          * might overwhelm an intermediate gateway).
 589          *
 590          * There are two phases to the opening: Initially we
 591          * open by one mss on each ack.  This makes the window
 592          * size increase exponentially with time.  If the
 593          * window is larger than the path can handle, this
 594          * exponential growth results in dropped packet(s)
 595          * almost immediately.  To get more time between
 596          * drops but still "push" the network to take advantage
 597          * of improving conditions, we switch from exponential
 598          * to linear window opening at some threshhold size.
 599          * For a threshhold, we use half the current window
 600          * size, truncated to a multiple of the mss.
 601          *
 602          * (the minimum cwnd that will give us exponential
 603          * growth is 2 mss.  We don't allow the threshhold
 604          * to go below this.)
 605          */
 606         {
 607                 u_int win = min(tp->snd_wnd, tp->snd_cwnd) / 2 / tp->t_maxseg;
 608                 if (win < 2)
 609                         win = 2;
 610                 tp->snd_cwnd = tp->t_maxseg;
 611                 tp->snd_ssthresh = win * tp->t_maxseg;
 612                 tp->t_dupacks = 0;
 613         }
 614         EXIT_FASTRECOVERY(tp);
 615         (void) tcp_output(tp);
 616
 617 out:
 618 #ifdef TCPDEBUG
 619         if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
 620                 tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,
 621                           PRU_SLOWTIMO);
 622 #endif
 623         if (tp)
 624                 INP_UNLOCK(inp);
 625         if (headlocked)
 626                 INP_INFO_WUNLOCK(&tcbinfo);
 627         splx(s);
 628 }