From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 50F4DA0579; Wed, 18 Mar 2020 09:09:09 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id B07761C02A; Wed, 18 Mar 2020 09:08:50 +0100 (CET) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by dpdk.org (Postfix) with ESMTP id B560F1C025 for ; Wed, 18 Mar 2020 09:08:47 +0100 (CET) IronPort-SDR: kXp9sO6Cc+OCUNHXyFgm5LajgSi7zpy93EXyx4+vwI5b6wnVkgqgX5jkvF44QdY06eeJsAijFC c/9T9PSwVRgA== X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga005.jf.intel.com ([10.7.209.41]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 18 Mar 2020 01:08:47 -0700 IronPort-SDR: ILH9H8S2l4jYZICQOQZbI8BKCZcj3LSfw366nxfLkuJV0L5nNSAi+XatAuAT2VW8cVtEwkoACb WkwX7brtsq+Q== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,566,1574150400"; d="scan'208";a="417862958" Received: from npg-dpdk-cvl-jeffguo-01.sh.intel.com ([10.67.111.128]) by orsmga005.jf.intel.com with ESMTP; 18 Mar 2020 01:08:44 -0700 From: Jeff Guo To: xiaolong.ye@intel.com, qi.z.zhang@intel.com Cc: dev@dpdk.org, jingjing.wu@intel.com, yahui.cao@intel.com, simei.su@intel.com, jia.guo@intel.com Date: Wed, 18 Mar 2020 13:03:59 -0400 Message-Id: <20200318170401.7938-3-jia.guo@intel.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20200318170401.7938-1-jia.guo@intel.com> References: <20200318170401.7938-1-jia.guo@intel.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Subject: [dpdk-dev] [dpdk-dev 2/4] net/iavf: add RSS configuration for VFs 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" Add RSS configuration for VFs. The VF must be capable of configuring RSS. Change-Id: I2e5692ef80d4bcd8852488d82f70386156827007 Signed-off-by: Jeff Guo --- drivers/net/iavf/Makefile | 1 + drivers/net/iavf/iavf.h | 10 + drivers/net/iavf/iavf_hash.c | 1134 +++++++++++++++++++++++++++++++++ drivers/net/iavf/iavf_vchnl.c | 33 +- drivers/net/iavf/meson.build | 1 + 5 files changed, 1174 insertions(+), 5 deletions(-) create mode 100644 drivers/net/iavf/iavf_hash.c diff --git a/drivers/net/iavf/Makefile b/drivers/net/iavf/Makefile index 1bf0f26b5..7b0093a3e 100644 --- a/drivers/net/iavf/Makefile +++ b/drivers/net/iavf/Makefile @@ -24,6 +24,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_IAVF_PMD) += iavf_ethdev.c SRCS-$(CONFIG_RTE_LIBRTE_IAVF_PMD) += iavf_vchnl.c SRCS-$(CONFIG_RTE_LIBRTE_IAVF_PMD) += iavf_rxtx.c SRCS-$(CONFIG_RTE_LIBRTE_IAVF_PMD) += iavf_generic_flow.c +SRCS-$(CONFIG_RTE_LIBRTE_IAVF_PMD) += iavf_hash.c ifeq ($(CONFIG_RTE_ARCH_X86), y) SRCS-$(CONFIG_RTE_LIBRTE_IAVF_PMD) += iavf_rxtx_vec_sse.c endif diff --git a/drivers/net/iavf/iavf.h b/drivers/net/iavf/iavf.h index 6cefa1bf2..ce264a6ad 100644 --- a/drivers/net/iavf/iavf.h +++ b/drivers/net/iavf/iavf.h @@ -74,6 +74,13 @@ #define IAVF_COMMS_PROTO_L2TPv3 0x0000000000000008 #define IAVF_COMMS_PROTO_ESP 0x0000000000000010 +/* DDP package type */ +enum ice_pkg_type { + IAVF_PKG_TYPE_UNKNOWN, + IAVF_PKG_TYPE_OS_DEFAULT, + IAVF_PKG_TYPE_COMMS, +}; + struct iavf_adapter; struct iavf_rx_queue; struct iavf_tx_queue; @@ -151,6 +158,7 @@ struct iavf_adapter { bool tx_vec_allowed; const uint32_t *ptype_tbl; bool stopped; + enum ice_pkg_type active_pkg_type; /* loaded ddp package type */ }; /* IAVF_DEV_PRIVATE_TO */ @@ -256,4 +264,6 @@ int iavf_config_promisc(struct iavf_adapter *adapter, bool enable_unicast, int iavf_add_del_eth_addr(struct iavf_adapter *adapter, struct rte_ether_addr *addr, bool add); int iavf_add_del_vlan(struct iavf_adapter *adapter, uint16_t vlanid, bool add); +int iavf_add_del_rss_cfg(struct iavf_adapter *adapter, + struct virtchnl_rss_cfg *rss_cfg, bool add); #endif /* _IAVF_ETHDEV_H_ */ diff --git a/drivers/net/iavf/iavf_hash.c b/drivers/net/iavf/iavf_hash.c new file mode 100644 index 000000000..bda56f3f8 --- /dev/null +++ b/drivers/net/iavf/iavf_hash.c @@ -0,0 +1,1134 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 Intel Corporation + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "iavf_log.h" +#include "iavf.h" +#include "iavf_generic_flow.h" + +#define IAVF_ACTION_RSS_MAX_QUEUE_NUM 32 + +struct rss_type_match_hdr { + uint32_t hdr_mask; + uint64_t eth_rss_hint; +}; + +struct iavf_hash_match_type { + uint64_t hash_type; + struct virtchnl_proto_stack *proto_stack; +}; + +struct iavf_rss_meta { + struct virtchnl_proto_stack *proto_stack; + uint32_t hash_function; +}; + +struct iavf_hash_flow_cfg { + bool simple_xor; + struct virtchnl_rss_cfg *rss_cfg; +}; + +static int +iavf_hash_init(struct iavf_adapter *ad); +static int +iavf_hash_create(struct iavf_adapter *ad, struct rte_flow *flow, void *meta, + struct rte_flow_error *error); +static int +iavf_hash_destroy(struct iavf_adapter *ad, struct rte_flow *flow, + struct rte_flow_error *error); +static void +iavf_hash_uninit(struct iavf_adapter *ad); +static void +iavf_hash_free(struct rte_flow *flow); +static int +iavf_hash_parse_pattern_action(struct iavf_adapter *ad, + struct iavf_pattern_match_item *array, + uint32_t array_len, + const struct rte_flow_item pattern[], + const struct rte_flow_action actions[], + void **meta, + struct rte_flow_error *error); + +/* Generate flow hash field from flow field type(s) */ +#define IAVF_FLOW_HASH_ETH \ + (BIT_ULL(VIRTCHNL_PROTO_HDR_ETH_DST) | \ + BIT_ULL(VIRTCHNL_PROTO_HDR_ETH_SRC)) +#define IAVF_FLOW_HASH_IPV4 \ + (BIT_ULL(VIRTCHNL_PROTO_HDR_IPV4_SRC) | \ + BIT_ULL(VIRTCHNL_PROTO_HDR_IPV4_DST)) +#define IAVF_FLOW_HASH_IPV6 \ + (BIT_ULL(VIRTCHNL_PROTO_HDR_IPV6_SRC) | \ + BIT_ULL(VIRTCHNL_PROTO_HDR_IPV6_DST)) +#define IAVF_FLOW_HASH_TCP_PORT \ + (BIT_ULL(VIRTCHNL_PROTO_HDR_TCP_SRC_PORT) | \ + BIT_ULL(VIRTCHNL_PROTO_HDR_TCP_DST_PORT)) +#define IAVF_FLOW_HASH_UDP_PORT \ + (BIT_ULL(VIRTCHNL_PROTO_HDR_UDP_SRC_PORT) | \ + BIT_ULL(VIRTCHNL_PROTO_HDR_UDP_DST_PORT)) +#define IAVF_FLOW_HASH_SCTP_PORT \ + (BIT_ULL(VIRTCHNL_PROTO_HDR_SCTP_SRC_PORT) | \ + BIT_ULL(VIRTCHNL_PROTO_HDR_SCTP_DST_PORT)) + +#define IAVF_HASH_INVALID 0 +#define IAVF_HASH_TCP_IPV4 (IAVF_FLOW_HASH_IPV4 | IAVF_FLOW_HASH_TCP_PORT) +#define IAVF_HASH_TCP_IPV6 (IAVF_FLOW_HASH_IPV6 | IAVF_FLOW_HASH_TCP_PORT) +#define IAVF_HASH_UDP_IPV4 (IAVF_FLOW_HASH_IPV4 | IAVF_FLOW_HASH_UDP_PORT) +#define IAVF_HASH_UDP_IPV6 (IAVF_FLOW_HASH_IPV6 | IAVF_FLOW_HASH_UDP_PORT) +#define IAVF_HASH_SCTP_IPV4 (IAVF_FLOW_HASH_IPV4 | IAVF_FLOW_HASH_SCTP_PORT) +#define IAVF_HASH_SCTP_IPV6 (IAVF_FLOW_HASH_IPV6 | IAVF_FLOW_HASH_SCTP_PORT) + +#define IAVF_FLOW_HASH_GTP_U_TEID \ + (BIT_ULL(VIRTCHNL_PROTO_HDR_GTPU_IP_TEID)) + +#define IAVF_FLOW_HASH_GTP_U_IPV4_TEID \ + (IAVF_FLOW_HASH_IPV4 | IAVF_FLOW_HASH_GTP_U_TEID) +#define IAVF_FLOW_HASH_GTP_U_IPV6_TEID \ + (IAVF_FLOW_HASH_IPV6 | IAVF_FLOW_HASH_GTP_U_TEID) + +#define IAVF_FLOW_HASH_GTP_U_EH_TEID \ + (BIT_ULL(VIRTCHNL_PROTO_HDR_GTPU_IP_TEID)) + +#define IAVF_FLOW_HASH_GTP_U_EH_QFI \ + (BIT_ULL(VIRTCHNL_PROTO_HDR_GTPU_EH_QFI)) + +#define IAVF_FLOW_HASH_GTP_U_IPV4_EH \ + (IAVF_FLOW_HASH_IPV4 | IAVF_FLOW_HASH_GTP_U_EH_TEID | \ + IAVF_FLOW_HASH_GTP_U_EH_QFI) +#define IAVF_FLOW_HASH_GTP_U_IPV6_EH \ + (IAVF_FLOW_HASH_IPV6 | IAVF_FLOW_HASH_GTP_U_EH_TEID | \ + IAVF_FLOW_HASH_GTP_U_EH_QFI) + +/* The first member is protocol header, the second member is ETH_RSS_*. */ +struct rss_type_match_hdr iavf_hint_empty = { + VIRTCHNL_PROTO_HDR_NONE, 0}; +struct rss_type_match_hdr iavf_hint_eth_ipv4 = { + VIRTCHNL_PROTO_HDR_IPV4, ETH_RSS_IPV4}; +struct rss_type_match_hdr iavf_hint_eth_ipv4_udp = { + VIRTCHNL_PROTO_HDR_IPV4 | VIRTCHNL_PROTO_HDR_UDP, + ETH_RSS_NONFRAG_IPV4_UDP}; +struct rss_type_match_hdr iavf_hint_eth_ipv4_tcp = { + VIRTCHNL_PROTO_HDR_IPV4 | VIRTCHNL_PROTO_HDR_TCP, + ETH_RSS_NONFRAG_IPV4_TCP}; +struct rss_type_match_hdr iavf_hint_eth_ipv4_sctp = { + VIRTCHNL_PROTO_HDR_IPV4 | VIRTCHNL_PROTO_HDR_SCTP, + ETH_RSS_NONFRAG_IPV4_SCTP}; +struct rss_type_match_hdr iavf_hint_eth_ipv4_gtpu_eh = { + VIRTCHNL_PROTO_HDR_GTPU_EH, ETH_RSS_IPV4}; +struct rss_type_match_hdr iavf_hint_eth_ipv4_esp = { + VIRTCHNL_PROTO_HDR_ESP, ETH_RSS_IPV4}; +struct rss_type_match_hdr iavf_hint_eth_ipv4_udp_esp = { + VIRTCHNL_PROTO_HDR_ESP, ETH_RSS_IPV4}; +struct rss_type_match_hdr iavf_hint_eth_ipv4_ah = { + VIRTCHNL_PROTO_HDR_AH, ETH_RSS_IPV4}; +struct rss_type_match_hdr iavf_hint_eth_ipv4_l2tpv3 = { + VIRTCHNL_PROTO_HDR_L2TPV3, ETH_RSS_IPV4}; +struct rss_type_match_hdr iavf_hint_eth_ipv4_pfcp = { + VIRTCHNL_PROTO_HDR_PFCP, ETH_RSS_IPV4}; +struct rss_type_match_hdr iavf_hint_eth_ipv6 = { + VIRTCHNL_PROTO_HDR_IPV6, ETH_RSS_IPV6}; +struct rss_type_match_hdr iavf_hint_eth_ipv6_udp = { + VIRTCHNL_PROTO_HDR_IPV6 | VIRTCHNL_PROTO_HDR_UDP, + ETH_RSS_NONFRAG_IPV6_UDP}; +struct rss_type_match_hdr iavf_hint_eth_ipv6_tcp = { + VIRTCHNL_PROTO_HDR_IPV6 | VIRTCHNL_PROTO_HDR_TCP, + ETH_RSS_NONFRAG_IPV6_TCP}; +struct rss_type_match_hdr iavf_hint_eth_ipv6_sctp = { + VIRTCHNL_PROTO_HDR_IPV6 | VIRTCHNL_PROTO_HDR_SCTP, + ETH_RSS_NONFRAG_IPV6_SCTP}; +struct rss_type_match_hdr iavf_hint_eth_ipv6_esp = { + VIRTCHNL_PROTO_HDR_ESP, ETH_RSS_IPV6}; +struct rss_type_match_hdr iavf_hint_eth_ipv6_udp_esp = { + VIRTCHNL_PROTO_HDR_ESP, ETH_RSS_IPV6}; +struct rss_type_match_hdr iavf_hint_eth_ipv6_ah = { + VIRTCHNL_PROTO_HDR_AH, ETH_RSS_IPV6}; +struct rss_type_match_hdr iavf_hint_eth_ipv6_l2tpv3 = { + VIRTCHNL_PROTO_HDR_L2TPV3, ETH_RSS_IPV6}; +struct rss_type_match_hdr iavf_hint_eth_ipv6_pfcp = { + VIRTCHNL_PROTO_HDR_PFCP, ETH_RSS_IPV6}; + +/* Supported pattern for hash. */ +static struct iavf_pattern_match_item iavf_hash_pattern_list[] = { + {iavf_pattern_eth_ipv4, IAVF_INSET_NONE, &iavf_hint_eth_ipv4}, + {iavf_pattern_eth_ipv4_udp, IAVF_INSET_NONE, &iavf_hint_eth_ipv4_udp}, + {iavf_pattern_eth_ipv4_tcp, IAVF_INSET_NONE, &iavf_hint_eth_ipv4_tcp}, + {iavf_pattern_eth_ipv4_sctp, IAVF_INSET_NONE, &iavf_hint_eth_ipv4_sctp}, + {iavf_pattern_eth_ipv6, IAVF_INSET_NONE, &iavf_hint_eth_ipv6}, + {iavf_pattern_eth_ipv4_gtpu_eh_ipv4, + IAVF_INSET_NONE, &iavf_hint_eth_ipv4_gtpu_eh}, + {iavf_pattern_eth_ipv4_gtpu_eh_ipv4_udp, + IAVF_INSET_NONE, &iavf_hint_eth_ipv4_gtpu_eh}, + {iavf_pattern_eth_ipv4_gtpu_eh_ipv4_tcp, + IAVF_INSET_NONE, &iavf_hint_eth_ipv4_gtpu_eh}, + {iavf_pattern_eth_ipv4_esp, + IAVF_INSET_NONE, &iavf_hint_eth_ipv4_esp}, + {iavf_pattern_eth_ipv4_udp_esp, + IAVF_INSET_NONE, &iavf_hint_eth_ipv4_udp_esp}, + {iavf_pattern_eth_ipv4_ah, + IAVF_INSET_NONE, &iavf_hint_eth_ipv4_ah}, + {iavf_pattern_eth_ipv4_l2tpv3, + IAVF_INSET_NONE, &iavf_hint_eth_ipv4_l2tpv3}, + {iavf_pattern_eth_ipv4_pfcp, + IAVF_INSET_NONE, &iavf_hint_eth_ipv4_pfcp}, + {iavf_pattern_eth_ipv6_udp, IAVF_INSET_NONE, &iavf_hint_eth_ipv6_udp}, + {iavf_pattern_eth_ipv6_tcp, IAVF_INSET_NONE, &iavf_hint_eth_ipv6_tcp}, + {iavf_pattern_eth_ipv6_sctp, IAVF_INSET_NONE, &iavf_hint_eth_ipv6_sctp}, + {iavf_pattern_eth_ipv6_esp, + IAVF_INSET_NONE, &iavf_hint_eth_ipv6_esp}, + {iavf_pattern_eth_ipv6_udp_esp, + IAVF_INSET_NONE, &iavf_hint_eth_ipv6_udp_esp}, + {iavf_pattern_eth_ipv6_ah, + IAVF_INSET_NONE, &iavf_hint_eth_ipv6_ah}, + {iavf_pattern_eth_ipv6_l2tpv3, + IAVF_INSET_NONE, &iavf_hint_eth_ipv6_l2tpv3}, + {iavf_pattern_eth_ipv6_pfcp, + IAVF_INSET_NONE, &iavf_hint_eth_ipv6_pfcp}, + {iavf_pattern_empty, IAVF_INSET_NONE, &iavf_hint_empty}, +}; + +#define GTP_EH_PDU_LINK_UP 1 +#define GTP_EH_PDU_LINK_DWN 0 + +#define TUNNEL_LEVEL_OUTER 0 +#define TUNNEL_LEVEL_INNER 1 + +#define PROTO_COUNT_ONE 1 +#define PROTO_COUNT_TWO 2 +#define PROTO_COUNT_THREE 3 + +#define BUFF_NOUSED 0 +#define FIELD_FOR_PROTO_ONLY 0 + +#define proto_hint_eth_src { \ + VIRTCHNL_PROTO_HDR_ETH, VIRTCHNL_PROTO_HDR_ETH_SRC, {BUFF_NOUSED } } + +#define proto_hint_eth_dst { \ + VIRTCHNL_PROTO_HDR_ETH, VIRTCHNL_PROTO_HDR_ETH_DST, {BUFF_NOUSED } } + +#define proto_hint_svlan { \ + VIRTCHNL_PROTO_HDR_S_VLAN, VIRTCHNL_PROTO_HDR_S_VLAN_ID, \ + {BUFF_NOUSED } } + +#define proto_hint_cvlan { \ + VIRTCHNL_PROTO_HDR_C_VLAN, VIRTCHNL_PROTO_HDR_C_VLAN_ID, \ + {BUFF_NOUSED } } + +#define proto_hint_ipv4_src { \ + VIRTCHNL_PROTO_HDR_IPV4, VIRTCHNL_PROTO_HDR_IPV4_SRC, {BUFF_NOUSED } } + +#define proto_hint_ipv4_dst { \ + VIRTCHNL_PROTO_HDR_IPV4, VIRTCHNL_PROTO_HDR_IPV4_DST, {BUFF_NOUSED } } + +#define proto_hint_ipv4_only { \ + VIRTCHNL_PROTO_HDR_IPV4, FIELD_FOR_PROTO_ONLY, {BUFF_NOUSED } } + +#define proto_hint_ipv4 { \ + VIRTCHNL_PROTO_HDR_IPV4, \ + VIRTCHNL_PROTO_HDR_IPV4_SRC | VIRTCHNL_PROTO_HDR_IPV4_DST, \ + {BUFF_NOUSED } } + +#define proto_hint_udp_src_port { \ + VIRTCHNL_PROTO_HDR_UDP, VIRTCHNL_PROTO_HDR_UDP_SRC_PORT, \ + {BUFF_NOUSED } } + +#define proto_hint_udp_dst_port { \ + VIRTCHNL_PROTO_HDR_UDP, VIRTCHNL_PROTO_HDR_UDP_DST_PORT, \ + {BUFF_NOUSED } } + +#define proto_hint_udp_only { \ + VIRTCHNL_PROTO_HDR_UDP, FIELD_FOR_PROTO_ONLY, {BUFF_NOUSED } } + +#define proto_hint_udp { \ + VIRTCHNL_PROTO_HDR_UDP, \ + VIRTCHNL_PROTO_HDR_UDP_SRC_PORT | VIRTCHNL_PROTO_HDR_UDP_DST_PORT, \ + {BUFF_NOUSED } } + +#define proto_hint_tcp_src_port { \ + VIRTCHNL_PROTO_HDR_TCP, VIRTCHNL_PROTO_HDR_TCP_SRC_PORT, \ + {BUFF_NOUSED } } + +#define proto_hint_tcp_dst_port { \ + VIRTCHNL_PROTO_HDR_TCP, VIRTCHNL_PROTO_HDR_TCP_DST_PORT, \ + {BUFF_NOUSED } } + +#define proto_hint_tcp_only { \ + VIRTCHNL_PROTO_HDR_TCP, FIELD_FOR_PROTO_ONLY, {BUFF_NOUSED } } + +#define proto_hint_tcp { \ + VIRTCHNL_PROTO_HDR_TCP, \ + VIRTCHNL_PROTO_HDR_TCP_SRC_PORT | VIRTCHNL_PROTO_HDR_TCP_DST_PORT, \ + {BUFF_NOUSED } } + +#define proto_hint_sctp_src_port { \ + VIRTCHNL_PROTO_HDR_SCTP, VIRTCHNL_PROTO_HDR_SCTP_SRC_PORT, \ + {BUFF_NOUSED } } + +#define proto_hint_sctp_dst_port { \ + VIRTCHNL_PROTO_HDR_SCTP, VIRTCHNL_PROTO_HDR_SCTP_DST_PORT, \ + {BUFF_NOUSED } } + +#define proto_hint_sctp_only { \ + VIRTCHNL_PROTO_HDR_SCTP, FIELD_FOR_PROTO_ONLY, {BUFF_NOUSED } } + +#define proto_hint_sctp { \ + VIRTCHNL_PROTO_HDR_SCTP, \ + VIRTCHNL_PROTO_HDR_SCTP_SRC_PORT | VIRTCHNL_PROTO_HDR_SCTP_DST_PORT, \ + {BUFF_NOUSED } } + +#define proto_hint_ipv6_src { \ + VIRTCHNL_PROTO_HDR_IPV6, VIRTCHNL_PROTO_HDR_IPV6_SRC, {BUFF_NOUSED } } + +#define proto_hint_ipv6_dst { \ + VIRTCHNL_PROTO_HDR_IPV6, VIRTCHNL_PROTO_HDR_IPV6_DST, {BUFF_NOUSED } } + +#define proto_hint_ipv6_only { \ + VIRTCHNL_PROTO_HDR_IPV6, FIELD_FOR_PROTO_ONLY, {BUFF_NOUSED } } + +#define proto_hint_ipv6 { \ + VIRTCHNL_PROTO_HDR_IPV6, \ + VIRTCHNL_PROTO_HDR_IPV6_SRC | VIRTCHNL_PROTO_HDR_IPV6_DST, \ + {BUFF_NOUSED } } + +#define proto_hint_gtpu_up_only { \ + VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_UP, \ + FIELD_FOR_PROTO_ONLY, {BUFF_NOUSED } } + +#define proto_hint_gtpu_dwn_only { \ + VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_DWN, \ + FIELD_FOR_PROTO_ONLY, {BUFF_NOUSED } } + +#define proto_hint_esp { \ + VIRTCHNL_PROTO_HDR_ESP, \ + VIRTCHNL_PROTO_HDR_ESP_SPI, {BUFF_NOUSED } } + +#define proto_hint_ah { \ + VIRTCHNL_PROTO_HDR_AH, \ + VIRTCHNL_PROTO_HDR_AH_SPI, {BUFF_NOUSED } } + +#define proto_hint_l2tpv3 { \ + VIRTCHNL_PROTO_HDR_L2TPV3, \ + VIRTCHNL_PROTO_HDR_L2TPV3_SESS_ID, {BUFF_NOUSED } } + +#define proto_hint_pfcp { \ + VIRTCHNL_PROTO_HDR_PFCP, VIRTCHNL_PROTO_HDR_PFCP_SEID, {BUFF_NOUSED } } + +struct virtchnl_proto_stack stack_hint_eth_src = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_eth_src } +}; + +struct virtchnl_proto_stack stack_hint_eth_dst = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_eth_dst } +}; + +struct virtchnl_proto_stack stack_hint_svlan = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_svlan } +}; + +struct virtchnl_proto_stack stack_hint_cvlan = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_cvlan } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_src = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_ipv4_src } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_dst = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_ipv4_dst } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_src_gtpu_up = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_TWO, {proto_hint_gtpu_up_only, + proto_hint_ipv4_src } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_dst_gtpu_dwn = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_TWO, {proto_hint_gtpu_dwn_only, + proto_hint_ipv4_dst } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_src_udp_gtpu_up = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_THREE, {proto_hint_gtpu_up_only, + proto_hint_ipv4_src, proto_hint_udp_only } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_dst_udp_gtpu_dwn = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_THREE, {proto_hint_gtpu_dwn_only, + proto_hint_ipv4_dst, proto_hint_udp_only } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_src_tcp_gtpu_up = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_THREE, {proto_hint_gtpu_up_only, + proto_hint_ipv4_src, proto_hint_tcp_only } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_dst_tcp_gtpu_dwn = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_THREE, {proto_hint_gtpu_dwn_only, + proto_hint_ipv4_dst, proto_hint_tcp_only } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_src_sctp_gtpu_up = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_THREE, {proto_hint_gtpu_up_only, + proto_hint_ipv4_src, proto_hint_sctp_only } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_dst_sctp_gtpu_dwn = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_THREE, {proto_hint_gtpu_dwn_only, + proto_hint_ipv4_dst, proto_hint_sctp_only } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_esp = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_TWO, {proto_hint_ipv4_only, + proto_hint_esp } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_ah = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_TWO, {proto_hint_ipv4_only, + proto_hint_ah } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_l2tpv3 = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_TWO, {proto_hint_ipv4_only, + proto_hint_l2tpv3 } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_pfcp = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_TWO, {proto_hint_ipv4_only, + proto_hint_pfcp } +}; + +struct virtchnl_proto_stack stack_hint_ipv4 = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_ipv4 } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_src_udp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4_src, + proto_hint_udp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_src_udp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4_src, + proto_hint_udp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_dst_udp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4_dst, + proto_hint_udp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_dst_udp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4_dst, + proto_hint_udp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_udp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_udp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_udp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_udp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_udp = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4, + proto_hint_udp } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_src_tcp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4_src, + proto_hint_tcp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_src_tcp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4_src, + proto_hint_tcp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_dst_tcp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4_dst, + proto_hint_tcp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_dst_tcp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4_dst, + proto_hint_tcp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_tcp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_tcp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_tcp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_tcp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_tcp = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4, + proto_hint_tcp } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_src_sctp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4_src, + proto_hint_sctp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_src_sctp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4_src, + proto_hint_sctp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_dst_sctp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4_dst, + proto_hint_sctp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_dst_sctp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4_dst, + proto_hint_sctp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_sctp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_sctp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_sctp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_sctp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv4_sctp = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv4, + proto_hint_sctp } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_src = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_ipv6_src } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_dst = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_ipv6_dst } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_esp = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_TWO, {proto_hint_ipv6_only, + proto_hint_esp } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_ah = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_TWO, {proto_hint_ipv6_only, + proto_hint_ah } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_l2tpv3 = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_TWO, {proto_hint_ipv6_only, + proto_hint_l2tpv3 } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_pfcp = { + TUNNEL_LEVEL_INNER, PROTO_COUNT_TWO, {proto_hint_ipv6_only, + proto_hint_pfcp } +}; + +struct virtchnl_proto_stack stack_hint_ipv6 = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_ipv6 } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_src_udp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6_src, + proto_hint_udp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_src_udp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6_src, + proto_hint_udp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_dst_udp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6_dst, + proto_hint_udp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_dst_udp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6_dst, + proto_hint_udp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_udp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_udp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_udp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_udp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_udp = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6, + proto_hint_udp } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_src_tcp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6_src, + proto_hint_tcp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_src_tcp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6_src, + proto_hint_tcp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_dst_tcp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6_dst, + proto_hint_tcp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_dst_tcp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6_dst, + proto_hint_tcp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_tcp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_tcp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_tcp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_tcp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_tcp = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6, + proto_hint_tcp } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_src_sctp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6_src, + proto_hint_sctp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_src_sctp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6_src, + proto_hint_sctp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_dst_sctp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6_dst, + proto_hint_sctp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_dst_sctp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6_dst, + proto_hint_sctp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_sctp_src_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_sctp_src_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_sctp_dst_port = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_ONE, {proto_hint_sctp_dst_port } +}; + +struct virtchnl_proto_stack stack_hint_ipv6_sctp = { + TUNNEL_LEVEL_OUTER, PROTO_COUNT_TWO, {proto_hint_ipv6, + proto_hint_sctp } +}; + +/** + * The first member is hash type, + * the second member is virtchnl protocol stack. + */ +struct iavf_hash_match_type iavf_hash_type_list[] = { + /* IPV4 */ + {ETH_RSS_IPV4 | ETH_RSS_ETH_SRC_ONLY, &stack_hint_eth_src}, + {ETH_RSS_IPV4 | ETH_RSS_ETH_DST_ONLY, &stack_hint_eth_dst}, + {ETH_RSS_IPV4 | ETH_RSS_S_VLAN, &stack_hint_svlan}, + {ETH_RSS_IPV4 | ETH_RSS_C_VLAN, &stack_hint_cvlan}, + {ETH_RSS_IPV4 | ETH_RSS_L3_SRC_ONLY, &stack_hint_ipv4_src}, + {ETH_RSS_IPV4 | ETH_RSS_L3_DST_ONLY, &stack_hint_ipv4_dst}, + {ETH_RSS_IPV4 | ETH_RSS_L3_SRC_ONLY | ETH_RSS_GTPU_UP, + &stack_hint_ipv4_src_gtpu_up}, + {ETH_RSS_IPV4 | ETH_RSS_L3_DST_ONLY | ETH_RSS_GTPU_DWN, + &stack_hint_ipv4_dst_gtpu_dwn}, + {ETH_RSS_IPV4 | ETH_RSS_ESP_SPI, &stack_hint_ipv4_esp}, + {ETH_RSS_IPV4 | ETH_RSS_AH_SPI, &stack_hint_ipv4_ah}, + {ETH_RSS_IPV4 | ETH_RSS_L2TPV3_SESS_ID, &stack_hint_ipv4_l2tpv3}, + {ETH_RSS_IPV4 | ETH_RSS_PFCP_SEID, &stack_hint_ipv4_pfcp}, + {ETH_RSS_IPV4, &stack_hint_ipv4}, + /* IPV4 UDP */ + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv4_src_udp_src_port}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv4_src_udp_dst_port}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_GTPU_UP, + &stack_hint_ipv4_src_udp_gtpu_up}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_SRC_ONLY, + &stack_hint_ipv4_src}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv4_dst_udp_src_port}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv4_dst_udp_dst_port}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_GTPU_DWN, + &stack_hint_ipv4_dst_udp_gtpu_dwn}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_DST_ONLY, + &stack_hint_ipv4_dst}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv4_udp_src_port}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv4_udp_dst_port}, + {ETH_RSS_NONFRAG_IPV4_UDP, &stack_hint_ipv4_udp}, + /* IPV4 TCP */ + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv4_src_tcp_src_port}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv4_src_tcp_dst_port}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_GTPU_UP, + &stack_hint_ipv4_src_tcp_gtpu_up}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_SRC_ONLY, + &stack_hint_ipv4_src}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv4_dst_tcp_src_port}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv4_dst_tcp_dst_port}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_GTPU_DWN, + &stack_hint_ipv4_dst_tcp_gtpu_dwn}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_DST_ONLY, + &stack_hint_ipv4_dst}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv4_tcp_src_port}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv4_tcp_dst_port}, + {ETH_RSS_NONFRAG_IPV4_TCP, &stack_hint_ipv4_tcp}, + /* IPV4 SCTP */ + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv4_src_sctp_src_port}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv4_src_sctp_dst_port}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_GTPU_UP, + &stack_hint_ipv4_src_sctp_gtpu_up}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_SRC_ONLY, + &stack_hint_ipv4_src}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv4_dst_sctp_src_port}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv4_dst_sctp_dst_port}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_GTPU_DWN, + &stack_hint_ipv4_dst_sctp_gtpu_dwn}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_DST_ONLY, + &stack_hint_ipv4_dst}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv4_sctp_src_port}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv4_sctp_dst_port}, + {ETH_RSS_NONFRAG_IPV4_SCTP, &stack_hint_ipv4_sctp}, + /* IPV6 */ + {ETH_RSS_IPV6 | ETH_RSS_ETH_SRC_ONLY, &stack_hint_eth_src}, + {ETH_RSS_IPV6 | ETH_RSS_ETH_DST_ONLY, &stack_hint_eth_dst}, + {ETH_RSS_IPV6 | ETH_RSS_S_VLAN, &stack_hint_svlan}, + {ETH_RSS_IPV6 | ETH_RSS_C_VLAN, &stack_hint_cvlan}, + {ETH_RSS_IPV6 | ETH_RSS_L3_SRC_ONLY, &stack_hint_ipv6_src}, + {ETH_RSS_IPV6 | ETH_RSS_L3_DST_ONLY, &stack_hint_ipv6_dst}, + {ETH_RSS_IPV6 | ETH_RSS_ESP_SPI, &stack_hint_ipv6_esp}, + {ETH_RSS_IPV6 | ETH_RSS_AH_SPI, &stack_hint_ipv6_ah}, + {ETH_RSS_IPV6 | ETH_RSS_L2TPV3_SESS_ID, &stack_hint_ipv6_l2tpv3}, + {ETH_RSS_IPV6 | ETH_RSS_PFCP_SEID, &stack_hint_ipv6_pfcp}, + {ETH_RSS_IPV6, &stack_hint_ipv6}, + /* IPV6 UDP */ + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv6_src_udp_src_port}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv6_src_udp_dst_port}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_SRC_ONLY, + &stack_hint_ipv6_src}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv6_dst_udp_src_port}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv6_dst_udp_dst_port}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_DST_ONLY, + &stack_hint_ipv6_dst}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv6_udp_src_port}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv6_udp_dst_port}, + {ETH_RSS_NONFRAG_IPV6_UDP, &stack_hint_ipv6_udp}, + /* IPV6 TCP */ + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv6_src_tcp_src_port}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv6_src_tcp_dst_port}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_SRC_ONLY, + &stack_hint_ipv6_src}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv6_dst_tcp_src_port}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv6_dst_tcp_dst_port}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_DST_ONLY, + &stack_hint_ipv6_dst}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv6_tcp_src_port}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv6_tcp_dst_port}, + {ETH_RSS_NONFRAG_IPV6_TCP, &stack_hint_ipv6_tcp}, + /* IPV6 SCTP */ + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv6_src_sctp_src_port}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv6_src_sctp_dst_port}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_SRC_ONLY, + &stack_hint_ipv6_src}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv6_dst_sctp_src_port}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv6_dst_sctp_dst_port}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_DST_ONLY, + &stack_hint_ipv6_dst}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L4_SRC_ONLY, + &stack_hint_ipv6_sctp_src_port}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L4_DST_ONLY, + &stack_hint_ipv6_sctp_dst_port}, + {ETH_RSS_NONFRAG_IPV6_SCTP, &stack_hint_ipv6_sctp}, +}; + +static struct iavf_flow_engine iavf_hash_engine = { + .init = iavf_hash_init, + .create = iavf_hash_create, + .destroy = iavf_hash_destroy, + .uninit = iavf_hash_uninit, + .free = iavf_hash_free, + .type = IAVF_FLOW_ENGINE_HASH, +}; + +/* Register parser for comms package. */ +static struct iavf_flow_parser iavf_hash_parser = { + .engine = &iavf_hash_engine, + .array = iavf_hash_pattern_list, + .array_len = RTE_DIM(iavf_hash_pattern_list), + .parse_pattern_action = iavf_hash_parse_pattern_action, + .stage = IAVF_FLOW_STAGE_RSS, +}; + +RTE_INIT(iavf_hash_engine_init) +{ + struct iavf_flow_engine *engine = &iavf_hash_engine; + + iavf_register_flow_engine(engine); +} + +static int +iavf_hash_init(struct iavf_adapter *ad) +{ + struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad); + struct iavf_flow_parser *parser; + + if (!(vf->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF)) + return -ENOTSUP; + + parser = &iavf_hash_parser; + + return iavf_register_parser(parser, ad); +} + +static int +iavf_hash_check_inset(const struct rte_flow_item pattern[], + struct rte_flow_error *error) +{ + const struct rte_flow_item *item = pattern; + + for (item = pattern; 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; + } + } + + return 0; +} + +static uint64_t +iavf_rss_hf_refine(uint64_t rss_hf, const struct rte_flow_item pattern[], + const struct rte_flow_action *action, + struct rte_flow_error *error) +{ + const struct rte_flow_item *item; + + for (item = pattern; item->type != RTE_FLOW_ITEM_TYPE_END; item++) { + if (item->type == RTE_FLOW_ITEM_TYPE_GTP_PSC) { + const struct rte_flow_action_rss *rss = action->conf; + const struct rte_flow_item_gtp_psc *psc = item->spec; + + if (psc && ((psc->pdu_type == GTP_EH_PDU_LINK_UP && + (rss->types & ETH_RSS_L3_SRC_ONLY)) || + (!psc->pdu_type && + (rss->types & ETH_RSS_L3_DST_ONLY)))) { + rss_hf |= psc->pdu_type ? ETH_RSS_GTPU_UP : + ETH_RSS_GTPU_DWN; + } else { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ITEM_SPEC, + pattern, + "Invalid input set"); + return -rte_errno; + } + } + } + + return rss_hf; +} + +static int +iavf_hash_parse_action(struct iavf_pattern_match_item *pattern_match_item, + const struct rte_flow_item pattern[], + const struct rte_flow_action actions[], + void **meta, struct rte_flow_error *error) +{ + struct iavf_rss_meta *rss_meta = (struct iavf_rss_meta *)*meta; + struct rss_type_match_hdr *m = (struct rss_type_match_hdr *) + (pattern_match_item->meta); + uint32_t type_list_len = RTE_DIM(iavf_hash_type_list); + struct iavf_hash_match_type *type_match_item; + const struct rte_flow_action *action; + enum rte_flow_action_type action_type; + const struct rte_flow_action_rss *rss; + uint64_t rss_hf; + uint16_t i; + + /* Supported action is RSS. */ + for (action = actions; action->type != + RTE_FLOW_ACTION_TYPE_END; action++) { + action_type = action->type; + switch (action_type) { + case RTE_FLOW_ACTION_TYPE_RSS: + rss = action->conf; + rss_hf = rss->types; + + /** + * Check simultaneous use of SRC_ONLY and DST_ONLY + * of the same level. + */ + rss_hf = rte_eth_rss_hf_refine(rss_hf); + + /** + * Check the item spec with the rss action and + * refine rss hash field. + */ + rss_hf = iavf_rss_hf_refine(rss_hf, pattern, action, + error); + + /* Check if pattern is empty. */ + if (pattern_match_item->pattern_list != + iavf_pattern_empty && rss->func == + RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ACTION, action, + "Not supported flow"); + + /* Check if rss types match pattern. */ + if (rss->func != RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) { + if (((rss_hf & ETH_RSS_IPV4) != + m->eth_rss_hint) && + ((rss_hf & ETH_RSS_NONFRAG_IPV4_UDP) != + m->eth_rss_hint) && + ((rss_hf & ETH_RSS_NONFRAG_IPV4_TCP) != + m->eth_rss_hint) && + ((rss_hf & ETH_RSS_NONFRAG_IPV4_SCTP) != + m->eth_rss_hint) && + ((rss_hf & ETH_RSS_IPV6) != + m->eth_rss_hint) && + ((rss_hf & ETH_RSS_NONFRAG_IPV6_UDP) != + m->eth_rss_hint) && + ((rss_hf & ETH_RSS_NONFRAG_IPV6_TCP) != + m->eth_rss_hint) && + ((rss_hf & ETH_RSS_NONFRAG_IPV6_SCTP) != + m->eth_rss_hint)) + return rte_flow_error_set(error, + ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, + action, "Not supported RSS types"); + } + + if (rss->level) + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ACTION, action, + "a nonzero RSS encapsulation level is not supported"); + + if (rss->key_len == 0) + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ACTION, action, + "RSS hash key_len mustn't be 0"); + + if (rss->queue_num > IAVF_ACTION_RSS_MAX_QUEUE_NUM) + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ACTION, action, + "too many queues for RSS context"); + + /* Check hash function and save it to rss_meta. */ + if (rss->func == RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) + rss_meta->hash_function = + RTE_ETH_HASH_FUNCTION_SIMPLE_XOR; + + if (rss->func == + RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) + rss_meta->hash_function = + RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ; + + type_match_item = + rte_zmalloc("iavf_type_match_item", + sizeof(struct iavf_hash_match_type), 0); + if (!type_match_item) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, + NULL, + "No memory for type_match_item"); + return -ENOMEM; + } + + /* Find matched proto stack according to hash type. */ + for (i = 0; i < type_list_len; i++) { + struct iavf_hash_match_type *ht_map = + &iavf_hash_type_list[i]; + if (rss_hf == ht_map->hash_type) { + type_match_item->hash_type = + ht_map->hash_type; + type_match_item->proto_stack = + ht_map->proto_stack; + } + } + + /* Save proto stack to rss_meta. */ + rss_meta->proto_stack = type_match_item->proto_stack; + + rte_free(type_match_item); + break; + + case RTE_FLOW_ACTION_TYPE_END: + break; + + default: + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, action, + "Invalid action."); + return -rte_errno; + } + } + + return 0; +} + +static int +iavf_hash_parse_pattern_action(__rte_unused struct iavf_adapter *ad, + struct iavf_pattern_match_item *array, + uint32_t array_len, + const struct rte_flow_item pattern[], + const struct rte_flow_action actions[], + void **meta, + struct rte_flow_error *error) +{ + int ret = 0; + struct iavf_pattern_match_item *pattern_match_item; + struct iavf_rss_meta *rss_meta_ptr; + + rss_meta_ptr = rte_zmalloc(NULL, sizeof(*rss_meta_ptr), 0); + if (!rss_meta_ptr) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for rss_meta_ptr"); + return -ENOMEM; + } + + *meta = rss_meta_ptr; + + /* Check rss supported pattern and find matched pattern. */ + pattern_match_item = + iavf_search_pattern_match_item(pattern, array, array_len, + error); + if (!pattern_match_item) + return -rte_errno; + + ret = iavf_hash_check_inset(pattern, error); + if (ret) + return -rte_errno; + + /* Check rss action. */ + ret = iavf_hash_parse_action(pattern_match_item, pattern, actions, + meta, error); + if (ret) + return -rte_errno; + + rte_free(pattern_match_item); + + return 0; +} + +static int +iavf_hash_create(__rte_unused struct iavf_adapter *ad, + __rte_unused struct rte_flow *flow, void *meta, + __rte_unused struct rte_flow_error *error) +{ + struct iavf_rss_meta *rss_meta = (struct iavf_rss_meta *)meta; + struct virtchnl_rss_cfg *rss_cfg; + int ret = 0; + + rss_cfg = rte_zmalloc("iavf rss rule", + sizeof(struct virtchnl_rss_cfg), 0); + if (!rss_cfg) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for rss rule"); + return -ENOMEM; + } + + rss_cfg->proto_stack = *rss_meta->proto_stack; + rss_cfg->hash_function = rss_meta->hash_function; + + ret = iavf_add_del_rss_cfg(ad, rss_cfg, true); + if (!ret) { + flow->rule = rss_cfg; + } else { + PMD_DRV_LOG(ERR, "fail to add RSS configure"); + rte_free(rss_cfg); + } + + return ret; +} + +static int +iavf_hash_destroy(__rte_unused struct iavf_adapter *ad, + struct rte_flow *flow, + __rte_unused struct rte_flow_error *error) +{ + struct virtchnl_rss_cfg *rss_cfg; + int ret = 0; + + rss_cfg = (struct virtchnl_rss_cfg *)flow->rule; + + ret = iavf_add_del_rss_cfg(ad, rss_cfg, false); + if (ret) + PMD_DRV_LOG(ERR, "fail to del RSS configure"); + + return ret; +} + +static void +iavf_hash_uninit(struct iavf_adapter *ad) +{ + iavf_unregister_parser(&iavf_hash_parser, ad); +} + +static void +iavf_hash_free(struct rte_flow *flow) +{ + rte_free(flow->rule); +} diff --git a/drivers/net/iavf/iavf_vchnl.c b/drivers/net/iavf/iavf_vchnl.c index 11c70f5fc..3b04ef114 100644 --- a/drivers/net/iavf/iavf_vchnl.c +++ b/drivers/net/iavf/iavf_vchnl.c @@ -336,13 +336,10 @@ iavf_get_vf_resource(struct iavf_adapter *adapter) args.out_buffer = vf->aq_resp; args.out_size = IAVF_AQ_BUF_SZ; - /* TODO: basic offload capabilities, need to - * add advanced/optional offload capabilities - */ - caps = IAVF_BASIC_OFFLOAD_CAPS | VIRTCHNL_VF_CAP_ADV_LINK_SPEED | VIRTCHNL_VF_OFFLOAD_QUERY_DDP | - VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC; + VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC | + VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF; args.in_args = (uint8_t *)∩︀ args.in_args_size = sizeof(caps); @@ -867,3 +864,29 @@ iavf_add_del_vlan(struct iavf_adapter *adapter, uint16_t vlanid, bool add) return err; } + +int +iavf_add_del_rss_cfg(struct iavf_adapter *adapter, + struct virtchnl_rss_cfg *rss_cfg, bool add) +{ + struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(adapter); + struct iavf_cmd_info args; + int err; + + memset(&args, 0, sizeof(args)); + args.ops = add ? VIRTCHNL_OP_ADD_RSS_CFG : + VIRTCHNL_OP_DEL_RSS_CFG; + args.in_args = (u8 *)rss_cfg; + args.in_args_size = sizeof(*rss_cfg); + args.out_buffer = vf->aq_resp; + args.out_size = IAVF_AQ_BUF_SZ; + + err = iavf_execute_vf_cmd(adapter, &args); + if (err) + PMD_DRV_LOG(ERR, + "Failed to execute command of %s", + add ? "OP_ADD_RSS_CFG" : + "OP_DEL_RSS_INPUT_CFG"); + + return err; +} diff --git a/drivers/net/iavf/meson.build b/drivers/net/iavf/meson.build index 32eabca4b..5a5cdd562 100644 --- a/drivers/net/iavf/meson.build +++ b/drivers/net/iavf/meson.build @@ -13,6 +13,7 @@ sources = files( 'iavf_rxtx.c', 'iavf_vchnl.c', 'iavf_generic_flow.c', + 'iavf_hash.c', ) if arch_subdir == 'x86' -- 2.20.1