[SCSI] fnic: Fnic Trace Utility (4d7007b4) · Commits · 戴 / test

drivers/scsi/fnic/Makefile

+2 −0

Original line number	Diff line number	Diff line
		@@ -7,6 +7,8 @@ fnic-y := \
		fnic_res.o \
		fnic_fcs.o \
		fnic_scsi.o \
		fnic_trace.o \
		fnic_debugfs.o \
		vnic_cq.o \
		vnic_dev.o \
		vnic_intr.o \

drivers/scsi/fnic/fnic.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		#include <scsi/libfcoe.h>
		#include "fnic_io.h"
		#include "fnic_res.h"
		#include "fnic_trace.h"
		#include "vnic_dev.h"
		#include "vnic_wq.h"
		#include "vnic_rq.h"

drivers/scsi/fnic/fnic_debugfs.c

0 → 100644

+314 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2012 Cisco Systems, Inc. All rights reserved.
		*
		* This program is free software; you may redistribute it and/or modify
		* it under the terms of the GNU General Public License as published by
		* the Free Software Foundation; version 2 of the License.
		*
		* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
		* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
		* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
		* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
		* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
		* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
		* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
		* SOFTWARE.
		*/

		#include <linux/module.h>
		#include <linux/errno.h>
		#include <linux/debugfs.h>
		#include "fnic.h"

		static struct dentry *fnic_trace_debugfs_root;
		static struct dentry *fnic_trace_debugfs_file;
		static struct dentry *fnic_trace_enable;

		/*
		* fnic_trace_ctrl_open - Open the trace_enable file
		* @inode: The inode pointer.
		* @file: The file pointer to attach the trace enable/disable flag.
		*
		* Description:
		* This routine opens a debugsfs file trace_enable.
		*
		* Returns:
		* This function returns zero if successful.
		*/
		static int fnic_trace_ctrl_open(struct inode inode, struct file filp)
		{
		filp->private_data = inode->i_private;
		return 0;
		}

		/*
		* fnic_trace_ctrl_read - Read a trace_enable debugfs file
		* @filp: The file pointer to read from.
		* @ubuf: The buffer to copy the data to.
		* @cnt: The number of bytes to read.
		* @ppos: The position in the file to start reading from.
		*
		* Description:
		* This routine reads value of variable fnic_tracing_enabled
		* and stores into local @buf. It will start reading file at @ppos and
		* copy up to @cnt of data to @ubuf from @buf.
		*
		* Returns:
		* This function returns the amount of data that was read.
		*/
		static ssize_t fnic_trace_ctrl_read(struct file *filp,
		char __user *ubuf,
		size_t cnt, loff_t *ppos)
		{
		char buf[64];
		int len;
		len = sprintf(buf, "%u\n", fnic_tracing_enabled);

		return simple_read_from_buffer(ubuf, cnt, ppos, buf, len);
		}

		/*
		* fnic_trace_ctrl_write - Write to trace_enable debugfs file
		* @filp: The file pointer to write from.
		* @ubuf: The buffer to copy the data from.
		* @cnt: The number of bytes to write.
		* @ppos: The position in the file to start writing to.
		*
		* Description:
		* This routine writes data from user buffer @ubuf to buffer @buf and
		* sets fnic_tracing_enabled value as per user input.
		*
		* Returns:
		* This function returns the amount of data that was written.
		*/
		static ssize_t fnic_trace_ctrl_write(struct file *filp,
		const char __user *ubuf,
		size_t cnt, loff_t *ppos)
		{
		char buf[64];
		unsigned long val;
		int ret;

		if (cnt >= sizeof(buf))
		return -EINVAL;

		if (copy_from_user(&buf, ubuf, cnt))
		return -EFAULT;

		buf[cnt] = 0;

		ret = kstrtoul(buf, 10, &val);
		if (ret < 0)
		return ret;

		fnic_tracing_enabled = val;
		(*ppos)++;

		return cnt;
		}

		/*
		* fnic_trace_debugfs_open - Open the fnic trace log
		* @inode: The inode pointer
		* @file: The file pointer to attach the log output
		*
		* Description:
		* This routine is the entry point for the debugfs open file operation.
		* It allocates the necessary buffer for the log, fills the buffer from
		* the in-memory log and then returns a pointer to that log in
		* the private_data field in @file.
		*
		* Returns:
		* This function returns zero if successful. On error it will return
		* a negative error value.
		*/
		static int fnic_trace_debugfs_open(struct inode *inode,
		struct file *file)
		{
		fnic_dbgfs_t *fnic_dbg_prt;
		fnic_dbg_prt = kzalloc(sizeof(fnic_dbgfs_t), GFP_KERNEL);
		if (!fnic_dbg_prt)
		return -ENOMEM;

		fnic_dbg_prt->buffer = vmalloc((3(trace_max_pages PAGE_SIZE)));
		if (!fnic_dbg_prt->buffer) {
		kfree(fnic_dbg_prt);
		return -ENOMEM;
		}
		memset((void *)fnic_dbg_prt->buffer, 0,
		(3(trace_max_pages PAGE_SIZE)));
		fnic_dbg_prt->buffer_len = fnic_get_trace_data(fnic_dbg_prt);
		file->private_data = fnic_dbg_prt;
		return 0;
		}

		/*
		* fnic_trace_debugfs_lseek - Seek through a debugfs file
		* @file: The file pointer to seek through.
		* @offset: The offset to seek to or the amount to seek by.
		* @howto: Indicates how to seek.
		*
		* Description:
		* This routine is the entry point for the debugfs lseek file operation.
		* The @howto parameter indicates whether @offset is the offset to directly
		* seek to, or if it is a value to seek forward or reverse by. This function
		* figures out what the new offset of the debugfs file will be and assigns
		* that value to the f_pos field of @file.
		*
		* Returns:
		* This function returns the new offset if successful and returns a negative
		* error if unable to process the seek.
		*/
		static loff_t fnic_trace_debugfs_lseek(struct file *file,
		loff_t offset,
		int howto)
		{
		fnic_dbgfs_t *fnic_dbg_prt = file->private_data;
		loff_t pos = -1;

		switch (howto) {
		case 0:
		pos = offset;
		break;
		case 1:
		pos = file->f_pos + offset;
		break;
		case 2:
		pos = fnic_dbg_prt->buffer_len - offset;
		}
		return (pos < 0 \|\| pos > fnic_dbg_prt->buffer_len) ?
		-EINVAL : (file->f_pos = pos);
		}

		/*
		* fnic_trace_debugfs_read - Read a debugfs file
		* @file: The file pointer to read from.
		* @ubuf: The buffer to copy the data to.
		* @nbytes: The number of bytes to read.
		* @pos: The position in the file to start reading from.
		*
		* Description:
		* This routine reads data from the buffer indicated in the private_data
		* field of @file. It will start reading at @pos and copy up to @nbytes of
		* data to @ubuf.
		*
		* Returns:
		* This function returns the amount of data that was read (this could be
		* less than @nbytes if the end of the file was reached).
		*/
		static ssize_t fnic_trace_debugfs_read(struct file *file,
		char __user *ubuf,
		size_t nbytes,
		loff_t *pos)
		{
		fnic_dbgfs_t *fnic_dbg_prt = file->private_data;
		int rc = 0;
		rc = simple_read_from_buffer(ubuf, nbytes, pos,
		fnic_dbg_prt->buffer,
		fnic_dbg_prt->buffer_len);
		return rc;
		}

		/*
		* fnic_trace_debugfs_release - Release the buffer used to store
		* debugfs file data
		* @inode: The inode pointer
		* @file: The file pointer that contains the buffer to release
		*
		* Description:
		* This routine frees the buffer that was allocated when the debugfs
		* file was opened.
		*
		* Returns:
		* This function returns zero.
		*/
		static int fnic_trace_debugfs_release(struct inode *inode,
		struct file *file)
		{
		fnic_dbgfs_t *fnic_dbg_prt = file->private_data;

		vfree(fnic_dbg_prt->buffer);
		kfree(fnic_dbg_prt);
		return 0;
		}

		static const struct file_operations fnic_trace_ctrl_fops = {
		.owner = THIS_MODULE,
		.open = fnic_trace_ctrl_open,
		.read = fnic_trace_ctrl_read,
		.write = fnic_trace_ctrl_write,
		};

		static const struct file_operations fnic_trace_debugfs_fops = {
		.owner = THIS_MODULE,
		.open = fnic_trace_debugfs_open,
		.llseek = fnic_trace_debugfs_lseek,
		.read = fnic_trace_debugfs_read,
		.release = fnic_trace_debugfs_release,
		};

		/*
		* fnic_trace_debugfs_init - Initialize debugfs for fnic trace logging
		*
		* Description:
		* When Debugfs is configured this routine sets up the fnic debugfs
		* file system. If not already created, this routine will create the
		* fnic directory. It will create file trace to log fnic trace buffer
		* output into debugfs and it will also create file trace_enable to
		* control enable/disable of trace logging into trace buffer.
		*/
		int fnic_trace_debugfs_init(void)
		{
		int rc = -1;
		fnic_trace_debugfs_root = debugfs_create_dir("fnic", NULL);
		if (!fnic_trace_debugfs_root) {
		printk(KERN_DEBUG "Cannot create debugfs root\n");
		return rc;
		}
		fnic_trace_enable = debugfs_create_file("tracing_enable",
		S_IFREG\|S_IRUGO\|S_IWUSR,
		fnic_trace_debugfs_root,
		NULL, &fnic_trace_ctrl_fops);

		if (!fnic_trace_enable) {
		printk(KERN_DEBUG "Cannot create trace_enable file"
		" under debugfs");
		return rc;
		}

		fnic_trace_debugfs_file = debugfs_create_file("trace",
		S_IFREG\|S_IRUGO\|S_IWUSR,
		fnic_trace_debugfs_root,
		NULL,
		&fnic_trace_debugfs_fops);

		if (!fnic_trace_debugfs_file) {
		printk(KERN_DEBUG "Cannot create trace file under debugfs");
		return rc;
		}
		rc = 0;
		return rc;
		}

		/*
		* fnic_trace_debugfs_terminate - Tear down debugfs infrastructure
		*
		* Description:
		* When Debugfs is configured this routine removes debugfs file system
		* elements that are specific to fnic trace logging.
		*/
		void fnic_trace_debugfs_terminate(void)
		{
		if (fnic_trace_debugfs_file) {
		debugfs_remove(fnic_trace_debugfs_file);
		fnic_trace_debugfs_file = NULL;
		}
		if (fnic_trace_enable) {
		debugfs_remove(fnic_trace_enable);
		fnic_trace_enable = NULL;
		}
		if (fnic_trace_debugfs_root) {
		debugfs_remove(fnic_trace_debugfs_root);
		fnic_trace_debugfs_root = NULL;
		}
		}

