Commit 4ee508ff authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch '100GbE' of git://git.kernel.org/pub/scm/linux/kernel/git/tnguy/next-queue 



Tony Nguyen says:

====================
100GbE Intel Wired LAN Driver Updates 2022-03-03

Jacob Keller says:

This series refactors the ice networking driver VF storage from a simple
static array to a hash table. It also introduces krefs and proper locking
and protection to prevent common use-after-free and concurrency issues.

There are two motivations for this work. First is to make the ice driver
more resilient by preventing a whole class of use-after-free bugs that can
occur around concurrent access to VF structures while removing VFs.

The second is to prepare the ice driver for future virtualization work to
support Scalable IOV, an alternative VF implementation compared to Single
Root IOV. The new VF implementation will allow for more dynamic VF creation
and removal, necessitating a more robust implementation for VF storage that
can't rely on the existing mechanisms to prevent concurrent access
violations.

The first few patches are cleanup and preparatory work needed to make the
conversion to the hash table safe. Following this preparatory work is a
patch to migrate the VF structures and variables to a new sub-structure for
code clarity. Next introduce new interface functions to abstract the VF
storage. Finally, the driver is actually converted to the hash table and
kref implementation.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents f2ecfa06 3d5985a1

drivers/net/ethernet/intel/ice/ice.h

+2 −11
Original line number Diff line number Diff line
@@ -109,7 +109,6 @@ 
/* All VF control VSIs share the same IRQ, so assign a unique ID for them */

#define ICE_RES_VF_CTRL_VEC_ID	(ICE_RES_RDMA_VEC_ID - 1)

#define ICE_INVAL_Q_INDEX	0xffff

#define ICE_INVAL_VFID		256



