scsi: lpfc: Add changes to assist in NVMET debugging (ce1b591c) · Commits · 戴 / test

drivers/scsi/lpfc/lpfc_nvmet.c

+143 −65

Original line number	Diff line number	Diff line
		@@ -112,6 +112,15 @@ lpfc_nvmet_xmt_ls_rsp_cmp(struct lpfc_hba phba, struct lpfc_iocbq cmdwqe,

		status = bf_get(lpfc_wcqe_c_status, wcqe);
		result = wcqe->parameter;
		ctxp = cmdwqe->context2;

		if (ctxp->state != LPFC_NVMET_STE_LS_RSP \|\| ctxp->entry_cnt != 2) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
		"6410 NVMET LS cmpl state mismatch IO x%x: "
		"%d %d\n",
		ctxp->oxid, ctxp->state, ctxp->entry_cnt);
		}

		if (!phba->targetport)
		goto out;

		@@ -123,15 +132,14 @@ lpfc_nvmet_xmt_ls_rsp_cmp(struct lpfc_hba phba, struct lpfc_iocbq cmdwqe,
		atomic_inc(&tgtp->xmt_ls_rsp_cmpl);

		out:
		ctxp = cmdwqe->context2;
		rsp = &ctxp->ctx.ls_req;

		lpfc_nvmeio_data(phba, "NVMET LS CMPL: xri x%x stat x%x result x%x\n",
		ctxp->oxid, status, result);

		lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC,
		"6038 %s: Entrypoint: ctx %p status %x/%x\n", __func__,
		ctxp, status, result);
		"6038 NVMET LS rsp cmpl: %d %d oxid x%x\n",
		status, result, ctxp->oxid);

		lpfc_nlp_put(cmdwqe->context1);
		cmdwqe->context2 = NULL;
		@@ -173,6 +181,12 @@ lpfc_nvmet_ctxbuf_post(struct lpfc_hba phba, struct lpfc_nvmet_ctxbuf ctx_buf)
		ctxp->txrdy = NULL;
		ctxp->txrdy_phys = 0;
		}

		if (ctxp->state == LPFC_NVMET_STE_FREE) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
		"6411 NVMET free, already free IO x%x: %d %d\n",
		ctxp->oxid, ctxp->state, ctxp->entry_cnt);
		}
		ctxp->state = LPFC_NVMET_STE_FREE;

		spin_lock_irqsave(&phba->sli4_hba.nvmet_io_wait_lock, iflag);
		@@ -580,8 +594,17 @@ lpfc_nvmet_xmt_ls_rsp(struct nvmet_fc_target_port *tgtport,
		int rc;

		lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC,
		"6023 %s: Entrypoint ctx %p %p\n", __func__,
		ctxp, tgtport);
		"6023 NVMET LS rsp oxid x%x\n", ctxp->oxid);

		if ((ctxp->state != LPFC_NVMET_STE_LS_RCV) \|\|
		(ctxp->entry_cnt != 1)) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
		"6412 NVMET LS rsp state mismatch "
		"oxid x%x: %d %d\n",
		ctxp->oxid, ctxp->state, ctxp->entry_cnt);
		}
		ctxp->state = LPFC_NVMET_STE_LS_RSP;
		ctxp->entry_cnt++;

		nvmewqeq = lpfc_nvmet_prep_ls_wqe(phba, ctxp, rsp->rspdma,
		rsp->rsplen);
		@@ -751,15 +774,14 @@ lpfc_nvmet_xmt_fcp_abort(struct nvmet_fc_target_port *tgtport,
		unsigned long flags;

		lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS,
		"6103 Abort op: oxri x%x flg x%x cnt %d\n",
		ctxp->oxid, ctxp->flag, ctxp->entry_cnt);
		"6103 NVMET Abort op: oxri x%x flg x%x ste %d\n",
		ctxp->oxid, ctxp->flag, ctxp->state);

		lpfc_nvmeio_data(phba, "NVMET FCP ABRT: "
		"xri x%x flg x%x cnt x%x\n",
		ctxp->oxid, ctxp->flag, ctxp->entry_cnt);
		lpfc_nvmeio_data(phba, "NVMET FCP ABRT: xri x%x flg x%x ste x%x\n",
		ctxp->oxid, ctxp->flag, ctxp->state);

		atomic_inc(&lpfc_nvmep->xmt_fcp_abort);
		ctxp->entry_cnt++;

		spin_lock_irqsave(&ctxp->ctxlock, flags);

		/* Since iaab/iaar are NOT set, we need to check
		@@ -770,11 +792,16 @@ lpfc_nvmet_xmt_fcp_abort(struct nvmet_fc_target_port *tgtport,
		return;
		}
		ctxp->flag \|= LPFC_NVMET_ABORT_OP;
		if (ctxp->flag & LPFC_NVMET_IO_INP)
		lpfc_nvmet_sol_fcp_issue_abort(phba, ctxp, ctxp->sid,

		/* An state of LPFC_NVMET_STE_RCV means we have just received
		* the NVME command and have not started processing it.
		* (by issuing any IO WQEs on this exchange yet)
		*/
		if (ctxp->state == LPFC_NVMET_STE_RCV)
		lpfc_nvmet_unsol_fcp_issue_abort(phba, ctxp, ctxp->sid,
		ctxp->oxid);
		else
		lpfc_nvmet_unsol_fcp_issue_abort(phba, ctxp, ctxp->sid,
		lpfc_nvmet_sol_fcp_issue_abort(phba, ctxp, ctxp->sid,
		ctxp->oxid);
		spin_unlock_irqrestore(&ctxp->ctxlock, flags);
		}
		@@ -790,6 +817,13 @@ lpfc_nvmet_xmt_fcp_release(struct nvmet_fc_target_port *tgtport,
		unsigned long flags;
		bool aborting = false;

		if (ctxp->state != LPFC_NVMET_STE_DONE &&
		ctxp->state != LPFC_NVMET_STE_ABORT) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
		"6413 NVMET release bad state %d %d oxid x%x\n",
		ctxp->state, ctxp->entry_cnt, ctxp->oxid);
		}

		spin_lock_irqsave(&ctxp->ctxlock, flags);
		if ((ctxp->flag & LPFC_NVMET_ABORT_OP) \|\|
		(ctxp->flag & LPFC_NVMET_XBUSY)) {
		@@ -891,6 +925,7 @@ lpfc_nvmet_setup_io_context(struct lpfc_hba *phba)
		return -ENOMEM;
		}
		ctx_buf->context->ctxbuf = ctx_buf;
		ctx_buf->context->state = LPFC_NVMET_STE_FREE;

		ctx_buf->iocbq = lpfc_sli_get_iocbq(phba);
		if (!ctx_buf->iocbq) {
		@@ -1103,7 +1138,7 @@ lpfc_sli4_nvmet_xri_aborted(struct lpfc_hba *phba,
		}

		lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS,
		"6318 XB aborted %x flg x%x (%x)\n",
		"6318 XB aborted oxid %x flg x%x (%x)\n",
		ctxp->oxid, ctxp->flag, released);
		if (released)
		lpfc_nvmet_ctxbuf_post(phba, ctxp->ctxbuf);
		@@ -1253,7 +1288,8 @@ dropit:
		ctxp->oxid = oxid;
		ctxp->sid = sid;
		ctxp->wqeq = NULL;
		ctxp->state = LPFC_NVMET_STE_RCV;
		ctxp->state = LPFC_NVMET_STE_LS_RCV;
		ctxp->entry_cnt = 1;
		ctxp->rqb_buffer = (void *)nvmebuf;

		lpfc_nvmeio_data(phba, "NVMET LS RCV: xri x%x sz %d from %06x\n",
		@@ -1268,8 +1304,8 @@ dropit:
		payload, size);

		lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC,
		"6037 %s: ctx %p sz %d rc %d: %08x %08x %08x "
		"%08x %08x %08x\n", __func__, ctxp, size, rc,
		"6037 NVMET Unsol rcv: sz %d rc %d: %08x %08x %08x "
		"%08x %08x %08x\n", size, rc,
		payload, (payload+1), *(payload+2),
		(payload+3), (payload+4), *(payload+5));

		@@ -1383,6 +1419,11 @@ lpfc_nvmet_unsol_fcp_buffer(struct lpfc_hba *phba,
		sid = sli4_sid_from_fc_hdr(fc_hdr);

		ctxp = (struct lpfc_nvmet_rcv_ctx *)ctx_buf->context;
		if (ctxp->state != LPFC_NVMET_STE_FREE) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
		"6414 NVMET Context corrupt %d %d oxid x%x\n",
		ctxp->state, ctxp->entry_cnt, ctxp->oxid);
		}
		memset(ctxp, 0, sizeof(ctxp->ctx));
		ctxp->wqeq = NULL;
		ctxp->txrdy = NULL;
		@@ -1547,9 +1588,9 @@ lpfc_nvmet_prep_ls_wqe(struct lpfc_hba *phba,

		if (!lpfc_is_link_up(phba)) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC,
		"6104 lpfc_nvmet_prep_ls_wqe: link err: "
		"NPORT x%x oxid:x%x\n",
		ctxp->sid, ctxp->oxid);
		"6104 NVMET prep LS wqe: link err: "
		"NPORT x%x oxid:x%x ste %d\n",
		ctxp->sid, ctxp->oxid, ctxp->state);
		return NULL;
		}

		@@ -1557,9 +1598,9 @@ lpfc_nvmet_prep_ls_wqe(struct lpfc_hba *phba,
		nvmewqe = lpfc_sli_get_iocbq(phba);
		if (nvmewqe == NULL) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC,
		"6105 lpfc_nvmet_prep_ls_wqe: No WQE: "
		"NPORT x%x oxid:x%x\n",
		ctxp->sid, ctxp->oxid);
		"6105 NVMET prep LS wqe: No WQE: "
		"NPORT x%x oxid x%x ste %d\n",
		ctxp->sid, ctxp->oxid, ctxp->state);
		return NULL;
		}

		@@ -1568,9 +1609,9 @@ lpfc_nvmet_prep_ls_wqe(struct lpfc_hba *phba,
		((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
		(ndlp->nlp_state != NLP_STE_MAPPED_NODE))) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC,
		"6106 lpfc_nvmet_prep_ls_wqe: No ndlp: "
		"NPORT x%x oxid:x%x\n",
		ctxp->sid, ctxp->oxid);
		"6106 NVMET prep LS wqe: No ndlp: "
		"NPORT x%x oxid x%x ste %d\n",
		ctxp->sid, ctxp->oxid, ctxp->state);
		goto nvme_wqe_free_wqeq_exit;
		}
		ctxp->wqeq = nvmewqe;
		@@ -1642,9 +1683,9 @@ lpfc_nvmet_prep_ls_wqe(struct lpfc_hba *phba,
		nvmewqe->drvrTimeout = (phba->fc_ratov * 3) + LPFC_DRVR_TIMEOUT;
		nvmewqe->iocb_flag \|= LPFC_IO_NVME_LS;

		/* Xmit NVME response to remote NPORT <did> */
		/* Xmit NVMET response to remote NPORT <did> */
		lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC,
		"6039 Xmit NVME LS response to remote "
		"6039 Xmit NVMET LS response to remote "
		"NPORT x%x iotag:x%x oxid:x%x size:x%x\n",
		ndlp->nlp_DID, nvmewqe->iotag, ctxp->oxid,
		rspsize);
		@@ -1676,9 +1717,9 @@ lpfc_nvmet_prep_fcp_wqe(struct lpfc_hba *phba,

		if (!lpfc_is_link_up(phba)) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
		"6107 lpfc_nvmet_prep_fcp_wqe: link err:"
		"NPORT x%x oxid:x%x\n", ctxp->sid,
		ctxp->oxid);
		"6107 NVMET prep FCP wqe: link err:"
		"NPORT x%x oxid x%x ste %d\n",
		ctxp->sid, ctxp->oxid, ctxp->state);
		return NULL;
		}

		@@ -1687,17 +1728,18 @@ lpfc_nvmet_prep_fcp_wqe(struct lpfc_hba *phba,
		((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
		(ndlp->nlp_state != NLP_STE_MAPPED_NODE))) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
		"6108 lpfc_nvmet_prep_fcp_wqe: no ndlp: "
		"NPORT x%x oxid:x%x\n",
		ctxp->sid, ctxp->oxid);
		"6108 NVMET prep FCP wqe: no ndlp: "
		"NPORT x%x oxid x%x ste %d\n",
		ctxp->sid, ctxp->oxid, ctxp->state);
		return NULL;
		}

		if (rsp->sg_cnt > phba->cfg_nvme_seg_cnt) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
		"6109 lpfc_nvmet_prep_fcp_wqe: seg cnt err: "
		"NPORT x%x oxid:x%x cnt %d\n",
		ctxp->sid, ctxp->oxid, phba->cfg_nvme_seg_cnt);
		"6109 NVMET prep FCP wqe: seg cnt err: "
		"NPORT x%x oxid x%x ste %d cnt %d\n",
		ctxp->sid, ctxp->oxid, ctxp->state,
		phba->cfg_nvme_seg_cnt);
		return NULL;
		}

		@@ -1708,9 +1750,9 @@ lpfc_nvmet_prep_fcp_wqe(struct lpfc_hba *phba,
		nvmewqe = ctxp->ctxbuf->iocbq;
		if (nvmewqe == NULL) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
		"6110 lpfc_nvmet_prep_fcp_wqe: No "
		"WQE: NPORT x%x oxid:x%x\n",
		ctxp->sid, ctxp->oxid);
		"6110 NVMET prep FCP wqe: No "
		"WQE: NPORT x%x oxid x%x ste %d\n",
		ctxp->sid, ctxp->oxid, ctxp->state);
		return NULL;
		}
		ctxp->wqeq = nvmewqe;
		@@ -1722,13 +1764,12 @@ lpfc_nvmet_prep_fcp_wqe(struct lpfc_hba *phba,
		/* Sanity check */
		if (((ctxp->state == LPFC_NVMET_STE_RCV) &&
		(ctxp->entry_cnt == 1)) \|\|
		((ctxp->state == LPFC_NVMET_STE_DATA) &&
		(ctxp->entry_cnt > 1))) {
		(ctxp->state == LPFC_NVMET_STE_DATA)) {
		wqe = (union lpfc_wqe128 *)&nvmewqe->wqe;
		} else {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
		"6111 Wrong state %s: %d cnt %d\n",
		__func__, ctxp->state, ctxp->entry_cnt);
		"6111 Wrong state NVMET FCP: %d cnt %d\n",
		ctxp->state, ctxp->entry_cnt);
		return NULL;
		}

		@@ -1832,7 +1873,6 @@ lpfc_nvmet_prep_fcp_wqe(struct lpfc_hba *phba,
		bf_set(wqe_ar, &wqe->fcp_tsend.wqe_com, 0);
		bf_set(wqe_irsplen, &wqe->fcp_tsend.wqe_com, 0);
		}
		ctxp->state = LPFC_NVMET_STE_DATA;
		break;

		case NVMET_FCOP_WRITEDATA:
		@@ -1923,7 +1963,6 @@ lpfc_nvmet_prep_fcp_wqe(struct lpfc_hba *phba,
		sgl->word2 = cpu_to_le32(sgl->word2);
		sgl->sge_len = 0;
		sgl++;
		ctxp->state = LPFC_NVMET_STE_DATA;
		atomic_inc(&tgtp->xmt_fcp_write);
		break;

		@@ -1980,7 +2019,6 @@ lpfc_nvmet_prep_fcp_wqe(struct lpfc_hba *phba,
		bf_set(wqe_cmd_type, &wqe->fcp_trsp.wqe_com,
		FCP_COMMAND_TRSP);
		bf_set(wqe_sup, &wqe->fcp_tsend.wqe_com, 0);
		ctxp->state = LPFC_NVMET_STE_RSP;

		if (rsp->rsplen == LPFC_NVMET_SUCCESS_LEN) {
		/* Good response - all zero's on wire */
		@@ -2029,6 +2067,8 @@ lpfc_nvmet_prep_fcp_wqe(struct lpfc_hba *phba,
		sgl++;
		ctxp->offset += cnt;
		}
		ctxp->state = LPFC_NVMET_STE_DATA;
		ctxp->entry_cnt++;
		return nvmewqe;
		}

		@@ -2210,13 +2250,28 @@ lpfc_nvmet_xmt_ls_abort_cmp(struct lpfc_hba phba, struct lpfc_iocbq cmdwqe,
		ctxp, wcqe->word0, wcqe->total_data_placed,
		result, wcqe->word3);

		if (ctxp) {
		if (!ctxp) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
		"6415 NVMET LS Abort No ctx: WCQE: "
		"%08x %08x %08x %08x\n",
		wcqe->word0, wcqe->total_data_placed,
		result, wcqe->word3);

		lpfc_sli_release_iocbq(phba, cmdwqe);
		return;
		}

		if (ctxp->state != LPFC_NVMET_STE_LS_ABORT) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
		"6416 NVMET LS abort cmpl state mismatch: "
		"oxid x%x: %d %d\n",
		ctxp->oxid, ctxp->state, ctxp->entry_cnt);
		}

		cmdwqe->context2 = NULL;
		cmdwqe->context3 = NULL;
		lpfc_sli_release_iocbq(phba, cmdwqe);
		kfree(ctxp);
		} else
		lpfc_sli_release_iocbq(phba, cmdwqe);
		}

		static int
		@@ -2240,7 +2295,7 @@ lpfc_nvmet_unsol_issue_abort(struct lpfc_hba *phba,
		((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
		(ndlp->nlp_state != NLP_STE_MAPPED_NODE))) {
		atomic_inc(&tgtp->xmt_abort_rsp_error);
		lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS,
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
		"6134 Drop ABTS - wrong NDLP state x%x.\n",
		(ndlp) ? ndlp->nlp_state : NLP_STE_MAX_STATE);

		@@ -2250,7 +2305,6 @@ lpfc_nvmet_unsol_issue_abort(struct lpfc_hba *phba,

		abts_wqeq = ctxp->wqeq;
		wqe_abts = &abts_wqeq->wqe;
		ctxp->state = LPFC_NVMET_STE_ABORT;

		/*
		* Since we zero the whole WQE, we need to ensure we set the WQE fields
		@@ -2338,7 +2392,7 @@ lpfc_nvmet_sol_fcp_issue_abort(struct lpfc_hba *phba,
		((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
		(ndlp->nlp_state != NLP_STE_MAPPED_NODE))) {
		atomic_inc(&tgtp->xmt_abort_rsp_error);
		lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS,
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
		"6160 Drop ABORT - wrong NDLP state x%x.\n",
		(ndlp) ? ndlp->nlp_state : NLP_STE_MAX_STATE);

		@@ -2351,7 +2405,7 @@ lpfc_nvmet_sol_fcp_issue_abort(struct lpfc_hba *phba,
		ctxp->abort_wqeq = lpfc_sli_get_iocbq(phba);
		if (!ctxp->abort_wqeq) {
		atomic_inc(&tgtp->xmt_abort_rsp_error);
		lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS,
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
		"6161 ABORT failed: No wqeqs: "
		"xri: x%x\n", ctxp->oxid);
		/* No failure to an ABTS request. */
		@@ -2471,6 +2525,15 @@ lpfc_nvmet_unsol_fcp_issue_abort(struct lpfc_hba *phba,
		ctxp->wqeq->hba_wqidx = 0;
		}

		if (ctxp->state == LPFC_NVMET_STE_FREE) {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
		"6417 NVMET ABORT ctx freed %d %d oxid x%x\n",
		ctxp->state, ctxp->entry_cnt, ctxp->oxid);
		rc = WQE_BUSY;
		goto aerr;
		}
		ctxp->state = LPFC_NVMET_STE_ABORT;
		ctxp->entry_cnt++;
		rc = lpfc_nvmet_unsol_issue_abort(phba, ctxp, sid, xri);
		if (rc == 0)
		goto aerr;
		@@ -2490,7 +2553,7 @@ aerr:
		atomic_inc(&tgtp->xmt_abort_rsp_error);
		ctxp->flag &= ~LPFC_NVMET_ABORT_OP;
		atomic_inc(&tgtp->xmt_abort_rsp_error);
		lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS,
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
		"6135 Failed to Issue ABTS for oxid x%x. Status x%x\n",
		ctxp->oxid, rc);
		return 1;
		@@ -2507,12 +2570,24 @@ lpfc_nvmet_unsol_ls_issue_abort(struct lpfc_hba *phba,
		unsigned long flags;
		int rc;

		if ((ctxp->state == LPFC_NVMET_STE_LS_RCV && ctxp->entry_cnt == 1) \|\|
		(ctxp->state == LPFC_NVMET_STE_LS_RSP && ctxp->entry_cnt == 2)) {
		ctxp->state = LPFC_NVMET_STE_LS_ABORT;
		ctxp->entry_cnt++;
		} else {
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
		"6418 NVMET LS abort state mismatch "
		"IO x%x: %d %d\n",
		ctxp->oxid, ctxp->state, ctxp->entry_cnt);
		ctxp->state = LPFC_NVMET_STE_LS_ABORT;
		}

		tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
		if (!ctxp->wqeq) {
		/* Issue ABTS for this WQE based on iotag */
		ctxp->wqeq = lpfc_sli_get_iocbq(phba);
		if (!ctxp->wqeq) {
		lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS,
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
		"6068 Abort failed: No wqeqs: "
		"xri: x%x\n", xri);
		/* No failure to an ABTS request. */
		@@ -2523,7 +2598,10 @@ lpfc_nvmet_unsol_ls_issue_abort(struct lpfc_hba *phba,
		abts_wqeq = ctxp->wqeq;
		wqe_abts = &abts_wqeq->wqe;

		lpfc_nvmet_unsol_issue_abort(phba, ctxp, sid, xri);
		if (lpfc_nvmet_unsol_issue_abort(phba, ctxp, sid, xri) == 0) {
		rc = WQE_BUSY;
		goto out;
		}

		spin_lock_irqsave(&phba->hbalock, flags);
		abts_wqeq->wqe_cmpl = lpfc_nvmet_xmt_ls_abort_cmp;
		@@ -2535,13 +2613,13 @@ lpfc_nvmet_unsol_ls_issue_abort(struct lpfc_hba *phba,
		atomic_inc(&tgtp->xmt_abort_unsol);
		return 0;
		}

		out:
		atomic_inc(&tgtp->xmt_abort_rsp_error);
		abts_wqeq->context2 = NULL;
		abts_wqeq->context3 = NULL;
		lpfc_sli_release_iocbq(phba, abts_wqeq);
		kfree(ctxp);
		lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS,
		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
		"6056 Failed to Issue ABTS. Status x%x\n", rc);
		return 0;
		}

