tcp_timer.c revision 50673
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: head/sys/netinet/tcp_timer.c 50673 1999-08-30 21:17:07Z jlemon $ 35 */ 36 37#include "opt_compat.h" 38#include "opt_tcpdebug.h" 39 40#include <sys/param.h> 41#include <sys/systm.h> 42#include <sys/kernel.h> 43#include <sys/sysctl.h> 44#include <sys/socket.h> 45#include <sys/socketvar.h> 46#include <sys/protosw.h> 47 48#include <machine/cpu.h> /* before tcp_seq.h, for tcp_random18() */ 49 50#include <net/route.h> 51 52#include <netinet/in.h> 53#include <netinet/in_systm.h> 54#include <netinet/in_pcb.h> 55#include <netinet/ip_var.h> 56#include <netinet/tcp.h> 57#include <netinet/tcp_fsm.h> 58#include <netinet/tcp_seq.h> 59#include <netinet/tcp_timer.h> 60#include <netinet/tcp_var.h> 61#include <netinet/tcpip.h> 62#ifdef TCPDEBUG 63#include <netinet/tcp_debug.h> 64#endif 65 66int tcp_keepinit; 67SYSCTL_INT(_net_inet_tcp, TCPCTL_KEEPINIT, keepinit, 68 CTLFLAG_RW, &tcp_keepinit , 0, ""); 69 70int tcp_keepidle; 71SYSCTL_INT(_net_inet_tcp, TCPCTL_KEEPIDLE, keepidle, 72 CTLFLAG_RW, &tcp_keepidle , 0, ""); 73 74int tcp_keepintvl; 75SYSCTL_INT(_net_inet_tcp, TCPCTL_KEEPINTVL, keepintvl, 76 CTLFLAG_RW, &tcp_keepintvl , 0, ""); 77 78int tcp_delacktime; 79SYSCTL_INT(_net_inet_tcp, TCPCTL_DELACKTIME, delacktime, CTLFLAG_RW, 80 &tcp_delacktime, 0, "Time before a delayed ACK is sent"); 81 82int tcp_msl; 83SYSCTL_INT(_net_inet_tcp, OID_AUTO, msl, CTLFLAG_RW, 84 &tcp_msl, 0, "Maximum segment lifetime"); 85 86static int always_keepalive = 0; 87SYSCTL_INT(_net_inet_tcp, OID_AUTO, always_keepalive, CTLFLAG_RW, 88 &always_keepalive , 0, "Assume SO_KEEPALIVE on all TCP connections"); 89 90static int tcp_keepcnt = TCPTV_KEEPCNT; 91 /* max idle probes */ 92int tcp_maxpersistidle; 93 /* max idle time in persist */ 94int tcp_maxidle; 95 96/* 97 * Tcp protocol timeout routine called every 500 ms. 98 * Updates timestamps used for TCP 99 * causes finite state machine actions if timers expire. 100 */ 101void 102tcp_slowtimo() 103{ 104 int s; 105 106 s = splnet(); 107 108 tcp_maxidle = tcp_keepcnt * tcp_keepintvl; 109 110 tcp_iss += TCP_ISSINCR/PR_SLOWHZ; /* increment iss */ 111#ifdef TCP_COMPAT_42 112 if ((int)tcp_iss < 0) 113 tcp_iss = TCP_ISSINCR; /* XXX */ 114#endif 115 splx(s); 116} 117 118/* 119 * Cancel all timers for TCP tp. 120 */ 121void 122tcp_canceltimers(tp) 123 struct tcpcb *tp; 124{ 125 callout_stop(tp->tt_2msl); 126 callout_stop(tp->tt_persist); 127 callout_stop(tp->tt_keep); 128 callout_stop(tp->tt_rexmt); 129} 130 131int tcp_backoff[TCP_MAXRXTSHIFT + 1] = 132 { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 }; 133 134static int tcp_totbackoff = 511; /* sum of tcp_backoff[] */ 135 136/* 137 * TCP timer processing. 138 */ 139void 140tcp_timer_delack(xtp) 141 void *xtp; 142{ 143 struct tcpcb *tp = xtp; 144 int s; 145 146 s = splnet(); 147 if (callout_pending(tp->tt_delack)) { 148 splx(s); 149 return; 150 } 151 callout_deactivate(tp->tt_delack); 152 153 tp->t_flags |= TF_ACKNOW; 154 tcpstat.tcps_delack++; 155 (void) tcp_output(tp); 156 splx(s); 157} 158 159void 160tcp_timer_2msl(xtp) 161 void *xtp; 162{ 163 struct tcpcb *tp = xtp; 164 int s; 165#ifdef TCPDEBUG 166 int ostate; 167 168 ostate = tp->t_state; 169#endif 170 s = splnet(); 171 if (callout_pending(tp->tt_2msl)) { 172 splx(s); 173 return; 174 } 175 callout_deactivate(tp->tt_2msl); 176 /* 177 * 2 MSL timeout in shutdown went off. If we're closed but 178 * still waiting for peer to close and connection has been idle 179 * too long, or if 2MSL time is up from TIME_WAIT, delete connection 180 * control block. Otherwise, check again in a bit. 181 */ 182 if (tp->t_state != TCPS_TIME_WAIT && 183 (ticks - tp->t_rcvtime) <= tcp_maxidle) 184 callout_reset(tp->tt_2msl, tcp_keepintvl, 185 tcp_timer_2msl, tp); 186 else 187 tp = tcp_close(tp); 188 189#ifdef TCPDEBUG 190 if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG)) 191 tcp_trace(TA_USER, ostate, tp, (struct tcpiphdr *)0, 192 PRU_SLOWTIMO); 193#endif 194 splx(s); 195} 196 197void 198tcp_timer_keep(xtp) 199 void *xtp; 200{ 201 struct tcpcb *tp = xtp; 202 int s; 203#ifdef TCPDEBUG 204 int ostate; 205 206 ostate = tp->t_state; 207#endif 208 s = splnet(); 209 if (callout_pending(tp->tt_keep)) { 210 splx(s); 211 return; 212 } 213 callout_deactivate(tp->tt_keep); 214 /* 215 * Keep-alive timer went off; send something 216 * or drop connection if idle for too long. 217 */ 218 tcpstat.tcps_keeptimeo++; 219 if (tp->t_state < TCPS_ESTABLISHED) 220 goto dropit; 221 if ((always_keepalive || 222 tp->t_inpcb->inp_socket->so_options & SO_KEEPALIVE) && 223 tp->t_state <= TCPS_CLOSING) { 224 if ((ticks - tp->t_rcvtime) >= tcp_keepidle + tcp_maxidle) 225 goto dropit; 226 /* 227 * Send a packet designed to force a response 228 * if the peer is up and reachable: 229 * either an ACK if the connection is still alive, 230 * or an RST if the peer has closed the connection 231 * due to timeout or reboot. 232 * Using sequence number tp->snd_una-1 233 * causes the transmitted zero-length segment 234 * to lie outside the receive window; 235 * by the protocol spec, this requires the 236 * correspondent TCP to respond. 237 */ 238 tcpstat.tcps_keepprobe++; 239#ifdef TCP_COMPAT_42 240 /* 241 * The keepalive packet must have nonzero length 242 * to get a 4.2 host to respond. 243 */ 244 tcp_respond(tp, tp->t_template, (struct mbuf *)NULL, 245 tp->rcv_nxt - 1, tp->snd_una - 1, 0); 246#else 247 tcp_respond(tp, tp->t_template, (struct mbuf *)NULL, 248 tp->rcv_nxt, tp->snd_una - 1, 0); 249#endif 250 callout_reset(tp->tt_keep, tcp_keepintvl, tcp_timer_keep, tp); 251 } else 252 callout_reset(tp->tt_keep, tcp_keepidle, tcp_timer_keep, tp); 253 254#ifdef TCPDEBUG 255 if (tp->t_inpcb->inp_socket->so_options & SO_DEBUG) 256 tcp_trace(TA_USER, ostate, tp, (struct tcpiphdr *)0, 257 PRU_SLOWTIMO); 258#endif 259 splx(s); 260 return; 261 262dropit: 263 tcpstat.tcps_keepdrops++; 264 tp = tcp_drop(tp, ETIMEDOUT); 265 266#ifdef TCPDEBUG 267 if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG)) 268 tcp_trace(TA_USER, ostate, tp, (struct tcpiphdr *)0, 269 PRU_SLOWTIMO); 270#endif 271 splx(s); 272} 273 274void 275tcp_timer_persist(xtp) 276 void *xtp; 277{ 278 struct tcpcb *tp = xtp; 279 int s; 280#ifdef TCPDEBUG 281 int ostate; 282 283 ostate = tp->t_state; 284#endif 285 s = splnet(); 286 if (callout_pending(tp->tt_persist)) { 287 splx(s); 288 return; 289 } 290 callout_deactivate(tp->tt_persist); 291 /* 292 * Persistance timer into zero window. 293 * Force a byte to be output, if possible. 294 */ 295 tcpstat.tcps_persisttimeo++; 296 /* 297 * Hack: if the peer is dead/unreachable, we do not 298 * time out if the window is closed. After a full 299 * backoff, drop the connection if the idle time 300 * (no responses to probes) reaches the maximum 301 * backoff that we would use if retransmitting. 302 */ 303 if (tp->t_rxtshift == TCP_MAXRXTSHIFT && 304 ((ticks - tp->t_rcvtime) >= tcp_maxpersistidle || 305 (ticks - tp->t_rcvtime) >= TCP_REXMTVAL(tp) * tcp_totbackoff)) { 306 tcpstat.tcps_persistdrop++; 307 tp = tcp_drop(tp, ETIMEDOUT); 308 goto out; 309 } 310 tcp_setpersist(tp); 311 tp->t_force = 1; 312 (void) tcp_output(tp); 313 tp->t_force = 0; 314 315out: 316#ifdef TCPDEBUG 317 if (tp->t_inpcb->inp_socket->so_options & SO_DEBUG) 318 tcp_trace(TA_USER, ostate, tp, (struct tcpiphdr *)0, 319 PRU_SLOWTIMO); 320#endif 321 splx(s); 322} 323 324void 325tcp_timer_rexmt(xtp) 326 void *xtp; 327{ 328 struct tcpcb *tp = xtp; 329 int s; 330 int rexmt; 331#ifdef TCPDEBUG 332 int ostate; 333 334 ostate = tp->t_state; 335#endif 336 s = splnet(); 337 if (callout_pending(tp->tt_rexmt)) { 338 splx(s); 339 return; 340 } 341 callout_deactivate(tp->tt_rexmt); 342 /* 343 * Retransmission timer went off. Message has not 344 * been acked within retransmit interval. Back off 345 * to a longer retransmit interval and retransmit one segment. 346 */ 347 if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) { 348 tp->t_rxtshift = TCP_MAXRXTSHIFT; 349 tcpstat.tcps_timeoutdrop++; 350 tp = tcp_drop(tp, tp->t_softerror ? 351 tp->t_softerror : ETIMEDOUT); 352 goto out; 353 } 354 if (tp->t_rxtshift == 1) { 355 /* 356 * first retransmit; record ssthresh and cwnd so they can 357 * be recovered if this turns out to be a "bad" retransmit. 358 * A retransmit is considered "bad" if an ACK for this 359 * segment is received within RTT/2 interval; the assumption 360 * here is that the ACK was already in flight. See 361 * "On Estimating End-to-End Network Path Properties" by 362 * Allman and Paxson for more details. 363 */ 364 tp->snd_cwnd_prev = tp->snd_cwnd; 365 tp->snd_ssthresh_prev = tp->snd_ssthresh; 366 tp->t_badrxtwin = ticks + (tp->t_srtt >> (TCP_RTT_SHIFT + 1)); 367 } 368 tcpstat.tcps_rexmttimeo++; 369 rexmt = TCP_REXMTVAL(tp) * tcp_backoff[tp->t_rxtshift]; 370 TCPT_RANGESET(tp->t_rxtcur, rexmt, 371 tp->t_rttmin, TCPTV_REXMTMAX); 372 /* 373 * If losing, let the lower level know and try for 374 * a better route. Also, if we backed off this far, 375 * our srtt estimate is probably bogus. Clobber it 376 * so we'll take the next rtt measurement as our srtt; 377 * move the current srtt into rttvar to keep the current 378 * retransmit times until then. 379 */ 380 if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) { 381 in_losing(tp->t_inpcb); 382 tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT); 383 tp->t_srtt = 0; 384 } 385 tp->snd_nxt = tp->snd_una; 386 /* 387 * Force a segment to be sent. 388 */ 389 tp->t_flags |= TF_ACKNOW; 390 /* 391 * If timing a segment in this window, stop the timer. 392 */ 393 tp->t_rtttime = 0; 394 /* 395 * Close the congestion window down to one segment 396 * (we'll open it by one segment for each ack we get). 397 * Since we probably have a window's worth of unacked 398 * data accumulated, this "slow start" keeps us from 399 * dumping all that data as back-to-back packets (which 400 * might overwhelm an intermediate gateway). 401 * 402 * There are two phases to the opening: Initially we 403 * open by one mss on each ack. This makes the window 404 * size increase exponentially with time. If the 405 * window is larger than the path can handle, this 406 * exponential growth results in dropped packet(s) 407 * almost immediately. To get more time between 408 * drops but still "push" the network to take advantage 409 * of improving conditions, we switch from exponential 410 * to linear window opening at some threshhold size. 411 * For a threshhold, we use half the current window 412 * size, truncated to a multiple of the mss. 413 * 414 * (the minimum cwnd that will give us exponential 415 * growth is 2 mss. We don't allow the threshhold 416 * to go below this.) 417 */ 418 { 419 u_int win = min(tp->snd_wnd, tp->snd_cwnd) / 2 / tp->t_maxseg; 420 if (win < 2) 421 win = 2; 422 tp->snd_cwnd = tp->t_maxseg; 423 tp->snd_ssthresh = win * tp->t_maxseg; 424 tp->t_dupacks = 0; 425 } 426 (void) tcp_output(tp); 427 428out: 429#ifdef TCPDEBUG 430 if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG)) 431 tcp_trace(TA_USER, ostate, tp, (struct tcpiphdr *)0, 432 PRU_SLOWTIMO); 433#endif 434 splx(s); 435} 436