4c639475ce
the malloc pool allocator is limited in its allocation size. as almost all data structures in cwfs are never freed, use brk() in ialloc() instead of mallocalign(). this means memory returned by ialloc() cannot be freed! to make sure we do not call free by accident, remove the #define malloc(n) ialloc(n, 0) macro and use ialloc() directly as in the original code to show the intend of permanent allocations.
424 lines
8.7 KiB
C
424 lines
8.7 KiB
C
/*
|
|
* interface to scsi devices via scsi(2) to sd(3),
|
|
* which does not implement LUNs.
|
|
*/
|
|
#include "all.h"
|
|
#include "io.h"
|
|
|
|
enum {
|
|
Ninquiry = 255,
|
|
Nsense = 255,
|
|
|
|
CMDtest = 0x00,
|
|
CMDreqsense = 0x03,
|
|
CMDread6 = 0x08,
|
|
CMDwrite6 = 0x0A,
|
|
CMDinquiry = 0x12,
|
|
CMDstart = 0x1B,
|
|
CMDread10 = 0x28,
|
|
CMDwrite10 = 0x2A,
|
|
};
|
|
|
|
typedef struct {
|
|
Target target[NTarget];
|
|
} Ctlr;
|
|
static Ctlr scsictlr[MaxScsi];
|
|
|
|
extern int scsiverbose;
|
|
|
|
void
|
|
scsiinit(void)
|
|
{
|
|
Ctlr *ctlr;
|
|
int ctlrno, targetno;
|
|
Target *tp;
|
|
|
|
scsiverbose = 1;
|
|
for(ctlrno = 0; ctlrno < MaxScsi; ctlrno++){
|
|
ctlr = &scsictlr[ctlrno];
|
|
memset(ctlr, 0, sizeof(Ctlr));
|
|
for(targetno = 0; targetno < NTarget; targetno++){
|
|
tp = &ctlr->target[targetno];
|
|
|
|
qlock(tp);
|
|
qunlock(tp);
|
|
sprint(tp->id, "scsictlr#%d.%d", ctlrno, targetno);
|
|
|
|
tp->ctlrno = ctlrno;
|
|
tp->targetno = targetno;
|
|
tp->inquiry = ialloc(Ninquiry, 0);
|
|
tp->sense = ialloc(Nsense, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
static uchar lastcmd[16];
|
|
static int lastcmdsz;
|
|
|
|
static int
|
|
sense2stcode(uchar *sense)
|
|
{
|
|
switch(sense[2] & 0x0F){
|
|
case 6: /* unit attention */
|
|
/*
|
|
* 0x28 - not ready to ready transition,
|
|
* medium may have changed.
|
|
* 0x29 - power on, RESET or BUS DEVICE RESET occurred.
|
|
*/
|
|
if(sense[12] != 0x28 && sense[12] != 0x29)
|
|
return STcheck;
|
|
/*FALLTHROUGH*/
|
|
case 0: /* no sense */
|
|
case 1: /* recovered error */
|
|
return STok;
|
|
case 8: /* blank data */
|
|
return STblank;
|
|
case 2: /* not ready */
|
|
if(sense[12] == 0x3A) /* medium not present */
|
|
return STcheck;
|
|
/*FALLTHROUGH*/
|
|
default:
|
|
/*
|
|
* If unit is becoming ready, rather than not ready,
|
|
* then wait a little then poke it again; should this
|
|
* be here or in the caller?
|
|
*/
|
|
if((sense[12] == 0x04 && sense[13] == 0x01)) {
|
|
// delay(500);
|
|
// scsitest(tp, lun);
|
|
fprint(2, "sense2stcode: unit becoming ready\n");
|
|
return STcheck; /* not exactly right */
|
|
}
|
|
return STcheck;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* issue the SCSI command via scsi(2). lun must already be in cmd[1].
|
|
*/
|
|
static int
|
|
doscsi(Target* tp, int rw, uchar* cmd, int cbytes, void* data, int* dbytes)
|
|
{
|
|
int lun, db = 0;
|
|
uchar reqcmd[6], reqdata[Nsense], dummy[1];
|
|
Scsi *sc;
|
|
|
|
sc = tp->sc;
|
|
if (sc == nil)
|
|
panic("doscsi: nil tp->sc");
|
|
lun = cmd[1] >> 5; /* save lun in case we need it for reqsense */
|
|
|
|
/* cope with zero arguments */
|
|
if (dbytes != nil)
|
|
db = *dbytes;
|
|
if (data == nil)
|
|
data = dummy;
|
|
|
|
if (scsi(sc, cmd, cbytes, data, db, rw) >= 0)
|
|
return STok;
|
|
|
|
/* cmd failed, get whatever sense data we can */
|
|
memset(reqcmd, 0, sizeof reqcmd);
|
|
reqcmd[0] = CMDreqsense;
|
|
reqcmd[1] = lun<<5;
|
|
reqcmd[4] = Nsense;
|
|
memset(reqdata, 0, sizeof reqdata);
|
|
if (scsicmd(sc, reqcmd, sizeof reqcmd, reqdata, sizeof reqdata,
|
|
Sread) < 0)
|
|
return STharderr;
|
|
|
|
/* translate sense data to ST* codes */
|
|
return sense2stcode(reqdata);
|
|
}
|
|
|
|
static int
|
|
scsiexec(Target* tp, int rw, uchar* cmd, int cbytes, void* data, int* dbytes)
|
|
{
|
|
int s;
|
|
|
|
/*
|
|
* issue the SCSI command. lun must already be in cmd[1].
|
|
*/
|
|
s = doscsi(tp, rw, cmd, cbytes, data, dbytes);
|
|
switch(s){
|
|
|
|
case STcheck:
|
|
memmove(lastcmd, cmd, cbytes);
|
|
lastcmdsz = cbytes;
|
|
/*FALLTHROUGH*/
|
|
|
|
default:
|
|
/*
|
|
* It's more complicated than this. There are conditions which
|
|
* are 'ok' but for which the returned status code is not 'STok'.
|
|
* Also, not all conditions require a reqsense, there may be a
|
|
* need to do a reqsense here when necessary and making it
|
|
* available to the caller somehow.
|
|
*
|
|
* Later.
|
|
*/
|
|
break;
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
static int
|
|
scsitest(Target* tp, char lun)
|
|
{
|
|
uchar cmd[6];
|
|
|
|
memset(cmd, 0, sizeof cmd);
|
|
cmd[0] = CMDtest;
|
|
cmd[1] = lun<<5;
|
|
return scsiexec(tp, SCSIread, cmd, sizeof cmd, 0, 0);
|
|
|
|
}
|
|
|
|
static int
|
|
scsistart(Target* tp, char lun, int start)
|
|
{
|
|
uchar cmd[6];
|
|
|
|
memset(cmd, 0, sizeof cmd);
|
|
cmd[0] = CMDstart;
|
|
cmd[1] = lun<<5;
|
|
if(start)
|
|
cmd[4] = 1;
|
|
return scsiexec(tp, SCSIread, cmd, sizeof cmd, 0, 0);
|
|
}
|
|
|
|
static int
|
|
scsiinquiry(Target* tp, char lun, int* nbytes)
|
|
{
|
|
uchar cmd[6];
|
|
|
|
memset(cmd, 0, sizeof cmd);
|
|
cmd[0] = CMDinquiry;
|
|
cmd[1] = lun<<5;
|
|
*nbytes = Ninquiry;
|
|
cmd[4] = *nbytes;
|
|
return scsiexec(tp, SCSIread, cmd, sizeof cmd, tp->inquiry, nbytes);
|
|
}
|
|
|
|
static char *key[] =
|
|
{
|
|
"no sense",
|
|
"recovered error",
|
|
"not ready",
|
|
"medium error",
|
|
"hardware error",
|
|
"illegal request",
|
|
"unit attention",
|
|
"data protect",
|
|
"blank check",
|
|
"vendor specific",
|
|
"copy aborted",
|
|
"aborted command",
|
|
"equal",
|
|
"volume overflow",
|
|
"miscompare",
|
|
"reserved"
|
|
};
|
|
|
|
static int
|
|
scsireqsense(Target* tp, char lun, int* nbytes, int quiet)
|
|
{
|
|
char *s;
|
|
int n, status, try;
|
|
uchar cmd[6], *sense;
|
|
|
|
sense = tp->sense;
|
|
for(try = 0; try < 20; try++) {
|
|
memset(cmd, 0, sizeof cmd);
|
|
cmd[0] = CMDreqsense;
|
|
cmd[1] = lun<<5;
|
|
cmd[4] = Ninquiry;
|
|
memset(sense, 0, Ninquiry);
|
|
|
|
*nbytes = Ninquiry;
|
|
status = scsiexec(tp, SCSIread, cmd, sizeof cmd, sense, nbytes);
|
|
if(status != STok)
|
|
return status;
|
|
*nbytes = sense[0x07]+8;
|
|
|
|
switch(sense[2] & 0x0F){
|
|
case 6: /* unit attention */
|
|
/*
|
|
* 0x28 - not ready to ready transition,
|
|
* medium may have changed.
|
|
* 0x29 - power on, RESET or BUS DEVICE RESET occurred.
|
|
*/
|
|
if(sense[12] != 0x28 && sense[12] != 0x29)
|
|
goto buggery;
|
|
/*FALLTHROUGH*/
|
|
case 0: /* no sense */
|
|
case 1: /* recovered error */
|
|
return STok;
|
|
case 8: /* blank data */
|
|
return STblank;
|
|
case 2: /* not ready */
|
|
if(sense[12] == 0x3A) /* medium not present */
|
|
goto buggery;
|
|
/*FALLTHROUGH*/
|
|
default:
|
|
/*
|
|
* If unit is becoming ready, rather than not ready,
|
|
* then wait a little then poke it again; should this
|
|
* be here or in the caller?
|
|
*/
|
|
if((sense[12] == 0x04 && sense[13] == 0x01)){
|
|
delay(500);
|
|
scsitest(tp, lun);
|
|
break;
|
|
}
|
|
goto buggery;
|
|
}
|
|
}
|
|
|
|
buggery:
|
|
if(quiet == 0){
|
|
s = key[sense[2]&0x0F];
|
|
fprint(2, "%s: reqsense: '%s' code #%2.2ux #%2.2ux\n",
|
|
tp->id, s, sense[12], sense[13]);
|
|
fprint(2, "%s: byte 2: #%2.2ux, bytes 15-17: #%2.2ux #%2.2ux #%2.2ux\n",
|
|
tp->id, sense[2], sense[15], sense[16], sense[17]);
|
|
fprint(2, "lastcmd (%d): ", lastcmdsz);
|
|
for(n = 0; n < lastcmdsz; n++)
|
|
fprint(2, " #%2.2ux", lastcmd[n]);
|
|
fprint(2, "\n");
|
|
}
|
|
|
|
return STcheck;
|
|
}
|
|
|
|
static Target*
|
|
scsitarget(Device* d)
|
|
{
|
|
int ctlrno, targetno;
|
|
|
|
ctlrno = d->wren.ctrl;
|
|
if(ctlrno < 0 || ctlrno >= MaxScsi /* || scsictlr[ctlrno].io == nil */)
|
|
return 0;
|
|
targetno = d->wren.targ;
|
|
if(targetno < 0 || targetno >= NTarget)
|
|
return 0;
|
|
return &scsictlr[ctlrno].target[targetno];
|
|
}
|
|
|
|
static void
|
|
scsiprobe(Device* d)
|
|
{
|
|
Target *tp;
|
|
int nbytes, s;
|
|
uchar *sense;
|
|
int acount;
|
|
|
|
if((tp = scsitarget(d)) == 0)
|
|
panic("scsiprobe: device = %Z", d);
|
|
|
|
acount = 0;
|
|
again:
|
|
s = scsitest(tp, d->wren.lun);
|
|
if(s < STok){
|
|
fprint(2, "%s: test, status %d\n", tp->id, s);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Determine if the drive exists and is not ready or
|
|
* is simply not responding.
|
|
* If the status is OK but the drive came back with a 'power on' or
|
|
* 'reset' status, try the test again to make sure the drive is really
|
|
* ready.
|
|
* If the drive is not ready and requires intervention, try to spin it
|
|
* up.
|
|
*/
|
|
s = scsireqsense(tp, d->wren.lun, &nbytes, acount);
|
|
sense = tp->sense;
|
|
switch(s){
|
|
case STok:
|
|
if ((sense[2] & 0x0F) == 0x06 &&
|
|
(sense[12] == 0x28 || sense[12] == 0x29))
|
|
if(acount == 0){
|
|
acount = 1;
|
|
goto again;
|
|
}
|
|
break;
|
|
case STcheck:
|
|
if((sense[2] & 0x0F) == 0x02){
|
|
if(sense[12] == 0x3A)
|
|
break;
|
|
if(sense[12] == 0x04 && sense[13] == 0x02){
|
|
fprint(2, "%s: starting...\n", tp->id);
|
|
if(scsistart(tp, d->wren.lun, 1) == STok)
|
|
break;
|
|
s = scsireqsense(tp, d->wren.lun, &nbytes, 0);
|
|
}
|
|
}
|
|
/*FALLTHROUGH*/
|
|
default:
|
|
fprint(2, "%s: unavailable, status %d\n", tp->id, s);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Inquire to find out what the device is.
|
|
* Hardware drivers may need some of the info.
|
|
*/
|
|
s = scsiinquiry(tp, d->wren.lun, &nbytes);
|
|
if(s != STok) {
|
|
fprint(2, "%s: inquiry failed, status %d\n", tp->id, s);
|
|
return;
|
|
}
|
|
fprint(2, "%s: %s\n", tp->id, (char*)tp->inquiry+8);
|
|
tp->ok = 1;
|
|
}
|
|
|
|
int
|
|
scsiio(Device* d, int rw, uchar* cmd, int cbytes, void* data, int dbytes)
|
|
{
|
|
Target *tp;
|
|
int e, nbytes, s;
|
|
|
|
if((tp = scsitarget(d)) == 0)
|
|
panic("scsiio: device = %Z", d);
|
|
|
|
qlock(tp);
|
|
if(tp->ok == 0)
|
|
scsiprobe(d);
|
|
qunlock(tp);
|
|
|
|
s = STinit;
|
|
for(e = 0; e < 10; e++){
|
|
for(;;){
|
|
nbytes = dbytes;
|
|
s = scsiexec(tp, rw, cmd, cbytes, data, &nbytes);
|
|
if(s == STok)
|
|
break;
|
|
s = scsireqsense(tp, d->wren.lun, &nbytes, 0);
|
|
if(s == STblank && rw == SCSIread) {
|
|
memset(data, 0, dbytes);
|
|
return STok;
|
|
}
|
|
if(s != STok)
|
|
break;
|
|
}
|
|
if(s == STok)
|
|
break;
|
|
}
|
|
if(e)
|
|
fprint(2, "%s: retry %d cmd #%x\n", tp->id, e, cmd[0]);
|
|
return s;
|
|
}
|
|
|
|
void
|
|
newscsi(Device *d, Scsi *sc)
|
|
{
|
|
Target *tp;
|
|
|
|
if((tp = scsitarget(d)) == nil)
|
|
panic("newscsi: device = %Z", d);
|
|
tp->sc = sc; /* connect Target to Scsi */
|
|
}
|