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

Commit 2ba5999f authored by Arkadi Sharshevsky's avatar Arkadi Sharshevsky Committed by David S. Miller
Browse files

mlxsw: spectrum: Add Support for erif table entries access 



Implement dpipe's table ops for erif table which provide:
1. Getting the entries in the table with the associate values.
	- match on "mlxsw_meta:erif_index"
	- action on "mlxsw_meta:forwared_out"
2. Synchronize the hardware in case of enabling/disabling counters which
   mean removing erif counters from all interfaces.

Signed-off-by: default avatarArkadi Sharshevsky <arkadis@mellanox.com>
Signed-off-by: default avatarJiri Pirko <jiri@mellanox.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent fd1b9d41

drivers/net/ethernet/mellanox/mlxsw/spectrum_dpipe.c

+185 −0
Original line number Diff line number Diff line
@@ -37,6 +37,7 @@ 


#include "spectrum.h"

#include "spectrum_dpipe.h"

#include "spectrum_router.h"



enum mlxsw_sp_field_metadata_id {

	MLXSW_SP_DPIPE_FIELD_METADATA_ERIF_PORT,
@@ -113,9 +114,193 @@ static int mlxsw_sp_dpipe_table_erif_matches_dump(void *priv, 
	return devlink_dpipe_match_put(skb, &match);

}



static void mlxsw_sp_erif_entry_clear(struct devlink_dpipe_entry *entry)

{

	unsigned int value_count, value_index;

	struct devlink_dpipe_value *value;



	value = entry->action_values;

	value_count = entry->action_values_count;

	for (value_index = 0; value_index < value_count; value_index++) {

		kfree(value[value_index].value);

		kfree(value[value_index].mask);

	}



	value = entry->match_values;

	value_count = entry->match_values_count;

	for (value_index = 0; value_index < value_count; value_index++) {

		kfree(value[value_index].value);

		kfree(value[value_index].mask);

	}

}



static void

mlxsw_sp_erif_match_action_prepare(struct devlink_dpipe_match *match,

				   struct devlink_dpipe_action *action)

{

	action->type = DEVLINK_DPIPE_ACTION_TYPE_FIELD_MODIFY;

	action->header = &mlxsw_sp_dpipe_header_metadata;

	action->field_id = MLXSW_SP_DPIPE_FIELD_METADATA_L3_FORWARD;



	match->type = DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT;

	match->header = &mlxsw_sp_dpipe_header_metadata;

	match->field_id = MLXSW_SP_DPIPE_FIELD_METADATA_ERIF_PORT;

}



static int mlxsw_sp_erif_entry_prepare(struct devlink_dpipe_entry *entry,

				       struct devlink_dpipe_value *match_value,

				       struct devlink_dpipe_match *match,

				       struct devlink_dpipe_value *action_value,

				       struct devlink_dpipe_action *action)

{

	entry->match_values = match_value;

	entry->match_values_count = 1;



	entry->action_values = action_value;

	entry->action_values_count = 1;



	match_value->match = match;

	match_value->value_size = sizeof(u32);

	match_value->value = kmalloc(match_value->value_size, GFP_KERNEL);

	if (!match_value->value)

		return -ENOMEM;



	action_value->action = action;

	action_value->value_size = sizeof(u32);

	action_value->value = kmalloc(action_value->value_size, GFP_KERNEL);

	if (!action_value->value)

		goto err_action_alloc;

	return 0;



err_action_alloc:

	kfree(match_value->value);

