use timeout(9) to schedule TCP timers. this avoid traversing all

tcp connections during tcp_slowtimo.  apdapted from thorpej@netbsd.org

7 files changed, 299 insertions, 305 deletions

diff --git a/sys/netinet/tcp_input.c b/sys/netinet/tcp_input.c
index 60394196464..302167307bf 100644
--- a/sys/netinet/tcp_input.c
+++ b/sys/netinet/tcp_input.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: tcp_input.c,v 1.106 2002/03/02 00:44:52 provos Exp $	*/
+/*	$OpenBSD: tcp_input.c,v 1.107 2002/03/08 03:49:58 provos Exp $	*/
 /*	$NetBSD: tcp_input.c,v 1.23 1996/02/13 23:43:44 christos Exp $	*/
 
 /*
@@ -79,6 +79,7 @@
 #include <sys/protosw.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
+#include <sys/kernel.h>
 
 #include <net/if.h>
 #include <net/route.h>
@@ -877,7 +878,7 @@ findpcb:
 	 * Segment received on connection.
 	 * Reset idle time and keep-alive timer.
 	 */
-	tp->t_idle = 0;
+	tp->t_rcvtime = tcp_now;
 	if (tp->t_state != TCPS_SYN_RECEIVED)
 		TCP_TIMER_ARM(tp, TCPT_KEEP, tcp_keepidle);
 
@@ -942,9 +943,10 @@ findpcb:
 				++tcpstat.tcps_predack;
 				if (ts_present)
 					tcp_xmit_timer(tp, tcp_now-ts_ecr+1);
