Return to blkio.c CVS log

Up to [Research Unix] / researchv8dc / cmd / qed

Annotation of researchv8dc/cmd/qed/blkio.c, revision 1.1

1.1     ! root        1: /*% cc -c -O %
        !             2:  */
        !             3: #include "vars.h"
        !             4: #define BLKSIZE        512
        !             5: #ifdef BIGTMP
        !             6: #define        MAXBLOCKS       4095
        !             7: #else
        !             8: #define        MAXBLOCKS       255
        !             9: #endif
        !            10: #define        BLMASK          MAXBLOCKS
        !            11: char   ibuff[512];
        !            12: int    iblock = -1;
        !            13: int    oblock = 0;
        !            14: char   obuff[512];
        !            15: int    ooff;           /* offset of next byte in obuff */
        !            16: initio()
        !            17: {
        !            18:        lock++;
        !            19:        iblock = -1;
        !            20:        oblock = 0;
        !            21:        ooff = 0;
        !            22:        unlock();
        !            23: }
        !            24: char *getline(tl, lbuf)
        !            25:        int tl;
        !            26:        char *lbuf;
        !            27: {
        !            28:        register char *bp, *lp;
        !            29:        register int nl;
        !            30:        extern int read();
        !            31: 
        !            32:        lp = lbuf;
        !            33:        nl = -((tl<<1) & 0774);
        !            34:        tl = (tl>>8) & BLMASK;
        !            35:        do {
        !            36:                if (nl<=0) {
        !            37:                        if (tl==oblock)
        !            38:                                bp = obuff;
        !            39:                        else {
        !            40:                                bp = ibuff;
        !            41:                                if (tl!=iblock) {
        !            42:                                        iblock = -1;    /* signal protection */
        !            43:                                        blkio(tl, bp, read);
        !            44:                                        iblock = tl;
        !            45:                                }
        !            46:                        }
        !            47:                        tl++;
        !            48:                        bp -= nl;
        !            49:                        nl += BLKSIZE;
        !            50:                }
        !            51:                nl--;
        !            52:        } while (*lp++ = *bp++);
        !            53:        return(lbuf);
        !            54: }
        !            55: int putline()
        !            56: {
        !            57:        register char *op, *lp;
        !            58:        register int r;
        !            59:        extern int write();
        !            60: 
        !            61:        modified();
        !            62:        lp = linebuf;
        !            63:        r = (oblock<<8) + (ooff>>1);    /* ooff may be 512! */
        !            64:        op = obuff + ooff;
        !            65:        lock++;
        !            66:        do {
        !            67:                if (op >= obuff+BLKSIZE) {
        !            68:                        /* delay updating oblock until after blkio succeeds */
        !            69:                        blkio(oblock, op=obuff, write);
        !            70:                        oblock++;
        !            71:                        ooff = 0;
        !            72:                }
        !            73:                if((*op = *lp++) == '\n') {
        !            74:                        *op++ = '\0';
        !            75:                        linebp = lp;
        !            76:                        break;
        !            77:                }
        !            78:        } while (*op++);
        !            79:        ooff = (((op-obuff)+3)&~3);
        !            80:        unlock();
        !            81:        return (r);
        !            82: }
        !            83: blkio(b, buf, iofcn)
        !            84:        char *buf;
        !            85:        int (*iofcn)();
        !            86: {
        !            87:        if (b>=MAXBLOCKS
        !            88:        || (lseek(tfile, ((long) b) * 512L, 0)<0L)
        !            89:        || (*iofcn)(tfile, buf, 512) != 512) {
        !            90:                error('T');
        !            91:        }
        !            92: }

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