![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to adsp_Control.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netat|
Return to adsp_Control.c CVS log | Up to [Apple XNU] / XNU / bsd / netat |
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) 1990, 1995-1998 Apple Computer, Inc.
24: * All Rights Reserved.
25: */
26:
27: /* Control.c
28: * From Mike Shoemaker v01.25 07/02/90 for MacOS
29: * 09/07/95 - Modified for performance (Tuyen Nguyen)
30: * Modified for MP, 1996 by Tuyen Nguyen
31: * Modified, April 9, 1997 by Tuyen Nguyen for MacOSX.
32: */
33:
34: #include <sys/errno.h>
35: #include <sys/types.h>
36: #include <sys/param.h>
37: #include <machine/spl.h>
38: #include <sys/systm.h>
39: #include <sys/kernel.h>
40: #include <sys/proc.h>
41: #include <sys/filedesc.h>
42: #include <sys/fcntl.h>
43: #include <sys/mbuf.h>
44: #include <sys/time.h>
45: #include <sys/socket.h>
46:
47: #include <netat/sysglue.h>
48: #include <netat/appletalk.h>
49: #include <netat/ddp.h>
50: #include <netat/at_pcb.h>
51: #include <netat/debug.h>
52: #include <netat/adsp.h>
53: #include <netat/adsp_internal.h>
54:
55: /* # of additional ticks to add to any timer that we're queuing up. For
56: * very short delays (1 and 2), the timer fires before the transmit
57: * even takes place */
58: #define TX_DLY 2
59:
60: int adsp_window = 1;
61:
62: /*
63: * CalcRecvWdw
64: *
65: * INPUTS:
66: * sp ADSP Stream
67: * OUTPUTS:
68: * # of bytes in avail in local receive queue
69: */
70: int CalcRecvWdw(sp) /* (CCBPtr sp) */
71: CCBPtr sp;
72: {
73: int bytes;
74:
75: bytes = calcRecvQ(sp);
76: bytes = sp->rbuflen - bytes; /* get what is left */
77:
78: if (bytes <= 16) { /* %%% this should be zero */
79: sp->rbufFull = 1; /* Save flag that our recv buf is full */
80: return 0;
81: }
82: else
83: return ((bytes+bytes+bytes) >> 2) + 1; /* %%% */
84: }
85:
86: calcRecvQ(sp)
87: CCBPtr sp;
88: {
89: int bytes = 0;
90: #ifdef AT_Socket
91: register struct mbuf *m, *p;
92:
93: if (((sp->gref)->so)->so_rcv.sb_mb)
94: for (p = ((sp->gref)->so)->so_rcv.sb_mb; p; p = p->m_nextpkt)
95: for (m = p; m; m = m->m_next)
96: bytes += m->m_len;
97: #else
98: register gbuf_t *mb;
99:
100: if (sp->rData) { /* There is data in buffer */
101: if (mb = sp->rbuf_mb) {
102: do {
103: bytes += gbuf_msgsize(mb);
104: mb = gbuf_next(mb);
105: } while (mb);
106: }
107: if (mb = sp->crbuf_mb)
108: bytes += gbuf_msgsize(mb);
109: }
110: #endif
111: return bytes;
112: }
113:
114: /*
115: * CheckSend
116: *
117: * Check to see if the transmit PB is available and if there is anything
118: * to transmit. Start off any pending transmit.
119: *
120: * Normally called from the write completion routine
121: *
122: * INPUTS:
123: * sp Connection control block
124: * OUTPUTS:
125: * true if sent a packet
126: */
127: void CheckSend(sp) /* (CCBPtr sp) */
128: register CCBPtr sp;
129: {
130: int i;
131: int attnMsg; /* True if attention message */
132: int s;
133: register gbuf_t *mp; /* send message block */
134: #ifdef notdef
135: register gbuf_t *tmp;
136: u_char current;
137: #endif
138: char *dp; /* a data pointer */
139: int use_attention_code;
140: int len; /* length used in allocd mblk */
141: int datalen; /* amount of data attached to mblk */
142: gbuf_t *mprev, *mlist = 0;
143:
144: top:
145:
146: if (sp->state == sClosed)
147: return;
148:
149: /* get a message block to hold DDP and
150: * ADSP headers + 2 bytes of attention
151: * code if necessary */
152: if ((mp = gbuf_alloc(AT_WR_OFFSET + DDPL_FRAME_LEN + ADSP_FRAME_LEN + ADSP_OPEN_FRAME_LEN + 2,
153: PRI_LO)) == 0) {
154: if (mlist)
155: gbuf_freel(mlist);
156: return; /* can't get buffers... do nothing! */
157: }
158: ATDISABLE(s, sp->lock);
159: sp->callSend = 0; /* Clear flag */
160: use_attention_code = 0;
161: len = 0;
162: datalen = 0;
163:
164: gbuf_rinc(mp,AT_WR_OFFSET);
165: gbuf_wset(mp,DDPL_FRAME_LEN); /* leave room for DDP header */
166:
167: if (sp->sendCtl) {
168: short mask;
169:
170: i = sp->sendCtl; /* get local copy bitmap of */
171: /* which ctl packets to send. */
172: attnMsg = 0;
173:
174: if (i & 0x1E) /* One of the open ctrl packets */
175: {
176:
177: /* point past ADSP header (no attention) */
178: dp = ((char *) gbuf_wptr(mp)) + ADSP_FRAME_LEN;
179: UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->firstRtmtSeq));
180:
181: UAS_ASSIGN(sp->of.version, netw(0x0100)); /* Fill in open connection parms */
182: UAS_ASSIGN(sp->of.dstCID, sp->remCID); /* Destination CID */
183: UAL_ASSIGN(sp->of.pktAttnRecvSeq, netdw(sp->attnRecvSeq));
184: bcopy((caddr_t) &sp->of, (caddr_t) dp, ADSP_OPEN_FRAME_LEN);
185: len += ADSP_OPEN_FRAME_LEN;
186:
187: if (i & B_CTL_OREQ) {
188: UAS_ASSIGN(sp->f.CID, sp->locCID);
189: mask = B_CTL_OREQ;
190: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_OREQ;
191: } else if (i & B_CTL_OACK) {
192: UAS_ASSIGN(sp->f.CID, sp->locCID);
193: mask = B_CTL_OACK;
194: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_OACK;
195: } else if (i & B_CTL_OREQACK) {
196: UAS_ASSIGN(sp->f.CID, sp->locCID);
197: mask = B_CTL_OREQACK;
198: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_OREQACK;
199: } else /* Deny */
200: {
201: UAS_ASSIGN(sp->f.CID, 0);
202: mask = B_CTL_ODENY;
203: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_ODENY;
204: UAL_ASSIGN(sp->f.pktFirstByteSeq, 0);
205: }
206:
207: if (i & (B_CTL_OREQ | B_CTL_OREQACK))
208: /* Need to start up a timer for it */
209: {
210: /* It's possible that we've received a duplicate
211: * open request. In this case, there will already be
212: * a timer queued up for the request+ack
213: * packet we sent the first time. So remove the timer
214: * and start another.
215: */
216: RemoveTimerElem(&adspGlobal.slowTimers, &sp->ProbeTimer);
217: InsertTimerElem(&adspGlobal.slowTimers, &sp->ProbeTimer,
218: sp->openInterval+1);
219: }
220: } else {
221: /* seq # of next byte to send */
222: UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->sendSeq));
223:
224: if (i & B_CTL_CLOSE) {
225: sp->state = sClosed; /* Now we're closed */
226: mask = B_CTL_CLOSE;
227: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_CLOSE;
228: } else if (i & B_CTL_PROBE) {
229: mask = B_CTL_PROBE;
230: sp->f.descriptor =
231: ADSP_CONTROL_BIT | ADSP_CTL_PROBE | ADSP_ACK_REQ_BIT;
232: } else if (i & B_CTL_FRESET) {
233: mask = B_CTL_FRESET;
234: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_FRESET;
235: InsertTimerElem(&adspGlobal.fastTimers,
236: &sp->ResetTimer, sp->rtmtInterval+TX_DLY);
237: } else if (i & B_CTL_FRESETACK) {
238: mask = B_CTL_FRESETACK;
239: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_FRESET_ACK;
240: }
241: else if (i & B_CTL_RETRANSMIT) {
242: mask = B_CTL_RETRANSMIT;
243: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_RETRANSMIT;
244: }
245: else {
246: dPrintf(D_M_ADSP, D_L_ERROR, ("CheckSend: Control bit error\n"));
247: }
248: } /* non open control packet */
249:
250: sp->sendCtl &= ~mask;
251: goto sendit;
252: } /* send control packet */
253:
254: if (sp->sendAttnData) /* Send attn ready to go? */
255: {
256: sp->sendAttnData = 0; /* Clear Flags */
257: if (sp->sapb) {
258: sp->sendAttnAck = 0; /* This will also do an Attn Ack */
259:
260: attnMsg = 1;
261: sp->f.descriptor = ADSP_ATTENTION_BIT | ADSP_ACK_REQ_BIT;
262: if (gbuf_cont(sp->sapb->mp)) {
263: gbuf_cont(mp) = gbuf_dupm(gbuf_cont(sp->sapb->mp));
264: /* Major hack here. The ADSP Attn code is butted up against
265: * the end of the adsp packet header, and the length is
266: * increased by 2. (There is a pad field behind the adsp
267: * header in the CCB just for this purpose.)
268: */
269: }
270: use_attention_code++;
271:
272: sp->f.data[0] = high(sp->sapb->u.attnParams.attnCode);
273: sp->f.data[1] = low(sp->sapb->u.attnParams.attnCode);
274: InsertTimerElem(&adspGlobal.fastTimers, &sp->AttnTimer,
275: sp->rtmtInterval+TX_DLY);
276: goto sendit;
277: }
278: } /* attn data */
279:
280: if (sp->sendAttnAck) /* Send attn ack ready to go? */
281: {
282: attnMsg = 1;
283: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_ATTENTION_BIT;
284: sp->sendAttnAck = 0;
285: goto sendit;
286: } /* attn ack */
287:
288: if ((sp->state == sOpen || sp->state == sClosing) && /* Correct state */
289: (!sp->waitingAck) && /* not waiting for an ACK */
290: (sp->sData) && /* have data to send */
291: (GTE(sp->sendWdwSeq,sp->sendSeq)) && /* he has room to accept it */
292: (sp->pktSendCnt < sp->pktSendMax)) /* haven't sent too many pkts
293: * in a row. */
294: {
295: attnMsg = 0;
296: if (datalen = attachData(sp, mp)) /* attach data to mp */
297: goto sendit; /* if successful, sendit */
298: }
299:
300: if (sp->sendDataAck) {
301: UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->sendSeq)); /* seq # of next byte */
302: attnMsg = 0;
303: sp->f.descriptor = ADSP_CONTROL_BIT;
304: goto sendit;
305: }
306:
307: /*
308: * Nothing left to do...
309: */
310: if (mp)
311: gbuf_freem(mp);
312: ATENABLE(s, sp->lock);
313: if (mlist)
314: adsp_sendddp(sp, mlist, 0, &sp->remoteAddress, DDP_ADSP);
315: return;
316:
317: sendit:
318:
319: if (attnMsg) {
320: UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->attnSendSeq));
321: UAL_ASSIGN(sp->f.pktNextRecvSeq, netdw(sp->attnRecvSeq));
322: UAS_ASSIGN(sp->f.pktRecvWdw, 0); /* Always zero in attn pkt */
323: } else {
324: sp->sendDataAck = 0;
325: UAL_ASSIGN(sp->f.pktNextRecvSeq, netdw(sp->recvSeq));
326: UAS_ASSIGN(sp->f.pktRecvWdw, netw(CalcRecvWdw(sp)));
327: }
328: if (use_attention_code) {
329: bcopy((caddr_t) &sp->f, (caddr_t) gbuf_wptr(mp), ADSP_FRAME_LEN + 2);
330: len += ADSP_FRAME_LEN + 2;
331: } else {
332: bcopy((caddr_t) &sp->f, (caddr_t) gbuf_wptr(mp), ADSP_FRAME_LEN);
333: len += ADSP_FRAME_LEN;
334: }
335: gbuf_winc(mp,len); /* update mblk length */
336: if (mlist)
337: gbuf_next(mprev) = mp;
338: else
339: mlist = mp;
340: mprev = mp;
341:
342: if (sp->state == sClosed) { /* must have sent a close advice */
343: /* send header + data */
344: ATENABLE(s, sp->lock);
345: adsp_sendddp(sp, mlist, 0, &sp->remoteAddress, DDP_ADSP);
346: DoClose(sp, 0, -1); /* complete close! */
347: return;
348: }
349: ATENABLE(s, sp->lock);
350: if (sp->state == sClosing) /* See if we were waiting on this write */
351: CheckOkToClose(sp);
352: goto top;
353: }
354:
355: /*
356: * completepb delivers a paramater block with all its appropriate fields
357: * set back to the user.
358: *
359: * The assumptions here are that the PB is not linked to any queue,
360: * that the fields including ioResult are set, and that the
361: * kernel is no longer interested in the mblks that may or
362: * maynot be linked to this pb.
363: */
364: void completepb(sp, pb)
365: register CCBPtr sp;
366: register struct adspcmd *pb;
367: {
368: if (sp->gref && (sp->gref->info == (caddr_t)sp->sp_mp)) {
369: if (gbuf_len(pb->mp) > sizeof(struct adspcmd))
370: gbuf_wset(pb->mp,sizeof(struct adspcmd));
371: SndMsgUp(sp->gref, pb->mp);
372: NotifyUser(sp);
373: } else
374: gbuf_freem(pb->mp);
375: }
376:
377: attachData(sp, mp)
378: register CCBPtr sp;
379: register gbuf_t *mp;
380: {
381: int seq;
382: int cnt;
383: char eom = 0;
384: int bsize;
385: int diff;
386: char sendAckReq;
387: int partial = 0; /* flag for a partial send */
388: int tcnt = 0;
389: register gbuf_t *smp; /* send data message block */
390: register gbuf_t *psmp; /* previous message block */
391:
392: sendAckReq = 0;
393:
394: if (LT(sp->sendSeq, sp->firstRtmtSeq)) /* Sanity check on send seq */
395: sp->sendSeq = sp->firstRtmtSeq; /* seq must be oldest in buffer. */
396:
397: /* This test and assignment was necessary because the retry VBL could
398: * have fired and reset send Seq to first Rtmt Seq, and then an
399: * expected ACK comes in that bumps first Rtmt Seq up. Then we
400: * have the problem that send Seq is less than first Rtmt Seq.
401: * The easiest fix to this timing dilemma seems to be to reset
402: * sendSeq to first Rtmt Seq if we're sending the first packet.
403: */
404: UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->sendSeq));
405:
406: if (smp = sp->sbuf_mb) /* Get oldest header */
407: eom = 1;
408: else if (smp = sp->csbuf_mb)
409: eom = 0;
410:
411: if (smp == 0) { /* this shouldn't happen... */
412: sp->sData = 0;
413: return 0;
414: }
415: /*
416: * Must find next byte to transmit
417: */
418: seq = sp->firstRtmtSeq; /* Seq # of oldest in buffer */
419: while ((diff = (sp->sendSeq - seq)) >= ((bsize = gbuf_msgsize(smp)) + eom)) {
420: seq += bsize + eom; /* update sequence # */
421: if (gbuf_next(smp)) { /* if another send buffer */
422: smp = gbuf_next(smp);
423: eom = 1;
424: } else if (smp == sp->csbuf_mb) { /* seen the current one? */
425: smp = 0;
426: break;
427: } else if (sp->csbuf_mb) { /* look at it */
428: smp = sp->csbuf_mb;
429: eom = 0;
430: } else { /* no more buffers */
431: smp = 0;
432: break;
433: }
434: } /* while */
435:
436: if (smp) {
437: if (gbuf_next(smp) == 0) /* last block */
438: sendAckReq = 1;
439: cnt = bsize - diff; /* # of bytes in this block */
440: } else
441: cnt = 0;
442:
443: /*
444: * Check to see if the number of bytes is less than the 'send
445: * Blocking' setting. If so, then we won't send this data unless
446: * we're flushing. So we set up a timer to force a flush later.
447: */
448: if ((cnt < sp->sendBlocking) && !sp->writeFlush) {
449: InsertTimerElem(&adspGlobal.fastTimers, &sp->FlushTimer,
450: sp->sendInterval);
451: return 0; /* no data to send */
452: }
453:
454: if (cnt > ADSP_MAX_DATA_LEN) { /* truncate to one packet */
455: cnt = ADSP_MAX_DATA_LEN;
456: eom = 0;
457: sendAckReq = 0; /* Won't send ack because end of data */
458: partial++;
459: }
460:
461: if (smp) {
462: /* trim extra bytes off the beginning of the "block" before the copy */
463: while (diff) {
464: if (gbuf_len(smp) > diff)
465: break;
466: else
467: diff -= gbuf_len(smp);
468: smp = gbuf_cont(smp);
469: }
470: if((gbuf_cont(mp) = gbuf_dupm(smp)) == 0) /* copy the data */
471: return 0;
472: smp = gbuf_cont(mp); /* use the new message blocks */
473: gbuf_rinc(smp,diff); /* and get to the first byte of data to send */
474: }
475: /*
476: * Check to see if this many bytes will close the other end's
477: * receive window. If so, we need to send an ack request along
478: * with this. sendWdwSeq is the seq # of the last byte that
479: * the remote has room for
480: */
481: if ((diff = sp->sendWdwSeq + 1 - sp->sendSeq) <= cnt) {
482: if (diff < cnt) { /* Won't fit exactly */
483: eom = 0; /* so can't send EOM */
484: cnt = diff;
485: partial++;
486: }
487: sendAckReq = 1; /* Make him tell us new recv. window */
488: sp->noXmitFlow = 1; /* Don't do flow control calc. */
489: }
490:
491: /* trim extra bytes off the tail of the "block" after the copy */
492: if (partial && smp) {
493: psmp = smp;
494: tcnt = cnt;
495: while (tcnt && smp) { /* while there are message blocks and data */
496: if (tcnt >= gbuf_len(smp)) {
497: tcnt -= gbuf_len(smp);
498: if (tcnt) {
499: psmp = smp;
500: smp = gbuf_cont(smp);
501: } else {
502: if (psmp != smp) { /* not the first item on the list */
503: gbuf_cont(psmp) = 0;
504: gbuf_freem(smp);
505: smp = psmp;
506: } else {
507: gbuf_freem(gbuf_cont(smp));
508: gbuf_cont(smp) = 0;
509: }
510: break;
511: }
512: } else {
513: gbuf_wset(smp,tcnt);
514: if (gbuf_cont(smp)) {
515: gbuf_freem(gbuf_cont(smp));
516: gbuf_cont(smp) = 0;
517: }
518: break;
519: }
520: }
521: }
522:
523: sp->sendSeq += cnt + eom; /* Update sendSeq field */
524:
525: if (GT(sp->sendSeq, sp->maxSendSeq)) /* Keep track of >st ever sent */
526: sp->maxSendSeq = sp->sendSeq;
527:
528: if (eom)
529: sp->f.descriptor = ADSP_EOM_BIT;
530: else
531: sp->f.descriptor = 0;
532:
533: if (sendAckReq || (++sp->pktSendCnt >= sp->pktSendMax)) {
534: /* Last packet in a series */
535: sp->f.descriptor |= ADSP_ACK_REQ_BIT; /* We want an ack to this */
536: sp->waitingAck = 1; /* Flag that we're waiting */
537: sp->sendStamp = SysTicks(); /* Save time we sent request */
538: sp->timerSeq = sp->sendSeq; /* Save seq # we want acked */
539: InsertTimerElem(&adspGlobal.fastTimers, &sp->RetryTimer,
540: sp->rtmtInterval+TX_DLY);
541: }
542: return cnt + eom;
543: }
544:
545:
546:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.