![[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 [Apple XNU] / XNU / bsd / netiso|
Return to tp_subr.c CVS log | Up to [Apple XNU] / XNU / bsd / netiso |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /*- ! 23: * Copyright (c) 1991, 1993 ! 24: * The Regents of the University of California. All rights reserved. ! 25: * ! 26: * Redistribution and use in source and binary forms, with or without ! 27: * modification, are permitted provided that the following conditions ! 28: * are met: ! 29: * 1. Redistributions of source code must retain the above copyright ! 30: * notice, this list of conditions and the following disclaimer. ! 31: * 2. Redistributions in binary form must reproduce the above copyright ! 32: * notice, this list of conditions and the following disclaimer in the ! 33: * documentation and/or other materials provided with the distribution. ! 34: * 3. All advertising materials mentioning features or use of this software ! 35: * must display the following acknowledgement: ! 36: * This product includes software developed by the University of ! 37: * California, Berkeley and its contributors. ! 38: * 4. Neither the name of the University nor the names of its contributors ! 39: * may be used to endorse or promote products derived from this software ! 40: * without specific prior written permission. ! 41: * ! 42: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 43: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 44: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 45: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 46: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 47: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 48: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 49: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 50: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 51: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 52: * SUCH DAMAGE. ! 53: * ! 54: * @(#)tp_subr.c 8.1 (Berkeley) 6/10/93 ! 55: */ ! 56: ! 57: /*********************************************************** ! 58: Copyright IBM Corporation 1987 ! 59: ! 60: All Rights Reserved ! 61: ! 62: Permission to use, copy, modify, and distribute this software and its ! 63: documentation for any purpose and without fee is hereby granted, ! 64: provided that the above copyright notice appear in all copies and that ! 65: both that copyright notice and this permission notice appear in ! 66: supporting documentation, and that the name of IBM not be ! 67: used in advertising or publicity pertaining to distribution of the ! 68: software without specific, written prior permission. ! 69: ! 70: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 71: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 72: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 73: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 74: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 75: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 76: SOFTWARE. ! 77: ! 78: ******************************************************************/ ! 79: ! 80: /* ! 81: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison ! 82: */ ! 83: /* ! 84: * ARGO TP ! 85: * ! 86: * The main work of data transfer is done here. ! 87: * These routines are called from tp.trans. ! 88: * They include the routines that check the validity of acks and Xacks, ! 89: * (tp_goodack() and tp_goodXack() ) ! 90: * take packets from socket buffers and send them (tp_send()), ! 91: * drop the data from the socket buffers (tp_sbdrop()), ! 92: * and put incoming packet data into socket buffers (tp_stash()). ! 93: */ ! 94: ! 95: #include <sys/param.h> ! 96: #include <sys/systm.h> ! 97: #include <sys/mbuf.h> ! 98: #include <sys/socket.h> ! 99: #include <sys/socketvar.h> ! 100: #include <sys/protosw.h> ! 101: #include <sys/errno.h> ! 102: #include <sys/time.h> ! 103: #include <sys/kernel.h> ! 104: ! 105: #include <netiso/tp_ip.h> ! 106: #include <netiso/iso.h> ! 107: #include <netiso/argo_debug.h> ! 108: #include <netiso/tp_timer.h> ! 109: #include <netiso/tp_param.h> ! 110: #include <netiso/tp_stat.h> ! 111: #include <netiso/tp_pcb.h> ! 112: #include <netiso/tp_tpdu.h> ! 113: #include <netiso/tp_trace.h> ! 114: #include <netiso/tp_meas.h> ! 115: #include <netiso/tp_seq.h> ! 116: ! 117: int tp_emit(), tp_sbdrop(); ! 118: int tprexmtthresh = 3; ! 119: extern int ticks; ! 120: void tp_send(); ! 121: ! 122: /* ! 123: * CALLED FROM: ! 124: * tp.trans, when an XAK arrives ! 125: * FUNCTION and ARGUMENTS: ! 126: * Determines if the sequence number (seq) from the XAK ! 127: * acks anything new. If so, drop the appropriate tpdu ! 128: * from the XPD send queue. ! 129: * RETURN VALUE: ! 130: * Returns 1 if it did this, 0 if the ack caused no action. ! 131: */ ! 132: int ! 133: tp_goodXack(tpcb, seq) ! 134: struct tp_pcb *tpcb; ! 135: SeqNum seq; ! 136: { ! 137: ! 138: IFTRACE(D_XPD) ! 139: tptraceTPCB(TPPTgotXack, ! 140: seq, tpcb->tp_Xuna, tpcb->tp_Xsndnxt, tpcb->tp_sndnew, ! 141: tpcb->tp_snduna); ! 142: ENDTRACE ! 143: ! 144: if ( seq == tpcb->tp_Xuna ) { ! 145: tpcb->tp_Xuna = tpcb->tp_Xsndnxt; ! 146: ! 147: /* DROP 1 packet from the Xsnd socket buf - just so happens ! 148: * that only one packet can be there at any time ! 149: * so drop the whole thing. If you allow > 1 packet ! 150: * the socket buffer, then you'll have to keep ! 151: * track of how many characters went w/ each XPD tpdu, so this ! 152: * will get messier ! 153: */ ! 154: IFDEBUG(D_XPD) ! 155: dump_mbuf(tpcb->tp_Xsnd.sb_mb, ! 156: "tp_goodXack Xsnd before sbdrop"); ! 157: ENDDEBUG ! 158: ! 159: IFTRACE(D_XPD) ! 160: tptraceTPCB(TPPTmisc, ! 161: "goodXack: dropping cc ", ! 162: (int)(tpcb->tp_Xsnd.sb_cc), ! 163: 0,0,0); ! 164: ENDTRACE ! 165: sbdroprecord(&tpcb->tp_Xsnd); ! 166: return 1; ! 167: } ! 168: return 0; ! 169: } ! 170: ! 171: /* ! 172: * CALLED FROM: ! 173: * tp_good_ack() ! 174: * FUNCTION and ARGUMENTS: ! 175: * updates ! 176: * smoothed average round trip time (*rtt) ! 177: * roundtrip time variance (*rtv) - actually deviation, not variance ! 178: * given the new value (diff) ! 179: * RETURN VALUE: ! 180: * void ! 181: */ ! 182: ! 183: void ! 184: tp_rtt_rtv(tpcb) ! 185: register struct tp_pcb *tpcb; ! 186: { ! 187: int old = tpcb->tp_rtt; ! 188: int delta, elapsed = ticks - tpcb->tp_rttemit; ! 189: ! 190: if (tpcb->tp_rtt != 0) { ! 191: /* ! 192: * rtt is the smoothed round trip time in machine clock ticks (hz). ! 193: * It is stored as a fixed point number, unscaled (unlike the tcp ! 194: * srtt). The rationale here is that it is only significant to the ! 195: * nearest unit of slowtimo, which is at least 8 machine clock ticks ! 196: * so there is no need to scale. The smoothing is done according ! 197: * to the same formula as TCP (rtt = rtt*7/8 + measured_rtt/8). ! 198: */ ! 199: delta = elapsed - tpcb->tp_rtt; ! 200: if ((tpcb->tp_rtt += (delta >> TP_RTT_ALPHA)) <= 0) ! 201: tpcb->tp_rtt = 1; ! 202: /* ! 203: * rtv is a smoothed accumulated mean difference, unscaled ! 204: * for reasons expressed above. ! 205: * It is smoothed with an alpha of .75, and the round trip timer ! 206: * will be set to rtt + 4*rtv, also as TCP does. ! 207: */ ! 208: if (delta < 0) ! 209: delta = -delta; ! 210: if ((tpcb->tp_rtv += ((delta - tpcb->tp_rtv) >> TP_RTV_ALPHA)) <= 0) ! 211: tpcb->tp_rtv = 1; ! 212: } else { ! 213: /* ! 214: * No rtt measurement yet - use the unsmoothed rtt. ! 215: * Set the variance to half the rtt (so our first ! 216: * retransmit happens at 3*rtt) ! 217: */ ! 218: tpcb->tp_rtt = elapsed; ! 219: tpcb->tp_rtv = elapsed >> 1; ! 220: } ! 221: tpcb->tp_rttemit = 0; ! 222: tpcb->tp_rxtshift = 0; ! 223: /* ! 224: * Quoting TCP: "the retransmit should happen at rtt + 4 * rttvar. ! 225: * Because of the way we do the smoothing, srtt and rttvar ! 226: * will each average +1/2 tick of bias. When we compute ! 227: * the retransmit timer, we want 1/2 tick of rounding and ! 228: * 1 extra tick because of +-1/2 tick uncertainty in the ! 229: * firing of the timer. The bias will give us exactly the ! 230: * 1.5 tick we need. But, because the bias is ! 231: * statistical, we have to test that we don't drop below ! 232: * the minimum feasible timer (which is 2 ticks)." ! 233: */ ! 234: TP_RANGESET(tpcb->tp_dt_ticks, TP_REXMTVAL(tpcb), ! 235: tpcb->tp_peer_acktime, 128 /* XXX */); ! 236: IFDEBUG(D_RTT) ! 237: printf("%s tpcb 0x%x, elapsed %d, delta %d, rtt %d, rtv %d, old %d\n", ! 238: "tp_rtt_rtv:",tpcb,elapsed,delta,tpcb->tp_rtt,tpcb->tp_rtv,old); ! 239: ENDDEBUG ! 240: tpcb->tp_rxtcur = tpcb->tp_dt_ticks; ! 241: } ! 242: ! 243: /* ! 244: * CALLED FROM: ! 245: * tp.trans when an AK arrives ! 246: * FUNCTION and ARGUMENTS: ! 247: * Given (cdt), the credit from the AK tpdu, and ! 248: * (seq), the sequence number from the AK tpdu, ! 249: * tp_goodack() determines if the AK acknowledges something in the send ! 250: * window, and if so, drops the appropriate packets from the retransmission ! 251: * list, computes the round trip time, and updates the retransmission timer ! 252: * based on the new smoothed round trip time. ! 253: * RETURN VALUE: ! 254: * Returns 1 if ! 255: * EITHER it actually acked something heretofore unacknowledged ! 256: * OR no news but the credit should be processed. ! 257: * If something heretofore unacked was acked with this sequence number, ! 258: * the appropriate tpdus are dropped from the retransmission control list, ! 259: * by calling tp_sbdrop(). ! 260: * No need to see the tpdu itself. ! 261: */ ! 262: int ! 263: tp_goodack(tpcb, cdt, seq, subseq) ! 264: register struct tp_pcb *tpcb; ! 265: u_int cdt; ! 266: register SeqNum seq; ! 267: u_int subseq; ! 268: { ! 269: int old_fcredit; ! 270: int bang = 0; /* bang --> ack for something heretofore unacked */ ! 271: u_int bytes_acked; ! 272: ! 273: IFDEBUG(D_ACKRECV) ! 274: printf("goodack tpcb 0x%x seq 0x%x cdt %d una 0x%x new 0x%x nxt 0x%x\n", ! 275: tpcb, seq, cdt, tpcb->tp_snduna, tpcb->tp_sndnew, tpcb->tp_sndnxt); ! 276: ENDDEBUG ! 277: IFTRACE(D_ACKRECV) ! 278: tptraceTPCB(TPPTgotack, ! 279: seq,cdt, tpcb->tp_snduna,tpcb->tp_sndnew,subseq); ! 280: ENDTRACE ! 281: ! 282: IFPERF(tpcb) ! 283: tpmeas(tpcb->tp_lref, TPtime_ack_rcvd, (struct timeval *)0, seq, 0, 0); ! 284: ENDPERF ! 285: ! 286: if (seq == tpcb->tp_snduna) { ! 287: if (subseq < tpcb->tp_r_subseq || ! 288: (subseq == tpcb->tp_r_subseq && cdt <= tpcb->tp_fcredit)) { ! 289: discard_the_ack: ! 290: IFDEBUG(D_ACKRECV) ! 291: printf("goodack discard : tpcb 0x%x subseq %d r_subseq %d\n", ! 292: tpcb, subseq, tpcb->tp_r_subseq); ! 293: ENDDEBUG ! 294: goto done; ! 295: } ! 296: if (cdt == tpcb->tp_fcredit /*&& thus subseq > tpcb->tp_r_subseq */) { ! 297: tpcb->tp_r_subseq = subseq; ! 298: if (tpcb->tp_timer[TM_data_retrans] == 0) ! 299: tpcb->tp_dupacks = 0; ! 300: else if (++tpcb->tp_dupacks == tprexmtthresh) { ! 301: /* partner went out of his way to signal with different ! 302: subsequences that he has the same lack of an expected ! 303: packet. This may be an early indiciation of a loss */ ! 304: ! 305: SeqNum onxt = tpcb->tp_sndnxt; ! 306: struct mbuf *onxt_m = tpcb->tp_sndnxt_m; ! 307: u_int win = min(tpcb->tp_fcredit, ! 308: tpcb->tp_cong_win / tpcb->tp_l_tpdusize) / 2; ! 309: IFDEBUG(D_ACKRECV) ! 310: printf("%s tpcb 0x%x seq 0x%x rttseq 0x%x onxt 0x%x\n", ! 311: "goodack dupacks:", tpcb, seq, tpcb->tp_rttseq, onxt); ! 312: ENDDEBUG ! 313: if (win < 2) ! 314: win = 2; ! 315: tpcb->tp_ssthresh = win * tpcb->tp_l_tpdusize; ! 316: tpcb->tp_timer[TM_data_retrans] = 0; ! 317: tpcb->tp_rttemit = 0; ! 318: tpcb->tp_sndnxt = tpcb->tp_snduna; ! 319: tpcb->tp_sndnxt_m = 0; ! 320: tpcb->tp_cong_win = tpcb->tp_l_tpdusize; ! 321: tp_send(tpcb); ! 322: tpcb->tp_cong_win = tpcb->tp_ssthresh + ! 323: tpcb->tp_dupacks * tpcb->tp_l_tpdusize; ! 324: if (SEQ_GT(tpcb, onxt, tpcb->tp_sndnxt)) { ! 325: tpcb->tp_sndnxt = onxt; ! 326: tpcb->tp_sndnxt_m = onxt_m; ! 327: } ! 328: ! 329: } else if (tpcb->tp_dupacks > tprexmtthresh) { ! 330: tpcb->tp_cong_win += tpcb->tp_l_tpdusize; ! 331: } ! 332: goto done; ! 333: } ! 334: } else if (SEQ_LT(tpcb, seq, tpcb->tp_snduna)) ! 335: goto discard_the_ack; ! 336: /* ! 337: * If the congestion window was inflated to account ! 338: * for the other side's cached packets, retract it. ! 339: */ ! 340: if (tpcb->tp_dupacks > tprexmtthresh && ! 341: tpcb->tp_cong_win > tpcb->tp_ssthresh) ! 342: tpcb->tp_cong_win = tpcb->tp_ssthresh; ! 343: tpcb->tp_r_subseq = subseq; ! 344: old_fcredit = tpcb->tp_fcredit; ! 345: tpcb->tp_fcredit = cdt; ! 346: if (cdt > tpcb->tp_maxfcredit) ! 347: tpcb->tp_maxfcredit = cdt; ! 348: tpcb->tp_dupacks = 0; ! 349: ! 350: if (IN_SWINDOW(tpcb, seq, tpcb->tp_snduna, tpcb->tp_sndnew)) { ! 351: ! 352: tpsbcheck(tpcb, 0); ! 353: bytes_acked = tp_sbdrop(tpcb, seq); ! 354: tpsbcheck(tpcb, 1); ! 355: /* ! 356: * If transmit timer is running and timed sequence ! 357: * number was acked, update smoothed round trip time. ! 358: * Since we now have an rtt measurement, cancel the ! 359: * timer backoff (cf., Phil Karn's retransmit alg.). ! 360: * Recompute the initial retransmit timer. ! 361: */ ! 362: if (tpcb->tp_rttemit && SEQ_GT(tpcb, seq, tpcb->tp_rttseq)) ! 363: tp_rtt_rtv(tpcb); ! 364: /* ! 365: * If all outstanding data is acked, stop retransmit timer. ! 366: * If there is more data to be acked, restart retransmit ! 367: * timer, using current (possibly backed-off) value. ! 368: * OSI combines the keepalive and persistance functions. ! 369: * So, there is no persistance timer per se, to restart. ! 370: */ ! 371: if (tpcb->tp_class != TP_CLASS_0) ! 372: tpcb->tp_timer[TM_data_retrans] = ! 373: (seq == tpcb->tp_sndnew) ? 0 : tpcb->tp_rxtcur; ! 374: /* ! 375: * When new data is acked, open the congestion window. ! 376: * If the window gives us less than ssthresh packets ! 377: * in flight, open exponentially (maxseg per packet). ! 378: * Otherwise open linearly: maxseg per window ! 379: * (maxseg^2 / cwnd per packet), plus a constant ! 380: * fraction of a packet (maxseg/8) to help larger windows ! 381: * open quickly enough. ! 382: */ ! 383: { ! 384: u_int cw = tpcb->tp_cong_win, incr = tpcb->tp_l_tpdusize; ! 385: ! 386: incr = min(incr, bytes_acked); ! 387: if (cw > tpcb->tp_ssthresh) ! 388: incr = incr * incr / cw + incr / 8; ! 389: tpcb->tp_cong_win = ! 390: min(cw + incr, tpcb->tp_sock->so_snd.sb_hiwat); ! 391: } ! 392: tpcb->tp_snduna = seq; ! 393: if (SEQ_LT(tpcb, tpcb->tp_sndnxt, seq)) { ! 394: tpcb->tp_sndnxt = seq; ! 395: tpcb->tp_sndnxt_m = 0; ! 396: } ! 397: bang++; ! 398: } ! 399: ! 400: if( cdt != 0 && old_fcredit == 0 ) { ! 401: tpcb->tp_sendfcc = 1; ! 402: } ! 403: if (cdt == 0) { ! 404: if (old_fcredit != 0) ! 405: IncStat(ts_zfcdt); ! 406: /* The following might mean that the window shrunk */ ! 407: if (tpcb->tp_timer[TM_data_retrans]) { ! 408: tpcb->tp_timer[TM_data_retrans] = 0; ! 409: tpcb->tp_timer[TM_sendack] = tpcb->tp_dt_ticks; ! 410: if (tpcb->tp_sndnxt != tpcb->tp_snduna) { ! 411: tpcb->tp_sndnxt = tpcb->tp_snduna; ! 412: tpcb->tp_sndnxt_m = 0; ! 413: } ! 414: } ! 415: } ! 416: tpcb->tp_fcredit = cdt; ! 417: bang |= (old_fcredit < cdt); ! 418: ! 419: done: ! 420: IFDEBUG(D_ACKRECV) ! 421: printf("goodack returns 0x%x, cdt 0x%x ocdt 0x%x cwin 0x%x\n", ! 422: bang, cdt, old_fcredit, tpcb->tp_cong_win); ! 423: ENDDEBUG ! 424: /* if (bang) XXXXX Very bad to remove this test, but somethings broken */ ! 425: tp_send(tpcb); ! 426: return (bang); ! 427: } ! 428: ! 429: /* ! 430: * CALLED FROM: ! 431: * tp_goodack() ! 432: * FUNCTION and ARGUMENTS: ! 433: * drops everything up TO but not INCLUDING seq # (seq) ! 434: * from the retransmission queue. ! 435: */ ! 436: tp_sbdrop(tpcb, seq) ! 437: register struct tp_pcb *tpcb; ! 438: SeqNum seq; ! 439: { ! 440: struct sockbuf *sb = &tpcb->tp_sock->so_snd; ! 441: register int i = SEQ_SUB(tpcb, seq, tpcb->tp_snduna); ! 442: int oldcc = sb->sb_cc, oldi = i; ! 443: ! 444: if (i >= tpcb->tp_seqhalf) ! 445: printf("tp_spdropping too much -- should panic"); ! 446: while (i-- > 0) ! 447: sbdroprecord(sb); ! 448: IFDEBUG(D_ACKRECV) ! 449: printf("tp_sbdroping %d pkts %d bytes on %x at 0x%x\n", ! 450: oldi, oldcc - sb->sb_cc, tpcb, seq); ! 451: ENDDEBUG ! 452: if (sb->sb_flags & SB_NOTIFY) ! 453: sowwakeup(tpcb->tp_sock); ! 454: return (oldcc - sb->sb_cc); ! 455: } ! 456: ! 457: /* ! 458: * CALLED FROM: ! 459: * tp.trans on user send request, arrival of AK and arrival of XAK ! 460: * FUNCTION and ARGUMENTS: ! 461: * Emits tpdus starting at sequence number (tpcb->tp_sndnxt). ! 462: * Emits until a) runs out of data, or b) runs into an XPD mark, or ! 463: * c) it hits seq number (highseq) limited by cong or credit. ! 464: * ! 465: * If you want XPD to buffer > 1 du per socket buffer, you can ! 466: * modifiy this to issue XPD tpdus also, but then it'll have ! 467: * to take some argument(s) to distinguish between the type of DU to ! 468: * hand tp_emit. ! 469: * ! 470: * When something is sent for the first time, its time-of-send ! 471: * is stashed (in system clock ticks rather than pf_slowtimo ticks). ! 472: * When the ack arrives, the smoothed round-trip time is figured ! 473: * using this value. ! 474: */ ! 475: void ! 476: tp_send(tpcb) ! 477: register struct tp_pcb *tpcb; ! 478: { ! 479: register int len; ! 480: register struct mbuf *m; ! 481: struct mbuf *mb = 0; ! 482: struct sockbuf *sb = &tpcb->tp_sock->so_snd; ! 483: unsigned int eotsdu = 0; ! 484: SeqNum highseq, checkseq; ! 485: int idle, idleticks, off, cong_win; ! 486: #ifdef TP_PERF_MEAS ! 487: int send_start_time = ticks; ! 488: SeqNum oldnxt = tpcb->tp_sndnxt; ! 489: #endif /* TP_PERF_MEAS */ ! 490: ! 491: idle = (tpcb->tp_snduna == tpcb->tp_sndnew); ! 492: if (idle) { ! 493: idleticks = tpcb->tp_inact_ticks - tpcb->tp_timer[TM_inact]; ! 494: if (idleticks > tpcb->tp_dt_ticks) ! 495: /* ! 496: * We have been idle for "a while" and no acks are ! 497: * expected to clock out any data we send -- ! 498: * slow start to get ack "clock" running again. ! 499: */ ! 500: tpcb->tp_cong_win = tpcb->tp_l_tpdusize; ! 501: } ! 502: ! 503: cong_win = tpcb->tp_cong_win; ! 504: highseq = SEQ(tpcb, tpcb->tp_fcredit + tpcb->tp_snduna); ! 505: if (tpcb->tp_Xsnd.sb_mb) ! 506: highseq = SEQ_MIN(tpcb, highseq, tpcb->tp_sndnew); ! 507: ! 508: IFDEBUG(D_DATA) ! 509: printf("tp_send enter tpcb 0x%x nxt 0x%x win %d high 0x%x\n", ! 510: tpcb, tpcb->tp_sndnxt, cong_win, highseq); ! 511: ENDDEBUG ! 512: IFTRACE(D_DATA) ! 513: tptraceTPCB( TPPTmisc, "tp_send sndnew snduna", ! 514: tpcb->tp_sndnew, tpcb->tp_snduna, 0, 0); ! 515: tptraceTPCB( TPPTmisc, "tp_send tpcb->tp_sndnxt win fcredit congwin", ! 516: tpcb->tp_sndnxt, cong_win, tpcb->tp_fcredit, tpcb->tp_cong_win); ! 517: ENDTRACE ! 518: IFTRACE(D_DATA) ! 519: tptraceTPCB( TPPTmisc, "tp_send 2 nxt high fcredit congwin", ! 520: tpcb->tp_sndnxt, highseq, tpcb->tp_fcredit, cong_win); ! 521: ENDTRACE ! 522: ! 523: if (tpcb->tp_sndnxt_m) ! 524: m = tpcb->tp_sndnxt_m; ! 525: else { ! 526: off = SEQ_SUB(tpcb, tpcb->tp_sndnxt, tpcb->tp_snduna); ! 527: for (m = sb->sb_mb; m && off > 0; m = m->m_next) ! 528: off--; ! 529: } ! 530: send: ! 531: /* ! 532: * Avoid silly window syndrome here . . . figure out how! ! 533: */ ! 534: checkseq = tpcb->tp_sndnum; ! 535: if (idle && SEQ_LT(tpcb, tpcb->tp_sndnum, highseq)) ! 536: checkseq = highseq; /* i.e. DON'T retain highest assigned packet */ ! 537: ! 538: while ((SEQ_LT(tpcb, tpcb->tp_sndnxt, highseq)) && m && cong_win > 0) { ! 539: ! 540: eotsdu = (m->m_flags & M_EOR) != 0; ! 541: len = m->m_pkthdr.len; ! 542: if (tpcb->tp_sndnxt == checkseq && eotsdu == 0 && ! 543: len < (tpcb->tp_l_tpdusize / 2)) ! 544: break; /* Nagle . . . . . */ ! 545: cong_win -= len; ! 546: /* make a copy - mb goes into the retransmission list ! 547: * while m gets emitted. m_copy won't copy a zero-length mbuf. ! 548: */ ! 549: mb = m; ! 550: m = m_copy(mb, 0, M_COPYALL); ! 551: if (m == MNULL) ! 552: break; ! 553: IFTRACE(D_STASH) ! 554: tptraceTPCB( TPPTmisc, ! 555: "tp_send mcopy nxt high eotsdu len", ! 556: tpcb->tp_sndnxt, highseq, eotsdu, len); ! 557: ENDTRACE ! 558: ! 559: IFDEBUG(D_DATA) ! 560: printf("tp_sending tpcb 0x%x nxt 0x%x\n", ! 561: tpcb, tpcb->tp_sndnxt); ! 562: ENDDEBUG ! 563: /* when headers are precomputed, may need to fill ! 564: in checksum here */ ! 565: if (tpcb->tp_sock->so_error = ! 566: tp_emit(DT_TPDU_type, tpcb, tpcb->tp_sndnxt, eotsdu, m)) { ! 567: /* error */ ! 568: break; ! 569: } ! 570: m = mb->m_nextpkt; ! 571: tpcb->tp_sndnxt_m = m; ! 572: if (tpcb->tp_sndnxt == tpcb->tp_sndnew) { ! 573: SEQ_INC(tpcb, tpcb->tp_sndnew); ! 574: /* ! 575: * Time this transmission if not a retransmission and ! 576: * not currently timing anything. ! 577: */ ! 578: if (tpcb->tp_rttemit == 0) { ! 579: tpcb->tp_rttemit = ticks; ! 580: tpcb->tp_rttseq = tpcb->tp_sndnxt; ! 581: } ! 582: tpcb->tp_sndnxt = tpcb->tp_sndnew; ! 583: } else ! 584: SEQ_INC(tpcb, tpcb->tp_sndnxt); ! 585: /* ! 586: * Set retransmit timer if not currently set. ! 587: * Initial value for retransmit timer is smoothed ! 588: * round-trip time + 2 * round-trip time variance. ! 589: * Initialize shift counter which is used for backoff ! 590: * of retransmit time. ! 591: */ ! 592: if (tpcb->tp_timer[TM_data_retrans] == 0 && ! 593: tpcb->tp_class != TP_CLASS_0) { ! 594: tpcb->tp_timer[TM_data_retrans] = tpcb->tp_dt_ticks; ! 595: tpcb->tp_timer[TM_sendack] = tpcb->tp_keepalive_ticks; ! 596: tpcb->tp_rxtshift = 0; ! 597: } ! 598: } ! 599: if (SEQ_GT(tpcb, tpcb->tp_sndnew, tpcb->tp_sndnum)) ! 600: tpcb->tp_oktonagle = 0; ! 601: #ifdef TP_PERF_MEAS ! 602: IFPERF(tpcb) ! 603: { ! 604: register int npkts; ! 605: int elapsed = ticks - send_start_time, *t; ! 606: struct timeval now; ! 607: ! 608: npkts = SEQ_SUB(tpcb, tpcb->tp_sndnxt, oldnxt); ! 609: ! 610: if (npkts > 0) ! 611: tpcb->tp_Nwindow++; ! 612: ! 613: if (npkts > TP_PM_MAX) ! 614: npkts = TP_PM_MAX; ! 615: ! 616: t = &(tpcb->tp_p_meas->tps_sendtime[npkts]); ! 617: *t += (t - elapsed) >> TP_RTT_ALPHA; ! 618: ! 619: if (mb == 0) { ! 620: IncPStat(tpcb, tps_win_lim_by_data[npkts] ); ! 621: } else { ! 622: IncPStat(tpcb, tps_win_lim_by_cdt[npkts] ); ! 623: /* not true with congestion-window being used */ ! 624: } ! 625: now.tv_sec = elapsed / hz; ! 626: now.tv_usec = (elapsed - (hz * now.tv_sec)) * 1000000 / hz; ! 627: tpmeas( tpcb->tp_lref, ! 628: TPsbsend, &elapsed, newseq, tpcb->tp_Nwindow, npkts); ! 629: } ! 630: ENDPERF ! 631: #endif /* TP_PERF_MEAS */ ! 632: ! 633: ! 634: IFTRACE(D_DATA) ! 635: tptraceTPCB( TPPTmisc, ! 636: "tp_send at end: new nxt eotsdu error", ! 637: tpcb->tp_sndnew, tpcb->tp_sndnxt, eotsdu, tpcb->tp_sock->so_error); ! 638: ! 639: ENDTRACE ! 640: } ! 641: ! 642: int TPNagleok; ! 643: int TPNagled; ! 644: ! 645: tp_packetize(tpcb, m, eotsdu) ! 646: register struct tp_pcb *tpcb; ! 647: register struct mbuf *m; ! 648: int eotsdu; ! 649: { ! 650: register struct mbuf *n; ! 651: register struct sockbuf *sb = &tpcb->tp_sock->so_snd; ! 652: int maxsize = tpcb->tp_l_tpdusize ! 653: - tp_headersize(DT_TPDU_type, tpcb) ! 654: - (tpcb->tp_use_checksum?4:0) ; ! 655: int totlen = m->m_pkthdr.len; ! 656: struct mbuf *m_split(); ! 657: /* ! 658: * Pre-packetize the data in the sockbuf ! 659: * according to negotiated mtu. Do it here ! 660: * where we can safely wait for mbufs. ! 661: * ! 662: * This presumes knowledge of sockbuf conventions. ! 663: * TODO: allocate space for header and fill it in (once!). ! 664: */ ! 665: IFDEBUG(D_DATA) ! 666: printf("SEND BF: maxsize %d totlen %d eotsdu %d sndnum 0x%x\n", ! 667: maxsize, totlen, eotsdu, tpcb->tp_sndnum); ! 668: ENDTRACE ! 669: if (tpcb->tp_oktonagle) { ! 670: if ((n = sb->sb_mb) == 0) ! 671: panic("tp_packetize"); ! 672: while (n->m_act) ! 673: n = n->m_act; ! 674: if (n->m_flags & M_EOR) ! 675: panic("tp_packetize 2"); ! 676: SEQ_INC(tpcb, tpcb->tp_sndnum); ! 677: if (totlen + n->m_pkthdr.len < maxsize) { ! 678: /* There is an unsent packet with space, combine data */ ! 679: struct mbuf *old_n = n; ! 680: tpsbcheck(tpcb,3); ! 681: n->m_pkthdr.len += totlen; ! 682: while (n->m_next) ! 683: n = n->m_next; ! 684: sbcompress(sb, m, n); ! 685: tpsbcheck(tpcb,4); ! 686: n = old_n; ! 687: TPNagled++; ! 688: goto out; ! 689: } ! 690: } ! 691: while (m) { ! 692: n = m; ! 693: if (totlen > maxsize) { ! 694: if ((m = m_split(n, maxsize, M_WAIT)) == 0) ! 695: panic("tp_packetize"); ! 696: } else ! 697: m = 0; ! 698: totlen -= maxsize; ! 699: tpsbcheck(tpcb, 5); ! 700: sbappendrecord(sb, n); ! 701: tpsbcheck(tpcb, 6); ! 702: SEQ_INC(tpcb, tpcb->tp_sndnum); ! 703: } ! 704: out: ! 705: if (eotsdu) { ! 706: n->m_flags |= M_EOR; /* XXX belongs at end */ ! 707: tpcb->tp_oktonagle = 0; ! 708: } else { ! 709: SEQ_DEC(tpcb, tpcb->tp_sndnum); ! 710: tpcb->tp_oktonagle = 1; ! 711: TPNagleok++; ! 712: } ! 713: IFDEBUG(D_DATA) ! 714: printf("SEND out: oktonagle %d sndnum 0x%x\n", ! 715: tpcb->tp_oktonagle, tpcb->tp_sndnum); ! 716: ENDTRACE ! 717: return 0; ! 718: } ! 719: ! 720: ! 721: /* ! 722: * NAME: tp_stash() ! 723: * CALLED FROM: ! 724: * tp.trans on arrival of a DT tpdu ! 725: * FUNCTION, ARGUMENTS, and RETURN VALUE: ! 726: * Returns 1 if ! 727: * a) something new arrived and it's got eotsdu_reached bit on, ! 728: * b) this arrival was caused other out-of-sequence things to be ! 729: * accepted, or ! 730: * c) this arrival is the highest seq # for which we last gave credit ! 731: * (sender just sent a whole window) ! 732: * In other words, returns 1 if tp should send an ack immediately, 0 if ! 733: * the ack can wait a while. ! 734: * ! 735: * Note: this implementation no longer renegs on credit, (except ! 736: * when debugging option D_RENEG is on, for the purpose of testing ! 737: * ack subsequencing), so we don't need to check for incoming tpdus ! 738: * being in a reneged portion of the window. ! 739: */ ! 740: ! 741: tp_stash(tpcb, e) ! 742: register struct tp_pcb *tpcb; ! 743: register struct tp_event *e; ! 744: { ! 745: register int ack_reason= tpcb->tp_ack_strat & ACK_STRAT_EACH; ! 746: /* 0--> delay acks until full window */ ! 747: /* 1--> ack each tpdu */ ! 748: #ifndef lint ! 749: #define E e->ATTR(DT_TPDU) ! 750: #else /* lint */ ! 751: #define E e->ev_union.EV_DT_TPDU ! 752: #endif /* lint */ ! 753: ! 754: if ( E.e_eot ) { ! 755: register struct mbuf *n = E.e_data; ! 756: n->m_flags |= M_EOR; ! 757: n->m_act = 0; ! 758: } ! 759: IFDEBUG(D_STASH) ! 760: dump_mbuf(tpcb->tp_sock->so_rcv.sb_mb, ! 761: "stash: so_rcv before appending"); ! 762: dump_mbuf(E.e_data, ! 763: "stash: e_data before appending"); ! 764: ENDDEBUG ! 765: ! 766: IFPERF(tpcb) ! 767: PStat(tpcb, Nb_from_ll) += E.e_datalen; ! 768: tpmeas(tpcb->tp_lref, TPtime_from_ll, &e->e_time, ! 769: E.e_seq, (u_int)PStat(tpcb, Nb_from_ll), (u_int)E.e_datalen); ! 770: ENDPERF ! 771: ! 772: if (E.e_seq == tpcb->tp_rcvnxt) { ! 773: ! 774: IFDEBUG(D_STASH) ! 775: printf("stash EQ: seq 0x%x datalen 0x%x eot 0x%x\n", ! 776: E.e_seq, E.e_datalen, E.e_eot); ! 777: ENDDEBUG ! 778: ! 779: IFTRACE(D_STASH) ! 780: tptraceTPCB(TPPTmisc, "stash EQ: seq len eot", ! 781: E.e_seq, E.e_datalen, E.e_eot, 0); ! 782: ENDTRACE ! 783: ! 784: SET_DELACK(tpcb); ! 785: ! 786: sbappend(&tpcb->tp_sock->so_rcv, E.e_data); ! 787: ! 788: SEQ_INC( tpcb, tpcb->tp_rcvnxt ); ! 789: /* ! 790: * move chains from the reassembly queue to the socket buffer ! 791: */ ! 792: if (tpcb->tp_rsycnt) { ! 793: register struct mbuf **mp; ! 794: struct mbuf **mplim; ! 795: ! 796: mp = tpcb->tp_rsyq + (tpcb->tp_rcvnxt % tpcb->tp_maxlcredit); ! 797: mplim = tpcb->tp_rsyq + tpcb->tp_maxlcredit; ! 798: ! 799: while (tpcb->tp_rsycnt && *mp) { ! 800: sbappend(&tpcb->tp_sock->so_rcv, *mp); ! 801: tpcb->tp_rsycnt--; ! 802: *mp = 0; ! 803: SEQ_INC(tpcb, tpcb->tp_rcvnxt); ! 804: ack_reason |= ACK_REORDER; ! 805: if (++mp == mplim) ! 806: mp = tpcb->tp_rsyq; ! 807: } ! 808: } ! 809: IFDEBUG(D_STASH) ! 810: dump_mbuf(tpcb->tp_sock->so_rcv.sb_mb, ! 811: "stash: so_rcv after appending"); ! 812: ENDDEBUG ! 813: ! 814: } else { ! 815: register struct mbuf **mp; ! 816: SeqNum uwe; ! 817: ! 818: IFTRACE(D_STASH) ! 819: tptraceTPCB(TPPTmisc, "stash Reseq: seq rcvnxt lcdt", ! 820: E.e_seq, tpcb->tp_rcvnxt, tpcb->tp_lcredit, 0); ! 821: ENDTRACE ! 822: ! 823: if (tpcb->tp_rsyq == 0) ! 824: tp_rsyset(tpcb); ! 825: uwe = SEQ(tpcb, tpcb->tp_rcvnxt + tpcb->tp_maxlcredit); ! 826: if (tpcb->tp_rsyq == 0 || ! 827: !IN_RWINDOW(tpcb, E.e_seq, tpcb->tp_rcvnxt, uwe)) { ! 828: ack_reason = ACK_DONT; ! 829: m_freem(E.e_data); ! 830: } else if (*(mp = tpcb->tp_rsyq + (E.e_seq % tpcb->tp_maxlcredit))) { ! 831: IFDEBUG(D_STASH) ! 832: printf("tp_stash - drop & ack\n"); ! 833: ENDDEBUG ! 834: ! 835: /* retransmission - drop it and force an ack */ ! 836: IncStat(ts_dt_dup); ! 837: IFPERF(tpcb) ! 838: IncPStat(tpcb, tps_n_ack_cuz_dup); ! 839: ENDPERF ! 840: ! 841: m_freem(E.e_data); ! 842: ack_reason |= ACK_DUP; ! 843: } else { ! 844: *mp = E.e_data; ! 845: tpcb->tp_rsycnt++; ! 846: ack_reason = ACK_DONT; ! 847: } ! 848: } ! 849: /* there were some comments of historical interest here. */ ! 850: { ! 851: LOCAL_CREDIT(tpcb); ! 852: ! 853: if ( E.e_seq == tpcb->tp_sent_uwe ) ! 854: ack_reason |= ACK_STRAT_FULLWIN; ! 855: ! 856: IFTRACE(D_STASH) ! 857: tptraceTPCB(TPPTmisc, ! 858: "end of stash, eot, ack_reason, sent_uwe ", ! 859: E.e_eot, ack_reason, tpcb->tp_sent_uwe, 0); ! 860: ENDTRACE ! 861: ! 862: if ( ack_reason == ACK_DONT ) { ! 863: IncStat( ts_ackreason[ACK_DONT] ); ! 864: return 0; ! 865: } else { ! 866: IFPERF(tpcb) ! 867: if(ack_reason & ACK_STRAT_EACH) { ! 868: IncPStat(tpcb, tps_n_ack_cuz_strat); ! 869: } else if(ack_reason & ACK_STRAT_FULLWIN) { ! 870: IncPStat(tpcb, tps_n_ack_cuz_fullwin); ! 871: } else if(ack_reason & ACK_REORDER) { ! 872: IncPStat(tpcb, tps_n_ack_cuz_reorder); ! 873: } ! 874: tpmeas(tpcb->tp_lref, TPtime_ack_sent, 0, ! 875: SEQ_ADD(tpcb, E.e_seq, 1), 0, 0); ! 876: ENDPERF ! 877: { ! 878: register int i; ! 879: ! 880: /* keep track of all reasons that apply */ ! 881: for( i=1; i<_ACK_NUM_REASONS_ ;i++) { ! 882: if( ack_reason & (1<<i) ) ! 883: IncStat( ts_ackreason[i] ); ! 884: } ! 885: } ! 886: return 1; ! 887: } ! 888: } ! 889: } ! 890: ! 891: /* ! 892: * tp_rsyflush - drop all the packets on the reassembly queue. ! 893: * Do this when closing the socket, or when somebody has changed ! 894: * the space avaible in the receive socket (XXX). ! 895: */ ! 896: tp_rsyflush(tpcb) ! 897: register struct tp_pcb *tpcb; ! 898: { ! 899: register struct mbuf *m, **mp; ! 900: if (tpcb->tp_rsycnt) { ! 901: for (mp == tpcb->tp_rsyq + tpcb->tp_maxlcredit; ! 902: --mp >= tpcb->tp_rsyq; ) ! 903: if (*mp) { ! 904: tpcb->tp_rsycnt--; ! 905: m_freem(*mp); ! 906: } ! 907: if (tpcb->tp_rsycnt) { ! 908: printf("tp_rsyflush %x\n", tpcb); ! 909: tpcb->tp_rsycnt = 0; ! 910: } ! 911: } ! 912: FREE((caddr_t)tpcb->tp_rsyq, M_PCB); ! 913: tpcb->tp_rsyq = 0; ! 914: } ! 915: ! 916: tp_rsyset(tpcb) ! 917: register struct tp_pcb *tpcb; ! 918: { ! 919: register struct socket *so = tpcb->tp_sock; ! 920: int maxcredit = tpcb->tp_xtd_format ? 0xffff : 0xf; ! 921: int old_credit = tpcb->tp_maxlcredit; ! 922: caddr_t rsyq; ! 923: ! 924: tpcb->tp_maxlcredit = maxcredit = min(maxcredit, ! 925: (so->so_rcv.sb_hiwat + tpcb->tp_l_tpdusize)/ tpcb->tp_l_tpdusize); ! 926: ! 927: if (old_credit == tpcb->tp_maxlcredit && tpcb->tp_rsyq != 0) ! 928: return; ! 929: maxcredit *= sizeof(struct mbuf *); ! 930: if (tpcb->tp_rsyq) ! 931: tp_rsyflush(tpcb); ! 932: // if (rsyq = (caddr_t)malloc(maxcredit, M_PCB, M_NOWAIT)) ! 933: MALLOC(rsyq, caddr_t, maxcredit, M_PCB, M_NOWAIT); ! 934: if (rsyq) ! 935: bzero(rsyq, maxcredit); ! 936: tpcb->tp_rsyq = (struct mbuf **)rsyq; ! 937: } ! 938: ! 939: tpsbcheck(tpcb, i) ! 940: struct tp_pcb *tpcb; ! 941: { ! 942: register struct mbuf *n, *m; ! 943: register int len = 0, mbcnt = 0, pktlen; ! 944: struct sockbuf *sb = &tpcb->tp_sock->so_snd; ! 945: ! 946: for (n = sb->sb_mb; n; n = n->m_nextpkt) { ! 947: if ((n->m_flags & M_PKTHDR) == 0) ! 948: panic("tpsbcheck nohdr"); ! 949: pktlen = len + n->m_pkthdr.len; ! 950: for (m = n; m; m = m->m_next) { ! 951: len += m->m_len; ! 952: mbcnt += MSIZE; ! 953: if (m->m_flags & M_EXT) ! 954: mbcnt += m->m_ext.ext_size; ! 955: } ! 956: if (len != pktlen) { ! 957: printf("test %d; len %d != pktlen %d on mbuf 0x%x\n", ! 958: i, len, pktlen, n); ! 959: panic("tpsbcheck short"); ! 960: } ! 961: } ! 962: if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) { ! 963: printf("test %d: cc %d != %d || mbcnt %d != %d\n", i, len, sb->sb_cc, ! 964: mbcnt, sb->sb_mbcnt); ! 965: panic("tpsbcheck"); ! 966: } ! 967: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.