#define ICE_MAX_RXQS_PER_TC		256	/* Used when setting VSI context per TC Rx queues */
@@ -333,7 +332,7 @@ struct ice_vsi { 
	u16 vsi_num;			/* HW (absolute) index of this VSI */

	u16 idx;			/* software index in pf->vsi[] */



	s16 vf_id;			/* VF ID for SR-IOV VSIs */

	struct ice_vf *vf;		/* VF associated with this VSI */



	u16 ethtype;			/* Ethernet protocol for pause frame */

	u16 num_gfltr;
@@ -529,15 +528,7 @@ struct ice_pf { 
	struct ice_vsi **vsi;		/* VSIs created by the driver */

	struct ice_sw *first_sw;	/* first switch created by firmware */

	u16 eswitch_mode;		/* current mode of eswitch */

	/* Virtchnl/SR-IOV config info */

	struct ice_vf *vf;

	u16 num_alloc_vfs;		/* actual number of VFs allocated */

	u16 num_vfs_supported;		/* num VFs supported for this PF */

	u16 num_qps_per_vf;

	u16 num_msix_per_vf;

	/* used to ratelimit the MDD event logging */

	unsigned long last_printed_mdd_jiffies;

	DECLARE_BITMAP(malvfs, ICE_MAX_VF_COUNT);

	struct ice_vfs vfs;

	DECLARE_BITMAP(features, ICE_F_MAX);

	DECLARE_BITMAP(state, ICE_STATE_NBITS);

	DECLARE_BITMAP(flags, ICE_PF_FLAGS_NBITS);

drivers/net/ethernet/intel/ice/ice_base.c

+2 −2
Original line number Diff line number Diff line
@@ -323,7 +323,7 @@ ice_setup_tx_ctx(struct ice_tx_ring *ring, struct ice_tlan_ctx *tlan_ctx, u16 pf 
		break;

	case ICE_VSI_VF:

		/* Firmware expects vmvf_num to be absolute VF ID */

		tlan_ctx->vmvf_num = hw->func_caps.vf_base_id + vsi->vf_id;

		tlan_ctx->vmvf_num = hw->func_caps.vf_base_id + vsi->vf->vf_id;

		tlan_ctx->vmvf_type = ICE_TLAN_CTX_VMVF_TYPE_VF;

		break;

	case ICE_VSI_SWITCHDEV_CTRL:
@@ -429,7 +429,7 @@ static int ice_setup_rx_ctx(struct ice_rx_ring *ring) 
	 */

	if (ice_is_dvm_ena(hw))

		if (vsi->type == ICE_VSI_VF &&

		    ice_vf_is_port_vlan_ena(&vsi->back->vf[vsi->vf_id]))

		    ice_vf_is_port_vlan_ena(vsi->vf))

			rlan_ctx.l2tsel = 1;

		else

			rlan_ctx.l2tsel = 0;

drivers/net/ethernet/intel/ice/ice_eswitch.c

+94 −67
Original line number Diff line number Diff line
@@ -176,10 +176,20 @@ static void ice_eswitch_remap_rings_to_vectors(struct ice_pf *pf) 
	int q_id;



	ice_for_each_txq(vsi, q_id) {

		struct ice_repr *repr = pf->vf[q_id].repr;

		struct ice_q_vector *q_vector = repr->q_vector;

		struct ice_tx_ring *tx_ring = vsi->tx_rings[q_id];

		struct ice_rx_ring *rx_ring = vsi->rx_rings[q_id];

		struct ice_q_vector *q_vector;

		struct ice_tx_ring *tx_ring;

		struct ice_rx_ring *rx_ring;

		struct ice_repr *repr;

		struct ice_vf *vf;



		vf = ice_get_vf_by_id(pf, q_id);

		if (WARN_ON(!vf))

			continue;



		repr = vf->repr;

		q_vector = repr->q_vector;

		tx_ring = vsi->tx_rings[q_id];

		rx_ring = vsi->rx_rings[q_id];



		q_vector->vsi = vsi;

		q_vector->reg_idx = vsi->q_vectors[0]->reg_idx;
@@ -199,6 +209,38 @@ static void ice_eswitch_remap_rings_to_vectors(struct ice_pf *pf) 
		rx_ring->q_vector = q_vector;

		rx_ring->next = NULL;

		rx_ring->netdev = repr->netdev;



		ice_put_vf(vf);

	}

}



/**

 * ice_eswitch_release_reprs - clear PR VSIs configuration

 * @pf: poiner to PF struct

 * @ctrl_vsi: pointer to switchdev control VSI

 */

static void

ice_eswitch_release_reprs(struct ice_pf *pf, struct ice_vsi *ctrl_vsi)

{

	struct ice_vf *vf;

	unsigned int bkt;



	lockdep_assert_held(&pf->vfs.table_lock);



	ice_for_each_vf(pf, bkt, vf) {

		struct ice_vsi *vsi = vf->repr->src_vsi;



		/* Skip VFs that aren't configured */

		if (!vf->repr->dst)

			continue;



		ice_vsi_update_security(vsi, ice_vsi_ctx_set_antispoof);

		metadata_dst_free(vf->repr->dst);

		vf->repr->dst = NULL;

		ice_fltr_add_mac_and_broadcast(vsi, vf->hw_lan_addr.addr,

					       ICE_FWD_TO_VSI);



		netif_napi_del(&vf->repr->q_vector->napi);

	}

}
@@ -210,11 +252,13 @@ static int ice_eswitch_setup_reprs(struct ice_pf *pf) 
{

	struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;

	int max_vsi_num = 0;

	int i;

	struct ice_vf *vf;

	unsigned int bkt;



	ice_for_each_vf(pf, i) {

		struct ice_vsi *vsi = pf->vf[i].repr->src_vsi;

		struct ice_vf *vf = &pf->vf[i];

	lockdep_assert_held(&pf->vfs.table_lock);



	ice_for_each_vf(pf, bkt, vf) {

		struct ice_vsi *vsi = vf->repr->src_vsi;



		ice_remove_vsi_fltr(&pf->hw, vsi->idx);

		vf->repr->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX,
@@ -231,6 +275,7 @@ static int ice_eswitch_setup_reprs(struct ice_pf *pf) 
						       vf->hw_lan_addr.addr,

						       ICE_FWD_TO_VSI);

			metadata_dst_free(vf->repr->dst);

			vf->repr->dst = NULL;

			goto err;

		}
@@ -239,6 +284,7 @@ static int ice_eswitch_setup_reprs(struct ice_pf *pf) 
						       vf->hw_lan_addr.addr,

						       ICE_FWD_TO_VSI);

			metadata_dst_free(vf->repr->dst);

			vf->repr->dst = NULL;

			ice_vsi_update_security(vsi, ice_vsi_ctx_set_antispoof);

			goto err;

		}
