2005-01-07 01:45:51 +00:00
|
|
|
/*-
|
1995-10-03 16:54:17 +00:00
|
|
|
* Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
|
1994-05-24 10:09:53 +00:00
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
1995-10-03 16:54:17 +00:00
|
|
|
* @(#)tcp_timer.c 8.2 (Berkeley) 5/24/95
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
2000-01-09 19:17:30 +00:00
|
|
|
#include "opt_inet6.h"
|
1997-09-16 18:36:06 +00:00
|
|
|
#include "opt_tcpdebug.h"
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
1995-11-09 20:23:09 +00:00
|
|
|
#include <sys/kernel.h>
|
2002-09-05 15:33:30 +00:00
|
|
|
#include <sys/lock.h>
|
2001-06-23 03:21:46 +00:00
|
|
|
#include <sys/mbuf.h>
|
2002-09-05 15:33:30 +00:00
|
|
|
#include <sys/mutex.h>
|
|
|
|
#include <sys/protosw.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/socketvar.h>
|
2002-09-05 15:33:30 +00:00
|
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <sys/systm.h>
|
1995-10-03 16:54:17 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <net/route.h>
|
|
|
|
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netinet/in_pcb.h>
|
2002-09-05 15:33:30 +00:00
|
|
|
#include <netinet/in_systm.h>
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
#include <netinet6/in6_pcb.h>
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <netinet/ip_var.h>
|
|
|
|
#include <netinet/tcp.h>
|
|
|
|
#include <netinet/tcp_fsm.h>
|
|
|
|
#include <netinet/tcp_timer.h>
|
|
|
|
#include <netinet/tcp_var.h>
|
|
|
|
#include <netinet/tcpip.h>
|
1996-07-12 17:28:47 +00:00
|
|
|
#ifdef TCPDEBUG
|
|
|
|
#include <netinet/tcp_debug.h>
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-08-30 21:17:07 +00:00
|
|
|
int tcp_keepinit;
|
1999-08-31 03:40:24 +00:00
|
|
|
SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPINIT, keepinit, CTLTYPE_INT|CTLFLAG_RW,
|
|
|
|
&tcp_keepinit, 0, sysctl_msec_to_ticks, "I", "");
|
1996-09-13 23:51:44 +00:00
|
|
|
|
1999-08-30 21:17:07 +00:00
|
|
|
int tcp_keepidle;
|
1999-08-31 03:40:24 +00:00
|
|
|
SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPIDLE, keepidle, CTLTYPE_INT|CTLFLAG_RW,
|
|
|
|
&tcp_keepidle, 0, sysctl_msec_to_ticks, "I", "");
|
1995-11-09 20:23:09 +00:00
|
|
|
|
1999-08-30 21:17:07 +00:00
|
|
|
int tcp_keepintvl;
|
1999-08-31 03:40:24 +00:00
|
|
|
SYSCTL_PROC(_net_inet_tcp, TCPCTL_KEEPINTVL, keepintvl, CTLTYPE_INT|CTLFLAG_RW,
|
|
|
|
&tcp_keepintvl, 0, sysctl_msec_to_ticks, "I", "");
|
1995-11-09 20:23:09 +00:00
|
|
|
|
1999-08-30 21:17:07 +00:00
|
|
|
int tcp_delacktime;
|
2007-03-19 19:00:51 +00:00
|
|
|
SYSCTL_PROC(_net_inet_tcp, TCPCTL_DELACKTIME, delacktime, CTLTYPE_INT|CTLFLAG_RW,
|
|
|
|
&tcp_delacktime, 0, sysctl_msec_to_ticks, "I",
|
1999-08-31 03:40:24 +00:00
|
|
|
"Time before a delayed ACK is sent");
|
2004-08-16 18:32:07 +00:00
|
|
|
|
1999-08-30 21:17:07 +00:00
|
|
|
int tcp_msl;
|
1999-08-31 03:40:24 +00:00
|
|
|
SYSCTL_PROC(_net_inet_tcp, OID_AUTO, msl, CTLTYPE_INT|CTLFLAG_RW,
|
|
|
|
&tcp_msl, 0, sysctl_msec_to_ticks, "I", "Maximum segment lifetime");
|
1999-08-30 21:17:07 +00:00
|
|
|
|
2002-07-18 19:06:12 +00:00
|
|
|
int tcp_rexmit_min;
|
|
|
|
SYSCTL_PROC(_net_inet_tcp, OID_AUTO, rexmit_min, CTLTYPE_INT|CTLFLAG_RW,
|
2007-03-19 19:00:51 +00:00
|
|
|
&tcp_rexmit_min, 0, sysctl_msec_to_ticks, "I",
|
|
|
|
"Minimum Retransmission Timeout");
|
2002-07-18 19:06:12 +00:00
|
|
|
|
|
|
|
int tcp_rexmit_slop;
|
|
|
|
SYSCTL_PROC(_net_inet_tcp, OID_AUTO, rexmit_slop, CTLTYPE_INT|CTLFLAG_RW,
|
2007-03-19 19:00:51 +00:00
|
|
|
&tcp_rexmit_slop, 0, sysctl_msec_to_ticks, "I",
|
|
|
|
"Retransmission Timer Slop");
|
2002-07-18 19:06:12 +00:00
|
|
|
|
2001-12-07 17:01:28 +00:00
|
|
|
static int always_keepalive = 1;
|
2004-08-16 18:32:07 +00:00
|
|
|
SYSCTL_INT(_net_inet_tcp, OID_AUTO, always_keepalive, CTLFLAG_RW,
|
1999-05-03 23:57:32 +00:00
|
|
|
&always_keepalive , 0, "Assume SO_KEEPALIVE on all TCP connections");
|
1996-04-04 11:17:04 +00:00
|
|
|
|
2007-02-26 22:25:21 +00:00
|
|
|
int tcp_fast_finwait2_recycle = 0;
|
|
|
|
SYSCTL_INT(_net_inet_tcp, OID_AUTO, fast_finwait2_recycle, CTLFLAG_RW,
|
2007-03-19 19:00:51 +00:00
|
|
|
&tcp_fast_finwait2_recycle, 0,
|
|
|
|
"Recycle closed FIN_WAIT_2 connections faster");
|
2007-02-26 22:25:21 +00:00
|
|
|
|
|
|
|
int tcp_finwait2_timeout;
|
|
|
|
SYSCTL_PROC(_net_inet_tcp, OID_AUTO, finwait2_timeout, CTLTYPE_INT|CTLFLAG_RW,
|
2007-03-19 19:00:51 +00:00
|
|
|
&tcp_finwait2_timeout, 0, sysctl_msec_to_ticks, "I", "FIN-WAIT2 timeout");
|
2007-02-26 22:25:21 +00:00
|
|
|
|
|
|
|
|
1995-11-14 20:34:56 +00:00
|
|
|
static int tcp_keepcnt = TCPTV_KEEPCNT;
|
|
|
|
/* max idle probes */
|
1999-08-30 21:17:07 +00:00
|
|
|
int tcp_maxpersistidle;
|
1995-11-14 20:34:56 +00:00
|
|
|
/* max idle time in persist */
|
1994-05-24 10:09:53 +00:00
|
|
|
int tcp_maxidle;
|
1995-10-03 16:54:17 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Tcp protocol timeout routine called every 500 ms.
|
1999-08-30 21:17:07 +00:00
|
|
|
* Updates timestamps used for TCP
|
1994-05-24 10:09:53 +00:00
|
|
|
* causes finite state machine actions if timers expire.
|
|
|
|
*/
|
|
|
|
void
|
2007-09-24 05:26:24 +00:00
|
|
|
tcp_slowtimo(void)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1995-04-09 01:29:31 +00:00
|
|
|
|
1995-10-03 16:54:17 +00:00
|
|
|
tcp_maxidle = tcp_keepcnt * tcp_keepintvl;
|
2003-03-08 22:06:20 +00:00
|
|
|
INP_INFO_WLOCK(&tcbinfo);
|
2007-05-16 17:14:25 +00:00
|
|
|
(void) tcp_tw_2msl_scan(0);
|
2003-03-08 22:06:20 +00:00
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2001-02-26 21:33:55 +00:00
|
|
|
int tcp_syn_backoff[TCP_MAXRXTSHIFT + 1] =
|
|
|
|
{ 1, 1, 1, 1, 1, 2, 4, 8, 16, 32, 64, 64, 64 };
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
int tcp_backoff[TCP_MAXRXTSHIFT + 1] =
|
2003-06-04 10:03:55 +00:00
|
|
|
{ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 512, 512, 512 };
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-06-04 10:03:55 +00:00
|
|
|
static int tcp_totbackoff = 2559; /* sum of tcp_backoff[] */
|
1995-10-03 16:54:17 +00:00
|
|
|
|
Update TCP for infrastructural changes to the socket/pcb refcount model,
pru_abort(), pru_detach(), and in_pcbdetach():
- Universally support and enforce the invariant that so_pcb is
never NULL, converting dozens of unnecessary NULL checks into
assertions, and eliminating dozens of unnecessary error handling
cases in protocol code.
- In some cases, eliminate unnecessary pcbinfo locking, as it is no
longer required to ensure so_pcb != NULL. For example, the receive
code no longer requires the pcbinfo lock, and the send code only
requires it if building a new connection on an otherwise unconnected
socket triggered via sendto() with an address. This should
significnatly reduce tcbinfo lock contention in the receive and send
cases.
- In order to support the invariant that so_pcb != NULL, it is now
necessary for the TCP code to not discard the tcpcb any time a
connection is dropped, but instead leave the tcpcb until the socket
is shutdown. This case is handled by setting INP_DROPPED, to
substitute for using a NULL so_pcb to indicate that the connection
has been dropped. This requires the inpcb lock, but not the pcbinfo
lock.
- Unlike all other protocols in the tree, TCP may need to retain access
to the socket after the file descriptor has been closed. Set
SS_PROTOREF in tcp_detach() in order to prevent the socket from being
freed, and add a flag, INP_SOCKREF, so that the TCP code knows whether
or not it needs to free the socket when the connection finally does
close. The typical case where this occurs is if close() is called on
a TCP socket before all sent data in the send socket buffer has been
transmitted or acknowledged. If INP_SOCKREF is found when the
connection is dropped, we release the inpcb, tcpcb, and socket instead
of flagging INP_DROPPED.
- Abort and detach protocol switch methods no longer return failures,
nor attempt to free sockets, as the socket layer does this.
- Annotate the existence of a long-standing race in the TCP timer code,
in which timers are stopped but not drained when the socket is freed,
as waiting for drain may lead to deadlocks, or have to occur in a
context where waiting is not permitted. This race has been handled
by testing to see if the tcpcb pointer in the inpcb is NULL (and vice
versa), which is not normally permitted, but may be true of a inpcb
and tcpcb have been freed. Add a counter to test how often this race
has actually occurred, and a large comment for each instance where
we compare potentially freed memory with NULL. This will have to be
fixed in the near future, but requires is to further address how to
handle the timer shutdown shutdown issue.
- Several TCP calls no longer potentially free the passed inpcb/tcpcb,
so no longer need to return a pointer to indicate whether the argument
passed in is still valid.
- Un-macroize debugging and locking setup for various protocol switch
methods for TCP, as it lead to more obscurity, and as locking becomes
more customized to the methods, offers less benefit.
- Assert copyright on tcp_usrreq.c due to significant modifications that
have been made as part of this work.
These changes significantly modify the memory management and connection
logic of our TCP implementation, and are (as such) High Risk Changes,
and likely to contain serious bugs. Please report problems to the
current@ mailing list ASAP, ideally with simple test cases, and
optionally, packet traces.
MFC after: 3 months
2006-04-01 16:36:36 +00:00
|
|
|
static int tcp_timer_race;
|
|
|
|
SYSCTL_INT(_net_inet_tcp, OID_AUTO, timer_race, CTLFLAG_RD, &tcp_timer_race,
|
|
|
|
0, "Count of t_inpcb races on tcp_discardcb");
|
|
|
|
|
2007-09-07 09:19:22 +00:00
|
|
|
/*
|
|
|
|
* TCP timer processing.
|
|
|
|
*/
|
2007-04-11 09:45:16 +00:00
|
|
|
|
2007-09-07 09:19:22 +00:00
|
|
|
void
|
|
|
|
tcp_timer_delack(void *xtp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2007-09-07 09:19:22 +00:00
|
|
|
struct tcpcb *tp = xtp;
|
|
|
|
struct inpcb *inp;
|
1999-08-30 21:17:07 +00:00
|
|
|
|
2007-09-07 09:19:22 +00:00
|
|
|
INP_INFO_RLOCK(&tcbinfo);
|
|
|
|
inp = tp->t_inpcb;
|
Update TCP for infrastructural changes to the socket/pcb refcount model,
pru_abort(), pru_detach(), and in_pcbdetach():
- Universally support and enforce the invariant that so_pcb is
never NULL, converting dozens of unnecessary NULL checks into
assertions, and eliminating dozens of unnecessary error handling
cases in protocol code.
- In some cases, eliminate unnecessary pcbinfo locking, as it is no
longer required to ensure so_pcb != NULL. For example, the receive
code no longer requires the pcbinfo lock, and the send code only
requires it if building a new connection on an otherwise unconnected
socket triggered via sendto() with an address. This should
significnatly reduce tcbinfo lock contention in the receive and send
cases.
- In order to support the invariant that so_pcb != NULL, it is now
necessary for the TCP code to not discard the tcpcb any time a
connection is dropped, but instead leave the tcpcb until the socket
is shutdown. This case is handled by setting INP_DROPPED, to
substitute for using a NULL so_pcb to indicate that the connection
has been dropped. This requires the inpcb lock, but not the pcbinfo
lock.
- Unlike all other protocols in the tree, TCP may need to retain access
to the socket after the file descriptor has been closed. Set
SS_PROTOREF in tcp_detach() in order to prevent the socket from being
freed, and add a flag, INP_SOCKREF, so that the TCP code knows whether
or not it needs to free the socket when the connection finally does
close. The typical case where this occurs is if close() is called on
a TCP socket before all sent data in the send socket buffer has been
transmitted or acknowledged. If INP_SOCKREF is found when the
connection is dropped, we release the inpcb, tcpcb, and socket instead
of flagging INP_DROPPED.
- Abort and detach protocol switch methods no longer return failures,
nor attempt to free sockets, as the socket layer does this.
- Annotate the existence of a long-standing race in the TCP timer code,
in which timers are stopped but not drained when the socket is freed,
as waiting for drain may lead to deadlocks, or have to occur in a
context where waiting is not permitted. This race has been handled
by testing to see if the tcpcb pointer in the inpcb is NULL (and vice
versa), which is not normally permitted, but may be true of a inpcb
and tcpcb have been freed. Add a counter to test how often this race
has actually occurred, and a large comment for each instance where
we compare potentially freed memory with NULL. This will have to be
fixed in the near future, but requires is to further address how to
handle the timer shutdown shutdown issue.
- Several TCP calls no longer potentially free the passed inpcb/tcpcb,
so no longer need to return a pointer to indicate whether the argument
passed in is still valid.
- Un-macroize debugging and locking setup for various protocol switch
methods for TCP, as it lead to more obscurity, and as locking becomes
more customized to the methods, offers less benefit.
- Assert copyright on tcp_usrreq.c due to significant modifications that
have been made as part of this work.
These changes significantly modify the memory management and connection
logic of our TCP implementation, and are (as such) High Risk Changes,
and likely to contain serious bugs. Please report problems to the
current@ mailing list ASAP, ideally with simple test cases, and
optionally, packet traces.
MFC after: 3 months
2006-04-01 16:36:36 +00:00
|
|
|
/*
|
2007-09-07 09:19:22 +00:00
|
|
|
* XXXRW: While this assert is in fact correct, bugs in the tcpcb
|
|
|
|
* tear-down mean we need it as a work-around for races between
|
|
|
|
* timers and tcp_discardcb().
|
|
|
|
*
|
|
|
|
* KASSERT(inp != NULL, ("tcp_timer_delack: inp == NULL"));
|
2007-04-11 09:45:16 +00:00
|
|
|
*/
|
2007-09-07 09:19:22 +00:00
|
|
|
if (inp == NULL) {
|
|
|
|
tcp_timer_race++;
|
|
|
|
INP_INFO_RUNLOCK(&tcbinfo);
|
2002-12-24 21:00:31 +00:00
|
|
|
return;
|
|
|
|
}
|
2002-06-10 20:05:46 +00:00
|
|
|
INP_LOCK(inp);
|
2007-09-07 09:19:22 +00:00
|
|
|
INP_INFO_RUNLOCK(&tcbinfo);
|
2007-09-24 05:26:24 +00:00
|
|
|
if ((inp->inp_vflag & INP_DROPPED) || callout_pending(&tp->t_timers->tt_delack)
|
|
|
|
|| !callout_active(&tp->t_timers->tt_delack)) {
|
2007-09-07 09:19:22 +00:00
|
|
|
INP_UNLOCK(inp);
|
1999-08-30 21:17:07 +00:00
|
|
|
return;
|
|
|
|
}
|
2007-09-24 05:26:24 +00:00
|
|
|
callout_deactivate(&tp->t_timers->tt_delack);
|
1999-08-30 21:17:07 +00:00
|
|
|
|
|
|
|
tp->t_flags |= TF_ACKNOW;
|
|
|
|
tcpstat.tcps_delack++;
|
|
|
|
(void) tcp_output(tp);
|
2007-09-07 09:19:22 +00:00
|
|
|
INP_UNLOCK(inp);
|
1999-08-30 21:17:07 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2007-09-07 09:19:22 +00:00
|
|
|
void
|
|
|
|
tcp_timer_2msl(void *xtp)
|
1999-08-30 21:17:07 +00:00
|
|
|
{
|
2007-09-07 09:19:22 +00:00
|
|
|
struct tcpcb *tp = xtp;
|
|
|
|
struct inpcb *inp;
|
1999-08-30 21:17:07 +00:00
|
|
|
#ifdef TCPDEBUG
|
|
|
|
int ostate;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-08-30 21:17:07 +00:00
|
|
|
ostate = tp->t_state;
|
|
|
|
#endif
|
2007-09-07 09:19:22 +00:00
|
|
|
/*
|
|
|
|
* XXXRW: Does this actually happen?
|
|
|
|
*/
|
|
|
|
INP_INFO_WLOCK(&tcbinfo);
|
|
|
|
inp = tp->t_inpcb;
|
|
|
|
/*
|
|
|
|
* XXXRW: While this assert is in fact correct, bugs in the tcpcb
|
|
|
|
* tear-down mean we need it as a work-around for races between
|
|
|
|
* timers and tcp_discardcb().
|
|
|
|
*
|
|
|
|
* KASSERT(inp != NULL, ("tcp_timer_2msl: inp == NULL"));
|
|
|
|
*/
|
|
|
|
if (inp == NULL) {
|
|
|
|
tcp_timer_race++;
|
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
INP_LOCK(inp);
|
|
|
|
tcp_free_sackholes(tp);
|
2007-09-24 05:26:24 +00:00
|
|
|
if ((inp->inp_vflag & INP_DROPPED) || callout_pending(&tp->t_timers->tt_2msl) ||
|
|
|
|
!callout_active(&tp->t_timers->tt_2msl)) {
|
2007-09-07 09:19:22 +00:00
|
|
|
INP_UNLOCK(tp->t_inpcb);
|
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
|
|
|
return;
|
|
|
|
}
|
2007-09-24 05:26:24 +00:00
|
|
|
callout_deactivate(&tp->t_timers->tt_2msl);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 2 MSL timeout in shutdown went off. If we're closed but
|
|
|
|
* still waiting for peer to close and connection has been idle
|
|
|
|
* too long, or if 2MSL time is up from TIME_WAIT, delete connection
|
|
|
|
* control block. Otherwise, check again in a bit.
|
2007-02-26 22:25:21 +00:00
|
|
|
*
|
|
|
|
* If fastrecycle of FIN_WAIT_2, in FIN_WAIT_2 and receiver has closed,
|
|
|
|
* there's no point in hanging onto FIN_WAIT_2 socket. Just close it.
|
|
|
|
* Ignore fact that there were recent incoming segments.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2007-02-26 22:25:21 +00:00
|
|
|
if (tcp_fast_finwait2_recycle && tp->t_state == TCPS_FIN_WAIT_2 &&
|
2007-09-07 09:19:22 +00:00
|
|
|
tp->t_inpcb && tp->t_inpcb->inp_socket &&
|
2007-02-26 22:25:21 +00:00
|
|
|
(tp->t_inpcb->inp_socket->so_rcv.sb_state & SBS_CANTRCVMORE)) {
|
|
|
|
tcpstat.tcps_finwait2_drops++;
|
2007-09-07 09:19:22 +00:00
|
|
|
tp = tcp_close(tp);
|
2007-02-26 22:25:21 +00:00
|
|
|
} else {
|
|
|
|
if (tp->t_state != TCPS_TIME_WAIT &&
|
|
|
|
(ticks - tp->t_rcvtime) <= tcp_maxidle)
|
2007-09-24 05:26:24 +00:00
|
|
|
callout_reset(&tp->t_timers->tt_2msl, tcp_keepintvl,
|
2007-09-07 09:19:22 +00:00
|
|
|
tcp_timer_2msl, tp);
|
|
|
|
else
|
|
|
|
tp = tcp_close(tp);
|
|
|
|
}
|
1999-08-30 21:17:07 +00:00
|
|
|
|
|
|
|
#ifdef TCPDEBUG
|
2007-05-27 17:52:02 +00:00
|
|
|
if (tp->t_inpcb->inp_socket->so_options & SO_DEBUG)
|
2002-05-31 11:52:35 +00:00
|
|
|
tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,
|
|
|
|
PRU_SLOWTIMO);
|
1999-08-30 21:17:07 +00:00
|
|
|
#endif
|
2007-09-07 09:19:22 +00:00
|
|
|
if (tp != NULL)
|
|
|
|
INP_UNLOCK(inp);
|
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
1999-08-30 21:17:07 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2007-09-07 09:19:22 +00:00
|
|
|
void
|
|
|
|
tcp_timer_keep(void *xtp)
|
1999-08-30 21:17:07 +00:00
|
|
|
{
|
2007-09-07 09:19:22 +00:00
|
|
|
struct tcpcb *tp = xtp;
|
2001-06-23 03:21:46 +00:00
|
|
|
struct tcptemp *t_template;
|
2007-09-07 09:19:22 +00:00
|
|
|
struct inpcb *inp;
|
1999-08-30 21:17:07 +00:00
|
|
|
#ifdef TCPDEBUG
|
|
|
|
int ostate;
|
|
|
|
|
|
|
|
ostate = tp->t_state;
|
|
|
|
#endif
|
2007-09-07 09:19:22 +00:00
|
|
|
INP_INFO_WLOCK(&tcbinfo);
|
|
|
|
inp = tp->t_inpcb;
|
|
|
|
/*
|
|
|
|
* XXXRW: While this assert is in fact correct, bugs in the tcpcb
|
|
|
|
* tear-down mean we need it as a work-around for races between
|
|
|
|
* timers and tcp_discardcb().
|
|
|
|
*
|
|
|
|
* KASSERT(inp != NULL, ("tcp_timer_keep: inp == NULL"));
|
|
|
|
*/
|
|
|
|
if (inp == NULL) {
|
|
|
|
tcp_timer_race++;
|
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
INP_LOCK(inp);
|
2007-09-24 05:26:24 +00:00
|
|
|
if ((inp->inp_vflag & INP_DROPPED) || callout_pending(&tp->t_timers->tt_keep)
|
|
|
|
|| !callout_active(&tp->t_timers->tt_keep)) {
|
2007-09-07 09:19:22 +00:00
|
|
|
INP_UNLOCK(inp);
|
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
|
|
|
return;
|
|
|
|
}
|
2007-09-24 05:26:24 +00:00
|
|
|
callout_deactivate(&tp->t_timers->tt_keep);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1999-08-30 21:17:07 +00:00
|
|
|
* Keep-alive timer went off; send something
|
|
|
|
* or drop connection if idle for too long.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1999-08-30 21:17:07 +00:00
|
|
|
tcpstat.tcps_keeptimeo++;
|
|
|
|
if (tp->t_state < TCPS_ESTABLISHED)
|
|
|
|
goto dropit;
|
2003-11-08 22:57:13 +00:00
|
|
|
if ((always_keepalive || inp->inp_socket->so_options & SO_KEEPALIVE) &&
|
1999-08-30 21:17:07 +00:00
|
|
|
tp->t_state <= TCPS_CLOSING) {
|
|
|
|
if ((ticks - tp->t_rcvtime) >= tcp_keepidle + tcp_maxidle)
|
|
|
|
goto dropit;
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1999-08-30 21:17:07 +00:00
|
|
|
* Send a packet designed to force a response
|
|
|
|
* if the peer is up and reachable:
|
|
|
|
* either an ACK if the connection is still alive,
|
|
|
|
* or an RST if the peer has closed the connection
|
|
|
|
* due to timeout or reboot.
|
|
|
|
* Using sequence number tp->snd_una-1
|
|
|
|
* causes the transmitted zero-length segment
|
|
|
|
* to lie outside the receive window;
|
|
|
|
* by the protocol spec, this requires the
|
|
|
|
* correspondent TCP to respond.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1999-08-30 21:17:07 +00:00
|
|
|
tcpstat.tcps_keepprobe++;
|
2003-02-19 22:18:06 +00:00
|
|
|
t_template = tcpip_maketemplate(inp);
|
2001-06-23 03:21:46 +00:00
|
|
|
if (t_template) {
|
|
|
|
tcp_respond(tp, t_template->tt_ipgen,
|
|
|
|
&t_template->tt_t, (struct mbuf *)NULL,
|
|
|
|
tp->rcv_nxt, tp->snd_una - 1, 0);
|
|
|
|
(void) m_free(dtom(t_template));
|
|
|
|
}
|
2007-09-24 05:26:24 +00:00
|
|
|
callout_reset(&tp->t_timers->tt_keep, tcp_keepintvl, tcp_timer_keep, tp);
|
2002-05-31 11:52:35 +00:00
|
|
|
} else
|
2007-09-24 05:26:24 +00:00
|
|
|
callout_reset(&tp->t_timers->tt_keep, tcp_keepidle, tcp_timer_keep, tp);
|
1999-08-30 21:17:07 +00:00
|
|
|
|
|
|
|
#ifdef TCPDEBUG
|
2003-11-08 22:57:13 +00:00
|
|
|
if (inp->inp_socket->so_options & SO_DEBUG)
|
2000-01-09 19:17:30 +00:00
|
|
|
tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,
|
1999-08-30 21:17:07 +00:00
|
|
|
PRU_SLOWTIMO);
|
|
|
|
#endif
|
2007-09-07 09:19:22 +00:00
|
|
|
INP_UNLOCK(inp);
|
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
|
|
|
return;
|
1999-08-30 21:17:07 +00:00
|
|
|
|
|
|
|
dropit:
|
|
|
|
tcpstat.tcps_keepdrops++;
|
2007-09-07 09:19:22 +00:00
|
|
|
tp = tcp_drop(tp, ETIMEDOUT);
|
|
|
|
|
|
|
|
#ifdef TCPDEBUG
|
|
|
|
if (tp != NULL && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
|
|
|
|
tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,
|
|
|
|
PRU_SLOWTIMO);
|
|
|
|
#endif
|
|
|
|
if (tp != NULL)
|
|
|
|
INP_UNLOCK(tp->t_inpcb);
|
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
1999-08-30 21:17:07 +00:00
|
|
|
}
|
|
|
|
|
2007-09-07 09:19:22 +00:00
|
|
|
void
|
|
|
|
tcp_timer_persist(void *xtp)
|
1999-08-30 21:17:07 +00:00
|
|
|
{
|
2007-09-07 09:19:22 +00:00
|
|
|
struct tcpcb *tp = xtp;
|
|
|
|
struct inpcb *inp;
|
1999-08-30 21:17:07 +00:00
|
|
|
#ifdef TCPDEBUG
|
|
|
|
int ostate;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-08-30 21:17:07 +00:00
|
|
|
ostate = tp->t_state;
|
|
|
|
#endif
|
2007-09-07 09:19:22 +00:00
|
|
|
INP_INFO_WLOCK(&tcbinfo);
|
|
|
|
inp = tp->t_inpcb;
|
|
|
|
/*
|
|
|
|
* XXXRW: While this assert is in fact correct, bugs in the tcpcb
|
|
|
|
* tear-down mean we need it as a work-around for races between
|
|
|
|
* timers and tcp_discardcb().
|
|
|
|
*
|
|
|
|
* KASSERT(inp != NULL, ("tcp_timer_persist: inp == NULL"));
|
|
|
|
*/
|
|
|
|
if (inp == NULL) {
|
|
|
|
tcp_timer_race++;
|
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
INP_LOCK(inp);
|
2007-09-24 05:26:24 +00:00
|
|
|
if ((inp->inp_vflag & INP_DROPPED) || callout_pending(&tp->t_timers->tt_persist)
|
|
|
|
|| !callout_active(&tp->t_timers->tt_persist)) {
|
2007-09-07 09:19:22 +00:00
|
|
|
INP_UNLOCK(inp);
|
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
|
|
|
return;
|
|
|
|
}
|
2007-09-24 05:26:24 +00:00
|
|
|
callout_deactivate(&tp->t_timers->tt_persist);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Persistance timer into zero window.
|
|
|
|
* Force a byte to be output, if possible.
|
|
|
|
*/
|
1999-08-30 21:17:07 +00:00
|
|
|
tcpstat.tcps_persisttimeo++;
|
|
|
|
/*
|
|
|
|
* Hack: if the peer is dead/unreachable, we do not
|
|
|
|
* time out if the window is closed. After a full
|
|
|
|
* backoff, drop the connection if the idle time
|
|
|
|
* (no responses to probes) reaches the maximum
|
|
|
|
* backoff that we would use if retransmitting.
|
|
|
|
*/
|
|
|
|
if (tp->t_rxtshift == TCP_MAXRXTSHIFT &&
|
|
|
|
((ticks - tp->t_rcvtime) >= tcp_maxpersistidle ||
|
|
|
|
(ticks - tp->t_rcvtime) >= TCP_REXMTVAL(tp) * tcp_totbackoff)) {
|
|
|
|
tcpstat.tcps_persistdrop++;
|
2007-09-07 09:19:22 +00:00
|
|
|
tp = tcp_drop(tp, ETIMEDOUT);
|
|
|
|
goto out;
|
1999-08-30 21:17:07 +00:00
|
|
|
}
|
|
|
|
tcp_setpersist(tp);
|
2005-05-21 00:38:29 +00:00
|
|
|
tp->t_flags |= TF_FORCEDATA;
|
1999-08-30 21:17:07 +00:00
|
|
|
(void) tcp_output(tp);
|
2005-05-21 00:38:29 +00:00
|
|
|
tp->t_flags &= ~TF_FORCEDATA;
|
1999-08-30 21:17:07 +00:00
|
|
|
|
2007-09-07 09:19:22 +00:00
|
|
|
out:
|
1999-08-30 21:17:07 +00:00
|
|
|
#ifdef TCPDEBUG
|
2006-05-16 10:51:26 +00:00
|
|
|
if (tp != NULL && tp->t_inpcb->inp_socket->so_options & SO_DEBUG)
|
|
|
|
tcp_trace(TA_USER, ostate, tp, NULL, NULL, PRU_SLOWTIMO);
|
1999-08-30 21:17:07 +00:00
|
|
|
#endif
|
2007-09-07 09:19:22 +00:00
|
|
|
if (tp != NULL)
|
|
|
|
INP_UNLOCK(inp);
|
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
1999-08-30 21:17:07 +00:00
|
|
|
}
|
|
|
|
|
2007-09-07 09:19:22 +00:00
|
|
|
void
|
|
|
|
tcp_timer_rexmt(void * xtp)
|
1999-08-30 21:17:07 +00:00
|
|
|
{
|
2007-09-07 09:19:22 +00:00
|
|
|
struct tcpcb *tp = xtp;
|
1999-08-30 21:17:07 +00:00
|
|
|
int rexmt;
|
2007-09-07 09:19:22 +00:00
|
|
|
int headlocked;
|
|
|
|
struct inpcb *inp;
|
1999-08-30 21:17:07 +00:00
|
|
|
#ifdef TCPDEBUG
|
|
|
|
int ostate;
|
|
|
|
|
|
|
|
ostate = tp->t_state;
|
|
|
|
#endif
|
2007-09-07 09:19:22 +00:00
|
|
|
INP_INFO_WLOCK(&tcbinfo);
|
|
|
|
headlocked = 1;
|
|
|
|
inp = tp->t_inpcb;
|
|
|
|
/*
|
|
|
|
* XXXRW: While this assert is in fact correct, bugs in the tcpcb
|
|
|
|
* tear-down mean we need it as a work-around for races between
|
|
|
|
* timers and tcp_discardcb().
|
|
|
|
*
|
|
|
|
* KASSERT(inp != NULL, ("tcp_timer_rexmt: inp == NULL"));
|
|
|
|
*/
|
|
|
|
if (inp == NULL) {
|
|
|
|
tcp_timer_race++;
|
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
INP_LOCK(inp);
|
2007-09-24 05:26:24 +00:00
|
|
|
if ((inp->inp_vflag & INP_DROPPED) || callout_pending(&tp->t_timers->tt_rexmt)
|
|
|
|
|| !callout_active(&tp->t_timers->tt_rexmt)) {
|
2007-09-07 09:19:22 +00:00
|
|
|
INP_UNLOCK(inp);
|
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
|
|
|
return;
|
|
|
|
}
|
2007-09-24 05:26:24 +00:00
|
|
|
callout_deactivate(&tp->t_timers->tt_rexmt);
|
2004-06-23 21:04:37 +00:00
|
|
|
tcp_free_sackholes(tp);
|
1999-08-30 21:17:07 +00:00
|
|
|
/*
|
|
|
|
* Retransmission timer went off. Message has not
|
|
|
|
* been acked within retransmit interval. Back off
|
|
|
|
* to a longer retransmit interval and retransmit one segment.
|
|
|
|
*/
|
|
|
|
if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {
|
|
|
|
tp->t_rxtshift = TCP_MAXRXTSHIFT;
|
|
|
|
tcpstat.tcps_timeoutdrop++;
|
2007-09-07 09:19:22 +00:00
|
|
|
tp = tcp_drop(tp, tp->t_softerror ?
|
|
|
|
tp->t_softerror : ETIMEDOUT);
|
|
|
|
goto out;
|
1999-08-30 21:17:07 +00:00
|
|
|
}
|
2007-09-07 09:19:22 +00:00
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
|
|
|
headlocked = 0;
|
1999-08-30 21:17:07 +00:00
|
|
|
if (tp->t_rxtshift == 1) {
|
1995-07-29 18:48:44 +00:00
|
|
|
/*
|
1999-08-30 21:17:07 +00:00
|
|
|
* first retransmit; record ssthresh and cwnd so they can
|
2004-08-16 18:32:07 +00:00
|
|
|
* be recovered if this turns out to be a "bad" retransmit.
|
|
|
|
* A retransmit is considered "bad" if an ACK for this
|
1999-08-30 21:17:07 +00:00
|
|
|
* segment is received within RTT/2 interval; the assumption
|
2004-08-16 18:32:07 +00:00
|
|
|
* here is that the ACK was already in flight. See
|
1999-08-30 21:17:07 +00:00
|
|
|
* "On Estimating End-to-End Network Path Properties" by
|
|
|
|
* Allman and Paxson for more details.
|
1995-07-29 18:48:44 +00:00
|
|
|
*/
|
1999-08-30 21:17:07 +00:00
|
|
|
tp->snd_cwnd_prev = tp->snd_cwnd;
|
|
|
|
tp->snd_ssthresh_prev = tp->snd_ssthresh;
|
2003-07-15 21:49:53 +00:00
|
|
|
tp->snd_recover_prev = tp->snd_recover;
|
|
|
|
if (IN_FASTRECOVERY(tp))
|
2007-09-07 09:19:22 +00:00
|
|
|
tp->t_flags |= TF_WASFRECOVERY;
|
2003-07-15 21:49:53 +00:00
|
|
|
else
|
2007-09-07 09:19:22 +00:00
|
|
|
tp->t_flags &= ~TF_WASFRECOVERY;
|
1999-08-30 21:17:07 +00:00
|
|
|
tp->t_badrxtwin = ticks + (tp->t_srtt >> (TCP_RTT_SHIFT + 1));
|
|
|
|
}
|
|
|
|
tcpstat.tcps_rexmttimeo++;
|
2001-02-26 21:33:55 +00:00
|
|
|
if (tp->t_state == TCPS_SYN_SENT)
|
|
|
|
rexmt = TCP_REXMTVAL(tp) * tcp_syn_backoff[tp->t_rxtshift];
|
|
|
|
else
|
|
|
|
rexmt = TCP_REXMTVAL(tp) * tcp_backoff[tp->t_rxtshift];
|
1999-08-30 21:17:07 +00:00
|
|
|
TCPT_RANGESET(tp->t_rxtcur, rexmt,
|
|
|
|
tp->t_rttmin, TCPTV_REXMTMAX);
|
2001-05-31 19:24:49 +00:00
|
|
|
/*
|
2004-11-02 22:22:22 +00:00
|
|
|
* Disable rfc1323 if we havn't got any response to
|
2004-08-16 18:32:07 +00:00
|
|
|
* our third SYN to work-around some broken terminal servers
|
|
|
|
* (most of which have hopefully been retired) that have bad VJ
|
|
|
|
* header compression code which trashes TCP segments containing
|
2001-05-31 19:24:49 +00:00
|
|
|
* unknown-to-them TCP options.
|
|
|
|
*/
|
|
|
|
if ((tp->t_state == TCPS_SYN_SENT) && (tp->t_rxtshift == 3))
|
2004-11-02 22:22:22 +00:00
|
|
|
tp->t_flags &= ~(TF_REQ_SCALE|TF_REQ_TSTMP);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2003-11-20 20:07:39 +00:00
|
|
|
* If we backed off this far, our srtt estimate is probably bogus.
|
|
|
|
* Clobber it so we'll take the next rtt measurement as our srtt;
|
1999-08-30 21:17:07 +00:00
|
|
|
* move the current srtt into rttvar to keep the current
|
|
|
|
* retransmit times until then.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1999-08-30 21:17:07 +00:00
|
|
|
if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) {
|
2000-01-09 19:17:30 +00:00
|
|
|
#ifdef INET6
|
|
|
|
if ((tp->t_inpcb->inp_vflag & INP_IPV6) != 0)
|
|
|
|
in6_losing(tp->t_inpcb);
|
|
|
|
else
|
|
|
|
#endif
|
1999-08-30 21:17:07 +00:00
|
|
|
tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT);
|
|
|
|
tp->t_srtt = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1999-08-30 21:17:07 +00:00
|
|
|
tp->snd_nxt = tp->snd_una;
|
2003-07-15 21:49:53 +00:00
|
|
|
tp->snd_recover = tp->snd_max;
|
1999-08-30 21:17:07 +00:00
|
|
|
/*
|
|
|
|
* Force a segment to be sent.
|
|
|
|
*/
|
|
|
|
tp->t_flags |= TF_ACKNOW;
|
|
|
|
/*
|
|
|
|
* If timing a segment in this window, stop the timer.
|
|
|
|
*/
|
|
|
|
tp->t_rtttime = 0;
|
|
|
|
/*
|
|
|
|
* Close the congestion window down to one segment
|
|
|
|
* (we'll open it by one segment for each ack we get).
|
|
|
|
* Since we probably have a window's worth of unacked
|
|
|
|
* data accumulated, this "slow start" keeps us from
|
|
|
|
* dumping all that data as back-to-back packets (which
|
|
|
|
* might overwhelm an intermediate gateway).
|
|
|
|
*
|
|
|
|
* There are two phases to the opening: Initially we
|
|
|
|
* open by one mss on each ack. This makes the window
|
|
|
|
* size increase exponentially with time. If the
|
|
|
|
* window is larger than the path can handle, this
|
|
|
|
* exponential growth results in dropped packet(s)
|
|
|
|
* almost immediately. To get more time between
|
|
|
|
* drops but still "push" the network to take advantage
|
|
|
|
* of improving conditions, we switch from exponential
|
|
|
|
* to linear window opening at some threshhold size.
|
|
|
|
* For a threshhold, we use half the current window
|
|
|
|
* size, truncated to a multiple of the mss.
|
|
|
|
*
|
|
|
|
* (the minimum cwnd that will give us exponential
|
|
|
|
* growth is 2 mss. We don't allow the threshhold
|
|
|
|
* to go below this.)
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
u_int win = min(tp->snd_wnd, tp->snd_cwnd) / 2 / tp->t_maxseg;
|
|
|
|
if (win < 2)
|
|
|
|
win = 2;
|
|
|
|
tp->snd_cwnd = tp->t_maxseg;
|
|
|
|
tp->snd_ssthresh = win * tp->t_maxseg;
|
|
|
|
tp->t_dupacks = 0;
|
|
|
|
}
|
2003-07-15 21:49:53 +00:00
|
|
|
EXIT_FASTRECOVERY(tp);
|
1999-08-30 21:17:07 +00:00
|
|
|
(void) tcp_output(tp);
|
|
|
|
|
2007-09-07 09:19:22 +00:00
|
|
|
out:
|
1999-08-30 21:17:07 +00:00
|
|
|
#ifdef TCPDEBUG
|
2006-03-26 01:33:41 +00:00
|
|
|
if (tp != NULL && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
|
2002-05-31 11:52:35 +00:00
|
|
|
tcp_trace(TA_USER, ostate, tp, (void *)0, (struct tcphdr *)0,
|
|
|
|
PRU_SLOWTIMO);
|
1999-08-30 21:17:07 +00:00
|
|
|
#endif
|
2007-09-07 09:19:22 +00:00
|
|
|
if (tp != NULL)
|
|
|
|
INP_UNLOCK(inp);
|
|
|
|
if (headlocked)
|
|
|
|
INP_INFO_WUNLOCK(&tcbinfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
tcp_timer_activate(struct tcpcb *tp, int timer_type, u_int delta)
|
|
|
|
{
|
|
|
|
struct callout *t_callout;
|
|
|
|
void *f_callout;
|
|
|
|
|
|
|
|
switch (timer_type) {
|
|
|
|
case TT_DELACK:
|
2007-09-24 05:26:24 +00:00
|
|
|
t_callout = &tp->t_timers->tt_delack;
|
2007-09-07 09:19:22 +00:00
|
|
|
f_callout = tcp_timer_delack;
|
|
|
|
break;
|
|
|
|
case TT_REXMT:
|
2007-09-24 05:26:24 +00:00
|
|
|
t_callout = &tp->t_timers->tt_rexmt;
|
2007-09-07 09:19:22 +00:00
|
|
|
f_callout = tcp_timer_rexmt;
|
|
|
|
break;
|
|
|
|
case TT_PERSIST:
|
2007-09-24 05:26:24 +00:00
|
|
|
t_callout = &tp->t_timers->tt_persist;
|
2007-09-07 09:19:22 +00:00
|
|
|
f_callout = tcp_timer_persist;
|
|
|
|
break;
|
|
|
|
case TT_KEEP:
|
2007-09-24 05:26:24 +00:00
|
|
|
t_callout = &tp->t_timers->tt_keep;
|
2007-09-07 09:19:22 +00:00
|
|
|
f_callout = tcp_timer_keep;
|
|
|
|
break;
|
|
|
|
case TT_2MSL:
|
2007-09-24 05:26:24 +00:00
|
|
|
t_callout = &tp->t_timers->tt_2msl;
|
2007-09-07 09:19:22 +00:00
|
|
|
f_callout = tcp_timer_2msl;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
panic("bad timer_type");
|
|
|
|
}
|
|
|
|
if (delta == 0) {
|
|
|
|
callout_stop(t_callout);
|
|
|
|
} else {
|
|
|
|
callout_reset(t_callout, delta, f_callout, tp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
tcp_timer_active(struct tcpcb *tp, int timer_type)
|
|
|
|
{
|
|
|
|
struct callout *t_callout;
|
|
|
|
|
|
|
|
switch (timer_type) {
|
|
|
|
case TT_DELACK:
|
2007-09-24 05:26:24 +00:00
|
|
|
t_callout = &tp->t_timers->tt_delack;
|
2007-09-07 09:19:22 +00:00
|
|
|
break;
|
|
|
|
case TT_REXMT:
|
2007-09-24 05:26:24 +00:00
|
|
|
t_callout = &tp->t_timers->tt_rexmt;
|
2007-09-07 09:19:22 +00:00
|
|
|
break;
|
|
|
|
case TT_PERSIST:
|
2007-09-24 05:26:24 +00:00
|
|
|
t_callout = &tp->t_timers->tt_persist;
|
2007-09-07 09:19:22 +00:00
|
|
|
break;
|
|
|
|
case TT_KEEP:
|
2007-09-24 05:26:24 +00:00
|
|
|
t_callout = &tp->t_timers->tt_keep;
|
2007-09-07 09:19:22 +00:00
|
|
|
break;
|
|
|
|
case TT_2MSL:
|
2007-09-24 05:26:24 +00:00
|
|
|
t_callout = &tp->t_timers->tt_2msl;
|
2007-09-07 09:19:22 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
panic("bad timer_type");
|
|
|
|
}
|
|
|
|
return callout_active(t_callout);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|