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 
33 static 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 
libfc_priv(struct scsi_cmnd * cmd)48 static 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  */
62 struct 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  */
77 static void fc_fcp_recv_data(struct fc_fcp_pkt *, struct fc_frame *);
78 static void fc_fcp_recv(struct fc_seq *, struct fc_frame *, void *);
79 static void fc_fcp_resp(struct fc_fcp_pkt *, struct fc_frame *);
80 static void fc_fcp_complete_locked(struct fc_fcp_pkt *);
81 static void fc_tm_done(struct fc_seq *, struct fc_frame *, void *);
82 static void fc_fcp_error(struct fc_fcp_pkt *, struct fc_frame *);
83 static void fc_fcp_recovery(struct fc_fcp_pkt *, u8 code);
84 static void fc_fcp_timeout(struct timer_list *);
85 static void fc_fcp_rec(struct fc_fcp_pkt *);
86 static void fc_fcp_rec_error(struct fc_fcp_pkt *, struct fc_frame *);
87 static void fc_fcp_rec_resp(struct fc_seq *, struct fc_frame *, void *);
88 static void fc_io_compl(struct fc_fcp_pkt *);
89 
90 static void fc_fcp_srr(struct fc_fcp_pkt *, enum fc_rctl, u32);
91 static void fc_fcp_srr_resp(struct fc_seq *, struct fc_frame *, void *);
92 static 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 FC_CMD_PLOGO		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  */
fc_fcp_pkt_alloc(struct fc_lport * lport,gfp_t gfp)131 static 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(si->scsi_pkt_pool, gfp);
137 	if (fsp) {
138 		memset(fsp, 0, sizeof(*fsp));
139 		fsp->lp = lport;
140 		fsp->xfer_ddp = FC_XID_UNKNOWN;
141 		refcount_set(&fsp->ref_cnt, 1);
142 		timer_setup(&fsp->timer, NULL, 0);
143 		INIT_LIST_HEAD(&fsp->list);
144 		spin_lock_init(&fsp->scsi_pkt_lock);
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  */
fc_fcp_pkt_release(struct fc_fcp_pkt * fsp)158 static void fc_fcp_pkt_release(struct fc_fcp_pkt *fsp)
159 {
160 	if (refcount_dec_and_test(&fsp->ref_cnt)) {
161 		struct fc_fcp_internal *si = fc_get_scsi_internal(fsp->lp);
162 
163 		mempool_free(fsp, 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  */
fc_fcp_pkt_hold(struct fc_fcp_pkt * fsp)171 static void fc_fcp_pkt_hold(struct fc_fcp_pkt *fsp)
172 {
173 	refcount_inc(&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  */
fc_fcp_pkt_destroy(struct fc_seq * seq,void * fsp)187 static 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  */
fc_fcp_lock_pkt(struct fc_fcp_pkt * fsp)209 static inline int fc_fcp_lock_pkt(struct fc_fcp_pkt *fsp)
210 {
211 	spin_lock_bh(&fsp->scsi_pkt_lock);
212 	if (fsp->state & FC_SRB_COMPL) {
213 		spin_unlock_bh(&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  */
fc_fcp_unlock_pkt(struct fc_fcp_pkt * fsp)226 static inline void fc_fcp_unlock_pkt(struct fc_fcp_pkt *fsp)
227 {
228 	spin_unlock_bh(&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  */
fc_fcp_timer_set(struct fc_fcp_pkt * fsp,unsigned long delay)237 static void fc_fcp_timer_set(struct fc_fcp_pkt *fsp, unsigned long delay)
238 {
239 	if (!(fsp->state & FC_SRB_COMPL)) {
240 		mod_timer(&fsp->timer, jiffies + delay);
241 		fsp->timer_delay = delay;
242 	}
243 }
244 
fc_fcp_abort_done(struct fc_fcp_pkt * fsp)245 static 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  */
fc_fcp_send_abort(struct fc_fcp_pkt * fsp)261 static 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, 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  */
fc_fcp_retry_cmd(struct fc_fcp_pkt * fsp,int status_code)293 static void fc_fcp_retry_cmd(struct fc_fcp_pkt *fsp, int status_code)
294 {
295 	if (fsp->seq_ptr) {
296 		fc_exch_done(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  */
fc_fcp_ddp_setup(struct fc_fcp_pkt * fsp,u16 xid)311 void 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(fsp->cmd),
319 					scsi_sg_count(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  */
fc_fcp_ddp_done(struct fc_fcp_pkt * fsp)329 void 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  */
fc_fcp_can_queue_ramp_up(struct fc_lport * lport)350 static 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 
378 unlock:
379 	spin_unlock_irqrestore(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  */
fc_fcp_can_queue_ramp_down(struct fc_lport * lport)392 static 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 
415 unlock:
416 	spin_unlock_irqrestore(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  */
fc_fcp_frame_alloc(struct fc_lport * lport,size_t len)428 static 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(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  */
get_fsp_rec_tov(struct fc_fcp_pkt * fsp)452 static 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(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  */
fc_fcp_recv_data(struct fc_fcp_pkt * fsp,struct fc_frame * fp)467 static 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, 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(sc);
517 	nents = scsi_sg_count(sc);
518 
519 	if (!(fr_flags(fp) & FCPHF_CRC_UNCHECKED)) {
520 		copy_len = fc_copy_buffer_to_sglist(buf, len, sg, &nents,
521 						    &offset, NULL);
522 	} else {
523 		crc = crc32(~0, (u8 *) fh, sizeof(*fh));
524 		copy_len = fc_copy_buffer_to_sglist(buf, len, sg, &nents,
525 						    &offset, &crc);
526 		buf = fc_frame_payload_get(fp, 0);
527 		if (len % 4)
528 			crc = crc32(crc, buf + len, 4 - (len % 4));
529 
530 		if (~crc != le32_to_cpu(fr_crc(fp))) {
531 crc_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;
567 err:
568 	fc_fcp_recovery(fsp, 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  */
fc_fcp_send_data(struct fc_fcp_pkt * fsp,struct fc_seq * seq,size_t offset,size_t seq_blen)584 static 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(seq);
638 	f_ctl = FC_FC_REL_OFF;
639 	WARN_ON(!seq);
640 
641 	sg = scsi_sglist(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(lport, 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 & ~PAGE_MASK, 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, FC_RCTL_DD_SOL_DATA, ep->did, ep->sid,
710 			       FC_TYPE_FCP, f_ctl, fh_parm_offset);
711 
712 		/*
713 		 * send fragment using for a sequence.
714 		 */
715 		error = fc_seq_send(lport, 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  */
fc_fcp_abts_resp(struct fc_fcp_pkt * fsp,struct fc_frame * fp)731 static 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, 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  */
fc_fcp_recv(struct fc_seq * seq,struct fc_frame * fp,void * arg)768 static 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(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, sizeof(*dd));
810 		WARN_ON(!dd);
811 
812 		rc = fc_fcp_send_data(fsp, seq,
813 				      (size_t) ntohl(dd->ft_data_ro),
814 				      (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 	}
832 unlock:
833 	fc_fcp_unlock_pkt(fsp);
834 out:
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  */
fc_fcp_resp(struct fc_fcp_pkt * fsp,struct fc_frame * fp)843 static 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(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, 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 
957 len_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);
960 err:
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  */
fc_fcp_complete_locked(struct fc_fcp_pkt * fsp)973 static 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(seq);
1009 			conf_frame = fc_fcp_frame_alloc(fsp->lp, 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(conf_frame, FC_RCTL_DD_SOL_CTL,
1015 					       ep->did, ep->sid,
1016 					       FC_TYPE_FCP, f_ctl, 0);
1017 				fc_seq_send(lport, csp, conf_frame);
1018 			}
1019 		}
1020 		fc_exch_done(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  */
fc_fcp_cleanup_cmd(struct fc_fcp_pkt * fsp,int error)1036 static void fc_fcp_cleanup_cmd(struct fc_fcp_pkt *fsp, int error)
1037 {
1038 	if (fsp->seq_ptr) {
1039 		fc_exch_done(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  */
fc_fcp_cleanup_each_cmd(struct fc_lport * lport,unsigned int id,unsigned int lun,int error)1054 static 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);
1063 restart:
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(&si->scsi_queue_lock, flags);
1074 
1075 		spin_lock_bh(&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(&fsp->scsi_pkt_lock);
1088 
1089 			fc_fcp_cleanup_cmd(fsp, error);
1090 
1091 			spin_lock_bh(&fsp->scsi_pkt_lock);
1092 			fc_io_compl(fsp);
1093 		}
1094 		spin_unlock_bh(&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(&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  */
fc_fcp_abort_io(struct fc_lport * lport)1111 static void fc_fcp_abort_io(struct fc_lport *lport)
1112 {
1113 	fc_fcp_cleanup_each_cmd(lport, -1, -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  */
fc_fcp_pkt_send(struct fc_lport * lport,struct fc_fcp_pkt * fsp)1124 static 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(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(&fsp->list, &si->scsi_pkt_queue);
1139 	spin_unlock_irqrestore(&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(fsp->cmd)->fsp = NULL;
1144 		list_del(&fsp->list);
1145 		spin_unlock_irqrestore(&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  */
fc_fcp_cmd_send(struct fc_lport * lport,struct fc_fcp_pkt * fsp,void (* resp)(struct fc_seq *,struct fc_frame * fp,void * arg))1157 static 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, 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, FC_RCTL_DD_UNSOL_CMD, rport->port_id,
1185 		       rpriv->local_port->port_id, FC_TYPE_FCP,
1186 		       FC_FCTL_REQ, 0);
1187 
1188 	seq = fc_exch_seq_send(lport, fp, resp, fc_fcp_pkt_destroy, fsp, 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, get_fsp_rec_tov(fsp));
1199 
1200 unlock:
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  */
fc_fcp_error(struct fc_fcp_pkt * fsp,struct fc_frame * fp)1210 static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1211 {
1212 	int error = PTR_ERR(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);
1229 unlock:
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  */
fc_fcp_pkt_abort(struct fc_fcp_pkt * fsp)1239 static 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(&fsp->tm_done);
1256 	fsp->wait_for_comp = 1;
1257 
1258 	spin_unlock_bh(&fsp->scsi_pkt_lock);
1259 	ticks_left = wait_for_completion_timeout(&fsp->tm_done,
1260 							FC_SCSI_TM_TOV);
1261 	spin_lock_bh(&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  */
fc_lun_reset_send(struct timer_list * t)1279 static 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, 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  */
fc_lun_reset(struct fc_lport * lport,struct fc_fcp_pkt * fsp,unsigned int id,unsigned int lun)1303 static 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(&fsp->tm_done);
1314 
1315 	fc_lun_reset_send(&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(&fsp->tm_done, FC_SCSI_TM_TOV);
1322 
1323 	spin_lock_bh(&fsp->scsi_pkt_lock);
1324 	fsp->state |= FC_SRB_COMPL;
1325 	spin_unlock_bh(&fsp->scsi_pkt_lock);
1326 
1327 	del_timer_sync(&fsp->timer);
1328 
1329 	spin_lock_bh(&fsp->scsi_pkt_lock);
1330 	if (fsp->seq_ptr) {
1331 		fc_exch_done(fsp->seq_ptr);
1332 		fsp->seq_ptr = NULL;
1333 	}
1334 	fsp->wait_for_comp = 0;
1335 	spin_unlock_bh(&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  */
fc_tm_done(struct fc_seq * seq,struct fc_frame * fp,void * arg)1357 static 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(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(seq);
1386 out_unlock:
1387 	fc_fcp_unlock_pkt(fsp);
1388 out:
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  */
fc_fcp_cleanup(struct fc_lport * lport)1396 static void fc_fcp_cleanup(struct fc_lport *lport)
1397 {
1398 	fc_fcp_cleanup_each_cmd(lport, -1, -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  */
fc_fcp_timeout(struct timer_list * t)1412 static 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, 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;
1442 unlock:
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  */
fc_fcp_rec(struct fc_fcp_pkt * fsp)1450 static 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, 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, FC_RCTL_ELS_REQ, rport->port_id,
1473 		       rpriv->local_port->port_id, FC_TYPE_ELS,
1474 		       FC_FCTL_REQ, 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 	}
1481 retry:
1482 	if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1483 		fc_fcp_timer_set(fsp, 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  */
fc_fcp_rec_resp(struct fc_seq * seq,struct fc_frame * fp,void * arg)1499 static 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(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, 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, 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,  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 	}
1631 unlock_out:
1632 	fc_fcp_unlock_pkt(fsp);
1633 out:
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  */
fc_fcp_rec_error(struct fc_fcp_pkt * fsp,struct fc_frame * fp)1643 static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1644 {
1645 	int error = PTR_ERR(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);
1678 out:
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  */
fc_fcp_recovery(struct fc_fcp_pkt * fsp,u8 code)1687 static 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  */
fc_fcp_srr(struct fc_fcp_pkt * fsp,enum fc_rctl r_ctl,u32 offset)1708 static 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, sizeof(*srr));
1725 	if (!fp)
1726 		goto retry;
1727 
1728 	srr = fc_frame_payload_get(fp, 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, FC_RCTL_ELS4_REQ, rport->port_id,
1737 		       rpriv->local_port->port_id, FC_TYPE_FCP,
1738 		       FC_FCTL_REQ, 0);
1739 
1740 	seq = fc_exch_seq_send(lport, fp, fc_fcp_srr_resp,
1741 			       fc_fcp_pkt_destroy,
1742 			       fsp, 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;
1752 retry:
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  */
fc_fcp_srr_resp(struct fc_seq * seq,struct fc_frame * fp,void * arg)1762 static 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(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, 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);
1799 out:
1800 	fc_exch_done(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  */
fc_fcp_srr_error(struct fc_fcp_pkt * fsp,struct fc_frame * fp)1809 static 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(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);
1829 out:
1830 	fc_exch_done(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  */
fc_fcp_lport_queue_ready(struct fc_lport * lport)1837 static 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  */
fc_queuecommand(struct Scsi_Host * shost,struct scsi_cmnd * sc_cmd)1851 int 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(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(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(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 	}
1933 out:
1934 	return rc;
1935 }
1936 EXPORT_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  */
fc_io_compl(struct fc_fcp_pkt * fsp)1945 static 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(&fsp->scsi_pkt_lock);
1958 		del_timer_sync(&fsp->timer);
1959 		spin_lock_bh(&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(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(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(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(sc_cmd, 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(&fsp->list);
2075 	libfc_priv(sc_cmd)->fsp = NULL;
2076 	spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
2077 	scsi_done(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  */
fc_eh_abort(struct scsi_cmnd * sc_cmd)2090 int 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(sc_cmd);
2100 	if (rval)
2101 		return rval;
2102 
2103 	lport = shost_priv(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(sc_cmd)->fsp;
2112 	if (!fsp) {
2113 		/* command completed while scsi eh was setting up */
2114 		spin_unlock_irqrestore(&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(&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 
2130 release_pkt:
2131 	fc_fcp_pkt_release(fsp);
2132 	return rc;
2133 }
2134 EXPORT_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  */
fc_eh_device_reset(struct scsi_cmnd * sc_cmd)2143 int 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(sc_cmd);
2152 	if (rval)
2153 		return rval;
2154 
2155 	lport = shost_priv(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), sc_cmd->device->lun);
2179 	fsp->state = FC_SRB_FREE;
2180 	fc_fcp_pkt_release(fsp);
2181 
2182 out:
2183 	return rc;
2184 }
2185 EXPORT_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  */
fc_eh_host_reset(struct scsi_cmnd * sc_cmd)2191 int 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(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 }
2216 EXPORT_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  */
fc_slave_alloc(struct scsi_device * sdev)2225 int 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 }
2235 EXPORT_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  */
fc_fcp_destroy(struct fc_lport * lport)2241 void fc_fcp_destroy(struct fc_lport *lport)
2242 {
2243 	struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
2244 
2245 	if (!list_empty(&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(si->scsi_pkt_pool);
2250 	kfree(si);
2251 	lport->scsi_priv = NULL;
2252 }
2253 EXPORT_SYMBOL(fc_fcp_destroy);
2254 
fc_setup_fcp(void)2255 int fc_setup_fcp(void)
2256 {
2257 	int rc = 0;
2258 
2259 	scsi_pkt_cachep = kmem_cache_create("libfc_fcp_pkt",
2260 					    sizeof(struct fc_fcp_pkt),
2261 					    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 
fc_destroy_fcp(void)2271 void fc_destroy_fcp(void)
2272 {
2273 	kmem_cache_destroy(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  */
fc_fcp_init(struct fc_lport * lport)2280 int 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(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(&si->scsi_pkt_queue);
2300 	spin_lock_init(&si->scsi_queue_lock);
2301 
2302 	si->scsi_pkt_pool = mempool_create_slab_pool(2, scsi_pkt_cachep);
2303 	if (!si->scsi_pkt_pool) {
2304 		rc = -ENOMEM;
2305 		goto free_internal;
2306 	}
2307 	return 0;
2308 
2309 free_internal:
2310 	kfree(si);
2311 	return rc;
2312 }
2313 EXPORT_SYMBOL(fc_fcp_init);
2314