Return to volid.c CVS log

Up to [Research Unix] / researchv10no / cmd / worm / oscsi / scsi

Annotation of researchv10no/cmd/worm/oscsi/scsi/volid.c, revision 1.1

1.1     ! root        1: #include       <stddef.h>
        !             2: #include       <stdio.h>
        !             3: #include       "../scsi.h"
        !             4: #include       "../juke.h"
        !             5: 
        !             6: static
        !             7: myread(int drive, long block, struct scsi_return *ret, char *err)
        !             8: {
        !             9:        struct scsi_cmd cmd;
        !            10: 
        !            11:        cmd.bus_id = s_id;
        !            12:        set10(cmd, 0x28, drive<<5, block>>24, block>>16, block>>8, block, 0, 0, 1, 0);
        !            13:        return(s_io(0, &cmd, 0, ret, 1024, err));
        !            14: }
        !            15: 
        !            16: j_rvolid(int drive, char *err)
        !            17: {
        !            18:        struct scsi_return ret;
        !            19:        long b, lastb;
        !            20:        char buf[1024];
        !            21:        int debug = 0;
        !            22: 
        !            23:        err[0] = 0;
        !            24:        if(s_start(drive, err) < 0)
        !            25:                return(-1);
        !            26:        if(myread(drive, 0L, &ret, err) == 0){
        !            27:                memset(buf, 0, 1024);
        !            28:                if(memcmp(buf, ret.data, 1024)){
        !            29:                        if(debug)
        !            30:                                fprintf(stderr, "superblok at 0\n");
        !            31:                        goto done;      /* found a superblock at 0 */
        !            32:                }
        !            33:        }
        !            34:        for(b = 1, lastb = -1;;){
        !            35: hack:
        !            36:                if(debug)
        !            37:                        fprintf(stderr, "read block %d\n", b);
        !            38:                if(myread(drive, b, &ret, err))
        !            39:                        break;
        !            40:                lastb = b;
        !            41:                b = ((long *)ret.data)[9];
        !            42:        }
        !            43:        if(lastb < 0){
        !            44:                if(b == 1){     /* for disks with a bad block 1 */
        !            45:                        b = 2;
        !            46:                        goto hack;
        !            47:                }
        !            48:                if(debug)
        !            49:                        fprintf(stderr, "tried for superblock at blocks 1,2\n");
        !            50:                sprintf(err, "no superblock");
        !            51:                s_stop(drive, buf);
        !            52:                return(1);
        !            53:        }
        !            54:        if(myread(drive, lastb, &ret, err) < 0){
        !            55:                s_stop(drive, buf);
        !            56:                fprintf(stderr, "read fail on block %d (b=%d)\n", lastb, b);/**/
        !            57:                return(-1);
        !            58:        }
        !            59:        if(debug)
        !            60:                fprintf(stderr, "superblock at %d\n", lastb);
        !            61: done:
        !            62:        strncpy(err, (char *)&ret.data[42], 128);
        !            63:        err[127] = 0;
        !            64:        s_stop(drive, buf);
        !            65:        return(0);
        !            66: }
        !            67: 
        !            68: static
        !            69: mywrite(int drive, long block, struct scsi_cmd *cmd, struct scsi_return *ret, char *err)
        !            70: {
        !            71:        set10((*cmd), 0x2A, drive<<5, block>>24, block>>16, block>>8, block, 0, 0, 1, 0);
        !            72:        return(s_io(0, cmd, 1024, ret, 0, err));
        !            73: }
        !            74: 
        !            75: j_wvolid(int drive, char *vol_id, char *err)
        !            76: {
        !            77:        char tmpfile[L_tmpnam];
        !            78:        char buf[512];
        !            79:        struct scsi_return ret;
        !            80:        struct scsi_cmd cmd;
        !            81:        FILE *fp;
        !            82:        int n;
        !            83: 
        !            84:        printf("mkfs %s\n", vol_id);
        !            85:        /* first get the capacity/size for mkfs to make a valid superblock */
        !            86:        tmpnam(tmpfile);
        !            87:        if((fp = fopen(tmpfile, "w+r")) == NULL){
        !            88:                pperror(err, tmpfile);
        !            89:                return(-1);
        !            90:        }
        !            91:        if(s_start(drive, err) < 0)
        !            92:                return(-1);
        !            93:        set10(cmd, 0x25, drive<<5, 0, 0, 0, 0, 0, 0, 0, 0);
        !            94:        if(n = s_io(0, &cmd, 0, &ret, 8, err))
        !            95:                return(n);
        !            96:        switch(longat(&ret.data[0]))
        !            97:        {
        !            98:        case 1637999:           /* sony 12in clv single density */
        !            99:                sprintf(buf, "worm mkfs -n %d -f %s %s", 1600000, tmpfile, vol_id);
        !           100:                break;
        !           101:        case 3275999:           /* sony 12in clv double density */
        !           102:                sprintf(buf, "worm mkfs -n %d -f %s %s", 3250000, tmpfile, vol_id);
        !           103:                break;
        !           104:        default:
        !           105:                fprintf(stderr, "warning: bad capacity %d\n", longat(&ret.data[0]));
        !           106:                sprintf(buf, "worm mkfs -f %s %s", tmpfile, vol_id);
        !           107:                break;
        !           108:        }
        !           109:        if(system(buf)){
        !           110:                sprintf(err, "%s: error", buf);
        !           111:                return(-1);
        !           112:        }
        !           113:        unlink(tmpfile);
        !           114:        fseek(fp, 1024L, 0);
        !           115:        if(fread(cmd.data, 1, 1024, fp) == 0){
        !           116:                pperror(err, "mkfs read");
        !           117:                return(-1);
        !           118:        }
        !           119:        fclose(fp);
        !           120:        if(mywrite(drive, 1L, &cmd, &ret, err))
        !           121:                return(-1);
        !           122:        unlink(tmpfile);
        !           123:        s_stop(drive, err);
        !           124:        return(0);
        !           125: }

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