@@ -252,8 +298,8 @@ static int ice_eswitch_setup_reprs(struct ice_pf *pf) 
		netif_keep_dst(vf->repr->netdev);

	}



	ice_for_each_vf(pf, i) {

		struct ice_repr *repr = pf->vf[i].repr;

	ice_for_each_vf(pf, bkt, vf) {

		struct ice_repr *repr = vf->repr;

		struct ice_vsi *vsi = repr->src_vsi;

		struct metadata_dst *dst;
@@ -266,42 +312,11 @@ static int ice_eswitch_setup_reprs(struct ice_pf *pf) 
	return 0;



err:

	for (i = i - 1; i >= 0; i--) {

		struct ice_vsi *vsi = pf->vf[i].repr->src_vsi;

		struct ice_vf *vf = &pf->vf[i];



		ice_vsi_update_security(vsi, ice_vsi_ctx_set_antispoof);

		metadata_dst_free(vf->repr->dst);

		ice_fltr_add_mac_and_broadcast(vsi, vf->hw_lan_addr.addr,

					       ICE_FWD_TO_VSI);

	}

	ice_eswitch_release_reprs(pf, ctrl_vsi);



	return -ENODEV;

}



/**

 * ice_eswitch_release_reprs - clear PR VSIs configuration

 * @pf: poiner to PF struct

 * @ctrl_vsi: pointer to switchdev control VSI

 */

static void

ice_eswitch_release_reprs(struct ice_pf *pf, struct ice_vsi *ctrl_vsi)

{

	int i;



	ice_for_each_vf(pf, i) {

		struct ice_vsi *vsi = pf->vf[i].repr->src_vsi;

		struct ice_vf *vf = &pf->vf[i];



		ice_vsi_update_security(vsi, ice_vsi_ctx_set_antispoof);

		metadata_dst_free(vf->repr->dst);

		ice_fltr_add_mac_and_broadcast(vsi, vf->hw_lan_addr.addr,

					       ICE_FWD_TO_VSI);



		netif_napi_del(&vf->repr->q_vector->napi);

	}

}



/**

 * ice_eswitch_update_repr - reconfigure VF port representor

 * @vsi: VF VSI for which port representor is configured
@@ -316,7 +331,7 @@ void ice_eswitch_update_repr(struct ice_vsi *vsi) 
	if (!ice_is_switchdev_running(pf))

		return;



	vf = &pf->vf[vsi->vf_id];

	vf = vsi->vf;

	repr = vf->repr;

	repr->src_vsi = vsi;

	repr->dst->u.port_info.port_id = vsi->vsi_num;
@@ -324,7 +339,8 @@ void ice_eswitch_update_repr(struct ice_vsi *vsi) 
	ret = ice_vsi_update_security(vsi, ice_vsi_ctx_clear_antispoof);

	if (ret) {

		ice_fltr_add_mac_and_broadcast(vsi, vf->hw_lan_addr.addr, ICE_FWD_TO_VSI);

		dev_err(ice_pf_to_dev(pf), "Failed to update VF %d port representor", vsi->vf_id);

		dev_err(ice_pf_to_dev(pf), "Failed to update VF %d port representor",

			vsi->vf->vf_id);

	}

}
@@ -408,7 +424,7 @@ static void ice_eswitch_release_env(struct ice_pf *pf) 
static struct ice_vsi *

ice_eswitch_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi)

{

	return ice_vsi_setup(pf, pi, ICE_VSI_SWITCHDEV_CTRL, ICE_INVAL_VFID, NULL);

	return ice_vsi_setup(pf, pi, ICE_VSI_SWITCHDEV_CTRL, NULL, NULL);

}



/**
@@ -417,10 +433,13 @@ ice_eswitch_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi) 
 */

static void ice_eswitch_napi_del(struct ice_pf *pf)

{

	int i;

	struct ice_vf *vf;

	unsigned int bkt;



	ice_for_each_vf(pf, i)

		netif_napi_del(&pf->vf[i].repr->q_vector->napi);

	lockdep_assert_held(&pf->vfs.table_lock);



	ice_for_each_vf(pf, bkt, vf)

		netif_napi_del(&vf->repr->q_vector->napi);

}



/**
@@ -429,10 +448,13 @@ static void ice_eswitch_napi_del(struct ice_pf *pf) 
 */

static void ice_eswitch_napi_enable(struct ice_pf *pf)

{

	int i;

	struct ice_vf *vf;

	unsigned int bkt;



	lockdep_assert_held(&pf->vfs.table_lock);



	ice_for_each_vf(pf, i)

		napi_enable(&pf->vf[i].repr->q_vector->napi);

	ice_for_each_vf(pf, bkt, vf)

		napi_enable(&vf->repr->q_vector->napi);

}



/**
@@ -441,10 +463,13 @@ static void ice_eswitch_napi_enable(struct ice_pf *pf) 
 */

static void ice_eswitch_napi_disable(struct ice_pf *pf)

{

	int i;

	struct ice_vf *vf;

	unsigned int bkt;



	lockdep_assert_held(&pf->vfs.table_lock);



	ice_for_each_vf(pf, i)

		napi_disable(&pf->vf[i].repr->q_vector->napi);

	ice_for_each_vf(pf, bkt, vf)

		napi_disable(&vf->repr->q_vector->napi);

}



/**
@@ -522,7 +547,7 @@ ice_eswitch_mode_set(struct devlink *devlink, u16 mode, 
	if (pf->eswitch_mode == mode)

		return 0;



	if (pf->num_alloc_vfs) {

	if (ice_has_vfs(pf)) {

		dev_info(ice_pf_to_dev(pf), "Changing eswitch mode is allowed only if there is no VFs created");

		NL_SET_ERR_MSG_MOD(extack, "Changing eswitch mode is allowed only if there is no VFs created");

		return -EOPNOTSUPP;
@@ -613,16 +638,17 @@ int ice_eswitch_configure(struct ice_pf *pf) 
 */

static void ice_eswitch_start_all_tx_queues(struct ice_pf *pf)

{

	struct ice_repr *repr;

	int i;

	struct ice_vf *vf;

	unsigned int bkt;



	lockdep_assert_held(&pf->vfs.table_lock);



	if (test_bit(ICE_DOWN, pf->state))

		return;



	ice_for_each_vf(pf, i) {

		repr = pf->vf[i].repr;

		if (repr)

			ice_repr_start_tx_queues(repr);

	ice_for_each_vf(pf, bkt, vf) {

		if (vf->repr)

			ice_repr_start_tx_queues(vf->repr);

	}

}
@@ -632,16 +658,17 @@ static void ice_eswitch_start_all_tx_queues(struct ice_pf *pf) 
 */

void ice_eswitch_stop_all_tx_queues(struct ice_pf *pf)

{

	struct ice_repr *repr;

	int i;

	struct ice_vf *vf;

	unsigned int bkt;



	lockdep_assert_held(&pf->vfs.table_lock);



	if (test_bit(ICE_DOWN, pf->state))

		return;



	ice_for_each_vf(pf, i) {

		repr = pf->vf[i].repr;

		if (repr)

			ice_repr_stop_tx_queues(repr);

	ice_for_each_vf(pf, bkt, vf) {

		if (vf->repr)

			ice_repr_stop_tx_queues(vf->repr);

	}

}

drivers/net/ethernet/intel/ice/ice_ethtool.c

+12 −8
Original line number Diff line number Diff line
@@ -316,16 +316,20 @@ ice_get_eeprom(struct net_device *netdev, struct ethtool_eeprom *eeprom, 
 */

static bool ice_active_vfs(struct ice_pf *pf)

{

	unsigned int i;



	ice_for_each_vf(pf, i) {

		struct ice_vf *vf = &pf->vf[i];

	bool active = false;

	struct ice_vf *vf;

	unsigned int bkt;



		if (test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states))

			return true;

	rcu_read_lock();

	ice_for_each_vf_rcu(pf, bkt, vf) {

		if (test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {

			active = true;

			break;

		}

	}

	rcu_read_unlock();



	return false;

	return active;

}



/**
@@ -1298,7 +1302,7 @@ static int ice_set_priv_flags(struct net_device *netdev, u32 flags) 
	}



	if (test_bit(ICE_FLAG_VF_VLAN_PRUNING, change_flags) &&

	    pf->num_alloc_vfs) {

	    ice_has_vfs(pf)) {

		dev_err(dev, "vf-vlan-pruning: VLAN pruning cannot be changed while VFs are active.\n");

		/* toggle bit back to previous state */

		change_bit(ICE_FLAG_VF_VLAN_PRUNING, pf->flags);

drivers/net/ethernet/intel/ice/ice_lib.c

+125 −78
Original line number Diff line number Diff line
@@ -166,21 +166,19 @@ static void ice_vsi_set_num_desc(struct ice_vsi *vsi) 
/**

 * ice_vsi_set_num_qs - Set number of queues, descriptors and vectors for a VSI

 * @vsi: the VSI being configured

 * @vf_id: ID of the VF being configured

 * @vf: the VF associated with this VSI, if any

 *

 * Return 0 on success and a negative value on error

 */

static void ice_vsi_set_num_qs(struct ice_vsi *vsi, u16 vf_id)

static void ice_vsi_set_num_qs(struct ice_vsi *vsi, struct ice_vf *vf)

{

	enum ice_vsi_type vsi_type = vsi->type;

	struct ice_pf *pf = vsi->back;

	struct ice_vf *vf = NULL;



	if (vsi->type == ICE_VSI_VF)

		vsi->vf_id = vf_id;

	else

		vsi->vf_id = ICE_INVAL_VFID;

	if (WARN_ON(vsi_type == ICE_VSI_VF && !vf))

		return;



	switch (vsi->type) {

	switch (vsi_type) {

	case ICE_VSI_PF:

		if (vsi->req_txq) {

			vsi->alloc_txq = vsi->req_txq;
@@ -217,22 +215,21 @@ static void ice_vsi_set_num_qs(struct ice_vsi *vsi, u16 vf_id) 
		/* The number of queues for ctrl VSI is equal to number of VFs.

		 * Each ring is associated to the corresponding VF_PR netdev.

		 */

		vsi->alloc_txq = pf->num_alloc_vfs;

		vsi->alloc_rxq = pf->num_alloc_vfs;

		vsi->alloc_txq = ice_get_num_vfs(pf);

		vsi->alloc_rxq = vsi->alloc_txq;

		vsi->num_q_vectors = 1;

		break;

	case ICE_VSI_VF:

		vf = &pf->vf[vsi->vf_id];

		if (vf->num_req_qs)

			vf->num_vf_qs = vf->num_req_qs;

		vsi->alloc_txq = vf->num_vf_qs;

		vsi->alloc_rxq = vf->num_vf_qs;

		/* pf->num_msix_per_vf includes (VF miscellaneous vector +

		/* pf->vfs.num_msix_per includes (VF miscellaneous vector +

		 * data queue interrupts). Since vsi->num_q_vectors is number

		 * of queues vectors, subtract 1 (ICE_NONQ_VECS_VF) from the

		 * original vector count

		 */

		vsi->num_q_vectors = pf->num_msix_per_vf - ICE_NONQ_VECS_VF;

		vsi->num_q_vectors = pf->vfs.num_msix_per - ICE_NONQ_VECS_VF;

		break;

	case ICE_VSI_CTRL:

		vsi->alloc_txq = 1;
@@ -248,7 +245,7 @@ static void ice_vsi_set_num_qs(struct ice_vsi *vsi, u16 vf_id) 
		vsi->alloc_rxq = 1;

		break;

	default:

		dev_warn(ice_pf_to_dev(pf), "Unknown VSI type %d\n", vsi->type);

		dev_warn(ice_pf_to_dev(pf), "Unknown VSI type %d\n", vsi_type);

		break;

	}
@@ -299,7 +296,7 @@ void ice_vsi_delete(struct ice_vsi *vsi) 
		return;



	if (vsi->type == ICE_VSI_VF)

		ctxt->vf_num = vsi->vf_id;

		ctxt->vf_num = vsi->vf->vf_id;

	ctxt->vsi_num = vsi->vsi_num;



	memcpy(&ctxt->info, &vsi->info, sizeof(ctxt->info));
@@ -384,8 +381,7 @@ int ice_vsi_clear(struct ice_vsi *vsi) 
	pf->vsi[vsi->idx] = NULL;

	if (vsi->idx < pf->next_vsi && vsi->type != ICE_VSI_CTRL)

		pf->next_vsi = vsi->idx;

	if (vsi->idx < pf->next_vsi && vsi->type == ICE_VSI_CTRL &&

	    vsi->vf_id != ICE_INVAL_VFID)

	if (vsi->idx < pf->next_vsi && vsi->type == ICE_VSI_CTRL && vsi->vf)

		pf->next_vsi = vsi->idx;



	ice_vsi_free_arrays(vsi);
@@ -437,13 +433,16 @@ static irqreturn_t ice_eswitch_msix_clean_rings(int __always_unused irq, void *d 
{

	struct ice_q_vector *q_vector = (struct ice_q_vector *)data;

	struct ice_pf *pf = q_vector->vsi->back;

	int i;

	struct ice_vf *vf;

	unsigned int bkt;



	if (!q_vector->tx.tx_ring && !q_vector->rx.rx_ring)

		return IRQ_HANDLED;



	ice_for_each_vf(pf, i)

		napi_schedule(&pf->vf[i].repr->q_vector->napi);

	rcu_read_lock();

	ice_for_each_vf_rcu(pf, bkt, vf)

		napi_schedule(&vf->repr->q_vector->napi);

	rcu_read_unlock();



	return IRQ_HANDLED;

}
@@ -453,17 +452,24 @@ static irqreturn_t ice_eswitch_msix_clean_rings(int __always_unused irq, void *d 
 * @pf: board private structure

 * @vsi_type: type of VSI

 * @ch: ptr to channel

 * @vf_id: ID of the VF being configured

 * @vf: VF for ICE_VSI_VF and ICE_VSI_CTRL

 *

 * The VF pointer is used for ICE_VSI_VF and ICE_VSI_CTRL. For ICE_VSI_CTRL,

 * it may be NULL in the case there is no association with a VF. For

 * ICE_VSI_VF the VF pointer *must not* be NULL.

 *

 * returns a pointer to a VSI on success, NULL on failure.

 */

static struct ice_vsi *

ice_vsi_alloc(struct ice_pf *pf, enum ice_vsi_type vsi_type,

	      struct ice_channel *ch, u16 vf_id)

	      struct ice_channel *ch, struct ice_vf *vf)

{

	struct device *dev = ice_pf_to_dev(pf);

	struct ice_vsi *vsi = NULL;



	if (WARN_ON(vsi_type == ICE_VSI_VF && !vf))

		return NULL;



	/* Need to protect the allocation of the VSIs at the PF level */

	mutex_lock(&pf->sw_mutex);
@@ -485,9 +491,9 @@ ice_vsi_alloc(struct ice_pf *pf, enum ice_vsi_type vsi_type, 
	set_bit(ICE_VSI_DOWN, vsi->state);



	if (vsi_type == ICE_VSI_VF)

		ice_vsi_set_num_qs(vsi, vf_id);

		ice_vsi_set_num_qs(vsi, vf);

	else if (vsi_type != ICE_VSI_CHNL)

		ice_vsi_set_num_qs(vsi, ICE_INVAL_VFID);

		ice_vsi_set_num_qs(vsi, NULL);



	switch (vsi->type) {

	case ICE_VSI_SWITCHDEV_CTRL:
@@ -510,10 +516,16 @@ ice_vsi_alloc(struct ice_pf *pf, enum ice_vsi_type vsi_type, 


		/* Setup ctrl VSI MSIX irq handler */

		vsi->irq_handler = ice_msix_clean_ctrl_vsi;



		/* For the PF control VSI this is NULL, for the VF control VSI

		 * this will be the first VF to allocate it.

		 */

		vsi->vf = vf;

		break;

	case ICE_VSI_VF:

		if (ice_vsi_alloc_arrays(vsi))

			goto err_rings;

		vsi->vf = vf;

		break;

	case ICE_VSI_CHNL:

		if (!ch)
@@ -531,7 +543,7 @@ ice_vsi_alloc(struct ice_pf *pf, enum ice_vsi_type vsi_type, 
		goto unlock_pf;

	}



	if (vsi->type == ICE_VSI_CTRL && vf_id == ICE_INVAL_VFID) {

	if (vsi->type == ICE_VSI_CTRL && !vf) {

		/* Use the last VSI slot as the index for PF control VSI */

		vsi->idx = pf->num_alloc_vsi - 1;

		pf->ctrl_vsi_idx = vsi->idx;
@@ -546,8 +558,8 @@ ice_vsi_alloc(struct ice_pf *pf, enum ice_vsi_type vsi_type, 
						 pf->next_vsi);

	}



	if (vsi->type == ICE_VSI_CTRL && vf_id != ICE_INVAL_VFID)

		pf->vf[vf_id].ctrl_vsi_idx = vsi->idx;

	if (vsi->type == ICE_VSI_CTRL && vf)

		vf->ctrl_vsi_idx = vsi->idx;

	goto unlock_pf;



err_rings:
@@ -1130,7 +1142,7 @@ static int ice_vsi_init(struct ice_vsi *vsi, bool init_vsi) 
	case ICE_VSI_VF:

		ctxt->flags = ICE_AQ_VSI_TYPE_VF;

		/* VF number here is the absolute VF number (0-255) */

		ctxt->vf_num = vsi->vf_id + hw->func_caps.vf_base_id;

		ctxt->vf_num = vsi->vf->vf_id + hw->func_caps.vf_base_id;

		break;

	default:

		ret = -ENODEV;
@@ -1321,6 +1333,36 @@ ice_get_res(struct ice_pf *pf, struct ice_res_tracker *res, u16 needed, u16 id) 
	return ice_search_res(res, needed, id);

}



/**

 * ice_get_vf_ctrl_res - Get VF control VSI resource

 * @pf: pointer to the PF structure

 * @vsi: the VSI to allocate a resource for

 *

 * Look up whether another VF has already allocated the control VSI resource.

 * If so, re-use this resource so that we share it among all VFs.

 *

 * Otherwise, allocate the resource and return it.

 */

static int ice_get_vf_ctrl_res(struct ice_pf *pf, struct ice_vsi *vsi)

{

	struct ice_vf *vf;

	unsigned int bkt;

	int base;



	rcu_read_lock();

	ice_for_each_vf_rcu(pf, bkt, vf) {

		if (vf != vsi->vf && vf->ctrl_vsi_idx != ICE_NO_VSI) {

			base = pf->vsi[vf->ctrl_vsi_idx]->base_vector;

			rcu_read_unlock();

			return base;

		}

	}

	rcu_read_unlock();



	return ice_get_res(pf, pf->irq_tracker, vsi->num_q_vectors,

			   ICE_RES_VF_CTRL_VEC_ID);

}



/**

 * ice_vsi_setup_vector_base - Set up the base vector for the given VSI

 * @vsi: ptr to the VSI
@@ -1353,20 +1395,8 @@ static int ice_vsi_setup_vector_base(struct ice_vsi *vsi) 


	num_q_vectors = vsi->num_q_vectors;

	/* reserve slots from OS requested IRQs */

	if (vsi->type == ICE_VSI_CTRL && vsi->vf_id != ICE_INVAL_VFID) {

		int i;



		ice_for_each_vf(pf, i) {

			struct ice_vf *vf = &pf->vf[i];



			if (i != vsi->vf_id && vf->ctrl_vsi_idx != ICE_NO_VSI) {

				base = pf->vsi[vf->ctrl_vsi_idx]->base_vector;

				break;

			}

		}

		if (i == pf->num_alloc_vfs)

			base = ice_get_res(pf, pf->irq_tracker, num_q_vectors,

					   ICE_RES_VF_CTRL_VEC_ID);

	if (vsi->type == ICE_VSI_CTRL && vsi->vf) {

		base = ice_get_vf_ctrl_res(pf, vsi);

	} else {

		base = ice_get_res(pf, pf->irq_tracker, num_q_vectors,

				   vsi->idx);
@@ -2218,7 +2248,7 @@ ice_vsi_set_q_vectors_reg_idx(struct ice_vsi *vsi) 
		}



		if (vsi->type == ICE_VSI_VF) {

			struct ice_vf *vf = &vsi->back->vf[vsi->vf_id];

			struct ice_vf *vf = vsi->vf;



			q_vector->reg_idx = ice_calc_vf_reg_idx(vf, q_vector);

		} else {
@@ -2403,9 +2433,8 @@ static void ice_set_agg_vsi(struct ice_vsi *vsi) 
 * @pf: board private structure

 * @pi: pointer to the port_info instance

 * @vsi_type: VSI type

 * @vf_id: defines VF ID to which this VSI connects. This field is meant to be

 *         used only for ICE_VSI_VF VSI type. For other VSI types, should

 *         fill-in ICE_INVAL_VFID as input.

 * @vf: pointer to VF to which this VSI connects. This field is used primarily

 *      for the ICE_VSI_VF type. Other VSI types should pass NULL.

 * @ch: ptr to channel

 *

 * This allocates the sw VSI structure and its queue resources.
@@ -2415,7 +2444,8 @@ static void ice_set_agg_vsi(struct ice_vsi *vsi) 
 */

struct ice_vsi *

ice_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi,

	      enum ice_vsi_type vsi_type, u16 vf_id, struct ice_channel *ch)

	      enum ice_vsi_type vsi_type, struct ice_vf *vf,

	      struct ice_channel *ch)

{

	u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 };

	struct device *dev = ice_pf_to_dev(pf);
@@ -2423,11 +2453,11 @@ ice_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi, 
	int ret, i;



	if (vsi_type == ICE_VSI_CHNL)

		vsi = ice_vsi_alloc(pf, vsi_type, ch, ICE_INVAL_VFID);

		vsi = ice_vsi_alloc(pf, vsi_type, ch, NULL);

	else if (vsi_type == ICE_VSI_VF || vsi_type == ICE_VSI_CTRL)

		vsi = ice_vsi_alloc(pf, vsi_type, NULL, vf_id);

		vsi = ice_vsi_alloc(pf, vsi_type, NULL, vf);

	else

		vsi = ice_vsi_alloc(pf, vsi_type, NULL, ICE_INVAL_VFID);

		vsi = ice_vsi_alloc(pf, vsi_type, NULL, NULL);



	if (!vsi) {

		dev_err(dev, "could not allocate VSI\n");
@@ -2439,9 +2469,6 @@ ice_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi, 
	if (vsi->type == ICE_VSI_PF)

		vsi->ethtype = ETH_P_PAUSE;



	if (vsi->type == ICE_VSI_VF || vsi->type == ICE_VSI_CTRL)

		vsi->vf_id = vf_id;



	ice_alloc_fd_res(vsi);



	if (vsi_type != ICE_VSI_CHNL) {
@@ -2861,6 +2888,37 @@ void ice_napi_del(struct ice_vsi *vsi) 
		netif_napi_del(&vsi->q_vectors[v_idx]->napi);

}



/**

 * ice_free_vf_ctrl_res - Free the VF control VSI resource

 * @pf: pointer to PF structure

 * @vsi: the VSI to free resources for

 *

 * Check if the VF control VSI resource is still in use. If no VF is using it

 * any more, release the VSI resource. Otherwise, leave it to be cleaned up

 * once no other VF uses it.

 */

static void ice_free_vf_ctrl_res(struct ice_pf *pf,  struct ice_vsi *vsi)

{

	struct ice_vf *vf;

	unsigned int bkt;



	rcu_read_lock();

	ice_for_each_vf_rcu(pf, bkt, vf) {

		if (vf != vsi->vf && vf->ctrl_vsi_idx != ICE_NO_VSI) {

			rcu_read_unlock();

			return;

		}

	}

	rcu_read_unlock();



	/* No other VFs left that have control VSI. It is now safe to reclaim

	 * SW interrupts back to the common pool.

	 */

	ice_free_res(pf->irq_tracker, vsi->base_vector,

		     ICE_RES_VF_CTRL_VEC_ID);

	pf->num_avail_sw_msix += vsi->num_q_vectors;

}



/**

 * ice_vsi_release - Delete a VSI and free its resources

 * @vsi: the VSI being removed
@@ -2904,23 +2962,8 @@ int ice_vsi_release(struct ice_vsi *vsi) 
	 * many interrupts each VF needs. SR-IOV MSIX resources are also

	 * cleared in the same manner.

	 */

	if (vsi->type == ICE_VSI_CTRL && vsi->vf_id != ICE_INVAL_VFID) {

		int i;



		ice_for_each_vf(pf, i) {

			struct ice_vf *vf = &pf->vf[i];



			if (i != vsi->vf_id && vf->ctrl_vsi_idx != ICE_NO_VSI)

				break;

		}

		if (i == pf->num_alloc_vfs) {

			/* No other VFs left that have control VSI, reclaim SW

			 * interrupts back to the common pool

			 */

			ice_free_res(pf->irq_tracker, vsi->base_vector,

				     ICE_RES_VF_CTRL_VEC_ID);

			pf->num_avail_sw_msix += vsi->num_q_vectors;

		}

	if (vsi->type == ICE_VSI_CTRL && vsi->vf) {

		ice_free_vf_ctrl_res(pf, vsi);

	} else if (vsi->type != ICE_VSI_VF) {

		/* reclaim SW interrupts back to the common pool */

		ice_free_res(pf->irq_tracker, vsi->base_vector, vsi->idx);
@@ -3104,7 +3147,6 @@ int ice_vsi_rebuild(struct ice_vsi *vsi, bool init_vsi) 
	u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 };

	struct ice_coalesce_stored *coalesce;

	int prev_num_q_vectors = 0;

	struct ice_vf *vf = NULL;

	enum ice_vsi_type vtype;

	struct ice_pf *pf;

	int ret, i;
@@ -3114,8 +3156,8 @@ int ice_vsi_rebuild(struct ice_vsi *vsi, bool init_vsi) 


	pf = vsi->back;

	vtype = vsi->type;

	if (vtype == ICE_VSI_VF)

		vf = &pf->vf[vsi->vf_id];

	if (WARN_ON(vtype == ICE_VSI_VF) && !vsi->vf)

		return -EINVAL;



	ice_vsi_init_vlan_ops(vsi);
@@ -3154,9 +3196,9 @@ int ice_vsi_rebuild(struct ice_vsi *vsi, bool init_vsi) 
	ice_vsi_clear_rings(vsi);

	ice_vsi_free_arrays(vsi);

	if (vtype == ICE_VSI_VF)

		ice_vsi_set_num_qs(vsi, vf->vf_id);

		ice_vsi_set_num_qs(vsi, vsi->vf);

	else

		ice_vsi_set_num_qs(vsi, ICE_INVAL_VFID);

		ice_vsi_set_num_qs(vsi, NULL);



	ret = ice_vsi_alloc_arrays(vsi);

	if (ret < 0)
@@ -4013,9 +4055,14 @@ static u16 ice_vsi_num_zero_vlans(struct ice_vsi *vsi) 
#define ICE_DVM_NUM_ZERO_VLAN_FLTRS	2

#define ICE_SVM_NUM_ZERO_VLAN_FLTRS	1

	/* no VLAN 0 filter is created when a port VLAN is active */

	if (vsi->type == ICE_VSI_VF &&

	    ice_vf_is_port_vlan_ena(&vsi->back->vf[vsi->vf_id]))

	if (vsi->type == ICE_VSI_VF) {

		if (WARN_ON(!vsi->vf))

			return 0;



		if (ice_vf_is_port_vlan_ena(vsi->vf))

			return 0;

	}



	if (ice_is_dvm_ena(&vsi->back->hw))

		return ICE_DVM_NUM_ZERO_VLAN_FLTRS;

	else