Commit 0363aa29 authored by Edward Cree's avatar Edward Cree Committed by David S. Miller
Browse files

sfc: add functions to allocate/free MAE counters 



efx_tc_flower_get_counter_index() will create an MAE counter mapped to
 the passed (TC filter) cookie, or increment the reference if one already
 exists for that cookie.

Signed-off-by: default avatarEdward Cree <ecree.xilinx@gmail.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 19a0c989

drivers/net/ethernet/sfc/mae.c

+51 −0
Original line number Diff line number Diff line
@@ -434,6 +434,57 @@ int efx_mae_match_check_caps(struct efx_nic *efx, 
#undef CHECK_BIT

#undef CHECK



int efx_mae_allocate_counter(struct efx_nic *efx, struct efx_tc_counter *cnt)

{

	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_COUNTER_ALLOC_OUT_LEN(1));

	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_COUNTER_ALLOC_V2_IN_LEN);

	size_t outlen;

	int rc;



	if (!cnt)

		return -EINVAL;



	MCDI_SET_DWORD(inbuf, MAE_COUNTER_ALLOC_V2_IN_REQUESTED_COUNT, 1);

	MCDI_SET_DWORD(inbuf, MAE_COUNTER_ALLOC_V2_IN_COUNTER_TYPE, cnt->type);

	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_COUNTER_ALLOC, inbuf, sizeof(inbuf),

			  outbuf, sizeof(outbuf), &outlen);

	if (rc)

		return rc;

	/* pcol says this can't happen, since count is 1 */

	if (outlen < sizeof(outbuf))

		return -EIO;

	cnt->fw_id = MCDI_DWORD(outbuf, MAE_COUNTER_ALLOC_OUT_COUNTER_ID);

	cnt->gen = MCDI_DWORD(outbuf, MAE_COUNTER_ALLOC_OUT_GENERATION_COUNT);

	return 0;

}



int efx_mae_free_counter(struct efx_nic *efx, struct efx_tc_counter *cnt)

{

	MCDI_DECLARE_BUF(outbuf, MC_CMD_MAE_COUNTER_FREE_OUT_LEN(1));

	MCDI_DECLARE_BUF(inbuf, MC_CMD_MAE_COUNTER_FREE_V2_IN_LEN);

	size_t outlen;

	int rc;



	MCDI_SET_DWORD(inbuf, MAE_COUNTER_FREE_V2_IN_COUNTER_ID_COUNT, 1);

	MCDI_SET_DWORD(inbuf, MAE_COUNTER_FREE_V2_IN_FREE_COUNTER_ID, cnt->fw_id);

	MCDI_SET_DWORD(inbuf, MAE_COUNTER_FREE_V2_IN_COUNTER_TYPE, cnt->type);

	rc = efx_mcdi_rpc(efx, MC_CMD_MAE_COUNTER_FREE, inbuf, sizeof(inbuf),

			  outbuf, sizeof(outbuf), &outlen);

	if (rc)

		return rc;

	/* pcol says this can't happen, since count is 1 */

	if (outlen < sizeof(outbuf))

		return -EIO;

	/* FW freed a different ID than we asked for, should also never happen.

	 * Warn because it means we've now got a different idea to the FW of

	 * what counters exist, which could cause mayhem later.

	 */

	if (WARN_ON(MCDI_DWORD(outbuf, MAE_COUNTER_FREE_OUT_FREED_COUNTER_ID) !=

		    cnt->fw_id))

		return -EIO;

	return 0;

}



static bool efx_mae_asl_id(u32 id)

{

	return !!(id & BIT(31));

drivers/net/ethernet/sfc/mae.h

+3 −0
Original line number Diff line number Diff line
@@ -45,6 +45,9 @@ int efx_mae_match_check_caps(struct efx_nic *efx, 
			     const struct efx_tc_match_fields *mask,

			     struct netlink_ext_ack *extack);



int efx_mae_allocate_counter(struct efx_nic *efx, struct efx_tc_counter *cnt);

int efx_mae_free_counter(struct efx_nic *efx, struct efx_tc_counter *cnt);



int efx_mae_alloc_action_set(struct efx_nic *efx, struct efx_tc_action_set *act);

int efx_mae_free_action_set(struct efx_nic *efx, u32 fw_id);

drivers/net/ethernet/sfc/tc_counters.c

+109 −0
Original line number Diff line number Diff line
@@ -74,6 +74,115 @@ void efx_tc_fini_counters(struct efx_nic *efx) 
	rhashtable_free_and_destroy(&efx->tc->counter_ht, efx_tc_counter_free, NULL);

}



/* Counter allocation */



static struct efx_tc_counter *efx_tc_flower_allocate_counter(struct efx_nic *efx,

							     int type)

