Ultrix-3.1/sys/net/tcp_timer.c
/**********************************************************************
* Copyright (c) Digital Equipment Corporation 1984, 1985, 1986. *
* All Rights Reserved. *
* Reference "/usr/src/COPYRIGHT" for applicable restrictions. *
**********************************************************************/
/*
* Copyright (c) 1982 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*
* SCCSID: @(#)tcp_timer.c 3.0 4/21/86
* Based on: @(#)tcp_timer.c 6.7 (Berkeley) 6/8/85
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/protosw.h>
#include <errno.h>
#include <net/if.h>
#include <net/route.h>
#include <netinet/in.h>
#include <netinet/in_pcb.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_var.h>
#include <netinet/tcp.h>
#include <netinet/tcp_fsm.h>
#include <netinet/tcp_seq.h>
#include <netinet/tcp_timer.h>
#include <netinet/tcp_var.h>
#include <netinet/tcpip.h>
int tcpnodelack = 0;
/*
* Fast timeout routine for processing delayed acks
*/
tcp_fasttimo()
{
register struct inpcb *inp;
register struct tcpcb *tp;
int s = splnet();
inp = tcb.inp_next;
if (inp)
for (; inp != &tcb; inp = inp->inp_next)
if ((tp = (struct tcpcb *)inp->inp_ppcb) &&
(tp->t_flags & TF_DELACK)) {
tp->t_flags &= ~TF_DELACK;
tp->t_flags |= TF_ACKNOW;
(void) tcp_output(tp);
}
splx(s);
}
/*
* Tcp protocol timeout routine called every 500 ms.
* Updates the timers in all active tcb's and
* causes finite state machine actions if timers expire.
*/
tcp_slowtimo()
{
register struct inpcb *ip, *ipnxt;
register struct tcpcb *tp;
int s = splnet();
register int i;
/*
* Search through tcb's and update active timers.
*/
ip = tcb.inp_next;
if (ip == 0) {
splx(s);
return;
}
for (; ip != &tcb; ip = ipnxt) {
ipnxt = ip->inp_next;
tp = intotcpcb(ip);
if (tp == 0)
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);
if (ipnxt->inp_prev != ip)
goto tpgone;
}
}
tp->t_idle++;
if (tp->t_rtt)
tp->t_rtt++;
tpgone:
;
}
tcp_iss += TCP_ISSINCR/PR_SLOWHZ; /* increment iss */
splx(s);
}
/*
* Cancel all timers for TCP tp.
*/
tcp_canceltimers(tp)
struct tcpcb *tp;
{
register int i;
for (i = 0; i < TCPT_NTIMERS; i++)
tp->t_timer[i] = 0;
}
#ifdef pdp11
/* Note that the formula used by tcp_timers() goes like this:
* t_timer = ( (t_srtt/10) * tcp_backoff[t_rxshift-1] ) / 10;
* t_srtt ~=~ t_rtt * 10;
* with the result limited to the range 0.5--15 seconds.
* t_srtt is the "smoothed" round trip time *10, t_rtt is 1 round trip time.
*/
int tcp_backoff[TCP_MAXRXTSHIFT] = /* scaled by 10 */
{ 12, 20, 25, 32, 40, 50, 60, 80, 160, 320 }; /* NEW */
/* { 10, 12, 14, 17, 20, 30, 50, 80, 160, 320 }; OLD */
int tcprexmtprint = 0;
#else vax
float tcp_backoff[TCP_MAXRXTSHIFT] =
{ 1.0, 1.2, 1.4, 1.7, 2.0, 3.0, 5.0, 8.0, 16.0, 32.0 };
#endif pdp11
int tcpexprexmtbackoff = 0;
/*
* TCP timer processing.
*/
struct tcpcb *
tcp_timers(tp, timer)
register struct tcpcb *tp;
int timer;
{
switch (timer) {
/*
* 2 MSL timeout in shutdown went off. Delete connection
* control block.
*/
case TCPT_2MSL:
tp = tcp_close(tp);
break;
/*
* Retransmission timer went off. Message has not
* been acked within retransmit interval. Back off
* to a longer retransmit interval and retransmit one segment.
*/
case TCPT_REXMT:
tp->t_rxtshift++;
if (tp->t_rxtshift > TCP_MAXRXTSHIFT) {
tp = tcp_drop(tp, ETIMEDOUT);
break;
}
/*
* If losing, let the lower level know
* and try for a better route.
*/
if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 2)
in_rtchange(tp->t_inpcb);
#ifdef vax
TCPT_RANGESET(tp->t_timer[TCPT_REXMT],
(int)tp->t_srtt, TCPTV_MIN, TCPTV_MAX);
#else pdp11
TCPT_RANGESET(tp->t_timer[TCPT_REXMT],
((int)tp->t_srtt/10), TCPTV_MIN, TCPTV_MAX);
#endif
if (tcpexprexmtbackoff) {
TCPT_RANGESET(tp->t_timer[TCPT_REXMT],
tp->t_timer[TCPT_REXMT] << tp->t_rxtshift,
TCPTV_MIN, TCPTV_MAX);
} else {
#ifdef vax
TCPT_RANGESET(tp->t_timer[TCPT_REXMT],
tp->t_timer[TCPT_REXMT] *
tcp_backoff[tp->t_rxtshift - 1],
TCPTV_MIN, TCPTV_MAX);
#else pdp11
TCPT_RANGESET(tp->t_timer[TCPT_REXMT],
((tp->t_timer[TCPT_REXMT] *
tcp_backoff[tp->t_rxtshift - 1])/10),
TCPTV_MIN, TCPTV_MAX);
#endif
}
tp->snd_nxt = tp->snd_una;
/*
* If timing a segment in this window,
* and we have already gotten some timing estimate,
* stop the timer.
*/
if (tp->t_rtt && tp->t_srtt)
tp->t_rtt = 0;
(void) tcp_output(tp);
break;
/*
* Persistance timer into zero window.
* Force a byte to be output, if possible.
*/
case TCPT_PERSIST:
tcp_setpersist(tp);
tp->t_force = 1;
(void) tcp_output(tp);
tp->t_force = 0;
break;
/*
* Keep-alive timer went off; send something
* or drop connection if idle for too long.
*/
case TCPT_KEEP:
if (tp->t_state < TCPS_ESTABLISHED)
goto dropit;
if (tp->t_inpcb->inp_socket->so_options & SO_KEEPALIVE) {
if (tp->t_idle >= TCPTV_MAXIDLE)
goto dropit;
/*
* Saying tp->rcv_nxt-1 lies about what
* we have received, and by the protocol spec
* requires the correspondent TCP to respond.
* Saying tp->snd_una-1 causes the transmitted
* byte to lie outside the receive window; this
* is important because we don't necessarily
* have a byte in the window to send (consider
* a one-way stream!)
*/
#ifdef pdp11
MAPSAVE();
#endif pdp11
tcp_respond(tp,
tp->t_template, tp->rcv_nxt-1, tp->snd_una-1, 0);
#ifdef pdp11
MAPREST();
#endif pdp11
} else
tp->t_idle = 0;
tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
break;
dropit:
tp = tcp_drop(tp, ETIMEDOUT);
break;
}
return (tp);
}