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

Commit 12fb0da4 authored by Edward Cree's avatar Edward Cree Committed by David S. Miller
Browse files

sfc: clean fallbacks between promisc/normal in efx_ef10_filter_sync_rx_mode 



Separate functions for inserting individual and promisc filters; explicit
 fallback logic in efx_ef10_filter_sync_rx_mode(), in order not to overload
 the 'promisc' flag as also meaning "fall back to promisc".

Signed-off-by: default avatarEdward Cree <ecree@solarflare.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent ab8b1f7c

drivers/net/ethernet/sfc/ef10.c

+208 −80
Original line number Diff line number Diff line
@@ -49,6 +49,7 @@ enum { 
 */

#define HUNT_FILTER_TBL_ROWS 8192



#define EFX_EF10_FILTER_ID_INVALID 0xffff

struct efx_ef10_dev_addr {

	u8 addr[ETH_ALEN];

	u16 id;
@@ -76,8 +77,12 @@ struct efx_ef10_filter_table { 
#define EFX_EF10_FILTER_DEV_MC_MAX	256

	struct efx_ef10_dev_addr dev_uc_list[EFX_EF10_FILTER_DEV_UC_MAX];

	struct efx_ef10_dev_addr dev_mc_list[EFX_EF10_FILTER_DEV_MC_MAX];

	int dev_uc_count;		/* negative for PROMISC */

	int dev_mc_count;		/* negative for PROMISC/ALLMULTI */

	int dev_uc_count;

	int dev_mc_count;

/* Indices (like efx_ef10_dev_addr.id) for promisc/allmulti filters */

	u16 ucdef_id;

	u16 bcast_id;

	u16 mcdef_id;

};



/* An arbitrary search limit for the software hash table */
@@ -3273,6 +3278,19 @@ static int efx_ef10_filter_remove_safe(struct efx_nic *efx, 
					       filter_id, false);

}



static u32 efx_ef10_filter_get_unsafe_id(struct efx_nic *efx, u32 filter_id)

{

	return filter_id % HUNT_FILTER_TBL_ROWS;

}



static int efx_ef10_filter_remove_unsafe(struct efx_nic *efx,

					 enum efx_filter_priority priority,

					 u32 filter_id)

{

	return efx_ef10_filter_remove_internal(efx, 1U << priority,

					       filter_id, true);

}



static int efx_ef10_filter_get_safe(struct efx_nic *efx,

				    enum efx_filter_priority priority,

				    u32 filter_id, struct efx_filter_spec *spec)
@@ -3646,6 +3664,10 @@ static int efx_ef10_filter_table_probe(struct efx_nic *efx) 
		goto fail;

	}



	table->ucdef_id = EFX_EF10_FILTER_ID_INVALID;

	table->bcast_id = EFX_EF10_FILTER_ID_INVALID;

	table->mcdef_id = EFX_EF10_FILTER_ID_INVALID;



	efx->filter_state = table;

	init_waitqueue_head(&table->waitq);

	return 0;
@@ -3748,6 +3770,12 @@ static void efx_ef10_filter_table_remove(struct efx_nic *efx) 
	kfree(table);

}



#define EFX_EF10_FILTER_DO_MARK_OLD(id) \

		if (id != EFX_EF10_FILTER_ID_INVALID) { \

			filter_idx = efx_ef10_filter_get_unsafe_id(efx, id); \

			WARN_ON(!table->entry[filter_idx].spec); \

			table->entry[filter_idx].spec |= EFX_EF10_FILTER_FLAG_AUTO_OLD; \

		}

static void efx_ef10_filter_mark_old(struct efx_nic *efx)

{

	struct efx_ef10_filter_table *table = efx->filter_state;
@@ -3758,33 +3786,39 @@ static void efx_ef10_filter_mark_old(struct efx_nic *efx) 


	/* Mark old filters that may need to be removed */

	spin_lock_bh(&efx->filter_lock);

	for (i = 0; i < table->dev_uc_count; i++) {

		filter_idx = table->dev_uc_list[i].id % HUNT_FILTER_TBL_ROWS;

		table->entry[filter_idx].spec |= EFX_EF10_FILTER_FLAG_AUTO_OLD;

	}

	for (i = 0; i < table->dev_mc_count; i++) {

		filter_idx = table->dev_mc_list[i].id % HUNT_FILTER_TBL_ROWS;

		table->entry[filter_idx].spec |= EFX_EF10_FILTER_FLAG_AUTO_OLD;

	}

	for (i = 0; i < table->dev_uc_count; i++)

		EFX_EF10_FILTER_DO_MARK_OLD(table->dev_uc_list[i].id);

	for (i = 0; i < table->dev_mc_count; i++)

		EFX_EF10_FILTER_DO_MARK_OLD(table->dev_mc_list[i].id);

	EFX_EF10_FILTER_DO_MARK_OLD(table->ucdef_id);

	EFX_EF10_FILTER_DO_MARK_OLD(table->bcast_id);

	EFX_EF10_FILTER_DO_MARK_OLD(table->mcdef_id);

	spin_unlock_bh(&efx->filter_lock);

}

