Return to h_io.c CVS log

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

Annotation of researchv10dc/cmd/worm/oscsi/scsi/h_io.c, revision 1.1

1.1     ! root        1: #include       <stdio.h>
        !             2: #include       "../scsi.h"
        !             3: #include       "../scsish.h"
        !             4: #include       <scsi.h>
        !             5: 
        !             6: #define                DEV             "/dev/scsi"
        !             7: 
        !             8: static fd = -1;
        !             9: int s_id;
        !            10: int s_ignua = 1;
        !            11: void (*ss_extsense)(uchar *, char *, int);
        !            12: 
        !            13: ss_io(int preserve, struct scsi_cmd *cmd, int ncmd, struct scsi_return *ret, int nret, char *err)
        !            14: {
        !            15:        int n;
        !            16:        int retv;
        !            17: 
        !            18:        err[0] = 0;
        !            19:        retv = -1;
        !            20:        if(fd < 0){
        !            21:                if((fd = open(DEV, 2)) < 0){
        !            22:                        pperror(err, DEV);
        !            23:                        return(-1);
        !            24:                }
        !            25:        }
        !            26:        cmd->flags |= (ncmd == 0)? SCSI_RD:SCSI_WR;
        !            27:        if((n = write(fd, cmd, 16+ncmd)) != 16+ncmd){
        !            28:                pperror(err, "scsiio write");
        !            29: err_ret:
        !            30:                close(fd);
        !            31:                fd = -1;
        !            32:                return(retv);
        !            33:        }
        !            34:        if(nret >= 0){
        !            35:                if((n = read(fd, ret, 36+nret)) != 36+nret){
        !            36:                        if(n == 36)
        !            37:                                retv = 1;
        !            38:                        else
        !            39:                                pperror(err, "scsiio read");
        !            40:                        goto err_ret;
        !            41:                }
        !            42:        } else {
        !            43:                if((n = read(fd, ret, 36-nret)) < 0){
        !            44:                        pperror(err, "scsiio read");
        !            45:                        goto err_ret;
        !            46:                }
        !            47:                ret->nread = n-36;
        !            48:        }
        !            49:        if(!preserve){
        !            50:                close(fd);
        !            51:                fd = -1;
        !            52:        }
        !            53:        return(0);
        !            54: }
        !            55: 
        !            56: static char *smsg[16] =
        !            57: {
        !            58:        "good", "check condition", "met/good", "reserved",
        !            59:        "busy", "reserved", "reserved", "reserved",
        !            60:        "intermediate good", "reserved", "intermediate good/met", "reserved",
        !            61:        "reservation conflict", "reserved", "reserved", "reserved",
        !            62: };
        !            63: 
        !            64: s_io(int preserve, struct scsi_cmd *cmd, int ncmd, struct scsi_return *ret, int nret, char *err)
        !            65: {
        !            66:        int n;
        !            67:        int status;
        !            68:        char buf[512];
        !            69:        char ioerr[512];
        !            70:        struct scsi_cmd mycmd;
        !            71:        int ignoredua = 0;
        !            72: 
        !            73:        cmd->bus_id = s_id;
        !            74: again:
        !            75:        if(n = ss_io(preserve, cmd, ncmd, ret, nret, err)){
        !            76:                if(n < 0)
        !            77:                        return(n);
        !            78:                strcpy(ioerr, err);
        !            79:                err[0] = 0;
        !            80:        } else
        !            81:                ioerr[0] = 0;
        !            82:        if(status = ret->scsi_stat){
        !            83:                mycmd.bus_id = s_id;
        !            84:                set6(mycmd, 0x03, cmd->cmd[1]&0xE0, 0, 0, 100, 0);
        !            85:                if(n = ss_io(0, &mycmd, 0, ret, -100, err))
        !            86:                        return(n);
        !            87:                if(s_ignua){    /* ignore unit attention ?? */
        !            88:                        if((ret->data[2]&0xF) == 6){    /* it is */
        !            89:                                if(ignoredua++ == 0){   /* but only ignore once */
        !            90:                                        mycmd.bus_id = s_id;
        !            91:                                        set6(mycmd, 0x12, cmd->cmd[1]&0xE0, 0, 0, 5, 0);
        !            92:                                        if(n = ss_io(0, &mycmd, 0, ret, 5, err))
        !            93:                                                return(n);
        !            94:                                        goto again;
        !            95:                                }
        !            96:                        }
        !            97:                }
        !            98:                if(ss_extsense == 0)
        !            99:                        ss_extsense = gen_extsense;
        !           100:                (*ss_extsense)(ret->data, buf, sizeof buf);
        !           101:                sprintf(err, "%s; %s", ioerr[0]? ioerr : smsg[(status>>1)&0xF], buf);
        !           102:                return(1);
        !           103:        }
        !           104:        return(0);
        !           105: }

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