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 * $Id: tcp_timer.c,v 1.27 1998/04/06 06:52:46 phk Exp $ 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 66 int tcp_keepinit = TCPTV_KEEP_INIT; 67 SYSCTL_INT(_net_inet_tcp, TCPCTL_KEEPINIT, keepinit, 68 CTLFLAG_RW, &tcp_keepinit , 0, ""); 69 70 int tcp_keepidle = TCPTV_KEEP_IDLE; 71 SYSCTL_INT(_net_inet_tcp, TCPCTL_KEEPIDLE, keepidle, 72 CTLFLAG_RW, &tcp_keepidle , 0, ""); 73 74 static int tcp_keepintvl = TCPTV_KEEPINTVL; 75 SYSCTL_INT(_net_inet_tcp, TCPCTL_KEEPINTVL, keepintvl, 76 CTLFLAG_RW, &tcp_keepintvl , 0, ""); 77 78 static int always_keepalive = 0; 79 SYSCTL_INT(_net_inet_tcp, OID_AUTO, always_keepalive, 80 CTLFLAG_RW, &always_keepalive , 0, ""); 81 82 static int tcp_keepcnt = TCPTV_KEEPCNT; 83 /* max idle probes */ 84 static int tcp_maxpersistidle = TCPTV_KEEP_IDLE; 85 /* max idle time in persist */ 86 int tcp_maxidle; 87 88 /* 89 * Fast timeout routine for processing delayed acks 90 */ 91 void 92 tcp_fasttimo() 93 { 94 register struct inpcb *inp; 95 register struct tcpcb *tp; 96 int s; 97 98 if (tcp_delack_enabled) { 99 s = splnet(); 100 for (inp = tcb.lh_first; inp != NULL; inp = inp->inp_list.le_next) { 101 if ((tp = (struct tcpcb *)inp->inp_ppcb) && 102 (tp->t_flags & TF_DELACK)) { 103 tp->t_flags &= ~TF_DELACK; 104 tp->t_flags |= TF_ACKNOW; 105 tcpstat.tcps_delack++; 106 (void) tcp_output(tp); 107 } 108 } 109 splx(s); 110 } 111 } 112 113 /* 114 * Tcp protocol timeout routine called every 500 ms. 115 * Updates the timers in all active tcb's and 116 * causes finite state machine actions if timers expire. 117 */ 118 void 119 tcp_slowtimo() 120 { 121 register struct inpcb *ip, *ipnxt; 122 register struct tcpcb *tp; 123 register int i; 124 int s; 125 #ifdef TCPDEBUG 126 int ostate; 127 #endif 128 129 s = splnet(); 130 131 tcp_maxidle = tcp_keepcnt * tcp_keepintvl; 132 133 ip = tcb.lh_first; 134 if (ip == NULL) { 135 splx(s); 136 return; 137 } 138 /* 139 * Search through tcb's and update active timers. 140 */ 141 for (; ip != NULL; ip = ipnxt) { 142 ipnxt = ip->inp_list.le_next; 143 tp = intotcpcb(ip); 144 if (tp == 0 || tp->t_state == TCPS_LISTEN) 145 continue; 146 for (i = 0; i < TCPT_NTIMERS; i++) { 147 if (tp->t_timer[i] && --tp->t_timer[i] == 0) { 148 #ifdef TCPDEBUG 149 ostate = tp->t_state; 150 #endif 151 tp = tcp_timers(tp, i); 152 if (tp == NULL) 153 goto tpgone; 154 #ifdef TCPDEBUG 155 if (tp->t_inpcb->inp_socket->so_options 156 & SO_DEBUG) 157 tcp_trace(TA_USER, ostate, tp, 158 (struct tcpiphdr *)0, 159 PRU_SLOWTIMO); 160 #endif 161 } 162 } 163 tp->t_idle++; 164 tp->t_duration++; 165 if (tp->t_rtt) 166 tp->t_rtt++; 167 tpgone: 168 ; 169 } 170 tcp_iss += TCP_ISSINCR/PR_SLOWHZ; /* increment iss */ 171 #ifdef TCP_COMPAT_42 172 if ((int)tcp_iss < 0) 173 tcp_iss = TCP_ISSINCR; /* XXX */ 174 #endif 175 tcp_now++; /* for timestamps */ 176 splx(s); 177 } 178 179 /* 180 * Cancel all timers for TCP tp. 181 */ 182 void 183 tcp_canceltimers(tp) 184 struct tcpcb *tp; 185 { 186 register int i; 187 188 for (i = 0; i < TCPT_NTIMERS; i++) 189 tp->t_timer[i] = 0; 190 } 191 192 int tcp_backoff[TCP_MAXRXTSHIFT + 1] = 193 { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 }; 194 195 static int tcp_totbackoff = 511; /* sum of tcp_backoff[] */ 196 197 /* 198 * TCP timer processing. 199 */ 200 struct tcpcb * 201 tcp_timers(tp, timer) 202 register struct tcpcb *tp; 203 int timer; 204 { 205 register int rexmt; 206 207 switch (timer) { 208 209 /* 210 * 2 MSL timeout in shutdown went off. If we're closed but 211 * still waiting for peer to close and connection has been idle 212 * too long, or if 2MSL time is up from TIME_WAIT, delete connection 213 * control block. Otherwise, check again in a bit. 214 */ 215 case TCPT_2MSL: 216 if (tp->t_state != TCPS_TIME_WAIT && 217 tp->t_idle <= tcp_maxidle) 218 tp->t_timer[TCPT_2MSL] = tcp_keepintvl; 219 else 220 tp = tcp_close(tp); 221 break; 222 223 /* 224 * Retransmission timer went off. Message has not 225 * been acked within retransmit interval. Back off 226 * to a longer retransmit interval and retransmit one segment. 227 */ 228 case TCPT_REXMT: 229 if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) { 230 tp->t_rxtshift = TCP_MAXRXTSHIFT; 231 tcpstat.tcps_timeoutdrop++; 232 tp = tcp_drop(tp, tp->t_softerror ? 233 tp->t_softerror : ETIMEDOUT); 234 break; 235 } 236 tcpstat.tcps_rexmttimeo++; 237 rexmt = TCP_REXMTVAL(tp) * tcp_backoff[tp->t_rxtshift]; 238 TCPT_RANGESET(tp->t_rxtcur, rexmt, 239 tp->t_rttmin, TCPTV_REXMTMAX); 240 tp->t_timer[TCPT_REXMT] = tp->t_rxtcur; 241 /* 242 * If losing, let the lower level know and try for 243 * a better route. Also, if we backed off this far, 244 * our srtt estimate is probably bogus. Clobber it 245 * so we'll take the next rtt measurement as our srtt; 246 * move the current srtt into rttvar to keep the current 247 * retransmit times until then. 248 */ 249 if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) { 250 in_losing(tp->t_inpcb); 251 tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT); 252 tp->t_srtt = 0; 253 } 254 tp->snd_nxt = tp->snd_una; 255 /* 256 * Force a segment to be sent. 257 */ 258 tp->t_flags |= TF_ACKNOW; 259 /* 260 * If timing a segment in this window, stop the timer. 261 */ 262 tp->t_rtt = 0; 263 /* 264 * Close the congestion window down to one segment 265 * (we'll open it by one segment for each ack we get). 266 * Since we probably have a window's worth of unacked 267 * data accumulated, this "slow start" keeps us from 268 * dumping all that data as back-to-back packets (which 269 * might overwhelm an intermediate gateway). 270 * 271 * There are two phases to the opening: Initially we 272 * open by one mss on each ack. This makes the window 273 * size increase exponentially with time. If the 274 * window is larger than the path can handle, this 275 * exponential growth results in dropped packet(s) 276 * almost immediately. To get more time between 277 * drops but still "push" the network to take advantage 278 * of improving conditions, we switch from exponential 279 * to linear window opening at some threshhold size. 280 * For a threshhold, we use half the current window 281 * size, truncated to a multiple of the mss. 282 * 283 * (the minimum cwnd that will give us exponential 284 * growth is 2 mss. We don't allow the threshhold 285 * to go below this.) 286 */ 287 { 288 u_int win = min(tp->snd_wnd, tp->snd_cwnd) / 2 / tp->t_maxseg; 289 if (win < 2) 290 win = 2; 291 tp->snd_cwnd = tp->t_maxseg; 292 tp->snd_ssthresh = win * tp->t_maxseg; 293 tp->t_dupacks = 0; 294 } 295 (void) tcp_output(tp); 296 break; 297 298 /* 299 * Persistance timer into zero window. 300 * Force a byte to be output, if possible. 301 */ 302 case TCPT_PERSIST: 303 tcpstat.tcps_persisttimeo++; 304 /* 305 * Hack: if the peer is dead/unreachable, we do not 306 * time out if the window is closed. After a full 307 * backoff, drop the connection if the idle time 308 * (no responses to probes) reaches the maximum 309 * backoff that we would use if retransmitting. 310 */ 311 if (tp->t_rxtshift == TCP_MAXRXTSHIFT && 312 (tp->t_idle >= tcp_maxpersistidle || 313 tp->t_idle >= TCP_REXMTVAL(tp) * tcp_totbackoff)) { 314 tcpstat.tcps_persistdrop++; 315 tp = tcp_drop(tp, ETIMEDOUT); 316 break; 317 } 318 tcp_setpersist(tp); 319 tp->t_force = 1; 320 (void) tcp_output(tp); 321 tp->t_force = 0; 322 break; 323 324 /* 325 * Keep-alive timer went off; send something 326 * or drop connection if idle for too long. 327 */ 328 case TCPT_KEEP: 329 tcpstat.tcps_keeptimeo++; 330 if (tp->t_state < TCPS_ESTABLISHED) 331 goto dropit; 332 if ((always_keepalive || 333 tp->t_inpcb->inp_socket->so_options & SO_KEEPALIVE) && 334 tp->t_state <= TCPS_CLOSING) { 335 if (tp->t_idle >= tcp_keepidle + tcp_maxidle) 336 goto dropit; 337 /* 338 * Send a packet designed to force a response 339 * if the peer is up and reachable: 340 * either an ACK if the connection is still alive, 341 * or an RST if the peer has closed the connection 342 * due to timeout or reboot. 343 * Using sequence number tp->snd_una-1 344 * causes the transmitted zero-length segment 345 * to lie outside the receive window; 346 * by the protocol spec, this requires the 347 * correspondent TCP to respond. 348 */ 349 tcpstat.tcps_keepprobe++; 350 #ifdef TCP_COMPAT_42 351 /* 352 * The keepalive packet must have nonzero length 353 * to get a 4.2 host to respond. 354 */ 355 tcp_respond(tp, tp->t_template, (struct mbuf *)NULL, 356 tp->rcv_nxt - 1, tp->snd_una - 1, 0); 357 #else 358 tcp_respond(tp, tp->t_template, (struct mbuf *)NULL, 359 tp->rcv_nxt, tp->snd_una - 1, 0); 360 #endif 361 tp->t_timer[TCPT_KEEP] = tcp_keepintvl; 362 } else 363 tp->t_timer[TCPT_KEEP] = tcp_keepidle; 364 break; 365 dropit: 366 tcpstat.tcps_keepdrops++; 367 tp = tcp_drop(tp, ETIMEDOUT); 368 break; 369 } 370 return (tp); 371 } 372