#undef EFX_EF10_FILTER_DO_MARK_OLD



static void efx_ef10_filter_uc_addr_list(struct efx_nic *efx, bool *promisc)

{

	struct efx_ef10_filter_table *table = efx->filter_state;

	struct net_device *net_dev = efx->net_dev;

	struct netdev_hw_addr *uc;

	int addr_count;

	unsigned int i;



	if (net_dev->flags & IFF_PROMISC ||

	    netdev_uc_count(net_dev) >= EFX_EF10_FILTER_DEV_UC_MAX) {

	table->ucdef_id = EFX_EF10_FILTER_ID_INVALID;

	addr_count = netdev_uc_count(net_dev);

	if (net_dev->flags & IFF_PROMISC)

		*promisc = true;

	}

	table->dev_uc_count = 1 + netdev_uc_count(net_dev);

	table->dev_uc_count = 1 + addr_count;

	ether_addr_copy(table->dev_uc_list[0].addr, net_dev->dev_addr);

	i = 1;

	netdev_for_each_uc_addr(uc, net_dev) {

		if (i >= EFX_EF10_FILTER_DEV_UC_MAX) {

			*promisc = true;

			break;

		}

		ether_addr_copy(table->dev_uc_list[i].addr, uc->addr);

		table->dev_uc_list[i].id = EFX_EF10_FILTER_ID_INVALID;

		i++;

	}

}
@@ -3792,65 +3826,51 @@ static void efx_ef10_filter_uc_addr_list(struct efx_nic *efx, bool *promisc) 
static void efx_ef10_filter_mc_addr_list(struct efx_nic *efx, bool *promisc)

