Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
fc_fcp.c
Go to the documentation of this file.
1 /*
2  * Copyright(c) 2007 Intel Corporation. All rights reserved.
3  * Copyright(c) 2008 Red Hat, Inc. All rights reserved.
4  * Copyright(c) 2008 Mike Christie
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License along with
16  * this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18  *
19  * Maintained at www.Open-FCoE.org
20  */
21 
22 #include <linux/module.h>
23 #include <linux/delay.h>
24 #include <linux/kernel.h>
25 #include <linux/types.h>
26 #include <linux/spinlock.h>
27 #include <linux/scatterlist.h>
28 #include <linux/err.h>
29 #include <linux/crc32.h>
30 #include <linux/slab.h>
31 
32 #include <scsi/scsi_tcq.h>
33 #include <scsi/scsi.h>
34 #include <scsi/scsi_host.h>
35 #include <scsi/scsi_device.h>
36 #include <scsi/scsi_cmnd.h>
37 
38 #include <scsi/fc/fc_fc2.h>
39 
40 #include <scsi/libfc.h>
41 #include <scsi/fc_encode.h>
42 
43 #include "fc_libfc.h"
44 
45 static struct kmem_cache *scsi_pkt_cachep;
46 
47 /* SRB state definitions */
48 #define FC_SRB_FREE 0 /* cmd is free */
49 #define FC_SRB_CMD_SENT (1 << 0) /* cmd has been sent */
50 #define FC_SRB_RCV_STATUS (1 << 1) /* response has arrived */
51 #define FC_SRB_ABORT_PENDING (1 << 2) /* cmd abort sent to device */
52 #define FC_SRB_ABORTED (1 << 3) /* abort acknowledged */
53 #define FC_SRB_DISCONTIG (1 << 4) /* non-sequential data recvd */
54 #define FC_SRB_COMPL (1 << 5) /* fc_io_compl has been run */
55 #define FC_SRB_FCP_PROCESSING_TMO (1 << 6) /* timer function processing */
56 
57 #define FC_SRB_READ (1 << 1)
58 #define FC_SRB_WRITE (1 << 0)
59 
60 /*
61  * The SCp.ptr should be tested and set under the scsi_pkt_queue lock
62  */
63 #define CMD_SP(Cmnd) ((struct fc_fcp_pkt *)(Cmnd)->SCp.ptr)
64 #define CMD_ENTRY_STATUS(Cmnd) ((Cmnd)->SCp.have_data_in)
65 #define CMD_COMPL_STATUS(Cmnd) ((Cmnd)->SCp.this_residual)
66 #define CMD_SCSI_STATUS(Cmnd) ((Cmnd)->SCp.Status)
67 #define CMD_RESID_LEN(Cmnd) ((Cmnd)->SCp.buffers_residual)
68 
78 struct fc_fcp_internal {
79  mempool_t *scsi_pkt_pool;
80  spinlock_t scsi_queue_lock;
81  struct list_head scsi_pkt_queue;
82  unsigned long last_can_queue_ramp_down_time;
83  unsigned long last_can_queue_ramp_up_time;
84  int max_can_queue;
85 };
86 
87 #define fc_get_scsi_internal(x) ((struct fc_fcp_internal *)(x)->scsi_priv)
88 
89 /*
90  * function prototypes
91  * FC scsi I/O related functions
92  */
93 static void fc_fcp_recv_data(struct fc_fcp_pkt *, struct fc_frame *);
94 static void fc_fcp_recv(struct fc_seq *, struct fc_frame *, void *);
95 static void fc_fcp_resp(struct fc_fcp_pkt *, struct fc_frame *);
96 static void fc_fcp_complete_locked(struct fc_fcp_pkt *);
97 static void fc_tm_done(struct fc_seq *, struct fc_frame *, void *);
98 static void fc_fcp_error(struct fc_fcp_pkt *, struct fc_frame *);
99 static void fc_fcp_recovery(struct fc_fcp_pkt *, u8 code);
100 static void fc_fcp_timeout(unsigned long);
101 static void fc_fcp_rec(struct fc_fcp_pkt *);
102 static void fc_fcp_rec_error(struct fc_fcp_pkt *, struct fc_frame *);
103 static void fc_fcp_rec_resp(struct fc_seq *, struct fc_frame *, void *);
104 static void fc_io_compl(struct fc_fcp_pkt *);
105 
106 static void fc_fcp_srr(struct fc_fcp_pkt *, enum fc_rctl, u32);
107 static void fc_fcp_srr_resp(struct fc_seq *, struct fc_frame *, void *);
108 static void fc_fcp_srr_error(struct fc_fcp_pkt *, struct fc_frame *);
109 
110 /*
111  * command status codes
112  */
113 #define FC_COMPLETE 0
114 #define FC_CMD_ABORTED 1
115 #define FC_CMD_RESET 2
116 #define FC_CMD_PLOGO 3
117 #define FC_SNS_RCV 4
118 #define FC_TRANS_ERR 5
119 #define FC_DATA_OVRRUN 6
120 #define FC_DATA_UNDRUN 7
121 #define FC_ERROR 8
122 #define FC_HRD_ERROR 9
123 #define FC_CRC_ERROR 10
124 #define FC_TIMED_OUT 11
125 
126 /*
127  * Error recovery timeout values.
128  */
129 #define FC_SCSI_TM_TOV (10 * HZ)
130 #define FC_HOST_RESET_TIMEOUT (30 * HZ)
131 #define FC_CAN_QUEUE_PERIOD (60 * HZ)
132 
133 #define FC_MAX_ERROR_CNT 5
134 #define FC_MAX_RECOV_RETRY 3
135 
136 #define FC_FCP_DFLT_QUEUE_DEPTH 32
137 
146 static struct fc_fcp_pkt *fc_fcp_pkt_alloc(struct fc_lport *lport, gfp_t gfp)
147 {
148  struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
149  struct fc_fcp_pkt *fsp;
150 
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);
161  } else {
162  per_cpu_ptr(lport->stats, get_cpu())->FcpPktAllocFails++;
163  put_cpu();
164  }
165  return fsp;
166 }
167 
175 static void fc_fcp_pkt_release(struct fc_fcp_pkt *fsp)
176 {
177  if (atomic_dec_and_test(&fsp->ref_cnt)) {
178  struct fc_fcp_internal *si = fc_get_scsi_internal(fsp->lp);
179 
180  mempool_free(fsp, si->scsi_pkt_pool);
181  }
182 }
183 
188 static void fc_fcp_pkt_hold(struct fc_fcp_pkt *fsp)
189 {
190  atomic_inc(&fsp->ref_cnt);
191 }
192 
204 static void fc_fcp_pkt_destroy(struct fc_seq *seq, void *fsp)
205 {
206  fc_fcp_pkt_release(fsp);
207 }
208 
226 static inline int fc_fcp_lock_pkt(struct fc_fcp_pkt *fsp)
227 {
228  spin_lock_bh(&fsp->scsi_pkt_lock);
229  if (fsp->state & FC_SRB_COMPL) {
230  spin_unlock_bh(&fsp->scsi_pkt_lock);
231  return -EPERM;
232  }
233 
234  fc_fcp_pkt_hold(fsp);
235  return 0;
236 }
237 
243 static inline void fc_fcp_unlock_pkt(struct fc_fcp_pkt *fsp)
244 {
245  spin_unlock_bh(&fsp->scsi_pkt_lock);
246  fc_fcp_pkt_release(fsp);
247 }
248 
254 static void fc_fcp_timer_set(struct fc_fcp_pkt *fsp, unsigned long delay)
255 {
256  if (!(fsp->state & FC_SRB_COMPL))
257  mod_timer(&fsp->timer, jiffies + delay);
258 }
259 
265 static int fc_fcp_send_abort(struct fc_fcp_pkt *fsp)
266 {
267  if (!fsp->seq_ptr)
268  return -EINVAL;
269 
270  per_cpu_ptr(fsp->lp->stats, get_cpu())->FcpPktAborts++;
271  put_cpu();
272 
273  fsp->state |= FC_SRB_ABORT_PENDING;
274  return fsp->lp->tt.seq_exch_abort(fsp->seq_ptr, 0);
275 }
276 
286 static void fc_fcp_retry_cmd(struct fc_fcp_pkt *fsp)
287 {
288  if (fsp->seq_ptr) {
289  fsp->lp->tt.exch_done(fsp->seq_ptr);
290  fsp->seq_ptr = NULL;
291  }
292 
293  fsp->state &= ~FC_SRB_ABORT_PENDING;
294  fsp->io_status = 0;
295  fsp->status_code = FC_ERROR;
296  fc_fcp_complete_locked(fsp);
297 }
298 
304 void fc_fcp_ddp_setup(struct fc_fcp_pkt *fsp, u16 xid)
305 {
306  struct fc_lport *lport;
307 
308  lport = fsp->lp;
309  if ((fsp->req_flags & FC_SRB_READ) &&
310  (lport->lro_enabled) && (lport->tt.ddp_setup)) {
311  if (lport->tt.ddp_setup(lport, xid, scsi_sglist(fsp->cmd),
312  scsi_sg_count(fsp->cmd)))
313  fsp->xfer_ddp = xid;
314  }
315 }
316 
322 void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp)
323 {
324  struct fc_lport *lport;
325 
326  if (!fsp)
327  return;
328 
329  if (fsp->xfer_ddp == FC_XID_UNKNOWN)
330  return;
331 
332  lport = fsp->lp;
333  if (lport->tt.ddp_done) {
334  fsp->xfer_len = lport->tt.ddp_done(lport, fsp->xfer_ddp);
335  fsp->xfer_ddp = FC_XID_UNKNOWN;
336  }
337 }
338 
343 static void fc_fcp_can_queue_ramp_up(struct fc_lport *lport)
344 {
345  struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
346  unsigned long flags;
347  int can_queue;
348 
349  spin_lock_irqsave(lport->host->host_lock, flags);
350 
351  if (si->last_can_queue_ramp_up_time &&
352  (time_before(jiffies, si->last_can_queue_ramp_up_time +
353  FC_CAN_QUEUE_PERIOD)))
354  goto unlock;
355 
356  if (time_before(jiffies, si->last_can_queue_ramp_down_time +
357  FC_CAN_QUEUE_PERIOD))
358  goto unlock;
359 
360  si->last_can_queue_ramp_up_time = jiffies;
361 
362  can_queue = lport->host->can_queue << 1;
363  if (can_queue >= si->max_can_queue) {
364  can_queue = si->max_can_queue;
365  si->last_can_queue_ramp_down_time = 0;
366  }
367  lport->host->can_queue = can_queue;
368  shost_printk(KERN_ERR, lport->host, "libfc: increased "
369  "can_queue to %d.\n", can_queue);
370 
371 unlock:
372  spin_unlock_irqrestore(lport->host->host_lock, flags);
373 }
374 
385 static void fc_fcp_can_queue_ramp_down(struct fc_lport *lport)
386 {
387  struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
388  unsigned long flags;
389  int can_queue;
390 
391  spin_lock_irqsave(lport->host->host_lock, flags);
392 
393  if (si->last_can_queue_ramp_down_time &&
394  (time_before(jiffies, si->last_can_queue_ramp_down_time +
395  FC_CAN_QUEUE_PERIOD)))
396  goto unlock;
397 
398  si->last_can_queue_ramp_down_time = jiffies;
399 
400  can_queue = lport->host->can_queue;
401  can_queue >>= 1;
402  if (!can_queue)
403  can_queue = 1;
404  lport->host->can_queue = can_queue;
405  shost_printk(KERN_ERR, lport->host, "libfc: Could not allocate frame.\n"
406  "Reducing can_queue to %d.\n", can_queue);
407 
408 unlock:
409  spin_unlock_irqrestore(lport->host->host_lock, flags);
410 }
411 
412 /*
413  * fc_fcp_frame_alloc() - Allocates fc_frame structure and buffer.
414  * @lport: fc lport struct
415  * @len: payload length
416  *
417  * Allocates fc_frame structure and buffer but if fails to allocate
418  * then reduce can_queue.
419  */
420 static inline struct fc_frame *fc_fcp_frame_alloc(struct fc_lport *lport,
421  size_t len)
422 {
423  struct fc_frame *fp;
424 
425  fp = fc_frame_alloc(lport, len);
426  if (likely(fp))
427  return fp;
428 
429  per_cpu_ptr(lport->stats, get_cpu())->FcpFrameAllocFails++;
430  put_cpu();
431  /* error case */
432  fc_fcp_can_queue_ramp_down(lport);
433  return NULL;
434 }
435 
441 static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
442 {
443  struct scsi_cmnd *sc = fsp->cmd;
444  struct fc_lport *lport = fsp->lp;
445  struct fc_stats *stats;
446  struct fc_frame_header *fh;
447  size_t start_offset;
448  size_t offset;
449  u32 crc;
450  u32 copy_len = 0;
451  size_t len;
452  void *buf;
453  struct scatterlist *sg;
454  u32 nents;
455  u8 host_bcode = FC_COMPLETE;
456 
457  fh = fc_frame_header_get(fp);
458  offset = ntohl(fh->fh_parm_offset);
459  start_offset = offset;
460  len = fr_len(fp) - sizeof(*fh);
461  buf = fc_frame_payload_get(fp, 0);
462 
463  /*
464  * if this I/O is ddped then clear it and initiate recovery since data
465  * frames are expected to be placed directly in that case.
466  *
467  * Indicate error to scsi-ml because something went wrong with the
468  * ddp handling to get us here.
469  */
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");
473  host_bcode = FC_ERROR;
474  goto err;
475  }
476  if (offset + len > fsp->data_len) {
477  /* this should never happen */
478  if ((fr_flags(fp) & FCPHF_CRC_UNCHECKED) &&
479  fc_frame_crc_check(fp))
480  goto crc_err;
481  FC_FCP_DBG(fsp, "data received past end. len %zx offset %zx "
482  "data_len %x\n", len, offset, fsp->data_len);
483 
484  /* Data is corrupted indicate scsi-ml should retry */
485  host_bcode = FC_DATA_OVRRUN;
486  goto err;
487  }
488  if (offset != fsp->xfer_len)
489  fsp->state |= FC_SRB_DISCONTIG;
490 
491  sg = scsi_sglist(sc);
492  nents = scsi_sg_count(sc);
493 
494  if (!(fr_flags(fp) & FCPHF_CRC_UNCHECKED)) {
495  copy_len = fc_copy_buffer_to_sglist(buf, len, sg, &nents,
496  &offset, NULL);
497  } else {
498  crc = crc32(~0, (u8 *) fh, sizeof(*fh));
499  copy_len = fc_copy_buffer_to_sglist(buf, len, sg, &nents,
500  &offset, &crc);
501  buf = fc_frame_payload_get(fp, 0);
502  if (len % 4)
503  crc = crc32(crc, buf + len, 4 - (len % 4));
504 
505  if (~crc != le32_to_cpu(fr_crc(fp))) {
506 crc_err:
507  stats = per_cpu_ptr(lport->stats, get_cpu());
508  stats->ErrorFrames++;
509  /* per cpu count, not total count, but OK for limit */
510  if (stats->InvalidCRCCount++ < FC_MAX_ERROR_CNT)
511  printk(KERN_WARNING "libfc: CRC error on data "
512  "frame for port (%6.6x)\n",
513  lport->port_id);
514  put_cpu();
515  /*
516  * Assume the frame is total garbage.
517  * We may have copied it over the good part
518  * of the buffer.
519  * If so, we need to retry the entire operation.
520  * Otherwise, ignore it.
521  */
522  if (fsp->state & FC_SRB_DISCONTIG) {
523  host_bcode = FC_CRC_ERROR;
524  goto err;
525  }
526  return;
527  }
528  }
529 
530  if (fsp->xfer_contig_end == start_offset)
531  fsp->xfer_contig_end += copy_len;
532  fsp->xfer_len += copy_len;
533 
534  /*
535  * In the very rare event that this data arrived after the response
536  * and completes the transfer, call the completion handler.
537  */
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);
541  return;
542 err:
543  fc_fcp_recovery(fsp, host_bcode);
544 }
545 
559 static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
560  size_t offset, size_t seq_blen)
561 {
562  struct fc_exch *ep;
563  struct scsi_cmnd *sc;
564  struct scatterlist *sg;
565  struct fc_frame *fp = NULL;
566  struct fc_lport *lport = fsp->lp;
567  struct page *page;
568  size_t remaining;
569  size_t t_blen;
570  size_t tlen;
571  size_t sg_bytes;
572  size_t frame_offset, fh_parm_offset;
573  size_t off;
574  int error;
575  void *data = NULL;
576  void *page_addr;
577  int using_sg = lport->sg_supp;
578  u32 f_ctl;
579 
580  WARN_ON(seq_blen <= 0);
581  if (unlikely(offset + seq_blen > fsp->data_len)) {
582  /* this should never happen */
583  FC_FCP_DBG(fsp, "xfer-ready past end. seq_blen %zx "
584  "offset %zx\n", seq_blen, offset);
585  fc_fcp_send_abort(fsp);
586  return 0;
587  } else if (offset != fsp->xfer_len) {
588  /* Out of Order Data Request - no problem, but unexpected. */
589  FC_FCP_DBG(fsp, "xfer-ready non-contiguous. "
590  "seq_blen %zx offset %zx\n", seq_blen, offset);
591  }
592 
593  /*
594  * if LLD is capable of seq_offload then set transport
595  * burst length (t_blen) to seq_blen, otherwise set t_blen
596  * to max FC frame payload previously set in fsp->max_payload.
597  */
598  t_blen = fsp->max_payload;
599  if (lport->seq_offload) {
600  t_blen = min(seq_blen, (size_t)lport->lso_max);
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);
603  }
604 
605  if (t_blen > 512)
606  t_blen &= ~(512 - 1); /* round down to block size */
607  sc = fsp->cmd;
608 
609  remaining = seq_blen;
610  fh_parm_offset = frame_offset = offset;
611  tlen = 0;
612  seq = lport->tt.seq_start_next(seq);
613  f_ctl = FC_FC_REL_OFF;
614  WARN_ON(!seq);
615 
616  sg = scsi_sglist(sc);
617 
618  while (remaining > 0 && sg) {
619  if (offset >= sg->length) {
620  offset -= sg->length;
621  sg = sg_next(sg);
622  continue;
623  }
624  if (!fp) {
625  tlen = min(t_blen, remaining);
626 
627  /*
628  * TODO. Temporary workaround. fc_seq_send() can't
629  * handle odd lengths in non-linear skbs.
630  * This will be the final fragment only.
631  */
632  if (tlen % 4)
633  using_sg = 0;
634  fp = fc_frame_alloc(lport, using_sg ? 0 : tlen);
635  if (!fp)
636  return -ENOMEM;
637 
638  data = fc_frame_header_get(fp) + 1;
639  fh_parm_offset = frame_offset;
640  fr_max_payload(fp) = fsp->max_payload;
641  }
642 
643  off = offset + sg->offset;
644  sg_bytes = min(tlen, sg->length - offset);
645  sg_bytes = min(sg_bytes,
646  (size_t) (PAGE_SIZE - (off & ~PAGE_MASK)));
647  page = sg_page(sg) + (off >> PAGE_SHIFT);
648  if (using_sg) {
649  get_page(page);
650  skb_fill_page_desc(fp_skb(fp),
651  skb_shinfo(fp_skb(fp))->nr_frags,
652  page, off & ~PAGE_MASK, sg_bytes);
653  fp_skb(fp)->data_len += sg_bytes;
654  fr_len(fp) += sg_bytes;
655  fp_skb(fp)->truesize += PAGE_SIZE;
656  } else {
657  /*
658  * The scatterlist item may be bigger than PAGE_SIZE,
659  * but we must not cross pages inside the kmap.
660  */
661  page_addr = kmap_atomic(page);
662  memcpy(data, (char *)page_addr + (off & ~PAGE_MASK),
663  sg_bytes);
664  kunmap_atomic(page_addr);
665  data += sg_bytes;
666  }
667  offset += sg_bytes;
668  frame_offset += sg_bytes;
669  tlen -= sg_bytes;
670  remaining -= sg_bytes;
671 
672  if ((skb_shinfo(fp_skb(fp))->nr_frags < FC_FRAME_SG_LEN) &&
673  (tlen))
674  continue;
675 
676  /*
677  * Send sequence with transfer sequence initiative in case
678  * this is last FCP frame of the sequence.
679  */
680  if (remaining == 0)
681  f_ctl |= FC_FC_SEQ_INIT | FC_FC_END_SEQ;
682 
683  ep = fc_seq_exch(seq);
684  fc_fill_fc_hdr(fp, FC_RCTL_DD_SOL_DATA, ep->did, ep->sid,
685  FC_TYPE_FCP, f_ctl, fh_parm_offset);
686 
687  /*
688  * send fragment using for a sequence.
689  */
690  error = lport->tt.seq_send(lport, seq, fp);
691  if (error) {
692  WARN_ON(1); /* send error should be rare */
693  return error;
694  }
695  fp = NULL;
696  }
697  fsp->xfer_len += seq_blen; /* premature count? */
698  return 0;
699 }
700 
706 static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
707 {
708  int ba_done = 1;
709  struct fc_ba_rjt *brp;
710  struct fc_frame_header *fh;
711 
712  fh = fc_frame_header_get(fp);
713  switch (fh->fh_r_ctl) {
714  case FC_RCTL_BA_ACC:
715  break;
716  case FC_RCTL_BA_RJT:
717  brp = fc_frame_payload_get(fp, sizeof(*brp));
718  if (brp && brp->br_reason == FC_BA_RJT_LOG_ERR)
719  break;
720  /* fall thru */
721  default:
722  /*
723  * we will let the command timeout
724  * and scsi-ml recover in this case,
725  * therefore cleared the ba_done flag.
726  */
727  ba_done = 0;
728  }
729 
730  if (ba_done) {
731  fsp->state |= FC_SRB_ABORTED;
732  fsp->state &= ~FC_SRB_ABORT_PENDING;
733 
734  if (fsp->wait_for_comp)
735  complete(&fsp->tm_done);
736  else
737  fc_fcp_complete_locked(fsp);
738  }
739 }
740 
750 static void fc_fcp_recv(struct fc_seq *seq, struct fc_frame *fp, void *arg)
751 {
752  struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)arg;
753  struct fc_lport *lport = fsp->lp;
754  struct fc_frame_header *fh;
755  struct fcp_txrdy *dd;
756  u8 r_ctl;
757  int rc = 0;
758 
759  if (IS_ERR(fp)) {
760  fc_fcp_error(fsp, fp);
761  return;
762  }
763 
764  fh = fc_frame_header_get(fp);
765  r_ctl = fh->fh_r_ctl;
766 
767  if (lport->state != LPORT_ST_READY)
768  goto out;
769  if (fc_fcp_lock_pkt(fsp))
770  goto out;
771 
772  if (fh->fh_type == FC_TYPE_BLS) {
773  fc_fcp_abts_resp(fsp, fp);
774  goto unlock;
775  }
776 
777  if (fsp->state & (FC_SRB_ABORTED | FC_SRB_ABORT_PENDING))
778  goto unlock;
779 
780  if (r_ctl == FC_RCTL_DD_DATA_DESC) {
781  /*
782  * received XFER RDY from the target
783  * need to send data to the target
784  */
785  WARN_ON(fr_flags(fp) & FCPHF_CRC_UNCHECKED);
786  dd = fc_frame_payload_get(fp, sizeof(*dd));
787  WARN_ON(!dd);
788 
789  rc = fc_fcp_send_data(fsp, seq,
790  (size_t) ntohl(dd->ft_data_ro),
791  (size_t) ntohl(dd->ft_burst_len));
792  if (!rc)
793  seq->rec_data = fsp->xfer_len;
794  } else if (r_ctl == FC_RCTL_DD_SOL_DATA) {
795  /*
796  * received a DATA frame
797  * next we will copy the data to the system buffer
798  */
799  WARN_ON(fr_len(fp) < sizeof(*fh)); /* len may be 0 */
800  fc_fcp_recv_data(fsp, fp);
801  seq->rec_data = fsp->xfer_contig_end;
802  } else if (r_ctl == FC_RCTL_DD_CMD_STATUS) {
803  WARN_ON(fr_flags(fp) & FCPHF_CRC_UNCHECKED);
804 
805  fc_fcp_resp(fsp, fp);
806  } else {
807  FC_FCP_DBG(fsp, "unexpected frame. r_ctl %x\n", r_ctl);
808  }
809 unlock:
810  fc_fcp_unlock_pkt(fsp);
811 out:
812  fc_frame_free(fp);
813 }
814 
820 static void fc_fcp_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
821 {
822  struct fc_frame_header *fh;
823  struct fcp_resp *fc_rp;
824  struct fcp_resp_ext *rp_ex;
825  struct fcp_resp_rsp_info *fc_rp_info;
826  u32 plen;
827  u32 expected_len;
828  u32 respl = 0;
829  u32 snsl = 0;
830  u8 flags = 0;
831 
832  plen = fr_len(fp);
833  fh = (struct fc_frame_header *)fr_hdr(fp);
834  if (unlikely(plen < sizeof(*fh) + sizeof(*fc_rp)))
835  goto len_err;
836  plen -= sizeof(*fh);
837  fc_rp = (struct fcp_resp *)(fh + 1);
838  fsp->cdb_status = fc_rp->fr_status;
839  flags = fc_rp->fr_flags;
840  fsp->scsi_comp_flags = flags;
841  expected_len = fsp->data_len;
842 
843  /* if ddp, update xfer len */
844  fc_fcp_ddp_done(fsp);
845 
846  if (unlikely((flags & ~FCP_CONF_REQ) || fc_rp->fr_status)) {
847  rp_ex = (void *)(fc_rp + 1);
848  if (flags & (FCP_RSP_LEN_VAL | FCP_SNS_LEN_VAL)) {
849  if (plen < sizeof(*fc_rp) + sizeof(*rp_ex))
850  goto len_err;
851  fc_rp_info = (struct fcp_resp_rsp_info *)(rp_ex + 1);
852  if (flags & FCP_RSP_LEN_VAL) {
853  respl = ntohl(rp_ex->fr_rsp_len);
854  if ((respl != FCP_RESP_RSP_INFO_LEN4) &&
855  (respl != FCP_RESP_RSP_INFO_LEN8))
856  goto len_err;
857  if (fsp->wait_for_comp) {
858  /* Abuse cdb_status for rsp code */
859  fsp->cdb_status = fc_rp_info->rsp_code;
860  complete(&fsp->tm_done);
861  /*
862  * tmfs will not have any scsi cmd so
863  * exit here
864  */
865  return;
866  }
867  }
868  if (flags & FCP_SNS_LEN_VAL) {
869  snsl = ntohl(rp_ex->fr_sns_len);
870  if (snsl > SCSI_SENSE_BUFFERSIZE)
871  snsl = SCSI_SENSE_BUFFERSIZE;
872  memcpy(fsp->cmd->sense_buffer,
873  (char *)fc_rp_info + respl, snsl);
874  }
875  }
876  if (flags & (FCP_RESID_UNDER | FCP_RESID_OVER)) {
877  if (plen < sizeof(*fc_rp) + sizeof(rp_ex->fr_resid))
878  goto len_err;
879  if (flags & FCP_RESID_UNDER) {
880  fsp->scsi_resid = ntohl(rp_ex->fr_resid);
881  /*
882  * The cmnd->underflow is the minimum number of
883  * bytes that must be transferred for this
884  * command. Provided a sense condition is not
885  * present, make sure the actual amount
886  * transferred is at least the underflow value
887  * or fail.
888  */
889  if (!(flags & FCP_SNS_LEN_VAL) &&
890  (fc_rp->fr_status == 0) &&
891  (scsi_bufflen(fsp->cmd) -
892  fsp->scsi_resid) < fsp->cmd->underflow)
893  goto err;
894  expected_len -= fsp->scsi_resid;
895  } else {
896  fsp->status_code = FC_ERROR;
897  }
898  }
899  }
900  fsp->state |= FC_SRB_RCV_STATUS;
901 
902  /*
903  * Check for missing or extra data frames.
904  */
905  if (unlikely(fsp->xfer_len != expected_len)) {
906  if (fsp->xfer_len < expected_len) {
907  /*
908  * Some data may be queued locally,
909  * Wait a at least one jiffy to see if it is delivered.
910  * If this expires without data, we may do SRR.
911  */
912  fc_fcp_timer_set(fsp, 2);
913  return;
914  }
915  fsp->status_code = FC_DATA_OVRRUN;
916  FC_FCP_DBG(fsp, "tgt %6.6x xfer len %zx greater than expected, "
917  "len %x, data len %x\n",
918  fsp->rport->port_id,
919  fsp->xfer_len, expected_len, fsp->data_len);
920  }
921  fc_fcp_complete_locked(fsp);
922  return;
923 
924 len_err:
925  FC_FCP_DBG(fsp, "short FCP response. flags 0x%x len %u respl %u "
926  "snsl %u\n", flags, fr_len(fp), respl, snsl);
927 err:
928  fsp->status_code = FC_ERROR;
929  fc_fcp_complete_locked(fsp);
930 }
931 
940 static void fc_fcp_complete_locked(struct fc_fcp_pkt *fsp)
941 {
942  struct fc_lport *lport = fsp->lp;
943  struct fc_seq *seq;
944  struct fc_exch *ep;
945  u32 f_ctl;
946 
947  if (fsp->state & FC_SRB_ABORT_PENDING)
948  return;
949 
950  if (fsp->state & FC_SRB_ABORTED) {
951  if (!fsp->status_code)
952  fsp->status_code = FC_CMD_ABORTED;
953  } else {
954  /*
955  * Test for transport underrun, independent of response
956  * underrun status.
957  */
958  if (fsp->xfer_len < fsp->data_len && !fsp->io_status &&
959  (!(fsp->scsi_comp_flags & FCP_RESID_UNDER) ||
960  fsp->xfer_len < fsp->data_len - fsp->scsi_resid)) {
961  fsp->status_code = FC_DATA_UNDRUN;
962  fsp->io_status = 0;
963  }
964  }
965 
966  seq = fsp->seq_ptr;
967  if (seq) {
968  fsp->seq_ptr = NULL;
969  if (unlikely(fsp->scsi_comp_flags & FCP_CONF_REQ)) {
970  struct fc_frame *conf_frame;
971  struct fc_seq *csp;
972 
973  csp = lport->tt.seq_start_next(seq);
974  conf_frame = fc_fcp_frame_alloc(fsp->lp, 0);
975  if (conf_frame) {
976  f_ctl = FC_FC_SEQ_INIT;
977  f_ctl |= FC_FC_LAST_SEQ | FC_FC_END_SEQ;
978  ep = fc_seq_exch(seq);
979  fc_fill_fc_hdr(conf_frame, FC_RCTL_DD_SOL_CTL,
980  ep->did, ep->sid,
981  FC_TYPE_FCP, f_ctl, 0);
982  lport->tt.seq_send(lport, csp, conf_frame);
983  }
984  }
985  lport->tt.exch_done(seq);
986  }
987  /*
988  * Some resets driven by SCSI are not I/Os and do not have
989  * SCSI commands associated with the requests. We should not
990  * call I/O completion if we do not have a SCSI command.
991  */
992  if (fsp->cmd)
993  fc_io_compl(fsp);
994 }
995 
1001 static void fc_fcp_cleanup_cmd(struct fc_fcp_pkt *fsp, int error)
1002 {
1003  struct fc_lport *lport = fsp->lp;
1004 
1005  if (fsp->seq_ptr) {
1006  lport->tt.exch_done(fsp->seq_ptr);
1007  fsp->seq_ptr = NULL;
1008  }
1009  fsp->status_code = error;
1010 }
1011 
1021 static void fc_fcp_cleanup_each_cmd(struct fc_lport *lport, unsigned int id,
1022  unsigned int lun, int error)
1023 {
1024  struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
1025  struct fc_fcp_pkt *fsp;
1026  struct scsi_cmnd *sc_cmd;
1027  unsigned long flags;
1028 
1029  spin_lock_irqsave(&si->scsi_queue_lock, flags);
1030 restart:
1031  list_for_each_entry(fsp, &si->scsi_pkt_queue, list) {
1032  sc_cmd = fsp->cmd;
1033  if (id != -1 && scmd_id(sc_cmd) != id)
1034  continue;
1035 
1036  if (lun != -1 && sc_cmd->device->lun != lun)
1037  continue;
1038 
1039  fc_fcp_pkt_hold(fsp);
1040  spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
1041 
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);
1046  }
1047 
1048  fc_fcp_pkt_release(fsp);
1049  spin_lock_irqsave(&si->scsi_queue_lock, flags);
1050  /*
1051  * while we dropped the lock multiple pkts could
1052  * have been released, so we have to start over.
1053  */
1054  goto restart;
1055  }
1056  spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
1057 }
1058 
1063 static void fc_fcp_abort_io(struct fc_lport *lport)
1064 {
1065  fc_fcp_cleanup_each_cmd(lport, -1, -1, FC_HRD_ERROR);
1066 }
1067 
1076 static int fc_fcp_pkt_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp)
1077 {
1078  struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
1079  unsigned long flags;
1080  int rc;
1081 
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;
1085 
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);
1088 
1089  spin_lock_irqsave(&si->scsi_queue_lock, flags);
1090  list_add_tail(&fsp->list, &si->scsi_pkt_queue);
1091  spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
1092  rc = lport->tt.fcp_cmd_send(lport, fsp, fc_fcp_recv);
1093  if (unlikely(rc)) {
1094  spin_lock_irqsave(&si->scsi_queue_lock, flags);
1095  fsp->cmd->SCp.ptr = NULL;
1096  list_del(&fsp->list);
1097  spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
1098  }
1099 
1100  return rc;
1101 }
1102 
1109 static inline unsigned int get_fsp_rec_tov(struct fc_fcp_pkt *fsp)
1110 {
1111  struct fc_rport_libfc_priv *rpriv = fsp->rport->dd_data;
1112 
1113  return msecs_to_jiffies(rpriv->e_d_tov) + HZ;
1114 }
1115 
1122 static int fc_fcp_cmd_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
1123  void (*resp)(struct fc_seq *,
1124  struct fc_frame *fp,
1125  void *arg))
1126 {
1127  struct fc_frame *fp;
1128  struct fc_seq *seq;
1129  struct fc_rport *rport;
1130  struct fc_rport_libfc_priv *rpriv;
1131  const size_t len = sizeof(fsp->cdb_cmd);
1132  int rc = 0;
1133 
1134  if (fc_fcp_lock_pkt(fsp))
1135  return 0;
1136 
1137  fp = fc_fcp_frame_alloc(lport, sizeof(fsp->cdb_cmd));
1138  if (!fp) {
1139  rc = -1;
1140  goto unlock;
1141  }
1142 
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;
1147  rpriv = rport->dd_data;
1148 
1149  fc_fill_fc_hdr(fp, FC_RCTL_DD_UNSOL_CMD, rport->port_id,
1150  rpriv->local_port->port_id, FC_TYPE_FCP,
1151  FC_FCTL_REQ, 0);
1152 
1153  seq = lport->tt.exch_seq_send(lport, fp, resp, fc_fcp_pkt_destroy,
1154  fsp, 0);
1155  if (!seq) {
1156  rc = -1;
1157  goto unlock;
1158  }
1159  fsp->seq_ptr = seq;
1160  fc_fcp_pkt_hold(fsp); /* hold for fc_fcp_pkt_destroy */
1161 
1162  setup_timer(&fsp->timer, fc_fcp_timeout, (unsigned long)fsp);
1163  if (rpriv->flags & FC_RP_FLAGS_REC_SUPPORTED)
1164  fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1165 
1166 unlock:
1167  fc_fcp_unlock_pkt(fsp);
1168  return rc;
1169 }
1170 
1176 static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1177 {
1178  int error = PTR_ERR(fp);
1179 
1180  if (fc_fcp_lock_pkt(fsp))
1181  return;
1182 
1183  if (error == -FC_EX_CLOSED) {
1184  fc_fcp_retry_cmd(fsp);
1185  goto unlock;
1186  }
1187 
1188  /*
1189  * clear abort pending, because the lower layer
1190  * decided to force completion.
1191  */
1192  fsp->state &= ~FC_SRB_ABORT_PENDING;
1193  fsp->status_code = FC_CMD_PLOGO;
1194  fc_fcp_complete_locked(fsp);
1195 unlock:
1196  fc_fcp_unlock_pkt(fsp);
1197 }
1198 
1205 static int fc_fcp_pkt_abort(struct fc_fcp_pkt *fsp)
1206 {
1207  int rc = FAILED;
1208  unsigned long ticks_left;
1209 
1210  if (fc_fcp_send_abort(fsp))
1211  return FAILED;
1212 
1213  init_completion(&fsp->tm_done);
1214  fsp->wait_for_comp = 1;
1215 
1216  spin_unlock_bh(&fsp->scsi_pkt_lock);
1217  ticks_left = wait_for_completion_timeout(&fsp->tm_done,
1218  FC_SCSI_TM_TOV);
1219  spin_lock_bh(&fsp->scsi_pkt_lock);
1220  fsp->wait_for_comp = 0;
1221 
1222  if (!ticks_left) {
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");
1226  rc = SUCCESS;
1227  fc_fcp_complete_locked(fsp);
1228  }
1229 
1230  return rc;
1231 }
1232 
1237 static void fc_lun_reset_send(unsigned long data)
1238 {
1239  struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
1240  struct fc_lport *lport = fsp->lp;
1241 
1242  if (lport->tt.fcp_cmd_send(lport, fsp, fc_tm_done)) {
1243  if (fsp->recov_retry++ >= FC_MAX_RECOV_RETRY)
1244  return;
1245  if (fc_fcp_lock_pkt(fsp))
1246  return;
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);
1250  }
1251 }
1252 
1261 static int fc_lun_reset(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
1262  unsigned int id, unsigned int lun)
1263 {
1264  int rc;
1265 
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);
1269 
1270  fsp->wait_for_comp = 1;
1271  init_completion(&fsp->tm_done);
1272 
1273  fc_lun_reset_send((unsigned long)fsp);
1274 
1275  /*
1276  * wait for completion of reset
1277  * after that make sure all commands are terminated
1278  */
1279  rc = wait_for_completion_timeout(&fsp->tm_done, FC_SCSI_TM_TOV);
1280 
1281  spin_lock_bh(&fsp->scsi_pkt_lock);
1282  fsp->state |= FC_SRB_COMPL;
1283  spin_unlock_bh(&fsp->scsi_pkt_lock);
1284 
1285  del_timer_sync(&fsp->timer);
1286 
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;
1291  }
1292  fsp->wait_for_comp = 0;
1293  spin_unlock_bh(&fsp->scsi_pkt_lock);
1294 
1295  if (!rc) {
1296  FC_SCSI_DBG(lport, "lun reset failed\n");
1297  return FAILED;
1298  }
1299 
1300  /* cdb_status holds the tmf's rsp code */
1301  if (fsp->cdb_status != FCP_TMF_CMPL)
1302  return FAILED;
1303 
1304  FC_SCSI_DBG(lport, "lun reset to lun %u completed\n", lun);
1305  fc_fcp_cleanup_each_cmd(lport, id, lun, FC_CMD_ABORTED);
1306  return SUCCESS;
1307 }
1308 
1315 static void fc_tm_done(struct fc_seq *seq, struct fc_frame *fp, void *arg)
1316 {
1317  struct fc_fcp_pkt *fsp = arg;
1318  struct fc_frame_header *fh;
1319 
1320  if (IS_ERR(fp)) {
1321  /*
1322  * If there is an error just let it timeout or wait
1323  * for TMF to be aborted if it timedout.
1324  *
1325  * scsi-eh will escalate for when either happens.
1326  */
1327  return;
1328  }
1329 
1330  if (fc_fcp_lock_pkt(fsp))
1331  goto out;
1332 
1333  /*
1334  * raced with eh timeout handler.
1335  */
1336  if (!fsp->seq_ptr || !fsp->wait_for_comp)
1337  goto out_unlock;
1338 
1339  fh = fc_frame_header_get(fp);
1340  if (fh->fh_type != FC_TYPE_BLS)
1341  fc_fcp_resp(fsp, fp);
1342  fsp->seq_ptr = NULL;
1343  fsp->lp->tt.exch_done(seq);
1344 out_unlock:
1345  fc_fcp_unlock_pkt(fsp);
1346 out:
1347  fc_frame_free(fp);
1348 }
1349 
1354 static void fc_fcp_cleanup(struct fc_lport *lport)
1355 {
1356  fc_fcp_cleanup_each_cmd(lport, -1, -1, FC_ERROR);
1357 }
1358 
1370 static void fc_fcp_timeout(unsigned long data)
1371 {
1372  struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
1373  struct fc_rport *rport = fsp->rport;
1374  struct fc_rport_libfc_priv *rpriv = rport->dd_data;
1375 
1376  if (fc_fcp_lock_pkt(fsp))
1377  return;
1378 
1379  if (fsp->cdb_cmd.fc_tm_flags)
1380  goto unlock;
1381 
1382  fsp->state |= FC_SRB_FCP_PROCESSING_TMO;
1383 
1384  if (fsp->state & FC_SRB_RCV_STATUS)
1385  fc_fcp_complete_locked(fsp);
1386  else if (rpriv->flags & FC_RP_FLAGS_REC_SUPPORTED)
1387  fc_fcp_rec(fsp);
1388  else
1389  fc_fcp_recovery(fsp, FC_TIMED_OUT);
1390  fsp->state &= ~FC_SRB_FCP_PROCESSING_TMO;
1391 unlock:
1392  fc_fcp_unlock_pkt(fsp);
1393 }
1394 
1399 static void fc_fcp_rec(struct fc_fcp_pkt *fsp)
1400 {
1401  struct fc_lport *lport;
1402  struct fc_frame *fp;
1403  struct fc_rport *rport;
1404  struct fc_rport_libfc_priv *rpriv;
1405 
1406  lport = fsp->lp;
1407  rport = fsp->rport;
1408  rpriv = rport->dd_data;
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);
1413  return;
1414  }
1415 
1416  fp = fc_fcp_frame_alloc(lport, sizeof(struct fc_els_rec));
1417  if (!fp)
1418  goto retry;
1419 
1420  fr_seq(fp) = fsp->seq_ptr;
1421  fc_fill_fc_hdr(fp, FC_RCTL_ELS_REQ, rport->port_id,
1422  rpriv->local_port->port_id, FC_TYPE_ELS,
1423  FC_FCTL_REQ, 0);
1424  if (lport->tt.elsct_send(lport, rport->port_id, fp, ELS_REC,
1425  fc_fcp_rec_resp, fsp,
1426  2 * lport->r_a_tov)) {
1427  fc_fcp_pkt_hold(fsp); /* hold while REC outstanding */
1428  return;
1429  }
1430 retry:
1431  if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1432  fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1433  else
1434  fc_fcp_recovery(fsp, FC_TIMED_OUT);
1435 }
1436 
1448 static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
1449 {
1450  struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)arg;
1451  struct fc_els_rec_acc *recp;
1452  struct fc_els_ls_rjt *rjt;
1453  u32 e_stat;
1454  u8 opcode;
1455  u32 offset;
1456  enum dma_data_direction data_dir;
1457  enum fc_rctl r_ctl;
1458  struct fc_rport_libfc_priv *rpriv;
1459 
1460  if (IS_ERR(fp)) {
1461  fc_fcp_rec_error(fsp, fp);
1462  return;
1463  }
1464 
1465  if (fc_fcp_lock_pkt(fsp))
1466  goto out;
1467 
1468  fsp->recov_retry = 0;
1469  opcode = fc_frame_payload_op(fp);
1470  if (opcode == ELS_LS_RJT) {
1471  rjt = fc_frame_payload_get(fp, sizeof(*rjt));
1472  switch (rjt->er_reason) {
1473  default:
1474  FC_FCP_DBG(fsp, "device %x unexpected REC reject "
1475  "reason %d expl %d\n",
1476  fsp->rport->port_id, rjt->er_reason,
1477  rjt->er_explan);
1478  /* fall through */
1479  case ELS_RJT_UNSUP:
1480  FC_FCP_DBG(fsp, "device does not support REC\n");
1481  rpriv = fsp->rport->dd_data;
1482  /*
1483  * if we do not spport RECs or got some bogus
1484  * reason then resetup timer so we check for
1485  * making progress.
1486  */
1487  rpriv->flags &= ~FC_RP_FLAGS_REC_SUPPORTED;
1488  break;
1489  case ELS_RJT_LOGIC:
1490  case ELS_RJT_UNAB:
1491  /*
1492  * If no data transfer, the command frame got dropped
1493  * so we just retry. If data was transferred, we
1494  * lost the response but the target has no record,
1495  * so we abort and retry.
1496  */
1497  if (rjt->er_explan == ELS_EXPL_OXID_RXID &&
1498  fsp->xfer_len == 0) {
1499  fc_fcp_retry_cmd(fsp);
1500  break;
1501  }
1502  fc_fcp_recovery(fsp, FC_ERROR);
1503  break;
1504  }
1505  } else if (opcode == ELS_LS_ACC) {
1506  if (fsp->state & FC_SRB_ABORTED)
1507  goto unlock_out;
1508 
1509  data_dir = fsp->cmd->sc_data_direction;
1510  recp = fc_frame_payload_get(fp, sizeof(*recp));
1511  offset = ntohl(recp->reca_fc4value);
1512  e_stat = ntohl(recp->reca_e_stat);
1513 
1514  if (e_stat & ESB_ST_COMPLETE) {
1515 
1516  /*
1517  * The exchange is complete.
1518  *
1519  * For output, we must've lost the response.
1520  * For input, all data must've been sent.
1521  * We lost may have lost the response
1522  * (and a confirmation was requested) and maybe
1523  * some data.
1524  *
1525  * If all data received, send SRR
1526  * asking for response. If partial data received,
1527  * or gaps, SRR requests data at start of gap.
1528  * Recovery via SRR relies on in-order-delivery.
1529  */
1530  if (data_dir == DMA_TO_DEVICE) {
1531  r_ctl = FC_RCTL_DD_CMD_STATUS;
1532  } else if (fsp->xfer_contig_end == offset) {
1533  r_ctl = FC_RCTL_DD_CMD_STATUS;
1534  } else {
1535  offset = fsp->xfer_contig_end;
1536  r_ctl = FC_RCTL_DD_SOL_DATA;
1537  }
1538  fc_fcp_srr(fsp, r_ctl, offset);
1539  } else if (e_stat & ESB_ST_SEQ_INIT) {
1540  /*
1541  * The remote port has the initiative, so just
1542  * keep waiting for it to complete.
1543  */
1544  fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1545  } else {
1546 
1547  /*
1548  * The exchange is incomplete, we have seq. initiative.
1549  * Lost response with requested confirmation,
1550  * lost confirmation, lost transfer ready or
1551  * lost write data.
1552  *
1553  * For output, if not all data was received, ask
1554  * for transfer ready to be repeated.
1555  *
1556  * If we received or sent all the data, send SRR to
1557  * request response.
1558  *
1559  * If we lost a response, we may have lost some read
1560  * data as well.
1561  */
1562  r_ctl = FC_RCTL_DD_SOL_DATA;
1563  if (data_dir == DMA_TO_DEVICE) {
1564  r_ctl = FC_RCTL_DD_CMD_STATUS;
1565  if (offset < fsp->data_len)
1566  r_ctl = FC_RCTL_DD_DATA_DESC;
1567  } else if (offset == fsp->xfer_contig_end) {
1568  r_ctl = FC_RCTL_DD_CMD_STATUS;
1569  } else if (fsp->xfer_contig_end < offset) {
1570  offset = fsp->xfer_contig_end;
1571  }
1572  fc_fcp_srr(fsp, r_ctl, offset);
1573  }
1574  }
1575 unlock_out:
1576  fc_fcp_unlock_pkt(fsp);
1577 out:
1578  fc_fcp_pkt_release(fsp); /* drop hold for outstanding REC */
1579  fc_frame_free(fp);
1580 }
1581 
1587 static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1588 {
1589  int error = PTR_ERR(fp);
1590 
1591  if (fc_fcp_lock_pkt(fsp))
1592  goto out;
1593 
1594  switch (error) {
1595  case -FC_EX_CLOSED:
1596  fc_fcp_retry_cmd(fsp);
1597  break;
1598 
1599  default:
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;
1603  /* fall through */
1604 
1605  case -FC_EX_TIMEOUT:
1606  /*
1607  * Assume REC or LS_ACC was lost.
1608  * The exchange manager will have aborted REC, so retry.
1609  */
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,
1612  FC_MAX_RECOV_RETRY);
1613  if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1614  fc_fcp_rec(fsp);
1615  else
1616  fc_fcp_recovery(fsp, FC_ERROR);
1617  break;
1618  }
1619  fc_fcp_unlock_pkt(fsp);
1620 out:
1621  fc_fcp_pkt_release(fsp); /* drop hold for outstanding REC */
1622 }
1623 
1628 static void fc_fcp_recovery(struct fc_fcp_pkt *fsp, u8 code)
1629 {
1630  fsp->status_code = code;
1631  fsp->cdb_status = 0;
1632  fsp->io_status = 0;
1633  /*
1634  * if this fails then we let the scsi command timer fire and
1635  * scsi-ml escalate.
1636  */
1637  fc_fcp_send_abort(fsp);
1638 }
1639 
1647 static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
1648 {
1649  struct fc_lport *lport = fsp->lp;
1650  struct fc_rport *rport;
1651  struct fc_rport_libfc_priv *rpriv;
1652  struct fc_exch *ep = fc_seq_exch(fsp->seq_ptr);
1653  struct fc_seq *seq;
1654  struct fcp_srr *srr;
1655  struct fc_frame *fp;
1656  unsigned int rec_tov;
1657 
1658  rport = fsp->rport;
1659  rpriv = rport->dd_data;
1660 
1661  if (!(rpriv->flags & FC_RP_FLAGS_RETRY) ||
1662  rpriv->rp_state != RPORT_ST_READY)
1663  goto retry; /* shouldn't happen */
1664  fp = fc_fcp_frame_alloc(lport, sizeof(*srr));
1665  if (!fp)
1666  goto retry;
1667 
1668  srr = fc_frame_payload_get(fp, sizeof(*srr));
1669  memset(srr, 0, sizeof(*srr));
1670  srr->srr_op = ELS_SRR;
1671  srr->srr_ox_id = htons(ep->oxid);
1672  srr->srr_rx_id = htons(ep->rxid);
1673  srr->srr_r_ctl = r_ctl;
1674  srr->srr_rel_off = htonl(offset);
1675 
1676  fc_fill_fc_hdr(fp, FC_RCTL_ELS4_REQ, rport->port_id,
1677  rpriv->local_port->port_id, FC_TYPE_FCP,
1678  FC_FCTL_REQ, 0);
1679 
1680  rec_tov = get_fsp_rec_tov(fsp);
1681  seq = lport->tt.exch_seq_send(lport, fp, fc_fcp_srr_resp,
1682  fc_fcp_pkt_destroy,
1683  fsp, jiffies_to_msecs(rec_tov));
1684  if (!seq)
1685  goto retry;
1686 
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 */
1692  return;
1693 retry:
1694  fc_fcp_retry_cmd(fsp);
1695 }
1696 
1703 static void fc_fcp_srr_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
1704 {
1705  struct fc_fcp_pkt *fsp = arg;
1706  struct fc_frame_header *fh;
1707 
1708  if (IS_ERR(fp)) {
1709  fc_fcp_srr_error(fsp, fp);
1710  return;
1711  }
1712 
1713  if (fc_fcp_lock_pkt(fsp))
1714  goto out;
1715 
1716  fh = fc_frame_header_get(fp);
1717  /*
1718  * BUG? fc_fcp_srr_error calls exch_done which would release
1719  * the ep. But if fc_fcp_srr_error had got -FC_EX_TIMEOUT,
1720  * then fc_exch_timeout would be sending an abort. The exch_done
1721  * call by fc_fcp_srr_error would prevent fc_exch.c from seeing
1722  * an abort response though.
1723  */
1724  if (fh->fh_type == FC_TYPE_BLS) {
1725  fc_fcp_unlock_pkt(fsp);
1726  return;
1727  }
1728 
1729  switch (fc_frame_payload_op(fp)) {
1730  case ELS_LS_ACC:
1731  fsp->recov_retry = 0;
1732  fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
1733  break;
1734  case ELS_LS_RJT:
1735  default:
1736  fc_fcp_recovery(fsp, FC_ERROR);
1737  break;
1738  }
1739  fc_fcp_unlock_pkt(fsp);
1740 out:
1741  fsp->lp->tt.exch_done(seq);
1742  fc_frame_free(fp);
1743 }
1744 
1750 static void fc_fcp_srr_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1751 {
1752  if (fc_fcp_lock_pkt(fsp))
1753  goto out;
1754  switch (PTR_ERR(fp)) {
1755  case -FC_EX_TIMEOUT:
1756  if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1757  fc_fcp_rec(fsp);
1758  else
1759  fc_fcp_recovery(fsp, FC_TIMED_OUT);
1760  break;
1761  case -FC_EX_CLOSED: /* e.g., link failure */
1762  /* fall through */
1763  default:
1764  fc_fcp_retry_cmd(fsp);
1765  break;
1766  }
1767  fc_fcp_unlock_pkt(fsp);
1768 out:
1769  fsp->lp->tt.exch_done(fsp->recov_seq);
1770 }
1771 
1776 static inline int fc_fcp_lport_queue_ready(struct fc_lport *lport)
1777 {
1778  /* lock ? */
1779  return (lport->state == LPORT_ST_READY) &&
1780  lport->link_up && !lport->qfull;
1781 }
1782 
1790 int fc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *sc_cmd)
1791 {
1792  struct fc_lport *lport = shost_priv(shost);
1793  struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
1794  struct fc_fcp_pkt *fsp;
1795  struct fc_rport_libfc_priv *rpriv;
1796  int rval;
1797  int rc = 0;
1798  struct fc_stats *stats;
1799 
1800  rval = fc_remote_port_chkready(rport);
1801  if (rval) {
1802  sc_cmd->result = rval;
1803  sc_cmd->scsi_done(sc_cmd);
1804  return 0;
1805  }
1806 
1807  if (!*(struct fc_remote_port **)rport->dd_data) {
1808  /*
1809  * rport is transitioning from blocked/deleted to
1810  * online
1811  */
1812  sc_cmd->result = DID_IMM_RETRY << 16;
1813  sc_cmd->scsi_done(sc_cmd);
1814  goto out;
1815  }
1816 
1817  rpriv = rport->dd_data;
1818 
1819  if (!fc_fcp_lport_queue_ready(lport)) {
1820  if (lport->qfull)
1821  fc_fcp_can_queue_ramp_down(lport);
1822  rc = SCSI_MLQUEUE_HOST_BUSY;
1823  goto out;
1824  }
1825 
1826  fsp = fc_fcp_pkt_alloc(lport, GFP_ATOMIC);
1827  if (fsp == NULL) {
1828  rc = SCSI_MLQUEUE_HOST_BUSY;
1829  goto out;
1830  }
1831 
1832  /*
1833  * build the libfc request pkt
1834  */
1835  fsp->cmd = sc_cmd; /* save the cmd */
1836  fsp->rport = rport; /* set the remote port ptr */
1837 
1838  /*
1839  * set up the transfer length
1840  */
1841  fsp->data_len = scsi_bufflen(sc_cmd);
1842  fsp->xfer_len = 0;
1843 
1844  /*
1845  * setup the data direction
1846  */
1847  stats = per_cpu_ptr(lport->stats, get_cpu());
1848  if (sc_cmd->sc_data_direction == DMA_FROM_DEVICE) {
1849  fsp->req_flags = FC_SRB_READ;
1850  stats->InputRequests++;
1851  stats->InputBytes += fsp->data_len;
1852  } else if (sc_cmd->sc_data_direction == DMA_TO_DEVICE) {
1853  fsp->req_flags = FC_SRB_WRITE;
1854  stats->OutputRequests++;
1855  stats->OutputBytes += fsp->data_len;
1856  } else {
1857  fsp->req_flags = 0;
1858  stats->ControlRequests++;
1859  }
1860  put_cpu();
1861 
1862  /*
1863  * send it to the lower layer
1864  * if we get -1 return then put the request in the pending
1865  * queue.
1866  */
1867  rval = fc_fcp_pkt_send(lport, fsp);
1868  if (rval != 0) {
1869  fsp->state = FC_SRB_FREE;
1870  fc_fcp_pkt_release(fsp);
1871  rc = SCSI_MLQUEUE_HOST_BUSY;
1872  }
1873 out:
1874  return rc;
1875 }
1876 EXPORT_SYMBOL(fc_queuecommand);
1877 
1885 static void fc_io_compl(struct fc_fcp_pkt *fsp)
1886 {
1887  struct fc_fcp_internal *si;
1888  struct scsi_cmnd *sc_cmd;
1889  struct fc_lport *lport;
1890  unsigned long flags;
1891 
1892  /* release outstanding ddp context */
1893  fc_fcp_ddp_done(fsp);
1894 
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);
1900  }
1901 
1902  lport = fsp->lp;
1903  si = fc_get_scsi_internal(lport);
1904 
1905  /*
1906  * if can_queue ramp down is done then try can_queue ramp up
1907  * since commands are completing now.
1908  */
1909  if (si->last_can_queue_ramp_down_time)
1910  fc_fcp_can_queue_ramp_up(lport);
1911 
1912  sc_cmd = fsp->cmd;
1913  CMD_SCSI_STATUS(sc_cmd) = fsp->cdb_status;
1914  switch (fsp->status_code) {
1915  case FC_COMPLETE:
1916  if (fsp->cdb_status == 0) {
1917  /*
1918  * good I/O status
1919  */
1920  sc_cmd->result = DID_OK << 16;
1921  if (fsp->scsi_resid)
1922  CMD_RESID_LEN(sc_cmd) = fsp->scsi_resid;
1923  } else {
1924  /*
1925  * transport level I/O was ok but scsi
1926  * has non zero status
1927  */
1928  sc_cmd->result = (DID_OK << 16) | fsp->cdb_status;
1929  }
1930  break;
1931  case FC_ERROR:
1932  FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
1933  "due to FC_ERROR\n");
1934  sc_cmd->result = DID_ERROR << 16;
1935  break;
1936  case FC_DATA_UNDRUN:
1937  if ((fsp->cdb_status == 0) && !(fsp->req_flags & FC_SRB_READ)) {
1938  /*
1939  * scsi status is good but transport level
1940  * underrun.
1941  */
1942  if (fsp->state & FC_SRB_RCV_STATUS) {
1943  sc_cmd->result = DID_OK << 16;
1944  } else {
1945  FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml"
1946  " due to FC_DATA_UNDRUN (trans)\n");
1947  sc_cmd->result = DID_ERROR << 16;
1948  }
1949  } else {
1950  /*
1951  * scsi got underrun, this is an error
1952  */
1953  FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
1954  "due to FC_DATA_UNDRUN (scsi)\n");
1955  CMD_RESID_LEN(sc_cmd) = fsp->scsi_resid;
1956  sc_cmd->result = (DID_ERROR << 16) | fsp->cdb_status;
1957  }
1958  break;
1959  case FC_DATA_OVRRUN:
1960  /*
1961  * overrun is an error
1962  */
1963  FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
1964  "due to FC_DATA_OVRRUN\n");
1965  sc_cmd->result = (DID_ERROR << 16) | fsp->cdb_status;
1966  break;
1967  case FC_CMD_ABORTED:
1968  FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
1969  "due to FC_CMD_ABORTED\n");
1970  sc_cmd->result = (DID_ERROR << 16) | fsp->io_status;
1971  break;
1972  case FC_CMD_RESET:
1973  FC_FCP_DBG(fsp, "Returning DID_RESET to scsi-ml "
1974  "due to FC_CMD_RESET\n");
1975  sc_cmd->result = (DID_RESET << 16);
1976  break;
1977  case FC_HRD_ERROR:
1978  FC_FCP_DBG(fsp, "Returning DID_NO_CONNECT to scsi-ml "
1979  "due to FC_HRD_ERROR\n");
1980  sc_cmd->result = (DID_NO_CONNECT << 16);
1981  break;
1982  case FC_CRC_ERROR:
1983  FC_FCP_DBG(fsp, "Returning DID_PARITY to scsi-ml "
1984  "due to FC_CRC_ERROR\n");
1985  sc_cmd->result = (DID_PARITY << 16);
1986  break;
1987  case FC_TIMED_OUT:
1988  FC_FCP_DBG(fsp, "Returning DID_BUS_BUSY to scsi-ml "
1989  "due to FC_TIMED_OUT\n");
1990  sc_cmd->result = (DID_BUS_BUSY << 16) | fsp->io_status;
1991  break;
1992  default:
1993  FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
1994  "due to unknown error\n");
1995  sc_cmd->result = (DID_ERROR << 16);
1996  break;
1997  }
1998 
1999  if (lport->state != LPORT_ST_READY && fsp->status_code != FC_COMPLETE)
2000  sc_cmd->result = (DID_TRANSPORT_DISRUPTED << 16);
2001 
2002  spin_lock_irqsave(&si->scsi_queue_lock, flags);
2003  list_del(&fsp->list);
2004  sc_cmd->SCp.ptr = NULL;
2005  spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
2006  sc_cmd->scsi_done(sc_cmd);
2007 
2008  /* release ref from initial allocation in queue command */
2009  fc_fcp_pkt_release(fsp);
2010 }
2011 
2019 int fc_eh_abort(struct scsi_cmnd *sc_cmd)
2020 {
2021  struct fc_fcp_pkt *fsp;
2022  struct fc_lport *lport;
2023  struct fc_fcp_internal *si;
2024  int rc = FAILED;
2025  unsigned long flags;
2026  int rval;
2027 
2028  rval = fc_block_scsi_eh(sc_cmd);
2029  if (rval)
2030  return rval;
2031 
2032  lport = shost_priv(sc_cmd->device->host);
2033  if (lport->state != LPORT_ST_READY)
2034  return rc;
2035  else if (!lport->link_up)
2036  return rc;
2037 
2038  si = fc_get_scsi_internal(lport);
2039  spin_lock_irqsave(&si->scsi_queue_lock, flags);
2040  fsp = CMD_SP(sc_cmd);
2041  if (!fsp) {
2042  /* command completed while scsi eh was setting up */
2043  spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
2044  return SUCCESS;
2045  }
2046  /* grab a ref so the fsp and sc_cmd cannot be relased from under us */
2047  fc_fcp_pkt_hold(fsp);
2048  spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
2049 
2050  if (fc_fcp_lock_pkt(fsp)) {
2051  /* completed while we were waiting for timer to be deleted */
2052  rc = SUCCESS;
2053  goto release_pkt;
2054  }
2055 
2056  rc = fc_fcp_pkt_abort(fsp);
2057  fc_fcp_unlock_pkt(fsp);
2058 
2059 release_pkt:
2060  fc_fcp_pkt_release(fsp);
2061  return rc;
2062 }
2063 EXPORT_SYMBOL(fc_eh_abort);
2064 
2072 int fc_eh_device_reset(struct scsi_cmnd *sc_cmd)
2073 {
2074  struct fc_lport *lport;
2075  struct fc_fcp_pkt *fsp;
2076  struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
2077  int rc = FAILED;
2078  int rval;
2079 
2080  rval = fc_block_scsi_eh(sc_cmd);
2081  if (rval)
2082  return rval;
2083 
2084  lport = shost_priv(sc_cmd->device->host);
2085 
2086  if (lport->state != LPORT_ST_READY)
2087  return rc;
2088 
2089  FC_SCSI_DBG(lport, "Resetting rport (%6.6x)\n", rport->port_id);
2090 
2091  fsp = fc_fcp_pkt_alloc(lport, GFP_NOIO);
2092  if (fsp == NULL) {
2093  printk(KERN_WARNING "libfc: could not allocate scsi_pkt\n");
2094  goto out;
2095  }
2096 
2097  /*
2098  * Build the libfc request pkt. Do not set the scsi cmnd, because
2099  * the sc passed in is not setup for execution like when sent
2100  * through the queuecommand callout.
2101  */
2102  fsp->rport = rport; /* set the remote port ptr */
2103 
2104  /*
2105  * flush outstanding commands
2106  */
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);
2110 
2111 out:
2112  return rc;
2113 }
2114 EXPORT_SYMBOL(fc_eh_device_reset);
2115 
2120 int fc_eh_host_reset(struct scsi_cmnd *sc_cmd)
2121 {
2122  struct Scsi_Host *shost = sc_cmd->device->host;
2123  struct fc_lport *lport = shost_priv(shost);
2124  unsigned long wait_tmo;
2125 
2126  FC_SCSI_DBG(lport, "Resetting host\n");
2127 
2128  fc_block_scsi_eh(sc_cmd);
2129 
2130  lport->tt.lport_reset(lport);
2131  wait_tmo = jiffies + FC_HOST_RESET_TIMEOUT;
2132  while (!fc_fcp_lport_queue_ready(lport) && time_before(jiffies,
2133  wait_tmo))
2134  msleep(1000);
2135 
2136  if (fc_fcp_lport_queue_ready(lport)) {
2137  shost_printk(KERN_INFO, shost, "libfc: Host reset succeeded "
2138  "on port (%6.6x)\n", lport->port_id);
2139  return SUCCESS;
2140  } else {
2141  shost_printk(KERN_INFO, shost, "libfc: Host reset failed, "
2142  "port (%6.6x) is not ready.\n",
2143  lport->port_id);
2144  return FAILED;
2145  }
2146 }
2147 EXPORT_SYMBOL(fc_eh_host_reset);
2148 
2156 int fc_slave_alloc(struct scsi_device *sdev)
2157 {
2158  struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
2159 
2160  if (!rport || fc_remote_port_chkready(rport))
2161  return -ENXIO;
2162 
2163  if (sdev->tagged_supported)
2164  scsi_activate_tcq(sdev, FC_FCP_DFLT_QUEUE_DEPTH);
2165  else
2166  scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev),
2167  FC_FCP_DFLT_QUEUE_DEPTH);
2168 
2169  return 0;
2170 }
2171 EXPORT_SYMBOL(fc_slave_alloc);
2172 
2179 int fc_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
2180 {
2181  switch (reason) {
2182  case SCSI_QDEPTH_DEFAULT:
2183  scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
2184  break;
2185  case SCSI_QDEPTH_QFULL:
2186  scsi_track_queue_full(sdev, qdepth);
2187  break;
2188  case SCSI_QDEPTH_RAMP_UP:
2189  scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
2190  break;
2191  default:
2192  return -EOPNOTSUPP;
2193  }
2194  return sdev->queue_depth;
2195 }
2196 EXPORT_SYMBOL(fc_change_queue_depth);
2197 
2203 int fc_change_queue_type(struct scsi_device *sdev, int tag_type)
2204 {
2205  if (sdev->tagged_supported) {
2206  scsi_set_tag_type(sdev, tag_type);
2207  if (tag_type)
2208  scsi_activate_tcq(sdev, sdev->queue_depth);
2209  else
2210  scsi_deactivate_tcq(sdev, sdev->queue_depth);
2211  } else
2212  tag_type = 0;
2213 
2214  return tag_type;
2215 }
2216 EXPORT_SYMBOL(fc_change_queue_type);
2217 
2222 void fc_fcp_destroy(struct fc_lport *lport)
2223 {
2224  struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
2225 
2226  if (!list_empty(&si->scsi_pkt_queue))
2227  printk(KERN_ERR "libfc: Leaked SCSI packets when destroying "
2228  "port (%6.6x)\n", lport->port_id);
2229 
2230  mempool_destroy(si->scsi_pkt_pool);
2231  kfree(si);
2232  lport->scsi_priv = NULL;
2233 }
2234 EXPORT_SYMBOL(fc_fcp_destroy);
2235 
2236 int fc_setup_fcp(void)
2237 {
2238  int rc = 0;
2239 
2240  scsi_pkt_cachep = kmem_cache_create("libfc_fcp_pkt",
2241  sizeof(struct fc_fcp_pkt),
2242  0, SLAB_HWCACHE_ALIGN, NULL);
2243  if (!scsi_pkt_cachep) {
2244  printk(KERN_ERR "libfc: Unable to allocate SRB cache, "
2245  "module load failed!");
2246  rc = -ENOMEM;
2247  }
2248 
2249  return rc;
2250 }
2251 
2252 void fc_destroy_fcp(void)
2253 {
2254  if (scsi_pkt_cachep)
2255  kmem_cache_destroy(scsi_pkt_cachep);
2256 }
2257 
2262 int fc_fcp_init(struct fc_lport *lport)
2263 {
2264  int rc;
2265  struct fc_fcp_internal *si;
2266 
2267  if (!lport->tt.fcp_cmd_send)
2268  lport->tt.fcp_cmd_send = fc_fcp_cmd_send;
2269 
2270  if (!lport->tt.fcp_cleanup)
2271  lport->tt.fcp_cleanup = fc_fcp_cleanup;
2272 
2273  if (!lport->tt.fcp_abort_io)
2274  lport->tt.fcp_abort_io = fc_fcp_abort_io;
2275 
2276  si = kzalloc(sizeof(struct fc_fcp_internal), GFP_KERNEL);
2277  if (!si)
2278  return -ENOMEM;
2279  lport->scsi_priv = si;
2280  si->max_can_queue = lport->host->can_queue;
2281  INIT_LIST_HEAD(&si->scsi_pkt_queue);
2282  spin_lock_init(&si->scsi_queue_lock);
2283 
2284  si->scsi_pkt_pool = mempool_create_slab_pool(2, scsi_pkt_cachep);
2285  if (!si->scsi_pkt_pool) {
2286  rc = -ENOMEM;
2287  goto free_internal;
2288  }
2289  return 0;
2290 
2291 free_internal:
2292  kfree(si);
2293  return rc;
2294 }
2295 EXPORT_SYMBOL(fc_fcp_init);
Generated on Thu Jan 10 2013 14:21:26 for Linux Kernel by   doxygen 1.8.2