[SCSI] fnic: Fnic Statistics Collection

This feature gathers active and cumulative per fnic stats for io,
abort, terminate, reset, vlan discovery path and it also includes
various important stats for debugging issues. It also provided
debugfs and ioctl interface for user to retrieve these stats.
It also provides functionality to reset cumulative stats through
user interface.

Signed-off-by: Hiral Patel <hiralpat@cisco.com>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>

9 files changed, 971 insertions, 24 deletions

diff --git a/drivers/scsi/fnic/fnic.h b/drivers/scsi/fnic/fnic.h
index e4dd3d7cd236..db7a9506ccd3 100644
--- a/drivers/scsi/fnic/fnic.h
+++ b/drivers/scsi/fnic/fnic.h
@@ -27,6 +27,7 @@
 #include "fnic_io.h"
 #include "fnic_res.h"
 #include "fnic_trace.h"
+#include "fnic_stats.h"
 #include "vnic_dev.h"
 #include "vnic_wq.h"
 #include "vnic_rq.h"
@@ -232,6 +233,13 @@ struct fnic {
         unsigned int wq_count;
         unsigned int cq_count;
 
+        struct dentry *fnic_stats_debugfs_host;
+        struct dentry *fnic_stats_debugfs_file;
+        struct dentry *fnic_reset_debugfs_file;
+        unsigned int reset_stats;
+        atomic64_t io_cmpl_skip;
+        struct fnic_stats fnic_stats;
+
         u32 vlan_hw_insert:1;           /* let hw insert the tag */
         u32 in_remove:1;                /* fnic device in removal */
         u32 stop_rx_link_events:1;      /* stop proc. rx frames, link events */
diff --git a/drivers/scsi/fnic/fnic_debugfs.c b/drivers/scsi/fnic/fnic_debugfs.c
index cbcb0121c84d..b6073f875761 100644
--- a/drivers/scsi/fnic/fnic_debugfs.c
+++ b/drivers/scsi/fnic/fnic_debugfs.c
@@ -23,6 +23,58 @@
 static struct dentry *fnic_trace_debugfs_root;
 static struct dentry *fnic_trace_debugfs_file;
 static struct dentry *fnic_trace_enable;
+static struct dentry *fnic_stats_debugfs_root;
+
+/*
+ * fnic_debugfs_init - Initialize debugfs for fnic debug 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 and statistics directory for trace buffer and
+ * stats logging.
+ */
+int fnic_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;
+        }
+
+        if (!fnic_trace_debugfs_root) {
+                printk(KERN_DEBUG
+                        "fnic root directory doesn't exist in debugfs\n");
+                return rc;
+        }
+
+        fnic_stats_debugfs_root = debugfs_create_dir("statistics",
+                                                fnic_trace_debugfs_root);
+        if (!fnic_stats_debugfs_root) {
+                printk(KERN_DEBUG "Cannot create Statistics directory\n");
+                return rc;
+        }
+
+        rc = 0;
+        return rc;
+}
+
+/*
+ * fnic_debugfs_terminate - Tear down debugfs infrastructure
+ *
+ * Description:
+ * When Debugfs is configured this routine removes debugfs file system
+ * elements that are specific to fnic.
+ */
+void fnic_debugfs_terminate(void)
+{
+        debugfs_remove(fnic_stats_debugfs_root);
+        fnic_stats_debugfs_root = NULL;
+
+        debugfs_remove(fnic_trace_debugfs_root);
+        fnic_trace_debugfs_root = NULL;
+}
 
 /*
  * fnic_trace_ctrl_open - Open the trace_enable file
@@ -241,16 +293,16 @@ static const struct file_operations fnic_trace_debugfs_fops = {
  * 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.
+ * 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");
+                printk(KERN_DEBUG
+                        "FNIC Debugfs root directory doesn't exist\n");
                 return rc;
         }
         fnic_trace_enable = debugfs_create_file("tracing_enable",
@@ -259,8 +311,8 @@ int fnic_trace_debugfs_init(void)
                                           NULL, &fnic_trace_ctrl_fops);
 
         if (!fnic_trace_enable) {
-                printk(KERN_DEBUG "Cannot create trace_enable file"
-                                  " under debugfs");
+                printk(KERN_DEBUG
+                        "Cannot create trace_enable file under debugfs\n");
                 return rc;
         }
 
@@ -271,7 +323,8 @@ int fnic_trace_debugfs_init(void)
                                                   &fnic_trace_debugfs_fops);
 
         if (!fnic_trace_debugfs_file) {
-                printk(KERN_DEBUG "Cannot create trace file under debugfs");
+                printk(KERN_DEBUG
+                        "Cannot create trace file under debugfs\n");
                 return rc;
         }
         rc = 0;
@@ -295,8 +348,323 @@ void fnic_trace_debugfs_terminate(void)
                 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;
+}
+
+/*
+ * fnic_reset_stats_open - Open the reset_stats file
+ * @inode: The inode pointer.
+ * @file: The file pointer to attach the stats reset flag.
+ *
+ * Description:
+ * This routine opens a debugsfs file reset_stats and stores i_private data
+ * to debug structure to retrieve later for while performing other
+ * file oprations.
+ *
+ * Returns:
+ * This function returns zero if successful.
+ */
+static int fnic_reset_stats_open(struct inode *inode, struct file *file)
+{
+        struct stats_debug_info *debug;
+
+        debug = kzalloc(sizeof(struct stats_debug_info), GFP_KERNEL);
+        if (!debug)
+                return -ENOMEM;
+
+        debug->i_private = inode->i_private;
+
+        file->private_data = debug;
+
+        return 0;
+}
+
+/*
+ * fnic_reset_stats_read - Read a reset_stats 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 reset_stats
+ * 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_reset_stats_read(struct file *file,
+                                        char __user *ubuf,
+                                        size_t cnt, loff_t *ppos)
+{
+        struct stats_debug_info *debug = file->private_data;
+        struct fnic *fnic = (struct fnic *)debug->i_private;
+        char buf[64];
+        int len;
+
+        len = sprintf(buf, "%u\n", fnic->reset_stats);
+
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, len);
+}
+
+/*
+ * fnic_reset_stats_write - Write to reset_stats 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
+ * resets cumulative stats of fnic.
+ *
+ * Returns:
+ * This function returns the amount of data that was written.
+ */
+static ssize_t fnic_reset_stats_write(struct file *file,
+                                        const char __user *ubuf,
+                                        size_t cnt, loff_t *ppos)
+{
+        struct stats_debug_info *debug = file->private_data;
+        struct fnic *fnic = (struct fnic *)debug->i_private;
+        struct fnic_stats *stats = &fnic->fnic_stats;
+        u64 *io_stats_p = (u64 *)&stats->io_stats;
+        u64 *fw_stats_p = (u64 *)&stats->fw_stats;
+        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->reset_stats = val;
+
+        if (fnic->reset_stats) {
+                /* Skip variable is used to avoid descrepancies to Num IOs
+                 * and IO Completions stats. Skip incrementing No IO Compls
+                 * for pending active IOs after reset stats
+                 */
+                atomic64_set(&fnic->io_cmpl_skip,
+                        atomic64_read(&stats->io_stats.active_ios));
+                memset(&stats->abts_stats, 0, sizeof(struct abort_stats));
+                memset(&stats->term_stats, 0,
+                        sizeof(struct terminate_stats));
+                memset(&stats->reset_stats, 0, sizeof(struct reset_stats));
+                memset(&stats->misc_stats, 0, sizeof(struct misc_stats));
+                memset(&stats->vlan_stats, 0, sizeof(struct vlan_stats));
+                memset(io_stats_p+1, 0,
+                        sizeof(struct io_path_stats) - sizeof(u64));
+                memset(fw_stats_p+1, 0,
+                        sizeof(struct fw_stats) - sizeof(u64));
         }
+
+        (*ppos)++;
+        return cnt;
+}
+
+/*
+ * fnic_reset_stats_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_reset_stats_release(struct inode *inode,
+                                        struct file *file)
+{
+        struct stats_debug_info *debug = file->private_data;
+        kfree(debug);
+        return 0;
+}
+
+/*
+ * fnic_stats_debugfs_open - Open the stats file for specific host
+ * and get fnic stats.
+ * @inode: The inode pointer.
+ * @file: The file pointer to attach the specific host statistics.
+ *
+ * Description:
+ * This routine opens a debugsfs file stats of specific host and print
+ * fnic stats.
+ *
+ * Returns:
+ * This function returns zero if successful.
+ */
+static int fnic_stats_debugfs_open(struct inode *inode,
+                                        struct file *file)
+{
+        struct fnic *fnic = inode->i_private;
+        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
+        struct stats_debug_info *debug;
+        int buf_size = 2 * PAGE_SIZE;
+
+        debug = kzalloc(sizeof(struct stats_debug_info), GFP_KERNEL);
+        if (!debug)
+                return -ENOMEM;
+
+        debug->debug_buffer = vmalloc(buf_size);
+        if (!debug->debug_buffer) {
+                kfree(debug);
+                return -ENOMEM;
+        }
+
+        debug->buf_size = buf_size;
+        memset((void *)debug->debug_buffer, 0, buf_size);
+        debug->buffer_len = fnic_get_stats_data(debug, fnic_stats);
+
+        file->private_data = debug;
+
+        return 0;
+}
+
+/*
+ * fnic_stats_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_stats_debugfs_read(struct file *file,
+                                        char __user *ubuf,
+                                        size_t nbytes,
+                                        loff_t *pos)
+{
+        struct stats_debug_info *debug = file->private_data;
+        int rc = 0;
+        rc = simple_read_from_buffer(ubuf, nbytes, pos,
+                                        debug->debug_buffer,
+                                        debug->buffer_len);
+        return rc;
+}
+
+/*
+ * fnic_stats_stats_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_stats_debugfs_release(struct inode *inode,
+                                        struct file *file)
+{
+        struct stats_debug_info *debug = file->private_data;
+        vfree(debug->debug_buffer);
+        kfree(debug);
+        return 0;
+}
+
+static const struct file_operations fnic_stats_debugfs_fops = {
+        .owner = THIS_MODULE,
+        .open = fnic_stats_debugfs_open,
+        .read = fnic_stats_debugfs_read,
+        .release = fnic_stats_debugfs_release,
+};
+
+static const struct file_operations fnic_reset_debugfs_fops = {
+        .owner = THIS_MODULE,
+        .open = fnic_reset_stats_open,
+        .read = fnic_reset_stats_read,
+        .write = fnic_reset_stats_write,
+        .release = fnic_reset_stats_release,
+};
+
+/*
+ * fnic_stats_init - Initialize stats struct and create stats file per fnic
+ *
+ * Description:
+ * When Debugfs is configured this routine sets up the stats file per fnic
+ * It will create file stats and reset_stats under statistics/host# directory
+ * to log per fnic stats.
+ */
+int fnic_stats_debugfs_init(struct fnic *fnic)
+{
+        int rc = -1;
+        char name[16];
+
+        snprintf(name, sizeof(name), "host%d", fnic->lport->host->host_no);
+
+        if (!fnic_stats_debugfs_root) {
+                printk(KERN_DEBUG "fnic_stats root doesn't exist\n");
+                return rc;
+        }
+        fnic->fnic_stats_debugfs_host = debugfs_create_dir(name,
+                                                fnic_stats_debugfs_root);
+        if (!fnic->fnic_stats_debugfs_host) {
+                printk(KERN_DEBUG "Cannot create host directory\n");
+                return rc;
+        }
+
+        fnic->fnic_stats_debugfs_file = debugfs_create_file("stats",
+                                                S_IFREG|S_IRUGO|S_IWUSR,
+                                                fnic->fnic_stats_debugfs_host,
+                                                fnic,
+                                                &fnic_stats_debugfs_fops);
+        if (!fnic->fnic_stats_debugfs_file) {
+                printk(KERN_DEBUG "Cannot create host stats file\n");
+                return rc;
+        }
+
+        fnic->fnic_reset_debugfs_file = debugfs_create_file("reset_stats",
+                                                S_IFREG|S_IRUGO|S_IWUSR,
+                                                fnic->fnic_stats_debugfs_host,
+                                                fnic,
+                                                &fnic_reset_debugfs_fops);
+        if (!fnic->fnic_reset_debugfs_file) {
+                printk(KERN_DEBUG "Cannot create host stats file\n");
+                return rc;
+        }
+        rc = 0;
+        return rc;
+}
+
+/*
+ * fnic_stats_debugfs_remove - Tear down debugfs infrastructure of stats
+ *
+ * Description:
+ * When Debugfs is configured this routine removes debugfs file system
+ * elements that are specific to fnic stats.
+ */
+void fnic_stats_debugfs_remove(struct fnic *fnic)
+{
+        if (!fnic)
+                return;
+
+        debugfs_remove(fnic->fnic_stats_debugfs_file);
+        fnic->fnic_stats_debugfs_file = NULL;
+
+        debugfs_remove(fnic->fnic_reset_debugfs_file);
+        fnic->fnic_reset_debugfs_file = NULL;
+
+        debugfs_remove(fnic->fnic_stats_debugfs_host);
+        fnic->fnic_stats_debugfs_host = NULL;
 }
