Check if the rule is a flow director rule, and get the
flow director info.
Signed-off-by: Beilei Xing <beilei.x...@intel.com>
---
drivers/net/i40e/i40e_ethdev.c | 537 +++++++++++++++++++++++++++++++++++++++++
1 file changed, 537 insertions(+)
diff --git a/drivers/net/i40e/i40e_ethdev.c b/drivers/net/i40e/i40e_ethdev.c
index 1ffafa0..12255fa 100644
--- a/drivers/net/i40e/i40e_ethdev.c
+++ b/drivers/net/i40e/i40e_ethdev.c
@@ -502,6 +502,11 @@ static int i40e_parse_tunnel_filter(const struct
rte_flow_attr *attr,
const struct rte_flow_action *actions,
struct rte_eth_tunnel_filter_conf *filter,
struct rte_flow_error *error);
+static int i40e_parse_fdir_filter(const struct rte_flow_attr *attr,
+ const struct rte_flow_item *pattern,
+ const struct rte_flow_action *actions,
+ struct rte_eth_fdir_filter *filter,
+ struct rte_flow_error *error);
static int i40e_flow_validate(__rte_unused struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
const struct rte_flow_item *pattern,
@@ -11006,6 +11011,532 @@ i40e_parse_tunnel_filter(const struct rte_flow_attr
*attr,
return ret;
}
+/**
+ * Parse the rule to see if it is a flow firector rule.
+ * And get the flow director filter info.
+ */
+static int
+i40e_parse_fdir_filter(const struct rte_flow_attr *attr,
+ const struct rte_flow_item *pattern,
+ const struct rte_flow_action *actions,
+ struct rte_eth_fdir_filter *filter,
+ struct rte_flow_error *error)
+{
+ const struct rte_flow_item *item;
+ const struct rte_flow_action *act;
+ const struct rte_flow_item_eth *eth_spec, *eth_mask;
+ const struct rte_flow_item_vlan *vlan_spec, *vlan_mask;
+ const struct rte_flow_item_ipv4 *ipv4_spec, *ipv4_mask;
+ const struct rte_flow_item_ipv6 *ipv6_spec, *ipv6_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_sctp *sctp_spec, *sctp_mask;
+ const struct rte_flow_item_vf *vf_spec;
+ const struct rte_flow_action_mark *mark_spec;
+ const struct rte_flow_action_queue *act_q;
+ struct ether_addr macaddr_masked = {
+ .addr_bytes = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0}
+ };
+ uint32_t i;
+ uint32_t flow_type = RTE_ETH_FLOW_UNKNOWN;
+ enum i40e_filter_pctype pctype;
+ uint64_t input_set = I40E_INSET_NONE;
+ uint16_t l3 = 0;
+ uint16_t flag_offset;
+
+ /* parse pattern */
+ i = 0;
+
+ /* The first not void item should be ETH or IPv4 or IPv6 */
+ PATTERN_SKIP_VOID(filter, struct rte_eth_fdir_filter,
+ RTE_FLOW_ERROR_TYPE_ITEM_NUM);
+ if (item->type != RTE_FLOW_ITEM_TYPE_ETH &&
+ item->type != RTE_FLOW_ITEM_TYPE_VLAN &&
+ item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
+ item->type != RTE_FLOW_ITEM_TYPE_IPV6) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ /* Check if the not void item is ETH. */
+ if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
+ eth_spec = (const struct rte_flow_item_eth *)item->spec;
+ eth_mask = (const struct rte_flow_item_eth *)item->mask;
+
+ if ((!eth_spec && eth_mask) || (eth_spec && !eth_mask)) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ if (eth_spec) {
+ filter->input.flow.l2_flow.ether_type =
+ (uint16_t)eth_spec->type;
+ }
+
+ if (eth_mask) {
+ /* SRC address and DST address should be masked. */
+ if (!is_same_ether_addr(ð_mask->src,
+ &macaddr_masked) ||
+ !is_same_ether_addr(ð_mask->dst,
+ &macaddr_masked)) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ if (eth_mask->type && eth_mask->type != 0xFFFF) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ flow_type = RTE_ETH_FLOW_L2_PAYLOAD;
+ input_set |= I40E_INSET_LAST_ETHER_TYPE;
+ }
+
+ i++;
+ PATTERN_SKIP_VOID(filter, struct rte_eth_fdir_filter,
+ RTE_FLOW_ERROR_TYPE_ITEM);
+ if (item->type != RTE_FLOW_ITEM_TYPE_VLAN &&
+ item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
+ item->type != RTE_FLOW_ITEM_TYPE_IPV6 &&
+ item->type != RTE_FLOW_ITEM_TYPE_VF &&
+ item->type != RTE_FLOW_ITEM_TYPE_END) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+ }
+
+ /* Check if the not void item is VLAN. */
+ if (item->type == RTE_FLOW_ITEM_TYPE_VLAN) {
+ vlan_spec = (const struct rte_flow_item_vlan *)item->spec;
+ vlan_mask = (const struct rte_flow_item_vlan *)item->mask;
+
+ if (i == 1) {
+ if ((vlan_spec && !vlan_mask) ||
+ (!vlan_spec && vlan_mask)) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+ } else if (i == 2) {
+ if (!vlan_spec || !vlan_mask) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+ }
+
+ if (vlan_spec && vlan_mask) {
+ filter->input.flow_ext.vlan_tci =
+ rte_be_to_cpu_16(vlan_spec->tci) & 0x0FFF;
+ if (vlan_mask->tpid ||
+ (vlan_mask->tci && vlan_mask->tci !=
+ rte_cpu_to_be_16(0x0FFF))) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ input_set |= I40E_INSET_VLAN_INNER;
+ }
+
+ /* Check if the next not void item is IPV4 or IPV6. */
+ i++;
+ PATTERN_SKIP_VOID(filter, struct rte_eth_fdir_filter,
+ RTE_FLOW_ERROR_TYPE_ITEM);
+ if (item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
+ item->type != RTE_FLOW_ITEM_TYPE_IPV6) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+ }
+
+ /* Check if the not void item is IPV4. */
+ if (item->type == RTE_FLOW_ITEM_TYPE_IPV4) {
+ l3 = RTE_FLOW_ITEM_TYPE_IPV4;
+ ipv4_spec = (const struct rte_flow_item_ipv4 *)item->spec;
+ ipv4_mask = (const struct rte_flow_item_ipv4 *)item->mask;
+
+ /* Check if it is fragment. */
+ flag_offset = rte_be_to_cpu_16(ipv4_spec->hdr.fragment_offset);
+ if (flag_offset & !IPV4_HDR_MF_FLAG)
+ flow_type = RTE_ETH_FLOW_NONFRAG_IPV4_OTHER;
+ if (flag_offset & IPV4_HDR_OFFSET_MASK ||
+ flag_offset & IPV4_HDR_MF_FLAG)
+ flow_type = RTE_ETH_FLOW_FRAG_IPV4;
+
+ if (ipv4_spec) {
+ filter->input.flow.ip4_flow.proto =
+ ipv4_spec->hdr.next_proto_id;
+ filter->input.flow.ip4_flow.tos =
+ ipv4_spec->hdr.type_of_service;
+ filter->input.flow.ip4_flow.ttl =
+ ipv4_spec->hdr.time_to_live;
+ filter->input.flow.ip4_flow.src_ip =
+ ipv4_spec->hdr.src_addr;
+ filter->input.flow.ip4_flow.dst_ip =
+ ipv4_spec->hdr.dst_addr;
+ }
+
+ if (ipv4_mask) {
+ if (ipv4_mask->hdr.version_ihl ||
+ ipv4_mask->hdr.total_length ||
+ ipv4_mask->hdr.packet_id ||
+ ipv4_mask->hdr.fragment_offset ||
+ ipv4_mask->hdr.hdr_checksum) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ if (ipv4_mask->hdr.src_addr == 0xFFFFFFFF)
+ input_set |= I40E_INSET_IPV4_SRC;
+ if (ipv4_mask->hdr.dst_addr == 0xFFFFFFFF)
+ input_set |= I40E_INSET_IPV4_DST;
+ if (ipv4_mask->hdr.type_of_service == 0xFF)
+ input_set |= I40E_INSET_IPV4_TOS;
+ if (ipv4_mask->hdr.time_to_live == 0xFF)
+ input_set |= I40E_INSET_IPV4_TTL;
+ if (ipv4_mask->hdr.next_proto_id == 0xFF)
+ input_set |= I40E_INSET_IPV4_PROTO;
+ }
+ }
+
+ /* Check if the not void item is IPV6. */
+ if (item->type == RTE_FLOW_ITEM_TYPE_IPV6) {
+ l3 = RTE_FLOW_ITEM_TYPE_IPV6;
+ ipv6_spec = (const struct rte_flow_item_ipv6 *)item->spec;
+ ipv6_mask = (const struct rte_flow_item_ipv6 *)item->mask;
+
+ /* Check if it is fragment. */
+ if (ipv6_spec->hdr.proto == 44)
+ flow_type = RTE_ETH_FLOW_FRAG_IPV6;
+ else
+ flow_type = RTE_ETH_FLOW_NONFRAG_IPV6_OTHER;
+
+ uint32_t j;
+
+ if (ipv6_spec) {
+ filter->input.flow.ipv6_flow.tc =
+ (uint8_t)(ipv6_spec->hdr.vtc_flow << 4);
+ filter->input.flow.ipv6_flow.proto =
+ ipv6_spec->hdr.proto;
+ filter->input.flow.ipv6_flow.hop_limits =
+ ipv6_spec->hdr.hop_limits;
+
+ rte_memcpy(filter->input.flow.ipv6_flow.src_ip,
+ ipv6_spec->hdr.src_addr, 16);
+ rte_memcpy(filter->input.flow.ipv6_flow.dst_ip,
+ ipv6_spec->hdr.dst_addr, 16);
+ }
+
+ if (ipv6_mask) {
+ if (ipv6_mask->hdr.payload_len) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ for (j = 0; j < RTE_DIM(ipv6_mask->hdr.src_addr); j++) {
+ if (ipv6_mask->hdr.src_addr[j] != 0xFF ||
+ ipv6_mask->hdr.dst_addr[j] != 0xFF) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+ }
+
+ input_set |= I40E_INSET_IPV6_SRC;
+ input_set |= I40E_INSET_IPV6_DST;
+
+ if ((ipv6_mask->hdr.vtc_flow & rte_cpu_to_be_16(0xFF0))
+ == rte_cpu_to_be_16(0xFF0))
+ input_set |= I40E_INSET_IPV6_TC;
+ if (ipv6_mask->hdr.proto == 0xFF)
+ input_set |= I40E_INSET_IPV6_NEXT_HDR;
+ if (ipv6_mask->hdr.hop_limits == 0xFF)
+ input_set |= I40E_INSET_IPV6_HOP_LIMIT;
+ }
+ }
+
+ if (item->type == RTE_FLOW_ITEM_TYPE_IPV4 ||
+ item->type == RTE_FLOW_ITEM_TYPE_IPV6) {
+ /* Check the next not void item */
+ i++;
+ PATTERN_SKIP_VOID(filter, struct rte_eth_fdir_filter,
+ RTE_FLOW_ERROR_TYPE_ITEM);
+ if ((flow_type == RTE_ETH_FLOW_FRAG_IPV4) ||
+ (flow_type == RTE_ETH_FLOW_FRAG_IPV6)) {
+ if (item->type != RTE_FLOW_ITEM_TYPE_END) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+ } else {
+ if (item->type != RTE_FLOW_ITEM_TYPE_TCP &&
+ item->type != RTE_FLOW_ITEM_TYPE_UDP &&
+ item->type != RTE_FLOW_ITEM_TYPE_SCTP &&
+ item->type != RTE_FLOW_ITEM_TYPE_VF &&
+ item->type != RTE_FLOW_ITEM_TYPE_END) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+ }
+ }
+
+ /* Check if the next not void item is TCP. */
+ if (item->type == RTE_FLOW_ITEM_TYPE_TCP) {
+ tcp_spec = (const struct rte_flow_item_tcp *)item->spec;
+ tcp_mask = (const struct rte_flow_item_tcp *)item->mask;
+
+ if (!tcp_spec || !tcp_mask) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ if (l3 == RTE_FLOW_ITEM_TYPE_IPV4)
+ flow_type = RTE_ETH_FLOW_NONFRAG_IPV4_TCP;
+ else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6)
+ flow_type = RTE_ETH_FLOW_NONFRAG_IPV6_TCP;
+
+ if (tcp_spec) {
+ if (l3 == RTE_FLOW_ITEM_TYPE_IPV4) {
+ filter->input.flow.tcp4_flow.src_port =
+ tcp_spec->hdr.src_port;
+ filter->input.flow.tcp4_flow.dst_port =
+ tcp_spec->hdr.dst_port;
+ } else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6) {
+ filter->input.flow.tcp6_flow.src_port =
+ tcp_spec->hdr.src_port;
+ filter->input.flow.tcp6_flow.dst_port =
+ tcp_spec->hdr.dst_port;
+ }
+ }
+
+ if (tcp_mask) {
+ 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) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ if ((tcp_mask->hdr.src_port != 0xFFFF &&
+ tcp_mask->hdr.src_port != 0) ||
+ (tcp_mask->hdr.dst_port != 0xFFFF &&
+ tcp_mask->hdr.dst_port != 0)) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ if (tcp_mask->hdr.src_port == 0xFFFF)
+ input_set |= I40E_INSET_SRC_PORT;
+ if (tcp_mask->hdr.dst_port == 0xFFFF)
+ input_set |= I40E_INSET_DST_PORT;
+ }
+ }
+
+ /* Check if the not void item is UDP. */
+ if (item->type == RTE_FLOW_ITEM_TYPE_UDP) {
+ udp_spec = (const struct rte_flow_item_udp *)item->spec;
+ udp_mask = (const struct rte_flow_item_udp *)item->mask;
+
+ if (!udp_spec || !udp_mask) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ if (l3 == RTE_FLOW_ITEM_TYPE_IPV4)
+ flow_type = RTE_ETH_FLOW_NONFRAG_IPV4_UDP;
+ else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6)
+ flow_type = RTE_ETH_FLOW_NONFRAG_IPV6_UDP;
+
+ if (udp_spec) {
+ if (l3 == RTE_FLOW_ITEM_TYPE_IPV4) {
+ filter->input.flow.udp4_flow.src_port =
+ udp_spec->hdr.src_port;
+ filter->input.flow.udp4_flow.dst_port =
+ udp_spec->hdr.dst_port;
+ } else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6) {
+ filter->input.flow.udp6_flow.src_port =
+ udp_spec->hdr.src_port;
+ filter->input.flow.udp6_flow.dst_port =
+ udp_spec->hdr.dst_port;
+ }
+ }
+
+ if (udp_mask) {
+ if (udp_mask->hdr.dgram_len ||
+ udp_mask->hdr.dgram_cksum) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ if ((udp_mask->hdr.src_port != 0xFFFF &&
+ udp_mask->hdr.src_port != 0) ||
+ (udp_mask->hdr.dst_port != 0xFFFF &&
+ udp_mask->hdr.dst_port != 0)) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ if (udp_mask->hdr.src_port == 0xFFFF)
+ input_set |= I40E_INSET_SRC_PORT;
+ if (udp_mask->hdr.dst_port == 0xFFFF)
+ input_set |= I40E_INSET_DST_PORT;
+ }
+ }
+
+ /* Check if the not void item is SCTP. */
+ if (item->type == RTE_FLOW_ITEM_TYPE_SCTP) {
+ sctp_spec = (const struct rte_flow_item_sctp *)item->spec;
+ sctp_mask = (const struct rte_flow_item_sctp *)item->mask;
+
+ if (!sctp_spec || !sctp_mask) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ if (l3 == RTE_FLOW_ITEM_TYPE_IPV4)
+ flow_type = RTE_ETH_FLOW_NONFRAG_IPV4_SCTP;
+ else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6)
+ flow_type = RTE_ETH_FLOW_NONFRAG_IPV6_SCTP;
+
+ if (sctp_spec) {
+ if (l3 == RTE_FLOW_ITEM_TYPE_IPV4) {
+ filter->input.flow.sctp4_flow.src_port =
+ sctp_spec->hdr.src_port;
+ filter->input.flow.sctp4_flow.dst_port =
+ sctp_spec->hdr.dst_port;
+ filter->input.flow.sctp4_flow.verify_tag =
+ sctp_spec->hdr.tag;
+ } else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6) {
+ filter->input.flow.sctp6_flow.src_port =
+ sctp_spec->hdr.src_port;
+ filter->input.flow.sctp6_flow.dst_port =
+ sctp_spec->hdr.dst_port;
+ filter->input.flow.sctp6_flow.verify_tag =
+ sctp_spec->hdr.tag;
+ }
+ }
+
+ if (sctp_mask) {
+ if (sctp_mask->hdr.cksum) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ if ((sctp_mask->hdr.src_port != 0xFFFF &&
+ sctp_mask->hdr.src_port != 0) ||
+ (sctp_mask->hdr.dst_port != 0xFFFF &&
+ sctp_mask->hdr.dst_port != 0) ||
+ (sctp_mask->hdr.tag != 0xFFFFFFFF &&
+ sctp_mask->hdr.tag != 0)) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ if (sctp_mask->hdr.src_port == 0xFFFF)
+ input_set |= I40E_INSET_SRC_PORT;
+ if (sctp_mask->hdr.dst_port == 0xFFFF)
+ input_set |= I40E_INSET_DST_PORT;
+ if (sctp_mask->hdr.tag == 0xFFFFFFFF)
+ input_set |= I40E_INSET_SCTP_VT;
+ }
+ }
+
+ if (item->type == RTE_FLOW_ITEM_TYPE_TCP ||
+ item->type == RTE_FLOW_ITEM_TYPE_UDP ||
+ item->type == RTE_FLOW_ITEM_TYPE_SCTP) {
+ i++;
+ PATTERN_SKIP_VOID(filter, struct rte_eth_fdir_filter,
+ RTE_FLOW_ERROR_TYPE_ITEM);
+ if (item->type != RTE_FLOW_ITEM_TYPE_VF &&
+ item->type != RTE_FLOW_ITEM_TYPE_END) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+ }
+
+ /* Check if the next not void item is VF. */
+ if (item->type == RTE_FLOW_ITEM_TYPE_VF) {
+ vf_spec = (const struct rte_flow_item_vf *)item->spec;
+ filter->input.flow_ext.is_vf = 1;
+ filter->input.flow_ext.dst_id = vf_spec->id;
+ }
+
+ if (item->type != RTE_FLOW_ITEM_TYPE_END) {
+ /* Check if the next not void item is END. */
+ i++;
+ PATTERN_SKIP_VOID(filter, struct rte_eth_fdir_filter,
+ RTE_FLOW_ERROR_TYPE_ITEM);
+ if (item->type != RTE_FLOW_ITEM_TYPE_END) {
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+ }
+
+ pctype = i40e_flowtype_to_pctype(flow_type);
+ if (pctype == 0 || pctype > I40E_FILTER_PCTYPE_L2_PAYLOAD) {
+ PMD_DRV_LOG(ERR, "Not supported flow type (%u)",
+ conf->flow_type);
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ if (input_set != i40e_get_default_input_set(pctype)) {
+ PMD_DRV_LOG(ERR, "Invalid input set");
+ error->type = RTE_FLOW_ERROR_TYPE_ITEM;
+ return -EINVAL;
+ }
+
+ filter->input.flow_type = flow_type;
+
+ /* parse action */
+ i = 0;
+
+ /* Check if the first not void action is QUEUE or DROP. */
+ ACTION_SKIP_VOID(filter, struct rte_eth_fdir_filter,
+ RTE_FLOW_ERROR_TYPE_ACTION_NUM);
+ if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE &&
+ act->type != RTE_FLOW_ACTION_TYPE_DROP) {
+ error->type = RTE_FLOW_ERROR_TYPE_ACTION;
+ return -EINVAL;
+ }
+
+ act_q = (const struct rte_flow_action_queue *)act->conf;
+ filter->action.flex_off = 0;
+ if (act->type == RTE_FLOW_ACTION_TYPE_QUEUE)
+ filter->action.behavior = RTE_ETH_FDIR_ACCEPT;
+ else
+ filter->action.behavior = RTE_ETH_FDIR_REJECT;
+
+ filter->action.report_status = RTE_ETH_FDIR_REPORT_ID;
+ filter->action.rx_queue = act_q->index;
+
+ /* Check if the next not void item is MARK or END. */
+ i++;
+ ACTION_SKIP_VOID(filter, struct rte_eth_fdir_filter,
+ RTE_FLOW_ERROR_TYPE_ACTION_NUM);
+ if (act->type != RTE_FLOW_ACTION_TYPE_MARK &&
+ act->type != RTE_FLOW_ACTION_TYPE_END) {
+ error->type = RTE_FLOW_ERROR_TYPE_ACTION;
+ return -EINVAL;
+ }
+
+ if (act->type == RTE_FLOW_ACTION_TYPE_MARK) {
+ mark_spec = (const struct rte_flow_action_mark *)act->conf;
+ filter->soft_id = mark_spec->id;
+
+ /* Check if the next not void item is END. */
+ i++;
+ ACTION_SKIP_VOID(filter, struct rte_eth_fdir_filter,
+ RTE_FLOW_ERROR_TYPE_ACTION_NUM);
+ if (act->type != RTE_FLOW_ACTION_TYPE_END) {
+ error->type = RTE_FLOW_ERROR_TYPE_ACTION;
+ return -EINVAL;
+ }
+ }
+
+ return i40e_parse_attr(attr, error);
+}
+
static int
i40e_flow_validate(__rte_unused struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
@@ -11014,6 +11545,7 @@ i40e_flow_validate(__rte_unused struct rte_eth_dev *dev,
struct rte_flow_error *error)
{
struct rte_eth_ethertype_filter ethertype_filter;
+ struct rte_eth_fdir_filter fdir_filter;
struct rte_eth_mac_filter macvlan_filter;
struct rte_eth_tunnel_filter_conf tunnel_filter;
int ret;
@@ -11023,6 +11555,11 @@ i40e_flow_validate(__rte_unused struct rte_eth_dev
*dev,
if (!ret)
return 0;
+ ret = i40e_parse_fdir_filter(attr, pattern, actions,
+ &fdir_filter, error);
+ if (!ret)
+ return 0;
+
ret = i40e_parse_macvlan_filter(attr, pattern, actions,
&macvlan_filter, error);
if (!ret)
--
2.5.5