	return -ENOMEM;

}



static int mlxsw_sp_erif_entry_get(struct mlxsw_sp *mlxsw_sp,

				   struct devlink_dpipe_entry *entry,

				   struct mlxsw_sp_rif *rif,

				   bool counters_enabled)

{

	u32 *action_value;

	u32 *rif_value;

	u64 cnt;

	int err;



	/* Set Match RIF index */

	rif_value = entry->match_values->value;

	*rif_value = mlxsw_sp_rif_index(rif);

	entry->match_values->mapping_value = mlxsw_sp_rif_dev_ifindex(rif);

	entry->match_values->mapping_valid = true;



	/* Set Action Forwarding */

	action_value = entry->action_values->value;

	*action_value = 1;



	entry->counter_valid = false;

	entry->counter = 0;

	if (!counters_enabled)

		return 0;



	entry->index = mlxsw_sp_rif_index(rif);

	err = mlxsw_sp_rif_counter_value_get(mlxsw_sp, rif,

					     MLXSW_SP_RIF_COUNTER_EGRESS,

					     &cnt);

	if (!err) {

		entry->counter = cnt;

		entry->counter_valid = true;

	}

	return 0;

}



static int

mlxsw_sp_table_erif_entries_dump(void *priv, bool counters_enabled,

				 struct devlink_dpipe_dump_ctx *dump_ctx)

{

	struct devlink_dpipe_value match_value = {{0}}, action_value = {{0}};

	struct devlink_dpipe_action action = {0};

	struct devlink_dpipe_match match = {0};

	struct devlink_dpipe_entry entry = {0};

	struct mlxsw_sp *mlxsw_sp = priv;

	unsigned int rif_count;

	int i, j;

	int err;



	mlxsw_sp_erif_match_action_prepare(&match, &action);

	err = mlxsw_sp_erif_entry_prepare(&entry, &match_value, &match,

					  &action_value, &action);

	if (err)

		return err;



	rif_count = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);

	rtnl_lock();

	i = 0;

start_again:

	err = devlink_dpipe_entry_ctx_prepare(dump_ctx);

	if (err)

		return err;

	j = 0;

	for (; i < rif_count; i++) {

		if (!mlxsw_sp->rifs[i])

			continue;

		err = mlxsw_sp_erif_entry_get(mlxsw_sp, &entry,

					      mlxsw_sp->rifs[i],

					      counters_enabled);

		if (err)

			goto err_entry_get;

		err = devlink_dpipe_entry_ctx_append(dump_ctx, &entry);

		if (err) {

			if (err == -EMSGSIZE) {

				if (!j)

					goto err_entry_append;

				break;

			}

			goto err_entry_append;

		}

		j++;

	}



	devlink_dpipe_entry_ctx_close(dump_ctx);

	if (i != rif_count)

		goto start_again;

	rtnl_unlock();



	mlxsw_sp_erif_entry_clear(&entry);

	return 0;

err_entry_append:

err_entry_get:

	rtnl_unlock();

	mlxsw_sp_erif_entry_clear(&entry);

	return err;

}



static int mlxsw_sp_table_erif_counters_update(void *priv, bool enable)

{

	struct mlxsw_sp *mlxsw_sp = priv;

	int i;



	rtnl_lock();

	for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) {

		if (!mlxsw_sp->rifs[i])

			continue;

		if (enable)

			mlxsw_sp_rif_counter_alloc(mlxsw_sp,

						   mlxsw_sp->rifs[i],

						   MLXSW_SP_RIF_COUNTER_EGRESS);

		else

			mlxsw_sp_rif_counter_free(mlxsw_sp,

						  mlxsw_sp->rifs[i],

						  MLXSW_SP_RIF_COUNTER_EGRESS);

	}

	rtnl_unlock();

	return 0;

}



static struct devlink_dpipe_table_ops mlxsw_sp_erif_ops = {

	.matches_dump = mlxsw_sp_dpipe_table_erif_matches_dump,

	.actions_dump = mlxsw_sp_dpipe_table_erif_actions_dump,

	.entries_dump = mlxsw_sp_table_erif_entries_dump,

	.counters_set_update = mlxsw_sp_table_erif_counters_update,

};



static int mlxsw_sp_dpipe_erif_table_init(struct mlxsw_sp *mlxsw_sp)