Return to md_io.c CVS log

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

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

1.1     ! root        1: #include       <stdio.h>
        !             2: #include       "../scsi.h"
        !             3: #include       "../scsish.h"
        !             4: #include       <sys/types.h>
        !             5: #include       <sys/dsreq.h>
        !             6: 
        !             7: #define        DEV(buf, target, lun)   sprintf(buf, "/dev/scsi/sc0d%dl%d", target, lun)
        !             8: 
        !             9: static fd = -1;
        !            10: int s_id;
        !            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 retv;
        !            16:        dsreq_t ds;
        !            17:        char dev[512];
        !            18: 
        !            19:        err[0] = 0;
        !            20:        retv = -1;
        !            21:        if(ncmd && nret){
        !            22:                sprintf(err, "both input (%d bytes) and output (%d bytes) expected", ncmd, nret);
        !            23:                return(retv);
        !            24:        }
        !            25:        if(cmd->bus_id & 0x8000){
        !            26:                sprintf(err, "reset not supported");
        !            27:                return(retv);
        !            28:        }
        !            29:        if(fd < 0){
        !            30:                DEV(dev, cmd->bus_id, ((cmd->cmd[1]>>5)&7));
        !            31:                if((fd = open(dev, 2)) < 0){
        !            32:                        pperror(err, dev);
        !            33:                        return(-1);
        !            34:                }
        !            35:        }
        !            36:        ds.ds_flags = DSRQ_SENSE;
        !            37:        ds.ds_time = 30000;
        !            38:        ds.ds_cmdbuf = (char *)cmd->cmd;
        !            39:        ds.ds_cmdlen = 10;
        !            40:        if(ncmd){
        !            41:                ds.ds_databuf = (char *)cmd->data;
        !            42:                ds.ds_datalen = ncmd;
        !            43:                ds.ds_flags |= DSRQ_WRITE;
        !            44:        } else {
        !            45:                ds.ds_databuf = (char *)ret->data;
        !            46:                ds.ds_datalen = nret;
        !            47:                ds.ds_flags |= DSRQ_READ;
        !            48:        }
        !            49:        ds.ds_sensebuf = (char *)ret->sense;
        !            50:        ds.ds_senselen = sizeof ret->sense;
        !            51:        ds.ds_iovbuf = 0;
        !            52:        ds.ds_link = 0;
        !            53:        if(ioctl(fd, DS_ENTER, &ds) < 0){
        !            54:                pperror(err, "DS_ENTER ioctl");
        !            55: err_ret:
        !            56:                close(fd);
        !            57:                fd = -1;
        !            58:                return(retv);
        !            59:        }
        !            60:        if(ds.ds_ret
        !            61:                && (ds.ds_ret != DSRT_SHORT)
        !            62:                && (ds.ds_ret != DSRT_OK)
        !            63:        )       /* an error */
        !            64:                fprintf(stderr, "ds_ret = #%x\n", ds.ds_ret);
        !            65:        ret->type = 3;
        !            66:        ret->scsi_stat = ds.ds_status;
        !            67:        ret->scsi_msg = ds.ds_msg;
        !            68:        ret->reg1 = ret->reg2 = 0;
        !            69:        if(nret >= 0){
        !            70:                if(ds.ds_datasent != nret){
        !            71:                        if(ds.ds_datasent == 0)
        !            72:                                retv = 1;
        !            73:                        else
        !            74:                                sprintf(err, "data transfer error; wanted %d, got %d", nret, ds.ds_datasent);
        !            75:                        goto err_ret;
        !            76:                }
        !            77:        } else {
        !            78:                ret->nread = ds.ds_datasent;
        !            79:        }
        !            80:        if(!preserve){
        !            81:                close(fd);
        !            82:                fd = -1;
        !            83:        }
        !            84:        return(0);
        !            85: }
        !            86: 
        !            87: static char *smsg[16] =
        !            88: {
        !            89:        "good", "check condition", "met/good", "reserved",
        !            90:        "busy", "reserved", "reserved", "reserved",
        !            91:        "intermediate good", "reserved", "intermediate good/met", "reserved",
        !            92:        "reservation conflict", "reserved", "reserved", "reserved",
        !            93: };
        !            94: 
        !            95: s_io(int preserve, struct scsi_cmd *cmd, int ncmd, struct scsi_return *ret, int nret, char *err)
        !            96: {
        !            97:        int n;
        !            98:        int status;
        !            99:        char buf[512];
        !           100:        char ioerr[512];
        !           101: 
        !           102:        cmd->bus_id = s_id;
        !           103:        if(n = ss_io(preserve, cmd, ncmd, ret, nret, err)){
        !           104:                if(n < 0)
        !           105:                        return(n);
        !           106:                strcpy(ioerr, err);
        !           107:                err[0] = 0;
        !           108:        } else
        !           109:                ioerr[0] = 0;
        !           110:        if(status = ret->scsi_stat){
        !           111:                (*ss_extsense)(ret->data, buf, sizeof buf);
        !           112:                sprintf(err, "%s; %s", ioerr[0]? ioerr : smsg[(status>>1)&0xF], buf);
        !           113:                return(1);
        !           114:        }
        !           115:        return(0);
        !           116: }

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