![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmcld.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / dev|
Return to cmcld.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 root 1: /*
2: * Raw line discipline and listener stuff for talking to controller
3: */
4: #include "cm.h"
5: #if NCM
6: #include "../h/param.h"
7: #include "../h/systm.h"
8: #include "../h/stream.h"
9: #include "../h/ioctl.h"
10: #include "../h/pte.h"
11: #include "../h/map.h"
12: #include "../h/buf.h"
13: #include "../h/ubavar.h"
14: #include "../h/conf.h"
15: #include "../h/dkstat.h"
16: #include "../h/dkmod.h"
17: #include "sparam.h"
18: #include "dk.h"
19: #include "kdi.h"
20: #include "kmc.h"
21:
22: /* channel states */
23: #define CLOSED 0
24: #define RCLOSE 1
25: #define LCLOSE 2
26: #define OPEN 3
27:
28: /*
29: * CMC/Listener message structure
30: */
31: struct dialin {
32: char type;
33: char srv;
34: short param0;
35: short param1;
36: short param2;
37: short param3;
38: short param4;
39: short param5;
40: };
41:
42: struct dialout {
43: short chan;
44: struct dialin d;
45: };
46:
47: /*
48: * Message codes
49: */
50: #define T_LSTNR 4
51: #define T_CHG 3
52: #define T_REPLY 10
53: #define D_CLOSE 1
54: #define D_ISCLOSED 2
55:
56: /*
57: * Raw-mode line discipline for DK (only)
58: */
59: int nulldev(), rdkopen(), rdkclose(), rdkiput(), rdkoput(), rdkosrv();
60: static struct qinit rdkrinit = { rdkiput, NULL, rdkopen, rdkclose, 72, 36};
61: static struct qinit rdkwinit = { rdkoput, rdkosrv, rdkopen, nulldev, 72, 36};
62: struct streamtab rdkinfo = { &rdkrinit, &rdkwinit };
63:
64: extern struct dkstat dkstat;
65: #define NDKMOD (NDK+NKMC) /* number of different DK devices */
66: struct dkmodule dkmod[NDKMOD];
67:
68: #define NDKRAW 32
69: struct rdk {
70: struct queue *q;
71: struct dkmodule *module;
72: short chan;
73: } rdk[NDKRAW];
74:
75: rdkopen(q, dev)
76: register struct queue *q;
77: {
78: static timer_on = 0;
79: register struct rdk *dkp, *edkp;
80: register struct dkmodule *dkm;
81:
82: edkp = NULL;
83: for (dkp=rdk; ; dkp++) {
84: if (dkp >= &rdk[NDKRAW])
85: break;
86: if (dkp->q == q) {
87: if (dkp->chan != minor(dev) || WR(q)->ptr==NULL) {
88: printf("q %x dkp %x\n", q, dkp);
89: panic("rdkopen botch");
90: }
91: return(1);
92: }
93: if (dkp->q == NULL && edkp==NULL)
94: edkp = dkp;
95: }
96: if (edkp==NULL)
97: return(0);
98: for (dkm=dkmod; ; dkm++) {
99: if (dkm >= &dkmod[NDKMOD])
100: return(0);
101: if (major(dev) == dkm->dev)
102: break;
103: }
104: edkp->q = q;
105: edkp->chan = minor(dev);
106: edkp->module = dkm;
107: q->flag |= QDELIM;
108: q->ptr = 0;
109: WR(q)->ptr = (caddr_t)edkp;
110: if (timer_on==0) {
111: dktimer();
112: timer_on = 1;
113: }
114: return(1);
115: }
116:
117: rdkclose(q)
118: register struct queue *q;
119: {
120: register i;
121: register struct block *bp;
122: register struct rdk *dkp = (struct rdk *)WR(q)->ptr;
123:
124: if (dkp==NULL) printf("null ptr; q %x wq %x\n", q, WR(q));
125: if (WR(q)==dkp->module->listnrq)
126: dkp->module->listnrq = NULL;
127: while (bp = getq(q))
128: (*q->next->qinfo->putp)(q->next, bp);
129: dkp->q = NULL;
130: dkp->module = NULL;
131: }
132:
133: /*
134: * output put procedure.
135: */
136: rdkoput(q, bp)
137: register struct queue *q;
138: register struct block *bp;
139: {
140: register struct block *bp1;
141: register struct ioctl1 {
142: int com;
143: int stuff;
144: } *iop;
145: register struct rdk *dkp = (struct rdk *)q->ptr;
146: register struct dkmodule *modp = dkp->module;
147: register i;
148:
149: switch (bp->type) {
150:
151: case M_IOCTL:
152: switch (((struct ioctl1 *)bp->rptr)->com) {
153:
154: /* hang everybody up */
155: case DIOCHUP:
156: /* must be on channel 1 or 0 */
157: if (dkp->chan <= 1) {
158: dkmesg(modp, T_LSTNR, 0, 0, 0, 1);
159: bp->type = M_IOCACK;
160: bp->rptr = bp->wptr;
161: qreply(q, bp);
162: return;
163: }
164: break;
165:
166: /* announce listener channel */
167: case DIOCLHN:
168: if (modp->listnrq == NULL) {
169: modp->listnrq = q;
170: dkmesg(modp, T_LSTNR, 0, 0, 0, 0);
171: bp->type = M_IOCACK;
172: bp->rptr = bp->wptr;
173: qreply(q, bp);
174: return;
175: }
176: break;
177:
178: /* delay input */
179: case DIOCSTOP:
180: RD(q)->ptr = (caddr_t)1;
181: bp->type = M_IOCACK;
182: bp->rptr = bp->wptr;
183: qreply(q, bp);
184: return;
185:
186: /* suggest a free outgoing channel */
187: case DIOCCHAN:
188: for (i=3; i<modp->nchan; i+=2) {
189: if (modp->dkstate[i]==CLOSED) {
190: ((struct ioctl1 *)bp->rptr)->stuff = i;
191: bp->wptr =
192: bp->rptr+sizeof(struct ioctl1);
193: bp->type = M_IOCACK;
194: break;
195: }
196: }
197: qreply(q, bp);
198: return;
199:
200: default:
201: (*q->next->qinfo->putp)(q->next, bp);
202: return;
203: }
204: bp->type = M_IOCNAK;
205: bp->wptr = bp->rptr;
206: qreply(q, bp);
207: return;
208: }
209: putq(q, bp);
210: }
211:
212: rdkosrv(q)
213: register struct queue *q;
214: {
215: register struct block *bp;
216:
217: while ((q->next->flag&QFULL)==0 && (bp = getq(q)))
218: (*q->next->qinfo->putp)(q->next, bp);
219: }
220:
221: /*
222: * input put procedure
223: * -- ignores all control bytes
224: */
225: rdkiput(q, bp)
226: register struct queue *q;
227: register struct block *bp;
228: {
229: register struct rdk *dkp = (struct rdk *)WR(q)->ptr;
230:
231: switch (bp->type) {
232:
233: case M_DATA:
234: if (WR(q)==dkp->module->listnrq && dklstnr(dkp->module, bp))
235: return;
236: if (q->next->flag&QFULL) { /* sorry, you lose */
237: freeb(bp);
238: return;
239: }
240: if (q->ptr) { /* input delayed */
241: putq(q, bp);
242: qpctl(q, M_DELIM);
243: return;
244: }
245: (*q->next->qinfo->putp)(q->next, bp);
246: putctl(q->next, M_DELIM);
247: return;
248:
249: case M_IOCACK:
250: case M_IOCNAK:
251: case M_HANGUP:
252: (*q->next->qinfo->putp)(q->next, bp);
253: return;
254:
255: case M_CLOSE:
256: if (dkp->module->dkstate[*bp->rptr] == RCLOSE)
257: dkmesg(dkp->module, T_CHG, D_ISCLOSED, 0, *bp->rptr, 0);
258: else
259: dkmesg(dkp->module, T_CHG, D_CLOSE, 0, *bp->rptr, 0);
260: freeb(bp);
261: return;
262:
263: default:
264: freeb(bp);
265: }
266: }
267:
268: /*
269: * listener sends a message to CMC
270: */
271: dkmesg(modp, type, srv, p0, p1, p2)
272: register struct dkmodule *modp;
273: {
274: register struct dialout *dp;
275: register struct block *bp;
276:
277: if (modp->listnrq==NULL || modp->listnrq->next->flag&QFULL)
278: return;
279: if ((bp = allocb(sizeof(struct dialout))) == NULL)
280: return; /* hope it will be retried later */
281: dp = (struct dialout *)bp->wptr;
282: dp->chan = 1; /* channel 1 builtin */
283: dp->d.type = type;
284: dp->d.srv = srv;
285: dp->d.param0 = p0;
286: dp->d.param1 = p1;
287: dp->d.param2 = p2;
288: bp->wptr += sizeof(struct dialout);
289: (*modp->listnrq->next->qinfo->putp)(modp->listnrq->next, bp);
290: putctl(modp->listnrq->next, M_DELIM);
291: }
292:
293: /*
294: * Receive message for listener
295: */
296: dklstnr(modp, bp)
297: register struct block *bp;
298: struct dkmodule *modp;
299: {
300: register struct dialin *dialp;
301: register i;
302: register struct queue *listnrq = modp->listnrq;
303: register struct rdk *dkp;
304:
305: dialp = (struct dialin *)bp->rptr;
306: switch (dialp->type) {
307:
308: case T_CHG:
309: i = dialp->param1;
310: if (i <= 0 || i >= modp->nchan) {
311: dkstat.chgstrange++;
312: if (dialp->srv)
313: dkmesg(modp, T_CHG, D_ISCLOSED, 0, i, 0);
314: freeb(bp);
315: return(1);
316: }
317: switch (dialp->srv) {
318:
319: case D_CLOSE: /* remote shutdown */
320: switch (modp->dkstate[i]) {
321:
322: case RCLOSE:
323: dkstat.notclosed++;
324: case OPEN:
325: putctl1(listnrq->next, M_CLOSE, i);
326: break;
327:
328: case LCLOSE:
329: case CLOSED:
330: dkmesg(modp, T_CHG, D_ISCLOSED, 0, i, 0);
331: putctl1(listnrq->next, M_CLOSE, i);
332: break;
333: }
334: break;
335:
336: case D_ISCLOSED:
337: switch (modp->dkstate[i]) {
338:
339: case LCLOSE:
340: case CLOSED:
341: putctl1(listnrq->next, M_CLOSE, i);
342: break;
343:
344: case OPEN:
345: case RCLOSE:
346: dkstat.isclosed++;
347: break;
348: }
349: break;
350: }
351: freeb(bp);
352: return(1);
353:
354: case T_REPLY: /* CMC sends reply; find, and hand to process */
355: i = dialp->param0;
356: if (i < 0 || i >= modp->nchan)
357: return(0);
358: for (dkp=rdk; dkp<&rdk[NDKRAW]; dkp++) {
359: if (dkp->module==modp && dkp->chan==i) {
360: (*dkp->q->next->qinfo->putp)(dkp->q->next, bp);
361: putctl(dkp->q->next, M_DELIM);
362: return(1);
363: }
364: }
365: return(0);
366:
367: default:
368: return(0);
369: }
370: }
371:
372: /*
373: * 15-second timer
374: */
375: dktimer()
376: {
377: register i;
378: register struct dkmodule *dkp;
379:
380: for (dkp = dkmod; dkp < &dkmod[NDKMOD]; dkp++) {
381: if (dkp->listnrq) {
382: dkmesg(dkp, T_LSTNR, 0, 0, 0, 0);
383: for (i=0; i< dkp->nchan; i++)
384: if (dkp->dkstate[i] == LCLOSE)
385: dkmesg(dkp, T_CHG, D_CLOSE, 0, i, 0);
386: }
387: }
388: timeout(dktimer, (caddr_t)NULL, 15*hz);
389: }
390: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.