[mirror_ubuntu-jammy-kernel.git] / drivers / net / ethernet / mellanox / mlx5 / core / eswitch_offloads_termtbl.c

// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
// Copyright (c) 2019 Mellanox Technologies.

#include <linux/mlx5/fs.h>
#include "eswitch.h"

struct mlx5_termtbl_handle {
	struct hlist_node termtbl_hlist;

	struct mlx5_flow_table *termtbl;
	struct mlx5_flow_act flow_act;
	struct mlx5_flow_destination dest;

	struct mlx5_flow_handle *rule;
	int ref_count;
};

static u32
mlx5_eswitch_termtbl_hash(struct mlx5_flow_act *flow_act,
			  struct mlx5_flow_destination *dest)
{
	u32 hash;

	hash = jhash_1word(flow_act->action, 0);
	hash = jhash((const void *)&flow_act->vlan,
		     sizeof(flow_act->vlan), hash);
	hash = jhash((const void *)&dest->vport.num,
		     sizeof(dest->vport.num), hash);
	hash = jhash((const void *)&dest->vport.vhca_id,
		     sizeof(dest->vport.num), hash);
	return hash;
}

static int
mlx5_eswitch_termtbl_cmp(struct mlx5_flow_act *flow_act1,
			 struct mlx5_flow_destination *dest1,
			 struct mlx5_flow_act *flow_act2,
			 struct mlx5_flow_destination *dest2)
{
	return flow_act1->action != flow_act2->action ||
	       dest1->vport.num != dest2->vport.num ||
	       dest1->vport.vhca_id != dest2->vport.vhca_id ||
	       memcmp(&flow_act1->vlan, &flow_act2->vlan,
		      sizeof(flow_act1->vlan));
}

static int
mlx5_eswitch_termtbl_create(struct mlx5_core_dev *dev,
			    struct mlx5_termtbl_handle *tt,
			    struct mlx5_flow_act *flow_act)
{
	struct mlx5_flow_table_attr ft_attr = {};
	struct mlx5_flow_namespace *root_ns;
	int err;

	root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_FDB);
	if (!root_ns) {
		esw_warn(dev, "Failed to get FDB flow namespace\n");
		return -EOPNOTSUPP;
	}

	/* As this is the terminating action then the termination table is the
	 * same prio as the slow path
	 */
	ft_attr.flags = MLX5_FLOW_TABLE_TERMINATION;
	ft_attr.prio = FDB_SLOW_PATH;
	ft_attr.max_fte = 1;
	ft_attr.autogroup.max_num_groups = 1;
	tt->termtbl = mlx5_create_auto_grouped_flow_table(root_ns, &ft_attr);
	if (IS_ERR(tt->termtbl)) {
		esw_warn(dev, "Failed to create termination table\n");
		return -EOPNOTSUPP;
	}

	tt->rule = mlx5_add_flow_rules(tt->termtbl, NULL, flow_act,
				       &tt->dest, 1);

	if (IS_ERR(tt->rule)) {
		esw_warn(dev, "Failed to create termination table rule\n");
		goto add_flow_err;
	}
	return 0;

add_flow_err:
	err = mlx5_destroy_flow_table(tt->termtbl);
	if (err)
		esw_warn(dev, "Failed to destroy termination table\n");

	return -EOPNOTSUPP;
}

static struct mlx5_termtbl_handle *
mlx5_eswitch_termtbl_get_create(struct mlx5_eswitch *esw,
				struct mlx5_flow_act *flow_act,
				struct mlx5_flow_destination *dest)
{
	struct mlx5_termtbl_handle *tt;
	bool found = false;
	u32 hash_key;
	int err;

	mutex_lock(&esw->offloads.termtbl_mutex);

	hash_key = mlx5_eswitch_termtbl_hash(flow_act, dest);
	hash_for_each_possible(esw->offloads.termtbl_tbl, tt,
			       termtbl_hlist, hash_key) {
		if (!mlx5_eswitch_termtbl_cmp(&tt->flow_act, &tt->dest,
					      flow_act, dest)) {
			found = true;
			break;
		}
	}
	if (found)
		goto tt_add_ref;

	tt = kzalloc(sizeof(*tt), GFP_KERNEL);
	if (!tt) {
		err = -ENOMEM;
		goto tt_create_err;
	}

	tt->dest.type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
	tt->dest.vport.num = dest->vport.num;
	tt->dest.vport.vhca_id = dest->vport.vhca_id;
	memcpy(&tt->flow_act, flow_act, sizeof(*flow_act));

