1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright(c) 2007 Intel Corporation. All rights reserved.
4 * Copyright(c) 2008 Red Hat, Inc. All rights reserved.
5 * Copyright(c) 2008 Mike Christie
6 *
7 * Maintained at www.Open-FCoE.org
8 */
9
10#include <linux/module.h>
11#include <linux/delay.h>
12#include <linux/kernel.h>
13#include <linux/types.h>
14#include <linux/spinlock.h>
15#include <linux/scatterlist.h>
16#include <linux/err.h>
17#include <linux/crc32.h>
18#include <linux/slab.h>
19
20#include <scsi/scsi_tcq.h>
21#include <scsi/scsi.h>
22#include <scsi/scsi_host.h>
23#include <scsi/scsi_device.h>
24#include <scsi/scsi_cmnd.h>
25
26#include <scsi/fc/fc_fc2.h>
27
28#include <scsi/libfc.h>
29
30#include "fc_encode.h"
31#include "fc_libfc.h"
32
33static struct kmem_cache *scsi_pkt_cachep;
34
35/* SRB state definitions */
36#define FC_SRB_FREE 0 /* cmd is free */
37#define FC_SRB_CMD_SENT (1 << 0) /* cmd has been sent */
38#define FC_SRB_RCV_STATUS (1 << 1) /* response has arrived */
39#define FC_SRB_ABORT_PENDING (1 << 2) /* cmd abort sent to device */
40#define FC_SRB_ABORTED (1 << 3) /* abort acknowledged */
41#define FC_SRB_DISCONTIG (1 << 4) /* non-sequential data recvd */
42#define FC_SRB_COMPL (1 << 5) /* fc_io_compl has been run */
43#define FC_SRB_FCP_PROCESSING_TMO (1 << 6) /* timer function processing */
44
45#define FC_SRB_READ (1 << 1)
46#define FC_SRB_WRITE (1 << 0)
47
48static struct libfc_cmd_priv *libfc_priv(struct scsi_cmnd *cmd)
49{
50 return scsi_cmd_priv(cmd);
51}
52
53/**
54 * struct fc_fcp_internal - FCP layer internal data
55 * @scsi_pkt_pool: Memory pool to draw FCP packets from
56 * @scsi_queue_lock: Protects the scsi_pkt_queue
57 * @scsi_pkt_queue: Current FCP packets
58 * @last_can_queue_ramp_down_time: ramp down time
59 * @last_can_queue_ramp_up_time: ramp up time
60 * @max_can_queue: max can_queue size
61 */
62struct fc_fcp_internal {
63 mempool_t *scsi_pkt_pool;
64 spinlock_t scsi_queue_lock;
65 struct list_head scsi_pkt_queue;
66 unsigned long last_can_queue_ramp_down_time;
67 unsigned long last_can_queue_ramp_up_time;
68 int max_can_queue;
69};
70
71#define fc_get_scsi_internal(x) ((struct fc_fcp_internal *)(x)->scsi_priv)
72
73/*
74 * function prototypes
75 * FC scsi I/O related functions
76 */
77static void fc_fcp_recv_data(struct fc_fcp_pkt *, struct fc_frame *);
78static void fc_fcp_recv(struct fc_seq *, struct fc_frame *, void *);
79static void fc_fcp_resp(struct fc_fcp_pkt *, struct fc_frame *);
80static void fc_fcp_complete_locked(struct fc_fcp_pkt *);
81static void fc_tm_done(struct fc_seq *, struct fc_frame *, void *);
82static void fc_fcp_error(struct fc_fcp_pkt *, struct fc_frame *);
83static void fc_fcp_recovery(struct fc_fcp_pkt *, u8 code);
84static void fc_fcp_timeout(struct timer_list *);
85static void fc_fcp_rec(struct fc_fcp_pkt *);
86static void fc_fcp_rec_error(struct fc_fcp_pkt *, struct fc_frame *);
87static void fc_fcp_rec_resp(struct fc_seq *, struct fc_frame *, void *);
88static void fc_io_compl(struct fc_fcp_pkt *);
89
90static void fc_fcp_srr(struct fc_fcp_pkt *, enum fc_rctl, u32);
91static void fc_fcp_srr_resp(struct fc_seq *, struct fc_frame *, void *);
92static void fc_fcp_srr_error(struct fc_fcp_pkt *, struct fc_frame *);
93
94/*
95 * command status codes
96 */
97#define FC_COMPLETE 0
98#define FC_CMD_ABORTED 1
99#define FC_CMD_RESET 2
100#define 3
101#define FC_SNS_RCV 4
102#define FC_TRANS_ERR 5
103#define FC_DATA_OVRRUN 6
104#define FC_DATA_UNDRUN 7
105#define FC_ERROR 8
106#define FC_HRD_ERROR 9
107#define FC_CRC_ERROR 10
108#define FC_TIMED_OUT 11
109#define FC_TRANS_RESET 12
110
111/*
112 * Error recovery timeout values.
113 */
114#define FC_SCSI_TM_TOV (10 * HZ)
115#define FC_HOST_RESET_TIMEOUT (30 * HZ)
116#define FC_CAN_QUEUE_PERIOD (60 * HZ)
117
118#define FC_MAX_ERROR_CNT 5
119#define FC_MAX_RECOV_RETRY 3
120
121#define FC_FCP_DFLT_QUEUE_DEPTH 32
122
123/**
124 * fc_fcp_pkt_alloc() - Allocate a fcp_pkt
125 * @lport: The local port that the FCP packet is for
126 * @gfp: GFP flags for allocation
127 *
128 * Return value: fcp_pkt structure or null on allocation failure.
129 * Context: Can be called from process context, no lock is required.
130 */
131static struct fc_fcp_pkt *fc_fcp_pkt_alloc(struct fc_lport *lport, gfp_t gfp)
132{
133 struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
134 struct fc_fcp_pkt *fsp;
135
136 fsp = mempool_alloc(pool: si->scsi_pkt_pool, gfp_mask: gfp);
137 if (fsp) {
138 memset(fsp, 0, sizeof(*fsp));
139 fsp->lp = lport;
140 fsp->xfer_ddp = FC_XID_UNKNOWN;
141 refcount_set(r: &fsp->ref_cnt, n: 1);
142 timer_setup(&fsp->timer, NULL, 0);
143 INIT_LIST_HEAD(list: &fsp->list);
144 spin_lock_init(&fsp->scsi_pkt_lock);
145 } else {
146 this_cpu_inc(lport->stats->FcpPktAllocFails);
147 }
148 return fsp;
149}
150
151/**
152 * fc_fcp_pkt_release() - Release hold on a fcp_pkt
153 * @fsp: The FCP packet to be released
154 *
155 * Context: Can be called from process or interrupt context,
156 * no lock is required.
157 */
158static void fc_fcp_pkt_release(struct fc_fcp_pkt *fsp)
159{
160 if (refcount_dec_and_test(r: &fsp->ref_cnt)) {
161 struct fc_fcp_internal *si = fc_get_scsi_internal(fsp->lp);
162
163 mempool_free(element: fsp, pool: si->scsi_pkt_pool);
164 }
165}
166
167/**
168 * fc_fcp_pkt_hold() - Hold a fcp_pkt
169 * @fsp: The FCP packet to be held
170 */
171static void fc_fcp_pkt_hold(struct fc_fcp_pkt *fsp)
172{
173 refcount_inc(r: &fsp->ref_cnt);
174}
175
176/**
177 * fc_fcp_pkt_destroy() - Release hold on a fcp_pkt
178 * @seq: The sequence that the FCP packet is on (required by destructor API)
179 * @fsp: The FCP packet to be released
180 *
181 * This routine is called by a destructor callback in the fc_exch_seq_send()
182 * routine of the libfc Transport Template. The 'struct fc_seq' is a required
183 * argument even though it is not used by this routine.
184 *
185 * Context: No locking required.
186 */
187static void fc_fcp_pkt_destroy(struct fc_seq *seq, void *fsp)
188{
189 fc_fcp_pkt_release(fsp);
190}
191
192/**
193 * fc_fcp_lock_pkt() - Lock a fcp_pkt and increase its reference count
194 * @fsp: The FCP packet to be locked and incremented
195 *
196 * We should only return error if we return a command to SCSI-ml before
197 * getting a response. This can happen in cases where we send a abort, but
198 * do not wait for the response and the abort and command can be passing
199 * each other on the wire/network-layer.
200 *
201 * Note: this function locks the packet and gets a reference to allow
202 * callers to call the completion function while the lock is held and
203 * not have to worry about the packets refcount.
204 *
205 * TODO: Maybe we should just have callers grab/release the lock and
206 * have a function that they call to verify the fsp and grab a ref if
207 * needed.
208 */
209static inline int fc_fcp_lock_pkt(struct fc_fcp_pkt *fsp)
210{
211 spin_lock_bh(lock: &fsp->scsi_pkt_lock);
212 if (fsp->state & FC_SRB_COMPL) {
213 spin_unlock_bh(lock: &fsp->scsi_pkt_lock);
214 return -EPERM;
215 }
216
217 fc_fcp_pkt_hold(fsp);
218 return 0;
219}
220
221/**
222 * fc_fcp_unlock_pkt() - Release a fcp_pkt's lock and decrement its
223 * reference count
224 * @fsp: The FCP packet to be unlocked and decremented
225 */
226static inline void fc_fcp_unlock_pkt(struct fc_fcp_pkt *fsp)
227{
228 spin_unlock_bh(lock: &fsp->scsi_pkt_lock);
229 fc_fcp_pkt_release(fsp);
230}
231
232/**
233 * fc_fcp_timer_set() - Start a timer for a fcp_pkt
234 * @fsp: The FCP packet to start a timer for
235 * @delay: The timeout period in jiffies
236 */
237static void fc_fcp_timer_set(struct fc_fcp_pkt *fsp, unsigned long delay)
238{
239 if (!(fsp->state & FC_SRB_COMPL)) {
240 mod_timer(timer: &fsp->timer, expires: jiffies + delay);
241 fsp->timer_delay = delay;
242 }
243}
244
245static void fc_fcp_abort_done(struct fc_fcp_pkt *fsp)
246{
247 fsp->state |= FC_SRB_ABORTED;
248 fsp->state &= ~FC_SRB_ABORT_PENDING;
249
250 if (fsp->wait_for_comp)
251 complete(&fsp->tm_done);
252 else
253 fc_fcp_complete_locked(fsp);
254}
255
256/**
257 * fc_fcp_send_abort() - Send an abort for exchanges associated with a
258 * fcp_pkt
259 * @fsp: The FCP packet to abort exchanges on
260 */
261static int fc_fcp_send_abort(struct fc_fcp_pkt *fsp)
262{
263 int rc;
264
265 if (!fsp->seq_ptr)
266 return -EINVAL;
267
268 this_cpu_inc(fsp->lp->stats->FcpPktAborts);
269
270 fsp->state |= FC_SRB_ABORT_PENDING;
271 rc = fc_seq_exch_abort(fsp->seq_ptr, timer_msec: 0);
272 /*
273 * fc_seq_exch_abort() might return -ENXIO if
274 * the sequence is already completed
275 */
276 if (rc == -ENXIO) {
277 fc_fcp_abort_done(fsp);
278 rc = 0;
279 }
280 return rc;
281}
282
283/**
284 * fc_fcp_retry_cmd() - Retry a fcp_pkt
285 * @fsp: The FCP packet to be retried
286 * @status_code: The FCP status code to set
287 *
288 * Sets the status code to be FC_ERROR and then calls
289 * fc_fcp_complete_locked() which in turn calls fc_io_compl().
290 * fc_io_compl() will notify the SCSI-ml that the I/O is done.
291 * The SCSI-ml will retry the command.
292 */
293static void fc_fcp_retry_cmd(struct fc_fcp_pkt *fsp, int status_code)
294{
295 if (fsp->seq_ptr) {
296 fc_exch_done(sp: fsp->seq_ptr);
297 fsp->seq_ptr = NULL;
298 }
299
300 fsp->state &= ~FC_SRB_ABORT_PENDING;
301 fsp->io_status = 0;
302 fsp->status_code = status_code;
303 fc_fcp_complete_locked(fsp);
304}
305
306/**
307 * fc_fcp_ddp_setup() - Calls a LLD's ddp_setup routine to set up DDP context
308 * @fsp: The FCP packet that will manage the DDP frames
309 * @xid: The XID that will be used for the DDP exchange
310 */
311void fc_fcp_ddp_setup(struct fc_fcp_pkt *fsp, u16 xid)
312{
313 struct fc_lport *lport;
314
315 lport = fsp->lp;
316 if ((fsp->req_flags & FC_SRB_READ) &&
317 (lport->lro_enabled) && (lport->tt.ddp_setup)) {
318 if (lport->tt.ddp_setup(lport, xid, scsi_sglist(cmd: fsp->cmd),
319 scsi_sg_count(cmd: fsp->cmd)))
320 fsp->xfer_ddp = xid;
321 }
322}
323
324/**
325 * fc_fcp_ddp_done() - Calls a LLD's ddp_done routine to release any
326 * DDP related resources for a fcp_pkt
327 * @fsp: The FCP packet that DDP had been used on
328 */
329void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp)
330{
331 struct fc_lport *lport;
332
333 if (!fsp)
334 return;
335
336 if (fsp->xfer_ddp == FC_XID_UNKNOWN)
337 return;
338
339 lport = fsp->lp;
340 if (lport->tt.ddp_done) {
341 fsp->xfer_len = lport->tt.ddp_done(lport, fsp->xfer_ddp);
342 fsp->xfer_ddp = FC_XID_UNKNOWN;
343 }
344}
345
346/**
347 * fc_fcp_can_queue_ramp_up() - increases can_queue
348 * @lport: lport to ramp up can_queue
349 */
350static void fc_fcp_can_queue_ramp_up(struct fc_lport *lport)
351{
352 struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
353 unsigned long flags;
354 int can_queue;
355
356 spin_lock_irqsave(lport->host->host_lock, flags);
357
358 if (si->last_can_queue_ramp_up_time &&
359 (time_before(jiffies, si->last_can_queue_ramp_up_time +
360 FC_CAN_QUEUE_PERIOD)))
361 goto unlock;
362
363 if (time_before(jiffies, si->last_can_queue_ramp_down_time +
364 FC_CAN_QUEUE_PERIOD))
365 goto unlock;
366
367 si->last_can_queue_ramp_up_time = jiffies;
368
369 can_queue = lport->host->can_queue << 1;
370 if (can_queue >= si->max_can_queue) {
371 can_queue = si->max_can_queue;
372 si->last_can_queue_ramp_down_time = 0;
373 }
374 lport->host->can_queue = can_queue;
375 shost_printk(KERN_ERR, lport->host, "libfc: increased "
376 "can_queue to %d.\n", can_queue);
377
378unlock:
379 spin_unlock_irqrestore(lock: lport->host->host_lock, flags);
380}
381
382/**
383 * fc_fcp_can_queue_ramp_down() - reduces can_queue
384 * @lport: lport to reduce can_queue
385 *
386 * If we are getting memory allocation failures, then we may
387 * be trying to execute too many commands. We let the running
388 * commands complete or timeout, then try again with a reduced
389 * can_queue. Eventually we will hit the point where we run
390 * on all reserved structs.
391 */
392static bool fc_fcp_can_queue_ramp_down(struct fc_lport *lport)
393{
394 struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
395 unsigned long flags;
396 int can_queue;
397 bool changed = false;
398
399 spin_lock_irqsave(lport->host->host_lock, flags);
400
401 if (si->last_can_queue_ramp_down_time &&
402 (time_before(jiffies, si->last_can_queue_ramp_down_time +
403 FC_CAN_QUEUE_PERIOD)))
404 goto unlock;
405
406 si->last_can_queue_ramp_down_time = jiffies;
407
408 can_queue = lport->host->can_queue;
409 can_queue >>= 1;
410 if (!can_queue)
411 can_queue = 1;
412 lport->host->can_queue = can_queue;
413 changed = true;
414
415unlock:
416 spin_unlock_irqrestore(lock: lport->host->host_lock, flags);
417 return changed;
418}
419
420/*
421 * fc_fcp_frame_alloc() - Allocates fc_frame structure and buffer.
422 * @lport: fc lport struct
423 * @len: payload length
424 *
425 * Allocates fc_frame structure and buffer but if fails to allocate
426 * then reduce can_queue.
427 */
428static inline struct fc_frame *fc_fcp_frame_alloc(struct fc_lport *lport,
429 size_t len)
430{
431 struct fc_frame *fp;
432
433 fp = fc_frame_alloc(dev: lport, len);
434 if (likely(fp))
435 return fp;
436
437 this_cpu_inc(lport->stats->FcpFrameAllocFails);
438 /* error case */
439 fc_fcp_can_queue_ramp_down(lport);
440 shost_printk(KERN_ERR, lport->host,
441 "libfc: Could not allocate frame, "
442 "reducing can_queue to %d.\n", lport->host->can_queue);
443 return NULL;
444}
445
446/**
447 * get_fsp_rec_tov() - Helper function to get REC_TOV
448 * @fsp: the FCP packet
449 *
450 * Returns rec tov in jiffies as rpriv->e_d_tov + 1 second
451 */
452static inline unsigned int get_fsp_rec_tov(struct fc_fcp_pkt *fsp)
453{
454 struct fc_rport_libfc_priv *rpriv = fsp->rport->dd_data;
455 unsigned int e_d_tov = FC_DEF_E_D_TOV;
456
457 if (rpriv && rpriv->e_d_tov > e_d_tov)
458 e_d_tov = rpriv->e_d_tov;
459 return msecs_to_jiffies(m: e_d_tov) + HZ;
460}
461
462/**
463 * fc_fcp_recv_data() - Handler for receiving SCSI-FCP data from a target
464 * @fsp: The FCP packet the data is on
465 * @fp: The data frame
466 */
467static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
468{
469 struct scsi_cmnd *sc = fsp->cmd;
470 struct fc_lport *lport = fsp->lp;
471 struct fc_frame_header *fh;
472 size_t start_offset;
473 size_t offset;
474 u32 crc;
475 u32 copy_len = 0;
476 size_t len;
477 void *buf;
478 struct scatterlist *sg;
479 u32 nents;
480 u8 host_bcode = FC_COMPLETE;
481
482 fh = fc_frame_header_get(fp);
483 offset = ntohl(fh->fh_parm_offset);
484 start_offset = offset;
485 len = fr_len(fp) - sizeof(*fh);
486 buf = fc_frame_payload_get(fp, len: 0);
487
488 /*
489 * if this I/O is ddped then clear it and initiate recovery since data
490 * frames are expected to be placed directly in that case.
491 *
492 * Indicate error to scsi-ml because something went wrong with the
493 * ddp handling to get us here.
494 */
495 if (fsp->xfer_ddp != FC_XID_UNKNOWN) {
496 fc_fcp_ddp_done(fsp);
497 FC_FCP_DBG(fsp, "DDP I/O in fc_fcp_recv_data set ERROR\n");
498 host_bcode = FC_ERROR;
499 goto err;
500 }
501 if (offset + len > fsp->data_len) {
502 /* this should never happen */
503 if ((fr_flags(fp) & FCPHF_CRC_UNCHECKED) &&
504 fc_frame_crc_check(fp))
505 goto crc_err;
506 FC_FCP_DBG(fsp, "data received past end. len %zx offset %zx "
507 "data_len %x\n", len, offset, fsp->data_len);
508
509 /* Data is corrupted indicate scsi-ml should retry */
510 host_bcode = FC_DATA_OVRRUN;
511 goto err;
512 }
513 if (offset != fsp->xfer_len)
514 fsp->state |= FC_SRB_DISCONTIG;
515
516 sg = scsi_sglist(cmd: sc);
517 nents = scsi_sg_count(cmd: sc);
518
519 if (!(fr_flags(fp) & FCPHF_CRC_UNCHECKED)) {
520 copy_len = fc_copy_buffer_to_sglist(buf, len, sg, nents: &nents,
521 offset: &offset, NULL);
522 } else {
523 crc = crc32(~0, (u8 *) fh, sizeof(*fh));
524 copy_len = fc_copy_buffer_to_sglist(buf, len, sg, nents: &nents,
525 offset: &offset, crc: &crc);
526 buf = fc_frame_payload_get(fp, len: 0);
527 if (len % 4)
528 crc = crc32(crc, buf + len, 4 - (len % 4));
529
530 if (~crc != le32_to_cpu(fr_crc(fp))) {
531crc_err:
532 this_cpu_inc(lport->stats->ErrorFrames);
533 /* per cpu count, not total count, but OK for limit */
534 if (this_cpu_inc_return(lport->stats->InvalidCRCCount) < FC_MAX_ERROR_CNT)
535 printk(KERN_WARNING "libfc: CRC error on data "
536 "frame for port (%6.6x)\n",
537 lport->port_id);
538 /*
539 * Assume the frame is total garbage.
540 * We may have copied it over the good part
541 * of the buffer.
542 * If so, we need to retry the entire operation.
543 * Otherwise, ignore it.
544 */
545 if (fsp->state & FC_SRB_DISCONTIG) {
546 host_bcode = FC_CRC_ERROR;
547 goto err;
548 }
549 return;
550 }
551 }
552
553 if (fsp->xfer_contig_end == start_offset)
554 fsp->xfer_contig_end += copy_len;
555 fsp->xfer_len += copy_len;
556
557 /*
558 * In the very rare event that this data arrived after the response
559 * and completes the transfer, call the completion handler.
560 */
561 if (unlikely(fsp->state & FC_SRB_RCV_STATUS) &&
562 fsp->xfer_len == fsp->data_len - fsp->scsi_resid) {
563 FC_FCP_DBG( fsp, "complete out-of-order sequence\n" );
564 fc_fcp_complete_locked(fsp);
565 }
566 return;
567err:
568 fc_fcp_recovery(fsp, code: host_bcode);
569}
570
571/**
572 * fc_fcp_send_data() - Send SCSI data to a target
573 * @fsp: The FCP packet the data is on
574 * @seq: The sequence the data is to be sent on
575 * @offset: The starting offset for this data request
576 * @seq_blen: The burst length for this data request
577 *
578 * Called after receiving a Transfer Ready data descriptor.
579 * If the LLD is capable of sequence offload then send down the
580 * seq_blen amount of data in single frame, otherwise send
581 * multiple frames of the maximum frame payload supported by
582 * the target port.
583 */
584static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
585 size_t offset, size_t seq_blen)
586{
587 struct fc_exch *ep;
588 struct scsi_cmnd *sc;
589 struct scatterlist *sg;
590 struct fc_frame *fp = NULL;
591 struct fc_lport *lport = fsp->lp;
592 struct page *page;
593 size_t remaining;
594 size_t t_blen;
595 size_t tlen;
596 size_t sg_bytes;
597 size_t frame_offset, fh_parm_offset;
598 size_t off;
599 int error;
600 void *data = NULL;
601 void *page_addr;
602 int using_sg = lport->sg_supp;
603 u32 f_ctl;
604
605 WARN_ON(seq_blen <= 0);
606 if (unlikely(offset + seq_blen > fsp->data_len)) {
607 /* this should never happen */
608 FC_FCP_DBG(fsp, "xfer-ready past end. seq_blen %zx "
609 "offset %zx\n", seq_blen, offset);
610 fc_fcp_send_abort(fsp);
611 return 0;
612 } else if (offset != fsp->xfer_len) {
613 /* Out of Order Data Request - no problem, but unexpected. */
614 FC_FCP_DBG(fsp, "xfer-ready non-contiguous. "
615 "seq_blen %zx offset %zx\n", seq_blen, offset);
616 }
617
618 /*
619 * if LLD is capable of seq_offload then set transport
620 * burst length (t_blen) to seq_blen, otherwise set t_blen
621 * to max FC frame payload previously set in fsp->max_payload.
622 */
623 t_blen = fsp->max_payload;
624 if (lport->seq_offload) {
625 t_blen = min(seq_blen, (size_t)lport->lso_max);
626 FC_FCP_DBG(fsp, "fsp=%p:lso:blen=%zx lso_max=0x%x t_blen=%zx\n",
627 fsp, seq_blen, lport->lso_max, t_blen);
628 }
629
630 if (t_blen > 512)
631 t_blen &= ~(512 - 1); /* round down to block size */
632 sc = fsp->cmd;
633
634 remaining = seq_blen;
635 fh_parm_offset = frame_offset = offset;
636 tlen = 0;
637 seq = fc_seq_start_next(sp: seq);
638 f_ctl = FC_FC_REL_OFF;
639 WARN_ON(!seq);
640
641 sg = scsi_sglist(cmd: sc);
642
643 while (remaining > 0 && sg) {
644 if (offset >= sg->length) {
645 offset -= sg->length;
646 sg = sg_next(sg);
647 continue;
648 }
649 if (!fp) {
650 tlen = min(t_blen, remaining);
651
652 /*
653 * TODO. Temporary workaround. fc_seq_send() can't
654 * handle odd lengths in non-linear skbs.
655 * This will be the final fragment only.
656 */
657 if (tlen % 4)
658 using_sg = 0;
659 fp = fc_frame_alloc(dev: lport, len: using_sg ? 0 : tlen);
660 if (!fp)
661 return -ENOMEM;
662
663 data = fc_frame_header_get(fp) + 1;
664 fh_parm_offset = frame_offset;
665 fr_max_payload(fp) = fsp->max_payload;
666 }
667
668 off = offset + sg->offset;
669 sg_bytes = min(tlen, sg->length - offset);
670 sg_bytes = min(sg_bytes,
671 (size_t) (PAGE_SIZE - (off & ~PAGE_MASK)));
672 page = sg_page(sg) + (off >> PAGE_SHIFT);
673 if (using_sg) {
674 get_page(page);
675 skb_fill_page_desc(fp_skb(fp),
676 skb_shinfo(fp_skb(fp))->nr_frags,
677 page, off: off & ~PAGE_MASK, size: sg_bytes);
678 fp_skb(fp)->data_len += sg_bytes;
679 fr_len(fp) += sg_bytes;
680 fp_skb(fp)->truesize += PAGE_SIZE;
681 } else {
682 /*
683 * The scatterlist item may be bigger than PAGE_SIZE,
684 * but we must not cross pages inside the kmap.
685 */
686 page_addr = kmap_atomic(page);
687 memcpy(data, (char *)page_addr + (off & ~PAGE_MASK),
688 sg_bytes);
689 kunmap_atomic(page_addr);
690 data += sg_bytes;
691 }
692 offset += sg_bytes;
693 frame_offset += sg_bytes;
694 tlen -= sg_bytes;
695 remaining -= sg_bytes;
696
697 if ((skb_shinfo(fp_skb(fp))->nr_frags < FC_FRAME_SG_LEN) &&
698 (tlen))
699 continue;
700
701 /*
702 * Send sequence with transfer sequence initiative in case
703 * this is last FCP frame of the sequence.
704 */
705 if (remaining == 0)
706 f_ctl |= FC_FC_SEQ_INIT | FC_FC_END_SEQ;
707
708 ep = fc_seq_exch(seq);
709 fc_fill_fc_hdr(fp, r_ctl: FC_RCTL_DD_SOL_DATA, did: ep->did, sid: ep->sid,
710 type: FC_TYPE_FCP, f_ctl, parm_offset: fh_parm_offset);
711
712 /*
713 * send fragment using for a sequence.
714 */
715 error = fc_seq_send(lport, sp: seq, fp);
716 if (error) {
717 WARN_ON(1); /* send error should be rare */
718 return error;
719 }
720 fp = NULL;
721 }
722 fsp->xfer_len += seq_blen; /* premature count? */
723 return 0;
724}
725
726/**
727 * fc_fcp_abts_resp() - Receive an ABTS response
728 * @fsp: The FCP packet that is being aborted
729 * @fp: The response frame
730 */
731static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
732{
733 int ba_done = 1;
734 struct fc_ba_rjt *brp;
735 struct fc_frame_header *fh;
736
737 fh = fc_frame_header_get(fp);
738 switch (fh->fh_r_ctl) {
739 case FC_RCTL_BA_ACC:
740 break;
741 case FC_RCTL_BA_RJT:
742 brp = fc_frame_payload_get(fp, len: sizeof(*brp));
743 if (brp && brp->br_reason == FC_BA_RJT_LOG_ERR)
744 break;
745 fallthrough;
746 default:
747 /*
748 * we will let the command timeout
749 * and scsi-ml recover in this case,
750 * therefore cleared the ba_done flag.
751 */
752 ba_done = 0;
753 }
754
755 if (ba_done)
756 fc_fcp_abort_done(fsp);
757}
758
759/**
760 * fc_fcp_recv() - Receive an FCP frame
761 * @seq: The sequence the frame is on
762 * @fp: The received frame
763 * @arg: The related FCP packet
764 *
765 * Context: Called from Soft IRQ context. Can not be called
766 * holding the FCP packet list lock.
767 */
768static void fc_fcp_recv(struct fc_seq *seq, struct fc_frame *fp, void *arg)
769{
770 struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)arg;
771 struct fc_lport *lport = fsp->lp;
772 struct fc_frame_header *fh;
773 struct fcp_txrdy *dd;
774 u8 r_ctl;
775 int rc = 0;
776
777 if (IS_ERR(ptr: fp)) {
778 fc_fcp_error(fsp, fp);
779 return;
780 }
781
782 fh = fc_frame_header_get(fp);
783 r_ctl = fh->fh_r_ctl;
784
785 if (lport->state != LPORT_ST_READY) {
786 FC_FCP_DBG(fsp, "lport state %d, ignoring r_ctl %x\n",
787 lport->state, r_ctl);
788 goto out;
789 }
790 if (fc_fcp_lock_pkt(fsp))
791 goto out;
792
793 if (fh->fh_type == FC_TYPE_BLS) {
794 fc_fcp_abts_resp(fsp, fp);
795 goto unlock;
796 }
797
798 if (fsp->state & (FC_SRB_ABORTED | FC_SRB_ABORT_PENDING)) {
799 FC_FCP_DBG(fsp, "command aborted, ignoring r_ctl %x\n", r_ctl);
800 goto unlock;
801 }
802
803 if (r_ctl == FC_RCTL_DD_DATA_DESC) {
804 /*
805 * received XFER RDY from the target
806 * need to send data to the target
807 */
808 WARN_ON(fr_flags(fp) & FCPHF_CRC_UNCHECKED);
809 dd = fc_frame_payload_get(fp, len: sizeof(*dd));
810 WARN_ON(!dd);
811
812 rc = fc_fcp_send_data(fsp, seq,
813 offset: (size_t) ntohl(dd->ft_data_ro),
814 seq_blen: (size_t) ntohl(dd->ft_burst_len));
815 if (!rc)
816 seq->rec_data = fsp->xfer_len;
817 } else if (r_ctl == FC_RCTL_DD_SOL_DATA) {
818 /*
819 * received a DATA frame
820 * next we will copy the data to the system buffer
821 */
822 WARN_ON(fr_len(fp) < sizeof(*fh)); /* len may be 0 */
823 fc_fcp_recv_data(fsp, fp);
824 seq->rec_data = fsp->xfer_contig_end;
825 } else if (r_ctl == FC_RCTL_DD_CMD_STATUS) {
826 WARN_ON(fr_flags(fp) & FCPHF_CRC_UNCHECKED);
827
828 fc_fcp_resp(fsp, fp);
829 } else {
830 FC_FCP_DBG(fsp, "unexpected frame. r_ctl %x\n", r_ctl);
831 }
832unlock:
833 fc_fcp_unlock_pkt(fsp);
834out:
835 fc_frame_free(fp);
836}
837
838/**
839 * fc_fcp_resp() - Handler for FCP responses
840 * @fsp: The FCP packet the response is for
841 * @fp: The response frame
842 */
843static void fc_fcp_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
844{
845 struct fc_frame_header *fh;
846 struct fcp_resp *fc_rp;
847 struct fcp_resp_ext *rp_ex;
848 struct fcp_resp_rsp_info *fc_rp_info;
849 u32 plen;
850 u32 expected_len;
851 u32 respl = 0;
852 u32 snsl = 0;
853 u8 flags = 0;
854
855 plen = fr_len(fp);
856 fh = (struct fc_frame_header *)fr_hdr(fp);
857 if (unlikely(plen < sizeof(*fh) + sizeof(*fc_rp)))
858 goto len_err;
859 plen -= sizeof(*fh);
860 fc_rp = (struct fcp_resp *)(fh + 1);
861 fsp->cdb_status = fc_rp->fr_status;
862 flags = fc_rp->fr_flags;
863 fsp->scsi_comp_flags = flags;
864 expected_len = fsp->data_len;
865
866 /* if ddp, update xfer len */
867 fc_fcp_ddp_done(fsp);
868
869 if (unlikely((flags & ~FCP_CONF_REQ) || fc_rp->fr_status)) {
870 rp_ex = (void *)(fc_rp + 1);
871 if (flags & (FCP_RSP_LEN_VAL | FCP_SNS_LEN_VAL)) {
872 if (plen < sizeof(*fc_rp) + sizeof(*rp_ex))
873 goto len_err;
874 fc_rp_info = (struct fcp_resp_rsp_info *)(rp_ex + 1);
875 if (flags & FCP_RSP_LEN_VAL) {
876 respl = ntohl(rp_ex->fr_rsp_len);
877 if ((respl != FCP_RESP_RSP_INFO_LEN4) &&
878 (respl != FCP_RESP_RSP_INFO_LEN8))
879 goto len_err;
880 if (fsp->wait_for_comp) {
881 /* Abuse cdb_status for rsp code */
882 fsp->cdb_status = fc_rp_info->rsp_code;
883 complete(&fsp->tm_done);
884 /*
885 * tmfs will not have any scsi cmd so
886 * exit here
887 */
888 return;
889 }
890 }
891 if (flags & FCP_SNS_LEN_VAL) {
892 snsl = ntohl(rp_ex->fr_sns_len);
893 if (snsl > SCSI_SENSE_BUFFERSIZE)
894 snsl = SCSI_SENSE_BUFFERSIZE;
895 memcpy(fsp->cmd->sense_buffer,
896 (char *)fc_rp_info + respl, snsl);
897 }
898 }
899 if (flags & (FCP_RESID_UNDER | FCP_RESID_OVER)) {
900 if (plen < sizeof(*fc_rp) + sizeof(rp_ex->fr_resid))
901 goto len_err;
902 if (flags & FCP_RESID_UNDER) {
903 fsp->scsi_resid = ntohl(rp_ex->fr_resid);
904 /*
905 * The cmnd->underflow is the minimum number of
906 * bytes that must be transferred for this
907 * command. Provided a sense condition is not
908 * present, make sure the actual amount
909 * transferred is at least the underflow value
910 * or fail.
911 */
912 if (!(flags & FCP_SNS_LEN_VAL) &&
913 (fc_rp->fr_status == 0) &&
914 (scsi_bufflen(cmd: fsp->cmd) -
915 fsp->scsi_resid) < fsp->cmd->underflow)
916 goto err;
917 expected_len -= fsp->scsi_resid;
918 } else {
919 fsp->status_code = FC_ERROR;
920 }
921 }
922 }
923 fsp->state |= FC_SRB_RCV_STATUS;
924
925 /*
926 * Check for missing or extra data frames.
927 */
928 if (unlikely(fsp->cdb_status == SAM_STAT_GOOD &&
929 fsp->xfer_len != expected_len)) {
930 if (fsp->xfer_len < expected_len) {
931 /*
932 * Some data may be queued locally,
933 * Wait a at least one jiffy to see if it is delivered.
934 * If this expires without data, we may do SRR.
935 */
936 if (fsp->lp->qfull) {
937 FC_FCP_DBG(fsp, "tgt %6.6x queue busy retry\n",
938 fsp->rport->port_id);
939 return;
940 }
941 FC_FCP_DBG(fsp, "tgt %6.6x xfer len %zx data underrun "
942 "len %x, data len %x\n",
943 fsp->rport->port_id,
944 fsp->xfer_len, expected_len, fsp->data_len);
945 fc_fcp_timer_set(fsp, delay: get_fsp_rec_tov(fsp));
946 return;
947 }
948 fsp->status_code = FC_DATA_OVRRUN;
949 FC_FCP_DBG(fsp, "tgt %6.6x xfer len %zx greater than expected, "
950 "len %x, data len %x\n",
951 fsp->rport->port_id,
952 fsp->xfer_len, expected_len, fsp->data_len);
953 }
954 fc_fcp_complete_locked(fsp);
955 return;
956
957len_err:
958 FC_FCP_DBG(fsp, "short FCP response. flags 0x%x len %u respl %u "
959 "snsl %u\n", flags, fr_len(fp), respl, snsl);
960err:
961 fsp->status_code = FC_ERROR;
962 fc_fcp_complete_locked(fsp);
963}
964
965/**
966 * fc_fcp_complete_locked() - Complete processing of a fcp_pkt with the
967 * fcp_pkt lock held
968 * @fsp: The FCP packet to be completed
969 *
970 * This function may sleep if a timer is pending. The packet lock must be
971 * held, and the host lock must not be held.
972 */
973static void fc_fcp_complete_locked(struct fc_fcp_pkt *fsp)
974{
975 struct fc_lport *lport = fsp->lp;
976 struct fc_seq *seq;
977 struct fc_exch *ep;
978 u32 f_ctl;
979
980 if (fsp->state & FC_SRB_ABORT_PENDING)
981 return;
982
983 if (fsp->state & FC_SRB_ABORTED) {
984 if (!fsp->status_code)
985 fsp->status_code = FC_CMD_ABORTED;
986 } else {
987 /*
988 * Test for transport underrun, independent of response
989 * underrun status.
990 */
991 if (fsp->cdb_status == SAM_STAT_GOOD &&
992 fsp->xfer_len < fsp->data_len && !fsp->io_status &&
993 (!(fsp->scsi_comp_flags & FCP_RESID_UNDER) ||
994 fsp->xfer_len < fsp->data_len - fsp->scsi_resid)) {
995 FC_FCP_DBG(fsp, "data underrun, xfer %zx data %x\n",
996 fsp->xfer_len, fsp->data_len);
997 fsp->status_code = FC_DATA_UNDRUN;
998 }
999 }
1000
1001 seq = fsp->seq_ptr;
1002 if (seq) {
1003 fsp->seq_ptr = NULL;
1004 if (unlikely(fsp->scsi_comp_flags & FCP_CONF_REQ)) {
1005 struct fc_frame *conf_frame;
1006 struct fc_seq *csp;
1007
1008 csp = fc_seq_start_next(sp: seq);
1009 conf_frame = fc_fcp_frame_alloc(lport: fsp->lp, len: 0);
1010 if (conf_frame) {
1011 f_ctl = FC_FC_SEQ_INIT;
1012 f_ctl |= FC_FC_LAST_SEQ | FC_FC_END_SEQ;
1013 ep = fc_seq_exch(seq);
1014 fc_fill_fc_hdr(fp: conf_frame, r_ctl: FC_RCTL_DD_SOL_CTL,
1015 did: ep->did, sid: ep->sid,
1016 type: FC_TYPE_FCP, f_ctl, parm_offset: 0);
1017 fc_seq_send(lport, sp: csp, fp: conf_frame);
1018 }
1019 }
1020 fc_exch_done(sp: seq);
1021 }
1022 /*
1023 * Some resets driven by SCSI are not I/Os and do not have
1024 * SCSI commands associated with the requests. We should not
1025 * call I/O completion if we do not have a SCSI command.
1026 */
1027 if (fsp->cmd)
1028 fc_io_compl(fsp);
1029}
1030
1031/**
1032 * fc_fcp_cleanup_cmd() - Cancel the active exchange on a fcp_pkt
1033 * @fsp: The FCP packet whose exchanges should be canceled
1034 * @error: The reason for the cancellation
1035 */
1036static void fc_fcp_cleanup_cmd(struct fc_fcp_pkt *fsp, int error)
1037{
1038 if (fsp->seq_ptr) {
1039 fc_exch_done(sp: fsp->seq_ptr);
1040 fsp->seq_ptr = NULL;
1041 }
1042 fsp->status_code = error;
1043}
1044
1045/**
1046 * fc_fcp_cleanup_each_cmd() - Cancel all exchanges on a local port
1047 * @lport: The local port whose exchanges should be canceled
1048 * @id: The target's ID
1049 * @lun: The LUN
1050 * @error: The reason for cancellation
1051 *
1052 * If lun or id is -1, they are ignored.
1053 */
1054static void fc_fcp_cleanup_each_cmd(struct fc_lport *lport, unsigned int id,
1055 unsigned int lun, int error)
1056{
1057 struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
1058 struct fc_fcp_pkt *fsp;
1059 struct scsi_cmnd *sc_cmd;
1060 unsigned long flags;
1061
1062 spin_lock_irqsave(&si->scsi_queue_lock, flags);
1063restart:
1064 list_for_each_entry(fsp, &si->scsi_pkt_queue, list) {
1065 sc_cmd = fsp->cmd;
1066 if (id != -1 && scmd_id(sc_cmd) != id)
1067 continue;
1068
1069 if (lun != -1 && sc_cmd->device->lun != lun)
1070 continue;
1071
1072 fc_fcp_pkt_hold(fsp);
1073 spin_unlock_irqrestore(lock: &si->scsi_queue_lock, flags);
1074
1075 spin_lock_bh(lock: &fsp->scsi_pkt_lock);
1076 if (!(fsp->state & FC_SRB_COMPL)) {
1077 fsp->state |= FC_SRB_COMPL;
1078 /*
1079 * TODO: dropping scsi_pkt_lock and then reacquiring
1080 * again around fc_fcp_cleanup_cmd() is required,
1081 * since fc_fcp_cleanup_cmd() calls into
1082 * fc_seq_set_resp() and that func preempts cpu using
1083 * schedule. May be schedule and related code should be
1084 * removed instead of unlocking here to avoid scheduling
1085 * while atomic bug.
1086 */
1087 spin_unlock_bh(lock: &fsp->scsi_pkt_lock);
1088
1089 fc_fcp_cleanup_cmd(fsp, error);
1090
1091 spin_lock_bh(lock: &fsp->scsi_pkt_lock);
1092 fc_io_compl(fsp);
1093 }
1094 spin_unlock_bh(lock: &fsp->scsi_pkt_lock);
1095
1096 fc_fcp_pkt_release(fsp);
1097 spin_lock_irqsave(&si->scsi_queue_lock, flags);
1098 /*
1099 * while we dropped the lock multiple pkts could
1100 * have been released, so we have to start over.
1101 */
1102 goto restart;
1103 }
1104 spin_unlock_irqrestore(lock: &si->scsi_queue_lock, flags);
1105}
1106
1107/**
1108 * fc_fcp_abort_io() - Abort all FCP-SCSI exchanges on a local port
1109 * @lport: The local port whose exchanges are to be aborted
1110 */
1111static void fc_fcp_abort_io(struct fc_lport *lport)
1112{
1113 fc_fcp_cleanup_each_cmd(lport, id: -1, lun: -1, FC_HRD_ERROR);
1114}
1115
1116/**
1117 * fc_fcp_pkt_send() - Send a fcp_pkt
1118 * @lport: The local port to send the FCP packet on
1119 * @fsp: The FCP packet to send
1120 *
1121 * Return: Zero for success and -1 for failure
1122 * Locks: Called without locks held
1123 */
1124static int fc_fcp_pkt_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp)
1125{
1126 struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
1127 unsigned long flags;
1128 int rc;
1129
1130 libfc_priv(cmd: fsp->cmd)->fsp = fsp;
1131 fsp->cdb_cmd.fc_dl = htonl(fsp->data_len);
1132 fsp->cdb_cmd.fc_flags = fsp->req_flags & ~FCP_CFL_LEN_MASK;
1133
1134 int_to_scsilun(fsp->cmd->device->lun, &fsp->cdb_cmd.fc_lun);
1135 memcpy(fsp->cdb_cmd.fc_cdb, fsp->cmd->cmnd, fsp->cmd->cmd_len);
1136
1137 spin_lock_irqsave(&si->scsi_queue_lock, flags);
1138 list_add_tail(new: &fsp->list, head: &si->scsi_pkt_queue);
1139 spin_unlock_irqrestore(lock: &si->scsi_queue_lock, flags);
1140 rc = lport->tt.fcp_cmd_send(lport, fsp, fc_fcp_recv);
1141 if (unlikely(rc)) {
1142 spin_lock_irqsave(&si->scsi_queue_lock, flags);
1143 libfc_priv(cmd: fsp->cmd)->fsp = NULL;
1144 list_del(entry: &fsp->list);
1145 spin_unlock_irqrestore(lock: &si->scsi_queue_lock, flags);
1146 }
1147
1148 return rc;
1149}
1150
1151/**
1152 * fc_fcp_cmd_send() - Send a FCP command
1153 * @lport: The local port to send the command on
1154 * @fsp: The FCP packet the command is on
1155 * @resp: The handler for the response
1156 */
1157static int fc_fcp_cmd_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
1158 void (*resp)(struct fc_seq *,
1159 struct fc_frame *fp,
1160 void *arg))
1161{
1162 struct fc_frame *fp;
1163 struct fc_seq *seq;
1164 struct fc_rport *rport;
1165 struct fc_rport_libfc_priv *rpriv;
1166 const size_t len = sizeof(fsp->cdb_cmd);
1167 int rc = 0;
1168
1169 if (fc_fcp_lock_pkt(fsp))
1170 return 0;
1171
1172 fp = fc_fcp_frame_alloc(lport, len: sizeof(fsp->cdb_cmd));
1173 if (!fp) {
1174 rc = -1;
1175 goto unlock;
1176 }
1177
1178 memcpy(fc_frame_payload_get(fp, len), &fsp->cdb_cmd, len);
1179 fr_fsp(fp) = fsp;
1180 rport = fsp->rport;
1181 fsp->max_payload = rport->maxframe_size;
1182 rpriv = rport->dd_data;
1183
1184 fc_fill_fc_hdr(fp, r_ctl: FC_RCTL_DD_UNSOL_CMD, did: rport->port_id,
1185 sid: rpriv->local_port->port_id, type: FC_TYPE_FCP,
1186 FC_FCTL_REQ, parm_offset: 0);
1187
1188 seq = fc_exch_seq_send(lport, fp, resp, destructor: fc_fcp_pkt_destroy, arg: fsp, timer_msec: 0);
1189 if (!seq) {
1190 rc = -1;
1191 goto unlock;
1192 }
1193 fsp->seq_ptr = seq;
1194 fc_fcp_pkt_hold(fsp); /* hold for fc_fcp_pkt_destroy */
1195
1196 fsp->timer.function = fc_fcp_timeout;
1197 if (rpriv->flags & FC_RP_FLAGS_REC_SUPPORTED)
1198 fc_fcp_timer_set(fsp, delay: get_fsp_rec_tov(fsp));
1199
1200unlock:
1201 fc_fcp_unlock_pkt(fsp);
1202 return rc;
1203}
1204
1205/**
1206 * fc_fcp_error() - Handler for FCP layer errors
1207 * @fsp: The FCP packet the error is on
1208 * @fp: The frame that has errored
1209 */
1210static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1211{
1212 int error = PTR_ERR(ptr: fp);
1213
1214 if (fc_fcp_lock_pkt(fsp))
1215 return;
1216
1217 if (error == -FC_EX_CLOSED) {
1218 fc_fcp_retry_cmd(fsp, FC_ERROR);
1219 goto unlock;
1220 }
1221
1222 /*
1223 * clear abort pending, because the lower layer
1224 * decided to force completion.
1225 */
1226 fsp->state &= ~FC_SRB_ABORT_PENDING;
1227 fsp->status_code = FC_CMD_PLOGO;
1228 fc_fcp_complete_locked(fsp);
1229unlock:
1230 fc_fcp_unlock_pkt(fsp);
1231}
1232
1233/**
1234 * fc_fcp_pkt_abort() - Abort a fcp_pkt
1235 * @fsp: The FCP packet to abort on
1236 *
1237 * Called to send an abort and then wait for abort completion
1238 */
1239static int fc_fcp_pkt_abort(struct fc_fcp_pkt *fsp)
1240{
1241 int rc = FAILED;
1242 unsigned long ticks_left;
1243
1244 FC_FCP_DBG(fsp, "pkt abort state %x\n", fsp->state);
1245 if (fc_fcp_send_abort(fsp)) {
1246 FC_FCP_DBG(fsp, "failed to send abort\n");
1247 return FAILED;
1248 }
1249
1250 if (fsp->state & FC_SRB_ABORTED) {
1251 FC_FCP_DBG(fsp, "target abort cmd completed\n");
1252 return SUCCESS;
1253 }
1254
1255 init_completion(x: &fsp->tm_done);
1256 fsp->wait_for_comp = 1;
1257
1258 spin_unlock_bh(lock: &fsp->scsi_pkt_lock);
1259 ticks_left = wait_for_completion_timeout(x: &fsp->tm_done,
1260 FC_SCSI_TM_TOV);
1261 spin_lock_bh(lock: &fsp->scsi_pkt_lock);
1262 fsp->wait_for_comp = 0;
1263
1264 if (!ticks_left) {
1265 FC_FCP_DBG(fsp, "target abort cmd failed\n");
1266 } else if (fsp->state & FC_SRB_ABORTED) {
1267 FC_FCP_DBG(fsp, "target abort cmd passed\n");
1268 rc = SUCCESS;
1269 fc_fcp_complete_locked(fsp);
1270 }
1271
1272 return rc;
1273}
1274
1275/**
1276 * fc_lun_reset_send() - Send LUN reset command
1277 * @t: Timer context used to fetch the FSP packet
1278 */
1279static void fc_lun_reset_send(struct timer_list *t)
1280{
1281 struct fc_fcp_pkt *fsp = from_timer(fsp, t, timer);
1282 struct fc_lport *lport = fsp->lp;
1283
1284 if (lport->tt.fcp_cmd_send(lport, fsp, fc_tm_done)) {
1285 if (fsp->recov_retry++ >= FC_MAX_RECOV_RETRY)
1286 return;
1287 if (fc_fcp_lock_pkt(fsp))
1288 return;
1289 fsp->timer.function = fc_lun_reset_send;
1290 fc_fcp_timer_set(fsp, delay: get_fsp_rec_tov(fsp));
1291 fc_fcp_unlock_pkt(fsp);
1292 }
1293}
1294
1295/**
1296 * fc_lun_reset() - Send a LUN RESET command to a device
1297 * and wait for the reply
1298 * @lport: The local port to sent the command on
1299 * @fsp: The FCP packet that identifies the LUN to be reset
1300 * @id: The SCSI command ID
1301 * @lun: The LUN ID to be reset
1302 */
1303static int fc_lun_reset(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
1304 unsigned int id, unsigned int lun)
1305{
1306 int rc;
1307
1308 fsp->cdb_cmd.fc_dl = htonl(fsp->data_len);
1309 fsp->cdb_cmd.fc_tm_flags = FCP_TMF_LUN_RESET;
1310 int_to_scsilun(lun, &fsp->cdb_cmd.fc_lun);
1311
1312 fsp->wait_for_comp = 1;
1313 init_completion(x: &fsp->tm_done);
1314
1315 fc_lun_reset_send(t: &fsp->timer);
1316
1317 /*
1318 * wait for completion of reset
1319 * after that make sure all commands are terminated
1320 */
1321 rc = wait_for_completion_timeout(x: &fsp->tm_done, FC_SCSI_TM_TOV);
1322
1323 spin_lock_bh(lock: &fsp->scsi_pkt_lock);
1324 fsp->state |= FC_SRB_COMPL;
1325 spin_unlock_bh(lock: &fsp->scsi_pkt_lock);
1326
1327 del_timer_sync(timer: &fsp->timer);
1328
1329 spin_lock_bh(lock: &fsp->scsi_pkt_lock);
1330 if (fsp->seq_ptr) {
1331 fc_exch_done(sp: fsp->seq_ptr);
1332 fsp->seq_ptr = NULL;
1333 }
1334 fsp->wait_for_comp = 0;
1335 spin_unlock_bh(lock: &fsp->scsi_pkt_lock);
1336
1337 if (!rc) {
1338 FC_SCSI_DBG(lport, "lun reset failed\n");
1339 return FAILED;
1340 }
1341
1342 /* cdb_status holds the tmf's rsp code */
1343 if (fsp->cdb_status != FCP_TMF_CMPL)
1344 return FAILED;
1345
1346 FC_SCSI_DBG(lport, "lun reset to lun %u completed\n", lun);
1347 fc_fcp_cleanup_each_cmd(lport, id, lun, FC_CMD_ABORTED);
1348 return SUCCESS;
1349}
1350
1351/**
1352 * fc_tm_done() - Task Management response handler
1353 * @seq: The sequence that the response is on
1354 * @fp: The response frame
1355 * @arg: The FCP packet the response is for
1356 */
1357static void fc_tm_done(struct fc_seq *seq, struct fc_frame *fp, void *arg)
1358{
1359 struct fc_fcp_pkt *fsp = arg;
1360 struct fc_frame_header *fh;
1361
1362 if (IS_ERR(ptr: fp)) {
1363 /*
1364 * If there is an error just let it timeout or wait
1365 * for TMF to be aborted if it timedout.
1366 *
1367 * scsi-eh will escalate for when either happens.
1368 */
1369 return;
1370 }
1371
1372 if (fc_fcp_lock_pkt(fsp))
1373 goto out;
1374
1375 /*
1376 * raced with eh timeout handler.
1377 */
1378 if (!fsp->seq_ptr || !fsp->wait_for_comp)
1379 goto out_unlock;
1380
1381 fh = fc_frame_header_get(fp);
1382 if (fh->fh_type != FC_TYPE_BLS)
1383 fc_fcp_resp(fsp, fp);
1384 fsp->seq_ptr = NULL;
1385 fc_exch_done(sp: seq);
1386out_unlock:
1387 fc_fcp_unlock_pkt(fsp);
1388out:
1389 fc_frame_free(fp);
1390}
1391
1392/**
1393 * fc_fcp_cleanup() - Cleanup all FCP exchanges on a local port
1394 * @lport: The local port to be cleaned up
1395 */
1396static void fc_fcp_cleanup(struct fc_lport *lport)
1397{
1398 fc_fcp_cleanup_each_cmd(lport, id: -1, lun: -1, FC_ERROR);
1399}
1400
1401/**
1402 * fc_fcp_timeout() - Handler for fcp_pkt timeouts
1403 * @t: Timer context used to fetch the FSP packet
1404 *
1405 * If REC is supported then just issue it and return. The REC exchange will
1406 * complete or time out and recovery can continue at that point. Otherwise,
1407 * if the response has been received without all the data it has been
1408 * ER_TIMEOUT since the response was received. If the response has not been
1409 * received we see if data was received recently. If it has been then we
1410 * continue waiting, otherwise, we abort the command.
1411 */
1412static void fc_fcp_timeout(struct timer_list *t)
1413{
1414 struct fc_fcp_pkt *fsp = from_timer(fsp, t, timer);
1415 struct fc_rport *rport = fsp->rport;
1416 struct fc_rport_libfc_priv *rpriv = rport->dd_data;
1417
1418 if (fc_fcp_lock_pkt(fsp))
1419 return;
1420
1421 if (fsp->cdb_cmd.fc_tm_flags)
1422 goto unlock;
1423
1424 if (fsp->lp->qfull) {
1425 FC_FCP_DBG(fsp, "fcp timeout, resetting timer delay %d\n",
1426 fsp->timer_delay);
1427 fsp->timer.function = fc_fcp_timeout;
1428 fc_fcp_timer_set(fsp, delay: fsp->timer_delay);
1429 goto unlock;
1430 }
1431 FC_FCP_DBG(fsp, "fcp timeout, delay %d flags %x state %x\n",
1432 fsp->timer_delay, rpriv->flags, fsp->state);
1433 fsp->state |= FC_SRB_FCP_PROCESSING_TMO;
1434
1435 if (rpriv->flags & FC_RP_FLAGS_REC_SUPPORTED)
1436 fc_fcp_rec(fsp);
1437 else if (fsp->state & FC_SRB_RCV_STATUS)
1438 fc_fcp_complete_locked(fsp);
1439 else
1440 fc_fcp_recovery(fsp, FC_TIMED_OUT);
1441 fsp->state &= ~FC_SRB_FCP_PROCESSING_TMO;
1442unlock:
1443 fc_fcp_unlock_pkt(fsp);
1444}
1445
1446/**
1447 * fc_fcp_rec() - Send a REC ELS request
1448 * @fsp: The FCP packet to send the REC request on
1449 */
1450static void fc_fcp_rec(struct fc_fcp_pkt *fsp)
1451{
1452 struct fc_lport *lport;
1453 struct fc_frame *fp;
1454 struct fc_rport *rport;
1455 struct fc_rport_libfc_priv *rpriv;
1456
1457 lport = fsp->lp;
1458 rport = fsp->rport;
1459 rpriv = rport->dd_data;
1460 if (!fsp->seq_ptr || rpriv->rp_state != RPORT_ST_READY) {
1461 fsp->status_code = FC_HRD_ERROR;
1462 fsp->io_status = 0;
1463 fc_fcp_complete_locked(fsp);
1464 return;
1465 }
1466
1467 fp = fc_fcp_frame_alloc(lport, len: sizeof(struct fc_els_rec));
1468 if (!fp)
1469 goto retry;
1470
1471 fr_seq(fp) = fsp->seq_ptr;
1472 fc_fill_fc_hdr(fp, r_ctl: FC_RCTL_ELS_REQ, did: rport->port_id,
1473 sid: rpriv->local_port->port_id, type: FC_TYPE_ELS,
1474 FC_FCTL_REQ, parm_offset: 0);
1475 if (lport->tt.elsct_send(lport, rport->port_id, fp, ELS_REC,
1476 fc_fcp_rec_resp, fsp,
1477 2 * lport->r_a_tov)) {
1478 fc_fcp_pkt_hold(fsp); /* hold while REC outstanding */
1479 return;
1480 }
1481retry:
1482 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1483 fc_fcp_timer_set(fsp, delay: get_fsp_rec_tov(fsp));
1484 else
1485 fc_fcp_recovery(fsp, FC_TIMED_OUT);
1486}
1487
1488/**
1489 * fc_fcp_rec_resp() - Handler for REC ELS responses
1490 * @seq: The sequence the response is on
1491 * @fp: The response frame
1492 * @arg: The FCP packet the response is on
1493 *
1494 * If the response is a reject then the scsi layer will handle
1495 * the timeout. If the response is a LS_ACC then if the I/O was not completed
1496 * set the timeout and return. If the I/O was completed then complete the
1497 * exchange and tell the SCSI layer.
1498 */
1499static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
1500{
1501 struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)arg;
1502 struct fc_els_rec_acc *recp;
1503 struct fc_els_ls_rjt *rjt;
1504 u32 e_stat;
1505 u8 opcode;
1506 u32 offset;
1507 enum dma_data_direction data_dir;
1508 enum fc_rctl r_ctl;
1509 struct fc_rport_libfc_priv *rpriv;
1510
1511 if (IS_ERR(ptr: fp)) {
1512 fc_fcp_rec_error(fsp, fp);
1513 return;
1514 }
1515
1516 if (fc_fcp_lock_pkt(fsp))
1517 goto out;
1518
1519 fsp->recov_retry = 0;
1520 opcode = fc_frame_payload_op(fp);
1521 if (opcode == ELS_LS_RJT) {
1522 rjt = fc_frame_payload_get(fp, len: sizeof(*rjt));
1523 switch (rjt->er_reason) {
1524 default:
1525 FC_FCP_DBG(fsp,
1526 "device %x invalid REC reject %d/%d\n",
1527 fsp->rport->port_id, rjt->er_reason,
1528 rjt->er_explan);
1529 fallthrough;
1530 case ELS_RJT_UNSUP:
1531 FC_FCP_DBG(fsp, "device does not support REC\n");
1532 rpriv = fsp->rport->dd_data;
1533 /*
1534 * if we do not spport RECs or got some bogus
1535 * reason then resetup timer so we check for
1536 * making progress.
1537 */
1538 rpriv->flags &= ~FC_RP_FLAGS_REC_SUPPORTED;
1539 break;
1540 case ELS_RJT_LOGIC:
1541 case ELS_RJT_UNAB:
1542 FC_FCP_DBG(fsp, "device %x REC reject %d/%d\n",
1543 fsp->rport->port_id, rjt->er_reason,
1544 rjt->er_explan);
1545 /*
1546 * If response got lost or is stuck in the
1547 * queue somewhere we have no idea if and when
1548 * the response will be received. So quarantine
1549 * the xid and retry the command.
1550 */
1551 if (rjt->er_explan == ELS_EXPL_OXID_RXID) {
1552 struct fc_exch *ep = fc_seq_exch(fsp->seq_ptr);
1553 ep->state |= FC_EX_QUARANTINE;
1554 fsp->state |= FC_SRB_ABORTED;
1555 fc_fcp_retry_cmd(fsp, FC_TRANS_RESET);
1556 break;
1557 }
1558 fc_fcp_recovery(fsp, FC_TRANS_RESET);
1559 break;
1560 }
1561 } else if (opcode == ELS_LS_ACC) {
1562 if (fsp->state & FC_SRB_ABORTED)
1563 goto unlock_out;
1564
1565 data_dir = fsp->cmd->sc_data_direction;
1566 recp = fc_frame_payload_get(fp, len: sizeof(*recp));
1567 offset = ntohl(recp->reca_fc4value);
1568 e_stat = ntohl(recp->reca_e_stat);
1569
1570 if (e_stat & ESB_ST_COMPLETE) {
1571
1572 /*
1573 * The exchange is complete.
1574 *
1575 * For output, we must've lost the response.
1576 * For input, all data must've been sent.
1577 * We lost may have lost the response
1578 * (and a confirmation was requested) and maybe
1579 * some data.
1580 *
1581 * If all data received, send SRR
1582 * asking for response. If partial data received,
1583 * or gaps, SRR requests data at start of gap.
1584 * Recovery via SRR relies on in-order-delivery.
1585 */
1586 if (data_dir == DMA_TO_DEVICE) {
1587 r_ctl = FC_RCTL_DD_CMD_STATUS;
1588 } else if (fsp->xfer_contig_end == offset) {
1589 r_ctl = FC_RCTL_DD_CMD_STATUS;
1590 } else {
1591 offset = fsp->xfer_contig_end;
1592 r_ctl = FC_RCTL_DD_SOL_DATA;
1593 }
1594 fc_fcp_srr(fsp, r_ctl, offset);
1595 } else if (e_stat & ESB_ST_SEQ_INIT) {
1596 /*
1597 * The remote port has the initiative, so just
1598 * keep waiting for it to complete.
1599 */
1600 fc_fcp_timer_set(fsp, delay: get_fsp_rec_tov(fsp));
1601 } else {
1602
1603 /*
1604 * The exchange is incomplete, we have seq. initiative.
1605 * Lost response with requested confirmation,
1606 * lost confirmation, lost transfer ready or
1607 * lost write data.
1608 *
1609 * For output, if not all data was received, ask
1610 * for transfer ready to be repeated.
1611 *
1612 * If we received or sent all the data, send SRR to
1613 * request response.
1614 *
1615 * If we lost a response, we may have lost some read
1616 * data as well.
1617 */
1618 r_ctl = FC_RCTL_DD_SOL_DATA;
1619 if (data_dir == DMA_TO_DEVICE) {
1620 r_ctl = FC_RCTL_DD_CMD_STATUS;
1621 if (offset < fsp->data_len)
1622 r_ctl = FC_RCTL_DD_DATA_DESC;
1623 } else if (offset == fsp->xfer_contig_end) {
1624 r_ctl = FC_RCTL_DD_CMD_STATUS;
1625 } else if (fsp->xfer_contig_end < offset) {
1626 offset = fsp->xfer_contig_end;
1627 }
1628 fc_fcp_srr(fsp, r_ctl, offset);
1629 }
1630 }
1631unlock_out:
1632 fc_fcp_unlock_pkt(fsp);
1633out:
1634 fc_fcp_pkt_release(fsp); /* drop hold for outstanding REC */
1635 fc_frame_free(fp);
1636}
1637
1638/**
1639 * fc_fcp_rec_error() - Handler for REC errors
1640 * @fsp: The FCP packet the error is on
1641 * @fp: The REC frame
1642 */
1643static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1644{
1645 int error = PTR_ERR(ptr: fp);
1646
1647 if (fc_fcp_lock_pkt(fsp))
1648 goto out;
1649
1650 switch (error) {
1651 case -FC_EX_CLOSED:
1652 FC_FCP_DBG(fsp, "REC %p fid %6.6x exchange closed\n",
1653 fsp, fsp->rport->port_id);
1654 fc_fcp_retry_cmd(fsp, FC_ERROR);
1655 break;
1656
1657 default:
1658 FC_FCP_DBG(fsp, "REC %p fid %6.6x error unexpected error %d\n",
1659 fsp, fsp->rport->port_id, error);
1660 fsp->status_code = FC_CMD_PLOGO;
1661 fallthrough;
1662
1663 case -FC_EX_TIMEOUT:
1664 /*
1665 * Assume REC or LS_ACC was lost.
1666 * The exchange manager will have aborted REC, so retry.
1667 */
1668 FC_FCP_DBG(fsp, "REC %p fid %6.6x exchange timeout retry %d/%d\n",
1669 fsp, fsp->rport->port_id, fsp->recov_retry,
1670 FC_MAX_RECOV_RETRY);
1671 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1672 fc_fcp_rec(fsp);
1673 else
1674 fc_fcp_recovery(fsp, FC_ERROR);
1675 break;
1676 }
1677 fc_fcp_unlock_pkt(fsp);
1678out:
1679 fc_fcp_pkt_release(fsp); /* drop hold for outstanding REC */
1680}
1681
1682/**
1683 * fc_fcp_recovery() - Handler for fcp_pkt recovery
1684 * @fsp: The FCP pkt that needs to be aborted
1685 * @code: The FCP status code to set
1686 */
1687static void fc_fcp_recovery(struct fc_fcp_pkt *fsp, u8 code)
1688{
1689 FC_FCP_DBG(fsp, "start recovery code %x\n", code);
1690 fsp->status_code = code;
1691 fsp->cdb_status = 0;
1692 fsp->io_status = 0;
1693 /*
1694 * if this fails then we let the scsi command timer fire and
1695 * scsi-ml escalate.
1696 */
1697 fc_fcp_send_abort(fsp);
1698}
1699
1700/**
1701 * fc_fcp_srr() - Send a SRR request (Sequence Retransmission Request)
1702 * @fsp: The FCP packet the SRR is to be sent on
1703 * @r_ctl: The R_CTL field for the SRR request
1704 * @offset: The SRR relative offset
1705 * This is called after receiving status but insufficient data, or
1706 * when expecting status but the request has timed out.
1707 */
1708static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
1709{
1710 struct fc_lport *lport = fsp->lp;
1711 struct fc_rport *rport;
1712 struct fc_rport_libfc_priv *rpriv;
1713 struct fc_exch *ep = fc_seq_exch(fsp->seq_ptr);
1714 struct fc_seq *seq;
1715 struct fcp_srr *srr;
1716 struct fc_frame *fp;
1717
1718 rport = fsp->rport;
1719 rpriv = rport->dd_data;
1720
1721 if (!(rpriv->flags & FC_RP_FLAGS_RETRY) ||
1722 rpriv->rp_state != RPORT_ST_READY)
1723 goto retry; /* shouldn't happen */
1724 fp = fc_fcp_frame_alloc(lport, len: sizeof(*srr));
1725 if (!fp)
1726 goto retry;
1727
1728 srr = fc_frame_payload_get(fp, len: sizeof(*srr));
1729 memset(srr, 0, sizeof(*srr));
1730 srr->srr_op = ELS_SRR;
1731 srr->srr_ox_id = htons(ep->oxid);
1732 srr->srr_rx_id = htons(ep->rxid);
1733 srr->srr_r_ctl = r_ctl;
1734 srr->srr_rel_off = htonl(offset);
1735
1736 fc_fill_fc_hdr(fp, r_ctl: FC_RCTL_ELS4_REQ, did: rport->port_id,
1737 sid: rpriv->local_port->port_id, type: FC_TYPE_FCP,
1738 FC_FCTL_REQ, parm_offset: 0);
1739
1740 seq = fc_exch_seq_send(lport, fp, resp: fc_fcp_srr_resp,
1741 destructor: fc_fcp_pkt_destroy,
1742 arg: fsp, timer_msec: get_fsp_rec_tov(fsp));
1743 if (!seq)
1744 goto retry;
1745
1746 fsp->recov_seq = seq;
1747 fsp->xfer_len = offset;
1748 fsp->xfer_contig_end = offset;
1749 fsp->state &= ~FC_SRB_RCV_STATUS;
1750 fc_fcp_pkt_hold(fsp); /* hold for outstanding SRR */
1751 return;
1752retry:
1753 fc_fcp_retry_cmd(fsp, FC_TRANS_RESET);
1754}
1755
1756/**
1757 * fc_fcp_srr_resp() - Handler for SRR response
1758 * @seq: The sequence the SRR is on
1759 * @fp: The SRR frame
1760 * @arg: The FCP packet the SRR is on
1761 */
1762static void fc_fcp_srr_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
1763{
1764 struct fc_fcp_pkt *fsp = arg;
1765 struct fc_frame_header *fh;
1766
1767 if (IS_ERR(ptr: fp)) {
1768 fc_fcp_srr_error(fsp, fp);
1769 return;
1770 }
1771
1772 if (fc_fcp_lock_pkt(fsp))
1773 goto out;
1774
1775 fh = fc_frame_header_get(fp);
1776 /*
1777 * BUG? fc_fcp_srr_error calls fc_exch_done which would release
1778 * the ep. But if fc_fcp_srr_error had got -FC_EX_TIMEOUT,
1779 * then fc_exch_timeout would be sending an abort. The fc_exch_done
1780 * call by fc_fcp_srr_error would prevent fc_exch.c from seeing
1781 * an abort response though.
1782 */
1783 if (fh->fh_type == FC_TYPE_BLS) {
1784 fc_fcp_unlock_pkt(fsp);
1785 return;
1786 }
1787
1788 switch (fc_frame_payload_op(fp)) {
1789 case ELS_LS_ACC:
1790 fsp->recov_retry = 0;
1791 fc_fcp_timer_set(fsp, delay: get_fsp_rec_tov(fsp));
1792 break;
1793 case ELS_LS_RJT:
1794 default:
1795 fc_fcp_recovery(fsp, FC_ERROR);
1796 break;
1797 }
1798 fc_fcp_unlock_pkt(fsp);
1799out:
1800 fc_exch_done(sp: seq);
1801 fc_frame_free(fp);
1802}
1803
1804/**
1805 * fc_fcp_srr_error() - Handler for SRR errors
1806 * @fsp: The FCP packet that the SRR error is on
1807 * @fp: The SRR frame
1808 */
1809static void fc_fcp_srr_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1810{
1811 if (fc_fcp_lock_pkt(fsp))
1812 goto out;
1813 switch (PTR_ERR(ptr: fp)) {
1814 case -FC_EX_TIMEOUT:
1815 FC_FCP_DBG(fsp, "SRR timeout, retries %d\n", fsp->recov_retry);
1816 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1817 fc_fcp_rec(fsp);
1818 else
1819 fc_fcp_recovery(fsp, FC_TIMED_OUT);
1820 break;
1821 case -FC_EX_CLOSED: /* e.g., link failure */
1822 FC_FCP_DBG(fsp, "SRR error, exchange closed\n");
1823 fallthrough;
1824 default:
1825 fc_fcp_retry_cmd(fsp, FC_ERROR);
1826 break;
1827 }
1828 fc_fcp_unlock_pkt(fsp);
1829out:
1830 fc_exch_done(sp: fsp->recov_seq);
1831}
1832
1833/**
1834 * fc_fcp_lport_queue_ready() - Determine if the lport and it's queue is ready
1835 * @lport: The local port to be checked
1836 */
1837static inline int fc_fcp_lport_queue_ready(struct fc_lport *lport)
1838{
1839 /* lock ? */
1840 return (lport->state == LPORT_ST_READY) &&
1841 lport->link_up && !lport->qfull;
1842}
1843
1844/**
1845 * fc_queuecommand() - The queuecommand function of the SCSI template
1846 * @shost: The Scsi_Host that the command was issued to
1847 * @sc_cmd: The scsi_cmnd to be executed
1848 *
1849 * This is the i/o strategy routine, called by the SCSI layer.
1850 */
1851int fc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *sc_cmd)
1852{
1853 struct fc_lport *lport = shost_priv(shost);
1854 struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
1855 struct fc_fcp_pkt *fsp;
1856 int rval;
1857 int rc = 0;
1858
1859 rval = fc_remote_port_chkready(rport);
1860 if (rval) {
1861 sc_cmd->result = rval;
1862 scsi_done(cmd: sc_cmd);
1863 return 0;
1864 }
1865
1866 if (!*(struct fc_remote_port **)rport->dd_data) {
1867 /*
1868 * rport is transitioning from blocked/deleted to
1869 * online
1870 */
1871 sc_cmd->result = DID_IMM_RETRY << 16;
1872 scsi_done(cmd: sc_cmd);
1873 goto out;
1874 }
1875
1876 if (!fc_fcp_lport_queue_ready(lport)) {
1877 if (lport->qfull) {
1878 if (fc_fcp_can_queue_ramp_down(lport))
1879 shost_printk(KERN_ERR, lport->host,
1880 "libfc: queue full, "
1881 "reducing can_queue to %d.\n",
1882 lport->host->can_queue);
1883 }
1884 rc = SCSI_MLQUEUE_HOST_BUSY;
1885 goto out;
1886 }
1887
1888 fsp = fc_fcp_pkt_alloc(lport, GFP_ATOMIC);
1889 if (fsp == NULL) {
1890 rc = SCSI_MLQUEUE_HOST_BUSY;
1891 goto out;
1892 }
1893
1894 /*
1895 * build the libfc request pkt
1896 */
1897 fsp->cmd = sc_cmd; /* save the cmd */
1898 fsp->rport = rport; /* set the remote port ptr */
1899
1900 /*
1901 * set up the transfer length
1902 */
1903 fsp->data_len = scsi_bufflen(cmd: sc_cmd);
1904 fsp->xfer_len = 0;
1905
1906 /*
1907 * setup the data direction
1908 */
1909 if (sc_cmd->sc_data_direction == DMA_FROM_DEVICE) {
1910 fsp->req_flags = FC_SRB_READ;
1911 this_cpu_inc(lport->stats->InputRequests);
1912 this_cpu_add(lport->stats->InputBytes, fsp->data_len);
1913 } else if (sc_cmd->sc_data_direction == DMA_TO_DEVICE) {
1914 fsp->req_flags = FC_SRB_WRITE;
1915 this_cpu_inc(lport->stats->OutputRequests);
1916 this_cpu_add(lport->stats->OutputBytes, fsp->data_len);
1917 } else {
1918 fsp->req_flags = 0;
1919 this_cpu_inc(lport->stats->ControlRequests);
1920 }
1921
1922 /*
1923 * send it to the lower layer
1924 * if we get -1 return then put the request in the pending
1925 * queue.
1926 */
1927 rval = fc_fcp_pkt_send(lport, fsp);
1928 if (rval != 0) {
1929 fsp->state = FC_SRB_FREE;
1930 fc_fcp_pkt_release(fsp);
1931 rc = SCSI_MLQUEUE_HOST_BUSY;
1932 }
1933out:
1934 return rc;
1935}
1936EXPORT_SYMBOL(fc_queuecommand);
1937
1938/**
1939 * fc_io_compl() - Handle responses for completed commands
1940 * @fsp: The FCP packet that is complete
1941 *
1942 * Translates fcp_pkt errors to a Linux SCSI errors.
1943 * The fcp packet lock must be held when calling.
1944 */
1945static void fc_io_compl(struct fc_fcp_pkt *fsp)
1946{
1947 struct fc_fcp_internal *si;
1948 struct scsi_cmnd *sc_cmd;
1949 struct fc_lport *lport;
1950 unsigned long flags;
1951
1952 /* release outstanding ddp context */
1953 fc_fcp_ddp_done(fsp);
1954
1955 fsp->state |= FC_SRB_COMPL;
1956 if (!(fsp->state & FC_SRB_FCP_PROCESSING_TMO)) {
1957 spin_unlock_bh(lock: &fsp->scsi_pkt_lock);
1958 del_timer_sync(timer: &fsp->timer);
1959 spin_lock_bh(lock: &fsp->scsi_pkt_lock);
1960 }
1961
1962 lport = fsp->lp;
1963 si = fc_get_scsi_internal(lport);
1964
1965 /*
1966 * if can_queue ramp down is done then try can_queue ramp up
1967 * since commands are completing now.
1968 */
1969 if (si->last_can_queue_ramp_down_time)
1970 fc_fcp_can_queue_ramp_up(lport);
1971
1972 sc_cmd = fsp->cmd;
1973 libfc_priv(cmd: sc_cmd)->status = fsp->cdb_status;
1974 switch (fsp->status_code) {
1975 case FC_COMPLETE:
1976 if (fsp->cdb_status == 0) {
1977 /*
1978 * good I/O status
1979 */
1980 sc_cmd->result = DID_OK << 16;
1981 if (fsp->scsi_resid)
1982 libfc_priv(cmd: sc_cmd)->resid_len = fsp->scsi_resid;
1983 } else {
1984 /*
1985 * transport level I/O was ok but scsi
1986 * has non zero status
1987 */
1988 sc_cmd->result = (DID_OK << 16) | fsp->cdb_status;
1989 }
1990 break;
1991 case FC_ERROR:
1992 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
1993 "due to FC_ERROR\n");
1994 sc_cmd->result = DID_ERROR << 16;
1995 break;
1996 case FC_DATA_UNDRUN:
1997 if ((fsp->cdb_status == 0) && !(fsp->req_flags & FC_SRB_READ)) {
1998 /*
1999 * scsi status is good but transport level
2000 * underrun.
2001 */
2002 if (fsp->state & FC_SRB_RCV_STATUS) {
2003 sc_cmd->result = DID_OK << 16;
2004 } else {
2005 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml"
2006 " due to FC_DATA_UNDRUN (trans)\n");
2007 sc_cmd->result = DID_ERROR << 16;
2008 }
2009 } else {
2010 /*
2011 * scsi got underrun, this is an error
2012 */
2013 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
2014 "due to FC_DATA_UNDRUN (scsi)\n");
2015 libfc_priv(cmd: sc_cmd)->resid_len = fsp->scsi_resid;
2016 sc_cmd->result = (DID_ERROR << 16) | fsp->cdb_status;
2017 }
2018 break;
2019 case FC_DATA_OVRRUN:
2020 /*
2021 * overrun is an error
2022 */
2023 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
2024 "due to FC_DATA_OVRRUN\n");
2025 sc_cmd->result = (DID_ERROR << 16) | fsp->cdb_status;
2026 break;
2027 case FC_CMD_ABORTED:
2028 if (host_byte(sc_cmd->result) == DID_TIME_OUT)
2029 FC_FCP_DBG(fsp, "Returning DID_TIME_OUT to scsi-ml "
2030 "due to FC_CMD_ABORTED\n");
2031 else {
2032 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
2033 "due to FC_CMD_ABORTED\n");
2034 set_host_byte(cmd: sc_cmd, status: DID_ERROR);
2035 }
2036 sc_cmd->result |= fsp->io_status;
2037 break;
2038 case FC_CMD_RESET:
2039 FC_FCP_DBG(fsp, "Returning DID_RESET to scsi-ml "
2040 "due to FC_CMD_RESET\n");
2041 sc_cmd->result = (DID_RESET << 16);
2042 break;
2043 case FC_TRANS_RESET:
2044 FC_FCP_DBG(fsp, "Returning DID_SOFT_ERROR to scsi-ml "
2045 "due to FC_TRANS_RESET\n");
2046 sc_cmd->result = (DID_SOFT_ERROR << 16);
2047 break;
2048 case FC_HRD_ERROR:
2049 FC_FCP_DBG(fsp, "Returning DID_NO_CONNECT to scsi-ml "
2050 "due to FC_HRD_ERROR\n");
2051 sc_cmd->result = (DID_NO_CONNECT << 16);
2052 break;
2053 case FC_CRC_ERROR:
2054 FC_FCP_DBG(fsp, "Returning DID_PARITY to scsi-ml "
2055 "due to FC_CRC_ERROR\n");
2056 sc_cmd->result = (DID_PARITY << 16);
2057 break;
2058 case FC_TIMED_OUT:
2059 FC_FCP_DBG(fsp, "Returning DID_BUS_BUSY to scsi-ml "
2060 "due to FC_TIMED_OUT\n");
2061 sc_cmd->result = (DID_BUS_BUSY << 16) | fsp->io_status;
2062 break;
2063 default:
2064 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
2065 "due to unknown error\n");
2066 sc_cmd->result = (DID_ERROR << 16);
2067 break;
2068 }
2069
2070 if (lport->state != LPORT_ST_READY && fsp->status_code != FC_COMPLETE)
2071 sc_cmd->result = (DID_TRANSPORT_DISRUPTED << 16);
2072
2073 spin_lock_irqsave(&si->scsi_queue_lock, flags);
2074 list_del(entry: &fsp->list);
2075 libfc_priv(cmd: sc_cmd)->fsp = NULL;
2076 spin_unlock_irqrestore(lock: &si->scsi_queue_lock, flags);
2077 scsi_done(cmd: sc_cmd);
2078
2079 /* release ref from initial allocation in queue command */
2080 fc_fcp_pkt_release(fsp);
2081}
2082
2083/**
2084 * fc_eh_abort() - Abort a command
2085 * @sc_cmd: The SCSI command to abort
2086 *
2087 * From SCSI host template.
2088 * Send an ABTS to the target device and wait for the response.
2089 */
2090int fc_eh_abort(struct scsi_cmnd *sc_cmd)
2091{
2092 struct fc_fcp_pkt *fsp;
2093 struct fc_lport *lport;
2094 struct fc_fcp_internal *si;
2095 int rc = FAILED;
2096 unsigned long flags;
2097 int rval;
2098
2099 rval = fc_block_scsi_eh(cmnd: sc_cmd);
2100 if (rval)
2101 return rval;
2102
2103 lport = shost_priv(shost: sc_cmd->device->host);
2104 if (lport->state != LPORT_ST_READY)
2105 return rc;
2106 else if (!lport->link_up)
2107 return rc;
2108
2109 si = fc_get_scsi_internal(lport);
2110 spin_lock_irqsave(&si->scsi_queue_lock, flags);
2111 fsp = libfc_priv(cmd: sc_cmd)->fsp;
2112 if (!fsp) {
2113 /* command completed while scsi eh was setting up */
2114 spin_unlock_irqrestore(lock: &si->scsi_queue_lock, flags);
2115 return SUCCESS;
2116 }
2117 /* grab a ref so the fsp and sc_cmd cannot be released from under us */
2118 fc_fcp_pkt_hold(fsp);
2119 spin_unlock_irqrestore(lock: &si->scsi_queue_lock, flags);
2120
2121 if (fc_fcp_lock_pkt(fsp)) {
2122 /* completed while we were waiting for timer to be deleted */
2123 rc = SUCCESS;
2124 goto release_pkt;
2125 }
2126
2127 rc = fc_fcp_pkt_abort(fsp);
2128 fc_fcp_unlock_pkt(fsp);
2129
2130release_pkt:
2131 fc_fcp_pkt_release(fsp);
2132 return rc;
2133}
2134EXPORT_SYMBOL(fc_eh_abort);
2135
2136/**
2137 * fc_eh_device_reset() - Reset a single LUN
2138 * @sc_cmd: The SCSI command which identifies the device whose
2139 * LUN is to be reset
2140 *
2141 * Set from SCSI host template.
2142 */
2143int fc_eh_device_reset(struct scsi_cmnd *sc_cmd)
2144{
2145 struct fc_lport *lport;
2146 struct fc_fcp_pkt *fsp;
2147 struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
2148 int rc = FAILED;
2149 int rval;
2150
2151 rval = fc_block_scsi_eh(cmnd: sc_cmd);
2152 if (rval)
2153 return rval;
2154
2155 lport = shost_priv(shost: sc_cmd->device->host);
2156
2157 if (lport->state != LPORT_ST_READY)
2158 return rc;
2159
2160 FC_SCSI_DBG(lport, "Resetting rport (%6.6x)\n", rport->port_id);
2161
2162 fsp = fc_fcp_pkt_alloc(lport, GFP_NOIO);
2163 if (fsp == NULL) {
2164 printk(KERN_WARNING "libfc: could not allocate scsi_pkt\n");
2165 goto out;
2166 }
2167
2168 /*
2169 * Build the libfc request pkt. Do not set the scsi cmnd, because
2170 * the sc passed in is not setup for execution like when sent
2171 * through the queuecommand callout.
2172 */
2173 fsp->rport = rport; /* set the remote port ptr */
2174
2175 /*
2176 * flush outstanding commands
2177 */
2178 rc = fc_lun_reset(lport, fsp, scmd_id(sc_cmd), lun: sc_cmd->device->lun);
2179 fsp->state = FC_SRB_FREE;
2180 fc_fcp_pkt_release(fsp);
2181
2182out:
2183 return rc;
2184}
2185EXPORT_SYMBOL(fc_eh_device_reset);
2186
2187/**
2188 * fc_eh_host_reset() - Reset a Scsi_Host.
2189 * @sc_cmd: The SCSI command that identifies the SCSI host to be reset
2190 */
2191int fc_eh_host_reset(struct scsi_cmnd *sc_cmd)
2192{
2193 struct Scsi_Host *shost = sc_cmd->device->host;
2194 struct fc_lport *lport = shost_priv(shost);
2195 unsigned long wait_tmo;
2196
2197 FC_SCSI_DBG(lport, "Resetting host\n");
2198
2199 fc_lport_reset(lport);
2200 wait_tmo = jiffies + FC_HOST_RESET_TIMEOUT;
2201 while (!fc_fcp_lport_queue_ready(lport) && time_before(jiffies,
2202 wait_tmo))
2203 msleep(msecs: 1000);
2204
2205 if (fc_fcp_lport_queue_ready(lport)) {
2206 shost_printk(KERN_INFO, shost, "libfc: Host reset succeeded "
2207 "on port (%6.6x)\n", lport->port_id);
2208 return SUCCESS;
2209 } else {
2210 shost_printk(KERN_INFO, shost, "libfc: Host reset failed, "
2211 "port (%6.6x) is not ready.\n",
2212 lport->port_id);
2213 return FAILED;
2214 }
2215}
2216EXPORT_SYMBOL(fc_eh_host_reset);
2217
2218/**
2219 * fc_slave_alloc() - Configure the queue depth of a Scsi_Host
2220 * @sdev: The SCSI device that identifies the SCSI host
2221 *
2222 * Configures queue depth based on host's cmd_per_len. If not set
2223 * then we use the libfc default.
2224 */
2225int fc_slave_alloc(struct scsi_device *sdev)
2226{
2227 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
2228
2229 if (!rport || fc_remote_port_chkready(rport))
2230 return -ENXIO;
2231
2232 scsi_change_queue_depth(sdev, FC_FCP_DFLT_QUEUE_DEPTH);
2233 return 0;
2234}
2235EXPORT_SYMBOL(fc_slave_alloc);
2236
2237/**
2238 * fc_fcp_destroy() - Tear down the FCP layer for a given local port
2239 * @lport: The local port that no longer needs the FCP layer
2240 */
2241void fc_fcp_destroy(struct fc_lport *lport)
2242{
2243 struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
2244
2245 if (!list_empty(head: &si->scsi_pkt_queue))
2246 printk(KERN_ERR "libfc: Leaked SCSI packets when destroying "
2247 "port (%6.6x)\n", lport->port_id);
2248
2249 mempool_destroy(pool: si->scsi_pkt_pool);
2250 kfree(objp: si);
2251 lport->scsi_priv = NULL;
2252}
2253EXPORT_SYMBOL(fc_fcp_destroy);
2254
2255int fc_setup_fcp(void)
2256{
2257 int rc = 0;
2258
2259 scsi_pkt_cachep = kmem_cache_create(name: "libfc_fcp_pkt",
2260 size: sizeof(struct fc_fcp_pkt),
2261 align: 0, SLAB_HWCACHE_ALIGN, NULL);
2262 if (!scsi_pkt_cachep) {
2263 printk(KERN_ERR "libfc: Unable to allocate SRB cache, "
2264 "module load failed!");
2265 rc = -ENOMEM;
2266 }
2267
2268 return rc;
2269}
2270
2271void fc_destroy_fcp(void)
2272{
2273 kmem_cache_destroy(s: scsi_pkt_cachep);
2274}
2275
2276/**
2277 * fc_fcp_init() - Initialize the FCP layer for a local port
2278 * @lport: The local port to initialize the exchange layer for
2279 */
2280int fc_fcp_init(struct fc_lport *lport)
2281{
2282 int rc;
2283 struct fc_fcp_internal *si;
2284
2285 if (!lport->tt.fcp_cmd_send)
2286 lport->tt.fcp_cmd_send = fc_fcp_cmd_send;
2287
2288 if (!lport->tt.fcp_cleanup)
2289 lport->tt.fcp_cleanup = fc_fcp_cleanup;
2290
2291 if (!lport->tt.fcp_abort_io)
2292 lport->tt.fcp_abort_io = fc_fcp_abort_io;
2293
2294 si = kzalloc(size: sizeof(struct fc_fcp_internal), GFP_KERNEL);
2295 if (!si)
2296 return -ENOMEM;
2297 lport->scsi_priv = si;
2298 si->max_can_queue = lport->host->can_queue;
2299 INIT_LIST_HEAD(list: &si->scsi_pkt_queue);
2300 spin_lock_init(&si->scsi_queue_lock);
2301
2302 si->scsi_pkt_pool = mempool_create_slab_pool(min_nr: 2, kc: scsi_pkt_cachep);
2303 if (!si->scsi_pkt_pool) {
2304 rc = -ENOMEM;
2305 goto free_internal;
2306 }
2307 return 0;
2308
2309free_internal:
2310 kfree(objp: si);
2311 return rc;
2312}
2313EXPORT_SYMBOL(fc_fcp_init);
2314

source code of linux/drivers/scsi/libfc/fc_fcp.c