Return to pipe.c CVS log

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

Annotation of researchv10no/sys/fs/pipe.c, revision 1.1

1.1     ! root        1: #include "sys/param.h"
        !             2: #include "sys/systm.h"
        !             3: #include "sys/user.h"
        !             4: #include "sys/inode.h"
        !             5: #include "sys/file.h"
        !             6: #include "sys/proc.h"
        !             7: #include "sys/stream.h"
        !             8: #include "sys/stat.h"
        !             9: #include "sys/conf.h"
        !            10: 
        !            11: static struct inode *mkpipend();
        !            12: extern struct streamtab nilinfo;
        !            13: 
        !            14: #define        PIPFSTYP        6               /* until we do it right */
        !            15: 
        !            16: /*
        !            17:  * The sys-pipe entry.
        !            18:  * Allocate 2 open inodes, stream them, and splice them together
        !            19:  */
        !            20: pipe()
        !            21: {
        !            22:        struct inode *ip1, *ip2;
        !            23:        register struct file *rf, *wf;
        !            24:        register r;
        !            25: 
        !            26:        rf = falloc();
        !            27:        if(rf == NULL)
        !            28:                return;
        !            29:        r = u.u_r.r_val1;
        !            30:        wf = falloc();
        !            31:        if(wf == NULL) {
        !            32:                rf->f_count = 0;
        !            33:                u.u_ofile[r] = NULL;
        !            34:                return;
        !            35:        }
        !            36:        u.u_r.r_val2 = u.u_r.r_val1;
        !            37:        u.u_r.r_val1 = r;
        !            38:        if (makepipe(&ip1, &ip2)==0) {
        !            39:                rf->f_count = 0;
        !            40:                wf->f_count = 0;
        !            41:                u.u_ofile[u.u_r.r_val1] = NULL;
        !            42:                u.u_ofile[u.u_r.r_val2] = NULL;
        !            43:                return;
        !            44:        }
        !            45:        wf->f_flag = FREAD|FWRITE;
        !            46:        wf->f_inode = ip1;
        !            47:        rf->f_flag = FREAD|FWRITE;
        !            48:        rf->f_inode = ip2;
        !            49: }
        !            50: 
        !            51: /*
        !            52:  * also called by connld, unfortunately
        !            53:  */
        !            54: makepipe(ip1, ip2)
        !            55: struct inode **ip1, **ip2;
        !            56: {
        !            57:        register struct inode *i1, *i2;
        !            58: 
        !            59:        if (nfstyp <= PIPFSTYP || fstypsw[PIPFSTYP] == NULL) {  /* config error */
        !            60:                u.u_error = ENODEV;
        !            61:                return (0);
        !            62:        }
        !            63:        i1 = mkpipend();
        !            64:        i2 = mkpipend();
        !            65:        if (i1==NULL || i2==NULL) {
        !            66:                if (i1)
        !            67:                        iput(i1);
        !            68:                if (i2)
        !            69:                        iput(i2);
        !            70:                return(0);
        !            71:        }
        !            72:        qdetach(RD(i1->i_sptr->wrq->next), 1);
        !            73:        i1->i_sptr->wrq->next = RD(i2->i_sptr->wrq);
        !            74:        qdetach(RD(i2->i_sptr->wrq->next), 1);
        !            75:        i2->i_sptr->wrq->next = RD(i1->i_sptr->wrq);
        !            76:        *ip1 = i1;
        !            77:        *ip2 = i2;
        !            78:        return(1);
        !            79: }
        !            80: 
        !            81: static struct inode *
        !            82: mkpipend()
        !            83: {
        !            84:        register struct inode *ip;
        !            85: 
        !            86:        if ((ip = iuniq(PIPFSTYP)) == NULL)
        !            87:                return(NULL);
        !            88:        if ((ip = stopen(&nilinfo, NODEV, 0, ip)) == NULL)
        !            89:                return(NULL);
        !            90:        ip->i_flag |= IOPEN;            /* white lie */
        !            91:        prele(ip);
        !            92:        return(ip);
        !            93: }
        !            94: 
        !            95: /*
        !            96:  * pipe file system:
        !            97:  * exists just so pipe creation is fast
        !            98:  * inodes are in-core only
        !            99:  * must be configured, but can't be mounted,
        !           100:  * which is a little unfortunate
        !           101:  * only stat exists
        !           102:  */
        !           103: 
        !           104: static int pipstat();
        !           105: struct fstypsw pipfs =
        !           106:        fsinit(nulldev, nulldev, nodev, nodev, nodev, pipstat,
        !           107:        nullnami, nodev, nodev, nullopen, nodev);
        !           108: 
        !           109: static
        !           110: pipstat(ip, ub)
        !           111:        register struct inode *ip;
        !           112:        struct stat *ub;
        !           113: {
        !           114:        struct stat ds;
        !           115: 
        !           116:        ds.st_dev = ip->i_dev;
        !           117:        ds.st_ino = ip->i_number;
        !           118:        ds.st_mode = ip->i_mode;
        !           119:        ds.st_nlink = 0;
        !           120:        ds.st_uid = ip->i_uid;
        !           121:        ds.st_gid = ip->i_gid;
        !           122:        ds.st_size = 0;
        !           123:        ds.st_atime = time;
        !           124:        ds.st_mtime = time;
        !           125:        ds.st_ctime = time;
        !           126:        if (copyout((caddr_t)&ds, (caddr_t)ub, sizeof(ds)) < 0)
        !           127:                u.u_error = EFAULT;
        !           128: }

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