{

	struct efx_ef10_filter_table *table = efx->filter_state;

	struct efx_ef10_nic_data *nic_data = efx->nic_data;

	struct net_device *net_dev = efx->net_dev;

	struct netdev_hw_addr *mc;

	unsigned int i, addr_count;



	table->mcdef_id = EFX_EF10_FILTER_ID_INVALID;

	table->bcast_id = EFX_EF10_FILTER_ID_INVALID;

	if (net_dev->flags & (IFF_PROMISC | IFF_ALLMULTI))

		*promisc = true;



	if (nic_data->workaround_26807) {

		if (*promisc) {

			table->dev_mc_count = 0;

			return;

		}

	addr_count = netdev_mc_count(net_dev);

	} else {

		/* Allow room for broadcast and promiscuous */

		addr_count = netdev_mc_count(net_dev) + 2;

	}



	if (addr_count >= EFX_EF10_FILTER_DEV_MC_MAX) {

		if (nic_data->workaround_26807) {

			table->dev_mc_count = 0;

		} else {

			table->dev_mc_count = 1;

			eth_broadcast_addr(table->dev_mc_list[0].addr);

		}

	i = 0;

	netdev_for_each_mc_addr(mc, net_dev) {

		if (i >= EFX_EF10_FILTER_DEV_MC_MAX) {

			*promisc = true;

		return;

			break;

		}



	table->dev_mc_count = 1 + netdev_mc_count(net_dev);

	eth_broadcast_addr(table->dev_mc_list[0].addr);

	i = 1;

	netdev_for_each_mc_addr(mc, net_dev) {

		ether_addr_copy(table->dev_mc_list[i].addr, mc->addr);

		table->dev_mc_list[i].id = EFX_EF10_FILTER_ID_INVALID;

		i++;

	}



	table->dev_mc_count = i;

}



static void efx_ef10_filter_insert_addr_list(struct efx_nic *efx,

					     bool multicast, bool *promisc)

static int efx_ef10_filter_insert_addr_list(struct efx_nic *efx,

					     bool multicast, bool rollback)

{

	struct efx_ef10_filter_table *table = efx->filter_state;

	struct efx_ef10_dev_addr *addr_list;

	struct efx_filter_spec spec;

	int *addr_count;

	unsigned int i;

	u8 baddr[ETH_ALEN];

	unsigned int i, j;

	int addr_count;

	int rc;



	if (multicast) {

		addr_list = table->dev_mc_list;

		addr_count = &table->dev_mc_count;

		addr_count = table->dev_mc_count;

	} else {

		addr_list = table->dev_uc_list;

		addr_count = &table->dev_uc_count;

		addr_count = table->dev_uc_count;

	}



	/* Insert/renew filters */

	for (i = 0; i < *addr_count; i++) {

	for (i = 0; i < addr_count; i++) {

		efx_filter_init_rx(&spec, EFX_FILTER_PRI_AUTO,

				   EFX_FILTER_FLAG_RX_RSS,

				   0);
@@ -3858,29 +3878,66 @@ static void efx_ef10_filter_insert_addr_list(struct efx_nic *efx, 
					 addr_list[i].addr);

		rc = efx_ef10_filter_insert(efx, &spec, true);

		if (rc < 0) {

			/* Fall back to promiscuous, but leave the broadcast

			 * filter for multicast

			 */

			while (i--) {

				struct efx_ef10_nic_data *nic_data =

					efx->nic_data;



				if (multicast && i == 1 &&

				    !nic_data->workaround_26807)

					break;

			if (rollback) {

				netif_info(efx, drv, efx->net_dev,

					   "efx_ef10_filter_insert failed rc=%d\n",

					   rc);

				/* Fall back to promiscuous */

				for (j = 0; j < i; j++) {

					if (addr_list[j].id == EFX_EF10_FILTER_ID_INVALID)

						continue;

					efx_ef10_filter_remove_unsafe(

						efx, EFX_FILTER_PRI_AUTO,

						addr_list[j].id);

					addr_list[j].id = EFX_EF10_FILTER_ID_INVALID;

				}

				return rc;

			} else {

				/* mark as not inserted, and carry on */

				rc = EFX_EF10_FILTER_ID_INVALID;

			}

		}

		addr_list[i].id = efx_ef10_filter_get_unsafe_id(efx, rc);

	}



				efx_ef10_filter_remove_safe(

	if (multicast && rollback) {

		/* Also need an Ethernet broadcast filter */

		efx_filter_init_rx(&spec, EFX_FILTER_PRI_AUTO,

				   EFX_FILTER_FLAG_RX_RSS,

				   0);

		eth_broadcast_addr(baddr);

		efx_filter_set_eth_local(&spec, EFX_FILTER_VID_UNSPEC, baddr);

		rc = efx_ef10_filter_insert(efx, &spec, true);

		if (rc < 0) {

			netif_warn(efx, drv, efx->net_dev,

				   "Broadcast filter insert failed rc=%d\n", rc);

			/* Fall back to promiscuous */

			for (j = 0; j < i; j++) {

				if (addr_list[j].id == EFX_EF10_FILTER_ID_INVALID)

					continue;

				efx_ef10_filter_remove_unsafe(

					efx, EFX_FILTER_PRI_AUTO,

					addr_list[i].id);

					addr_list[j].id);

				addr_list[j].id = EFX_EF10_FILTER_ID_INVALID;

			}

			*addr_count = i;

			*promisc = true;

			break;

			return rc;

		} else {

			table->bcast_id = efx_ef10_filter_get_unsafe_id(efx, rc);

		}

		addr_list[i].id = rc;

	}



	if (*promisc) {

	return 0;

}



static int efx_ef10_filter_insert_def(struct efx_nic *efx, bool multicast,

				      bool rollback)

{

	struct efx_ef10_filter_table *table = efx->filter_state;

	struct efx_ef10_nic_data *nic_data = efx->nic_data;

	struct efx_filter_spec spec;

	u8 baddr[ETH_ALEN];

	int rc;



	efx_filter_init_rx(&spec, EFX_FILTER_PRI_AUTO,

			   EFX_FILTER_FLAG_RX_RSS,

			   0);
@@ -3891,14 +3948,44 @@ static void efx_ef10_filter_insert_addr_list(struct efx_nic *efx, 
		efx_filter_set_uc_def(&spec);



	rc = efx_ef10_filter_insert(efx, &spec, true);

		if (rc < 0)

	if (rc < 0) {

		netif_warn(efx, drv, efx->net_dev,

				   "%scast mismatch filter insert failed.",

				   multicast ? "Multi" : "Uni");

		else

			addr_list[(*addr_count)++].id = rc;

			   "%scast mismatch filter insert failed rc=%d\n",

			   multicast ? "Multi" : "Uni", rc);

	} else if (multicast) {

		table->mcdef_id = efx_ef10_filter_get_unsafe_id(efx, rc);

		if (!nic_data->workaround_26807) {

			/* Also need an Ethernet broadcast filter */

			efx_filter_init_rx(&spec, EFX_FILTER_PRI_AUTO,

					   EFX_FILTER_FLAG_RX_RSS,

					   0);

			eth_broadcast_addr(baddr);

			efx_filter_set_eth_local(&spec, EFX_FILTER_VID_UNSPEC,

						 baddr);

			rc = efx_ef10_filter_insert(efx, &spec, true);

			if (rc < 0) {

				netif_warn(efx, drv, efx->net_dev,

					   "Broadcast filter insert failed rc=%d\n",

					   rc);

				if (rollback) {

					/* Roll back the mc_def filter */

					efx_ef10_filter_remove_unsafe(

							efx, EFX_FILTER_PRI_AUTO,

							table->mcdef_id);

					table->mcdef_id = EFX_EF10_FILTER_ID_INVALID;

					return rc;

				}

			} else {

				table->bcast_id = efx_ef10_filter_get_unsafe_id(efx, rc);

			}

		}

		rc = 0;

	} else {

		table->ucdef_id = rc;

		rc = 0;

	}

	return rc;

}



/* Remove filters that weren't renewed.  Since nothing else changes the AUTO_OLD

 * flag or removes these filters, we don't need to hold the filter_lock while
@@ -4014,15 +4101,56 @@ static void efx_ef10_filter_sync_rx_mode(struct efx_nic *efx) 
	efx_ef10_filter_mc_addr_list(efx, &mc_promisc);

	netif_addr_unlock_bh(net_dev);



	/* Insert/renew filters */

	efx_ef10_filter_insert_addr_list(efx, false, &uc_promisc);

	/* Insert/renew unicast filters */

	if (uc_promisc) {

		efx_ef10_filter_insert_def(efx, false, false);

		efx_ef10_filter_insert_addr_list(efx, false, false);

	} else {

		/* If any of the filters failed to insert, fall back to

		 * promiscuous mode - add in the uc_def filter.  But keep

		 * our individual unicast filters.

		 */

		if (efx_ef10_filter_insert_addr_list(efx, false, false))

			efx_ef10_filter_insert_def(efx, false, false);

	}



	/* Insert/renew multicast filters */

	/* If changing promiscuous state with cascaded multicast filters, remove

	 * old filters first, so that packets are dropped rather than duplicated

	 */

	if (nic_data->workaround_26807 && efx->mc_promisc != mc_promisc)

		efx_ef10_filter_remove_old(efx);

	efx_ef10_filter_insert_addr_list(efx, true, &mc_promisc);

	if (mc_promisc) {

		if (nic_data->workaround_26807) {

			/* If we failed to insert promiscuous filters, rollback

			 * and fall back to individual multicast filters

			 */

			if (efx_ef10_filter_insert_def(efx, true, true)) {

				/* Changing promisc state, so remove old filters */

				efx_ef10_filter_remove_old(efx);

				efx_ef10_filter_insert_addr_list(efx, true, false);

			}

		} else {

			/* If we failed to insert promiscuous filters, don't

			 * rollback.  Regardless, also insert the mc_list

			 */

			efx_ef10_filter_insert_def(efx, true, false);

			efx_ef10_filter_insert_addr_list(efx, true, false);

		}

	} else {

		/* If any filters failed to insert, rollback and fall back to

		 * promiscuous mode - mc_def filter and maybe broadcast.  If

		 * that fails, roll back again and insert as many of our

		 * individual multicast filters as we can.

		 */

		if (efx_ef10_filter_insert_addr_list(efx, true, true)) {

			/* Changing promisc state, so remove old filters */

			if (nic_data->workaround_26807)

				efx_ef10_filter_remove_old(efx);

			if (efx_ef10_filter_insert_def(efx, true, true))

				efx_ef10_filter_insert_addr_list(efx, true, false);

		}

	}



	efx_ef10_filter_remove_old(efx);

	efx->mc_promisc = mc_promisc;