diff --git a/drivers/scsi/fnic/fnic_fcs.c b/drivers/scsi/fnic/fnic_fcs.c
index 006fa92a02df..60a1c50aa68f 100644
--- a/drivers/scsi/fnic/fnic_fcs.c
+++ b/drivers/scsi/fnic/fnic_fcs.c
@@ -302,6 +302,7 @@ static inline int is_fnic_fip_flogi_reject(struct fcoe_ctlr *fip,
 static void fnic_fcoe_send_vlan_req(struct fnic *fnic)
 {
         struct fcoe_ctlr *fip = &fnic->ctlr;
+        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
         struct sk_buff *skb;
         char *eth_fr;
         int fr_len;
@@ -337,6 +338,7 @@ static void fnic_fcoe_send_vlan_req(struct fnic *fnic)
         vlan->desc.wwnn.fd_desc.fip_dtype = FIP_DT_NAME;
         vlan->desc.wwnn.fd_desc.fip_dlen = sizeof(vlan->desc.wwnn) / FIP_BPW;
         put_unaligned_be64(fip->lp->wwnn, &vlan->desc.wwnn.fd_wwn);
+        atomic64_inc(&fnic_stats->vlan_stats.vlan_disc_reqs);
 
         skb_put(skb, sizeof(*vlan));
         skb->protocol = htons(ETH_P_FIP);
@@ -354,6 +356,7 @@ static void fnic_fcoe_process_vlan_resp(struct fnic *fnic, struct sk_buff *skb)
         struct fcoe_ctlr *fip = &fnic->ctlr;
         struct fip_header *fiph;
         struct fip_desc *desc;
+        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
         u16 vid;
         size_t rlen;
         size_t dlen;
@@ -402,6 +405,7 @@ static void fnic_fcoe_process_vlan_resp(struct fnic *fnic, struct sk_buff *skb)
         /* any VLAN descriptors present ? */
         if (list_empty(&fnic->vlans)) {
                 /* retry from timer */
+                atomic64_inc(&fnic_stats->vlan_stats.resp_withno_vlanID);
                 FNIC_FCS_DBG(KERN_INFO, fnic->lport->host,
                           "No VLAN descriptors in FIP VLAN response\n");
                 spin_unlock_irqrestore(&fnic->vlans_lock, flags);
@@ -533,6 +537,7 @@ drop:
 void fnic_handle_fip_frame(struct work_struct *work)
 {
         struct fnic *fnic = container_of(work, struct fnic, fip_frame_work);
+        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
         unsigned long flags;
         struct sk_buff *skb;
         struct ethhdr *eh;
@@ -567,6 +572,8 @@ void fnic_handle_fip_frame(struct work_struct *work)
                          * fcf's & restart from scratch
                          */
                         if (is_fnic_fip_flogi_reject(&fnic->ctlr, skb)) {
+                                atomic64_inc(
+                                        &fnic_stats->vlan_stats.flogi_rejects);
                                 shost_printk(KERN_INFO, fnic->lport->host,
                                           "Trigger a Link down - VLAN Disc\n");
                                 fcoe_ctlr_link_down(&fnic->ctlr);
@@ -753,6 +760,7 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
         struct fnic *fnic = vnic_dev_priv(rq->vdev);
         struct sk_buff *skb;
         struct fc_frame *fp;
+        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
         unsigned int eth_hdrs_stripped;
         u8 type, color, eop, sop, ingress_port, vlan_stripped;
         u8 fcoe = 0, fcoe_sof, fcoe_eof;
@@ -803,6 +811,7 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
                 eth_hdrs_stripped = 0;
                 skb_trim(skb, bytes_written);
                 if (!fcs_ok) {
+                        atomic64_inc(&fnic_stats->misc_stats.frame_errors);
                         FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
                                      "fcs error.  dropping packet.\n");
                         goto drop;
@@ -818,6 +827,7 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
         }
 
         if (!fcs_ok || packet_error || !fcoe_fc_crc_ok || fcoe_enc_error) {
+                atomic64_inc(&fnic_stats->misc_stats.frame_errors);
                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
                              "fnic rq_cmpl fcoe x%x fcsok x%x"
                              " pkterr x%x fcoe_fc_crc_ok x%x, fcoe_enc_err"
@@ -1205,6 +1215,7 @@ void fnic_handle_fip_timer(struct fnic *fnic)
 {
         unsigned long flags;
         struct fcoe_vlan *vlan;
+        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
         u64 sol_time;
 
         spin_lock_irqsave(&fnic->fnic_lock, flags);
@@ -1273,6 +1284,7 @@ void fnic_handle_fip_timer(struct fnic *fnic)
                         vlan->state = FIP_VLAN_SENT; /* sent now */
                 }
                 spin_unlock_irqrestore(&fnic->vlans_lock, flags);
+                atomic64_inc(&fnic_stats->vlan_stats.sol_expiry_count);
                 vlan->sol_count++;
                 sol_time = jiffies + msecs_to_jiffies
                                         (FCOE_CTLR_START_DELAY);
diff --git a/drivers/scsi/fnic/fnic_isr.c b/drivers/scsi/fnic/fnic_isr.c
index 5c1f223cabce..7d9b54ae7f62 100644
--- a/drivers/scsi/fnic/fnic_isr.c
+++ b/drivers/scsi/fnic/fnic_isr.c
@@ -37,6 +37,9 @@ static irqreturn_t fnic_isr_legacy(int irq, void *data)
         if (!pba)
                 return IRQ_NONE;
 
+        fnic->fnic_stats.misc_stats.last_isr_time = jiffies;
+        atomic64_inc(&fnic->fnic_stats.misc_stats.isr_count);
+
         if (pba & (1 << FNIC_INTX_NOTIFY)) {
                 vnic_intr_return_all_credits(&fnic->intr[FNIC_INTX_NOTIFY]);
                 fnic_handle_link_event(fnic);
@@ -66,6 +69,9 @@ static irqreturn_t fnic_isr_msi(int irq, void *data)
         struct fnic *fnic = data;
         unsigned long work_done = 0;
 
+        fnic->fnic_stats.misc_stats.last_isr_time = jiffies;
+        atomic64_inc(&fnic->fnic_stats.misc_stats.isr_count);
+
         work_done += fnic_wq_copy_cmpl_handler(fnic, -1);
         work_done += fnic_wq_cmpl_handler(fnic, -1);
         work_done += fnic_rq_cmpl_handler(fnic, -1);
@@ -83,6 +89,9 @@ static irqreturn_t fnic_isr_msix_rq(int irq, void *data)
         struct fnic *fnic = data;
         unsigned long rq_work_done = 0;
 
+        fnic->fnic_stats.misc_stats.last_isr_time = jiffies;
+        atomic64_inc(&fnic->fnic_stats.misc_stats.isr_count);
+
         rq_work_done = fnic_rq_cmpl_handler(fnic, -1);
         vnic_intr_return_credits(&fnic->intr[FNIC_MSIX_RQ],
                                  rq_work_done,
@@ -97,6 +106,9 @@ static irqreturn_t fnic_isr_msix_wq(int irq, void *data)
         struct fnic *fnic = data;
         unsigned long wq_work_done = 0;
 
+        fnic->fnic_stats.misc_stats.last_isr_time = jiffies;
+        atomic64_inc(&fnic->fnic_stats.misc_stats.isr_count);
+
         wq_work_done = fnic_wq_cmpl_handler(fnic, -1);
         vnic_intr_return_credits(&fnic->intr[FNIC_MSIX_WQ],
                                  wq_work_done,
@@ -110,6 +122,9 @@ static irqreturn_t fnic_isr_msix_wq_copy(int irq, void *data)
         struct fnic *fnic = data;
         unsigned long wq_copy_work_done = 0;
 
+        fnic->fnic_stats.misc_stats.last_isr_time = jiffies;
+        atomic64_inc(&fnic->fnic_stats.misc_stats.isr_count);
+
         wq_copy_work_done = fnic_wq_copy_cmpl_handler(fnic, -1);
         vnic_intr_return_credits(&fnic->intr[FNIC_MSIX_WQ_COPY],
                                  wq_copy_work_done,
@@ -122,6 +137,9 @@ static irqreturn_t fnic_isr_msix_err_notify(int irq, void *data)
 {
         struct fnic *fnic = data;
 
+        fnic->fnic_stats.misc_stats.last_isr_time = jiffies;
+        atomic64_inc(&fnic->fnic_stats.misc_stats.isr_count);
+
         vnic_intr_return_all_credits(&fnic->intr[FNIC_MSIX_ERR_NOTIFY]);
         fnic_log_q_error(fnic);
         fnic_handle_link_event(fnic);
diff --git a/drivers/scsi/fnic/fnic_main.c b/drivers/scsi/fnic/fnic_main.c
index bbf81ea3a252..be09b101b4a1 100644
--- a/drivers/scsi/fnic/fnic_main.c
+++ b/drivers/scsi/fnic/fnic_main.c
@@ -556,6 +556,13 @@ static int fnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         host->transportt = fnic_fc_transport;
 
+        err = fnic_stats_debugfs_init(fnic);
+        if (err) {
+                shost_printk(KERN_ERR, fnic->lport->host,
+                                "Failed to initialize debugfs for stats\n");
+                fnic_stats_debugfs_remove(fnic);
+        }
+
         /* Setup PCI resources */
         pci_set_drvdata(pdev, fnic);
 
@@ -917,6 +924,7 @@ err_out_release_regions:
 err_out_disable_device:
         pci_disable_device(pdev);
 err_out_free_hba:
+        fnic_stats_debugfs_remove(fnic);
         scsi_host_put(lp->host);
 err_out:
         return err;
@@ -969,6 +977,7 @@ static void fnic_remove(struct pci_dev *pdev)
 
         fcoe_ctlr_destroy(&fnic->ctlr);
         fc_lport_destroy(lp);
+        fnic_stats_debugfs_remove(fnic);
 
         /*
          * This stops the fnic device, masks all interrupts. Completed
@@ -1014,6 +1023,14 @@ static int __init fnic_init_module(void)
 
         printk(KERN_INFO PFX "%s, ver %s\n", DRV_DESCRIPTION, DRV_VERSION);
 
+        /* Create debugfs entries for fnic */
+        err = fnic_debugfs_init();
+        if (err < 0) {
+                printk(KERN_ERR PFX "Failed to create fnic directory "
+                                "for tracing and stats logging\n");
+                fnic_debugfs_terminate();
+        }
+
         /* Allocate memory for trace buffer */
         err = fnic_trace_buf_init();
         if (err < 0) {
@@ -1102,6 +1119,7 @@ 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();
+        fnic_debugfs_terminate();
         return err;
 }
 
@@ -1118,6 +1136,7 @@ static void __exit fnic_cleanup_module(void)
         kmem_cache_destroy(fnic_io_req_cache);
         fc_release_transport(fnic_fc_transport);
         fnic_trace_free();
+        fnic_debugfs_terminate();
 }
 
 module_init(fnic_init_module);
diff --git a/drivers/scsi/fnic/fnic_scsi.c b/drivers/scsi/fnic/fnic_scsi.c
index 50f3b327bd1e..0521436d05d6 100644
--- a/drivers/scsi/fnic/fnic_scsi.c
+++ b/drivers/scsi/fnic/fnic_scsi.c
@@ -226,15 +226,23 @@ int fnic_fw_reset_handler(struct fnic *fnic)
 
         if (!vnic_wq_copy_desc_avail(wq))
                 ret = -EAGAIN;
-        else
+        else {
                 fnic_queue_wq_copy_desc_fw_reset(wq, SCSI_NO_TAG);
+                atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
+                if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
+                          atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
+                        atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
+                                atomic64_read(
+                                  &fnic->fnic_stats.fw_stats.active_fw_reqs));
+        }
 
         spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
 
-        if (!ret)
+        if (!ret) {
+                atomic64_inc(&fnic->fnic_stats.reset_stats.fw_resets);
                 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
                               "Issued fw reset\n");
-        else {
+        } else {
                 fnic_clear_state_flags(fnic, FNIC_FLAGS_FWRESET);
                 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
                               "Failed to issue fw reset\n");
@@ -291,6 +299,12 @@ int fnic_flogi_reg_handler(struct fnic *fnic, u32 fc_id)
                               fc_id, fnic->ctlr.map_dest, gw_mac);
         }
 
+        atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
+        if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
+                  atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
+                atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
+                  atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs));
+
 flogi_reg_ioreq_end:
         spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
         return ret;
@@ -310,6 +324,7 @@ static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
         struct fc_rport *rport = starget_to_rport(scsi_target(sc->device));
         struct fc_rport_libfc_priv *rp = rport->dd_data;
         struct host_sg_desc *desc;
+        struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
         u8 pri_tag = 0;
         unsigned int i;
         unsigned long intr_flags;
@@ -358,6 +373,7 @@ static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
                 spin_unlock_irqrestore(&fnic->wq_copy_lock[0], intr_flags);
                 FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
                           "fnic_queue_wq_copy_desc failure - no descriptors\n");
+                atomic64_inc(&misc_stats->io_cpwq_alloc_failures);
                 return SCSI_MLQUEUE_HOST_BUSY;
         }
 
@@ -386,6 +402,12 @@ static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
                                          rport->maxframe_size, rp->r_a_tov,
                                          rp->e_d_tov);
 
+        atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
+        if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
+                  atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
+                atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
+                  atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs));
+
         spin_unlock_irqrestore(&fnic->wq_copy_lock[0], intr_flags);
         return 0;
 }
