diff mbox series

[v2,19/44] fnic: Stop using the SCSI pointer

Message ID 20220208172514.3481-20-bvanassche@acm.org
State Superseded
Headers show
Series Remove the SCSI pointer from struct scsi_cmnd | expand

Commit Message

Bart Van Assche Feb. 8, 2022, 5:24 p.m. UTC 
Set .cmd_size in the SCSI host template instead of using the SCSI pointer
from struct scsi_cmnd. This patch prepares for removal of the SCSI pointer
from struct scsi_cmnd.

Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 drivers/scsi/fnic/fnic.h      |  27 +++-
 drivers/scsi/fnic/fnic_main.c |   1 +
 drivers/scsi/fnic/fnic_scsi.c | 289 +++++++++++++++++-----------------
 3 files changed, 163 insertions(+), 154 deletions(-)

Comments

Hannes Reinecke Feb. 9, 2022, 7:56 a.m. UTC | #1 
On 2/8/22 18:24, Bart Van Assche wrote:
> Set .cmd_size in the SCSI host template instead of using the SCSI pointer
> from struct scsi_cmnd. This patch prepares for removal of the SCSI pointer
> from struct scsi_cmnd.
> 
> Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
> ---
>   drivers/scsi/fnic/fnic.h      |  27 +++-
>   drivers/scsi/fnic/fnic_main.c |   1 +
>   drivers/scsi/fnic/fnic_scsi.c | 289 +++++++++++++++++-----------------
>   3 files changed, 163 insertions(+), 154 deletions(-)
> 
> diff --git a/drivers/scsi/fnic/fnic.h b/drivers/scsi/fnic/fnic.h
> index b95d0063dedb..aa07189fb5fb 100644
> --- a/drivers/scsi/fnic/fnic.h
> +++ b/drivers/scsi/fnic/fnic.h
> @@ -89,15 +89,28 @@
>   #define FNIC_DEV_RST_ABTS_PENDING       BIT(21)
>   
>   /*
> - * Usage of the scsi_cmnd scratchpad.
> + * fnic private data per SCSI command.
>    * These fields are locked by the hashed io_req_lock.
>    */
> -#define CMD_SP(Cmnd)		((Cmnd)->SCp.ptr)
> -#define CMD_STATE(Cmnd)		((Cmnd)->SCp.phase)
> -#define CMD_ABTS_STATUS(Cmnd)	((Cmnd)->SCp.Message)
> -#define CMD_LR_STATUS(Cmnd)	((Cmnd)->SCp.have_data_in)
> -#define CMD_TAG(Cmnd)           ((Cmnd)->SCp.sent_command)
> -#define CMD_FLAGS(Cmnd)         ((Cmnd)->SCp.Status)
> +struct fnic_cmd_priv {
> +	struct fnic_io_req *io_req;
> +	enum fnic_ioreq_state state;
> +	u32 flags;
> +	u16 abts_status;
> +	u16 lr_status;
> +};
> +
> +static inline struct fnic_cmd_priv *fnic_priv(struct scsi_cmnd *cmd)
> +{
> +	return scsi_cmd_priv(cmd);
> +}
> +
> +static inline u64 fnic_flags_and_state(struct scsi_cmnd *cmd)
> +{
> +	struct fnic_cmd_priv *fcmd = fnic_priv(cmd);
> +
> +	return ((u64)fcmd->flags << 32) | fcmd->state;
> +}
>   
>   #define FCPIO_INVALID_CODE 0x100 /* hdr_status value unused by firmware */
>   
> diff --git a/drivers/scsi/fnic/fnic_main.c b/drivers/scsi/fnic/fnic_main.c
> index 44dbaa662d94..9161bd2fd421 100644
> --- a/drivers/scsi/fnic/fnic_main.c
> +++ b/drivers/scsi/fnic/fnic_main.c
> @@ -124,6 +124,7 @@ static struct scsi_host_template fnic_host_template = {
>   	.max_sectors = 0xffff,
>   	.shost_groups = fnic_host_groups,
>   	.track_queue_depth = 1,
> +	.cmd_size = sizeof(struct fnic_cmd_priv),
>   };
>   
>   static void
> diff --git a/drivers/scsi/fnic/fnic_scsi.c b/drivers/scsi/fnic/fnic_scsi.c
> index 549754245f7a..3c00e5b88350 100644
> --- a/drivers/scsi/fnic/fnic_scsi.c
> +++ b/drivers/scsi/fnic/fnic_scsi.c
> @@ -497,8 +497,8 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc)
>   	 * caller disabling them.
>   	 */
>   	spin_unlock(lp->host->host_lock);
> -	CMD_STATE(sc) = FNIC_IOREQ_NOT_INITED;
> -	CMD_FLAGS(sc) = FNIC_NO_FLAGS;
> +	fnic_priv(sc)->state = FNIC_IOREQ_NOT_INITED;
> +	fnic_priv(sc)->flags = FNIC_NO_FLAGS;
>   
Why not keep the macros?
Would be less churn with the driver, no?

Cheers,

