[PATCH 0/7] refactor flow validate and create interface

[PATCH 0/7] refactor flow validate and create interface

[Chaoyong He]

This patch series refactor the flow validate and create interface,
make the logic more readable and esaier to extend.

Chaoyong He (7):
  net/nfp: remove the unused parameter
  net/nfp: exit as soon as possible
  net/nfp: remove the duplicate logic of output action
  net/nfp: split out the flow item check logic
  net/nfp: simplify the flow item calculate logic
  net/nfp: split out the flow action check logic
  net/nfp: simplify the flow action calculate logic

 drivers/net/nfp/flower/nfp_flower_flow.c | 784 +++++++++++++----------
 1 file changed, 431 insertions(+), 353 deletions(-)

-- 
2.39.1

[PATCH 1/7] net/nfp: remove the unused parameter

[Chaoyong He]

Remove the unused 'error' parameter of 'nfp_flow_setup()' interface.

Signed-off-by: Chaoyong He <chaoyong.he@corigine.com>
Reviewed-by: Long Wu <long.wu@corigine.com>
Reviewed-by: Peng Zhang <peng.zhang@corigine.com>
---
 drivers/net/nfp/flower/nfp_flower_flow.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/drivers/net/nfp/flower/nfp_flower_flow.c b/drivers/net/nfp/flower/nfp_flower_flow.c