drivers/scsi/fnic/fnic_main.c

+14 −0

Original line number	Diff line number	Diff line
		@@ -68,6 +68,10 @@ unsigned int fnic_log_level;
		module_param(fnic_log_level, int, S_IRUGO\|S_IWUSR);
		MODULE_PARM_DESC(fnic_log_level, "bit mask of fnic logging levels");

		unsigned int fnic_trace_max_pages = 16;
		module_param(fnic_trace_max_pages, uint, S_IRUGO\|S_IWUSR);
		MODULE_PARM_DESC(fnic_trace_max_pages, "Total allocated memory pages "
		"for fnic trace buffer");

		static struct libfc_function_template fnic_transport_template = {
		.frame_send = fnic_send,
		@@ -861,6 +865,14 @@ static int __init fnic_init_module(void)

		printk(KERN_INFO PFX "%s, ver %s\n", DRV_DESCRIPTION, DRV_VERSION);

		/* Allocate memory for trace buffer */
		err = fnic_trace_buf_init();
		if (err < 0) {
		printk(KERN_ERR PFX "Trace buffer initialization Failed "
		"Fnic Tracing utility is disabled\n");
		fnic_trace_free();
		}

		/* Create a cache for allocation of default size sgls */
		len = sizeof(struct fnic_dflt_sgl_list);
		fnic_sgl_cache[FNIC_SGL_CACHE_DFLT] = kmem_cache_create
		@@ -931,6 +943,7 @@ err_create_fnic_ioreq_slab:
		err_create_fnic_sgl_slab_max:
		kmem_cache_destroy(fnic_sgl_cache[FNIC_SGL_CACHE_DFLT]);
		err_create_fnic_sgl_slab_dflt:
		fnic_trace_free();
		return err;
		}

		@@ -942,6 +955,7 @@ static void __exit fnic_cleanup_module(void)
		kmem_cache_destroy(fnic_sgl_cache[FNIC_SGL_CACHE_DFLT]);
		kmem_cache_destroy(fnic_io_req_cache);
		fc_release_transport(fnic_fc_transport);
		fnic_trace_free();
		}

		module_init(fnic_init_module);