Hannes
Himanshu Madhani Feb. 9, 2022, 6:17 p.m. UTC | #2 
> On Feb 8, 2022, at 9:24 AM, Bart Van Assche <bvanassche@acm.org> wrote:
> 
> Set .cmd_size in the SCSI host template instead of using the SCSI pointer
> from struct scsi_cmnd. This patch prepares for removal of the SCSI pointer
> from struct scsi_cmnd.
> 
> Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
> ---
> drivers/scsi/fnic/fnic.h      |  27 +++-
> drivers/scsi/fnic/fnic_main.c |   1 +
> drivers/scsi/fnic/fnic_scsi.c | 289 +++++++++++++++++-----------------
> 3 files changed, 163 insertions(+), 154 deletions(-)
> 
> diff --git a/drivers/scsi/fnic/fnic.h b/drivers/scsi/fnic/fnic.h
> index b95d0063dedb..aa07189fb5fb 100644
> --- a/drivers/scsi/fnic/fnic.h
> +++ b/drivers/scsi/fnic/fnic.h
> @@ -89,15 +89,28 @@
> #define FNIC_DEV_RST_ABTS_PENDING       BIT(21)
> 
> /*
> - * Usage of the scsi_cmnd scratchpad.
> + * fnic private data per SCSI command.
>  * These fields are locked by the hashed io_req_lock.
>  */
> -#define CMD_SP(Cmnd)		((Cmnd)->SCp.ptr)
> -#define CMD_STATE(Cmnd)		((Cmnd)->SCp.phase)
> -#define CMD_ABTS_STATUS(Cmnd)	((Cmnd)->SCp.Message)
> -#define CMD_LR_STATUS(Cmnd)	((Cmnd)->SCp.have_data_in)
> -#define CMD_TAG(Cmnd)           ((Cmnd)->SCp.sent_command)
> -#define CMD_FLAGS(Cmnd)         ((Cmnd)->SCp.Status)
> +struct fnic_cmd_priv {
> +	struct fnic_io_req *io_req;
> +	enum fnic_ioreq_state state;
> +	u32 flags;
> +	u16 abts_status;
> +	u16 lr_status;
> +};
> +
> +static inline struct fnic_cmd_priv *fnic_priv(struct scsi_cmnd *cmd)
> +{
> +	return scsi_cmd_priv(cmd);
> +}
> +
> +static inline u64 fnic_flags_and_state(struct scsi_cmnd *cmd)
> +{
> +	struct fnic_cmd_priv *fcmd = fnic_priv(cmd);
> +
> +	return ((u64)fcmd->flags << 32) | fcmd->state;
> +}
> 
> #define FCPIO_INVALID_CODE 0x100 /* hdr_status value unused by firmware */
> 
> diff --git a/drivers/scsi/fnic/fnic_main.c b/drivers/scsi/fnic/fnic_main.c
> index 44dbaa662d94..9161bd2fd421 100644
> --- a/drivers/scsi/fnic/fnic_main.c
> +++ b/drivers/scsi/fnic/fnic_main.c
> @@ -124,6 +124,7 @@ static struct scsi_host_template fnic_host_template = {
> 	.max_sectors = 0xffff,
> 	.shost_groups = fnic_host_groups,
> 	.track_queue_depth = 1,
> +	.cmd_size = sizeof(struct fnic_cmd_priv),
> };
> 
> static void
> diff --git a/drivers/scsi/fnic/fnic_scsi.c b/drivers/scsi/fnic/fnic_scsi.c
> index 549754245f7a..3c00e5b88350 100644
> --- a/drivers/scsi/fnic/fnic_scsi.c
> +++ b/drivers/scsi/fnic/fnic_scsi.c
> @@ -497,8 +497,8 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc)
> 	 * caller disabling them.
> 	 */
> 	spin_unlock(lp->host->host_lock);
> -	CMD_STATE(sc) = FNIC_IOREQ_NOT_INITED;
> -	CMD_FLAGS(sc) = FNIC_NO_FLAGS;
> +	fnic_priv(sc)->state = FNIC_IOREQ_NOT_INITED;
> +	fnic_priv(sc)->flags = FNIC_NO_FLAGS;
> 
> 	/* Get a new io_req for this SCSI IO */
> 	io_req = mempool_alloc(fnic->io_req_pool, GFP_ATOMIC);
> @@ -513,7 +513,7 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc)
> 	sg_count = scsi_dma_map(sc);
> 	if (sg_count < 0) {
> 		FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
> -			  tag, sc, 0, sc->cmnd[0], sg_count, CMD_STATE(sc));
> +			  tag, sc, 0, sc->cmnd[0], sg_count, fnic_priv(sc)->state);
> 		mempool_free(io_req, fnic->io_req_pool);
> 		goto out;
> 	}
> @@ -558,9 +558,9 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc)
> 	io_lock_acquired = 1;
> 	io_req->port_id = rport->port_id;
> 	io_req->start_time = jiffies;
> -	CMD_STATE(sc) = FNIC_IOREQ_CMD_PENDING;
> -	CMD_SP(sc) = (char *)io_req;
> -	CMD_FLAGS(sc) |= FNIC_IO_INITIALIZED;
> +	fnic_priv(sc)->state = FNIC_IOREQ_CMD_PENDING;
> +	fnic_priv(sc)->io_req = io_req;
> +	fnic_priv(sc)->flags |= FNIC_IO_INITIALIZED;
> 
> 	/* create copy wq desc and enqueue it */
> 	wq = &fnic->wq_copy[0];
> @@ -571,11 +571,10 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc)
> 		 * refetch the pointer under the lock.
> 		 */
> 		FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
> -			  tag, sc, 0, 0, 0,
> -			  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
> -		io_req = (struct fnic_io_req *)CMD_SP(sc);
> -		CMD_SP(sc) = NULL;
> -		CMD_STATE(sc) = FNIC_IOREQ_CMD_COMPLETE;
> +			  tag, sc, 0, 0, 0, fnic_flags_and_state(sc));
> +		io_req = fnic_priv(sc)->io_req;
> +		fnic_priv(sc)->io_req = NULL;
> +		fnic_priv(sc)->state = FNIC_IOREQ_CMD_COMPLETE;
> 		spin_unlock_irqrestore(io_lock, flags);
> 		if (io_req) {
> 			fnic_release_ioreq_buf(fnic, io_req, sc);
> @@ -594,7 +593,7 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc)
> 			     atomic64_read(&fnic_stats->io_stats.active_ios));
> 
> 		/* REVISIT: Use per IO lock in the final code */
> -		CMD_FLAGS(sc) |= FNIC_IO_ISSUED;
> +		fnic_priv(sc)->flags |= FNIC_IO_ISSUED;
> 	}
> out:
> 	cmd_trace = ((u64)sc->cmnd[0] << 56 | (u64)sc->cmnd[7] << 40 |
> @@ -603,8 +602,8 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc)
> 			sc->cmnd[5]);
> 
> 	FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
> -		  tag, sc, io_req, sg_count, cmd_trace,
> -		  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
> +		   tag, sc, io_req, sg_count, cmd_trace,
> +		   fnic_flags_and_state(sc));
> 
> 	/* if only we issued IO, will we have the io lock */
> 	if (io_lock_acquired)
> @@ -867,11 +866,11 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
> 
> 	io_lock = fnic_io_lock_hash(fnic, sc);
> 	spin_lock_irqsave(io_lock, flags);
> -	io_req = (struct fnic_io_req *)CMD_SP(sc);
> +	io_req = fnic_priv(sc)->io_req;
> 	WARN_ON_ONCE(!io_req);
> 	if (!io_req) {
> 		atomic64_inc(&fnic_stats->io_stats.ioreq_null);
> -		CMD_FLAGS(sc) |= FNIC_IO_REQ_NULL;
> +		fnic_priv(sc)->flags |= FNIC_IO_REQ_NULL;
> 		spin_unlock_irqrestore(io_lock, flags);
> 		shost_printk(KERN_ERR, fnic->lport->host,
> 			  "icmnd_cmpl io_req is null - "
> @@ -888,17 +887,17 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
> 	 *  if SCSI-ML has already issued abort on this command,
> 	 *  set completion of the IO. The abts path will clean it up
> 	 */
> -	if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
> +	if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
> 
> 		/*
> 		 * set the FNIC_IO_DONE so that this doesn't get
> 		 * flagged as 'out of order' if it was not aborted
> 		 */
> -		CMD_FLAGS(sc) |= FNIC_IO_DONE;
> -		CMD_FLAGS(sc) |= FNIC_IO_ABTS_PENDING;
> +		fnic_priv(sc)->flags |= FNIC_IO_DONE;
> +		fnic_priv(sc)->flags |= FNIC_IO_ABTS_PENDING;
> 		spin_unlock_irqrestore(io_lock, flags);
> 		if(FCPIO_ABORTED == hdr_status)
> -			CMD_FLAGS(sc) |= FNIC_IO_ABORTED;
> +			fnic_priv(sc)->flags |= FNIC_IO_ABORTED;
> 
> 		FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
> 			"icmnd_cmpl abts pending "
> @@ -912,7 +911,7 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
> 	}
> 
> 	/* Mark the IO as complete */
> -	CMD_STATE(sc) = FNIC_IOREQ_CMD_COMPLETE;
> +	fnic_priv(sc)->state = FNIC_IOREQ_CMD_COMPLETE;
> 
> 	icmnd_cmpl = &desc->u.icmnd_cmpl;
> 
> @@ -983,8 +982,8 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
> 	}
> 
> 	/* Break link with the SCSI command */
> -	CMD_SP(sc) = NULL;
> -	CMD_FLAGS(sc) |= FNIC_IO_DONE;
> +	fnic_priv(sc)->io_req = NULL;
> +	fnic_priv(sc)->flags |= FNIC_IO_DONE;
> 
> 	spin_unlock_irqrestore(io_lock, flags);
> 
> @@ -1009,8 +1008,7 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
> 		  ((u64)icmnd_cmpl->_resvd0[1] << 56 |
> 		  (u64)icmnd_cmpl->_resvd0[0] << 48 |
> 		  jiffies_to_msecs(jiffies - start_time)),
> -		  desc, cmd_trace,
> -		  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
> +		  desc, cmd_trace, fnic_flags_and_state(sc));
> 
> 	if (sc->sc_data_direction == DMA_FROM_DEVICE) {
> 		fnic->lport->host_stats.fcp_input_requests++;
> @@ -1095,12 +1093,12 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
> 	}
> 	io_lock = fnic_io_lock_hash(fnic, sc);
> 	spin_lock_irqsave(io_lock, flags);
> -	io_req = (struct fnic_io_req *)CMD_SP(sc);
> +	io_req = fnic_priv(sc)->io_req;
> 	WARN_ON_ONCE(!io_req);
> 	if (!io_req) {
> 		atomic64_inc(&fnic_stats->io_stats.ioreq_null);
> 		spin_unlock_irqrestore(io_lock, flags);
> -		CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_REQ_NULL;
> +		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_REQ_NULL;
> 		shost_printk(KERN_ERR, fnic->lport->host,
> 			  "itmf_cmpl io_req is null - "
> 			  "hdr status = %s tag = 0x%x sc 0x%p\n",
> @@ -1115,9 +1113,9 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
> 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> 			      "dev reset abts cmpl recd. id %x status %s\n",
> 			      id, fnic_fcpio_status_to_str(hdr_status));
> -		CMD_STATE(sc) = FNIC_IOREQ_ABTS_COMPLETE;
> -		CMD_ABTS_STATUS(sc) = hdr_status;
> -		CMD_FLAGS(sc) |= FNIC_DEV_RST_DONE;
> +		fnic_priv(sc)->state = FNIC_IOREQ_ABTS_COMPLETE;
> +		fnic_priv(sc)->abts_status = hdr_status;
> +		fnic_priv(sc)->flags |= FNIC_DEV_RST_DONE;
> 		if (io_req->abts_done)
> 			complete(io_req->abts_done);
> 		spin_unlock_irqrestore(io_lock, flags);
> @@ -1127,7 +1125,7 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
> 		case FCPIO_SUCCESS:
> 			break;
> 		case FCPIO_TIMEOUT:
> -			if (CMD_FLAGS(sc) & FNIC_IO_ABTS_ISSUED)
> +			if (fnic_priv(sc)->flags & FNIC_IO_ABTS_ISSUED)
> 				atomic64_inc(&abts_stats->abort_fw_timeouts);
> 			else
> 				atomic64_inc(
> @@ -1139,34 +1137,34 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
> 				(int)(id & FNIC_TAG_MASK));
> 			break;
> 		case FCPIO_IO_NOT_FOUND:
> -			if (CMD_FLAGS(sc) & FNIC_IO_ABTS_ISSUED)
> +			if (fnic_priv(sc)->flags & FNIC_IO_ABTS_ISSUED)
> 				atomic64_inc(&abts_stats->abort_io_not_found);
> 			else
> 				atomic64_inc(
> 					&term_stats->terminate_io_not_found);
> 			break;
> 		default:
> -			if (CMD_FLAGS(sc) & FNIC_IO_ABTS_ISSUED)
> +			if (fnic_priv(sc)->flags & FNIC_IO_ABTS_ISSUED)
> 				atomic64_inc(&abts_stats->abort_failures);
> 			else
> 				atomic64_inc(
> 					&term_stats->terminate_failures);
> 			break;
> 		}
> -		if (CMD_STATE(sc) != FNIC_IOREQ_ABTS_PENDING) {
> +		if (fnic_priv(sc)->state != FNIC_IOREQ_ABTS_PENDING) {
> 			/* This is a late completion. Ignore it */
> 			spin_unlock_irqrestore(io_lock, flags);
> 			return;
> 		}
> 
> -		CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_DONE;
> -		CMD_ABTS_STATUS(sc) = hdr_status;
> +		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_DONE;
> +		fnic_priv(sc)->abts_status = hdr_status;
> 
> 		/* If the status is IO not found consider it as success */
> 		if (hdr_status == FCPIO_IO_NOT_FOUND)
> -			CMD_ABTS_STATUS(sc) = FCPIO_SUCCESS;
> +			fnic_priv(sc)->abts_status = FCPIO_SUCCESS;
> 
> -		if (!(CMD_FLAGS(sc) & (FNIC_IO_ABORTED | FNIC_IO_DONE)))
> +		if (!(fnic_priv(sc)->flags & (FNIC_IO_ABORTED | FNIC_IO_DONE)))
> 			atomic64_inc(&misc_stats->no_icmnd_itmf_cmpls);
> 
> 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> @@ -1185,7 +1183,7 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
> 		} else {
> 			FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> 				      "abts cmpl, completing IO\n");
> -			CMD_SP(sc) = NULL;
> +			fnic_priv(sc)->io_req = NULL;
> 			sc->result = (DID_ERROR << 16);
> 
> 			spin_unlock_irqrestore(io_lock, flags);
> @@ -1202,8 +1200,7 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
> 				    (u64)sc->cmnd[2] << 24 |
> 				    (u64)sc->cmnd[3] << 16 |
> 				    (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
> -				   (((u64)CMD_FLAGS(sc) << 32) |
> -				    CMD_STATE(sc)));
> +				   fnic_flags_and_state(sc));
> 			scsi_done(sc);
> 			atomic64_dec(&fnic_stats->io_stats.active_ios);
> 			if (atomic64_read(&fnic->io_cmpl_skip))
> @@ -1213,15 +1210,14 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
> 		}
> 	} else if (id & FNIC_TAG_DEV_RST) {
> 		/* Completion of device reset */
> -		CMD_LR_STATUS(sc) = hdr_status;
> -		if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
> +		fnic_priv(sc)->lr_status = hdr_status;
> +		if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
> 			spin_unlock_irqrestore(io_lock, flags);
> -			CMD_FLAGS(sc) |= FNIC_DEV_RST_ABTS_PENDING;
> +			fnic_priv(sc)->flags |= FNIC_DEV_RST_ABTS_PENDING;
> 			FNIC_TRACE(fnic_fcpio_itmf_cmpl_handler,
> 				  sc->device->host->host_no, id, sc,
> 				  jiffies_to_msecs(jiffies - start_time),
> -				  desc, 0,
> -				  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
> +				  desc, 0, fnic_flags_and_state(sc));
> 			FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> 				"Terminate pending "
> 				"dev reset cmpl recd. id %d status %s\n",
> @@ -1229,14 +1225,13 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
> 				fnic_fcpio_status_to_str(hdr_status));
> 			return;
> 		}
> -		if (CMD_FLAGS(sc) & FNIC_DEV_RST_TIMED_OUT) {
> +		if (fnic_priv(sc)->flags & FNIC_DEV_RST_TIMED_OUT) {
> 			/* Need to wait for terminate completion */
> 			spin_unlock_irqrestore(io_lock, flags);
> 			FNIC_TRACE(fnic_fcpio_itmf_cmpl_handler,
> 				  sc->device->host->host_no, id, sc,
> 				  jiffies_to_msecs(jiffies - start_time),
> -				  desc, 0,
> -				  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
> +				  desc, 0, fnic_flags_and_state(sc));
> 			FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> 				"dev reset cmpl recd after time out. "
> 				"id %d status %s\n",
> @@ -1244,8 +1239,8 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
> 				fnic_fcpio_status_to_str(hdr_status));
> 			return;
> 		}
> -		CMD_STATE(sc) = FNIC_IOREQ_CMD_COMPLETE;
> -		CMD_FLAGS(sc) |= FNIC_DEV_RST_DONE;
> +		fnic_priv(sc)->state = FNIC_IOREQ_CMD_COMPLETE;
> +		fnic_priv(sc)->flags |= FNIC_DEV_RST_DONE;
> 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> 			      "dev reset cmpl recd. id %d status %s\n",
> 			      (int)(id & FNIC_TAG_MASK),
> @@ -1257,7 +1252,7 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
> 	} else {
> 		shost_printk(KERN_ERR, fnic->lport->host,
> 			     "Unexpected itmf io state %s tag %x\n",
> -			     fnic_ioreq_state_to_str(CMD_STATE(sc)), id);
> +			     fnic_ioreq_state_to_str(fnic_priv(sc)->state), id);
> 		spin_unlock_irqrestore(io_lock, flags);
> 	}
> 
> @@ -1370,21 +1365,21 @@ static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data,
> 	io_lock = fnic_io_lock_tag(fnic, tag);
> 	spin_lock_irqsave(io_lock, flags);
> 
> -	io_req = (struct fnic_io_req *)CMD_SP(sc);
> -	if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
> -	    !(CMD_FLAGS(sc) & FNIC_DEV_RST_DONE)) {
> +	io_req = fnic_priv(sc)->io_req;
> +	if ((fnic_priv(sc)->flags & FNIC_DEVICE_RESET) &&
> +	    !(fnic_priv(sc)->flags & FNIC_DEV_RST_DONE)) {
> 		/*
> 		 * We will be here only when FW completes reset
> 		 * without sending completions for outstanding ios.
> 		 */
> -		CMD_FLAGS(sc) |= FNIC_DEV_RST_DONE;
> +		fnic_priv(sc)->flags |= FNIC_DEV_RST_DONE;
> 		if (io_req && io_req->dr_done)
> 			complete(io_req->dr_done);
> 		else if (io_req && io_req->abts_done)
> 			complete(io_req->abts_done);
> 		spin_unlock_irqrestore(io_lock, flags);
> 		return true;
> -	} else if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
> +	} else if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET) {
> 		spin_unlock_irqrestore(io_lock, flags);
> 		return true;
> 	}
> @@ -1393,7 +1388,7 @@ static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data,
> 		goto cleanup_scsi_cmd;
> 	}
> 
> -	CMD_SP(sc) = NULL;
> +	fnic_priv(sc)->io_req = NULL;
> 
> 	spin_unlock_irqrestore(io_lock, flags);
> 
> @@ -1417,7 +1412,7 @@ static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data,
> 		atomic64_inc(&fnic_stats->io_stats.io_completions);
> 
> 	/* Complete the command to SCSI */
> -	if (!(CMD_FLAGS(sc) & FNIC_IO_ISSUED))
> +	if (!(fnic_priv(sc)->flags & FNIC_IO_ISSUED))
> 		shost_printk(KERN_ERR, fnic->lport->host,
> 			     "Calling done for IO not issued to fw: tag:0x%x sc:0x%p\n",
> 			     tag, sc);
> @@ -1429,7 +1424,7 @@ static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data,
> 		       (u64)sc->cmnd[2] << 24 |
> 		       (u64)sc->cmnd[3] << 16 |
> 		       (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
> -		   (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
> +		   fnic_flags_and_state(sc));
> 
> 	scsi_done(sc);
> 
> @@ -1468,7 +1463,7 @@ void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
> 	spin_lock_irqsave(io_lock, flags);
> 
> 	/* Get the IO context which this desc refers to */
> -	io_req = (struct fnic_io_req *)CMD_SP(sc);
> +	io_req = fnic_priv(sc)->io_req;
> 
> 	/* fnic interrupts are turned off by now */
> 
> @@ -1477,7 +1472,7 @@ void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
> 		goto wq_copy_cleanup_scsi_cmd;
> 	}
> 
> -	CMD_SP(sc) = NULL;
> +	fnic_priv(sc)->io_req = NULL;
> 
> 	spin_unlock_irqrestore(io_lock, flags);
> 
> @@ -1496,7 +1491,7 @@ void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
> 		   0, ((u64)sc->cmnd[0] << 32 |
> 		       (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
> 		       (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
> -		   (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
> +		   fnic_flags_and_state(sc));
> 
> 	scsi_done(sc);
> }
> @@ -1571,15 +1566,15 @@ static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data,
> 	io_lock = fnic_io_lock_tag(fnic, abt_tag);
> 	spin_lock_irqsave(io_lock, flags);
> 
> -	io_req = (struct fnic_io_req *)CMD_SP(sc);
> +	io_req = fnic_priv(sc)->io_req;
> 
> 	if (!io_req || io_req->port_id != iter_data->port_id) {
> 		spin_unlock_irqrestore(io_lock, flags);
> 		return true;
> 	}
> 
> -	if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
> -	    (!(CMD_FLAGS(sc) & FNIC_DEV_RST_ISSUED))) {
> +	if ((fnic_priv(sc)->flags & FNIC_DEVICE_RESET) &&
> +	    !(fnic_priv(sc)->flags & FNIC_DEV_RST_ISSUED)) {
> 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> 			"fnic_rport_exch_reset dev rst not pending sc 0x%p\n",
> 			sc);
> @@ -1591,7 +1586,7 @@ static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data,
> 	 * Found IO that is still pending with firmware and
> 	 * belongs to rport that went away
> 	 */
> -	if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
> +	if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
> 		spin_unlock_irqrestore(io_lock, flags);
> 		return true;
> 	}
> @@ -1599,20 +1594,20 @@ static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data,
> 		shost_printk(KERN_ERR, fnic->lport->host,
> 			"fnic_rport_exch_reset: io_req->abts_done is set "
> 			"state is %s\n",
> -			fnic_ioreq_state_to_str(CMD_STATE(sc)));
> +			fnic_ioreq_state_to_str(fnic_priv(sc)->state));
> 	}
> 
> -	if (!(CMD_FLAGS(sc) & FNIC_IO_ISSUED)) {
> +	if (!(fnic_priv(sc)->flags & FNIC_IO_ISSUED)) {
> 		shost_printk(KERN_ERR, fnic->lport->host,
> 			     "rport_exch_reset "
> 			     "IO not yet issued %p tag 0x%x flags "
> 			     "%x state %d\n",
> -			     sc, abt_tag, CMD_FLAGS(sc), CMD_STATE(sc));
> +			     sc, abt_tag, fnic_priv(sc)->flags, fnic_priv(sc)->state);
> 	}
> -	old_ioreq_state = CMD_STATE(sc);
> -	CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
> -	CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
> -	if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
> +	old_ioreq_state = fnic_priv(sc)->state;
> +	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_PENDING;
> +	fnic_priv(sc)->abts_status = FCPIO_INVALID_CODE;
> +	if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET) {
> 		atomic64_inc(&reset_stats->device_reset_terminates);
> 		abt_tag |= FNIC_TAG_DEV_RST;
> 	}
> @@ -1638,15 +1633,15 @@ static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data,
> 		 * lun reset
> 		 */
> 		spin_lock_irqsave(io_lock, flags);
> -		if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
> -			CMD_STATE(sc) = old_ioreq_state;
> +		if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING)
> +			fnic_priv(sc)->state = old_ioreq_state;
> 		spin_unlock_irqrestore(io_lock, flags);
> 	} else {
> 		spin_lock_irqsave(io_lock, flags);
> -		if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET)
> -			CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
> +		if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET)
> +			fnic_priv(sc)->flags |= FNIC_DEV_RST_TERM_ISSUED;
> 		else
> -			CMD_FLAGS(sc) |= FNIC_IO_INTERNAL_TERM_ISSUED;
> +			fnic_priv(sc)->flags |= FNIC_IO_INTERNAL_TERM_ISSUED;
> 		spin_unlock_irqrestore(io_lock, flags);
> 		atomic64_inc(&term_stats->terminates);
> 		iter_data->term_cnt++;
> @@ -1754,9 +1749,9 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
> 	FNIC_SCSI_DBG(KERN_DEBUG,
> 		fnic->lport->host,
> 		"Abort Cmd called FCID 0x%x, LUN 0x%llx TAG %x flags %x\n",
> -		rport->port_id, sc->device->lun, tag, CMD_FLAGS(sc));
> +		rport->port_id, sc->device->lun, tag, fnic_priv(sc)->flags);
> 
> -	CMD_FLAGS(sc) = FNIC_NO_FLAGS;
> +	fnic_priv(sc)->flags = FNIC_NO_FLAGS;
> 
> 	if (lp->state != LPORT_ST_READY || !(lp->link_up)) {
> 		ret = FAILED;
> @@ -1773,11 +1768,11 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
> 	 * happened, the completion wont actually complete the command
> 	 * and it will be considered as an aborted command
> 	 *
> -	 * The CMD_SP will not be cleared except while holding io_req_lock.
> +	 * .io_req will not be cleared except while holding io_req_lock.
> 	 */
> 	io_lock = fnic_io_lock_hash(fnic, sc);
> 	spin_lock_irqsave(io_lock, flags);
> -	io_req = (struct fnic_io_req *)CMD_SP(sc);
> +	io_req = fnic_priv(sc)->io_req;
> 	if (!io_req) {
> 		spin_unlock_irqrestore(io_lock, flags);
> 		goto fnic_abort_cmd_end;
> @@ -1785,7 +1780,7 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
> 
> 	io_req->abts_done = &tm_done;
> 
> -	if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
> +	if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
> 		spin_unlock_irqrestore(io_lock, flags);
> 		goto wait_pending;
> 	}
> @@ -1814,9 +1809,9 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
> 	 * the completion wont be done till mid-layer, since abort
> 	 * has already started.
> 	 */
> -	old_ioreq_state = CMD_STATE(sc);
> -	CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
> -	CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
> +	old_ioreq_state = fnic_priv(sc)->state;
> +	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_PENDING;
> +	fnic_priv(sc)->abts_status = FCPIO_INVALID_CODE;
> 
> 	spin_unlock_irqrestore(io_lock, flags);
> 
> @@ -1838,9 +1833,9 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
> 	if (fnic_queue_abort_io_req(fnic, tag, task_req, fc_lun.scsi_lun,
> 				    io_req)) {
> 		spin_lock_irqsave(io_lock, flags);
> -		if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
> -			CMD_STATE(sc) = old_ioreq_state;
> -		io_req = (struct fnic_io_req *)CMD_SP(sc);
> +		if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING)
> +			fnic_priv(sc)->state = old_ioreq_state;
> +		io_req = fnic_priv(sc)->io_req;
> 		if (io_req)
> 			io_req->abts_done = NULL;
> 		spin_unlock_irqrestore(io_lock, flags);
> @@ -1848,10 +1843,10 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
> 		goto fnic_abort_cmd_end;
> 	}
> 	if (task_req == FCPIO_ITMF_ABT_TASK) {
> -		CMD_FLAGS(sc) |= FNIC_IO_ABTS_ISSUED;
> +		fnic_priv(sc)->flags |= FNIC_IO_ABTS_ISSUED;
> 		atomic64_inc(&fnic_stats->abts_stats.aborts);
> 	} else {
> -		CMD_FLAGS(sc) |= FNIC_IO_TERM_ISSUED;
> +		fnic_priv(sc)->flags |= FNIC_IO_TERM_ISSUED;
> 		atomic64_inc(&fnic_stats->term_stats.terminates);
> 	}
> 
> @@ -1869,32 +1864,32 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
> 	/* Check the abort status */
> 	spin_lock_irqsave(io_lock, flags);
> 
> -	io_req = (struct fnic_io_req *)CMD_SP(sc);
> +	io_req = fnic_priv(sc)->io_req;
> 	if (!io_req) {
> 		atomic64_inc(&fnic_stats->io_stats.ioreq_null);
> 		spin_unlock_irqrestore(io_lock, flags);
> -		CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_REQ_NULL;
> +		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_REQ_NULL;
> 		ret = FAILED;
> 		goto fnic_abort_cmd_end;
> 	}
> 	io_req->abts_done = NULL;
> 
> 	/* fw did not complete abort, timed out */
> -	if (CMD_ABTS_STATUS(sc) == FCPIO_INVALID_CODE) {
> +	if (fnic_priv(sc)->abts_status == FCPIO_INVALID_CODE) {
> 		spin_unlock_irqrestore(io_lock, flags);
> 		if (task_req == FCPIO_ITMF_ABT_TASK) {
> 			atomic64_inc(&abts_stats->abort_drv_timeouts);
> 		} else {
> 			atomic64_inc(&term_stats->terminate_drv_timeouts);
> 		}
> -		CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_TIMED_OUT;
> +		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_TIMED_OUT;
> 		ret = FAILED;
> 		goto fnic_abort_cmd_end;
> 	}
> 
> 	/* IO out of order */
> 
> -	if (!(CMD_FLAGS(sc) & (FNIC_IO_ABORTED | FNIC_IO_DONE))) {
> +	if (!(fnic_priv(sc)->flags & (FNIC_IO_ABORTED | FNIC_IO_DONE))) {
> 		spin_unlock_irqrestore(io_lock, flags);
> 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> 			"Issuing Host reset due to out of order IO\n");
> @@ -1903,7 +1898,7 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
> 		goto fnic_abort_cmd_end;
> 	}
> 
> -	CMD_STATE(sc) = FNIC_IOREQ_ABTS_COMPLETE;
> +	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_COMPLETE;
> 
> 	start_time = io_req->start_time;
> 	/*
> @@ -1911,9 +1906,9 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
> 	 * free the io_req if successful. If abort fails,
> 	 * Device reset will clean the I/O.
> 	 */
> -	if (CMD_ABTS_STATUS(sc) == FCPIO_SUCCESS)
> -		CMD_SP(sc) = NULL;
> -	else {
> +	if (fnic_priv(sc)->abts_status == FCPIO_SUCCESS) {
> +		fnic_priv(sc)->io_req = NULL;
> +	} else {
> 		ret = FAILED;
> 		spin_unlock_irqrestore(io_lock, flags);
> 		goto fnic_abort_cmd_end;
> @@ -1939,7 +1934,7 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
> 		  0, ((u64)sc->cmnd[0] << 32 |
> 		  (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
> 		  (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
> -		  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
> +		  fnic_flags_and_state(sc));
> 
> 	FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> 		      "Returning from abort cmd type %x %s\n", task_req,
> @@ -2030,7 +2025,7 @@ static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
> 
> 	io_lock = fnic_io_lock_tag(fnic, abt_tag);
> 	spin_lock_irqsave(io_lock, flags);
> -	io_req = (struct fnic_io_req *)CMD_SP(sc);
> +	io_req = fnic_priv(sc)->io_req;
> 	if (!io_req) {
> 		spin_unlock_irqrestore(io_lock, flags);
> 		return true;
> @@ -2042,14 +2037,14 @@ static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
> 	 */
> 	FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> 		      "Found IO in %s on lun\n",
> -		      fnic_ioreq_state_to_str(CMD_STATE(sc)));
> +		      fnic_ioreq_state_to_str(fnic_priv(sc)->state));
> 
> -	if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
> +	if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
> 		spin_unlock_irqrestore(io_lock, flags);
> 		return true;
> 	}
> -	if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
> -	    (!(CMD_FLAGS(sc) & FNIC_DEV_RST_ISSUED))) {
> +	if ((fnic_priv(sc)->flags & FNIC_DEVICE_RESET) &&
> +	    (!(fnic_priv(sc)->flags & FNIC_DEV_RST_ISSUED))) {
> 		FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
> 			      "%s dev rst not pending sc 0x%p\n", __func__,
> 			      sc);
> @@ -2060,8 +2055,8 @@ static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
> 	if (io_req->abts_done)
> 		shost_printk(KERN_ERR, fnic->lport->host,
> 			     "%s: io_req->abts_done is set state is %s\n",
> -			     __func__, fnic_ioreq_state_to_str(CMD_STATE(sc)));
> -	old_ioreq_state = CMD_STATE(sc);
> +			     __func__, fnic_ioreq_state_to_str(fnic_priv(sc)->state));
> +	old_ioreq_state = fnic_priv(sc)->state;
> 	/*
> 	 * Any pending IO issued prior to reset is expected to be
> 	 * in abts pending state, if not we need to set
> @@ -2069,17 +2064,17 @@ static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
> 	 * When IO is completed, the IO will be handed over and
> 	 * handled in this function.
> 	 */
> -	CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
> +	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_PENDING;
> 
> 	BUG_ON(io_req->abts_done);
> 
> -	if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
> +	if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET) {
> 		abt_tag |= FNIC_TAG_DEV_RST;
> 		FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
> 			      "%s: dev rst sc 0x%p\n", __func__, sc);
> 	}
> 
> -	CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
> +	fnic_priv(sc)->abts_status = FCPIO_INVALID_CODE;
> 	io_req->abts_done = &tm_done;
> 	spin_unlock_irqrestore(io_lock, flags);
> 
> @@ -2090,48 +2085,48 @@ static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
> 				    FCPIO_ITMF_ABT_TASK_TERM,
> 				    fc_lun.scsi_lun, io_req)) {
> 		spin_lock_irqsave(io_lock, flags);
> -		io_req = (struct fnic_io_req *)CMD_SP(sc);
> +		io_req = fnic_priv(sc)->io_req;
> 		if (io_req)
> 			io_req->abts_done = NULL;
> -		if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
> -			CMD_STATE(sc) = old_ioreq_state;
> +		if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING)
> +			fnic_priv(sc)->state = old_ioreq_state;
> 		spin_unlock_irqrestore(io_lock, flags);
> 		iter_data->ret = FAILED;
> 		return false;
> 	} else {
> 		spin_lock_irqsave(io_lock, flags);
> -		if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET)
> -			CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
> +		if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET)
> +			fnic_priv(sc)->flags |= FNIC_DEV_RST_TERM_ISSUED;
> 		spin_unlock_irqrestore(io_lock, flags);
> 	}
> -	CMD_FLAGS(sc) |= FNIC_IO_INTERNAL_TERM_ISSUED;
> +	fnic_priv(sc)->flags |= FNIC_IO_INTERNAL_TERM_ISSUED;
> 
> 	wait_for_completion_timeout(&tm_done, msecs_to_jiffies
> 				    (fnic->config.ed_tov));
> 
> 	/* Recheck cmd state to check if it is now aborted */
> 	spin_lock_irqsave(io_lock, flags);
> -	io_req = (struct fnic_io_req *)CMD_SP(sc);
> +	io_req = fnic_priv(sc)->io_req;
> 	if (!io_req) {
> 		spin_unlock_irqrestore(io_lock, flags);
> -		CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_REQ_NULL;
> +		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_REQ_NULL;
> 		return true;
> 	}
> 
> 	io_req->abts_done = NULL;
> 
> 	/* if abort is still pending with fw, fail */
> -	if (CMD_ABTS_STATUS(sc) == FCPIO_INVALID_CODE) {
> +	if (fnic_priv(sc)->abts_status == FCPIO_INVALID_CODE) {
> 		spin_unlock_irqrestore(io_lock, flags);
> -		CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_DONE;
> +		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_DONE;
> 		iter_data->ret = FAILED;
> 		return false;
> 	}
> -	CMD_STATE(sc) = FNIC_IOREQ_ABTS_COMPLETE;
> +	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_COMPLETE;
> 
> 	/* original sc used for lr is handled by dev reset code */
> 	if (sc != iter_data->lr_sc)
> -		CMD_SP(sc) = NULL;
> +		fnic_priv(sc)->io_req = NULL;
> 	spin_unlock_irqrestore(io_lock, flags);
> 
> 	/* original sc used for lr is handled by dev reset code */
> @@ -2272,7 +2267,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 		goto fnic_device_reset_end;
> 	}
> 
> -	CMD_FLAGS(sc) = FNIC_DEVICE_RESET;
> +	fnic_priv(sc)->flags = FNIC_DEVICE_RESET;
> 	/* Allocate tag if not present */
> 
> 	if (unlikely(tag < 0)) {
> @@ -2288,7 +2283,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 	}
> 	io_lock = fnic_io_lock_hash(fnic, sc);
> 	spin_lock_irqsave(io_lock, flags);
> -	io_req = (struct fnic_io_req *)CMD_SP(sc);
> +	io_req = fnic_priv(sc)->io_req;
> 
> 	/*
> 	 * If there is a io_req attached to this command, then use it,
> @@ -2302,11 +2297,11 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 		}
> 		memset(io_req, 0, sizeof(*io_req));
> 		io_req->port_id = rport->port_id;
> -		CMD_SP(sc) = (char *)io_req;
> +		fnic_priv(sc)->io_req = io_req;
> 	}
> 	io_req->dr_done = &tm_done;
> -	CMD_STATE(sc) = FNIC_IOREQ_CMD_PENDING;
> -	CMD_LR_STATUS(sc) = FCPIO_INVALID_CODE;
> +	fnic_priv(sc)->state = FNIC_IOREQ_CMD_PENDING;
> +	fnic_priv(sc)->lr_status = FCPIO_INVALID_CODE;
> 	spin_unlock_irqrestore(io_lock, flags);
> 
> 	FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host, "TAG %x\n", tag);
> @@ -2317,13 +2312,13 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 	 */
> 	if (fnic_queue_dr_io_req(fnic, sc, io_req)) {
> 		spin_lock_irqsave(io_lock, flags);
> -		io_req = (struct fnic_io_req *)CMD_SP(sc);
> +		io_req = fnic_priv(sc)->io_req;
> 		if (io_req)
> 			io_req->dr_done = NULL;
> 		goto fnic_device_reset_clean;
> 	}
> 	spin_lock_irqsave(io_lock, flags);
> -	CMD_FLAGS(sc) |= FNIC_DEV_RST_ISSUED;
> +	fnic_priv(sc)->flags |= FNIC_DEV_RST_ISSUED;
> 	spin_unlock_irqrestore(io_lock, flags);
> 
> 	/*
> @@ -2334,7 +2329,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 				    msecs_to_jiffies(FNIC_LUN_RESET_TIMEOUT));
> 
> 	spin_lock_irqsave(io_lock, flags);
> -	io_req = (struct fnic_io_req *)CMD_SP(sc);
> +	io_req = fnic_priv(sc)->io_req;
> 	if (!io_req) {
> 		spin_unlock_irqrestore(io_lock, flags);
> 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> @@ -2343,7 +2338,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 	}
> 	io_req->dr_done = NULL;
> 
> -	status = CMD_LR_STATUS(sc);
> +	status = fnic_priv(sc)->lr_status;
> 
> 	/*
> 	 * If lun reset not completed, bail out with failed. io_req
> @@ -2353,7 +2348,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 		atomic64_inc(&reset_stats->device_reset_timeouts);
> 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> 			      "Device reset timed out\n");
> -		CMD_FLAGS(sc) |= FNIC_DEV_RST_TIMED_OUT;
> +		fnic_priv(sc)->flags |= FNIC_DEV_RST_TIMED_OUT;
> 		spin_unlock_irqrestore(io_lock, flags);
> 		int_to_scsilun(sc->device->lun, &fc_lun);
> 		/*
> @@ -2362,7 +2357,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 		 */
> 		while (1) {
> 			spin_lock_irqsave(io_lock, flags);
> -			if (CMD_FLAGS(sc) & FNIC_DEV_RST_TERM_ISSUED) {
> +			if (fnic_priv(sc)->flags & FNIC_DEV_RST_TERM_ISSUED) {
> 				spin_unlock_irqrestore(io_lock, flags);
> 				break;
> 			}
> @@ -2375,8 +2370,8 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 				msecs_to_jiffies(FNIC_ABT_TERM_DELAY_TIMEOUT));
> 			} else {
> 				spin_lock_irqsave(io_lock, flags);
> -				CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
> -				CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
> +				fnic_priv(sc)->flags |= FNIC_DEV_RST_TERM_ISSUED;
> +				fnic_priv(sc)->state = FNIC_IOREQ_ABTS_PENDING;
> 				io_req->abts_done = &tm_done;
> 				spin_unlock_irqrestore(io_lock, flags);
> 				FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> @@ -2387,13 +2382,13 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 		}
> 		while (1) {
> 			spin_lock_irqsave(io_lock, flags);
> -			if (!(CMD_FLAGS(sc) & FNIC_DEV_RST_DONE)) {
> +			if (!(fnic_priv(sc)->flags & FNIC_DEV_RST_DONE)) {
> 				spin_unlock_irqrestore(io_lock, flags);
> 				wait_for_completion_timeout(&tm_done,
> 				msecs_to_jiffies(FNIC_LUN_RESET_TIMEOUT));
> 				break;
> 			} else {
> -				io_req = (struct fnic_io_req *)CMD_SP(sc);
> +				io_req = fnic_priv(sc)->io_req;
> 				io_req->abts_done = NULL;
> 				goto fnic_device_reset_clean;
> 			}
> @@ -2408,7 +2403,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 		FNIC_SCSI_DBG(KERN_DEBUG,
> 			      fnic->lport->host,
> 			      "Device reset completed - failed\n");
> -		io_req = (struct fnic_io_req *)CMD_SP(sc);
> +		io_req = fnic_priv(sc)->io_req;
> 		goto fnic_device_reset_clean;
> 	}
> 
> @@ -2421,7 +2416,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 	 */
> 	if (fnic_clean_pending_aborts(fnic, sc, new_sc)) {
> 		spin_lock_irqsave(io_lock, flags);
> -		io_req = (struct fnic_io_req *)CMD_SP(sc);
> +		io_req = fnic_priv(sc)->io_req;
> 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
> 			      "Device reset failed"
> 			      " since could not abort all IOs\n");
> @@ -2430,14 +2425,14 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 
> 	/* Clean lun reset command */
> 	spin_lock_irqsave(io_lock, flags);
> -	io_req = (struct fnic_io_req *)CMD_SP(sc);
> +	io_req = fnic_priv(sc)->io_req;
> 	if (io_req)
> 		/* Completed, and successful */
> 		ret = SUCCESS;
> 
> fnic_device_reset_clean:
> 	if (io_req)
> -		CMD_SP(sc) = NULL;
> +		fnic_priv(sc)->io_req = NULL;
> 
> 	spin_unlock_irqrestore(io_lock, flags);
> 
> @@ -2453,7 +2448,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
> 		  0, ((u64)sc->cmnd[0] << 32 |
> 		  (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
> 		  (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
> -		  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
> +		  fnic_flags_and_state(sc));
> 
> 	/* free tag if it is allocated */
> 	if (unlikely(tag_gen_flag))
> @@ -2698,7 +2693,7 @@ static bool fnic_abts_pending_iter(struct scsi_cmnd *sc, void *data,
> 	io_lock = fnic_io_lock_hash(fnic, sc);
> 	spin_lock_irqsave(io_lock, flags);
> 
> -	io_req = (struct fnic_io_req *)CMD_SP(sc);
> +	io_req = fnic_priv(sc)->io_req;
> 	if (!io_req) {
> 		spin_unlock_irqrestore(io_lock, flags);
> 		return true;
> @@ -2710,8 +2705,8 @@ static bool fnic_abts_pending_iter(struct scsi_cmnd *sc, void *data,
> 	 */
> 	FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
> 		      "Found IO in %s on lun\n",
> -		      fnic_ioreq_state_to_str(CMD_STATE(sc)));
> -	cmd_state = CMD_STATE(sc);
> +		      fnic_ioreq_state_to_str(fnic_priv(sc)->state));
> +	cmd_state = fnic_priv(sc)->state;
> 	spin_unlock_irqrestore(io_lock, flags);
> 	if (cmd_state == FNIC_IOREQ_ABTS_PENDING)
> 		iter_data->ret = 1;

Reviewed-by: Himanshu Madhani <himanshu.madhani@oracle.com>

--
Himanshu Madhani	 Oracle Linux Engineering
Bart Van Assche Feb. 9, 2022, 6:22 p.m. UTC | #3 
On 2/8/22 23:56, Hannes Reinecke wrote:
> On 2/8/22 18:24, Bart Van Assche wrote:
>> Set .cmd_size in the SCSI host template instead of using the SCSI pointer
>> from struct scsi_cmnd. This patch prepares for removal of the SCSI 
>> pointer
>> from struct scsi_cmnd.
>>
>> Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
>> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
>> ---
>>   drivers/scsi/fnic/fnic.h      |  27 +++-
>>   drivers/scsi/fnic/fnic_main.c |   1 +
>>   drivers/scsi/fnic/fnic_scsi.c | 289 +++++++++++++++++-----------------
>>   3 files changed, 163 insertions(+), 154 deletions(-)
>>
>> diff --git a/drivers/scsi/fnic/fnic.h b/drivers/scsi/fnic/fnic.h
>> index b95d0063dedb..aa07189fb5fb 100644
>> --- a/drivers/scsi/fnic/fnic.h
>> +++ b/drivers/scsi/fnic/fnic.h
>> @@ -89,15 +89,28 @@
>>   #define FNIC_DEV_RST_ABTS_PENDING       BIT(21)
>>   /*
>> - * Usage of the scsi_cmnd scratchpad.
>> + * fnic private data per SCSI command.
>>    * These fields are locked by the hashed io_req_lock.
>>    */
>> -#define CMD_SP(Cmnd)        ((Cmnd)->SCp.ptr)
>> -#define CMD_STATE(Cmnd)        ((Cmnd)->SCp.phase)
>> -#define CMD_ABTS_STATUS(Cmnd)    ((Cmnd)->SCp.Message)
>> -#define CMD_LR_STATUS(Cmnd)    ((Cmnd)->SCp.have_data_in)
>> -#define CMD_TAG(Cmnd)           ((Cmnd)->SCp.sent_command)
>> -#define CMD_FLAGS(Cmnd)         ((Cmnd)->SCp.Status)
>> +struct fnic_cmd_priv {
>> +    struct fnic_io_req *io_req;
>> +    enum fnic_ioreq_state state;
>> +    u32 flags;
>> +    u16 abts_status;
>> +    u16 lr_status;
>> +};
>> +
>> +static inline struct fnic_cmd_priv *fnic_priv(struct scsi_cmnd *cmd)
>> +{
>> +    return scsi_cmd_priv(cmd);
>> +}
>> +
>> +static inline u64 fnic_flags_and_state(struct scsi_cmnd *cmd)
>> +{
>> +    struct fnic_cmd_priv *fcmd = fnic_priv(cmd);
>> +
>> +    return ((u64)fcmd->flags << 32) | fcmd->state;
>> +}
>>   #define FCPIO_INVALID_CODE 0x100 /* hdr_status value unused by 
>> firmware */
>> diff --git a/drivers/scsi/fnic/fnic_main.c 
>> b/drivers/scsi/fnic/fnic_main.c
>> index 44dbaa662d94..9161bd2fd421 100644
>> --- a/drivers/scsi/fnic/fnic_main.c
>> +++ b/drivers/scsi/fnic/fnic_main.c
>> @@ -124,6 +124,7 @@ static struct scsi_host_template 
>> fnic_host_template = {
>>       .max_sectors = 0xffff,
>>       .shost_groups = fnic_host_groups,
>>       .track_queue_depth = 1,
>> +    .cmd_size = sizeof(struct fnic_cmd_priv),
>>   };
>>   static void
>> diff --git a/drivers/scsi/fnic/fnic_scsi.c 
>> b/drivers/scsi/fnic/fnic_scsi.c
>> index 549754245f7a..3c00e5b88350 100644
>> --- a/drivers/scsi/fnic/fnic_scsi.c
>> +++ b/drivers/scsi/fnic/fnic_scsi.c
>> @@ -497,8 +497,8 @@ static int fnic_queuecommand_lck(struct scsi_cmnd 
>> *sc)
>>        * caller disabling them.
>>        */
>>       spin_unlock(lp->host->host_lock);
>> -    CMD_STATE(sc) = FNIC_IOREQ_NOT_INITED;
>> -    CMD_FLAGS(sc) = FNIC_NO_FLAGS;
>> +    fnic_priv(sc)->state = FNIC_IOREQ_NOT_INITED;
>> +    fnic_priv(sc)->flags = FNIC_NO_FLAGS;
> Why not keep the macros?
> Would be less churn with the driver, no?

Keeping the macros would indeed make this patch smaller. My opinion is 
that the CMD_STATE() and CMD_FLAGS() macro definitions are too short to 
keep them and that expanding these macros makes the driver code easier 
to read.

Thanks,

Bart.
Hannes Reinecke Feb. 10, 2022, 7:30 a.m. UTC | #4 
On 2/9/22 19:22, Bart Van Assche wrote:
> On 2/8/22 23:56, Hannes Reinecke wrote:
>> On 2/8/22 18:24, Bart Van Assche wrote:
>>> Set .cmd_size in the SCSI host template instead of using the SCSI 
>>> pointer
>>> from struct scsi_cmnd. This patch prepares for removal of the SCSI 
>>> pointer
>>> from struct scsi_cmnd.
>>>
>>> Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
>>> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
>>> ---
>>>   drivers/scsi/fnic/fnic.h      |  27 +++-
>>>   drivers/scsi/fnic/fnic_main.c |   1 +
>>>   drivers/scsi/fnic/fnic_scsi.c | 289 +++++++++++++++++-----------------
>>>   3 files changed, 163 insertions(+), 154 deletions(-)
>>>
>>> diff --git a/drivers/scsi/fnic/fnic.h b/drivers/scsi/fnic/fnic.h
>>> index b95d0063dedb..aa07189fb5fb 100644
>>> --- a/drivers/scsi/fnic/fnic.h
>>> +++ b/drivers/scsi/fnic/fnic.h
>>> @@ -89,15 +89,28 @@
>>>   #define FNIC_DEV_RST_ABTS_PENDING       BIT(21)
>>>   /*
>>> - * Usage of the scsi_cmnd scratchpad.
>>> + * fnic private data per SCSI command.
>>>    * These fields are locked by the hashed io_req_lock.
>>>    */
>>> -#define CMD_SP(Cmnd)        ((Cmnd)->SCp.ptr)
>>> -#define CMD_STATE(Cmnd)        ((Cmnd)->SCp.phase)
>>> -#define CMD_ABTS_STATUS(Cmnd)    ((Cmnd)->SCp.Message)
>>> -#define CMD_LR_STATUS(Cmnd)    ((Cmnd)->SCp.have_data_in)
>>> -#define CMD_TAG(Cmnd)           ((Cmnd)->SCp.sent_command)
>>> -#define CMD_FLAGS(Cmnd)         ((Cmnd)->SCp.Status)
>>> +struct fnic_cmd_priv {
>>> +    struct fnic_io_req *io_req;
>>> +    enum fnic_ioreq_state state;
>>> +    u32 flags;
>>> +    u16 abts_status;
>>> +    u16 lr_status;
>>> +};
>>> +
>>> +static inline struct fnic_cmd_priv *fnic_priv(struct scsi_cmnd *cmd)
>>> +{
>>> +    return scsi_cmd_priv(cmd);
>>> +}
>>> +
>>> +static inline u64 fnic_flags_and_state(struct scsi_cmnd *cmd)
>>> +{
>>> +    struct fnic_cmd_priv *fcmd = fnic_priv(cmd);
>>> +
>>> +    return ((u64)fcmd->flags << 32) | fcmd->state;
>>> +}
>>>   #define FCPIO_INVALID_CODE 0x100 /* hdr_status value unused by 
>>> firmware */
>>> diff --git a/drivers/scsi/fnic/fnic_main.c 
>>> b/drivers/scsi/fnic/fnic_main.c
>>> index 44dbaa662d94..9161bd2fd421 100644
>>> --- a/drivers/scsi/fnic/fnic_main.c
>>> +++ b/drivers/scsi/fnic/fnic_main.c
>>> @@ -124,6 +124,7 @@ static struct scsi_host_template 
>>> fnic_host_template = {
>>>       .max_sectors = 0xffff,
>>>       .shost_groups = fnic_host_groups,
>>>       .track_queue_depth = 1,
>>> +    .cmd_size = sizeof(struct fnic_cmd_priv),
>>>   };
>>>   static void
>>> diff --git a/drivers/scsi/fnic/fnic_scsi.c 
>>> b/drivers/scsi/fnic/fnic_scsi.c
>>> index 549754245f7a..3c00e5b88350 100644
>>> --- a/drivers/scsi/fnic/fnic_scsi.c
>>> +++ b/drivers/scsi/fnic/fnic_scsi.c
>>> @@ -497,8 +497,8 @@ static int fnic_queuecommand_lck(struct scsi_cmnd 
>>> *sc)
>>>        * caller disabling them.
>>>        */
>>>       spin_unlock(lp->host->host_lock);
>>> -    CMD_STATE(sc) = FNIC_IOREQ_NOT_INITED;
>>> -    CMD_FLAGS(sc) = FNIC_NO_FLAGS;
>>> +    fnic_priv(sc)->state = FNIC_IOREQ_NOT_INITED;
>>> +    fnic_priv(sc)->flags = FNIC_NO_FLAGS;
>> Why not keep the macros?
>> Would be less churn with the driver, no?
> 
> Keeping the macros would indeed make this patch smaller. My opinion is 
> that the CMD_STATE() and CMD_FLAGS() macro definitions are too short to 
> keep them and that expanding these macros makes the driver code easier 
> to read.
> 
Fair enough.

Reviewed-by: Hannes Reinecke <hare@suse.de>

Cheers,

Hannes
diff mbox series

Patch

diff --git a/drivers/scsi/fnic/fnic.h b/drivers/scsi/fnic/fnic.h
index b95d0063dedb..aa07189fb5fb 100644
--- a/drivers/scsi/fnic/fnic.h
+++ b/drivers/scsi/fnic/fnic.h
@@ -89,15 +89,28 @@ 
 #define FNIC_DEV_RST_ABTS_PENDING       BIT(21)
 
 /*
- * Usage of the scsi_cmnd scratchpad.
+ * fnic private data per SCSI command.
  * These fields are locked by the hashed io_req_lock.
  */
-#define CMD_SP(Cmnd)		((Cmnd)->SCp.ptr)
-#define CMD_STATE(Cmnd)		((Cmnd)->SCp.phase)
-#define CMD_ABTS_STATUS(Cmnd)	((Cmnd)->SCp.Message)
-#define CMD_LR_STATUS(Cmnd)	((Cmnd)->SCp.have_data_in)
-#define CMD_TAG(Cmnd)           ((Cmnd)->SCp.sent_command)
-#define CMD_FLAGS(Cmnd)         ((Cmnd)->SCp.Status)
+struct fnic_cmd_priv {
+	struct fnic_io_req *io_req;
+	enum fnic_ioreq_state state;
+	u32 flags;
+	u16 abts_status;
+	u16 lr_status;
+};
+
+static inline struct fnic_cmd_priv *fnic_priv(struct scsi_cmnd *cmd)
+{
+	return scsi_cmd_priv(cmd);
+}
+
+static inline u64 fnic_flags_and_state(struct scsi_cmnd *cmd)
+{
+	struct fnic_cmd_priv *fcmd = fnic_priv(cmd);
+
+	return ((u64)fcmd->flags << 32) | fcmd->state;
+}
 
 #define FCPIO_INVALID_CODE 0x100 /* hdr_status value unused by firmware */
 
diff --git a/drivers/scsi/fnic/fnic_main.c b/drivers/scsi/fnic/fnic_main.c
index 44dbaa662d94..9161bd2fd421 100644
--- a/drivers/scsi/fnic/fnic_main.c
+++ b/drivers/scsi/fnic/fnic_main.c
@@ -124,6 +124,7 @@  static struct scsi_host_template fnic_host_template = {
 	.max_sectors = 0xffff,
 	.shost_groups = fnic_host_groups,
 	.track_queue_depth = 1,
+	.cmd_size = sizeof(struct fnic_cmd_priv),
 };
 
 static void
diff --git a/drivers/scsi/fnic/fnic_scsi.c b/drivers/scsi/fnic/fnic_scsi.c
index 549754245f7a..3c00e5b88350 100644
--- a/drivers/scsi/fnic/fnic_scsi.c
+++ b/drivers/scsi/fnic/fnic_scsi.c
@@ -497,8 +497,8 @@  static int fnic_queuecommand_lck(struct scsi_cmnd *sc)
 	 * caller disabling them.
 	 */
 	spin_unlock(lp->host->host_lock);
-	CMD_STATE(sc) = FNIC_IOREQ_NOT_INITED;
-	CMD_FLAGS(sc) = FNIC_NO_FLAGS;
+	fnic_priv(sc)->state = FNIC_IOREQ_NOT_INITED;
+	fnic_priv(sc)->flags = FNIC_NO_FLAGS;
 
 	/* Get a new io_req for this SCSI IO */
 	io_req = mempool_alloc(fnic->io_req_pool, GFP_ATOMIC);
@@ -513,7 +513,7 @@  static int fnic_queuecommand_lck(struct scsi_cmnd *sc)
 	sg_count = scsi_dma_map(sc);
 	if (sg_count < 0) {
 		FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
-			  tag, sc, 0, sc->cmnd[0], sg_count, CMD_STATE(sc));
+			  tag, sc, 0, sc->cmnd[0], sg_count, fnic_priv(sc)->state);
 		mempool_free(io_req, fnic->io_req_pool);
 		goto out;
 	}
@@ -558,9 +558,9 @@  static int fnic_queuecommand_lck(struct scsi_cmnd *sc)
 	io_lock_acquired = 1;
 	io_req->port_id = rport->port_id;
 	io_req->start_time = jiffies;
-	CMD_STATE(sc) = FNIC_IOREQ_CMD_PENDING;
-	CMD_SP(sc) = (char *)io_req;
-	CMD_FLAGS(sc) |= FNIC_IO_INITIALIZED;
+	fnic_priv(sc)->state = FNIC_IOREQ_CMD_PENDING;
+	fnic_priv(sc)->io_req = io_req;
+	fnic_priv(sc)->flags |= FNIC_IO_INITIALIZED;
 
 	/* create copy wq desc and enqueue it */
 	wq = &fnic->wq_copy[0];
@@ -571,11 +571,10 @@  static int fnic_queuecommand_lck(struct scsi_cmnd *sc)
 		 * refetch the pointer under the lock.
 		 */
 		FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
-			  tag, sc, 0, 0, 0,
-			  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
-		io_req = (struct fnic_io_req *)CMD_SP(sc);
-		CMD_SP(sc) = NULL;
-		CMD_STATE(sc) = FNIC_IOREQ_CMD_COMPLETE;
+			  tag, sc, 0, 0, 0, fnic_flags_and_state(sc));
+		io_req = fnic_priv(sc)->io_req;
+		fnic_priv(sc)->io_req = NULL;
+		fnic_priv(sc)->state = FNIC_IOREQ_CMD_COMPLETE;
 		spin_unlock_irqrestore(io_lock, flags);
 		if (io_req) {
 			fnic_release_ioreq_buf(fnic, io_req, sc);
@@ -594,7 +593,7 @@  static int fnic_queuecommand_lck(struct scsi_cmnd *sc)
 			     atomic64_read(&fnic_stats->io_stats.active_ios));
 
 		/* REVISIT: Use per IO lock in the final code */
-		CMD_FLAGS(sc) |= FNIC_IO_ISSUED;
+		fnic_priv(sc)->flags |= FNIC_IO_ISSUED;
 	}
 out:
 	cmd_trace = ((u64)sc->cmnd[0] << 56 | (u64)sc->cmnd[7] << 40 |
@@ -603,8 +602,8 @@  static int fnic_queuecommand_lck(struct scsi_cmnd *sc)
 			sc->cmnd[5]);
 
 	FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