-				else if (tp->t_rtt &&
+				else if (tp->t_rtttime &&
 					    SEQ_GT(th->th_ack, tp->t_rtseq))
-					tcp_xmit_timer(tp, tp->t_rtt);
+					tcp_xmit_timer(tp,
+					    tcp_now - tp->t_rtttime);
 				acked = th->th_ack - tp->snd_una;
 				tcpstat.tcps_rcvackpack++;
 				tcpstat.tcps_rcvackbyte += acked;
@@ -1287,8 +1289,8 @@ findpcb:
 			 * if we didn't have to retransmit the SYN,
 			 * use its rtt as our initial srtt & rtt var.
 			 */
-			if (tp->t_rtt)
-				tcp_xmit_timer(tp, tp->t_rtt);
+			if (tp->t_rtttime)
+				tcp_xmit_timer(tp, tcp_now - tp->t_rtttime);
 			/*
 			 * Since new data was acked (the SYN), open the
 			 * congestion window by one MSS.  We do this
@@ -1645,7 +1647,7 @@ trimthenstep6:
 #ifdef TCP_SACK
                     			if (!tp->sack_disable) {
 						TCP_TIMER_DISARM(tp, TCPT_REXMT);
-						tp->t_rtt = 0;
+						tp->t_rtttime = 0;
 						tcpstat.tcps_sndrexmitfast++;
 #if defined(TCP_SACK) && defined(TCP_FACK) 
 						tp->t_dupacks = tcprexmtthresh;
@@ -1668,7 +1670,7 @@ trimthenstep6:
 					}
 #endif /* TCP_SACK */
 					TCP_TIMER_DISARM(tp, TCPT_REXMT);
-					tp->t_rtt = 0;
+					tp->t_rtttime = 0;
 					tp->snd_nxt = th->th_ack;
 					tp->snd_cwnd = tp->t_maxseg;
 					tcpstat.tcps_sndrexmitfast++;
@@ -1778,8 +1780,8 @@ trimthenstep6:
 		 */
 		if (ts_present)
 			tcp_xmit_timer(tp, tcp_now-ts_ecr+1);
-		else if (tp->t_rtt && SEQ_GT(th->th_ack, tp->t_rtseq))
-			tcp_xmit_timer(tp,tp->t_rtt);
+		else if (tp->t_rtttime && SEQ_GT(th->th_ack, tp->t_rtseq))
+			tcp_xmit_timer(tp, tcp_now - tp->t_rtttime);
 
 		/*
 		 * If all outstanding data is acked, stop retransmit
@@ -2664,7 +2666,7 @@ tcp_sack_partialack(tp, th)
 	if (SEQ_LT(th->th_ack, tp->snd_last)) {
 		/* Turn off retx. timer (will start again next segment) */
 		TCP_TIMER_DISARM(tp, TCPT_REXMT);
-		tp->t_rtt = 0;
+		tp->t_rtttime = 0;
 #ifndef TCP_FACK
 		/* 
 		 * Partial window deflation.  This statement relies on the 
@@ -2766,7 +2768,7 @@ tcp_xmit_timer(tp, rtt)
 		tp->t_srtt = rtt << (TCP_RTT_SHIFT + 2);
 		tp->t_rttvar = rtt << (TCP_RTTVAR_SHIFT + 2 - 1);
 	}
-	tp->t_rtt = 0;
+	tp->t_rtttime = 0;
 	tp->t_rxtshift = 0;
 
 	/*
@@ -3085,7 +3087,7 @@ tcp_newreno(tp, th)
 		tcp_seq onxt = tp->snd_nxt;
 		u_long  ocwnd = tp->snd_cwnd;
 		TCP_TIMER_DISARM(tp, TCPT_REXMT);
-		tp->t_rtt = 0;
+		tp->t_rtttime = 0;
 		tp->snd_nxt = th->th_ack;
 		/* 
 		 * Set snd_cwnd to one segment beyond acknowledged offset
diff --git a/sys/netinet/tcp_output.c b/sys/netinet/tcp_output.c
index 83b71bf0058..625bca510c8 100644
--- a/sys/netinet/tcp_output.c
+++ b/sys/netinet/tcp_output.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: tcp_output.c,v 1.48 2002/03/01 22:29:29 provos Exp $	*/
+/*	$OpenBSD: tcp_output.c,v 1.49 2002/03/08 03:49:58 provos Exp $	*/
 /*	$NetBSD: tcp_output.c,v 1.16 1997/06/03 16:17:09 kml Exp $	*/
 
 /*
@@ -78,6 +78,7 @@
 #include <sys/protosw.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
+#include <sys/kernel.h>
 
 #include <net/route.h>
 #include <net/if.h>
@@ -249,7 +250,7 @@ tcp_output(tp)
 	 * to send, then transmit; otherwise, investigate further.
 	 */
 	idle = (tp->snd_max == tp->snd_una);
-	if (idle && tp->t_idle >= tp->t_rxtcur)
+	if (idle && (tcp_now - tp->t_rcvtime) >= tp->t_rxtcur)
 		/*
 		 * We have been idle for "a while" and no acks are
 		 * expected to clock out any data we send --
@@ -982,8 +983,8 @@ send:
 			 * Time this transmission if not a retransmission and
 			 * not currently timing anything.
 			 */
-			if (tp->t_rtt == 0) {
-				tp->t_rtt = 1;
+			if (tp->t_rtttime == 0) {
+				tp->t_rtttime = tcp_now;
 				tp->t_rtseq = startseq;
 				tcpstat.tcps_segstimed++;
 			}
diff --git a/sys/netinet/tcp_subr.c b/sys/netinet/tcp_subr.c
index 77e5d4def27..7c4667ca83c 100644
--- a/sys/netinet/tcp_subr.c
+++ b/sys/netinet/tcp_subr.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: tcp_subr.c,v 1.59 2002/03/02 00:44:52 provos Exp $	*/
+/*	$OpenBSD: tcp_subr.c,v 1.60 2002/03/08 03:49:58 provos Exp $	*/
 /*	$NetBSD: tcp_subr.c,v 1.22 1996/02/13 23:44:00 christos Exp $	*/
 
 /*
@@ -670,6 +670,7 @@ tcp_close(struct tcpcb *tp)
 	/* free the reassembly queue, if any */
 	tcp_freeq(tp);
 
+	tcp_canceltimers(tp);
 	TCP_CLEAR_DELACK(tp);
 
 #ifdef TCP_SACK
diff --git a/sys/netinet/tcp_timer.c b/sys/netinet/tcp_timer.c
index f05bd00cfef..5b86cac3218 100644
--- a/sys/netinet/tcp_timer.c
+++ b/sys/netinet/tcp_timer.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: tcp_timer.c,v 1.27 2002/03/01 22:29:29 provos Exp $	*/
+/*	$OpenBSD: tcp_timer.c,v 1.28 2002/03/08 03:49:58 provos Exp $	*/
 /*	$NetBSD: tcp_timer.c,v 1.14 1996/02/13 23:44:09 christos Exp $	*/
 
 /*
@@ -68,6 +68,18 @@ int	tcp_maxidle;
  */
 int	tcp_delack_ticks;
 
+void	tcp_timer_rexmt(void *);
+void	tcp_timer_persist(void *);
+void	tcp_timer_keep(void *);
+void	tcp_timer_2msl(void *);
+
+const tcp_timer_func_t tcp_timer_funcs[TCPT_NTIMERS] = {
+	tcp_timer_rexmt,
+	tcp_timer_persist,
+	tcp_timer_keep,
+	tcp_timer_2msl,
+};
+
 /*
  * Timer state initialization, called from tcp_init().
  */
@@ -117,44 +129,10 @@ tcp_delack(void *arg)
 void
 tcp_slowtimo()
 {
-	register struct inpcb *ip, *ipnxt;
-	register struct tcpcb *tp;
 	int s;
-	register long i;
 
 	s = splsoftnet();
 	tcp_maxidle = TCPTV_KEEPCNT * tcp_keepintvl;
-	/*
-	 * Search through tcb's and update active timers.
-	 */
-	ip = tcbtable.inpt_queue.cqh_first;
-	if (ip == (struct inpcb *)0) {				/* XXX */
-		splx(s);
-		return;
-	}
-	for (; ip != (struct inpcb *)&tcbtable.inpt_queue; ip = ipnxt) {
-		ipnxt = ip->inp_queue.cqe_next;
-		tp = intotcpcb(ip);
-		if (tp == 0 || tp->t_state == TCPS_LISTEN)
-			continue;
-		for (i = 0; i < TCPT_NTIMERS; i++) {
-			if (tp->t_timer[i] && --tp->t_timer[i] == 0) {
-				(void) tcp_usrreq(tp->t_inpcb->inp_socket,
-				    PRU_SLOWTIMO, (struct mbuf *)0,
-				    (struct mbuf *)i, (struct mbuf *)0);
-				/* XXX NOT MP SAFE */
-				if ((ipnxt == (void *)&tcbtable.inpt_queue &&
-				    tcbtable.inpt_queue.cqh_last != ip) ||
-				    ipnxt->inp_queue.cqe_prev != ip)
-					goto tpgone;
-			}
-		}
-		tp->t_idle++;
-		if (tp->t_rtt)
-			tp->t_rtt++;
-tpgone:
-		;
-	}
 #ifdef TCP_COMPAT_42
 	tcp_iss += TCP_ISSINCR/PR_SLOWHZ;		/* increment iss */
 	if ((int)tcp_iss < 0)
@@ -163,7 +141,6 @@ tpgone:
 	tcp_now++;					/* for timestamps */
 	splx(s);
 }
-#ifndef TUBA_INCLUDE
 
 /*
  * Cancel all timers for TCP tp.
@@ -186,266 +163,285 @@ int tcp_totbackoff = 511;	/* sum of tcp_backoff[] */
 /*
  * TCP timer processing.
  */
-struct tcpcb *
-tcp_timers(tp, timer)
-	register struct tcpcb *tp;
-	int timer;
-{
-	short rto;
+
 #ifdef TCP_SACK
+void	tcp_timer_freesack(struct tcpcb *);
+
+void
+tcp_timer_freesack(struct tcpcb *tp)
+{
 	struct sackhole *p, *q;
 	/*
 	 * Free SACK holes for 2MSL and REXMT timers.
 	 */
-	if (timer == TCPT_2MSL || timer == TCPT_REXMT) {
-		q = tp->snd_holes;
-		while (q != NULL) {
-			p = q;
-			q = q->next;
-			pool_put(&sackhl_pool, p);
-		}
-		tp->snd_holes = 0;
-#if defined(TCP_SACK) && defined(TCP_FACK)
-		tp->snd_fack = tp->snd_una;
-		tp->retran_data = 0;
-		tp->snd_awnd = 0;
-#endif /* TCP_FACK */
+	q = tp->snd_holes;
+	while (q != NULL) {
+		p = q;
+		q = q->next;
+		pool_put(&sackhl_pool, p);
 	}
+	tp->snd_holes = 0;
+#ifdef TCP_FACK
+	tp->snd_fack = tp->snd_una;
+	tp->retran_data = 0;
+	tp->snd_awnd = 0;
+#endif /* TCP_FACK */
+}
 #endif /* TCP_SACK */
 
-	switch (timer) {
+void
+tcp_timer_rexmt(void *arg)
+{
+	struct tcpcb *tp = arg;
+	uint32_t rto;
+	int s;
 
-	/*
-	 * 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.
-	 */
-	case TCPT_2MSL:
-		if (tp->t_state != TCPS_TIME_WAIT &&
-		    tp->t_idle <= tcp_maxidle)
-			TCP_TIMER_ARM(tp, TCPT_2MSL, tcp_keepintvl);
-		else
-			tp = tcp_close(tp);
-		break;
+	s = splsoftnet();
 
-	/*
-	 * Retransmission timer went off.  Message has not
-	 * been acked within retransmit interval.  Back off
-	 * to a longer retransmit interval and retransmit one segment.
+#ifdef TCP_SACK
+	tcp_timer_freesack(tp);
+#endif
+	if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {
+		tp->t_rxtshift = TCP_MAXRXTSHIFT;
+		tcpstat.tcps_timeoutdrop++;
+		tp = tcp_drop(tp, tp->t_softerror ?
+		    tp->t_softerror : ETIMEDOUT);
+		goto out;
+	}
+	tcpstat.tcps_rexmttimeo++;
+	rto = TCP_REXMTVAL(tp);
+	if (rto < tp->t_rttmin)
+		rto = tp->t_rttmin;
+	TCPT_RANGESET((long) tp->t_rxtcur,
+	    rto * tcp_backoff[tp->t_rxtshift],
+	    tp->t_rttmin, TCPTV_REXMTMAX);
+	TCP_TIMER_ARM(tp, TCPT_REXMT, tp->t_rxtcur);
+
+	/* 
+	 * If we are losing and we are trying path MTU discovery,
+	 * try turning it off.  This will avoid black holes in
+	 * the network which suppress or fail to send "packet
+	 * too big" ICMP messages.  We should ideally do
+	 * lots more sophisticated searching to find the right
+	 * value here...
 	 */
-	case TCPT_REXMT:
-		if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {
-			tp->t_rxtshift = TCP_MAXRXTSHIFT;
-			tcpstat.tcps_timeoutdrop++;
-			tp = tcp_drop(tp, tp->t_softerror ?
-			    tp->t_softerror : ETIMEDOUT);
-			break;
-		}
-		tcpstat.tcps_rexmttimeo++;
-		rto = TCP_REXMTVAL(tp);
-		if (rto < tp->t_rttmin)
-			rto = tp->t_rttmin;
-		TCPT_RANGESET((long) tp->t_rxtcur,
-		    rto * tcp_backoff[tp->t_rxtshift],
-		    tp->t_rttmin, TCPTV_REXMTMAX);
-		TCP_TIMER_ARM(tp, TCPT_REXMT, tp->t_rxtcur);
-
-		/* 
-		 * If we are losing and we are trying path MTU discovery,
-		 * try turning it off.  This will avoid black holes in
-		 * the network which suppress or fail to send "packet
-		 * too big" ICMP messages.  We should ideally do
-		 * lots more sophisticated searching to find the right
-		 * value here...
-		 */
-		if (ip_mtudisc && tp->t_inpcb &&
-		    TCPS_HAVEESTABLISHED(tp->t_state) &&
-		    tp->t_rxtshift > TCP_MAXRXTSHIFT / 6) {
-			struct inpcb *inp = tp->t_inpcb;
-			struct rtentry *rt = NULL;
-			struct sockaddr_in sin;
-
-			/* No data to send means path mtu is not a problem */
-			if (!inp->inp_socket->so_snd.sb_cc)
-				goto out;
-
-			rt = in_pcbrtentry(inp);
-			/* Check if path MTU discovery is disabled already */
-			if (rt && (rt->rt_flags & RTF_HOST) &&
-			    (rt->rt_rmx.rmx_locks & RTV_MTU))
-				goto out;
-
-			rt = NULL;
-			switch(tp->pf) {
+	if (ip_mtudisc && tp->t_inpcb &&
+	    TCPS_HAVEESTABLISHED(tp->t_state) &&
+	    tp->t_rxtshift > TCP_MAXRXTSHIFT / 6) {
+		struct inpcb *inp = tp->t_inpcb;
+		struct rtentry *rt = NULL;
+		struct sockaddr_in sin;
+
+		/* No data to send means path mtu is not a problem */
+		if (!inp->inp_socket->so_snd.sb_cc)
+			goto leave;
+
+		rt = in_pcbrtentry(inp);
+		/* Check if path MTU discovery is disabled already */
+		if (rt && (rt->rt_flags & RTF_HOST) &&
+		    (rt->rt_rmx.rmx_locks & RTV_MTU))
+			goto leave;
+
+		rt = NULL;
+		switch(tp->pf) {
 #ifdef INET6
-			case PF_INET6:
-				/*
-				 * We can not turn off path MTU for IPv6.
-				 * Do nothing for now, maybe lower to
-				 * minimum MTU.
-				 */
-				break;
+		case PF_INET6:
+			/*
+			 * We can not turn off path MTU for IPv6.
+			 * Do nothing for now, maybe lower to
+			 * minimum MTU.
+			 */
+			break;
 #endif
-			case PF_INET:
-				bzero(&sin, sizeof(struct sockaddr_in));
-				sin.sin_family = AF_INET;
-				sin.sin_len = sizeof(struct sockaddr_in);
-				sin.sin_addr = inp->inp_faddr;
-				rt = icmp_mtudisc_clone(sintosa(&sin));
-				break;
-			}
-			if (rt != NULL) {
-				/* Disable path MTU discovery */
-				if ((rt->rt_rmx.rmx_locks & RTV_MTU) == 0) {
-					rt->rt_rmx.rmx_locks |= RTV_MTU;
-					in_rtchange(inp, 0);
-				}
-
-				rtfree(rt);
-			}
-			out:
-				;
+		case PF_INET:
+			bzero(&sin, sizeof(struct sockaddr_in));
+			sin.sin_family = AF_INET;
+			sin.sin_len = sizeof(struct sockaddr_in);
+			sin.sin_addr = inp->inp_faddr;
+			rt = icmp_mtudisc_clone(sintosa(&sin));
+			break;
 		}
+		if (rt != NULL) {
+			/* Disable path MTU discovery */
+			if ((rt->rt_rmx.rmx_locks & RTV_MTU) == 0) {
+				rt->rt_rmx.rmx_locks |= RTV_MTU;
+				in_rtchange(inp, 0);
+			}
 
-		/*
-		 * If losing, let the lower level know and try for
-		 * a better route.  Also, 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;
-		 * move the current srtt into rttvar to keep the current
-		 * retransmit times until then.
-		 */
-		if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) {
-			in_losing(tp->t_inpcb);
-			tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT);
-			tp->t_srtt = 0;
+			rtfree(rt);
 		}
-		tp->snd_nxt = tp->snd_una;
+	leave:
+		;
+	}
+
+	/*
+	 * If losing, let the lower level know and try for
+	 * a better route.  Also, 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;
+	 * move the current srtt into rttvar to keep the current
+	 * retransmit times until then.
+	 */
+	if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) {
+		in_losing(tp->t_inpcb);
+		tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT);
+		tp->t_srtt = 0;
+	}
+	tp->snd_nxt = tp->snd_una;
 #if defined(TCP_SACK)
-		/*
-		 * Note:  We overload snd_last to function also as the
-		 * snd_last variable described in RFC 2582
-		 */
-		tp->snd_last = tp->snd_max;
+	/*
+	 * Note:  We overload snd_last to function also as the
+	 * snd_last variable described in RFC 2582
+	 */
+	tp->snd_last = tp->snd_max;
 #endif /* TCP_SACK */
-		/*
-		 * If timing a segment in this window, stop the timer.
-		 */
-		tp->t_rtt = 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.)
-		 */
-		{
+	/*
+	 * 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_long win = ulmin(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;
-		}
-		(void) tcp_output(tp);
-		break;
+	}
+	(void) tcp_output(tp);
 
-	/*
-	 * Persistance timer into zero window.
-	 * Force a byte to be output, if possible.
-	 */
-	case TCPT_PERSIST:
-		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.
-		 */
-		rto = TCP_REXMTVAL(tp);
-		if (rto < tp->t_rttmin)
-			rto = tp->t_rttmin;
-		if (tp->t_rxtshift == TCP_MAXRXTSHIFT &&
-		    (tp->t_idle >= tcp_maxpersistidle ||
-		     tp->t_idle >= rto * tcp_totbackoff)) {
-			tcpstat.tcps_persistdrop++;
-			tp = tcp_drop(tp, ETIMEDOUT);
-			break;
-		}
-		tcp_setpersist(tp);
-		tp->t_force = 1;
-		(void) tcp_output(tp);
-		tp->t_force = 0;
-		break;
+ out:
+	splx(s);
+}
+
+void
+tcp_timer_persist(void *arg)
+{
+	struct tcpcb *tp = arg;
+	uint32_t rto;
+	int s;
 
+	s = splsoftnet();
+	tcpstat.tcps_persisttimeo++;
 	/*
-	 * Keep-alive timer went off; send something
-	 * or drop connection if idle for too long.
+	 * 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.
 	 */
-	case TCPT_KEEP:
-		tcpstat.tcps_keeptimeo++;
-		if (TCPS_HAVEESTABLISHED(tp->t_state) == 0)
+	rto = TCP_REXMTVAL(tp);
+	if (rto < tp->t_rttmin)
+		rto = tp->t_rttmin;
+	if (tp->t_rxtshift == TCP_MAXRXTSHIFT &&
+	    ((tcp_now - tp->t_rcvtime) >= tcp_maxpersistidle ||
+	    (tcp_now - tp->t_rcvtime) >= rto * tcp_totbackoff)) {
+		tcpstat.tcps_persistdrop++;
+		tp = tcp_drop(tp, ETIMEDOUT);
+		goto out;
+	}
+	tcp_setpersist(tp);
+	tp->t_force = 1;
+	(void) tcp_output(tp);
+	tp->t_force = 0;
+ out:
+	splx(s);
+}
+
+void
+tcp_timer_keep(void *arg)
+{
+	struct tcpcb *tp = arg;
+	int s;
+
+	s = splsoftnet();
+
+	tcpstat.tcps_keeptimeo++;
+	if (TCPS_HAVEESTABLISHED(tp->t_state) == 0)
+		goto dropit;
+	if (tp->t_inpcb->inp_socket->so_options & SO_KEEPALIVE &&
+	    tp->t_state <= TCPS_CLOSING) {
+		if ((tcp_maxidle > 0) &&
+		    ((tcp_now - tp->t_rcvtime) >= tcp_keepidle + tcp_maxidle))
 			goto dropit;
-		if (tp->t_inpcb->inp_socket->so_options & SO_KEEPALIVE &&
-		    tp->t_state <= TCPS_CLOSING) {
-			if (tp->t_idle >= tcp_keepidle + tcp_maxidle)
-				goto dropit;
-			/*
-			 * 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.
-			 */
-			tcpstat.tcps_keepprobe++;
+		/*
+		 * 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.
+		 */
+		tcpstat.tcps_keepprobe++;
 #ifdef TCP_COMPAT_42
-			/*
-			 * The keepalive packet must have nonzero length
-			 * to get a 4.2 host to respond.
-			 */
-			tcp_respond(tp,
-				mtod(tp->t_template, caddr_t),
-				(struct mbuf *)NULL,
-				tp->rcv_nxt - 1, tp->snd_una - 1, 0);
+		/*
+		 * The keepalive packet must have nonzero length
+		 * to get a 4.2 host to respond.
+		 */
+		tcp_respond(tp, mtod(tp->t_template, caddr_t),
+		    (struct mbuf *)NULL, tp->rcv_nxt - 1, tp->snd_una - 1, 0);
 #else
-			tcp_respond(tp,
-				mtod(tp->t_template, caddr_t),
-				(struct mbuf *)NULL,
-				tp->rcv_nxt, tp->snd_una - 1, 0);
+		tcp_respond(tp, mtod(tp->t_template, caddr_t),
+		    (struct mbuf *)NULL, tp->rcv_nxt, tp->snd_una - 1, 0);
 #endif
-			TCP_TIMER_ARM(tp, TCPT_KEEP, tcp_keepintvl);
-		} else
-			TCP_TIMER_ARM(tp, TCPT_KEEP, tcp_keepidle);
-		break;
-	dropit:
-		tcpstat.tcps_keepdrops++;
-		tp = tcp_drop(tp, ETIMEDOUT);
-		break;
-	}
-	return (tp);
+		TCP_TIMER_ARM(tp, TCPT_KEEP, tcp_keepintvl);
+	} else
+		TCP_TIMER_ARM(tp, TCPT_KEEP, tcp_keepidle);
+
+	splx(s);
+	return;
+
+ dropit:
+	tcpstat.tcps_keepdrops++;
+	tp = tcp_drop(tp, ETIMEDOUT);
+
+	splx(s);
+}
+
+void
+tcp_timer_2msl(void *arg)
+{
+	struct tcpcb *tp = arg;
+	int s;
+
+	s = splsoftnet();
+
+#ifdef TCP_SACK
+	tcp_timer_freesack(tp);
+#endif
+
+	if (tp->t_state != TCPS_TIME_WAIT &&
+	    ((tcp_maxidle == 0) || ((tcp_now - tp->t_rcvtime) <= tcp_maxidle)))
+		TCP_TIMER_ARM(tp, TCPT_2MSL, tcp_keepintvl);
+	else
+		tp = tcp_close(tp);
+
+	splx(s);
 }
-#endif /* TUBA_INCLUDE */
diff --git a/sys/netinet/tcp_timer.h b/sys/netinet/tcp_timer.h
index 03523dd8f31..d6e7b0a30a9 100644
--- a/sys/netinet/tcp_timer.h
+++ b/sys/netinet/tcp_timer.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: tcp_timer.h,v 1.7 2002/03/01 22:29:29 provos Exp $	*/
+/*	$OpenBSD: tcp_timer.h,v 1.8 2002/03/08 03:49:58 provos Exp $	*/
 /*	$NetBSD: tcp_timer.h,v 1.6 1995/03/26 20:32:37 jtc Exp $	*/
 
 /*
@@ -120,16 +120,16 @@ char *tcptimers[] =
  * Init, arm, disarm, and test TCP timers.
  */
 #define	TCP_TIMER_INIT(tp, timer)					\
-	(tp)->t_timer[(timer)] = 0
+	timeout_set(&(tp)->t_timer[(timer)], tcp_timer_funcs[(timer)], tp)
 
 #define	TCP_TIMER_ARM(tp, timer, nticks)				\
-	(tp)->t_timer[(timer)] = (nticks)
+	timeout_add(&(tp)->t_timer[(timer)], (nticks) * (hz / PR_SLOWHZ))
 
 #define	TCP_TIMER_DISARM(tp, timer)					\
-	(tp)->t_timer[(timer)] = 0
+	timeout_del(&(tp)->t_timer[(timer)])
 
 #define	TCP_TIMER_ISARMED(tp, timer)					\
-	(tp)->t_timer[(timer)]
+	timeout_pending(&(tp)->t_timer[(timer)])
 
 /*
  * Force a time value to be in a certain range.
@@ -143,6 +143,10 @@ char *tcptimers[] =
 }
 
 #ifdef _KERNEL
+typedef void (*tcp_timer_func_t)(void *);
+
+extern const tcp_timer_func_t tcp_timer_funcs[TCPT_NTIMERS];
+
 extern int tcptv_keep_init;
 extern int tcp_keepidle;		/* time before keepalive probes begin */
 extern int tcp_keepintvl;		/* time between keepalive probes */
diff --git a/sys/netinet/tcp_usrreq.c b/sys/netinet/tcp_usrreq.c
index d461a000965..beb5b64f66d 100644
--- a/sys/netinet/tcp_usrreq.c
+++ b/sys/netinet/tcp_usrreq.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: tcp_usrreq.c,v 1.57 2002/03/02 00:44:52 provos Exp $	*/
+/*	$OpenBSD: tcp_usrreq.c,v 1.58 2002/03/08 03:49:58 provos Exp $	*/
 /*	$NetBSD: tcp_usrreq.c,v 1.20 1996/02/13 23:44:16 christos Exp $	*/
 
 /*
@@ -81,6 +81,7 @@
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/domain.h>
+#include <sys/kernel.h>
 
 #include <net/if.h>
 #include <net/route.h>
@@ -481,15 +482,6 @@ tcp_usrreq(so, req, m, nam, control)
 			in_setpeeraddr(inp, nam);
 		break;
 
-	/*
-	 * TCP slow timer went off; going through this
-	 * routine for tracing's sake.
-	 */
-	case PRU_SLOWTIMO:
-		tp = tcp_timers(tp, (long)nam);
-		req |= (long)nam << 8;		/* for debug's sake */
-		break;
-
 	default:
 		panic("tcp_usrreq");
 	}
diff --git a/sys/netinet/tcp_var.h b/sys/netinet/tcp_var.h
index fd919eb3116..6bfafb545e4 100644
--- a/sys/netinet/tcp_var.h
+++ b/sys/netinet/tcp_var.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: tcp_var.h,v 1.40 2002/03/02 00:44:52 provos Exp $	*/
+/*	$OpenBSD: tcp_var.h,v 1.41 2002/03/08 03:49:58 provos Exp $	*/
 /*	$NetBSD: tcp_var.h,v 1.17 1996/02/13 23:44:24 christos Exp $	*/
 
 /*
@@ -61,8 +61,8 @@ struct sackhole {
  */
 struct tcpcb {
 	struct ipqehead segq;		/* sequencing queue */
+	struct timeout t_timer[TCPT_NTIMERS];	/* tcp timers */
 	short	t_state;		/* state of this connection */
-	short	t_timer[TCPT_NTIMERS];	/* tcp timers */
 	short	t_rxtshift;		/* log(2) of rexmt exp. backoff */
 	short	t_rxtcur;		/* current retransmit value */
 	short	t_dupacks;		/* consecutive dup acks recd */
@@ -145,8 +145,8 @@ struct tcpcb {
  * transmit timing stuff.  See below for scale of srtt and rttvar.
  * "Variance" is actually smoothed difference.
  */
-	short	t_idle;			/* inactivity time */
-	short	t_rtt;			/* round trip time */
+	uint32_t t_rcvtime;		/* time last segment received */
+	uint32_t t_rtttime;		/* time we started measuring rtt */
 	tcp_seq	t_rtseq;		/* sequence number being timed */
 	short	t_srtt;			/* smoothed round-trip time */
 	short	t_rttvar;		/* variance in round-trip time */
@@ -403,8 +403,6 @@ void	 tcp_setpersist __P((struct tcpcb *));
 void	 tcp_slowtimo __P((void));
 struct mbuf *
 	 tcp_template __P((struct tcpcb *));
-struct tcpcb *
-	 tcp_timers __P((struct tcpcb *, int));
 void	 tcp_trace __P((int, int, struct tcpcb *, caddr_t, int, int));
 struct tcpcb *
 	 tcp_usrclosed __P((struct tcpcb *));