Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7d791df7 authored by James Smart's avatar James Smart Committed by James Bottomley
Browse files

[SCSI] lpfc 8.3.25: Add FCF priority failover functionality 



This patch implements a new FCF failover policy for the lpfc driver. It
allows the driver to choose which FCF to failover to based on the FCF
priority. This patch also introduces a new sysfs parameter
(fcf_failover_policy) to allow the user to choose which FCF failover policy
to use.

Signed-off-by: default avatarAlex Iannicelli <alex.iannicelli@emulex.com>
Signed-off-by: default avatarJames Smart <james.smart@emulex.com>
Signed-off-by: default avatarJames Bottomley <JBottomley@Parallels.com>
parent b76f2dc9

drivers/scsi/lpfc/lpfc.h

+3 −0
Original line number Diff line number Diff line
@@ -680,6 +680,9 @@ struct lpfc_hba { 
	uint32_t cfg_enable_rrq;

	uint32_t cfg_topology;

	uint32_t cfg_link_speed;

#define LPFC_FCF_FOV 1		/* Fast fcf failover */

#define LPFC_FCF_PRIORITY 2	/* Priority fcf failover */

	uint32_t cfg_fcf_failover_policy;

	uint32_t cfg_cr_delay;

	uint32_t cfg_cr_count;

	uint32_t cfg_multi_ring_support;

drivers/scsi/lpfc/lpfc_attr.c

+5 −0
Original line number Diff line number Diff line
@@ -2193,6 +2193,9 @@ 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);



LPFC_ATTR_R(fcf_failover_policy, 1, 1, 2,

	"FCF Fast failover=1 Priority failover=2");



int lpfc_enable_rrq;

module_param(lpfc_enable_rrq, int, S_IRUGO);

MODULE_PARM_DESC(lpfc_enable_rrq, "Enable RRQ functionality");
@@ -3775,6 +3778,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_fcf_failover_policy,

	&dev_attr_lpfc_enable_rrq,

	&dev_attr_nport_evt_cnt,

	&dev_attr_board_mode,
@@ -4995,6 +4999,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_fcf_failover_policy_init(phba, lpfc_fcf_failover_policy);

	lpfc_enable_rrq_init(phba, lpfc_enable_rrq);

	lpfc_use_msi_init(phba, lpfc_use_msi);

	lpfc_fcp_imax_init(phba, lpfc_fcp_imax);

drivers/scsi/lpfc/lpfc_crtn.h

+2 −0
Original line number Diff line number Diff line
@@ -235,9 +235,11 @@ int lpfc_sli4_redisc_fcf_table(struct lpfc_hba *); 
void lpfc_fcf_redisc_wait_start_timer(struct lpfc_hba *);

void lpfc_sli4_fcf_dead_failthrough(struct lpfc_hba *);

uint16_t lpfc_sli4_fcf_rr_next_index_get(struct lpfc_hba *);

void lpfc_sli4_set_fcf_flogi_fail(struct lpfc_hba *, uint16_t);

int lpfc_sli4_fcf_rr_index_set(struct lpfc_hba *, uint16_t);

void lpfc_sli4_fcf_rr_index_clear(struct lpfc_hba *, uint16_t);

int lpfc_sli4_fcf_rr_next_proc(struct lpfc_vport *, uint16_t);

void lpfc_sli4_clear_fcf_rr_bmask(struct lpfc_hba *);



int lpfc_mem_alloc(struct lpfc_hba *, int align);

void lpfc_mem_free(struct lpfc_hba *);

drivers/scsi/lpfc/lpfc_els.c

+2 −0
Original line number Diff line number Diff line
@@ -874,6 +874,8 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 
					phba->fcf.current_rec.fcf_indx,

					irsp->ulpStatus, irsp->un.ulpWord[4],

					irsp->ulpTimeout);

			lpfc_sli4_set_fcf_flogi_fail(phba,

					phba->fcf.current_rec.fcf_indx);

			fcf_index = lpfc_sli4_fcf_rr_next_index_get(phba);

			rc = lpfc_sli4_fcf_rr_next_proc(vport, fcf_index);

			if (rc)

drivers/scsi/lpfc/lpfc_hbadisc.c

+212 −8
Original line number Diff line number Diff line
@@ -1109,6 +1109,28 @@ out: 
	return;

}



/**

 * lpfc_sli4_clear_fcf_rr_bmask

 * @phba pointer to the struct lpfc_hba for this port.

 * This fucnction resets the round robin bit mask and clears the

 * fcf priority list. The list deletions are done while holding the

 * hbalock. The ON_LIST flag and the FLOGI_FAILED flags are cleared

 * from the lpfc_fcf_pri record.

 **/

void

