Return to spipe.c CVS log

Up to [Research Unix] / researchv10no / sys / io

Annotation of researchv10no/sys/io/spipe.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * stream pipe
                      3:  */
                      4: #include "sys/param.h"
                      5: #include "sys/stream.h"
                      6: #include "sys/conf.h"
                      7: 
                      8: extern struct  queue   *spipes[];
                      9: extern int spcnt;
                     10: 
                     11: int    spsrv(), spclose();
                     12: long   spopen();
                     13: static struct qinit sprinit = { putq, spsrv, spopen, spclose, 128, 65 };
                     14: struct streamtab spinfo = { &sprinit, &sprinit };
                     15: struct cdevsw spcdev = cstrinit(&spinfo);
                     16: 
                     17: long
                     18: spopen(q, dev)
                     19: register struct queue *q;
                     20: {
                     21:        register d = minor(dev);
                     22:        register struct queue *oq;
                     23: 
                     24:        if (d > spcnt)
                     25:                return (0);
                     26:        if (q->ptr) {                   /* already open */
                     27:                if (d&01)
                     28:                        return(0);      /* reopening master */
                     29:                else
                     30:                        return(1);      /* reopening slave */
                     31:        }
                     32:        q->flag |= QDELIM;
                     33:        if (oq = spipes[d^01]) {
                     34:                if (d&01)
                     35:                        return(0);      /* master with old lingering slave */
                     36:                WR(q)->ptr = (caddr_t)oq;
                     37:                WR(oq)->ptr = (caddr_t)q;
                     38:        } else if ((d&01) == 0)
                     39:                return(0);              /* slave opened first */
                     40:        q->ptr = (caddr_t)dev;
                     41:        spipes[d] = q;
                     42:        return(1);
                     43: }
                     44: 
                     45: spclose(q)
                     46: register struct queue *q;
                     47: {
                     48:        register struct queue *oq;
                     49:        register struct block *bp;
                     50: 
                     51:        if (oq = (struct queue *)WR(q)->ptr) {
                     52:                while (bp = getq(WR(q)))
                     53:                        (*oq->next->qinfo->putp)(oq->next, bp);
                     54:                putctl(oq->next, M_HANGUP);
                     55:                WR(oq)->ptr = NULL;
                     56:        }
                     57:        spipes[minor((int)q->ptr)] = NULL;
                     58: }
                     59: 
                     60: spsrv(q)
                     61: register struct queue *q;
                     62: {
                     63:        register struct block *bp;
                     64:        register struct queue *oq;
                     65: 
                     66:        if (q->flag&QREADR) {
                     67:                oq = (struct queue *)WR(q)->ptr;
                     68:                if (oq && (q->next->flag & QFULL) == 0)
                     69:                        qenable(WR(oq));
                     70:                return;
                     71:        }
                     72:        oq = (struct queue *)q->ptr;
                     73:        while (bp = getq(q)) {
                     74:                if (oq == NULL) {
                     75:                        freeb(bp);
                     76:                        continue;
                     77:                }
                     78:                if (oq->next->flag & QFULL && bp->type < QPCTL) {
                     79:                        putbq(q, bp);
                     80:                        return;
                     81:                }
                     82:                (*oq->next->qinfo->putp)(oq->next, bp);
                     83:        }
                     84: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.