Commit ef7b79b9 authored by Mark Bloch's avatar Mark Bloch Committed by Jakub Kicinski
Browse files

net/mlx5: fs, separate action and destination into distinct struct 



Introduce a dedicated structure to encapsulate flow context, actions,
destination count, and modification mask. This refactoring lays the
groundwork for forthcoming patches that will integrate the NO APPEND
software logic. Future modifications should focus solely on these
specific fields.

Signed-off-by: default avatarMark Bloch <mbloch@nvidia.com>
Signed-off-by: default avatarSaeed Mahameed <saeedm@nvidia.com>
Reviewed-by: default avatarJacob Keller <jacob.e.keller@intel.com>
Link: https://patch.msgid.link/20240911201757.1505453-8-saeed@kernel.org


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent 8ad0e960

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.h

+4 −4
Original line number Diff line number Diff line
@@ -203,10 +203,10 @@ TRACE_EVENT(mlx5_fs_set_fte, 
			   fs_get_obj(__entry->fg, fte->node.parent);

			   __entry->group_index = __entry->fg->id;

			   __entry->index = fte->index;

			   __entry->action = fte->action.action;

			   __entry->action = fte->act_dests.action.action;

			   __entry->mask_enable = __entry->fg->mask.match_criteria_enable;

			   __entry->flow_tag = fte->flow_context.flow_tag;

			   __entry->flow_source = fte->flow_context.flow_source;

			   __entry->flow_tag = fte->act_dests.flow_context.flow_tag;

			   __entry->flow_source = fte->act_dests.flow_context.flow_source;

			   memcpy(__entry->mask_outer,

				  MLX5_ADDR_OF(fte_match_param,

					       &__entry->fg->mask.match_criteria,
@@ -284,7 +284,7 @@ TRACE_EVENT(mlx5_fs_add_rule, 
	    TP_fast_assign(

			   __entry->rule = rule;

			   fs_get_obj(__entry->fte, rule->node.parent);

			   __entry->index = __entry->fte->dests_size - 1;

			   __entry->index = __entry->fte->act_dests.dests_size - 1;

			   __entry->sw_action = rule->sw_action;

			   memcpy(__entry->destination,

				  &rule->dest_attr,

drivers/net/ethernet/mellanox/mlx5/core/fs_cmd.c

+30 −30
Original line number Diff line number Diff line
@@ -463,7 +463,7 @@ static int mlx5_set_extended_dest(struct mlx5_core_dev *dev, 
	int num_encap = 0;



	*extended_dest = false;

	if (!(fte->action.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST))

	if (!(fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST))

		return 0;



	list_for_each_entry(dst, &fte->node.children, node.list) {
@@ -502,17 +502,17 @@ mlx5_cmd_set_fte_flow_meter(struct fs_fte *fte, void *in_flow_context) 
				   execute_aso[0]);

	MLX5_SET(execute_aso, execute_aso, valid, 1);

	MLX5_SET(execute_aso, execute_aso, aso_object_id,

		 fte->action.exe_aso.object_id);

		 fte->act_dests.action.exe_aso.object_id);



	exe_aso_ctrl = MLX5_ADDR_OF(execute_aso, execute_aso, exe_aso_ctrl);

	MLX5_SET(exe_aso_ctrl_flow_meter, exe_aso_ctrl, return_reg_id,

		 fte->action.exe_aso.return_reg_id);

		 fte->act_dests.action.exe_aso.return_reg_id);

	MLX5_SET(exe_aso_ctrl_flow_meter, exe_aso_ctrl, aso_type,

		 fte->action.exe_aso.type);

		 fte->act_dests.action.exe_aso.type);

	MLX5_SET(exe_aso_ctrl_flow_meter, exe_aso_ctrl, init_color,

		 fte->action.exe_aso.flow_meter.init_color);

		 fte->act_dests.action.exe_aso.flow_meter.init_color);

	MLX5_SET(exe_aso_ctrl_flow_meter, exe_aso_ctrl, meter_id,

		 fte->action.exe_aso.flow_meter.meter_idx);

		 fte->act_dests.action.exe_aso.flow_meter.meter_idx);

}



static int mlx5_cmd_set_fte(struct mlx5_core_dev *dev,
@@ -541,7 +541,7 @@ static int mlx5_cmd_set_fte(struct mlx5_core_dev *dev, 
	else

		dst_cnt_size = MLX5_ST_SZ_BYTES(extended_dest_format);



	inlen = MLX5_ST_SZ_BYTES(set_fte_in) + fte->dests_size * dst_cnt_size;

	inlen = MLX5_ST_SZ_BYTES(set_fte_in) + fte->act_dests.dests_size * dst_cnt_size;

	in = kvzalloc(inlen, GFP_KERNEL);

	if (!in)

		return -ENOMEM;
@@ -553,7 +553,7 @@ static int mlx5_cmd_set_fte(struct mlx5_core_dev *dev, 
	MLX5_SET(set_fte_in, in, table_id,   ft->id);

	MLX5_SET(set_fte_in, in, flow_index, fte->index);

	MLX5_SET(set_fte_in, in, ignore_flow_level,

		 !!(fte->action.flags & FLOW_ACT_IGNORE_FLOW_LEVEL));

		 !!(fte->act_dests.action.flags & FLOW_ACT_IGNORE_FLOW_LEVEL));



	MLX5_SET(set_fte_in, in, vport_number, ft->vport);

	MLX5_SET(set_fte_in, in, other_vport,
@@ -563,23 +563,23 @@ static int mlx5_cmd_set_fte(struct mlx5_core_dev *dev, 
	MLX5_SET(flow_context, in_flow_context, group_id, group_id);



	MLX5_SET(flow_context, in_flow_context, flow_tag,

		 fte->flow_context.flow_tag);

		 fte->act_dests.flow_context.flow_tag);

	MLX5_SET(flow_context, in_flow_context, flow_source,

		 fte->flow_context.flow_source);

		 fte->act_dests.flow_context.flow_source);

	MLX5_SET(flow_context, in_flow_context, uplink_hairpin_en,

		 !!(fte->flow_context.flags & FLOW_CONTEXT_UPLINK_HAIRPIN_EN));

		 !!(fte->act_dests.flow_context.flags & FLOW_CONTEXT_UPLINK_HAIRPIN_EN));



	MLX5_SET(flow_context, in_flow_context, extended_destination,

		 extended_dest);



	action = fte->action.action;

	action = fte->act_dests.action.action;

	if (extended_dest)

		action &= ~MLX5_FLOW_CONTEXT_ACTION_PACKET_REFORMAT;



	MLX5_SET(flow_context, in_flow_context, action, action);



	if (!extended_dest && fte->action.pkt_reformat) {

		struct mlx5_pkt_reformat *pkt_reformat = fte->action.pkt_reformat;

	if (!extended_dest && fte->act_dests.action.pkt_reformat) {

		struct mlx5_pkt_reformat *pkt_reformat = fte->act_dests.action.pkt_reformat;



		if (pkt_reformat->owner == MLX5_FLOW_RESOURCE_OWNER_SW) {

			reformat_id = mlx5_fs_dr_action_get_pkt_reformat_id(pkt_reformat);
@@ -591,46 +591,46 @@ static int mlx5_cmd_set_fte(struct mlx5_core_dev *dev, 
				goto err_out;

			}

		} else {

			reformat_id = fte->action.pkt_reformat->id;

			reformat_id = fte->act_dests.action.pkt_reformat->id;

		}

	}



	MLX5_SET(flow_context, in_flow_context, packet_reformat_id, (u32)reformat_id);



	if (fte->action.modify_hdr) {

		if (fte->action.modify_hdr->owner == MLX5_FLOW_RESOURCE_OWNER_SW) {

	if (fte->act_dests.action.modify_hdr) {

		if (fte->act_dests.action.modify_hdr->owner == MLX5_FLOW_RESOURCE_OWNER_SW) {

			mlx5_core_err(dev, "Can't use SW-owned modify_hdr in FW-owned table\n");

			err = -EOPNOTSUPP;

			goto err_out;

		}



		MLX5_SET(flow_context, in_flow_context, modify_header_id,

			 fte->action.modify_hdr->id);

			 fte->act_dests.action.modify_hdr->id);

	}



	MLX5_SET(flow_context, in_flow_context, encrypt_decrypt_type,

		 fte->action.crypto.type);

		 fte->act_dests.action.crypto.type);

	MLX5_SET(flow_context, in_flow_context, encrypt_decrypt_obj_id,

		 fte->action.crypto.obj_id);

		 fte->act_dests.action.crypto.obj_id);



	vlan = MLX5_ADDR_OF(flow_context, in_flow_context, push_vlan);



	MLX5_SET(vlan, vlan, ethtype, fte->action.vlan[0].ethtype);

	MLX5_SET(vlan, vlan, vid, fte->action.vlan[0].vid);

	MLX5_SET(vlan, vlan, prio, fte->action.vlan[0].prio);

	MLX5_SET(vlan, vlan, ethtype, fte->act_dests.action.vlan[0].ethtype);

	MLX5_SET(vlan, vlan, vid, fte->act_dests.action.vlan[0].vid);

	MLX5_SET(vlan, vlan, prio, fte->act_dests.action.vlan[0].prio);



	vlan = MLX5_ADDR_OF(flow_context, in_flow_context, push_vlan_2);



	MLX5_SET(vlan, vlan, ethtype, fte->action.vlan[1].ethtype);

	MLX5_SET(vlan, vlan, vid, fte->action.vlan[1].vid);

	MLX5_SET(vlan, vlan, prio, fte->action.vlan[1].prio);

	MLX5_SET(vlan, vlan, ethtype, fte->act_dests.action.vlan[1].ethtype);

	MLX5_SET(vlan, vlan, vid, fte->act_dests.action.vlan[1].vid);

	MLX5_SET(vlan, vlan, prio, fte->act_dests.action.vlan[1].prio);



	in_match_value = MLX5_ADDR_OF(flow_context, in_flow_context,

				      match_value);

	memcpy(in_match_value, &fte->val, sizeof(fte->val));



	in_dests = MLX5_ADDR_OF(flow_context, in_flow_context, destination);

	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST) {

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST) {

		int list_size = 0;



		list_for_each_entry(dst, &fte->node.children, node.list) {
@@ -706,7 +706,7 @@ static int mlx5_cmd_set_fte(struct mlx5_core_dev *dev, 
			 list_size);

	}



	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_COUNT) {

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_COUNT) {

		int max_list_size = BIT(MLX5_CAP_FLOWTABLE_TYPE(dev,

					log_max_flow_counter,

					ft->type));
@@ -731,8 +731,8 @@ static int mlx5_cmd_set_fte(struct mlx5_core_dev *dev, 
			 list_size);

	}



	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_EXECUTE_ASO) {

		if (fte->action.exe_aso.type == MLX5_EXE_ASO_FLOW_METER) {

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_EXECUTE_ASO) {

		if (fte->act_dests.action.exe_aso.type == MLX5_EXE_ASO_FLOW_METER) {

			mlx5_cmd_set_fte_flow_meter(fte, in_flow_context);

		} else {

			err = -EOPNOTSUPP;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c

+28 −28
Original line number Diff line number Diff line
@@ -605,12 +605,12 @@ static void modify_fte(struct fs_fte *fte) 
	dev = get_dev(&fte->node);



	root = find_root(&ft->node);

	err = root->cmds->update_fte(root, ft, fg, fte->modify_mask, fte);

	err = root->cmds->update_fte(root, ft, fg, fte->act_dests.modify_mask, fte);

	if (err)

		mlx5_core_warn(dev,

			       "%s can't del rule fg id=%d fte_index=%d\n",

			       __func__, fg->id, fte->index);

	fte->modify_mask = 0;

	fte->act_dests.modify_mask = 0;

}



static void del_sw_hw_rule(struct fs_node *node)
@@ -628,29 +628,29 @@ static void del_sw_hw_rule(struct fs_node *node) 
	}



	if (rule->dest_attr.type == MLX5_FLOW_DESTINATION_TYPE_COUNTER) {

		--fte->dests_size;

		fte->modify_mask |=

		--fte->act_dests.dests_size;

		fte->act_dests.modify_mask |=

			BIT(MLX5_SET_FTE_MODIFY_ENABLE_MASK_ACTION) |

			BIT(MLX5_SET_FTE_MODIFY_ENABLE_MASK_FLOW_COUNTERS);

		fte->action.action &= ~MLX5_FLOW_CONTEXT_ACTION_COUNT;

		fte->act_dests.action.action &= ~MLX5_FLOW_CONTEXT_ACTION_COUNT;

		goto out;

	}



	if (rule->dest_attr.type == MLX5_FLOW_DESTINATION_TYPE_PORT) {

		--fte->dests_size;

		fte->modify_mask |= BIT(MLX5_SET_FTE_MODIFY_ENABLE_MASK_ACTION);

		fte->action.action &= ~MLX5_FLOW_CONTEXT_ACTION_ALLOW;

		--fte->act_dests.dests_size;

		fte->act_dests.modify_mask |= BIT(MLX5_SET_FTE_MODIFY_ENABLE_MASK_ACTION);

		fte->act_dests.action.action &= ~MLX5_FLOW_CONTEXT_ACTION_ALLOW;

		goto out;

	}



	if (is_fwd_dest_type(rule->dest_attr.type)) {

		--fte->dests_size;

		--fte->fwd_dests;

		--fte->act_dests.dests_size;

		--fte->act_dests.fwd_dests;



		if (!fte->fwd_dests)

			fte->action.action &=

		if (!fte->act_dests.fwd_dests)

			fte->act_dests.action.action &=

				~MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;

		fte->modify_mask |=

		fte->act_dests.modify_mask |=

			BIT(MLX5_SET_FTE_MODIFY_ENABLE_MASK_DESTINATION_LIST);

		goto out;

	}
@@ -672,7 +672,7 @@ static void del_hw_fte(struct fs_node *node) 
	fs_get_obj(ft, fg->node.parent);



	trace_mlx5_fs_del_fte(fte);

	WARN_ON(fte->dests_size);

	WARN_ON(fte->act_dests.dests_size);

	dev = get_dev(&ft->node);

	root = find_root(&ft->node);

	if (node->active) {
@@ -784,8 +784,8 @@ static struct fs_fte *alloc_fte(struct mlx5_flow_table *ft, 


	memcpy(fte->val, &spec->match_value, sizeof(fte->val));

	fte->node.type =  FS_TYPE_FLOW_ENTRY;

	fte->action = *flow_act;

	fte->flow_context = spec->flow_context;

	fte->act_dests.action = *flow_act;

	fte->act_dests.flow_context = spec->flow_context;



	tree_init_node(&fte->node, del_hw_fte, del_sw_fte);
@@ -1116,7 +1116,7 @@ static int _mlx5_modify_rule_destination(struct mlx5_flow_rule *rule, 
	int err = 0;



	fs_get_obj(fte, rule->node.parent);

	if (!(fte->action.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST))

	if (!(fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST))

		return -EINVAL;

	down_write_ref_node(&fte->node, false);

	fs_get_obj(fg, fte->node.parent);
@@ -1462,7 +1462,7 @@ static void destroy_flow_handle(struct fs_fte *fte, 
{

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

		if (refcount_dec_and_test(&handle->rule[i]->node.refcount)) {

			fte->dests_size--;

			fte->act_dests.dests_size--;

			list_del(&handle->rule[i]->node.list);

			kfree(handle->rule[i]);

		}
@@ -1512,10 +1512,10 @@ create_flow_handle(struct fs_fte *fte, 
		else

			list_add_tail(&rule->node.list, &fte->node.children);

		if (dest) {

			fte->dests_size++;

			fte->act_dests.dests_size++;



			if (is_fwd_dest_type(dest[i].type))

				fte->fwd_dests++;

				fte->act_dests.fwd_dests++;



			type = dest[i].type ==

				MLX5_FLOW_DESTINATION_TYPE_COUNTER;
@@ -1776,17 +1776,17 @@ static int check_conflicting_ftes(struct fs_fte *fte, 
				  const struct mlx5_flow_context *flow_context,

				  const struct mlx5_flow_act *flow_act)

{

	if (check_conflicting_actions(flow_act, &fte->action)) {

	if (check_conflicting_actions(flow_act, &fte->act_dests.action)) {

		mlx5_core_warn(get_dev(&fte->node),

			       "Found two FTEs with conflicting actions\n");

		return -EEXIST;

	}



	if ((flow_context->flags & FLOW_CONTEXT_HAS_TAG) &&

	    fte->flow_context.flow_tag != flow_context->flow_tag) {

	    fte->act_dests.flow_context.flow_tag != flow_context->flow_tag) {

		mlx5_core_warn(get_dev(&fte->node),

			       "FTE flow tag %u already exists with different flow tag %u\n",

			       fte->flow_context.flow_tag,

			       fte->act_dests.flow_context.flow_tag,

			       flow_context->flow_tag);

		return -EEXIST;

	}
@@ -1810,12 +1810,12 @@ static struct mlx5_flow_handle *add_rule_fg(struct mlx5_flow_group *fg, 
	if (ret)

		return ERR_PTR(ret);



	old_action = fte->action.action;

	fte->action.action |= flow_act->action;

	old_action = fte->act_dests.action.action;

	fte->act_dests.action.action |= flow_act->action;

	handle = add_rule_fte(fte, fg, dest, dest_num,

			      old_action != flow_act->action);

	if (IS_ERR(handle)) {

		fte->action.action = old_action;

		fte->act_dests.action.action = old_action;

		return handle;

	}

	trace_mlx5_fs_set_fte(fte, false);
@@ -2269,8 +2269,8 @@ void mlx5_del_flow_rules(struct mlx5_flow_handle *handle) 
		fte->node.del_hw_func(&fte->node);

		up_write_ref_node(&fte->node, false);

		tree_put_node(&fte->node, false);

	} else if (fte->dests_size) {

		if (fte->modify_mask)

	} else if (fte->act_dests.dests_size) {

		if (fte->act_dests.modify_mask)

			modify_fte(fte);

		up_write_ref_node(&fte->node, false);

	} else {

drivers/net/ethernet/mellanox/mlx5/core/fs_core.h

+9 −5
Original line number Diff line number Diff line
@@ -230,19 +230,23 @@ struct mlx5_ft_underlay_qp { 
			   MLX5_BYTE_OFF(fte_match_param,		     \

					 MLX5_FTE_MATCH_PARAM_RESERVED)))



struct fs_fte_action {

	int				modify_mask;

	u32				dests_size;

	u32				fwd_dests;

	struct mlx5_flow_context	flow_context;

	struct mlx5_flow_act		action;

};



/* Type of children is mlx5_flow_rule */

struct fs_fte {

	struct fs_node			node;

	struct mlx5_fs_dr_rule		fs_dr_rule;

	u32				val[MLX5_ST_SZ_DW_MATCH_PARAM];

	u32				dests_size;

	u32				fwd_dests;

	struct fs_fte_action		act_dests;

	u32				index;

	struct mlx5_flow_context	flow_context;

	struct mlx5_flow_act		action;

	enum fs_fte_status		status;

	struct rhash_head		hash;

	int				modify_mask;

};



/* Type of children is mlx5_flow_table/namespace */

drivers/net/ethernet/mellanox/mlx5/core/steering/fs_dr.c

+33 −31
Original line number Diff line number Diff line
@@ -298,12 +298,12 @@ static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 
	match_sz = sizeof(fte->val);



	/* Drop reformat action bit if destination vport set with reformat */

	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST) {

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST) {

		list_for_each_entry(dst, &fte->node.children, node.list) {

			if (!contain_vport_reformat_action(dst))

				continue;



			fte->action.action &= ~MLX5_FLOW_CONTEXT_ACTION_PACKET_REFORMAT;

			fte->act_dests.action.action &= ~MLX5_FLOW_CONTEXT_ACTION_PACKET_REFORMAT;

			break;

		}

	}
@@ -313,7 +313,7 @@ static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 
	 * TX: modify header -> push vlan -> encap

	 * RX: decap -> pop vlan -> modify header

	 */

	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_DECAP) {

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_DECAP) {

		enum mlx5dr_action_reformat_type decap_type =

			DR_ACTION_REFORMAT_TYP_TNL_L2_TO_L2;
@@ -329,26 +329,26 @@ static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 
		actions[num_actions++] = tmp_action;

	}



	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_PACKET_REFORMAT) {

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_PACKET_REFORMAT) {

		bool is_decap;



		if (fte->action.pkt_reformat->owner == MLX5_FLOW_RESOURCE_OWNER_FW) {

		if (fte->act_dests.action.pkt_reformat->owner == MLX5_FLOW_RESOURCE_OWNER_FW) {

			err = -EINVAL;

			mlx5dr_err(domain, "FW-owned reformat can't be used in SW rule\n");

			goto free_actions;

		}



		is_decap = fte->action.pkt_reformat->reformat_type ==

		is_decap = fte->act_dests.action.pkt_reformat->reformat_type ==

			   MLX5_REFORMAT_TYPE_L3_TUNNEL_TO_L2;



		if (is_decap)

			actions[num_actions++] =

				fte->action.pkt_reformat->action.dr_action;

				fte->act_dests.action.pkt_reformat->action.dr_action;

		else

			delay_encap_set = true;

	}



	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_VLAN_POP) {

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_VLAN_POP) {

		tmp_action =

			mlx5dr_action_create_pop_vlan();

		if (!tmp_action) {
@@ -359,7 +359,7 @@ static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 
		actions[num_actions++] = tmp_action;

	}



	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_VLAN_POP_2) {

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_VLAN_POP_2) {

		tmp_action =

			mlx5dr_action_create_pop_vlan();

		if (!tmp_action) {
@@ -370,12 +370,12 @@ static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 
		actions[num_actions++] = tmp_action;

	}



	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR)

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR)

		actions[num_actions++] =

			fte->action.modify_hdr->action.dr_action;

			fte->act_dests.action.modify_hdr->action.dr_action;



	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH) {

		tmp_action = create_action_push_vlan(domain, &fte->action.vlan[0]);

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH) {

		tmp_action = create_action_push_vlan(domain, &fte->act_dests.action.vlan[0]);

		if (!tmp_action) {

			err = -ENOMEM;

			goto free_actions;
@@ -384,8 +384,8 @@ static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 
		actions[num_actions++] = tmp_action;

	}



	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH_2) {

		tmp_action = create_action_push_vlan(domain, &fte->action.vlan[1]);

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH_2) {

		tmp_action = create_action_push_vlan(domain, &fte->act_dests.action.vlan[1]);

		if (!tmp_action) {

			err = -ENOMEM;

			goto free_actions;
@@ -396,11 +396,11 @@ static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 


	if (delay_encap_set)

		actions[num_actions++] =

			fte->action.pkt_reformat->action.dr_action;

			fte->act_dests.action.pkt_reformat->action.dr_action;



	/* The order of the actions below is not important */



	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_DROP) {

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_DROP) {

		tmp_action = mlx5dr_action_create_drop();

		if (!tmp_action) {

			err = -ENOMEM;
@@ -410,9 +410,9 @@ static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 
		term_actions[num_term_actions++].dest = tmp_action;

	}



	if (fte->flow_context.flow_tag) {

	if (fte->act_dests.flow_context.flow_tag) {

		tmp_action =

			mlx5dr_action_create_tag(fte->flow_context.flow_tag);

			mlx5dr_action_create_tag(fte->act_dests.flow_context.flow_tag);

		if (!tmp_action) {

			err = -ENOMEM;

			goto free_actions;
@@ -421,7 +421,7 @@ static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 
		actions[num_actions++] = tmp_action;

	}



	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST) {

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST) {

		list_for_each_entry(dst, &fte->node.children, node.list) {

			enum mlx5_flow_destination_type type = dst->dest_attr.type;

			u32 id;
@@ -502,7 +502,7 @@ static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 
		}

	}



	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_COUNT) {

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_COUNT) {

		list_for_each_entry(dst, &fte->node.children, node.list) {

			u32 id;
@@ -529,19 +529,21 @@ static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 
		}

	}



	if (fte->action.action & MLX5_FLOW_CONTEXT_ACTION_EXECUTE_ASO) {

		if (fte->action.exe_aso.type != MLX5_EXE_ASO_FLOW_METER) {

	if (fte->act_dests.action.action & MLX5_FLOW_CONTEXT_ACTION_EXECUTE_ASO) {

		struct mlx5_flow_act *action = &fte->act_dests.action;



		if (fte->act_dests.action.exe_aso.type != MLX5_EXE_ASO_FLOW_METER) {

			err = -EOPNOTSUPP;

			goto free_actions;

		}



		tmp_action =

			mlx5dr_action_create_aso(domain,

						 fte->action.exe_aso.object_id,

						 fte->action.exe_aso.return_reg_id,

						 fte->action.exe_aso.type,

						 fte->action.exe_aso.flow_meter.init_color,

						 fte->action.exe_aso.flow_meter.meter_idx);

						 action->exe_aso.object_id,

						 action->exe_aso.return_reg_id,

						 action->exe_aso.type,

						 action->exe_aso.flow_meter.init_color,

						 action->exe_aso.flow_meter.meter_idx);

		if (!tmp_action) {

			err = -ENOMEM;

			goto free_actions;
@@ -568,8 +570,8 @@ static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 
		actions[num_actions++] = term_actions->dest;

	} else if (num_term_actions > 1) {

		bool ignore_flow_level =

			!!(fte->action.flags & FLOW_ACT_IGNORE_FLOW_LEVEL);

		u32 flow_source = fte->flow_context.flow_source;

			!!(fte->act_dests.action.flags & FLOW_ACT_IGNORE_FLOW_LEVEL);

		u32 flow_source = fte->act_dests.flow_context.flow_source;



		if (num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX ||

		    fs_dr_num_actions == MLX5_FLOW_CONTEXT_ACTION_MAX) {
@@ -593,7 +595,7 @@ static int mlx5_cmd_dr_create_fte(struct mlx5_flow_root_namespace *ns, 
				  &params,

				  num_actions,

				  actions,

				  fte->flow_context.flow_source);

				  fte->act_dests.flow_context.flow_source);

	if (!rule) {

		err = -EINVAL;

		goto free_actions;