Building a better rte_flow parser

index 56dbf288a94..55e1de85d09 100644
@@ -6850,20 +6850,6 @@ ixgbe_ethertype_filter_program(struct ixgbe_hw *hw, uint8_t idx,
 	IXGBE_WRITE_FLUSH(hw);
 }
 
-static int
-ixgbe_ethertype_table_lookup(const struct ixgbe_ethertype_table *table,
-			uint16_t ethertype)
-{
-	int idx;
-
-	for (idx = 0; idx < IXGBE_MAX_ETQF_FILTERS; idx++) {
-		if (table->entries[idx].used &&
-				table->entries[idx].ethertype == ethertype)
-			return idx;
-	}
-	return -ENOENT;
-}
-
 int
 ixgbe_ethertype_table_add(struct ixgbe_ethertype_table *table,
 			uint16_t ethertype, uint32_t etqf, uint32_t etqs)

@@ -6901,42 +6887,6 @@ ixgbe_ethertype_table_del(struct ixgbe_ethertype_table *table, uint8_t idx)
 	return 0;
 }
 
-int
-ixgbe_add_del_ethertype_filter(struct ixgbe_adapter *adapter,
-			struct rte_eth_ethertype_filter *filter, bool add)
-{
-	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(adapter);
-	struct ixgbe_ethertype_table *table =
-		&IXGBE_DEV_PRIVATE_TO_FILTER_INFO(adapter)->ethertype_table;
-	uint32_t etqf, etqs;
-	int idx;
-
-	if (filter->queue >= IXGBE_MAX_RX_QUEUE_NUM ||
-		filter->ether_type == RTE_ETHER_TYPE_IPV4 ||
-		filter->ether_type == RTE_ETHER_TYPE_IPV6 ||
-		filter->flags & (RTE_ETHTYPE_FLAGS_MAC | RTE_ETHTYPE_FLAGS_DROP))
-		return -EINVAL;
-
-	if (add) {
-		etqf = IXGBE_ETQF_FILTER_EN | filter->ether_type;
-		etqs = IXGBE_ETQS_QUEUE_EN |
-			(((uint32_t)filter->queue << IXGBE_ETQS_RX_QUEUE_SHIFT) &
-			IXGBE_ETQS_RX_QUEUE);
-		idx = ixgbe_ethertype_table_add(table, filter->ether_type, etqf, etqs);
-		if (idx < 0)
-			return idx;
-	} else {
-		idx = ixgbe_ethertype_table_lookup(table, filter->ether_type);
-		if (idx < 0)
-			return idx;
-		ixgbe_ethertype_table_del(table, idx);
-		etqf = 0;
-		etqs = 0;
-	}
-	ixgbe_ethertype_filter_program(hw, idx, etqf, etqs);
-	return 0;
-}
-
 static int
 ixgbe_dev_flow_ops_get(__rte_unused struct rte_eth_dev *dev,
 		       const struct rte_flow_ops **ops)

@@ -8399,27 +8349,6 @@ ixgbe_ntuple_filter_restore(struct rte_eth_dev *dev)
 	}
 }
 
-/* restore ethernet type filter */
-static inline void
-ixgbe_ethertype_filter_restore(struct rte_eth_dev *dev)
-{
-	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
-	struct ixgbe_filter_info *filter_info =
-		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
-	int i;
-
-	for (i = 0; i < IXGBE_MAX_ETQF_FILTERS; i++) {
-		/* skip over entries not managed by rte_flow */
-		if (i == filter_info->timesync_idx ||
-				i == filter_info->antispoof_idx||
-				!filter_info->ethertype_table.entries[i].used)
-			continue;
-		ixgbe_ethertype_filter_program(hw, i,
-			filter_info->ethertype_table.entries[i].etqf,
-			filter_info->ethertype_table.entries[i].etqs);
-	}
-}
-
 /* restore SYN filter */
 static inline void
 ixgbe_syn_filter_restore(struct rte_eth_dev *dev)

@@ -8475,7 +8404,6 @@ static int
 ixgbe_filter_restore(struct rte_eth_dev *dev)
 {
 	ixgbe_ntuple_filter_restore(dev);
-	ixgbe_ethertype_filter_restore(dev);
 	ixgbe_syn_filter_restore(dev);
 	ixgbe_fdir_filter_restore(dev);
 	ixgbe_l2_tn_filter_restore(dev);

@@ -8514,26 +8442,6 @@ ixgbe_clear_all_ntuple_filter(struct rte_eth_dev *dev)
 		ixgbe_remove_5tuple_filter(adapter, p_5tuple);
 }
 
-/* remove all the ether type filters */
-void
-ixgbe_clear_all_ethertype_filter(struct rte_eth_dev *dev)
-{
-	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
-	struct ixgbe_filter_info *filter_info =
-		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
-	int i;
-
-	for (i = 0; i < IXGBE_MAX_ETQF_FILTERS; i++) {
-		/* only clear rte_flow filters */
-		if (!filter_info->ethertype_table.entries[i].used ||
-			(filter_info->timesync_installed && i == filter_info->timesync_idx) ||
-			(filter_info->antispoof_installed && i == filter_info->antispoof_idx))
-			continue;
-		ixgbe_ethertype_table_del(&filter_info->ethertype_table, i);
-		ixgbe_ethertype_filter_program(hw, i, 0, 0);
-	}
-}
-
 /* remove the SYN filter */
 void
 ixgbe_clear_syn_filter(struct rte_eth_dev *dev)

index fd819490f32..00d63a5bd51 100644
@@ -676,9 +676,6 @@ bool ixgbe_rss_update_sp(enum ixgbe_mac_type mac_type);
 int ixgbe_add_del_ntuple_filter(struct ixgbe_adapter *adapter,
 			struct rte_eth_ntuple_filter *filter,
 			bool add);
-int ixgbe_add_del_ethertype_filter(struct ixgbe_adapter *adapter,
-			struct rte_eth_ethertype_filter *filter,
-			bool add);
 int ixgbe_syn_filter_set(struct ixgbe_adapter *adapter,
 			struct rte_eth_syn_filter *filter,
 			bool add);

@@ -759,7 +756,6 @@ int ixgbe_clear_all_fdir_filter(struct rte_eth_dev *dev);
 
 extern const struct rte_flow_ops ixgbe_flow_ops;
 
-void ixgbe_clear_all_ethertype_filter(struct rte_eth_dev *dev);
 void ixgbe_clear_all_ntuple_filter(struct rte_eth_dev *dev);
 void ixgbe_clear_syn_filter(struct rte_eth_dev *dev);
 int ixgbe_clear_all_l2_tn_filter(struct rte_eth_dev *dev);

296 lines not on this page · raw message

index 5e68c9886c1..d7694283a54 100644
@@ -5,8 +5,16 @@
 #ifndef _IXGBE_FLOW_H_
 #define _IXGBE_FLOW_H_
 
+#include "../common/flow_check.h"
 #include "../common/flow_engine.h"
 
+int
+ixgbe_flow_actions_check(const struct ci_flow_actions *actions,
+		const struct ci_flow_actions_check_param *param,
+		struct rte_flow_error *error);
+
 extern const struct ci_flow_engine_list ixgbe_flow_engine_list;
 
+extern const struct ci_flow_engine ixgbe_ethertype_flow_engine;
+
 #endif /*  _IXGBE_FLOW_H_ */

299 lines not on this page · raw message

