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