X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/7cc62c26d645736708f4d4e7e309108691195a33..4d8170e59e43abc00690852d097c26731af5297c:/usr/src/sys/netinet/tcp_timer.c diff --git a/usr/src/sys/netinet/tcp_timer.c b/usr/src/sys/netinet/tcp_timer.c index 3318bf00fd..2d80f3f115 100644 --- a/usr/src/sys/netinet/tcp_timer.c +++ b/usr/src/sys/netinet/tcp_timer.c @@ -1,35 +1,41 @@ /* - * Copyright (c) 1982, 1986 Regents of the University of California. - * All rights reserved. The Berkeley software License Agreement - * specifies the terms and conditions for redistribution. + * Copyright (c) 1982, 1986, 1988, 1990 Regents of the University of California. + * All rights reserved. * - * @(#)tcp_timer.c 7.6 (Berkeley) %G% + * %sccs.include.redist.c% + * + * @(#)tcp_timer.c 7.21 (Berkeley) %G% */ -#include "param.h" -#include "systm.h" -#include "mbuf.h" -#include "socket.h" -#include "socketvar.h" -#include "protosw.h" -#include "errno.h" - -#include "../net/if.h" -#include "../net/route.h" - -#include "in.h" -#include "in_pcb.h" -#include "in_systm.h" -#include "ip.h" -#include "ip_var.h" -#include "tcp.h" -#include "tcp_fsm.h" -#include "tcp_seq.h" -#include "tcp_timer.h" -#include "tcp_var.h" -#include "tcpip.h" - -int tcpnodelack = 0; +#ifndef TUBA_INCLUDE +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +int tcp_keepidle = TCPTV_KEEP_IDLE; +int tcp_keepintvl = TCPTV_KEEPINTVL; +int tcp_maxidle; +#endif /* TUBA_INCLUDE */ /* * Fast timeout routine for processing delayed acks */ @@ -64,6 +70,7 @@ tcp_slowtimo() int s = splnet(); register int i; + tcp_maxidle = TCPTV_KEEPCNT * tcp_keepintvl; /* * Search through tcb's and update active timers. */ @@ -97,8 +104,10 @@ tpgone: if ((int)tcp_iss < 0) tcp_iss = 0; /* XXX */ #endif + tcp_now++; /* for timestamps */ splx(s); } +#ifndef TUBA_INCLUDE /* * Cancel all timers for TCP tp. @@ -112,10 +121,8 @@ tcp_canceltimers(tp) tp->t_timer[i] = 0; } -int tcp_backoff[TCP_MAXRXTSHIFT] = - { 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 }; - -int tcp_keeplen = 1; /* must be nonzero for 4.2 compat- XXX */ +int tcp_backoff[TCP_MAXRXTSHIFT + 1] = + { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 }; /* * TCP timer processing. @@ -137,8 +144,8 @@ tcp_timers(tp, timer) */ case TCPT_2MSL: if (tp->t_state != TCPS_TIME_WAIT && - tp->t_idle <= TCPTV_MAXIDLE) - tp->t_timer[TCPT_2MSL] = TCPTV_KEEP; + tp->t_idle <= tcp_maxidle) + tp->t_timer[TCPT_2MSL] = tcp_keepintvl; else tp = tcp_close(tp); break; @@ -149,24 +156,33 @@ tcp_timers(tp, timer) * to a longer retransmit interval and retransmit one segment. */ case TCPT_REXMT: - if (tp->t_rxtshift >= TCP_MAXRXTSHIFT) { + if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) { + tp->t_rxtshift = TCP_MAXRXTSHIFT; tcpstat.tcps_timeoutdrop++; - tp = tcp_drop(tp, ETIMEDOUT); + tp = tcp_drop(tp, tp->t_softerror ? + tp->t_softerror : ETIMEDOUT); break; } tcpstat.tcps_rexmttimeo++; - rexmt = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1; - rexmt *= tcp_backoff[tp->t_rxtshift]; - tp->t_rxtshift++; - TCPT_RANGESET(tp->t_timer[TCPT_REXMT], rexmt, - TCPTV_MIN, TCPTV_MAX); + rexmt = TCP_REXMTVAL(tp) * tcp_backoff[tp->t_rxtshift]; + TCPT_RANGESET(tp->t_rxtcur, rexmt, + tp->t_rttmin, TCPTV_REXMTMAX); + tp->t_timer[TCPT_REXMT] = tp->t_rxtcur; /* - * If losing, let the lower level know - * and try for a better route. + * 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 || - rexmt >= 10 * PR_SLOWHZ) + if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) { +#if BSD>=43 in_losing(tp->t_inpcb); +#endif + tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT); + tp->t_srtt = 0; + } tp->snd_nxt = tp->snd_una; /* * If timing a segment in this window, stop the timer. @@ -179,8 +195,31 @@ tcp_timers(tp, timer) * 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; + } (void) tcp_output(tp); break; @@ -206,7 +245,7 @@ tcp_timers(tp, timer) goto dropit; if (tp->t_inpcb->inp_socket->so_options & SO_KEEPALIVE && tp->t_state <= TCPS_CLOSE_WAIT) { - if (tp->t_idle >= TCPTV_MAXIDLE) + if (tp->t_idle >= tcp_keepidle + tcp_maxidle) goto dropit; /* * Send a packet designed to force a response @@ -221,10 +260,20 @@ tcp_timers(tp, timer) * correspondent TCP to respond. */ tcpstat.tcps_keepprobe++; - tcp_respond(tp, tp->t_template, - tp->rcv_nxt - tcp_keeplen, tp->snd_una - 1, 0); - } - tp->t_timer[TCPT_KEEP] = TCPTV_KEEP; +#ifdef TCP_COMPAT_42 + /* + * The keepalive packet must have nonzero length + * to get a 4.2 host to respond. + */ + tcp_respond(tp, tp->t_template, (struct mbuf *)NULL, + tp->rcv_nxt - 1, tp->snd_una - 1, 0); +#else + tcp_respond(tp, tp->t_template, (struct mbuf *)NULL, + tp->rcv_nxt, tp->snd_una - 1, 0); +#endif + tp->t_timer[TCPT_KEEP] = tcp_keepintvl; + } else + tp->t_timer[TCPT_KEEP] = tcp_keepidle; break; dropit: tcpstat.tcps_keepdrops++; @@ -233,3 +282,4 @@ tcp_timers(tp, timer) } return (tp); } +#endif /* TUBA_INCLUDE */