-		  tag, sc, io_req, sg_count, cmd_trace,
-		  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
+		   tag, sc, io_req, sg_count, cmd_trace,
+		   fnic_flags_and_state(sc));
 
 	/* if only we issued IO, will we have the io lock */
 	if (io_lock_acquired)
@@ -867,11 +866,11 @@  static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
 
 	io_lock = fnic_io_lock_hash(fnic, sc);
 	spin_lock_irqsave(io_lock, flags);
-	io_req = (struct fnic_io_req *)CMD_SP(sc);
+	io_req = fnic_priv(sc)->io_req;
 	WARN_ON_ONCE(!io_req);
 	if (!io_req) {
 		atomic64_inc(&fnic_stats->io_stats.ioreq_null);
-		CMD_FLAGS(sc) |= FNIC_IO_REQ_NULL;
+		fnic_priv(sc)->flags |= FNIC_IO_REQ_NULL;
 		spin_unlock_irqrestore(io_lock, flags);
 		shost_printk(KERN_ERR, fnic->lport->host,
 			  "icmnd_cmpl io_req is null - "
@@ -888,17 +887,17 @@  static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
 	 *  if SCSI-ML has already issued abort on this command,
 	 *  set completion of the IO. The abts path will clean it up
 	 */
-	if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
+	if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
 
 		/*
 		 * set the FNIC_IO_DONE so that this doesn't get
 		 * flagged as 'out of order' if it was not aborted
 		 */
-		CMD_FLAGS(sc) |= FNIC_IO_DONE;
-		CMD_FLAGS(sc) |= FNIC_IO_ABTS_PENDING;
+		fnic_priv(sc)->flags |= FNIC_IO_DONE;
+		fnic_priv(sc)->flags |= FNIC_IO_ABTS_PENDING;
 		spin_unlock_irqrestore(io_lock, flags);
 		if(FCPIO_ABORTED == hdr_status)
-			CMD_FLAGS(sc) |= FNIC_IO_ABORTED;
+			fnic_priv(sc)->flags |= FNIC_IO_ABORTED;
 
 		FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
 			"icmnd_cmpl abts pending "
@@ -912,7 +911,7 @@  static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
 	}
 
 	/* Mark the IO as complete */
-	CMD_STATE(sc) = FNIC_IOREQ_CMD_COMPLETE;
+	fnic_priv(sc)->state = FNIC_IOREQ_CMD_COMPLETE;
 
 	icmnd_cmpl = &desc->u.icmnd_cmpl;
 
@@ -983,8 +982,8 @@  static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
 	}
 
 	/* Break link with the SCSI command */
