![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dkp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / io|
Return to dkp.c CVS log | Up to [Research Unix] / researchv10no / sys / io |
1.1 root 1: /*
2: * Datakit URP protocol
3: *
4: * In the language we speak to the device driver,
5: * M_DATA blocks contain data envelopes
6: * M_CTL blocks contain a control envelope,
7: * followed by zero or more data envelopes
8: *
9: * Drivers are allowed to store up blocks for a while;
10: * the S_DELIM bit means that stored data must now be sent.
11: * The point is to work with some broken URP implementations
12: * that have found their way into Datakit controllers;
13: * a driver that speaks to one might have to save data up,
14: * then send it with no intervening control-nulls when S_DELIM comes.
15: */
16:
17: #include "sys/param.h"
18: #include "sys/stream.h"
19: #include "sys/conf.h"
20: #include "sys/ttyio.h"
21: #include "sys/dkio.h"
22: #include "sys/dkstat.h"
23: #include "sys/dkp.h"
24: #include "sys/dkmod.h"
25:
26: #ifdef CAREFUL
27: #define TRC(c) *dkptrp++ = c; if (dkptrp>=&dkptrb[1024]) dkptrp=dkptrb
28: char dkptrb[1024]; char *dkptrp = dkptrb;
29: #else
30: #define TRC(c)
31: #endif
32:
33: extern struct dkstat dkstat;
34:
35: /*
36: * Protocol control bytes
37: */
38: #define SEQ 0010 /* sequence number, ends trailers */
39: #undef ECHO
40: #define ECHO 0020 /* echos, data given to next queue */
41: #define REJ 0030 /* rejections, transmission error */
42: #define ACK 0040 /* acknowledgments */
43: #define BOT 0050 /* beginning of trailer */
44: #define BOTM 0051 /* beginning of trailer, more data follows */
45: #define BOTS 0052 /* seq update algorithm on this trailer */
46: #define SOU 0053 /* start of unsequenced trailer */
47: #define EOU 0054 /* end of unsequenced trailer */
48: #define ENQ 0055 /* xmitter requests flow/error status */
49: #define CHECK 0056 /* xmitter requests error status */
50: #define INITREQ 0057 /* request initialization */
51: #define INIT0 0060 /* disable trailer processing */
52: #define INIT1 0061 /* enable trailer procesing */
53: #define AINIT 0062 /* response to INIT0/INIT1 */
54: #undef DELAY
55: #define DELAY 0100 /* real-time printing delay */
56: #define BREAK 0110 /* Send/receive break (new style) */
57:
58: #define OPEN 01
59: #define LCLOSE 02
60: #define RCLOSE 04
61: #define XCHARMODE 010
62: #define OPENING 020
63: #define RJING 040
64: #define STOPPED 0100
65: #define RCHARMODE 0200
66:
67: #define DKPPRI 28
68: #define DKPTIME 2
69:
70: extern struct dkp dkp[];
71: extern int dkpcnt;
72: long dkpopen(), cdkpopen();
73: int dkpiput(), dkpisrv(), dkpoput(), dkposrv();
74: int dkpclose();
75: static struct qinit cdkprinit = { dkpiput,dkpisrv,cdkpopen,dkpclose,512,64 };
76: static struct qinit cdkpwinit = { dkpoput,dkposrv,cdkpopen,dkpclose,128,65 };
77: static struct qinit dkprinit = { dkpiput,dkpisrv,dkpopen,dkpclose,1500,512 };
78: static struct qinit dkpwinit = { dkpoput,dkposrv,dkpopen,dkpclose,1500,512 };
79: struct streamtab dkpstream = { &dkprinit, &dkpwinit };
80: struct streamtab cdkpstream = { &cdkprinit, &cdkpwinit };
81:
82: #define MAXMSG 4096 /* max message size allowed */
83:
84: long
85: dkpopen(q)
86: struct queue *q;
87: {
88: return(rdkpopen(q, !XCHARMODE));
89: }
90:
91: long
92: cdkpopen(q)
93: struct queue *q;
94: {
95: return(rdkpopen(q, XCHARMODE));
96: }
97:
98: rdkpopen(q, mode)
99: register struct queue *q;
100: {
101: register struct dkp *dkpp;
102: static timer = 0;
103: int dkptimer();
104:
105: if (timer == 0) {
106: timer = 1;
107: timeout(dkptimer, (caddr_t)NULL, HZ);
108: }
109: if (q->ptr == NULL) {
110: for (dkpp = dkp; dkpp->state!=0; dkpp++)
111: if (dkpp >= &dkp[dkpcnt])
112: return(0);
113: dkpp->rdq = q;
114: q->ptr = (caddr_t)dkpp;
115: WR(q)->ptr = (caddr_t)dkpp;
116: WR(q)->flag |= QNOENB;
117: putctl(q->next, M_FLUSH);
118: dkpp->timer = DKPTIME;
119: dkpp->trx = 0;
120: dkpp->iseq = 0;
121: dkpp->lastecho = ECHO+0;
122: dkpp->WS = 1;
123: dkpp->WACK = 1;
124: dkpp->WNX = 1;
125: dkpp->XW = 3;
126: dkpp->xsize = 64;
127: dkpp->lastctl = 0;
128: if (mode!=XCHARMODE) {
129: WR(q)->flag |= QDELIM;
130: dkpp->state = OPENING | RCHARMODE;
131: putctl1d(WR(q)->next, M_CTL, INIT1);
132: } else {
133: dkpp->XW = 1;
134: dkpp->state = RCHARMODE | XCHARMODE | OPEN;
135: putctl1d(WR(q)->next, M_CTL, INIT0);
136: }
137: }
138: return(1);
139: }
140:
141: /*
142: * Shut it down.
143: * The problem is to dispose of unacked stuff in the window.
144: * -- no real solution; the receiver might hang on for hours.
145: * Give it 15 seconds.
146: */
147: dkpclose(q)
148: register struct queue *q;
149: {
150: register struct dkp *dkpp;
151: register s = spl5();
152: register i;
153:
154: dkpp = (struct dkp *)q->ptr;
155: dkpp->state |= LCLOSE;
156: flushq(q, 1);
157: for (i=0; dkpp->WACK < dkpp->WNX && i<15; i++)
158: tsleep((caddr_t)dkpp, DKPPRI, 1);
159: if (dkpp->WACK < dkpp->WNX)
160: dkprack(dkpp, ACK+((dkpp->WNX-1) & 07));
161: dkpinflush(dkpp);
162: splx(s);
163: dkpp->state = 0;
164: flushq(WR(q), 1);
165: }
166:
167:
168: /*
169: * Process a bunch of input
170: * -- for now, ignore strange control bytes
171: */
172: dkpisrv(q)
173: register struct queue *q;
174: {
175: register struct dkp *dkpp = (struct dkp *)q->ptr;
176: register struct block *bp;
177: register c;
178:
179: while (bp = getq(q)) {
180: if (bp->type == M_CTL) {
181: c = *bp->rptr & 0370;
182: if (c==REJ || c==ECHO) {
183: dkpp->lastecho = *bp->rptr;
184: bp->class |= S_DELIM;
185: (*WR(q)->next->qinfo->putp)(WR(q)->next, bp);
186: } else
187: freeb(bp); /* unknown control */
188: continue;
189: }
190: if ((q->next->flag&QFULL)==0 || bp->type>=QPCTL
191: || dkpp->state&RCLOSE) {
192: TRC('G'); TRC(*bp->rptr);
193: (*q->next->qinfo->putp)(q->next, bp);
194: } else {
195: putbq(q, bp);
196: return;
197: }
198: }
199: }
200:
201: /*
202: * Packet arrives.
203: */
204: dkpiput(q, bp)
205: struct queue *q;
206: register struct block *bp;
207: {
208: register struct dkp *dkpp;
209: register i;
210: register struct block *nbp;
211:
212: if ((dkpp = (struct dkp *)q->ptr)==NULL) {
213: freeb(bp);
214: return;
215: }
216: switch (bp->type) {
217:
218: moredata:
219: bp->rptr++;
220: bp->type = M_DATA;
221: case M_DATA:
222: bp->class &= ~S_DELIM;
223: if (bp->rptr >= bp->wptr||q->flag&QFULL||dkpp->state&LCLOSE) {
224: freeb(bp);
225: return;
226: }
227: if (dkpp->state & RCHARMODE) {
228: putq(q, bp);
229: return;
230: }
231: switch (dkpp->trx) {
232:
233: case 1:
234: case 2:
235: dkpp->trbuf[dkpp->trx++] = *bp->rptr;
236: goto moredata;
237:
238: default:
239: dkpp->trx = 0;
240: case 0:
241: break;
242: }
243: bp->next = NULL;
244: if (dkpp->indata > MAXMSG) { /* protect against garbage */
245: freeb(bp);
246: return;
247: }
248: if (dkpp->inp) {
249: dkpp->inpe->next = bp;
250: dkpp->inpe = bp;
251: } else {
252: dkpp->inp = bp;
253: dkpp->inpe = bp;
254: }
255: dkpp->indata += bp->wptr - bp->rptr;
256: return;
257:
258: case M_CTL:
259: switch (*bp->rptr) {
260:
261: case ENQ:
262: putctl1(WR(q)->next, M_CTL, dkpp->lastecho);
263: case CHECK:
264: putctl1d(WR(q)->next, M_CTL, ACK+dkpp->iseq);
265: dkpinflush(dkpp);
266: goto moredata;
267:
268: case AINIT:
269: dkpp->state &= ~OPENING;
270: dkpp->state |= OPEN;
271: qenable(WR(q));
272: dkpinflush(dkpp);
273: goto moredata;
274:
275: case INIT0:
276: case INIT1:
277: putctl1d(WR(q)->next, M_CTL, AINIT);
278: if (*bp->rptr==INIT0 && (dkpp->state&RCHARMODE)==0) {
279: dkpp->state |= RCHARMODE;
280: dkpp->XW = 1; /* why? */
281: q->flag &= ~QDELIM;
282: } else if (*bp->rptr==INIT1 && (dkpp->state&RCHARMODE)) {
283: dkpp->state &= ~RCHARMODE;
284: dkpp->XW = 3; /* why? */
285: q->flag |= QDELIM;
286: }
287: dkpinflush(dkpp);
288: dkpp->iseq = 0;
289: wakeup((caddr_t)dkpp);
290: goto moredata;
291:
292: case INITREQ:
293: if (dkpp->state&XCHARMODE)
294: putctl1d(WR(q)->next, M_CTL, INIT0);
295: else {
296: if (dkpp->WS < dkpp->WNX)
297: dkprack(dkpp, ECHO+((dkpp->WNX-1)&07));
298: dkpp->WS = 1;
299: dkpp->WACK = 1;
300: dkpp->WNX = 1;
301: putctl1d(WR(q)->next, M_CTL, INIT1);
302: }
303: dkpinflush(dkpp);
304: goto moredata;
305:
306: case BREAK:
307: qpctl(q, M_BREAK);
308: dkpp->indata++;
309: goto moredata;
310:
311: case BOT:
312: case BOTS:
313: case BOTM:
314: dkpp->trx = 1;
315: dkpp->trbuf[0] = *bp->rptr;
316: goto moredata;
317:
318: case REJ+0: case REJ+1: case REJ+2: case REJ+3:
319: case REJ+4: case REJ+5: case REJ+6: case REJ+7:
320: if (dkpp->state&XCHARMODE)
321: goto moredata;
322: TRC('r');
323: if (((*bp->rptr+1)&07) == (dkpp->WACK&07)
324: && (dkpp->state&RJING) == 0) {
325: dkstat.dkprxmit++;
326: for (i=dkpp->WACK; i<dkpp->WNX; i++) {
327: TRC('Z');
328: TRC('0' + (i&07));
329: dkpp->state |= RJING;
330: dkpxmit(WR(q), dkpp->xb[i&07], i);
331: }
332: }
333: goto moredata;
334:
335: case ACK+0: case ACK+1: case ACK+2: case ACK+3:
336: case ACK+4: case ACK+5: case ACK+6: case ACK+7:
337: case ECHO+0: case ECHO+1: case ECHO+2: case ECHO+3:
338: case ECHO+4: case ECHO+5: case ECHO+6: case ECHO+7:
339: dkprack(dkpp, *bp->rptr);
340: goto moredata;
341:
342: case SEQ+0: case SEQ+1: case SEQ+2: case SEQ+3:
343: case SEQ+4: case SEQ+5: case SEQ+6: case SEQ+7:
344: i = *bp->rptr & 07;
345: if (dkpp->state & RCHARMODE) {
346: TRC('e');
347: qpctl1(q, M_CTL, ECHO+i);
348: goto moredata;
349: }
350: if (dkpp->trx !=3
351: || dkpp->indata != dkpp->trbuf[1] + (dkpp->trbuf[2]<<8)
352: || i != ((dkpp->iseq+1)&07)) { /* reject? */
353: if (dkpp->trx != 3)
354: dkstat.dkprjtrs++;
355: else if (i != ((dkpp->iseq+1)&07))
356: dkstat.dkprjseq++;
357: else
358: dkstat.dkprjpks++;
359: dkpinflush(dkpp);
360: if (dkpp->trbuf[0]==BOTS)
361: dkpp->iseq = i;
362: TRC('R'); TRC('0'+dkpp->iseq);
363: TRC(dkpp->trx!=3?'t':(i!=(dkpp->iseq+1)&07?'s':'c'));
364: qpctl1(q, M_CTL, REJ+dkpp->iseq);
365: goto moredata;
366: }
367: /* accept */
368: if (dkpp->inpe==NULL)
369: dkpp->inp = dkpp->inpe = allocb(0);
370: if (dkpp->trbuf[0] != BOTM && q->flag&QDELIM)
371: dkpp->inpe->class |= S_DELIM;
372: while (nbp = dkpp->inp) {
373: dkpp->inp = nbp->next;
374: putq(q, nbp);
375: }
376: TRC('A'); TRC('0'+i);
377: dkpp->inpe = NULL;
378: dkpp->trx = 0;
379: dkpp->indata = 0;
380: dkpp->iseq = i;
381: qpctl1(q, M_CTL, ECHO+i);
382: goto moredata;
383:
384: default:
385: if (*bp->rptr < 0200) /* non-supervisory */
386: dkpp->indata++;
387: dkpp->lastctl = *bp->rptr;
388: qpctl1(q, M_CTL, *bp->rptr);
389: goto moredata;
390: }
391:
392: case M_HANGUP:
393: dkpp->state |= RCLOSE;
394: flushq(WR(q), 1);
395: dkprack(dkpp, ECHO+((dkpp->WNX-1) & 07));
396: putq(q, bp);
397: return;
398:
399: case M_IOCACK:
400: case M_IOCNAK:
401: (*q->next->qinfo->putp)(q->next, bp);
402: return;
403:
404: case M_PRICTL:
405: if (*bp->rptr != DKMXINIT) {
406: (*q->next->qinfo->putp)(q->next, bp);
407: return;
408: }
409: bp->type = M_CTL;
410: bp->wptr = bp->rptr;
411: *bp->wptr++ = INITREQ;
412: dkpiput(q, bp);
413: putctl1d(WR(q)->next, M_CTL, INITREQ);
414: return;
415:
416: default:
417: freeb(bp);
418: return;
419: }
420: }
421:
422: /*
423: * --- Output processor
424: */
425:
426: /*
427: * accept data from writer
428: * -- handle most non-data messages
429: */
430:
431: int dkpwbig = 200;
432:
433: dkpoput(q, bp)
434: register struct queue *q;
435: register struct block *bp;
436: {
437: register struct dkp *dkpp = (struct dkp *)q->ptr;
438: register unsigned char *sp;
439: register x, s;
440: struct block *xbp;
441:
442: if (dkpp->state & RCLOSE) {
443: freeb(bp);
444: return;
445: }
446: switch (bp->type) {
447:
448: case M_STOP:
449: dkpp->state |= STOPPED;
450: freeb(bp);
451: return;
452:
453: case M_START:
454: dkpp->state &= ~STOPPED;
455: freeb(bp);
456: qenable(q);
457: return;
458:
459: case M_FLUSH:
460: /* annul data for blocks in transit */
461: freeb(bp);
462: s = spl5(); /* in case an ECHO is about to arrive */
463: for (x=0; x<8; x++)
464: if ((bp = dkpp->xb[x]) != NULL)
465: bp->wptr = bp->rptr;
466: splx(s);
467: flushq(q, 0);
468: return;
469:
470: case M_IOCTL:
471: sp = (unsigned char *)stiodata(bp);
472: switch (stiocom(bp)) {
473:
474: case TIOCSDEV:
475: x = ((struct ttydevb *)sp)->ispeed;
476: bp->wptr = bp->rptr;
477: bp->type = M_IOCACK;
478: qreply(q, bp);
479: if (x==0)
480: putctl(OTHERQ(q), M_HANGUP);
481: return;
482:
483: case TIOCGDEV:
484: ((struct ttydevb *)sp)->ispeed = ((struct ttydevb *)sp)->ospeed = B9600;
485: bp->wptr = bp->rptr + sizeof(struct ttydevb) + STIOCHDR;
486: if (bp->wptr >= bp->lim)
487: panic("dkioc");
488: bp->type = M_IOCACK;
489: qreply(q, bp);
490: return;
491:
492: case DIOCSTREAM:
493: RD(q)->flag &= ~QDELIM;
494: bp->wptr = bp->rptr;
495: bp->type = M_IOCACK;
496: qreply(q, bp);
497: return;
498:
499: case DIOCRECORD:
500: if ((dkpp->state&RCHARMODE) == 0) {
501: RD(q)->flag |= QDELIM;
502: bp->type = M_IOCACK;
503: } else
504: bp->type = M_IOCNAK;
505: bp->wptr = bp->rptr;
506: qreply(q, bp);
507: return;
508:
509: case KIOCINIT:
510: if (dkpp->state&XCHARMODE)
511: putctl1d(q->next, M_CTL, INIT0);
512: else {
513: s = spl5();
514: if (dkpp->WS < dkpp->WNX)
515: dkprack(dkpp, ECHO+((dkpp->WNX-1)&07));
516: dkpp->WS = 1;
517: dkpp->WACK = 1;
518: dkpp->WNX = 1;
519: splx(s);
520: putctl1d(q->next, M_CTL, INIT1);
521: }
522: bp->wptr = bp->rptr;
523: bp->type = M_IOCACK;
524: qreply(q, bp);
525: return;
526:
527: case KIOCISURP:
528: bp->wptr = bp->rptr;
529: bp->type = M_IOCACK;
530: qreply(q, bp);
531: return;
532:
533: case DIOCSCTL:
534: bp->type = M_IOCACK;
535: bp->wptr = bp->rptr;
536: if (*sp == 0) {
537: qreply(q, bp);
538: return;
539: }
540: if ((xbp = allocb(1)) == NULL)
541: bp->type = M_IOCNAK;
542: else {
543: xbp->type = M_CTL;
544: xbp->class |= S_DELIM;
545: *xbp->wptr++ = *sp;
546: putq(q, xbp);
547: if (dkpp->WNX < dkpp->WS+dkpp->XW)
548: qenable(q);
549: }
550: qreply(q, bp);
551: return;
552:
553: case DIOCRCTL:
554: *sp = dkpp->lastctl;
555: dkpp->lastctl = 0;
556: bp->type = M_IOCACK;
557: bp->wptr = sp + 1;
558: qreply(q, bp);
559: return;
560:
561: case DIOCXWIN:
562: bp->type = M_IOCACK;
563: if (sp[4] >= 8 || sp[4] <= 0)
564: bp->type = M_IOCNAK;
565: else if ((x = sp[0] + (sp[1]<<8)) < 0 || x > MAXMSG)
566: bp->type = M_IOCNAK;
567: else {
568: dkpp->xsize = x;
569: dkpp->XW = sp[4];
570: if (x > dkpwbig)
571: q->flag |= QBIGB;
572: else
573: q->flag &=~ QBIGB;
574: }
575: bp->wptr = bp->rptr;
576: qreply(q, bp);
577: return;
578:
579: default:
580: (*q->next->qinfo->putp)(q->next, bp);
581: return;
582: }
583:
584: case M_DELAY:
585: x = *bp->rptr;
586: *bp->rptr = DELAY;
587: bp->type = M_CTL;
588: while (x) {
589: (*bp->rptr)++;
590: x >>= 1;
591: }
592: goto putonq;
593:
594: case M_PRICTL:
595: (*q->next->qinfo->putp)(q->next, bp);
596: return;
597:
598: default:
599: freeb(bp);
600: return;
601:
602: case M_BREAK:
603: bp->type = M_CTL;
604: *bp->wptr++ = BREAK;
605: case M_DATA:
606: case M_CTL:
607: putonq:
608: putq(q, bp);
609: if (dkpp->WNX < dkpp->WS+dkpp->XW)
610: qenable(q);
611: return;
612: }
613: }
614:
615: /*
616: * Out server:
617: * if space in window, process queue
618: * This is the only place that WNX is incremented,
619: * and the only place xb[i] is set nonzero
620: * (remember these facts when thinking about races)
621: */
622: dkposrv(q)
623: register struct queue *q;
624: {
625: register struct dkp *dkpp = (struct dkp *)q->ptr;
626: register struct block *bp, *xbp;
627: register int seqno;
628: register struct block **bpp;
629: register int s;
630:
631: if (dkpp->state & (STOPPED|OPENING))
632: return;
633: while (dkpp->WNX < dkpp->WS+dkpp->XW) {
634: if ((bp = getq(q)) == NULL)
635: break;
636: /*
637: * Bite off one URP block; put back the rest.
638: * The initial blocks are passed by reference.
639: */
640: if (bp->type==M_DATA && bp->wptr-bp->rptr > dkpp->xsize) {
641: xbp = dupb(bp);
642: bp->rptr += dkpp->xsize;
643: xbp->wptr = xbp->rptr+dkpp->xsize;
644: xbp->class &= ~S_DELIM;
645: putbq(q, bp);
646: bp = xbp;
647: }
648: if (dkpp->state & XCHARMODE) {
649: dkpp->outcnt += bp->wptr - bp->rptr;
650: (*q->next->qinfo->putp)(q->next, bp);
651: if (dkpp->outcnt >= dkpp->xsize) {
652: putctl1d(q->next, M_CTL, SEQ+(dkpp->WNX&07));
653: dkpp->WNX++;
654: dkpp->WACK = dkpp->WNX;
655: dkpp->outcnt = 0;
656: }
657: continue;
658: }
659: TRC('x'); TRC('0'+dkpp->WS/10); TRC('0'+dkpp->WS%10);
660: TRC('.'); TRC('0'+dkpp->WNX/10); TRC('0'+dkpp->WNX%10);
661: bpp = &dkpp->xb[dkpp->WNX&07];
662: if (*bpp) {
663: s = spl5(); /* in case of last-minute ECHO */
664: if (*bpp) {
665: freeb(*bpp);
666: printf("dkp losing block %x\n", *bpp);
667: *bpp = 0; /* if ECHO comes later, don't free twice */
668: }
669: splx(s);
670: }
671: *bpp = bp;
672: seqno = dkpp->WNX++; /* in case ECHO comes right away */
673: dkpxmit(q, bp, seqno);
674: /* what if INIT[01] arrived between `bpp = ...' and here? */
675: }
676: }
677:
678: /*
679: * Send out a message, with trailer.
680: */
681: dkpxmit(q, bp, seqno)
682: register struct queue *q;
683: register struct block *bp;
684: {
685: register size;
686: register struct block *xbp;
687: register struct dkp *dkpp = (struct dkp *)q->ptr;
688:
689: if (bp==NULL) {
690: printf("null bp in dkpxmit\n");
691: return;
692: }
693: size = bp->wptr - bp->rptr;
694: seqno &= 07;
695: /* send ptr to block, if non-empty */
696: if (size) {
697: if ((xbp = dupb(bp)) == NULL)
698: return;
699: xbp->class &=~ S_DELIM;
700: TRC('X'); TRC('0'+seqno);
701: (*q->next->qinfo->putp)(q->next, xbp);
702: }
703: /* send trailer */
704: if ((xbp = allocb(3)) == NULL)
705: return;
706: xbp->type = M_CTL;
707: *xbp->wptr++ = bp->class&S_DELIM? BOT: BOTM;
708: *xbp->wptr++ = size;
709: *xbp->wptr++ = size >> 8;
710: (*q->next->qinfo->putp)(q->next, xbp);
711: putctl1d(q->next, M_CTL, SEQ + seqno);
712: dkpp->timer = DKPTIME;
713: }
714:
715: /*
716: * Receive an ack of some sort for a transmitted message.
717: * Advance various windows.
718: * should be called at spl5 to avoid races
719: */
720: dkprack(dkpp, msg)
721: register struct dkp *dkpp;
722: {
723: register struct block **bpp;
724: register seqno, i;
725:
726: seqno = msg & 07;
727: msg &= 0370;
728: /* invariants: 0 <= WS <= WACK <= WNX; seqno maximal < WNX; WS < 8 */
729: if (seqno >= dkpp->WNX)
730: seqno -= 8;
731: else if (seqno+8 < dkpp->WNX)
732: seqno += 8;
733: dkpp->state &= ~RJING;
734: for (i=dkpp->WS; i<=seqno; i++) {
735: bpp = &dkpp->xb[i&07];
736: if (*bpp) {
737: freeb(*bpp);
738: *bpp = NULL;
739: }
740: }
741: if ((int)dkpp->WACK <= seqno)
742: dkpp->WACK = seqno+1;
743: if (msg==ECHO) {
744: TRC('E'); TRC('0'+(seqno&07));
745: if (dkpp->WS <= seqno) {
746: dkpp->timer = DKPTIME; /* push off timeout */
747: dkpp->WS = seqno+1;
748: if (dkpp->WNX<dkpp->WS+dkpp->XW && WR(dkpp->rdq)->count)
749: qenable(WR(dkpp->rdq));
750: }
751: } else {
752: for (i=dkpp->WACK; i<dkpp->WNX; i++) {
753: if (dkpp->xb[i&07]==0)
754: printf("WS %d WACK %d WNX %d i %d seqno %d\n",
755: dkpp->WS, dkpp->WACK, dkpp->WNX, i, seqno);
756: dkpxmit(WR(dkpp->rdq), dkpp->xb[i&07], i);
757: dkstat.dkprxmit++;
758: }
759: }
760: if (dkpp->WS >= 8) {
761: dkpp->WS -= 8;
762: dkpp->WACK -= 8;
763: dkpp->WNX -= 8;
764: }
765: }
766:
767: dkptimer()
768: {
769: register struct dkp *dkpp;
770: register struct queue *q;
771: register int i;
772:
773: for (dkpp = dkp, i = dkpcnt; i > 0; dkpp++, --i) {
774: if ((dkpp->state&(OPEN|OPENING)) == 0)
775: continue;
776: if (--dkpp->timer>0)
777: continue;
778: q = WR(dkpp->rdq)->next;
779: if (q->flag&QFULL)
780: continue;
781: if (dkpp->state & XCHARMODE) {
782: if (dkpp->WS < dkpp->WNX)
783: putctl1d(q, M_CTL, SEQ+((dkpp->WNX-1)&07));
784: dkpp->timer = 10;
785: continue;
786: }
787: if (dkpp->state&OPENING)
788: putctl1d(q, M_CTL, INIT1);
789: if (dkpp->WS != dkpp->WNX)
790: putctl1d(q, M_CTL, ENQ);
791: dkpp->timer = DKPTIME;
792: }
793: timeout(dkptimer, (caddr_t)NULL, HZ);
794: }
795:
796: /*
797: * throw away data in front of the barrier, and clear the trailer buffer
798: */
799: dkpinflush(dkpp)
800: register struct dkp *dkpp;
801: {
802: register struct block *bp;
803:
804: while (bp = dkpp->inp) {
805: dkpp->inp = bp->next;
806: freeb(bp);
807: }
808: dkpp->inpe = NULL;
809: dkpp->trx = 0;
810: dkpp->indata = 0;
811: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.