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