{

	struct efx_tc_counter *cnt;

	int rc, rc2;



	cnt = kzalloc(sizeof(*cnt), GFP_USER);

	if (!cnt)

		return ERR_PTR(-ENOMEM);



	cnt->type = type;



	rc = efx_mae_allocate_counter(efx, cnt);

	if (rc)

		goto fail1;

	rc = rhashtable_insert_fast(&efx->tc->counter_ht, &cnt->linkage,

				    efx_tc_counter_ht_params);

	if (rc)

		goto fail2;

	return cnt;

fail2:

	/* If we get here, it implies that we couldn't insert into the table,

	 * which in turn probably means that the fw_id was already taken.

	 * In that case, it's unclear whether we really 'own' the fw_id; but

	 * the firmware seemed to think we did, so it's proper to free it.

	 */

	rc2 = efx_mae_free_counter(efx, cnt);

	if (rc2)

		netif_warn(efx, hw, efx->net_dev,

			   "Failed to free MAE counter %u, rc %d\n",

			   cnt->fw_id, rc2);

fail1:

	kfree(cnt);

	return ERR_PTR(rc > 0 ? -EIO : rc);

}



static void efx_tc_flower_release_counter(struct efx_nic *efx,

					  struct efx_tc_counter *cnt)

{

	int rc;



	rhashtable_remove_fast(&efx->tc->counter_ht, &cnt->linkage,

			       efx_tc_counter_ht_params);

	rc = efx_mae_free_counter(efx, cnt);

	if (rc)

		netif_warn(efx, hw, efx->net_dev,

			   "Failed to free MAE counter %u, rc %d\n",

			   cnt->fw_id, rc);

	/* This doesn't protect counter updates coming in arbitrarily long

	 * after we deleted the counter.  The RCU just ensures that we won't

	 * free the counter while another thread has a pointer to it.

	 * Ensuring we don't update the wrong counter if the ID gets re-used

	 * is handled by the generation count.

	 */

	synchronize_rcu();

	kfree(cnt);

}



/* TC cookie to counter mapping */



void efx_tc_flower_put_counter_index(struct efx_nic *efx,

				     struct efx_tc_counter_index *ctr)

{

	if (!refcount_dec_and_test(&ctr->ref))

		return; /* still in use */

	rhashtable_remove_fast(&efx->tc->counter_id_ht, &ctr->linkage,

			       efx_tc_counter_id_ht_params);

	efx_tc_flower_release_counter(efx, ctr->cnt);

	kfree(ctr);

}



struct efx_tc_counter_index *efx_tc_flower_get_counter_index(

				struct efx_nic *efx, unsigned long cookie,

				enum efx_tc_counter_type type)

{

	struct efx_tc_counter_index *ctr, *old;

	struct efx_tc_counter *cnt;



	ctr = kzalloc(sizeof(*ctr), GFP_USER);

	if (!ctr)

		return ERR_PTR(-ENOMEM);

	ctr->cookie = cookie;

	old = rhashtable_lookup_get_insert_fast(&efx->tc->counter_id_ht,

						&ctr->linkage,

						efx_tc_counter_id_ht_params);

	if (old) {

		/* don't need our new entry */

		kfree(ctr);

		if (!refcount_inc_not_zero(&old->ref))

			return ERR_PTR(-EAGAIN);

		/* existing entry found */

		ctr = old;

	} else {

		cnt = efx_tc_flower_allocate_counter(efx, type);

		if (IS_ERR(cnt)) {

			rhashtable_remove_fast(&efx->tc->counter_id_ht,

					       &ctr->linkage,

					       efx_tc_counter_id_ht_params);

			kfree(ctr);

			return (void *)cnt; /* it's an ERR_PTR */

		}

		ctr->cnt = cnt;

		refcount_set(&ctr->ref, 1);

	}

	return ctr;

}



/* TC Channel.  Counter updates are delivered on this channel's RXQ. */



static void efx_tc_handle_no_channel(struct efx_nic *efx)

drivers/net/ethernet/sfc/tc_counters.h

+7 −0
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ struct efx_tc_counter { 
	u32 fw_id; /* index in firmware counter table */

	enum efx_tc_counter_type type;

	struct rhash_head linkage; /* efx->tc->counter_ht */

	u32 gen; /* Generation count at which this counter is current */

};



struct efx_tc_counter_index {
@@ -40,6 +41,12 @@ int efx_tc_init_counters(struct efx_nic *efx); 
void efx_tc_destroy_counters(struct efx_nic *efx);

void efx_tc_fini_counters(struct efx_nic *efx);



struct efx_tc_counter_index *efx_tc_flower_get_counter_index(

				struct efx_nic *efx, unsigned long cookie,

				enum efx_tc_counter_type type);

void efx_tc_flower_put_counter_index(struct efx_nic *efx,

				     struct efx_tc_counter_index *ctr);



extern const struct efx_channel_type efx_tc_channel_type;



#endif /* EFX_TC_COUNTERS_H */