drivers/scsi/fnic/fnic_scsi.c

+109 −11

Original line number	Diff line number	Diff line
		@@ -393,11 +393,12 @@ static int fnic_queuecommand_lck(struct scsi_cmnd sc, void (done)(struct scsi_
		{
		struct fc_lport *lp = shost_priv(sc->device->host);
		struct fc_rport *rport;
		struct fnic_io_req *io_req;
		struct fnic_io_req *io_req = NULL;
		struct fnic *fnic = lport_priv(lp);
		struct vnic_wq_copy *wq;
		int ret;
		int sg_count;
		u64 cmd_trace;
		int sg_count = 0;
		unsigned long flags;
		unsigned long ptr;

		@@ -437,6 +438,9 @@ static int fnic_queuecommand_lck(struct scsi_cmnd sc, void (done)(struct scsi_
		/* Map the data buffer */
		sg_count = scsi_dma_map(sc);
		if (sg_count < 0) {
		FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
		sc->request->tag, sc, 0, sc->cmnd[0],
		sg_count, CMD_STATE(sc));
		mempool_free(io_req, fnic->io_req_pool);
		goto out;
		}
		@@ -486,7 +490,9 @@ static int fnic_queuecommand_lck(struct scsi_cmnd sc, void (done)(struct scsi_
		* refetch the pointer under the lock.
		*/
		spinlock_t *io_lock = fnic_io_lock_hash(fnic, sc);

		FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
		sc->request->tag, sc, 0, 0, 0,
		(((u64)CMD_FLAGS(sc) << 32) \| CMD_STATE(sc)));
		spin_lock_irqsave(io_lock, flags);
		io_req = (struct fnic_io_req *)CMD_SP(sc);
		CMD_SP(sc) = NULL;
		@@ -501,6 +507,15 @@ static int fnic_queuecommand_lck(struct scsi_cmnd sc, void (done)(struct scsi_
		CMD_FLAGS(sc) \|= FNIC_IO_ISSUED;
		}
		out:
		cmd_trace = ((u64)sc->cmnd[0] << 56 \| (u64)sc->cmnd[7] << 40 \|
		(u64)sc->cmnd[8] << 32 \| (u64)sc->cmnd[2] << 24 \|
		(u64)sc->cmnd[3] << 16 \| (u64)sc->cmnd[4] << 8 \|
		sc->cmnd[5]);

		FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
		sc->request->tag, sc, io_req,
		sg_count, cmd_trace,
		(((u64)CMD_FLAGS(sc) >> 32) \| CMD_STATE(sc)));
		atomic_dec(&fnic->in_flight);
		/* acquire host lock before returning to SCSI */
		spin_lock(lp->host->host_lock);
		@@ -674,6 +689,7 @@ static inline void fnic_fcpio_ack_handler(struct fnic *fnic,
		struct vnic_wq_copy *wq;
		u16 request_out = desc->u.ack.request_out;
		unsigned long flags;
		u64 ox_id_tag = (u64 )(void *)desc;

		/* mark the ack state */
		wq = &fnic->wq_copy[cq_index - fnic->raw_wq_count - fnic->rq_count];
		@@ -684,6 +700,9 @@ static inline void fnic_fcpio_ack_handler(struct fnic *fnic,
		fnic->fw_ack_recd[0] = 1;
		}
		spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
		FNIC_TRACE(fnic_fcpio_ack_handler,
		fnic->lport->host->host_no, 0, 0, ox_id_tag[2], ox_id_tag[3],
		ox_id_tag[4], ox_id_tag[5]);
		}

		/*
		@@ -703,6 +722,7 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
		struct scsi_cmnd *sc;
		unsigned long flags;
		spinlock_t *io_lock;
		u64 cmd_trace;
		unsigned long start_time;

		/* Decode the cmpl description to get the io_req id */
		@@ -724,6 +744,14 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
		"icmnd_cmpl sc is null - "
		"hdr status = %s tag = 0x%x desc = 0x%p\n",
		fnic_fcpio_status_to_str(hdr_status), id, desc);
		FNIC_TRACE(fnic_fcpio_icmnd_cmpl_handler,
		fnic->lport->host->host_no, id,
		((u64)icmnd_cmpl->_resvd0[1] << 16 \|
		(u64)icmnd_cmpl->_resvd0[0]),
		((u64)hdr_status << 16 \|
		(u64)icmnd_cmpl->scsi_status << 8 \|
		(u64)icmnd_cmpl->flags), desc,
		(u64)icmnd_cmpl->residual, 0);
		return;
		}

		@@ -864,6 +892,20 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,

		mempool_free(io_req, fnic->io_req_pool);

		cmd_trace = ((u64)hdr_status << 56) \|
		(u64)icmnd_cmpl->scsi_status << 48 \|
		(u64)icmnd_cmpl->flags << 40 \| (u64)sc->cmnd[0] << 32 \|
		(u64)sc->cmnd[2] << 24 \| (u64)sc->cmnd[3] << 16 \|
		(u64)sc->cmnd[4] << 8 \| sc->cmnd[5];

		FNIC_TRACE(fnic_fcpio_icmnd_cmpl_handler,
		sc->device->host->host_no, id, sc,
		((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)));

		if (sc->sc_data_direction == DMA_FROM_DEVICE) {
		fnic->lport->host_stats.fcp_input_requests++;
		fnic->fcp_input_bytes += xfer_len;
		@@ -876,7 +918,6 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
		/* Call SCSI completion function to complete the IO */
		if (sc->scsi_done)
		sc->scsi_done(sc);

		}

		/* fnic_fcpio_itmf_cmpl_handler
		@@ -974,9 +1015,22 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,

		fnic_release_ioreq_buf(fnic, io_req, sc);
		mempool_free(io_req, fnic->io_req_pool);
		if (sc->scsi_done)
		if (sc->scsi_done) {
		FNIC_TRACE(fnic_fcpio_itmf_cmpl_handler,
		sc->device->host->host_no, id,
		sc,
		jiffies_to_msecs(jiffies - start_time),
		desc,
		(((u64)hdr_status << 40) \|
		(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)));
		sc->scsi_done(sc);
		}
		}

		} else if (id & FNIC_TAG_DEV_RST) {
		/* Completion of device reset */
		@@ -984,6 +1038,11 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
		if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
		spin_unlock_irqrestore(io_lock, flags);
		CMD_FLAGS(sc) \|= 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)));
		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
		"Terminate pending "
		"dev reset cmpl recd. id %d status %s\n",
		@@ -994,6 +1053,11 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
		if (CMD_FLAGS(sc) & 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)));
		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
		"dev reset cmpl recd after time out. "
		"id %d status %s\n",
		@@ -1142,10 +1206,20 @@ cleanup_scsi_cmd:
		" DID_TRANSPORT_DISRUPTED\n");

		/* Complete the command to SCSI */
		if (sc->scsi_done)
		if (sc->scsi_done) {
		FNIC_TRACE(fnic_cleanup_io,
		sc->device->host->host_no, i, sc,
		jiffies_to_msecs(jiffies - start_time),
		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)));

		sc->scsi_done(sc);
		}
		}
		}

		void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
		struct fcpio_host_req *desc)
		@@ -1195,9 +1269,18 @@ wq_copy_cleanup_scsi_cmd:
		FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host, "wq_copy_cleanup_handler:"
		" DID_NO_CONNECT\n");

		if (sc->scsi_done)
		if (sc->scsi_done) {
		FNIC_TRACE(fnic_wq_copy_cleanup_handler,
		sc->device->host->host_no, id, sc,
		jiffies_to_msecs(jiffies - start_time),
		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)));

		sc->scsi_done(sc);
		}
		}

		static inline int fnic_queue_abort_io_req(struct fnic *fnic, int tag,
		u32 task_req, u8 *fc_lun,
		@@ -1476,7 +1559,7 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
		{
		struct fc_lport *lp;
		struct fnic *fnic;
		struct fnic_io_req *io_req;
		struct fnic_io_req *io_req = NULL;
		struct fc_rport *rport;
		spinlock_t *io_lock;
		unsigned long flags;
		@@ -1503,7 +1586,6 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)

		CMD_FLAGS(sc) = FNIC_NO_FLAGS;


		if (lp->state != LPORT_ST_READY \|\| !(lp->link_up)) {
		ret = FAILED;
		goto fnic_abort_cmd_end;
		@@ -1621,6 +1703,14 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
		mempool_free(io_req, fnic->io_req_pool);

		fnic_abort_cmd_end:
		FNIC_TRACE(fnic_abort_cmd, sc->device->host->host_no,
		sc->request->tag, sc,
		jiffies_to_msecs(jiffies - start_time),
		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_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
		"Returning from abort cmd type %x %s\n", task_req,
		(ret == SUCCESS) ?
		@@ -1891,7 +1981,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
		{
		struct fc_lport *lp;
		struct fnic *fnic;
		struct fnic_io_req *io_req;
		struct fnic_io_req *io_req = NULL;
		struct fc_rport *rport;
		int status;
		int ret = FAILED;
		@@ -1899,7 +1989,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
		unsigned long flags;
		unsigned long start_time = 0;
		struct scsi_lun fc_lun;
		int tag;
		int tag = 0;
		DECLARE_COMPLETION_ONSTACK(tm_done);
		int tag_gen_flag = 0; /to track tags allocated by fnic driver/

		@@ -2094,6 +2184,14 @@ fnic_device_reset_clean:
		}

		fnic_device_reset_end:
		FNIC_TRACE(fnic_device_reset, sc->device->host->host_no,
		sc->request->tag, sc,
		jiffies_to_msecs(jiffies - start_time),
		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)));

		/* free tag if it is allocated */
		if (unlikely(tag_gen_flag))
		fnic_scsi_host_end_tag(fnic, sc);

Admin message