Return to spipe.c CVS log

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

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

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

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