Return to spipe.c CVS log

Up to [Research Unix] / researchv9 / sys / dev

Annotation of researchv9/sys/dev/spipe.c, revision 1.1.1.1

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

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