lpfc_sli4_clear_fcf_rr_bmask(struct lpfc_hba *phba)

{

	struct lpfc_fcf_pri *fcf_pri;

	struct lpfc_fcf_pri *next_fcf_pri;

	memset(phba->fcf.fcf_rr_bmask, 0, sizeof(*phba->fcf.fcf_rr_bmask));

	spin_lock_irq(&phba->hbalock);

	list_for_each_entry_safe(fcf_pri, next_fcf_pri,

				&phba->fcf.fcf_pri_list, list) {

		list_del_init(&fcf_pri->list);

		fcf_pri->fcf_rec.flag = 0;

	}

	spin_unlock_irq(&phba->hbalock);

}

static void

lpfc_mbx_cmpl_reg_fcfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)

{
@@ -1130,7 +1152,8 @@ lpfc_mbx_cmpl_reg_fcfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq) 
	spin_unlock_irq(&phba->hbalock);



	/* If there is a pending FCoE event, restart FCF table scan. */

	if (lpfc_check_pending_fcoe_event(phba, LPFC_UNREG_FCF))

	if ((!(phba->hba_flag & FCF_RR_INPROG)) &&

		lpfc_check_pending_fcoe_event(phba, LPFC_UNREG_FCF))

		goto fail_out;



	/* Mark successful completion of FCF table scan */
@@ -1249,6 +1272,30 @@ lpfc_vlan_id_match(uint16_t curr_vlan_id, uint16_t new_vlan_id) 
	return (curr_vlan_id == new_vlan_id);

}



/**

 * lpfc_update_fcf_record - Update driver fcf record

 * __lpfc_update_fcf_record_pri - update the lpfc_fcf_pri record.

 * @phba: pointer to lpfc hba data structure.

 * @fcf_index: Index for the lpfc_fcf_record.

 * @new_fcf_record: pointer to hba fcf record.

 *

 * This routine updates the driver FCF priority record from the new HBA FCF

 * record. This routine is called with the host lock held.

 **/

static void

__lpfc_update_fcf_record_pri(struct lpfc_hba *phba, uint16_t fcf_index,

				 struct fcf_record *new_fcf_record

				 )

{

	struct lpfc_fcf_pri *fcf_pri;



	fcf_pri = &phba->fcf.fcf_pri[fcf_index];

	fcf_pri->fcf_rec.fcf_index = fcf_index;

	/* FCF record priority */

	fcf_pri->fcf_rec.priority = new_fcf_record->fip_priority;



}



/**

 * lpfc_copy_fcf_record - Copy fcf information to lpfc_hba.

 * @fcf: pointer to driver fcf record.
@@ -1332,6 +1379,9 @@ __lpfc_update_fcf_record(struct lpfc_hba *phba, struct lpfc_fcf_rec *fcf_rec, 
	fcf_rec->addr_mode = addr_mode;

	fcf_rec->vlan_id = vlan_id;

	fcf_rec->flag |= (flag | RECORD_VALID);

	__lpfc_update_fcf_record_pri(phba,

		bf_get(lpfc_fcf_record_fcf_index, new_fcf_record),

				 new_fcf_record);

}



/**
@@ -1834,6 +1884,8 @@ lpfc_sli4_fcf_record_match(struct lpfc_hba *phba, 
		return false;

	if (!lpfc_fab_name_match(fcf_rec->fabric_name, new_fcf_record))

		return false;

	if (fcf_rec->priority != new_fcf_record->fip_priority)

		return false;

	return true;

}
@@ -1896,6 +1948,152 @@ stop_flogi_current_fcf: 
	return 1;

}



/**

 * lpfc_sli4_fcf_pri_list_del

 * @phba: pointer to lpfc hba data structure.

 * @fcf_index the index of the fcf record to delete

 * This routine checks the on list flag of the fcf_index to be deleted.

 * If it is one the list then it is removed from the list, and the flag

 * is cleared. This routine grab the hbalock before removing the fcf

 * record from the list.

 **/

static void lpfc_sli4_fcf_pri_list_del(struct lpfc_hba *phba,

			uint16_t fcf_index)

{

	struct lpfc_fcf_pri *new_fcf_pri;



	new_fcf_pri = &phba->fcf.fcf_pri[fcf_index];

	lpfc_printf_log(phba, KERN_INFO, LOG_FIP,

		"3058 deleting idx x%x pri x%x flg x%x\n",

		fcf_index, new_fcf_pri->fcf_rec.priority,

		 new_fcf_pri->fcf_rec.flag);

	spin_lock_irq(&phba->hbalock);

	if (new_fcf_pri->fcf_rec.flag & LPFC_FCF_ON_PRI_LIST) {

		if (phba->fcf.current_rec.priority ==

				new_fcf_pri->fcf_rec.priority)

			phba->fcf.eligible_fcf_cnt--;

		list_del_init(&new_fcf_pri->list);

		new_fcf_pri->fcf_rec.flag &= ~LPFC_FCF_ON_PRI_LIST;

	}

	spin_unlock_irq(&phba->hbalock);

}