-	CMD_SP(sc) = NULL;
-	CMD_FLAGS(sc) |= FNIC_IO_DONE;
+	fnic_priv(sc)->io_req = NULL;
+	fnic_priv(sc)->flags |= FNIC_IO_DONE;
 
 	spin_unlock_irqrestore(io_lock, flags);
 
@@ -1009,8 +1008,7 @@  static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
 		  ((u64)icmnd_cmpl->_resvd0[1] << 56 |
 		  (u64)icmnd_cmpl->_resvd0[0] << 48 |
 		  jiffies_to_msecs(jiffies - start_time)),
-		  desc, cmd_trace,
-		  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
+		  desc, cmd_trace, fnic_flags_and_state(sc));
 
 	if (sc->sc_data_direction == DMA_FROM_DEVICE) {
 		fnic->lport->host_stats.fcp_input_requests++;
@@ -1095,12 +1093,12 @@  static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
 	}
 	io_lock = fnic_io_lock_hash(fnic, sc);
 	spin_lock_irqsave(io_lock, flags);
-	io_req = (struct fnic_io_req *)CMD_SP(sc);
+	io_req = fnic_priv(sc)->io_req;
 	WARN_ON_ONCE(!io_req);
 	if (!io_req) {
 		atomic64_inc(&fnic_stats->io_stats.ioreq_null);
 		spin_unlock_irqrestore(io_lock, flags);
-		CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_REQ_NULL;
+		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_REQ_NULL;
 		shost_printk(KERN_ERR, fnic->lport->host,
 			  "itmf_cmpl io_req is null - "
 			  "hdr status = %s tag = 0x%x sc 0x%p\n",
@@ -1115,9 +1113,9 @@  static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 			      "dev reset abts cmpl recd. id %x status %s\n",
 			      id, fnic_fcpio_status_to_str(hdr_status));
-		CMD_STATE(sc) = FNIC_IOREQ_ABTS_COMPLETE;
-		CMD_ABTS_STATUS(sc) = hdr_status;
-		CMD_FLAGS(sc) |= FNIC_DEV_RST_DONE;
+		fnic_priv(sc)->state = FNIC_IOREQ_ABTS_COMPLETE;
+		fnic_priv(sc)->abts_status = hdr_status;
+		fnic_priv(sc)->flags |= FNIC_DEV_RST_DONE;
 		if (io_req->abts_done)
 			complete(io_req->abts_done);
 		spin_unlock_irqrestore(io_lock, flags);
@@ -1127,7 +1125,7 @@  static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
 		case FCPIO_SUCCESS:
 			break;
 		case FCPIO_TIMEOUT:
-			if (CMD_FLAGS(sc) & FNIC_IO_ABTS_ISSUED)
+			if (fnic_priv(sc)->flags & FNIC_IO_ABTS_ISSUED)
 				atomic64_inc(&abts_stats->abort_fw_timeouts);
 			else
 				atomic64_inc(
@@ -1139,34 +1137,34 @@  static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
 				(int)(id & FNIC_TAG_MASK));
 			break;
 		case FCPIO_IO_NOT_FOUND:
-			if (CMD_FLAGS(sc) & FNIC_IO_ABTS_ISSUED)
+			if (fnic_priv(sc)->flags & FNIC_IO_ABTS_ISSUED)
 				atomic64_inc(&abts_stats->abort_io_not_found);
 			else
 				atomic64_inc(
 					&term_stats->terminate_io_not_found);
 			break;
 		default:
-			if (CMD_FLAGS(sc) & FNIC_IO_ABTS_ISSUED)
+			if (fnic_priv(sc)->flags & FNIC_IO_ABTS_ISSUED)
 				atomic64_inc(&abts_stats->abort_failures);
 			else
 				atomic64_inc(
 					&term_stats->terminate_failures);
 			break;
 		}