index f05e35580c..e5ee6f1fb9 100644
--- a/drivers/net/nfp/flower/nfp_flower_flow.c
+++ b/drivers/net/nfp/flower/nfp_flower_flow.c
@@ -4567,7 +4567,6 @@ nfp_flow_setup(struct nfp_flower_representor *representor,
 		const struct rte_flow_attr *attr,
 		const struct rte_flow_item items[],
 		const struct rte_flow_action actions[],
-		__rte_unused struct rte_flow_error *error,
 		bool validate_flag)
 {
 	uint64_t cookie;
@@ -4644,7 +4643,7 @@ nfp_flow_validate(struct rte_eth_dev *dev,
 	representor = dev->data->dev_private;
 	priv = representor->app_fw_flower->flow_priv;
 
-	nfp_flow = nfp_flow_setup(representor, attr, items, actions, error, true);
+	nfp_flow = nfp_flow_setup(representor, attr, items, actions, true);
 	if (nfp_flow == NULL) {
 		return rte_flow_error_set(error, ENOTSUP,
 				RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
@@ -4680,7 +4679,7 @@ nfp_flow_create(struct rte_eth_dev *dev,
 	app_fw_flower = representor->app_fw_flower;
 	priv = app_fw_flower->flow_priv;
 
-	nfp_flow = nfp_flow_setup(representor, attr, items, actions, error, false);
+	nfp_flow = nfp_flow_setup(representor, attr, items, actions, false);
 	if (nfp_flow == NULL) {
 		rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
 				NULL, "This flow can not be offloaded.");
-- 
2.39.1

[PATCH 2/7] net/nfp: exit as soon as possible

[Chaoyong He]

Add log message and exit as soon as possible.

Signed-off-by: Chaoyong He <chaoyong.he@corigine.com>
Reviewed-by: Long Wu <long.wu@corigine.com>
Reviewed-by: Peng Zhang <peng.zhang@corigine.com>
---
 drivers/net/nfp/flower/nfp_flower_flow.c | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/drivers/net/nfp/flower/nfp_flower_flow.c b/drivers/net/nfp/flower/nfp_flower_flow.c
index e5ee6f1fb9..f1388620d6 100644
--- a/drivers/net/nfp/flower/nfp_flower_flow.c
+++ b/drivers/net/nfp/flower/nfp_flower_flow.c
@@ -1479,7 +1479,7 @@ nfp_flow_key_layers_calculate(const struct rte_flow_item items[],
 		const struct rte_flow_action actions[],
 		struct nfp_fl_key_ls *key_ls)
 {
-	int ret = 0;
+	int ret;
 
 	key_ls->key_layer_two = 0;
 	key_ls->key_layer = NFP_FLOWER_LAYER_PORT;
@@ -1490,10 +1490,19 @@ nfp_flow_key_layers_calculate(const struct rte_flow_item items[],
 	key_ls->vlan = 0;
 	key_ls->tun_type = NFP_FL_TUN_NONE;
 
-	ret |= nfp_flow_key_layers_calculate_items(items, key_ls);
-	ret |= nfp_flow_key_layers_calculate_actions(actions, key_ls);
+	ret = nfp_flow_key_layers_calculate_items(items, key_ls);
+	if (ret != 0) {
+		PMD_DRV_LOG(ERR, "flow items calculate failed");
+		return ret;
+	}
 
-	return ret;
+	ret = nfp_flow_key_layers_calculate_actions(actions, key_ls);
+	if (ret != 0) {
+		PMD_DRV_LOG(ERR, "flow actions check failed");
+		return ret;
+	}
+
+	return 0;
 }
 
 static bool
-- 
2.39.1

[PATCH 3/7] net/nfp: remove the duplicate logic of output action

[Chaoyong He]

Remove the duplicate logic of output flow action.

Signed-off-by: Chaoyong He <chaoyong.he@corigine.com>
Reviewed-by: Long Wu <long.wu@corigine.com>
Reviewed-by: Peng Zhang <peng.zhang@corigine.com>
---
 drivers/net/nfp/flower/nfp_flower_flow.c | 81 ++++++------------------
 1 file changed, 19 insertions(+), 62 deletions(-)

diff --git a/drivers/net/nfp/flower/nfp_flower_flow.c b/drivers/net/nfp/flower/nfp_flower_flow.c
index f1388620d6..b533f4e3f2 100644
--- a/drivers/net/nfp/flower/nfp_flower_flow.c
+++ b/drivers/net/nfp/flower/nfp_flower_flow.c
@@ -2508,55 +2508,33 @@ nfp_flow_action_output(char *act_data,
 		struct nfp_fl_rule_metadata *nfp_flow_meta,
 		uint32_t output_cnt)
 {
-	size_t act_size;
+	uint32_t port_id;
 	struct rte_eth_dev *ethdev;
 	struct nfp_fl_act_output *output;
 	struct nfp_flower_representor *representor;
-	const struct rte_flow_action_port_id *port_id;
-
-	port_id = action->conf;
-	if (port_id == NULL || port_id->id >= RTE_MAX_ETHPORTS)
-		return -ERANGE;
-
-	ethdev = &rte_eth_devices[port_id->id];
-	representor = ethdev->data->dev_private;
-	act_size = sizeof(struct nfp_fl_act_output);
-
-	output = (struct nfp_fl_act_output *)act_data;
-	output->head.jump_id = NFP_FL_ACTION_OPCODE_OUTPUT;
-	output->head.len_lw  = act_size >> NFP_FL_LW_SIZ;
-	output->port         = rte_cpu_to_be_32(representor->port_id);
-	if (output_cnt == 0)
-		output->flags = rte_cpu_to_be_16(NFP_FL_OUT_FLAGS_LAST);
-
-	nfp_flow_meta->shortcut = rte_cpu_to_be_32(representor->port_id);
+	const struct rte_flow_action_ethdev *action_ethdev;
+	const struct rte_flow_action_port_id *action_port_id;
 
-	return 0;
-}
+	if (action->conf == NULL)
+		return -EINVAL;
 
-static int
-nfp_flow_action_output_stage(char *act_data,
-		const struct rte_flow_action *action,
-		struct nfp_fl_rule_metadata *nfp_flow_meta,
-		uint32_t output_cnt)
-{
-	size_t act_size;
-	struct rte_eth_dev *ethdev;
-	struct nfp_fl_act_output *output;
-	struct nfp_flower_representor *representor;
-	const struct rte_flow_action_ethdev *action_ethdev;
+	if (action->type == RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT) {
+		action_ethdev = action->conf;
+		port_id = action_ethdev->port_id;
+	} else {
+		action_port_id = action->conf;
+		port_id = action_port_id->id;
+	}
 
-	action_ethdev = action->conf;
-	if (action_ethdev == NULL || action_ethdev->port_id >= RTE_MAX_ETHPORTS)
+	if (port_id >= RTE_MAX_ETHPORTS)
 		return -ERANGE;
 
-	ethdev = &rte_eth_devices[action_ethdev->port_id];
+	ethdev = &rte_eth_devices[port_id];
 	representor = ethdev->data->dev_private;
-	act_size = sizeof(struct nfp_fl_act_output);
 
 	output = (struct nfp_fl_act_output *)act_data;
 	output->head.jump_id = NFP_FL_ACTION_OPCODE_OUTPUT;
-	output->head.len_lw  = act_size >> NFP_FL_LW_SIZ;
+	output->head.len_lw  = sizeof(struct nfp_fl_act_output) >> NFP_FL_LW_SIZ;
 	output->port         = rte_cpu_to_be_32(representor->port_id);
 	if (output_cnt == 0)
 		output->flags = rte_cpu_to_be_16(NFP_FL_OUT_FLAGS_LAST);
@@ -3999,28 +3977,7 @@ nfp_flow_action_compile_drop(struct nfp_action_compile_param *param)
 }
 
 static int
-nfp_flow_action_compile_repr_port(struct nfp_action_compile_param *param)
-{
-	int ret;
-	uint32_t output_cnt;
-
-	output_cnt = *param->output_cnt - 1;
-	*param->output_cnt = output_cnt;
-
-	ret = nfp_flow_action_output_stage(param->position, param->action,
-			param->nfp_flow_meta, output_cnt);
-	if (ret != 0) {
-		PMD_DRV_LOG(ERR, "Failed process RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT");
-		return ret;
-	}
-
-	param->position += sizeof(struct nfp_fl_act_output);
-
-	return 0;
-}
-
-static int
-nfp_flow_action_compile_port_id(struct nfp_action_compile_param *param)
+nfp_flow_action_compile_output(struct nfp_action_compile_param *param)
 {
 	int ret;
 	uint32_t output_cnt;
@@ -4031,7 +3988,7 @@ nfp_flow_action_compile_port_id(struct nfp_action_compile_param *param)
 	ret = nfp_flow_action_output(param->position, param->action,
 			param->nfp_flow_meta, output_cnt);
 	if (ret != 0) {
-		PMD_DRV_LOG(ERR, "Failed process RTE_FLOW_ACTION_TYPE_PORT_ID");
+		PMD_DRV_LOG(ERR, "Failed process output action");
 		return ret;
 	}
 
@@ -4393,8 +4350,8 @@ static nfp_flow_action_compile_fn action_compile_fns[] = {
 	[RTE_FLOW_ACTION_TYPE_DROP]             = nfp_flow_action_compile_drop,
 	[RTE_FLOW_ACTION_TYPE_COUNT]            = nfp_flow_action_compile_stub,
 	[RTE_FLOW_ACTION_TYPE_JUMP]             = nfp_flow_action_compile_stub,
-	[RTE_FLOW_ACTION_TYPE_PORT_ID]          = nfp_flow_action_compile_port_id,
-	[RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT] = nfp_flow_action_compile_repr_port,
+	[RTE_FLOW_ACTION_TYPE_PORT_ID]          = nfp_flow_action_compile_output,
+	[RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT] = nfp_flow_action_compile_output,
 	[RTE_FLOW_ACTION_TYPE_SET_MAC_SRC]      = nfp_flow_action_compile_mac_src,
 	[RTE_FLOW_ACTION_TYPE_SET_MAC_DST]      = nfp_flow_action_compile_mac_dst,
 	[RTE_FLOW_ACTION_TYPE_OF_POP_VLAN]      = nfp_flow_action_compile_pop_vlan,
-- 
2.39.1

[PATCH 4/7] net/nfp: split out the flow item check logic

[Chaoyong He]

Split out the flow item check logic.

Signed-off-by: Chaoyong He <chaoyong.he@corigine.com>
Reviewed-by: Long Wu <long.wu@corigine.com>
Reviewed-by: Peng Zhang <peng.zhang@corigine.com>
---
 drivers/net/nfp/flower/nfp_flower_flow.c | 109 +++++++++++++++++++++++
 1 file changed, 109 insertions(+)

diff --git a/drivers/net/nfp/flower/nfp_flower_flow.c b/drivers/net/nfp/flower/nfp_flower_flow.c
index b533f4e3f2..f73be3c9a2 100644
--- a/drivers/net/nfp/flower/nfp_flower_flow.c
+++ b/drivers/net/nfp/flower/nfp_flower_flow.c
@@ -820,8 +820,111 @@ struct nfp_item_calculate_param {
 	struct nfp_item_flag *flag;
 };
 
+typedef int (*nfp_flow_key_check_item_fn)(struct nfp_item_calculate_param *param);
 typedef int (*nfp_flow_key_calculate_item_fn)(struct nfp_item_calculate_param *param);
 
+static int
+nfp_flow_item_check_port(struct nfp_item_calculate_param *param)
+{
+	const struct rte_flow_item_port_id *port_id;
+
+	port_id = param->item->spec;
+	if (port_id == NULL || port_id->id >= RTE_MAX_ETHPORTS)
+		return -ERANGE;
+
+	return 0;
+}
+
+static int
+nfp_flow_item_check_ipv4(struct nfp_item_calculate_param *param)
+{
+	if (!param->flag->outer_ip4_flag)
+		param->flag->outer_ip4_flag = true;
+
+	return 0;
+}
+
+static int
+nfp_flow_item_check_ipv6(struct nfp_item_calculate_param *param)
+{
+	if (!param->flag->outer_ip6_flag)
+		param->flag->outer_ip6_flag = true;
+
+	return 0;
+}
+
+static int
+nfp_flow_item_check_vxlan(struct nfp_item_calculate_param *param)
+{
+	if (!param->flag->outer_ip4_flag && !param->flag->outer_ip6_flag) {
+		PMD_DRV_LOG(ERR, "No outer IP layer for VXLAN tunnel.");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int
+nfp_flow_item_check_geneve(struct nfp_item_calculate_param *param)
+{
+	if (!param->flag->outer_ip4_flag && !param->flag->outer_ip6_flag) {
+		PMD_DRV_LOG(ERR, "No outer IP layer for GENEVE tunnel.");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int
+nfp_flow_item_check_gre(struct nfp_item_calculate_param *param)
+{
+	if (!param->flag->outer_ip4_flag && !param->flag->outer_ip6_flag) {
+		PMD_DRV_LOG(ERR, "No outer IP layer for GRE tunnel.");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static nfp_flow_key_check_item_fn check_item_fns[] = {
+	[RTE_FLOW_ITEM_TYPE_PORT_ID]         = nfp_flow_item_check_port,
+	[RTE_FLOW_ITEM_TYPE_IPV4]            = nfp_flow_item_check_ipv4,
+	[RTE_FLOW_ITEM_TYPE_IPV6]            = nfp_flow_item_check_ipv6,
+	[RTE_FLOW_ITEM_TYPE_VXLAN]           = nfp_flow_item_check_vxlan,
+	[RTE_FLOW_ITEM_TYPE_GENEVE]          = nfp_flow_item_check_geneve,
+	[RTE_FLOW_ITEM_TYPE_GRE]             = nfp_flow_item_check_gre,
+};
+
+static int
+nfp_flow_key_layers_check_items(const struct rte_flow_item items[])
+{
+	int ret;
+	struct nfp_item_flag flag = {};
+	const struct rte_flow_item *item;
+	struct nfp_item_calculate_param param = {
+		.flag = &flag,
+	};
+
+	for (item = items; item->type != RTE_FLOW_ITEM_TYPE_END; ++item) {
+		if (item->type >= RTE_DIM(check_item_fns)) {
+			PMD_DRV_LOG(ERR, "Flow item %d unsupported", item->type);
+			return -ERANGE;
+		}
+
+		if (check_item_fns[item->type] == NULL)
+			continue;
+
+		param.item = item;
+		ret = check_item_fns[item->type](&param);
+		if (ret != 0) {
+			PMD_DRV_LOG(ERR, "Flow item %d check fail", item->type);
+			return ret;
+		}
+	}
+
+	return 0;
+}
+
 static int
 nfp_flow_item_calculate_stub(struct nfp_item_calculate_param *param __rte_unused)
 {
@@ -1490,6 +1593,12 @@ nfp_flow_key_layers_calculate(const struct rte_flow_item items[],
 	key_ls->vlan = 0;
 	key_ls->tun_type = NFP_FL_TUN_NONE;
 
+	ret = nfp_flow_key_layers_check_items(items);
+	if (ret != 0) {
+		PMD_DRV_LOG(ERR, "flow items check failed");
+		return ret;
+	}
+
 	ret = nfp_flow_key_layers_calculate_items(items, key_ls);
 	if (ret != 0) {
 		PMD_DRV_LOG(ERR, "flow items calculate failed");
-- 
2.39.1

[PATCH 5/7] net/nfp: simplify the flow item calculate logic

[Chaoyong He]

Simplify the flow item calculate logic.

Signed-off-by: Chaoyong He <chaoyong.he@corigine.com>
Reviewed-by: Long Wu <long.wu@corigine.com>
Reviewed-by: Peng Zhang <peng.zhang@corigine.com>
---
 drivers/net/nfp/flower/nfp_flower_flow.c | 66 ++++++------------------
 1 file changed, 15 insertions(+), 51 deletions(-)

diff --git a/drivers/net/nfp/flower/nfp_flower_flow.c b/drivers/net/nfp/flower/nfp_flower_flow.c
index f73be3c9a2..c8270d81f1 100644
--- a/drivers/net/nfp/flower/nfp_flower_flow.c
+++ b/drivers/net/nfp/flower/nfp_flower_flow.c
@@ -821,7 +821,7 @@ struct nfp_item_calculate_param {
 };
 
 typedef int (*nfp_flow_key_check_item_fn)(struct nfp_item_calculate_param *param);
-typedef int (*nfp_flow_key_calculate_item_fn)(struct nfp_item_calculate_param *param);
+typedef void (*nfp_flow_key_calculate_item_fn)(struct nfp_item_calculate_param *param);
 
 static int
 nfp_flow_item_check_port(struct nfp_item_calculate_param *param)
@@ -925,24 +925,21 @@ nfp_flow_key_layers_check_items(const struct rte_flow_item items[])
 	return 0;
 }
 
-static int
+static void
 nfp_flow_item_calculate_stub(struct nfp_item_calculate_param *param __rte_unused)
 {
-	return 0;
 }
 
-static int
+static void
 nfp_flow_item_calculate_eth(struct nfp_item_calculate_param *param)
 {
 	if (param->item->spec != NULL) {
 		param->key_ls->key_layer |= NFP_FLOWER_LAYER_MAC;
 		param->key_ls->key_size += sizeof(struct nfp_flower_mac_mpls);
 	}
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_item_calculate_port(struct nfp_item_calculate_param *param)
 {
 	struct rte_eth_dev *ethdev;
@@ -950,56 +947,43 @@ nfp_flow_item_calculate_port(struct nfp_item_calculate_param *param)
 	const struct rte_flow_item_port_id *port_id;
 
 	port_id = param->item->spec;
-	if (port_id == NULL || port_id->id >= RTE_MAX_ETHPORTS)
-		return -ERANGE;
-
 	ethdev = &rte_eth_devices[port_id->id];
 	repr = ethdev->data->dev_private;
 	param->key_ls->port = repr->port_id;
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_item_calculate_vlan(struct nfp_item_calculate_param *param)
 {
 	param->key_ls->vlan = NFP_FLOWER_MASK_VLAN_CFI;
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_item_calculate_ipv4(struct nfp_item_calculate_param *param)
 {
 	param->key_ls->key_layer |= NFP_FLOWER_LAYER_IPV4;
 	param->key_ls->key_size += sizeof(struct nfp_flower_ipv4);
 	if (!param->flag->outer_ip4_flag)
 		param->flag->outer_ip4_flag = true;
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_item_calculate_ipv6(struct nfp_item_calculate_param *param)
 {
 	param->key_ls->key_layer |= NFP_FLOWER_LAYER_IPV6;
 	param->key_ls->key_size += sizeof(struct nfp_flower_ipv6);
 	if (!param->flag->outer_ip6_flag)
 		param->flag->outer_ip6_flag = true;
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_item_calculate_l4(struct nfp_item_calculate_param *param)
 {
 	param->key_ls->key_layer |= NFP_FLOWER_LAYER_TP;
 	param->key_ls->key_size += sizeof(struct nfp_flower_tp_ports);
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_item_calculate_vxlan(struct nfp_item_calculate_param *param)
 {
 	struct nfp_fl_key_ls *key_ls = param->key_ls;
@@ -1016,7 +1000,7 @@ nfp_flow_item_calculate_vxlan(struct nfp_item_calculate_param *param)
 		 * in `struct nfp_flower_ipv4_udp_tun`.
 		 */
 		key_ls->key_size -= sizeof(struct nfp_flower_ipv4);
-	} else if (param->flag->outer_ip6_flag) {
+	} else {
 		key_ls->key_layer |= NFP_FLOWER_LAYER_EXT_META;
 		key_ls->key_layer_two |= NFP_FLOWER_LAYER2_TUN_IPV6;
 		key_ls->key_size += sizeof(struct nfp_flower_ext_meta);
@@ -1026,15 +1010,10 @@ nfp_flow_item_calculate_vxlan(struct nfp_item_calculate_param *param)
 		 * in `struct nfp_flower_ipv6_udp_tun`.
 		 */
 		key_ls->key_size -= sizeof(struct nfp_flower_ipv6);
-	} else {
-		PMD_DRV_LOG(ERR, "No outer IP layer for VXLAN tunnel.");
-		return -EINVAL;
 	}
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_item_calculate_geneve(struct nfp_item_calculate_param *param)
 {
 	struct nfp_fl_key_ls *key_ls = param->key_ls;
@@ -1053,7 +1032,7 @@ nfp_flow_item_calculate_geneve(struct nfp_item_calculate_param *param)
 		 * in `struct nfp_flower_ipv4_udp_tun`.
 		 */
 		key_ls->key_size -= sizeof(struct nfp_flower_ipv4);
-	} else if (param->flag->outer_ip6_flag) {
+	} else {
 		key_ls->key_layer_two |= NFP_FLOWER_LAYER2_TUN_IPV6;
 		key_ls->key_size += sizeof(struct nfp_flower_ipv6_udp_tun);
 		/*
@@ -1061,15 +1040,10 @@ nfp_flow_item_calculate_geneve(struct nfp_item_calculate_param *param)
 		 * in `struct nfp_flower_ipv6_udp_tun`.
 		 */
 		key_ls->key_size -= sizeof(struct nfp_flower_ipv6);
-	} else {
-		PMD_DRV_LOG(ERR, "No outer IP layer for GENEVE tunnel.");
-		return -EINVAL;
 	}
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_item_calculate_gre(struct nfp_item_calculate_param *param)
 {
 	struct nfp_fl_key_ls *key_ls = param->key_ls;
@@ -1088,7 +1062,7 @@ nfp_flow_item_calculate_gre(struct nfp_item_calculate_param *param)
 		 * in `struct nfp_flower_ipv4_gre_tun`.
 		 */
 		key_ls->key_size -= sizeof(struct nfp_flower_ipv4);
-	} else if (param->flag->outer_ip6_flag) {
+	} else {
 		key_ls->key_layer_two |= NFP_FLOWER_LAYER2_TUN_IPV6;
 		key_ls->key_size += sizeof(struct nfp_flower_ipv6_gre_tun);
 		/*
@@ -1096,12 +1070,7 @@ nfp_flow_item_calculate_gre(struct nfp_item_calculate_param *param)
 		 * in `struct nfp_flower_ipv6_gre_tun`.
 		 */
 		key_ls->key_size -= sizeof(struct nfp_flower_ipv6);
-	} else {
-		PMD_DRV_LOG(ERR, "No outer IP layer for GRE tunnel.");
-		return -EINVAL;
 	}
-
-	return 0;
 }
 
 static nfp_flow_key_calculate_item_fn item_fns[] = {
@@ -1123,7 +1092,6 @@ static int
 nfp_flow_key_layers_calculate_items(const struct rte_flow_item items[],
 		struct nfp_fl_key_ls *key_ls)
 {
-	int ret;
 	struct nfp_item_flag flag = {};
 	const struct rte_flow_item *item;
 	struct nfp_item_calculate_param param = {
@@ -1138,11 +1106,7 @@ nfp_flow_key_layers_calculate_items(const struct rte_flow_item items[],
 		}
 
 		param.item = item;
-		ret = item_fns[item->type](&param);
-		if (ret != 0) {
-			PMD_DRV_LOG(ERR, "Flow item %d calculate fail", item->type);
-			return ret;
-		}
+		item_fns[item->type](&param);
 	}
 
 	return 0;
-- 
2.39.1

[PATCH 6/7] net/nfp: split out the flow action check logic

[Chaoyong He]

Split out the flow action check logic.

Signed-off-by: Chaoyong He <chaoyong.he@corigine.com>
Reviewed-by: Long Wu <long.wu@corigine.com>
Reviewed-by: Peng Zhang <peng.zhang@corigine.com>
---
 drivers/net/nfp/flower/nfp_flower_flow.c | 368 +++++++++++++++--------
 1 file changed, 244 insertions(+), 124 deletions(-)

diff --git a/drivers/net/nfp/flower/nfp_flower_flow.c b/drivers/net/nfp/flower/nfp_flower_flow.c
index c8270d81f1..87a3d5b394 100644
--- a/drivers/net/nfp/flower/nfp_flower_flow.c
+++ b/drivers/net/nfp/flower/nfp_flower_flow.c
@@ -1128,8 +1128,246 @@ struct nfp_action_calculate_param {
 	struct nfp_action_flag *flag;
 };
 
+typedef int (*nfp_flow_key_check_action_fn)(struct nfp_action_calculate_param *param);
 typedef int (*nfp_flow_key_calculate_action_fn)(struct nfp_action_calculate_param *param);
 
+static int
+nfp_flow_action_check_port(struct nfp_action_calculate_param *param)
+{
+	uint32_t port_id;
+	const struct rte_flow_action *action;
+	const struct rte_flow_action_ethdev *action_ethdev;
+	const struct rte_flow_action_port_id *action_port_id;
+
+	action = param->action;
+	if (action->conf == NULL)
+		return -EINVAL;
+
+	if (action->type == RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT) {
+		action_ethdev = action->conf;
+		port_id = action_ethdev->port_id;
+	} else {
+		action_port_id = action->conf;
+		port_id = action_port_id->id;
+	}
+
+	if (port_id >= RTE_MAX_ETHPORTS)
+		return -ERANGE;
+
+	return 0;
+}
+
+static int
+nfp_flow_action_check_meter(struct nfp_action_calculate_param *param)
+{
+	if (param->flag->meter_flag) {
+		PMD_DRV_LOG(ERR, "Only support one meter action.");
+		return -ENOTSUP;
+	}
+
+	param->flag->meter_flag = true;
+
+	return 0;
+}
+
+static bool
+nfp_flow_field_id_dst_support(enum rte_flow_field_id field)
+{
+	switch (field) {
+	case RTE_FLOW_FIELD_IPV4_SRC:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_IPV4_DST:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_IPV6_SRC:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_IPV6_DST:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_TCP_PORT_SRC:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_TCP_PORT_DST:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_UDP_PORT_SRC:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_UDP_PORT_DST:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_IPV4_TTL:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_IPV6_HOPLIMIT:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_MAC_SRC:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_MAC_DST:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_IPV4_DSCP:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_IPV6_DSCP:
+		return true;
+	default:
+		break;
+	}
+
+	return false;
+}
+
+static bool
+nfp_flow_field_id_src_support(enum rte_flow_field_id field)
+{
+	return field == RTE_FLOW_FIELD_POINTER ||
+			field == RTE_FLOW_FIELD_VALUE;
+}
+
+static uint32_t
+nfp_flow_field_width(enum rte_flow_field_id field,
+		uint32_t inherit)
+{
+	switch (field) {
+	case RTE_FLOW_FIELD_IPV4_SRC:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_IPV4_DST:
+		return 32;
+	case RTE_FLOW_FIELD_IPV6_SRC:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_IPV6_DST:
+		return 128;
+	case RTE_FLOW_FIELD_TCP_PORT_SRC:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_TCP_PORT_DST:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_UDP_PORT_SRC:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_UDP_PORT_DST:
+		return 16;
+	case RTE_FLOW_FIELD_IPV4_TTL:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_IPV6_HOPLIMIT:
+		return 8;
+	case RTE_FLOW_FIELD_MAC_SRC:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_MAC_DST:
+		return 48;
+	case RTE_FLOW_FIELD_IPV4_DSCP:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_IPV6_DSCP:
+		return 6;
+	case RTE_FLOW_FIELD_POINTER:
+		/* FALLTHROUGH */
+	case RTE_FLOW_FIELD_VALUE:
+		return inherit;
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+static bool
+nfp_flow_is_validate_field_data(const struct rte_flow_field_data *data,
+		uint32_t conf_width,
+		uint32_t data_width)
+{
+	if (data->level != 0) {
+		PMD_DRV_LOG(ERR, "The 'level' is not support");
+		return false;
+	}
+
+	if (data->tag_index != 0) {
+		PMD_DRV_LOG(ERR, "The 'tag_index' is not support");
+		return false;
+	}
+
+	if (data->class_id != 0) {
+		PMD_DRV_LOG(ERR, "The 'class_id' is not support");
+		return false;
+	}
+
+	if (data->offset + conf_width > data_width) {
+		PMD_DRV_LOG(ERR, "The 'offset' value is too big");
+		return false;
+	}
+
+	return true;
+}
+
+static int
+nfp_flow_action_check_modify(struct nfp_action_calculate_param *param)
+{
+	uint32_t width;
+	uint32_t dst_width;
+	uint32_t src_width;
+	const struct rte_flow_field_data *dst_data;
+	const struct rte_flow_field_data *src_data;
+	const struct rte_flow_action_modify_field *conf;
+
+	conf = param->action->conf;
+	if (conf == NULL)
+		return -EINVAL;
+
+	dst_data = &conf->dst;
+	src_data = &conf->src;
+	if (!nfp_flow_field_id_dst_support(dst_data->field) ||
+			!nfp_flow_field_id_src_support(src_data->field)) {
+		PMD_DRV_LOG(ERR, "Not supported field id");
+		return -EINVAL;
+	}
+
+	width = conf->width;
+	if (width == 0) {
+		PMD_DRV_LOG(ERR, "No bits are required to modify");
+		return -EINVAL;
+	}
+
+	dst_width = nfp_flow_field_width(dst_data->field, 0);
+	src_width = nfp_flow_field_width(src_data->field, dst_width);
+	if (width > dst_width || width > src_width) {
+		PMD_DRV_LOG(ERR, "Cannot modify more bits than the width of a field");
+		return -EINVAL;
+	}
+
+	if (!nfp_flow_is_validate_field_data(dst_data, width, dst_width)) {
+		PMD_DRV_LOG(ERR, "The dest field data has problem");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static nfp_flow_key_check_action_fn check_action_fns[] = {
+	[RTE_FLOW_ACTION_TYPE_PORT_ID]          = nfp_flow_action_check_port,
+	[RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT] = nfp_flow_action_check_port,
+	[RTE_FLOW_ACTION_TYPE_METER]            = nfp_flow_action_check_meter,
+	[RTE_FLOW_ACTION_TYPE_MODIFY_FIELD]     = nfp_flow_action_check_modify,
+};
+
+static int
+nfp_flow_key_layers_check_actions(const struct rte_flow_action actions[])
+{
+	int ret;
+	struct nfp_action_flag flag = {};
+	const struct rte_flow_action *action;
+	struct nfp_action_calculate_param param = {
+		.flag = &flag,
+	};
+
+	for (action = actions; action->type != RTE_FLOW_ACTION_TYPE_END; ++action) {
+		if (action->type >= RTE_DIM(check_action_fns)) {
+			PMD_DRV_LOG(ERR, "Flow action %d unsupported", action->type);
+			return -ERANGE;
+		}
+
+		if (check_action_fns[action->type] == NULL)
+			continue;
+
+		param.action = action;
+		ret = check_action_fns[action->type](&param);
+		if (ret != 0) {
+			PMD_DRV_LOG(ERR, "Flow action %d calculate fail", action->type);
+			return ret;
+		}
+	}
+
+	return 0;
+}
+
 static int
 nfp_flow_action_calculate_stub(struct nfp_action_calculate_param *param __rte_unused)
 {
@@ -1272,124 +1510,6 @@ nfp_flow_action_calculate_mark(struct nfp_action_calculate_param *param)
 	return 0;
 }
 
-static bool
-nfp_flow_field_id_dst_support(enum rte_flow_field_id field)
-{
-	switch (field) {
-	case RTE_FLOW_FIELD_IPV4_SRC:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_IPV4_DST:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_IPV6_SRC:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_IPV6_DST:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_TCP_PORT_SRC:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_TCP_PORT_DST:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_UDP_PORT_SRC:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_UDP_PORT_DST:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_IPV4_TTL:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_IPV6_HOPLIMIT:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_MAC_SRC:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_MAC_DST:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_IPV4_DSCP:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_IPV6_DSCP:
-		return true;
-	default:
-		break;
-	}
-
-	return false;
-}
-
-static bool
-nfp_flow_field_id_src_support(enum rte_flow_field_id field)
-{
-	return field == RTE_FLOW_FIELD_POINTER ||
-			field == RTE_FLOW_FIELD_VALUE;
-}
-
-static uint32_t
-nfp_flow_field_width(enum rte_flow_field_id field,
-		uint32_t inherit)
-{
-	switch (field) {
-	case RTE_FLOW_FIELD_IPV4_SRC:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_IPV4_DST:
-		return 32;
-	case RTE_FLOW_FIELD_IPV6_SRC:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_IPV6_DST:
-		return 128;
-	case RTE_FLOW_FIELD_TCP_PORT_SRC:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_TCP_PORT_DST:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_UDP_PORT_SRC:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_UDP_PORT_DST:
-		return 16;
-	case RTE_FLOW_FIELD_IPV4_TTL:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_IPV6_HOPLIMIT:
-		return 8;
-	case RTE_FLOW_FIELD_MAC_SRC:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_MAC_DST:
-		return 48;
-	case RTE_FLOW_FIELD_IPV4_DSCP:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_IPV6_DSCP:
-		return 6;
-	case RTE_FLOW_FIELD_POINTER:
-		/* FALLTHROUGH */
-	case RTE_FLOW_FIELD_VALUE:
-		return inherit;
-	default:
-		break;
-	}
-
-	return 0;
-}
-
-static bool
-nfp_flow_is_validate_field_data(const struct rte_flow_field_data *data,
-		uint32_t conf_width,
-		uint32_t data_width)
-{
-	if (data->level != 0) {
-		PMD_DRV_LOG(ERR, "The 'level' is not support");
-		return false;
-	}
-
-	if (data->tag_index != 0) {
-		PMD_DRV_LOG(ERR, "The 'tag_index' is not support");
-		return false;
-	}
-
-	if (data->class_id != 0) {
-		PMD_DRV_LOG(ERR, "The 'class_id' is not support");
-		return false;
-	}
-
-	if (data->offset + conf_width > data_width) {
-		PMD_DRV_LOG(ERR, "The 'offset' value is too big");
-		return false;
-	}
-
-	return true;
-}
-
 static int
 nfp_flow_action_calculate_modify_dispatch(struct nfp_action_calculate_param *param,
 		enum rte_flow_field_id field)
@@ -1569,6 +1689,12 @@ nfp_flow_key_layers_calculate(const struct rte_flow_item items[],
 		return ret;
 	}
 
+	ret = nfp_flow_key_layers_check_actions(actions);
+	if (ret != 0) {
+		PMD_DRV_LOG(ERR, "flow actions check failed");
+		return ret;
+	}
+
 	ret = nfp_flow_key_layers_calculate_actions(actions, key_ls);
 	if (ret != 0) {
 		PMD_DRV_LOG(ERR, "flow actions check failed");
@@ -2588,9 +2714,6 @@ nfp_flow_action_output(char *act_data,
 	const struct rte_flow_action_ethdev *action_ethdev;
 	const struct rte_flow_action_port_id *action_port_id;
 
-	if (action->conf == NULL)
-		return -EINVAL;
-
 	if (action->type == RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT) {
 		action_ethdev = action->conf;
 		port_id = action_ethdev->port_id;
@@ -2599,9 +2722,6 @@ nfp_flow_action_output(char *act_data,
 		port_id = action_port_id->id;
 	}
 
-	if (port_id >= RTE_MAX_ETHPORTS)
-		return -ERANGE;
-
 	ethdev = &rte_eth_devices[port_id];
 	representor = ethdev->data->dev_private;
 
-- 
2.39.1

[PATCH 7/7] net/nfp: simplify the flow action calculate logic

[Chaoyong He]

Simplify the flow action calculate logic.

Signed-off-by: Chaoyong He <chaoyong.he@corigine.com>
Reviewed-by: Long Wu <long.wu@corigine.com>
Reviewed-by: Peng Zhang <peng.zhang@corigine.com>
---
 drivers/net/nfp/flower/nfp_flower_flow.c | 126 +++++------------------
 1 file changed, 23 insertions(+), 103 deletions(-)

diff --git a/drivers/net/nfp/flower/nfp_flower_flow.c b/drivers/net/nfp/flower/nfp_flower_flow.c
index 87a3d5b394..9b144e41d0 100644
--- a/drivers/net/nfp/flower/nfp_flower_flow.c
+++ b/drivers/net/nfp/flower/nfp_flower_flow.c
@@ -1129,7 +1129,7 @@ struct nfp_action_calculate_param {
 };
 
 typedef int (*nfp_flow_key_check_action_fn)(struct nfp_action_calculate_param *param);
-typedef int (*nfp_flow_key_calculate_action_fn)(struct nfp_action_calculate_param *param);
+typedef void (*nfp_flow_key_calculate_action_fn)(struct nfp_action_calculate_param *param);
 
 static int
 nfp_flow_action_check_port(struct nfp_action_calculate_param *param)
@@ -1368,78 +1368,63 @@ nfp_flow_key_layers_check_actions(const struct rte_flow_action actions[])
 	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_stub(struct nfp_action_calculate_param *param __rte_unused)
 {
-	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_port(struct nfp_action_calculate_param *param)
 {
 	param->key_ls->act_size += sizeof(struct nfp_fl_act_output);
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_mac(struct nfp_action_calculate_param *param)
 {
 	if (!param->flag->mac_set_flag) {
 		param->key_ls->act_size += sizeof(struct nfp_fl_act_set_eth);
 		param->flag->mac_set_flag = true;
 	}
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_pop_vlan(struct nfp_action_calculate_param *param)
 {
 	param->key_ls->act_size += sizeof(struct nfp_fl_act_pop_vlan);
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_push_vlan(struct nfp_action_calculate_param *param)
 {
 	param->key_ls->act_size += sizeof(struct nfp_fl_act_push_vlan);
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_ipv4_addr(struct nfp_action_calculate_param *param)
 {
 	if (!param->flag->ip_set_flag) {
 		param->key_ls->act_size += sizeof(struct nfp_fl_act_set_ip4_addrs);
 		param->flag->ip_set_flag = true;
 	}
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_ipv6_addr(struct nfp_action_calculate_param *param)
 {
 	param->key_ls->act_size += sizeof(struct nfp_fl_act_set_ipv6_addr);
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_tp(struct nfp_action_calculate_param *param)
 {
 	if (!param->flag->tp_set_flag) {
 		param->key_ls->act_size += sizeof(struct nfp_fl_act_set_tport);
 		param->flag->tp_set_flag = true;
 	}
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_ttl(struct nfp_action_calculate_param *param)
 {
 	if ((param->key_ls->key_layer & NFP_FLOWER_LAYER_IPV4) != 0) {
@@ -1453,68 +1438,53 @@ nfp_flow_action_calculate_ttl(struct nfp_action_calculate_param *param)
 			param->flag->tc_hl_flag = true;
 		}
 	}
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_ipv4_dscp(struct nfp_action_calculate_param *param)
 {
 	if (!param->flag->ttl_tos_flag) {
 		param->key_ls->act_size += sizeof(struct nfp_fl_act_set_ip4_ttl_tos);
 		param->flag->ttl_tos_flag = true;
 	}
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_ipv6_dscp(struct nfp_action_calculate_param *param)
 {
 	if (!param->flag->tc_hl_flag) {
 		param->key_ls->act_size += sizeof(struct nfp_fl_act_set_ipv6_tc_hl_fl);
 		param->flag->tc_hl_flag = true;
 	}
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_encap(struct nfp_action_calculate_param *param)
 {
 	param->key_ls->act_size += sizeof(struct nfp_fl_act_pre_tun);
 	param->key_ls->act_size += sizeof(struct nfp_fl_act_set_tun);
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_meter(struct nfp_action_calculate_param *param)
 {
-	if (param->flag->meter_flag) {
-		PMD_DRV_LOG(ERR, "Only support one meter action.");
-		return -ENOTSUP;
-	}
-
 	param->key_ls->act_size += sizeof(struct nfp_fl_act_meter);
-	param->flag->meter_flag = true;
-
-	return 0;
 }
 
-static int
+static void
 nfp_flow_action_calculate_mark(struct nfp_action_calculate_param *param)
 {
 	param->key_ls->act_size += sizeof(struct nfp_fl_act_mark);
-
-	return 0;
 }
 
-static int
-nfp_flow_action_calculate_modify_dispatch(struct nfp_action_calculate_param *param,
-		enum rte_flow_field_id field)
+static void
+nfp_flow_action_calculate_modify(struct nfp_action_calculate_param *param)
 {
-	switch (field) {
+	const struct rte_flow_action_modify_field *conf;
+
+	conf = param->action->conf;
+
+	switch (conf->dst.field) {
 	case RTE_FLOW_FIELD_IPV4_SRC:
 		/* FALLTHROUGH */
 	case RTE_FLOW_FIELD_IPV4_DST:
@@ -1546,51 +1516,6 @@ nfp_flow_action_calculate_modify_dispatch(struct nfp_action_calculate_param *par
 	default:
 		break;    /* NOTREACHED */
 	}
-
-	return -ENOTSUP;
-}
-
-static int
-nfp_flow_action_calculate_modify(struct nfp_action_calculate_param *param)
-{
-	uint32_t width;
-	uint32_t dst_width;
-	uint32_t src_width;
-	const struct rte_flow_field_data *dst_data;
-	const struct rte_flow_field_data *src_data;
-	const struct rte_flow_action_modify_field *conf;
-
-	conf = param->action->conf;
-	if (conf == NULL)
-		return -EINVAL;
-
-	dst_data = &conf->dst;
-	src_data = &conf->src;
-	if (!nfp_flow_field_id_dst_support(dst_data->field) ||
-			!nfp_flow_field_id_src_support(src_data->field)) {
-		PMD_DRV_LOG(ERR, "Not supported field id");
-		return -EINVAL;
-	}
-
-	width = conf->width;
-	if (width == 0) {
-		PMD_DRV_LOG(ERR, "No bits are required to modify");
-		return -EINVAL;
-	}
-
-	dst_width = nfp_flow_field_width(dst_data->field, 0);
-	src_width = nfp_flow_field_width(src_data->field, dst_width);
-	if (width > dst_width || width > src_width) {
-		PMD_DRV_LOG(ERR, "Cannot modify more bits than the width of a field");
-		return -EINVAL;
-	}
-
-	if (!nfp_flow_is_validate_field_data(dst_data, width, dst_width)) {
-		PMD_DRV_LOG(ERR, "The dest field data has problem");
-		return -EINVAL;
-	}
-
-	return nfp_flow_action_calculate_modify_dispatch(param, dst_data->field);
 }
 
 static nfp_flow_key_calculate_action_fn action_fns[] = {
@@ -1630,7 +1555,6 @@ static int
 nfp_flow_key_layers_calculate_actions(const struct rte_flow_action actions[],
 		struct nfp_fl_key_ls *key_ls)
 {
-	int ret;
 	struct nfp_action_flag flag = {};
 	const struct rte_flow_action *action;
 	struct nfp_action_calculate_param param = {
@@ -1651,11 +1575,7 @@ nfp_flow_key_layers_calculate_actions(const struct rte_flow_action actions[],
 		}
 
 		param.action = action;
-		ret = action_fns[action->type](&param);
-		if (ret != 0) {
-			PMD_DRV_LOG(ERR, "Flow action %d calculate fail", action->type);
-			return ret;
-		}
+		action_fns[action->type](&param);
 	}
 
 	return 0;
-- 
2.39.1