/**

 * lpfc_sli4_set_fcf_flogi_fail

 * @phba: pointer to lpfc hba data structure.

 * @fcf_index the index of the fcf record to update

 * This routine acquires the hbalock and then set the LPFC_FCF_FLOGI_FAILED

 * flag so the the round robin slection for the particular priority level

 * will try a different fcf record that does not have this bit set.

 * If the fcf record is re-read for any reason this flag is cleared brfore

 * adding it to the priority list.

 **/

void

lpfc_sli4_set_fcf_flogi_fail(struct lpfc_hba *phba, uint16_t fcf_index)

{

	struct lpfc_fcf_pri *new_fcf_pri;

	new_fcf_pri = &phba->fcf.fcf_pri[fcf_index];

	spin_lock_irq(&phba->hbalock);

	new_fcf_pri->fcf_rec.flag |= LPFC_FCF_FLOGI_FAILED;

	spin_unlock_irq(&phba->hbalock);

}



/**

 * lpfc_sli4_fcf_pri_list_add

 * @phba: pointer to lpfc hba data structure.

 * @fcf_index the index of the fcf record to add

 * This routine checks the priority of the fcf_index to be added.

 * If it is a lower priority than the current head of the fcf_pri list

 * then it is added to the list in the right order.

 * If it is the same priority as the current head of the list then it

 * is added to the head of the list and its bit in the rr_bmask is set.

 * If the fcf_index to be added is of a higher priority than the current

 * head of the list then the rr_bmask is cleared, its bit is set in the

 * rr_bmask and it is added to the head of the list.

 * returns:

 * 0=success 1=failure

 **/

int lpfc_sli4_fcf_pri_list_add(struct lpfc_hba *phba, uint16_t fcf_index,

	struct fcf_record *new_fcf_record)

{

	uint16_t current_fcf_pri;

	uint16_t last_index;

	struct lpfc_fcf_pri *fcf_pri;

	struct lpfc_fcf_pri *next_fcf_pri;

	struct lpfc_fcf_pri *new_fcf_pri;

	int ret;



	new_fcf_pri = &phba->fcf.fcf_pri[fcf_index];

	lpfc_printf_log(phba, KERN_INFO, LOG_FIP,

		"3059 adding idx x%x pri x%x flg x%x\n",

		fcf_index, new_fcf_record->fip_priority,

		 new_fcf_pri->fcf_rec.flag);

	spin_lock_irq(&phba->hbalock);

	if (new_fcf_pri->fcf_rec.flag & LPFC_FCF_ON_PRI_LIST)

		list_del_init(&new_fcf_pri->list);

	new_fcf_pri->fcf_rec.fcf_index = fcf_index;

	new_fcf_pri->fcf_rec.priority = new_fcf_record->fip_priority;

	if (list_empty(&phba->fcf.fcf_pri_list)) {

		list_add(&new_fcf_pri->list, &phba->fcf.fcf_pri_list);

		ret = lpfc_sli4_fcf_rr_index_set(phba,

				new_fcf_pri->fcf_rec.fcf_index);

		goto out;

	}



	last_index = find_first_bit(phba->fcf.fcf_rr_bmask,

				LPFC_SLI4_FCF_TBL_INDX_MAX);

	if (last_index >= LPFC_SLI4_FCF_TBL_INDX_MAX) {

		ret = 0; /* Empty rr list */

		goto out;

	}

	current_fcf_pri = phba->fcf.fcf_pri[last_index].fcf_rec.priority;

	if (new_fcf_pri->fcf_rec.priority <=  current_fcf_pri) {

		list_add(&new_fcf_pri->list, &phba->fcf.fcf_pri_list);

		if (new_fcf_pri->fcf_rec.priority <  current_fcf_pri) {

			memset(phba->fcf.fcf_rr_bmask, 0,

				sizeof(*phba->fcf.fcf_rr_bmask));

			/* fcfs_at_this_priority_level = 1; */

			phba->fcf.eligible_fcf_cnt = 1;

		} else

			/* fcfs_at_this_priority_level++; */

			phba->fcf.eligible_fcf_cnt++;

		ret = lpfc_sli4_fcf_rr_index_set(phba,

				new_fcf_pri->fcf_rec.fcf_index);

		goto out;

	}