-		if (CMD_STATE(sc) != FNIC_IOREQ_ABTS_PENDING) {
+		if (fnic_priv(sc)->state != FNIC_IOREQ_ABTS_PENDING) {
 			/* This is a late completion. Ignore it */
 			spin_unlock_irqrestore(io_lock, flags);
 			return;
 		}
 
-		CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_DONE;
-		CMD_ABTS_STATUS(sc) = hdr_status;
+		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_DONE;
+		fnic_priv(sc)->abts_status = hdr_status;
 
 		/* If the status is IO not found consider it as success */
 		if (hdr_status == FCPIO_IO_NOT_FOUND)
-			CMD_ABTS_STATUS(sc) = FCPIO_SUCCESS;
+			fnic_priv(sc)->abts_status = FCPIO_SUCCESS;
 
-		if (!(CMD_FLAGS(sc) & (FNIC_IO_ABORTED | FNIC_IO_DONE)))
+		if (!(fnic_priv(sc)->flags & (FNIC_IO_ABORTED | FNIC_IO_DONE)))
 			atomic64_inc(&misc_stats->no_icmnd_itmf_cmpls);
 
 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
@@ -1185,7 +1183,7 @@  static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
 		} else {
 			FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 				      "abts cmpl, completing IO\n");
-			CMD_SP(sc) = NULL;
+			fnic_priv(sc)->io_req = NULL;
 			sc->result = (DID_ERROR << 16);
 
 			spin_unlock_irqrestore(io_lock, flags);
