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