Return to internal.c CVS log

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

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

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

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