@@ -1202,8 +1200,7 @@  static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
 				    (u64)sc->cmnd[2] << 24 |
 				    (u64)sc->cmnd[3] << 16 |
 				    (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
-				   (((u64)CMD_FLAGS(sc) << 32) |
-				    CMD_STATE(sc)));
+				   fnic_flags_and_state(sc));
 			scsi_done(sc);
 			atomic64_dec(&fnic_stats->io_stats.active_ios);
 			if (atomic64_read(&fnic->io_cmpl_skip))
@@ -1213,15 +1210,14 @@  static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
 		}
 	} else if (id & FNIC_TAG_DEV_RST) {
 		/* Completion of device reset */
-		CMD_LR_STATUS(sc) = hdr_status;
-		if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
+		fnic_priv(sc)->lr_status = hdr_status;
+		if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
 			spin_unlock_irqrestore(io_lock, flags);
-			CMD_FLAGS(sc) |= FNIC_DEV_RST_ABTS_PENDING;
+			fnic_priv(sc)->flags |= FNIC_DEV_RST_ABTS_PENDING;
 			FNIC_TRACE(fnic_fcpio_itmf_cmpl_handler,
 				  sc->device->host->host_no, id, sc,
 				  jiffies_to_msecs(jiffies - start_time),
-				  desc, 0,
-				  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
+				  desc, 0, fnic_flags_and_state(sc));
 			FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 				"Terminate pending "
 				"dev reset cmpl recd. id %d status %s\n",
@@ -1229,14 +1225,13 @@  static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
 				fnic_fcpio_status_to_str(hdr_status));
 			return;
 		}
-		if (CMD_FLAGS(sc) & FNIC_DEV_RST_TIMED_OUT) {
+		if (fnic_priv(sc)->flags & FNIC_DEV_RST_TIMED_OUT) {
 			/* Need to wait for terminate completion */
 			spin_unlock_irqrestore(io_lock, flags);
 			FNIC_TRACE(fnic_fcpio_itmf_cmpl_handler,
 				  sc->device->host->host_no, id, sc,
 				  jiffies_to_msecs(jiffies - start_time),
-				  desc, 0,
-				  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
+				  desc, 0, fnic_flags_and_state(sc));
 			FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 				"dev reset cmpl recd after time out. "
 				"id %d status %s\n",
@@ -1244,8 +1239,8 @@  static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
 				fnic_fcpio_status_to_str(hdr_status));
 			return;
 		}
-		CMD_STATE(sc) = FNIC_IOREQ_CMD_COMPLETE;
-		CMD_FLAGS(sc) |= FNIC_DEV_RST_DONE;
+		fnic_priv(sc)->state = FNIC_IOREQ_CMD_COMPLETE;
+		fnic_priv(sc)->flags |= FNIC_DEV_RST_DONE;
 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 			      "dev reset cmpl recd. id %d status %s\n",
 			      (int)(id & FNIC_TAG_MASK),
@@ -1257,7 +1252,7 @@  static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
 	} else {
 		shost_printk(KERN_ERR, fnic->lport->host,
 			     "Unexpected itmf io state %s tag %x\n",
-			     fnic_ioreq_state_to_str(CMD_STATE(sc)), id);
+			     fnic_ioreq_state_to_str(fnic_priv(sc)->state), id);
 		spin_unlock_irqrestore(io_lock, flags);
 	}
 
@@ -1370,21 +1365,21 @@  static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data,
 	io_lock = fnic_io_lock_tag(fnic, tag);
 	spin_lock_irqsave(io_lock, flags);
 