@@ -401,6 +423,7 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi_
         struct fc_rport *rport;
         struct fnic_io_req *io_req = NULL;
         struct fnic *fnic = lport_priv(lp);
+        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
         struct vnic_wq_copy *wq;
         int ret;
         u64 cmd_trace;
@@ -414,6 +437,7 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi_
         rport = starget_to_rport(scsi_target(sc->device));
         ret = fc_remote_port_chkready(rport);
         if (ret) {
+                atomic64_inc(&fnic_stats->misc_stats.rport_not_ready);
                 sc->result = ret;
                 done(sc);
                 return 0;
@@ -436,6 +460,7 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi_
         /* Get a new io_req for this SCSI IO */
         io_req = mempool_alloc(fnic->io_req_pool, GFP_ATOMIC);
         if (!io_req) {
+                atomic64_inc(&fnic_stats->io_stats.alloc_failures);
                 ret = SCSI_MLQUEUE_HOST_BUSY;
                 goto out;
         }
@@ -462,6 +487,7 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi_
                         mempool_alloc(fnic->io_sgl_pool[io_req->sgl_type],
                                       GFP_ATOMIC);
                 if (!io_req->sgl_list) {
+                        atomic64_inc(&fnic_stats->io_stats.alloc_failures);
                         ret = SCSI_MLQUEUE_HOST_BUSY;
                         scsi_dma_unmap(sc);
                         mempool_free(io_req, fnic->io_req_pool);
@@ -509,6 +535,13 @@ static int fnic_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi_
                         mempool_free(io_req, fnic->io_req_pool);
                 }
         } else {
+                atomic64_inc(&fnic_stats->io_stats.active_ios);
+                atomic64_inc(&fnic_stats->io_stats.num_ios);
+                if (atomic64_read(&fnic_stats->io_stats.active_ios) >
+                          atomic64_read(&fnic_stats->io_stats.max_active_ios))
+                        atomic64_set(&fnic_stats->io_stats.max_active_ios,
+                             atomic64_read(&fnic_stats->io_stats.active_ios));
+
                 /* REVISIT: Use per IO lock in the final code */
                 CMD_FLAGS(sc) |= FNIC_IO_ISSUED;
         }
