From patchwork Fri Dec 2 11:53:36 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Xing, Beilei" X-Patchwork-Id: 17377 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [IPv6:::1]) by dpdk.org (Postfix) with ESMTP id 5EAE1FA76; Fri, 2 Dec 2016 05:14:23 +0100 (CET) Received: from mga14.intel.com (mga14.intel.com [192.55.52.115]) by dpdk.org (Postfix) with ESMTP id 199D458DB for ; Fri, 2 Dec 2016 05:13:30 +0100 (CET) Received: from orsmga003.jf.intel.com ([10.7.209.27]) by fmsmga103.fm.intel.com with ESMTP; 01 Dec 2016 20:13:16 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.33,284,1477983600"; d="scan'208";a="907853580" Received: from dpdk9.sh.intel.com ([10.239.129.141]) by orsmga003.jf.intel.com with ESMTP; 01 Dec 2016 20:13:15 -0800 From: Beilei Xing To: jingjing.wu@intel.com, helin.zhang@intel.com Cc: dev@dpdk.org, wenzhuo.lu@intel.com Date: Fri, 2 Dec 2016 06:53:36 -0500 Message-Id: <1480679625-4157-16-git-send-email-beilei.xing@intel.com> X-Mailer: git-send-email 2.5.5 In-Reply-To: <1480679625-4157-1-git-send-email-beilei.xing@intel.com> References: <1480679625-4157-1-git-send-email-beilei.xing@intel.com> Subject: [dpdk-dev] [PATCH 15/24] net/i40e: parse flow director filter X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Check if the rule is a flow director rule, and get the flow director info. Signed-off-by: Beilei Xing --- 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)