Date: Sat, 25 Mar 95 01:33 PST From: julian@tfs.com (Julian Elischer) To: hackers@FreeBSD.org Subject: OOPS previous patch flawed Message-ID: <m0rsSEB-0003vlC@TFS.COM>
next in thread | raw e-mail | index | archive | help
NATURALLY I spotted a flaw in the patch just AFTER I posted it..
here is the fixed version..
###############cut here############
*** 1.4 1995/03/25 01:22:38
--- st.c 1995/03/25 09:17:10
***************
*** 1859,1870 ****
flags));
}
- #ifdef NETBSD
- #define SIGNAL_SHORT_READ
- #else
- #define SIGNAL_SHORT_READ bp->b_flags |= B_ERROR;
- #endif
-
/*
* Look at the returned sense and act on the error and detirmine
* The unix error number to pass back... (0 = report no error)
--- 1859,1864 ----
***************
*** 1889,1981 ****
if (sense->error_code & SSD_ERRCODE_VALID) {
info = ntohl(*((int32 *) sense->ext.extended.info));
} else {
! info = xs->datalen; /* bad choice if fixed blocks */
}
if ((sense->error_code & SSD_ERRCODE) != 0x70) {
! return SCSIRET_CONTINUE; /* let the generic code handle it */
}
! if (st->flags & ST_FIXEDBLOCKS) {
! xs->resid = info * st->blksiz;
! if (sense->ext.extended.flags & SSD_EOM) {
! st->flags |= ST_EIO_PENDING;
! if (bp) {
! bp->b_resid = xs->resid;
! SIGNAL_SHORT_READ
! }
! }
! if (sense->ext.extended.flags & SSD_FILEMARK) {
! st->flags |= ST_AT_FILEMARK;
! if (bp) {
! bp->b_resid = xs->resid;
! SIGNAL_SHORT_READ
}
- }
- if (sense->ext.extended.flags & SSD_ILI) {
- st->flags |= ST_EIO_PENDING;
- if (bp) {
- bp->b_resid = xs->resid;
- SIGNAL_SHORT_READ
- }
- if (sense->error_code & SSD_ERRCODE_VALID &&
- !silent)
- printf("st%d: block wrong size"
- ", %d blocks residual\n", unit
- ,info);
-
/*
! * This quirk code helps the drive read
! * the first tape block, regardless of
! * format. That is required for these
! * drives to return proper MODE SENSE
! * information.
*/
! if ((st->quirks & ST_Q_SNS_HLP) &&
! !(sc_link->flags & SDEV_MEDIA_LOADED)) {
! st->blksiz -= 512;
! }
! }
! /*
! * If no data was tranfered, do it immediatly
! */
! if (xs->resid >= xs->datalen) {
! if (st->flags & ST_EIO_PENDING) {
! return EIO;
! }
! if (st->flags & ST_AT_FILEMARK) {
! if (bp) {
! bp->b_resid = xs->resid;
! SIGNAL_SHORT_READ
}
- return 0;
}
- }
- } else { /* must be variable mode */
- xs->resid = xs->datalen; /* to be sure */
- if (sense->ext.extended.flags & SSD_EOM) {
- return (EIO);
- }
- if (sense->ext.extended.flags & SSD_FILEMARK) {
- if (bp)
- bp->b_resid = bp->b_bcount;
return 0;
! }
! if (sense->ext.extended.flags & SSD_ILI) {
! if (info < 0) {
! /*
! * the record was bigger than the read
! */
! if (!silent)
! printf("st%d: %d-byte record "
! "too big\n", unit,
! xs->datalen - info);
return (EIO);
}
! xs->resid = info;
! if (bp) {
! bp->b_resid = info;
! SIGNAL_SHORT_READ
}
}
}
key = sense->ext.extended.flags & SSD_KEY;
--- 1883,1969 ----
if (sense->error_code & SSD_ERRCODE_VALID) {
info = ntohl(*((int32 *) sense->ext.extended.info));
} else {
! if (st->flags & ST_FIXEDBLOCKS) {
! info = xs->datalen / st->blksiz;
! } else {
! info = xs->datalen;
! }
}
if ((sense->error_code & SSD_ERRCODE) != 0x70) {
! return SCSIRET_CONTINUE;/* let the generic code handle it */
}
! if(st->flags & (SSD_EOM|SSD_FILEMARK|SSD_ILI)) {
! if (st->flags & ST_FIXEDBLOCKS) {
! xs->resid = info * st->blksiz;
! xs->flags |= SCSI_RESID_VALID;
! if (sense->ext.extended.flags & SSD_EOM) {
! st->flags |= ST_EIO_PENDING;
! }
! if (sense->ext.extended.flags & SSD_FILEMARK) {
! st->flags |= ST_AT_FILEMARK;
! }
! if (sense->ext.extended.flags & SSD_ILI) {
! st->flags |= ST_EIO_PENDING;
! if (sense->error_code & SSD_ERRCODE_VALID &&
! !silent)
! printf("st%d: block wrong size"
! ", %d blocks residual\n", unit
! ,info);
! /*XXX*/ /* is this how it works ? */
! /* check def of ILI for fixed blk tapes */
!
! /*
! * This quirk code helps the drive read
! * the first tape block, regardless of
! * format. That is required for these
! * drives to return proper MODE SENSE
! * information.
! */
! if ((st->quirks & ST_Q_SNS_HLP) &&
! !(sc_link->flags & SDEV_MEDIA_LOADED)) {
! st->blksiz -= 512;
! }
}
/*
! * If no data was tranfered, do it immediatly
*/
! if (xs->resid >= xs->datalen) {
! xs->flags &= ~SCSI_RESID_VALID;
! if (st->flags & ST_AT_FILEMARK) {
! xs->flags |= SCSI_EOF;
! st->flags &= ~ST_AT_FILEMARK;
! return 0;
! }
! if (st->flags & ST_EIO_PENDING) {
! st->flags &= ~ST_EIO_PENDING;
! return EIO;
}
}
return 0;
! } else { /* must be variable mode */
! xs->resid = xs->datalen; /* to be sure */
! if (sense->ext.extended.flags & SSD_EOM) {
return (EIO);
}
! if (sense->ext.extended.flags & SSD_FILEMARK) {
! xs->flags |= SCSI_EOF;
! }
! if (sense->ext.extended.flags & SSD_ILI) {
! if (info < 0) {
! /*
! * the record was bigger than the read
! */
! if (!silent)
! printf("st%d: %d-byte record "
! "too big\n", unit,
! xs->datalen - info);
! return (EIO);
! }
! xs->resid = info;
! xs->flags |= SCSI_RESID_VALID;
}
}
+ return 0;
}
key = sense->ext.extended.flags & SSD_KEY;
***************
*** 1987,2005 ****
* MODE SENSE information.
*/
if ((st->quirks & ST_Q_SNS_HLP) &&
! !(sc_link->flags & SDEV_MEDIA_LOADED)) { /* still starting */
st->blksiz -= 512;
} else if (!(st->flags & (ST_2FM_AT_EOD | ST_BLANK_READ))) {
st->flags |= ST_BLANK_READ;
! xs->resid = xs->datalen;
! if (bp) {
! bp->b_resid = xs->resid;
! /*return an EOF */
! }
return (ESUCCESS);
}
}
! return SCSIRET_CONTINUE; /* let the default/generic handler handle it */
}
/*
--- 1975,1990 ----
* MODE SENSE information.
*/
if ((st->quirks & ST_Q_SNS_HLP) &&
! !(sc_link->flags & SDEV_MEDIA_LOADED)) {
! /* still starting */
st->blksiz -= 512;
} else if (!(st->flags & (ST_2FM_AT_EOD | ST_BLANK_READ))) {
st->flags |= ST_BLANK_READ;
! xs->flags |= SCSI_EOF;
return (ESUCCESS);
}
}
! return SCSIRET_CONTINUE; /* Use the the generic handler */
}
/*
*** 1.4 1995/03/25 01:22:38
--- scsi_base.c 1995/03/25 09:28:48
***************
*** 17,22 ****
--- 17,23 ----
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
+ #include <sys/kernel.h>
#include <sys/buf.h>
#include <sys/uio.h>
#include <sys/malloc.h>
***************
*** 61,66 ****
--- 62,68 ----
sc_link->flags |= SDEV_WAITING;
tsleep((caddr_t)sc_link, PRIBIO, "scsiget", 0);
}
+ sc_link->active++;
sc_link->opennings--;
if (xs = next_free_xs) {
next_free_xs = xs->next;
***************
*** 97,102 ****
--- 99,105 ----
SC_DEBUG(sc_link, SDEV_DB3, ("free_xs\n"));
/* if was 0 and someone waits, wake them up */
+ sc_link->active--;
if ((!sc_link->opennings++) && (sc_link->flags & SDEV_WAITING)) {
sc_link->flags &= ~SDEV_WAITING;
wakeup((caddr_t)sc_link); /* remember, it wakes them ALL up */
***************
*** 356,361 ****
--- 359,367 ----
}
/* BUG: This isn't used anywhere. Do you have plans for it,
* Julian? (dufault@hda.com).
+ * This allows a private 'done' handler to
+ * resubmit the command if it wants to retry,
+ * In this case the xs must NOT be freed. (julian)
*/
if (retval == -2) {
return; /* it did it all, finish up */
***************
*** 427,433 ****
if (bp && !(flags & SCSI_USER)) flags |= SCSI_NOSLEEP;
SC_DEBUG(sc_link, SDEV_DB2, ("scsi_cmd\n"));
! xs = get_xs(sc_link, flags); /* should wait unless booting */
if (!xs) return (ENOMEM);
/*
* Fill out the scsi_xfer structure. We don't know whose context
--- 433,439 ----
if (bp && !(flags & SCSI_USER)) flags |= SCSI_NOSLEEP;
SC_DEBUG(sc_link, SDEV_DB2, ("scsi_cmd\n"));
! xs = get_xs(sc_link, flags);
if (!xs) return (ENOMEM);
/*
* Fill out the scsi_xfer structure. We don't know whose context
***************
*** 442,448 ****
xs->cmdlen = cmdlen;
xs->data = data_addr;
xs->datalen = datalen;
! xs->resid = datalen;
xs->bp = bp;
/*XXX*/ /*use constant not magic number */
if (datalen && ((caddr_t) data_addr < (caddr_t) KERNBASE)) {
--- 448,454 ----
xs->cmdlen = cmdlen;
xs->data = data_addr;
xs->datalen = datalen;
! xs->resid = datalen; /* just to be safe, but don't mark as VALID */
xs->bp = bp;
/*XXX*/ /*use constant not magic number */
if (datalen && ((caddr_t) data_addr < (caddr_t) KERNBASE)) {
***************
*** 503,510 ****
switch (retval) {
case SUCCESSFULLY_QUEUED:
! if (bp)
! return retval; /* will sleep (or not) elsewhere */
s = splbio();
while (!(xs->flags & ITSDONE)) {
tsleep((caddr_t)xs, PRIBIO + 1, "scsicmd", 0);
--- 509,517 ----
switch (retval) {
case SUCCESSFULLY_QUEUED:
! if (bp) {
! return 0; /* will sleep (or not) elsewhere */
! }
s = splbio();
while (!(xs->flags & ITSDONE)) {
tsleep((caddr_t)xs, PRIBIO + 1, "scsicmd", 0);
***************
*** 561,566 ****
--- 568,616 ----
return (retval);
}
+ /*
+ * submit a scsi command, given the command.. used for retries
+ * and callable from timeout()
+ */
+ #ifdef NOTYET
+ errval scsi_submit(xs)
+ struct scsi_xfer *xs;
+ {
+ struct scsi_link *sc_link = xs->sc_link;
+ int retval;
+
+ retval = (*(sc_link->adapter->scsi_cmd)) (xs);
+
+ return retval;
+ }
+
+ /*
+ * Retry a scsi command, given the command, and a delay.
+ */
+ errval scsi_retry(xs,delay)
+ struct scsi_xfer *xs;
+ int delay;
+ {
+ if(delay)
+ {
+ timeout(((void())*)scsi_submit,xs,hz*delay);
+ return(0);
+ }
+ else
+ {
+ return(scsi_submit(xs));
+ }
+ }
+ #endif
+
+ /*
+ * handle checking for errors..
+ * called at interrupt time from scsi_done() and
+ * at user time from scsi_scsi_cmd(), depending on whether
+ * there was a bp (basically, if there is a bp, there may be no
+ * associated process at the time. (it could be an async operation))
+ * lower level routines shouldn't know about xs->bp.. we are the lowest.
+ */
static errval
sc_err1(xs)
struct scsi_xfer *xs;
***************
*** 581,591 ****
retval = ESUCCESS;
if (bp) {
bp->b_error = 0;
! bp->b_resid = 0;
}
break;
case XS_SENSE:
retval = scsi_interpret_sense(xs);
if (retval == SCSIRET_DO_RETRY) {
if (xs->retries--) {
--- 631,660 ----
retval = ESUCCESS;
if (bp) {
bp->b_error = 0;
! bp->b_resid = 0; /* assume all data transferred */
! }
! /*
! * if it appears untouched,
! * assume done
! * (don't we trust the adapter drivers to do this?)
! */
! if(!(xs->flags & SCSI_RESID_VALID)
! && (xs->resid == xs->datalen)) {
! xs->resid = 0;
}
break;
case XS_SENSE:
+ /*
+ * The return here is tricky.. a device might
+ * return a sense which is not an error. A tape will return
+ * for a short read or EOF (for example) with no error but
+ * with sense info. The private error handler may have
+ * set the residual values up correctly, and should have
+ * set the SCSI_RESID_VALID flag. We need to
+ * tell physio not to retry for
+ * more data. We mustn't clobber that resid value.
+ */
retval = scsi_interpret_sense(xs);
if (retval == SCSIRET_DO_RETRY) {
if (xs->retries--) {
***************
*** 593,609 ****
xs->flags &= ~ITSDONE;
goto retry;
}
}
- retval = EIO; /* Too many retries */
if (bp) {
! bp->b_error = 0;
! bp->b_resid = 0;
if (retval) {
bp->b_flags |= B_ERROR;
- bp->b_error = retval;
bp->b_resid = bp->b_bcount;
}
SC_DEBUG(xs->sc_link, SDEV_DB3,
("scsi_interpret_sense (bp) returned %d\n", retval));
} else {
--- 662,713 ----
xs->flags &= ~ITSDONE;
goto retry;
}
+ retval = EIO; /* Too many retries */
+ }
+ /*
+ * an EOF condition results in a VALID resid..
+ */
+ if(xs->flags & SCSI_EOF) {
+ xs->resid = xs->datalen;
+ xs->flags |= SCSI_RESID_VALID;
}
if (bp) {
! bp->b_error = retval;
if (retval) {
bp->b_flags |= B_ERROR;
bp->b_resid = bp->b_bcount;
+ } else {
+ /*
+ * apparently it was not an error.
+ * The trick is that in this case, the error
+ * interpretting code could have set xs->resid
+ * to be something useful.
+ * if not, maybe the adapter driver did..
+ *
+ * It may have been an EOF (resid == datalen)
+ * or a short read, ( 0 < resid < datalen )
+ * or a corrected soft_error (resid == 0)
+ */
+ if( xs->flags & SCSI_RESID_VALID) {
+ bp->b_resid = xs->resid;
+ /*
+ * if it's a short read, set the error
+ * bit but not the error value..
+ * that's how FreeBSD indicates that.
+ */
+ if(xs->resid
+ && (xs->resid != xs->datalen))
+ bp->b_flags |= B_ERROR;
+ } else {
+ /*
+ * If nothing gives us a better value,
+ * assume we transfered all we wanted
+ */
+ bp->b_resid = 0;
+ }
}
+
SC_DEBUG(xs->sc_link, SDEV_DB3,
("scsi_interpret_sense (bp) returned %d\n", retval));
} else {
***************
*** 612,621 ****
}
break;
! case XS_BUSY:
! /*should somehow arange for a 1 sec delay here (how?) */
! /* XXX tsleep(&localvar, priority, "foo", hz);
! that's how! */
case XS_TIMEOUT:
/*
* If we can, resubmit it to the adapter.
--- 716,728 ----
}
break;
! case XS_BUSY: /*XXX*/
! /* should somehow arange for a 1 sec delay here (how?)[jre]
! * tsleep(&localvar, priority, "foo", hz);
! * that's how! [unknown]
! * no, we could be at interrupt context.. use
! * timeout(scsi_resubmit,xs,hz); [jre] (not implimenteed yet)
! */
case XS_TIMEOUT:
/*
* If we can, resubmit it to the adapter.
***************
*** 827,842 ****
errcode = (*sc_link->device->err_handler) (xs);
if (errcode >= 0)
return errcode; /* valid errno value */
switch(errcode) {
! case SCSIRET_DO_RETRY: /* Requested a retry */
return errcode;
! case SCSIRET_CONTINUE: /* Continue with default sense processing */
break;
! default:
sc_print_addr(xs->sc_link);
printf("unknown return code %d from sense handler.\n",
errcode);
--- 934,952 ----
errcode = (*sc_link->device->err_handler) (xs);
if (errcode >= 0)
+ if(xs->flags & SCSI_EOF) {
+ xs->resid = xs->datalen;
+ }
return errcode; /* valid errno value */
switch(errcode) {
! case SCSIRET_DO_RETRY: /* Requested a retry */
return errcode;
! case SCSIRET_CONTINUE: /* Continue with default sense processing */
break;
! default:
sc_print_addr(xs->sc_link);
printf("unknown return code %d from sense handler.\n",
errcode);
***************
*** 890,895 ****
--- 1000,1009 ----
switch ((int)key) {
case 0x0: /* NO SENSE */
case 0x1: /* RECOVERED ERROR */
+ if(xs->flags & SCSI_EOF) {
+ xs->resid = xs->datalen;
+ return (ESUCCESS);
+ }
if (xs->resid == xs->datalen)
xs->resid = 0; /* not short read */
case 0xc: /* EQUAL */
*** 1.4 1995/03/25 01:22:38
--- scsiconf.h 1995/03/25 05:39:29
***************
*** 406,412 ****
--- 406,414 ----
#define SCSI_NOMASK 0x02 /* dont allow interrupts.. booting */
#define SCSI_NOSTART 0x04 /* left over from ancient history */
#define SCSI_USER 0x08 /* Is a user cmd, call scsi_user_done */
+ #define SCSI_ITSDONE 0x10 /* the transfer is as done as it gets */
#define ITSDONE 0x10 /* the transfer is as done as it gets */
+ #define SCSI_INUSE 0x20 /* The scsi_xfer block is in use */
#define INUSE 0x20 /* The scsi_xfer block is in use */
#define SCSI_SILENT 0x40 /* Don't report errors to console */
#define SCSI_ERR_OK 0x80 /* An error on this operation is OK. */
***************
*** 416,421 ****
--- 418,425 ----
#define SCSI_DATA_OUT 0x800 /* expect data to flow OUT of memory */
#define SCSI_TARGET 0x1000 /* This defines a TARGET mode op. */
#define SCSI_ESCAPE 0x2000 /* Escape operation */
+ #define SCSI_EOF 0x4000 /* The operation should return EOF */
+ #define SCSI_RESID_VALID 0x8000 /* The resid field contains valid data */
/*
* Escape op codes. This provides an extensible setup for operations
#################end of patch##########
+----------------------------------+ ______ _ __
| __--_|\ Julian Elischer | \ U \/ / On assignment
| / \ julian@tfs.com +------>x USA \ in a very strange
| ( OZ ) 300 lakeside Dr. oakland CA. \___ ___ | country !
+- X_.---._/ USA+(510) 645-3137(wk) \_/ \\
v
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?m0rsSEB-0003vlC>