Return to rarct.c CVS log

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

Annotation of researchv8dc/cmd/rarepl/rarct.c, revision 1.1

1.1     ! root        1: /*% cc -O -o rarct %
        !             2:  *
        !             3:  * read the rct and other stuff
        !             4:  */
        !             5: 
        !             6: #include <stdio.h>
        !             7: #include <sys/param.h>
        !             8: #include <sys/udaioc.h>
        !             9: #include "rct.h"
        !            10: 
        !            11: struct ud_unit ud_unit;
        !            12: 
        !            13: main(argc, argv)
        !            14: int argc;
        !            15: char **argv;
        !            16: {
        !            17:        int hdr = 0;
        !            18:        int stat = 0;
        !            19:        int nd = 0;
        !            20:        int errs = 0;
        !            21: 
        !            22:        while (--argc > 0) {
        !            23:                if (**++argv == '-')
        !            24:                        switch (argv[0][1]) {
        !            25:                        case 'h':
        !            26:                                hdr++;
        !            27:                                continue;
        !            28: 
        !            29:                        case 'c':
        !            30:                                stat++;
        !            31:                                continue;
        !            32: 
        !            33:                        default:
        !            34:                                fprintf(stderr, "%s ignored\n", *argv);
        !            35:                                continue;
        !            36:                        }
        !            37:                nd++;
        !            38:                errs += dodev(*argv, hdr, stat);
        !            39:        }
        !            40:        if (nd == 0) {
        !            41:                fprintf(stderr, "usage: %s dev\n", argv[0]);
        !            42:                exit(1);
        !            43:        }
        !            44:        exit(errs);
        !            45: }
        !            46: 
        !            47: dodev(dev, hdr, stat)
        !            48: char *dev;
        !            49: int hdr, stat;
        !            50: {
        !            51:        int fd;
        !            52:        daddr_t size;
        !            53:        char buf[RBNSEC];
        !            54:        register daddr_t i;
        !            55:        daddr_t rctmax();
        !            56: 
        !            57:        if ((fd = open(dev, 0)) < 0) {
        !            58:                perror(dev);
        !            59:                return (1);
        !            60:        }
        !            61:        /*
        !            62:         * hack to force driver to read status
        !            63:         */
        !            64:        if (read(fd, buf, RBNSEC) != RBNSEC) {
        !            65:                perror("read first block");
        !            66:                close(fd);
        !            67:                return (1);
        !            68:        }
        !            69:        if (ioctl(fd, UIOCHAR, &ud_unit) < 0) {
        !            70:                perror("ioctl");
        !            71:                close(fd);
        !            72:                return (1);
        !            73:        }
        !            74:        if (stat)
        !            75:                statput();
        !            76:        if (hdr) {
        !            77:                rctread(fd, buf, RCTHDR);
        !            78:                hdrput(buf);
        !            79:        }
        !            80:        if (hdr || stat) {
        !            81:                close(fd);
        !            82:                return (0);
        !            83:        }
        !            84:        size = rctmax();
        !            85:        for (i = RCTTAB; i < size; i++) {
        !            86:                rctread(fd, buf, i);
        !            87:                rctput(buf, i);
        !            88:        }
        !            89:        close(fd);
        !            90:        return (0);
        !            91: }
        !            92: 
        !            93: daddr_t
        !            94: rctmax()
        !            95: {
        !            96:        daddr_t nrbns;
        !            97: 
        !            98:        nrbns = (ud_unit.radsize / ud_unit.tracksz) * ud_unit.rbns;
        !            99:        return ((nrbns / RBNPB) + RCTTAB);
        !           100: }
        !           101: 
        !           102: rctread(fd, buf, bno)
        !           103: char *buf;
        !           104: daddr_t bno;
        !           105: {
        !           106:        struct ud_rctbuf rb;
        !           107:        register int i;
        !           108: 
        !           109:        rb.lbn = bno;
        !           110:        rb.buf = buf;
        !           111:        if (ioctl(fd, UIORRCT, &rb) < 0) {
        !           112:                perror("read rct");
        !           113:                fprintf(stderr, "block %d\n", bno);
        !           114:                for (i = 0; i < RBNSEC; i++)
        !           115:                        buf[i] = 0;
        !           116:        }
        !           117: }
        !           118: 
        !           119: rctput(buf, bno)
        !           120: char *buf;
        !           121: int bno;
        !           122: {
        !           123:        register long rbn;
        !           124:        register struct rbd *rp;
        !           125:        register int i;
        !           126: 
        !           127:        rbn = (bno - RCTTAB) * RBNPB;
        !           128:        rp = (struct rbd *)buf;
        !           129:        for (i = 0; i < RBNPB; i++, rp++, rbn++)
        !           130:                if (rp->rb_lbn || rp->rb_code)
        !           131:                        printf("%ld: %o: %ld\n", rbn, rp->rb_code, rp->rb_lbn);
        !           132: }
        !           133: 
        !           134: hdrput(buf)
        !           135: char *buf;
        !           136: {
        !           137:        register struct rct *rc;
        !           138: 
        !           139:        rc = (struct rct *)buf;
        !           140:        printf("volser x%lx x%lx\n", rc->rc_volser[0], rc->rc_volser[1]);
        !           141:        printf("flags 0%x lbn %ld rbn %ld badrbn %ld\n",
        !           142:                rc->rc_flags, rc->rc_lbn, rc->rc_rbn, rc->rc_badrbn);
        !           143: }
        !           144: 
        !           145: statput()
        !           146: {
        !           147: 
        !           148:        printf("size %ld\nrctsize %ld\n", ud_unit.radsize, ud_unit.rctsize);
        !           149:        printf("medium x%lx\n", ud_unit.medium);
        !           150:        printf("tracks %d groups %d cyls %d\n",
        !           151:                ud_unit.tracksz, ud_unit.groupsz, ud_unit.cylsz);
        !           152:        printf("rbns/track %d\ncopies %d\n", ud_unit.rbns, ud_unit.copies);
        !           153: }

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