	list_for_each_entry_safe(fcf_pri, next_fcf_pri,

				&phba->fcf.fcf_pri_list, list) {

		if (new_fcf_pri->fcf_rec.priority <=

				fcf_pri->fcf_rec.priority) {

			if (fcf_pri->list.prev == &phba->fcf.fcf_pri_list)

				list_add(&new_fcf_pri->list,

						&phba->fcf.fcf_pri_list);

			else

				list_add(&new_fcf_pri->list,

					 &((struct lpfc_fcf_pri *)

					fcf_pri->list.prev)->list);

			ret = 0;

			goto out;

		} else if (fcf_pri->list.next == &phba->fcf.fcf_pri_list

			|| new_fcf_pri->fcf_rec.priority <

				next_fcf_pri->fcf_rec.priority) {

			list_add(&new_fcf_pri->list, &fcf_pri->list);

			ret = 0;

			goto out;

		}

		if (new_fcf_pri->fcf_rec.priority > fcf_pri->fcf_rec.priority)

			continue;



	}

	ret = 1;

out:

	/* we use = instead of |= to clear the FLOGI_FAILED flag. */

	new_fcf_pri->fcf_rec.flag = LPFC_FCF_ON_PRI_LIST;

	spin_unlock_irq(&phba->hbalock);

	return ret;

}



/**

 * lpfc_mbx_cmpl_fcf_scan_read_fcf_rec - fcf scan read_fcf mbox cmpl handler.

 * @phba: pointer to lpfc hba data structure.
@@ -1958,6 +2156,9 @@ lpfc_mbx_cmpl_fcf_scan_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq) 
	 * record for roundrobin FCF failover.

	 */

	if (!rc) {

		lpfc_sli4_fcf_pri_list_del(phba,

					bf_get(lpfc_fcf_record_fcf_index,

					       new_fcf_record));

		lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,

				"2781 FCF (x%x) failed connection "

				"list check: (x%x/x%x)\n",
@@ -2005,7 +2206,8 @@ lpfc_mbx_cmpl_fcf_scan_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq) 
		goto read_next_fcf;

	} else {

		fcf_index = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);

		rc = lpfc_sli4_fcf_rr_index_set(phba, fcf_index);

		rc = lpfc_sli4_fcf_pri_list_add(phba, fcf_index,

							new_fcf_record);

		if (rc)

			goto read_next_fcf;

	}
@@ -2018,7 +2220,8 @@ lpfc_mbx_cmpl_fcf_scan_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq) 
	 */

	spin_lock_irq(&phba->hbalock);

	if (phba->fcf.fcf_flag & FCF_IN_USE) {

		if (lpfc_sli4_fcf_record_match(phba, &phba->fcf.current_rec,

		if (phba->cfg_fcf_failover_policy == LPFC_FCF_FOV &&

			lpfc_sli4_fcf_record_match(phba, &phba->fcf.current_rec,

		    new_fcf_record, vlan_id)) {

			if (bf_get(lpfc_fcf_record_fcf_index, new_fcf_record) ==

			    phba->fcf.current_rec.fcf_indx) {
@@ -2232,7 +2435,8 @@ read_next_fcf: 
			    (phba->fcf.fcf_flag & FCF_REDISC_PEND))

				return;



			if (phba->fcf.fcf_flag & FCF_IN_USE) {

			if (phba->cfg_fcf_failover_policy == LPFC_FCF_FOV &&

				phba->fcf.fcf_flag & FCF_IN_USE) {

				/*

				 * In case the current in-use FCF record no

				 * longer existed during FCF discovery that
@@ -2423,7 +2627,8 @@ lpfc_mbx_cmpl_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq) 


	/* Update the eligible FCF record index bmask */

	fcf_index = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);

	rc = lpfc_sli4_fcf_rr_index_set(phba, fcf_index);



	rc = lpfc_sli4_fcf_pri_list_add(phba, fcf_index, new_fcf_record);



out:

	lpfc_sli4_mbox_cmd_free(phba, mboxq);
@@ -2893,8 +3098,7 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, struct lpfc_mbx_read_top *la) 
			goto out;

		}

		/* Reset FCF roundrobin bmask for new discovery */

		memset(phba->fcf.fcf_rr_bmask, 0,

		       sizeof(*phba->fcf.fcf_rr_bmask));

		lpfc_sli4_clear_fcf_rr_bmask(phba);

	}



	return;
@@ -5592,7 +5796,7 @@ lpfc_unregister_fcf_rescan(struct lpfc_hba *phba) 
	spin_unlock_irq(&phba->hbalock);



	/* Reset FCF roundrobin bmask for new discovery */

	memset(phba->fcf.fcf_rr_bmask, 0, sizeof(*phba->fcf.fcf_rr_bmask));

	lpfc_sli4_clear_fcf_rr_bmask(phba);



	rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);