Lines Matching defs:fsp
149 struct fc_fcp_pkt *fsp;
151 fsp = mempool_alloc(si->scsi_pkt_pool, gfp);
152 if (fsp) {
153 memset(fsp, 0, sizeof(*fsp));
154 fsp->lp = lport;
155 fsp->xfer_ddp = FC_XID_UNKNOWN;
156 atomic_set(&fsp->ref_cnt, 1);
157 init_timer(&fsp->timer);
158 fsp->timer.data = (unsigned long)fsp;
159 INIT_LIST_HEAD(&fsp->list);
160 spin_lock_init(&fsp->scsi_pkt_lock);
165 return fsp;
170 * @fsp: The FCP packet to be released
175 static void fc_fcp_pkt_release(struct fc_fcp_pkt *fsp)
177 if (atomic_dec_and_test(&fsp->ref_cnt)) {
178 struct fc_fcp_internal *si = fc_get_scsi_internal(fsp->lp);
180 mempool_free(fsp, si->scsi_pkt_pool);
186 * @fsp: The FCP packet to be held
188 static void fc_fcp_pkt_hold(struct fc_fcp_pkt *fsp)
190 atomic_inc(&fsp->ref_cnt);
196 * @fsp: The FCP packet to be released
204 static void fc_fcp_pkt_destroy(struct fc_seq *seq, void *fsp)
206 fc_fcp_pkt_release(fsp);
211 * @fsp: The FCP packet to be locked and incremented
223 * have a function that they call to verify the fsp and grab a ref if
226 static inline int fc_fcp_lock_pkt(struct fc_fcp_pkt *fsp)
228 spin_lock_bh(&fsp->scsi_pkt_lock);
229 if (fsp->state & FC_SRB_COMPL) {
230 spin_unlock_bh(&fsp->scsi_pkt_lock);
234 fc_fcp_pkt_hold(fsp);
241 * @fsp: The FCP packet to be unlocked and decremented
243 static inline void fc_fcp_unlock_pkt(struct fc_fcp_pkt *fsp)
245 spin_unlock_bh(&fsp->scsi_pkt_lock);
246 fc_fcp_pkt_release(fsp);
251 * @fsp: The FCP packet to start a timer for
254 static void fc_fcp_timer_set(struct fc_fcp_pkt *fsp, unsigned long delay)
256 if (!(fsp->state & FC_SRB_COMPL))
257 mod_timer(&fsp->timer, jiffies + delay);
263 * @fsp: The FCP packet to abort exchanges on
265 static int fc_fcp_send_abort(struct fc_fcp_pkt *fsp)
267 if (!fsp->seq_ptr)
270 per_cpu_ptr(fsp->lp->stats, get_cpu())->FcpPktAborts++;
273 fsp->state |= FC_SRB_ABORT_PENDING;
274 return fsp->lp->tt.seq_exch_abort(fsp->seq_ptr, 0);
279 * @fsp: The FCP packet to be retried
286 static void fc_fcp_retry_cmd(struct fc_fcp_pkt *fsp)
288 if (fsp->seq_ptr) {
289 fsp->lp->tt.exch_done(fsp->seq_ptr);
290 fsp->seq_ptr = NULL;
293 fsp->state &= ~FC_SRB_ABORT_PENDING;
294 fsp->io_status = 0;
295 fsp->status_code = FC_ERROR;
296 fc_fcp_complete_locked(fsp);
301 * @fsp: The FCP packet that will manage the DDP frames
304 void fc_fcp_ddp_setup(struct fc_fcp_pkt *fsp, u16 xid)
308 lport = fsp->lp;
309 if ((fsp->req_flags & FC_SRB_READ) &&
311 if (lport->tt.ddp_setup(lport, xid, scsi_sglist(fsp->cmd),
312 scsi_sg_count(fsp->cmd)))
313 fsp->xfer_ddp = xid;
320 * @fsp: The FCP packet that DDP had been used on
322 void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp)
326 if (!fsp)
329 if (fsp->xfer_ddp == FC_XID_UNKNOWN)
332 lport = fsp->lp;
334 fsp->xfer_len = lport->tt.ddp_done(lport, fsp->xfer_ddp);
335 fsp->xfer_ddp = FC_XID_UNKNOWN;
438 * @fsp: The FCP packet the data is on
441 static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
443 struct scsi_cmnd *sc = fsp->cmd;
444 struct fc_lport *lport = fsp->lp;
470 if (fsp->xfer_ddp != FC_XID_UNKNOWN) {
471 fc_fcp_ddp_done(fsp);
472 FC_FCP_DBG(fsp, "DDP I/O in fc_fcp_recv_data set ERROR\n");
476 if (offset + len > fsp->data_len) {
481 FC_FCP_DBG(fsp, "data received past end. len %zx offset %zx "
482 "data_len %x\n", len, offset, fsp->data_len);
488 if (offset != fsp->xfer_len)
489 fsp->state |= FC_SRB_DISCONTIG;
522 if (fsp->state & FC_SRB_DISCONTIG) {
530 if (fsp->xfer_contig_end == start_offset)
531 fsp->xfer_contig_end += copy_len;
532 fsp->xfer_len += copy_len;
538 if (unlikely(fsp->state & FC_SRB_RCV_STATUS) &&
539 fsp->xfer_len == fsp->data_len - fsp->scsi_resid)
540 fc_fcp_complete_locked(fsp);
543 fc_fcp_recovery(fsp, host_bcode);
548 * @fsp: The FCP packet the data is on
559 static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
566 struct fc_lport *lport = fsp->lp;
581 if (unlikely(offset + seq_blen > fsp->data_len)) {
583 FC_FCP_DBG(fsp, "xfer-ready past end. seq_blen %zx "
585 fc_fcp_send_abort(fsp);
587 } else if (offset != fsp->xfer_len) {
589 FC_FCP_DBG(fsp, "xfer-ready non-contiguous. "
596 * to max FC frame payload previously set in fsp->max_payload.
598 t_blen = fsp->max_payload;
601 FC_FCP_DBG(fsp, "fsp=%p:lso:blen=%zx lso_max=0x%x t_blen=%zx\n",
602 fsp, seq_blen, lport->lso_max, t_blen);
607 sc = fsp->cmd;
640 fr_max_payload(fp) = fsp->max_payload;
697 fsp->xfer_len += seq_blen; /* premature count? */
703 * @fsp: The FCP packet that is being aborted
706 static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
731 fsp->state |= FC_SRB_ABORTED;
732 fsp->state &= ~FC_SRB_ABORT_PENDING;
734 if (fsp->wait_for_comp)
735 complete(&fsp->tm_done);
737 fc_fcp_complete_locked(fsp);
752 struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)arg;
753 struct fc_lport *lport = fsp->lp;
760 fc_fcp_error(fsp, fp);
769 if (fc_fcp_lock_pkt(fsp))
773 fc_fcp_abts_resp(fsp, fp);
777 if (fsp->state & (FC_SRB_ABORTED | FC_SRB_ABORT_PENDING))
789 rc = fc_fcp_send_data(fsp, seq,
793 seq->rec_data = fsp->xfer_len;
800 fc_fcp_recv_data(fsp, fp);
801 seq->rec_data = fsp->xfer_contig_end;
805 fc_fcp_resp(fsp, fp);
807 FC_FCP_DBG(fsp, "unexpected frame. r_ctl %x\n", r_ctl);
810 fc_fcp_unlock_pkt(fsp);
817 * @fsp: The FCP packet the response is for
820 static void fc_fcp_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
838 fsp->cdb_status = fc_rp->fr_status;
840 fsp->scsi_comp_flags = flags;
841 expected_len = fsp->data_len;
844 fc_fcp_ddp_done(fsp);
857 if (fsp->wait_for_comp) {
859 fsp->cdb_status = fc_rp_info->rsp_code;
860 complete(&fsp->tm_done);
872 memcpy(fsp->cmd->sense_buffer,
880 fsp->scsi_resid = ntohl(rp_ex->fr_resid);
891 (scsi_bufflen(fsp->cmd) -
892 fsp->scsi_resid) < fsp->cmd->underflow)
894 expected_len -= fsp->scsi_resid;
896 fsp->status_code = FC_ERROR;
900 fsp->state |= FC_SRB_RCV_STATUS;
905 if (unlikely(fsp->cdb_status == SAM_STAT_GOOD &&
906 fsp->xfer_len != expected_len)) {
907 if (fsp->xfer_len < expected_len) {
913 fc_fcp_timer_set(fsp, 2);
916 fsp->status_code = FC_DATA_OVRRUN;
917 FC_FCP_DBG(fsp, "tgt %6.6x xfer len %zx greater than expected, "
919 fsp->rport->port_id,
920 fsp->xfer_len, expected_len, fsp->data_len);
922 fc_fcp_complete_locked(fsp);
926 FC_FCP_DBG(fsp, "short FCP response. flags 0x%x len %u respl %u "
929 fsp->status_code = FC_ERROR;
930 fc_fcp_complete_locked(fsp);
936 * @fsp: The FCP packet to be completed
941 static void fc_fcp_complete_locked(struct fc_fcp_pkt *fsp)
943 struct fc_lport *lport = fsp->lp;
948 if (fsp->state & FC_SRB_ABORT_PENDING)
951 if (fsp->state & FC_SRB_ABORTED) {
952 if (!fsp->status_code)
953 fsp->status_code = FC_CMD_ABORTED;
959 if (fsp->cdb_status == SAM_STAT_GOOD &&
960 fsp->xfer_len < fsp->data_len && !fsp->io_status &&
961 (!(fsp->scsi_comp_flags & FCP_RESID_UNDER) ||
962 fsp->xfer_len < fsp->data_len - fsp->scsi_resid))
963 fsp->status_code = FC_DATA_UNDRUN;
966 seq = fsp->seq_ptr;
968 fsp->seq_ptr = NULL;
969 if (unlikely(fsp->scsi_comp_flags & FCP_CONF_REQ)) {
974 conf_frame = fc_fcp_frame_alloc(fsp->lp, 0);
992 if (fsp->cmd)
993 fc_io_compl(fsp);
998 * @fsp: The FCP packet whose exchanges should be canceled
1001 static void fc_fcp_cleanup_cmd(struct fc_fcp_pkt *fsp, int error)
1003 struct fc_lport *lport = fsp->lp;
1005 if (fsp->seq_ptr) {
1006 lport->tt.exch_done(fsp->seq_ptr);
1007 fsp->seq_ptr = NULL;
1009 fsp->status_code = error;
1025 struct fc_fcp_pkt *fsp;
1031 list_for_each_entry(fsp, &si->scsi_pkt_queue, list) {
1032 sc_cmd = fsp->cmd;
1039 fc_fcp_pkt_hold(fsp);
1042 if (!fc_fcp_lock_pkt(fsp)) {
1043 fc_fcp_cleanup_cmd(fsp, error);
1044 fc_io_compl(fsp);
1045 fc_fcp_unlock_pkt(fsp);
1048 fc_fcp_pkt_release(fsp);
1071 * @fsp: The FCP packet to send
1076 static int fc_fcp_pkt_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp)
1082 fsp->cmd->SCp.ptr = (char *)fsp;
1083 fsp->cdb_cmd.fc_dl = htonl(fsp->data_len);
1084 fsp->cdb_cmd.fc_flags = fsp->req_flags & ~FCP_CFL_LEN_MASK;
1086 int_to_scsilun(fsp->cmd->device->lun, &fsp->cdb_cmd.fc_lun);
1087 memcpy(fsp->cdb_cmd.fc_cdb, fsp->cmd->cmnd, fsp->cmd->cmd_len);
1090 list_add_tail(&fsp->list, &si->scsi_pkt_queue);
1092 rc = lport->tt.fcp_cmd_send(lport, fsp, fc_fcp_recv);
1095 fsp->cmd->SCp.ptr = NULL;
1096 list_del(&fsp->list);
1105 * @fsp: the FCP packet
1109 static inline unsigned int get_fsp_rec_tov(struct fc_fcp_pkt *fsp)
1111 struct fc_rport_libfc_priv *rpriv = fsp->rport->dd_data;
1119 * @fsp: The FCP packet the command is on
1122 static int fc_fcp_cmd_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
1131 const size_t len = sizeof(fsp->cdb_cmd);
1134 if (fc_fcp_lock_pkt(fsp))
1137 fp = fc_fcp_frame_alloc(lport, sizeof(fsp->cdb_cmd));
1143 memcpy(fc_frame_payload_get(fp, len), &fsp->cdb_cmd, len);
1144 fr_fsp(fp) = fsp;
1145 rport = fsp->rport;
1146 fsp->max_payload = rport->maxframe_size;
1154 fsp, 0);
1159 fsp->seq_ptr = seq;
1160 fc_fcp_pkt_hold(fsp); /* hold for fc_fcp_pkt_destroy */
1162 setup_timer(&fsp->timer, fc_fcp_timeout, (unsigned long)fsp);
1164 fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1167 fc_fcp_unlock_pkt(fsp);
1173 * @fsp: The FCP packet the error is on
1176 static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1180 if (fc_fcp_lock_pkt(fsp))
1184 fc_fcp_retry_cmd(fsp);
1192 fsp->state &= ~FC_SRB_ABORT_PENDING;
1193 fsp->status_code = FC_CMD_PLOGO;
1194 fc_fcp_complete_locked(fsp);
1196 fc_fcp_unlock_pkt(fsp);
1201 * @fsp: The FCP packet to abort on
1205 static int fc_fcp_pkt_abort(struct fc_fcp_pkt *fsp)
1210 if (fc_fcp_send_abort(fsp))
1213 init_completion(&fsp->tm_done);
1214 fsp->wait_for_comp = 1;
1216 spin_unlock_bh(&fsp->scsi_pkt_lock);
1217 ticks_left = wait_for_completion_timeout(&fsp->tm_done,
1219 spin_lock_bh(&fsp->scsi_pkt_lock);
1220 fsp->wait_for_comp = 0;
1223 FC_FCP_DBG(fsp, "target abort cmd failed\n");
1224 } else if (fsp->state & FC_SRB_ABORTED) {
1225 FC_FCP_DBG(fsp, "target abort cmd passed\n");
1227 fc_fcp_complete_locked(fsp);
1239 struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
1240 struct fc_lport *lport = fsp->lp;
1242 if (lport->tt.fcp_cmd_send(lport, fsp, fc_tm_done)) {
1243 if (fsp->recov_retry++ >= FC_MAX_RECOV_RETRY)
1245 if (fc_fcp_lock_pkt(fsp))
1247 setup_timer(&fsp->timer, fc_lun_reset_send, (unsigned long)fsp);
1248 fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1249 fc_fcp_unlock_pkt(fsp);
1257 * @fsp: The FCP packet that identifies the LUN to be reset
1261 static int fc_lun_reset(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
1266 fsp->cdb_cmd.fc_dl = htonl(fsp->data_len);
1267 fsp->cdb_cmd.fc_tm_flags = FCP_TMF_LUN_RESET;
1268 int_to_scsilun(lun, &fsp->cdb_cmd.fc_lun);
1270 fsp->wait_for_comp = 1;
1271 init_completion(&fsp->tm_done);
1273 fc_lun_reset_send((unsigned long)fsp);
1279 rc = wait_for_completion_timeout(&fsp->tm_done, FC_SCSI_TM_TOV);
1281 spin_lock_bh(&fsp->scsi_pkt_lock);
1282 fsp->state |= FC_SRB_COMPL;
1283 spin_unlock_bh(&fsp->scsi_pkt_lock);
1285 del_timer_sync(&fsp->timer);
1287 spin_lock_bh(&fsp->scsi_pkt_lock);
1288 if (fsp->seq_ptr) {
1289 lport->tt.exch_done(fsp->seq_ptr);
1290 fsp->seq_ptr = NULL;
1292 fsp->wait_for_comp = 0;
1293 spin_unlock_bh(&fsp->scsi_pkt_lock);
1301 if (fsp->cdb_status != FCP_TMF_CMPL)
1317 struct fc_fcp_pkt *fsp = arg;
1330 if (fc_fcp_lock_pkt(fsp))
1336 if (!fsp->seq_ptr || !fsp->wait_for_comp)
1341 fc_fcp_resp(fsp, fp);
1342 fsp->seq_ptr = NULL;
1343 fsp->lp->tt.exch_done(seq);
1345 fc_fcp_unlock_pkt(fsp);
1372 struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
1373 struct fc_rport *rport = fsp->rport;
1376 if (fc_fcp_lock_pkt(fsp))
1379 if (fsp->cdb_cmd.fc_tm_flags)
1382 fsp->state |= FC_SRB_FCP_PROCESSING_TMO;
1385 fc_fcp_rec(fsp);
1386 else if (fsp->state & FC_SRB_RCV_STATUS)
1387 fc_fcp_complete_locked(fsp);
1389 fc_fcp_recovery(fsp, FC_TIMED_OUT);
1390 fsp->state &= ~FC_SRB_FCP_PROCESSING_TMO;
1392 fc_fcp_unlock_pkt(fsp);
1397 * @fsp: The FCP packet to send the REC request on
1399 static void fc_fcp_rec(struct fc_fcp_pkt *fsp)
1406 lport = fsp->lp;
1407 rport = fsp->rport;
1409 if (!fsp->seq_ptr || rpriv->rp_state != RPORT_ST_READY) {
1410 fsp->status_code = FC_HRD_ERROR;
1411 fsp->io_status = 0;
1412 fc_fcp_complete_locked(fsp);
1420 fr_seq(fp) = fsp->seq_ptr;
1425 fc_fcp_rec_resp, fsp,
1427 fc_fcp_pkt_hold(fsp); /* hold while REC outstanding */
1431 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1432 fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1434 fc_fcp_recovery(fsp, FC_TIMED_OUT);
1450 struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)arg;
1461 fc_fcp_rec_error(fsp, fp);
1465 if (fc_fcp_lock_pkt(fsp))
1468 fsp->recov_retry = 0;
1474 FC_FCP_DBG(fsp, "device %x unexpected REC reject "
1476 fsp->rport->port_id, rjt->er_reason,
1480 FC_FCP_DBG(fsp, "device does not support REC\n");
1481 rpriv = fsp->rport->dd_data;
1498 fsp->xfer_len == 0) {
1499 fc_fcp_retry_cmd(fsp);
1502 fc_fcp_recovery(fsp, FC_ERROR);
1506 if (fsp->state & FC_SRB_ABORTED)
1509 data_dir = fsp->cmd->sc_data_direction;
1532 } else if (fsp->xfer_contig_end == offset) {
1535 offset = fsp->xfer_contig_end;
1538 fc_fcp_srr(fsp, r_ctl, offset);
1544 fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1565 if (offset < fsp->data_len)
1567 } else if (offset == fsp->xfer_contig_end) {
1569 } else if (fsp->xfer_contig_end < offset) {
1570 offset = fsp->xfer_contig_end;
1572 fc_fcp_srr(fsp, r_ctl, offset);
1576 fc_fcp_unlock_pkt(fsp);
1578 fc_fcp_pkt_release(fsp); /* drop hold for outstanding REC */
1584 * @fsp: The FCP packet the error is on
1587 static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1591 if (fc_fcp_lock_pkt(fsp))
1596 fc_fcp_retry_cmd(fsp);
1600 FC_FCP_DBG(fsp, "REC %p fid %6.6x error unexpected error %d\n",
1601 fsp, fsp->rport->port_id, error);
1602 fsp->status_code = FC_CMD_PLOGO;
1610 FC_FCP_DBG(fsp, "REC fid %6.6x error error %d retry %d/%d\n",
1611 fsp->rport->port_id, error, fsp->recov_retry,
1613 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1614 fc_fcp_rec(fsp);
1616 fc_fcp_recovery(fsp, FC_ERROR);
1619 fc_fcp_unlock_pkt(fsp);
1621 fc_fcp_pkt_release(fsp); /* drop hold for outstanding REC */
1626 * @fsp: The FCP pkt that needs to be aborted
1628 static void fc_fcp_recovery(struct fc_fcp_pkt *fsp, u8 code)
1630 fsp->status_code = code;
1631 fsp->cdb_status = 0;
1632 fsp->io_status = 0;
1637 fc_fcp_send_abort(fsp);
1642 * @fsp: The FCP packet the SRR is to be sent on
1647 static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
1649 struct fc_lport *lport = fsp->lp;
1652 struct fc_exch *ep = fc_seq_exch(fsp->seq_ptr);
1658 rport = fsp->rport;
1680 rec_tov = get_fsp_rec_tov(fsp);
1683 fsp, jiffies_to_msecs(rec_tov));
1687 fsp->recov_seq = seq;
1688 fsp->xfer_len = offset;
1689 fsp->xfer_contig_end = offset;
1690 fsp->state &= ~FC_SRB_RCV_STATUS;
1691 fc_fcp_pkt_hold(fsp); /* hold for outstanding SRR */
1694 fc_fcp_retry_cmd(fsp);
1705 struct fc_fcp_pkt *fsp = arg;
1709 fc_fcp_srr_error(fsp, fp);
1713 if (fc_fcp_lock_pkt(fsp))
1725 fc_fcp_unlock_pkt(fsp);
1731 fsp->recov_retry = 0;
1732 fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1736 fc_fcp_recovery(fsp, FC_ERROR);
1739 fc_fcp_unlock_pkt(fsp);
1741 fsp->lp->tt.exch_done(seq);
1747 * @fsp: The FCP packet that the SRR error is on
1750 static void fc_fcp_srr_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1752 if (fc_fcp_lock_pkt(fsp))
1756 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1757 fc_fcp_rec(fsp);
1759 fc_fcp_recovery(fsp, FC_TIMED_OUT);
1764 fc_fcp_retry_cmd(fsp);
1767 fc_fcp_unlock_pkt(fsp);
1769 fsp->lp->tt.exch_done(fsp->recov_seq);
1794 struct fc_fcp_pkt *fsp;
1826 fsp = fc_fcp_pkt_alloc(lport, GFP_ATOMIC);
1827 if (fsp == NULL) {
1835 fsp->cmd = sc_cmd; /* save the cmd */
1836 fsp->rport = rport; /* set the remote port ptr */
1841 fsp->data_len = scsi_bufflen(sc_cmd);
1842 fsp->xfer_len = 0;
1849 fsp->req_flags = FC_SRB_READ;
1851 stats->InputBytes += fsp->data_len;
1853 fsp->req_flags = FC_SRB_WRITE;
1855 stats->OutputBytes += fsp->data_len;
1857 fsp->req_flags = 0;
1867 rval = fc_fcp_pkt_send(lport, fsp);
1869 fsp->state = FC_SRB_FREE;
1870 fc_fcp_pkt_release(fsp);
1880 * @fsp: The FCP packet that is complete
1885 static void fc_io_compl(struct fc_fcp_pkt *fsp)
1893 fc_fcp_ddp_done(fsp);
1895 fsp->state |= FC_SRB_COMPL;
1896 if (!(fsp->state & FC_SRB_FCP_PROCESSING_TMO)) {
1897 spin_unlock_bh(&fsp->scsi_pkt_lock);
1898 del_timer_sync(&fsp->timer);
1899 spin_lock_bh(&fsp->scsi_pkt_lock);
1902 lport = fsp->lp;
1912 sc_cmd = fsp->cmd;
1913 CMD_SCSI_STATUS(sc_cmd) = fsp->cdb_status;
1914 switch (fsp->status_code) {
1916 if (fsp->cdb_status == 0) {
1921 if (fsp->scsi_resid)
1922 CMD_RESID_LEN(sc_cmd) = fsp->scsi_resid;
1928 sc_cmd->result = (DID_OK << 16) | fsp->cdb_status;
1932 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
1937 if ((fsp->cdb_status == 0) && !(fsp->req_flags & FC_SRB_READ)) {
1942 if (fsp->state & FC_SRB_RCV_STATUS) {
1945 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml"
1953 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
1955 CMD_RESID_LEN(sc_cmd) = fsp->scsi_resid;
1956 sc_cmd->result = (DID_ERROR << 16) | fsp->cdb_status;
1963 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
1965 sc_cmd->result = (DID_ERROR << 16) | fsp->cdb_status;
1968 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
1970 sc_cmd->result = (DID_ERROR << 16) | fsp->io_status;
1973 FC_FCP_DBG(fsp, "Returning DID_RESET to scsi-ml "
1978 FC_FCP_DBG(fsp, "Returning DID_NO_CONNECT to scsi-ml "
1983 FC_FCP_DBG(fsp, "Returning DID_PARITY to scsi-ml "
1988 FC_FCP_DBG(fsp, "Returning DID_BUS_BUSY to scsi-ml "
1990 sc_cmd->result = (DID_BUS_BUSY << 16) | fsp->io_status;
1993 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
1999 if (lport->state != LPORT_ST_READY && fsp->status_code != FC_COMPLETE)
2003 list_del(&fsp->list);
2009 fc_fcp_pkt_release(fsp);
2021 struct fc_fcp_pkt *fsp;
2040 fsp = CMD_SP(sc_cmd);
2041 if (!fsp) {
2046 /* grab a ref so the fsp and sc_cmd cannot be released from under us */
2047 fc_fcp_pkt_hold(fsp);
2050 if (fc_fcp_lock_pkt(fsp)) {
2056 rc = fc_fcp_pkt_abort(fsp);
2057 fc_fcp_unlock_pkt(fsp);
2060 fc_fcp_pkt_release(fsp);
2075 struct fc_fcp_pkt *fsp;
2091 fsp = fc_fcp_pkt_alloc(lport, GFP_NOIO);
2092 if (fsp == NULL) {
2102 fsp->rport = rport; /* set the remote port ptr */
2107 rc = fc_lun_reset(lport, fsp, scmd_id(sc_cmd), sc_cmd->device->lun);
2108 fsp->state = FC_SRB_FREE;
2109 fc_fcp_pkt_release(fsp);