X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/405c9168af72200b21fd65c6312d9b6dc4ab358f..c59af027e112b534ee7b9ff495682274cc16e205:/usr/src/sys/netinet/tcp_timer.h diff --git a/usr/src/sys/netinet/tcp_timer.h b/usr/src/sys/netinet/tcp_timer.h index cc73ea6eb8..739e96607b 100644 --- a/usr/src/sys/netinet/tcp_timer.h +++ b/usr/src/sys/netinet/tcp_timer.h @@ -1,4 +1,11 @@ -/* tcp_timer.h 4.2 81/12/02 */ +/* + * Copyright (c) 1982, 1986 Regents of the University of California. + * All rights reserved. + * + * %sccs.include.redist.c% + * + * @(#)tcp_timer.h 7.8 (Berkeley) %G% + */ /* * Definitions of the TCP timers. These timers are counted @@ -19,76 +26,78 @@ * then the retransmit timer is cleared (if there are no more * outstanding segments) or reset to the base value (if there * are more ACKs expected). Whenever the retransmit timer goes off, - * we retransmit all unacknowledged segments, and do an exponential - * backoff on the retransmit timer. + * we retransmit one unacknowledged segment, and do a backoff + * on the retransmit timer. * * The TCPT_PERSIST timer is used to keep window size information - * flowing even if the window goes shut. If an output is attempted when there - * is data ready to transmit, but nothing gets sent because the window - * is shut, then we start the TCPT_PERSIST timer, and at intervals - * send a single byte into the peers window to force him to update - * our window information. We do this at most as often as TCPT_PERSMIN - * time intervals, but no more frequently than the current estimate of - * round-trip packet time. The TCPT_PERSIST timer is cleared whenever - * we receive a window update from the peer. + * flowing even if the window goes shut. If all previous transmissions + * have been acknowledged (so that there are no retransmissions in progress), + * and the window is too small to bother sending anything, then we start + * the TCPT_PERSIST timer. When it expires, if the window is nonzero, + * we go to transmit state. Otherwise, at intervals send a single byte + * into the peer's window to force him to update our window information. + * We do this at most as often as TCPT_PERSMIN time intervals, + * but no more frequently than the current estimate of round-trip + * packet time. The TCPT_PERSIST timer is cleared whenever we receive + * a window update from the peer. * * The TCPT_KEEP timer is used to keep connections alive. If an - * connection is idle (no segments received) for TCPTV_KEEP amount of time, - * but not yet established, then we drop the connection. If the connection - * is established, then we force the peer to send us a segment by sending: + * connection is idle (no segments received) for TCPTV_KEEP_INIT amount of time, + * but not yet established, then we drop the connection. Once the connection + * is established, if the connection is idle for TCPTV_KEEP_IDLE time + * (and keepalives have been enabled on the socket), we begin to probe + * the connection. We force the peer to send us a segment by sending: * * This segment is (deliberately) outside the window, and should elicit * an ack segment in response from the peer. If, despite the TCPT_KEEP * initiated segments we cannot elicit a response from a peer in TCPT_MAXIDLE - * amount of time, then we drop the connection. + * amount of time probing, then we drop the connection. */ -#define TCP_TTL 60 /* time to live for TCP segs */ +#define TCP_TTL 60 /* default time to live for TCP segs */ /* * Time constants. */ -#define TCPTV_MSL (120*PR_SLOWHZ) /* max seg lifetime */ -#define TCPTV_SRTTBASE ( 1*PR_SLOWHZ) /* base roundtrip time */ -#define TCPTV_KEEP (240*PR_SLOWHZ) /* keep alive - 4 mins */ +#define TCPTV_MSL ( 30*PR_SLOWHZ) /* max seg lifetime (hah!) */ +#define TCPTV_SRTTBASE 0 /* base roundtrip time; + if 0, no idea yet */ +#define TCPTV_SRTTDFLT ( 3*PR_SLOWHZ) /* assumed RTT if no info */ + #define TCPTV_PERSMIN ( 5*PR_SLOWHZ) /* retransmit persistance */ +#define TCPTV_PERSMAX ( 60*PR_SLOWHZ) /* maximum persist interval */ -#define TCPTV_MAXIDLE ( 4*TCPTV_KEEP) /* maximum allowable idle - time before drop conn */ +#define TCPTV_KEEP_INIT ( 75*PR_SLOWHZ) /* initial connect keep alive */ +#define TCPTV_KEEP_IDLE (120*60*PR_SLOWHZ) /* dflt time before probing */ +#define TCPTV_KEEPINTVL ( 75*PR_SLOWHZ) /* default probe interval */ +#define TCPTV_KEEPCNT 8 /* max probes before drop */ #define TCPTV_MIN ( 1*PR_SLOWHZ) /* minimum allowable value */ -#define TCPTV_MAX (480*PR_SLOWHZ) /* maximum allowable value */ +#define TCPTV_REXMTMAX ( 64*PR_SLOWHZ) /* max allowable REXMT value */ + +#define TCP_LINGERTIME 120 /* linger at most 2 minutes */ + +#define TCP_MAXRXTSHIFT 12 /* maximum retransmits */ #ifdef TCPTIMERS char *tcptimers[] = - { "REXMT", "KEEP", "PERSIST", "2MSL" }; + { "REXMT", "PERSIST", "KEEP", "2MSL" }; #endif -/* - * Retransmission smoothing constants. - * Smoothed round trip time is updated by - * tp->t_srtt = (tcp_alpha * tp->t_srtt) + ((1 - tcp_alpha) * tp->t_rtt) - * each time a new value of tp->t_rtt is available. The initial - * retransmit timeout is then based on - * tp->t_timer[TCPT_REXMT] = tcp_beta * tp->t_srtt; - * limited, however to be at least TCPTV_REXMTLO and at most TCPTV_REXMTHI. - */ -float tcp_alpha, tcp_beta; - -/* - * Initial values of tcp_alpha and tcp_beta. - * These are conservative: averaging over a long - * period of time, and allowing for large individual deviations from - * tp->t_srtt. - */ -#define TCP_ALPHA 0.9 -#define TCP_BETA 2.0 - /* * Force a time value to be in a certain range. */ -#define TCPT_RANGESET(tv, value, tvmin, tvmax) \ +#define TCPT_RANGESET(tv, value, tvmin, tvmax) { \ (tv) = (value); \ if ((tv) < (tvmin)) \ (tv) = (tvmin); \ - if ((tv) > (tvmax)) \ - (tv) = (tvmax); + else if ((tv) > (tvmax)) \ + (tv) = (tvmax); \ +} + +#ifdef KERNEL +extern int tcp_keepidle; /* time before keepalive probes begin */ +extern int tcp_keepintvl; /* time between keepalive probes */ +extern int tcp_maxidle; /* time to drop after starting probes */ +extern int tcp_ttl; /* time to live for TCP segs */ +extern int tcp_backoff[]; +#endif