scsi: lpfc: Beef up stat counters for debug

If log verbose in not turned on, its hard to tell when certain error
paths get hit. Add stats counters and corresponding logic to
debugfs/sysfs to aid understanding what paths were traversed.

Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <james.smart@broadcom.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index 0eef5aa..797bb42 100644 (file)
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -148,6 +148,7 @@ lpfc_nvme_info_show(struct device *dev, struct device_attribute *attr,
        struct lpfc_hba   *phba = vport->phba;
        struct lpfc_nvmet_tgtport *tgtp;
        struct nvme_fc_local_port *localport;
+       struct lpfc_nvme_lport *lport;
        struct lpfc_nodelist *ndlp;
        struct nvme_fc_remote_port *nrport;
        uint64_t data1, data2, data3, tot;
@@ -198,10 +199,15 @@ lpfc_nvme_info_show(struct device *dev, struct device_attribute *attr,
                }
 
                len += snprintf(buf+len, PAGE_SIZE-len,
-                               "LS: Xmt %08x Drop %08x Cmpl %08x Err %08x\n",
+                               "LS: Xmt %08x Drop %08x Cmpl %08x\n",
                                atomic_read(&tgtp->xmt_ls_rsp),
                                atomic_read(&tgtp->xmt_ls_drop),
-                               atomic_read(&tgtp->xmt_ls_rsp_cmpl),
+                               atomic_read(&tgtp->xmt_ls_rsp_cmpl));
+
+               len += snprintf(buf + len, PAGE_SIZE - len,
+                               "LS: RSP Abort %08x xb %08x Err %08x\n",
+                               atomic_read(&tgtp->xmt_ls_rsp_aborted),
+                               atomic_read(&tgtp->xmt_ls_rsp_xb_set),
                                atomic_read(&tgtp->xmt_ls_rsp_error));
 
                len += snprintf(buf+len, PAGE_SIZE-len,
@@ -236,6 +242,12 @@ lpfc_nvme_info_show(struct device *dev, struct device_attribute *attr,
                                atomic_read(&tgtp->xmt_fcp_rsp_drop));
 
                len += snprintf(buf+len, PAGE_SIZE-len,
+                               "FCP Rsp Abort: %08x xb %08x xricqe  %08x\n",
+                               atomic_read(&tgtp->xmt_fcp_rsp_aborted),
+                               atomic_read(&tgtp->xmt_fcp_rsp_xb_set),
+                               atomic_read(&tgtp->xmt_fcp_xri_abort_cqe));
+
+               len += snprintf(buf + len, PAGE_SIZE - len,
                                "ABORT: Xmt %08x Cmpl %08x\n",
                                atomic_read(&tgtp->xmt_fcp_abort),
                                atomic_read(&tgtp->xmt_fcp_abort_cmpl));
@@ -265,6 +277,7 @@ lpfc_nvme_info_show(struct device *dev, struct device_attribute *attr,
        }
 
        localport = vport->localport;
+       lport = (struct lpfc_nvme_lport *)localport->private;
        if (!localport) {
                len = snprintf(buf, PAGE_SIZE,
                                "NVME Initiator x%llx is not allocated\n",
@@ -347,9 +360,16 @@ lpfc_nvme_info_show(struct device *dev, struct device_attribute *attr,
 
        len += snprintf(buf + len, PAGE_SIZE - len, "\nNVME Statistics\n");
        len += snprintf(buf+len, PAGE_SIZE-len,
-                       "LS: Xmt %016x Cmpl %016x\n",
+                       "LS: Xmt %010x Cmpl %010x Abort %08x\n",
                        atomic_read(&phba->fc4NvmeLsRequests),
-                       atomic_read(&phba->fc4NvmeLsCmpls));
+                       atomic_read(&phba->fc4NvmeLsCmpls),
+                       atomic_read(&lport->xmt_ls_abort));
+
+       len += snprintf(buf + len, PAGE_SIZE - len,
+                       "LS XMIT: Err %08x  CMPL: xb %08x Err %08x\n",
+                       atomic_read(&lport->xmt_ls_err),
+                       atomic_read(&lport->cmpl_ls_xb),
+                       atomic_read(&lport->cmpl_ls_err));
 
        tot = atomic_read(&phba->fc4NvmeIoCmpls);
        data1 = atomic_read(&phba->fc4NvmeInputRequests);
@@ -360,8 +380,22 @@ lpfc_nvme_info_show(struct device *dev, struct device_attribute *attr,
                        data1, data2, data3);
 
        len += snprintf(buf+len, PAGE_SIZE-len,
-                       "    Cmpl %016llx Outstanding %016llx\n",
-                       tot, (data1 + data2 + data3) - tot);
+                       "    noxri %08x nondlp %08x qdepth %08x "
+                       "wqerr %08x\n",
+                       atomic_read(&lport->xmt_fcp_noxri),
+                       atomic_read(&lport->xmt_fcp_bad_ndlp),
+                       atomic_read(&lport->xmt_fcp_qdepth),
+                       atomic_read(&lport->xmt_fcp_wqerr));
+
+       len += snprintf(buf + len, PAGE_SIZE - len,
+                       "    Cmpl %016llx Outstanding %016llx Abort %08x\n",
+                       tot, ((data1 + data2 + data3) - tot),
+                       atomic_read(&lport->xmt_fcp_abort));
+
+       len += snprintf(buf + len, PAGE_SIZE - len,
+                       "FCP CMPL: xb %08x Err %08x\n",
+                       atomic_read(&lport->cmpl_fcp_xb),
+                       atomic_read(&lport->cmpl_fcp_err));
        return len;
 }
 

diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c
index b7f5749..17ea3bb 100644 (file)
--- a/drivers/scsi/lpfc/lpfc_debugfs.c
+++ b/drivers/scsi/lpfc/lpfc_debugfs.c
@@ -750,6 +750,8 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
        struct lpfc_hba   *phba = vport->phba;
        struct lpfc_nvmet_tgtport *tgtp;
        struct lpfc_nvmet_rcv_ctx *ctxp, *next_ctxp;
+       struct nvme_fc_local_port *localport;
+       struct lpfc_nvme_lport *lport;
        uint64_t tot, data1, data2, data3;
        int len = 0;
        int cnt;
@@ -775,10 +777,15 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
                }
 
                len += snprintf(buf + len, size - len,
-                               "LS: Xmt %08x Drop %08x Cmpl %08x Err %08x\n",
+                               "LS: Xmt %08x Drop %08x Cmpl %08x\n",
                                atomic_read(&tgtp->xmt_ls_rsp),
                                atomic_read(&tgtp->xmt_ls_drop),
-                               atomic_read(&tgtp->xmt_ls_rsp_cmpl),
+                               atomic_read(&tgtp->xmt_ls_rsp_cmpl));
+
+               len += snprintf(buf + len, size - len,
+                               "LS: RSP Abort %08x xb %08x Err %08x\n",
+                               atomic_read(&tgtp->xmt_ls_rsp_aborted),
+                               atomic_read(&tgtp->xmt_ls_rsp_xb_set),
                                atomic_read(&tgtp->xmt_ls_rsp_error));
 
                len += snprintf(buf + len, size - len,
@@ -812,6 +819,12 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
                                atomic_read(&tgtp->xmt_fcp_rsp_drop));
 
                len += snprintf(buf + len, size - len,
+                               "FCP Rsp Abort: %08x xb %08x xricqe  %08x\n",
+                               atomic_read(&tgtp->xmt_fcp_rsp_aborted),
+                               atomic_read(&tgtp->xmt_fcp_rsp_xb_set),
+                               atomic_read(&tgtp->xmt_fcp_xri_abort_cqe));
+
+               len += snprintf(buf + len, size - len,
                                "ABORT: Xmt %08x Cmpl %08x\n",
                                atomic_read(&tgtp->xmt_fcp_abort),
                                atomic_read(&tgtp->xmt_fcp_abort_cmpl));
@@ -885,8 +898,38 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
                                data1, data2, data3);
 
                len += snprintf(buf + len, size - len,
-                               "    Cmpl %016llx Outstanding %016llx\n",
+                               "   Cmpl %016llx Outstanding %016llx\n",
                                tot, (data1 + data2 + data3) - tot);
