tcp: Reimplement TCP_FASTKEEP socket option using per-pcb keepidle
[dragonfly.git] / sys / netinet / tcp_timer.c
CommitLineData
984263bc 1/*
66d6c637
JH
2 * Copyright (c) 2003, 2004 Jeffrey M. Hsu. All rights reserved.
3 * Copyright (c) 2003, 2004 The DragonFly Project. All rights reserved.
f23061d4 4 *
66d6c637
JH
5 * This code is derived from software contributed to The DragonFly Project
6 * by Jeffrey M. Hsu.
f23061d4 7 *
66d6c637
JH
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 DragonFly Project nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific, prior written permission.
f23061d4 19 *
66d6c637
JH
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
30 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34/*
984263bc
MD
35 * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
36 * The Regents of the University of California. All rights reserved.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. All advertising materials mentioning features or use of this software
47 * must display the following acknowledgement:
48 * This product includes software developed by the University of
49 * California, Berkeley and its contributors.
50 * 4. Neither the name of the University nor the names of its contributors
51 * may be used to endorse or promote products derived from this software
52 * without specific prior written permission.
53 *
54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64 * SUCH DAMAGE.
65 *
66 * @(#)tcp_timer.c 8.2 (Berkeley) 5/24/95
67 * $FreeBSD: src/sys/netinet/tcp_timer.c,v 1.34.2.14 2003/02/03 02:33:41 hsu Exp $
09517e50 68 * $DragonFly: src/sys/netinet/tcp_timer.c,v 1.17 2008/03/30 20:39:01 dillon Exp $
984263bc
MD
69 */
70
71#include "opt_compat.h"
72#include "opt_inet6.h"
73#include "opt_tcpdebug.h"
74
75#include <sys/param.h>
76#include <sys/systm.h>
77#include <sys/kernel.h>
78#include <sys/mbuf.h>
79#include <sys/sysctl.h>
80#include <sys/socket.h>
81#include <sys/socketvar.h>
82#include <sys/protosw.h>
2b57d013
MD
83#include <sys/thread.h>
84#include <sys/globaldata.h>
1cae611f 85#include <sys/thread2.h>
0f758523 86#include <sys/msgport2.h>
984263bc
MD
87
88#include <machine/cpu.h> /* before tcp_seq.h, for tcp_random18() */
89
90#include <net/route.h>
0f758523 91#include <net/netmsg2.h>
984263bc
MD
92
93#include <netinet/in.h>
94#include <netinet/in_systm.h>
95#include <netinet/in_pcb.h>
96#ifdef INET6
97#include <netinet6/in6_pcb.h>
98#endif
99#include <netinet/ip_var.h>
100#include <netinet/tcp.h>
101#include <netinet/tcp_fsm.h>
102#include <netinet/tcp_seq.h>
103#include <netinet/tcp_timer.h>
a48c5dd5 104#include <netinet/tcp_timer2.h>
984263bc
MD
105#include <netinet/tcp_var.h>
106#include <netinet/tcpip.h>
107#ifdef TCPDEBUG
108#include <netinet/tcp_debug.h>
109#endif
110
0f758523
SZ
111#define TCP_TIMER_REXMT 0x01
112#define TCP_TIMER_PERSIST 0x02
113#define TCP_TIMER_KEEP 0x04
114#define TCP_TIMER_2MSL 0x08
115#define TCP_TIMER_DELACK 0x10
116
117static struct tcpcb *tcp_timer_rexmt_handler(struct tcpcb *);
118static struct tcpcb *tcp_timer_persist_handler(struct tcpcb *);
119static struct tcpcb *tcp_timer_keep_handler(struct tcpcb *);
120static struct tcpcb *tcp_timer_2msl_handler(struct tcpcb *);
121static struct tcpcb *tcp_timer_delack_handler(struct tcpcb *);
122
123static const struct tcp_timer {
124 uint32_t tt_task;
125 struct tcpcb *(*tt_handler)(struct tcpcb *);
126} tcp_timer_handlers[] = {
127 { TCP_TIMER_DELACK, tcp_timer_delack_handler },
0f758523 128 { TCP_TIMER_REXMT, tcp_timer_rexmt_handler },
a48c5dd5 129 { TCP_TIMER_PERSIST, tcp_timer_persist_handler },
0f758523
SZ
130 { TCP_TIMER_KEEP, tcp_timer_keep_handler },
131 { TCP_TIMER_2MSL, tcp_timer_2msl_handler },
132 { 0, NULL }
133};
134
984263bc
MD
135static int
136sysctl_msec_to_ticks(SYSCTL_HANDLER_ARGS)
137{
138 int error, s, tt;
139
140 tt = *(int *)oidp->oid_arg1;
141 s = (int)((int64_t)tt * 1000 / hz);
142
143 error = sysctl_handle_int(oidp, &s, 0, req);
144 if (error || !req->newptr)
145 return (error);
146
147 tt = (int)((int64_t)s * hz / 1000);
148 if (tt < 1)
149 return (EINVAL);
150
151 *(int *)oidp->oid_arg1 = tt;
f23061d4 152 return (0);
984263bc
MD
153}
154
155int tcp_keepinit;
156SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPINIT, keepinit, CTLTYPE_INT|CTLFLAG_RW,
c9458756 157 &tcp_keepinit, 0, sysctl_msec_to_ticks, "I", "Time to establish TCP connection");
984263bc
MD
158
159int tcp_keepidle;
160SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPIDLE, keepidle, CTLTYPE_INT|CTLFLAG_RW,
c9458756 161 &tcp_keepidle, 0, sysctl_msec_to_ticks, "I", "Time before TCP keepalive probes begin");
984263bc
MD
162
163int tcp_keepintvl;
164SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPINTVL, keepintvl, CTLTYPE_INT|CTLFLAG_RW,
c9458756 165 &tcp_keepintvl, 0, sysctl_msec_to_ticks, "I", "Time between TCP keepalive probes");
984263bc
MD
166
167int tcp_delacktime;
168SYSCTL_PROC(_net_inet_tcp, TCPCTL_DELACKTIME, delacktime,
169 CTLTYPE_INT|CTLFLAG_RW, &tcp_delacktime, 0, sysctl_msec_to_ticks, "I",
170 "Time before a delayed ACK is sent");
f23061d4 171
984263bc
MD
172int tcp_msl;
173SYSCTL_PROC(_net_inet_tcp, OID_AUTO, msl, CTLTYPE_INT|CTLFLAG_RW,
174 &tcp_msl, 0, sysctl_msec_to_ticks, "I", "Maximum segment lifetime");
175
176int tcp_rexmit_min;
177SYSCTL_PROC(_net_inet_tcp, OID_AUTO, rexmit_min, CTLTYPE_INT|CTLFLAG_RW,
178 &tcp_rexmit_min, 0, sysctl_msec_to_ticks, "I", "Minimum Retransmission Timeout");
179
180int tcp_rexmit_slop;
181SYSCTL_PROC(_net_inet_tcp, OID_AUTO, rexmit_slop, CTLTYPE_INT|CTLFLAG_RW,
8acdb67c
JH
182 &tcp_rexmit_slop, 0, sysctl_msec_to_ticks, "I",
183 "Retransmission Timer Slop");
984263bc 184
09517e50 185static int always_keepalive = 1;
f23061d4 186SYSCTL_INT(_net_inet_tcp, OID_AUTO, always_keepalive, CTLFLAG_RW,
984263bc
MD
187 &always_keepalive , 0, "Assume SO_KEEPALIVE on all TCP connections");
188
9269e6b6 189/* max idle probes */
5d61ded3 190int tcp_keepcnt = TCPTV_KEEPCNT;
9269e6b6
SZ
191SYSCTL_INT(_net_inet_tcp, OID_AUTO, keepcnt, CTLFLAG_RW,
192 &tcp_keepcnt, 0, "Maximum number of keepalive probes to be sent");
193
194/* max idle time in persist */
984263bc 195int tcp_maxpersistidle;
9269e6b6 196
984263bc 197/*
984263bc
MD
198 * Cancel all timers for TCP tp.
199 */
200void
8a3125c6 201tcp_canceltimers(struct tcpcb *tp)
984263bc 202{
a48c5dd5
SZ
203 tcp_callout_stop(tp, tp->tt_2msl);
204 tcp_callout_stop(tp, tp->tt_persist);
205 tcp_callout_stop(tp, tp->tt_keep);
206 tcp_callout_stop(tp, tp->tt_rexmt);
984263bc
MD
207}
208
0f758523
SZ
209/*
210 * Caller should be in critical section
211 */
212static void
213tcp_send_timermsg(struct tcpcb *tp, uint32_t task)
214{
215 struct netmsg_tcp_timer *tmsg = tp->tt_msg;
216
217 KKASSERT(tmsg != NULL && tmsg->tt_cpuid == mycpuid &&
218 tmsg->tt_tcb != NULL);
219
220 tmsg->tt_tasks |= task;
002c1265
MD
221 if (tmsg->tt_msg.lmsg.ms_flags & MSGF_DONE)
222 lwkt_sendmsg(tmsg->tt_msgport, &tmsg->tt_msg.lmsg);
0f758523
SZ
223}
224
984263bc
MD
225int tcp_syn_backoff[TCP_MAXRXTSHIFT + 1] =
226 { 1, 1, 1, 1, 1, 2, 4, 8, 16, 32, 64, 64, 64 };
227
48a4676d 228int tcp_syn_backoff_low[TCP_MAXRXTSHIFT + 1] =
0e18fd45 229 { 1, 1, 2, 4, 8, 8, 16, 16, 32, 64, 64, 64, 64 };
48a4676d 230
984263bc
MD
231int tcp_backoff[TCP_MAXRXTSHIFT + 1] =
232 { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };
233
234static int tcp_totbackoff = 511; /* sum of tcp_backoff[] */
235
0f758523
SZ
236/* Caller should be in critical section */
237static struct tcpcb *
238tcp_timer_delack_handler(struct tcpcb *tp)
239{
240 tp->t_flags |= TF_ACKNOW;
241 tcpstat.tcps_delack++;
242 tcp_output(tp);
243 return tp;
244}
245
984263bc
MD
246/*
247 * TCP timer processing.
248 */
249void
8a3125c6 250tcp_timer_delack(void *xtp)
984263bc
MD
251{
252 struct tcpcb *tp = xtp;
a48c5dd5 253 struct callout *co = &tp->tt_delack->tc_callout;
984263bc 254
1cae611f 255 crit_enter();
a48c5dd5 256 if (callout_pending(co) || !callout_active(co)) {
1cae611f 257 crit_exit();
984263bc
MD
258 return;
259 }
a48c5dd5 260 callout_deactivate(co);
0f758523 261 tcp_send_timermsg(tp, TCP_TIMER_DELACK);
1cae611f 262 crit_exit();
984263bc
MD
263}
264
0f758523
SZ
265/* Caller should be in critical section */
266static struct tcpcb *
267tcp_timer_2msl_handler(struct tcpcb *tp)
984263bc 268{
984263bc
MD
269#ifdef TCPDEBUG
270 int ostate;
0f758523 271#endif
984263bc 272
0f758523 273#ifdef TCPDEBUG
984263bc
MD
274 ostate = tp->t_state;
275#endif
984263bc
MD
276 /*
277 * 2 MSL timeout in shutdown went off. If we're closed but
278 * still waiting for peer to close and connection has been idle
279 * too long, or if 2MSL time is up from TIME_WAIT, delete connection
280 * control block. Otherwise, check again in a bit.
281 */
282 if (tp->t_state != TCPS_TIME_WAIT &&
5d61ded3
SZ
283 (ticks - tp->t_rcvtime) <= tp->t_maxidle) {
284 tcp_callout_reset(tp, tp->tt_2msl, tp->t_keepintvl,
a48c5dd5
SZ
285 tcp_timer_2msl);
286 } else {
984263bc 287 tp = tcp_close(tp);
a48c5dd5 288 }
984263bc
MD
289
290#ifdef TCPDEBUG
291 if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
f23061d4 292 tcp_trace(TA_USER, ostate, tp, NULL, NULL, PRU_SLOWTIMO);
984263bc 293#endif
0f758523 294 return tp;
984263bc
MD
295}
296
297void
0f758523 298tcp_timer_2msl(void *xtp)
984263bc
MD
299{
300 struct tcpcb *tp = xtp;
a48c5dd5 301 struct callout *co = &tp->tt_2msl->tc_callout;
0f758523
SZ
302
303 crit_enter();
a48c5dd5 304 if (callout_pending(co) || !callout_active(co)) {
0f758523
SZ
305 crit_exit();
306 return;
307 }
a48c5dd5 308 callout_deactivate(co);
0f758523
SZ
309 tcp_send_timermsg(tp, TCP_TIMER_2MSL);
310 crit_exit();
311}
312
313/* Caller should be in critical section */
314static struct tcpcb *
315tcp_timer_keep_handler(struct tcpcb *tp)
316{
984263bc 317 struct tcptemp *t_template;
984263bc 318#ifdef TCPDEBUG
fb8d5c6d 319 int ostate = tp->t_state;
0f758523 320#endif
984263bc 321
984263bc
MD
322 /*
323 * Keep-alive timer went off; send something
324 * or drop connection if idle for too long.
325 */
326 tcpstat.tcps_keeptimeo++;
327 if (tp->t_state < TCPS_ESTABLISHED)
328 goto dropit;
efca2b8e
MD
329 if ((always_keepalive || (tp->t_flags & TF_KEEPALIVE) ||
330 (tp->t_inpcb->inp_socket->so_options & SO_KEEPALIVE)) &&
984263bc 331 tp->t_state <= TCPS_CLOSING) {
fb8d5c6d 332 if ((ticks - tp->t_rcvtime) >= tp->t_keepidle + tp->t_maxidle)
984263bc
MD
333 goto dropit;
334 /*
335 * Send a packet designed to force a response
336 * if the peer is up and reachable:
337 * either an ACK if the connection is still alive,
338 * or an RST if the peer has closed the connection
339 * due to timeout or reboot.
340 * Using sequence number tp->snd_una-1
341 * causes the transmitted zero-length segment
342 * to lie outside the receive window;
343 * by the protocol spec, this requires the
344 * correspondent TCP to respond.
345 */
346 tcpstat.tcps_keepprobe++;
347 t_template = tcp_maketemplate(tp);
348 if (t_template) {
349 tcp_respond(tp, t_template->tt_ipgen,
2038fb68 350 &t_template->tt_t, NULL,
984263bc 351 tp->rcv_nxt, tp->snd_una - 1, 0);
dd2b0fb4 352 tcp_freetemplate(t_template);
984263bc 353 }
5d61ded3 354 tcp_callout_reset(tp, tp->tt_keep, tp->t_keepintvl,
a48c5dd5
SZ
355 tcp_timer_keep);
356 } else {
fb8d5c6d 357 tcp_callout_reset(tp, tp->tt_keep, tp->t_keepidle,
a48c5dd5
SZ
358 tcp_timer_keep);
359 }
984263bc
MD
360
361#ifdef TCPDEBUG
362 if (tp->t_inpcb->inp_socket->so_options & SO_DEBUG)
f23061d4 363 tcp_trace(TA_USER, ostate, tp, NULL, NULL, PRU_SLOWTIMO);
984263bc 364#endif
0f758523 365 return tp;
984263bc
MD
366
367dropit:
368 tcpstat.tcps_keepdrops++;
369 tp = tcp_drop(tp, ETIMEDOUT);
370
371#ifdef TCPDEBUG
372 if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
f23061d4 373 tcp_trace(TA_USER, ostate, tp, NULL, NULL, PRU_SLOWTIMO);
984263bc 374#endif
0f758523 375 return tp;
984263bc
MD
376}
377
378void
0f758523 379tcp_timer_keep(void *xtp)
984263bc
MD
380{
381 struct tcpcb *tp = xtp;
a48c5dd5 382 struct callout *co = &tp->tt_keep->tc_callout;
984263bc 383
1cae611f 384 crit_enter();
a48c5dd5 385 if (callout_pending(co) || !callout_active(co)) {
1cae611f 386 crit_exit();
984263bc
MD
387 return;
388 }
a48c5dd5 389 callout_deactivate(co);
0f758523
SZ
390 tcp_send_timermsg(tp, TCP_TIMER_KEEP);
391 crit_exit();
392}
393
394/* Caller should be in critical section */
395static struct tcpcb *
396tcp_timer_persist_handler(struct tcpcb *tp)
397{
398#ifdef TCPDEBUG
399 int ostate;
400#endif
401
402#ifdef TCPDEBUG
403 ostate = tp->t_state;
404#endif
984263bc
MD
405 /*
406 * Persistance timer into zero window.
407 * Force a byte to be output, if possible.
408 */
409 tcpstat.tcps_persisttimeo++;
410 /*
411 * Hack: if the peer is dead/unreachable, we do not
412 * time out if the window is closed. After a full
413 * backoff, drop the connection if the idle time
414 * (no responses to probes) reaches the maximum
415 * backoff that we would use if retransmitting.
416 */
417 if (tp->t_rxtshift == TCP_MAXRXTSHIFT &&
418 ((ticks - tp->t_rcvtime) >= tcp_maxpersistidle ||
419 (ticks - tp->t_rcvtime) >= TCP_REXMTVAL(tp) * tcp_totbackoff)) {
420 tcpstat.tcps_persistdrop++;
421 tp = tcp_drop(tp, ETIMEDOUT);
422 goto out;
423 }
424 tcp_setpersist(tp);
c1d3b892 425 tp->t_flags |= TF_FORCE;
f23061d4 426 tcp_output(tp);
c1d3b892 427 tp->t_flags &= ~TF_FORCE;
984263bc
MD
428
429out:
430#ifdef TCPDEBUG
431 if (tp && tp->t_inpcb->inp_socket->so_options & SO_DEBUG)
f23061d4 432 tcp_trace(TA_USER, ostate, tp, NULL, NULL, PRU_SLOWTIMO);
984263bc 433#endif
0f758523
SZ
434 return tp;
435}
436
437void
438tcp_timer_persist(void *xtp)
439{
440 struct tcpcb *tp = xtp;
a48c5dd5 441 struct callout *co = &tp->tt_persist->tc_callout;
0f758523
SZ
442
443 crit_enter();
a48c5dd5 444 if (callout_pending(co) || !callout_active(co)){
0f758523
SZ
445 crit_exit();
446 return;
447 }
a48c5dd5 448 callout_deactivate(co);
0f758523 449 tcp_send_timermsg(tp, TCP_TIMER_PERSIST);
1cae611f 450 crit_exit();
984263bc
MD
451}
452
453void
efd4b327
JH
454tcp_save_congestion_state(struct tcpcb *tp)
455{
456 tp->snd_cwnd_prev = tp->snd_cwnd;
8acdb67c 457 tp->snd_wacked_prev = tp->snd_wacked;
efd4b327
JH
458 tp->snd_ssthresh_prev = tp->snd_ssthresh;
459 tp->snd_recover_prev = tp->snd_recover;
460 if (IN_FASTRECOVERY(tp))
8acdb67c 461 tp->t_flags |= TF_WASFRECOVERY;
efd4b327 462 else
8acdb67c 463 tp->t_flags &= ~TF_WASFRECOVERY;
efd4b327
JH
464 if (tp->t_flags & TF_RCVD_TSTMP) {
465 tp->t_rexmtTS = ticks;
466 tp->t_flags |= TF_FIRSTACCACK;
467 }
91489f6b
JH
468#ifdef later
469 tcp_sack_save_scoreboard(&tp->scb);
470#endif
efd4b327
JH
471}
472
473void
bfdb979e
JH
474tcp_revert_congestion_state(struct tcpcb *tp)
475{
476 tp->snd_cwnd = tp->snd_cwnd_prev;
8acdb67c 477 tp->snd_wacked = tp->snd_wacked_prev;
bfdb979e
JH
478 tp->snd_ssthresh = tp->snd_ssthresh_prev;
479 tp->snd_recover = tp->snd_recover_prev;
480 if (tp->t_flags & TF_WASFRECOVERY)
8acdb67c 481 ENTER_FASTRECOVERY(tp);
8819433a 482 if (tp->t_flags & TF_FASTREXMT) {
bfdb979e 483 ++tcpstat.tcps_sndfastrexmitbad;
8819433a
JH
484 if (tp->t_flags & TF_EARLYREXMT)
485 ++tcpstat.tcps_sndearlyrexmitbad;
486 } else
bfdb979e
JH
487 ++tcpstat.tcps_sndrtobad;
488 tp->t_badrxtwin = 0;
489 tp->t_rxtshift = 0;
490 tp->snd_nxt = tp->snd_max;
91489f6b
JH
491#ifdef later
492 tcp_sack_revert_scoreboard(&tp->scb, tp->snd_una);
493#endif
bfdb979e
JH
494}
495
0f758523
SZ
496/* Caller should be in critical section */
497static struct tcpcb *
498tcp_timer_rexmt_handler(struct tcpcb *tp)
984263bc 499{
984263bc
MD
500 int rexmt;
501#ifdef TCPDEBUG
502 int ostate;
0f758523 503#endif
984263bc 504
0f758523 505#ifdef TCPDEBUG
984263bc
MD
506 ostate = tp->t_state;
507#endif
984263bc
MD
508 /*
509 * Retransmission timer went off. Message has not
510 * been acked within retransmit interval. Back off
511 * to a longer retransmit interval and retransmit one segment.
512 */
513 if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {
514 tp->t_rxtshift = TCP_MAXRXTSHIFT;
515 tcpstat.tcps_timeoutdrop++;
516 tp = tcp_drop(tp, tp->t_softerror ?
517 tp->t_softerror : ETIMEDOUT);
518 goto out;
519 }
520 if (tp->t_rxtshift == 1) {
521 /*
522 * first retransmit; record ssthresh and cwnd so they can
f23061d4
JH
523 * be recovered if this turns out to be a "bad" retransmit.
524 * A retransmit is considered "bad" if an ACK for this
984263bc 525 * segment is received within RTT/2 interval; the assumption
f23061d4 526 * here is that the ACK was already in flight. See
984263bc
MD
527 * "On Estimating End-to-End Network Path Properties" by
528 * Allman and Paxson for more details.
529 */
984263bc 530 tp->t_badrxtwin = ticks + (tp->t_srtt >> (TCP_RTT_SHIFT + 1));
efd4b327 531 tcp_save_congestion_state(tp);
8819433a 532 tp->t_flags &= ~(TF_FASTREXMT | TF_EARLYREXMT);
d5082e3d
SZ
533 }
534 if (tp->t_state == TCPS_SYN_SENT || tp->t_state == TCPS_SYN_RECEIVED) {
535 /*
536 * Record the time that we spent in SYN or SYN|ACK
537 * retransmition.
538 *
539 * Needed by RFC3390 and RFC6298.
540 */
541 tp->t_rxtsyn += tp->t_rxtcur;
984263bc 542 }
91489f6b
JH
543 /* Throw away SACK blocks on a RTO, as specified by RFC2018. */
544 tcp_sack_cleanup(&tp->scb);
984263bc 545 tcpstat.tcps_rexmttimeo++;
48a4676d
SZ
546 if (tp->t_state == TCPS_SYN_SENT) {
547 if (tcp_low_rtobase) {
548 rexmt = TCP_REXMTVAL(tp) *
549 tcp_syn_backoff_low[tp->t_rxtshift];
550 } else {
551 rexmt = TCP_REXMTVAL(tp) *
552 tcp_syn_backoff[tp->t_rxtshift];
553 }
554 } else {
984263bc 555 rexmt = TCP_REXMTVAL(tp) * tcp_backoff[tp->t_rxtshift];
48a4676d 556 }
984263bc
MD
557 TCPT_RANGESET(tp->t_rxtcur, rexmt,
558 tp->t_rttmin, TCPTV_REXMTMAX);
559 /*
984263bc
MD
560 * If losing, let the lower level know and try for
561 * a better route. Also, if we backed off this far,
562 * our srtt estimate is probably bogus. Clobber it
563 * so we'll take the next rtt measurement as our srtt;
564 * move the current srtt into rttvar to keep the current
565 * retransmit times until then.
566 */
567 if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) {
568#ifdef INET6
569 if ((tp->t_inpcb->inp_vflag & INP_IPV6) != 0)
570 in6_losing(tp->t_inpcb);
571 else
572#endif
573 in_losing(tp->t_inpcb);
574 tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT);
575 tp->t_srtt = 0;
576 }
577 tp->snd_nxt = tp->snd_una;
91489f6b 578 tp->rexmt_high = tp->snd_una;
9845754e 579 tp->snd_recover = tp->snd_max;
984263bc
MD
580 /*
581 * Force a segment to be sent.
582 */
583 tp->t_flags |= TF_ACKNOW;
584 /*
585 * If timing a segment in this window, stop the timer.
586 */
587 tp->t_rtttime = 0;
588 /*
589 * Close the congestion window down to one segment
590 * (we'll open it by one segment for each ack we get).
591 * Since we probably have a window's worth of unacked
592 * data accumulated, this "slow start" keeps us from
593 * dumping all that data as back-to-back packets (which
594 * might overwhelm an intermediate gateway).
595 *
596 * There are two phases to the opening: Initially we
597 * open by one mss on each ack. This makes the window
598 * size increase exponentially with time. If the
599 * window is larger than the path can handle, this
600 * exponential growth results in dropped packet(s)
601 * almost immediately. To get more time between
602 * drops but still "push" the network to take advantage
603 * of improving conditions, we switch from exponential
604 * to linear window opening at some threshhold size.
605 * For a threshhold, we use half the current window
606 * size, truncated to a multiple of the mss.
607 *
608 * (the minimum cwnd that will give us exponential
609 * growth is 2 mss. We don't allow the threshhold
610 * to go below this.)
611 */
612 {
613 u_int win = min(tp->snd_wnd, tp->snd_cwnd) / 2 / tp->t_maxseg;
8acdb67c 614
984263bc
MD
615 if (win < 2)
616 win = 2;
617 tp->snd_cwnd = tp->t_maxseg;
8acdb67c 618 tp->snd_wacked = 0;
984263bc
MD
619 tp->snd_ssthresh = win * tp->t_maxseg;
620 tp->t_dupacks = 0;
621 }
9845754e 622 EXIT_FASTRECOVERY(tp);
f23061d4 623 tcp_output(tp);
984263bc
MD
624
625out:
626#ifdef TCPDEBUG
627 if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
f23061d4 628 tcp_trace(TA_USER, ostate, tp, NULL, NULL, PRU_SLOWTIMO);
984263bc 629#endif
0f758523
SZ
630 return tp;
631}
632
633void
634tcp_timer_rexmt(void *xtp)
635{
636 struct tcpcb *tp = xtp;
a48c5dd5 637 struct callout *co = &tp->tt_rexmt->tc_callout;
0f758523
SZ
638
639 crit_enter();
a48c5dd5 640 if (callout_pending(co) || !callout_active(co)) {
0f758523
SZ
641 crit_exit();
642 return;
643 }
a48c5dd5 644 callout_deactivate(co);
0f758523
SZ
645 tcp_send_timermsg(tp, TCP_TIMER_REXMT);
646 crit_exit();
647}
648
649static void
002c1265 650tcp_timer_handler(netmsg_t msg)
0f758523 651{
002c1265 652 struct netmsg_tcp_timer *tmsg = (struct netmsg_tcp_timer *)msg;
0f758523
SZ
653 const struct tcp_timer *tt;
654 struct tcpcb *tp;
0f758523
SZ
655
656 crit_enter();
657
658 KKASSERT(tmsg->tt_cpuid == mycpuid && tmsg->tt_tcb != NULL);
659 tp = tmsg->tt_tcb;
660
661 /* Save pending tasks and reset the tasks in message */
a48c5dd5
SZ
662 tmsg->tt_running_tasks = tmsg->tt_tasks;
663 tmsg->tt_prev_tasks = tmsg->tt_tasks;
0f758523
SZ
664 tmsg->tt_tasks = 0;
665
666 /* Reply ASAP */
002c1265 667 lwkt_replymsg(&tmsg->tt_msg.lmsg, 0);
0f758523 668
a48c5dd5
SZ
669 if (tmsg->tt_running_tasks == 0) {
670 /*
671 * All of the timers are cancelled when the message
672 * is pending; bail out.
673 */
674 crit_exit();
675 return;
676 }
677
0f758523 678 for (tt = tcp_timer_handlers; tt->tt_handler != NULL; ++tt) {
a48c5dd5 679 if ((tmsg->tt_running_tasks & tt->tt_task) == 0)
0f758523
SZ
680 continue;
681
a48c5dd5 682 tmsg->tt_running_tasks &= ~tt->tt_task;
0f758523
SZ
683 tp = tt->tt_handler(tp);
684 if (tp == NULL)
685 break;
686
a48c5dd5 687 if (tmsg->tt_running_tasks == 0) /* nothing left to do */
0f758523
SZ
688 break;
689 }
690
691 crit_exit();
692}
693
694void
3db1c8a3 695tcp_create_timermsg(struct tcpcb *tp, struct lwkt_port *msgport)
0f758523
SZ
696{
697 struct netmsg_tcp_timer *tmsg = tp->tt_msg;
698
002c1265 699 netmsg_init(&tmsg->tt_msg, NULL, &netisr_adone_rport,
d7d63d5d 700 MSGF_DROPABLE | MSGF_PRIORITY, tcp_timer_handler);
0f758523 701 tmsg->tt_cpuid = mycpuid;
3db1c8a3 702 tmsg->tt_msgport = msgport;
0f758523
SZ
703 tmsg->tt_tcb = tp;
704 tmsg->tt_tasks = 0;
705}
706
707void
708tcp_destroy_timermsg(struct tcpcb *tp)
709{
710 struct netmsg_tcp_timer *tmsg = tp->tt_msg;
711
712 if (tmsg == NULL || /* listen socket */
713 tmsg->tt_tcb == NULL) /* only tcp_attach() is called */
714 return;
715
716 KKASSERT(tmsg->tt_cpuid == mycpuid);
717 crit_enter();
002c1265 718 if ((tmsg->tt_msg.lmsg.ms_flags & MSGF_DONE) == 0) {
0f758523
SZ
719 /*
720 * This message is still pending to be processed;
721 * drop it.
722 */
002c1265 723 lwkt_dropmsg(&tmsg->tt_msg.lmsg);
0f758523 724 }
1cae611f 725 crit_exit();
984263bc 726}
a48c5dd5
SZ
727
728static __inline void
729tcp_callout_init(struct tcp_callout *tc, uint32_t task)
730{
608499ad 731 callout_init_mp(&tc->tc_callout);
a48c5dd5
SZ
732 tc->tc_task = task;
733}
734
735void
736tcp_inittimers(struct tcpcb *tp)
737{
738 tcp_callout_init(tp->tt_rexmt, TCP_TIMER_REXMT);
739 tcp_callout_init(tp->tt_persist, TCP_TIMER_PERSIST);
740 tcp_callout_init(tp->tt_keep, TCP_TIMER_KEEP);
741 tcp_callout_init(tp->tt_2msl, TCP_TIMER_2MSL);
742 tcp_callout_init(tp->tt_delack, TCP_TIMER_DELACK);
743}