	err = mlx5_eswitch_termtbl_create(esw->dev, tt, flow_act);
	if (err) {
		esw_warn(esw->dev, "Failed to create termination table\n");
		goto tt_create_err;
	}
	hash_add(esw->offloads.termtbl_tbl, &tt->termtbl_hlist, hash_key);
tt_add_ref:
	tt->ref_count++;
	mutex_unlock(&esw->offloads.termtbl_mutex);
	return tt;
tt_create_err:
	kfree(tt);
	mutex_unlock(&esw->offloads.termtbl_mutex);
	return ERR_PTR(err);
}

void
mlx5_eswitch_termtbl_put(struct mlx5_eswitch *esw,
			 struct mlx5_termtbl_handle *tt)
{
	mutex_lock(&esw->offloads.termtbl_mutex);
	if (--tt->ref_count == 0)
		hash_del(&tt->termtbl_hlist);
	mutex_unlock(&esw->offloads.termtbl_mutex);

	if (!tt->ref_count) {
		mlx5_del_flow_rules(tt->rule);
		mlx5_destroy_flow_table(tt->termtbl);
		kfree(tt);
	}
}

static void
mlx5_eswitch_termtbl_actions_move(struct mlx5_flow_act *src,
				  struct mlx5_flow_act *dst)
{
	if (!(src->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH))
		return;

	src->action &= ~MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH;
	dst->action |= MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH;
	memcpy(&dst->vlan[0], &src->vlan[0], sizeof(src->vlan[0]));
	memset(&src->vlan[0], 0, sizeof(src->vlan[0]));

	if (!(src->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH_2))
		return;

	src->action &= ~MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH_2;
	dst->action |= MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH_2;
	memcpy(&dst->vlan[1], &src->vlan[1], sizeof(src->vlan[1]));
	memset(&src->vlan[1], 0, sizeof(src->vlan[1]));
}

static bool mlx5_eswitch_offload_is_uplink_port(const struct mlx5_eswitch *esw,
						const struct mlx5_flow_spec *spec)
{
	u16 port_mask, port_value;

	if (MLX5_CAP_ESW_FLOWTABLE(esw->dev, flow_source))
		return spec->flow_context.flow_source ==
					MLX5_FLOW_CONTEXT_FLOW_SOURCE_UPLINK;

	port_mask = MLX5_GET(fte_match_param, spec->match_criteria,
			     misc_parameters.source_port);
	port_value = MLX5_GET(fte_match_param, spec->match_value,
			      misc_parameters.source_port);
	return (port_mask & port_value) == MLX5_VPORT_UPLINK;
}

bool
mlx5_eswitch_termtbl_required(struct mlx5_eswitch *esw,
			      struct mlx5_flow_act *flow_act,
			      struct mlx5_flow_spec *spec)
{
	if (!MLX5_CAP_ESW_FLOWTABLE_FDB(esw->dev, termination_table))
		return false;

	/* push vlan on RX */
	return (flow_act->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH) &&
		mlx5_eswitch_offload_is_uplink_port(esw, spec);
}

