mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2025-01-02 12:20:51 +00:00
Code Issues Releases Activity

Perform some more Ansification. Remove and then replace the isp_putback_atio

Browse Source 
function- we did it a bit cleaner. We only use this if a CTIO completes with
!CT_OK state. We now have managed to get away without having to poke around
and trying to find the original ATIO- the csio we're using has the tag_id
and lun values with it which is mostly what we need when we do the putback.

Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure
we call ISP_DMAFREE only if we had DATA to move.
This commit is contained in:
Matt Jacob 2001-04-04 21:49:51 +00:00
parent b5da7b232e
commit b25bcef87a
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=75196
1 changed files with 49 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
sys/dev/isp/isp_target.c
View File

@ -46,14 +46,14 @@
#endif #endif
#ifdef ISP_TARGET_MODE #ifdef ISP_TARGET_MODE
static char *atiocope = static const char atiocope[] =
"ATIO returned for lun %d because it was in the middle of Bus Device Reset"; "ATIO returned for lun %d because it was in the middle of Bus Device Reset";
static char *atior = static const char atior[] =
"ATIO returned for lun %d from initiator %d because a Bus Reset occurred"; "ATIO returned for lun %d from initiator %d because a Bus Reset occurred";
static void isp_got_msg __P((struct ispsoftc *, int, in_entry_t *)); static void isp_got_msg(struct ispsoftc *, int, in_entry_t *);
static void isp_got_msg_fc __P((struct ispsoftc *, int, in_fcentry_t *)); static void isp_got_msg_fc(struct ispsoftc *, int, in_fcentry_t *);
static void isp_notify_ack __P((struct ispsoftc *, void *)); static void isp_notify_ack(struct ispsoftc *, void *);
static void isp_handle_atio(struct ispsoftc *, at_entry_t *); static void isp_handle_atio(struct ispsoftc *, at_entry_t *);
static void isp_handle_atio2(struct ispsoftc *, at2_entry_t *); static void isp_handle_atio2(struct ispsoftc *, at2_entry_t *);
static void isp_handle_ctio(struct ispsoftc *, ct_entry_t *); static void isp_handle_ctio(struct ispsoftc *, ct_entry_t *);
@ -106,10 +106,7 @@ static void isp_handle_ctio2(struct ispsoftc *, ct2_entry_t *);
*/ */
int int
isp_target_notify(isp, vptr, optrp) isp_target_notify(struct ispsoftc *isp, void *vptr, u_int16_t *optrp)
struct ispsoftc *isp;
void *vptr;
u_int16_t *optrp;
{ {
u_int16_t status, seqid; u_int16_t status, seqid;
union { union {
@ -268,13 +265,8 @@ isp_target_notify(isp, vptr, optrp)
* response entry. The caller is responsible for synchronizing this. * response entry. The caller is responsible for synchronizing this.
*/ */
int int
isp_lun_cmd(isp, cmd, bus, tgt, lun, opaque) isp_lun_cmd(struct ispsoftc *isp, int cmd, int bus, int tgt, int lun,
struct ispsoftc *isp; u_int32_t opaque)
int cmd;
int bus;
int tgt;
int lun;
u_int32_t opaque;
{ {
lun_entry_t el; lun_entry_t el;
u_int16_t iptr, optr; u_int16_t iptr, optr;
@ -312,6 +304,7 @@ isp_lun_cmd(isp, cmd, bus, tgt, lun, opaque)
} else if (isp->isp_maxluns <= 16) { } else if (isp->isp_maxluns <= 16) {
el.le_lun = lun; el.le_lun = lun;
} }
el.le_timeout = 2;
if (isp_getrqentry(isp, &iptr, &optr, &outp)) { if (isp_getrqentry(isp, &iptr, &optr, &outp)) {
isp_prt(isp, ISP_LOGWARN, isp_prt(isp, ISP_LOGWARN,
@ -326,9 +319,7 @@ isp_lun_cmd(isp, cmd, bus, tgt, lun, opaque)
int int
isp_target_put_entry(isp, ap) isp_target_put_entry(struct ispsoftc *isp, void *ap)
struct ispsoftc *isp;
void *ap;
{ {
void *outp; void *outp;
u_int16_t iptr, optr; u_int16_t iptr, optr;
@ -365,13 +356,7 @@ isp_target_put_entry(isp, ap)
} }
int int
isp_target_put_atio(isp, iid, tgt, lun, ttype, tval) isp_target_put_atio(struct ispsoftc *isp, void *arg)
struct ispsoftc *isp;
int iid;
int tgt;
int lun;
int ttype;
int tval;
{ {
union { union {
at_entry_t _atio; at_entry_t _atio;
@ -380,23 +365,27 @@ isp_target_put_atio(isp, iid, tgt, lun, ttype, tval)
MEMZERO(&atun, sizeof atun); MEMZERO(&atun, sizeof atun);
if (IS_FC(isp)) { if (IS_FC(isp)) {
at2_entry_t *aep = arg;
atun._atio2.at_header.rqs_entry_type = RQSTYPE_ATIO2; atun._atio2.at_header.rqs_entry_type = RQSTYPE_ATIO2;
atun._atio2.at_header.rqs_entry_count = 1; atun._atio2.at_header.rqs_entry_count = 1;
if (isp->isp_maxluns > 16) { if (isp->isp_maxluns > 16) {
atun._atio2.at_scclun = (u_int16_t) lun; atun._atio2.at_scclun = (u_int16_t) aep->at_scclun;
} else { } else {
atun._atio2.at_lun = (u_int8_t) lun; atun._atio2.at_lun = (u_int8_t) aep->at_scclun;
} }
atun._atio2.at_status = CT_OK; atun._atio2.at_status = CT_OK;
} else { } else {
at_entry_t *aep = arg;
atun._atio.at_header.rqs_entry_type = RQSTYPE_ATIO; atun._atio.at_header.rqs_entry_type = RQSTYPE_ATIO;
atun._atio.at_header.rqs_entry_count = 1; atun._atio.at_header.rqs_entry_count = 1;
atun._atio.at_iid = iid; atun._atio.at_handle = aep->at_handle;
atun._atio.at_tgt = tgt; atun._atio.at_iid = aep->at_iid;
atun._atio.at_lun = lun; atun._atio.at_tgt = aep->at_tgt;
atun._atio.at_tag_type = ttype; atun._atio.at_lun = aep->at_lun;
atun._atio.at_tag_val = tval; atun._atio.at_tag_type = aep->at_tag_type;
atun._atio.at_status = CT_OK; atun._atio.at_tag_val = aep->at_tag_val;
atun._atio.at_status = (aep->at_flags & AT_TQAE);
atun._atio.at_status |= CT_OK;
} }
return (isp_target_put_entry(isp, &atun)); return (isp_target_put_entry(isp, &atun));
} }
@ -412,7 +401,7 @@ isp_target_put_atio(isp, iid, tgt, lun, ttype, tval)
* values. * values.
* *
* NB: the key, asc, ascq, cannot be used for parallel SCSI as it doesn't * NB: the key, asc, ascq, cannot be used for parallel SCSI as it doesn't
* NB: inline SCSI sense reporting. * NB: inline SCSI sense reporting. As such, we lose this information. XXX.
* *
* For both parallel && fibre channel, we use the feature that does * For both parallel && fibre channel, we use the feature that does
* an automatic resource autoreplenish so we don't have then later do * an automatic resource autoreplenish so we don't have then later do
@ -473,6 +462,9 @@ isp_endcmd(struct ispsoftc *isp, void *arg, u_int32_t code, u_int16_t hdl)
cto->ct_lun = aep->at_lun; cto->ct_lun = aep->at_lun;
cto->ct_tag_type = aep->at_tag_type; cto->ct_tag_type = aep->at_tag_type;
cto->ct_tag_val = aep->at_tag_val; cto->ct_tag_val = aep->at_tag_val;
if (aep->at_flags & AT_TQAE) {
cto->ct_flags |= CT_TQAE;
}
cto->ct_flags = CT_SENDSTATUS | CT_NO_DATA; cto->ct_flags = CT_SENDSTATUS | CT_NO_DATA;
if (hdl == 0) { if (hdl == 0) {
cto->ct_flags |= CT_CCINCR; cto->ct_flags |= CT_CCINCR;
@ -484,10 +476,7 @@ isp_endcmd(struct ispsoftc *isp, void *arg, u_int32_t code, u_int16_t hdl)
} }
void void
isp_target_async(isp, bus, event) isp_target_async(struct ispsoftc *isp, int bus, int event)
struct ispsoftc *isp;
int bus;
int event;
{ {
tmd_event_t evt; tmd_event_t evt;
tmd_msg_t msg; tmd_msg_t msg;
@ -550,10 +539,7 @@ isp_target_async(isp, bus, event)
*/ */
static void static void
isp_got_msg(isp, bus, inp) isp_got_msg(struct ispsoftc *isp, int bus, in_entry_t *inp)
struct ispsoftc *isp;
int bus;
in_entry_t *inp;
{ {
u_int8_t status = inp->in_status & ~QLTM_SVALID; u_int8_t status = inp->in_status & ~QLTM_SVALID;
@ -579,13 +565,10 @@ isp_got_msg(isp, bus, inp)
* Synthesize a message from the task management flags in a FCP_CMND_IU. * Synthesize a message from the task management flags in a FCP_CMND_IU.
*/ */
static void static void
isp_got_msg_fc(isp, bus, inp) isp_got_msg_fc(struct ispsoftc *isp, int bus, in_fcentry_t *inp)
struct ispsoftc *isp;
int bus;
in_fcentry_t *inp;
{ {
static char *f1 = "%s from iid %d lun %d seq 0x%x"; static const char f1[] = "%s from iid %d lun %d seq 0x%x";
static char *f2 = static const char f2[] =
"unknown %s 0x%x lun %d iid %d task flags 0x%x seq 0x%x\n"; "unknown %s 0x%x lun %d iid %d task flags 0x%x seq 0x%x\n";
if (inp->in_status != IN_MSG_RECEIVED) { if (inp->in_status != IN_MSG_RECEIVED) {
@ -638,9 +621,7 @@ isp_got_msg_fc(isp, bus, inp)
} }
static void static void
isp_notify_ack(isp, arg) isp_notify_ack(struct ispsoftc *isp, void *arg)
struct ispsoftc *isp;
void *arg;
{ {
char storage[QENTRY_LEN]; char storage[QENTRY_LEN];
u_int16_t iptr, optr; u_int16_t iptr, optr;
@ -701,9 +682,7 @@ isp_notify_ack(isp, arg)
} }
static void static void
isp_handle_atio(isp, aep) isp_handle_atio(struct ispsoftc *isp, at_entry_t *aep)
struct ispsoftc *isp;
at_entry_t *aep;
{ {
int lun; int lun;
lun = aep->at_lun; lun = aep->at_lun;
@ -776,16 +755,13 @@ isp_handle_atio(isp, aep)
isp_prt(isp, ISP_LOGERR, isp_prt(isp, ISP_LOGERR,
"Unknown ATIO status 0x%x from initiator %d for lun %d", "Unknown ATIO status 0x%x from initiator %d for lun %d",
aep->at_status, aep->at_iid, lun); aep->at_status, aep->at_iid, lun);
(void) isp_target_put_atio(isp, aep->at_iid, aep->at_tgt, (void) isp_target_put_atio(isp, aep);
lun, aep->at_tag_type, aep->at_tag_val);
break; break;
} }
} }
static void static void
isp_handle_atio2(isp, aep) isp_handle_atio2(struct ispsoftc *isp, at2_entry_t *aep)
struct ispsoftc *isp;
at2_entry_t *aep;
{ {
int lun; int lun;
@ -862,15 +838,13 @@ isp_handle_atio2(isp, aep)
isp_prt(isp, ISP_LOGERR, isp_prt(isp, ISP_LOGERR,
"Unknown ATIO2 status 0x%x from initiator %d for lun %d", "Unknown ATIO2 status 0x%x from initiator %d for lun %d",
aep->at_status, aep->at_iid, lun); aep->at_status, aep->at_iid, lun);
(void) isp_target_put_atio(isp, aep->at_iid, 0, lun, 0, 0); (void) isp_target_put_atio(isp, aep);
break; break;
} }
} }
static void static void
isp_handle_ctio(isp, ct) isp_handle_ctio(struct ispsoftc *isp, ct_entry_t *ct)
struct ispsoftc *isp;
ct_entry_t *ct;
{ {
void *xs; void *xs;
int pl = ISP_LOGTDEBUG2; int pl = ISP_LOGTDEBUG2;
@ -881,7 +855,6 @@ isp_handle_ctio(isp, ct)
if (xs == NULL) if (xs == NULL)
pl = ISP_LOGALL; pl = ISP_LOGALL;
} else { } else {
pl = ISP_LOGTDEBUG1;
xs = NULL; xs = NULL;
} }
@ -966,8 +939,13 @@ isp_handle_ctio(isp, ct)
isp_prt(isp, ISP_LOGERR, "Firmware timed out on %s", fmsg); isp_prt(isp, ISP_LOGERR, "Firmware timed out on %s", fmsg);
break; break;
case CT_PANIC:
if (fmsg == NULL)
fmsg = "Unrecoverable Error";
/*FALLTHROUGH*/
case CT_ERR: case CT_ERR:
fmsg = "Completed with Error"; if (fmsg == NULL)
fmsg = "Completed with Error";
/*FALLTHROUGH*/ /*FALLTHROUGH*/
case CT_PHASE_ERROR: case CT_PHASE_ERROR:
if (fmsg == NULL) if (fmsg == NULL)
@ -1019,35 +997,23 @@ isp_handle_ctio(isp, ct)
ct->ct_syshandle, ct->ct_status & ~QLTM_SVALID); ct->ct_syshandle, ct->ct_status & ~QLTM_SVALID);
} }
} else { } else {
if (ct->ct_flags & CT_SENDSTATUS) {
/*
* Sent status and command complete.
*
* We're now really done with this command, so we
* punt to the platform dependent layers because
* only there can we do the appropriate command
* complete thread synchronization.
*/
isp_prt(isp, pl, "status CTIO complete");
} else {
/* /*
* Final CTIO completed. Release DMA resources and * Final CTIO completed. Release DMA resources and
* notify platform dependent layers. * notify platform dependent layers.
*/ */
isp_prt(isp, pl, "data CTIO complete"); if (ct->ct_flags & CT_DATAMASK) {
ISP_DMAFREE(isp, xs, ct->ct_syshandle); ISP_DMAFREE(isp, xs, ct->ct_syshandle);
} }
(void) isp_async(isp, ISPASYNC_TARGET_ACTION, ct); isp_prt(isp, pl, "final CTIO complete");
/* /*
* The platform layer will destroy the handle if appropriate. * The platform layer will destroy the handle if appropriate.
*/ */
(void) isp_async(isp, ISPASYNC_TARGET_ACTION, ct);
} }
} }
static void static void
isp_handle_ctio2(isp, ct) isp_handle_ctio2(struct ispsoftc *isp, ct2_entry_t *ct)
struct ispsoftc *isp;
ct2_entry_t *ct;
{ {
XS_T *xs; XS_T *xs;
int pl = ISP_LOGTDEBUG2; int pl = ISP_LOGTDEBUG2;
@ -1058,7 +1024,6 @@ isp_handle_ctio2(isp, ct)
if (xs == NULL) if (xs == NULL)
pl = ISP_LOGALL; pl = ISP_LOGALL;
} else { } else {
pl = ISP_LOGTDEBUG1;
xs = NULL; xs = NULL;
} }
@ -1172,7 +1137,7 @@ isp_handle_ctio2(isp, ct)
break; break;
default: default:
isp_prt(isp, ISP_LOGERR, "Unknown CTIO status 0x%x", isp_prt(isp, ISP_LOGERR, "Unknown CTIO2 status 0x%x",
ct->ct_status & ~QLTM_SVALID); ct->ct_status & ~QLTM_SVALID);
break; break;
} }