@@ -542,12 +575,18 @@ static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic *fnic,
         struct fcpio_tag tag;
         int ret = 0;
         unsigned long flags;
+        struct reset_stats *reset_stats = &fnic->fnic_stats.reset_stats;
 
         fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
 
+        atomic64_inc(&reset_stats->fw_reset_completions);
+
         /* Clean up all outstanding io requests */
         fnic_cleanup_io(fnic, SCSI_NO_TAG);
 
+        atomic64_set(&fnic->fnic_stats.fw_stats.active_fw_reqs, 0);
+        atomic64_set(&fnic->fnic_stats.io_stats.active_ios, 0);
+
         spin_lock_irqsave(&fnic->fnic_lock, flags);
 
         /* fnic should be in FC_TRANS_ETH_MODE */
@@ -571,6 +610,7 @@ static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic *fnic,
                          * reset the firmware. Free the cached flogi
                          */
                         fnic->state = FNIC_IN_FC_MODE;
+                        atomic64_inc(&reset_stats->fw_reset_failures);
                         ret = -1;
                 }
         } else {
@@ -578,6 +618,7 @@ static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic *fnic,
                               fnic->lport->host,
                               "Unexpected state %s while processing"
                               " reset cmpl\n", fnic_state_to_str(fnic->state));
+                atomic64_inc(&reset_stats->fw_reset_failures);
                 ret = -1;
         }
 
@@ -701,10 +742,14 @@ static inline void fnic_fcpio_ack_handler(struct fnic *fnic,
         wq = &fnic->wq_copy[cq_index - fnic->raw_wq_count - fnic->rq_count];
         spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
 
+        fnic->fnic_stats.misc_stats.last_ack_time = jiffies;
         if (is_ack_index_in_range(wq, request_out)) {
                 fnic->fw_ack_index[0] = request_out;
                 fnic->fw_ack_recd[0] = 1;
-        }
+        } else
+                atomic64_inc(
+                        &fnic->fnic_stats.misc_stats.ack_index_out_of_range);
+
         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],
@@ -726,6 +771,7 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
         struct fcpio_icmnd_cmpl *icmnd_cmpl;
         struct fnic_io_req *io_req;
         struct scsi_cmnd *sc;
+        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
         unsigned long flags;
         spinlock_t *io_lock;
         u64 cmd_trace;