struct mlx5_flow_handle *
mlx5_eswitch_add_termtbl_rule(struct mlx5_eswitch *esw,
			      struct mlx5_flow_table *fdb,
			      struct mlx5_flow_spec *spec,
			      struct mlx5_esw_flow_attr *attr,
			      struct mlx5_flow_act *flow_act,
			      struct mlx5_flow_destination *dest,
			      int num_dest)
{
	struct mlx5_flow_act term_tbl_act = {};
	struct mlx5_flow_handle *rule = NULL;
	bool term_table_created = false;
	int num_vport_dests = 0;
	int i, curr_dest;

	mlx5_eswitch_termtbl_actions_move(flow_act, &term_tbl_act);
	term_tbl_act.action |= MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;

	for (i = 0; i < num_dest; i++) {
		struct mlx5_termtbl_handle *tt;

		/* only vport destinations can be terminated */
		if (dest[i].type != MLX5_FLOW_DESTINATION_TYPE_VPORT)
			continue;

		/* get the terminating table for the action list */
		tt = mlx5_eswitch_termtbl_get_create(esw, &term_tbl_act,
						     &dest[i]);
		if (IS_ERR(tt)) {
			esw_warn(esw->dev, "Failed to create termination table\n");
			goto revert_changes;
		}
		attr->dests[num_vport_dests].termtbl = tt;
		num_vport_dests++;

		/* link the destination with the termination table */
		dest[i].type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
		dest[i].ft = tt->termtbl;
		term_table_created = true;
	}

	/* at least one destination should reference a termination table */
	if (!term_table_created)
		goto revert_changes;

	/* create the FTE */
	rule = mlx5_add_flow_rules(fdb, spec, flow_act, dest, num_dest);
	if (IS_ERR(rule))
		goto revert_changes;

	goto out;

revert_changes:
	/* revert the changes that were made to the original flow_act
	 * and fall-back to the original rule actions
	 */
	mlx5_eswitch_termtbl_actions_move(&term_tbl_act, flow_act);

	for (curr_dest = 0; curr_dest < num_vport_dests; curr_dest++) {
		struct mlx5_termtbl_handle *tt = attr->dests[curr_dest].termtbl;

		/* search for the destination associated with the
		 * current term table
		 */
		for (i = 0; i < num_dest; i++) {
			if (dest[i].ft != tt->termtbl)
				continue;

			memset(&dest[i], 0, sizeof(dest[i]));
			dest[i].type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
			dest[i].vport.num = tt->dest.vport.num;
			dest[i].vport.vhca_id = tt->dest.vport.vhca_id;
			mlx5_eswitch_termtbl_put(esw, tt);
			break;
		}
	}
	rule = mlx5_add_flow_rules(fdb, spec, flow_act, dest, num_dest);
out:
	return rule;
}
Commit	Line	Data
10caabda OS	1	// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
	2	// Copyright (c) 2019 Mellanox Technologies.
	3
	4	#include <linux/mlx5/fs.h>
	5	#include "eswitch.h"
	6
	7	struct mlx5_termtbl_handle {
	8	struct hlist_node termtbl_hlist;
	9
	10	struct mlx5_flow_table *termtbl;
	11	struct mlx5_flow_act flow_act;
	12	struct mlx5_flow_destination dest;
	13
	14	struct mlx5_flow_handle *rule;
	15	int ref_count;
	16	};
	17
	18	static u32
	19	mlx5_eswitch_termtbl_hash(struct mlx5_flow_act *flow_act,
	20	struct mlx5_flow_destination *dest)
	21	{
	22	u32 hash;
	23
	24	hash = jhash_1word(flow_act->action, 0);
	25	hash = jhash((const void *)&flow_act->vlan,
	26	sizeof(flow_act->vlan), hash);
	27	hash = jhash((const void *)&dest->vport.num,
	28	sizeof(dest->vport.num), hash);
	29	hash = jhash((const void *)&dest->vport.vhca_id,
	30	sizeof(dest->vport.num), hash);
	31	return hash;
	32	}
	33
	34	static int
	35	mlx5_eswitch_termtbl_cmp(struct mlx5_flow_act *flow_act1,
	36	struct mlx5_flow_destination *dest1,
	37	struct mlx5_flow_act *flow_act2,
	38	struct mlx5_flow_destination *dest2)
	39	{
	40	return flow_act1->action != flow_act2->action \|\|
	41	dest1->vport.num != dest2->vport.num \|\|
	42	dest1->vport.vhca_id != dest2->vport.vhca_id \|\|
	43	memcmp(&flow_act1->vlan, &flow_act2->vlan,
	44	sizeof(flow_act1->vlan));
	45	}
	46
	47	static int
	48	mlx5_eswitch_termtbl_create(struct mlx5_core_dev *dev,
	49	struct mlx5_termtbl_handle *tt,
	50	struct mlx5_flow_act *flow_act)
	51	{
61dc7b01	52	struct mlx5_flow_table_attr ft_attr = {};
10caabda	53	struct mlx5_flow_namespace *root_ns;
10caabda OS	54	int err;
	55
	56	root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_FDB);
	57	if (!root_ns) {
	58	esw_warn(dev, "Failed to get FDB flow namespace\n");
	59	return -EOPNOTSUPP;
	60	}
	61
	62	/* As this is the terminating action then the termination table is the
	63	* same prio as the slow path
	64	*/
61dc7b01 PB	65	ft_attr.flags = MLX5_FLOW_TABLE_TERMINATION;
	66	ft_attr.prio = FDB_SLOW_PATH;
	67	ft_attr.max_fte = 1;
	68	ft_attr.autogroup.max_num_groups = 1;
	69	tt->termtbl = mlx5_create_auto_grouped_flow_table(root_ns, &ft_attr);
10caabda OS	70	if (IS_ERR(tt->termtbl)) {
	71	esw_warn(dev, "Failed to create termination table\n");
	72	return -EOPNOTSUPP;
	73	}
	74
