Return to media.c CVS log

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

Annotation of researchv10no/cmd/worm/oscsi/sony/media.c, revision 1.1

1.1     ! root        1: #include       <stdio.h>
        !             2: #include       <stddef.h>
        !             3: #include       "../scsi.h"
        !             4: #include       "../scsish.h"
        !             5: #include       "fns.h"
        !             6: 
        !             7: static int cnts[256];
        !             8: static char *cmsg[256];
        !             9: 
        !            10: sony_media1(int drive, long lbn, int lower, struct scsi_return *ret, char *err)
        !            11: {
        !            12:        struct scsi_cmd cmd;
        !            13:        int n;
        !            14: 
        !            15:        set6(cmd, 0x1D, drive<<5, 0, 0, 10, 0);
        !            16:        cmd.data[0] = 0x0A;     /* error margin check */
        !            17:        cmd.data[1] = lower? 2:1;
        !            18:        cmd.data[2] = 0;
        !            19:        cmd.data[3] = 0;
        !            20:        cmd.data[4] = drive;
        !            21:        cmd.data[5] = lbn;
        !            22:        cmd.data[6] = lbn>>8;
        !            23:        cmd.data[7] = lbn>>16;
        !            24:        cmd.data[8] = 0;
        !            25:        cmd.data[9] = 0;
        !            26:        if(n = s_io(0, &cmd, 10, ret, 0, err))
        !            27:                return(n);
        !            28:        setdiag(cmd, drive, 256);
        !            29:        if(n = s_io(0, &cmd, 0, ret, 256, err))
        !            30:                return(n);
        !            31:        return(0);
        !            32: }
        !            33: 
        !            34: int
        !            35: sony_media(int niargs, int *iargs, int ncargs, char **cargs, char *err)
        !            36: {
        !            37:        struct scsi_return ret;
        !            38:        uchar *d;
        !            39:        int bn, c;
        !            40:        char buf[256];
        !            41:        int lower;
        !            42:        int nline;
        !            43:        int cur, curb;
        !            44:        int drive = iargs[0];
        !            45:        long lbn = iargs[1];
        !            46:        int count = iargs[2];
        !            47:        extern char *strdup(char *);
        !            48:        int verbose = 0;
        !            49:        FILE *fp = 0;
        !            50: 
        !            51: #pragma ref niargs
        !            52: 
        !            53:        if(ncargs == 1){
        !            54:                if(strcmp(cargs[0], "-v") == 0)
        !            55:                        verbose = 1;
        !            56:                else if((fp = fopen(cargs[0], "w")) == NULL){
        !            57:                        pperror(err, cargs[0]);
        !            58:                        return(1);
        !            59:                }
        !            60:        }
        !            61:        if(sony_istatus(&ret, err))
        !            62:                return(1);
        !            63:        if((ret.data[100]&0x80) && (drive == (ret.data[100]&7)))
        !            64:                lower = 0;
        !            65:        else if((ret.data[101]&0x80) && (drive == (ret.data[101]&7)))
        !            66:                lower = 1;
        !            67:        else {
        !            68:                sprintf(err, "drive %d not occupied and ready\n", drive);
        !            69:                return(1);
        !            70:        }
        !            71:        printf("media margin check for %d blocks [%d-%d] on %s drive (%d,%d):",
        !            72:                count, lbn, lbn+count-1, lower? "lower":"upper", s_id, drive);
        !            73:        if(fp)
        !            74:                printf(" stored in '%s'", cargs[0]);
        !            75:        putchar('\n');
        !            76:        if(cmsg[0] == 0){
        !            77:                for(bn = 0; bn < 256; bn++){
        !            78:                        sprintf(buf, "rare error 0x%x", bn);
        !            79:                        cmsg[bn] = strdup(buf);
        !            80:                }
        !            81:                cmsg[0] = "good";
        !            82:                cmsg[0x40] = "seek error 1 (alternated)";
        !            83:                cmsg[0x41] = "seek error 2 (alternated)";
        !            84:                cmsg[0x42] = "seek error 3 (alternated)";
        !            85:                cmsg[0x44] = "read error 1 (alternated)";
        !            86:                cmsg[0x45] = "unwritten";
        !            87:                cmsg[0x46] = "read error 3 (alternated)";
        !            88:                cmsg[0x81] = "<50% burst";
        !            89:                cmsg[0x82] = "50-96% burst (alternated)";
        !            90:                cmsg[0x83] = ">96% burst (alternated)";
        !            91:                cmsg[0x84] = "uncorrectable (alternated)";
        !            92:        }
        !            93: #define        DO(ch,cp) if(fp) putc(ch,fp); else if(ch != cur){\
        !            94:                        int newb = bn+cp-ret.data;\
        !            95:                        if(verbose && (curb>=0)){\
        !            96:                                printf("%d %s@%d, ", newb-curb, cmsg[cur], curb);\
        !            97:                                if(++nline == 5){nline = 0; putchar('\n');}\
        !            98:                        }\
        !            99:                        cur = ch;\
        !           100:                        curb = newb;\
        !           101:                }
        !           102:        cur = 256;
        !           103:        curb = -1;
        !           104:        nline = 0;
        !           105:        for(bn = 0; bn < 256; bn++)
        !           106:                cnts[bn] = 0;
        !           107:        for(bn = lbn, c = count; c >= 256; c -= 256, bn += 256){
        !           108:                if(sony_media1(drive, bn, lower, &ret, err))
        !           109:                        return(1);
        !           110:                for(d = ret.data; d < &ret.data[256];){
        !           111:                        DO(*d, d);
        !           112:                        cnts[*d++]++;
        !           113:                }
        !           114:        }
        !           115:        if(c){
        !           116:                if(sony_media1(drive, bn, lower, &ret, err))
        !           117:                        return(1);
        !           118:                for(d = ret.data; c; c--){
        !           119:                        DO(*d, d);
        !           120:                        cnts[*d++]++;
        !           121:                }
        !           122:        }
        !           123:        DO(256, d);
        !           124:        if(nline)
        !           125:                putchar('\n');
        !           126:        printf("\t");
        !           127:        for(c = 0; c < 256; c++)
        !           128:                if(cnts[c])
        !           129:                        printf("%d %s, ", cnts[c], cmsg[c]);
        !           130:        printf("\n");
        !           131:        return(0);
        !           132: }

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