-	io_req = (struct fnic_io_req *)CMD_SP(sc);
-	if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
-	    !(CMD_FLAGS(sc) & FNIC_DEV_RST_DONE)) {
+	io_req = fnic_priv(sc)->io_req;
+	if ((fnic_priv(sc)->flags & FNIC_DEVICE_RESET) &&
+	    !(fnic_priv(sc)->flags & FNIC_DEV_RST_DONE)) {
 		/*
 		 * We will be here only when FW completes reset
 		 * without sending completions for outstanding ios.
 		 */
-		CMD_FLAGS(sc) |= FNIC_DEV_RST_DONE;
+		fnic_priv(sc)->flags |= FNIC_DEV_RST_DONE;
 		if (io_req && io_req->dr_done)
 			complete(io_req->dr_done);
 		else if (io_req && io_req->abts_done)
 			complete(io_req->abts_done);
 		spin_unlock_irqrestore(io_lock, flags);
 		return true;
-	} else if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
+	} else if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET) {
 		spin_unlock_irqrestore(io_lock, flags);
 		return true;
 	}
@@ -1393,7 +1388,7 @@  static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data,
 		goto cleanup_scsi_cmd;
 	}
 
-	CMD_SP(sc) = NULL;
+	fnic_priv(sc)->io_req = NULL;
 
 	spin_unlock_irqrestore(io_lock, flags);
 
@@ -1417,7 +1412,7 @@  static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data,
 		atomic64_inc(&fnic_stats->io_stats.io_completions);
 
 	/* Complete the command to SCSI */
-	if (!(CMD_FLAGS(sc) & FNIC_IO_ISSUED))
+	if (!(fnic_priv(sc)->flags & FNIC_IO_ISSUED))
 		shost_printk(KERN_ERR, fnic->lport->host,
 			     "Calling done for IO not issued to fw: tag:0x%x sc:0x%p\n",
 			     tag, sc);
@@ -1429,7 +1424,7 @@  static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data,
 		       (u64)sc->cmnd[2] << 24 |
 		       (u64)sc->cmnd[3] << 16 |
 		       (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
-		   (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
+		   fnic_flags_and_state(sc));
 
 	scsi_done(sc);
 
@@ -1468,7 +1463,7 @@  void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
 	spin_lock_irqsave(io_lock, flags);
 
 	/* Get the IO context which this desc refers to */
-	io_req = (struct fnic_io_req *)CMD_SP(sc);
+	io_req = fnic_priv(sc)->io_req;
 
 	/* fnic interrupts are turned off by now */
 
@@ -1477,7 +1472,7 @@  void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
 		goto wq_copy_cleanup_scsi_cmd;
 	}
 
-	CMD_SP(sc) = NULL;
+	fnic_priv(sc)->io_req = NULL;
 
 	spin_unlock_irqrestore(io_lock, flags);
 
@@ -1496,7 +1491,7 @@  void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
 		   0, ((u64)sc->cmnd[0] << 32 |
 		       (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
 		       (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
-		   (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
+		   fnic_flags_and_state(sc));
 
 	scsi_done(sc);
 }
@@ -1571,15 +1566,15 @@  static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data,
 	io_lock = fnic_io_lock_tag(fnic, abt_tag);
 	spin_lock_irqsave(io_lock, flags);
 
-	io_req = (struct fnic_io_req *)CMD_SP(sc);
+	io_req = fnic_priv(sc)->io_req;
 
 	if (!io_req || io_req->port_id != iter_data->port_id) {
 		spin_unlock_irqrestore(io_lock, flags);
 		return true;
 	}
 
-	if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
-	    (!(CMD_FLAGS(sc) & FNIC_DEV_RST_ISSUED))) {
+	if ((fnic_priv(sc)->flags & FNIC_DEVICE_RESET) &&
+	    !(fnic_priv(sc)->flags & FNIC_DEV_RST_ISSUED)) {
 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 			"fnic_rport_exch_reset dev rst not pending sc 0x%p\n",
 			sc);
@@ -1591,7 +1586,7 @@  static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data,
 	 * Found IO that is still pending with firmware and
 	 * belongs to rport that went away
 	 */
-	if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
+	if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
 		spin_unlock_irqrestore(io_lock, flags);
 		return true;
 	}
@@ -1599,20 +1594,20 @@  static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data,
 		shost_printk(KERN_ERR, fnic->lport->host,
 			"fnic_rport_exch_reset: io_req->abts_done is set "
 			"state is %s\n",
-			fnic_ioreq_state_to_str(CMD_STATE(sc)));
+			fnic_ioreq_state_to_str(fnic_priv(sc)->state));
 	}
 
-	if (!(CMD_FLAGS(sc) & FNIC_IO_ISSUED)) {
+	if (!(fnic_priv(sc)->flags & FNIC_IO_ISSUED)) {
 		shost_printk(KERN_ERR, fnic->lport->host,
 			     "rport_exch_reset "
 			     "IO not yet issued %p tag 0x%x flags "
 			     "%x state %d\n",
-			     sc, abt_tag, CMD_FLAGS(sc), CMD_STATE(sc));
+			     sc, abt_tag, fnic_priv(sc)->flags, fnic_priv(sc)->state);
 	}
-	old_ioreq_state = CMD_STATE(sc);
-	CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
-	CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
-	if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
+	old_ioreq_state = fnic_priv(sc)->state;
+	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_PENDING;
+	fnic_priv(sc)->abts_status = FCPIO_INVALID_CODE;
+	if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET) {
 		atomic64_inc(&reset_stats->device_reset_terminates);
 		abt_tag |= FNIC_TAG_DEV_RST;
 	}
@@ -1638,15 +1633,15 @@  static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data,
 		 * lun reset
 		 */
 		spin_lock_irqsave(io_lock, flags);
-		if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
-			CMD_STATE(sc) = old_ioreq_state;
+		if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING)
+			fnic_priv(sc)->state = old_ioreq_state;
 		spin_unlock_irqrestore(io_lock, flags);
 	} else {
 		spin_lock_irqsave(io_lock, flags);
-		if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET)
-			CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
+		if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET)
+			fnic_priv(sc)->flags |= FNIC_DEV_RST_TERM_ISSUED;
 		else
-			CMD_FLAGS(sc) |= FNIC_IO_INTERNAL_TERM_ISSUED;
+			fnic_priv(sc)->flags |= FNIC_IO_INTERNAL_TERM_ISSUED;
 		spin_unlock_irqrestore(io_lock, flags);
 		atomic64_inc(&term_stats->terminates);
 		iter_data->term_cnt++;
@@ -1754,9 +1749,9 @@  int fnic_abort_cmd(struct scsi_cmnd *sc)
 	FNIC_SCSI_DBG(KERN_DEBUG,
 		fnic->lport->host,
 		"Abort Cmd called FCID 0x%x, LUN 0x%llx TAG %x flags %x\n",
-		rport->port_id, sc->device->lun, tag, CMD_FLAGS(sc));
+		rport->port_id, sc->device->lun, tag, fnic_priv(sc)->flags);
 
-	CMD_FLAGS(sc) = FNIC_NO_FLAGS;
+	fnic_priv(sc)->flags = FNIC_NO_FLAGS;
 
 	if (lp->state != LPORT_ST_READY || !(lp->link_up)) {
 		ret = FAILED;
@@ -1773,11 +1768,11 @@  int fnic_abort_cmd(struct scsi_cmnd *sc)
 	 * happened, the completion wont actually complete the command
 	 * and it will be considered as an aborted command
 	 *
-	 * The CMD_SP will not be cleared except while holding io_req_lock.
+	 * .io_req will not be cleared except while holding io_req_lock.
 	 */
 	io_lock = fnic_io_lock_hash(fnic, sc);
 	spin_lock_irqsave(io_lock, flags);
-	io_req = (struct fnic_io_req *)CMD_SP(sc);
+	io_req = fnic_priv(sc)->io_req;
 	if (!io_req) {
 		spin_unlock_irqrestore(io_lock, flags);
 		goto fnic_abort_cmd_end;
@@ -1785,7 +1780,7 @@  int fnic_abort_cmd(struct scsi_cmnd *sc)
 
 	io_req->abts_done = &tm_done;
 
-	if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
+	if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
 		spin_unlock_irqrestore(io_lock, flags);
 		goto wait_pending;
 	}
@@ -1814,9 +1809,9 @@  int fnic_abort_cmd(struct scsi_cmnd *sc)
 	 * the completion wont be done till mid-layer, since abort
 	 * has already started.
 	 */
-	old_ioreq_state = CMD_STATE(sc);
-	CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
-	CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
+	old_ioreq_state = fnic_priv(sc)->state;
+	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_PENDING;
+	fnic_priv(sc)->abts_status = FCPIO_INVALID_CODE;
 
 	spin_unlock_irqrestore(io_lock, flags);
 
@@ -1838,9 +1833,9 @@  int fnic_abort_cmd(struct scsi_cmnd *sc)
 	if (fnic_queue_abort_io_req(fnic, tag, task_req, fc_lun.scsi_lun,
 				    io_req)) {
 		spin_lock_irqsave(io_lock, flags);
-		if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
-			CMD_STATE(sc) = old_ioreq_state;
-		io_req = (struct fnic_io_req *)CMD_SP(sc);
+		if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING)
+			fnic_priv(sc)->state = old_ioreq_state;
+		io_req = fnic_priv(sc)->io_req;
 		if (io_req)
 			io_req->abts_done = NULL;
 		spin_unlock_irqrestore(io_lock, flags);
@@ -1848,10 +1843,10 @@  int fnic_abort_cmd(struct scsi_cmnd *sc)
 		goto fnic_abort_cmd_end;
 	}
 	if (task_req == FCPIO_ITMF_ABT_TASK) {
-		CMD_FLAGS(sc) |= FNIC_IO_ABTS_ISSUED;
+		fnic_priv(sc)->flags |= FNIC_IO_ABTS_ISSUED;
 		atomic64_inc(&fnic_stats->abts_stats.aborts);
 	} else {
-		CMD_FLAGS(sc) |= FNIC_IO_TERM_ISSUED;
+		fnic_priv(sc)->flags |= FNIC_IO_TERM_ISSUED;
 		atomic64_inc(&fnic_stats->term_stats.terminates);
 	}
 
@@ -1869,32 +1864,32 @@  int fnic_abort_cmd(struct scsi_cmnd *sc)
 	/* Check the abort status */
 	spin_lock_irqsave(io_lock, flags);
 
-	io_req = (struct fnic_io_req *)CMD_SP(sc);
+	io_req = fnic_priv(sc)->io_req;
 	if (!io_req) {
 		atomic64_inc(&fnic_stats->io_stats.ioreq_null);
 		spin_unlock_irqrestore(io_lock, flags);
-		CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_REQ_NULL;
+		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_REQ_NULL;
 		ret = FAILED;
 		goto fnic_abort_cmd_end;
 	}
 	io_req->abts_done = NULL;
 
 	/* fw did not complete abort, timed out */
