Lines Matching refs:fsp
134 struct fc_fcp_pkt *fsp;
136 fsp = mempool_alloc(si->scsi_pkt_pool, gfp);
137 if (fsp) {
138 memset(fsp, 0, sizeof(*fsp));
139 fsp->lp = lport;
140 fsp->xfer_ddp = FC_XID_UNKNOWN;
141 refcount_set(&fsp->ref_cnt, 1);
142 timer_setup(&fsp->timer, NULL, 0);
143 INIT_LIST_HEAD(&fsp->list);
144 spin_lock_init(&fsp->scsi_pkt_lock);
148 return fsp;
153 * @fsp: The FCP packet to be released
158 static void fc_fcp_pkt_release(struct fc_fcp_pkt *fsp)
160 if (refcount_dec_and_test(&fsp->ref_cnt)) {
161 struct fc_fcp_internal *si = fc_get_scsi_internal(fsp->lp);
163 mempool_free(fsp, si->scsi_pkt_pool);
169 * @fsp: The FCP packet to be held
171 static void fc_fcp_pkt_hold(struct fc_fcp_pkt *fsp)
173 refcount_inc(&fsp->ref_cnt);
179 * @fsp: The FCP packet to be released
187 static void fc_fcp_pkt_destroy(struct fc_seq *seq, void *fsp)
189 fc_fcp_pkt_release(fsp);
194 * @fsp: The FCP packet to be locked and incremented
206 * have a function that they call to verify the fsp and grab a ref if
209 static inline int fc_fcp_lock_pkt(struct fc_fcp_pkt *fsp)
211 spin_lock_bh(&fsp->scsi_pkt_lock);
212 if (fsp->state & FC_SRB_COMPL) {
213 spin_unlock_bh(&fsp->scsi_pkt_lock);
217 fc_fcp_pkt_hold(fsp);
224 * @fsp: The FCP packet to be unlocked and decremented
226 static inline void fc_fcp_unlock_pkt(struct fc_fcp_pkt *fsp)
228 spin_unlock_bh(&fsp->scsi_pkt_lock);
229 fc_fcp_pkt_release(fsp);
234 * @fsp: The FCP packet to start a timer for
237 static void fc_fcp_timer_set(struct fc_fcp_pkt *fsp, unsigned long delay)
239 if (!(fsp->state & FC_SRB_COMPL)) {
240 mod_timer(&fsp->timer, jiffies + delay);
241 fsp->timer_delay = delay;
245 static void fc_fcp_abort_done(struct fc_fcp_pkt *fsp)
247 fsp->state |= FC_SRB_ABORTED;
248 fsp->state &= ~FC_SRB_ABORT_PENDING;
250 if (fsp->wait_for_comp)
251 complete(&fsp->tm_done);
253 fc_fcp_complete_locked(fsp);
259 * @fsp: The FCP packet to abort exchanges on
261 static int fc_fcp_send_abort(struct fc_fcp_pkt *fsp)
265 if (!fsp->seq_ptr)
268 if (fsp->state & FC_SRB_ABORT_PENDING) {
269 FC_FCP_DBG(fsp, "abort already pending\n");
273 this_cpu_inc(fsp->lp->stats->FcpPktAborts);
275 fsp->state |= FC_SRB_ABORT_PENDING;
276 rc = fc_seq_exch_abort(fsp->seq_ptr, 0);
282 fc_fcp_abort_done(fsp);
290 * @fsp: The FCP packet to be retried
298 static void fc_fcp_retry_cmd(struct fc_fcp_pkt *fsp, int status_code)
300 if (fsp->seq_ptr) {
301 fc_exch_done(fsp->seq_ptr);
302 fsp->seq_ptr = NULL;
305 fsp->state &= ~FC_SRB_ABORT_PENDING;
306 fsp->io_status = 0;
307 fsp->status_code = status_code;
308 fc_fcp_complete_locked(fsp);
313 * @fsp: The FCP packet that will manage the DDP frames
316 void fc_fcp_ddp_setup(struct fc_fcp_pkt *fsp, u16 xid)
320 lport = fsp->lp;
321 if ((fsp->req_flags & FC_SRB_READ) &&
323 if (lport->tt.ddp_setup(lport, xid, scsi_sglist(fsp->cmd),
324 scsi_sg_count(fsp->cmd)))
325 fsp->xfer_ddp = xid;
332 * @fsp: The FCP packet that DDP had been used on
334 void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp)
338 if (!fsp)
341 if (fsp->xfer_ddp == FC_XID_UNKNOWN)
344 lport = fsp->lp;
346 fsp->xfer_len = lport->tt.ddp_done(lport, fsp->xfer_ddp);
347 fsp->xfer_ddp = FC_XID_UNKNOWN;
453 * @fsp: the FCP packet
457 static inline unsigned int get_fsp_rec_tov(struct fc_fcp_pkt *fsp)
459 struct fc_rport_libfc_priv *rpriv = fsp->rport->dd_data;
469 * @fsp: The FCP packet the data is on
472 static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
474 struct scsi_cmnd *sc = fsp->cmd;
475 struct fc_lport *lport = fsp->lp;
500 if (fsp->xfer_ddp != FC_XID_UNKNOWN) {
501 fc_fcp_ddp_done(fsp);
502 FC_FCP_DBG(fsp, "DDP I/O in fc_fcp_recv_data set ERROR\n");
506 if (offset + len > fsp->data_len) {
511 FC_FCP_DBG(fsp, "data received past end. len %zx offset %zx "
512 "data_len %x\n", len, offset, fsp->data_len);
518 if (offset != fsp->xfer_len)
519 fsp->state |= FC_SRB_DISCONTIG;
550 if (fsp->state & FC_SRB_DISCONTIG) {
558 if (fsp->xfer_contig_end == start_offset)
559 fsp->xfer_contig_end += copy_len;
560 fsp->xfer_len += copy_len;
566 if (unlikely(fsp->state & FC_SRB_RCV_STATUS) &&
567 fsp->xfer_len == fsp->data_len - fsp->scsi_resid) {
568 FC_FCP_DBG( fsp, "complete out-of-order sequence\n" );
569 fc_fcp_complete_locked(fsp);
573 fc_fcp_recovery(fsp, host_bcode);
578 * @fsp: The FCP packet the data is on
589 static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
596 struct fc_lport *lport = fsp->lp;
611 if (unlikely(offset + seq_blen > fsp->data_len)) {
613 FC_FCP_DBG(fsp, "xfer-ready past end. seq_blen %zx "
615 fc_fcp_send_abort(fsp);
617 } else if (offset != fsp->xfer_len) {
619 FC_FCP_DBG(fsp, "xfer-ready non-contiguous. "
626 * to max FC frame payload previously set in fsp->max_payload.
628 t_blen = fsp->max_payload;
631 FC_FCP_DBG(fsp, "fsp=%p:lso:blen=%zx lso_max=0x%x t_blen=%zx\n",
632 fsp, seq_blen, lport->lso_max, t_blen);
637 sc = fsp->cmd;
670 fr_max_payload(fp) = fsp->max_payload;
727 fsp->xfer_len += seq_blen; /* premature count? */
733 * @fsp: The FCP packet that is being aborted
736 static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
761 fc_fcp_abort_done(fsp);
775 struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)arg;
776 struct fc_lport *lport = fsp->lp;
783 fc_fcp_error(fsp, fp);
791 FC_FCP_DBG(fsp, "lport state %d, ignoring r_ctl %x\n",
795 if (fc_fcp_lock_pkt(fsp))
799 fc_fcp_abts_resp(fsp, fp);
803 if (fsp->state & (FC_SRB_ABORTED | FC_SRB_ABORT_PENDING)) {
804 FC_FCP_DBG(fsp, "command aborted, ignoring r_ctl %x\n", r_ctl);
817 rc = fc_fcp_send_data(fsp, seq,
821 seq->rec_data = fsp->xfer_len;
828 fc_fcp_recv_data(fsp, fp);
829 seq->rec_data = fsp->xfer_contig_end;
833 fc_fcp_resp(fsp, fp);
835 FC_FCP_DBG(fsp, "unexpected frame. r_ctl %x\n", r_ctl);
838 fc_fcp_unlock_pkt(fsp);
845 * @fsp: The FCP packet the response is for
848 static void fc_fcp_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
866 fsp->cdb_status = fc_rp->fr_status;
868 fsp->scsi_comp_flags = flags;
869 expected_len = fsp->data_len;
872 fc_fcp_ddp_done(fsp);
885 if (fsp->wait_for_comp) {
887 fsp->cdb_status = fc_rp_info->rsp_code;
888 complete(&fsp->tm_done);
900 memcpy(fsp->cmd->sense_buffer,
908 fsp->scsi_resid = ntohl(rp_ex->fr_resid);
919 (scsi_bufflen(fsp->cmd) -
920 fsp->scsi_resid) < fsp->cmd->underflow)
922 expected_len -= fsp->scsi_resid;
924 fsp->status_code = FC_ERROR;
928 fsp->state |= FC_SRB_RCV_STATUS;
933 if (unlikely(fsp->cdb_status == SAM_STAT_GOOD &&
934 fsp->xfer_len != expected_len)) {
935 if (fsp->xfer_len < expected_len) {
941 if (fsp->lp->qfull) {
942 FC_FCP_DBG(fsp, "tgt %6.6x queue busy retry\n",
943 fsp->rport->port_id);
946 FC_FCP_DBG(fsp, "tgt %6.6x xfer len %zx data underrun "
948 fsp->rport->port_id,
949 fsp->xfer_len, expected_len, fsp->data_len);
950 fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
953 fsp->status_code = FC_DATA_OVRRUN;
954 FC_FCP_DBG(fsp, "tgt %6.6x xfer len %zx greater than expected, "
956 fsp->rport->port_id,
957 fsp->xfer_len, expected_len, fsp->data_len);
959 fc_fcp_complete_locked(fsp);
963 FC_FCP_DBG(fsp, "short FCP response. flags 0x%x len %u respl %u "
966 fsp->status_code = FC_ERROR;
967 fc_fcp_complete_locked(fsp);
973 * @fsp: The FCP packet to be completed
978 static void fc_fcp_complete_locked(struct fc_fcp_pkt *fsp)
980 struct fc_lport *lport = fsp->lp;
985 if (fsp->state & FC_SRB_ABORT_PENDING)
988 if (fsp->state & FC_SRB_ABORTED) {
989 if (!fsp->status_code)
990 fsp->status_code = FC_CMD_ABORTED;
996 if (fsp->cdb_status == SAM_STAT_GOOD &&
997 fsp->xfer_len < fsp->data_len && !fsp->io_status &&
998 (!(fsp->scsi_comp_flags & FCP_RESID_UNDER) ||
999 fsp->xfer_len < fsp->data_len - fsp->scsi_resid)) {
1000 FC_FCP_DBG(fsp, "data underrun, xfer %zx data %x\n",
1001 fsp->xfer_len, fsp->data_len);
1002 fsp->status_code = FC_DATA_UNDRUN;
1006 seq = fsp->seq_ptr;
1008 fsp->seq_ptr = NULL;
1009 if (unlikely(fsp->scsi_comp_flags & FCP_CONF_REQ)) {
1014 conf_frame = fc_fcp_frame_alloc(fsp->lp, 0);
1032 if (fsp->cmd)
1033 fc_io_compl(fsp);
1038 * @fsp: The FCP packet whose exchanges should be canceled
1041 static void fc_fcp_cleanup_cmd(struct fc_fcp_pkt *fsp, int error)
1043 if (fsp->seq_ptr) {
1044 fc_exch_done(fsp->seq_ptr);
1045 fsp->seq_ptr = NULL;
1047 fsp->status_code = error;
1063 struct fc_fcp_pkt *fsp;
1069 list_for_each_entry(fsp, &si->scsi_pkt_queue, list) {
1070 sc_cmd = fsp->cmd;
1077 fc_fcp_pkt_hold(fsp);
1080 spin_lock_bh(&fsp->scsi_pkt_lock);
1081 if (!(fsp->state & FC_SRB_COMPL)) {
1082 fsp->state |= FC_SRB_COMPL;
1092 spin_unlock_bh(&fsp->scsi_pkt_lock);
1094 fc_fcp_cleanup_cmd(fsp, error);
1096 spin_lock_bh(&fsp->scsi_pkt_lock);
1097 fc_io_compl(fsp);
1099 spin_unlock_bh(&fsp->scsi_pkt_lock);
1101 fc_fcp_pkt_release(fsp);
1124 * @fsp: The FCP packet to send
1129 static int fc_fcp_pkt_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp)
1135 libfc_priv(fsp->cmd)->fsp = fsp;
1136 fsp->cdb_cmd.fc_dl = htonl(fsp->data_len);
1137 fsp->cdb_cmd.fc_flags = fsp->req_flags & ~FCP_CFL_LEN_MASK;
1139 int_to_scsilun(fsp->cmd->device->lun, &fsp->cdb_cmd.fc_lun);
1140 memcpy(fsp->cdb_cmd.fc_cdb, fsp->cmd->cmnd, fsp->cmd->cmd_len);
1143 list_add_tail(&fsp->list, &si->scsi_pkt_queue);
1145 rc = lport->tt.fcp_cmd_send(lport, fsp, fc_fcp_recv);
1148 libfc_priv(fsp->cmd)->fsp = NULL;
1149 list_del(&fsp->list);
1159 * @fsp: The FCP packet the command is on
1162 static int fc_fcp_cmd_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
1171 const size_t len = sizeof(fsp->cdb_cmd);
1174 if (fc_fcp_lock_pkt(fsp))
1177 fp = fc_fcp_frame_alloc(lport, sizeof(fsp->cdb_cmd));
1183 memcpy(fc_frame_payload_get(fp, len), &fsp->cdb_cmd, len);
1184 fr_fsp(fp) = fsp;
1185 rport = fsp->rport;
1186 fsp->max_payload = rport->maxframe_size;
1193 seq = fc_exch_seq_send(lport, fp, resp, fc_fcp_pkt_destroy, fsp, 0);
1198 fsp->seq_ptr = seq;
1199 fc_fcp_pkt_hold(fsp); /* hold for fc_fcp_pkt_destroy */
1201 fsp->timer.function = fc_fcp_timeout;
1203 fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1206 fc_fcp_unlock_pkt(fsp);
1212 * @fsp: The FCP packet the error is on
1215 static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1219 if (fc_fcp_lock_pkt(fsp))
1223 fc_fcp_retry_cmd(fsp, FC_ERROR);
1231 fsp->state &= ~FC_SRB_ABORT_PENDING;
1232 fsp->status_code = FC_CMD_PLOGO;
1233 fc_fcp_complete_locked(fsp);
1235 fc_fcp_unlock_pkt(fsp);
1240 * @fsp: The FCP packet to abort on
1244 static int fc_fcp_pkt_abort(struct fc_fcp_pkt *fsp)
1249 FC_FCP_DBG(fsp, "pkt abort state %x\n", fsp->state);
1250 if (fc_fcp_send_abort(fsp)) {
1251 FC_FCP_DBG(fsp, "failed to send abort\n");
1255 if (fsp->state & FC_SRB_ABORTED) {
1256 FC_FCP_DBG(fsp, "target abort cmd completed\n");
1260 init_completion(&fsp->tm_done);
1261 fsp->wait_for_comp = 1;
1263 spin_unlock_bh(&fsp->scsi_pkt_lock);
1264 ticks_left = wait_for_completion_timeout(&fsp->tm_done,
1266 spin_lock_bh(&fsp->scsi_pkt_lock);
1267 fsp->wait_for_comp = 0;
1270 FC_FCP_DBG(fsp, "target abort cmd failed\n");
1271 } else if (fsp->state & FC_SRB_ABORTED) {
1272 FC_FCP_DBG(fsp, "target abort cmd passed\n");
1274 fc_fcp_complete_locked(fsp);
1286 struct fc_fcp_pkt *fsp = from_timer(fsp, t, timer);
1287 struct fc_lport *lport = fsp->lp;
1289 if (lport->tt.fcp_cmd_send(lport, fsp, fc_tm_done)) {
1290 if (fsp->recov_retry++ >= FC_MAX_RECOV_RETRY)
1292 if (fc_fcp_lock_pkt(fsp))
1294 fsp->timer.function = fc_lun_reset_send;
1295 fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1296 fc_fcp_unlock_pkt(fsp);
1304 * @fsp: The FCP packet that identifies the LUN to be reset
1308 static int fc_lun_reset(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
1313 fsp->cdb_cmd.fc_dl = htonl(fsp->data_len);
1314 fsp->cdb_cmd.fc_tm_flags = FCP_TMF_LUN_RESET;
1315 int_to_scsilun(lun, &fsp->cdb_cmd.fc_lun);
1317 fsp->wait_for_comp = 1;
1318 init_completion(&fsp->tm_done);
1320 fc_lun_reset_send(&fsp->timer);
1326 rc = wait_for_completion_timeout(&fsp->tm_done, FC_SCSI_TM_TOV);
1328 spin_lock_bh(&fsp->scsi_pkt_lock);
1329 fsp->state |= FC_SRB_COMPL;
1330 spin_unlock_bh(&fsp->scsi_pkt_lock);
1332 del_timer_sync(&fsp->timer);
1334 spin_lock_bh(&fsp->scsi_pkt_lock);
1335 if (fsp->seq_ptr) {
1336 fc_exch_done(fsp->seq_ptr);
1337 fsp->seq_ptr = NULL;
1339 fsp->wait_for_comp = 0;
1340 spin_unlock_bh(&fsp->scsi_pkt_lock);
1348 if (fsp->cdb_status != FCP_TMF_CMPL)
1364 struct fc_fcp_pkt *fsp = arg;
1377 if (fc_fcp_lock_pkt(fsp))
1383 if (!fsp->seq_ptr || !fsp->wait_for_comp)
1388 fc_fcp_resp(fsp, fp);
1389 fsp->seq_ptr = NULL;
1392 fc_fcp_unlock_pkt(fsp);
1419 struct fc_fcp_pkt *fsp = from_timer(fsp, t, timer);
1420 struct fc_rport *rport = fsp->rport;
1423 if (fc_fcp_lock_pkt(fsp))
1426 if (fsp->cdb_cmd.fc_tm_flags)
1429 if (fsp->lp->qfull) {
1430 FC_FCP_DBG(fsp, "fcp timeout, resetting timer delay %d\n",
1431 fsp->timer_delay);
1432 fsp->timer.function = fc_fcp_timeout;
1433 fc_fcp_timer_set(fsp, fsp->timer_delay);
1436 FC_FCP_DBG(fsp, "fcp timeout, delay %d flags %x state %x\n",
1437 fsp->timer_delay, rpriv->flags, fsp->state);
1438 fsp->state |= FC_SRB_FCP_PROCESSING_TMO;
1441 fc_fcp_rec(fsp);
1442 else if (fsp->state & FC_SRB_RCV_STATUS)
1443 fc_fcp_complete_locked(fsp);
1445 fc_fcp_recovery(fsp, FC_TIMED_OUT);
1446 fsp->state &= ~FC_SRB_FCP_PROCESSING_TMO;
1448 fc_fcp_unlock_pkt(fsp);
1453 * @fsp: The FCP packet to send the REC request on
1455 static void fc_fcp_rec(struct fc_fcp_pkt *fsp)
1462 lport = fsp->lp;
1463 rport = fsp->rport;
1465 if (!fsp->seq_ptr || rpriv->rp_state != RPORT_ST_READY) {
1466 fsp->status_code = FC_HRD_ERROR;
1467 fsp->io_status = 0;
1468 fc_fcp_complete_locked(fsp);
1476 fr_seq(fp) = fsp->seq_ptr;
1481 fc_fcp_rec_resp, fsp,
1483 fc_fcp_pkt_hold(fsp); /* hold while REC outstanding */
1487 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1488 fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1490 fc_fcp_recovery(fsp, FC_TIMED_OUT);
1506 struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)arg;
1517 fc_fcp_rec_error(fsp, fp);
1521 if (fc_fcp_lock_pkt(fsp))
1524 fsp->recov_retry = 0;
1530 FC_FCP_DBG(fsp,
1532 fsp->rport->port_id, rjt->er_reason,
1536 FC_FCP_DBG(fsp, "device does not support REC\n");
1537 rpriv = fsp->rport->dd_data;
1547 FC_FCP_DBG(fsp, "device %x REC reject %d/%d\n",
1548 fsp->rport->port_id, rjt->er_reason,
1557 struct fc_exch *ep = fc_seq_exch(fsp->seq_ptr);
1559 fsp->state |= FC_SRB_ABORTED;
1560 fc_fcp_retry_cmd(fsp, FC_TRANS_RESET);
1563 fc_fcp_recovery(fsp, FC_TRANS_RESET);
1567 if (fsp->state & FC_SRB_ABORTED)
1570 data_dir = fsp->cmd->sc_data_direction;
1593 } else if (fsp->xfer_contig_end == offset) {
1596 offset = fsp->xfer_contig_end;
1599 fc_fcp_srr(fsp, r_ctl, offset);
1605 fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1626 if (offset < fsp->data_len)
1628 } else if (offset == fsp->xfer_contig_end) {
1630 } else if (fsp->xfer_contig_end < offset) {
1631 offset = fsp->xfer_contig_end;
1633 fc_fcp_srr(fsp, r_ctl, offset);
1637 fc_fcp_unlock_pkt(fsp);
1639 fc_fcp_pkt_release(fsp); /* drop hold for outstanding REC */
1645 * @fsp: The FCP packet the error is on
1648 static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1652 if (fc_fcp_lock_pkt(fsp))
1657 FC_FCP_DBG(fsp, "REC %p fid %6.6x exchange closed\n",
1658 fsp, fsp->rport->port_id);
1659 fc_fcp_retry_cmd(fsp, FC_ERROR);
1663 FC_FCP_DBG(fsp, "REC %p fid %6.6x error unexpected error %d\n",
1664 fsp, fsp->rport->port_id, error);
1665 fsp->status_code = FC_CMD_PLOGO;
1673 FC_FCP_DBG(fsp, "REC %p fid %6.6x exchange timeout retry %d/%d\n",
1674 fsp, fsp->rport->port_id, fsp->recov_retry,
1676 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1677 fc_fcp_rec(fsp);
1679 fc_fcp_recovery(fsp, FC_TIMED_OUT);
1682 fc_fcp_unlock_pkt(fsp);
1684 fc_fcp_pkt_release(fsp); /* drop hold for outstanding REC */
1689 * @fsp: The FCP pkt that needs to be aborted
1692 static void fc_fcp_recovery(struct fc_fcp_pkt *fsp, u8 code)
1694 FC_FCP_DBG(fsp, "start recovery code %x\n", code);
1695 fsp->status_code = code;
1696 fsp->cdb_status = 0;
1697 fsp->io_status = 0;
1698 if (!fsp->cmd)
1703 fc_fcp_send_abort(fsp);
1708 * @fsp: The FCP packet the SRR is to be sent on
1714 static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
1716 struct fc_lport *lport = fsp->lp;
1719 struct fc_exch *ep = fc_seq_exch(fsp->seq_ptr);
1724 rport = fsp->rport;
1748 fsp, get_fsp_rec_tov(fsp));
1752 fsp->recov_seq = seq;
1753 fsp->xfer_len = offset;
1754 fsp->xfer_contig_end = offset;
1755 fsp->state &= ~FC_SRB_RCV_STATUS;
1756 fc_fcp_pkt_hold(fsp); /* hold for outstanding SRR */
1759 fc_fcp_retry_cmd(fsp, FC_TRANS_RESET);
1770 struct fc_fcp_pkt *fsp = arg;
1774 fc_fcp_srr_error(fsp, fp);
1778 if (fc_fcp_lock_pkt(fsp))
1790 fc_fcp_unlock_pkt(fsp);
1796 fsp->recov_retry = 0;
1797 fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1801 fc_fcp_recovery(fsp, FC_ERROR);
1804 fc_fcp_unlock_pkt(fsp);
1812 * @fsp: The FCP packet that the SRR error is on
1815 static void fc_fcp_srr_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1817 if (fc_fcp_lock_pkt(fsp))
1821 FC_FCP_DBG(fsp, "SRR timeout, retries %d\n", fsp->recov_retry);
1822 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1823 fc_fcp_rec(fsp);
1825 fc_fcp_recovery(fsp, FC_TIMED_OUT);
1828 FC_FCP_DBG(fsp, "SRR error, exchange closed\n");
1831 fc_fcp_retry_cmd(fsp, FC_ERROR);
1834 fc_fcp_unlock_pkt(fsp);
1836 fc_exch_done(fsp->recov_seq);
1861 struct fc_fcp_pkt *fsp;
1894 fsp = fc_fcp_pkt_alloc(lport, GFP_ATOMIC);
1895 if (fsp == NULL) {
1903 fsp->cmd = sc_cmd; /* save the cmd */
1904 fsp->rport = rport; /* set the remote port ptr */
1909 fsp->data_len = scsi_bufflen(sc_cmd);
1910 fsp->xfer_len = 0;
1916 fsp->req_flags = FC_SRB_READ;
1918 this_cpu_add(lport->stats->InputBytes, fsp->data_len);
1920 fsp->req_flags = FC_SRB_WRITE;
1922 this_cpu_add(lport->stats->OutputBytes, fsp->data_len);
1924 fsp->req_flags = 0;
1933 rval = fc_fcp_pkt_send(lport, fsp);
1935 fsp->state = FC_SRB_FREE;
1936 fc_fcp_pkt_release(fsp);
1946 * @fsp: The FCP packet that is complete
1951 static void fc_io_compl(struct fc_fcp_pkt *fsp)
1959 fc_fcp_ddp_done(fsp);
1961 fsp->state |= FC_SRB_COMPL;
1962 if (!(fsp->state & FC_SRB_FCP_PROCESSING_TMO)) {
1963 spin_unlock_bh(&fsp->scsi_pkt_lock);
1964 del_timer_sync(&fsp->timer);
1965 spin_lock_bh(&fsp->scsi_pkt_lock);
1968 lport = fsp->lp;
1978 sc_cmd = fsp->cmd;
1979 libfc_priv(sc_cmd)->status = fsp->cdb_status;
1980 switch (fsp->status_code) {
1982 if (fsp->cdb_status == 0) {
1987 if (fsp->scsi_resid)
1988 libfc_priv(sc_cmd)->resid_len = fsp->scsi_resid;
1994 sc_cmd->result = (DID_OK << 16) | fsp->cdb_status;
1998 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
2003 if ((fsp->cdb_status == 0) && !(fsp->req_flags & FC_SRB_READ)) {
2008 if (fsp->state & FC_SRB_RCV_STATUS) {
2011 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml"
2019 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
2021 libfc_priv(sc_cmd)->resid_len = fsp->scsi_resid;
2022 sc_cmd->result = (DID_ERROR << 16) | fsp->cdb_status;
2029 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
2031 sc_cmd->result = (DID_ERROR << 16) | fsp->cdb_status;
2035 FC_FCP_DBG(fsp, "Returning DID_TIME_OUT to scsi-ml "
2038 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
2042 sc_cmd->result |= fsp->io_status;
2045 FC_FCP_DBG(fsp, "Returning DID_RESET to scsi-ml "
2050 FC_FCP_DBG(fsp, "Returning DID_SOFT_ERROR to scsi-ml "
2055 FC_FCP_DBG(fsp, "Returning DID_NO_CONNECT to scsi-ml "
2060 FC_FCP_DBG(fsp, "Returning DID_PARITY to scsi-ml "
2065 FC_FCP_DBG(fsp, "Returning DID_BUS_BUSY to scsi-ml "
2067 sc_cmd->result = (DID_BUS_BUSY << 16) | fsp->io_status;
2070 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
2076 if (lport->state != LPORT_ST_READY && fsp->status_code != FC_COMPLETE)
2080 list_del(&fsp->list);
2081 libfc_priv(sc_cmd)->fsp = NULL;
2086 fc_fcp_pkt_release(fsp);
2098 struct fc_fcp_pkt *fsp;
2117 fsp = libfc_priv(sc_cmd)->fsp;
2118 if (!fsp) {
2123 /* grab a ref so the fsp and sc_cmd cannot be released from under us */
2124 fc_fcp_pkt_hold(fsp);
2127 if (fc_fcp_lock_pkt(fsp)) {
2133 rc = fc_fcp_pkt_abort(fsp);
2134 fc_fcp_unlock_pkt(fsp);
2137 fc_fcp_pkt_release(fsp);
2152 struct fc_fcp_pkt *fsp;
2168 fsp = fc_fcp_pkt_alloc(lport, GFP_NOIO);
2169 if (fsp == NULL) {
2179 fsp->rport = rport; /* set the remote port ptr */
2184 rc = fc_lun_reset(lport, fsp, scmd_id(sc_cmd), sc_cmd->device->lun);
2185 fsp->state = FC_SRB_FREE;
2186 fc_fcp_pkt_release(fsp);