xref: /openbsd-src/sys/netinet/tcp_timer.c (revision 91f110e064cd7c194e59e019b83bb7496c1c84d4) 
1 /*	$OpenBSD: tcp_timer.c,v 1.47 2013/08/08 14:29:29 mpi Exp $	*/
2 /*	$NetBSD: tcp_timer.c,v 1.14 1996/02/13 23:44:09 christos Exp $	*/
3 
4 /*
5  * Copyright (c) 1982, 1986, 1988, 1990, 1993
6  *	The Regents of the University of California.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  *	@(#)tcp_timer.c	8.1 (Berkeley) 6/10/93
33  */
34 
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/mbuf.h>
38 #include <sys/socket.h>
39 #include <sys/socketvar.h>
40 #include <sys/protosw.h>
41 #include <sys/kernel.h>
42 #include <sys/pool.h>
43 
44 #include <net/route.h>
45 
46 #include <netinet/in.h>
47 #include <netinet/in_systm.h>
48 #include <netinet/ip.h>
49 #include <netinet/in_pcb.h>
50 #include <netinet/ip_var.h>
51 #include <netinet/tcp.h>
52 #include <netinet/tcp_fsm.h>
53 #include <netinet/tcp_timer.h>
54 #include <netinet/tcp_var.h>
55 #include <netinet/ip_icmp.h>
56 #include <netinet/tcp_seq.h>
57 
58 int	tcp_always_keepalive;
59 int	tcp_keepidle;
60 int	tcp_keepintvl;
61 int	tcp_maxpersistidle;	/* max idle time in persist */
62 int	tcp_maxidle;
63 
64 /*
65  * Time to delay the ACK.  This is initialized in tcp_init(), unless
66  * its patched.
67  */
68 int	tcp_delack_ticks;
69 
70 void	tcp_timer_rexmt(void *);
71 void	tcp_timer_persist(void *);
72 void	tcp_timer_keep(void *);
73 void	tcp_timer_2msl(void *);
74 
75 const tcp_timer_func_t tcp_timer_funcs[TCPT_NTIMERS] = {
76 	tcp_timer_rexmt,
77 	tcp_timer_persist,
78 	tcp_timer_keep,
79 	tcp_timer_2msl,
80 };
81 
82 /*
83  * Timer state initialization, called from tcp_init().
84  */
85 void
86 tcp_timer_init(void)
87 {
88 
89 	if (tcp_keepidle == 0)
90 		tcp_keepidle = TCPTV_KEEP_IDLE;
91 
92 	if (tcp_keepintvl == 0)
93 		tcp_keepintvl = TCPTV_KEEPINTVL;
94 
95 	if (tcp_maxpersistidle == 0)
96 		tcp_maxpersistidle = TCPTV_KEEP_IDLE;
97 
98 	if (tcp_delack_ticks == 0)
99 		tcp_delack_ticks = TCP_DELACK_TICKS;
100 }
101 
102 /*
103  * Callout to process delayed ACKs for a TCPCB.
104  */
105 void
106 tcp_delack(void *arg)
107 {
108 	struct tcpcb *tp = arg;
109 	int s;
110 
111 	/*
112 	 * If tcp_output() wasn't able to transmit the ACK
113 	 * for whatever reason, it will restart the delayed
114 	 * ACK callout.
115 	 */
116 
117 	s = splsoftnet();
118 	if (tp->t_flags & TF_DEAD) {
119 		splx(s);
120 		return;
121 	}
122 	tp->t_flags |= TF_ACKNOW;
123 	(void) tcp_output(tp);
124 	splx(s);
125 }
126 
127 /*
128  * Tcp protocol timeout routine called every 500 ms.
129  * Updates the timers in all active tcb's and
130  * causes finite state machine actions if timers expire.
131  */
132 void
133 tcp_slowtimo()
134 {
135 	int s;
136 
137 	s = splsoftnet();
138 	tcp_maxidle = TCPTV_KEEPCNT * tcp_keepintvl;
139 	tcp_iss += TCP_ISSINCR2/PR_SLOWHZ;		/* increment iss */
140 	tcp_now++;					/* for timestamps */
141 	splx(s);
142 }
143 
144 /*
145  * Cancel all timers for TCP tp.
146  */
147 void
148 tcp_canceltimers(tp)
149 	struct tcpcb *tp;
150 {
151 	int i;
152 
153 	for (i = 0; i < TCPT_NTIMERS; i++)
154 		TCP_TIMER_DISARM(tp, i);
155 }
156 
157 int	tcp_backoff[TCP_MAXRXTSHIFT + 1] =
158     { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };
159 
160 int tcp_totbackoff = 511;	/* sum of tcp_backoff[] */
161 
162 /*
163  * TCP timer processing.
164  */
165 
166 #ifdef TCP_SACK
167 void	tcp_timer_freesack(struct tcpcb *);
168 
169 void
170 tcp_timer_freesack(struct tcpcb *tp)
171 {
172 	struct sackhole *p, *q;
173 	/*
174 	 * Free SACK holes for 2MSL and REXMT timers.
175 	 */
176 	q = tp->snd_holes;
177 	while (q != NULL) {
178 		p = q;
179 		q = q->next;
180 		pool_put(&sackhl_pool, p);
181 	}
182 	tp->snd_holes = 0;
183 #ifdef TCP_FACK
184 	tp->snd_fack = tp->snd_una;
185 	tp->retran_data = 0;
186 	tp->snd_awnd = 0;
187 #endif /* TCP_FACK */
188 }
189 #endif /* TCP_SACK */
190 
191 void
192 tcp_timer_rexmt(void *arg)
193 {
194 	struct tcpcb *tp = arg;
195 	uint32_t rto;
196 	int s;
197 
198 	s = splsoftnet();
199 	if (tp->t_flags & TF_DEAD) {
200 		splx(s);
201 		return;
202 	}
203 
204 	if ((tp->t_flags & TF_PMTUD_PEND) && tp->t_inpcb &&
205 	    SEQ_GEQ(tp->t_pmtud_th_seq, tp->snd_una) &&
206 	    SEQ_LT(tp->t_pmtud_th_seq, (int)(tp->snd_una + tp->t_maxseg))) {
207 		struct sockaddr_in sin;
208 		struct icmp icmp;
209 
210 		tp->t_flags &= ~TF_PMTUD_PEND;
211 
212 		/* XXX create fake icmp message with relevant entries */
213 		icmp.icmp_nextmtu = tp->t_pmtud_nextmtu;
214 		icmp.icmp_ip.ip_len = tp->t_pmtud_ip_len;
215 		icmp.icmp_ip.ip_hl = tp->t_pmtud_ip_hl;
216 		icmp.icmp_ip.ip_dst = tp->t_inpcb->inp_faddr;
217 		icmp_mtudisc(&icmp, tp->t_inpcb->inp_rtableid);
218 
219 		/*
220 		 * Notify all connections to the same peer about
221 		 * new mss and trigger retransmit.
222 		 */
223 		bzero(&sin, sizeof(sin));
224 		sin.sin_len = sizeof(sin);
225 		sin.sin_family = AF_INET;
226 		sin.sin_addr = tp->t_inpcb->inp_faddr;
227 		in_pcbnotifyall(&tcbtable, sintosa(&sin),
228 		    tp->t_inpcb->inp_rtableid, EMSGSIZE, tcp_mtudisc);
229 		splx(s);
230 		return;
231 	}
232 
233 #ifdef TCP_SACK
234 	tcp_timer_freesack(tp);
235 #endif
236 	if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {
237 		tp->t_rxtshift = TCP_MAXRXTSHIFT;
238 		tcpstat.tcps_timeoutdrop++;
239 		(void)tcp_drop(tp, tp->t_softerror ?
240 		    tp->t_softerror : ETIMEDOUT);
241 		goto out;
242 	}
243 	tcpstat.tcps_rexmttimeo++;
244 	rto = TCP_REXMTVAL(tp);
245 	if (rto < tp->t_rttmin)
246 		rto = tp->t_rttmin;
247 	TCPT_RANGESET(tp->t_rxtcur,
248 	    rto * tcp_backoff[tp->t_rxtshift],
249 	    tp->t_rttmin, TCPTV_REXMTMAX);
250 	TCP_TIMER_ARM(tp, TCPT_REXMT, tp->t_rxtcur);
251 
252 	/*
253 	 * If we are losing and we are trying path MTU discovery,
254 	 * try turning it off.  This will avoid black holes in
255 	 * the network which suppress or fail to send "packet
256 	 * too big" ICMP messages.  We should ideally do
257 	 * lots more sophisticated searching to find the right
258 	 * value here...
259 	 */
260 	if (ip_mtudisc && tp->t_inpcb &&
261 	    TCPS_HAVEESTABLISHED(tp->t_state) &&
262 	    tp->t_rxtshift > TCP_MAXRXTSHIFT / 6) {
263 		struct inpcb *inp = tp->t_inpcb;
264 		struct rtentry *rt = NULL;
265 
266 		/* No data to send means path mtu is not a problem */
267 		if (!inp->inp_socket->so_snd.sb_cc)
268 			goto leave;
269 
270 		rt = in_pcbrtentry(inp);
271 		/* Check if path MTU discovery is disabled already */
272 		if (rt && (rt->rt_flags & RTF_HOST) &&
273 		    (rt->rt_rmx.rmx_locks & RTV_MTU))
274 			goto leave;
275 
276 		rt = NULL;
277 		switch(tp->pf) {
278 #ifdef INET6
279 		case PF_INET6:
280 			/*
281 			 * We can not turn off path MTU for IPv6.
282 			 * Do nothing for now, maybe lower to
283 			 * minimum MTU.
284 			 */
285 			break;
286 #endif
287 		case PF_INET:
288 			rt = icmp_mtudisc_clone(inp->inp_faddr,
289 			    inp->inp_rtableid);
290 			break;
291 		}
292 		if (rt != NULL) {
293 			/* Disable path MTU discovery */
294 			if ((rt->rt_rmx.rmx_locks & RTV_MTU) == 0) {
295 				rt->rt_rmx.rmx_locks |= RTV_MTU;
296 				in_rtchange(inp, 0);
297 			}
298 
299 			rtfree(rt);
300 		}
301 	leave:
302 		;
303 	}
304 
305 	/*
306 	 * If losing, let the lower level know and try for
307 	 * a better route.  Also, if we backed off this far,
308 	 * our srtt estimate is probably bogus.  Clobber it
309 	 * so we'll take the next rtt measurement as our srtt;
310 	 * move the current srtt into rttvar to keep the current
311 	 * retransmit times until then.
312 	 */
313 	if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) {
314 		in_losing(tp->t_inpcb);
315 		tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT);
316 		tp->t_srtt = 0;
317 	}
318 	tp->snd_nxt = tp->snd_una;
319 #if defined(TCP_SACK)
320 	/*
321 	 * Note:  We overload snd_last to function also as the
322 	 * snd_last variable described in RFC 2582
323 	 */
324 	tp->snd_last = tp->snd_max;
325 #endif /* TCP_SACK */
326 	/*
327 	 * If timing a segment in this window, stop the timer.
328 	 */
329 	tp->t_rtttime = 0;
330 #ifdef TCP_ECN
331 	/*
332 	 * if ECN is enabled, there might be a broken firewall which
333 	 * blocks ecn packets.  fall back to non-ecn.
334 	 */
335 	if ((tp->t_state == TCPS_SYN_SENT || tp->t_state == TCPS_SYN_RECEIVED)
336 	    && tcp_do_ecn && !(tp->t_flags & TF_DISABLE_ECN))
337 		tp->t_flags |= TF_DISABLE_ECN;
338 #endif
339 	/*
340 	 * Close the congestion window down to one segment
341 	 * (we'll open it by one segment for each ack we get).
342 	 * Since we probably have a window's worth of unacked
343 	 * data accumulated, this "slow start" keeps us from
344 	 * dumping all that data as back-to-back packets (which
345 	 * might overwhelm an intermediate gateway).
346 	 *
347 	 * There are two phases to the opening: Initially we
348 	 * open by one mss on each ack.  This makes the window
349 	 * size increase exponentially with time.  If the
350 	 * window is larger than the path can handle, this
351 	 * exponential growth results in dropped packet(s)
352 	 * almost immediately.  To get more time between
353 	 * drops but still "push" the network to take advantage
354 	 * of improving conditions, we switch from exponential
355 	 * to linear window opening at some threshold size.
356 	 * For a threshold, we use half the current window
357 	 * size, truncated to a multiple of the mss.
358 	 *
359 	 * (the minimum cwnd that will give us exponential
360 	 * growth is 2 mss.  We don't allow the threshold
361 	 * to go below this.)
362 	 */
363 	{
364 		u_long win = ulmin(tp->snd_wnd, tp->snd_cwnd) / 2 / tp->t_maxseg;
365 		if (win < 2)
366 			win = 2;
367 		tp->snd_cwnd = tp->t_maxseg;
368 		tp->snd_ssthresh = win * tp->t_maxseg;
369 		tp->t_dupacks = 0;
370 #ifdef TCP_ECN
371 		tp->snd_last = tp->snd_max;
372 		tp->t_flags |= TF_SEND_CWR;
373 #endif
374 #if 1 /* TCP_ECN */
375 		tcpstat.tcps_cwr_timeout++;
376 #endif
377 	}
378 	(void) tcp_output(tp);
379 
380  out:
381 	splx(s);
382 }
383 
384 void
385 tcp_timer_persist(void *arg)
386 {
387 	struct tcpcb *tp = arg;
388 	uint32_t rto;
389 	int s;
390 
391 	s = splsoftnet();
392 	if ((tp->t_flags & TF_DEAD) ||
393             TCP_TIMER_ISARMED(tp, TCPT_REXMT)) {
394 		splx(s);
395 		return;
396 	}
397 	tcpstat.tcps_persisttimeo++;
398 	/*
399 	 * Hack: if the peer is dead/unreachable, we do not
400 	 * time out if the window is closed.  After a full
401 	 * backoff, drop the connection if the idle time
402 	 * (no responses to probes) reaches the maximum
403 	 * backoff that we would use if retransmitting.
404 	 */
405 	rto = TCP_REXMTVAL(tp);
406 	if (rto < tp->t_rttmin)
407 		rto = tp->t_rttmin;
408 	if (tp->t_rxtshift == TCP_MAXRXTSHIFT &&
409 	    ((tcp_now - tp->t_rcvtime) >= tcp_maxpersistidle ||
410 	    (tcp_now - tp->t_rcvtime) >= rto * tcp_totbackoff)) {
411 		tcpstat.tcps_persistdrop++;
412 		tp = tcp_drop(tp, ETIMEDOUT);
413 		goto out;
414 	}
415 	tcp_setpersist(tp);
416 	tp->t_force = 1;
417 	(void) tcp_output(tp);
418 	tp->t_force = 0;
419  out:
420 	splx(s);
421 }
422 
423 void
424 tcp_timer_keep(void *arg)
425 {
426 	struct tcpcb *tp = arg;
427 	int s;
428 
429 	s = splsoftnet();
430 	if (tp->t_flags & TF_DEAD) {
431 		splx(s);
432 		return;
433 	}
434 
435 	tcpstat.tcps_keeptimeo++;
436 	if (TCPS_HAVEESTABLISHED(tp->t_state) == 0)
437 		goto dropit;
438 	if ((tcp_always_keepalive ||
439 	    tp->t_inpcb->inp_socket->so_options & SO_KEEPALIVE) &&
440 	    tp->t_state <= TCPS_CLOSING) {
441 		if ((tcp_maxidle > 0) &&
442 		    ((tcp_now - tp->t_rcvtime) >= tcp_keepidle + tcp_maxidle))
443 			goto dropit;
444 		/*
445 		 * Send a packet designed to force a response
446 		 * if the peer is up and reachable:
447 		 * either an ACK if the connection is still alive,
448 		 * or an RST if the peer has closed the connection
449 		 * due to timeout or reboot.
450 		 * Using sequence number tp->snd_una-1
451 		 * causes the transmitted zero-length segment
452 		 * to lie outside the receive window;
453 		 * by the protocol spec, this requires the
454 		 * correspondent TCP to respond.
455 		 */
456 		tcpstat.tcps_keepprobe++;
457 		tcp_respond(tp, mtod(tp->t_template, caddr_t),
458 		    NULL, tp->rcv_nxt, tp->snd_una - 1, 0, 0);
459 		TCP_TIMER_ARM(tp, TCPT_KEEP, tcp_keepintvl);
460 	} else
461 		TCP_TIMER_ARM(tp, TCPT_KEEP, tcp_keepidle);
462 
463 	splx(s);
464 	return;
465 
466  dropit:
467 	tcpstat.tcps_keepdrops++;
468 	tp = tcp_drop(tp, ETIMEDOUT);
469 
470 	splx(s);
471 }
472 
473 void
474 tcp_timer_2msl(void *arg)
475 {
476 	struct tcpcb *tp = arg;
477 	int s;
478 
479 	s = splsoftnet();
480 	if (tp->t_flags & TF_DEAD) {
481 		splx(s);
482 		return;
483 	}
484 
485 #ifdef TCP_SACK
486 	tcp_timer_freesack(tp);
487 #endif
488 
489 	if (tp->t_state != TCPS_TIME_WAIT &&
490 	    ((tcp_maxidle == 0) || ((tcp_now - tp->t_rcvtime) <= tcp_maxidle)))
491 		TCP_TIMER_ARM(tp, TCPT_2MSL, tcp_keepintvl);
492 	else
493 		tp = tcp_close(tp);
494 
495 	splx(s);
496 }
497