5c2aa8ae	75	tt->rule = mlx5_add_flow_rules(tt->termtbl, NULL, flow_act,
10caabda OS	76	&tt->dest, 1);
	77
	78	if (IS_ERR(tt->rule)) {
	79	esw_warn(dev, "Failed to create termination table rule\n");
	80	goto add_flow_err;
	81	}
	82	return 0;
	83
	84	add_flow_err:
	85	err = mlx5_destroy_flow_table(tt->termtbl);
	86	if (err)
	87	esw_warn(dev, "Failed to destroy termination table\n");
	88
	89	return -EOPNOTSUPP;
	90	}
	91
	92	static struct mlx5_termtbl_handle *
	93	mlx5_eswitch_termtbl_get_create(struct mlx5_eswitch *esw,
	94	struct mlx5_flow_act *flow_act,
	95	struct mlx5_flow_destination *dest)
	96	{
	97	struct mlx5_termtbl_handle *tt;
	98	bool found = false;
	99	u32 hash_key;
	100	int err;
	101
	102	mutex_lock(&esw->offloads.termtbl_mutex);
	103
	104	hash_key = mlx5_eswitch_termtbl_hash(flow_act, dest);
	105	hash_for_each_possible(esw->offloads.termtbl_tbl, tt,
	106	termtbl_hlist, hash_key) {
	107	if (!mlx5_eswitch_termtbl_cmp(&tt->flow_act, &tt->dest,
	108	flow_act, dest)) {
	109	found = true;
	110	break;
	111	}
	112	}
	113	if (found)
	114	goto tt_add_ref;
	115
	116	tt = kzalloc(sizeof(*tt), GFP_KERNEL);
	117	if (!tt) {
	118	err = -ENOMEM;
	119	goto tt_create_err;
	120	}
	121
	122	tt->dest.type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
	123	tt->dest.vport.num = dest->vport.num;
	124	tt->dest.vport.vhca_id = dest->vport.vhca_id;
	125	memcpy(&tt->flow_act, flow_act, sizeof(*flow_act));
	126
	127	err = mlx5_eswitch_termtbl_create(esw->dev, tt, flow_act);
	128	if (err) {
	129	esw_warn(esw->dev, "Failed to create termination table\n");
	130	goto tt_create_err;
	131	}
	132	hash_add(esw->offloads.termtbl_tbl, &tt->termtbl_hlist, hash_key);
	133	tt_add_ref:
	134	tt->ref_count++;
	135	mutex_unlock(&esw->offloads.termtbl_mutex);
	136	return tt;
	137	tt_create_err:
	138	kfree(tt);
	139	mutex_unlock(&esw->offloads.termtbl_mutex);
140	return ERR_PTR(err);
141	}
142
143	void
144	mlx5_eswitch_termtbl_put(struct mlx5_eswitch *esw,
145	struct mlx5_termtbl_handle *tt)
146	{
147	mutex_lock(&esw->offloads.termtbl_mutex);
148	if (--tt->ref_count == 0)
149	hash_del(&tt->termtbl_hlist);
150	mutex_unlock(&esw->offloads.termtbl_mutex);
151
152	if (!tt->ref_count) {
153	mlx5_del_flow_rules(tt->rule);
154	mlx5_destroy_flow_table(tt->termtbl);
155	kfree(tt);
156	}
157	}
158
159	static void
160	mlx5_eswitch_termtbl_actions_move(struct mlx5_flow_act *src,
161	struct mlx5_flow_act *dst)
162	{
163	if (!(src->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH))
164	return;
165
166	src->action &= ~MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH;
167	dst->action \|= MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH;
168	memcpy(&dst->vlan[0], &src->vlan[0], sizeof(src->vlan[0]));
169	memset(&src->vlan[0], 0, sizeof(src->vlan[0]));
170
171	if (!(src->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH_2))
172	return;
173
174	src->action &= ~MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH_2;
175	dst->action \|= MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH_2;
176	memcpy(&dst->vlan[1], &src->vlan[1], sizeof(src->vlan[1]));
177	memset(&src->vlan[1], 0, sizeof(src->vlan[1]));
178	}
179
d5dbcc4e DL	180	static bool mlx5_eswitch_offload_is_uplink_port(const struct mlx5_eswitch *esw,
	181	const struct mlx5_flow_spec *spec)
	182	{
1708dd54	183	u16 port_mask, port_value;
d5dbcc4e DL	184
d5dbcc4e DL	185	if (MLX5_CAP_ESW_FLOWTABLE(esw->dev, flow_source))
950d3af7 DL	186	return spec->flow_context.flow_source ==
950d3af7 DL	187	MLX5_FLOW_CONTEXT_FLOW_SOURCE_UPLINK;
d5dbcc4e DL	188
	189	port_mask = MLX5_GET(fte_match_param, spec->match_criteria,
	190	misc_parameters.source_port);
	191	port_value = MLX5_GET(fte_match_param, spec->match_value,
	192	misc_parameters.source_port);
1708dd54	193	return (port_mask & port_value) == MLX5_VPORT_UPLINK;
d5dbcc4e DL	194	}
d5dbcc4e DL	195
10caabda OS	196	bool
	197	mlx5_eswitch_termtbl_required(struct mlx5_eswitch *esw,
	198	struct mlx5_flow_act *flow_act,
	199	struct mlx5_flow_spec *spec)
	200	{
10caabda OS	201	if (!MLX5_CAP_ESW_FLOWTABLE_FDB(esw->dev, termination_table))
	202	return false;
	203
	204	/* push vlan on RX */
	205	return (flow_act->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH) &&
d5dbcc4e	206	mlx5_eswitch_offload_is_uplink_port(esw, spec);
10caabda OS	207	}
	208
	209	struct mlx5_flow_handle *
	210	mlx5_eswitch_add_termtbl_rule(struct mlx5_eswitch *esw,
	211	struct mlx5_flow_table *fdb,
	212	struct mlx5_flow_spec *spec,
	213	struct mlx5_esw_flow_attr *attr,
	214	struct mlx5_flow_act *flow_act,
	215	struct mlx5_flow_destination *dest,
	216	int num_dest)
	217	{
	218	struct mlx5_flow_act term_tbl_act = {};
	219	struct mlx5_flow_handle *rule = NULL;
	220	bool term_table_created = false;
	221	int num_vport_dests = 0;
	222	int i, curr_dest;
	223
	224	mlx5_eswitch_termtbl_actions_move(flow_act, &term_tbl_act);
	225	term_tbl_act.action \|= MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
	226
	227	for (i = 0; i < num_dest; i++) {
	228	struct mlx5_termtbl_handle *tt;
	229
	230	/* only vport destinations can be terminated */
	231	if (dest[i].type != MLX5_FLOW_DESTINATION_TYPE_VPORT)
	232	continue;
	233
	234	/* get the terminating table for the action list */
	235	tt = mlx5_eswitch_termtbl_get_create(esw, &term_tbl_act,
	236	&dest[i]);
	237	if (IS_ERR(tt)) {
	238	esw_warn(esw->dev, "Failed to create termination table\n");
	239	goto revert_changes;
	240	}
	241	attr->dests[num_vport_dests].termtbl = tt;
	242	num_vport_dests++;
	243
	244	/* link the destination with the termination table */
	245	dest[i].type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
	246	dest[i].ft = tt->termtbl;
	247	term_table_created = true;
	248	}
	249
	250	/* at least one destination should reference a termination table */
	251	if (!term_table_created)
	252	goto revert_changes;
	253
	254	/* create the FTE */
	255	rule = mlx5_add_flow_rules(fdb, spec, flow_act, dest, num_dest);
	256	if (IS_ERR(rule))
	257	goto revert_changes;
	258
	259	goto out;
	260
	261	revert_changes:
	262	/* revert the changes that were made to the original flow_act
	263	* and fall-back to the original rule actions
	264	*/
	265	mlx5_eswitch_termtbl_actions_move(&term_tbl_act, flow_act);
	266
	267	for (curr_dest = 0; curr_dest < num_vport_dests; curr_dest++) {
	268	struct mlx5_termtbl_handle *tt = attr->dests[curr_dest].termtbl;
	269
	270	/* search for the destination associated with the
271	* current term table
272	*/
273	for (i = 0; i < num_dest; i++) {
274	if (dest[i].ft != tt->termtbl)
275	continue;
276
277	memset(&dest[i], 0, sizeof(dest[i]));
278	dest[i].type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
279	dest[i].vport.num = tt->dest.vport.num;
280	dest[i].vport.vhca_id = tt->dest.vport.vhca_id;
281	mlx5_eswitch_termtbl_put(esw, tt);
282	break;
283	}
284	}
285	rule = mlx5_add_flow_rules(fdb, spec, flow_act, dest, num_dest);
286	out:
287	return rule;
288	}