@@ -746,6 +792,7 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
         sc = scsi_host_find_tag(fnic->lport->host, id);
         WARN_ON_ONCE(!sc);
         if (!sc) {
+                atomic64_inc(&fnic_stats->io_stats.sc_null);
                 shost_printk(KERN_ERR, fnic->lport->host,
                           "icmnd_cmpl sc is null - "
                           "hdr status = %s tag = 0x%x desc = 0x%p\n",
@@ -766,6 +813,7 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
         io_req = (struct fnic_io_req *)CMD_SP(sc);
         WARN_ON_ONCE(!io_req);
         if (!io_req) {
+                atomic64_inc(&fnic_stats->io_stats.ioreq_null);
                 CMD_FLAGS(sc) |= FNIC_IO_REQ_NULL;
                 spin_unlock_irqrestore(io_lock, flags);
                 shost_printk(KERN_ERR, fnic->lport->host,
@@ -824,31 +872,54 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
                 if (icmnd_cmpl->flags & FCPIO_ICMND_CMPL_RESID_UNDER)
                         xfer_len -= icmnd_cmpl->residual;
 
+                if (icmnd_cmpl->scsi_status == SAM_STAT_TASK_SET_FULL)
+                        atomic64_inc(&fnic_stats->misc_stats.queue_fulls);
                 break;
 
         case FCPIO_TIMEOUT:          /* request was timed out */
+                atomic64_inc(&fnic_stats->misc_stats.fcpio_timeout);
                 sc->result = (DID_TIME_OUT << 16) | icmnd_cmpl->scsi_status;
                 break;
 
         case FCPIO_ABORTED:          /* request was aborted */
+                atomic64_inc(&fnic_stats->misc_stats.fcpio_aborted);
                 sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
                 break;
 
         case FCPIO_DATA_CNT_MISMATCH: /* recv/sent more/less data than exp. */
+                atomic64_inc(&fnic_stats->misc_stats.data_count_mismatch);
                 scsi_set_resid(sc, icmnd_cmpl->residual);
                 sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
                 break;
 
         case FCPIO_OUT_OF_RESOURCE:  /* out of resources to complete request */
+                atomic64_inc(&fnic_stats->fw_stats.fw_out_of_resources);
                 sc->result = (DID_REQUEUE << 16) | icmnd_cmpl->scsi_status;
                 break;
-        case FCPIO_INVALID_HEADER:   /* header contains invalid data */
-        case FCPIO_INVALID_PARAM:    /* some parameter in request invalid */
-        case FCPIO_REQ_NOT_SUPPORTED:/* request type is not supported */
+
         case FCPIO_IO_NOT_FOUND:     /* requested I/O was not found */
+                atomic64_inc(&fnic_stats->io_stats.io_not_found);
+                sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
+                break;
+
         case FCPIO_SGL_INVALID:      /* request was aborted due to sgl error */
-        case FCPIO_MSS_INVALID:      /* request was aborted due to mss error */
+                atomic64_inc(&fnic_stats->misc_stats.sgl_invalid);
+                sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
+                break;
+
         case FCPIO_FW_ERR:           /* request was terminated due fw error */
+                atomic64_inc(&fnic_stats->fw_stats.io_fw_errs);
+                sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
+                break;
+
+        case FCPIO_MSS_INVALID:      /* request was aborted due to mss error */
+                atomic64_inc(&fnic_stats->misc_stats.mss_invalid);
+                sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
+                break;
+
+        case FCPIO_INVALID_HEADER:   /* header contains invalid data */
+        case FCPIO_INVALID_PARAM:    /* some parameter in request invalid */
+        case FCPIO_REQ_NOT_SUPPORTED:/* request type is not supported */
         default:
                 shost_printk(KERN_ERR, fnic->lport->host, "hdr status = %s\n",
                              fnic_fcpio_status_to_str(hdr_status));
@@ -856,6 +927,11 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
                 break;
         }
 
+        if (hdr_status != FCPIO_SUCCESS) {
+                atomic64_inc(&fnic_stats->io_stats.io_failures);
+                shost_printk(KERN_ERR, fnic->lport->host, "hdr status = %s\n",
+                             fnic_fcpio_status_to_str(hdr_status));
+        }
         /* Break link with the SCSI command */
         CMD_SP(sc) = NULL;
         CMD_FLAGS(sc) |= FNIC_IO_DONE;
@@ -889,6 +965,12 @@ static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
         } else
                 fnic->lport->host_stats.fcp_control_requests++;
 
+        atomic64_dec(&fnic_stats->io_stats.active_ios);
+        if (atomic64_read(&fnic->io_cmpl_skip))
+                atomic64_dec(&fnic->io_cmpl_skip);
+        else
+                atomic64_inc(&fnic_stats->io_stats.io_completions);
+
         /* Call SCSI completion function to complete the IO */
         if (sc->scsi_done)
                 sc->scsi_done(sc);
@@ -906,6 +988,10 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
         u32 id;
         struct scsi_cmnd *sc;
         struct fnic_io_req *io_req;
+        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
+        struct abort_stats *abts_stats = &fnic->fnic_stats.abts_stats;
+        struct terminate_stats *term_stats = &fnic->fnic_stats.term_stats;
+        struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
         unsigned long flags;
         spinlock_t *io_lock;
         unsigned long start_time;
@@ -923,6 +1009,7 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
         sc = scsi_host_find_tag(fnic->lport->host, id & FNIC_TAG_MASK);
         WARN_ON_ONCE(!sc);
         if (!sc) {
+                atomic64_inc(&fnic_stats->io_stats.sc_null);
                 shost_printk(KERN_ERR, fnic->lport->host,
                           "itmf_cmpl sc is null - hdr status = %s tag = 0x%x\n",
                           fnic_fcpio_status_to_str(hdr_status), id);
@@ -933,6 +1020,7 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
         io_req = (struct fnic_io_req *)CMD_SP(sc);
         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;
                 shost_printk(KERN_ERR, fnic->lport->host,
@@ -957,6 +1045,31 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
                 spin_unlock_irqrestore(io_lock, flags);
         } else if (id & FNIC_TAG_ABORT) {
                 /* Completion of abort cmd */
+                switch (hdr_status) {
+                case FCPIO_SUCCESS:
+                        break;
+                case FCPIO_TIMEOUT:
+                        if (CMD_FLAGS(sc) & FNIC_IO_ABTS_ISSUED)
+                                atomic64_inc(&abts_stats->abort_fw_timeouts);
+                        else
+                                atomic64_inc(
+                                        &term_stats->terminate_fw_timeouts);
+                        break;
+                case FCPIO_IO_NOT_FOUND:
+                        if (CMD_FLAGS(sc) & 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)
+                                atomic64_inc(&abts_stats->abort_failures);
+                        else
+                                atomic64_inc(
+                                        &term_stats->terminate_failures);
+                        break;
+                }
                 if (CMD_STATE(sc) != FNIC_IOREQ_ABTS_PENDING) {
                         /* This is a late completion. Ignore it */
                         spin_unlock_irqrestore(io_lock, flags);
@@ -964,6 +1077,16 @@ static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
                 }
                 CMD_ABTS_STATUS(sc) = hdr_status;
                 CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_DONE;
+
+                atomic64_dec(&fnic_stats->io_stats.active_ios);
+                if (atomic64_read(&fnic->io_cmpl_skip))
+                        atomic64_dec(&fnic->io_cmpl_skip);
+                else
+                        atomic64_inc(&fnic_stats->io_stats.io_completions);
+
+                if (!(CMD_FLAGS(sc) & (FNIC_IO_ABORTED | FNIC_IO_DONE)))
+                        atomic64_inc(&misc_stats->no_icmnd_itmf_cmpls);
+
                 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
                               "abts cmpl recd. id %d status %s\n",
                               (int)(id & FNIC_TAG_MASK),
@@ -1067,6 +1190,18 @@ static int fnic_fcpio_cmpl_handler(struct vnic_dev *vdev,
         struct fnic *fnic = vnic_dev_priv(vdev);
 
         switch (desc->hdr.type) {
+        case FCPIO_ICMND_CMPL: /* fw completed a command */
+        case FCPIO_ITMF_CMPL: /* fw completed itmf (abort cmd, lun reset)*/
+        case FCPIO_FLOGI_REG_CMPL: /* fw completed flogi_reg */
+        case FCPIO_FLOGI_FIP_REG_CMPL: /* fw completed flogi_fip_reg */
+        case FCPIO_RESET_CMPL: /* fw completed reset */
+                atomic64_dec(&fnic->fnic_stats.fw_stats.active_fw_reqs);
+                break;
+        default:
+                break;
+        }
+
+        switch (desc->hdr.type) {
         case FCPIO_ACK: /* fw copied copy wq desc to its queue */
                 fnic_fcpio_ack_handler(fnic, cq_index, desc);
                 break;
@@ -1126,6 +1261,7 @@ static void fnic_cleanup_io(struct fnic *fnic, int exclude_id)
         struct scsi_cmnd *sc;
         spinlock_t *io_lock;
         unsigned long start_time = 0;
+        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
 
         for (i = 0; i < fnic->fnic_max_tag_id; i++) {
                 if (i == exclude_id)
@@ -1179,6 +1315,11 @@ cleanup_scsi_cmd:
                 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host, "fnic_cleanup_io:"
                               " DID_TRANSPORT_DISRUPTED\n");
 
+                if (atomic64_read(&fnic->io_cmpl_skip))
+                        atomic64_dec(&fnic->io_cmpl_skip);
+                else
+                        atomic64_inc(&fnic_stats->io_stats.io_completions);
+
                 /* Complete the command to SCSI */
                 if (sc->scsi_done) {
                         FNIC_TRACE(fnic_cleanup_io,
@@ -1262,6 +1403,7 @@ static inline int fnic_queue_abort_io_req(struct fnic *fnic, int tag,
 {
         struct vnic_wq_copy *wq = &fnic->wq_copy[0];
         struct Scsi_Host *host = fnic->lport->host;
+        struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
         unsigned long flags;
 
         spin_lock_irqsave(host->host_lock, flags);
@@ -1283,12 +1425,19 @@ static inline int fnic_queue_abort_io_req(struct fnic *fnic, int tag,
                 atomic_dec(&fnic->in_flight);
                 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
                         "fnic_queue_abort_io_req: failure: no descriptors\n");
+                atomic64_inc(&misc_stats->abts_cpwq_alloc_failures);
                 return 1;
         }
         fnic_queue_wq_copy_desc_itmf(wq, tag | FNIC_TAG_ABORT,
                                      0, task_req, tag, fc_lun, io_req->port_id,
                                      fnic->config.ra_tov, fnic->config.ed_tov);
 
+        atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
+        if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
+                  atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
+                atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
+                  atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs));
+
         spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
         atomic_dec(&fnic->in_flight);
 
@@ -1299,10 +1448,13 @@ static void fnic_rport_exch_reset(struct fnic *fnic, u32 port_id)
 {
         int tag;
         int abt_tag;
+        int term_cnt = 0;
         struct fnic_io_req *io_req;
         spinlock_t *io_lock;
         unsigned long flags;
         struct scsi_cmnd *sc;
+        struct reset_stats *reset_stats = &fnic->fnic_stats.reset_stats;
+        struct terminate_stats *term_stats = &fnic->fnic_stats.term_stats;
         struct scsi_lun fc_lun;
         enum fnic_ioreq_state old_ioreq_state;
 
@@ -1366,6 +1518,7 @@ static void fnic_rport_exch_reset(struct fnic *fnic, u32 port_id)
                 CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
                 CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
                 if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
+                        atomic64_inc(&reset_stats->device_reset_terminates);
                         abt_tag = (tag | FNIC_TAG_DEV_RST);
                         FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
                         "fnic_rport_exch_reset dev rst sc 0x%p\n",
@@ -1402,8 +1555,12 @@ static void fnic_rport_exch_reset(struct fnic *fnic, u32 port_id)
                         else
                                 CMD_FLAGS(sc) |= FNIC_IO_INTERNAL_TERM_ISSUED;
                         spin_unlock_irqrestore(io_lock, flags);
+                        atomic64_inc(&term_stats->terminates);
+                        term_cnt++;
                 }
         }
+        if (term_cnt > atomic64_read(&term_stats->max_terminates))
+                atomic64_set(&term_stats->max_terminates, term_cnt);
 
 }
 
@@ -1411,6 +1568,7 @@ void fnic_terminate_rport_io(struct fc_rport *rport)
 {
         int tag;
         int abt_tag;
+        int term_cnt = 0;
         struct fnic_io_req *io_req;
         spinlock_t *io_lock;
         unsigned long flags;
@@ -1420,6 +1578,8 @@ void fnic_terminate_rport_io(struct fc_rport *rport)
         struct fc_lport *lport;
         struct fnic *fnic;
         struct fc_rport *cmd_rport;
+        struct reset_stats *reset_stats;
+        struct terminate_stats *term_stats;
         enum fnic_ioreq_state old_ioreq_state;
 
         if (!rport) {
@@ -1448,6 +1608,9 @@ void fnic_terminate_rport_io(struct fc_rport *rport)
         if (fnic->in_remove)
                 return;
 
+        reset_stats = &fnic->fnic_stats.reset_stats;
+        term_stats = &fnic->fnic_stats.term_stats;
+
         for (tag = 0; tag < fnic->fnic_max_tag_id; tag++) {
                 abt_tag = tag;
                 io_lock = fnic_io_lock_tag(fnic, tag);
@@ -1504,6 +1667,7 @@ void fnic_terminate_rport_io(struct fc_rport *rport)
                 CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
                 CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
                 if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
+                        atomic64_inc(&reset_stats->device_reset_terminates);
                         abt_tag = (tag | FNIC_TAG_DEV_RST);
                         FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
                         "fnic_terminate_rport_io dev rst sc 0x%p\n", sc);
@@ -1540,8 +1704,12 @@ void fnic_terminate_rport_io(struct fc_rport *rport)
                         else
                                 CMD_FLAGS(sc) |= FNIC_IO_INTERNAL_TERM_ISSUED;
                         spin_unlock_irqrestore(io_lock, flags);
+                        atomic64_inc(&term_stats->terminates);
+                        term_cnt++;
                 }
         }
+        if (term_cnt > atomic64_read(&term_stats->max_terminates))
+                atomic64_set(&term_stats->max_terminates, term_cnt);
 
 }
 
@@ -1562,6 +1730,9 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
         int ret = SUCCESS;
         u32 task_req = 0;
         struct scsi_lun fc_lun;
+        struct fnic_stats *fnic_stats;
+        struct abort_stats *abts_stats;
+        struct terminate_stats *term_stats;
         int tag;
         DECLARE_COMPLETION_ONSTACK(tm_done);
 
@@ -1572,6 +1743,10 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
         lp = shost_priv(sc->device->host);
 
         fnic = lport_priv(lp);
+        fnic_stats = &fnic->fnic_stats;
+        abts_stats = &fnic->fnic_stats.abts_stats;
+        term_stats = &fnic->fnic_stats.term_stats;
+
         rport = starget_to_rport(scsi_target(sc->device));
         tag = sc->request->tag;
         FNIC_SCSI_DBG(KERN_DEBUG,
@@ -1630,8 +1805,10 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
          */
         if (fc_remote_port_chkready(rport) == 0)
                 task_req = FCPIO_ITMF_ABT_TASK;
-        else
+        else {
+                atomic64_inc(&fnic_stats->misc_stats.rport_not_ready);
                 task_req = FCPIO_ITMF_ABT_TASK_TERM;
+        }
 
         /* Now queue the abort command to firmware */
         int_to_scsilun(sc->device->lun, &fc_lun);
@@ -1646,10 +1823,13 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
                 ret = FAILED;
                 goto fnic_abort_cmd_end;
         }
-        if (task_req == FCPIO_ITMF_ABT_TASK)
+        if (task_req == FCPIO_ITMF_ABT_TASK) {
                 CMD_FLAGS(sc) |= FNIC_IO_ABTS_ISSUED;
-        else
+                atomic64_inc(&fnic_stats->abts_stats.aborts);
+        } else {
                 CMD_FLAGS(sc) |= FNIC_IO_TERM_ISSUED;
+                atomic64_inc(&fnic_stats->term_stats.terminates);
+        }
 
         /*
          * We queued an abort IO, wait for its completion.
@@ -1667,6 +1847,7 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
 
         io_req = (struct fnic_io_req *)CMD_SP(sc);
         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;
                 ret = FAILED;
@@ -1677,6 +1858,15 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
         /* fw did not complete abort, timed out */
         if (CMD_ABTS_STATUS(sc) == FCPIO_INVALID_CODE) {
                 spin_unlock_irqrestore(io_lock, flags);
+                if (task_req == FCPIO_ITMF_ABT_TASK) {
+                        FNIC_SCSI_DBG(KERN_INFO,
+                                fnic->lport->host, "Abort Driver Timeout\n");
+                        atomic64_inc(&abts_stats->abort_drv_timeouts);
+                } else {
+                        FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
+                                "Terminate Driver Timeout\n");
+                        atomic64_inc(&term_stats->terminate_drv_timeouts);
+                }
                 CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_TIMED_OUT;
                 ret = FAILED;
                 goto fnic_abort_cmd_end;
@@ -1721,6 +1911,7 @@ static inline int fnic_queue_dr_io_req(struct fnic *fnic,
 {
         struct vnic_wq_copy *wq = &fnic->wq_copy[0];
         struct Scsi_Host *host = fnic->lport->host;
+        struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
         struct scsi_lun fc_lun;
         int ret = 0;
         unsigned long intr_flags;
@@ -1742,6 +1933,7 @@ static inline int fnic_queue_dr_io_req(struct fnic *fnic,
         if (!vnic_wq_copy_desc_avail(wq)) {
                 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
                           "queue_dr_io_req failure - no descriptors\n");
+                atomic64_inc(&misc_stats->devrst_cpwq_alloc_failures);
                 ret = -EAGAIN;
                 goto lr_io_req_end;
         }
@@ -1754,6 +1946,12 @@ static inline int fnic_queue_dr_io_req(struct fnic *fnic,
                                      fc_lun.scsi_lun, io_req->port_id,
                                      fnic->config.ra_tov, fnic->config.ed_tov);
 
+        atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
+        if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
+                  atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
+                atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
+                  atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs));
+
 lr_io_req_end:
         spin_unlock_irqrestore(&fnic->wq_copy_lock[0], intr_flags);
         atomic_dec(&fnic->in_flight);
@@ -1988,6 +2186,8 @@ int fnic_device_reset(struct scsi_cmnd *sc)
         unsigned long flags;
         unsigned long start_time = 0;
         struct scsi_lun fc_lun;
+        struct fnic_stats *fnic_stats;
+        struct reset_stats *reset_stats;
         int tag = 0;
         DECLARE_COMPLETION_ONSTACK(tm_done);
         int tag_gen_flag = 0;   /*to track tags allocated by fnic driver*/
@@ -1999,6 +2199,10 @@ int fnic_device_reset(struct scsi_cmnd *sc)
         lp = shost_priv(sc->device->host);
 
         fnic = lport_priv(lp);
+        fnic_stats = &fnic->fnic_stats;
+        reset_stats = &fnic->fnic_stats.reset_stats;
+
+        atomic64_inc(&reset_stats->device_resets);
 
         rport = starget_to_rport(scsi_target(sc->device));
         FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
@@ -2009,8 +2213,10 @@ int fnic_device_reset(struct scsi_cmnd *sc)
                 goto fnic_device_reset_end;
 
         /* Check if remote port up */
-        if (fc_remote_port_chkready(rport))
+        if (fc_remote_port_chkready(rport)) {
+                atomic64_inc(&fnic_stats->misc_stats.rport_not_ready);
                 goto fnic_device_reset_end;
+        }
 
         CMD_FLAGS(sc) = FNIC_DEVICE_RESET;
         /* Allocate tag if not present */
@@ -2086,6 +2292,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
          * gets cleaned up during higher levels of EH
          */
         if (status == FCPIO_INVALID_CODE) {
+                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;
@@ -2199,6 +2406,10 @@ fnic_device_reset_end:
                       "Returning from device reset %s\n",
                       (ret == SUCCESS) ?
                       "SUCCESS" : "FAILED");
+
+        if (ret == FAILED)
+                atomic64_inc(&reset_stats->device_reset_failures);
+
         return ret;
 }
 
@@ -2208,13 +2419,17 @@ int fnic_reset(struct Scsi_Host *shost)
         struct fc_lport *lp;
         struct fnic *fnic;
         int ret = 0;
+        struct reset_stats *reset_stats;
 
         lp = shost_priv(shost);
         fnic = lport_priv(lp);
+        reset_stats = &fnic->fnic_stats.reset_stats;
 
         FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
                       "fnic_reset called\n");
 
+        atomic64_inc(&reset_stats->fnic_resets);
+
         /*
          * Reset local port, this will clean up libFC exchanges,
          * reset remote port sessions, and if link is up, begin flogi
@@ -2226,6 +2441,11 @@ int fnic_reset(struct Scsi_Host *shost)
                       (ret == 0) ?
                       "SUCCESS" : "FAILED");
 
+        if (ret == 0)
+                atomic64_inc(&reset_stats->fnic_reset_completions);
+        else
+                atomic64_inc(&reset_stats->fnic_reset_failures);
+
         return ret;
 }
 
diff --git a/drivers/scsi/fnic/fnic_stats.h b/drivers/scsi/fnic/fnic_stats.h
new file mode 100644
index 000000000000..540cceb843cd
--- /dev/null
+++ b/drivers/scsi/fnic/fnic_stats.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2013 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.
+ */
+#ifndef _FNIC_STATS_H_
+#define _FNIC_STATS_H_
+struct io_path_stats {
+        atomic64_t active_ios;
+        atomic64_t max_active_ios;
+        atomic64_t io_completions;
+        atomic64_t io_failures;
+        atomic64_t ioreq_null;
+        atomic64_t alloc_failures;
+        atomic64_t sc_null;
+        atomic64_t io_not_found;
+        atomic64_t num_ios;
+};
+
+struct abort_stats {
+        atomic64_t aborts;
+        atomic64_t abort_failures;
+        atomic64_t abort_drv_timeouts;
+        atomic64_t abort_fw_timeouts;
+        atomic64_t abort_io_not_found;
+};
+
+struct terminate_stats {
+        atomic64_t terminates;
+        atomic64_t max_terminates;
+        atomic64_t terminate_drv_timeouts;
+        atomic64_t terminate_fw_timeouts;
+        atomic64_t terminate_io_not_found;
+        atomic64_t terminate_failures;
+};
+
+struct reset_stats {
+        atomic64_t device_resets;
+        atomic64_t device_reset_failures;
+        atomic64_t device_reset_aborts;
+        atomic64_t device_reset_timeouts;
+        atomic64_t device_reset_terminates;
+        atomic64_t fw_resets;
+        atomic64_t fw_reset_completions;
+        atomic64_t fw_reset_failures;
+        atomic64_t fnic_resets;
+        atomic64_t fnic_reset_completions;
+        atomic64_t fnic_reset_failures;
+};
+
+struct fw_stats {
+        atomic64_t active_fw_reqs;
+        atomic64_t max_fw_reqs;
+        atomic64_t fw_out_of_resources;
+        atomic64_t io_fw_errs;
+};
+
+struct vlan_stats {
+        atomic64_t vlan_disc_reqs;
+        atomic64_t resp_withno_vlanID;
+        atomic64_t sol_expiry_count;
+        atomic64_t flogi_rejects;
+};
+
+struct misc_stats {
+        u64 last_isr_time;
+        u64 last_ack_time;
+        atomic64_t isr_count;
+        atomic64_t max_cq_entries;
+        atomic64_t ack_index_out_of_range;
+        atomic64_t data_count_mismatch;
+        atomic64_t fcpio_timeout;
+        atomic64_t fcpio_aborted;
+        atomic64_t sgl_invalid;
+        atomic64_t mss_invalid;
+        atomic64_t abts_cpwq_alloc_failures;
+        atomic64_t devrst_cpwq_alloc_failures;
+        atomic64_t io_cpwq_alloc_failures;
+        atomic64_t no_icmnd_itmf_cmpls;
+        atomic64_t queue_fulls;
+        atomic64_t rport_not_ready;
+        atomic64_t frame_errors;
+};
+
+struct fnic_stats {
+        struct io_path_stats io_stats;
+        struct abort_stats abts_stats;
+        struct terminate_stats term_stats;
+        struct reset_stats reset_stats;
+        struct fw_stats fw_stats;
+        struct vlan_stats vlan_stats;
+        struct misc_stats misc_stats;
+};
+
+struct stats_debug_info {
+        char *debug_buffer;
+        void *i_private;
+        int buf_size;
+        int buffer_len;
+};
+
+int fnic_get_stats_data(struct stats_debug_info *, struct fnic_stats *);
+int fnic_stats_debugfs_init(struct fnic *);
+void fnic_stats_debugfs_remove(struct fnic *);
+#endif /* _FNIC_STATS_H_ */
diff --git a/drivers/scsi/fnic/fnic_trace.c b/drivers/scsi/fnic/fnic_trace.c
index 23a60e3d8527..e002e7187dc0 100644
--- a/drivers/scsi/fnic/fnic_trace.c
+++ b/drivers/scsi/fnic/fnic_trace.c
@@ -189,6 +189,191 @@ int fnic_get_trace_data(fnic_dbgfs_t *fnic_dbgfs_prt)
 }
 
 /*
+ * fnic_get_stats_data - Copy fnic stats buffer to a memory file
+ * @fnic_dbgfs_t: pointer to debugfs fnic stats buffer
+ *
+ * Description:
+ * This routine gathers the fnic stats debugfs data from the fnic_stats struct
+ * and dumps it to stats_debug_info.
+ *
+ * Return Value:
+ * This routine returns the amount of bytes that were dumped into
+ * stats_debug_info
+ */
+int fnic_get_stats_data(struct stats_debug_info *debug,
+                        struct fnic_stats *stats)
+{
+        int len = 0;
+        int buf_size = debug->buf_size;
+        struct timespec val1, val2;
+
+        len = snprintf(debug->debug_buffer + len, buf_size - len,
+                  "------------------------------------------\n"
+                  "\t\tIO Statistics\n"
+                  "------------------------------------------\n");
+        len += snprintf(debug->debug_buffer + len, buf_size - len,
+                  "Number of Active IOs: %lld\nMaximum Active IOs: %lld\n"
+                  "Number of IOs: %lld\nNumber of IO Completions: %lld\n"
+                  "Number of IO Failures: %lld\nNumber of IO NOT Found: %lld\n"
+                  "Number of Memory alloc Failures: %lld\n"
+                  "Number of IOREQ Null: %lld\n"
+                  "Number of SCSI cmd pointer Null: %lld\n",
+                  (u64)atomic64_read(&stats->io_stats.active_ios),
+                  (u64)atomic64_read(&stats->io_stats.max_active_ios),
+                  (u64)atomic64_read(&stats->io_stats.num_ios),
+                  (u64)atomic64_read(&stats->io_stats.io_completions),
+                  (u64)atomic64_read(&stats->io_stats.io_failures),
+                  (u64)atomic64_read(&stats->io_stats.io_not_found),
+                  (u64)atomic64_read(&stats->io_stats.alloc_failures),
+                  (u64)atomic64_read(&stats->io_stats.ioreq_null),
+                  (u64)atomic64_read(&stats->io_stats.sc_null));
+
+        len += snprintf(debug->debug_buffer + len, buf_size - len,
+                  "\n------------------------------------------\n"
+                  "\t\tAbort Statistics\n"
+                  "------------------------------------------\n");
+        len += snprintf(debug->debug_buffer + len, buf_size - len,
+                  "Number of Aborts: %lld\n"
+                  "Number of Abort Failures: %lld\n"
+                  "Number of Abort Driver Timeouts: %lld\n"
+                  "Number of Abort FW Timeouts: %lld\n"
+                  "Number of Abort IO NOT Found: %lld\n",
+                  (u64)atomic64_read(&stats->abts_stats.aborts),
+                  (u64)atomic64_read(&stats->abts_stats.abort_failures),
+                  (u64)atomic64_read(&stats->abts_stats.abort_drv_timeouts),
+                  (u64)atomic64_read(&stats->abts_stats.abort_fw_timeouts),
+                  (u64)atomic64_read(&stats->abts_stats.abort_io_not_found));
+
+        len += snprintf(debug->debug_buffer + len, buf_size - len,
+                  "\n------------------------------------------\n"
+                  "\t\tTerminate Statistics\n"
+                  "------------------------------------------\n");
+        len += snprintf(debug->debug_buffer + len, buf_size - len,
+                  "Number of Terminates: %lld\n"
+                  "Maximum Terminates: %lld\n"
+                  "Number of Terminate Driver Timeouts: %lld\n"
+                  "Number of Terminate FW Timeouts: %lld\n"
+                  "Number of Terminate IO NOT Found: %lld\n"
+                  "Number of Terminate Failures: %lld\n",
+                  (u64)atomic64_read(&stats->term_stats.terminates),
+                  (u64)atomic64_read(&stats->term_stats.max_terminates),
+                  (u64)atomic64_read(&stats->term_stats.terminate_drv_timeouts),
+                  (u64)atomic64_read(&stats->term_stats.terminate_fw_timeouts),
+                  (u64)atomic64_read(&stats->term_stats.terminate_io_not_found),
+                  (u64)atomic64_read(&stats->term_stats.terminate_failures));
+
+        len += snprintf(debug->debug_buffer + len, buf_size - len,
+                  "\n------------------------------------------\n"
+                  "\t\tReset Statistics\n"
+                  "------------------------------------------\n");
+
+        len += snprintf(debug->debug_buffer + len, buf_size - len,
+                  "Number of Device Resets: %lld\n"
+                  "Number of Device Reset Failures: %lld\n"
+                  "Number of Device Reset Aborts: %lld\n"
+                  "Number of Device Reset Timeouts: %lld\n"
+                  "Number of Device Reset Terminates: %lld\n"
+                  "Number of FW Resets: %lld\n"
+                  "Number of FW Reset Completions: %lld\n"
+                  "Number of FW Reset Failures: %lld\n"
+                  "Number of Fnic Reset: %lld\n"
+                  "Number of Fnic Reset Completions: %lld\n"
+                  "Number of Fnic Reset Failures: %lld\n",
+                  (u64)atomic64_read(&stats->reset_stats.device_resets),
+                  (u64)atomic64_read(&stats->reset_stats.device_reset_failures),
+                  (u64)atomic64_read(&stats->reset_stats.device_reset_aborts),
+                  (u64)atomic64_read(&stats->reset_stats.device_reset_timeouts),
+                  (u64)atomic64_read(
+                          &stats->reset_stats.device_reset_terminates),
+                  (u64)atomic64_read(&stats->reset_stats.fw_resets),
+                  (u64)atomic64_read(&stats->reset_stats.fw_reset_completions),
+                  (u64)atomic64_read(&stats->reset_stats.fw_reset_failures),
+                  (u64)atomic64_read(&stats->reset_stats.fnic_resets),
+                  (u64)atomic64_read(
+                          &stats->reset_stats.fnic_reset_completions),
+                  (u64)atomic64_read(&stats->reset_stats.fnic_reset_failures));
+
+        len += snprintf(debug->debug_buffer + len, buf_size - len,
+                  "\n------------------------------------------\n"
+                  "\t\tFirmware Statistics\n"
+                  "------------------------------------------\n");
+
+        len += snprintf(debug->debug_buffer + len, buf_size - len,
+                  "Number of Active FW Requests %lld\n"
+                  "Maximum FW Requests: %lld\n"
+                  "Number of FW out of resources: %lld\n"
+                  "Number of FW IO errors: %lld\n",
+                  (u64)atomic64_read(&stats->fw_stats.active_fw_reqs),
+                  (u64)atomic64_read(&stats->fw_stats.max_fw_reqs),
+                  (u64)atomic64_read(&stats->fw_stats.fw_out_of_resources),
+                  (u64)atomic64_read(&stats->fw_stats.io_fw_errs));
+
+        len += snprintf(debug->debug_buffer + len, buf_size - len,
+                  "\n------------------------------------------\n"
+                  "\t\tVlan Discovery Statistics\n"
+                  "------------------------------------------\n");
+
+        len += snprintf(debug->debug_buffer + len, buf_size - len,
+                  "Number of Vlan Discovery Requests Sent %lld\n"
+                  "Vlan Response Received with no FCF VLAN ID: %lld\n"
+                  "No solicitations recvd after vlan set, expiry count: %lld\n"
+                  "Flogi rejects count: %lld\n",
+                  (u64)atomic64_read(&stats->vlan_stats.vlan_disc_reqs),
+                  (u64)atomic64_read(&stats->vlan_stats.resp_withno_vlanID),
+                  (u64)atomic64_read(&stats->vlan_stats.sol_expiry_count),
+                  (u64)atomic64_read(&stats->vlan_stats.flogi_rejects));
+
+        len += snprintf(debug->debug_buffer + len, buf_size - len,
+                  "\n------------------------------------------\n"
+                  "\t\tOther Important Statistics\n"
+                  "------------------------------------------\n");
+
+        jiffies_to_timespec(stats->misc_stats.last_isr_time, &val1);
+        jiffies_to_timespec(stats->misc_stats.last_ack_time, &val2);
+
+        len += snprintf(debug->debug_buffer + len, buf_size - len,
+                  "Last ISR time: %llu (%8lu.%8lu)\n"
+                  "Last ACK time: %llu (%8lu.%8lu)\n"
+                  "Number of ISRs: %lld\n"
+                  "Maximum CQ Entries: %lld\n"
+                  "Number of ACK index out of range: %lld\n"
+                  "Number of data count mismatch: %lld\n"
+                  "Number of FCPIO Timeouts: %lld\n"
+                  "Number of FCPIO Aborted: %lld\n"
+                  "Number of SGL Invalid: %lld\n"
+                  "Number of Copy WQ Alloc Failures for ABTs: %lld\n"
+                  "Number of Copy WQ Alloc Failures for Device Reset: %lld\n"
+                  "Number of Copy WQ Alloc Failures for IOs: %lld\n"
+                  "Number of no icmnd itmf Completions: %lld\n"
+                  "Number of QUEUE Fulls: %lld\n"
+                  "Number of rport not ready: %lld\n"
+                  "Number of receive frame errors: %lld\n",
+                  (u64)stats->misc_stats.last_isr_time,
+                  val1.tv_sec, val1.tv_nsec,
+                  (u64)stats->misc_stats.last_ack_time,
+                  val2.tv_sec, val2.tv_nsec,
+                  (u64)atomic64_read(&stats->misc_stats.isr_count),
+                  (u64)atomic64_read(&stats->misc_stats.max_cq_entries),
+                  (u64)atomic64_read(&stats->misc_stats.ack_index_out_of_range),
+                  (u64)atomic64_read(&stats->misc_stats.data_count_mismatch),
+                  (u64)atomic64_read(&stats->misc_stats.fcpio_timeout),
+                  (u64)atomic64_read(&stats->misc_stats.fcpio_aborted),
+                  (u64)atomic64_read(&stats->misc_stats.sgl_invalid),
+                  (u64)atomic64_read(
+                          &stats->misc_stats.abts_cpwq_alloc_failures),
+                  (u64)atomic64_read(
+                          &stats->misc_stats.devrst_cpwq_alloc_failures),
+                  (u64)atomic64_read(&stats->misc_stats.io_cpwq_alloc_failures),
+                  (u64)atomic64_read(&stats->misc_stats.no_icmnd_itmf_cmpls),
+                  (u64)atomic64_read(&stats->misc_stats.queue_fulls),
+                  (u64)atomic64_read(&stats->misc_stats.rport_not_ready),
+                  (u64)atomic64_read(&stats->misc_stats.frame_errors));
+
+        return len;
+
+}
+
+/*
  * fnic_trace_buf_init - Initialize fnic trace buffer logging facility
  *
  * Description:
diff --git a/drivers/scsi/fnic/fnic_trace.h b/drivers/scsi/fnic/fnic_trace.h
index cef42b4c4d6c..d412f2ee3c4f 100644
--- a/drivers/scsi/fnic/fnic_trace.h
+++ b/drivers/scsi/fnic/fnic_trace.h
@@ -84,7 +84,8 @@ fnic_trace_data_t *fnic_trace_get_buf(void);
 int fnic_get_trace_data(fnic_dbgfs_t *);
 int fnic_trace_buf_init(void);
 void fnic_trace_free(void);
+int fnic_debugfs_init(void);
+void fnic_debugfs_terminate(void);
 int fnic_trace_debugfs_init(void);
 void fnic_trace_debugfs_terminate(void);
-
 #endif