+
+               localport = vport->localport;
+               if (!localport)
+                       return len;
+               lport = (struct lpfc_nvme_lport *)localport->private;
+               if (!lport)
+                       return len;
+
+               len += snprintf(buf + len, size - len,
+                               "LS Xmt Err: Abrt %08x Err %08x  "
+                               "Cmpl Err: xb %08x Err %08x\n",
+                               atomic_read(&lport->xmt_ls_abort),
+                               atomic_read(&lport->xmt_ls_err),
+                               atomic_read(&lport->cmpl_ls_xb),
+                               atomic_read(&lport->cmpl_ls_err));
+
+               len += snprintf(buf + len, size - len,
+                               "FCP Xmt Err: noxri %06x nondlp %06x "
+                               "qdepth %06x wqerr %06x Abrt %06x\n",
+                               atomic_read(&lport->xmt_fcp_noxri),
+                               atomic_read(&lport->xmt_fcp_bad_ndlp),
+                               atomic_read(&lport->xmt_fcp_qdepth),
+                               atomic_read(&lport->xmt_fcp_wqerr),
+                               atomic_read(&lport->xmt_fcp_abort));
+
+               len += snprintf(buf + len, size - len,
+                               "FCP Cmpl Err: xb %08x Err %08x\n",
+                               atomic_read(&lport->cmpl_fcp_xb),
+                               atomic_read(&lport->cmpl_fcp_err));
+
        }
 
        return len;

