/* * tcp_output.c * * Derived from: * * Copyright (c) 1982, 1986 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that this notice is preserved and that due credit is given * to the University of California at Berkeley. The name of the University * may not be used to endorse or promote products derived from this * software without specific prior written permission. This software * is provided ``as is'' without express or implied warranty. * * @(#)tcp_output.c 7.12 (Berkeley) 12/7/87 * * Modified for x-kernel v3.3 * Modifications Copyright (c) 1996,1991 Arizona Board of Regents * * $Revision: 1.5 $ * $Date: 1997/06/26 06:50:30 $ */ #include "xkernel.h" #include "tcp_internal.h" #define TCPOUTFLAGS #include "tcp_fsm.h" #include "tcp_seq.h" #include "tcp_timer.h" #include "tcp_var.h" #include "tcpip.h" #include "tcp_debug.h" #define MAX_TCPOPTLEN 32 /* max # bytes that go in options */ /* * Initial options. */ static u_char tcp_initopt[4] = { TCPOPT_MAXSEG, 4, 0x0, 0x0, }; void tcp_setpersist(tp) register struct tcpcb *tp; { register t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1; if (tp->t_timer[TCPT_REXMT]) Kabort("tcp_output REXMT"); /* * Start/restart persistance timer. */ TCPT_RANGESET(tp->t_timer[TCPT_PERSIST], t * tcp_backoff[tp->t_rxtshift], TCPTV_PERSMIN, TCPTV_PERSMAX); if (tp->t_rxtshift < TCP_MAXRXTSHIFT) tp->t_rxtshift++; } /* * Tcp output routine: figure out what should be sent and send it. */ int vtcp_output(tp) register struct tcpcb *tp; { register Sessn so = tp->t_inpcb->inp_session; register struct tcpstate *tcpst = sototcpst(so); register int len, win; int off, flags, error; #ifdef XNETSIM int sndCnt=0; #endif struct tcphdr tHdr; u_char opt[MAX_TCPOPTLEN]; Msg m; unsigned optlen = 0, hdrlen, lv; int idle, sendalot, againCnt=-1; int currentTime; PSTATE *ps=(PSTATE *)so->myprotl->state; xTrace0(tcpp, 5, "tcp output"); if(tcpst == NULL) { /* * Oops, looks like the socket closed on us. Well, no * need to do anymore output so... -mjk 8/16/90 */ xTrace0(tcpp, 5, "tcpst NULL -- tcp output exiting"); return 0; } /* VENKAT: ADDED THIS HERE */ /*#ifdef XNETSIM if (tp->v_other10 > 0) { printf("tcp_output returning because previous thread is blocked!\n"); return 0; } #endif*/ currentTime = tcpGetTime(); DO_TRACE(ps, TCP_EVENT_OUT, currentTime, tp->t_state, tcpst->tid); /* * Determine length of data that should be transmitted, * and flags that will be used. * If there is some data or critical controls (SYN, RST) * to send, then transmit; otherwise, investigate further. */ idle = (tp->snd_max == tp->snd_una); /* LSB Taken from 4.4 on 9/12/95. Retracts cwnd when not sending * anything for a while. */ if (idle && tp->t_idle >= tp->t_rxtcur) /* * We have been idle for "a while" and no acks are * expected to clock out any data we send -- * slow start to get ack "clock" running again. */ tp->snd_cwnd = tp->t_maxseg; again: #ifdef XNETSIM sndCnt++; #endif sendalot = 0; /* (Vegas) Don't send more than 3 segments at once. May need * to change it if other side only ACKs every three or more. */ if (++againCnt >= tp->v_max_send) return (0); off = tp->snd_nxt - tp->snd_una; xTrace2(tcpp, TR_MAJOR_EVENTS, "tcp_output: tp->snd_wnd=%x, tp->snd_cwnd=%x", tp->snd_wnd, tp->snd_cwnd); /* Code to do spike supression in Vegas. Spike_timeInc is the * average time interval between sending packets at the current * rate. Spike prevention works by preventing sending more than * 2 max segments worth of data during each spike_timeInc * interval (so we can at most send at twice the current rate). * Spike_byteCnt is the number of bytes we have sent during the * current interval, and the current interval ends at spike_nextTime. * Currently off since there are problems when the other side * doesn't ACK each packet immediately (like acking every 2 packets). */ if (tp->v_spike_do) { if (tp->snd_cwnd < tp->snd_ssthresh || tp->v_spike_nextTime < currentTime) { /* We need to increase spike_nextTime */ tp->v_spike_nextTime = currentTime + (tp->v_spike_timeInc - ((currentTime - tp->v_spike_nextTime)%tp->v_spike_timeInc)); tp->v_spike_byteCnt = 0; } else if ( (tp->snd_nxt - tp->snd_una) <= 2*tp->t_maxseg) /* If we have less than 2 maxseg in transit, don't do spike prev */ ; else if ( (2*tp->t_maxseg - tp->v_spike_byteCnt) < MIN(tp->t_maxseg, sblength(tcpst->snd))) { /* We've already sent all the data we can during the current * spike_timeInc interval. */ DO_TRACE(ps, TCP_EVENT_OTHER3, tp->v_spike_byteCnt, tp->v_spike_timeInc, tcpst->tid); return (0); } DO_TRACE(ps, TCP_EVENT_OTHER4, tp->v_spike_nextTime, tp->v_spike_timeInc, tcpst->tid); } /* End of spike prevention stuff */ /* Code to do an exponential decrease in Vegas (send on every other * ACK) sending rate after losses, instead of waiting half of RTT * before starting sending again. Currently not used. */ /* if (tp->v_use_sndwnd) { */ /* win = tp->snd_wnd; */ /* DO_TRACE(ps, TCP_EVENT_OTHER1, win, 0, tcpst->tid); */ /* tp->v_use_sndwnd = 0; */ /* } */ /* else { */ win = MIN(tp->snd_wnd, tp->snd_cwnd); /* } */ DO_TRACE(ps, TCP_EVENT_OUT0, sblength(tcpst->snd), tp->snd_wnd>>4, tcpst->tid); DO_TRACE(ps, TCP_EVENT_DATA, tp->snd_nxt, tp->snd_cwnd>>4, tcpst->tid); DO_TRACE(ps, TCP_EVENT_DATA, tp->snd_una, tp->snd_ssthresh>>4, tcpst->tid); /* * If in persist timeout with window of 0, send 1 byte. * Otherwise, if window is small but nonzero * and timer expired, we will send what we can * and go to transmit state. */ if (tp->t_force) { if (win == 0) win = 1; else { tp->t_timer[TCPT_PERSIST] = 0; tp->t_rxtshift = 0; } } len = MIN(sblength(tcpst->snd), win) - off; xTrace4(tcpp, 5, "tcp_output: sbLen: %d win: %d off: %d len == %d", sblength(tcpst->snd), win, off, len); flags = tcp_outflags[tp->t_state]; if (len < 0) { /* * If FIN has been sent but not acked, * but we haven't been called to retransmit, * len will be -1. Otherwise, window shrank * after we sent into it. If window shrank to 0, * cancel pending retransmit and pull snd_nxt * back to (closed) window. We will enter persist * state below. If the window didn't close completely, * just wait for an ACK. */ len = 0; if (win == 0) { tp->t_timer[TCPT_REXMT] = 0; tp->snd_nxt = tp->snd_una; } } if (len > tp->t_maxseg) { len = tp->t_maxseg; sendalot = 1; } if (SEQ_LT(tp->snd_nxt + len, tp->snd_una + sblength(tcpst->snd))) flags &= ~TH_FIN; win = tcpst->rcv_space; /* * If our state indicates that FIN should be sent * and we have not yet done so, or we're retransmitting the FIN, * then we need to send. */ if (flags & TH_FIN && ((tp->t_flags & TF_SENTFIN) == 0 || tp->snd_nxt == tp->snd_una)) goto send; /* * Send if we owe peer an ACK. */ if (tp->t_flags & TF_ACKNOW) goto send; if (flags & (TH_SYN|TH_RST)) goto send; if (SEQ_GT(tp->snd_up, tp->snd_una)) goto send; /* * Sender silly window avoidance. If connection is idle * and can send all data, a maximum segment, * at least a maximum default-size segment do it, * or are forced, do it; otherwise don't bother. * If peer's buffer is tiny, then send * when window is at least half open. * If retransmitting (possibly after persist timer forced us * to send into a small window), then must resend. */ if (len) { if (len == tp->t_maxseg) goto send; if ((idle || tp->t_flags & TF_NODELAY) && len + off >= sblength(tcpst->snd)) goto send; if (tp->t_force) goto send; if (len >= tp->max_sndwnd / 2) goto send; if (SEQ_LT(tp->snd_nxt, tp->snd_max)) goto send; } /* * Compare available window to amount of window * known to peer (as advertised window less * next expected input). If the difference is at least two * max size segments or at least 35% of the maximum possible * window, then want to send a window update to peer. */ if (win > 0) { /* * "adv" is the amount we can increase the window, * taking into account that we are limited by * TCP_MAXWIN << tp->rcv_scale. */ long adv = MIN(win, (long)TCP_MAXWIN << tp->rcv_scale) - (tp->rcv_adv - tp->rcv_nxt); /* if ((win == tcpst->rcv_hiwat) && LSB: old (adv >= 2 * tp->t_maxseg)) */ if (adv >= (long) (2 * tp->t_maxseg)) goto send; if (100 * adv / tcpst->rcv_hiwat >= 35) goto send; } /* * TCP window updates are not reliable, rather a polling protocol * using ``persist'' packets is used to insure receipt of window * updates. The three ``states'' for the output side are: * idle not doing retransmits or persists * persisting to move a small or zero window * (re)transmitting and thereby not persisting * * tp->t_timer[TCPT_PERSIST] * is set when we are in persist state. * tp->t_force * is set when we are called to send a persist packet. * tp->t_timer[TCPT_REXMT] * is set when we are retransmitting * The output side is idle when both timers are zero. * * If send window is too small, there is data to transmit, and no * retransmit or persist is pending, then go to persist state. * If nothing happens soon, send when timer expires: * if window is nonzero, transmit what we can, * otherwise force out a byte. */ if (sblength(tcpst->snd) && tp->t_timer[TCPT_REXMT] == 0 && tp->t_timer[TCPT_PERSIST] == 0) { tp->t_rxtshift = 0; tcp_setpersist(tp); } /* * No reason to send a segment, just return. */ xTrace0(tcpp, 5, "tcp_output -- no reason to send"); return (0); send: /* * Before ESTABLISHED, force sending of initial options * unless TCP set not to do any options. * NOTE: we assume that the IP/TCP header plus TCP options * always fit in a single mbuf, leaving room for a maximum * link header, i.e. * max_linkhdr + sizeof (struct tcpiphdr) + optlen <= MHLEN */ optlen = 0; hdrlen = sizeof (struct tcpiphdr); if (flags & TH_SYN) { tp->snd_nxt = tp->iss; /* LSB: not present in prev vers */ if ((tp->t_flags & TF_NOOPT) == 0) { u_short mss; opt[0] = TCPOPT_MAXSEG; opt[1] = 4; mss = MIN(tcpst->rcv_hiwat/2, tcp_mss(tp)); /* if (mss > IP_MSS - sizeof(struct tcpiphdr)) { */ mss = htons(mss); bcopy((char *)&mss, (char *)(opt+2), sizeof(mss)); optlen = 4; /* } */ if ((tp->t_flags & TF_REQ_SCALE) && ((flags & TH_ACK) == 0 || (tp->t_flags & TF_RCVD_SCALE))) { /* *((u_int *) (opt + optlen)) = */ lv = htonl( TCPOPT_NOP << 24 | TCPOPT_WINDOW << 16 | TCPOLEN_WINDOW << 8 | tp->request_r_scale); bcopy((char *)&lv, (opt+optlen), sizeof(int)); optlen += 4; } } } hdrlen += optlen; /* * Grab a header mbuf, attaching a cepy of data to * be transmitted, and initialize the header from * the template for sends on this connection. */ sbcollect(tcpst->snd, &m, off, len, 0); if (len) { if (tp->t_force && len == 1) ps->tcpstat.tcps_sndprobe++; else if (SEQ_LT(tp->snd_nxt, tp->snd_max)) { DO_TRACE(ps, TCP_EVENT_DUP, 0, len, 0); ps->tcpstat.tcps_sndrexmitpack++; ps->tcpstat.tcps_sndrexmitbyte += len; } else { ps->tcpstat.tcps_sndpack++; ps->tcpstat.tcps_sndbyte += len; } } else if (tp->t_flags & TF_ACKNOW) ps->tcpstat.tcps_sndacks++; else if (flags & (TH_SYN|TH_FIN|TH_RST)) ps->tcpstat.tcps_sndctrl++; else if (SEQ_GT(tp->snd_up, tp->snd_una)) ps->tcpstat.tcps_sndurg++; else ps->tcpstat.tcps_sndwinup++; if (flags & TH_SYN) tp->v_synsent = currentTime; /* Vegas, remember when SYN was sent */ if (tp->t_template == 0) Kabort("tcp_output"); tHdr = tp->t_template->ti_t; /* * Fill in fields, remembering maximum advertised * window for use in delaying messages about window sizes. * If resending a FIN, be sure not to use a new sequence number. */ if (flags & TH_FIN && tp->t_flags & TF_SENTFIN && tp->snd_nxt == tp->snd_max) tp->snd_nxt--; tHdr.th_seq = tp->snd_nxt; xTrace1(tcpp, 4, "Sending seq %d", tHdr.th_seq); tHdr.th_ack = tp->rcv_nxt; xTrace1(tcpp, 4, "Sending ack %d", tHdr.th_ack); if (optlen) { int padOptLen = (optlen + 3) & ~0x3; void *buf; buf = msgPush(&m, padOptLen); xAssert(buf); tcpOptionsStore(opt, buf, padOptLen, &optlen); tHdr.th_off = (sizeof (struct tcphdr) + padOptLen) >> 2; } #ifdef XNETSIM if (sndCnt >= 2) flags |= 0x80; /* Used in simulator to study traffic and network behavior. This flag set means that a packet was sent immediately before this one */ if (tp->snd_cwnd <= tp->snd_ssthresh) flags |= 0x40; /* Used in simulator to study traffic and network behavior. This flag set means that we are probably in slow-start mode */ #endif tHdr.th_flags = flags; /* * Calculate receive window. Don't shrink window, * but avoid silly window syndrome. */ if (win < (long)(tcpst->rcv_hiwat / 4) && win < (long)tp->t_maxseg) win = 0; if (win > (long)TCP_MAXWIN << tp->rcv_scale) win = (long)TCP_MAXWIN << tp->rcv_scale; if (win < (long)(tp->rcv_adv - tp->rcv_nxt)) win = (int)(tp->rcv_adv - tp->rcv_nxt); tHdr.th_win = (u_short) (win>>tp->rcv_scale); if (SEQ_GT(tp->snd_up, tp->snd_nxt)) { tHdr.th_urp = (u_short)(tp->snd_up - tp->snd_nxt); tHdr.th_flags |= TH_URG; } else /* * If no urgent pointer to send, then we pull * the urgent pointer to the left edge of the send window * so that it doesn't drift into the send window on sequence * number wraparound. */ tp->snd_up = tp->snd_una; /* drag it along */ /* * If anything to send and we can send it all, set PUSH. * (This will keep happy those implementations which only * give data to the user when a buffer fills or a PUSH comes in.) */ if (len && off+len == sblength(tcpst->snd)) tHdr.th_flags |= TH_PUSH; DO_TRACE(ps, TCP_EVENT_OUT1, tHdr.th_seq, msgLength(&m), tcpst->tid); /* Set Vegas variables */ tp->v_spike_byteCnt += msgLength(&m); tp->v_cong_detect_last_sendtime = currentTime; xTrace2(tcpp, 4, "Sending %d bytes with flags ( %s )", msgLength(&m), tcpFlagStr(tHdr.th_flags)); { hdrStore_t store; void *buf; store.h = &tp->t_template->ti_p; store.m = &m; buf = msgPush(&m, sizeof(struct tcphdr)); xAssert(buf); tcpHdrStore(&tHdr, buf, sizeof(struct tcphdr), &store); } /* * In transmit state, time the transmission and arrange for * the retransmit. In persist state, just set snd_max. */ if (tp->t_force == 0 || tp->t_timer[TCPT_PERSIST] == 0) { tcp_seq startseq = tp->snd_nxt; /* * Advance snd_nxt over sequence space of this segment. */ if (flags & TH_SYN) tp->snd_nxt++; if (flags & TH_FIN) { tp->snd_nxt++; tp->t_flags |= TF_SENTFIN; } tp->snd_nxt += len; if (SEQ_GT(tp->snd_nxt, tp->snd_max)) { tp->snd_max = tp->snd_nxt; /* * Time this transmission if not a retransmission and * not currently timing anything. */ if (tp->t_rtt == 0) { tp->t_rtt = 1; tp->t_rtseq = startseq; ps->tcpstat.tcps_segstimed++; } } /* * Set retransmit timer if not currently set, * and not doing an ack or a keep-alive probe. * Initial value for retransmit timer is smoothed * round-trip time + 2 * round-trip time variance. * Initialize shift counter which is used for backoff * of retransmit time. */ if (tp->t_timer[TCPT_REXMT] == 0 && tp->snd_nxt != tp->snd_una) { tp->t_timer[TCPT_REXMT] = tp->t_rxtcur; if (tp->t_timer[TCPT_PERSIST]) { tp->t_timer[TCPT_PERSIST] = 0; tp->t_rxtshift = 0; } } } else if (SEQ_GT(tp->snd_nxt + len, tp->snd_max)) tp->snd_max = tp->snd_nxt + len; /* * Send it out. */ #ifdef XNETSIM tp->v_other10 = 1; /* VENKAT: If TCP comes back around quick enough and cannot send then we essentially drop the packet, since we return if tp->v_other10 ==1 */ #endif error = xPush(xGetSessnDown(tcpcbtoso(tp), 0), &m) < 0; msgDestroy(&m); if (error) { if (error == ENOBUFS) tcp_quench(tp->t_inpcb); return (error); } ps->tcpstat.tcps_sndtotal++; /* * Data sent (as far as we can tell). * If this advertises a larger window than any other segment, * then remember the size of the advertised window. * Any pending ACK has now been sent. */ if (win > 0 && SEQ_GT(tp->rcv_nxt+win, tp->rcv_adv)) { tp->rcv_adv = tp->rcv_nxt + win; xTrace3(tcpp, 5, "rcv_adv = rcv_nxt (%x) + win (%x) = %x", tp->rcv_nxt, win, tp->rcv_adv); } tp->t_flags &= ~(TF_ACKNOW|TF_DELACK); if (sendalot) goto again; return (0); }