Return to internal.c CVS log

Up to [Research Unix] / researchv10dc / cmd / worm / scsi / sony

Annotation of researchv10dc/cmd/worm/scsi/sony/internal.c, revision 1.1

1.1     ! root        1: #include       <stdio.h>
        !             2: #include       "../scsi.h"
        !             3: #include       "../scsish.h"
        !             4: #include       "../tcl.h"
        !             5: #include       "fns.h"
        !             6: 
        !             7: static
        !             8: internal(int n, int b1, int nb, struct scsi_return *ret, char *err)
        !             9: {
        !            10:        struct scsi_cmd cmd;
        !            11: 
        !            12:        set6(cmd, 0x1D, b1, 0, 0, 10, 0);
        !            13:        setlongtimeout(&cmd);
        !            14:        cmd.data[0] = n;
        !            15:        cmd.data[1] = b1>>8;
        !            16:        cmd.data[2] = 0;
        !            17:        cmd.data[3] = 0;
        !            18:        cmd.data[4] = 0;
        !            19:        cmd.data[5] = 0;
        !            20:        cmd.data[6] = 0;
        !            21:        cmd.data[7] = 0;
        !            22:        cmd.data[8] = 0;
        !            23:        cmd.data[9] = 0;
        !            24:        if(n = s_io(0, &cmd, 10, ret, 0, err))
        !            25:                return(n);
        !            26:        setdiag(cmd, 0, nb);
        !            27:        if(n = s_io(0, &cmd, 0, ret, nb, err))
        !            28:                return(n);
        !            29:        return(0);
        !            30: }
        !            31: 
        !            32: static char *cmds[] = {
        !            33:        "internal command table",
        !            34:        "error information table",
        !            35:        "arm controller diagnostics",
        !            36:        "scsi control board diagnostics",
        !            37:        "drive controller diagnostics",
        !            38:        "jukebox status",
        !            39:        0
        !            40: };
        !            41: 
        !            42: static char *msg1[16] =
        !            43: {
        !            44:        "drive not connected or powered off",
        !            45:        "drive connected but no disk",
        !            46:        "diagnostic aborted: write-protect",
        !            47:        "diagnostic aborted: write area full",
        !            48:        "urk 4", "urk 5", "urk 6", "urk 7", "urk 8", "urk 9", "urk 10",
        !            49:        "urk 11", "urk 12", "urk 13", "urk 14", "urk 15"
        !            50: };
        !            51: 
        !            52: static char *testn[10] =
        !            53: {
        !            54:        "drive on/off",
        !            55:        "read disk id",
        !            56:        "move",
        !            57:        "seek",
        !            58:        "blank sector search",
        !            59:        "written sector search",
        !            60:        "search writable area",
        !            61:        "write",
        !            62:        "ECC margin check",
        !            63:        "read data compare"
        !            64: };
        !            65: 
        !            66: int
        !            67: sony_internal(ClientData cd, Tcl_Interp *it, int argc, char **argv)
        !            68: {
        !            69:        struct scsi_cmd cmd;
        !            70:        struct scsi_return ret;
        !            71:        register unsigned char *d;
        !            72:        int i, drive, lower, arg, j;
        !            73:        long t1, t2;
        !            74:        char c;
        !            75:        extern char *cmesg[];
        !            76:        extern char *i0com[], *i1err[], *scsicmd[], *busid[], *scsiident[];
        !            77: 
        !            78:        if(argc <= 1){
        !            79:                printf("available internal commands:\n");
        !            80:                for(i = 0; cmds[i]; i++)
        !            81:                        printf("\tinternal %d: %s\n", i, cmds[i]);
        !            82:                return(TCL_OK);
        !            83:        }
        !            84:        switch(arg = atoi(argv[1]))
        !            85:        {
        !            86:        case 0:
        !            87:                if(internal(0xE5, 0, 256, &ret, cd->err))
        !            88:                        ERR_RETURN
        !            89:                printf("internal 0 (%s):\n", cmds[arg]);
        !            90:                printf("Diagnostic #E5: last 16 internal tasks (drive,shelf)\n");
        !            91:                for(i = 0, d = ret.data; i < 16; i++, d += 16){
        !            92:                        printf("[%d] %s (%d,%d) ",
        !            93:                                d[0], i0com[d[1]], d[2], d[3]);
        !            94:                        c = '[';
        !            95:                        for(j = 0; j < 16; j += 4){
        !            96:                                printf("%c#%x#%x#%x#%x", c, d[j], d[j+1], d[j+2], d[j+3]);
        !            97:                                c = ' ';
        !            98:                        }
        !            99:                        printf("]\n");
        !           100:                }
        !           101:                break;
        !           102:        case 1:
        !           103:                if(internal(0xE4, 0, 256, &ret, cd->err))
        !           104:                        ERR_RETURN
        !           105:                printf("internal 1 (%s):\n", cmds[arg]);
        !           106:                printf("Diagnostic #E4: last 16 errors; initiator[identify] error[sense] (cmd)\n");
        !           107:                for(i = 0, d = ret.data; i < 16; i++, d += 16){
        !           108:                        printf("%s[%s]: %s[#%x] (%s) ",
        !           109:                                busid[d[0]], scsiident[d[1]], i1err[d[14]], d[15], scsicmd[d[4]]);
        !           110:                        c = '[';
        !           111:                        for(j = 0; j < 16; j += 4){
        !           112:                                printf("%c#%x#%x#%x#%x", c, d[j], d[j+1], d[j+2], d[j+3]);
        !           113:                                c = ' ';
        !           114:                        }
        !           115:                        printf("]\n");
        !           116:                }
        !           117:                break;
        !           118:        case 2:
        !           119:                printf("internal 2 (%s):\n", cmds[arg]);
        !           120:                fflush(stdout);
        !           121:                time(&t1);
        !           122:                if(internal(0x90, 0, 8, &ret, cd->err))
        !           123:                        ERR_RETURN
        !           124:                time(&t2);
        !           125:                d = ret.data;
        !           126:                if(d[0] == 0)
        !           127:                        printf("\tended normally");
        !           128:                else
        !           129:                        printf("\tfailed, error codes=#%x, #%x, #%x",
        !           130:                                d[0], d[1], d[2]);
        !           131:                printf(" (time: %lds)\n", t2-t1);
        !           132:                break;
        !           133:        case 3:
        !           134:                printf("internal 3 (%s):\n", cmds[arg]);
        !           135:                fflush(stdout);
        !           136:                time(&t1);
        !           137:                if(internal(0xe0, 0, 8, &ret, cd->err))
        !           138:                        ERR_RETURN
        !           139:                time(&t2);
        !           140:                d = ret.data;
        !           141:                if(d[0] == 0)
        !           142:                        printf("\tended normally");
        !           143:                else
        !           144:                        printf("\tfailed, error codes=#%x, #%x, #%x",
        !           145:                                d[0], d[1], d[2]);
        !           146:                printf(" (time: %lds)\n", t2-t1);
        !           147:                break;
        !           148:        case 4:
        !           149:                drive = (argc >= 3)? atoi(argv[2]) : 0;
        !           150:                if(sony_istatus(&ret, cd->err))
        !           151:                        ERR_RETURN
        !           152:                if((ret.data[100]&0x80) && (drive == (ret.data[100]&7)))
        !           153:                        lower = 0x100;
        !           154:                else if((ret.data[101]&0x80) && (drive == (ret.data[101]&7)))
        !           155:                        lower = 0x200;
        !           156:                else {
        !           157:                        fprintf(stderr, "drive %d not occupied\n", drive);
        !           158:                        ERR_RETURN
        !           159:                }
        !           160:                printf("drive %d[%ser]: %s\n", drive, (lower == 0x200)?"low":"upp", cmds[arg]);
        !           161:                fflush(stdout);
        !           162:                time(&t1);
        !           163:                if(internal(0x18, lower, 256, &ret, cd->err))
        !           164:                        ERR_RETURN
        !           165:                time(&t2);
        !           166:                d = ret.data;
        !           167:                if(d[1]&0x80){
        !           168:                        printf("diagnostic result:");
        !           169:                        if((d[1]&0x70) == 0)
        !           170:                                printf(" no faults");
        !           171:                        else {
        !           172:                                if(d[1]&0x10)
        !           173:                                        printf(" controller-fault");
        !           174:                                if(d[1]&0x20)
        !           175:                                        printf(" drive-fault");
        !           176:                                if(d[1]&0x10)
        !           177:                                        printf(" disk-fault");
        !           178:                                printf(" (last error code 0x%2.2ux)", d[4]);
        !           179:                        }
        !           180:                } else
        !           181:                        printf("diagnostic not performed: %s", msg1[d[1]&0xF]);
        !           182:                printf(" (time: %lds)\n", t2-t1);
        !           183:                for(i = 0; i < 10; i++)
        !           184:                        printf("test %d[%s]: %s\n", i, testn[i], cmesg[d[i*8+drive+8]]);
        !           185:                printf("diagnostic count (drive:avail):");
        !           186:                for(d += 104, i = 0; i < 8; i++, d += 2)
        !           187:                        printf(" %d:%d", i, d[0]+d[1]*256);
        !           188:                printf("\n");
        !           189:                break;
        !           190:        case 5:
        !           191:                set10(cmd,  0xD3, 0, 0, 0, 0, 0, 0, 0, 0, 0);
        !           192:                if(s_io(0, &cmd, 0, &ret, 20, cd->err))
        !           193:                        ERR_RETURN
        !           194:                printf("%s: component(fatal err/err/cmds)\n", cmds[arg]);
        !           195:                d = ret.data;
        !           196: #define        ONE(str, x, sep)        printf("%s(%d/%d/%d)%c", str, d[x+3], d[x+2], d[x+1]+256*d[x], sep)
        !           197:        
        !           198:                ONE("upper drive", 4, ' ');
        !           199:                ONE("lower drive", 8, ' ');
        !           200:                ONE("sys control", 12, ' ');
        !           201:                printf("backup mem(0/%d/%d)\n", d[19]+256*d[18], d[17]+256*d[16]);
        !           202:                break;
        !           203:        }
        !           204:        return(TCL_OK);
        !           205: }

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