diff --git a/drivers/scsi/lpfc/lpfc_nvme.c b/drivers/scsi/lpfc/lpfc_nvme.c
index 4b2a73e..81e3a4f 100644 (file)
--- a/drivers/scsi/lpfc/lpfc_nvme.c
+++ b/drivers/scsi/lpfc/lpfc_nvme.c
@@ -221,6 +221,7 @@ lpfc_nvme_cmpl_gen_req(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe,
                       struct lpfc_wcqe_complete *wcqe)
 {
        struct lpfc_vport *vport = cmdwqe->vport;
+       struct lpfc_nvme_lport *lport;
        uint32_t status;
        struct nvmefc_ls_req *pnvme_lsreq;
        struct lpfc_dmabuf *buf_ptr;
@@ -230,6 +231,13 @@ lpfc_nvme_cmpl_gen_req(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe,
 
        pnvme_lsreq = (struct nvmefc_ls_req *)cmdwqe->context2;
        status = bf_get(lpfc_wcqe_c_status, wcqe) & LPFC_IOCB_STATUS_MASK;
+       if (status) {
+               lport = (struct lpfc_nvme_lport *)vport->localport->private;
+               if (bf_get(lpfc_wcqe_c_xb, wcqe))
+                       atomic_inc(&lport->cmpl_ls_xb);
+               atomic_inc(&lport->cmpl_ls_err);
+       }
+
        ndlp = (struct lpfc_nodelist *)cmdwqe->context1;
        lpfc_printf_vlog(vport, KERN_INFO, LOG_NVME_DISC,
                         "6047 nvme cmpl Enter "
@@ -508,6 +516,7 @@ lpfc_nvme_ls_req(struct nvme_fc_local_port *pnvme_lport,
                                pnvme_lsreq, lpfc_nvme_cmpl_gen_req,
                                ndlp, 2, 30, 0);
        if (ret != WQE_SUCCESS) {
+               atomic_inc(&lport->xmt_ls_err);
                lpfc_printf_vlog(vport, KERN_INFO, LOG_NVME_DISC,
                                 "6052 EXIT. issue ls wqe failed lport %p, "
                                 "rport %p lsreq%p Status %x DID %x\n",
@@ -592,6 +601,7 @@ lpfc_nvme_ls_abort(struct nvme_fc_local_port *pnvme_lport,
 
        /* Abort the targeted IOs and remove them from the abort list. */
        list_for_each_entry_safe(wqe, next_wqe, &abort_list, dlist) {
+               atomic_inc(&lport->xmt_ls_abort);
                spin_lock_irq(&phba->hbalock);
                list_del_init(&wqe->dlist);
                lpfc_sli_issue_abort_iotag(phba, pring, wqe);
@@ -795,8 +805,9 @@ lpfc_nvme_io_cmd_wqe_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pwqeIn,
        struct lpfc_nvme_rport *rport;
        struct lpfc_nodelist *ndlp;
        struct lpfc_nvme_fcpreq_priv *freqpriv;
+       struct lpfc_nvme_lport *lport;
        unsigned long flags;
-       uint32_t code;
+       uint32_t code, status;
        uint16_t cid, sqhd, data;
        uint32_t *ptr;
 
@@ -811,10 +822,17 @@ lpfc_nvme_io_cmd_wqe_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pwqeIn,
 
        nCmd = lpfc_ncmd->nvmeCmd;
        rport = lpfc_ncmd->nrport;
+       status = bf_get(lpfc_wcqe_c_status, wcqe);
+       if (status) {
+               lport = (struct lpfc_nvme_lport *)vport->localport->private;
+               if (bf_get(lpfc_wcqe_c_xb, wcqe))
+                       atomic_inc(&lport->cmpl_fcp_xb);
+               atomic_inc(&lport->cmpl_fcp_err);
+       }
 
        lpfc_nvmeio_data(phba, "NVME FCP CMPL: xri x%x stat x%x parm x%x\n",
                         lpfc_ncmd->cur_iocbq.sli4_xritag,
-                        bf_get(lpfc_wcqe_c_status, wcqe), wcqe->parameter);
+                        status, wcqe->parameter);
        /*
         * Catch race where our node has transitioned, but the
         * transport is still transitioning.
@@ -872,8 +890,7 @@ lpfc_nvme_io_cmd_wqe_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pwqeIn,
                nCmd->rcv_rsplen = LPFC_NVME_ERSP_LEN;
                nCmd->transferred_length = nCmd->payload_length;
        } else {
-               lpfc_ncmd->status = (bf_get(lpfc_wcqe_c_status, wcqe) &
-                           LPFC_IOCB_STATUS_MASK);
+               lpfc_ncmd->status = (status & LPFC_IOCB_STATUS_MASK);
                lpfc_ncmd->result = (wcqe->parameter & IOERR_PARAM_MASK);
 
                /* For NVME, the only failure path that results in an
@@ -1336,6 +1353,7 @@ lpfc_nvme_fcp_io_submit(struct nvme_fc_local_port *pnvme_lport,
                        lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_IOERR,
                                         "6066 Missing node for DID %x\n",
                                         pnvme_rport->port_id);
+                       atomic_inc(&lport->xmt_fcp_bad_ndlp);
                        ret = -ENODEV;
                        goto out_fail;
                }
@@ -1349,6 +1367,7 @@ lpfc_nvme_fcp_io_submit(struct nvme_fc_local_port *pnvme_lport,
                                 "IO. State x%x, Type x%x\n",
                                 rport, pnvme_rport->port_id,
                                 ndlp->nlp_state, ndlp->nlp_type);
+               atomic_inc(&lport->xmt_fcp_bad_ndlp);
                ret = -ENODEV;
                goto out_fail;
 
@@ -1370,12 +1389,14 @@ lpfc_nvme_fcp_io_submit(struct nvme_fc_local_port *pnvme_lport,
         */
        if ((atomic_read(&ndlp->cmd_pending) >= ndlp->cmd_qdepth) &&
            !expedite) {
+               atomic_inc(&lport->xmt_fcp_qdepth);
                ret = -EBUSY;
                goto out_fail;
        }
 
        lpfc_ncmd = lpfc_get_nvme_buf(phba, ndlp, expedite);
        if (lpfc_ncmd == NULL) {
+               atomic_inc(&lport->xmt_fcp_noxri);
                lpfc_printf_vlog(vport, KERN_INFO, LOG_NVME_IOERR,
                                 "6065 driver's buffer pool is empty, "
                                 "IO failed\n");
@@ -1428,6 +1449,7 @@ lpfc_nvme_fcp_io_submit(struct nvme_fc_local_port *pnvme_lport,
 
        ret = lpfc_sli4_issue_wqe(phba, LPFC_FCP_RING, &lpfc_ncmd->cur_iocbq);
        if (ret) {
+               atomic_inc(&lport->xmt_fcp_wqerr);
                atomic_dec(&ndlp->cmd_pending);
                lpfc_printf_vlog(vport, KERN_INFO, LOG_NVME_IOERR,
                                 "6113 FCP could not issue WQE err %x "
@@ -1624,6 +1646,7 @@ lpfc_nvme_fcp_abort(struct nvme_fc_local_port *pnvme_lport,
                return;
        }
 
+       atomic_inc(&lport->xmt_fcp_abort);
        lpfc_nvmeio_data(phba, "NVME FCP ABORT: xri x%x idx %d to %06x\n",
                         nvmereq_wqe->sli4_xritag,
                         nvmereq_wqe->hba_wqidx, pnvme_rport->port_id);
@@ -2302,6 +2325,18 @@ lpfc_nvme_create_localport(struct lpfc_vport *vport)
                lport->vport = vport;
                vport->nvmei_support = 1;
 
+               atomic_set(&lport->xmt_fcp_noxri, 0);
+               atomic_set(&lport->xmt_fcp_bad_ndlp, 0);
+               atomic_set(&lport->xmt_fcp_qdepth, 0);
+               atomic_set(&lport->xmt_fcp_wqerr, 0);
+               atomic_set(&lport->xmt_fcp_abort, 0);
+               atomic_set(&lport->xmt_ls_abort, 0);
+               atomic_set(&lport->xmt_ls_err, 0);
+               atomic_set(&lport->cmpl_fcp_xb, 0);
+               atomic_set(&lport->cmpl_fcp_err, 0);
+               atomic_set(&lport->cmpl_ls_xb, 0);
+               atomic_set(&lport->cmpl_ls_err, 0);
+
                /* Don't post more new bufs if repost already recovered
                 * the nvme sgls.
                 */

diff --git a/drivers/scsi/lpfc/lpfc_nvme.h b/drivers/scsi/lpfc/lpfc_nvme.h
index 03b0e84..e79f8f7 100644 (file)
--- a/drivers/scsi/lpfc/lpfc_nvme.h
+++ b/drivers/scsi/lpfc/lpfc_nvme.h
@@ -38,7 +38,18 @@ struct lpfc_nvme_qhandle {
 struct lpfc_nvme_lport {
        struct lpfc_vport *vport;
        struct completion lport_unreg_done;
-       /* Add sttats counters here */
+       /* Add stats counters here */
+       atomic_t xmt_fcp_noxri;
+       atomic_t xmt_fcp_bad_ndlp;
+       atomic_t xmt_fcp_qdepth;
+       atomic_t xmt_fcp_wqerr;
+       atomic_t xmt_fcp_abort;
+       atomic_t xmt_ls_abort;
+       atomic_t xmt_ls_err;
+       atomic_t cmpl_fcp_xb;
+       atomic_t cmpl_fcp_err;
+       atomic_t cmpl_ls_xb;
+       atomic_t cmpl_ls_err;
 };
 
 struct lpfc_nvme_rport {

diff --git a/drivers/scsi/lpfc/lpfc_nvmet.c b/drivers/scsi/lpfc/lpfc_nvmet.c
index 02a1cfa..8dbf5c9 100644 (file)
--- a/drivers/scsi/lpfc/lpfc_nvmet.c
+++ b/drivers/scsi/lpfc/lpfc_nvmet.c
@@ -127,10 +127,17 @@ lpfc_nvmet_xmt_ls_rsp_cmp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe,
 
        tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
 
-       if (status)
-               atomic_inc(&tgtp->xmt_ls_rsp_error);
-       else
-               atomic_inc(&tgtp->xmt_ls_rsp_cmpl);
+       if (tgtp) {
+               if (status) {
+                       atomic_inc(&tgtp->xmt_ls_rsp_error);
+                       if (status == IOERR_ABORT_REQUESTED)
+                               atomic_inc(&tgtp->xmt_ls_rsp_aborted);
+                       if (bf_get(lpfc_wcqe_c_xb, wcqe))
+                               atomic_inc(&tgtp->xmt_ls_rsp_xb_set);
+               } else {
+                       atomic_inc(&tgtp->xmt_ls_rsp_cmpl);
+               }
+       }
 
 out:
        rsp = &ctxp->ctx.ls_req;
@@ -532,8 +539,11 @@ lpfc_nvmet_xmt_fcp_op_cmp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe,
        if (status) {
                rsp->fcp_error = NVME_SC_DATA_XFER_ERROR;
                rsp->transferred_length = 0;
-               if (tgtp)
+               if (tgtp) {
                        atomic_inc(&tgtp->xmt_fcp_rsp_error);
+                       if (status == IOERR_ABORT_REQUESTED)
+                               atomic_inc(&tgtp->xmt_fcp_rsp_aborted);
+               }
 
                logerr = LOG_NVME_IOERR;
 
@@ -541,6 +551,8 @@ lpfc_nvmet_xmt_fcp_op_cmp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe,
                if (bf_get(lpfc_wcqe_c_xb, wcqe)) {
                        ctxp->flag |= LPFC_NVMET_XBUSY;
                        logerr |= LOG_NVME_ABTS;
+                       if (tgtp)
+                               atomic_inc(&tgtp->xmt_fcp_rsp_xb_set);
 
                } else {
                        ctxp->flag &= ~LPFC_NVMET_XBUSY;
@@ -1244,6 +1256,8 @@ lpfc_nvmet_create_targetport(struct lpfc_hba *phba)
                atomic_set(&tgtp->xmt_ls_rsp, 0);
                atomic_set(&tgtp->xmt_ls_drop, 0);
                atomic_set(&tgtp->xmt_ls_rsp_error, 0);
+               atomic_set(&tgtp->xmt_ls_rsp_xb_set, 0);
+               atomic_set(&tgtp->xmt_ls_rsp_aborted, 0);
                atomic_set(&tgtp->xmt_ls_rsp_cmpl, 0);
                atomic_set(&tgtp->rcv_fcp_cmd_in, 0);
                atomic_set(&tgtp->rcv_fcp_cmd_out, 0);
@@ -1256,7 +1270,10 @@ lpfc_nvmet_create_targetport(struct lpfc_hba *phba)
                atomic_set(&tgtp->xmt_fcp_release, 0);
                atomic_set(&tgtp->xmt_fcp_rsp_cmpl, 0);
                atomic_set(&tgtp->xmt_fcp_rsp_error, 0);
+               atomic_set(&tgtp->xmt_fcp_rsp_xb_set, 0);
+               atomic_set(&tgtp->xmt_fcp_rsp_aborted, 0);
                atomic_set(&tgtp->xmt_fcp_rsp_drop, 0);
+               atomic_set(&tgtp->xmt_fcp_xri_abort_cqe, 0);
                atomic_set(&tgtp->xmt_fcp_abort, 0);
                atomic_set(&tgtp->xmt_fcp_abort_cmpl, 0);
                atomic_set(&tgtp->xmt_abort_unsol, 0);
@@ -1298,6 +1315,7 @@ lpfc_sli4_nvmet_xri_aborted(struct lpfc_hba *phba,
        uint16_t xri = bf_get(lpfc_wcqe_xa_xri, axri);
        uint16_t rxid = bf_get(lpfc_wcqe_xa_remote_xid, axri);
        struct lpfc_nvmet_rcv_ctx *ctxp, *next_ctxp;
+       struct lpfc_nvmet_tgtport *tgtp;
        struct lpfc_nodelist *ndlp;
        unsigned long iflag = 0;
        int rrq_empty = 0;
@@ -1308,6 +1326,12 @@ lpfc_sli4_nvmet_xri_aborted(struct lpfc_hba *phba,
 
        if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME))
                return;
+
+       if (phba->targetport) {
+               tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
+               atomic_inc(&tgtp->xmt_fcp_xri_abort_cqe);
+       }
+
        spin_lock_irqsave(&phba->hbalock, iflag);
        spin_lock(&phba->sli4_hba.abts_nvme_buf_list_lock);
        list_for_each_entry_safe(ctxp, next_ctxp,

diff --git a/drivers/scsi/lpfc/lpfc_nvmet.h b/drivers/scsi/lpfc/lpfc_nvmet.h
index 0309602..5b32c9e 100644 (file)
--- a/drivers/scsi/lpfc/lpfc_nvmet.h
+++ b/drivers/scsi/lpfc/lpfc_nvmet.h
@@ -47,6 +47,8 @@ struct lpfc_nvmet_tgtport {
 
        /* Stats counters - lpfc_nvmet_xmt_ls_rsp_cmp */
        atomic_t xmt_ls_rsp_error;
+       atomic_t xmt_ls_rsp_aborted;
+       atomic_t xmt_ls_rsp_xb_set;
        atomic_t xmt_ls_rsp_cmpl;
 
        /* Stats counters - lpfc_nvmet_unsol_fcp_buffer */
@@ -64,12 +66,15 @@ struct lpfc_nvmet_tgtport {
        atomic_t xmt_fcp_rsp;
 
        /* Stats counters - lpfc_nvmet_xmt_fcp_op_cmp */
+       atomic_t xmt_fcp_rsp_xb_set;
        atomic_t xmt_fcp_rsp_cmpl;
        atomic_t xmt_fcp_rsp_error;
+       atomic_t xmt_fcp_rsp_aborted;
        atomic_t xmt_fcp_rsp_drop;
 
 
        /* Stats counters - lpfc_nvmet_xmt_fcp_abort */
+       atomic_t xmt_fcp_xri_abort_cqe;
        atomic_t xmt_fcp_abort;
        atomic_t xmt_fcp_abort_cmpl;
        atomic_t xmt_abort_sol;