index acd5f8cdb11..f41f5501d88 100644
@@ -804,10 +804,10 @@ cons_parse_syn_filter(const struct rte_flow_attr *attr, const struct rte_flow_it
 	filter->queue = q_act->index;
 
 	/* Support 2 priorities, the lowest or highest. */
-	if (!attr->priority) {
-		filter->hig_pri = 0;
-	} else if (attr->priority == (uint32_t)~0U) {
+	if (attr->priority == 0) {
 		filter->hig_pri = 1;
+	} else if (attr->priority == (uint32_t)~0U) {
+		filter->hig_pri = 0;
 	} else {
 		memset(filter, 0, sizeof(struct rte_eth_syn_filter));
 		rte_flow_error_set(error, EINVAL,

index 55e1de85d09..64013c137a7 100644
@@ -6463,43 +6463,11 @@ ixgbevf_set_default_mac_addr(struct rte_eth_dev *dev,
 	return 0;
 }
 
-int
-ixgbe_syn_filter_set(struct ixgbe_adapter *adapter,
-			struct rte_eth_syn_filter *filter,
-			bool add)
+void
+ixgbe_syn_filter_program(struct ixgbe_hw *hw, uint32_t synqf)
 {
-	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(adapter);
-	struct ixgbe_filter_info *filter_info =
-		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(adapter);
-	uint32_t syn_info;
-	uint32_t synqf;
-
-	if (filter->queue >= IXGBE_MAX_RX_QUEUE_NUM)
-		return -EINVAL;
-
-	syn_info = filter_info->syn_info;
-
-	if (add) {
-		if (syn_info & IXGBE_SYN_FILTER_ENABLE)
-			return -EINVAL;
-		synqf = (uint32_t)(((filter->queue << IXGBE_SYN_FILTER_QUEUE_SHIFT) &
-			IXGBE_SYN_FILTER_QUEUE) | IXGBE_SYN_FILTER_ENABLE);
-
-		if (filter->hig_pri)
-			synqf |= IXGBE_SYN_FILTER_SYNQFP;
-		else
-			synqf &= ~IXGBE_SYN_FILTER_SYNQFP;
-	} else {
-		synqf = IXGBE_READ_REG(hw, IXGBE_SYNQF);
-		if (!(syn_info & IXGBE_SYN_FILTER_ENABLE))
-			return -ENOENT;
-		synqf &= ~(IXGBE_SYN_FILTER_QUEUE | IXGBE_SYN_FILTER_ENABLE);
-	}
-
-	filter_info->syn_info = synqf;
 	IXGBE_WRITE_REG(hw, IXGBE_SYNQF, synqf);
 	IXGBE_WRITE_FLUSH(hw);
-	return 0;
 }
 
 

@@ -8349,23 +8317,6 @@ ixgbe_ntuple_filter_restore(struct rte_eth_dev *dev)
 	}
 }
 
-/* restore SYN filter */
-static inline void
-ixgbe_syn_filter_restore(struct rte_eth_dev *dev)
-{
-	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
-	struct ixgbe_filter_info *filter_info =
-		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
-	uint32_t synqf;
-
-	synqf = filter_info->syn_info;
-
-	if (synqf & IXGBE_SYN_FILTER_ENABLE) {
-		IXGBE_WRITE_REG(hw, IXGBE_SYNQF, synqf);
-		IXGBE_WRITE_FLUSH(hw);
-	}
-}
-
 /* restore L2 tunnel filter */
 static inline void
 ixgbe_l2_tn_filter_restore(struct rte_eth_dev *dev)

@@ -8404,7 +8355,6 @@ static int
 ixgbe_filter_restore(struct rte_eth_dev *dev)
 {
 	ixgbe_ntuple_filter_restore(dev);
-	ixgbe_syn_filter_restore(dev);
 	ixgbe_fdir_filter_restore(dev);
 	ixgbe_l2_tn_filter_restore(dev);
 	ixgbe_rss_filter_restore(dev);

@@ -8442,22 +8392,6 @@ ixgbe_clear_all_ntuple_filter(struct rte_eth_dev *dev)
 		ixgbe_remove_5tuple_filter(adapter, p_5tuple);
 }
 
-/* remove the SYN filter */
-void
-ixgbe_clear_syn_filter(struct rte_eth_dev *dev)
-{
-	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
-	struct ixgbe_filter_info *filter_info =
-		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
-
-	if (filter_info->syn_info & IXGBE_SYN_FILTER_ENABLE) {
-		filter_info->syn_info = 0;
-
-		IXGBE_WRITE_REG(hw, IXGBE_SYNQF, 0);
-		IXGBE_WRITE_FLUSH(hw);
-	}
-}
-
 /* remove all the L2 tunnel filters */
 int
 ixgbe_clear_all_l2_tn_filter(struct rte_eth_dev *dev)

index 00d63a5bd51..6f1ed43cb74 100644
@@ -311,8 +311,6 @@ struct ixgbe_filter_info {
 	/* Bit mask for every used 5tuple filter */
 	uint32_t fivetuple_mask[IXGBE_5TUPLE_ARRAY_SIZE];
 	struct ixgbe_5tuple_filter_list fivetuple_list;
-	/* store the SYN filter info */
-	uint32_t syn_info;
 	/* store the rss filter info */
 	struct ixgbe_rte_flow_rss_conf rss_info;
 	/* shared EtherType (ETQF) slot table */

@@ -676,15 +674,13 @@ bool ixgbe_rss_update_sp(enum ixgbe_mac_type mac_type);
 int ixgbe_add_del_ntuple_filter(struct ixgbe_adapter *adapter,
 			struct rte_eth_ntuple_filter *filter,
 			bool add);
-int ixgbe_syn_filter_set(struct ixgbe_adapter *adapter,
-			struct rte_eth_syn_filter *filter,
-			bool add);
 
 void ixgbe_ethertype_filter_program(struct ixgbe_hw *hw, uint8_t idx,
 			uint32_t etqf, uint32_t etqs);
 int ixgbe_ethertype_table_add(struct ixgbe_ethertype_table *table,
 			uint16_t ethertype, uint32_t etqf, uint32_t etqs);
 int ixgbe_ethertype_table_del(struct ixgbe_ethertype_table *table, uint8_t idx);
+void ixgbe_syn_filter_program(struct ixgbe_hw *hw, uint32_t synqf);
 
 /**
  * l2 tunnel configuration.

@@ -757,7 +753,6 @@ int ixgbe_clear_all_fdir_filter(struct rte_eth_dev *dev);
 extern const struct rte_flow_ops ixgbe_flow_ops;
 
 void ixgbe_clear_all_ntuple_filter(struct rte_eth_dev *dev);
-void ixgbe_clear_syn_filter(struct rte_eth_dev *dev);
 int ixgbe_clear_all_l2_tn_filter(struct rte_eth_dev *dev);
 
 int ixgbe_disable_sec_tx_path_generic(struct ixgbe_hw *hw);

318 lines not on this page · raw message

index d7694283a54..453a23d3b63 100644
@@ -16,5 +16,6 @@ ixgbe_flow_actions_check(const struct ci_flow_actions *actions,
 extern const struct ci_flow_engine_list ixgbe_flow_engine_list;
 
 extern const struct ci_flow_engine ixgbe_ethertype_flow_engine;
+extern const struct ci_flow_engine ixgbe_syn_flow_engine;
 
 #endif /*  _IXGBE_FLOW_H_ */

312 lines not on this page · raw message

index 64013c137a7..c8821a34112 100644
@@ -150,7 +150,6 @@ static int eth_ixgbe_dev_uninit(struct rte_eth_dev *eth_dev);
 static int ixgbe_fdir_filter_init(struct rte_eth_dev *eth_dev);
 static int ixgbe_fdir_filter_uninit(struct rte_eth_dev *eth_dev);
 static int ixgbe_l2_tn_filter_init(struct rte_eth_dev *eth_dev);
-static int ixgbe_l2_tn_filter_uninit(struct rte_eth_dev *eth_dev);
 static int ixgbe_ntuple_filter_uninit(struct rte_eth_dev *eth_dev);
 static int ixgbe_dev_configure(struct rte_eth_dev *dev);
 static int ixgbe_dev_start(struct rte_eth_dev *dev);

@@ -1284,7 +1283,7 @@ eth_ixgbe_dev_init(struct rte_eth_dev *eth_dev, void *init_params __rte_unused)
 	ret = ci_flow_engine_conf_init(&ad->flow_engine_conf,
 			&ixgbe_flow_engine_list, eth_dev->data);
 	if (ret)
-		goto err_flow_engine_conf_init;
+		goto err_l2_tn_filter_init;
 
 	/* initialize flow filter lists */
 	ixgbe_filterlist_init(eth_dev);

@@ -1297,8 +1296,6 @@ eth_ixgbe_dev_init(struct rte_eth_dev *eth_dev, void *init_params __rte_unused)
 
 	return 0;
 
-err_flow_engine_conf_init:
-	ixgbe_l2_tn_filter_uninit(eth_dev);
 err_l2_tn_filter_init:
 	ixgbe_fdir_filter_uninit(eth_dev);
 err_fdir_filter_init:

@@ -1368,25 +1365,6 @@ static int ixgbe_fdir_filter_uninit(struct rte_eth_dev *eth_dev)
 	return 0;
 }
 
-static int ixgbe_l2_tn_filter_uninit(struct rte_eth_dev *eth_dev)
-{
-	struct ixgbe_l2_tn_info *l2_tn_info =
-		IXGBE_DEV_PRIVATE_TO_L2_TN_INFO(eth_dev->data->dev_private);
-	struct ixgbe_l2_tn_filter *l2_tn_filter;
-
-	rte_free(l2_tn_info->hash_map);
-	rte_hash_free(l2_tn_info->hash_handle);
-
-	while ((l2_tn_filter = TAILQ_FIRST(&l2_tn_info->l2_tn_list))) {
-		TAILQ_REMOVE(&l2_tn_info->l2_tn_list,
-			     l2_tn_filter,
-			     entries);
-		rte_free(l2_tn_filter);
-	}
-
-	return 0;
-}
-
 static int ixgbe_fdir_filter_init(struct rte_eth_dev *eth_dev)
 {
 	struct ixgbe_hw_fdir_info *fdir_info =

@@ -1432,34 +1410,7 @@ static int ixgbe_l2_tn_filter_init(struct rte_eth_dev *eth_dev)
 {
 	struct ixgbe_l2_tn_info *l2_tn_info =
 		IXGBE_DEV_PRIVATE_TO_L2_TN_INFO(eth_dev->data->dev_private);
-	char l2_tn_hash_name[RTE_HASH_NAMESIZE];
-	struct rte_hash_parameters l2_tn_hash_params = {
-		.name = l2_tn_hash_name,
-		.entries = IXGBE_MAX_L2_TN_FILTER_NUM,
-		.key_len = sizeof(struct ixgbe_l2_tn_key),
-		.hash_func = rte_hash_crc,
-		.hash_func_init_val = 0,
-		.socket_id = rte_socket_id(),
-	};
 
-	TAILQ_INIT(&l2_tn_info->l2_tn_list);
-	snprintf(l2_tn_hash_name, RTE_HASH_NAMESIZE,
-		 "l2_tn_%s", eth_dev->device->name);
-	l2_tn_info->hash_handle = rte_hash_create(&l2_tn_hash_params);
-	if (!l2_tn_info->hash_handle) {
-		PMD_INIT_LOG(ERR, "Failed to create L2 TN hash table!");
-		return -EINVAL;
-	}
-	l2_tn_info->hash_map = rte_zmalloc("ixgbe",
-				   sizeof(struct ixgbe_l2_tn_filter *) *
-				   IXGBE_MAX_L2_TN_FILTER_NUM,
-				   0);
-	if (!l2_tn_info->hash_map) {
-		PMD_INIT_LOG(ERR,
-			"Failed to allocate memory for L2 TN hash map!");
-		rte_hash_free(l2_tn_info->hash_handle);
-		return -ENOMEM;
-	}
 	l2_tn_info->e_tag_en = FALSE;
 	l2_tn_info->e_tag_fwd_en = FALSE;
 	l2_tn_info->e_tag_ether_type = RTE_ETHER_TYPE_ETAG;

@@ -3100,9 +3051,6 @@ ixgbe_dev_close(struct rte_eth_dev *dev)
 	/* remove all the fdir filters & hash */
 	ixgbe_fdir_filter_uninit(dev);
 
-	/* remove all the L2 tunnel filters & hash */
-	ixgbe_l2_tn_filter_uninit(dev);
-
 	/* Remove all ntuple filters of the device */
 	ixgbe_ntuple_filter_uninit(dev);
 

@@ -7693,7 +7641,7 @@ ixgbe_e_tag_enable(struct ixgbe_hw *hw)
 	return 0;
 }
 
-static int
+int
 ixgbe_e_tag_filter_del(struct ixgbe_adapter *adapter,
 		       struct ixgbe_l2_tunnel_conf *l2_tunnel)
 {

@@ -7730,7 +7678,7 @@ ixgbe_e_tag_filter_del(struct ixgbe_adapter *adapter,
 	return ret;
 }
 
-static int
+int
 ixgbe_e_tag_filter_add(struct ixgbe_adapter *adapter,
 		       struct ixgbe_l2_tunnel_conf *l2_tunnel)
 {

@@ -7772,154 +7720,6 @@ ixgbe_e_tag_filter_add(struct ixgbe_adapter *adapter,
 	return -EINVAL;
 }
 
-static inline struct ixgbe_l2_tn_filter *
-ixgbe_l2_tn_filter_lookup(struct ixgbe_l2_tn_info *l2_tn_info,
-			  struct ixgbe_l2_tn_key *key)
-{
-	int ret;
-
-	ret = rte_hash_lookup(l2_tn_info->hash_handle, (const void *)key);
-	if (ret < 0)
-		return NULL;
-
-	return l2_tn_info->hash_map[ret];
-}
-
-static inline int
-ixgbe_insert_l2_tn_filter(struct ixgbe_l2_tn_info *l2_tn_info,
-			  struct ixgbe_l2_tn_filter *l2_tn_filter)
-{
-	int ret;
-
-	ret = rte_hash_add_key(l2_tn_info->hash_handle,
-			       &l2_tn_filter->key);
-
-	if (ret < 0) {
-		PMD_DRV_LOG(ERR,
-			    "Failed to insert L2 tunnel filter"
-			    " to hash table %d!",
-			    ret);
-		return ret;
-	}
-
-	l2_tn_info->hash_map[ret] = l2_tn_filter;
-
-	TAILQ_INSERT_TAIL(&l2_tn_info->l2_tn_list, l2_tn_filter, entries);
-
-	return 0;
-}
-
-static inline int
-ixgbe_remove_l2_tn_filter(struct ixgbe_l2_tn_info *l2_tn_info,
-			  struct ixgbe_l2_tn_key *key)
-{
-	int ret;
-	struct ixgbe_l2_tn_filter *l2_tn_filter;
-
-	ret = rte_hash_del_key(l2_tn_info->hash_handle, key);
-
-	if (ret < 0) {
-		PMD_DRV_LOG(ERR,
-			    "No such L2 tunnel filter to delete %d!",
-			    ret);
-		return ret;
-	}
-
-	l2_tn_filter = l2_tn_info->hash_map[ret];
-	l2_tn_info->hash_map[ret] = NULL;
-
-	TAILQ_REMOVE(&l2_tn_info->l2_tn_list, l2_tn_filter, entries);
-	rte_free(l2_tn_filter);
-
-	return 0;
-}
-
-/* Add l2 tunnel filter */
-int
-ixgbe_dev_l2_tunnel_filter_add(struct ixgbe_adapter *adapter,
-			       struct ixgbe_l2_tunnel_conf *l2_tunnel,
-			       bool restore)
-{
-	int ret;
-	struct ixgbe_l2_tn_info *l2_tn_info =
-		IXGBE_DEV_PRIVATE_TO_L2_TN_INFO(adapter);
-	struct ixgbe_l2_tn_key key;
-	struct ixgbe_l2_tn_filter *node;
-
-	if (!restore) {
-		key.l2_tn_type = l2_tunnel->l2_tunnel_type;
-		key.tn_id = l2_tunnel->tunnel_id;
-
-		node = ixgbe_l2_tn_filter_lookup(l2_tn_info, &key);
-
-		if (node) {
-			PMD_DRV_LOG(ERR,
-				    "The L2 tunnel filter already exists!");
-			return -EINVAL;
-		}
-
-		node = rte_zmalloc("ixgbe_l2_tn",
-				   sizeof(struct ixgbe_l2_tn_filter),
-				   0);
-		if (!node)
-			return -ENOMEM;
-
-		memcpy(&node->key,
-				 &key,
-				 sizeof(struct ixgbe_l2_tn_key));
-		node->pool = l2_tunnel->pool;
-		ret = ixgbe_insert_l2_tn_filter(l2_tn_info, node);
-		if (ret < 0) {
-			rte_free(node);
-			return ret;
-		}
-	}
-
-	switch (l2_tunnel->l2_tunnel_type) {
-	case RTE_ETH_L2_TUNNEL_TYPE_E_TAG:
-		ret = ixgbe_e_tag_filter_add(adapter, l2_tunnel);
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "Invalid tunnel type");
-		ret = -EINVAL;
-		break;
-	}
-
-	if ((!restore) && (ret < 0))
-		(void)ixgbe_remove_l2_tn_filter(l2_tn_info, &key);
-
-	return ret;
-}
-
-/* Delete l2 tunnel filter */
-int
-ixgbe_dev_l2_tunnel_filter_del(struct ixgbe_adapter *adapter,
-			       struct ixgbe_l2_tunnel_conf *l2_tunnel)
-{
-	int ret;
-	struct ixgbe_l2_tn_info *l2_tn_info =
-		IXGBE_DEV_PRIVATE_TO_L2_TN_INFO(adapter);
-	struct ixgbe_l2_tn_key key;
-
-	key.l2_tn_type = l2_tunnel->l2_tunnel_type;
-	key.tn_id = l2_tunnel->tunnel_id;
-	ret = ixgbe_remove_l2_tn_filter(l2_tn_info, &key);
-	if (ret < 0)
-		return ret;
-
-	switch (l2_tunnel->l2_tunnel_type) {
-	case RTE_ETH_L2_TUNNEL_TYPE_E_TAG:
-		ret = ixgbe_e_tag_filter_del(adapter, l2_tunnel);
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "Invalid tunnel type");
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
 static int
 ixgbe_e_tag_forwarding_en_dis(struct rte_eth_dev *dev, bool en)
 {

@@ -8317,26 +8117,6 @@ ixgbe_ntuple_filter_restore(struct rte_eth_dev *dev)
 	}
 }
 
-/* restore L2 tunnel filter */
-static inline void
-ixgbe_l2_tn_filter_restore(struct rte_eth_dev *dev)
-{
-	struct ixgbe_adapter *adapter =
-		IXGBE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
-	struct ixgbe_l2_tn_info *l2_tn_info =
-		IXGBE_DEV_PRIVATE_TO_L2_TN_INFO(adapter);
-	struct ixgbe_l2_tn_filter *node;
-	struct ixgbe_l2_tunnel_conf l2_tn_conf;
-
-	TAILQ_FOREACH(node, &l2_tn_info->l2_tn_list, entries) {
-		l2_tn_conf.l2_tunnel_type = node->key.l2_tn_type;
-		l2_tn_conf.tunnel_id      = node->key.tn_id;
-		l2_tn_conf.pool           = node->pool;
-		(void)ixgbe_dev_l2_tunnel_filter_add(adapter,
-						     &l2_tn_conf, TRUE);
-	}
-}
-
 /* restore rss filter */
 static inline void
 ixgbe_rss_filter_restore(struct rte_eth_dev *dev)

@@ -8356,7 +8136,6 @@ ixgbe_filter_restore(struct rte_eth_dev *dev)
 {
 	ixgbe_ntuple_filter_restore(dev);
 	ixgbe_fdir_filter_restore(dev);
-	ixgbe_l2_tn_filter_restore(dev);
 	ixgbe_rss_filter_restore(dev);
 
 	return 0;

@@ -8392,30 +8171,6 @@ ixgbe_clear_all_ntuple_filter(struct rte_eth_dev *dev)
 		ixgbe_remove_5tuple_filter(adapter, p_5tuple);
 }
 
-/* remove all the L2 tunnel filters */
-int
-ixgbe_clear_all_l2_tn_filter(struct rte_eth_dev *dev)
-{
-	struct ixgbe_adapter *adapter =
-			IXGBE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
-	struct ixgbe_l2_tn_info *l2_tn_info =
-		IXGBE_DEV_PRIVATE_TO_L2_TN_INFO(dev->data->dev_private);
-	struct ixgbe_l2_tn_filter *l2_tn_filter;
-	struct ixgbe_l2_tunnel_conf l2_tn_conf;
-	int ret = 0;
-
-	while ((l2_tn_filter = TAILQ_FIRST(&l2_tn_info->l2_tn_list))) {
-		l2_tn_conf.l2_tunnel_type = l2_tn_filter->key.l2_tn_type;
-		l2_tn_conf.tunnel_id      = l2_tn_filter->key.tn_id;
-		l2_tn_conf.pool           = l2_tn_filter->pool;
-		ret = ixgbe_dev_l2_tunnel_filter_del(adapter, &l2_tn_conf);
-		if (ret < 0)
-			return ret;
-	}
-
-	return 0;
-}
-
 void
 ixgbe_dev_macsec_setting_save(struct rte_eth_dev *dev,
 				struct ixgbe_macsec_setting *macsec_setting)

index 6f1ed43cb74..a28d1bba3b7 100644
@@ -323,23 +323,7 @@ struct ixgbe_filter_info {
 	uint8_t antispoof_idx;
 };
 
-struct ixgbe_l2_tn_key {
-	enum rte_eth_tunnel_type          l2_tn_type;
-	uint32_t                          tn_id;
-};
-
-struct ixgbe_l2_tn_filter {
-	TAILQ_ENTRY(ixgbe_l2_tn_filter)    entries;
-	struct ixgbe_l2_tn_key             key;
-	uint32_t                           pool;
-};
-
-TAILQ_HEAD(ixgbe_l2_tn_filter_list, ixgbe_l2_tn_filter);
-
 struct ixgbe_l2_tn_info {
-	struct ixgbe_l2_tn_filter_list      l2_tn_list;
-	struct ixgbe_l2_tn_filter         **hash_map;
-	struct rte_hash                    *hash_handle;
 	bool e_tag_en; /* e-tag enabled */
 	bool e_tag_fwd_en; /* e-tag based forwarding enabled */
 	uint16_t e_tag_ether_type; /* ether type for e-tag */

@@ -694,12 +678,11 @@ struct ixgbe_l2_tunnel_conf {
 };
 
 int
-ixgbe_dev_l2_tunnel_filter_add(struct ixgbe_adapter *adapter,
-			       struct ixgbe_l2_tunnel_conf *l2_tunnel,
-			       bool restore);
+ixgbe_e_tag_filter_add(struct ixgbe_adapter *adapter,
+		       struct ixgbe_l2_tunnel_conf *l2_tunnel);
 int
-ixgbe_dev_l2_tunnel_filter_del(struct ixgbe_adapter *adapter,
-			       struct ixgbe_l2_tunnel_conf *l2_tunnel);
+ixgbe_e_tag_filter_del(struct ixgbe_adapter *adapter,
+		       struct ixgbe_l2_tunnel_conf *l2_tunnel);
 void ixgbe_filterlist_init(struct rte_eth_dev *dev);
 void ixgbe_filterlist_flush(struct rte_eth_dev *dev);
 /*

@@ -753,7 +736,6 @@ int ixgbe_clear_all_fdir_filter(struct rte_eth_dev *dev);
 extern const struct rte_flow_ops ixgbe_flow_ops;
 
 void ixgbe_clear_all_ntuple_filter(struct rte_eth_dev *dev);
-int ixgbe_clear_all_l2_tn_filter(struct rte_eth_dev *dev);
 
 int ixgbe_disable_sec_tx_path_generic(struct ixgbe_hw *hw);
 

276 lines not on this page · raw message

index 453a23d3b63..ba0486b2c0e 100644
@@ -17,5 +17,6 @@ extern const struct ci_flow_engine_list ixgbe_flow_engine_list;
 
 extern const struct ci_flow_engine ixgbe_ethertype_flow_engine;
 extern const struct ci_flow_engine ixgbe_syn_flow_engine;
+extern const struct ci_flow_engine ixgbe_l2_tunnel_flow_engine;
 
 #endif /*  _IXGBE_FLOW_H_ */

322 lines not on this page · raw message

index c9c13a93fd7..ac7c164ba35 100644
@@ -209,6 +209,7 @@ cons_parse_ntuple_filter(const struct rte_flow_attr *attr,
 	const struct rte_flow_item_vlan *vlan_mask;
 	struct rte_flow_item_eth eth_null;
 	struct rte_flow_item_vlan vlan_null;
+	uint16_t priority;
 
 	/* Priority must be 16-bit */
 	if (attr->priority > UINT16_MAX) {

@@ -503,9 +504,21 @@ cons_parse_ntuple_filter(const struct rte_flow_attr *attr,
 
 	filter->queue = q_act->index;
 
-	filter->priority = (uint16_t)attr->priority;
-	if (attr->priority < IXGBE_MIN_N_TUPLE_PRIO || attr->priority > IXGBE_MAX_N_TUPLE_PRIO)
-		filter->priority = 1;
+	/*
+	 * rte_flow priority: 0 through UINT32_MAX, 0 is highest
+	 *
+	 * ntuple priority: 001b through 111b, 111b is highest
+	 *
+	 * which means we need to transform priority from rte_flow to ntuple:
+	 *
+	 * 1) clamp max value
+	 * 2) reverse
+	 * 3) add min value
+	 */
+	priority = RTE_MIN(IXGBE_MAX_N_TUPLE_PRIO - 1, (uint16_t)attr->priority);
+	priority = IXGBE_MAX_N_TUPLE_PRIO - 1 - priority;
+	priority += IXGBE_MIN_N_TUPLE_PRIO;
+	filter->priority = priority;
 
 	return 0;
 }

index c8821a34112..db5e36adcc9 100644
@@ -150,7 +150,6 @@ static int eth_ixgbe_dev_uninit(struct rte_eth_dev *eth_dev);
 static int ixgbe_fdir_filter_init(struct rte_eth_dev *eth_dev);
 static int ixgbe_fdir_filter_uninit(struct rte_eth_dev *eth_dev);
 static int ixgbe_l2_tn_filter_init(struct rte_eth_dev *eth_dev);
-static int ixgbe_ntuple_filter_uninit(struct rte_eth_dev *eth_dev);
 static int ixgbe_dev_configure(struct rte_eth_dev *dev);
 static int ixgbe_dev_start(struct rte_eth_dev *dev);
 static int ixgbe_dev_stop(struct rte_eth_dev *dev);

@@ -301,10 +300,6 @@ static int ixgbevf_add_mac_addr(struct rte_eth_dev *dev,
 static void ixgbevf_remove_mac_addr(struct rte_eth_dev *dev, uint32_t index);
 static int ixgbevf_set_default_mac_addr(struct rte_eth_dev *dev,
 					     struct rte_ether_addr *mac_addr);
-static int ixgbe_add_5tuple_filter(struct ixgbe_adapter *adapter,
-			struct ixgbe_5tuple_filter *filter);
-static void ixgbe_remove_5tuple_filter(struct ixgbe_adapter *adapter,
-			struct ixgbe_5tuple_filter *filter);
 static int ixgbe_dev_flow_ops_get(struct rte_eth_dev *dev,
 				  const struct rte_flow_ops **ops);
 static int ixgbevf_dev_set_mtu(struct rte_eth_dev *dev, uint16_t mtu);

@@ -1266,9 +1261,6 @@ eth_ixgbe_dev_init(struct rte_eth_dev *eth_dev, void *init_params __rte_unused)
 	memset(filter_info, 0,
 	       sizeof(struct ixgbe_filter_info));
 
-	/* initialize 5tuple filter list */
-	TAILQ_INIT(&filter_info->fivetuple_list);
-
 	/* initialize flow director filter list & hash */
 	ret = ixgbe_fdir_filter_init(eth_dev);
 	if (ret)

@@ -1328,24 +1320,6 @@ eth_ixgbe_dev_uninit(struct rte_eth_dev *eth_dev)
 	return 0;
 }
 
-static int ixgbe_ntuple_filter_uninit(struct rte_eth_dev *eth_dev)
-{
-	struct ixgbe_filter_info *filter_info =
-		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(eth_dev->data->dev_private);
-	struct ixgbe_5tuple_filter *p_5tuple;
-
-	while ((p_5tuple = TAILQ_FIRST(&filter_info->fivetuple_list))) {
-		TAILQ_REMOVE(&filter_info->fivetuple_list,
-			     p_5tuple,
-			     entries);
-		rte_free(p_5tuple);
-	}
-	memset(filter_info->fivetuple_mask, 0,
-	       sizeof(uint32_t) * IXGBE_5TUPLE_ARRAY_SIZE);
-
-	return 0;
-}
-
 static int ixgbe_fdir_filter_uninit(struct rte_eth_dev *eth_dev)
 {
 	struct ixgbe_hw_fdir_info *fdir_info =

@@ -3051,9 +3025,6 @@ ixgbe_dev_close(struct rte_eth_dev *dev)
 	/* remove all the fdir filters & hash */
 	ixgbe_fdir_filter_uninit(dev);
 
-	/* Remove all ntuple filters of the device */
-	ixgbe_ntuple_filter_uninit(dev);
-
 	/* clear all the filters list */
 	ixgbe_filterlist_flush(dev);
 

@@ -6418,134 +6389,50 @@ ixgbe_syn_filter_program(struct ixgbe_hw *hw, uint32_t synqf)
 	IXGBE_WRITE_FLUSH(hw);
 }
 
-
-static inline enum ixgbe_5tuple_protocol
-convert_protocol_type(uint8_t protocol_value)
+/* program a single ntuple (5-tuple) filter slot into hardware */
+void
+ixgbe_ntuple_filter_program(struct ixgbe_hw *hw, uint16_t index,
+			const struct ixgbe_5tuple_filter_info *filter_info,
+			uint16_t queue)
 {
-	if (protocol_value == IPPROTO_TCP)
-		return IXGBE_FILTER_PROTOCOL_TCP;
-	else if (protocol_value == IPPROTO_UDP)
-		return IXGBE_FILTER_PROTOCOL_UDP;
-	else if (protocol_value == IPPROTO_SCTP)
-		return IXGBE_FILTER_PROTOCOL_SCTP;
-	else
-		return IXGBE_FILTER_PROTOCOL_NONE;
-}
-
-/* inject a 5-tuple filter to HW */
-static inline void
-ixgbe_inject_5tuple_filter(struct ixgbe_adapter *adapter,
-			   struct ixgbe_5tuple_filter *filter)
-{
-	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(adapter);
-	int i;
 	uint32_t ftqf, sdpqf;
 	uint32_t l34timir = 0;
 	uint8_t mask = 0xff;
 
-	i = filter->index;
+	sdpqf = (uint32_t)(filter_info->dst_port << IXGBE_SDPQF_DSTPORT_SHIFT);
+	sdpqf = sdpqf | (filter_info->src_port & IXGBE_SDPQF_SRCPORT);
 
-	sdpqf = (uint32_t)(filter->filter_info.dst_port <<
-				IXGBE_SDPQF_DSTPORT_SHIFT);
-	sdpqf = sdpqf | (filter->filter_info.src_port & IXGBE_SDPQF_SRCPORT);
-
-	ftqf = (uint32_t)(filter->filter_info.proto &
-		IXGBE_FTQF_PROTOCOL_MASK);
-	ftqf |= (uint32_t)((filter->filter_info.priority &
+	ftqf = (uint32_t)(filter_info->proto & IXGBE_FTQF_PROTOCOL_MASK);
+	ftqf |= (uint32_t)((filter_info->priority &
 		IXGBE_FTQF_PRIORITY_MASK) << IXGBE_FTQF_PRIORITY_SHIFT);
-	if (filter->filter_info.src_ip_mask == 0) /* 0 means compare. */
+	if (filter_info->src_ip_mask == 0) /* 0 means compare. */
 		mask &= IXGBE_FTQF_SOURCE_ADDR_MASK;
-	if (filter->filter_info.dst_ip_mask == 0)
+	if (filter_info->dst_ip_mask == 0)
 		mask &= IXGBE_FTQF_DEST_ADDR_MASK;
-	if (filter->filter_info.src_port_mask == 0)
+	if (filter_info->src_port_mask == 0)
 		mask &= IXGBE_FTQF_SOURCE_PORT_MASK;
-	if (filter->filter_info.dst_port_mask == 0)
+	if (filter_info->dst_port_mask == 0)
 		mask &= IXGBE_FTQF_DEST_PORT_MASK;
-	if (filter->filter_info.proto_mask == 0)
+	if (filter_info->proto_mask == 0)
 		mask &= IXGBE_FTQF_PROTOCOL_COMP_MASK;
 	ftqf |= mask << IXGBE_FTQF_5TUPLE_MASK_SHIFT;
 	ftqf |= IXGBE_FTQF_POOL_MASK_EN;
 	ftqf |= IXGBE_FTQF_QUEUE_ENABLE;
 
-	IXGBE_WRITE_REG(hw, IXGBE_DAQF(i), filter->filter_info.dst_ip);
-	IXGBE_WRITE_REG(hw, IXGBE_SAQF(i), filter->filter_info.src_ip);
-	IXGBE_WRITE_REG(hw, IXGBE_SDPQF(i), sdpqf);
-	IXGBE_WRITE_REG(hw, IXGBE_FTQF(i), ftqf);
+	IXGBE_WRITE_REG(hw, IXGBE_DAQF(index), filter_info->dst_ip);
+	IXGBE_WRITE_REG(hw, IXGBE_SAQF(index), filter_info->src_ip);
+	IXGBE_WRITE_REG(hw, IXGBE_SDPQF(index), sdpqf);
+	IXGBE_WRITE_REG(hw, IXGBE_FTQF(index), ftqf);
 
 	l34timir |= IXGBE_L34T_IMIR_RESERVE;
-	l34timir |= (uint32_t)(filter->queue <<
-				IXGBE_L34T_IMIR_QUEUE_SHIFT);
-	IXGBE_WRITE_REG(hw, IXGBE_L34T_IMIR(i), l34timir);
+	l34timir |= (uint32_t)(queue << IXGBE_L34T_IMIR_QUEUE_SHIFT);
+	IXGBE_WRITE_REG(hw, IXGBE_L34T_IMIR(index), l34timir);
 }
 
-/*
- * add a 5tuple filter
- *
- * @param
- * dev: Pointer to struct rte_eth_dev.
- * index: the index the filter allocates.
- * filter: pointer to the filter that will be added.
- * rx_queue: the queue id the filter assigned to.
- *
- * @return
- *    - On success, zero.
- *    - On failure, a negative value.
- */
-static int
-ixgbe_add_5tuple_filter(struct ixgbe_adapter *adapter,
-			struct ixgbe_5tuple_filter *filter)
+/* clear a single ntuple (5-tuple) filter slot from hardware */
+void
+ixgbe_ntuple_filter_clear(struct ixgbe_hw *hw, uint16_t index)
 {
-	struct ixgbe_filter_info *filter_info =
-		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(adapter);
-	int i, idx, shift;
-
-	/*
-	 * look for an unused 5tuple filter index,
-	 * and insert the filter to list.
-	 */
-	for (i = 0; i < IXGBE_MAX_FTQF_FILTERS; i++) {
-		idx = i / (sizeof(uint32_t) * NBBY);
-		shift = i % (sizeof(uint32_t) * NBBY);
-		if (!(filter_info->fivetuple_mask[idx] & (1 << shift))) {
-			filter_info->fivetuple_mask[idx] |= 1 << shift;
-			filter->index = i;
-			TAILQ_INSERT_TAIL(&filter_info->fivetuple_list,
-					  filter,
-					  entries);
-			break;
-		}
-	}
-	if (i >= IXGBE_MAX_FTQF_FILTERS) {
-		PMD_DRV_LOG(ERR, "5tuple filters are full.");
-		return -ENOSYS;
-	}
-
-	ixgbe_inject_5tuple_filter(adapter, filter);
-
-	return 0;
-}
-
-/*
- * remove a 5tuple filter
- *
- * @param
- * dev: Pointer to struct rte_eth_dev.
- * filter: the pointer of the filter will be removed.
- */
-static void
-ixgbe_remove_5tuple_filter(struct ixgbe_adapter *adapter,
-			struct ixgbe_5tuple_filter *filter)
-{
-	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(adapter);
-	struct ixgbe_filter_info *filter_info =
-		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(adapter);
-	uint16_t index = filter->index;
-
-	filter_info->fivetuple_mask[index / (sizeof(uint32_t) * NBBY)] &=
-				~(1 << (index % (sizeof(uint32_t) * NBBY)));
-	TAILQ_REMOVE(&filter_info->fivetuple_list, filter, entries);
-	rte_free(filter);
-
 	IXGBE_WRITE_REG(hw, IXGBE_DAQF(index), 0);
 	IXGBE_WRITE_REG(hw, IXGBE_SAQF(index), 0);
 	IXGBE_WRITE_REG(hw, IXGBE_SDPQF(index), 0);

@@ -6598,165 +6485,6 @@ ixgbevf_dev_set_mtu(struct rte_eth_dev *dev, uint16_t mtu)
 	return 0;
 }
 
-static inline struct ixgbe_5tuple_filter *
-ixgbe_5tuple_filter_lookup(struct ixgbe_5tuple_filter_list *filter_list,
-			struct ixgbe_5tuple_filter_info *key)
-{
-	struct ixgbe_5tuple_filter *it;
-
-	TAILQ_FOREACH(it, filter_list, entries) {
-		if (memcmp(key, &it->filter_info,
-			sizeof(struct ixgbe_5tuple_filter_info)) == 0) {
-			return it;
-		}
-	}
-	return NULL;
-}
-
-/* translate elements in struct rte_eth_ntuple_filter to struct ixgbe_5tuple_filter_info*/
-static inline int
-ntuple_filter_to_5tuple(struct rte_eth_ntuple_filter *filter,
-			struct ixgbe_5tuple_filter_info *filter_info)
-{
-	if (filter->queue >= IXGBE_MAX_RX_QUEUE_NUM ||
-		filter->priority > IXGBE_5TUPLE_MAX_PRI ||
-		filter->priority < IXGBE_5TUPLE_MIN_PRI)
-		return -EINVAL;
-
-	switch (filter->dst_ip_mask) {
-	case UINT32_MAX:
-		filter_info->dst_ip_mask = 0;
-		filter_info->dst_ip = filter->dst_ip;
-		break;
-	case 0:
-		filter_info->dst_ip_mask = 1;
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "invalid dst_ip mask.");
-		return -EINVAL;
-	}
-
-	switch (filter->src_ip_mask) {
-	case UINT32_MAX:
-		filter_info->src_ip_mask = 0;
-		filter_info->src_ip = filter->src_ip;
-		break;
-	case 0:
-		filter_info->src_ip_mask = 1;
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "invalid src_ip mask.");
-		return -EINVAL;
-	}
-
-	switch (filter->dst_port_mask) {
-	case UINT16_MAX:
-		filter_info->dst_port_mask = 0;
-		filter_info->dst_port = filter->dst_port;
-		break;
-	case 0:
-		filter_info->dst_port_mask = 1;
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "invalid dst_port mask.");
-		return -EINVAL;
-	}
-
-	switch (filter->src_port_mask) {
-	case UINT16_MAX:
-		filter_info->src_port_mask = 0;
-		filter_info->src_port = filter->src_port;
-		break;
-	case 0:
-		filter_info->src_port_mask = 1;
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "invalid src_port mask.");
-		return -EINVAL;
-	}
-
-	switch (filter->proto_mask) {
-	case UINT8_MAX:
-		filter_info->proto_mask = 0;
-		filter_info->proto =
-			convert_protocol_type(filter->proto);
-		break;
-	case 0:
-		filter_info->proto_mask = 1;
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "invalid protocol mask.");
-		return -EINVAL;
-	}
-
-	filter_info->priority = (uint8_t)filter->priority;
-	return 0;
-}
-
-/*
- * add or delete a ntuple filter
- *
- * @param
- * dev: Pointer to struct rte_eth_dev.
- * ntuple_filter: Pointer to struct rte_eth_ntuple_filter
- * add: if true, add filter, if false, remove filter
- *
- * @return
- *    - On success, zero.
- *    - On failure, a negative value.
- */
-int
-ixgbe_add_del_ntuple_filter(struct ixgbe_adapter *adapter,
-			struct rte_eth_ntuple_filter *ntuple_filter,
-			bool add)
-{
-	struct ixgbe_filter_info *filter_info =
-		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(adapter);
-	struct ixgbe_5tuple_filter_info filter_5tuple;
-	struct ixgbe_5tuple_filter *filter;
-	int ret;
-
-	if (ntuple_filter->flags != RTE_5TUPLE_FLAGS) {
-		PMD_DRV_LOG(ERR, "only 5tuple is supported.");
-		return -EINVAL;
-	}
-
-	memset(&filter_5tuple, 0, sizeof(struct ixgbe_5tuple_filter_info));
-	ret = ntuple_filter_to_5tuple(ntuple_filter, &filter_5tuple);
-	if (ret < 0)
-		return ret;
-
-	filter = ixgbe_5tuple_filter_lookup(&filter_info->fivetuple_list,
-					 &filter_5tuple);
-	if (filter != NULL && add) {
-		PMD_DRV_LOG(ERR, "filter exists.");
-		return -EEXIST;
-	}
-	if (filter == NULL && !add) {
-		PMD_DRV_LOG(ERR, "filter doesn't exist.");
-		return -ENOENT;
-	}
-
-	if (add) {
-		filter = rte_zmalloc("ixgbe_5tuple_filter",
-				sizeof(struct ixgbe_5tuple_filter), 0);
-		if (filter == NULL)
-			return -ENOMEM;
-		memcpy(&filter->filter_info,
-				 &filter_5tuple,
-				 sizeof(struct ixgbe_5tuple_filter_info));
-		filter->queue = ntuple_filter->queue;
-		ret = ixgbe_add_5tuple_filter(adapter, filter);
-		if (ret < 0) {
-			rte_free(filter);
-			return ret;
-		}
-	} else
-		ixgbe_remove_5tuple_filter(adapter, filter);
-
-	return 0;
-}
-
 void
 ixgbe_ethertype_filter_program(struct ixgbe_hw *hw, uint8_t idx,
 			uint32_t etqf, uint32_t etqs)

@@ -8102,21 +7830,6 @@ int ixgbe_enable_sec_tx_path_generic(struct ixgbe_hw *hw)
 	return IXGBE_SUCCESS;
 }
 
-/* restore n-tuple filter */
-static inline void
-ixgbe_ntuple_filter_restore(struct rte_eth_dev *dev)
-{
-	struct ixgbe_adapter *adapter =
-		IXGBE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
-	struct ixgbe_filter_info *filter_info =
-		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
-	struct ixgbe_5tuple_filter *node;
-
-	TAILQ_FOREACH(node, &filter_info->fivetuple_list, entries) {
-		ixgbe_inject_5tuple_filter(adapter, node);
-	}
-}
-
 /* restore rss filter */
 static inline void
 ixgbe_rss_filter_restore(struct rte_eth_dev *dev)

@@ -8134,7 +7847,6 @@ ixgbe_rss_filter_restore(struct rte_eth_dev *dev)
 static int
 ixgbe_filter_restore(struct rte_eth_dev *dev)
 {
-	ixgbe_ntuple_filter_restore(dev);
 	ixgbe_fdir_filter_restore(dev);
 	ixgbe_rss_filter_restore(dev);
 

@@ -8157,20 +7869,6 @@ ixgbe_l2_tunnel_conf(struct rte_eth_dev *dev)
 	(void)ixgbe_update_e_tag_eth_type(hw, l2_tn_info->e_tag_ether_type);
 }
 
-/* remove all the n-tuple filters */
-void
-ixgbe_clear_all_ntuple_filter(struct rte_eth_dev *dev)
-{
-	struct ixgbe_adapter *adapter =
-		IXGBE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
-	struct ixgbe_filter_info *filter_info =
-		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
-	struct ixgbe_5tuple_filter *p_5tuple;
-
-	while ((p_5tuple = TAILQ_FIRST(&filter_info->fivetuple_list)))
-		ixgbe_remove_5tuple_filter(adapter, p_5tuple);
-}
-
 void
 ixgbe_dev_macsec_setting_save(struct rte_eth_dev *dev,
 				struct ixgbe_macsec_setting *macsec_setting)

index a28d1bba3b7..daab7fb0d5a 100644
@@ -100,8 +100,6 @@
 #define IXGBE_L34T_IMIR_LLI             0x00100000
 #define IXGBE_L34T_IMIR_QUEUE           0x0FE00000
 #define IXGBE_L34T_IMIR_QUEUE_SHIFT     21
-#define IXGBE_5TUPLE_MAX_PRI            7
-#define IXGBE_5TUPLE_MIN_PRI            1
 
 /* The overhead from MTU to max frame size. */
 #define IXGBE_ETH_OVERHEAD (RTE_ETHER_HDR_LEN + RTE_ETHER_CRC_LEN)

@@ -265,8 +263,6 @@ enum ixgbe_5tuple_protocol {
 	IXGBE_FILTER_PROTOCOL_NONE,
 };
 
-TAILQ_HEAD(ixgbe_5tuple_filter_list, ixgbe_5tuple_filter);
-
 struct ixgbe_5tuple_filter_info {
 	uint32_t dst_ip;
 	uint32_t src_ip;

@@ -282,18 +278,6 @@ struct ixgbe_5tuple_filter_info {
 		proto_mask:1;    /* if mask is 1b, do not compare protocol. */
 };
 
-/* 5tuple filter structure */
-struct ixgbe_5tuple_filter {
-	TAILQ_ENTRY(ixgbe_5tuple_filter) entries;
-	uint16_t index;       /* the index of 5tuple filter */
-	struct ixgbe_5tuple_filter_info filter_info;
-	uint16_t queue;       /* rx queue assigned to */
-};
-
-#define IXGBE_5TUPLE_ARRAY_SIZE \
-	(RTE_ALIGN(IXGBE_MAX_FTQF_FILTERS, (sizeof(uint32_t) * NBBY)) / \
-	 (sizeof(uint32_t) * NBBY))
-
 /* Shared EtherType (ETQF) filter table. */
 struct ixgbe_ethertype_table {
 	struct ixgbe_ethertype_entry {

@@ -308,9 +292,6 @@ struct ixgbe_ethertype_table {
  * Structure to store filters' info.
  */
 struct ixgbe_filter_info {
-	/* Bit mask for every used 5tuple filter */
-	uint32_t fivetuple_mask[IXGBE_5TUPLE_ARRAY_SIZE];
-	struct ixgbe_5tuple_filter_list fivetuple_list;
 	/* store the rss filter info */
 	struct ixgbe_rte_flow_rss_conf rss_info;
 	/* shared EtherType (ETQF) slot table */

@@ -655,9 +636,10 @@ uint32_t ixgbe_rssrk_reg_get(enum ixgbe_mac_type mac_type, uint8_t i);
 
 bool ixgbe_rss_update_sp(enum ixgbe_mac_type mac_type);
 
-int ixgbe_add_del_ntuple_filter(struct ixgbe_adapter *adapter,
-			struct rte_eth_ntuple_filter *filter,
-			bool add);
+void ixgbe_ntuple_filter_program(struct ixgbe_hw *hw, uint16_t index,
+			const struct ixgbe_5tuple_filter_info *filter_info,
+			uint16_t queue);
+void ixgbe_ntuple_filter_clear(struct ixgbe_hw *hw, uint16_t index);
 
 void ixgbe_ethertype_filter_program(struct ixgbe_hw *hw, uint8_t idx,
 			uint32_t etqf, uint32_t etqs);

@@ -735,8 +717,6 @@ int ixgbe_clear_all_fdir_filter(struct rte_eth_dev *dev);
 
 extern const struct rte_flow_ops ixgbe_flow_ops;
 
-void ixgbe_clear_all_ntuple_filter(struct rte_eth_dev *dev);
-
 int ixgbe_disable_sec_tx_path_generic(struct ixgbe_hw *hw);
 
 int ixgbe_enable_sec_tx_path_generic(struct ixgbe_hw *hw);

568 lines not on this page · raw message

index ba0486b2c0e..6f082e9402f 100644
@@ -18,5 +18,6 @@ extern const struct ci_flow_engine_list ixgbe_flow_engine_list;
 extern const struct ci_flow_engine ixgbe_ethertype_flow_engine;
 extern const struct ci_flow_engine ixgbe_syn_flow_engine;
 extern const struct ci_flow_engine ixgbe_l2_tunnel_flow_engine;
+extern const struct ci_flow_engine ixgbe_ntuple_flow_engine;
 
 #endif /*  _IXGBE_FLOW_H_ */

694 lines not on this page · raw message

index daab7fb0d5a..798623e0068 100644
@@ -313,8 +313,6 @@ struct ixgbe_l2_tn_info {
 struct rte_flow {
 	struct ci_flow flow;
 	enum rte_filter_type filter_type;
-	/* security flows are not rte_filter_type */
-	bool is_security;
 	void *rule;
 };
 

174 lines not on this page · raw message

index 6f082e9402f..87cf0282454 100644
@@ -19,5 +19,6 @@ extern const struct ci_flow_engine ixgbe_ethertype_flow_engine;
 extern const struct ci_flow_engine ixgbe_syn_flow_engine;
 extern const struct ci_flow_engine ixgbe_l2_tunnel_flow_engine;
 extern const struct ci_flow_engine ixgbe_ntuple_flow_engine;
+extern const struct ci_flow_engine ixgbe_security_flow_engine;
 
 #endif /*  _IXGBE_FLOW_H_ */

586 lines not on this page · raw message

444 lines not on this page · raw message

91 lines not on this page · raw message

index db5e36adcc9..3228d1c5be3 100644
@@ -147,8 +147,6 @@ static const char * const ixgbevf_valid_arguments[] = {
 
 static int eth_ixgbe_dev_init(struct rte_eth_dev *eth_dev, void *init_params);
 static int eth_ixgbe_dev_uninit(struct rte_eth_dev *eth_dev);
-static int ixgbe_fdir_filter_init(struct rte_eth_dev *eth_dev);
-static int ixgbe_fdir_filter_uninit(struct rte_eth_dev *eth_dev);
 static int ixgbe_l2_tn_filter_init(struct rte_eth_dev *eth_dev);
 static int ixgbe_dev_configure(struct rte_eth_dev *dev);
 static int ixgbe_dev_start(struct rte_eth_dev *dev);

@@ -1008,7 +1006,7 @@ ixgbe_parse_devargs(struct ixgbe_adapter *adapter,
 				       &pballoc) != 0)
 			ret = -EINVAL;
 		else
-			adapter->fdir_conf.pballoc = pballoc;
+			adapter->fdir_hw_config.pballoc = pballoc;
 	}
 
 	rte_kvargs_free(kvlist);

@@ -1261,11 +1259,6 @@ eth_ixgbe_dev_init(struct rte_eth_dev *eth_dev, void *init_params __rte_unused)
 	memset(filter_info, 0,
 	       sizeof(struct ixgbe_filter_info));
 
-	/* initialize flow director filter list & hash */
-	ret = ixgbe_fdir_filter_init(eth_dev);
-	if (ret)
-		goto err_fdir_filter_init;
-
 	/* initialize l2 tunnel filter list & hash */
 	ret = ixgbe_l2_tn_filter_init(eth_dev);
 	if (ret)

@@ -1289,8 +1282,6 @@ eth_ixgbe_dev_init(struct rte_eth_dev *eth_dev, void *init_params __rte_unused)
 	return 0;
 
 err_l2_tn_filter_init:
-	ixgbe_fdir_filter_uninit(eth_dev);
-err_fdir_filter_init:
 	ixgbe_disable_intr(hw);
 	rte_intr_disable(intr_handle);
 	rte_intr_callback_unregister(intr_handle,

@@ -1320,31 +1311,25 @@ eth_ixgbe_dev_uninit(struct rte_eth_dev *eth_dev)
 	return 0;
 }
 
-static int ixgbe_fdir_filter_uninit(struct rte_eth_dev *eth_dev)
+void
+ixgbe_fdir_state_detach(struct ixgbe_fdir_state *state)
 {
-	struct ixgbe_hw_fdir_info *fdir_info =
-		IXGBE_DEV_PRIVATE_TO_FDIR_INFO(eth_dev->data->dev_private);
-	struct ixgbe_fdir_filter *fdir_filter;
+	if (!ci_usage_count_release(&state->engine_use_count))
+		return;
 
-	rte_free(fdir_info->hash_map);
-	rte_hash_free(fdir_info->hash_handle);
+	rte_hash_free(state->hash_handle);
 
-	while ((fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list))) {
-		TAILQ_REMOVE(&fdir_info->fdir_list,
-			     fdir_filter,
-			     entries);
-		rte_free(fdir_filter);
-	}
-
-	return 0;
+	/* erase mask state as well */
+	*state = (struct ixgbe_fdir_state){0};
 }
 
-static int ixgbe_fdir_filter_init(struct rte_eth_dev *eth_dev)
+struct ixgbe_fdir_state *
+ixgbe_fdir_state_attach(struct rte_eth_dev_data *dev_data)
 {
-	struct ixgbe_hw_fdir_info *fdir_info =
-		IXGBE_DEV_PRIVATE_TO_FDIR_INFO(eth_dev->data->dev_private);
+	struct ixgbe_adapter *adapter = IXGBE_DEV_PRIVATE_TO_ADAPTER(dev_data->dev_private);
+	struct ixgbe_fdir_state *state = &adapter->fdir_state;
 	char fdir_hash_name[RTE_HASH_NAMESIZE];
-	struct rte_hash_parameters fdir_hash_params = {
+	struct rte_hash_parameters hash_params = {
 		.name = fdir_hash_name,
 		.entries = IXGBE_MAX_FDIR_FILTER_NUM,
 		.key_len = sizeof(union ixgbe_atr_input),

@@ -1353,31 +1338,28 @@ static int ixgbe_fdir_filter_init(struct rte_eth_dev *eth_dev)
 		.socket_id = rte_socket_id(),
 	};
 
-	TAILQ_INIT(&fdir_info->fdir_list);
-	snprintf(fdir_hash_name, RTE_HASH_NAMESIZE,
-		 "fdir_%s", eth_dev->device->name);
-	fdir_info->hash_handle = rte_hash_create(&fdir_hash_params);
-	if (!fdir_info->hash_handle) {
-		PMD_INIT_LOG(ERR, "Failed to create fdir hash table!");
-		return -EINVAL;
-	}
-	fdir_info->hash_map = rte_zmalloc("ixgbe",
-					  sizeof(struct ixgbe_fdir_filter *) *
-					  IXGBE_MAX_FDIR_FILTER_NUM,
-					  0);
-	if (!fdir_info->hash_map) {
-		PMD_INIT_LOG(ERR,
-			     "Failed to allocate memory for fdir hash map!");
-		rte_hash_free(fdir_info->hash_handle);
-		return -ENOMEM;
-	}
-	fdir_info->n_flows = 0;
-	fdir_info->mask_added = FALSE;
+	snprintf(fdir_hash_name, RTE_HASH_NAMESIZE, "ixgbe_fdir_hash_%s",
+			dev_data->name);
+
+	if (ci_usage_count_claim(&state->engine_use_count)) {
+		struct rte_hash *hash_handle;
+
+		hash_handle = rte_hash_create(&hash_params);
 
-	/* drop queue is always fixed */
-	IXGBE_DEV_FDIR_CONF(eth_dev)->drop_queue = IXGBE_FDIR_DROP_QUEUE;
+		if (hash_handle == NULL) {
+			PMD_INIT_LOG(ERR, "Failed to create fdir hash table!");
+			ci_usage_count_release(&state->engine_use_count);
+			return NULL;
+		}
+
+		state->hash_handle = hash_handle;
+		state->config.mode = RTE_FDIR_MODE_NONE;
+
+		/* set up default values for the mask */
+		ixgbe_fdir_mask_set_default(&state->mask_conf.mask);
+	}
 
-	return 0;
+	return state;
 }
 
 static int ixgbe_l2_tn_filter_init(struct rte_eth_dev *eth_dev)

@@ -2174,9 +2156,27 @@ ixgbe_check_mq_mode(struct rte_eth_dev *dev)
 {
 	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
 	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+	struct ixgbe_adapter *adapter = IXGBE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
 	uint16_t nb_rx_q = dev->data->nb_rx_queues;
 	uint16_t nb_tx_q = dev->data->nb_tx_queues;
 
+	/* DCB-family modes reprogram RXPBSIZE and clash with FDIR's own use of it */
+	switch (dev_conf->rxmode.mq_mode) {
+	case RTE_ETH_MQ_RX_VMDQ_DCB:
+	case RTE_ETH_MQ_RX_DCB:
+	case RTE_ETH_MQ_RX_DCB_RSS:
+	case RTE_ETH_MQ_RX_VMDQ_DCB_RSS:
+		if (adapter->fdir_state.config.mode != RTE_FDIR_MODE_NONE) {
+			PMD_INIT_LOG(ERR, "Cannot use DCB mq_mode %d while "
+					"flow director rules are active.",
+					dev_conf->rxmode.mq_mode);
+			return -EINVAL;
+		}
+		break;
+	default:
+		break;
+	}
+
 	if (RTE_ETH_DEV_SRIOV(dev).active != 0) {
 		/* check multi-queue mode */
 		switch (dev_conf->rxmode.mq_mode) {

@@ -2497,7 +2497,6 @@ ixgbe_dev_start(struct rte_eth_dev *dev)
 	struct ixgbe_adapter *adapter =
 		IXGBE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
 	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(adapter);
-	struct rte_eth_fdir_conf *fdir_conf = IXGBE_DEV_FDIR_CONF(dev);
 	struct ixgbe_vf_info *vfinfo =
 		*IXGBE_DEV_PRIVATE_TO_P_VFDATA(dev->data->dev_private);
 	struct rte_pci_device *pci_dev = RTE_CLASS_TO_BUS_DEVICE(dev, *pci_dev);

@@ -2602,14 +2601,6 @@ ixgbe_dev_start(struct rte_eth_dev *dev)
 	/* Configure DCB hw */
 	ixgbe_configure_dcb(dev);
 
-	if (fdir_conf->mode != RTE_FDIR_MODE_NONE) {
-		struct ixgbe_hw_fdir_info *info =
-			IXGBE_DEV_PRIVATE_TO_FDIR_INFO(adapter);
-		err = ixgbe_fdir_configure(dev, fdir_conf, &info->mask);
-		if (err)
-			goto error;
-	}
-
 	/* Restore vf rate limit */
 	if (vfinfo != NULL) {
 		for (vf = 0; vf < pci_dev->max_vfs; vf++)

@@ -2878,6 +2869,9 @@ ixgbe_dev_stop(struct rte_eth_dev *dev)
 	/* reset hierarchy commit */
 	tm_conf->committed = false;
 
+	/* the reset above wiped the flow director setup, kept flows are replayed on start */
+	ixgbe_fdir_hw_invalidate(dev);
+
 	adapter->rss_reta_updated = 0;
 
 	hw->adapter_stopped = true;

@@ -3022,9 +3016,6 @@ ixgbe_dev_close(struct rte_eth_dev *dev)
 	/* uninitialize PF if max_vfs not zero */
 	ixgbe_pf_host_uninit(dev);
 
-	/* remove all the fdir filters & hash */
-	ixgbe_fdir_filter_uninit(dev);
-
 	/* clear all the filters list */
 	ixgbe_filterlist_flush(dev);
 

@@ -7847,7 +7838,6 @@ ixgbe_rss_filter_restore(struct rte_eth_dev *dev)
 static int
 ixgbe_filter_restore(struct rte_eth_dev *dev)
 {
-	ixgbe_fdir_filter_restore(dev);
 	ixgbe_rss_filter_restore(dev);
 
 	return 0;

165 lines not on this page · raw message

802 lines not on this page · raw message

1,664 lines not on this page · raw message

index 87cf0282454..256e0478f58 100644
@@ -20,5 +20,7 @@ extern const struct ci_flow_engine ixgbe_syn_flow_engine;
 extern const struct ci_flow_engine ixgbe_l2_tunnel_flow_engine;
 extern const struct ci_flow_engine ixgbe_ntuple_flow_engine;
 extern const struct ci_flow_engine ixgbe_security_flow_engine;
+extern const struct ci_flow_engine ixgbe_fdir_flow_engine;
+extern const struct ci_flow_engine ixgbe_fdir_tunnel_flow_engine;
 
 #endif /*  _IXGBE_FLOW_H_ */

160 lines not on this page · raw message

index c42b8fc96ba..bf456034168 100644

Lines of this file are not shown. View the raw message.

index 3228d1c5be3..2a1819c0f3e 100644
@@ -7830,7 +7830,7 @@ ixgbe_rss_filter_restore(struct rte_eth_dev *dev)
 	struct ixgbe_filter_info *filter_info =
 		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(adapter);
 
-	if (filter_info->rss_info.conf.queue_num)
+	if (filter_info->rss_info.queue_num)
 		ixgbe_config_rss_filter(adapter,
 			&filter_info->rss_info, TRUE);
 }

index 06edca96698..d769e375269 100644
@@ -209,9 +209,11 @@ struct ixgbe_fdir_state {
 	struct ixgbe_fdir_mask_state mask_conf;
 };
 
-struct ixgbe_rte_flow_rss_conf {
-	struct rte_flow_action_rss conf; /**< RSS parameters. */
-	uint8_t key[IXGBE_HKEY_MAX_INDEX * sizeof(uint32_t)]; /* Hash key. */
+struct ixgbe_rss_conf {
+	uint64_t types; /**< RSS hash types. */
+	uint32_t key_len; /**< Hash key length, 0 for default key. */
+	uint32_t queue_num; /**< Number of entries in queue. */
+	uint8_t key[IXGBE_HKEY_MAX_INDEX * sizeof(uint32_t)]; /**< Hash key. */
 	uint16_t queue[IXGBE_MAX_RX_QUEUE_NUM]; /**< Queues indices to use. */
 };
 

@@ -299,7 +301,7 @@ struct ixgbe_ethertype_table {
  */
 struct ixgbe_filter_info {
 	/* store the rss filter info */
-	struct ixgbe_rte_flow_rss_conf rss_info;
+	struct ixgbe_rss_conf rss_info;
 	/* shared EtherType (ETQF) slot table */
 	struct ixgbe_ethertype_table ethertype_table;
 	/* 1588 timestamping ETQF slot (valid when timesync_installed) */

@@ -738,12 +740,10 @@ void ixgbe_tm_conf_init(struct rte_eth_dev *dev);
 void ixgbe_tm_conf_uninit(struct rte_eth_dev *dev);
 int ixgbe_set_queue_rate_limit(struct rte_eth_dev *dev, uint16_t queue_idx,
 			       uint32_t tx_rate);
-int ixgbe_rss_conf_init(struct ixgbe_rte_flow_rss_conf *out,
-			const struct rte_flow_action_rss *in);
-int ixgbe_action_rss_same(const struct rte_flow_action_rss *comp,
-			  const struct rte_flow_action_rss *with);
+int ixgbe_rss_conf_init(struct ixgbe_rss_conf *out,
+		const struct rte_flow_action_rss *in);
 int ixgbe_config_rss_filter(struct ixgbe_adapter *adapter,
-		struct ixgbe_rte_flow_rss_conf *conf, bool add);
+		const struct ixgbe_rss_conf *conf, bool add);
 
 void ixgbe_dev_macsec_register_enable(struct rte_eth_dev *dev,
 		struct ixgbe_macsec_setting *macsec_setting);

index 98d0af6535c..aca3da5607a 100644
@@ -57,7 +57,7 @@ struct ixgbe_filter_ele_base {
 /* rss filter list structure */
 struct ixgbe_rss_conf_ele {
 	struct ixgbe_filter_ele_base base;
-	struct ixgbe_rte_flow_rss_conf filter_info;
+	struct ixgbe_rss_conf filter_info;
 };
 /* ixgbe_flow memory list structure */
 struct ixgbe_flow_mem {

@@ -140,7 +140,8 @@ ixgbe_flow_actions_check_rss(const struct ci_flow_actions *parsed_actions,
 	const struct rte_flow_action *action = parsed_actions->actions[0];
 	const struct rte_flow_action_rss *rss_act = action->conf;
 	struct rte_eth_dev_data *dev_data = param->driver_ctx;
-	const size_t rss_key_len = sizeof(((struct ixgbe_rte_flow_rss_conf *)0)->key);
+	const size_t rss_key_len = sizeof(((struct ixgbe_rss_conf *)0)->key);
+	const size_t rss_queue_max = RTE_DIM(((struct ixgbe_rss_conf *)0)->queue);
 	size_t q_idx, q;
 
 	/* check if queue list is not empty */

@@ -149,6 +150,11 @@ ixgbe_flow_actions_check_rss(const struct ci_flow_actions *parsed_actions,
 			RTE_FLOW_ERROR_TYPE_ACTION_CONF, rss_act,
 			"RSS queue list is empty");
 	}
+	if (rss_act->queue_num > rss_queue_max) {
+		return rte_flow_error_set(error, ENOTSUP,
+			RTE_FLOW_ERROR_TYPE_ACTION_CONF, rss_act,
+			"RSS queue list is too long");
+	}
 
 	/* check if each RSS queue is valid */
 	for (q_idx = 0; q_idx < rss_act->queue_num; q_idx++) {

@@ -185,7 +191,7 @@ static int
 ixgbe_parse_rss_filter(struct rte_eth_dev *dev,
 			const struct rte_flow_attr *attr,
 			const struct rte_flow_action actions[],
-			struct ixgbe_rte_flow_rss_conf *rss_conf,
+			struct ixgbe_rss_conf *rss_conf,
 			struct rte_flow_error *error)
 {
 	struct ci_flow_actions parsed_actions;

@@ -199,8 +205,8 @@ ixgbe_parse_rss_filter(struct rte_eth_dev *dev,
 		.check = ixgbe_flow_actions_check_rss,
 		.max_actions = 1,
 	};
+	const struct rte_flow_action_rss *rss_act;
 	int ret;
-	const struct rte_flow_action *action;
 
 	/* validate attributes */
 	ret = ci_flow_check_attr(attr, NULL, error);

@@ -211,12 +217,14 @@ ixgbe_parse_rss_filter(struct rte_eth_dev *dev,
 	ret = ci_flow_check_actions(actions, &ap_param, &parsed_actions, error);
 	if (ret)
 		return ret;
-	action = parsed_actions.actions[0];
+	rss_act = parsed_actions.actions[0]->conf;
 
-	if (ixgbe_rss_conf_init(rss_conf, action->conf))
-		return rte_flow_error_set(error, EINVAL,
-				RTE_FLOW_ERROR_TYPE_ACTION, NULL,
+	ret = ixgbe_rss_conf_init(rss_conf, rss_act);
+	if (ret) {
+		return rte_flow_error_set(error, -ret,
+				RTE_FLOW_ERROR_TYPE_ACTION_CONF, rss_act,
 				"RSS context initialization failure");
+	}
 
 	return 0;
 }

@@ -230,7 +238,7 @@ ixgbe_clear_rss_filter(struct rte_eth_dev *dev)
 	struct ixgbe_filter_info *filter_info =
 		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
 
-	if (filter_info->rss_info.conf.queue_num)
+	if (filter_info->rss_info.queue_num)
 		ixgbe_config_rss_filter(adapter, &filter_info->rss_info, FALSE);
 }
 

@@ -275,7 +283,7 @@ ixgbe_flow_create(struct rte_eth_dev *dev,
 {
 	int ret;
 	struct ixgbe_adapter *adapter = IXGBE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
-	struct ixgbe_rte_flow_rss_conf rss_conf;
+	struct ixgbe_rss_conf rss_conf = {0};
 	struct rte_flow *flow = NULL;
 	struct ixgbe_rss_conf_ele *rss_filter_ptr;
 	struct ixgbe_flow_mem *ixgbe_flow_mem_ptr;

@@ -303,7 +311,6 @@ ixgbe_flow_create(struct rte_eth_dev *dev,
 	TAILQ_INSERT_TAIL(&adapter->flow_list,
 				&ixgbe_flow_mem_ptr->base, entries);
 
-	memset(&rss_conf, 0, sizeof(struct ixgbe_rte_flow_rss_conf));
 	ret = ixgbe_parse_rss_filter(dev, attr,
 					actions, &rss_conf, error);
 	if (!ret) {

@@ -319,8 +326,7 @@ ixgbe_flow_create(struct rte_eth_dev *dev,
 			rte_free(rss_filter_ptr);
 			goto out;
 		}
-		ixgbe_rss_conf_init(&rss_filter_ptr->filter_info,
-				    &rss_conf.conf);
+		rss_filter_ptr->filter_info = rss_conf;
 		flow->rule = rss_filter_ptr;
 		flow->filter_type = RTE_ETH_FILTER_HASH;
 		return flow;

@@ -350,7 +356,7 @@ ixgbe_flow_validate(struct rte_eth_dev *dev,
 		struct rte_flow_error *error)
 {
 	struct ixgbe_adapter *ad = IXGBE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
-	struct ixgbe_rte_flow_rss_conf rss_conf;
+	struct ixgbe_rss_conf rss_conf = {0};
 	int ret;
 
 	/* try the new flow engine first */

@@ -360,7 +366,6 @@ ixgbe_flow_validate(struct rte_eth_dev *dev,
 
 	/* fall back to legacy engines */
 
-	memset(&rss_conf, 0, sizeof(struct ixgbe_rte_flow_rss_conf));
 	ret = ixgbe_parse_rss_filter(dev, attr,
 					actions, &rss_conf, error);
 

@@ -488,7 +493,7 @@ ixgbe_flow_rule_size(const struct rte_flow *flow)
 	case RTE_ETH_FILTER_L2_TUNNEL:
 		return sizeof(struct ixgbe_l2_tunnel_conf);
 	case RTE_ETH_FILTER_HASH:
-		return sizeof(struct ixgbe_rte_flow_rss_conf);
+		return sizeof(struct ixgbe_rss_conf);
 	default:
 		return 0;
 	}

114 lines not on this page · raw message

index 2a1819c0f3e..52a54117b78 100644
@@ -344,7 +344,6 @@ static int ixgbe_dev_udp_tunnel_port_add(struct rte_eth_dev *dev,
 					 struct rte_eth_udp_tunnel *udp_tunnel);
 static int ixgbe_dev_udp_tunnel_port_del(struct rte_eth_dev *dev,
 					 struct rte_eth_udp_tunnel *udp_tunnel);
-static int ixgbe_filter_restore(struct rte_eth_dev *dev);
 static void ixgbe_l2_tunnel_conf(struct rte_eth_dev *dev);
 static int ixgbe_wait_for_link_up(struct ixgbe_hw *hw);
 static int devarg_handle_int(__rte_unused const char *key, const char *value,

@@ -1270,9 +1269,6 @@ eth_ixgbe_dev_init(struct rte_eth_dev *eth_dev, void *init_params __rte_unused)
 	if (ret)
 		goto err_l2_tn_filter_init;
 
-	/* initialize flow filter lists */
-	ixgbe_filterlist_init(eth_dev);
-
 	/* initialize bandwidth configuration info */
 	memset(bw_conf, 0, sizeof(struct ixgbe_bw_conf));
 

@@ -2759,7 +2755,6 @@ ixgbe_dev_start(struct rte_eth_dev *dev)
 	/* resume enabled intr since hw reset */
 	ixgbe_enable_intr(dev);
 	ixgbe_l2_tunnel_conf(dev);
-	ixgbe_filter_restore(dev);
 
 	if (tm_conf->root && !tm_conf->committed)
 		PMD_DRV_LOG(WARNING,

@@ -3016,9 +3011,6 @@ ixgbe_dev_close(struct rte_eth_dev *dev)
 	/* uninitialize PF if max_vfs not zero */
 	ixgbe_pf_host_uninit(dev);
 
-	/* clear all the filters list */
-	ixgbe_filterlist_flush(dev);
-
 	/* Remove all Traffic Manager configuration */
 	ixgbe_tm_conf_uninit(dev);
 

@@ -7821,28 +7813,6 @@ int ixgbe_enable_sec_tx_path_generic(struct ixgbe_hw *hw)
 	return IXGBE_SUCCESS;
 }
 
-/* restore rss filter */
-static inline void
-ixgbe_rss_filter_restore(struct rte_eth_dev *dev)
-{
-	struct ixgbe_adapter *adapter =
-		IXGBE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
-	struct ixgbe_filter_info *filter_info =
-		IXGBE_DEV_PRIVATE_TO_FILTER_INFO(adapter);
-
-	if (filter_info->rss_info.queue_num)
-		ixgbe_config_rss_filter(adapter,
-			&filter_info->rss_info, TRUE);
-}
-
-static int
-ixgbe_filter_restore(struct rte_eth_dev *dev)
-{
-	ixgbe_rss_filter_restore(dev);
-
-	return 0;
-}
-
 static void
 ixgbe_l2_tunnel_conf(struct rte_eth_dev *dev)
 {

index d769e375269..a53b6887b76 100644
@@ -300,8 +300,6 @@ struct ixgbe_ethertype_table {
  * Structure to store filters' info.
  */
 struct ixgbe_filter_info {
-	/* store the rss filter info */
-	struct ixgbe_rss_conf rss_info;
 	/* shared EtherType (ETQF) slot table */
 	struct ixgbe_ethertype_table ethertype_table;
 	/* 1588 timestamping ETQF slot (valid when timesync_installed) */

@@ -318,10 +316,9 @@ struct ixgbe_l2_tn_info {
 	uint16_t e_tag_ether_type; /* ether type for e-tag */
 };
 
+/* no driver-specific data needed */
 struct rte_flow {
 	struct ci_flow flow;
-	enum rte_filter_type filter_type;
-	void *rule;
 };
 
 struct ixgbe_macsec_setting {

@@ -429,9 +426,6 @@ struct ixgbe_tm_conf {
 	bool committed;
 };
 
-struct ixgbe_filter_ele_base;
-TAILQ_HEAD(ixgbe_filter_ele_list, ixgbe_filter_ele_base);
-
 /*
  * Structure to store private data for each driver instance (for each port).
  */

@@ -453,7 +447,6 @@ struct ixgbe_adapter {
 	struct ixgbe_bypass_info    bps;
 #endif /* RTE_LIBRTE_IXGBE_BYPASS */
 	struct ixgbe_filter_info    filter;
-	struct ixgbe_filter_ele_list flow_list;
 	struct ixgbe_l2_tn_info     l2_tn;
 	struct ixgbe_bw_conf        bw_conf;
 	struct ixgbe_ipsec          ipsec;

@@ -669,8 +662,6 @@ ixgbe_e_tag_filter_add(struct ixgbe_adapter *adapter,
 int
 ixgbe_e_tag_filter_del(struct ixgbe_adapter *adapter,
 		       struct ixgbe_l2_tunnel_conf *l2_tunnel);
-void ixgbe_filterlist_init(struct rte_eth_dev *dev);
-void ixgbe_filterlist_flush(struct rte_eth_dev *dev);
 /*
  * Flow director function prototypes
  */

@@ -742,8 +733,9 @@ int ixgbe_set_queue_rate_limit(struct rte_eth_dev *dev, uint16_t queue_idx,
 			       uint32_t tx_rate);
 int ixgbe_rss_conf_init(struct ixgbe_rss_conf *out,
 		const struct rte_flow_action_rss *in);
-int ixgbe_config_rss_filter(struct ixgbe_adapter *adapter,
-		const struct ixgbe_rss_conf *conf, bool add);
+void ixgbe_hw_rss_filter_program(struct ixgbe_hw *hw,
+		const struct ixgbe_rss_conf *conf);
+void ixgbe_hw_rss_filter_clear(struct ixgbe_hw *hw);
 
 void ixgbe_dev_macsec_register_enable(struct rte_eth_dev *dev,
 		struct ixgbe_macsec_setting *macsec_setting);

484 lines not on this page · raw message

index 256e0478f58..959b2c95947 100644
@@ -22,5 +22,6 @@ extern const struct ci_flow_engine ixgbe_ntuple_flow_engine;
 extern const struct ci_flow_engine ixgbe_security_flow_engine;
 extern const struct ci_flow_engine ixgbe_fdir_flow_engine;
 extern const struct ci_flow_engine ixgbe_fdir_tunnel_flow_engine;
+extern const struct ci_flow_engine ixgbe_hash_flow_engine;
 
 #endif /*  _IXGBE_FLOW_H_ */

216 lines not on this page · raw message

70 lines not on this page · raw message

index 52a54117b78..5200fab866d 100644
@@ -3914,6 +3914,9 @@ ixgbe_dev_info_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
 	dev_info->reta_size = ixgbe_reta_size_get(hw->mac.type);
 	dev_info->flow_type_rss_offloads = IXGBE_RSS_OFFLOAD_ALL;
 
+	/* rte_flow rules are kept across dev_stop/dev_start and replayed on start */
+	dev_info->dev_capa |= RTE_ETH_DEV_CAPA_FLOW_RULE_KEEP;
+
 	dev_info->speed_capa = RTE_ETH_LINK_SPEED_1G | RTE_ETH_LINK_SPEED_10G;
 	if (hw->device_id == IXGBE_DEV_ID_X550EM_A_1G_T ||
 			hw->device_id == IXGBE_DEV_ID_X550EM_A_1G_T_L)

index 41d5586403b..92aa0e39554 100644
@@ -42,6 +42,9 @@
 #include "i40e_regs.h"
 #include "rte_pmd_i40e.h"
 #include "i40e_hash.h"
+#include "i40e_flow.h"
+
+#include "../common/flow_engine.h"
 
 #define ETH_I40E_FLOATING_VEB_ARG	"enable_floating_veb"
 #define ETH_I40E_FLOATING_VEB_LIST_ARG	"floating_veb_list"

@@ -1838,6 +1841,12 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
 	if (ret < 0)
 		goto err_init_fdir_filter_list;
 
+	/* initialize flow engine configuration */
+	ret = ci_flow_engine_conf_init(&pf->flow_engine_conf,
+			&i40e_flow_engine_list, dev->data);
+	if (ret < 0)
+		goto err_flow_engine_conf_init;
+
 	/* initialize queue region configuration */
 	i40e_init_queue_region_conf(dev);
 

@@ -1846,6 +1855,12 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
 
 	return 0;
 
+err_flow_engine_conf_init:
+	rte_free(pf->fdir.fdir_flow_pool.bitmap);
+	rte_free(pf->fdir.fdir_flow_pool.pool);
+	rte_free(pf->fdir.fdir_filter_array);
+	rte_free(pf->fdir.hash_map);
+	rte_hash_free(pf->fdir.hash_table);
 err_init_fdir_filter_list:
 	rte_hash_free(pf->tunnel.hash_table);
 	rte_free(pf->tunnel.hash_map);

@@ -2613,6 +2628,8 @@ i40e_dev_start(struct rte_eth_dev *dev)
 	/* Set the max frame size to HW*/
 	i40e_aq_set_mac_config(hw, max_frame_size, TRUE, false, 0, NULL);
 
+	ci_flow_replay(&pf->flow_engine_conf);
+
 	return I40E_SUCCESS;
 
 tx_err:

@@ -2715,6 +2732,10 @@ i40e_dev_close(struct rte_eth_dev *dev)
 
 	ret = i40e_dev_stop(dev);
 
+	/* free the flows and reset flow config */
+	ci_flow_cleanup(&pf->flow_engine_conf);
+	ci_flow_engine_conf_reset(&pf->flow_engine_conf);
+
 	i40e_dev_free_queues(dev);
 
 	/* Disable interrupt */

index 1e64a2d2800..16b67268f7f 100644
@@ -21,6 +21,8 @@
 #include "base/i40e_type.h"
 #include "base/virtchnl.h"
 
+#include "../common/flow_engine.h"
+
 #define I40E_AQ_LEN               32
 #define I40E_AQ_BUF_SZ            4096
 /* Number of queues per TC should be one of 1, 2, 4, 8, 16, 32, 64 */

@@ -278,6 +280,7 @@ enum i40e_flxpld_layer_idx {
  * Struct to store flow created.
  */
 struct rte_flow {
+	struct ci_flow base;
 	TAILQ_ENTRY(rte_flow) node;
 	enum rte_filter_type filter_type;
 	void *rule;

@@ -1182,6 +1185,8 @@ struct i40e_pf {
 	/* The floating enable flag for the specific VF */
 	bool floating_veb_list[I40E_MAX_VF];
 	struct i40e_flow_list flow_list;
+	/* flow engine configuration */
+	struct ci_flow_engine_conf flow_engine_conf;
 	bool mpls_replace_flag;  /* 1 - MPLS filter replace is done */
 	bool gtp_replace_flag;   /* 1 - GTP-C/U filter replace is done */
 	bool qinq_replace_flag;  /* QINQ filter replace is done */

107 lines not on this page · raw message

new file mode 100644
index 00000000000..c9588686619
@@ -0,0 +1,12 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Intel Corporation
+ */
+
+#ifndef _I40E_FLOW_H_
+#define _I40E_FLOW_H_
+
+#include "../common/flow_engine.h"
+
+extern const struct ci_flow_engine_list i40e_flow_engine_list;
+
+#endif /* _I40E_FLOW_H_ */

index 92aa0e39554..94bf6ee392a 100644
@@ -392,12 +392,6 @@ static int i40e_set_default_mac_addr(struct rte_eth_dev *dev,
 
 static int i40e_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu);
 
-static int i40e_ethertype_filter_convert(
-	const struct rte_eth_ethertype_filter *input,
-	struct i40e_ethertype_filter *filter);
-static int i40e_sw_ethertype_filter_insert(struct i40e_pf *pf,
-				   struct i40e_ethertype_filter *filter);
-
 static int i40e_tunnel_filter_convert(
 	struct i40e_aqc_cloud_filters_element_bb *cld_filter,
 	struct i40e_tunnel_filter *tunnel_filter);

@@ -405,7 +399,6 @@ static int i40e_sw_tunnel_filter_insert(struct i40e_pf *pf,
 				struct i40e_tunnel_filter *tunnel_filter);
 static int i40e_cloud_filter_qinq_create(struct i40e_pf *pf);
 
-static void i40e_ethertype_filter_restore(struct i40e_pf *pf);
 static void i40e_tunnel_filter_restore(struct i40e_pf *pf);
 static void i40e_filter_restore(struct i40e_pf *pf);
 static void i40e_notify_all_vfs_link_status(struct rte_eth_dev *dev);

@@ -1003,51 +996,6 @@ config_floating_veb(struct rte_eth_dev *dev)
 #define I40E_L2_TAGS_S_TAG_SHIFT 1
 #define I40E_L2_TAGS_S_TAG_MASK I40E_MASK(0x1, I40E_L2_TAGS_S_TAG_SHIFT)
 
-static int
-i40e_init_ethtype_filter_list(struct rte_eth_dev *dev)
-{
-	struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
-	struct i40e_ethertype_rule *ethertype_rule = &pf->ethertype;
-	char ethertype_hash_name[RTE_HASH_NAMESIZE];
-	int ret;
-
-	struct rte_hash_parameters ethertype_hash_params = {
-		.name = ethertype_hash_name,
-		.entries = I40E_MAX_ETHERTYPE_FILTER_NUM,
-		.key_len = sizeof(struct i40e_ethertype_filter_input),
-		.hash_func = rte_hash_crc,
-		.hash_func_init_val = 0,
-		.socket_id = rte_socket_id(),
-	};
-
-	/* Initialize ethertype filter rule list and hash */
-	TAILQ_INIT(&ethertype_rule->ethertype_list);
-	snprintf(ethertype_hash_name, RTE_HASH_NAMESIZE,
-		 "ethertype_%s", dev->device->name);
-	ethertype_rule->hash_table = rte_hash_create(&ethertype_hash_params);
-	if (!ethertype_rule->hash_table) {
-		PMD_INIT_LOG(ERR, "Failed to create ethertype hash table!");
-		return -EINVAL;
-	}
-	ethertype_rule->hash_map = rte_zmalloc("i40e_ethertype_hash_map",
-				       sizeof(struct i40e_ethertype_filter *) *
-				       I40E_MAX_ETHERTYPE_FILTER_NUM,
-				       0);
-	if (!ethertype_rule->hash_map) {
-		PMD_INIT_LOG(ERR,
-			     "Failed to allocate memory for ethertype hash map!");
-		ret = -ENOMEM;
-		goto err_ethertype_hash_map_alloc;
-	}
-
-	return 0;
-
-err_ethertype_hash_map_alloc:
-	rte_hash_free(ethertype_rule->hash_table);
-
-	return ret;
-}
-
 static int
 i40e_init_tunnel_filter_list(struct rte_eth_dev *dev)
 {

@@ -1831,9 +1779,6 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
 	/* Initialize the filter invalidation configuration */
 	i40e_init_filter_invalidation(pf);
 
-	ret = i40e_init_ethtype_filter_list(dev);
-	if (ret < 0)
-		goto err_init_ethtype_filter_list;
 	ret = i40e_init_tunnel_filter_list(dev);
 	if (ret < 0)
 		goto err_init_tunnel_filter_list;

@@ -1865,9 +1810,6 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
 	rte_hash_free(pf->tunnel.hash_table);
 	rte_free(pf->tunnel.hash_map);
 err_init_tunnel_filter_list:
-	rte_hash_free(pf->ethertype.hash_table);
-	rte_free(pf->ethertype.hash_map);
-err_init_ethtype_filter_list:
 	rte_intr_callback_unregister(intr_handle,
 		i40e_dev_interrupt_handler, dev);
 	rte_free(dev->data->mac_addrs);

@@ -1890,24 +1832,6 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
 	return ret;
 }
 
-static void
-i40e_rm_ethtype_filter_list(struct i40e_pf *pf)
-{
-	struct i40e_ethertype_filter *p_ethertype;
-	struct i40e_ethertype_rule *ethertype_rule;
-
-	ethertype_rule = &pf->ethertype;
-	/* Remove all ethertype filter rules and hash */
-	rte_free(ethertype_rule->hash_map);
-	rte_hash_free(ethertype_rule->hash_table);
-
-	while ((p_ethertype = TAILQ_FIRST(&ethertype_rule->ethertype_list))) {
-		TAILQ_REMOVE(&ethertype_rule->ethertype_list,
-			     p_ethertype, rules);
-		rte_free(p_ethertype);
-	}
-}
-
 static void
 i40e_rm_tunnel_filter_list(struct i40e_pf *pf)
 {

@@ -2805,7 +2729,6 @@ i40e_dev_close(struct rte_eth_dev *dev)
 		i40e_msec_delay(500);
 	} while (retries++ < 5);
 
-	i40e_rm_ethtype_filter_list(pf);
 	i40e_rm_tunnel_filter_list(pf);
 	i40e_rm_fdir_filter_list(pf);
 

@@ -9891,130 +9814,16 @@ i40e_set_hash_inset(struct i40e_hw *hw, uint64_t input_set,
 	return 0;
 }
 
-/* Convert ethertype filter structure */
-static int
-i40e_ethertype_filter_convert(const struct rte_eth_ethertype_filter *input,
-			      struct i40e_ethertype_filter *filter)
-{
-	memcpy(&filter->input.mac_addr, &input->mac_addr,
-		RTE_ETHER_ADDR_LEN);
-	filter->input.ether_type = input->ether_type;
-	filter->flags = input->flags;
-	filter->queue = input->queue;
-
-	return 0;
-}
-
-/* Check if there exists the ethertype filter */
-struct i40e_ethertype_filter *
-i40e_sw_ethertype_filter_lookup(struct i40e_ethertype_rule *ethertype_rule,
-				const struct i40e_ethertype_filter_input *input)
-{
-	int ret;
-
-	ret = rte_hash_lookup(ethertype_rule->hash_table, (const void *)input);
-	if (ret < 0)
-		return NULL;
-
-	return ethertype_rule->hash_map[ret];
-}
-
-/* Add ethertype filter in SW list */
-static int
-i40e_sw_ethertype_filter_insert(struct i40e_pf *pf,
-				struct i40e_ethertype_filter *filter)
-{
-	struct i40e_ethertype_rule *rule = &pf->ethertype;
-	int ret;
-
-	ret = rte_hash_add_key(rule->hash_table, &filter->input);
-	if (ret < 0) {
-		PMD_DRV_LOG(ERR,
-			    "Failed to insert ethertype filter"
-			    " to hash table %d!",
-			    ret);
-		return ret;
-	}
-	rule->hash_map[ret] = filter;
-
-	TAILQ_INSERT_TAIL(&rule->ethertype_list, filter, rules);
-
-	return 0;
-}
-
-/* Delete ethertype filter in SW list */
 int
-i40e_sw_ethertype_filter_del(struct i40e_pf *pf,
-			     struct i40e_ethertype_filter_input *input)
-{
-	struct i40e_ethertype_rule *rule = &pf->ethertype;
-	struct i40e_ethertype_filter *filter;
-	int ret;
-
-	ret = rte_hash_del_key(rule->hash_table, input);
-	if (ret < 0) {
-		PMD_DRV_LOG(ERR,
-			    "Failed to delete ethertype filter"
-			    " to hash table %d!",
-			    ret);
-		return ret;
-	}
-	filter = rule->hash_map[ret];
-	rule->hash_map[ret] = NULL;
-
-	TAILQ_REMOVE(&rule->ethertype_list, filter, rules);
-	rte_free(filter);
-
-	return 0;
-}
-
-/*
- * Configure ethertype filter, which can director packet by filtering
- * with mac address and ether_type or only ether_type
- */
-int
-i40e_ethertype_filter_set(struct i40e_pf *pf,
+i40e_ethertype_filter_program(struct i40e_pf *pf,
 			struct rte_eth_ethertype_filter *filter,
 			bool add)
 {
 	struct i40e_hw *hw = I40E_PF_TO_HW(pf);
-	struct i40e_ethertype_rule *ethertype_rule = &pf->ethertype;
-	struct i40e_ethertype_filter *ethertype_filter, *node;
-	struct i40e_ethertype_filter check_filter;
 	struct i40e_control_filter_stats stats;
 	uint16_t flags = 0;
 	int ret;
 
-	if (filter->queue >= pf->dev_data->nb_rx_queues) {
-		PMD_DRV_LOG(ERR, "Invalid queue ID");
-		return -EINVAL;
-	}
-	if (filter->ether_type == RTE_ETHER_TYPE_IPV4 ||
-		filter->ether_type == RTE_ETHER_TYPE_IPV6) {
-		PMD_DRV_LOG(ERR,
-			"unsupported ether_type(0x%04x) in control packet filter.",
-			filter->ether_type);
-		return -EINVAL;
-	}
-	if (filter->ether_type == RTE_ETHER_TYPE_VLAN)
-		PMD_DRV_LOG(WARNING,
-			"filter vlan ether_type in first tag is not supported.");
-
-	/* Check if there is the filter in SW list */
-	memset(&check_filter, 0, sizeof(check_filter));
-	i40e_ethertype_filter_convert(filter, &check_filter);
-	node = i40e_sw_ethertype_filter_lookup(ethertype_rule,
-					       &check_filter.input);
-	if (add && node) {
-		PMD_DRV_LOG(ERR, "Conflict with existing ethertype rules!");
-		return -EINVAL;
-	}
-
-	if (!add && !node) {
-		PMD_DRV_LOG(ERR, "There's no corresponding ethertype filter!");
-		return -EINVAL;
-	}
-
 	if (!(filter->flags & RTE_ETHTYPE_FLAGS_MAC))
 		flags |= I40E_AQC_ADD_CONTROL_PACKET_FLAGS_IGNORE_MAC;
 	if (filter->flags & RTE_ETHTYPE_FLAGS_DROP)

@@ -10035,25 +9844,7 @@ i40e_ethertype_filter_set(struct i40e_pf *pf,
 	if (ret < 0)
 		return -ENOSYS;
 
-	/* Add or delete a filter in SW list */
-	if (add) {
-		ethertype_filter = rte_zmalloc("ethertype_filter",
-				       sizeof(*ethertype_filter), 0);
-		if (ethertype_filter == NULL) {
-			PMD_DRV_LOG(ERR, "Failed to alloc memory.");
-			return -ENOMEM;
-		}
-
-		memcpy(ethertype_filter, &check_filter,
-			   sizeof(check_filter));
-		ret = i40e_sw_ethertype_filter_insert(pf, ethertype_filter);
-		if (ret < 0)
-			rte_free(ethertype_filter);
-	} else {
-		ret = i40e_sw_ethertype_filter_del(pf, &node->input);
-	}
-
-	return ret;
+	return 0;
 }
 
 static int

@@ -11624,52 +11415,6 @@ i40e_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu __rte_unused)
 	return 0;
 }
 
-/* Restore ethertype filter */
-static void
-i40e_ethertype_filter_restore(struct i40e_pf *pf)
-{
-	struct i40e_hw *hw = I40E_PF_TO_HW(pf);
-	struct i40e_ethertype_filter_list
-		*ethertype_list = &pf->ethertype.ethertype_list;
-	struct i40e_ethertype_filter *f;
-	struct i40e_control_filter_stats stats;
-	enum i40e_status_code ret;
-	uint16_t flags;
-	bool stats_valid = false;
-
-	TAILQ_FOREACH(f, ethertype_list, rules) {
-		flags = 0;
-		if (!(f->flags & RTE_ETHTYPE_FLAGS_MAC))
-			flags |= I40E_AQC_ADD_CONTROL_PACKET_FLAGS_IGNORE_MAC;
-		if (f->flags & RTE_ETHTYPE_FLAGS_DROP)
-			flags |= I40E_AQC_ADD_CONTROL_PACKET_FLAGS_DROP;
-		flags |= I40E_AQC_ADD_CONTROL_PACKET_FLAGS_TO_QUEUE;
-
-		ret = i40e_aq_add_rem_control_packet_filter(hw,
-					    f->input.mac_addr.addr_bytes,
-					    f->input.ether_type,
-					    flags, pf->main_vsi->seid,
-					    f->queue, 1, &stats, NULL);
-		if (ret != I40E_SUCCESS) {
-			PMD_DRV_LOG(ERR,
-				    "Failed to restore ethertype filter, ether_type=0x%04x, queue=%u, vsi_seid=%u, err %d",
-				    f->input.ether_type, f->queue,
-				    pf->main_vsi->seid, ret);
-			continue;
-		}
-
-		stats_valid = true;
-	}
-
-	if (stats_valid) {
-		PMD_DRV_LOG(INFO, "Ethertype filter:"
-			    " mac_etype_used = %u, etype_used = %u,"
-			    " mac_etype_free = %u, etype_free = %u",
-			    stats.mac_etype_used, stats.etype_used,
-			    stats.mac_etype_free, stats.etype_free);
-	}
-}
-
 /* Restore tunnel filter */
 static void
 i40e_tunnel_filter_restore(struct i40e_pf *pf)

@@ -11728,7 +11473,6 @@ i40e_tunnel_filter_restore(struct i40e_pf *pf)
 static void
 i40e_filter_restore(struct i40e_pf *pf)
 {
-	i40e_ethertype_filter_restore(pf);
 	i40e_tunnel_filter_restore(pf);
 	i40e_fdir_filter_restore(pf);
 	(void)i40e_hash_filter_restore(pf);

index 16b67268f7f..f674f7995d8 100644
@@ -805,27 +805,6 @@ struct i40e_fdir_info {
 /* Ethertype filter number HW supports */
 #define I40E_MAX_ETHERTYPE_FILTER_NUM 768
 
-/* Ethertype filter struct */
-struct i40e_ethertype_filter_input {
-	struct rte_ether_addr mac_addr;   /* Mac address to match */
-	uint16_t ether_type;          /* Ether type to match */
-};
-
-struct i40e_ethertype_filter {
-	TAILQ_ENTRY(i40e_ethertype_filter) rules;
-	struct i40e_ethertype_filter_input input;
-	uint16_t flags;              /* Flags from RTE_ETHTYPE_FLAGS_* */
-	uint16_t queue;              /* Queue assigned to when match */
-};
-
-TAILQ_HEAD(i40e_ethertype_filter_list, i40e_ethertype_filter);
-
-struct i40e_ethertype_rule {
-	struct i40e_ethertype_filter_list ethertype_list;
-	struct i40e_ethertype_filter  **hash_map;
-	struct rte_hash *hash_table;
-};
-
 /* queue region info */
 struct i40e_queue_region_info {
 	/* the region id for this configuration */

@@ -1176,7 +1155,6 @@ struct i40e_pf {
 	struct i40e_vmdq_info *vmdq;
 
 	struct i40e_fdir_info fdir; /* flow director info */
-	struct i40e_ethertype_rule ethertype; /* Ethertype filter rule */
 	struct i40e_tunnel_rule tunnel; /* Tunnel filter rule */
 	struct i40e_rss_conf_list rss_config_list; /* RSS rule list */
 	struct i40e_queue_regions queue_region; /* queue region info */

@@ -1325,7 +1303,6 @@ extern const struct rte_flow_ops i40e_flow_ops;
 
 struct i40e_filter_ctx {
 	union {
-		struct rte_eth_ethertype_filter ethertype_filter;
 		struct i40e_fdir_filter_conf fdir_filter;
 		struct i40e_tunnel_filter_conf consistent_tunnel_filter;
 		struct i40e_rte_flow_rss_conf rss_conf;

@@ -1407,11 +1384,6 @@ int i40e_rx_burst_mode_get(struct rte_eth_dev *dev, uint16_t queue_id,
 			   struct rte_eth_burst_mode *mode);
 int i40e_tx_burst_mode_get(struct rte_eth_dev *dev, uint16_t queue_id,
 			   struct rte_eth_burst_mode *mode);
-struct i40e_ethertype_filter *
-i40e_sw_ethertype_filter_lookup(struct i40e_ethertype_rule *ethertype_rule,
-			const struct i40e_ethertype_filter_input *input);
-int i40e_sw_ethertype_filter_del(struct i40e_pf *pf,
-				 struct i40e_ethertype_filter_input *input);
 int i40e_sw_fdir_filter_del(struct i40e_pf *pf,
 			    struct i40e_fdir_input *input);
 struct i40e_tunnel_filter *

@@ -1420,7 +1392,7 @@ i40e_sw_tunnel_filter_lookup(struct i40e_tunnel_rule *tunnel_rule,
 int i40e_sw_tunnel_filter_del(struct i40e_pf *pf,
 			      struct i40e_tunnel_filter_input *input);
 uint64_t i40e_get_default_input_set(uint16_t pctype);
-int i40e_ethertype_filter_set(struct i40e_pf *pf,
+int i40e_ethertype_filter_program(struct i40e_pf *pf,
 			      struct rte_eth_ethertype_filter *filter,
 			      bool add);
 struct rte_flow *

398 lines not on this page · raw message

index c9588686619..11d13a76fe9 100644
@@ -7,6 +7,10 @@
 
 #include "../common/flow_engine.h"
 
+int i40e_get_outer_vlan(struct i40e_pf *pf, uint16_t *tpid);
+
 extern const struct ci_flow_engine_list i40e_flow_engine_list;
 
+extern const struct ci_flow_engine i40e_flow_engine_ethertype;
+
 #endif /* _I40E_FLOW_H_ */

351 lines not on this page · raw message

index 94bf6ee392a..dd42b61c679 100644
@@ -1041,129 +1041,6 @@ i40e_init_tunnel_filter_list(struct rte_eth_dev *dev)
 	return ret;
 }
 
-static int
-i40e_init_fdir_filter_list(struct rte_eth_dev *dev)
-{
-	struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
-	struct i40e_hw *hw = I40E_PF_TO_HW(pf);
-	struct i40e_fdir_info *fdir_info = &pf->fdir;
-	char fdir_hash_name[RTE_HASH_NAMESIZE];
-	uint32_t alloc = hw->func_caps.fd_filters_guaranteed;
-	uint32_t best = hw->func_caps.fd_filters_best_effort;
-	enum i40e_filter_pctype pctype;
-	struct rte_bitmap *bmp = NULL;
-	uint32_t bmp_size;
-	void *mem = NULL;
-	uint32_t i = 0;
-	int ret;
-
-	struct rte_hash_parameters fdir_hash_params = {
-		.name = fdir_hash_name,
-		.entries = I40E_MAX_FDIR_FILTER_NUM,
-		.key_len = sizeof(struct i40e_fdir_input),
-		.hash_func = rte_hash_crc,
-		.hash_func_init_val = 0,
-		.socket_id = rte_socket_id(),
-	};
-
-	/* Initialize flow director filter rule list and hash */
-	TAILQ_INIT(&fdir_info->fdir_list);
-	snprintf(fdir_hash_name, RTE_HASH_NAMESIZE,
-		 "fdir_%s", dev->device->name);
-	fdir_info->hash_table = rte_hash_create(&fdir_hash_params);
-	if (!fdir_info->hash_table) {
-		PMD_INIT_LOG(ERR, "Failed to create fdir hash table!");
-		return -EINVAL;
-	}
-
-	fdir_info->hash_map = rte_zmalloc("i40e_fdir_hash_map",
-					  sizeof(struct i40e_fdir_filter *) *
-					  I40E_MAX_FDIR_FILTER_NUM,
-					  0);
-	if (!fdir_info->hash_map) {
-		PMD_INIT_LOG(ERR,
-			     "Failed to allocate memory for fdir hash map!");
-		ret = -ENOMEM;
-		goto err_fdir_hash_map_alloc;
-	}
-
-	fdir_info->fdir_filter_array = rte_zmalloc("fdir_filter",
-			sizeof(struct i40e_fdir_filter) *
-			I40E_MAX_FDIR_FILTER_NUM,
-			0);
-
-	if (!fdir_info->fdir_filter_array) {
-		PMD_INIT_LOG(ERR,
-			     "Failed to allocate memory for fdir filter array!");
-		ret = -ENOMEM;
-		goto err_fdir_filter_array_alloc;
-	}
-
-	for (pctype = I40E_FILTER_PCTYPE_NONF_IPV4_UDP;
-	     pctype <= I40E_FILTER_PCTYPE_L2_PAYLOAD; pctype++)
-		pf->fdir.flow_count[pctype] = 0;
-
-	fdir_info->fdir_space_size = alloc + best;
-	fdir_info->fdir_actual_cnt = 0;
-	fdir_info->fdir_guarantee_total_space = alloc;
-	fdir_info->fdir_guarantee_free_space =
-		fdir_info->fdir_guarantee_total_space;
-
-	PMD_DRV_LOG(INFO, "FDIR guarantee space: %u, best_effort space %u.", alloc, best);
-
-	fdir_info->fdir_flow_pool.pool =
-			rte_zmalloc("i40e_fdir_entry",
-				sizeof(struct i40e_fdir_entry) *
-				fdir_info->fdir_space_size,
-				0);
-
-	if (!fdir_info->fdir_flow_pool.pool) {
-		PMD_INIT_LOG(ERR,
-			     "Failed to allocate memory for bitmap flow!");
-		ret = -ENOMEM;
-		goto err_fdir_bitmap_flow_alloc;
-	}
-
-	for (i = 0; i < fdir_info->fdir_space_size; i++)
-		fdir_info->fdir_flow_pool.pool[i].idx = i;
-
-	bmp_size =
-		rte_bitmap_get_memory_footprint(fdir_info->fdir_space_size);
-	mem = rte_zmalloc("fdir_bmap", bmp_size, RTE_CACHE_LINE_SIZE);
-	if (mem == NULL) {
-		PMD_INIT_LOG(ERR,
-			     "Failed to allocate memory for fdir bitmap!");
-		ret = -ENOMEM;
-		goto err_fdir_mem_alloc;
-	}
-	bmp = rte_bitmap_init(fdir_info->fdir_space_size, mem, bmp_size);
-	if (bmp == NULL) {
-		PMD_INIT_LOG(ERR,
-			     "Failed to initialization fdir bitmap!");
-		ret = -ENOMEM;
-		goto err_fdir_bmp_alloc;
-	}
-	for (i = 0; i < fdir_info->fdir_space_size; i++)
-		rte_bitmap_set(bmp, i);
-
-	fdir_info->fdir_flow_pool.bitmap = bmp;
-
-	return 0;
-
-err_fdir_bmp_alloc:
-	rte_free(mem);
-err_fdir_mem_alloc:
-	rte_free(fdir_info->fdir_flow_pool.pool);
-err_fdir_bitmap_flow_alloc:
-	rte_free(fdir_info->fdir_filter_array);
-err_fdir_filter_array_alloc:
-	rte_free(fdir_info->hash_map);
-err_fdir_hash_map_alloc:
-	rte_hash_free(fdir_info->hash_table);
-
-	return ret;
-}
-
 static void
 i40e_init_customized_info(struct i40e_pf *pf)
 {

@@ -1782,9 +1659,9 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
 	ret = i40e_init_tunnel_filter_list(dev);
 	if (ret < 0)
 		goto err_init_tunnel_filter_list;
-	ret = i40e_init_fdir_filter_list(dev);
+	ret = i40e_fdir_flow_store_init(dev);
 	if (ret < 0)
-		goto err_init_fdir_filter_list;
+		goto err_init_fdir_flow_store;
 
 	/* initialize flow engine configuration */
 	ret = ci_flow_engine_conf_init(&pf->flow_engine_conf,

@@ -1801,12 +1678,8 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
 	return 0;
 
 err_flow_engine_conf_init:
-	rte_free(pf->fdir.fdir_flow_pool.bitmap);
-	rte_free(pf->fdir.fdir_flow_pool.pool);
-	rte_free(pf->fdir.fdir_filter_array);
-	rte_free(pf->fdir.hash_map);
-	rte_hash_free(pf->fdir.hash_table);
-err_init_fdir_filter_list:
+	i40e_fdir_flow_store_free(&pf->fdir);
+err_init_fdir_flow_store:
 	rte_hash_free(pf->tunnel.hash_table);
 	rte_free(pf->tunnel.hash_map);
 err_init_tunnel_filter_list:

@@ -1849,32 +1722,13 @@ i40e_rm_tunnel_filter_list(struct i40e_pf *pf)
 	}
 }
 
-static void
-i40e_rm_fdir_filter_list(struct i40e_pf *pf)
-{
-	struct i40e_fdir_filter *p_fdir;
-	struct i40e_fdir_info *fdir_info;
-
-	fdir_info = &pf->fdir;
-
-	/* Remove all flow director rules */
-	while ((p_fdir = TAILQ_FIRST(&fdir_info->fdir_list)))
-		TAILQ_REMOVE(&fdir_info->fdir_list, p_fdir, rules);
-}
-
 static void
 i40e_fdir_memory_cleanup(struct i40e_pf *pf)
 {
-	struct i40e_fdir_info *fdir_info;
+	struct i40e_fdir_info *fdir_info = &pf->fdir;
 
-	fdir_info = &pf->fdir;
-
-	/* flow director memory cleanup */
-	rte_free(fdir_info->hash_map);
-	rte_hash_free(fdir_info->hash_table);
-	rte_free(fdir_info->fdir_flow_pool.bitmap);
-	rte_free(fdir_info->fdir_flow_pool.pool);
-	rte_free(fdir_info->fdir_filter_array);
+	i40e_fdir_flow_store_free(fdir_info);
+	i40e_fdir_tmpl_store_free(fdir_info);
 }
 
 void i40e_flex_payload_reg_set_default(struct i40e_hw *hw)

@@ -2659,6 +2513,7 @@ i40e_dev_close(struct rte_eth_dev *dev)
 	/* free the flows and reset flow config */
 	ci_flow_cleanup(&pf->flow_engine_conf);
 	ci_flow_engine_conf_reset(&pf->flow_engine_conf);
+	i40e_fdir_teardown(pf);
 
 	i40e_dev_free_queues(dev);
 

@@ -2730,7 +2585,6 @@ i40e_dev_close(struct rte_eth_dev *dev)
 	} while (retries++ < 5);
 
 	i40e_rm_tunnel_filter_list(pf);
-	i40e_rm_fdir_filter_list(pf);
 
 	/* Remove all flows */
 	while ((p_flow = TAILQ_FIRST(&pf->flow_list))) {

@@ -9758,7 +9612,12 @@ i40e_filter_input_set_init(struct i40e_pf *pf)
 		/* store the default input set */
 		if (!pf->support_multi_driver)
 			pf->hash_input_set[pctype] = input_set;
-		pf->fdir.input_set[pctype] = input_set;
+		{
+			struct i40e_fdir_pctype_state *state =
+				&pf->fdir.flows.pctype[pctype];
+
+			state->input_set = input_set;
+		}
 	}
 }
 

186 lines not on this page · raw message

1,513 lines not on this page · raw message

210 lines not on this page · raw message

index 2e7943ef8b3..0aff505b643 100644
@@ -3044,7 +3044,7 @@ int rte_pmd_i40e_flow_add_del_packet_template(
 			uint8_t add)
 {
 	struct rte_eth_dev *dev = &rte_eth_devices[port];
-	struct i40e_fdir_filter_conf filter_conf;
+	struct i40e_fdir_filter filter_conf;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 

@@ -3068,7 +3068,9 @@ int rte_pmd_i40e_flow_add_del_packet_template(
 		(enum i40e_fdir_status)conf->action.report_status;
 	filter_conf.action.flex_off = conf->action.flex_off;
 
-	return i40e_flow_add_del_fdir_filter(dev, &filter_conf, add);
+	if (add)
+		return i40e_fdir_tmpl_add(dev, &filter_conf);
+	return i40e_fdir_tmpl_del(dev, &filter_conf);
 }
 
 RTE_EXPORT_SYMBOL(rte_pmd_i40e_inset_get)

index dd42b61c679..279aadeab73 100644
@@ -1659,9 +1659,7 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
 	ret = i40e_init_tunnel_filter_list(dev);
 	if (ret < 0)
 		goto err_init_tunnel_filter_list;
-	ret = i40e_fdir_flow_store_init(dev);
-	if (ret < 0)
-		goto err_init_fdir_flow_store;
+	i40e_fdir_flow_store_init(dev);
 
 	/* initialize flow engine configuration */
 	ret = ci_flow_engine_conf_init(&pf->flow_engine_conf,

@@ -1678,8 +1676,6 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
 	return 0;
 
 err_flow_engine_conf_init:
-	i40e_fdir_flow_store_free(&pf->fdir);
-err_init_fdir_flow_store:
 	rte_hash_free(pf->tunnel.hash_table);
 	rte_free(pf->tunnel.hash_map);
 err_init_tunnel_filter_list:

@@ -1722,15 +1718,6 @@ i40e_rm_tunnel_filter_list(struct i40e_pf *pf)
 	}
 }
 
-static void
-i40e_fdir_memory_cleanup(struct i40e_pf *pf)
-{
-	struct i40e_fdir_info *fdir_info = &pf->fdir;
-
-	i40e_fdir_flow_store_free(fdir_info);
-	i40e_fdir_tmpl_store_free(fdir_info);
-}
-
 void i40e_flex_payload_reg_set_default(struct i40e_hw *hw)
 {
 	/*

@@ -2513,7 +2500,7 @@ i40e_dev_close(struct rte_eth_dev *dev)
 	/* free the flows and reset flow config */
 	ci_flow_cleanup(&pf->flow_engine_conf);
 	ci_flow_engine_conf_reset(&pf->flow_engine_conf);
-	i40e_fdir_teardown(pf);
+	i40e_fdir_cleanup(dev);
 
 	i40e_dev_free_queues(dev);
 

@@ -2589,14 +2576,9 @@ i40e_dev_close(struct rte_eth_dev *dev)
 	/* Remove all flows */
 	while ((p_flow = TAILQ_FIRST(&pf->flow_list))) {
 		TAILQ_REMOVE(&pf->flow_list, p_flow, node);
-		/* Do not free FDIR flows since they are static allocated */
-		if (p_flow->filter_type != RTE_ETH_FILTER_FDIR)
-			rte_free(p_flow);
+		rte_free(p_flow);
 	}
 
-	/* release the fdir static allocated memory */
-	i40e_fdir_memory_cleanup(pf);
-
 	/* Remove all Traffic Manager configuration */
 	i40e_tm_conf_uninit(dev);
 

@@ -9614,7 +9596,7 @@ i40e_filter_input_set_init(struct i40e_pf *pf)
 			pf->hash_input_set[pctype] = input_set;
 		{
 			struct i40e_fdir_pctype_state *state =
-				&pf->fdir.flows.pctype[pctype];
+				&pf->fdir.fdir_state.pctype[pctype];
 
 			state->input_set = input_set;
 		}

205 lines not on this page · raw message

1,008 lines not on this page · raw message

1,723 lines not on this page · raw message

index 11d13a76fe9..6823dbef332 100644

Lines of this file are not shown. View the raw message.

2,154 lines not on this page · raw message

index 0aff505b643..646044c4c51 100644

Lines of this file are not shown. View the raw message.

index 279aadeab73..70f5fba7335 100644
@@ -392,14 +392,6 @@ static int i40e_set_default_mac_addr(struct rte_eth_dev *dev,
 
 static int i40e_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu);
 
-static int i40e_tunnel_filter_convert(
-	struct i40e_aqc_cloud_filters_element_bb *cld_filter,
-	struct i40e_tunnel_filter *tunnel_filter);
-static int i40e_sw_tunnel_filter_insert(struct i40e_pf *pf,
-				struct i40e_tunnel_filter *tunnel_filter);
-static int i40e_cloud_filter_qinq_create(struct i40e_pf *pf);
-
-static void i40e_tunnel_filter_restore(struct i40e_pf *pf);
 static void i40e_filter_restore(struct i40e_pf *pf);
 static void i40e_notify_all_vfs_link_status(struct rte_eth_dev *dev);
 static int i40e_fec_get_capability(struct rte_eth_dev *dev,

@@ -996,49 +988,43 @@ config_floating_veb(struct rte_eth_dev *dev)
 #define I40E_L2_TAGS_S_TAG_SHIFT 1
 #define I40E_L2_TAGS_S_TAG_MASK I40E_MASK(0x1, I40E_L2_TAGS_S_TAG_SHIFT)
 
-static int
-i40e_init_tunnel_filter_list(struct rte_eth_dev *dev)
+struct i40e_tunnel_state *
+i40e_tunnel_state_attach(struct rte_eth_dev_data *dev_data)
 {
-	struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
-	struct i40e_tunnel_rule *tunnel_rule = &pf->tunnel;
-	char tunnel_hash_name[RTE_HASH_NAMESIZE];
-	int ret;
-
-	struct rte_hash_parameters tunnel_hash_params = {
+	struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev_data->dev_private);
+	struct i40e_tunnel_state *state = &pf->tunnel_state;
+	char tunnel_hash_name[RTE_HASH_NAMESIZE] = {0};
+	struct rte_hash_parameters hash_params = {
 		.name = tunnel_hash_name,
 		.entries = I40E_MAX_TUNNEL_FILTER_NUM,
-		.key_len = sizeof(struct i40e_tunnel_filter_input),
+		.key_len = sizeof(struct i40e_tunnel_filter_match_key),
 		.hash_func = rte_hash_crc,
 		.hash_func_init_val = 0,
 		.socket_id = rte_socket_id(),
 	};
 
-	/* Initialize tunnel filter rule list and hash */
-	TAILQ_INIT(&tunnel_rule->tunnel_list);
-	snprintf(tunnel_hash_name, RTE_HASH_NAMESIZE,
-		 "tunnel_%s", dev->device->name);
-	tunnel_rule->hash_table = rte_hash_create(&tunnel_hash_params);
-	if (!tunnel_rule->hash_table) {
-		PMD_INIT_LOG(ERR, "Failed to create tunnel hash table!");
-		return -EINVAL;
-	}
-	tunnel_rule->hash_map = rte_zmalloc("i40e_tunnel_hash_map",
-				    sizeof(struct i40e_tunnel_filter *) *
-				    I40E_MAX_TUNNEL_FILTER_NUM,
-				    0);
-	if (!tunnel_rule->hash_map) {
-		PMD_INIT_LOG(ERR,
-			     "Failed to allocate memory for tunnel hash map!");
-		ret = -ENOMEM;
-		goto err_tunnel_hash_map_alloc;
+	snprintf(tunnel_hash_name, RTE_HASH_NAMESIZE, "i40e_tunnel_hash_%s", dev_data->name);
+
+	if (ci_usage_count_claim(&state->use_count)) {
+		state->hash_table = rte_hash_create(&hash_params);
+		if (state->hash_table == NULL) {
+			PMD_DRV_LOG(ERR, "Failed to create tunnel hash table");
+			ci_usage_count_release(&state->use_count);
+			return NULL;
+		}
 	}
 
-	return 0;
+	return state;
+}
 
-err_tunnel_hash_map_alloc:
-	rte_hash_free(tunnel_rule->hash_table);
+void
+i40e_tunnel_state_detach(struct i40e_tunnel_state *state)
+{
+	if (!ci_usage_count_release(&state->use_count))
+		return;
 
-	return ret;
+	rte_hash_free(state->hash_table);
+	state->hash_table = NULL;
 }
 
 static void

@@ -1656,10 +1642,9 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
 	/* Initialize the filter invalidation configuration */
 	i40e_init_filter_invalidation(pf);
 
-	ret = i40e_init_tunnel_filter_list(dev);
-	if (ret < 0)
-		goto err_init_tunnel_filter_list;
 	i40e_fdir_flow_store_init(dev);
+	/* after device init, tunnel configuration is in its default state */
+	pf->tunnel_state = (struct i40e_tunnel_state){0};
 
 	/* initialize flow engine configuration */
 	ret = ci_flow_engine_conf_init(&pf->flow_engine_conf,

@@ -1676,9 +1661,6 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
 	return 0;
 
 err_flow_engine_conf_init:
-	rte_hash_free(pf->tunnel.hash_table);
-	rte_free(pf->tunnel.hash_map);
-err_init_tunnel_filter_list:
 	rte_intr_callback_unregister(intr_handle,
 		i40e_dev_interrupt_handler, dev);
 	rte_free(dev->data->mac_addrs);

@@ -1701,23 +1683,6 @@ eth_i40e_dev_init(struct rte_eth_dev *dev, void *init_params __rte_unused)
 	return ret;
 }
 
-static void
-i40e_rm_tunnel_filter_list(struct i40e_pf *pf)
-{
-	struct i40e_tunnel_filter *p_tunnel;
-	struct i40e_tunnel_rule *tunnel_rule;
-
-	tunnel_rule = &pf->tunnel;
-	/* Remove all tunnel director rules and hash */
-	rte_free(tunnel_rule->hash_map);
-	rte_hash_free(tunnel_rule->hash_table);
-
-	while ((p_tunnel = TAILQ_FIRST(&tunnel_rule->tunnel_list))) {
-		TAILQ_REMOVE(&tunnel_rule->tunnel_list, p_tunnel, rules);
-		rte_free(p_tunnel);
-	}
-}
-
 void i40e_flex_payload_reg_set_default(struct i40e_hw *hw)
 {
 	/*

@@ -2571,8 +2536,6 @@ i40e_dev_close(struct rte_eth_dev *dev)
 		i40e_msec_delay(500);
 	} while (retries++ < 5);
 
-	i40e_rm_tunnel_filter_list(pf);
-
 	/* Remove all flows */
 	while ((p_flow = TAILQ_FIRST(&pf->flow_list))) {
 		TAILQ_REMOVE(&pf->flow_list, p_flow, node);

@@ -7719,569 +7682,76 @@ i40e_dev_get_filter_type(uint16_t filter_type, uint16_t *flag)
 	return 0;
 }
 
-/* Convert tunnel filter structure */
-static int
-i40e_tunnel_filter_convert(
-	struct i40e_aqc_cloud_filters_element_bb *cld_filter,
-	struct i40e_tunnel_filter *tunnel_filter)
-{
-	rte_ether_addr_copy((struct rte_ether_addr *)
-			&cld_filter->element.outer_mac,
-		(struct rte_ether_addr *)&tunnel_filter->input.outer_mac);
-	rte_ether_addr_copy((struct rte_ether_addr *)
-			&cld_filter->element.inner_mac,
-		(struct rte_ether_addr *)&tunnel_filter->input.inner_mac);
-	tunnel_filter->input.inner_vlan = cld_filter->element.inner_vlan;
-	if ((rte_le_to_cpu_16(cld_filter->element.flags) &
-	     I40E_AQC_ADD_CLOUD_FLAGS_IPV6) ==
-	    I40E_AQC_ADD_CLOUD_FLAGS_IPV6)
-		tunnel_filter->input.ip_type = I40E_TUNNEL_IPTYPE_IPV6;
-	else
-		tunnel_filter->input.ip_type = I40E_TUNNEL_IPTYPE_IPV4;
-	tunnel_filter->input.flags = cld_filter->element.flags;
-	tunnel_filter->input.tenant_id = cld_filter->element.tenant_id;
-	tunnel_filter->queue = cld_filter->element.queue_number;
-	memcpy(tunnel_filter->input.general_fields,
-		   cld_filter->general_fields,
-		   sizeof(cld_filter->general_fields));
-
-	return 0;
-}
-
-/* Check if there exists the tunnel filter */
-struct i40e_tunnel_filter *
-i40e_sw_tunnel_filter_lookup(struct i40e_tunnel_rule *tunnel_rule,
-			     const struct i40e_tunnel_filter_input *input)
-{
-	int ret;
-
-	ret = rte_hash_lookup(tunnel_rule->hash_table, (const void *)input);
-	if (ret < 0)
-		return NULL;
-
-	return tunnel_rule->hash_map[ret];
-}
-
-/* Add a tunnel filter into the SW list */
-static int
-i40e_sw_tunnel_filter_insert(struct i40e_pf *pf,
-			     struct i40e_tunnel_filter *tunnel_filter)
-{
-	struct i40e_tunnel_rule *rule = &pf->tunnel;
-	int ret;
-
-	ret = rte_hash_add_key(rule->hash_table, &tunnel_filter->input);
-	if (ret < 0) {
-		PMD_DRV_LOG(ERR,
-			    "Failed to insert tunnel filter to hash table %d!",
-			    ret);
-		return ret;
-	}
-	rule->hash_map[ret] = tunnel_filter;
-
-	TAILQ_INSERT_TAIL(&rule->tunnel_list, tunnel_filter, rules);
-
-	return 0;
-}
-
-/* Delete a tunnel filter from the SW list */
 int
-i40e_sw_tunnel_filter_del(struct i40e_pf *pf,
-			  struct i40e_tunnel_filter_input *input)
+i40e_tunnel_filter_replace(struct i40e_pf *pf,
+		const struct i40e_tunnel_filter_replacement *replacement)
 {
-	struct i40e_tunnel_rule *rule = &pf->tunnel;
-	struct i40e_tunnel_filter *tunnel_filter;
+	struct i40e_aqc_replace_cloud_filters_cmd_buf buffer = {0};
+	struct i40e_aqc_replace_cloud_filters_cmd command = {
+		.valid_flags = replacement->valid_flags,
+		.old_filter_type = replacement->old_filter_type,
+		.new_filter_type = replacement->new_filter_type,
+		.tr_bit = replacement->tr_bit,
+		.tr_bit2 = replacement->tr_bit2,
+	};
+	struct i40e_hw *hw = I40E_PF_TO_HW(pf);
+	struct rte_eth_dev *dev = &rte_eth_devices[pf->dev_data->port_id];
 	int ret;
 
-	ret = rte_hash_del_key(rule->hash_table, input);
-	if (ret < 0) {
-		PMD_DRV_LOG(ERR,
-			    "Failed to delete tunnel filter to hash table %d!",
-			    ret);
-		return ret;
+	if (pf->support_multi_driver) {
+		PMD_DRV_LOG(ERR, "Replacing tunnel filters is not supported.");
+		return I40E_NOT_SUPPORTED;
 	}
-	tunnel_filter = rule->hash_map[ret];
-	rule->hash_map[ret] = NULL;
 
-	TAILQ_REMOVE(&rule->tunnel_list, tunnel_filter, rules);
-	rte_free(tunnel_filter);
+	memcpy(buffer.data, replacement->data, sizeof(replacement->data));
+	ret = i40e_aq_replace_cloud_filters(hw, &command, &buffer);
+	if (ret != I40E_SUCCESS)
+		return ret;
+
+	PMD_DRV_LOG(WARNING, "i40e device %s changed %s filter type."
+			" original: 0x%x, new: 0x%x",
+			dev->device->name,
+			(command.valid_flags & I40E_AQC_REPLACE_CLOUD_FILTER) != 0 ?
+			"cloud" : "cloud l1",
+			command.old_filter_type, command.new_filter_type);
 
 	return 0;
 }
 
-#define I40E_AQC_REPLACE_CLOUD_CMD_INPUT_TR_WORD0 0x48
-#define I40E_TR_VXLAN_GRE_KEY_MASK		0x4
-#define I40E_TR_GENEVE_KEY_MASK			0x8
-#define I40E_TR_GENERIC_UDP_TUNNEL_MASK		0x40
-#define I40E_TR_GRE_KEY_MASK			0x400
-#define I40E_TR_GRE_KEY_WITH_XSUM_MASK		0x800
-#define I40E_TR_GRE_NO_KEY_MASK			0x8000
-#define I40E_AQC_REPLACE_CLOUD_CMD_INPUT_PORT_TR_WORD0 0x49
-#define I40E_AQC_REPLACE_CLOUD_CMD_INPUT_DIRECTION_WORD0 0x41
-#define I40E_AQC_REPLACE_CLOUD_CMD_INPUT_INGRESS_WORD0 0x80
 #define I40E_DIRECTION_INGRESS_KEY		0x8000
 #define I40E_TR_L4_TYPE_TCP			0x2
 #define I40E_TR_L4_TYPE_UDP			0x4
 #define I40E_TR_L4_TYPE_SCTP			0x8
 
-static enum
-i40e_status_code i40e_replace_mpls_l1_filter(struct i40e_pf *pf)
-{
-	struct i40e_aqc_replace_cloud_filters_cmd  filter_replace;
-	struct i40e_aqc_replace_cloud_filters_cmd_buf  filter_replace_buf;
-	struct i40e_hw *hw = I40E_PF_TO_HW(pf);
-	struct rte_eth_dev *dev = &rte_eth_devices[pf->dev_data->port_id];
-	enum i40e_status_code status = I40E_SUCCESS;
-
-	if (pf->support_multi_driver) {
-		PMD_DRV_LOG(ERR, "Replace l1 filter is not supported.");
-		return I40E_NOT_SUPPORTED;
-	}
-
-	memset(&filter_replace, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd));
-	memset(&filter_replace_buf, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd_buf));
-
-	/* create L1 filter */
-	filter_replace.old_filter_type =
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_IMAC;
-	filter_replace.new_filter_type = I40E_AQC_ADD_L1_FILTER_0X11;
-	filter_replace.tr_bit = 0;
-
-	/* Prepare the buffer, 3 entries */
-	filter_replace_buf.data[0] =
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_TEID_WORD0;
-	filter_replace_buf.data[0] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[2] = 0xFF;
-	filter_replace_buf.data[3] = 0xFF;
-	filter_replace_buf.data[4] =
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_TEID_WORD1;
-	filter_replace_buf.data[4] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[7] = 0xF0;
-	filter_replace_buf.data[8]
-		= I40E_AQC_REPLACE_CLOUD_CMD_INPUT_TR_WORD0;
-	filter_replace_buf.data[8] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[10] = I40E_TR_VXLAN_GRE_KEY_MASK |
-		I40E_TR_GENEVE_KEY_MASK |
-		I40E_TR_GENERIC_UDP_TUNNEL_MASK;
-	filter_replace_buf.data[11] = (I40E_TR_GRE_KEY_MASK |
-		I40E_TR_GRE_KEY_WITH_XSUM_MASK |
-		I40E_TR_GRE_NO_KEY_MASK) >> 8;
-
-	status = i40e_aq_replace_cloud_filters(hw, &filter_replace,
-					       &filter_replace_buf);
-	if (!status && (filter_replace.old_filter_type !=
-			filter_replace.new_filter_type))
-		PMD_DRV_LOG(WARNING, "i40e device %s changed cloud l1 type."
-			    " original: 0x%x, new: 0x%x",
-			    dev->device->name,
-			    filter_replace.old_filter_type,
-			    filter_replace.new_filter_type);
-
-	return status;
-}
-
-static enum
-i40e_status_code i40e_replace_mpls_cloud_filter(struct i40e_pf *pf)
-{
-	struct i40e_aqc_replace_cloud_filters_cmd  filter_replace;
-	struct i40e_aqc_replace_cloud_filters_cmd_buf  filter_replace_buf;
-	struct i40e_hw *hw = I40E_PF_TO_HW(pf);
-	struct rte_eth_dev *dev = &rte_eth_devices[pf->dev_data->port_id];
-	enum i40e_status_code status = I40E_SUCCESS;
-
-	if (pf->support_multi_driver) {
-		PMD_DRV_LOG(ERR, "Replace cloud filter is not supported.");
-		return I40E_NOT_SUPPORTED;
-	}
-
-	/* For MPLSoUDP */
-	memset(&filter_replace, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd));
-	memset(&filter_replace_buf, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd_buf));
-	filter_replace.valid_flags = I40E_AQC_REPLACE_CLOUD_FILTER |
-		I40E_AQC_MIRROR_CLOUD_FILTER;
-	filter_replace.old_filter_type = I40E_AQC_ADD_CLOUD_FILTER_IIP;
-	filter_replace.new_filter_type =
-		I40E_AQC_ADD_CLOUD_FILTER_0X11;
-	/* Prepare the buffer, 2 entries */
-	filter_replace_buf.data[0] = I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_STAG;
-	filter_replace_buf.data[0] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[4] = I40E_AQC_ADD_L1_FILTER_0X11;
-	filter_replace_buf.data[4] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	status = i40e_aq_replace_cloud_filters(hw, &filter_replace,
-					       &filter_replace_buf);
-	if (status < 0)
-		return status;
-	if (filter_replace.old_filter_type !=
-	    filter_replace.new_filter_type)
-		PMD_DRV_LOG(WARNING, "i40e device %s changed cloud filter type."
-			    " original: 0x%x, new: 0x%x",
-			    dev->device->name,
-			    filter_replace.old_filter_type,
-			    filter_replace.new_filter_type);
-
-	/* For MPLSoGRE */
-	memset(&filter_replace, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd));
-	memset(&filter_replace_buf, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd_buf));
-
-	filter_replace.valid_flags = I40E_AQC_REPLACE_CLOUD_FILTER |
-		I40E_AQC_MIRROR_CLOUD_FILTER;
-	filter_replace.old_filter_type = I40E_AQC_ADD_CLOUD_FILTER_IMAC;
-	filter_replace.new_filter_type =
-		I40E_AQC_ADD_CLOUD_FILTER_0X12;
-	/* Prepare the buffer, 2 entries */
-	filter_replace_buf.data[0] = I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_STAG;
-	filter_replace_buf.data[0] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[4] = I40E_AQC_ADD_L1_FILTER_0X11;
-	filter_replace_buf.data[4] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-
-	status = i40e_aq_replace_cloud_filters(hw, &filter_replace,
-					       &filter_replace_buf);
-	if (!status && (filter_replace.old_filter_type !=
-			filter_replace.new_filter_type))
-		PMD_DRV_LOG(WARNING, "i40e device %s changed cloud filter type."
-			    " original: 0x%x, new: 0x%x",
-			    dev->device->name,
-			    filter_replace.old_filter_type,
-			    filter_replace.new_filter_type);
-
-	return status;
-}
-
-static enum i40e_status_code
-i40e_replace_gtp_l1_filter(struct i40e_pf *pf)
-{
-	struct i40e_aqc_replace_cloud_filters_cmd  filter_replace;
-	struct i40e_aqc_replace_cloud_filters_cmd_buf  filter_replace_buf;
-	struct i40e_hw *hw = I40E_PF_TO_HW(pf);
-	struct rte_eth_dev *dev = &rte_eth_devices[pf->dev_data->port_id];
-	enum i40e_status_code status = I40E_SUCCESS;
-
-	if (pf->support_multi_driver) {
-		PMD_DRV_LOG(ERR, "Replace l1 filter is not supported.");
-		return I40E_NOT_SUPPORTED;
-	}
-
-	/* For GTP-C */
-	memset(&filter_replace, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd));
-	memset(&filter_replace_buf, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd_buf));
-	/* create L1 filter */
-	filter_replace.old_filter_type =
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_IMAC;
-	filter_replace.new_filter_type = I40E_AQC_ADD_L1_FILTER_0X12;
-	filter_replace.tr_bit = I40E_AQC_NEW_TR_22 |
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	/* Prepare the buffer, 2 entries */
-	filter_replace_buf.data[0] =
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_TEID_WORD0;
-	filter_replace_buf.data[0] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[2] = 0xFF;
-	filter_replace_buf.data[3] = 0xFF;
-	filter_replace_buf.data[4] =
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_TEID_WORD1;
-	filter_replace_buf.data[4] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[6] = 0xFF;
-	filter_replace_buf.data[7] = 0xFF;
-	status = i40e_aq_replace_cloud_filters(hw, &filter_replace,
-					       &filter_replace_buf);
-	if (status < 0)
-		return status;
-	if (filter_replace.old_filter_type !=
-	    filter_replace.new_filter_type)
-		PMD_DRV_LOG(WARNING, "i40e device %s changed cloud l1 type."
-			    " original: 0x%x, new: 0x%x",
-			    dev->device->name,
-			    filter_replace.old_filter_type,
-			    filter_replace.new_filter_type);
-
-	/* for GTP-U */
-	memset(&filter_replace, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd));
-	memset(&filter_replace_buf, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd_buf));
-	/* create L1 filter */
-	filter_replace.old_filter_type =
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_TUNNLE_KEY;
-	filter_replace.new_filter_type = I40E_AQC_ADD_L1_FILTER_0X13;
-	filter_replace.tr_bit = I40E_AQC_NEW_TR_21 |
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	/* Prepare the buffer, 2 entries */
-	filter_replace_buf.data[0] =
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_TEID_WORD0;
-	filter_replace_buf.data[0] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[2] = 0xFF;
-	filter_replace_buf.data[3] = 0xFF;
-	filter_replace_buf.data[4] =
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_TEID_WORD1;
-	filter_replace_buf.data[4] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[6] = 0xFF;
-	filter_replace_buf.data[7] = 0xFF;
-
-	status = i40e_aq_replace_cloud_filters(hw, &filter_replace,
-					       &filter_replace_buf);
-	if (!status && (filter_replace.old_filter_type !=
-			filter_replace.new_filter_type))
-		PMD_DRV_LOG(WARNING, "i40e device %s changed cloud l1 type."
-			    " original: 0x%x, new: 0x%x",
-			    dev->device->name,
-			    filter_replace.old_filter_type,
-			    filter_replace.new_filter_type);
-
-	return status;
-}
-
-static enum
-i40e_status_code i40e_replace_gtp_cloud_filter(struct i40e_pf *pf)
-{
-	struct i40e_aqc_replace_cloud_filters_cmd  filter_replace;
-	struct i40e_aqc_replace_cloud_filters_cmd_buf  filter_replace_buf;
-	struct i40e_hw *hw = I40E_PF_TO_HW(pf);
-	struct rte_eth_dev *dev = &rte_eth_devices[pf->dev_data->port_id];
-	enum i40e_status_code status = I40E_SUCCESS;
-
-	if (pf->support_multi_driver) {
-		PMD_DRV_LOG(ERR, "Replace cloud filter is not supported.");
-		return I40E_NOT_SUPPORTED;
-	}
-
-	/* for GTP-C */
-	memset(&filter_replace, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd));
-	memset(&filter_replace_buf, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd_buf));
-	filter_replace.valid_flags = I40E_AQC_REPLACE_CLOUD_FILTER;
-	filter_replace.old_filter_type = I40E_AQC_ADD_CLOUD_FILTER_IMAC_IVLAN;
-	filter_replace.new_filter_type =
-		I40E_AQC_ADD_CLOUD_FILTER_0X11;
-	/* Prepare the buffer, 2 entries */
-	filter_replace_buf.data[0] = I40E_AQC_ADD_L1_FILTER_0X12;
-	filter_replace_buf.data[0] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[4] = I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_STAG;
-	filter_replace_buf.data[4] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	status = i40e_aq_replace_cloud_filters(hw, &filter_replace,
-					       &filter_replace_buf);
-	if (status < 0)
-		return status;
-	if (filter_replace.old_filter_type !=
-	    filter_replace.new_filter_type)
-		PMD_DRV_LOG(WARNING, "i40e device %s changed cloud filter type."
-			    " original: 0x%x, new: 0x%x",
-			    dev->device->name,
-			    filter_replace.old_filter_type,
-			    filter_replace.new_filter_type);
-
-	/* for GTP-U */
-	memset(&filter_replace, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd));
-	memset(&filter_replace_buf, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd_buf));
-	filter_replace.valid_flags = I40E_AQC_REPLACE_CLOUD_FILTER;
-	filter_replace.old_filter_type =
-		I40E_AQC_ADD_CLOUD_FILTER_IMAC_IVLAN_TEN_ID;
-	filter_replace.new_filter_type =
-		I40E_AQC_ADD_CLOUD_FILTER_0X12;
-	/* Prepare the buffer, 2 entries */
-	filter_replace_buf.data[0] = I40E_AQC_ADD_L1_FILTER_0X13;
-	filter_replace_buf.data[0] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[4] = I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_STAG;
-	filter_replace_buf.data[4] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-
-	status = i40e_aq_replace_cloud_filters(hw, &filter_replace,
-					       &filter_replace_buf);
-	if (!status && (filter_replace.old_filter_type !=
-			filter_replace.new_filter_type))
-		PMD_DRV_LOG(WARNING, "i40e device %s changed cloud filter type."
-			    " original: 0x%x, new: 0x%x",
-			    dev->device->name,
-			    filter_replace.old_filter_type,
-			    filter_replace.new_filter_type);
-
-	return status;
-}
-
-static enum i40e_status_code
-i40e_replace_port_l1_filter(struct i40e_pf *pf,
-			    enum i40e_l4_port_type l4_port_type)
-{
-	struct i40e_aqc_replace_cloud_filters_cmd_buf  filter_replace_buf;
-	struct i40e_aqc_replace_cloud_filters_cmd  filter_replace;
-	enum i40e_status_code status = I40E_SUCCESS;
-	struct i40e_hw *hw = I40E_PF_TO_HW(pf);
-	struct rte_eth_dev *dev = &rte_eth_devices[pf->dev_data->port_id];
-
-	if (pf->support_multi_driver) {
-		PMD_DRV_LOG(ERR, "Replace l1 filter is not supported.");
-		return I40E_NOT_SUPPORTED;
-	}
-
-	memset(&filter_replace, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd));
-	memset(&filter_replace_buf, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd_buf));
-
-	/* create L1 filter */
-	if (l4_port_type == I40E_L4_PORT_TYPE_SRC) {
-		filter_replace.old_filter_type =
-			I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_TUNNLE_KEY;
-		filter_replace.new_filter_type = I40E_AQC_ADD_L1_FILTER_0X11;
-		filter_replace_buf.data[8] =
-			I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_SRC_PORT;
-	} else {
-		filter_replace.old_filter_type =
-			I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_STAG_IVLAN;
-		filter_replace.new_filter_type = I40E_AQC_ADD_L1_FILTER_0X10;
-		filter_replace_buf.data[8] =
-			I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_DST_PORT;
-	}
-
-	filter_replace.tr_bit = 0;
-	/* Prepare the buffer, 3 entries */
-	filter_replace_buf.data[0] =
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_DIRECTION_WORD0;
-	filter_replace_buf.data[0] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[2] = 0x00;
-	filter_replace_buf.data[3] =
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_INGRESS_WORD0;
-	filter_replace_buf.data[4] =
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_PORT_TR_WORD0;
-	filter_replace_buf.data[4] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[5] = 0x00;
-	filter_replace_buf.data[6] = I40E_TR_L4_TYPE_UDP |
-		I40E_TR_L4_TYPE_TCP |
-		I40E_TR_L4_TYPE_SCTP;
-	filter_replace_buf.data[7] = 0x00;
-	filter_replace_buf.data[8] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[9] = 0x00;
-	filter_replace_buf.data[10] = 0xFF;
-	filter_replace_buf.data[11] = 0xFF;
-
-	status = i40e_aq_replace_cloud_filters(hw, &filter_replace,
-					       &filter_replace_buf);
-	if (!status && filter_replace.old_filter_type !=
-	    filter_replace.new_filter_type)
-		PMD_DRV_LOG(WARNING, "i40e device %s changed cloud l1 type."
-			    " original: 0x%x, new: 0x%x",
-			    dev->device->name,
-			    filter_replace.old_filter_type,
-			    filter_replace.new_filter_type);
-
-	return status;
-}
-
-static enum i40e_status_code
-i40e_replace_port_cloud_filter(struct i40e_pf *pf,
-			       enum i40e_l4_port_type l4_port_type)
-{
-	struct i40e_aqc_replace_cloud_filters_cmd_buf  filter_replace_buf;
-	struct i40e_aqc_replace_cloud_filters_cmd  filter_replace;
-	enum i40e_status_code status = I40E_SUCCESS;
-	struct i40e_hw *hw = I40E_PF_TO_HW(pf);
-	struct rte_eth_dev *dev = &rte_eth_devices[pf->dev_data->port_id];
-
-	if (pf->support_multi_driver) {
-		PMD_DRV_LOG(ERR, "Replace cloud filter is not supported.");
-		return I40E_NOT_SUPPORTED;
-	}
-
-	memset(&filter_replace, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd));
-	memset(&filter_replace_buf, 0,
-	       sizeof(struct i40e_aqc_replace_cloud_filters_cmd_buf));
-
-	if (l4_port_type == I40E_L4_PORT_TYPE_SRC) {
-		filter_replace.old_filter_type = I40E_AQC_ADD_CLOUD_FILTER_IIP;
-		filter_replace.new_filter_type =
-			I40E_AQC_ADD_CLOUD_FILTER_0X11;
-		filter_replace_buf.data[4] = I40E_AQC_ADD_CLOUD_FILTER_0X11;
-	} else {
-		filter_replace.old_filter_type = I40E_AQC_ADD_CLOUD_FILTER_OIP;
-		filter_replace.new_filter_type =
-			I40E_AQC_ADD_CLOUD_FILTER_0X10;
-		filter_replace_buf.data[4] = I40E_AQC_ADD_CLOUD_FILTER_0X10;
-	}
-
-	filter_replace.valid_flags = I40E_AQC_REPLACE_CLOUD_FILTER;
-	filter_replace.tr_bit = 0;
-	/* Prepare the buffer, 2 entries */
-	filter_replace_buf.data[0] = I40E_AQC_REPLACE_CLOUD_CMD_INPUT_FV_STAG;
-	filter_replace_buf.data[0] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	filter_replace_buf.data[4] |=
-		I40E_AQC_REPLACE_CLOUD_CMD_INPUT_VALIDATED;
-	status = i40e_aq_replace_cloud_filters(hw, &filter_replace,
-					       &filter_replace_buf);
-
-	if (!status && filter_replace.old_filter_type !=
-	    filter_replace.new_filter_type)
-		PMD_DRV_LOG(WARNING, "i40e device %s changed cloud filter type."
-			    " original: 0x%x, new: 0x%x",
-			    dev->device->name,
-			    filter_replace.old_filter_type,
-			    filter_replace.new_filter_type);
-
-	return status;
-}
-
-int
-i40e_dev_consistent_tunnel_filter_set(struct i40e_pf *pf,
-		      struct i40e_tunnel_filter_conf *tunnel_filter,
-		      uint8_t add)
+static int
+i40e_tunnel_filter_convert_conf(struct i40e_pf *pf,
+		struct i40e_tunnel_filter_conf *tunnel_filter,
+		struct i40e_aqc_cloud_filters_element_bb *cld_filter,
+		struct i40e_vsi **vsi, bool *big_buffer)
 {
 	uint16_t ip_type;
 	uint32_t ipv4_addr, ipv4_addr_le;
 	uint8_t i, tun_type = 0;
 	/* internal variable to convert ipv6 byte order */
 	uint32_t convert_ipv6[4];
-	int val, ret = 0;
+	int val;
 	struct i40e_pf_vf *vf = NULL;
-	struct i40e_hw *hw = I40E_PF_TO_HW(pf);
-	struct i40e_vsi *vsi;
-	struct i40e_aqc_cloud_filters_element_bb cld_filter = {0};
-	struct i40e_tunnel_rule *tunnel_rule = &pf->tunnel;
-	struct i40e_tunnel_filter *node;
-	struct i40e_tunnel_filter check_filter; /* Check if filter exists */
 	uint32_t teid_le;
-	bool big_buffer = 0;
 
 	rte_ether_addr_copy(&tunnel_filter->outer_mac,
-			(struct rte_ether_addr *)&cld_filter.element.outer_mac);
+			(struct rte_ether_addr *)&cld_filter->element.outer_mac);
 	rte_ether_addr_copy(&tunnel_filter->inner_mac,
-			(struct rte_ether_addr *)&cld_filter.element.inner_mac);
+			(struct rte_ether_addr *)&cld_filter->element.inner_mac);
 
-	cld_filter.element.inner_vlan =
+	cld_filter->element.inner_vlan =
 		rte_cpu_to_le_16(tunnel_filter->inner_vlan);
 	if (tunnel_filter->ip_type == I40E_TUNNEL_IPTYPE_IPV4) {
 		ip_type = I40E_AQC_ADD_CLOUD_FLAGS_IPV4;
 		ipv4_addr = rte_be_to_cpu_32(tunnel_filter->ip_addr.ipv4_addr);
 		ipv4_addr_le = rte_cpu_to_le_32(ipv4_addr);
-		memcpy(&cld_filter.element.ipaddr.v4.data,
+		memcpy(&cld_filter->element.ipaddr.v4.data,
 				&ipv4_addr_le,
-				sizeof(cld_filter.element.ipaddr.v4.data));
+				sizeof(cld_filter->element.ipaddr.v4.data));
 	} else {
 		ip_type = I40E_AQC_ADD_CLOUD_FLAGS_IPV6;
 		for (i = 0; i < 4; i++) {