drivers/scsi/lpfc/lpfc_nvmet.h

+8 −6

Original line number	Diff line number	Diff line
		@@ -93,12 +93,14 @@ struct lpfc_nvmet_rcv_ctx {
		uint16_t cpu;
		uint16_t state;
		/* States */
		#define LPFC_NVMET_STE_FREE 0
		#define LPFC_NVMET_STE_RCV 1
		#define LPFC_NVMET_STE_DATA 2
		#define LPFC_NVMET_STE_ABORT 3
		#define LPFC_NVMET_STE_RSP 4
		#define LPFC_NVMET_STE_DONE 5
		#define LPFC_NVMET_STE_LS_RCV 1
		#define LPFC_NVMET_STE_LS_ABORT 2
		#define LPFC_NVMET_STE_LS_RSP 3
		#define LPFC_NVMET_STE_RCV 4
		#define LPFC_NVMET_STE_DATA 5
		#define LPFC_NVMET_STE_ABORT 6
		#define LPFC_NVMET_STE_DONE 7
		#define LPFC_NVMET_STE_FREE 0xff
		uint16_t flag;
		#define LPFC_NVMET_IO_INP 0x1 /* IO is in progress on exchange */
		#define LPFC_NVMET_ABORT_OP 0x2 /* Abort WQE issued on exchange */

Admin message