-	if (CMD_ABTS_STATUS(sc) == FCPIO_INVALID_CODE) {
+	if (fnic_priv(sc)->abts_status == FCPIO_INVALID_CODE) {
 		spin_unlock_irqrestore(io_lock, flags);
 		if (task_req == FCPIO_ITMF_ABT_TASK) {
 			atomic64_inc(&abts_stats->abort_drv_timeouts);
 		} else {
 			atomic64_inc(&term_stats->terminate_drv_timeouts);
 		}
-		CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_TIMED_OUT;
+		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_TIMED_OUT;
 		ret = FAILED;
 		goto fnic_abort_cmd_end;
 	}
 
 	/* IO out of order */
 
-	if (!(CMD_FLAGS(sc) & (FNIC_IO_ABORTED | FNIC_IO_DONE))) {
+	if (!(fnic_priv(sc)->flags & (FNIC_IO_ABORTED | FNIC_IO_DONE))) {
 		spin_unlock_irqrestore(io_lock, flags);
 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 			"Issuing Host reset due to out of order IO\n");
@@ -1903,7 +1898,7 @@  int fnic_abort_cmd(struct scsi_cmnd *sc)
 		goto fnic_abort_cmd_end;
 	}
 
-	CMD_STATE(sc) = FNIC_IOREQ_ABTS_COMPLETE;
+	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_COMPLETE;
 
 	start_time = io_req->start_time;
 	/*
@@ -1911,9 +1906,9 @@  int fnic_abort_cmd(struct scsi_cmnd *sc)
 	 * free the io_req if successful. If abort fails,
 	 * Device reset will clean the I/O.
 	 */
-	if (CMD_ABTS_STATUS(sc) == FCPIO_SUCCESS)
-		CMD_SP(sc) = NULL;
-	else {
+	if (fnic_priv(sc)->abts_status == FCPIO_SUCCESS) {
+		fnic_priv(sc)->io_req = NULL;
+	} else {
 		ret = FAILED;
 		spin_unlock_irqrestore(io_lock, flags);
 		goto fnic_abort_cmd_end;
@@ -1939,7 +1934,7 @@  int fnic_abort_cmd(struct scsi_cmnd *sc)
 		  0, ((u64)sc->cmnd[0] << 32 |
 		  (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
 		  (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
-		  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
+		  fnic_flags_and_state(sc));
 
 	FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 		      "Returning from abort cmd type %x %s\n", task_req,
@@ -2030,7 +2025,7 @@  static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
 
 	io_lock = fnic_io_lock_tag(fnic, abt_tag);
 	spin_lock_irqsave(io_lock, flags);
-	io_req = (struct fnic_io_req *)CMD_SP(sc);
+	io_req = fnic_priv(sc)->io_req;
 	if (!io_req) {
 		spin_unlock_irqrestore(io_lock, flags);
 		return true;
@@ -2042,14 +2037,14 @@  static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
 	 */
 	FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 		      "Found IO in %s on lun\n",
-		      fnic_ioreq_state_to_str(CMD_STATE(sc)));
+		      fnic_ioreq_state_to_str(fnic_priv(sc)->state));
 
-	if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
+	if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
 		spin_unlock_irqrestore(io_lock, flags);
 		return true;
 	}
-	if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
-	    (!(CMD_FLAGS(sc) & FNIC_DEV_RST_ISSUED))) {
+	if ((fnic_priv(sc)->flags & FNIC_DEVICE_RESET) &&
+	    (!(fnic_priv(sc)->flags & FNIC_DEV_RST_ISSUED))) {
 		FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
 			      "%s dev rst not pending sc 0x%p\n", __func__,
 			      sc);
@@ -2060,8 +2055,8 @@  static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
 	if (io_req->abts_done)
 		shost_printk(KERN_ERR, fnic->lport->host,
 			     "%s: io_req->abts_done is set state is %s\n",
-			     __func__, fnic_ioreq_state_to_str(CMD_STATE(sc)));
-	old_ioreq_state = CMD_STATE(sc);
+			     __func__, fnic_ioreq_state_to_str(fnic_priv(sc)->state));
+	old_ioreq_state = fnic_priv(sc)->state;
 	/*
 	 * Any pending IO issued prior to reset is expected to be
 	 * in abts pending state, if not we need to set
@@ -2069,17 +2064,17 @@  static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
 	 * When IO is completed, the IO will be handed over and
 	 * handled in this function.
 	 */
-	CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
+	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_PENDING;
 
 	BUG_ON(io_req->abts_done);
 
-	if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
+	if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET) {
 		abt_tag |= FNIC_TAG_DEV_RST;
 		FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
 			      "%s: dev rst sc 0x%p\n", __func__, sc);
 	}
 
-	CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
+	fnic_priv(sc)->abts_status = FCPIO_INVALID_CODE;
 	io_req->abts_done = &tm_done;
 	spin_unlock_irqrestore(io_lock, flags);
 
@@ -2090,48 +2085,48 @@  static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
 				    FCPIO_ITMF_ABT_TASK_TERM,
 				    fc_lun.scsi_lun, io_req)) {
 		spin_lock_irqsave(io_lock, flags);
-		io_req = (struct fnic_io_req *)CMD_SP(sc);
+		io_req = fnic_priv(sc)->io_req;
 		if (io_req)
 			io_req->abts_done = NULL;
-		if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
-			CMD_STATE(sc) = old_ioreq_state;
+		if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING)
+			fnic_priv(sc)->state = old_ioreq_state;
 		spin_unlock_irqrestore(io_lock, flags);
 		iter_data->ret = FAILED;
 		return false;
 	} else {
 		spin_lock_irqsave(io_lock, flags);
-		if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET)
-			CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
+		if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET)
+			fnic_priv(sc)->flags |= FNIC_DEV_RST_TERM_ISSUED;
 		spin_unlock_irqrestore(io_lock, flags);
 	}
-	CMD_FLAGS(sc) |= FNIC_IO_INTERNAL_TERM_ISSUED;
+	fnic_priv(sc)->flags |= FNIC_IO_INTERNAL_TERM_ISSUED;
 
 	wait_for_completion_timeout(&tm_done, msecs_to_jiffies
 				    (fnic->config.ed_tov));
 
 	/* Recheck cmd state to check if it is now aborted */
 	spin_lock_irqsave(io_lock, flags);
-	io_req = (struct fnic_io_req *)CMD_SP(sc);
+	io_req = fnic_priv(sc)->io_req;
 	if (!io_req) {
 		spin_unlock_irqrestore(io_lock, flags);
-		CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_REQ_NULL;
+		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_REQ_NULL;
 		return true;
 	}
 
 	io_req->abts_done = NULL;
 
 	/* if abort is still pending with fw, fail */
-	if (CMD_ABTS_STATUS(sc) == FCPIO_INVALID_CODE) {
+	if (fnic_priv(sc)->abts_status == FCPIO_INVALID_CODE) {
 		spin_unlock_irqrestore(io_lock, flags);
-		CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_DONE;
+		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_DONE;
 		iter_data->ret = FAILED;
 		return false;
 	}
-	CMD_STATE(sc) = FNIC_IOREQ_ABTS_COMPLETE;
+	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_COMPLETE;
 
 	/* original sc used for lr is handled by dev reset code */
 	if (sc != iter_data->lr_sc)
-		CMD_SP(sc) = NULL;
+		fnic_priv(sc)->io_req = NULL;
 	spin_unlock_irqrestore(io_lock, flags);
 
 	/* original sc used for lr is handled by dev reset code */
@@ -2272,7 +2267,7 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 		goto fnic_device_reset_end;
 	}
 
-	CMD_FLAGS(sc) = FNIC_DEVICE_RESET;
+	fnic_priv(sc)->flags = FNIC_DEVICE_RESET;
 	/* Allocate tag if not present */
 
 	if (unlikely(tag < 0)) {
@@ -2288,7 +2283,7 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 	}
 	io_lock = fnic_io_lock_hash(fnic, sc);
 	spin_lock_irqsave(io_lock, flags);
-	io_req = (struct fnic_io_req *)CMD_SP(sc);
+	io_req = fnic_priv(sc)->io_req;
 
 	/*
 	 * If there is a io_req attached to this command, then use it,
@@ -2302,11 +2297,11 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 		}
 		memset(io_req, 0, sizeof(*io_req));
 		io_req->port_id = rport->port_id;
-		CMD_SP(sc) = (char *)io_req;
+		fnic_priv(sc)->io_req = io_req;
 	}
 	io_req->dr_done = &tm_done;
-	CMD_STATE(sc) = FNIC_IOREQ_CMD_PENDING;
-	CMD_LR_STATUS(sc) = FCPIO_INVALID_CODE;
+	fnic_priv(sc)->state = FNIC_IOREQ_CMD_PENDING;
+	fnic_priv(sc)->lr_status = FCPIO_INVALID_CODE;
 	spin_unlock_irqrestore(io_lock, flags);
 
 	FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host, "TAG %x\n", tag);
@@ -2317,13 +2312,13 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 	 */
 	if (fnic_queue_dr_io_req(fnic, sc, io_req)) {
 		spin_lock_irqsave(io_lock, flags);
-		io_req = (struct fnic_io_req *)CMD_SP(sc);
+		io_req = fnic_priv(sc)->io_req;
 		if (io_req)
 			io_req->dr_done = NULL;
 		goto fnic_device_reset_clean;
 	}
 	spin_lock_irqsave(io_lock, flags);
-	CMD_FLAGS(sc) |= FNIC_DEV_RST_ISSUED;
+	fnic_priv(sc)->flags |= FNIC_DEV_RST_ISSUED;
 	spin_unlock_irqrestore(io_lock, flags);
 
 	/*
@@ -2334,7 +2329,7 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 				    msecs_to_jiffies(FNIC_LUN_RESET_TIMEOUT));
 
 	spin_lock_irqsave(io_lock, flags);
-	io_req = (struct fnic_io_req *)CMD_SP(sc);
+	io_req = fnic_priv(sc)->io_req;
 	if (!io_req) {
 		spin_unlock_irqrestore(io_lock, flags);
 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
@@ -2343,7 +2338,7 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 	}
 	io_req->dr_done = NULL;
 
-	status = CMD_LR_STATUS(sc);
+	status = fnic_priv(sc)->lr_status;
 
 	/*
 	 * If lun reset not completed, bail out with failed. io_req
@@ -2353,7 +2348,7 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 		atomic64_inc(&reset_stats->device_reset_timeouts);
 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 			      "Device reset timed out\n");
-		CMD_FLAGS(sc) |= FNIC_DEV_RST_TIMED_OUT;
+		fnic_priv(sc)->flags |= FNIC_DEV_RST_TIMED_OUT;
 		spin_unlock_irqrestore(io_lock, flags);
 		int_to_scsilun(sc->device->lun, &fc_lun);
 		/*
@@ -2362,7 +2357,7 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 		 */
 		while (1) {
 			spin_lock_irqsave(io_lock, flags);
-			if (CMD_FLAGS(sc) & FNIC_DEV_RST_TERM_ISSUED) {
+			if (fnic_priv(sc)->flags & FNIC_DEV_RST_TERM_ISSUED) {
 				spin_unlock_irqrestore(io_lock, flags);
 				break;
 			}
@@ -2375,8 +2370,8 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 				msecs_to_jiffies(FNIC_ABT_TERM_DELAY_TIMEOUT));
 			} else {
 				spin_lock_irqsave(io_lock, flags);
-				CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
-				CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
+				fnic_priv(sc)->flags |= FNIC_DEV_RST_TERM_ISSUED;
+				fnic_priv(sc)->state = FNIC_IOREQ_ABTS_PENDING;
 				io_req->abts_done = &tm_done;
 				spin_unlock_irqrestore(io_lock, flags);
 				FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
@@ -2387,13 +2382,13 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 		}
 		while (1) {
 			spin_lock_irqsave(io_lock, flags);
-			if (!(CMD_FLAGS(sc) & FNIC_DEV_RST_DONE)) {
+			if (!(fnic_priv(sc)->flags & FNIC_DEV_RST_DONE)) {
 				spin_unlock_irqrestore(io_lock, flags);
 				wait_for_completion_timeout(&tm_done,
 				msecs_to_jiffies(FNIC_LUN_RESET_TIMEOUT));
 				break;
 			} else {
-				io_req = (struct fnic_io_req *)CMD_SP(sc);
+				io_req = fnic_priv(sc)->io_req;
 				io_req->abts_done = NULL;
 				goto fnic_device_reset_clean;
 			}
@@ -2408,7 +2403,7 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 		FNIC_SCSI_DBG(KERN_DEBUG,
 			      fnic->lport->host,
 			      "Device reset completed - failed\n");
-		io_req = (struct fnic_io_req *)CMD_SP(sc);
+		io_req = fnic_priv(sc)->io_req;
 		goto fnic_device_reset_clean;
 	}
 
@@ -2421,7 +2416,7 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 	 */
 	if (fnic_clean_pending_aborts(fnic, sc, new_sc)) {
 		spin_lock_irqsave(io_lock, flags);
-		io_req = (struct fnic_io_req *)CMD_SP(sc);
+		io_req = fnic_priv(sc)->io_req;
 		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 			      "Device reset failed"
 			      " since could not abort all IOs\n");
@@ -2430,14 +2425,14 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 
 	/* Clean lun reset command */
 	spin_lock_irqsave(io_lock, flags);
-	io_req = (struct fnic_io_req *)CMD_SP(sc);
+	io_req = fnic_priv(sc)->io_req;
 	if (io_req)
 		/* Completed, and successful */
 		ret = SUCCESS;
 
 fnic_device_reset_clean:
 	if (io_req)
-		CMD_SP(sc) = NULL;
+		fnic_priv(sc)->io_req = NULL;
 
 	spin_unlock_irqrestore(io_lock, flags);
 
@@ -2453,7 +2448,7 @@  int fnic_device_reset(struct scsi_cmnd *sc)
 		  0, ((u64)sc->cmnd[0] << 32 |
 		  (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
 		  (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
-		  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
+		  fnic_flags_and_state(sc));
 
 	/* free tag if it is allocated */
 	if (unlikely(tag_gen_flag))
@@ -2698,7 +2693,7 @@  static bool fnic_abts_pending_iter(struct scsi_cmnd *sc, void *data,
 	io_lock = fnic_io_lock_hash(fnic, sc);
 	spin_lock_irqsave(io_lock, flags);
 
-	io_req = (struct fnic_io_req *)CMD_SP(sc);
+	io_req = fnic_priv(sc)->io_req;
 	if (!io_req) {
 		spin_unlock_irqrestore(io_lock, flags);
 		return true;
@@ -2710,8 +2705,8 @@  static bool fnic_abts_pending_iter(struct scsi_cmnd *sc, void *data,
 	 */
 	FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
 		      "Found IO in %s on lun\n",
-		      fnic_ioreq_state_to_str(CMD_STATE(sc)));
-	cmd_state = CMD_STATE(sc);
+		      fnic_ioreq_state_to_str(fnic_priv(sc)->state));
+	cmd_state = fnic_priv(sc)->state;
 	spin_unlock_irqrestore(io_lock, flags);
 	if (cmd_state == FNIC_IOREQ_ABTS_PENDING)
 		iter_data->ret = 1;