[SCSI] lpfc 8.3.19: Added support for ELS RRQ command (19ca7609) · Commits · github.com / kvm-riscv / linux

drivers/scsi/lpfc/lpfc.h

+6 −1

Original line number	Diff line number	Diff line
		@@ -486,7 +486,7 @@ struct lpfc_hba {
		int (*lpfc_new_scsi_buf)
		(struct lpfc_vport *, int);
		struct lpfc_scsi_buf * (*lpfc_get_scsi_buf)
		(struct lpfc_hba *);
		(struct lpfc_hba , struct lpfc_nodelist );
		int (*lpfc_scsi_prep_dma_buf)
		(struct lpfc_hba , struct lpfc_scsi_buf );
		void (*lpfc_scsi_unprep_dma_buf)
		@@ -574,6 +574,7 @@ struct lpfc_hba {
		#define HBA_FIP_SUPPORT 0x800 /* FIP support in HBA */
		#define HBA_AER_ENABLED 0x1000 /* AER enabled with HBA */
		#define HBA_DEVLOSS_TMO 0x2000 /* HBA in devloss timeout */
		#define HBA_RRQ_ACTIVE 0x4000 /* process the rrq active list */
		uint32_t fcp_ring_in_use; /* When polling test if intr-hndlr active*/
		struct lpfc_dmabuf slim2p;

		@@ -623,6 +624,7 @@ struct lpfc_hba {
		/* HBA Config Parameters */
		uint32_t cfg_ack0;
		uint32_t cfg_enable_npiv;
		uint32_t cfg_enable_rrq;
		uint32_t cfg_topology;
		uint32_t cfg_link_speed;
		uint32_t cfg_cr_delay;
		@@ -733,6 +735,7 @@ struct lpfc_hba {
		uint32_t total_scsi_bufs;
		struct list_head lpfc_iocb_list;
		uint32_t total_iocbq_bufs;
		struct list_head active_rrq_list;
		spinlock_t hbalock;

		/* pci_mem_pools */
		@@ -745,6 +748,7 @@ struct lpfc_hba {

		mempool_t *mbox_mem_pool;
		mempool_t *nlp_mem_pool;
		mempool_t *rrq_pool;

		struct fc_host_statistics link_stats;
		enum intr_type_t intr_type;
		@@ -801,6 +805,7 @@ struct lpfc_hba {
		unsigned long skipped_hb;
		struct timer_list hb_tmofunc;
		uint8_t hb_outstanding;
		struct timer_list rrq_tmr;
		enum hba_temp_state over_temp_state;
		/* ndlp reference management */
		spinlock_t ndlp_lock;

drivers/scsi/lpfc/lpfc_attr.c

+9 −0

Original line number	Diff line number	Diff line
		@@ -1977,6 +1977,13 @@ lpfc_param_show(enable_npiv);
		lpfc_param_init(enable_npiv, 1, 0, 1);
		static DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO, lpfc_enable_npiv_show, NULL);

		int lpfc_enable_rrq;
		module_param(lpfc_enable_rrq, int, 0);
		MODULE_PARM_DESC(lpfc_enable_rrq, "Enable RRQ functionality");
		lpfc_param_show(enable_rrq);
		lpfc_param_init(enable_rrq, 0, 0, 1);
		static DEVICE_ATTR(lpfc_enable_rrq, S_IRUGO, lpfc_enable_rrq_show, NULL);

		/*
		# lpfc_suppress_link_up: Bring link up at initialization
		# 0x0 = bring link up (issue MBX_INIT_LINK)
		@@ -3394,6 +3401,7 @@ struct device_attribute *lpfc_hba_attrs[] = {
		&dev_attr_lpfc_fdmi_on,
		&dev_attr_lpfc_max_luns,
		&dev_attr_lpfc_enable_npiv,
		&dev_attr_lpfc_enable_rrq,
		&dev_attr_nport_evt_cnt,
		&dev_attr_board_mode,
		&dev_attr_max_vpi,
		@@ -4610,6 +4618,7 @@ lpfc_get_cfgparam(struct lpfc_hba *phba)
		lpfc_link_speed_init(phba, lpfc_link_speed);
		lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
		lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
		lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
		lpfc_use_msi_init(phba, lpfc_use_msi);
		lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
		lpfc_fcp_wq_count_init(phba, lpfc_fcp_wq_count);

drivers/scsi/lpfc/lpfc_crtn.h

+10 −2

Original line number	Diff line number	Diff line
		@@ -416,5 +416,13 @@ struct lpfc_iocbq lpfc_sli_ringtx_get(struct lpfc_hba ,
		int __lpfc_sli_issue_iocb(struct lpfc_hba *, uint32_t,
		struct lpfc_iocbq *, uint32_t);
		uint32_t lpfc_drain_txq(struct lpfc_hba *);


		void lpfc_clr_rrq_active(struct lpfc_hba , uint16_t, struct lpfc_node_rrq );
		int lpfc_test_rrq_active(struct lpfc_hba , struct lpfc_nodelist , uint16_t);
		void lpfc_handle_rrq_active(struct lpfc_hba *);
		int lpfc_send_rrq(struct lpfc_hba , struct lpfc_node_rrq );
		int lpfc_set_rrq_active(struct lpfc_hba , struct lpfc_nodelist ,
		uint16_t, uint16_t, uint16_t);
		void lpfc_cleanup_wt_rrqs(struct lpfc_hba *);
		void lpfc_cleanup_vports_rrqs(struct lpfc_vport *);
		struct lpfc_node_rrq lpfc_get_active_rrq(struct lpfc_vport , uint16_t,
		uint32_t);

drivers/scsi/lpfc/lpfc_disc.h

+17 −0

Original line number	Diff line number	Diff line
		@@ -68,6 +68,12 @@ struct lpfc_fast_path_event {
		} un;
		};

		#define LPFC_SLI4_MAX_XRI 1024 /* Used to make the ndlp's xri_bitmap */
		#define XRI_BITMAP_ULONGS (LPFC_SLI4_MAX_XRI / BITS_PER_LONG)
		struct lpfc_node_rrqs {
		unsigned long xri_bitmap[XRI_BITMAP_ULONGS];
		};

		struct lpfc_nodelist {
		struct list_head nlp_listp;
		struct lpfc_name nlp_portname;
		@@ -110,8 +116,19 @@ struct lpfc_nodelist {
		atomic_t cmd_pending;
		uint32_t cmd_qdepth;
		unsigned long last_change_time;
		struct lpfc_node_rrqs active_rrqs;
		struct lpfc_scsicmd_bkt lat_data; / Latency data */
		};
		struct lpfc_node_rrq {
		struct list_head list;
		uint16_t xritag;
		uint16_t send_rrq;
		uint16_t rxid;
		uint32_t nlp_DID; /* FC D_ID of entry */
		struct lpfc_vport *vport;
		struct lpfc_nodelist *ndlp;
		unsigned long rrq_stop_time;
		};

		/* Defines for nlp_flag (uint32) */
		#define NLP_IGNR_REG_CMPL 0x00000001 /* Rcvd rscn before we cmpl reg login */

drivers/scsi/lpfc/lpfc_els.c

+231 −1

Original line number	Diff line number	Diff line
		@@ -1290,6 +1290,7 @@ lpfc_plogi_confirm_nport(struct lpfc_hba phba, uint32_t prsp,
		uint32_t rc, keepDID = 0;
		int put_node;
		int put_rport;
		struct lpfc_node_rrqs rrq;

		/* Fabric nodes can have the same WWPN so we don't bother searching
		* by WWPN. Just return the ndlp that was given to us.
		@@ -1307,6 +1308,7 @@ lpfc_plogi_confirm_nport(struct lpfc_hba phba, uint32_t prsp,

		if (new_ndlp == ndlp && NLP_CHK_NODE_ACT(new_ndlp))
		return ndlp;
		memset(&rrq.xri_bitmap, 0, sizeof(new_ndlp->active_rrqs.xri_bitmap));

		if (!new_ndlp) {
		rc = memcmp(&ndlp->nlp_portname, name,
		@@ -1327,12 +1329,25 @@ lpfc_plogi_confirm_nport(struct lpfc_hba phba, uint32_t prsp,
		if (!new_ndlp)
		return ndlp;
		keepDID = new_ndlp->nlp_DID;
		} else
		if (phba->sli_rev == LPFC_SLI_REV4)
		memcpy(&rrq.xri_bitmap,
		&new_ndlp->active_rrqs.xri_bitmap,
		sizeof(new_ndlp->active_rrqs.xri_bitmap));
		} else {
		keepDID = new_ndlp->nlp_DID;
		if (phba->sli_rev == LPFC_SLI_REV4)
		memcpy(&rrq.xri_bitmap,
		&new_ndlp->active_rrqs.xri_bitmap,
		sizeof(new_ndlp->active_rrqs.xri_bitmap));
		}

		lpfc_unreg_rpi(vport, new_ndlp);
		new_ndlp->nlp_DID = ndlp->nlp_DID;
		new_ndlp->nlp_prev_state = ndlp->nlp_prev_state;
		if (phba->sli_rev == LPFC_SLI_REV4)
		memcpy(new_ndlp->active_rrqs.xri_bitmap,
		&ndlp->active_rrqs.xri_bitmap,
		sizeof(ndlp->active_rrqs.xri_bitmap));

		if (ndlp->nlp_flag & NLP_NPR_2B_DISC)
		new_ndlp->nlp_flag \|= NLP_NPR_2B_DISC;
		@@ -1371,12 +1386,20 @@ lpfc_plogi_confirm_nport(struct lpfc_hba phba, uint32_t prsp,

		/* Two ndlps cannot have the same did on the nodelist */
		ndlp->nlp_DID = keepDID;
		if (phba->sli_rev == LPFC_SLI_REV4)
		memcpy(&ndlp->active_rrqs.xri_bitmap,
		&rrq.xri_bitmap,
		sizeof(ndlp->active_rrqs.xri_bitmap));
		lpfc_drop_node(vport, ndlp);
		}
		else {
		lpfc_unreg_rpi(vport, ndlp);
		/* Two ndlps cannot have the same did */
		ndlp->nlp_DID = keepDID;
		if (phba->sli_rev == LPFC_SLI_REV4)
		memcpy(&ndlp->active_rrqs.xri_bitmap,
		&rrq.xri_bitmap,
		sizeof(ndlp->active_rrqs.xri_bitmap));
		lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
		/* Since we are swapping the ndlp passed in with the new one
		* and the did has already been swapped, copy over the
		@@ -1436,6 +1459,73 @@ lpfc_end_rscn(struct lpfc_vport *vport)
		}
		}

		/**
		* lpfc_cmpl_els_rrq - Completion handled for els RRQs.
		* @phba: pointer to lpfc hba data structure.
		* @cmdiocb: pointer to lpfc command iocb data structure.
		* @rspiocb: pointer to lpfc response iocb data structure.
		*
		* This routine will call the clear rrq function to free the rrq and
		* clear the xri's bit in the ndlp's xri_bitmap. If the ndlp does not
		* exist then the clear_rrq is still called because the rrq needs to
		* be freed.
		**/

		static void
		lpfc_cmpl_els_rrq(struct lpfc_hba phba, struct lpfc_iocbq cmdiocb,
		struct lpfc_iocbq *rspiocb)
		{
		struct lpfc_vport *vport = cmdiocb->vport;
		IOCB_t *irsp;
		struct lpfc_nodelist *ndlp;
		struct lpfc_node_rrq *rrq;

		/* we pass cmdiocb to state machine which needs rspiocb as well */
		rrq = cmdiocb->context_un.rrq;
		cmdiocb->context_un.rsp_iocb = rspiocb;

		irsp = &rspiocb->iocb;
		lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
		"RRQ cmpl: status:x%x/x%x did:x%x",
		irsp->ulpStatus, irsp->un.ulpWord[4],
		irsp->un.elsreq64.remoteID);

		ndlp = lpfc_findnode_did(vport, irsp->un.elsreq64.remoteID);
		if (!ndlp \|\| !NLP_CHK_NODE_ACT(ndlp) \|\| ndlp != rrq->ndlp) {
		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
		"2882 RRQ completes to NPort x%x "
		"with no ndlp. Data: x%x x%x x%x\n",
		irsp->un.elsreq64.remoteID,
		irsp->ulpStatus, irsp->un.ulpWord[4],
		irsp->ulpIoTag);
		goto out;
		}

		/* rrq completes to NPort <nlp_DID> */
		lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
		"2880 RRQ completes to NPort x%x "
		"Data: x%x x%x x%x x%x x%x\n",
		ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
		irsp->ulpTimeout, rrq->xritag, rrq->rxid);

		if (irsp->ulpStatus) {
		/* Check for retry */
		/* RRQ failed Don't print the vport to vport rjts */
		if (irsp->ulpStatus != IOSTAT_LS_RJT \|\|
		(((irsp->un.ulpWord[4]) >> 16 != LSRJT_INVALID_CMD) &&
		((irsp->un.ulpWord[4]) >> 16 != LSRJT_UNABLE_TPC)) \|\|
		(phba)->pport->cfg_log_verbose & LOG_ELS)
		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
		"2881 RRQ failure DID:%06X Status:x%x/x%x\n",
		ndlp->nlp_DID, irsp->ulpStatus,
		irsp->un.ulpWord[4]);
		}
		out:
		if (rrq)
		lpfc_clr_rrq_active(phba, rrq->xritag, rrq);
		lpfc_els_free_iocb(phba, cmdiocb);
		return;
		}
		/**
		* lpfc_cmpl_els_plogi - Completion callback function for plogi
		* @phba: pointer to lpfc hba data structure.
		@@ -3912,6 +4002,47 @@ lpfc_els_rsp_rnid_acc(struct lpfc_vport *vport, uint8_t format,
		return 0;
		}

		/**
		* lpfc_els_clear_rrq - Clear the rq that this rrq describes.
		* @vport: pointer to a virtual N_Port data structure.
		* @iocb: pointer to the lpfc command iocb data structure.
		* @ndlp: pointer to a node-list data structure.
		*
		* Return
		**/
		static void
		lpfc_els_clear_rrq(struct lpfc_vport *vport,
		struct lpfc_iocbq iocb, struct lpfc_nodelist ndlp)
		{
		struct lpfc_hba *phba = vport->phba;
		uint8_t *pcmd;
		struct RRQ *rrq;
		uint16_t rxid;
		struct lpfc_node_rrq *prrq;


		pcmd = (uint8_t ) (((struct lpfc_dmabuf ) iocb->context2)->virt);
		pcmd += sizeof(uint32_t);
		rrq = (struct RRQ *)pcmd;
		rxid = bf_get(rrq_oxid, rrq);

		lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
		"2883 Clear RRQ for SID:x%x OXID:x%x RXID:x%x"
		" x%x x%x\n",
		bf_get(rrq_did, rrq),
		bf_get(rrq_oxid, rrq),
		rxid,
		iocb->iotag, iocb->iocb.ulpContext);

		lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
		"Clear RRQ: did:x%x flg:x%x exchg:x%.08x",
		ndlp->nlp_DID, ndlp->nlp_flag, rrq->rrq_exchg);
		prrq = lpfc_get_active_rrq(vport, rxid, ndlp->nlp_DID);
		if (prrq)
		lpfc_clr_rrq_active(phba, rxid, prrq);
		return;
		}

		/**
		* lpfc_els_rsp_echo_acc - Issue echo acc response
		* @vport: pointer to a virtual N_Port data structure.
		@@ -4801,6 +4932,8 @@ lpfc_els_rcv_rrq(struct lpfc_vport vport, struct lpfc_iocbq cmdiocb,
		struct lpfc_nodelist *ndlp)
		{
		lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
		if (vport->phba->sli_rev == LPFC_SLI_REV4)
		lpfc_els_clear_rrq(vport, cmdiocb, ndlp);
		}

		/**
		@@ -5203,6 +5336,97 @@ lpfc_els_rcv_rps(struct lpfc_vport vport, struct lpfc_iocbq cmdiocb,
		return 0;
		}

		/* lpfc_issue_els_rrq - Process an unsolicited rps iocb
		* @vport: pointer to a host virtual N_Port data structure.
		* @ndlp: pointer to a node-list data structure.
		* @did: DID of the target.
		* @rrq: Pointer to the rrq struct.
		*
		* Build a ELS RRQ command and send it to the target. If the issue_iocb is
		* Successful the the completion handler will clear the RRQ.
		*
		* Return codes
		* 0 - Successfully sent rrq els iocb.
		* 1 - Failed to send rrq els iocb.
		**/
		static int
		lpfc_issue_els_rrq(struct lpfc_vport vport, struct lpfc_nodelist ndlp,
		uint32_t did, struct lpfc_node_rrq *rrq)
		{
		struct lpfc_hba *phba = vport->phba;
		struct RRQ *els_rrq;
		IOCB_t *icmd;
		struct lpfc_iocbq *elsiocb;
		uint8_t *pcmd;
		uint16_t cmdsize;
		int ret;


		if (ndlp != rrq->ndlp)
		ndlp = rrq->ndlp;
		if (!ndlp \|\| !NLP_CHK_NODE_ACT(ndlp))
		return 1;

		/* If ndlp is not NULL, we will bump the reference count on it */
		cmdsize = (sizeof(uint32_t) + sizeof(struct RRQ));
		elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, 0, ndlp, did,
		ELS_CMD_RRQ);
		if (!elsiocb)
		return 1;

		icmd = &elsiocb->iocb;
		pcmd = (uint8_t ) (((struct lpfc_dmabuf ) elsiocb->context2)->virt);

		/* For RRQ request, remainder of payload is Exchange IDs */
		((uint32_t ) (pcmd)) = ELS_CMD_RRQ;
		pcmd += sizeof(uint32_t);
		els_rrq = (struct RRQ *) pcmd;

		bf_set(rrq_oxid, els_rrq, rrq->xritag);
		bf_set(rrq_rxid, els_rrq, rrq->rxid);
		bf_set(rrq_did, els_rrq, vport->fc_myDID);
		els_rrq->rrq = cpu_to_be32(els_rrq->rrq);
		els_rrq->rrq_exchg = cpu_to_be32(els_rrq->rrq_exchg);


		lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
		"Issue RRQ: did:x%x",
		did, rrq->xritag, rrq->rxid);
		elsiocb->context_un.rrq = rrq;
		elsiocb->iocb_cmpl = lpfc_cmpl_els_rrq;
		ret = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);

		if (ret == IOCB_ERROR) {
		lpfc_els_free_iocb(phba, elsiocb);
		return 1;
		}
		return 0;
		}

		/**
		* lpfc_send_rrq - Sends ELS RRQ if needed.
		* @phba: pointer to lpfc hba data structure.
		* @rrq: pointer to the active rrq.
		*
		* This routine will call the lpfc_issue_els_rrq if the rrq is
		* still active for the xri. If this function returns a failure then
		* the caller needs to clean up the RRQ by calling lpfc_clr_active_rrq.
		*
		* Returns 0 Success.
		* 1 Failure.
		**/
		int
		lpfc_send_rrq(struct lpfc_hba phba, struct lpfc_node_rrq rrq)
		{
		struct lpfc_nodelist *ndlp = lpfc_findnode_did(rrq->vport,
		rrq->nlp_DID);
		if (lpfc_test_rrq_active(phba, ndlp, rrq->xritag))
		return lpfc_issue_els_rrq(rrq->vport, ndlp,
		rrq->nlp_DID, rrq);
		else
		return 1;
		}

		/**
		* lpfc_els_rsp_rpl_acc - Issue an accept rpl els command
		* @vport: pointer to a host virtual N_Port data structure.
		@@ -7373,8 +7597,11 @@ lpfc_sli4_els_xri_aborted(struct lpfc_hba *phba,
		struct sli4_wcqe_xri_aborted *axri)
		{
		uint16_t xri = bf_get(lpfc_wcqe_xa_xri, axri);
		uint16_t rxid = bf_get(lpfc_wcqe_xa_remote_xid, axri);

		struct lpfc_sglq sglq_entry = NULL, sglq_next = NULL;
		unsigned long iflag = 0;
		struct lpfc_nodelist *ndlp;
		struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];

		spin_lock_irqsave(&phba->hbalock, iflag);
		@@ -7383,11 +7610,14 @@ lpfc_sli4_els_xri_aborted(struct lpfc_hba *phba,
		&phba->sli4_hba.lpfc_abts_els_sgl_list, list) {
		if (sglq_entry->sli4_xritag == xri) {
		list_del(&sglq_entry->list);
		ndlp = sglq_entry->ndlp;
		sglq_entry->ndlp = NULL;
		list_add_tail(&sglq_entry->list,
		&phba->sli4_hba.lpfc_sgl_list);
		sglq_entry->state = SGL_FREED;
		spin_unlock(&phba->sli4_hba.abts_sgl_list_lock);
		spin_unlock_irqrestore(&phba->hbalock, iflag);
		lpfc_set_rrq_active(phba, ndlp, xri, rxid, 1);

		/* Check if TXQ queue needs to be serviced */
		if (pring->txq_cnt)