[PATCH v2 17/19] net/i40e: reimplement tunnel parsers
Anatoly Burakov
anatoly.burakov at intel.com
Tue Sep 8 17:20:59 CEST 2026
Use the new flow graph API and the common parsing framework to implement
flow parser for tunnel filters: QinQ, VXLAN, NVGRE, MPLS, GTP, and L4.
As a result of transitioning to more formalized validation, some
checks have become more stringent:
- VLAN TCI mask is now required to be fully masked (all-ones); previously
the mask was only checked for eth_proto and any non-zero vlan_tci mask
value was silently accepted
In addition to using the new graph infrastructure, some of the checks were
made more stringent and/or more correct. In particular:
- old code did not check for whether fields other than ports are masked
(they are now rejected)
- old code did not check for whether src/ports are fully masked (masks
other than full are now rejected)
- old code used spec to decide which port to copy (as a result, it was not
possible to match port 0 - this is now allowed)
Tunnel engine now also share a refcounted global state, and track all
flows and do deduplication inside the engine.
Signed-off-by: Anatoly Burakov <anatoly.burakov at intel.com>
---
drivers/net/intel/i40e/i40e_ethdev.c | 548 +++----
drivers/net/intel/i40e/i40e_ethdev.h | 52 +-
drivers/net/intel/i40e/i40e_flow.c | 1702 +--------------------
drivers/net/intel/i40e/i40e_flow.h | 6 +
drivers/net/intel/i40e/i40e_flow_tunnel.c | 1590 +++++++++++++++++++
drivers/net/intel/i40e/meson.build | 1 +
6 files changed, 1829 insertions(+), 2070 deletions(-)
create mode 100644 drivers/net/intel/i40e/i40e_flow_tunnel.c
diff --git a/drivers/net/intel/i40e/i40e_ethdev.c b/drivers/net/intel/i40e/i40e_ethdev.c
index 572dfff13a..97211b5994 100644
--- a/drivers/net/intel/i40e/i40e_ethdev.c
+++ b/drivers/net/intel/i40e/i40e_ethdev.c
@@ -392,14 +392,8 @@ 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 +990,41 @@ 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_%d", dev_data->port_id);
+
+ if (state->refcnt == 0) {
+ state->hash_table = rte_hash_create(&hash_params);
+ if (state->hash_table == NULL)
+ return NULL;
}
- return 0;
+ state->refcnt++;
+ 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 (--state->refcnt > 0)
+ return;
- return ret;
+ rte_hash_free(state->hash_table);
+ *state = (struct i40e_tunnel_state){0};
}
static void
@@ -1656,9 +1642,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_tunnel_filter_list(dev);
- if (ret < 0)
- goto err_init_tunnel_filter_list;
i40e_fdir_flow_store_init(dev);
/* initialize flow engine configuration */
@@ -1676,9 +1659,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 +1681,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);
- }
-}
-
static void
i40e_fdir_memory_cleanup(struct i40e_pf *pf)
{
@@ -2578,8 +2541,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);
@@ -7747,96 +7708,6 @@ 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)
-{
- struct i40e_tunnel_rule *rule = &pf->tunnel;
- struct i40e_tunnel_filter *tunnel_filter;
- 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;
- }
- tunnel_filter = rule->hash_map[ret];
- rule->hash_map[ret] = NULL;
-
- TAILQ_REMOVE(&rule->tunnel_list, tunnel_filter, rules);
- rte_free(tunnel_filter);
-
- 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
@@ -8275,41 +8146,35 @@ i40e_replace_port_cloud_filter(struct i40e_pf *pf,
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++) {
@@ -8317,9 +8182,9 @@ i40e_dev_consistent_tunnel_filter_set(struct i40e_pf *pf,
rte_cpu_to_le_32(rte_be_to_cpu_32(
tunnel_filter->ip_addr.ipv6_addr[i]));
}
- memcpy(&cld_filter.element.ipaddr.v6.data,
+ memcpy(&cld_filter->element.ipaddr.v6.data,
&convert_ipv6,
- sizeof(cld_filter.element.ipaddr.v6.data));
+ sizeof(cld_filter->element.ipaddr.v6.data));
}
/* check tunneled type */
@@ -8334,137 +8199,96 @@ i40e_dev_consistent_tunnel_filter_set(struct i40e_pf *pf,
tun_type = I40E_AQC_ADD_CLOUD_TNL_TYPE_IP;
break;
case I40E_TUNNEL_TYPE_MPLSoUDP:
- if (!pf->mpls_replace_flag) {
- i40e_replace_mpls_l1_filter(pf);
- i40e_replace_mpls_cloud_filter(pf);
- pf->mpls_replace_flag = 1;
- }
teid_le = rte_cpu_to_le_32(tunnel_filter->tenant_id);
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD0] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD0] =
teid_le >> 4;
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD1] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD1] =
(teid_le & 0xF) << 12;
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD2] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD2] =
0x40;
- big_buffer = 1;
+ *big_buffer = 1;
tun_type = I40E_AQC_ADD_CLOUD_TNL_TYPE_MPLSOUDP;
break;
case I40E_TUNNEL_TYPE_MPLSoGRE:
- if (!pf->mpls_replace_flag) {
- i40e_replace_mpls_l1_filter(pf);
- i40e_replace_mpls_cloud_filter(pf);
- pf->mpls_replace_flag = 1;
- }
teid_le = rte_cpu_to_le_32(tunnel_filter->tenant_id);
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD0] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD0] =
teid_le >> 4;
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD1] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD1] =
(teid_le & 0xF) << 12;
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD2] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD2] =
0x0;
- big_buffer = 1;
+ *big_buffer = 1;
tun_type = I40E_AQC_ADD_CLOUD_TNL_TYPE_MPLSOGRE;
break;
case I40E_TUNNEL_TYPE_GTPC:
- if (!pf->gtp_replace_flag) {
- i40e_replace_gtp_l1_filter(pf);
- i40e_replace_gtp_cloud_filter(pf);
- pf->gtp_replace_flag = 1;
- }
teid_le = rte_cpu_to_le_32(tunnel_filter->tenant_id);
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X12_WORD0] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X12_WORD0] =
(teid_le >> 16) & 0xFFFF;
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X12_WORD1] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X12_WORD1] =
teid_le & 0xFFFF;
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X12_WORD2] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X12_WORD2] =
0x0;
- big_buffer = 1;
+ *big_buffer = 1;
break;
case I40E_TUNNEL_TYPE_GTPU:
- if (!pf->gtp_replace_flag) {
- i40e_replace_gtp_l1_filter(pf);
- i40e_replace_gtp_cloud_filter(pf);
- pf->gtp_replace_flag = 1;
- }
teid_le = rte_cpu_to_le_32(tunnel_filter->tenant_id);
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X13_WORD0] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X13_WORD0] =
(teid_le >> 16) & 0xFFFF;
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X13_WORD1] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X13_WORD1] =
teid_le & 0xFFFF;
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X13_WORD2] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X13_WORD2] =
0x0;
- big_buffer = 1;
+ *big_buffer = 1;
break;
case I40E_TUNNEL_TYPE_QINQ:
- if (!pf->qinq_replace_flag) {
- ret = i40e_cloud_filter_qinq_create(pf);
- if (ret < 0)
- PMD_DRV_LOG(DEBUG,
- "QinQ tunnel filter already created.");
- pf->qinq_replace_flag = 1;
- }
/* Add in the General fields the values of
* the Outer and Inner VLAN
* Big Buffer should be set, see changes in
* i40e_aq_add_cloud_filters
*/
- cld_filter.general_fields[0] = tunnel_filter->inner_vlan;
- cld_filter.general_fields[1] = tunnel_filter->outer_vlan;
- big_buffer = 1;
+ cld_filter->general_fields[0] = tunnel_filter->inner_vlan;
+ cld_filter->general_fields[1] = tunnel_filter->outer_vlan;
+ *big_buffer = 1;
break;
case I40E_CLOUD_TYPE_UDP:
case I40E_CLOUD_TYPE_TCP:
case I40E_CLOUD_TYPE_SCTP:
if (tunnel_filter->l4_port_type == I40E_L4_PORT_TYPE_SRC) {
- if (!pf->sport_replace_flag) {
- i40e_replace_port_l1_filter(pf,
- tunnel_filter->l4_port_type);
- i40e_replace_port_cloud_filter(pf,
- tunnel_filter->l4_port_type);
- pf->sport_replace_flag = 1;
- }
teid_le = rte_cpu_to_le_32(tunnel_filter->tenant_id);
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD0] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD0] =
I40E_DIRECTION_INGRESS_KEY;
if (tunnel_filter->tunnel_type == I40E_CLOUD_TYPE_UDP)
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD1] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD1] =
I40E_TR_L4_TYPE_UDP;
else if (tunnel_filter->tunnel_type == I40E_CLOUD_TYPE_TCP)
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD1] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD1] =
I40E_TR_L4_TYPE_TCP;
else
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD1] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD1] =
I40E_TR_L4_TYPE_SCTP;
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD2] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X11_WORD2] =
(teid_le >> 16) & 0xFFFF;
- big_buffer = 1;
+ *big_buffer = 1;
} else {
- if (!pf->dport_replace_flag) {
- i40e_replace_port_l1_filter(pf,
- tunnel_filter->l4_port_type);
- i40e_replace_port_cloud_filter(pf,
- tunnel_filter->l4_port_type);
- pf->dport_replace_flag = 1;
- }
teid_le = rte_cpu_to_le_32(tunnel_filter->tenant_id);
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X10_WORD0] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X10_WORD0] =
I40E_DIRECTION_INGRESS_KEY;
if (tunnel_filter->tunnel_type == I40E_CLOUD_TYPE_UDP)
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X10_WORD1] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X10_WORD1] =
I40E_TR_L4_TYPE_UDP;
else if (tunnel_filter->tunnel_type == I40E_CLOUD_TYPE_TCP)
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X10_WORD1] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X10_WORD1] =
I40E_TR_L4_TYPE_TCP;
else
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X10_WORD1] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X10_WORD1] =
I40E_TR_L4_TYPE_SCTP;
- cld_filter.general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X10_WORD2] =
+ cld_filter->general_fields[I40E_AQC_ADD_CLOUD_FV_FLU_0X10_WORD2] =
(teid_le >> 16) & 0xFFFF;
- big_buffer = 1;
+ *big_buffer = 1;
}
break;
@@ -8475,74 +8299,191 @@ i40e_dev_consistent_tunnel_filter_set(struct i40e_pf *pf,
}
if (tunnel_filter->tunnel_type == I40E_TUNNEL_TYPE_MPLSoUDP)
- cld_filter.element.flags =
+ cld_filter->element.flags =
I40E_AQC_ADD_CLOUD_FILTER_0X11;
else if (tunnel_filter->tunnel_type == I40E_TUNNEL_TYPE_MPLSoGRE)
- cld_filter.element.flags =
+ cld_filter->element.flags =
I40E_AQC_ADD_CLOUD_FILTER_0X12;
else if (tunnel_filter->tunnel_type == I40E_TUNNEL_TYPE_GTPC)
- cld_filter.element.flags =
+ cld_filter->element.flags =
I40E_AQC_ADD_CLOUD_FILTER_0X11;
else if (tunnel_filter->tunnel_type == I40E_TUNNEL_TYPE_GTPU)
- cld_filter.element.flags =
+ cld_filter->element.flags =
I40E_AQC_ADD_CLOUD_FILTER_0X12;
else if (tunnel_filter->tunnel_type == I40E_TUNNEL_TYPE_QINQ)
- cld_filter.element.flags |=
+ cld_filter->element.flags |=
I40E_AQC_ADD_CLOUD_FILTER_0X10;
else if (tunnel_filter->tunnel_type == I40E_CLOUD_TYPE_UDP ||
tunnel_filter->tunnel_type == I40E_CLOUD_TYPE_TCP ||
tunnel_filter->tunnel_type == I40E_CLOUD_TYPE_SCTP) {
if (tunnel_filter->l4_port_type == I40E_L4_PORT_TYPE_SRC)
- cld_filter.element.flags |=
+ cld_filter->element.flags |=
I40E_AQC_ADD_CLOUD_FILTER_0X11;
else
- cld_filter.element.flags |=
+ cld_filter->element.flags |=
I40E_AQC_ADD_CLOUD_FILTER_0X10;
} else {
val = i40e_dev_get_filter_type(tunnel_filter->filter_type,
- &cld_filter.element.flags);
+ &cld_filter->element.flags);
if (val < 0) {
return -EINVAL;
}
}
- cld_filter.element.flags |=
+ cld_filter->element.flags |=
rte_cpu_to_le_16(I40E_AQC_ADD_CLOUD_FLAGS_TO_QUEUE | ip_type |
(tun_type << I40E_AQC_ADD_CLOUD_TNL_TYPE_SHIFT));
- cld_filter.element.tenant_id = rte_cpu_to_le_32(tunnel_filter->tenant_id);
- cld_filter.element.queue_number =
+ cld_filter->element.tenant_id = rte_cpu_to_le_32(tunnel_filter->tenant_id);
+ cld_filter->element.queue_number =
rte_cpu_to_le_16(tunnel_filter->queue_id);
if (!tunnel_filter->is_to_vf)
- vsi = pf->main_vsi;
+ *vsi = pf->main_vsi;
else {
if (tunnel_filter->vf_id >= pf->vf_num) {
PMD_DRV_LOG(ERR, "Invalid argument.");
return -EINVAL;
}
vf = &pf->vfs[tunnel_filter->vf_id];
- vsi = vf->vsi;
+ *vsi = vf->vsi;
}
- /* Check if there is the filter in SW list */
- memset(&check_filter, 0, sizeof(check_filter));
- i40e_tunnel_filter_convert(&cld_filter, &check_filter);
- check_filter.is_to_vf = tunnel_filter->is_to_vf;
- check_filter.vf_id = tunnel_filter->vf_id;
- node = i40e_sw_tunnel_filter_lookup(tunnel_rule, &check_filter.input);
- if (add && node) {
- PMD_DRV_LOG(ERR, "Conflict with existing tunnel rules!");
- return -EINVAL;
- }
+ return 0;
+}
+
+static int
+i40e_tunnel_filter_prepare_hw(struct i40e_pf *pf,
+ struct i40e_tunnel_filter_conf *tunnel_filter)
+{
+ int ret;
- if (!add && !node) {
- PMD_DRV_LOG(ERR, "There's no corresponding tunnel filter!");
- return -EINVAL;
+ switch (tunnel_filter->tunnel_type) {
+ case I40E_TUNNEL_TYPE_MPLSoUDP:
+ case I40E_TUNNEL_TYPE_MPLSoGRE:
+ if (!pf->mpls_replace_flag) {
+ ret = i40e_replace_mpls_l1_filter(pf);
+ if (ret < 0)
+ return ret;
+ ret = i40e_replace_mpls_cloud_filter(pf);
+ if (ret < 0)
+ return ret;
+ pf->mpls_replace_flag = 1;
+ }
+ break;
+ case I40E_TUNNEL_TYPE_GTPC:
+ case I40E_TUNNEL_TYPE_GTPU:
+ if (!pf->gtp_replace_flag) {
+ ret = i40e_replace_gtp_l1_filter(pf);
+ if (ret < 0)
+ return ret;
+ ret = i40e_replace_gtp_cloud_filter(pf);
+ if (ret < 0)
+ return ret;
+ pf->gtp_replace_flag = 1;
+ }
+ break;
+ case I40E_TUNNEL_TYPE_QINQ:
+ if (!pf->qinq_replace_flag) {
+ ret = i40e_cloud_filter_qinq_create(pf);
+ if (ret < 0)
+ PMD_DRV_LOG(DEBUG,
+ "QinQ tunnel filter already created.");
+ pf->qinq_replace_flag = 1;
+ }
+ break;
+ case I40E_CLOUD_TYPE_UDP:
+ case I40E_CLOUD_TYPE_TCP:
+ case I40E_CLOUD_TYPE_SCTP:
+ if (tunnel_filter->l4_port_type == I40E_L4_PORT_TYPE_SRC) {
+ if (!pf->sport_replace_flag) {
+ ret = i40e_replace_port_l1_filter(pf,
+ tunnel_filter->l4_port_type);
+ if (ret < 0)
+ return ret;
+ ret = i40e_replace_port_cloud_filter(pf,
+ tunnel_filter->l4_port_type);
+ if (ret < 0)
+ return ret;
+ pf->sport_replace_flag = 1;
+ }
+ } else if (!pf->dport_replace_flag) {
+ ret = i40e_replace_port_l1_filter(pf,
+ tunnel_filter->l4_port_type);
+ if (ret < 0)
+ return ret;
+ ret = i40e_replace_port_cloud_filter(pf,
+ tunnel_filter->l4_port_type);
+ if (ret < 0)
+ return ret;
+ pf->dport_replace_flag = 1;
+ }
+ break;
+ default:
+ break;
}
+ return 0;
+}
+
+int
+i40e_tunnel_filter_match_key_get(struct i40e_pf *pf,
+ struct i40e_tunnel_filter_conf *tunnel_filter,
+ struct i40e_tunnel_filter_match_key *input)
+{
+ struct i40e_aqc_cloud_filters_element_bb cld_filter = {0};
+ struct i40e_vsi *vsi;
+ bool big_buffer = 0;
+ int ret;
+
+ ret = i40e_tunnel_filter_convert_conf(pf, tunnel_filter, &cld_filter,
+ &vsi, &big_buffer);
+ if (ret != 0)
+ return ret;
+
+ rte_ether_addr_copy((struct rte_ether_addr *)
+ &cld_filter.element.outer_mac,
+ (struct rte_ether_addr *)&input->outer_mac);
+ rte_ether_addr_copy((struct rte_ether_addr *)
+ &cld_filter.element.inner_mac,
+ (struct rte_ether_addr *)&input->inner_mac);
+ 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)
+ input->ip_type = I40E_TUNNEL_IPTYPE_IPV6;
+ else
+ input->ip_type = I40E_TUNNEL_IPTYPE_IPV4;
+ input->flags = cld_filter.element.flags;
+ input->tenant_id = cld_filter.element.tenant_id;
+ memcpy(input->general_fields, cld_filter.general_fields,
+ sizeof(cld_filter.general_fields));
+
+ return 0;
+}
+
+int
+i40e_tunnel_filter_program(struct i40e_pf *pf,
+ struct i40e_tunnel_filter_conf *tunnel_filter,
+ uint8_t add)
+{
+ struct i40e_hw *hw = I40E_PF_TO_HW(pf);
+ struct i40e_aqc_cloud_filters_element_bb cld_filter = {0};
+ struct i40e_vsi *vsi;
+ bool big_buffer = 0;
+ int ret;
+
+ ret = i40e_tunnel_filter_convert_conf(pf, tunnel_filter, &cld_filter,
+ &vsi, &big_buffer);
+ if (ret != 0)
+ return ret;
+
if (add) {
- struct i40e_tunnel_filter *tunnel;
+ ret = i40e_tunnel_filter_prepare_hw(pf, tunnel_filter);
+ if (ret < 0)
+ return ret;
+ }
+ if (add) {
if (big_buffer)
ret = i40e_aq_add_cloud_filters_bb(hw,
vsi->seid, &cld_filter, 1);
@@ -8553,16 +8494,6 @@ i40e_dev_consistent_tunnel_filter_set(struct i40e_pf *pf,
PMD_DRV_LOG(ERR, "Failed to add a tunnel filter.");
return -ENOTSUP;
}
- tunnel = rte_zmalloc("tunnel_filter", sizeof(*tunnel), 0);
- if (tunnel == NULL) {
- PMD_DRV_LOG(ERR, "Failed to alloc memory.");
- return -ENOMEM;
- }
-
- memcpy(tunnel, &check_filter, sizeof(check_filter));
- ret = i40e_sw_tunnel_filter_insert(pf, tunnel);
- if (ret < 0)
- rte_free(tunnel);
} else {
if (big_buffer)
ret = i40e_aq_rem_cloud_filters_bb(
@@ -8574,7 +8505,6 @@ i40e_dev_consistent_tunnel_filter_set(struct i40e_pf *pf,
PMD_DRV_LOG(ERR, "Failed to delete a tunnel filter.");
return -ENOTSUP;
}
- ret = i40e_sw_tunnel_filter_del(pf, &node->input);
}
return ret;
@@ -11282,65 +11212,9 @@ i40e_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu __rte_unused)
return 0;
}
-/* Restore tunnel filter */
-static void
-i40e_tunnel_filter_restore(struct i40e_pf *pf)
-{
- struct i40e_hw *hw = I40E_PF_TO_HW(pf);
- struct i40e_vsi *vsi;
- struct i40e_pf_vf *vf;
- struct i40e_tunnel_filter_list
- *tunnel_list = &pf->tunnel.tunnel_list;
- struct i40e_tunnel_filter *f;
- struct i40e_aqc_cloud_filters_element_bb cld_filter;
- bool big_buffer = 0;
-
- TAILQ_FOREACH(f, tunnel_list, rules) {
- if (!f->is_to_vf)
- vsi = pf->main_vsi;
- else {
- vf = &pf->vfs[f->vf_id];
- vsi = vf->vsi;
- }
- memset(&cld_filter, 0, sizeof(cld_filter));
- rte_ether_addr_copy((struct rte_ether_addr *)
- &f->input.outer_mac,
- (struct rte_ether_addr *)&cld_filter.element.outer_mac);
- rte_ether_addr_copy((struct rte_ether_addr *)
- &f->input.inner_mac,
- (struct rte_ether_addr *)&cld_filter.element.inner_mac);
- cld_filter.element.inner_vlan = f->input.inner_vlan;
- cld_filter.element.flags = f->input.flags;
- cld_filter.element.tenant_id = f->input.tenant_id;
- cld_filter.element.queue_number = f->queue;
- memcpy(cld_filter.general_fields,
- f->input.general_fields,
- sizeof(f->input.general_fields));
-
- if (((f->input.flags &
- I40E_AQC_ADD_CLOUD_FILTER_0X11) ==
- I40E_AQC_ADD_CLOUD_FILTER_0X11) ||
- ((f->input.flags &
- I40E_AQC_ADD_CLOUD_FILTER_0X12) ==
- I40E_AQC_ADD_CLOUD_FILTER_0X12) ||
- ((f->input.flags &
- I40E_AQC_ADD_CLOUD_FILTER_0X10) ==
- I40E_AQC_ADD_CLOUD_FILTER_0X10))
- big_buffer = 1;
-
- if (big_buffer)
- i40e_aq_add_cloud_filters_bb(hw,
- vsi->seid, &cld_filter, 1);
- else
- i40e_aq_add_cloud_filters(hw, vsi->seid,
- &cld_filter.element, 1);
- }
-}
-
static void
i40e_filter_restore(struct i40e_pf *pf)
{
- i40e_tunnel_filter_restore(pf);
i40e_fdir_filter_restore(pf);
(void)i40e_hash_filter_restore(pf);
}
diff --git a/drivers/net/intel/i40e/i40e_ethdev.h b/drivers/net/intel/i40e/i40e_ethdev.h
index 7a326fa75b..9d68d8fd0f 100644
--- a/drivers/net/intel/i40e/i40e_ethdev.h
+++ b/drivers/net/intel/i40e/i40e_ethdev.h
@@ -877,8 +877,8 @@ enum i40e_tunnel_iptype {
I40E_TUNNEL_IPTYPE_IPV6,
};
-/* Tunnel filter struct */
-struct i40e_tunnel_filter_input {
+/* Tunnel filter hash table match key */
+struct i40e_tunnel_filter_match_key {
uint8_t outer_mac[6]; /* Outer mac address to match */
uint8_t inner_mac[6]; /* Inner mac address to match */
uint16_t inner_vlan; /* Inner vlan address to match */
@@ -888,20 +888,9 @@ struct i40e_tunnel_filter_input {
uint16_t general_fields[32]; /* Big buffer */
};
-struct i40e_tunnel_filter {
- TAILQ_ENTRY(i40e_tunnel_filter) rules;
- struct i40e_tunnel_filter_input input;
- uint8_t is_to_vf; /* 0 - to PF, 1 - to VF */
- uint16_t vf_id; /* VF id, available when is_to_vf is 1. */
- uint16_t queue; /* Queue assigned to when match */
-};
-
-TAILQ_HEAD(i40e_tunnel_filter_list, i40e_tunnel_filter);
-
-struct i40e_tunnel_rule {
- struct i40e_tunnel_filter_list tunnel_list;
- struct i40e_tunnel_filter **hash_map;
+struct i40e_tunnel_state {
struct rte_hash *hash_table;
+ uint16_t refcnt;
};
/**
@@ -1170,7 +1159,7 @@ struct i40e_pf {
struct i40e_vmdq_info *vmdq;
struct i40e_fdir_info fdir; /* flow director info */
- struct i40e_tunnel_rule tunnel; /* Tunnel filter rule */
+ struct i40e_tunnel_state tunnel_state; /* tunnel flow engine state */
struct i40e_rss_conf_list rss_config_list; /* RSS rule list */
struct i40e_queue_regions queue_region; /* queue region info */
struct i40e_fc_conf fc_conf; /* Flow control conf */
@@ -1317,23 +1306,10 @@ struct i40e_vf_representor {
extern const struct rte_flow_ops i40e_flow_ops;
struct i40e_filter_ctx {
- union {
- struct i40e_tunnel_filter_conf consistent_tunnel_filter;
- struct i40e_rte_flow_rss_conf rss_conf;
- };
+ struct i40e_rte_flow_rss_conf rss_conf;
enum rte_filter_type type;
};
-typedef int (*parse_filter_t)(struct rte_eth_dev *dev,
- const struct rte_flow_item pattern[],
- const struct rte_flow_action actions[],
- struct rte_flow_error *error,
- struct i40e_filter_ctx *filter);
-struct i40e_valid_pattern {
- enum rte_flow_item_type *items;
- parse_filter_t parse_filter;
-};
-
int i40e_dev_switch_queues(struct i40e_pf *pf, bool on);
int i40e_vsi_release(struct i40e_vsi *vsi);
struct i40e_vsi *i40e_vsi_setup(struct i40e_pf *pf,
@@ -1399,11 +1375,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_tunnel_filter *
-i40e_sw_tunnel_filter_lookup(struct i40e_tunnel_rule *tunnel_rule,
- const struct i40e_tunnel_filter_input *input);
-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_program(struct i40e_pf *pf,
struct rte_eth_ethertype_filter *filter,
@@ -1433,9 +1404,14 @@ void i40e_fdir_flex_store(struct i40e_pf *pf,
int i40e_dev_tunnel_filter_set(struct i40e_pf *pf,
struct rte_eth_tunnel_filter_conf *tunnel_filter,
uint8_t add);
-int i40e_dev_consistent_tunnel_filter_set(struct i40e_pf *pf,
- struct i40e_tunnel_filter_conf *tunnel_filter,
- uint8_t add);
+int i40e_tunnel_filter_match_key_get(struct i40e_pf *pf,
+ struct i40e_tunnel_filter_conf *tunnel_filter,
+ struct i40e_tunnel_filter_match_key *out);
+struct i40e_tunnel_state *i40e_tunnel_state_attach(struct rte_eth_dev_data *dev_data);
+void i40e_tunnel_state_detach(struct i40e_tunnel_state *state);
+int i40e_tunnel_filter_program(struct i40e_pf *pf,
+ struct i40e_tunnel_filter_conf *tunnel_filter,
+ uint8_t add);
int i40e_fdir_flush(struct i40e_pf *pf);
int i40e_find_all_vlan_for_mac(struct i40e_vsi *vsi,
struct i40e_macvlan_filter *mv_f,
diff --git a/drivers/net/intel/i40e/i40e_flow.c b/drivers/net/intel/i40e/i40e_flow.c
index 104749eb8c..0de0c82521 100644
--- a/drivers/net/intel/i40e/i40e_flow.c
+++ b/drivers/net/intel/i40e/i40e_flow.c
@@ -34,6 +34,12 @@ const struct ci_flow_engine_list i40e_flow_engine_list = {
{
&i40e_flow_engine_ethertype,
&i40e_flow_engine_fdir,
+ &i40e_flow_engine_tunnel_qinq,
+ &i40e_flow_engine_tunnel_vxlan,
+ &i40e_flow_engine_tunnel_nvgre,
+ &i40e_flow_engine_tunnel_mpls,
+ &i40e_flow_engine_tunnel_gtp,
+ &i40e_flow_engine_tunnel_l4,
}
};
@@ -60,50 +66,7 @@ static int i40e_flow_dev_dump(struct rte_eth_dev *dev,
struct rte_flow *flow,
FILE *file,
struct rte_flow_error *error);
-static int i40e_flow_parse_tunnel_action(struct rte_eth_dev *dev,
- const struct rte_flow_action *actions,
- struct rte_flow_error *error,
- struct i40e_tunnel_filter_conf *filter);
-static int i40e_flow_parse_vxlan_filter(struct rte_eth_dev *dev,
- const struct rte_flow_item pattern[],
- const struct rte_flow_action actions[],
- struct rte_flow_error *error,
- struct i40e_filter_ctx *filter);
-static int i40e_flow_parse_nvgre_filter(struct rte_eth_dev *dev,
- const struct rte_flow_item pattern[],
- const struct rte_flow_action actions[],
- struct rte_flow_error *error,
- struct i40e_filter_ctx *filter);
-static int i40e_flow_parse_mpls_filter(struct rte_eth_dev *dev,
- const struct rte_flow_item pattern[],
- const struct rte_flow_action actions[],
- struct rte_flow_error *error,
- struct i40e_filter_ctx *filter);
-static int i40e_flow_parse_gtp_filter(struct rte_eth_dev *dev,
- const struct rte_flow_item pattern[],
- const struct rte_flow_action actions[],
- struct rte_flow_error *error,
- struct i40e_filter_ctx *filter);
-static int i40e_flow_destroy_tunnel_filter(struct i40e_pf *pf,
- struct i40e_tunnel_filter *filter);
-static int i40e_flow_flush_tunnel_filter(struct i40e_pf *pf);
-static int
-i40e_flow_parse_qinq_filter(struct rte_eth_dev *dev,
- const struct rte_flow_item pattern[],
- const struct rte_flow_action actions[],
- struct rte_flow_error *error,
- struct i40e_filter_ctx *filter);
-static int
-i40e_flow_parse_qinq_pattern(struct rte_eth_dev *dev,
- const struct rte_flow_item *pattern,
- struct rte_flow_error *error,
- struct i40e_tunnel_filter_conf *filter);
-static int i40e_flow_parse_l4_cloud_filter(struct rte_eth_dev *dev,
- const struct rte_flow_item pattern[],
- const struct rte_flow_action actions[],
- struct rte_flow_error *error,
- struct i40e_filter_ctx *filter);
const struct rte_flow_ops i40e_flow_ops = {
.validate = i40e_flow_validate,
.create = i40e_flow_create,
@@ -113,322 +76,12 @@ const struct rte_flow_ops i40e_flow_ops = {
.dev_dump = i40e_flow_dev_dump,
};
-static enum rte_flow_item_type pattern_fdir_ipv4_udp[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV4,
- RTE_FLOW_ITEM_TYPE_UDP,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_fdir_ipv4_tcp[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV4,
- RTE_FLOW_ITEM_TYPE_TCP,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_fdir_ipv4_sctp[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV4,
- RTE_FLOW_ITEM_TYPE_SCTP,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_fdir_ipv4_gtpc[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV4,
- RTE_FLOW_ITEM_TYPE_UDP,
- RTE_FLOW_ITEM_TYPE_GTPC,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_fdir_ipv4_gtpu[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV4,
- RTE_FLOW_ITEM_TYPE_UDP,
- RTE_FLOW_ITEM_TYPE_GTPU,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_fdir_ipv6_udp[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV6,
- RTE_FLOW_ITEM_TYPE_UDP,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_fdir_ipv6_tcp[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV6,
- RTE_FLOW_ITEM_TYPE_TCP,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_fdir_ipv6_sctp[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV6,
- RTE_FLOW_ITEM_TYPE_SCTP,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_fdir_ipv6_gtpc[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV6,
- RTE_FLOW_ITEM_TYPE_UDP,
- RTE_FLOW_ITEM_TYPE_GTPC,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_fdir_ipv6_gtpu[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV6,
- RTE_FLOW_ITEM_TYPE_UDP,
- RTE_FLOW_ITEM_TYPE_GTPU,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-/* Pattern matched tunnel filter */
-static enum rte_flow_item_type pattern_vxlan_1[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV4,
- RTE_FLOW_ITEM_TYPE_UDP,
- RTE_FLOW_ITEM_TYPE_VXLAN,
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_vxlan_2[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV6,
- RTE_FLOW_ITEM_TYPE_UDP,
- RTE_FLOW_ITEM_TYPE_VXLAN,
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_vxlan_3[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV4,
- RTE_FLOW_ITEM_TYPE_UDP,
- RTE_FLOW_ITEM_TYPE_VXLAN,
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_VLAN,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_vxlan_4[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV6,
- RTE_FLOW_ITEM_TYPE_UDP,
- RTE_FLOW_ITEM_TYPE_VXLAN,
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_VLAN,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_nvgre_1[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV4,
- RTE_FLOW_ITEM_TYPE_NVGRE,
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_nvgre_2[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV6,
- RTE_FLOW_ITEM_TYPE_NVGRE,
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_nvgre_3[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV4,
- RTE_FLOW_ITEM_TYPE_NVGRE,
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_VLAN,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_nvgre_4[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV6,
- RTE_FLOW_ITEM_TYPE_NVGRE,
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_VLAN,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_mpls_1[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV4,
- RTE_FLOW_ITEM_TYPE_UDP,
- RTE_FLOW_ITEM_TYPE_MPLS,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_mpls_2[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV6,
- RTE_FLOW_ITEM_TYPE_UDP,
- RTE_FLOW_ITEM_TYPE_MPLS,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_mpls_3[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV4,
- RTE_FLOW_ITEM_TYPE_GRE,
- RTE_FLOW_ITEM_TYPE_MPLS,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_mpls_4[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_IPV6,
- RTE_FLOW_ITEM_TYPE_GRE,
- RTE_FLOW_ITEM_TYPE_MPLS,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static enum rte_flow_item_type pattern_qinq_1[] = {
- RTE_FLOW_ITEM_TYPE_ETH,
- RTE_FLOW_ITEM_TYPE_VLAN,
- RTE_FLOW_ITEM_TYPE_VLAN,
- RTE_FLOW_ITEM_TYPE_END,
-};
-
-static struct i40e_valid_pattern i40e_supported_patterns[] = {
- /* VXLAN */
- { pattern_vxlan_1, i40e_flow_parse_vxlan_filter },
- { pattern_vxlan_2, i40e_flow_parse_vxlan_filter },
- { pattern_vxlan_3, i40e_flow_parse_vxlan_filter },
- { pattern_vxlan_4, i40e_flow_parse_vxlan_filter },
- /* NVGRE */
- { pattern_nvgre_1, i40e_flow_parse_nvgre_filter },
- { pattern_nvgre_2, i40e_flow_parse_nvgre_filter },
- { pattern_nvgre_3, i40e_flow_parse_nvgre_filter },
- { pattern_nvgre_4, i40e_flow_parse_nvgre_filter },
- /* MPLSoUDP & MPLSoGRE */
- { pattern_mpls_1, i40e_flow_parse_mpls_filter },
- { pattern_mpls_2, i40e_flow_parse_mpls_filter },
- { pattern_mpls_3, i40e_flow_parse_mpls_filter },
- { pattern_mpls_4, i40e_flow_parse_mpls_filter },
- /* GTP-C & GTP-U */
- { pattern_fdir_ipv4_gtpc, i40e_flow_parse_gtp_filter },
- { pattern_fdir_ipv4_gtpu, i40e_flow_parse_gtp_filter },
- { pattern_fdir_ipv6_gtpc, i40e_flow_parse_gtp_filter },
- { pattern_fdir_ipv6_gtpu, i40e_flow_parse_gtp_filter },
- /* QINQ */
- { pattern_qinq_1, i40e_flow_parse_qinq_filter },
- /* L4 over port */
- { pattern_fdir_ipv4_udp, i40e_flow_parse_l4_cloud_filter },
- { pattern_fdir_ipv4_tcp, i40e_flow_parse_l4_cloud_filter },
- { pattern_fdir_ipv4_sctp, i40e_flow_parse_l4_cloud_filter },
- { pattern_fdir_ipv6_udp, i40e_flow_parse_l4_cloud_filter },
- { pattern_fdir_ipv6_tcp, i40e_flow_parse_l4_cloud_filter },
- { pattern_fdir_ipv6_sctp, i40e_flow_parse_l4_cloud_filter },
-};
-
-/* Find the first VOID or non-VOID item pointer */
-static const struct rte_flow_item *
-i40e_find_first_item(const struct rte_flow_item *item, bool is_void)
-{
- bool is_find;
-
- while (item->type != RTE_FLOW_ITEM_TYPE_END) {
- if (is_void)
- is_find = item->type == RTE_FLOW_ITEM_TYPE_VOID;
- else
- is_find = item->type != RTE_FLOW_ITEM_TYPE_VOID;
- if (is_find)
- break;
- item++;
- }
- return item;
-}
-
-/* Skip all VOID items of the pattern */
-static void
-i40e_pattern_skip_void_item(struct rte_flow_item *items,
- const struct rte_flow_item *pattern)
-{
- uint32_t cpy_count = 0;
- const struct rte_flow_item *pb = pattern, *pe = pattern;
-
- for (;;) {
- /* Find a non-void item first */
- pb = i40e_find_first_item(pb, false);
- if (pb->type == RTE_FLOW_ITEM_TYPE_END) {
- pe = pb;
- break;
- }
-
- /* Find a void item */
- pe = i40e_find_first_item(pb + 1, true);
-
- cpy_count = pe - pb;
- memcpy(items, pb, sizeof(struct rte_flow_item) * cpy_count);
-
- items += cpy_count;
-
- if (pe->type == RTE_FLOW_ITEM_TYPE_END) {
- pb = pe;
- break;
- }
-
- pb = pe + 1;
- }
- /* Copy the END item. */
- memcpy(items, pe, sizeof(struct rte_flow_item));
-}
-
-/* Check if the pattern matches a supported item type array */
-static bool
-i40e_match_pattern(enum rte_flow_item_type *item_array,
- struct rte_flow_item *pattern)
-{
- struct rte_flow_item *item = pattern;
-
- while ((*item_array == item->type) &&
- (*item_array != RTE_FLOW_ITEM_TYPE_END)) {
- item_array++;
- item++;
- }
-
- return (*item_array == RTE_FLOW_ITEM_TYPE_END &&
- item->type == RTE_FLOW_ITEM_TYPE_END);
-}
-
-/* Find if there's parse filter function matched */
-static parse_filter_t
-i40e_find_parse_filter_func(struct rte_flow_item *pattern, uint32_t *idx)
-{
- parse_filter_t parse_filter = NULL;
- uint8_t i = *idx;
-
- for (; i < RTE_DIM(i40e_supported_patterns); i++) {
- if (i40e_match_pattern(i40e_supported_patterns[i].items,
- pattern)) {
- parse_filter = i40e_supported_patterns[i].parse_filter;
- break;
- }
- }
-
- *idx = ++i;
-
- return parse_filter;
-}
-
#define I40E_FLOW_DUMP_CHUNK_BYTES 32
static const char *
i40e_flow_rule_name(enum rte_filter_type filter_type)
{
switch (filter_type) {
- case RTE_ETH_FILTER_TUNNEL:
- return "tunnel";
case RTE_ETH_FILTER_HASH:
return "hash";
default:
@@ -440,8 +93,6 @@ static size_t
i40e_flow_rule_size(enum rte_filter_type filter_type)
{
switch (filter_type) {
- case RTE_ETH_FILTER_TUNNEL:
- return sizeof(struct i40e_tunnel_filter);
case RTE_ETH_FILTER_HASH:
return sizeof(struct i40e_rss_filter);
default:
@@ -631,1190 +282,6 @@ i40e_flow_fdir_get_pctype_value(struct i40e_pf *pf,
return I40E_FILTER_PCTYPE_INVALID;
}
-/* Parse to get the action info of a tunnel filter
- * Tunnel action only supports PF, VF and QUEUE.
- */
-static int
-i40e_flow_parse_tunnel_action(struct rte_eth_dev *dev,
- const struct rte_flow_action *actions,
- struct rte_flow_error *error,
- struct i40e_tunnel_filter_conf *filter)
-{
- struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
- const struct rte_flow_action_queue *act_q;
- struct ci_flow_actions parsed_actions = {0};
- struct ci_flow_actions_check_param ac_param = {
- .allowed_types = (enum rte_flow_action_type[]) {
- RTE_FLOW_ACTION_TYPE_QUEUE,
- RTE_FLOW_ACTION_TYPE_PF,
- RTE_FLOW_ACTION_TYPE_VF,
- RTE_FLOW_ACTION_TYPE_END
- },
- .max_actions = 2,
- };
- const struct rte_flow_action *first, *second;
- int ret;
-
- ret = ci_flow_check_actions(actions, &ac_param, &parsed_actions, error);
- if (ret)
- return ret;
- first = parsed_actions.actions[0];
- /* can be NULL */
- second = parsed_actions.actions[1];
-
- /* first action must be PF or VF */
- if (first->type == RTE_FLOW_ACTION_TYPE_VF) {
- const struct rte_flow_action_vf *vf = first->conf;
- if (vf->id >= pf->vf_num) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ACTION, first,
- "Invalid VF ID for tunnel filter");
- return -rte_errno;
- }
- filter->vf_id = vf->id;
- filter->is_to_vf = 1;
- } else if (first->type != RTE_FLOW_ACTION_TYPE_PF) {
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ACTION, first,
- "Unsupported action");
- }
-
- /* check if second action is QUEUE */
- if (second == NULL)
- return 0;
-
- act_q = second->conf;
- /* check queue ID for PF flow */
- if (!filter->is_to_vf && act_q->index >= pf->dev_data->nb_rx_queues) {
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ACTION_CONF, act_q,
- "Invalid queue ID for tunnel filter");
- }
- /* check queue ID for VF flow */
- if (filter->is_to_vf && act_q->index >= pf->vf_nb_qps) {
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ACTION_CONF, act_q,
- "Invalid queue ID for tunnel filter");
- }
- filter->queue_id = act_q->index;
-
- return 0;
-}
-
-/* 1. Last in item should be NULL as range is not supported.
- * 2. Supported filter types: Source port only and Destination port only.
- * 3. Mask of fields which need to be matched should be
- * filled with 1.
- * 4. Mask of fields which needn't to be matched should be
- * filled with 0.
- */
-static int
-i40e_flow_parse_l4_pattern(const struct rte_flow_item *pattern,
- struct rte_flow_error *error,
- struct i40e_tunnel_filter_conf *filter)
-{
- const struct rte_flow_item_sctp *sctp_spec, *sctp_mask;
- const struct rte_flow_item_tcp *tcp_spec, *tcp_mask;
- const struct rte_flow_item_udp *udp_spec, *udp_mask;
- const struct rte_flow_item *item = pattern;
- enum rte_flow_item_type item_type;
-
- for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
- if (item->last) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Not support range");
- return -rte_errno;
- }
- item_type = item->type;
- switch (item_type) {
- case RTE_FLOW_ITEM_TYPE_ETH:
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid ETH item");
- return -rte_errno;
- }
-
- break;
- case RTE_FLOW_ITEM_TYPE_IPV4:
- filter->ip_type = I40E_TUNNEL_IPTYPE_IPV4;
- /* IPv4 is used to describe protocol,
- * spec and mask should be NULL.
- */
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid IPv4 item");
- return -rte_errno;
- }
-
- break;
- case RTE_FLOW_ITEM_TYPE_IPV6:
- filter->ip_type = I40E_TUNNEL_IPTYPE_IPV6;
- /* IPv6 is used to describe protocol,
- * spec and mask should be NULL.
- */
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid IPv6 item");
- return -rte_errno;
- }
-
- break;
- case RTE_FLOW_ITEM_TYPE_UDP:
- udp_spec = item->spec;
- udp_mask = item->mask;
-
- if (!udp_spec || !udp_mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid udp item");
- return -rte_errno;
- }
-
- if (udp_spec->hdr.src_port != 0 &&
- udp_spec->hdr.dst_port != 0) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid udp spec");
- return -rte_errno;
- }
-
- if (udp_spec->hdr.src_port != 0) {
- filter->l4_port_type =
- I40E_L4_PORT_TYPE_SRC;
- filter->tenant_id =
- rte_be_to_cpu_32(udp_spec->hdr.src_port);
- }
-
- if (udp_spec->hdr.dst_port != 0) {
- filter->l4_port_type =
- I40E_L4_PORT_TYPE_DST;
- filter->tenant_id =
- rte_be_to_cpu_32(udp_spec->hdr.dst_port);
- }
-
- filter->tunnel_type = I40E_CLOUD_TYPE_UDP;
-
- break;
- case RTE_FLOW_ITEM_TYPE_TCP:
- tcp_spec = item->spec;
- tcp_mask = item->mask;
-
- if (!tcp_spec || !tcp_mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid tcp item");
- return -rte_errno;
- }
-
- if (tcp_spec->hdr.src_port != 0 &&
- tcp_spec->hdr.dst_port != 0) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid tcp spec");
- return -rte_errno;
- }
-
- if (tcp_spec->hdr.src_port != 0) {
- filter->l4_port_type =
- I40E_L4_PORT_TYPE_SRC;
- filter->tenant_id =
- rte_be_to_cpu_32(tcp_spec->hdr.src_port);
- }
-
- if (tcp_spec->hdr.dst_port != 0) {
- filter->l4_port_type =
- I40E_L4_PORT_TYPE_DST;
- filter->tenant_id =
- rte_be_to_cpu_32(tcp_spec->hdr.dst_port);
- }
-
- filter->tunnel_type = I40E_CLOUD_TYPE_TCP;
-
- break;
- case RTE_FLOW_ITEM_TYPE_SCTP:
- sctp_spec = item->spec;
- sctp_mask = item->mask;
-
- if (!sctp_spec || !sctp_mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid sctp item");
- return -rte_errno;
- }
-
- if (sctp_spec->hdr.src_port != 0 &&
- sctp_spec->hdr.dst_port != 0) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid sctp spec");
- return -rte_errno;
- }
-
- if (sctp_spec->hdr.src_port != 0) {
- filter->l4_port_type =
- I40E_L4_PORT_TYPE_SRC;
- filter->tenant_id =
- rte_be_to_cpu_32(sctp_spec->hdr.src_port);
- }
-
- if (sctp_spec->hdr.dst_port != 0) {
- filter->l4_port_type =
- I40E_L4_PORT_TYPE_DST;
- filter->tenant_id =
- rte_be_to_cpu_32(sctp_spec->hdr.dst_port);
- }
-
- filter->tunnel_type = I40E_CLOUD_TYPE_SCTP;
-
- break;
- default:
- break;
- }
- }
-
- return 0;
-}
-
-static int
-i40e_flow_parse_l4_cloud_filter(struct rte_eth_dev *dev,
- const struct rte_flow_item pattern[],
- const struct rte_flow_action actions[],
- struct rte_flow_error *error,
- struct i40e_filter_ctx *filter)
-{
- struct i40e_tunnel_filter_conf *tunnel_filter = &filter->consistent_tunnel_filter;
- int ret;
-
- ret = i40e_flow_parse_l4_pattern(pattern, error, tunnel_filter);
- if (ret)
- return ret;
-
- ret = i40e_flow_parse_tunnel_action(dev, actions, error, tunnel_filter);
- if (ret)
- return ret;
-
- filter->type = RTE_ETH_FILTER_TUNNEL;
-
- return ret;
-}
-
-static uint16_t i40e_supported_tunnel_filter_types[] = {
- RTE_ETH_TUNNEL_FILTER_IMAC | RTE_ETH_TUNNEL_FILTER_TENID |
- RTE_ETH_TUNNEL_FILTER_IVLAN,
- RTE_ETH_TUNNEL_FILTER_IMAC | RTE_ETH_TUNNEL_FILTER_IVLAN,
- RTE_ETH_TUNNEL_FILTER_IMAC | RTE_ETH_TUNNEL_FILTER_TENID,
- RTE_ETH_TUNNEL_FILTER_OMAC | RTE_ETH_TUNNEL_FILTER_TENID |
- RTE_ETH_TUNNEL_FILTER_IMAC,
- RTE_ETH_TUNNEL_FILTER_IMAC,
-};
-
-static int
-i40e_check_tunnel_filter_type(uint8_t filter_type)
-{
- uint8_t i;
-
- for (i = 0; i < RTE_DIM(i40e_supported_tunnel_filter_types); i++) {
- if (filter_type == i40e_supported_tunnel_filter_types[i])
- return 0;
- }
-
- return -1;
-}
-
-/* 1. Last in item should be NULL as range is not supported.
- * 2. Supported filter types: IMAC_IVLAN_TENID, IMAC_IVLAN,
- * IMAC_TENID, OMAC_TENID_IMAC and IMAC.
- * 3. Mask of fields which need to be matched should be
- * filled with 1.
- * 4. Mask of fields which needn't to be matched should be
- * filled with 0.
- */
-static int
-i40e_flow_parse_vxlan_pattern(__rte_unused struct rte_eth_dev *dev,
- const struct rte_flow_item *pattern,
- struct rte_flow_error *error,
- struct i40e_tunnel_filter_conf *filter)
-{
- const struct rte_flow_item *item = pattern;
- const struct rte_flow_item_eth *eth_spec;
- const struct rte_flow_item_eth *eth_mask;
- const struct rte_flow_item_vxlan *vxlan_spec;
- const struct rte_flow_item_vxlan *vxlan_mask;
- const struct rte_flow_item_vlan *vlan_spec;
- const struct rte_flow_item_vlan *vlan_mask;
- uint8_t filter_type = 0;
- bool is_vni_masked = 0;
- uint8_t vni_mask[] = {0xFF, 0xFF, 0xFF};
- enum rte_flow_item_type item_type;
- bool vxlan_flag = 0;
- uint32_t tenant_id_be = 0;
- int ret;
-
- for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
- if (item->last) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Not support range");
- return -rte_errno;
- }
- item_type = item->type;
- switch (item_type) {
- case RTE_FLOW_ITEM_TYPE_ETH:
- eth_spec = item->spec;
- eth_mask = item->mask;
-
- /* Check if ETH item is used for place holder.
- * If yes, both spec and mask should be NULL.
- * If no, both spec and mask shouldn't be NULL.
- */
- if ((!eth_spec && eth_mask) ||
- (eth_spec && !eth_mask)) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid ether spec/mask");
- return -rte_errno;
- }
-
- if (eth_spec && eth_mask) {
- /* DST address of inner MAC shouldn't be masked.
- * SRC address of Inner MAC should be masked.
- */
- if (!rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr) ||
- !rte_is_zero_ether_addr(ð_mask->hdr.src_addr) ||
- eth_mask->hdr.ether_type) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid ether spec/mask");
- return -rte_errno;
- }
-
- if (!vxlan_flag) {
- memcpy(&filter->outer_mac,
- ð_spec->hdr.dst_addr,
- RTE_ETHER_ADDR_LEN);
- filter_type |= RTE_ETH_TUNNEL_FILTER_OMAC;
- } else {
- memcpy(&filter->inner_mac,
- ð_spec->hdr.dst_addr,
- RTE_ETHER_ADDR_LEN);
- filter_type |= RTE_ETH_TUNNEL_FILTER_IMAC;
- }
- }
- break;
- case RTE_FLOW_ITEM_TYPE_VLAN:
- vlan_spec = item->spec;
- vlan_mask = item->mask;
- if (!(vlan_spec && vlan_mask) ||
- vlan_mask->hdr.eth_proto) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid vlan item");
- return -rte_errno;
- }
-
- if (vlan_spec && vlan_mask) {
- if (vlan_mask->hdr.vlan_tci ==
- rte_cpu_to_be_16(I40E_VLAN_TCI_MASK))
- filter->inner_vlan =
- rte_be_to_cpu_16(vlan_spec->hdr.vlan_tci) &
- I40E_VLAN_TCI_MASK;
- filter_type |= RTE_ETH_TUNNEL_FILTER_IVLAN;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_IPV4:
- filter->ip_type = I40E_TUNNEL_IPTYPE_IPV4;
- /* IPv4 is used to describe protocol,
- * spec and mask should be NULL.
- */
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid IPv4 item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_IPV6:
- filter->ip_type = I40E_TUNNEL_IPTYPE_IPV6;
- /* IPv6 is used to describe protocol,
- * spec and mask should be NULL.
- */
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid IPv6 item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_UDP:
- /* UDP is used to describe protocol,
- * spec and mask should be NULL.
- */
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid UDP item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_VXLAN:
- vxlan_spec = item->spec;
- vxlan_mask = item->mask;
- /* Check if VXLAN item is used to describe protocol.
- * If yes, both spec and mask should be NULL.
- * If no, both spec and mask shouldn't be NULL.
- */
- if ((!vxlan_spec && vxlan_mask) ||
- (vxlan_spec && !vxlan_mask)) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid VXLAN item");
- return -rte_errno;
- }
-
- /* Check if VNI is masked. */
- if (vxlan_spec && vxlan_mask) {
- is_vni_masked =
- !!memcmp(vxlan_mask->hdr.vni, vni_mask,
- RTE_DIM(vni_mask));
- if (is_vni_masked) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid VNI mask");
- return -rte_errno;
- }
-
- memcpy(((uint8_t *)&tenant_id_be + 1),
- vxlan_spec->hdr.vni, 3);
- filter->tenant_id =
- rte_be_to_cpu_32(tenant_id_be);
- filter_type |= RTE_ETH_TUNNEL_FILTER_TENID;
- }
-
- vxlan_flag = 1;
- break;
- default:
- break;
- }
- }
-
- ret = i40e_check_tunnel_filter_type(filter_type);
- if (ret < 0) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- NULL,
- "Invalid filter type");
- return -rte_errno;
- }
- filter->filter_type = filter_type;
-
- filter->tunnel_type = I40E_TUNNEL_TYPE_VXLAN;
-
- return 0;
-}
-
-static int
-i40e_flow_parse_vxlan_filter(struct rte_eth_dev *dev,
- const struct rte_flow_item pattern[],
- const struct rte_flow_action actions[],
- struct rte_flow_error *error,
- struct i40e_filter_ctx *filter)
-{
- struct i40e_tunnel_filter_conf *tunnel_filter = &filter->consistent_tunnel_filter;
- int ret;
-
- ret = i40e_flow_parse_vxlan_pattern(dev, pattern,
- error, tunnel_filter);
- if (ret)
- return ret;
-
- ret = i40e_flow_parse_tunnel_action(dev, actions, error, tunnel_filter);
- if (ret)
- return ret;
-
- filter->type = RTE_ETH_FILTER_TUNNEL;
-
- return ret;
-}
-
-/* 1. Last in item should be NULL as range is not supported.
- * 2. Supported filter types: IMAC_IVLAN_TENID, IMAC_IVLAN,
- * IMAC_TENID, OMAC_TENID_IMAC and IMAC.
- * 3. Mask of fields which need to be matched should be
- * filled with 1.
- * 4. Mask of fields which needn't to be matched should be
- * filled with 0.
- */
-static int
-i40e_flow_parse_nvgre_pattern(__rte_unused struct rte_eth_dev *dev,
- const struct rte_flow_item *pattern,
- struct rte_flow_error *error,
- struct i40e_tunnel_filter_conf *filter)
-{
- const struct rte_flow_item *item = pattern;
- const struct rte_flow_item_eth *eth_spec;
- const struct rte_flow_item_eth *eth_mask;
- const struct rte_flow_item_nvgre *nvgre_spec;
- const struct rte_flow_item_nvgre *nvgre_mask;
- const struct rte_flow_item_vlan *vlan_spec;
- const struct rte_flow_item_vlan *vlan_mask;
- enum rte_flow_item_type item_type;
- uint8_t filter_type = 0;
- bool is_tni_masked = 0;
- uint8_t tni_mask[] = {0xFF, 0xFF, 0xFF};
- bool nvgre_flag = 0;
- uint32_t tenant_id_be = 0;
- int ret;
-
- for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
- if (item->last) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Not support range");
- return -rte_errno;
- }
- item_type = item->type;
- switch (item_type) {
- case RTE_FLOW_ITEM_TYPE_ETH:
- eth_spec = item->spec;
- eth_mask = item->mask;
-
- /* Check if ETH item is used for place holder.
- * If yes, both spec and mask should be NULL.
- * If no, both spec and mask shouldn't be NULL.
- */
- if ((!eth_spec && eth_mask) ||
- (eth_spec && !eth_mask)) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid ether spec/mask");
- return -rte_errno;
- }
-
- if (eth_spec && eth_mask) {
- /* DST address of inner MAC shouldn't be masked.
- * SRC address of Inner MAC should be masked.
- */
- if (!rte_is_broadcast_ether_addr(ð_mask->hdr.dst_addr) ||
- !rte_is_zero_ether_addr(ð_mask->hdr.src_addr) ||
- eth_mask->hdr.ether_type) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid ether spec/mask");
- return -rte_errno;
- }
-
- if (!nvgre_flag) {
- memcpy(&filter->outer_mac,
- ð_spec->hdr.dst_addr,
- RTE_ETHER_ADDR_LEN);
- filter_type |= RTE_ETH_TUNNEL_FILTER_OMAC;
- } else {
- memcpy(&filter->inner_mac,
- ð_spec->hdr.dst_addr,
- RTE_ETHER_ADDR_LEN);
- filter_type |= RTE_ETH_TUNNEL_FILTER_IMAC;
- }
- }
-
- break;
- case RTE_FLOW_ITEM_TYPE_VLAN:
- vlan_spec = item->spec;
- vlan_mask = item->mask;
- if (!(vlan_spec && vlan_mask) ||
- vlan_mask->hdr.eth_proto) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid vlan item");
- return -rte_errno;
- }
-
- if (vlan_spec && vlan_mask) {
- if (vlan_mask->hdr.vlan_tci ==
- rte_cpu_to_be_16(I40E_VLAN_TCI_MASK))
- filter->inner_vlan =
- rte_be_to_cpu_16(vlan_spec->hdr.vlan_tci) &
- I40E_VLAN_TCI_MASK;
- filter_type |= RTE_ETH_TUNNEL_FILTER_IVLAN;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_IPV4:
- filter->ip_type = I40E_TUNNEL_IPTYPE_IPV4;
- /* IPv4 is used to describe protocol,
- * spec and mask should be NULL.
- */
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid IPv4 item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_IPV6:
- filter->ip_type = I40E_TUNNEL_IPTYPE_IPV6;
- /* IPv6 is used to describe protocol,
- * spec and mask should be NULL.
- */
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid IPv6 item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_NVGRE:
- nvgre_spec = item->spec;
- nvgre_mask = item->mask;
- /* Check if NVGRE item is used to describe protocol.
- * If yes, both spec and mask should be NULL.
- * If no, both spec and mask shouldn't be NULL.
- */
- if ((!nvgre_spec && nvgre_mask) ||
- (nvgre_spec && !nvgre_mask)) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid NVGRE item");
- return -rte_errno;
- }
-
- if (nvgre_spec && nvgre_mask) {
- is_tni_masked =
- !!memcmp(nvgre_mask->tni, tni_mask,
- RTE_DIM(tni_mask));
- if (is_tni_masked) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid TNI mask");
- return -rte_errno;
- }
- if (nvgre_mask->protocol &&
- nvgre_mask->protocol != 0xFFFF) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid NVGRE item");
- return -rte_errno;
- }
- if (nvgre_mask->c_k_s_rsvd0_ver &&
- nvgre_mask->c_k_s_rsvd0_ver !=
- rte_cpu_to_be_16(0xFFFF)) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid NVGRE item");
- return -rte_errno;
- }
- if (nvgre_spec->c_k_s_rsvd0_ver !=
- rte_cpu_to_be_16(0x2000) &&
- nvgre_mask->c_k_s_rsvd0_ver) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid NVGRE item");
- return -rte_errno;
- }
- if (nvgre_mask->protocol &&
- nvgre_spec->protocol !=
- rte_cpu_to_be_16(0x6558)) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid NVGRE item");
- return -rte_errno;
- }
- memcpy(((uint8_t *)&tenant_id_be + 1),
- nvgre_spec->tni, 3);
- filter->tenant_id =
- rte_be_to_cpu_32(tenant_id_be);
- filter_type |= RTE_ETH_TUNNEL_FILTER_TENID;
- }
-
- nvgre_flag = 1;
- break;
- default:
- break;
- }
- }
-
- ret = i40e_check_tunnel_filter_type(filter_type);
- if (ret < 0) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- NULL,
- "Invalid filter type");
- return -rte_errno;
- }
- filter->filter_type = filter_type;
-
- filter->tunnel_type = I40E_TUNNEL_TYPE_NVGRE;
-
- return 0;
-}
-
-static int
-i40e_flow_parse_nvgre_filter(struct rte_eth_dev *dev,
- const struct rte_flow_item pattern[],
- const struct rte_flow_action actions[],
- struct rte_flow_error *error,
- struct i40e_filter_ctx *filter)
-{
- struct i40e_tunnel_filter_conf *tunnel_filter = &filter->consistent_tunnel_filter;
- int ret;
-
- ret = i40e_flow_parse_nvgre_pattern(dev, pattern,
- error, tunnel_filter);
- if (ret)
- return ret;
-
- ret = i40e_flow_parse_tunnel_action(dev, actions, error, tunnel_filter);
- if (ret)
- return ret;
-
- filter->type = RTE_ETH_FILTER_TUNNEL;
-
- return ret;
-}
-
-/* 1. Last in item should be NULL as range is not supported.
- * 2. Supported filter types: MPLS label.
- * 3. Mask of fields which need to be matched should be
- * filled with 1.
- * 4. Mask of fields which needn't to be matched should be
- * filled with 0.
- */
-static int
-i40e_flow_parse_mpls_pattern(__rte_unused struct rte_eth_dev *dev,
- const struct rte_flow_item *pattern,
- struct rte_flow_error *error,
- struct i40e_tunnel_filter_conf *filter)
-{
- const struct rte_flow_item *item = pattern;
- const struct rte_flow_item_mpls *mpls_spec;
- const struct rte_flow_item_mpls *mpls_mask;
- enum rte_flow_item_type item_type;
- bool is_mplsoudp = 0; /* 1 - MPLSoUDP, 0 - MPLSoGRE */
- const uint8_t label_mask[3] = {0xFF, 0xFF, 0xF0};
- uint32_t label_be = 0;
-
- for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
- if (item->last) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Not support range");
- return -rte_errno;
- }
- item_type = item->type;
- switch (item_type) {
- case RTE_FLOW_ITEM_TYPE_ETH:
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid ETH item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_IPV4:
- filter->ip_type = I40E_TUNNEL_IPTYPE_IPV4;
- /* IPv4 is used to describe protocol,
- * spec and mask should be NULL.
- */
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid IPv4 item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_IPV6:
- filter->ip_type = I40E_TUNNEL_IPTYPE_IPV6;
- /* IPv6 is used to describe protocol,
- * spec and mask should be NULL.
- */
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid IPv6 item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_UDP:
- /* UDP is used to describe protocol,
- * spec and mask should be NULL.
- */
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid UDP item");
- return -rte_errno;
- }
- is_mplsoudp = 1;
- break;
- case RTE_FLOW_ITEM_TYPE_GRE:
- /* GRE is used to describe protocol,
- * spec and mask should be NULL.
- */
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid GRE item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_MPLS:
- mpls_spec = item->spec;
- mpls_mask = item->mask;
-
- if (!mpls_spec || !mpls_mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid MPLS item");
- return -rte_errno;
- }
-
- if (memcmp(mpls_mask->label_tc_s, label_mask, 3)) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid MPLS label mask");
- return -rte_errno;
- }
- memcpy(((uint8_t *)&label_be + 1),
- mpls_spec->label_tc_s, 3);
- filter->tenant_id = rte_be_to_cpu_32(label_be) >> 4;
- break;
- default:
- break;
- }
- }
-
- if (is_mplsoudp)
- filter->tunnel_type = I40E_TUNNEL_TYPE_MPLSoUDP;
- else
- filter->tunnel_type = I40E_TUNNEL_TYPE_MPLSoGRE;
-
- return 0;
-}
-
-static int
-i40e_flow_parse_mpls_filter(struct rte_eth_dev *dev,
- const struct rte_flow_item pattern[],
- const struct rte_flow_action actions[],
- struct rte_flow_error *error,
- struct i40e_filter_ctx *filter)
-{
- struct i40e_tunnel_filter_conf *tunnel_filter = &filter->consistent_tunnel_filter;
- int ret;
-
- ret = i40e_flow_parse_mpls_pattern(dev, pattern,
- error, tunnel_filter);
- if (ret)
- return ret;
-
- ret = i40e_flow_parse_tunnel_action(dev, actions, error, tunnel_filter);
- if (ret)
- return ret;
-
- filter->type = RTE_ETH_FILTER_TUNNEL;
-
- return ret;
-}
-
-/* 1. Last in item should be NULL as range is not supported.
- * 2. Supported filter types: GTP TEID.
- * 3. Mask of fields which need to be matched should be
- * filled with 1.
- * 4. Mask of fields which needn't to be matched should be
- * filled with 0.
- * 5. GTP profile supports GTPv1 only.
- * 6. GTP-C response message ('source_port' = 2123) is not supported.
- */
-static int
-i40e_flow_parse_gtp_pattern(struct rte_eth_dev *dev,
- const struct rte_flow_item *pattern,
- struct rte_flow_error *error,
- struct i40e_tunnel_filter_conf *filter)
-{
- struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
- const struct rte_flow_item *item = pattern;
- const struct rte_flow_item_gtp *gtp_spec;
- const struct rte_flow_item_gtp *gtp_mask;
- enum rte_flow_item_type item_type;
-
- if (!pf->gtp_support) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "GTP is not supported by default.");
- return -rte_errno;
- }
-
- for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
- if (item->last) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Not support range");
- return -rte_errno;
- }
- item_type = item->type;
- switch (item_type) {
- case RTE_FLOW_ITEM_TYPE_ETH:
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid ETH item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_IPV4:
- filter->ip_type = I40E_TUNNEL_IPTYPE_IPV4;
- /* IPv4 is used to describe protocol,
- * spec and mask should be NULL.
- */
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid IPv4 item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_IPV6:
- filter->ip_type = I40E_TUNNEL_IPTYPE_IPV6;
- /* IPv6 is used to describe protocol,
- * spec and mask should be NULL.
- */
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid IPv6 item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_UDP:
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid UDP item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_GTPC:
- case RTE_FLOW_ITEM_TYPE_GTPU:
- gtp_spec = item->spec;
- gtp_mask = item->mask;
-
- if (!gtp_spec || !gtp_mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid GTP item");
- return -rte_errno;
- }
-
- if (gtp_mask->hdr.gtp_hdr_info ||
- gtp_mask->hdr.msg_type ||
- gtp_mask->hdr.plen ||
- gtp_mask->hdr.teid != UINT32_MAX) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid GTP mask");
- return -rte_errno;
- }
-
- if (item_type == RTE_FLOW_ITEM_TYPE_GTPC)
- filter->tunnel_type = I40E_TUNNEL_TYPE_GTPC;
- else if (item_type == RTE_FLOW_ITEM_TYPE_GTPU)
- filter->tunnel_type = I40E_TUNNEL_TYPE_GTPU;
-
- filter->tenant_id = rte_be_to_cpu_32(gtp_spec->hdr.teid);
-
- break;
- default:
- break;
- }
- }
-
- return 0;
-}
-
-static int
-i40e_flow_parse_gtp_filter(struct rte_eth_dev *dev,
- const struct rte_flow_item pattern[],
- const struct rte_flow_action actions[],
- struct rte_flow_error *error,
- struct i40e_filter_ctx *filter)
-{
- struct i40e_tunnel_filter_conf *tunnel_filter = &filter->consistent_tunnel_filter;
- int ret;
-
- ret = i40e_flow_parse_gtp_pattern(dev, pattern,
- error, tunnel_filter);
- if (ret)
- return ret;
-
- ret = i40e_flow_parse_tunnel_action(dev, actions, error, tunnel_filter);
- if (ret)
- return ret;
-
- filter->type = RTE_ETH_FILTER_TUNNEL;
-
- return ret;
-}
-
-/* 1. Last in item should be NULL as range is not supported.
- * 2. Supported filter types: QINQ.
- * 3. Mask of fields which need to be matched should be
- * filled with 1.
- * 4. Mask of fields which needn't to be matched should be
- * filled with 0.
- */
-static int
-i40e_flow_parse_qinq_pattern(__rte_unused struct rte_eth_dev *dev,
- const struct rte_flow_item *pattern,
- struct rte_flow_error *error,
- struct i40e_tunnel_filter_conf *filter)
-{
- const struct rte_flow_item *item = pattern;
- const struct rte_flow_item_vlan *vlan_spec = NULL;
- const struct rte_flow_item_vlan *vlan_mask = NULL;
- const struct rte_flow_item_vlan *i_vlan_spec = NULL;
- const struct rte_flow_item_vlan *i_vlan_mask = NULL;
- const struct rte_flow_item_vlan *o_vlan_spec = NULL;
- const struct rte_flow_item_vlan *o_vlan_mask = NULL;
-
- enum rte_flow_item_type item_type;
- bool vlan_flag = 0;
-
- for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
- if (item->last) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Not support range");
- return -rte_errno;
- }
- item_type = item->type;
- switch (item_type) {
- case RTE_FLOW_ITEM_TYPE_ETH:
- if (item->spec || item->mask) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid ETH item");
- return -rte_errno;
- }
- break;
- case RTE_FLOW_ITEM_TYPE_VLAN:
- vlan_spec = item->spec;
- vlan_mask = item->mask;
-
- if (!(vlan_spec && vlan_mask) ||
- vlan_mask->hdr.eth_proto) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- item,
- "Invalid vlan item");
- return -rte_errno;
- }
-
- if (!vlan_flag) {
- o_vlan_spec = vlan_spec;
- o_vlan_mask = vlan_mask;
- vlan_flag = 1;
- } else {
- i_vlan_spec = vlan_spec;
- i_vlan_mask = vlan_mask;
- vlan_flag = 0;
- }
- break;
-
- default:
- break;
- }
- }
-
- /* Get filter specification */
- if (o_vlan_mask != NULL && i_vlan_mask != NULL) {
- filter->outer_vlan = rte_be_to_cpu_16(o_vlan_spec->hdr.vlan_tci);
- filter->inner_vlan = rte_be_to_cpu_16(i_vlan_spec->hdr.vlan_tci);
- } else {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- NULL,
- "Invalid filter type");
- return -rte_errno;
- }
-
- filter->tunnel_type = I40E_TUNNEL_TYPE_QINQ;
- return 0;
-}
-
-static int
-i40e_flow_parse_qinq_filter(struct rte_eth_dev *dev,
- const struct rte_flow_item pattern[],
- const struct rte_flow_action actions[],
- struct rte_flow_error *error,
- struct i40e_filter_ctx *filter)
-{
- struct i40e_tunnel_filter_conf *tunnel_filter = &filter->consistent_tunnel_filter;
- int ret;
-
- ret = i40e_flow_parse_qinq_pattern(dev, pattern,
- error, tunnel_filter);
- if (ret)
- return ret;
-
- ret = i40e_flow_parse_tunnel_action(dev, actions, error, tunnel_filter);
- if (ret)
- return ret;
-
- filter->type = RTE_ETH_FILTER_TUNNEL;
-
- return ret;
-}
-
static int
i40e_flow_check(struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
@@ -1823,11 +290,6 @@ i40e_flow_check(struct rte_eth_dev *dev,
struct i40e_filter_ctx *filter_ctx,
struct rte_flow_error *error)
{
- struct rte_flow_item *items; /* internal pattern w/o VOID items */
- parse_filter_t parse_filter;
- uint32_t item_num = 0; /* non-void item number of pattern*/
- uint32_t i = 0;
- bool flag = false;
int ret;
ret = ci_flow_check_attr(attr, NULL, error);
@@ -1851,51 +313,8 @@ i40e_flow_check(struct rte_eth_dev *dev,
/* try parsing as RSS */
filter_ctx->type = RTE_ETH_FILTER_HASH;
- ret = i40e_hash_parse(dev, pattern, actions, &filter_ctx->rss_conf, error);
- if (!ret)
- return ret;
- i = 0;
- /* Get the non-void item number of pattern */
- while ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_END) {
- if ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_VOID)
- item_num++;
- i++;
- }
- item_num++;
- items = calloc(item_num, sizeof(struct rte_flow_item));
- if (items == NULL) {
- rte_flow_error_set(error, ENOMEM,
- RTE_FLOW_ERROR_TYPE_ITEM_NUM,
- NULL,
- "No memory for PMD internal items.");
- return -ENOMEM;
- }
-
- i40e_pattern_skip_void_item(items, pattern);
-
- i = 0;
- ret = I40E_NOT_SUPPORTED;
- do {
- parse_filter = i40e_find_parse_filter_func(items, &i);
- if (!parse_filter && !flag) {
- rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM,
- pattern, "Unsupported pattern");
-
- free(items);
- return -rte_errno;
- }
-
- if (parse_filter)
- ret = parse_filter(dev, items, actions, error, filter_ctx);
-
- flag = true;
- } while ((ret < 0) && (i < RTE_DIM(i40e_supported_patterns)));
-
- free(items);
-
- return ret;
+ return i40e_hash_parse(dev, pattern, actions, &filter_ctx->rss_conf, error);
}
static int
@@ -1948,14 +367,6 @@ i40e_flow_create(struct rte_eth_dev *dev,
}
switch (filter_ctx.type) {
- case RTE_ETH_FILTER_TUNNEL:
- ret = i40e_dev_consistent_tunnel_filter_set(pf,
- &filter_ctx.consistent_tunnel_filter, 1);
- if (ret)
- goto free_flow;
- flow->rule = TAILQ_LAST(&pf->tunnel.tunnel_list,
- i40e_tunnel_filter_list);
- break;
case RTE_ETH_FILTER_HASH:
ret = i40e_hash_filter_create(pf, &filter_ctx.rss_conf);
if (ret)
@@ -1996,10 +407,6 @@ i40e_flow_destroy(struct rte_eth_dev *dev,
return 0;
switch (filter_type) {
- case RTE_ETH_FILTER_TUNNEL:
- ret = i40e_flow_destroy_tunnel_filter(pf,
- (struct i40e_tunnel_filter *)flow->rule);
- break;
case RTE_ETH_FILTER_HASH:
ret = i40e_hash_filter_destroy(pf, flow->rule);
break;
@@ -2022,65 +429,6 @@ i40e_flow_destroy(struct rte_eth_dev *dev,
return ret;
}
-static int
-i40e_flow_destroy_tunnel_filter(struct i40e_pf *pf,
- struct i40e_tunnel_filter *filter)
-{
- struct i40e_hw *hw = I40E_PF_TO_HW(pf);
- struct i40e_vsi *vsi;
- struct i40e_pf_vf *vf;
- struct i40e_aqc_cloud_filters_element_bb cld_filter;
- struct i40e_tunnel_rule *tunnel_rule = &pf->tunnel;
- struct i40e_tunnel_filter *node;
- bool big_buffer = 0;
- int ret = 0;
-
- memset(&cld_filter, 0, sizeof(cld_filter));
- rte_ether_addr_copy((struct rte_ether_addr *)&filter->input.outer_mac,
- (struct rte_ether_addr *)&cld_filter.element.outer_mac);
- rte_ether_addr_copy((struct rte_ether_addr *)&filter->input.inner_mac,
- (struct rte_ether_addr *)&cld_filter.element.inner_mac);
- cld_filter.element.inner_vlan = filter->input.inner_vlan;
- cld_filter.element.flags = filter->input.flags;
- cld_filter.element.tenant_id = filter->input.tenant_id;
- cld_filter.element.queue_number = filter->queue;
- memcpy(cld_filter.general_fields,
- filter->input.general_fields,
- sizeof(cld_filter.general_fields));
-
- if (!filter->is_to_vf)
- vsi = pf->main_vsi;
- else {
- vf = &pf->vfs[filter->vf_id];
- vsi = vf->vsi;
- }
-
- if (((filter->input.flags & I40E_AQC_ADD_CLOUD_FILTER_0X11) ==
- I40E_AQC_ADD_CLOUD_FILTER_0X11) ||
- ((filter->input.flags & I40E_AQC_ADD_CLOUD_FILTER_0X12) ==
- I40E_AQC_ADD_CLOUD_FILTER_0X12) ||
- ((filter->input.flags & I40E_AQC_ADD_CLOUD_FILTER_0X10) ==
- I40E_AQC_ADD_CLOUD_FILTER_0X10))
- big_buffer = 1;
-
- if (big_buffer)
- ret = i40e_aq_rem_cloud_filters_bb(hw, vsi->seid,
- &cld_filter, 1);
- else
- ret = i40e_aq_rem_cloud_filters(hw, vsi->seid,
- &cld_filter.element, 1);
- if (ret < 0)
- return -ENOTSUP;
-
- node = i40e_sw_tunnel_filter_lookup(tunnel_rule, &filter->input);
- if (!node)
- return -EINVAL;
-
- ret = i40e_sw_tunnel_filter_del(pf, &node->input);
-
- return ret;
-}
-
static int
i40e_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
{
@@ -2092,14 +440,6 @@ i40e_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
if (ret != 0)
return ret;
- ret = i40e_flow_flush_tunnel_filter(pf);
- if (ret) {
- rte_flow_error_set(error, -ret,
- RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
- "Failed to flush tunnel flows.");
- return -rte_errno;
- }
-
ret = i40e_hash_filter_flush(pf);
if (ret)
rte_flow_error_set(error, -ret,
@@ -2108,34 +448,6 @@ i40e_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
return ret;
}
-/* Flush all tunnel filters */
-static int
-i40e_flow_flush_tunnel_filter(struct i40e_pf *pf)
-{
- struct i40e_tunnel_filter_list
- *tunnel_list = &pf->tunnel.tunnel_list;
- struct i40e_tunnel_filter *filter;
- struct rte_flow *flow;
- void *temp;
- int ret = 0;
-
- while ((filter = TAILQ_FIRST(tunnel_list))) {
- ret = i40e_flow_destroy_tunnel_filter(pf, filter);
- if (ret)
- return ret;
- }
-
- /* Delete tunnel flows in flow list. */
- RTE_TAILQ_FOREACH_SAFE(flow, &pf->flow_list, node, temp) {
- if (flow->filter_type == RTE_ETH_FILTER_TUNNEL) {
- TAILQ_REMOVE(&pf->flow_list, flow, node);
- rte_free(flow);
- }
- }
-
- return ret;
-}
-
static int
i40e_flow_query(struct rte_eth_dev *dev,
struct rte_flow *flow,
diff --git a/drivers/net/intel/i40e/i40e_flow.h b/drivers/net/intel/i40e/i40e_flow.h
index 6823dbef33..28e342210c 100644
--- a/drivers/net/intel/i40e/i40e_flow.h
+++ b/drivers/net/intel/i40e/i40e_flow.h
@@ -17,5 +17,11 @@ extern const struct ci_flow_engine_list i40e_flow_engine_list;
extern const struct ci_flow_engine i40e_flow_engine_ethertype;
extern const struct ci_flow_engine i40e_flow_engine_fdir;
+extern const struct ci_flow_engine i40e_flow_engine_tunnel_qinq;
+extern const struct ci_flow_engine i40e_flow_engine_tunnel_vxlan;
+extern const struct ci_flow_engine i40e_flow_engine_tunnel_nvgre;
+extern const struct ci_flow_engine i40e_flow_engine_tunnel_mpls;
+extern const struct ci_flow_engine i40e_flow_engine_tunnel_gtp;
+extern const struct ci_flow_engine i40e_flow_engine_tunnel_l4;
#endif /* _I40E_FLOW_H_ */
diff --git a/drivers/net/intel/i40e/i40e_flow_tunnel.c b/drivers/net/intel/i40e/i40e_flow_tunnel.c
new file mode 100644
index 0000000000..aae64af398
--- /dev/null
+++ b/drivers/net/intel/i40e/i40e_flow_tunnel.c
@@ -0,0 +1,1590 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Intel Corporation
+ */
+
+#include "i40e_ethdev.h"
+#include "i40e_flow.h"
+
+#include "../common/flow_engine.h"
+#include "../common/flow_check.h"
+#include "../common/flow_util.h"
+
+struct i40e_tunnel_priv {
+ struct i40e_tunnel_state *state;
+};
+
+struct i40e_tunnel_ctx {
+ struct ci_flow_engine_ctx base;
+ struct i40e_tunnel_filter_conf filter;
+};
+
+struct i40e_tunnel_flow {
+ struct rte_flow base;
+ struct i40e_tunnel_filter_conf filter;
+ struct i40e_tunnel_filter_match_key match_key;
+};
+
+static int
+i40e_check_tunnel_filter_type(uint8_t filter_type)
+{
+ const uint16_t i40e_supported_tunnel_filter_types[] = {
+ RTE_ETH_TUNNEL_FILTER_IMAC | RTE_ETH_TUNNEL_FILTER_TENID |
+ RTE_ETH_TUNNEL_FILTER_IVLAN,
+ RTE_ETH_TUNNEL_FILTER_IMAC | RTE_ETH_TUNNEL_FILTER_IVLAN,
+ RTE_ETH_TUNNEL_FILTER_IMAC | RTE_ETH_TUNNEL_FILTER_TENID,
+ RTE_ETH_TUNNEL_FILTER_OMAC | RTE_ETH_TUNNEL_FILTER_TENID |
+ RTE_ETH_TUNNEL_FILTER_IMAC,
+ RTE_ETH_TUNNEL_FILTER_IMAC,
+ };
+ uint8_t i;
+
+ for (i = 0; i < RTE_DIM(i40e_supported_tunnel_filter_types); i++) {
+ if (filter_type == i40e_supported_tunnel_filter_types[i])
+ return 0;
+ }
+ return -1;
+}
+
+/**
+ * QinQ tunnel filter graph implementation
+ * Pattern: START -> ETH -> OUTER_VLAN -> INNER_VLAN -> END
+ */
+enum i40e_tunnel_qinq_node_id {
+ I40E_TUNNEL_QINQ_NODE_START = FLOW_GRAPH_NODE_FIRST,
+ I40E_TUNNEL_QINQ_NODE_ETH,
+ I40E_TUNNEL_QINQ_NODE_OUTER_VLAN,
+ I40E_TUNNEL_QINQ_NODE_INNER_VLAN,
+ I40E_TUNNEL_QINQ_NODE_END,
+ I40E_TUNNEL_QINQ_NODE_MAX,
+};
+
+static int
+i40e_tunnel_node_vlan_validate(const void *ctx __rte_unused, const struct rte_flow_item *item,
+ struct rte_flow_error *error)
+{
+ const struct rte_flow_item_vlan *vlan_mask = item->mask;
+
+ /* matching eth proto not supported */
+ if (vlan_mask->hdr.eth_proto) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid VLAN mask");
+ }
+
+ /* VLAN TCI must be fully masked */
+ if (!CI_FIELD_IS_MASKED(&vlan_mask->hdr.vlan_tci)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid VLAN mask");
+ }
+
+ return 0;
+}
+
+/* common VLAN processing for both outer and inner VLAN nodes */
+static int
+i40e_tunnel_node_vlan_process(struct i40e_tunnel_ctx *tunnel_ctx,
+ const struct rte_flow_item *item, bool is_inner)
+{
+ const struct rte_flow_item_vlan *vlan_spec = item->spec;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ /* Store the VLAN ID and set filter flag */
+ if (is_inner) {
+ tunnel_filter->inner_vlan = rte_be_to_cpu_16(vlan_spec->hdr.vlan_tci);
+ tunnel_filter->filter_type |= RTE_ETH_TUNNEL_FILTER_IVLAN;
+ } else {
+ tunnel_filter->outer_vlan = rte_be_to_cpu_16(vlan_spec->hdr.vlan_tci);
+ /* no special flag for outer VLAN matching */
+ }
+
+ return 0;
+}
+
+static int
+i40e_tunnel_node_outer_vlan_process(void *ctx, const struct rte_flow_item *item,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+
+ return i40e_tunnel_node_vlan_process(tunnel_ctx, item, false);
+}
+
+static int
+i40e_tunnel_node_inner_vlan_process(void *ctx, const struct rte_flow_item *item,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+
+ return i40e_tunnel_node_vlan_process(tunnel_ctx, item, true);
+}
+
+static int
+i40e_tunnel_qinq_node_end_process(void *ctx, const struct rte_flow_item *item __rte_unused,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ tunnel_filter->tunnel_type = I40E_TUNNEL_TYPE_QINQ;
+
+ /* QinQ filter is not meant to set this flag */
+ tunnel_filter->filter_type &= ~RTE_ETH_TUNNEL_FILTER_IVLAN;
+
+ return 0;
+}
+
+static const struct flow_graph i40e_tunnel_qinq_graph = {
+ .nodes = (struct flow_graph_node[]) {
+ [I40E_TUNNEL_QINQ_NODE_START] = {
+ .name = "START",
+ },
+ [I40E_TUNNEL_QINQ_NODE_ETH] = {
+ .name = "ETH",
+ .type = RTE_FLOW_ITEM_TYPE_ETH,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ },
+ [I40E_TUNNEL_QINQ_NODE_OUTER_VLAN] = {
+ .name = "OUTER_VLAN",
+ .type = RTE_FLOW_ITEM_TYPE_VLAN,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_vlan_validate,
+ .process = i40e_tunnel_node_outer_vlan_process,
+ },
+ [I40E_TUNNEL_QINQ_NODE_INNER_VLAN] = {
+ .name = "INNER_VLAN",
+ .type = RTE_FLOW_ITEM_TYPE_VLAN,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_vlan_validate,
+ .process = i40e_tunnel_node_inner_vlan_process,
+ },
+ [I40E_TUNNEL_QINQ_NODE_END] = {
+ .name = "END",
+ .type = RTE_FLOW_ITEM_TYPE_END,
+ .process = i40e_tunnel_qinq_node_end_process,
+ },
+ },
+ .edges = (struct flow_graph_edge[]) {
+ [I40E_TUNNEL_QINQ_NODE_START] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_QINQ_NODE_ETH,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_QINQ_NODE_ETH] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_QINQ_NODE_OUTER_VLAN,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_QINQ_NODE_OUTER_VLAN] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_QINQ_NODE_INNER_VLAN,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_QINQ_NODE_INNER_VLAN] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_QINQ_NODE_END,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ },
+};
+
+/**
+ * VXLAN tunnel filter graph implementation
+ * Pattern: START -> ETH -> (IPv4 | IPv6) -> UDP -> VXLAN -> ETH -> [VLAN] -> END
+ */
+enum i40e_tunnel_vxlan_node_id {
+ I40E_TUNNEL_VXLAN_NODE_START = FLOW_GRAPH_NODE_FIRST,
+ I40E_TUNNEL_VXLAN_NODE_OUTER_ETH,
+ I40E_TUNNEL_VXLAN_NODE_IPV4,
+ I40E_TUNNEL_VXLAN_NODE_IPV6,
+ I40E_TUNNEL_VXLAN_NODE_UDP,
+ I40E_TUNNEL_VXLAN_NODE_VXLAN,
+ I40E_TUNNEL_VXLAN_NODE_INNER_ETH,
+ I40E_TUNNEL_VXLAN_NODE_INNER_VLAN,
+ I40E_TUNNEL_VXLAN_NODE_END,
+ I40E_TUNNEL_VXLAN_NODE_MAX,
+};
+
+static int
+i40e_tunnel_node_eth_validate(const void *ctx __rte_unused, const struct rte_flow_item *item,
+ struct rte_flow_error *error)
+{
+ const struct rte_flow_item_eth *eth_spec = item->spec;
+ const struct rte_flow_item_eth *eth_mask = item->mask;
+
+ /* spec/mask is optional */
+ if (eth_spec == NULL && eth_mask == NULL)
+ return 0;
+
+ /* matching eth type not supported */
+ if (eth_mask->hdr.ether_type) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid ETH mask");
+ }
+
+ /* source MAC must be fully unmasked */
+ if (!CI_FIELD_IS_ZERO(ð_mask->hdr.src_addr)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid ETH mask");
+ }
+ /* destination MAC must be fully masked */
+ if (!CI_FIELD_IS_MASKED(ð_mask->hdr.dst_addr)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid ETH mask");
+ }
+
+ return 0;
+}
+
+static int
+i40e_tunnel_eth_process(struct i40e_tunnel_ctx *tunnel_ctx,
+ const struct rte_flow_item *item, bool is_inner)
+{
+ const struct rte_flow_item_eth *eth_spec = item->spec;
+ const struct rte_flow_item_eth *eth_mask = item->mask;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ /* eth spec/mask is optional */
+ if (eth_spec == NULL && eth_mask == NULL)
+ return 0;
+
+ /* Store the MAC addresses and set filter flags */
+ if (is_inner) {
+ memcpy(&tunnel_filter->inner_mac, ð_spec->hdr.dst_addr,
+ sizeof(tunnel_filter->inner_mac));
+ tunnel_filter->filter_type |= RTE_ETH_TUNNEL_FILTER_IMAC;
+ } else {
+ memcpy(&tunnel_filter->outer_mac, ð_spec->hdr.dst_addr,
+ sizeof(tunnel_filter->outer_mac));
+ tunnel_filter->filter_type |= RTE_ETH_TUNNEL_FILTER_OMAC;
+ }
+ return 0;
+}
+
+static int
+i40e_tunnel_node_outer_eth_process(void *ctx, const struct rte_flow_item *item,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+
+ return i40e_tunnel_eth_process(tunnel_ctx, item, false);
+}
+
+static int
+i40e_tunnel_node_inner_eth_process(void *ctx, const struct rte_flow_item *item,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+
+ return i40e_tunnel_eth_process(tunnel_ctx, item, true);
+}
+
+static int
+i40e_tunnel_node_ipv4_process(void *ctx, const struct rte_flow_item *item __rte_unused,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ tunnel_filter->ip_type = I40E_TUNNEL_IPTYPE_IPV4;
+
+ return 0;
+}
+
+static int
+i40e_tunnel_node_ipv6_process(void *ctx, const struct rte_flow_item *item __rte_unused,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ tunnel_filter->ip_type = I40E_TUNNEL_IPTYPE_IPV6;
+
+ return 0;
+}
+
+static int
+i40e_tunnel_node_vxlan_validate(const void *ctx __rte_unused,
+ const struct rte_flow_item *item,
+ struct rte_flow_error *error)
+{
+ const struct rte_flow_item_vxlan *vxlan_spec = item->spec;
+ const struct rte_flow_item_vxlan *vxlan_mask = item->mask;
+
+ /* spec/mask are optional */
+ if (vxlan_spec == NULL && vxlan_mask == NULL)
+ return 0;
+
+ /* VNI must be fully masked */
+ if (!CI_FIELD_IS_MASKED(&vxlan_mask->hdr.vni)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid VXLAN mask");
+ }
+ return 0;
+}
+
+static int
+i40e_tunnel_node_vxlan_process(void *ctx, const struct rte_flow_item *item,
+ struct rte_flow_error *error __rte_unused)
+{
+ const struct rte_flow_item_vxlan *vxlan_spec = item->spec;
+ const struct rte_flow_item_vxlan *vxlan_mask = item->mask;
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ /* spec/mask are optional */
+ if (vxlan_spec == NULL && vxlan_mask == NULL)
+ return 0;
+
+ /* Store the VNI and set filter flag */
+ tunnel_filter->tenant_id = ci_be24_to_cpu(vxlan_spec->hdr.vni);
+ tunnel_filter->filter_type |= RTE_ETH_TUNNEL_FILTER_TENID;
+
+ return 0;
+}
+
+static int
+i40e_tunnel_node_end_validate(const void *ctx,
+ const struct rte_flow_item *item,
+ struct rte_flow_error *error)
+{
+ const struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ const struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ /* this shouldn't happen but check this just in case */
+ if (i40e_check_tunnel_filter_type(tunnel_filter->filter_type) != 0) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid tunnel filter configuration");
+ }
+ return 0;
+}
+
+static int
+i40e_tunnel_vxlan_node_end_process(void *ctx, const struct rte_flow_item *item __rte_unused,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ tunnel_filter->tunnel_type = I40E_TUNNEL_TYPE_VXLAN;
+
+ return 0;
+}
+
+static const struct flow_graph i40e_tunnel_vxlan_graph = {
+ .nodes = (struct flow_graph_node[]) {
+ [I40E_TUNNEL_VXLAN_NODE_START] = {
+ .name = "START",
+ },
+ [I40E_TUNNEL_VXLAN_NODE_OUTER_ETH] = {
+ .name = "ETH",
+ .type = RTE_FLOW_ITEM_TYPE_ETH,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY |
+ FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_eth_validate,
+ .process = i40e_tunnel_node_outer_eth_process,
+ },
+ [I40E_TUNNEL_VXLAN_NODE_IPV4] = {
+ .name = "IPv4",
+ .type = RTE_FLOW_ITEM_TYPE_IPV4,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ .process = i40e_tunnel_node_ipv4_process,
+ },
+ [I40E_TUNNEL_VXLAN_NODE_IPV6] = {
+ .name = "IPv6",
+ .type = RTE_FLOW_ITEM_TYPE_IPV6,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ .process = i40e_tunnel_node_ipv6_process,
+ },
+ [I40E_TUNNEL_VXLAN_NODE_UDP] = {
+ .name = "UDP",
+ .type = RTE_FLOW_ITEM_TYPE_UDP,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ },
+ [I40E_TUNNEL_VXLAN_NODE_VXLAN] = {
+ .name = "VXLAN",
+ .type = RTE_FLOW_ITEM_TYPE_VXLAN,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY |
+ FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_vxlan_validate,
+ .process = i40e_tunnel_node_vxlan_process,
+ },
+ [I40E_TUNNEL_VXLAN_NODE_INNER_ETH] = {
+ .name = "INNER_ETH",
+ .type = RTE_FLOW_ITEM_TYPE_ETH,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY |
+ FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_eth_validate,
+ .process = i40e_tunnel_node_inner_eth_process,
+ },
+ [I40E_TUNNEL_VXLAN_NODE_INNER_VLAN] = {
+ .name = "INNER_VLAN",
+ .type = RTE_FLOW_ITEM_TYPE_VLAN,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_vlan_validate,
+ .process = i40e_tunnel_node_inner_vlan_process,
+ },
+ [I40E_TUNNEL_VXLAN_NODE_END] = {
+ .name = "END",
+ .type = RTE_FLOW_ITEM_TYPE_END,
+ .validate = i40e_tunnel_node_end_validate,
+ .process = i40e_tunnel_vxlan_node_end_process
+ },
+ },
+ .edges = (struct flow_graph_edge[]) {
+ [I40E_TUNNEL_VXLAN_NODE_START] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_VXLAN_NODE_OUTER_ETH,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_VXLAN_NODE_OUTER_ETH] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_VXLAN_NODE_IPV4,
+ I40E_TUNNEL_VXLAN_NODE_IPV6,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_VXLAN_NODE_IPV4] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_VXLAN_NODE_UDP,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_VXLAN_NODE_IPV6] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_VXLAN_NODE_UDP,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_VXLAN_NODE_UDP] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_VXLAN_NODE_VXLAN,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_VXLAN_NODE_VXLAN] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_VXLAN_NODE_INNER_ETH,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_VXLAN_NODE_INNER_ETH] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_VXLAN_NODE_INNER_VLAN,
+ I40E_TUNNEL_VXLAN_NODE_END,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_VXLAN_NODE_INNER_VLAN] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_VXLAN_NODE_END,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ },
+};
+
+/**
+ * NVGRE tunnel filter graph implementation
+ * Pattern: START -> ETH -> (IPv4 | IPv6) -> NVGRE -> ETH -> [VLAN] -> END
+ */
+enum i40e_tunnel_nvgre_node_id {
+ I40E_TUNNEL_NVGRE_NODE_START = FLOW_GRAPH_NODE_FIRST,
+ I40E_TUNNEL_NVGRE_NODE_OUTER_ETH,
+ I40E_TUNNEL_NVGRE_NODE_IPV4,
+ I40E_TUNNEL_NVGRE_NODE_IPV6,
+ I40E_TUNNEL_NVGRE_NODE_NVGRE,
+ I40E_TUNNEL_NVGRE_NODE_INNER_ETH,
+ I40E_TUNNEL_NVGRE_NODE_INNER_VLAN,
+ I40E_TUNNEL_NVGRE_NODE_END,
+ I40E_TUNNEL_NVGRE_NODE_MAX,
+};
+
+static int
+i40e_tunnel_node_nvgre_validate(const void *ctx __rte_unused,
+ const struct rte_flow_item *item,
+ struct rte_flow_error *error)
+{
+ const struct rte_flow_item_nvgre *nvgre_spec = item->spec;
+ const struct rte_flow_item_nvgre *nvgre_mask = item->mask;
+
+ /* spec/mask are optional */
+ if (nvgre_spec == NULL && nvgre_mask == NULL)
+ return 0;
+
+ /* TNI must be fully masked */
+ if (!CI_FIELD_IS_MASKED(&nvgre_mask->tni)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM_MASK, item,
+ "Invalid NVGRE mask");
+ }
+ /* protocol must either be unmasked or fully masked */
+ if (!CI_FIELD_IS_ZERO_OR_MASKED(&nvgre_mask->protocol)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM_MASK, item,
+ "Invalid NVGRE mask");
+ }
+ /* reserved/version field must either be unmasked or fully masked */
+ if (!CI_FIELD_IS_ZERO_OR_MASKED(&nvgre_mask->c_k_s_rsvd0_ver)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM_MASK, item,
+ "Invalid NVGRE mask");
+ }
+ /* if reserved/version field is masked, it must be set to 0x2000 */
+ if (nvgre_mask->c_k_s_rsvd0_ver &&
+ nvgre_spec->c_k_s_rsvd0_ver != rte_cpu_to_be_16(0x2000)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM_MASK, item,
+ "Invalid NVGRE spec");
+ }
+ /* if protocol field is masked, it must be set to 0x6558 */
+ if (nvgre_mask->protocol &&
+ nvgre_spec->protocol != rte_cpu_to_be_16(0x6558)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM_MASK, item,
+ "Invalid NVGRE spec");
+ }
+ return 0;
+}
+
+static int
+i40e_tunnel_node_nvgre_process(void *ctx, const struct rte_flow_item *item,
+ struct rte_flow_error *error __rte_unused)
+{
+ const struct rte_flow_item_nvgre *nvgre_spec = item->spec;
+ const struct rte_flow_item_nvgre *nvgre_mask = item->mask;
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ /* spec/mask are optional */
+ if (nvgre_spec == NULL && nvgre_mask == NULL)
+ return 0;
+
+ /* Store the VNI and set filter flag */
+ tunnel_filter->tenant_id = ci_be24_to_cpu(nvgre_spec->tni);
+ tunnel_filter->filter_type |= RTE_ETH_TUNNEL_FILTER_TENID;
+
+ return 0;
+}
+
+static int
+i40e_tunnel_node_nvgre_end_process(void *ctx, const struct rte_flow_item *item __rte_unused,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ tunnel_filter->tunnel_type = I40E_TUNNEL_TYPE_NVGRE;
+
+ return 0;
+}
+
+static const struct flow_graph i40e_tunnel_nvgre_graph = {
+ .nodes = (struct flow_graph_node[]) {
+ [I40E_TUNNEL_NVGRE_NODE_START] = {
+ .name = "START",
+ },
+ [I40E_TUNNEL_NVGRE_NODE_OUTER_ETH] = {
+ .name = "ETH",
+ .type = RTE_FLOW_ITEM_TYPE_ETH,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY |
+ FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_eth_validate,
+ .process = i40e_tunnel_node_outer_eth_process,
+ },
+ [I40E_TUNNEL_NVGRE_NODE_IPV4] = {
+ .name = "IPv4",
+ .type = RTE_FLOW_ITEM_TYPE_IPV4,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ .process = i40e_tunnel_node_ipv4_process,
+ },
+ [I40E_TUNNEL_NVGRE_NODE_IPV6] = {
+ .name = "IPv6",
+ .type = RTE_FLOW_ITEM_TYPE_IPV6,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ .process = i40e_tunnel_node_ipv6_process,
+ },
+ [I40E_TUNNEL_NVGRE_NODE_NVGRE] = {
+ .name = "NVGRE",
+ .type = RTE_FLOW_ITEM_TYPE_NVGRE,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY |
+ FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_nvgre_validate,
+ .process = i40e_tunnel_node_nvgre_process,
+ },
+ [I40E_TUNNEL_NVGRE_NODE_INNER_ETH] = {
+ .name = "INNER_ETH",
+ .type = RTE_FLOW_ITEM_TYPE_ETH,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY |
+ FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_eth_validate,
+ .process = i40e_tunnel_node_inner_eth_process,
+ },
+ [I40E_TUNNEL_NVGRE_NODE_INNER_VLAN] = {
+ .name = "INNER_VLAN",
+ .type = RTE_FLOW_ITEM_TYPE_VLAN,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_vlan_validate,
+ .process = i40e_tunnel_node_inner_vlan_process,
+ },
+ [I40E_TUNNEL_NVGRE_NODE_END] = {
+ .name = "END",
+ .type = RTE_FLOW_ITEM_TYPE_END,
+ .validate = i40e_tunnel_node_end_validate,
+ .process = i40e_tunnel_node_nvgre_end_process
+ },
+ },
+ .edges = (struct flow_graph_edge[]) {
+ [I40E_TUNNEL_NVGRE_NODE_START] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_NVGRE_NODE_OUTER_ETH,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_NVGRE_NODE_OUTER_ETH] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_NVGRE_NODE_IPV4,
+ I40E_TUNNEL_NVGRE_NODE_IPV6,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_NVGRE_NODE_IPV4] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_NVGRE_NODE_NVGRE,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_NVGRE_NODE_IPV6] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_NVGRE_NODE_NVGRE,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_NVGRE_NODE_NVGRE] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_NVGRE_NODE_INNER_ETH,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_NVGRE_NODE_INNER_ETH] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_NVGRE_NODE_INNER_VLAN,
+ I40E_TUNNEL_NVGRE_NODE_END,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_NVGRE_NODE_INNER_VLAN] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_NVGRE_NODE_END,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ },
+};
+
+/**
+ * MPLS tunnel filter graph implementation
+ * Pattern: START -> ETH -> (IPv4 | IPv6) -> (UDP | GRE) -> MPLS -> END
+ */
+enum i40e_tunnel_mpls_node_id {
+ I40E_TUNNEL_MPLS_NODE_START = FLOW_GRAPH_NODE_FIRST,
+ I40E_TUNNEL_MPLS_NODE_ETH,
+ I40E_TUNNEL_MPLS_NODE_IPV4,
+ I40E_TUNNEL_MPLS_NODE_IPV6,
+ I40E_TUNNEL_MPLS_NODE_UDP,
+ I40E_TUNNEL_MPLS_NODE_GRE,
+ I40E_TUNNEL_MPLS_NODE_MPLS,
+ I40E_TUNNEL_MPLS_NODE_END,
+ I40E_TUNNEL_MPLS_NODE_MAX,
+};
+
+static int
+i40e_tunnel_mpls_node_udp_process(void *ctx, const struct rte_flow_item *item __rte_unused,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ tunnel_filter->tunnel_type = I40E_TUNNEL_TYPE_MPLSoUDP;
+
+ return 0;
+}
+
+static int
+i40e_tunnel_mpls_node_gre_process(void *ctx, const struct rte_flow_item *item __rte_unused,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ tunnel_filter->tunnel_type = I40E_TUNNEL_TYPE_MPLSoGRE;
+
+ return 0;
+}
+
+static int
+i40e_tunnel_node_mpls_validate(const void *ctx __rte_unused,
+ const struct rte_flow_item *item,
+ struct rte_flow_error *error)
+{
+ const struct rte_flow_item_mpls *mpls_mask = item->mask;
+ const uint8_t label_mask[3] = {0xFF, 0xFF, 0xF0};
+
+ /* MPLS label and TC must be fully masked */
+ if (memcmp(mpls_mask->label_tc_s, label_mask, 3)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid MPLS mask");
+ }
+ return 0;
+}
+
+static int
+i40e_tunnel_node_mpls_process(void *ctx, const struct rte_flow_item *item __rte_unused,
+ struct rte_flow_error *error __rte_unused)
+{
+ const struct rte_flow_item_mpls *mpls_spec = item->spec;
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ tunnel_filter->tenant_id = ci_be24_to_cpu(mpls_spec->label_tc_s) >> 4;
+
+ return 0;
+}
+
+static const struct flow_graph i40e_tunnel_mpls_graph = {
+ .nodes = (struct flow_graph_node[]) {
+ [I40E_TUNNEL_MPLS_NODE_START] = {
+ .name = "START",
+ },
+ [I40E_TUNNEL_MPLS_NODE_ETH] = {
+ .name = "ETH",
+ .type = RTE_FLOW_ITEM_TYPE_ETH,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ },
+ [I40E_TUNNEL_MPLS_NODE_IPV4] = {
+ .name = "IPv4",
+ .type = RTE_FLOW_ITEM_TYPE_IPV4,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ .process = i40e_tunnel_node_ipv4_process,
+ },
+ [I40E_TUNNEL_MPLS_NODE_IPV6] = {
+ .name = "IPv6",
+ .type = RTE_FLOW_ITEM_TYPE_IPV6,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ .process = i40e_tunnel_node_ipv6_process,
+ },
+ [I40E_TUNNEL_MPLS_NODE_UDP] = {
+ .name = "UDP",
+ .type = RTE_FLOW_ITEM_TYPE_UDP,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ .process = i40e_tunnel_mpls_node_udp_process,
+ },
+ [I40E_TUNNEL_MPLS_NODE_GRE] = {
+ .name = "GRE",
+ .type = RTE_FLOW_ITEM_TYPE_GRE,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ .process = i40e_tunnel_mpls_node_gre_process,
+ },
+ [I40E_TUNNEL_MPLS_NODE_MPLS] = {
+ .name = "MPLS",
+ .type = RTE_FLOW_ITEM_TYPE_MPLS,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_mpls_validate,
+ .process = i40e_tunnel_node_mpls_process,
+ },
+ [I40E_TUNNEL_MPLS_NODE_END] = {
+ .name = "END",
+ .type = RTE_FLOW_ITEM_TYPE_END,
+ },
+ },
+ .edges = (struct flow_graph_edge[]) {
+ [I40E_TUNNEL_MPLS_NODE_START] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_MPLS_NODE_ETH,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_MPLS_NODE_ETH] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_MPLS_NODE_IPV4,
+ I40E_TUNNEL_MPLS_NODE_IPV6,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_MPLS_NODE_IPV4] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_MPLS_NODE_UDP,
+ I40E_TUNNEL_MPLS_NODE_GRE,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_MPLS_NODE_IPV6] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_MPLS_NODE_UDP,
+ I40E_TUNNEL_MPLS_NODE_GRE,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_MPLS_NODE_UDP] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_MPLS_NODE_MPLS,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_MPLS_NODE_GRE] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_MPLS_NODE_MPLS,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_MPLS_NODE_MPLS] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_MPLS_NODE_END,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ },
+};
+
+/**
+ * GTP tunnel filter graph implementation
+ * Pattern: START -> ETH -> (IPv4 | IPv6) -> UDP -> (GTPC | GTPU) -> END
+ */
+enum i40e_tunnel_gtp_node_id {
+ I40E_TUNNEL_GTP_NODE_START = FLOW_GRAPH_NODE_FIRST,
+ I40E_TUNNEL_GTP_NODE_ETH,
+ I40E_TUNNEL_GTP_NODE_IPV4,
+ I40E_TUNNEL_GTP_NODE_IPV6,
+ I40E_TUNNEL_GTP_NODE_UDP,
+ I40E_TUNNEL_GTP_NODE_GTPC,
+ I40E_TUNNEL_GTP_NODE_GTPU,
+ I40E_TUNNEL_GTP_NODE_END,
+ I40E_TUNNEL_GTP_NODE_MAX,
+};
+
+static int
+i40e_tunnel_node_gtp_validate(const void *ctx, const struct rte_flow_item *item,
+ struct rte_flow_error *error)
+{
+ const struct rte_flow_item_gtp *gtp_mask = item->mask;
+ const struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ const struct rte_eth_dev_data *dev_data = tunnel_ctx->base.dev_data;
+ const struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev_data->dev_private);
+
+ /* does HW support GTP? */
+ if (!pf->gtp_support) {
+ return rte_flow_error_set(error, ENOTSUP,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "GTP not supported");
+ }
+
+ /* reject unsupported fields */
+ if (gtp_mask->hdr.gtp_hdr_info ||
+ gtp_mask->hdr.msg_type ||
+ gtp_mask->hdr.plen) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid GTP mask");
+ }
+
+ /* teid must be fully masked */
+ if (!CI_FIELD_IS_MASKED(>p_mask->hdr.teid)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid GTP mask");
+ }
+ return 0;
+}
+
+static int
+i40e_tunnel_node_gtp_process(void *ctx, const struct rte_flow_item *item,
+ struct rte_flow_error *error)
+{
+ const struct rte_flow_item_gtp *gtp_spec = item->spec;
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+
+ if (item->type == RTE_FLOW_ITEM_TYPE_GTPC)
+ tunnel_filter->tunnel_type = I40E_TUNNEL_TYPE_GTPC;
+ else if (item->type == RTE_FLOW_ITEM_TYPE_GTPU)
+ tunnel_filter->tunnel_type = I40E_TUNNEL_TYPE_GTPU;
+ else {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid GTP item type");
+ }
+ tunnel_filter->tenant_id = rte_be_to_cpu_32(gtp_spec->hdr.teid);
+
+ return 0;
+}
+
+static const struct flow_graph i40e_tunnel_gtp_graph = {
+ .nodes = (struct flow_graph_node[]) {
+ [I40E_TUNNEL_GTP_NODE_START] = {
+ .name = "START",
+ },
+ [I40E_TUNNEL_GTP_NODE_ETH] = {
+ .name = "ETH",
+ .type = RTE_FLOW_ITEM_TYPE_ETH,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ },
+ [I40E_TUNNEL_GTP_NODE_IPV4] = {
+ .name = "IPv4",
+ .type = RTE_FLOW_ITEM_TYPE_IPV4,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ .process = i40e_tunnel_node_ipv4_process,
+ },
+ [I40E_TUNNEL_GTP_NODE_IPV6] = {
+ .name = "IPv6",
+ .type = RTE_FLOW_ITEM_TYPE_IPV6,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ .process = i40e_tunnel_node_ipv6_process,
+ },
+ [I40E_TUNNEL_GTP_NODE_UDP] = {
+ .name = "UDP",
+ .type = RTE_FLOW_ITEM_TYPE_UDP,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ },
+ [I40E_TUNNEL_GTP_NODE_GTPC] = {
+ .name = "GTPC",
+ .type = RTE_FLOW_ITEM_TYPE_GTPC,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_gtp_validate,
+ .process = i40e_tunnel_node_gtp_process,
+ },
+ [I40E_TUNNEL_GTP_NODE_GTPU] = {
+ .name = "GTPU",
+ .type = RTE_FLOW_ITEM_TYPE_GTPU,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_gtp_validate,
+ .process = i40e_tunnel_node_gtp_process,
+ },
+ [I40E_TUNNEL_GTP_NODE_END] = {
+ .name = "END",
+ .type = RTE_FLOW_ITEM_TYPE_END,
+ },
+ },
+ .edges = (struct flow_graph_edge[]) {
+ [I40E_TUNNEL_GTP_NODE_START] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_GTP_NODE_ETH,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_GTP_NODE_ETH] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_GTP_NODE_IPV4,
+ I40E_TUNNEL_GTP_NODE_IPV6,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_GTP_NODE_IPV4] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_GTP_NODE_UDP,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_GTP_NODE_IPV6] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_GTP_NODE_UDP,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_GTP_NODE_UDP] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_GTP_NODE_GTPC,
+ I40E_TUNNEL_GTP_NODE_GTPU,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_GTP_NODE_GTPC] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_GTP_NODE_END,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_GTP_NODE_GTPU] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_GTP_NODE_END,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ },
+};
+
+/**
+ * L4 tunnel filter graph implementation
+ * Pattern: START -> ETH -> (IPv4 | IPv6) -> (TCP | UDP | SCTP) -> END
+ */
+enum i40e_tunnel_l4_node_id {
+ I40E_TUNNEL_L4_NODE_START = FLOW_GRAPH_NODE_FIRST,
+ I40E_TUNNEL_L4_NODE_ETH,
+ I40E_TUNNEL_L4_NODE_IPV4,
+ I40E_TUNNEL_L4_NODE_IPV6,
+ I40E_TUNNEL_L4_NODE_TCP,
+ I40E_TUNNEL_L4_NODE_UDP,
+ I40E_TUNNEL_L4_NODE_SCTP,
+ I40E_TUNNEL_L4_NODE_END,
+ I40E_TUNNEL_L4_NODE_MAX,
+};
+
+static int
+i40e_tunnel_node_tcp_validate(const void *ctx __rte_unused,
+ const struct rte_flow_item *item,
+ struct rte_flow_error *error)
+{
+ const struct rte_flow_item_tcp *tcp_mask = item->mask;
+
+ /* only source/destination ports are supported */
+ if (tcp_mask->hdr.sent_seq ||
+ tcp_mask->hdr.recv_ack ||
+ tcp_mask->hdr.data_off ||
+ tcp_mask->hdr.tcp_flags ||
+ tcp_mask->hdr.rx_win ||
+ tcp_mask->hdr.cksum ||
+ tcp_mask->hdr.tcp_urp) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid TCP mask");
+ }
+
+ /* src/dst ports have to be fully masked or fully unmasked */
+ if (!CI_FIELD_IS_ZERO_OR_MASKED(&tcp_mask->hdr.src_port) ||
+ !CI_FIELD_IS_ZERO_OR_MASKED(&tcp_mask->hdr.dst_port)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid TCP mask");
+ }
+ /* there can be only one! */
+ if (tcp_mask->hdr.src_port && tcp_mask->hdr.dst_port) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid TCP mask");
+ }
+ return 0;
+}
+
+static int
+i40e_tunnel_node_tcp_process(void *ctx, const struct rte_flow_item *item,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+ const struct rte_flow_item_tcp *tcp_spec = item->spec;
+ const struct rte_flow_item_tcp *tcp_mask = item->mask;
+
+ if (tcp_mask->hdr.src_port) {
+ tunnel_filter->l4_port_type = I40E_L4_PORT_TYPE_SRC;
+ tunnel_filter->tenant_id = rte_be_to_cpu_32(tcp_spec->hdr.src_port);
+ } else if (tcp_mask->hdr.dst_port) {
+ tunnel_filter->l4_port_type = I40E_L4_PORT_TYPE_DST;
+ tunnel_filter->tenant_id = rte_be_to_cpu_32(tcp_spec->hdr.dst_port);
+ }
+ tunnel_filter->tunnel_type = I40E_CLOUD_TYPE_TCP;
+
+ return 0;
+}
+
+static int
+i40e_tunnel_node_udp_validate(const void *ctx __rte_unused,
+ const struct rte_flow_item *item,
+ struct rte_flow_error *error)
+{
+ const struct rte_flow_item_udp *udp_mask = item->mask;
+
+ /* only source/destination ports are supported */
+ if (udp_mask->hdr.dgram_len ||
+ udp_mask->hdr.dgram_cksum) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid UDP mask");
+ }
+
+ /* src/dst ports have to be fully masked or fully unmasked */
+ if (!CI_FIELD_IS_ZERO_OR_MASKED(&udp_mask->hdr.src_port) ||
+ !CI_FIELD_IS_ZERO_OR_MASKED(&udp_mask->hdr.dst_port)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid UDP mask");
+ }
+ /* there can be only one! */
+ if (udp_mask->hdr.src_port && udp_mask->hdr.dst_port) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid UDP mask");
+ }
+ return 0;
+}
+
+static int
+i40e_tunnel_node_udp_process(void *ctx, const struct rte_flow_item *item,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+ const struct rte_flow_item_udp *udp_spec = item->spec;
+ const struct rte_flow_item_udp *udp_mask = item->mask;
+
+ if (udp_mask->hdr.src_port) {
+ tunnel_filter->l4_port_type = I40E_L4_PORT_TYPE_SRC;
+ tunnel_filter->tenant_id = rte_be_to_cpu_32(udp_spec->hdr.src_port);
+ } else if (udp_mask->hdr.dst_port) {
+ tunnel_filter->l4_port_type = I40E_L4_PORT_TYPE_DST;
+ tunnel_filter->tenant_id = rte_be_to_cpu_32(udp_spec->hdr.dst_port);
+ }
+ tunnel_filter->tunnel_type = I40E_CLOUD_TYPE_UDP;
+
+ return 0;
+}
+
+static int
+i40e_tunnel_node_sctp_validate(const void *ctx __rte_unused,
+ const struct rte_flow_item *item,
+ struct rte_flow_error *error)
+{
+ const struct rte_flow_item_sctp *sctp_mask = item->mask;
+
+ /* only source/destination ports are supported */
+ if (sctp_mask->hdr.cksum || sctp_mask->hdr.tag) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid SCTP mask");
+ }
+
+ /* src/dst ports have to be fully masked or fully unmasked */
+ if (!CI_FIELD_IS_ZERO_OR_MASKED(&sctp_mask->hdr.src_port) ||
+ !CI_FIELD_IS_ZERO_OR_MASKED(&sctp_mask->hdr.dst_port)) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid SCTP mask");
+ }
+ /* there can be only one! */
+ if (sctp_mask->hdr.src_port && sctp_mask->hdr.dst_port) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Invalid SCTP mask");
+ }
+ return 0;
+}
+
+static int
+i40e_tunnel_node_sctp_process(void *ctx, const struct rte_flow_item *item,
+ struct rte_flow_error *error __rte_unused)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = ctx;
+ struct i40e_tunnel_filter_conf *tunnel_filter = &tunnel_ctx->filter;
+ const struct rte_flow_item_sctp *sctp_spec = item->spec;
+ const struct rte_flow_item_sctp *sctp_mask = item->mask;
+
+ if (sctp_mask->hdr.src_port) {
+ tunnel_filter->l4_port_type = I40E_L4_PORT_TYPE_SRC;
+ tunnel_filter->tenant_id = rte_be_to_cpu_32(sctp_spec->hdr.src_port);
+ } else if (sctp_mask->hdr.dst_port) {
+ tunnel_filter->l4_port_type = I40E_L4_PORT_TYPE_DST;
+ tunnel_filter->tenant_id = rte_be_to_cpu_32(sctp_spec->hdr.dst_port);
+ }
+ tunnel_filter->tunnel_type = I40E_CLOUD_TYPE_SCTP;
+
+ return 0;
+}
+
+static const struct flow_graph i40e_tunnel_l4_graph = {
+ .nodes = (struct flow_graph_node[]) {
+ [I40E_TUNNEL_L4_NODE_START] = {
+ .name = "START",
+ },
+ [I40E_TUNNEL_L4_NODE_ETH] = {
+ .name = "ETH",
+ .type = RTE_FLOW_ITEM_TYPE_ETH,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ },
+ [I40E_TUNNEL_L4_NODE_IPV4] = {
+ .name = "IPv4",
+ .type = RTE_FLOW_ITEM_TYPE_IPV4,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ .process = i40e_tunnel_node_ipv4_process,
+ },
+ [I40E_TUNNEL_L4_NODE_IPV6] = {
+ .name = "IPv6",
+ .type = RTE_FLOW_ITEM_TYPE_IPV6,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_EMPTY,
+ .process = i40e_tunnel_node_ipv6_process,
+ },
+ [I40E_TUNNEL_L4_NODE_TCP] = {
+ .name = "TCP",
+ .type = RTE_FLOW_ITEM_TYPE_TCP,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_tcp_validate,
+ .process = i40e_tunnel_node_tcp_process,
+ },
+ [I40E_TUNNEL_L4_NODE_UDP] = {
+ .name = "UDP",
+ .type = RTE_FLOW_ITEM_TYPE_UDP,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_udp_validate,
+ .process = i40e_tunnel_node_udp_process,
+ },
+ [I40E_TUNNEL_L4_NODE_SCTP] = {
+ .name = "SCTP",
+ .type = RTE_FLOW_ITEM_TYPE_SCTP,
+ .constraints = FLOW_GRAPH_NODE_EXPECT_SPEC_MASK,
+ .validate = i40e_tunnel_node_sctp_validate,
+ .process = i40e_tunnel_node_sctp_process,
+ },
+ [I40E_TUNNEL_L4_NODE_END] = {
+ .name = "END",
+ .type = RTE_FLOW_ITEM_TYPE_END,
+ },
+ },
+ .edges = (struct flow_graph_edge[]) {
+ [I40E_TUNNEL_L4_NODE_START] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_L4_NODE_ETH,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_L4_NODE_ETH] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_L4_NODE_IPV4,
+ I40E_TUNNEL_L4_NODE_IPV6,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_L4_NODE_IPV4] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_L4_NODE_TCP,
+ I40E_TUNNEL_L4_NODE_UDP,
+ I40E_TUNNEL_L4_NODE_SCTP,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_L4_NODE_IPV6] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_L4_NODE_TCP,
+ I40E_TUNNEL_L4_NODE_UDP,
+ I40E_TUNNEL_L4_NODE_SCTP,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_L4_NODE_TCP] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_L4_NODE_END,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_L4_NODE_UDP] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_L4_NODE_END,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ [I40E_TUNNEL_L4_NODE_SCTP] = {
+ .next = (size_t[]) {
+ I40E_TUNNEL_L4_NODE_END,
+ FLOW_GRAPH_NODE_EDGE_END
+ }
+ },
+ },
+};
+
+static int
+i40e_tunnel_action_check(const struct ci_flow_actions *actions,
+ const struct ci_flow_actions_check_param *param,
+ struct rte_flow_error *error)
+{
+ struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(param->driver_ctx);
+ const struct rte_flow_action *first, *second;
+ const struct rte_flow_action_queue *act_q;
+ bool is_to_vf = false;
+
+ first = actions->actions[0];
+ /* can be NULL */
+ second = actions->actions[1];
+
+ /* first action must be PF or VF */
+ if (first->type == RTE_FLOW_ACTION_TYPE_VF) {
+ const struct rte_flow_action_vf *vf = first->conf;
+ if (vf->id >= pf->vf_num) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ACTION, first,
+ "Invalid VF ID for tunnel filter");
+ }
+ is_to_vf = true;
+ } else if (first->type != RTE_FLOW_ACTION_TYPE_PF) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ACTION, first,
+ "Unsupported action");
+ }
+
+ /* check if second action is QUEUE */
+ if (second == NULL)
+ return 0;
+
+ if (second->type != RTE_FLOW_ACTION_TYPE_QUEUE) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ACTION, second,
+ "Unsupported action");
+ }
+
+ act_q = second->conf;
+ /* check queue ID for PF flow */
+ if (!is_to_vf && act_q->index >= pf->dev_data->nb_rx_queues) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ACTION_CONF, act_q,
+ "Invalid queue ID for tunnel filter");
+ }
+ /* check queue ID for VF flow */
+ if (is_to_vf && act_q->index >= pf->vf_nb_qps) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ACTION_CONF, act_q,
+ "Invalid queue ID for tunnel filter");
+ }
+
+ return 0;
+}
+
+static int
+i40e_tunnel_ctx_init(const struct rte_flow_action actions[],
+ const struct rte_flow_attr *attr,
+ struct ci_flow_engine_ctx *ctx,
+ struct rte_flow_error *error)
+{
+ struct i40e_tunnel_ctx *tunnel_ctx = (struct i40e_tunnel_ctx *)ctx;
+ struct ci_flow_actions parsed_actions = {0};
+ struct ci_flow_actions_check_param ac_param = {
+ .allowed_types = (enum rte_flow_action_type[]) {
+ RTE_FLOW_ACTION_TYPE_QUEUE,
+ RTE_FLOW_ACTION_TYPE_PF,
+ RTE_FLOW_ACTION_TYPE_VF,
+ RTE_FLOW_ACTION_TYPE_END
+ },
+ .max_actions = 2,
+ .check = i40e_tunnel_action_check,
+ .driver_ctx = ctx->dev_data->dev_private,
+ };
+ const struct rte_flow_action *first, *second;
+ const struct rte_flow_action_queue *act_q;
+ int ret;
+
+ ret = ci_flow_check_attr(attr, NULL, error);
+ if (ret)
+ return ret;
+
+ ret = ci_flow_check_actions(actions, &ac_param, &parsed_actions, error);
+ if (ret)
+ return ret;
+
+ first = parsed_actions.actions[0];
+ /* can be NULL */
+ second = parsed_actions.actions[1];
+
+ if (first->type == RTE_FLOW_ACTION_TYPE_VF) {
+ const struct rte_flow_action_vf *vf = first->conf;
+ tunnel_ctx->filter.vf_id = vf->id;
+ tunnel_ctx->filter.is_to_vf = 1;
+ } else if (first->type == RTE_FLOW_ACTION_TYPE_PF) {
+ tunnel_ctx->filter.is_to_vf = 0;
+ }
+
+ /* check if second action is QUEUE */
+ if (second == NULL)
+ return 0;
+
+ act_q = second->conf;
+ tunnel_ctx->filter.queue_id = act_q->index;
+
+ return 0;
+}
+
+static int
+i40e_tunnel_ctx_to_flow(const struct ci_flow_engine_ctx *ctx,
+ struct ci_flow *flow,
+ struct rte_flow_error *error)
+{
+ const struct i40e_tunnel_ctx *tunnel_ctx = (const struct i40e_tunnel_ctx *)ctx;
+ struct i40e_tunnel_flow *tunnel_flow = (struct i40e_tunnel_flow *)flow;
+ struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(flow->dev_data->dev_private);
+ int ret;
+
+ /* copy filter configuration from context to flow */
+ tunnel_flow->filter = tunnel_ctx->filter;
+
+ /* compute hash input */
+ ret = i40e_tunnel_filter_match_key_get(pf, &tunnel_flow->filter,
+ &tunnel_flow->match_key);
+ if (ret != 0) {
+ return rte_flow_error_set(error, -ret,
+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
+ "Failed to build tunnel filter input");
+ }
+
+ return 0;
+}
+
+static int
+i40e_tunnel_flow_register(struct ci_flow *flow, struct rte_flow_error *error)
+{
+ struct i40e_tunnel_flow *tunnel_flow = (struct i40e_tunnel_flow *)flow;
+ struct i40e_tunnel_priv *priv = flow->engine_priv;
+ struct i40e_tunnel_state *state = priv->state;
+ int ret;
+
+ if (rte_hash_lookup(state->hash_table, &tunnel_flow->match_key) >= 0) {
+ return rte_flow_error_set(error, EEXIST,
+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
+ "Conflict with existing tunnel rule");
+ }
+
+ ret = rte_hash_add_key(state->hash_table, &tunnel_flow->match_key);
+ if (ret < 0) {
+ return rte_flow_error_set(error, -ret,
+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
+ "Tunnel filter table is full");
+ }
+
+ return 0;
+}
+
+static int
+i40e_tunnel_flow_unregister(struct ci_flow *flow, struct rte_flow_error *error)
+{
+ struct i40e_tunnel_flow *tunnel_flow = (struct i40e_tunnel_flow *)flow;
+ struct i40e_tunnel_priv *priv = flow->engine_priv;
+ struct i40e_tunnel_state *state = priv->state;
+
+ if (rte_hash_del_key(state->hash_table, &tunnel_flow->match_key) < 0) {
+ return rte_flow_error_set(error, ENOENT,
+ RTE_FLOW_ERROR_TYPE_HANDLE, flow,
+ "Tunnel filter is missing from the filter table");
+ }
+
+ return 0;
+}
+
+static int
+i40e_tunnel_flow_install(struct ci_flow *flow, struct rte_flow_error *error)
+{
+ struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(flow->dev_data->dev_private);
+ struct i40e_tunnel_flow *tunnel_flow = (struct i40e_tunnel_flow *)flow;
+ int ret;
+
+ ret = i40e_tunnel_filter_program(pf, &tunnel_flow->filter, 1);
+ if (ret) {
+ return rte_flow_error_set(error, -ret,
+ RTE_FLOW_ERROR_TYPE_HANDLE, flow,
+ "Failed to install tunnel filter");
+ }
+ return 0;
+}
+
+static int
+i40e_tunnel_flow_uninstall(struct ci_flow *flow, struct rte_flow_error *error)
+{
+ struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(flow->dev_data->dev_private);
+ struct i40e_tunnel_flow *tunnel_flow = (struct i40e_tunnel_flow *)flow;
+ int ret;
+
+ ret = i40e_tunnel_filter_program(pf, &tunnel_flow->filter, 0);
+ if (ret) {
+ return rte_flow_error_set(error, -ret,
+ RTE_FLOW_ERROR_TYPE_HANDLE, flow,
+ "Failed to uninstall tunnel filter");
+ }
+ return 0;
+}
+
+static int
+i40e_tunnel_flow_engine_init(const struct ci_flow_engine *engine __rte_unused,
+ struct rte_eth_dev_data *dev_data,
+ void *priv)
+{
+ struct i40e_tunnel_priv *tunnel_priv = priv;
+
+ tunnel_priv->state = i40e_tunnel_state_attach(dev_data);
+ return tunnel_priv->state == NULL ? -ENOMEM : 0;
+}
+
+static void
+i40e_tunnel_flow_engine_uninit(const struct ci_flow_engine *engine __rte_unused,
+ void *priv)
+{
+ struct i40e_tunnel_priv *tunnel_priv = priv;
+
+ i40e_tunnel_state_detach(tunnel_priv->state);
+}
+
+static const struct ci_flow_engine_ops i40e_flow_engine_tunnel_ops = {
+ .engine_init = i40e_tunnel_flow_engine_init,
+ .engine_uninit = i40e_tunnel_flow_engine_uninit,
+ .ctx_init = i40e_tunnel_ctx_init,
+ .ctx_to_flow = i40e_tunnel_ctx_to_flow,
+ .flow_register = i40e_tunnel_flow_register,
+ .flow_unregister = i40e_tunnel_flow_unregister,
+ .flow_install = i40e_tunnel_flow_install,
+ .flow_uninstall = i40e_tunnel_flow_uninstall,
+};
+
+const struct ci_flow_engine i40e_flow_engine_tunnel_nvgre = {
+ .name = "tunnel_nvgre",
+ .ops = &i40e_flow_engine_tunnel_ops,
+ .ctx_size = sizeof(struct i40e_tunnel_ctx),
+ .flow_size = sizeof(struct i40e_tunnel_flow),
+ .priv_size = sizeof(struct i40e_tunnel_priv),
+ .graph = &i40e_tunnel_nvgre_graph,
+};
+
+const struct ci_flow_engine i40e_flow_engine_tunnel_vxlan = {
+ .name = "tunnel_vxlan",
+ .ops = &i40e_flow_engine_tunnel_ops,
+ .ctx_size = sizeof(struct i40e_tunnel_ctx),
+ .flow_size = sizeof(struct i40e_tunnel_flow),
+ .priv_size = sizeof(struct i40e_tunnel_priv),
+ .graph = &i40e_tunnel_vxlan_graph,
+};
+
+const struct ci_flow_engine i40e_flow_engine_tunnel_mpls = {
+ .name = "tunnel_mpls",
+ .ops = &i40e_flow_engine_tunnel_ops,
+ .ctx_size = sizeof(struct i40e_tunnel_ctx),
+ .flow_size = sizeof(struct i40e_tunnel_flow),
+ .priv_size = sizeof(struct i40e_tunnel_priv),
+ .graph = &i40e_tunnel_mpls_graph,
+};
+
+const struct ci_flow_engine i40e_flow_engine_tunnel_gtp = {
+ .name = "tunnel_gtp",
+ .ops = &i40e_flow_engine_tunnel_ops,
+ .ctx_size = sizeof(struct i40e_tunnel_ctx),
+ .flow_size = sizeof(struct i40e_tunnel_flow),
+ .priv_size = sizeof(struct i40e_tunnel_priv),
+ .graph = &i40e_tunnel_gtp_graph,
+};
+
+const struct ci_flow_engine i40e_flow_engine_tunnel_l4 = {
+ .name = "tunnel_l4",
+ .ops = &i40e_flow_engine_tunnel_ops,
+ .ctx_size = sizeof(struct i40e_tunnel_ctx),
+ .flow_size = sizeof(struct i40e_tunnel_flow),
+ .priv_size = sizeof(struct i40e_tunnel_priv),
+ .graph = &i40e_tunnel_l4_graph,
+};
+
+const struct ci_flow_engine i40e_flow_engine_tunnel_qinq = {
+ .name = "tunnel_qinq",
+ .ops = &i40e_flow_engine_tunnel_ops,
+ .ctx_size = sizeof(struct i40e_tunnel_ctx),
+ .flow_size = sizeof(struct i40e_tunnel_flow),
+ .priv_size = sizeof(struct i40e_tunnel_priv),
+ .graph = &i40e_tunnel_qinq_graph,
+};
diff --git a/drivers/net/intel/i40e/meson.build b/drivers/net/intel/i40e/meson.build
index c07257cb80..0db60c1e99 100644
--- a/drivers/net/intel/i40e/meson.build
+++ b/drivers/net/intel/i40e/meson.build
@@ -35,6 +35,7 @@ sources += files(
'i40e_flow.c',
'i40e_flow_ethertype.c',
'i40e_flow_fdir.c',
+ 'i40e_flow_tunnel.c',
'i40e_tm.c',
'i40e_hash.c',
'i40e_vf_representor.c',
--
2.52.0
More information about the dev
mailing list