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