![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tp_subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / netiso|
Return to tp_subr.c CVS log | Up to [Net/2] / Net2 / netiso |
1.1 ! root 1: /*- ! 2: * Copyright (c) 1991 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms, with or without ! 6: * modification, are permitted provided that the following conditions ! 7: * are met: ! 8: * 1. Redistributions of source code must retain the above copyright ! 9: * notice, this list of conditions and the following disclaimer. ! 10: * 2. Redistributions in binary form must reproduce the above copyright ! 11: * notice, this list of conditions and the following disclaimer in the ! 12: * documentation and/or other materials provided with the distribution. ! 13: * 3. All advertising materials mentioning features or use of this software ! 14: * must display the following acknowledgement: ! 15: * This product includes software developed by the University of ! 16: * California, Berkeley and its contributors. ! 17: * 4. Neither the name of the University nor the names of its contributors ! 18: * may be used to endorse or promote products derived from this software ! 19: * without specific prior written permission. ! 20: * ! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 31: * SUCH DAMAGE. ! 32: * ! 33: * @(#)tp_subr.c 7.9 (Berkeley) 6/27/91 ! 34: */ ! 35: ! 36: /*********************************************************** ! 37: Copyright IBM Corporation 1987 ! 38: ! 39: All Rights Reserved ! 40: ! 41: Permission to use, copy, modify, and distribute this software and its ! 42: documentation for any purpose and without fee is hereby granted, ! 43: provided that the above copyright notice appear in all copies and that ! 44: both that copyright notice and this permission notice appear in ! 45: supporting documentation, and that the name of IBM not be ! 46: used in advertising or publicity pertaining to distribution of the ! 47: software without specific, written prior permission. ! 48: ! 49: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 50: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 51: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 52: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 53: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 54: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 55: SOFTWARE. ! 56: ! 57: ******************************************************************/ ! 58: ! 59: /* ! 60: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison ! 61: */ ! 62: /* ! 63: * ARGO TP ! 64: * ! 65: * $Header: tp_subr.c,v 5.3 88/11/18 17:28:43 nhall Exp $ ! 66: * $Source: /usr/argo/sys/netiso/RCS/tp_subr.c,v $ ! 67: * ! 68: * The main work of data transfer is done here. ! 69: * These routines are called from tp.trans. ! 70: * They include the routines that check the validity of acks and Xacks, ! 71: * (tp_goodack() and tp_goodXack() ) ! 72: * take packets from socket buffers and send them (tp_send()), ! 73: * drop the data from the socket buffers (tp_sbdrop()), ! 74: * and put incoming packet data into socket buffers (tp_stash()). ! 75: */ ! 76: ! 77: #include "param.h" ! 78: #include "mbuf.h" ! 79: #include "socket.h" ! 80: #include "socketvar.h" ! 81: #include "protosw.h" ! 82: #include "errno.h" ! 83: #include "types.h" ! 84: #include "time.h" ! 85: ! 86: #include "tp_ip.h" ! 87: #include "iso.h" ! 88: #include "argo_debug.h" ! 89: #include "tp_timer.h" ! 90: #include "tp_param.h" ! 91: #include "tp_stat.h" ! 92: #include "tp_pcb.h" ! 93: #include "tp_tpdu.h" ! 94: #include "tp_trace.h" ! 95: #include "tp_meas.h" ! 96: #include "tp_seq.h" ! 97: ! 98: int tp_emit(); ! 99: static void tp_sbdrop(); ! 100: ! 101: #define SMOOTH(newtype, alpha, old, new) \ ! 102: (newtype) (((new - old)>>alpha) + (old)) ! 103: ! 104: #define ABS(type, val) \ ! 105: (type) (((int)(val)<0)?-(val):(val)) ! 106: ! 107: #define TP_MAKE_RTC( Xreg, Xseq, Xeot, Xdata, Xlen, Xretval, Xtype) \ ! 108: { struct mbuf *xxn;\ ! 109: MGET(xxn, M_DONTWAIT, Xtype);\ ! 110: if( xxn == (struct mbuf *)0 ) {\ ! 111: printf("MAKE RTC FAILED: ENOBUFS\n");\ ! 112: return (int)Xretval;\ ! 113: }\ ! 114: xxn->m_act=MNULL;\ ! 115: Xreg = mtod(xxn, struct tp_rtc *);\ ! 116: if( Xreg == (struct tp_rtc *)0 ) {\ ! 117: return (int)Xretval;\ ! 118: }\ ! 119: Xreg->tprt_eot = Xeot;\ ! 120: Xreg->tprt_seq = Xseq;\ ! 121: Xreg->tprt_data = Xdata;\ ! 122: Xreg->tprt_octets = Xlen;\ ! 123: } ! 124: ! 125: ! 126: /* ! 127: * CALLED FROM: ! 128: * tp.trans, when an XAK arrives ! 129: * FUNCTION and ARGUMENTS: ! 130: * Determines if the sequence number (seq) from the XAK ! 131: * acks anything new. If so, drop the appropriate tpdu ! 132: * from the XPD send queue. ! 133: * RETURN VALUE: ! 134: * Returns 1 if it did this, 0 if the ack caused no action. ! 135: */ ! 136: int ! 137: tp_goodXack(tpcb, seq) ! 138: struct tp_pcb *tpcb; ! 139: SeqNum seq; ! 140: { ! 141: ! 142: IFTRACE(D_XPD) ! 143: tptraceTPCB(TPPTgotXack, ! 144: seq, tpcb->tp_Xuna, tpcb->tp_Xsndnxt, tpcb->tp_sndhiwat, ! 145: tpcb->tp_snduna); ! 146: ENDTRACE ! 147: ! 148: if ( seq == tpcb->tp_Xuna ) { ! 149: tpcb->tp_Xuna = tpcb->tp_Xsndnxt; ! 150: ! 151: /* DROP 1 packet from the Xsnd socket buf - just so happens ! 152: * that only one packet can be there at any time ! 153: * so drop the whole thing. If you allow > 1 packet ! 154: * the socket buffer, then you'll have to keep ! 155: * track of how many characters went w/ each XPD tpdu, so this ! 156: * will get messier ! 157: */ ! 158: IFDEBUG(D_XPD) ! 159: dump_mbuf(tpcb->tp_Xsnd.sb_mb, ! 160: "tp_goodXack Xsnd before sbdrop"); ! 161: ENDDEBUG ! 162: ! 163: IFTRACE(D_XPD) ! 164: tptraceTPCB(TPPTmisc, ! 165: "goodXack: dropping cc ", ! 166: (int)(tpcb->tp_Xsnd.sb_cc), ! 167: 0,0,0); ! 168: ENDTRACE ! 169: sbdrop( &tpcb->tp_Xsnd, (int)(tpcb->tp_Xsnd.sb_cc)); ! 170: CONG_ACK(tpcb, seq); ! 171: return 1; ! 172: } ! 173: return 0; ! 174: } ! 175: ! 176: /* ! 177: * CALLED FROM: ! 178: * tp_good_ack() ! 179: * FUNCTION and ARGUMENTS: ! 180: * updates ! 181: * smoothed average round trip time (base_rtt) ! 182: * roundtrip time variance (base_rtv) - actually deviation, not variance ! 183: * given the new value (diff) ! 184: * RETURN VALUE: ! 185: * void ! 186: */ ! 187: ! 188: void ! 189: tp_rtt_rtv( base_rtt, base_rtv, newmeas ) ! 190: struct timeval *base_rtt, *base_rtv, *newmeas; ! 191: { ! 192: /* update rt variance (really just the deviation): ! 193: * rtv.smooth_ave = SMOOTH( | oldrtt.smooth_avg - rtt.this_instance | ) ! 194: */ ! 195: base_rtv->tv_sec = ! 196: SMOOTH( long, TP_RTV_ALPHA, base_rtv->tv_sec, ! 197: ABS( long, base_rtt->tv_sec - newmeas->tv_sec )); ! 198: base_rtv->tv_usec = ! 199: SMOOTH( long, TP_RTV_ALPHA, base_rtv->tv_usec, ! 200: ABS(long, base_rtt->tv_usec - newmeas->tv_usec )); ! 201: ! 202: /* update smoothed average rtt */ ! 203: base_rtt->tv_sec = ! 204: SMOOTH( long, TP_RTT_ALPHA, base_rtt->tv_sec, newmeas->tv_sec); ! 205: base_rtt->tv_usec = ! 206: SMOOTH( long, TP_RTT_ALPHA, base_rtt->tv_usec, newmeas->tv_usec); ! 207: ! 208: } ! 209: ! 210: /* ! 211: * CALLED FROM: ! 212: * tp.trans when an AK arrives ! 213: * FUNCTION and ARGUMENTS: ! 214: * Given (cdt), the credit from the AK tpdu, and ! 215: * (seq), the sequence number from the AK tpdu, ! 216: * tp_goodack() determines if the AK acknowledges something in the send ! 217: * window, and if so, drops the appropriate packets from the retransmission ! 218: * list, computes the round trip time, and updates the retransmission timer ! 219: * based on the new smoothed round trip time. ! 220: * RETURN VALUE: ! 221: * Returns 1 if ! 222: * EITHER it actually acked something heretofore unacknowledged ! 223: * OR no news but the credit should be processed. ! 224: * If something heretofore unacked was acked with this sequence number, ! 225: * the appropriate tpdus are dropped from the retransmission control list, ! 226: * by calling tp_sbdrop(). ! 227: * No need to see the tpdu itself. ! 228: */ ! 229: int ! 230: tp_goodack(tpcb, cdt, seq, subseq) ! 231: register struct tp_pcb *tpcb; ! 232: u_int cdt; ! 233: register SeqNum seq, subseq; ! 234: { ! 235: int old_fcredit = tpcb->tp_fcredit; ! 236: int bang = 0; /* bang --> ack for something heretofore unacked */ ! 237: ! 238: IFDEBUG(D_ACKRECV) ! 239: printf("goodack seq 0x%x cdt 0x%x snduna 0x%x sndhiwat 0x%x\n", ! 240: seq, cdt, tpcb->tp_snduna, tpcb->tp_sndhiwat); ! 241: ENDDEBUG ! 242: IFTRACE(D_ACKRECV) ! 243: tptraceTPCB(TPPTgotack, ! 244: seq,cdt, tpcb->tp_snduna,tpcb->tp_sndhiwat,subseq); ! 245: ENDTRACE ! 246: ! 247: IFPERF(tpcb) ! 248: tpmeas(tpcb->tp_lref, TPtime_ack_rcvd, (struct timeval *)0, seq, 0, 0); ! 249: ENDPERF ! 250: ! 251: if ( subseq != 0 && (subseq <= tpcb->tp_r_subseq) ) { ! 252: /* discard the ack */ ! 253: IFTRACE(D_ACKRECV) ! 254: tptraceTPCB(TPPTmisc, "goodack discard : subseq tp_r_subseq", ! 255: subseq, tpcb->tp_r_subseq, 0, 0); ! 256: ENDTRACE ! 257: return 0; ! 258: } else { ! 259: tpcb->tp_r_subseq = subseq; ! 260: } ! 261: ! 262: if ( IN_SWINDOW(tpcb, seq, ! 263: tpcb->tp_snduna, SEQ(tpcb, tpcb->tp_sndhiwat+1)) ) { ! 264: ! 265: IFDEBUG(D_XPD) ! 266: dump_mbuf(tpcb->tp_sock->so_snd.sb_mb, ! 267: "tp_goodack snd before sbdrop"); ! 268: ENDDEBUG ! 269: tp_sbdrop(tpcb, SEQ_SUB(tpcb, seq, 1) ); ! 270: ! 271: /* increase congestion window but don't let it get too big */ ! 272: { ! 273: register int maxcdt = tpcb->tp_xtd_format?0xffff:0xf; ! 274: CONG_ACK(tpcb, seq); ! 275: } ! 276: ! 277: /* Compute smoothed round trip time. ! 278: * Only measure rtt for tp_snduna if tp_snduna was among ! 279: * the last TP_RTT_NUM seq numbers sent, and if the data ! 280: * were not retransmitted. ! 281: */ ! 282: if (SEQ_GEQ(tpcb, tpcb->tp_snduna, ! 283: SEQ(tpcb, tpcb->tp_sndhiwat - TP_RTT_NUM)) ! 284: && SEQ_GT(tpcb, seq, SEQ_ADD(tpcb, tpcb->tp_retrans_hiwat, 1))) { ! 285: ! 286: struct timeval *t = &tpcb->tp_rttemit[tpcb->tp_snduna & TP_RTT_NUM]; ! 287: struct timeval x; ! 288: ! 289: GET_TIME_SINCE(t, &x); ! 290: ! 291: tp_rtt_rtv( &(tpcb->tp_rtt), &(tpcb->tp_rtv), &x ); ! 292: ! 293: { /* update the global rtt, rtv stats */ ! 294: register int i = ! 295: (int) tpcb->tp_flags & (TPF_PEER_ON_SAMENET | TPF_NLQOS_PDN); ! 296: tp_rtt_rtv( &(tp_stat.ts_rtt[i]), &(tp_stat.ts_rtv[i]), &x ); ! 297: ! 298: IFTRACE(D_RTT) ! 299: tptraceTPCB(TPPTmisc, "Global rtt, rtv: i", i, 0, 0, 0); ! 300: ENDTRACE ! 301: } ! 302: ! 303: IFTRACE(D_RTT) ! 304: tptraceTPCB(TPPTmisc, ! 305: "Smoothed rtt: tp_snduna, (time.sec, time.usec), peer_acktime", ! 306: tpcb->tp_snduna, time.tv_sec, time.tv_usec, ! 307: tpcb->tp_peer_acktime); ! 308: ! 309: tptraceTPCB(TPPTmisc, ! 310: "(secs): emittime diff(x) rtt, rtv", ! 311: t->tv_sec, ! 312: x.tv_sec, ! 313: tpcb->tp_rtt.tv_sec, ! 314: tpcb->tp_rtv.tv_sec); ! 315: tptraceTPCB(TPPTmisc, ! 316: "(usecs): emittime diff(x) rtt rtv", ! 317: t->tv_usec, ! 318: x.tv_usec, ! 319: tpcb->tp_rtt.tv_usec, ! 320: tpcb->tp_rtv.tv_usec); ! 321: ENDTRACE ! 322: ! 323: { ! 324: /* Update data retransmission timer based on the smoothed ! 325: * round trip time, peer ack time, and the pseudo-arbitrary ! 326: * number 4. ! 327: * new ticks: avg rtt + 2*dev ! 328: * rtt, rtv are in microsecs, and ticks are 500 ms ! 329: * so 1 tick = 500*1000 us = 500000 us ! 330: * so ticks = (rtt + 2 rtv)/500000 ! 331: * with ticks no les than peer ack time and no less than 4 ! 332: */ ! 333: ! 334: int rtt = tpcb->tp_rtt.tv_usec + ! 335: tpcb->tp_rtt.tv_sec*1000000; ! 336: int rtv = tpcb->tp_rtv.tv_usec + ! 337: tpcb->tp_rtv.tv_sec*1000000; ! 338: ! 339: IFTRACE(D_RTT) ! 340: tptraceTPCB(TPPTmisc, "oldticks ,rtv, rtt, newticks", ! 341: tpcb->tp_dt_ticks, ! 342: rtv, rtt, ! 343: (rtt/500000 + (2 * rtv)/500000)); ! 344: ENDTRACE ! 345: tpcb->tp_dt_ticks = (rtt+ (2 * rtv))/500000; ! 346: tpcb->tp_dt_ticks = MAX( tpcb->tp_dt_ticks, ! 347: tpcb->tp_peer_acktime); ! 348: tpcb->tp_dt_ticks = MAX( tpcb->tp_dt_ticks, 4); ! 349: } ! 350: } ! 351: tpcb->tp_snduna = seq; ! 352: tpcb->tp_retrans = tpcb->tp_Nretrans; /* CE_BIT */ ! 353: ! 354: bang++; ! 355: } ! 356: ! 357: if( cdt != 0 && old_fcredit == 0 ) { ! 358: tpcb->tp_sendfcc = 1; ! 359: } ! 360: if( cdt == 0 && old_fcredit != 0 ) { ! 361: IncStat(ts_zfcdt); ! 362: } ! 363: tpcb->tp_fcredit = cdt; ! 364: ! 365: IFDEBUG(D_ACKRECV) ! 366: printf("goodack returning 0x%x, bang 0x%x cdt 0x%x old_fcredit 0x%x\n", ! 367: (bang || (old_fcredit < cdt) ), bang, cdt, old_fcredit ); ! 368: ENDDEBUG ! 369: ! 370: return (bang || (old_fcredit < cdt)) ; ! 371: } ! 372: ! 373: /* ! 374: * CALLED FROM: ! 375: * tp_goodack() ! 376: * FUNCTION and ARGUMENTS: ! 377: * drops everything up TO and INCLUDING seq # (seq) ! 378: * from the retransmission queue. ! 379: */ ! 380: static void ! 381: tp_sbdrop(tpcb, seq) ! 382: struct tp_pcb *tpcb; ! 383: SeqNum seq; ! 384: { ! 385: register struct tp_rtc *s = tpcb->tp_snduna_rtc; ! 386: ! 387: IFDEBUG(D_ACKRECV) ! 388: printf("tp_sbdrop up through seq 0x%x\n", seq); ! 389: ENDDEBUG ! 390: while (s != (struct tp_rtc *)0 && (SEQ_LEQ(tpcb, s->tprt_seq, seq))) { ! 391: m_freem( s->tprt_data ); ! 392: tpcb->tp_snduna_rtc = s->tprt_next; ! 393: (void) m_free( dtom( s ) ); ! 394: s = tpcb->tp_snduna_rtc; ! 395: } ! 396: if(tpcb->tp_snduna_rtc == (struct tp_rtc *)0) ! 397: tpcb->tp_sndhiwat_rtc = (struct tp_rtc *) 0; ! 398: ! 399: } ! 400: ! 401: /* ! 402: * CALLED FROM: ! 403: * tp.trans on user send request, arrival of AK and arrival of XAK ! 404: * FUNCTION and ARGUMENTS: ! 405: * Emits tpdus starting at sequence number (lowseq). ! 406: * Emits until a) runs out of data, or b) runs into an XPD mark, or ! 407: * c) it hits seq number (highseq) ! 408: * Removes the octets from the front of the socket buffer ! 409: * and repackages them in one mbuf chain per tpdu. ! 410: * Moves the mbuf chain to the doubly linked list that runs from ! 411: * tpcb->tp_sndhiwat_rtc to tpcb->tp_snduna_rtc. ! 412: * ! 413: * Creates tpdus that are no larger than <tpcb->tp_l_tpdusize - headersize>, ! 414: * ! 415: * If you want XPD to buffer > 1 du per socket buffer, you can ! 416: * modifiy this to issue XPD tpdus also, but then it'll have ! 417: * to take some argument(s) to distinguish between the type of DU to ! 418: * hand tp_emit, the socket buffer from which to get the data, and ! 419: * the chain of tp_rtc structures on which to put the data sent. ! 420: * ! 421: * When something is sent for the first time, its time-of-send ! 422: * is stashed (the last RTT_NUM of them are stashed). When the ! 423: * ack arrives, the smoothed round-trip time is figured using this value. ! 424: * RETURN VALUE: ! 425: * the highest seq # sent successfully. ! 426: */ ! 427: tp_send(tpcb) ! 428: register struct tp_pcb *tpcb; ! 429: { ! 430: register int len; ! 431: register struct mbuf *m; /* the one we're inspecting now */ ! 432: struct mbuf *mb;/* beginning of this tpdu */ ! 433: struct mbuf *nextrecord; /* NOT next tpdu but next sb record */ ! 434: struct sockbuf *sb = &tpcb->tp_sock->so_snd; ! 435: int maxsize = tpcb->tp_l_tpdusize ! 436: - tp_headersize(DT_TPDU_type, tpcb) ! 437: - (tpcb->tp_use_checksum?4:0) ; ! 438: unsigned int eotsdu_reached=0; ! 439: SeqNum lowseq, highseq ; ! 440: SeqNum lowsave; ! 441: #ifdef TP_PERF_MEAS ! 442: ! 443: struct timeval send_start_time; ! 444: IFPERF(tpcb) ! 445: GET_CUR_TIME(&send_start_time); ! 446: ENDPERF ! 447: #endif TP_PERF_MEAS ! 448: ! 449: lowsave = lowseq = SEQ(tpcb, tpcb->tp_sndhiwat + 1); ! 450: ! 451: ASSERT( tpcb->tp_cong_win > 0 && tpcb->tp_cong_win < 0xffff); ! 452: ! 453: if( tpcb->tp_rx_strat & TPRX_USE_CW ) { ! 454: /*first hiseq is temp vbl*/ ! 455: highseq = MIN(tpcb->tp_fcredit, tpcb->tp_cong_win); ! 456: } else { ! 457: highseq = tpcb->tp_fcredit; ! 458: } ! 459: highseq = SEQ(tpcb, tpcb->tp_snduna + highseq); ! 460: ! 461: SEQ_DEC(tpcb, highseq); ! 462: ! 463: IFDEBUG(D_DATA) ! 464: printf( ! 465: "tp_send enter tpcb 0x%x l %d -> h %d\ndump of sb_mb:\n", ! 466: tpcb, lowseq, highseq); ! 467: dump_mbuf(sb->sb_mb, "sb_mb:"); ! 468: ENDDEBUG ! 469: IFTRACE(D_DATA) ! 470: tptraceTPCB( TPPTmisc, "tp_send lowsave sndhiwat snduna", ! 471: lowsave, tpcb->tp_sndhiwat, tpcb->tp_snduna, 0); ! 472: tptraceTPCB( TPPTmisc, "tp_send low high fcredit congwin", ! 473: lowseq, highseq, tpcb->tp_fcredit, tpcb->tp_cong_win); ! 474: ENDTRACE ! 475: ! 476: ! 477: if ( SEQ_GT(tpcb, lowseq, highseq) ) ! 478: return ; /* don't send, don't change hiwat, don't set timers */ ! 479: ! 480: ASSERT( SEQ_LEQ(tpcb, lowseq, highseq) ); ! 481: SEQ_DEC(tpcb, lowseq); ! 482: ! 483: IFTRACE(D_DATA) ! 484: tptraceTPCB( TPPTmisc, "tp_send 2 low high fcredit congwin", ! 485: lowseq, highseq, tpcb->tp_fcredit, tpcb->tp_cong_win); ! 486: ENDTRACE ! 487: ! 488: while ((SEQ_LT(tpcb, lowseq, highseq)) && (mb = m = sb->sb_mb)) { ! 489: if (tpcb->tp_Xsnd.sb_mb) { ! 490: IFTRACE(D_XPD) ! 491: tptraceTPCB( TPPTmisc, ! 492: "tp_send XPD mark low high tpcb.Xuna", ! 493: lowseq, highseq, tpcb->tp_Xsnd.sb_mb, 0); ! 494: ENDTRACE ! 495: /* stop sending here because there are unacked XPD which were ! 496: * given to us before the next data were. ! 497: */ ! 498: IncStat(ts_xpd_intheway); ! 499: break; ! 500: } ! 501: eotsdu_reached = 0; ! 502: nextrecord = m->m_act; ! 503: for (len = 0; m; m = m->m_next) { ! 504: len += m->m_len; ! 505: if (m->m_flags & M_EOR) ! 506: eotsdu_reached = 1; ! 507: sbfree(sb, m); /* reduce counts in socket buffer */ ! 508: } ! 509: sb->sb_mb = nextrecord; ! 510: IFTRACE(D_STASH) ! 511: tptraceTPCB(TPPTmisc, "tp_send whole mbuf: m_len len maxsize", ! 512: 0, mb->m_len, len, maxsize); ! 513: ENDTRACE ! 514: ! 515: if ( len == 0 && !eotsdu_reached) { ! 516: /* THIS SHOULD NEVER HAPPEN! */ ! 517: ASSERT( 0 ); ! 518: goto done; ! 519: } ! 520: ! 521: /* If we arrive here one of the following holds: ! 522: * 1. We have exactly <maxsize> octets of whole mbufs, ! 523: * 2. We accumulated <maxsize> octets using partial mbufs, ! 524: * 3. We found an TPMT_EOT or an XPD mark ! 525: * 4. We hit the end of a chain through m_next. ! 526: * In this case, we'd LIKE to continue with the next record, ! 527: * but for the time being, for simplicity, we'll stop here. ! 528: * In all cases, m points to mbuf containing first octet to be ! 529: * sent in the tpdu AFTER the one we're going to send now, ! 530: * or else m is null. ! 531: * ! 532: * The chain we're working on now begins at mb and has length <len>. ! 533: */ ! 534: ! 535: IFTRACE(D_STASH) ! 536: tptraceTPCB( TPPTmisc, ! 537: "tp_send mcopy low high eotsdu_reached len", ! 538: lowseq, highseq, eotsdu_reached, len); ! 539: ENDTRACE ! 540: ! 541: /* make a copy - mb goes into the retransmission list ! 542: * while m gets emitted. m_copy won't copy a zero-length mbuf. ! 543: */ ! 544: if (len) { ! 545: if ((m = m_copy(mb, 0, len )) == MNULL) ! 546: goto done; ! 547: } else { ! 548: /* eotsdu reached */ ! 549: MGET(m, M_WAIT, TPMT_DATA); ! 550: if (m == MNULL) ! 551: goto done; ! 552: m->m_len = 0; ! 553: } ! 554: ! 555: SEQ_INC(tpcb,lowseq); /* it was decremented at the beginning */ ! 556: { ! 557: struct tp_rtc *t; ! 558: /* make an rtc and put it at the end of the chain */ ! 559: ! 560: TP_MAKE_RTC( t, lowseq, eotsdu_reached, mb, len, lowseq, ! 561: TPMT_SNDRTC); ! 562: t->tprt_next = (struct tp_rtc *)0; ! 563: ! 564: if ( tpcb->tp_sndhiwat_rtc != (struct tp_rtc *)0 ) ! 565: tpcb->tp_sndhiwat_rtc->tprt_next = t; ! 566: else { ! 567: ASSERT( tpcb->tp_snduna_rtc == (struct tp_rtc *)0 ); ! 568: tpcb->tp_snduna_rtc = t; ! 569: } ! 570: ! 571: tpcb->tp_sndhiwat_rtc = t; ! 572: } ! 573: ! 574: IFTRACE(D_DATA) ! 575: tptraceTPCB( TPPTmisc, ! 576: "tp_send emitting DT lowseq eotsdu_reached len", ! 577: lowseq, eotsdu_reached, len, 0); ! 578: ENDTRACE ! 579: if( tpcb->tp_sock->so_error = ! 580: tp_emit(DT_TPDU_type, tpcb, lowseq, eotsdu_reached, m) ) { ! 581: /* error */ ! 582: SEQ_DEC(tpcb, lowseq); ! 583: goto done; ! 584: } ! 585: /* set the transmit-time for computation of round-trip times */ ! 586: bcopy( (caddr_t)&time, ! 587: (caddr_t)&( tpcb->tp_rttemit[ lowseq & TP_RTT_NUM ] ), ! 588: sizeof(struct timeval)); ! 589: ! 590: } ! 591: ! 592: done: ! 593: #ifdef TP_PERF_MEAS ! 594: IFPERF(tpcb) ! 595: { ! 596: register int npkts; ! 597: struct timeval send_end_time; ! 598: register struct timeval *t; ! 599: ! 600: npkts = lowseq; ! 601: SEQ_INC(tpcb, npkts); ! 602: npkts = SEQ_SUB(tpcb, npkts, lowsave); ! 603: ! 604: if(npkts > 0) ! 605: tpcb->tp_Nwindow++; ! 606: ! 607: if (npkts > TP_PM_MAX) ! 608: npkts = TP_PM_MAX; ! 609: ! 610: GET_TIME_SINCE(&send_start_time, &send_end_time); ! 611: t = &(tpcb->tp_p_meas->tps_sendtime[npkts]); ! 612: t->tv_sec = ! 613: SMOOTH( long, TP_RTT_ALPHA, t->tv_sec, send_end_time.tv_sec); ! 614: t->tv_usec = ! 615: SMOOTH( long, TP_RTT_ALPHA, t->tv_usec, send_end_time.tv_usec); ! 616: ! 617: if ( SEQ_LT(tpcb, lowseq, highseq) ) { ! 618: IncPStat(tpcb, tps_win_lim_by_data[npkts] ); ! 619: } else { ! 620: IncPStat(tpcb, tps_win_lim_by_cdt[npkts] ); ! 621: /* not true with congestion-window being used */ ! 622: } ! 623: tpmeas( tpcb->tp_lref, ! 624: TPsbsend, &send_end_time, lowsave, tpcb->tp_Nwindow, npkts); ! 625: } ! 626: ENDPERF ! 627: #endif TP_PERF_MEAS ! 628: ! 629: tpcb->tp_sndhiwat = lowseq; ! 630: ! 631: if ( SEQ_LEQ(tpcb, lowsave, tpcb->tp_sndhiwat) && ! 632: (tpcb->tp_class != TP_CLASS_0) ) ! 633: tp_etimeout(tpcb->tp_refp, TM_data_retrans, lowsave, ! 634: tpcb->tp_sndhiwat, ! 635: (u_int)tpcb->tp_Nretrans, (int)tpcb->tp_dt_ticks); ! 636: IFTRACE(D_DATA) ! 637: tptraceTPCB( TPPTmisc, ! 638: "tp_send at end: sndhiwat lowseq eotsdu_reached error", ! 639: tpcb->tp_sndhiwat, lowseq, eotsdu_reached, tpcb->tp_sock->so_error); ! 640: ! 641: ENDTRACE ! 642: } ! 643: ! 644: /* ! 645: * NAME: tp_stash() ! 646: * CALLED FROM: ! 647: * tp.trans on arrival of a DT tpdu ! 648: * FUNCTION, ARGUMENTS, and RETURN VALUE: ! 649: * Returns 1 if ! 650: * a) something new arrived and it's got eotsdu_reached bit on, ! 651: * b) this arrival was caused other out-of-sequence things to be ! 652: * accepted, or ! 653: * c) this arrival is the highest seq # for which we last gave credit ! 654: * (sender just sent a whole window) ! 655: * In other words, returns 1 if tp should send an ack immediately, 0 if ! 656: * the ack can wait a while. ! 657: * ! 658: * Note: this implementation no longer renegs on credit, (except ! 659: * when debugging option D_RENEG is on, for the purpose of testing ! 660: * ack subsequencing), so we don't need to check for incoming tpdus ! 661: * being in a reneged portion of the window. ! 662: */ ! 663: ! 664: int ! 665: tp_stash( tpcb, e ) ! 666: register struct tp_pcb *tpcb; ! 667: register struct tp_event *e; ! 668: { ! 669: register int ack_reason= tpcb->tp_ack_strat & ACK_STRAT_EACH; ! 670: /* 0--> delay acks until full window */ ! 671: /* 1--> ack each tpdu */ ! 672: int newrec = 0; ! 673: ! 674: #ifndef lint ! 675: #define E e->ATTR(DT_TPDU) ! 676: #else lint ! 677: #define E e->ev_union.EV_DT_TPDU ! 678: #endif lint ! 679: ! 680: if ( E.e_eot ) { ! 681: register struct mbuf *n = E.e_data; ! 682: n->m_flags |= M_EOR; ! 683: n->m_act = 0; ! 684: } ! 685: IFDEBUG(D_STASH) ! 686: dump_mbuf(tpcb->tp_sock->so_rcv.sb_mb, ! 687: "stash: so_rcv before appending"); ! 688: dump_mbuf(E.e_data, ! 689: "stash: e_data before appending"); ! 690: ENDDEBUG ! 691: ! 692: IFPERF(tpcb) ! 693: PStat(tpcb, Nb_from_ll) += E.e_datalen; ! 694: tpmeas(tpcb->tp_lref, TPtime_from_ll, &e->e_time, ! 695: E.e_seq, (u_int)PStat(tpcb, Nb_from_ll), (u_int)E.e_datalen); ! 696: ENDPERF ! 697: ! 698: if( E.e_seq == tpcb->tp_rcvnxt ) { ! 699: ! 700: IFDEBUG(D_STASH) ! 701: printf("stash EQ: seq 0x%x datalen 0x%x eot 0x%x\n", ! 702: E.e_seq, E.e_datalen, E.e_eot); ! 703: ENDDEBUG ! 704: ! 705: IFTRACE(D_STASH) ! 706: tptraceTPCB(TPPTmisc, "stash EQ: seq len eot", ! 707: E.e_seq, E.e_datalen, E.e_eot, 0); ! 708: ENDTRACE ! 709: ! 710: sbappend(&tpcb->tp_sock->so_rcv, E.e_data); ! 711: ! 712: if (newrec = E.e_eot ) /* ASSIGNMENT */ ! 713: ack_reason |= ACK_EOT; ! 714: ! 715: SEQ_INC( tpcb, tpcb->tp_rcvnxt ); ! 716: /* ! 717: * move chains from the rtc list to the socket buffer ! 718: * and free the rtc header ! 719: */ ! 720: { ! 721: register struct tp_rtc **r = &tpcb->tp_rcvnxt_rtc; ! 722: register struct tp_rtc *s = tpcb->tp_rcvnxt_rtc; ! 723: ! 724: while (s != (struct tp_rtc *)0 && s->tprt_seq == tpcb->tp_rcvnxt) { ! 725: *r = s->tprt_next; ! 726: ! 727: sbappend(&tpcb->tp_sock->so_rcv, s->tprt_data); ! 728: ! 729: SEQ_INC( tpcb, tpcb->tp_rcvnxt ); ! 730: ! 731: (void) m_free( dtom( s ) ); ! 732: s = *r; ! 733: ack_reason |= ACK_REORDER; ! 734: } ! 735: } ! 736: IFDEBUG(D_STASH) ! 737: dump_mbuf(tpcb->tp_sock->so_rcv.sb_mb, ! 738: "stash: so_rcv after appending"); ! 739: ENDDEBUG ! 740: ! 741: } else { ! 742: register struct tp_rtc **s = &tpcb->tp_rcvnxt_rtc; ! 743: register struct tp_rtc *r = tpcb->tp_rcvnxt_rtc; ! 744: register struct tp_rtc *t; ! 745: ! 746: IFTRACE(D_STASH) ! 747: tptraceTPCB(TPPTmisc, "stash Reseq: seq rcvnxt lcdt", ! 748: E.e_seq, tpcb->tp_rcvnxt, tpcb->tp_lcredit, 0); ! 749: ENDTRACE ! 750: ! 751: r = tpcb->tp_rcvnxt_rtc; ! 752: while (r != (struct tp_rtc *)0 && SEQ_LT(tpcb, r->tprt_seq, E.e_seq)) { ! 753: s = &r->tprt_next; ! 754: r = r->tprt_next; ! 755: } ! 756: ! 757: if (r == (struct tp_rtc *)0 || SEQ_GT(tpcb, r->tprt_seq, E.e_seq) ) { ! 758: IncStat(ts_dt_ooo); ! 759: ! 760: IFTRACE(D_STASH) ! 761: tptrace(TPPTmisc, ! 762: "tp_stash OUT OF ORDER- MAKE RTC: seq, 1st seq in list\n", ! 763: E.e_seq, r->tprt_seq,0,0); ! 764: ENDTRACE ! 765: IFDEBUG(D_STASH) ! 766: printf("tp_stash OUT OF ORDER- MAKE RTC\n"); ! 767: ENDDEBUG ! 768: TP_MAKE_RTC(t, E.e_seq, E.e_eot, E.e_data, E.e_datalen, 0, ! 769: TPMT_RCVRTC); ! 770: ! 771: *s = t; ! 772: t->tprt_next = (struct tp_rtc *)r; ! 773: ack_reason = ACK_DONT; ! 774: goto done; ! 775: } else { ! 776: IFDEBUG(D_STASH) ! 777: printf("tp_stash - drop & ack\n"); ! 778: ENDDEBUG ! 779: ! 780: /* retransmission - drop it and force an ack */ ! 781: IncStat(ts_dt_dup); ! 782: IFPERF(tpcb) ! 783: IncPStat(tpcb, tps_n_ack_cuz_dup); ! 784: ENDPERF ! 785: ! 786: m_freem( E.e_data ); ! 787: ack_reason |= ACK_DUP; ! 788: goto done; ! 789: } ! 790: } ! 791: ! 792: ! 793: /* ! 794: * an ack should be sent when at least one of the ! 795: * following holds: ! 796: * a) we've received a TPDU with EOTSDU set ! 797: * b) the TPDU that just arrived represents the ! 798: * full window last advertised, or ! 799: * c) when seq X arrives [ where ! 800: * X = last_sent_uwe - 1/2 last_lcredit_sent ! 801: * (the packet representing 1/2 the last advertised window) ] ! 802: * and lcredit at the time of X arrival > last_lcredit_sent/2 ! 803: * In other words, if the last ack sent advertised cdt=8 and uwe = 8 ! 804: * then when seq 4 arrives I'd like to send a new ack ! 805: * iff the credit at the time of 4's arrival is > 4. ! 806: * The other end thinks it has cdt of 4 so if local cdt ! 807: * is still 4 there's no point in sending an ack, but if ! 808: * my credit has increased because the receiver has taken ! 809: * some data out of the buffer (soreceive doesn't notify ! 810: * me until the SYSTEM CALL finishes), I'd like to tell ! 811: * the other end. ! 812: */ ! 813: ! 814: done: ! 815: { ! 816: LOCAL_CREDIT(tpcb); ! 817: ! 818: if ( E.e_seq == tpcb->tp_sent_uwe ) ! 819: ack_reason |= ACK_STRAT_FULLWIN; ! 820: ! 821: IFTRACE(D_STASH) ! 822: tptraceTPCB(TPPTmisc, ! 823: "end of stash, eot, ack_reason, sent_uwe ", ! 824: E.e_eot, ack_reason, tpcb->tp_sent_uwe, 0); ! 825: ENDTRACE ! 826: ! 827: if ( ack_reason == ACK_DONT ) { ! 828: IncStat( ts_ackreason[ACK_DONT] ); ! 829: return 0; ! 830: } else { ! 831: IFPERF(tpcb) ! 832: if(ack_reason & ACK_EOT) { ! 833: IncPStat(tpcb, tps_n_ack_cuz_eot); ! 834: } ! 835: if(ack_reason & ACK_STRAT_EACH) { ! 836: IncPStat(tpcb, tps_n_ack_cuz_strat); ! 837: } else if(ack_reason & ACK_STRAT_FULLWIN) { ! 838: IncPStat(tpcb, tps_n_ack_cuz_fullwin); ! 839: } else if(ack_reason & ACK_REORDER) { ! 840: IncPStat(tpcb, tps_n_ack_cuz_reorder); ! 841: } ! 842: tpmeas(tpcb->tp_lref, TPtime_ack_sent, 0, ! 843: SEQ_ADD(tpcb, E.e_seq, 1), 0, 0); ! 844: ENDPERF ! 845: { ! 846: register int i; ! 847: ! 848: /* keep track of all reasons that apply */ ! 849: for( i=1; i<_ACK_NUM_REASONS_ ;i++) { ! 850: if( ack_reason & (1<<i) ) ! 851: IncStat( ts_ackreason[i] ); ! 852: } ! 853: } ! 854: return 1; ! 855: } ! 856: } ! 857: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.