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 0eef5aa52fc0f29c4b884ede40175bf77b42e22e..797bb42a63064bae9d2c3084651d39634e12f96e 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 b7f57492aefcf4929d23bcd953b67ecda8457239..17ea3bb04266bdf098e0f615a48410df90452a00 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,
@@ -811,6 +818,12 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
                                atomic_read(&tgtp->xmt_fcp_rsp_error),
                                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),
@@ -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 4b2a73ebd116ac24c64539afc979707e651c13ba..81e3a4f10c3c088df1373fa51b69cf7911c37add 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 03b0e8471ef47d00da7619e03b3569fc207eed17..e79f8f75758c5418f3d47b6494fd5f989dd58042 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 02a1cfa10f72dfdcbafd85fbaeed87c554180d0c..8dbf5c9d51aad3e64ae424d8256124a21af8a585 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 03096024e0737068a3bc7f9e8eeb281a0d8392e1..5b32c9e4d4ef97e658554377c08f2932a53c833d 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;