![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mx1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / 4.0.upgrade / sys / dev|
Return to mx1.c CVS log | Up to [CSRG BSD Unix] / 41BSD / 4.0.upgrade / sys / dev |
1.1 root 1: /* mx1.c 4.6 81/03/11 */
2:
3: #include "../h/param.h"
4: #include "../h/systm.h"
5: #include "../h/dir.h"
6: #include "../h/user.h"
7: #include "../h/reg.h"
8: #include "../h/proc.h"
9: #include "../h/tty.h"
10: #include "../h/inode.h"
11: #include "../h/mx.h"
12: #include "../h/file.h"
13: #include "../h/conf.h"
14:
15: /*
16: * Multiplexor: clist version
17: *
18: * installation:
19: * requires a line in cdevsw -
20: * mxopen, mxclose, mxread, mxwrite, mxioctl, 0,
21: *
22: * also requires a line in linesw -
23: * mxopen, mxclose, mcread, mcwrite, mxioctl, nulldev, nulldev,
24: *
25: * The linesw entry for mpx should be the last one in the table.
26: * 'nldisp' (number of line disciplines) should not include the
27: * mpx line. This is to prevent mpx from being enabled by an ioctl.
28: */
29: struct chan chans[NCHANS];
30: struct schan schans[NPORTS];
31: struct group *groups[NGROUPS];
32: int mpxline;
33: struct chan *xcp();
34: dev_t mpxdev = -1;
35:
36:
37: char mcdebugs[NDEBUGS];
38:
39:
40: /*
41: * Allocate a channel, set c_index to index.
42: */
43: struct chan *
44: challoc(index, isport)
45: {
46: register s,i;
47: register struct chan *cp;
48:
49: s = spl6();
50: for(i=0;i<((isport)?NPORTS:NCHANS);i++) {
51: cp = (isport)? (struct chan *)(schans+i): chans+i;
52: if(cp->c_group == NULL) {
53: cp->c_index = index;
54: cp->c_pgrp = 0;
55: cp->c_flags = 0;
56: splx(s);
57: return(cp);
58: }
59: }
60: splx(s);
61: return(NULL);
62: }
63:
64:
65:
66: /*
67: * Allocate a group table cell.
68: */
69: gpalloc()
70: {
71: register i;
72:
73: for (i=NGROUPS-1; i>=0; i--)
74: if (groups[i]==NULL) {
75: groups[i]++;
76: return(i);
77: }
78: u.u_error = ENXIO;
79: return(i);
80: }
81:
82:
83: /*
84: * Add a channel to the group in
85: * inode ip.
86: */
87: struct chan *
88: addch(ip, isport)
89: struct inode *ip;
90: {
91: register struct chan *cp;
92: register struct group *gp;
93: register i;
94:
95: plock(ip);
96: gp = &ip->i_un.i_group;
97: for(i=0;i<NINDEX;i++) {
98: cp = (struct chan *)gp->g_chans[i];
99: if (cp == NULL) {
100: if ((cp=challoc(i, isport)) != NULL) {
101: gp->g_chans[i] = cp;
102: cp->c_group = gp;
103: }
104: break;
105: }
106: cp = NULL;
107: }
108: prele(ip);
109: return(cp);
110: }
111:
112: /*
113: * Mpxchan system call.
114: */
115:
116: mpxchan()
117: {
118: extern mxopen(), mcread(), sdata(), scontrol();
119: struct inode *ip, *gip;
120: struct tty *tp;
121: struct file *fp, *chfp, *gfp;
122: struct chan *cp;
123: struct group *gp, *ngp;
124: struct mx_args vec;
125: struct a {
126: int cmd;
127: int *argvec;
128: } *uap;
129: dev_t dev;
130: register int i;
131:
132: /*
133: * Common setup code.
134: */
135:
136: uap = (struct a *)u.u_ap;
137: (void) copyin((caddr_t)uap->argvec, (caddr_t)&vec, sizeof vec);
138: gp = NULL; gfp = NULL; cp = NULL;
139:
140: switch(uap->cmd) {
141:
142: case NPGRP:
143: if (vec.m_arg[1] < 0)
144: break;
145: case CHAN:
146: case JOIN:
147: case EXTR:
148: case ATTACH:
149: case DETACH:
150: case CSIG:
151: gfp = getf(vec.m_arg[1]);
152: if (gfp==NULL)
153: return;
154: gip = gfp->f_inode;
155: gp = &gip->i_un.i_group;
156: if (gp->g_inode != gip) {
157: u.u_error = ENXIO;
158: return;
159: }
160: }
161:
162: switch(uap->cmd) {
163:
164: /*
165: * Create an MPX file.
166: */
167:
168: case MPX:
169: case MPXN:
170: if (mpxdev < 0) {
171: for (i=0; linesw[i].l_open; i++) {
172: if (linesw[i].l_read==mcread) {
173: mpxline = i;
174: for (i=0; cdevsw[i].d_open; i++) {
175: if (cdevsw[i].d_open==mxopen) {
176: mpxdev = (dev_t)(i<<8);
177: }
178: }
179: }
180: }
181: if (mpxdev < 0) {
182: u.u_error = ENXIO;
183: return;
184: }
185: }
186: if (uap->cmd==MPXN) {
187: if ((ip=ialloc(pipedev))==NULL)
188: return;
189: ip->i_mode = ((vec.m_arg[1]&0777)+IFMPC) & ~u.u_cmask;
190: ip->i_flag = IACC|IUPD|ICHG;
191: } else {
192: u.u_dirp = vec.m_name;
193: ip = namei(uchar,1);
194: if (ip != NULL) {
195: i = ip->i_mode&IFMT;
196: u.u_error = EEXIST;
197: if (i==IFMPC || i==IFMPB) {
198: i = minor(ip->i_un.i_rdev);
199: gp = groups[i];
200: if (gp && gp->g_inode==ip)
201: u.u_error = EBUSY;
202: }
203: iput(ip);
204: return;
205: }
206: if (u.u_error)
207: return;
208: ip = maknode((vec.m_arg[1]&0777)+IFMPC);
209: if (ip == NULL)
210: return;
211: }
212: if ((i=gpalloc()) < 0) {
213: iput(ip);
214: return;
215: }
216: if ((fp=falloc()) == NULL) {
217: iput(ip);
218: groups[i] = NULL;
219: return;
220: }
221: ip->i_un.i_rdev = (daddr_t)(mpxdev+i);
222: ip->i_count++;
223: prele(ip);
224:
225: gp = &ip->i_un.i_group;
226: groups[i] = gp;
227: gp->g_inode = ip;
228: gp->g_state = INUSE|ISGRP;
229: gp->g_group = NULL;
230: gp->g_file = fp;
231: gp->g_index = 0;
232: gp->g_rotmask = 1;
233: gp->g_rot = 0;
234: gp->g_datq = 0;
235: for(i=0;i<NINDEX;)
236: gp->g_chans[i++] = NULL;
237:
238: fp->f_flag = FREAD|FWRITE|FMP;
239: fp->f_inode = ip;
240: fp->f_un.f_chan = NULL;
241: return;
242:
243: /*
244: * join file descriptor (arg 0) to group (arg 1)
245: * return channel number
246: */
247:
248: case JOIN:
249: if ((fp=getf(vec.m_arg[0]))==NULL)
250: return;
251: ip = fp->f_inode;
252: switch (ip->i_mode & IFMT) {
253:
254: case IFMPC:
255: if ((fp->f_flag&FMP) != FMP) {
256: u.u_error = ENXIO;
257: return;
258: }
259: ngp = &ip->i_un.i_group;
260: if (mtree(ngp, gp) == NULL)
261: return;
262: fp->f_count++;
263: u.u_r.r_val1 = cpx((struct chan *)ngp);
264: return;
265:
266: case IFCHR:
267: dev = (dev_t)ip->i_un.i_rdev;
268: tp = cdevsw[major(dev)].d_ttys;
269: if (tp==NULL) {
270: u.u_error = ENXIO;
271: return;
272: }
273: tp = &tp[minor(dev)];
274: if (tp->t_chan) {
275: u.u_error = ENXIO;
276: return;
277: }
278: if ((cp=addch(gip, 1))==NULL) {
279: u.u_error = ENXIO;
280: return;
281: }
282: tp->t_chan = cp;
283: cp->c_fy = fp;
284: fp->f_count++;
285: cp->c_ttyp = tp;
286: cp->c_line = tp->t_line;
287: cp->c_flags = XGRP+PORT;
288: u.u_r.r_val1 = cpx(cp);
289: return;
290:
291: default:
292: u.u_error = ENXIO;
293: return;
294:
295: }
296:
297: /*
298: * Attach channel (arg 0) to group (arg 1).
299: */
300:
301: case ATTACH:
302: cp = xcp(gp, vec.m_arg[0]);
303: if (cp==NULL || cp->c_flags&ISGRP) {
304: u.u_error = ENXIO;
305: return;
306: }
307: u.u_r.r_val1 = cpx(cp);
308: wakeup((caddr_t)cp);
309: return;
310:
311: case DETACH:
312: cp = xcp(gp, vec.m_arg[0]);
313: if (cp==NULL) {
314: u.u_error = ENXIO;
315: return;
316: }
317: (void) detach(cp);
318: return;
319:
320: /*
321: * Extract channel (arg 0) from group (arg 1).
322: */
323:
324: case EXTR:
325: cp = xcp(gp, vec.m_arg[0]);
326: if (cp==NULL) {
327: u.u_error = ENXIO;
328: return;
329: }
330: if (cp->c_flags & ISGRP) {
331: (void) mxfalloc(((struct group *)cp)->g_file);
332: return;
333: }
334: if ((fp=cp->c_fy) != NULL) {
335: (void) mxfalloc(fp);
336: return;
337: }
338: if ((fp=falloc()) == NULL)
339: return;
340: fp->f_inode = gip;
341: gip->i_count++;
342: fp->f_un.f_chan = cp;
343: fp->f_flag = (vec.m_arg[2]) ?
344: (FREAD|FWRITE|FMPY) : (FREAD|FWRITE|FMPX);
345: cp->c_fy = fp;
346: return;
347:
348: /*
349: * Make new chan on group (arg 1).
350: */
351:
352: case CHAN:
353: if((gfp->f_flag&FMP)==FMP)cp = addch(gip, 0);
354: if(cp == NULL){
355: u.u_error = ENXIO;
356: return;
357: }
358: cp->c_flags = XGRP;
359: cp->c_fy = NULL;
360: cp->c_ttyp = cp->c_ottyp = (struct tty *)cp;
361: cp->c_line = cp->c_oline = mpxline;
362: u.u_r.r_val1 = cpx(cp);
363: return;
364:
365: /*
366: * Connect fd (arg 0) to channel fd (arg 1).
367: * (arg 2 < 0) => fd to chan only
368: * (arg 2 > 0) => chan to fd only
369: * (arg 2 == 0) => both directions
370: */
371:
372: case CONNECT:
373: if ((fp=getf(vec.m_arg[0]))==NULL)
374: return;
375: if ((chfp=getf(vec.m_arg[1]))==NULL)
376: return;
377: ip = fp->f_inode;
378: i = ip->i_mode&IFMT;
379: if (i!=IFCHR) {
380: u.u_error = ENXIO;
381: return;
382: }
383: dev = (dev_t)ip->i_un.i_rdev;
384: tp = cdevsw[major(dev)].d_ttys;
385: if (tp==NULL) {
386: u.u_error = ENXIO;
387: return;
388: }
389: tp = &tp[minor(dev)];
390: if (!(chfp->f_flag&FMPY)) {
391: u.u_error = ENXIO;
392: return;
393: }
394: cp = chfp->f_un.f_chan;
395: if (cp==NULL || cp->c_flags&PORT) {
396: u.u_error = ENXIO;
397: return;
398: }
399: i = vec.m_arg[2];
400: if (i>=0) {
401: cp->c_ottyp = tp;
402: cp->c_oline = tp->t_line;
403: }
404: if (i<=0) {
405: tp->t_chan = cp;
406: cp->c_ttyp = tp;
407: cp->c_line = tp->t_line;
408: }
409: u.u_r.r_val1 = 0;
410: return;
411:
412: case NPGRP: {
413: register struct proc *pp;
414:
415: if (gp != NULL) {
416: cp = xcp(gp, vec.m_arg[0]);
417: if (cp==NULL) {
418: u.u_error = ENXIO;
419: return;
420: }
421: }
422: pp = u.u_procp;
423: pp->p_pgrp = pp->p_pid;
424: if (vec.m_arg[2])
425: pp->p_pgrp = vec.m_arg[2];
426: if (gp != NULL)
427: cp->c_pgrp = pp->p_pgrp;
428: u.u_r.r_val1 = pp->p_pgrp;
429: return;
430: }
431:
432: case CSIG:
433: cp = xcp(gp, vec.m_arg[0]);
434: if (cp==NULL) {
435: u.u_error = ENXIO;
436: return;
437: }
438: gsignal(cp->c_pgrp, vec.m_arg[2]);
439: u.u_r.r_val1 = vec.m_arg[2];
440: return;
441:
442: case DEBUG:
443: i = vec.m_arg[0];
444: if (i<0 || i>NDEBUGS)
445: return;
446: mcdebugs[i] = vec.m_arg[1];
447: if (i==ALL)
448: for(i=0;i<NDEBUGS;i++)
449: mcdebugs[i] = vec.m_arg[1];
450: return;
451:
452: default:
453: u.u_error = ENXIO;
454: return;
455: }
456:
457: }
458: detach(cp)
459: register struct chan *cp;
460: {
461: register struct group *master,*sub;
462: register index;
463:
464: if (cp==NULL)
465: return(0);
466: if (cp->c_flags&ISGRP) {
467: sub = (struct group *)cp;
468: master = sub->g_group; index = sub->g_index;
469: closef(sub->g_file);
470: if (master != NULL)
471: master->g_chans[index] = NULL;
472: return(0);
473: } else if (cp->c_flags&PORT && cp->c_ttyp != NULL) {
474: closef(cp->c_fy);
475: chdrain(cp);
476: chfree(cp);
477: return(0);
478: }
479: if (cp->c_flags & WCLOSE) {
480: if (cp->c_fy) {
481: if (cp->c_fy->f_count)
482: return(1);
483: chdrain(cp);
484: chfree(cp);
485: return(0);
486: }
487: }
488: cp->c_flags |= WCLOSE;
489: chwake(cp);
490: return(1);
491: }
492:
493:
494: mxfalloc(fp)
495: register struct file *fp;
496: {
497: register i;
498:
499: if (fp==NULL) {
500: u.u_error = ENXIO;
501: return(-1);
502: }
503: i = ufalloc();
504: if (i < 0)
505: return(i);
506: u.u_ofile[i] = fp;
507: fp->f_count++;
508: u.u_r.r_val1 = i;
509: return(i);
510: }
511:
512: /*
513: * Grow a branch on a tree.
514: */
515:
516: mtree(sub,master)
517: register struct group *sub, *master;
518: {
519: register i;
520: int mtresiz, stresiz;
521:
522: if ((mtresiz=mup(master,sub)) == NULL) {
523: u.u_error = ENXIO;
524: return(NULL);
525: }
526: if ((stresiz=mdown(sub,master)) <= 0) {
527: u.u_error = ENXIO;
528: return(NULL);
529: }
530: if (sub->g_group != NULL) {
531: u.u_error = ENXIO;
532: return(NULL);
533: }
534: if (stresiz+mtresiz > NLEVELS) {
535: u.u_error = ENXIO;
536: return(NULL);
537: }
538: for (i=0;i<NINDEX;i++) {
539: if (master->g_chans[i] != NULL)
540: continue;
541: master->g_chans[i] = (struct chan *)sub;
542: sub->g_group = master;
543: sub->g_index = i;
544: return(1);
545: }
546: u.u_error = ENXIO;
547: return(NULL);
548: }
549:
550: mup(master,sub)
551: struct group *master, *sub;
552: {
553: register struct group *top;
554: register int depth;
555:
556: depth = 1; top = master;
557: while (top->g_group) {
558: depth++;
559: top = top->g_group;
560: }
561: if(top == sub)
562: return(NULL);
563: return(depth);
564: }
565:
566:
567: mdown(sub,master)
568: struct group *sub, *master;
569: {
570: register int maxdepth, i, depth;
571:
572: if(sub == (struct group *)NULL || (sub->g_state&ISGRP) == 0)
573: return(0);
574: if(sub == master)
575: return(-1);
576: maxdepth = 0;
577: for(i=0; i<NINDEX; i++) {
578: if((depth=mdown((struct group *)sub->g_chans[i],master)) == -1)
579: return(-1);
580: maxdepth = (depth>maxdepth) ? depth: maxdepth;
581: }
582: return(maxdepth+1);
583: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.