Annotation of sys/netinet/tcp_timer.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: tcp_timer.c,v 1.39 2007/06/15 18:23:07 markus 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:
43: #include <net/route.h>
44:
45: #include <netinet/in.h>
46: #include <netinet/in_systm.h>
47: #include <netinet/ip.h>
48: #include <netinet/in_pcb.h>
49: #include <netinet/ip_var.h>
50: #include <netinet/tcp.h>
51: #include <netinet/tcp_fsm.h>
52: #include <netinet/tcp_timer.h>
53: #include <netinet/tcp_var.h>
54: #include <netinet/ip_icmp.h>
55: #include <netinet/tcp_seq.h>
56:
57: int tcp_keepidle;
58: int tcp_keepintvl;
59: int tcp_maxpersistidle; /* max idle time in persist */
60: int tcp_maxidle;
61:
62: /*
63: * Time to delay the ACK. This is initialized in tcp_init(), unless
64: * its patched.
65: */
66: int tcp_delack_ticks;
67:
68: void tcp_timer_rexmt(void *);
69: void tcp_timer_persist(void *);
70: void tcp_timer_keep(void *);
71: void tcp_timer_2msl(void *);
72:
73: const tcp_timer_func_t tcp_timer_funcs[TCPT_NTIMERS] = {
74: tcp_timer_rexmt,
75: tcp_timer_persist,
76: tcp_timer_keep,
77: tcp_timer_2msl,
78: };
79:
80: /*
81: * Timer state initialization, called from tcp_init().
82: */
83: void
84: tcp_timer_init(void)
85: {
86:
87: if (tcp_keepidle == 0)
88: tcp_keepidle = TCPTV_KEEP_IDLE;
89:
90: if (tcp_keepintvl == 0)
91: tcp_keepintvl = TCPTV_KEEPINTVL;
92:
93: if (tcp_maxpersistidle == 0)
94: tcp_maxpersistidle = TCPTV_KEEP_IDLE;
95:
96: if (tcp_delack_ticks == 0)
97: tcp_delack_ticks = TCP_DELACK_TICKS;
98: }
99:
100: /*
101: * Callout to process delayed ACKs for a TCPCB.
102: */
103: void
104: tcp_delack(void *arg)
105: {
106: struct tcpcb *tp = arg;
107: int s;
108:
109: /*
110: * If tcp_output() wasn't able to transmit the ACK
111: * for whatever reason, it will restart the delayed
112: * ACK callout.
113: */
114:
115: s = splsoftnet();
116: if (tp->t_flags & TF_DEAD) {
117: splx(s);
118: return;
119: }
120: tp->t_flags |= TF_ACKNOW;
121: (void) tcp_output(tp);
122: splx(s);
123: }
124:
125: /*
126: * Tcp protocol timeout routine called every 500 ms.
127: * Updates the timers in all active tcb's and
128: * causes finite state machine actions if timers expire.
129: */
130: void
131: tcp_slowtimo()
132: {
133: int s;
134:
135: s = splsoftnet();
136: tcp_maxidle = TCPTV_KEEPCNT * tcp_keepintvl;
137: #ifdef TCP_COMPAT_42
138: tcp_iss += TCP_ISSINCR/PR_SLOWHZ; /* increment iss */
139: if ((int)tcp_iss < 0)
140: tcp_iss = 0; /* XXX */
141: #else
142: tcp_iss += TCP_ISSINCR2/PR_SLOWHZ; /* increment iss */
143: #endif /* TCP_COMPAT_42 */
144: tcp_now++; /* for timestamps */
145: splx(s);
146: }
147:
148: /*
149: * Cancel all timers for TCP tp.
150: */
151: void
152: tcp_canceltimers(tp)
153: struct tcpcb *tp;
154: {
155: int i;
156:
157: for (i = 0; i < TCPT_NTIMERS; i++)
158: TCP_TIMER_DISARM(tp, i);
159: }
160:
161: int tcp_backoff[TCP_MAXRXTSHIFT + 1] =
162: { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };
163:
164: int tcp_totbackoff = 511; /* sum of tcp_backoff[] */
165:
166: /*
167: * TCP timer processing.
168: */
169:
170: #ifdef TCP_SACK
171: void tcp_timer_freesack(struct tcpcb *);
172:
173: void
174: tcp_timer_freesack(struct tcpcb *tp)
175: {
176: struct sackhole *p, *q;
177: /*
178: * Free SACK holes for 2MSL and REXMT timers.
179: */
180: q = tp->snd_holes;
181: while (q != NULL) {
182: p = q;
183: q = q->next;
184: pool_put(&sackhl_pool, p);
185: }
186: tp->snd_holes = 0;
187: #ifdef TCP_FACK
188: tp->snd_fack = tp->snd_una;
189: tp->retran_data = 0;
190: tp->snd_awnd = 0;
191: #endif /* TCP_FACK */
192: }
193: #endif /* TCP_SACK */
194:
195: void
196: tcp_timer_rexmt(void *arg)
197: {
198: struct tcpcb *tp = arg;
199: uint32_t rto;
200: int s;
201:
202: s = splsoftnet();
203: if (tp->t_flags & TF_DEAD) {
204: splx(s);
205: return;
206: }
207:
208: if ((tp->t_flags & TF_PMTUD_PEND) && tp->t_inpcb &&
209: SEQ_GEQ(tp->t_pmtud_th_seq, tp->snd_una) &&
210: SEQ_LT(tp->t_pmtud_th_seq, (int)(tp->snd_una + tp->t_maxseg))) {
211: extern struct sockaddr_in icmpsrc;
212: struct icmp icmp;
213:
214: tp->t_flags &= ~TF_PMTUD_PEND;
215:
216: /* XXX create fake icmp message with relevant entries */
217: icmp.icmp_nextmtu = tp->t_pmtud_nextmtu;
218: icmp.icmp_ip.ip_len = tp->t_pmtud_ip_len;
219: icmp.icmp_ip.ip_hl = tp->t_pmtud_ip_hl;
220: icmpsrc.sin_addr = tp->t_inpcb->inp_faddr;
221: icmp_mtudisc(&icmp);
222:
223: /*
224: * Notify all connections to the same peer about
225: * new mss and trigger retransmit.
226: */
227: in_pcbnotifyall(&tcbtable, sintosa(&icmpsrc), EMSGSIZE,
228: 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: struct sockaddr_in sin;
266:
267: /* No data to send means path mtu is not a problem */
268: if (!inp->inp_socket->so_snd.sb_cc)
269: goto leave;
270:
271: rt = in_pcbrtentry(inp);
272: /* Check if path MTU discovery is disabled already */
273: if (rt && (rt->rt_flags & RTF_HOST) &&
274: (rt->rt_rmx.rmx_locks & RTV_MTU))
275: goto leave;
276:
277: rt = NULL;
278: switch(tp->pf) {
279: #ifdef INET6
280: case PF_INET6:
281: /*
282: * We can not turn off path MTU for IPv6.
283: * Do nothing for now, maybe lower to
284: * minimum MTU.
285: */
286: break;
287: #endif
288: case PF_INET:
289: bzero(&sin, sizeof(struct sockaddr_in));
290: sin.sin_family = AF_INET;
291: sin.sin_len = sizeof(struct sockaddr_in);
292: sin.sin_addr = inp->inp_faddr;
293: rt = icmp_mtudisc_clone(sintosa(&sin));
294: break;
295: }
296: if (rt != NULL) {
297: /* Disable path MTU discovery */
298: if ((rt->rt_rmx.rmx_locks & RTV_MTU) == 0) {
299: rt->rt_rmx.rmx_locks |= RTV_MTU;
300: in_rtchange(inp, 0);
301: }
302:
303: rtfree(rt);
304: }
305: leave:
306: ;
307: }
308:
309: /*
310: * If losing, let the lower level know and try for
311: * a better route. Also, if we backed off this far,
312: * our srtt estimate is probably bogus. Clobber it
313: * so we'll take the next rtt measurement as our srtt;
314: * move the current srtt into rttvar to keep the current
315: * retransmit times until then.
316: */
317: if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) {
318: in_losing(tp->t_inpcb);
319: tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT);
320: tp->t_srtt = 0;
321: }
322: tp->snd_nxt = tp->snd_una;
323: #if defined(TCP_SACK)
324: /*
325: * Note: We overload snd_last to function also as the
326: * snd_last variable described in RFC 2582
327: */
328: tp->snd_last = tp->snd_max;
329: #endif /* TCP_SACK */
330: /*
331: * If timing a segment in this window, stop the timer.
332: */
333: tp->t_rtttime = 0;
334: #ifdef TCP_ECN
335: /*
336: * if ECN is enabled, there might be a broken firewall which
337: * blocks ecn packets. fall back to non-ecn.
338: */
339: if ((tp->t_state == TCPS_SYN_SENT || tp->t_state == TCPS_SYN_RECEIVED)
340: && tcp_do_ecn && !(tp->t_flags & TF_DISABLE_ECN))
341: tp->t_flags |= TF_DISABLE_ECN;
342: #endif
343: /*
344: * Close the congestion window down to one segment
345: * (we'll open it by one segment for each ack we get).
346: * Since we probably have a window's worth of unacked
347: * data accumulated, this "slow start" keeps us from
348: * dumping all that data as back-to-back packets (which
349: * might overwhelm an intermediate gateway).
350: *
351: * There are two phases to the opening: Initially we
352: * open by one mss on each ack. This makes the window
353: * size increase exponentially with time. If the
354: * window is larger than the path can handle, this
355: * exponential growth results in dropped packet(s)
356: * almost immediately. To get more time between
357: * drops but still "push" the network to take advantage
358: * of improving conditions, we switch from exponential
359: * to linear window opening at some threshold size.
360: * For a threshold, we use half the current window
361: * size, truncated to a multiple of the mss.
362: *
363: * (the minimum cwnd that will give us exponential
364: * growth is 2 mss. We don't allow the threshold
365: * to go below this.)
366: */
367: {
368: u_long win = ulmin(tp->snd_wnd, tp->snd_cwnd) / 2 / tp->t_maxseg;
369: if (win < 2)
370: win = 2;
371: tp->snd_cwnd = tp->t_maxseg;
372: tp->snd_ssthresh = win * tp->t_maxseg;
373: tp->t_dupacks = 0;
374: #ifdef TCP_ECN
375: tp->snd_last = tp->snd_max;
376: tp->t_flags |= TF_SEND_CWR;
377: #endif
378: #if 1 /* TCP_ECN */
379: tcpstat.tcps_cwr_timeout++;
380: #endif
381: }
382: (void) tcp_output(tp);
383:
384: out:
385: splx(s);
386: }
387:
388: void
389: tcp_timer_persist(void *arg)
390: {
391: struct tcpcb *tp = arg;
392: uint32_t rto;
393: int s;
394:
395: s = splsoftnet();
396: if ((tp->t_flags & TF_DEAD) ||
397: TCP_TIMER_ISARMED(tp, TCPT_REXMT)) {
398: splx(s);
399: return;
400: }
401: tcpstat.tcps_persisttimeo++;
402: /*
403: * Hack: if the peer is dead/unreachable, we do not
404: * time out if the window is closed. After a full
405: * backoff, drop the connection if the idle time
406: * (no responses to probes) reaches the maximum
407: * backoff that we would use if retransmitting.
408: */
409: rto = TCP_REXMTVAL(tp);
410: if (rto < tp->t_rttmin)
411: rto = tp->t_rttmin;
412: if (tp->t_rxtshift == TCP_MAXRXTSHIFT &&
413: ((tcp_now - tp->t_rcvtime) >= tcp_maxpersistidle ||
414: (tcp_now - tp->t_rcvtime) >= rto * tcp_totbackoff)) {
415: tcpstat.tcps_persistdrop++;
416: tp = tcp_drop(tp, ETIMEDOUT);
417: goto out;
418: }
419: tcp_setpersist(tp);
420: tp->t_force = 1;
421: (void) tcp_output(tp);
422: tp->t_force = 0;
423: out:
424: splx(s);
425: }
426:
427: void
428: tcp_timer_keep(void *arg)
429: {
430: struct tcpcb *tp = arg;
431: int s;
432:
433: s = splsoftnet();
434: if (tp->t_flags & TF_DEAD) {
435: splx(s);
436: return;
437: }
438:
439: tcpstat.tcps_keeptimeo++;
440: if (TCPS_HAVEESTABLISHED(tp->t_state) == 0)
441: goto dropit;
442: if (tp->t_inpcb->inp_socket->so_options & SO_KEEPALIVE &&
443: tp->t_state <= TCPS_CLOSING) {
444: if ((tcp_maxidle > 0) &&
445: ((tcp_now - tp->t_rcvtime) >= tcp_keepidle + tcp_maxidle))
446: goto dropit;
447: /*
448: * Send a packet designed to force a response
449: * if the peer is up and reachable:
450: * either an ACK if the connection is still alive,
451: * or an RST if the peer has closed the connection
452: * due to timeout or reboot.
453: * Using sequence number tp->snd_una-1
454: * causes the transmitted zero-length segment
455: * to lie outside the receive window;
456: * by the protocol spec, this requires the
457: * correspondent TCP to respond.
458: */
459: tcpstat.tcps_keepprobe++;
460: #ifdef TCP_COMPAT_42
461: /*
462: * The keepalive packet must have nonzero length
463: * to get a 4.2 host to respond.
464: */
465: tcp_respond(tp, mtod(tp->t_template, caddr_t),
466: (struct mbuf *)NULL, tp->rcv_nxt - 1, tp->snd_una - 1, 0);
467: #else
468: tcp_respond(tp, mtod(tp->t_template, caddr_t),
469: (struct mbuf *)NULL, tp->rcv_nxt, tp->snd_una - 1, 0);
470: #endif
471: TCP_TIMER_ARM(tp, TCPT_KEEP, tcp_keepintvl);
472: } else
473: TCP_TIMER_ARM(tp, TCPT_KEEP, tcp_keepidle);
474:
475: splx(s);
476: return;
477:
478: dropit:
479: tcpstat.tcps_keepdrops++;
480: tp = tcp_drop(tp, ETIMEDOUT);
481:
482: splx(s);
483: }
484:
485: void
486: tcp_timer_2msl(void *arg)
487: {
488: struct tcpcb *tp = arg;
489: int s;
490:
491: s = splsoftnet();
492: if (tp->t_flags & TF_DEAD) {
493: splx(s);
494: return;
495: }
496:
497: #ifdef TCP_SACK
498: tcp_timer_freesack(tp);
499: #endif
500:
501: if (tp->t_state != TCPS_TIME_WAIT &&
502: ((tcp_maxidle == 0) || ((tcp_now - tp->t_rcvtime) <= tcp_maxidle)))
503: TCP_TIMER_ARM(tp, TCPT_2MSL, tcp_keepintvl);
504: else
505: tp = tcp_close(tp);
506:
507: splx(s);
508: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to tcp_timer.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netinet