ligang/vpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2f76b57280e76220ed7cad244059aa4f624371f4
vpp/src/plugins/avf/avf_advanced_flow.h
Xinyao Cai 6cb7273949 flow dpdk avf: add support for using l2tpv3 as RSS type 
This patch adds support for using l2tpv3 as RSS type

Type: feature
Signed-off-by: Xinyao Cai <xinyao.cai@intel.com>
Change-Id: Ic3e0935a4754d084184f1cc38ea9531ddfd9e7bc
2023-10-01 21:17:07 +00:00

1449 lines
43 KiB
C
Raw Blame History

/*
*------------------------------------------------------------------
* Copyright (c) 2020 Intel and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*------------------------------------------------------------------
*/
#ifndef _AVF_ADVANCED_FLOW_H_
#define _AVF_ADVANCED_FLOW_H_
#define AVF_SUCCESS (0)
#define AVF_FAILURE (-1)
#define BIT(a) (1UL << (a))
#define BIT_ULL(a) (1ULL << (a))
/* These macros are used to generate compilation errors if a structure/union
* is not exactly the correct length. It gives a divide by zero error if the
* structure/union is not of the correct size, otherwise it creates an enum
* that is never used.
*/
#define VIRTCHNL_CHECK_STRUCT_LEN(n, X) \
enum virtchnl_static_assert_enum_##X \
{ \
virtchnl_static_assert_##X = (n) / ((sizeof (struct X) == (n)) ? 1 : 0) \
}
#define VIRTCHNL_CHECK_UNION_LEN(n, X) \
enum virtchnl_static_asset_enum_##X \
{ \
virtchnl_static_assert_##X = (n) / ((sizeof (union X) == (n)) ? 1 : 0) \
}
/* AVF ethernet frame types */
#define AVF_ETHER_TYPE_IPV4 0x0800 /**< IPv4 Protocol. */
#define AVF_ETHER_TYPE_IPV6 0x86DD /**< IPv6 Protocol. */
#define VIRTCHNL_MAX_NUM_PROTO_HDRS 32
#define VIRTCHNL_MAX_SIZE_GEN_PACKET 1024
#define PROTO_HDR_SHIFT 5
#define PROTO_HDR_FIELD_START(proto_hdr_type) \
(proto_hdr_type << PROTO_HDR_SHIFT)
#define PROTO_HDR_FIELD_MASK ((1UL << PROTO_HDR_SHIFT) - 1)
/* VF use these macros to configure each protocol header.
* Specify which protocol headers and protocol header fields base on
* virtchnl_proto_hdr_type and virtchnl_proto_hdr_field.
* @param hdr: a struct of virtchnl_proto_hdr
* @param hdr_type: ETH/IPV4/TCP, etc
* @param field: SRC/DST/TEID/SPI, etc
*/
#define VIRTCHNL_ADD_PROTO_HDR_FIELD(hdr, field) \
((hdr)->field_selector |= BIT ((field) &PROTO_HDR_FIELD_MASK))
#define VIRTCHNL_DEL_PROTO_HDR_FIELD(hdr, field) \
((hdr)->field_selector &= ~BIT ((field) &PROTO_HDR_FIELD_MASK))
#define VIRTCHNL_TEST_PROTO_HDR_FIELD(hdr, val) \
((hdr)->field_selector & BIT ((val) &PROTO_HDR_FIELD_MASK))
#define VIRTCHNL_GET_PROTO_HDR_FIELD(hdr) ((hdr)->field_selector)
#define VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, hdr_type, field) \
(VIRTCHNL_ADD_PROTO_HDR_FIELD (hdr, VIRTCHNL_PROTO_HDR_##hdr_type##_##field))
#define VIRTCHNL_DEL_PROTO_HDR_FIELD_BIT(hdr, hdr_type, field) \
(VIRTCHNL_DEL_PROTO_HDR_FIELD (hdr, VIRTCHNL_PROTO_HDR_##hdr_type##_##field))
#define VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, hdr_type) \
((hdr)->type = VIRTCHNL_PROTO_HDR_##hdr_type)
#define VIRTCHNL_GET_PROTO_HDR_TYPE(hdr) (((hdr)->type) >> PROTO_HDR_SHIFT)
#define VIRTCHNL_TEST_PROTO_HDR_TYPE(hdr, val) \
((hdr)->type == ((val) >> PROTO_HDR_SHIFT))
#define VIRTCHNL_TEST_PROTO_HDR(hdr, val) \
(VIRTCHNL_TEST_PROTO_HDR_TYPE (hdr, val) && \
VIRTCHNL_TEST_PROTO_HDR_FIELD (hdr, val))
/* protocol */
#define AVF_PROT_MAC_INNER (1ULL << 1)
#define AVF_PROT_MAC_OUTER (1ULL << 2)
#define AVF_PROT_VLAN_INNER (1ULL << 3)
#define AVF_PROT_VLAN_OUTER (1ULL << 4)
#define AVF_PROT_IPV4_INNER (1ULL << 5)
#define AVF_PROT_IPV4_OUTER (1ULL << 6)
#define AVF_PROT_IPV6_INNER (1ULL << 7)
#define AVF_PROT_IPV6_OUTER (1ULL << 8)
#define AVF_PROT_TCP_INNER (1ULL << 9)
#define AVF_PROT_TCP_OUTER (1ULL << 10)
#define AVF_PROT_UDP_INNER (1ULL << 11)
#define AVF_PROT_UDP_OUTER (1ULL << 12)
#define AVF_PROT_SCTP_INNER (1ULL << 13)
#define AVF_PROT_SCTP_OUTER (1ULL << 14)
#define AVF_PROT_ICMP4_INNER (1ULL << 15)
#define AVF_PROT_ICMP4_OUTER (1ULL << 16)
#define AVF_PROT_ICMP6_INNER (1ULL << 17)
#define AVF_PROT_ICMP6_OUTER (1ULL << 18)
#define AVF_PROT_VXLAN (1ULL << 19)
#define AVF_PROT_NVGRE (1ULL << 20)
#define AVF_PROT_GTPU (1ULL << 21)
#define AVF_PROT_ESP (1ULL << 22)
#define AVF_PROT_AH (1ULL << 23)
#define AVF_PROT_L2TPV3OIP (1ULL << 24)
#define AVF_PROT_PFCP (1ULL << 25)
/* field */
#define AVF_SMAC (1ULL << 63)
#define AVF_DMAC (1ULL << 62)
#define AVF_ETHERTYPE (1ULL << 61)
#define AVF_IP_SRC (1ULL << 60)
#define AVF_IP_DST (1ULL << 59)
#define AVF_IP_PROTO (1ULL << 58)
#define AVF_IP_TTL (1ULL << 57)
#define AVF_IP_TOS (1ULL << 56)
#define AVF_SPORT (1ULL << 55)
#define AVF_DPORT (1ULL << 54)
#define AVF_ICMP_TYPE (1ULL << 53)
#define AVF_ICMP_CODE (1ULL << 52)
#define AVF_VXLAN_VNI (1ULL << 51)
#define AVF_NVGRE_TNI (1ULL << 50)
#define AVF_GTPU_TEID (1ULL << 49)
#define AVF_GTPU_QFI (1ULL << 48)
#define AVF_ESP_SPI (1ULL << 47)
#define AVF_AH_SPI (1ULL << 46)
#define AVF_L2TPV3OIP_SESSION_ID (1ULL << 45)
#define AVF_PFCP_S_FIELD (1ULL << 44)
#define AVF_PFCP_SEID (1ULL << 43)
/* input set */
#define AVF_INSET_NONE 0ULL
/* non-tunnel */
#define AVF_INSET_SMAC (AVF_PROT_MAC_OUTER | AVF_SMAC)
#define AVF_INSET_DMAC (AVF_PROT_MAC_OUTER | AVF_DMAC)
#define AVF_INSET_VLAN_INNER (AVF_PROT_VLAN_INNER)
#define AVF_INSET_VLAN_OUTER (AVF_PROT_VLAN_OUTER)
#define AVF_INSET_ETHERTYPE (AVF_ETHERTYPE)
#define AVF_INSET_IPV4_SRC (AVF_PROT_IPV4_OUTER | AVF_IP_SRC)
#define AVF_INSET_IPV4_DST (AVF_PROT_IPV4_OUTER | AVF_IP_DST)
#define AVF_INSET_IPV4_TOS (AVF_PROT_IPV4_OUTER | AVF_IP_TOS)
#define AVF_INSET_IPV4_PROTO (AVF_PROT_IPV4_OUTER | AVF_IP_PROTO)
#define AVF_INSET_IPV4_TTL (AVF_PROT_IPV4_OUTER | AVF_IP_TTL)
#define AVF_INSET_IPV6_SRC (AVF_PROT_IPV6_OUTER | AVF_IP_SRC)
#define AVF_INSET_IPV6_DST (AVF_PROT_IPV6_OUTER | AVF_IP_DST)
#define AVF_INSET_IPV6_NEXT_HDR (AVF_PROT_IPV6_OUTER | AVF_IP_PROTO)
#define AVF_INSET_IPV6_HOP_LIMIT (AVF_PROT_IPV6_OUTER | AVF_IP_TTL)
#define AVF_INSET_IPV6_TC (AVF_PROT_IPV6_OUTER | AVF_IP_TOS)
#define AVF_INSET_TCP_SRC_PORT (AVF_PROT_TCP_OUTER | AVF_SPORT)
#define AVF_INSET_TCP_DST_PORT (AVF_PROT_TCP_OUTER | AVF_DPORT)
#define AVF_INSET_UDP_SRC_PORT (AVF_PROT_UDP_OUTER | AVF_SPORT)
#define AVF_INSET_UDP_DST_PORT (AVF_PROT_UDP_OUTER | AVF_DPORT)
#define AVF_INSET_SCTP_SRC_PORT (AVF_PROT_SCTP_OUTER | AVF_SPORT)
#define AVF_INSET_SCTP_DST_PORT (AVF_PROT_SCTP_OUTER | AVF_DPORT)
#define AVF_INSET_ICMP4_SRC_PORT (AVF_PROT_ICMP4_OUTER | AVF_SPORT)
#define AVF_INSET_ICMP4_DST_PORT (AVF_PROT_ICMP4_OUTER | AVF_DPORT)
#define AVF_INSET_ICMP6_SRC_PORT (AVF_PROT_ICMP6_OUTER | AVF_SPORT)
#define AVF_INSET_ICMP6_DST_PORT (AVF_PROT_ICMP6_OUTER | AVF_DPORT)
#define AVF_INSET_ICMP4_TYPE (AVF_PROT_ICMP4_OUTER | AVF_ICMP_TYPE)
#define AVF_INSET_ICMP4_CODE (AVF_PROT_ICMP4_OUTER | AVF_ICMP_CODE)
#define AVF_INSET_ICMP6_TYPE (AVF_PROT_ICMP6_OUTER | AVF_ICMP_TYPE)
#define AVF_INSET_ICMP6_CODE (AVF_PROT_ICMP6_OUTER | AVF_ICMP_CODE)
#define AVF_INSET_GTPU_TEID (AVF_PROT_GTPU | AVF_GTPU_TEID)
#define AVF_INSET_GTPU_QFI (AVF_PROT_GTPU | AVF_GTPU_QFI)
#define AVF_INSET_ESP_SPI (AVF_PROT_ESP | AVF_ESP_SPI)
#define AVF_INSET_AH_SPI (AVF_PROT_AH | AVF_AH_SPI)
#define AVF_INSET_L2TPV3OIP_SESSION_ID \
(AVF_PROT_L2TPV3OIP | AVF_L2TPV3OIP_SESSION_ID)
#define AVF_INSET_PFCP_S_FIELD (AVF_PROT_PFCP | AVF_PFCP_S_FIELD)
#define AVF_INSET_PFCP_SEID (AVF_PROT_PFCP | AVF_PFCP_S_FIELD | AVF_PFCP_SEID)
#define AVF_ETH_RSS_IPV4 BIT_ULL (2)
#define AVF_ETH_RSS_FRAG_IPV4 BIT_ULL (3)
#define AVF_ETH_RSS_NONFRAG_IPV4_TCP BIT_ULL (4)
#define AVF_ETH_RSS_NONFRAG_IPV4_UDP BIT_ULL (5)
#define AVF_ETH_RSS_NONFRAG_IPV4_SCTP BIT_ULL (6)
#define AVF_ETH_RSS_NONFRAG_IPV4_OTHER BIT_ULL (7)
#define AVF_ETH_RSS_IPV6 BIT_ULL (8)
#define AVF_ETH_RSS_FRAG_IPV6 BIT_ULL (9)
#define AVF_ETH_RSS_NONFRAG_IPV6_TCP BIT_ULL (10)
#define AVF_ETH_RSS_NONFRAG_IPV6_UDP BIT_ULL (11)
#define AVF_ETH_RSS_NONFRAG_IPV6_SCTP BIT_ULL (12)
#define AVF_ETH_RSS_NONFRAG_IPV6_OTHER BIT_ULL (13)
#define AVF_ETH_RSS_L2_PAYLOAD BIT_ULL (14)
#define AVF_ETH_RSS_IPV6_EX BIT_ULL (15)
#define AVF_ETH_RSS_IPV6_TCP_EX BIT_ULL (16)
#define AVF_ETH_RSS_IPV6_UDP_EX BIT_ULL (17)
#define AVF_ETH_RSS_PORT BIT_ULL (18)
#define AVF_ETH_RSS_VXLAN BIT_ULL (19)
#define AVF_ETH_RSS_GENEVE BIT_ULL (20)
#define AVF_ETH_RSS_NVGRE BIT_ULL (21)
#define AVF_ETH_RSS_GTPU BIT_ULL (23)
#define AVF_ETH_RSS_ETH BIT_ULL (24)
#define AVF_ETH_RSS_S_VLAN BIT_ULL (25)
#define AVF_ETH_RSS_C_VLAN BIT_ULL (26)
#define AVF_ETH_RSS_ESP BIT_ULL (27)
#define AVF_ETH_RSS_AH BIT_ULL (28)
#define AVF_ETH_RSS_L2TPV3 BIT_ULL (29)
#define AVF_ETH_RSS_PFCP BIT_ULL (30)
#define AVF_ETH_RSS_PPPOE BIT_ULL (31)
#define AVF_ETH_RSS_ECPRI BIT_ULL (32)
#define AVF_ETH_RSS_MPLS BIT_ULL (33)
#define AVF_ETH_RSS_IPV4_CHKSUM BIT_ULL (34)
#define AVF_ETH_RSS_L4_CHKSUM BIT_ULL (35)
#define AVF_ETH_RSS_L2TPV2 BIT_ULL (36)
#define AVF_ETH_RSS_L3_SRC_ONLY BIT_ULL (63)
#define AVF_ETH_RSS_L3_DST_ONLY BIT_ULL (62)
#define AVF_ETH_RSS_L4_SRC_ONLY BIT_ULL (61)
#define AVF_ETH_RSS_L4_DST_ONLY BIT_ULL (60)
#define AVF_ETH_RSS_L2_SRC_ONLY BIT_ULL (59)
#define AVF_ETH_RSS_L2_DST_ONLY BIT_ULL (58)
#define AVF_ETH_RSS_L3_PRE32 BIT_ULL (57)
#define AVF_ETH_RSS_L3_PRE40 BIT_ULL (56)
#define AVF_ETH_RSS_L3_PRE48 BIT_ULL (55)
#define AVF_ETH_RSS_L3_PRE56 BIT_ULL (54)
#define AVF_ETH_RSS_L3_PRE64 BIT_ULL (53)
#define AVF_ETH_RSS_L3_PRE96 BIT_ULL (52)
#define foreach_avf_rss_hf \
_ (0, AVF_ETH_RSS_FRAG_IPV4, "ipv4-frag") \
_ (1, AVF_ETH_RSS_NONFRAG_IPV4_TCP, "ipv4-tcp") \
_ (2, AVF_ETH_RSS_NONFRAG_IPV4_UDP, "ipv4-udp") \
_ (3, AVF_ETH_RSS_NONFRAG_IPV4_SCTP, "ipv4-sctp") \
_ (4, AVF_ETH_RSS_NONFRAG_IPV4_OTHER, "ipv4-other") \
_ (5, AVF_ETH_RSS_IPV4, "ipv4") \
_ (6, AVF_ETH_RSS_IPV6_TCP_EX, "ipv6-tcp-ex") \
_ (7, AVF_ETH_RSS_IPV6_UDP_EX, "ipv6-udp-ex") \
_ (8, AVF_ETH_RSS_FRAG_IPV6, "ipv6-frag") \
_ (9, AVF_ETH_RSS_NONFRAG_IPV6_TCP, "ipv6-tcp") \
_ (10, AVF_ETH_RSS_NONFRAG_IPV6_UDP, "ipv6-udp") \
_ (11, AVF_ETH_RSS_NONFRAG_IPV6_SCTP, "ipv6-sctp") \
_ (12, AVF_ETH_RSS_NONFRAG_IPV6_OTHER, "ipv6-other") \
_ (13, AVF_ETH_RSS_IPV6_EX, "ipv6-ex") \
_ (14, AVF_ETH_RSS_IPV6, "ipv6") \
_ (15, AVF_ETH_RSS_L2_PAYLOAD, "l2-payload") \
_ (16, AVF_ETH_RSS_PORT, "port") \
_ (17, AVF_ETH_RSS_VXLAN, "vxlan") \
_ (18, AVF_ETH_RSS_GENEVE, "geneve") \
_ (19, AVF_ETH_RSS_NVGRE, "nvgre") \
_ (20, AVF_ETH_RSS_GTPU, "gtpu") \
_ (21, AVF_ETH_RSS_ESP, "esp") \
_ (22, AVF_ETH_RSS_L2TPV3, "l2tpv3") \
_ (60, AVF_ETH_RSS_L4_DST_ONLY, "l4-dst-only") \
_ (61, AVF_ETH_RSS_L4_SRC_ONLY, "l4-src-only") \
_ (62, AVF_ETH_RSS_L3_DST_ONLY, "l3-dst-only") \
_ (63, AVF_ETH_RSS_L3_SRC_ONLY, "l3-src-only")
/* Protocol header type within a packet segment. A segment consists of one or
* more protocol headers that make up a logical group of protocol headers. Each
* logical group of protocol headers encapsulates or is encapsulated using/by
* tunneling or encapsulation protocols for network virtualization.
*/
enum virtchnl_proto_hdr_type
{
VIRTCHNL_PROTO_HDR_NONE,
VIRTCHNL_PROTO_HDR_ETH,
VIRTCHNL_PROTO_HDR_S_VLAN,
VIRTCHNL_PROTO_HDR_C_VLAN,
VIRTCHNL_PROTO_HDR_IPV4,
VIRTCHNL_PROTO_HDR_IPV6,
VIRTCHNL_PROTO_HDR_TCP,
VIRTCHNL_PROTO_HDR_UDP,
VIRTCHNL_PROTO_HDR_SCTP,
VIRTCHNL_PROTO_HDR_GTPU_IP,
VIRTCHNL_PROTO_HDR_GTPU_EH,
VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_DWN,
VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_UP,
VIRTCHNL_PROTO_HDR_PPPOE,
VIRTCHNL_PROTO_HDR_L2TPV3,
VIRTCHNL_PROTO_HDR_ESP,
VIRTCHNL_PROTO_HDR_AH,
VIRTCHNL_PROTO_HDR_PFCP,
VIRTCHNL_PROTO_HDR_GTPC,
VIRTCHNL_PROTO_HDR_ECPRI,
VIRTCHNL_PROTO_HDR_L2TPV2,
VIRTCHNL_PROTO_HDR_PPP,
/* IPv4 and IPv6 Fragment header types are only associated to
* VIRTCHNL_PROTO_HDR_IPV4 and VIRTCHNL_PROTO_HDR_IPV6 respectively,
* cannot be used independently.
*/
VIRTCHNL_PROTO_HDR_IPV4_FRAG,
VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG,
VIRTCHNL_PROTO_HDR_GRE,
};
/* Protocol header field within a protocol header. */
enum virtchnl_proto_hdr_field
{
/* ETHER */
VIRTCHNL_PROTO_HDR_ETH_SRC = PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_ETH),
VIRTCHNL_PROTO_HDR_ETH_DST,
VIRTCHNL_PROTO_HDR_ETH_ETHERTYPE,
/* S-VLAN */
VIRTCHNL_PROTO_HDR_S_VLAN_ID =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_S_VLAN),
/* C-VLAN */
VIRTCHNL_PROTO_HDR_C_VLAN_ID =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_C_VLAN),
/* IPV4 */
VIRTCHNL_PROTO_HDR_IPV4_SRC =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_IPV4),
VIRTCHNL_PROTO_HDR_IPV4_DST,
VIRTCHNL_PROTO_HDR_IPV4_DSCP,
VIRTCHNL_PROTO_HDR_IPV4_TTL,
VIRTCHNL_PROTO_HDR_IPV4_PROT,
VIRTCHNL_PROTO_HDR_IPV4_CHKSUM,
/* IPV6 */
VIRTCHNL_PROTO_HDR_IPV6_SRC =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_IPV6),
VIRTCHNL_PROTO_HDR_IPV6_DST,
VIRTCHNL_PROTO_HDR_IPV6_TC,
VIRTCHNL_PROTO_HDR_IPV6_HOP_LIMIT,
VIRTCHNL_PROTO_HDR_IPV6_PROT,
/* IPV6 Prefix */
VIRTCHNL_PROTO_HDR_IPV6_PREFIX32_SRC,
VIRTCHNL_PROTO_HDR_IPV6_PREFIX32_DST,
VIRTCHNL_PROTO_HDR_IPV6_PREFIX40_SRC,
VIRTCHNL_PROTO_HDR_IPV6_PREFIX40_DST,
VIRTCHNL_PROTO_HDR_IPV6_PREFIX48_SRC,
VIRTCHNL_PROTO_HDR_IPV6_PREFIX48_DST,
VIRTCHNL_PROTO_HDR_IPV6_PREFIX56_SRC,
VIRTCHNL_PROTO_HDR_IPV6_PREFIX56_DST,
VIRTCHNL_PROTO_HDR_IPV6_PREFIX64_SRC,
VIRTCHNL_PROTO_HDR_IPV6_PREFIX64_DST,
VIRTCHNL_PROTO_HDR_IPV6_PREFIX96_SRC,
VIRTCHNL_PROTO_HDR_IPV6_PREFIX96_DST,
/* TCP */
VIRTCHNL_PROTO_HDR_TCP_SRC_PORT =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_TCP),
VIRTCHNL_PROTO_HDR_TCP_DST_PORT,
VIRTCHNL_PROTO_HDR_TCP_CHKSUM,
/* UDP */
VIRTCHNL_PROTO_HDR_UDP_SRC_PORT =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_UDP),
VIRTCHNL_PROTO_HDR_UDP_DST_PORT,
VIRTCHNL_PROTO_HDR_UDP_CHKSUM,
/* SCTP */
VIRTCHNL_PROTO_HDR_SCTP_SRC_PORT =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_SCTP),
VIRTCHNL_PROTO_HDR_SCTP_DST_PORT,
VIRTCHNL_PROTO_HDR_SCTP_CHKSUM,
/* GTPU_IP */
VIRTCHNL_PROTO_HDR_GTPU_IP_TEID =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_GTPU_IP),
/* GTPU_EH */
VIRTCHNL_PROTO_HDR_GTPU_EH_PDU =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_GTPU_EH),
VIRTCHNL_PROTO_HDR_GTPU_EH_QFI,
/* PPPOE */
VIRTCHNL_PROTO_HDR_PPPOE_SESS_ID =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_PPPOE),
/* L2TPV3 */
VIRTCHNL_PROTO_HDR_L2TPV3_SESS_ID =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_L2TPV3),
/* ESP */
VIRTCHNL_PROTO_HDR_ESP_SPI = PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_ESP),
/* AH */
VIRTCHNL_PROTO_HDR_AH_SPI = PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_AH),
/* PFCP */
VIRTCHNL_PROTO_HDR_PFCP_S_FIELD =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_PFCP),
VIRTCHNL_PROTO_HDR_PFCP_SEID,
/* GTPC */
VIRTCHNL_PROTO_HDR_GTPC_TEID =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_GTPC),
/* ECPRI */
VIRTCHNL_PROTO_HDR_ECPRI_MSG_TYPE =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_ECPRI),
VIRTCHNL_PROTO_HDR_ECPRI_PC_RTC_ID,
/* IPv4 Dummy Fragment */
VIRTCHNL_PROTO_HDR_IPV4_FRAG_PKID =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_IPV4_FRAG),
/* IPv6 Extension Fragment */
VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG_PKID =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG),
/* GTPU_DWN/UP */
VIRTCHNL_PROTO_HDR_GTPU_DWN_QFI =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_DWN),
VIRTCHNL_PROTO_HDR_GTPU_UP_QFI =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_UP),
/* L2TPv2 */
VIRTCHNL_PROTO_HDR_L2TPV2_SESS_ID =
PROTO_HDR_FIELD_START (VIRTCHNL_PROTO_HDR_L2TPV2),
VIRTCHNL_PROTO_HDR_L2TPV2_LEN_SESS_ID,
};
struct virtchnl_proto_hdr
{
enum virtchnl_proto_hdr_type type;
u32 field_selector; /* a bit mask to select field for header type */
u8 buffer[64];
/**
* binary buffer in network order for specific header type.
* For example, if type = VIRTCHNL_PROTO_HDR_IPV4, a IPv4
* header is expected to be copied into the buffer.
*/
};
VIRTCHNL_CHECK_STRUCT_LEN (72, virtchnl_proto_hdr);
struct virtchnl_proto_hdrs
{
u8 tunnel_level;
/**
* specify where protocol header start from. Must be 0 when sending a generic
* packet request. 0 - from the outer layer 1 - from the first inner layer 2
*- from the second inner layer
* ....
**/
int count;
/**
* the proto layers must < VIRTCHNL_MAX_NUM_PROTO_HDRS.
* Must be 0 when sending a generic packet request.
**/
union
{
struct virtchnl_proto_hdr proto_hdr[VIRTCHNL_MAX_NUM_PROTO_HDRS];
struct
{
u16 pkt_len;
u8 spec[VIRTCHNL_MAX_SIZE_GEN_PACKET];
u8 mask[VIRTCHNL_MAX_SIZE_GEN_PACKET];
} raw;
};
};
VIRTCHNL_CHECK_STRUCT_LEN (2312, virtchnl_proto_hdrs);
/* VIRTCHNL_OP_CONFIG_RSS_KEY
* VIRTCHNL_OP_CONFIG_RSS_LUT
* VF sends these messages to configure RSS. Only supported if both PF
* and VF drivers set the VIRTCHNL_VF_OFFLOAD_RSS_PF bit during
* configuration negotiation. If this is the case, then the RSS fields in
* the VF resource struct are valid.
* Both the key and LUT are initialized to 0 by the PF, meaning that
* RSS is effectively disabled until set up by the VF.
*/
struct virtchnl_rss_key
{
u16 vsi_id;
u16 key_len;
u8 key[1]; /* RSS hash key, packed bytes */
};
VIRTCHNL_CHECK_STRUCT_LEN (6, virtchnl_rss_key);
struct virtchnl_rss_lut
{
u16 vsi_id;
u16 lut_entries;
u8 lut[1]; /* RSS lookup table */
};
VIRTCHNL_CHECK_STRUCT_LEN (6, virtchnl_rss_lut);
/* VIRTCHNL_OP_GET_RSS_HENA_CAPS
* VIRTCHNL_OP_SET_RSS_HENA
* VF sends these messages to get and set the hash filter enable bits for RSS.
* By default, the PF sets these to all possible traffic types that the
* hardware supports. The VF can query this value if it wants to change the
* traffic types that are hashed by the hardware.
*/
struct virtchnl_rss_hena
{
u64 hena;
};
VIRTCHNL_CHECK_STRUCT_LEN (8, virtchnl_rss_hena);
/* Type of RSS algorithm */
enum virtchnl_rss_algorithm
{
VIRTCHNL_RSS_ALG_TOEPLITZ_ASYMMETRIC = 0,
VIRTCHNL_RSS_ALG_XOR_ASYMMETRIC = 1,
VIRTCHNL_RSS_ALG_TOEPLITZ_SYMMETRIC = 2,
VIRTCHNL_RSS_ALG_XOR_SYMMETRIC = 3,
};
struct virtchnl_rss_cfg
{
struct virtchnl_proto_hdrs proto_hdrs; /* protocol headers */
enum virtchnl_rss_algorithm rss_algorithm; /* rss algorithm type */
u8 reserved[128]; /* reserve for future */
};
VIRTCHNL_CHECK_STRUCT_LEN (2444, virtchnl_rss_cfg);
struct avf_pattern_match_item
{
enum avf_flow_item_type *pattern_list;
u64 input_set_mask;
void *meta;
};
enum avf_flow_item_type
{
AVF_FLOW_ITEM_TYPE_END,
AVF_FLOW_ITEM_TYPE_VOID,
AVF_FLOW_ITEM_TYPE_INVERT,
AVF_FLOW_ITEM_TYPE_ANY,
AVF_FLOW_ITEM_TYPE_PORT_ID,
AVF_FLOW_ITEM_TYPE_RAW,
AVF_FLOW_ITEM_TYPE_ETH,
AVF_FLOW_ITEM_TYPE_VLAN,
AVF_FLOW_ITEM_TYPE_IPV4,
AVF_FLOW_ITEM_TYPE_IPV6,
AVF_FLOW_ITEM_TYPE_ICMP,
AVF_FLOW_ITEM_TYPE_UDP,
AVF_FLOW_ITEM_TYPE_TCP,
AVF_FLOW_ITEM_TYPE_SCTP,
AVF_FLOW_ITEM_TYPE_VXLAN,
AVF_FLOW_ITEM_TYPE_E_TAG,
AVF_FLOW_ITEM_TYPE_NVGRE,
AVF_FLOW_ITEM_TYPE_MPLS,
AVF_FLOW_ITEM_TYPE_GRE,
AVF_FLOW_ITEM_TYPE_FUZZY,
AVF_FLOW_ITEM_TYPE_GTP,
AVF_FLOW_ITEM_TYPE_GTPC,
AVF_FLOW_ITEM_TYPE_GTPU,
AVF_FLOW_ITEM_TYPE_ESP,
AVF_FLOW_ITEM_TYPE_GENEVE,
AVF_FLOW_ITEM_TYPE_VXLAN_GPE,
AVF_FLOW_ITEM_TYPE_ARP_ETH_IPV4,
AVF_FLOW_ITEM_TYPE_IPV6_EXT,
AVF_FLOW_ITEM_TYPE_ICMP6,
AVF_FLOW_ITEM_TYPE_ICMP6_ND_NS,
AVF_FLOW_ITEM_TYPE_ICMP6_ND_NA,
AVF_FLOW_ITEM_TYPE_ICMP6_ND_OPT,
AVF_FLOW_ITEM_TYPE_ICMP6_ND_OPT_SLA_ETH,
AVF_FLOW_ITEM_TYPE_ICMP6_ND_OPT_TLA_ETH,
AVF_FLOW_ITEM_TYPE_MARK,
AVF_FLOW_ITEM_TYPE_META,
AVF_FLOW_ITEM_TYPE_GRE_KEY,
AVF_FLOW_ITEM_TYPE_GTP_PSC,
AVF_FLOW_ITEM_TYPE_PPPOES,
AVF_FLOW_ITEM_TYPE_PPPOED,
AVF_FLOW_ITEM_TYPE_PPPOE_PROTO_ID,
AVF_FLOW_ITEM_TYPE_NSH,
AVF_FLOW_ITEM_TYPE_IGMP,
AVF_FLOW_ITEM_TYPE_AH,
AVF_FLOW_ITEM_TYPE_HIGIG2,
AVF_FLOW_ITEM_TYPE_TAG,
AVF_FLOW_ITEM_TYPE_L2TPV3OIP,
AVF_FLOW_ITEM_TYPE_PFCP,
AVF_FLOW_ITEM_TYPE_ECPRI,
AVF_FLOW_ITEM_TYPE_IPV6_FRAG_EXT,
AVF_FLOW_ITEM_TYPE_GENEVE_OPT,
AVF_FLOW_ITEM_TYPE_INTEGRITY,
AVF_FLOW_ITEM_TYPE_CONNTRACK,
AVF_FLOW_ITEM_TYPE_PORT_REPRESENTOR,
AVF_FLOW_ITEM_TYPE_REPRESENTED_PORT,
AVF_FLOW_ITEM_TYPE_FLEX,
AVF_FLOW_ITEM_TYPE_L2TPV2,
AVF_FLOW_ITEM_TYPE_PPP,
AVF_FLOW_ITEM_TYPE_GRE_OPTION,
AVF_FLOW_ITEM_TYPE_MACSEC,
AVF_FLOW_ITEM_TYPE_METER_COLOR,
};
enum avf_flow_action_type
{
AVF_FLOW_ACTION_TYPE_END,
AVF_FLOW_ACTION_TYPE_VOID,
AVF_FLOW_ACTION_TYPE_PASSTHRU,
AVF_FLOW_ACTION_TYPE_JUMP,
AVF_FLOW_ACTION_TYPE_MARK,
AVF_FLOW_ACTION_TYPE_FLAG,
AVF_FLOW_ACTION_TYPE_QUEUE,
AVF_FLOW_ACTION_TYPE_DROP,
AVF_FLOW_ACTION_TYPE_COUNT,
AVF_FLOW_ACTION_TYPE_RSS,
AVF_FLOW_ACTION_TYPE_PF,
AVF_FLOW_ACTION_TYPE_VF,
AVF_FLOW_ACTION_TYPE_PORT_ID,
AVF_FLOW_ACTION_TYPE_METER,
AVF_FLOW_ACTION_TYPE_SECURITY,
AVF_FLOW_ACTION_TYPE_OF_DEC_NW_TTL,
AVF_FLOW_ACTION_TYPE_OF_POP_VLAN,
AVF_FLOW_ACTION_TYPE_OF_PUSH_VLAN,
AVF_FLOW_ACTION_TYPE_OF_SET_VLAN_VID,
AVF_FLOW_ACTION_TYPE_OF_SET_VLAN_PCP,
AVF_FLOW_ACTION_TYPE_OF_POP_MPLS,
AVF_FLOW_ACTION_TYPE_OF_PUSH_MPLS,
AVF_FLOW_ACTION_TYPE_VXLAN_ENCAP,
AVF_FLOW_ACTION_TYPE_VXLAN_DECAP,
AVF_FLOW_ACTION_TYPE_NVGRE_ENCAP,
AVF_FLOW_ACTION_TYPE_NVGRE_DECAP,
AVF_FLOW_ACTION_TYPE_RAW_ENCAP,
AVF_FLOW_ACTION_TYPE_RAW_DECAP,
AVF_FLOW_ACTION_TYPE_SET_IPV4_SRC,
AVF_FLOW_ACTION_TYPE_SET_IPV4_DST,
AVF_FLOW_ACTION_TYPE_SET_IPV6_SRC,
AVF_FLOW_ACTION_TYPE_SET_IPV6_DST,
AVF_FLOW_ACTION_TYPE_SET_TP_SRC,
AVF_FLOW_ACTION_TYPE_SET_TP_DST,
AVF_FLOW_ACTION_TYPE_MAC_SWAP,
AVF_FLOW_ACTION_TYPE_DEC_TTL,
AVF_FLOW_ACTION_TYPE_SET_TTL,
AVF_FLOW_ACTION_TYPE_SET_MAC_SRC,
AVF_FLOW_ACTION_TYPE_SET_MAC_DST,
AVF_FLOW_ACTION_TYPE_INC_TCP_SEQ,
AVF_FLOW_ACTION_TYPE_DEC_TCP_SEQ,
AVF_FLOW_ACTION_TYPE_INC_TCP_ACK,
AVF_FLOW_ACTION_TYPE_DEC_TCP_ACK,
AVF_FLOW_ACTION_TYPE_SET_TAG,
AVF_FLOW_ACTION_TYPE_SET_META,
AVF_FLOW_ACTION_TYPE_SET_IPV4_DSCP,
AVF_FLOW_ACTION_TYPE_SET_IPV6_DSCP,
AVF_FLOW_ACTION_TYPE_AGE,
AVF_FLOW_ACTION_TYPE_SAMPLE,
AVF_FLOW_ACTION_TYPE_SHARED,
AVF_FLOW_ACTION_TYPE_MODIFY_FIELD,
AVF_FLOW_ACTION_TYPE_INDIRECT,
AVF_FLOW_ACTION_TYPE_CONNTRACK,
AVF_FLOW_ACTION_TYPE_METER_COLOR,
AVF_FLOW_ACTION_TYPE_PORT_REPRESENTOR,
AVF_FLOW_ACTION_TYPE_REPRESENTED_PORT,
AVF_FLOW_ACTION_TYPE_METER_MARK,
AVF_FLOW_ACTION_TYPE_SEND_TO_KERNEL,
};
enum virtchnl_action
{
/* action types */
VIRTCHNL_ACTION_DROP = 0,
VIRTCHNL_ACTION_TC_REDIRECT,
VIRTCHNL_ACTION_PASSTHRU,
VIRTCHNL_ACTION_QUEUE,
VIRTCHNL_ACTION_Q_REGION,
VIRTCHNL_ACTION_MARK,
VIRTCHNL_ACTION_COUNT,
VIRTCHNL_ACTION_NONE,
};
/* action configuration for FDIR */
struct virtchnl_filter_action
{
enum virtchnl_action type;
union
{
/* used for queue and qgroup action */
struct
{
u16 index;
u8 region;
} queue;
/* used for count action */
struct
{
/* share counter ID with other flow rules */
u8 shared;
u32 id; /* counter ID */
} count;
/* used for mark action */
u32 mark_id;
u8 reserve[32];
} act_conf;
};
VIRTCHNL_CHECK_STRUCT_LEN (36, virtchnl_filter_action);
#define VIRTCHNL_MAX_NUM_ACTIONS 8
struct virtchnl_filter_action_set
{
/* action number must be less then VIRTCHNL_MAX_NUM_ACTIONS */
int count;
struct virtchnl_filter_action actions[VIRTCHNL_MAX_NUM_ACTIONS];
};
VIRTCHNL_CHECK_STRUCT_LEN (292, virtchnl_filter_action_set);
/* pattern and action for FDIR rule */
struct virtchnl_fdir_rule
{
struct virtchnl_proto_hdrs proto_hdrs;
struct virtchnl_filter_action_set action_set;
};
VIRTCHNL_CHECK_STRUCT_LEN (2604, virtchnl_fdir_rule);
/* query information to retrieve fdir rule counters.
* PF will fill out this structure to reset counter.
*/
struct virtchnl_fdir_query_info
{
u32 match_packets_valid : 1;
u32 match_bytes_valid : 1;
u32 reserved : 30; /* Reserved, must be zero. */
u32 pad;
u64 matched_packets; /* Number of packets for this rule. */
u64 matched_bytes; /* Number of bytes through this rule. */
};
VIRTCHNL_CHECK_STRUCT_LEN (24, virtchnl_fdir_query_info);
/* Status returned to VF after VF requests FDIR commands
* VIRTCHNL_FDIR_SUCCESS
* VF FDIR related request is successfully done by PF
* The request can be OP_ADD/DEL/QUERY_FDIR_FILTER.
*
* VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE
* OP_ADD_FDIR_FILTER request is failed due to no Hardware resource.
*
* VIRTCHNL_FDIR_FAILURE_RULE_EXIST
* OP_ADD_FDIR_FILTER request is failed due to the rule is already existed.
*
* VIRTCHNL_FDIR_FAILURE_RULE_CONFLICT
* OP_ADD_FDIR_FILTER request is failed due to conflict with existing rule.
*
* VIRTCHNL_FDIR_FAILURE_RULE_NONEXIST
* OP_DEL_FDIR_FILTER request is failed due to this rule doesn't exist.
*
* VIRTCHNL_FDIR_FAILURE_RULE_INVALID
* OP_ADD_FDIR_FILTER request is failed due to parameters validation
* or HW doesn't support.
*
* VIRTCHNL_FDIR_FAILURE_RULE_TIMEOUT
* OP_ADD/DEL_FDIR_FILTER request is failed due to timing out
* for programming.
*
* VIRTCHNL_FDIR_FAILURE_QUERY_INVALID
* OP_QUERY_FDIR_FILTER request is failed due to parameters validation,
* for example, VF query counter of a rule who has no counter action.
*/
enum virtchnl_fdir_prgm_status
{
VIRTCHNL_FDIR_SUCCESS = 0,
VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE,
VIRTCHNL_FDIR_FAILURE_RULE_EXIST,
VIRTCHNL_FDIR_FAILURE_RULE_CONFLICT,
VIRTCHNL_FDIR_FAILURE_RULE_NONEXIST,
VIRTCHNL_FDIR_FAILURE_RULE_INVALID,
VIRTCHNL_FDIR_FAILURE_RULE_TIMEOUT,
VIRTCHNL_FDIR_FAILURE_QUERY_INVALID,
VIRTCHNL_FDIR_FAILURE_MAX,
};
/* VIRTCHNL_OP_ADD_FDIR_FILTER
* VF sends this request to PF by filling out vsi_id,
* validate_only and rule_cfg. PF will return flow_id
* if the request is successfully done and return add_status to VF.
*/
struct virtchnl_fdir_add
{
u16 vsi_id; /* INPUT */
/*
* 1 for validating a fdir rule, 0 for creating a fdir rule.
* Validate and create share one ops: VIRTCHNL_OP_ADD_FDIR_FILTER.
*/
u16 validate_only; /* INPUT */
u32 flow_id; /* OUTPUT */
struct virtchnl_fdir_rule rule_cfg; /* INPUT */
enum virtchnl_fdir_prgm_status status; /* OUTPUT */
};
VIRTCHNL_CHECK_STRUCT_LEN (2616, virtchnl_fdir_add);
/* VIRTCHNL_OP_DEL_FDIR_FILTER
* VF sends this request to PF by filling out vsi_id
* and flow_id. PF will return del_status to VF.
*/
struct virtchnl_fdir_del
{
u16 vsi_id; /* INPUT */
u16 pad;
u32 flow_id; /* INPUT */
enum virtchnl_fdir_prgm_status status; /* OUTPUT */
};
VIRTCHNL_CHECK_STRUCT_LEN (12, virtchnl_fdir_del);
/* VIRTCHNL_OP_QUERY_FDIR_FILTER
* VF sends this request to PF by filling out vsi_id,
* flow_id and reset_counter. PF will return query_info
* and query_status to VF.
*/
struct virtchnl_fdir_query
{
u16 vsi_id; /* INPUT */
u16 pad1[3];
u32 flow_id; /* INPUT */
u32 reset_counter : 1; /* INPUT */
struct virtchnl_fdir_query_info query_info; /* OUTPUT */
enum virtchnl_fdir_prgm_status status; /* OUTPUT */
u32 pad2;
};
VIRTCHNL_CHECK_STRUCT_LEN (48, virtchnl_fdir_query);
/**
* Those headers used temporary, maybe OS packet
* definition can replace. Add flow error, pattern
* and action definition.
*/
/**
* Verbose error types.
*
* Most of them provide the type of the object referenced by struct
* rte_flow_error.cause.
*/
enum avf_flow_error_type
{
AVF_FLOW_ERROR_TYPE_NONE, /**< No error. */
AVF_FLOW_ERROR_TYPE_UNSPECIFIED, /**< Cause unspecified. */
AVF_FLOW_ERROR_TYPE_HANDLE, /**< Flow rule (handle). */
AVF_FLOW_ERROR_TYPE_ATTR_GROUP, /**< Group field. */
AVF_FLOW_ERROR_TYPE_ATTR_PRIORITY, /**< Priority field. */
AVF_FLOW_ERROR_TYPE_ATTR_INGRESS, /**< Ingress field. */
AVF_FLOW_ERROR_TYPE_ATTR_EGRESS, /**< Egress field. */
AVF_FLOW_ERROR_TYPE_ATTR_TRANSFER, /**< Transfer field. */
AVF_FLOW_ERROR_TYPE_ATTR, /**< Attributes structure. */
AVF_FLOW_ERROR_TYPE_ITEM_NUM, /**< Pattern length. */
AVF_FLOW_ERROR_TYPE_ITEM_SPEC, /**< Item specification. */
AVF_FLOW_ERROR_TYPE_ITEM_LAST, /**< Item specification range. */
AVF_FLOW_ERROR_TYPE_ITEM_MASK, /**< Item specification mask. */
AVF_FLOW_ERROR_TYPE_ITEM, /**< Specific pattern item. */
AVF_FLOW_ERROR_TYPE_ACTION_NUM, /**< Number of actions. */
AVF_FLOW_ERROR_TYPE_ACTION_CONF, /**< Action configuration. */
AVF_FLOW_ERROR_TYPE_ACTION, /**< Specific action. */
};
/**
* Verbose error structure definition.
* Both cause and message may be NULL regardless of the error type.
*/
struct avf_flow_error
{
enum avf_flow_error_type type; /**< Cause field and error types. */
const void *cause; /**< Object responsible for the error. */
const char *message; /**< Human-readable error message. */
};
#define AVF_ETHER_ADDR_LEN 6
struct avf_ether_addr
{
u8 addr_bytes[AVF_ETHER_ADDR_LEN]; /**< Addr bytes in tx order */
} __attribute__ ((__aligned__ (2)));
struct avf_flow_eth_hdr
{
struct avf_ether_addr dst; /**< Destination MAC. */
struct avf_ether_addr src; /**< Source MAC. */
u16 type; /**< EtherType or TPID. */
};
/**
* IPv4 Header
*/
struct avf_ipv4_hdr
{
u8 version_ihl; /**< version and header length */
u8 type_of_service; /**< type of service */
u16 total_length; /**< length of packet */
u16 packet_id; /**< packet ID */
u16 fragment_offset; /**< fragmentation offset */
u8 time_to_live; /**< time to live */
u8 next_proto_id; /**< protocol ID */
u16 hdr_checksum; /**< header checksum */
u32 src_addr; /**< source address */
u32 dst_addr; /**< destination address */
} __attribute__ ((__packed__));
/**
* IPv6 Header
*/
struct avf_ipv6_hdr
{
u32 vtc_flow; /**< IP version, traffic class & flow label. */
u16 payload_len; /**< IP packet length - includes header size */
u8 proto; /**< Protocol, next header. */
u8 hop_limits; /**< Hop limits. */
u8 src_addr[16]; /**< IP address of source host. */
u8 dst_addr[16]; /**< IP address of destination host(s). */
} __attribute__ ((__packed__));
/**
* TCP Header
*/
struct avf_tcp_hdr
{
u16 src_port; /**< TCP source port. */
u16 dst_port; /**< TCP destination port. */
u32 sent_seq; /**< TX data sequence number. */
u32 recv_ack; /**< RX data acknowledgment sequence number. */
u8 data_off; /**< Data offset. */
u8 tcp_flags; /**< TCP flags */
u16 rx_win; /**< RX flow control window. */
u16 cksum; /**< TCP checksum. */
u16 tcp_urp; /**< TCP urgent pointer, if any. */
} __attribute__ ((__packed__));
/**
* UDP Header
*/
struct avf_udp_hdr
{
u16 src_port; /**< UDP source port. */
u16 dst_port; /**< UDP destination port. */
u16 dgram_len; /**< UDP datagram length */
u16 dgram_cksum; /**< UDP datagram checksum */
} __attribute__ ((__packed__));
/**
* Match IP Authentication Header (AH), RFC 4302
*/
struct avf_ah_hdr
{
u32 next_hdr : 8;
u32 payload_len : 8;
u32 reserved : 16;
u32 spi;
u32 seq_num;
};
/**
* ESP Header
*/
struct avf_esp_hdr
{
u32 spi; /**< Security Parameters Index */
u32 seq; /**< packet sequence number */
} __attribute__ ((__packed__));
/**
* Match PFCP Header
*/
struct avf_pfcp_hdr
{
u8 s_field;
u8 msg_type;
u16 msg_len;
u64 seid;
};
/**
* Matches a L2TPv3 over IP header.
*/
struct avf_l2tpv3oip_hdr
{
u32 session_id; /**< Session ID. */
};
/**
* Matches a GTP PDU extension header with type 0x85.
*/
struct avf_gtp_psc_hdr
{
u8 pdu_type; /**< PDU type. */
u8 qfi; /**< QoS flow identifier. */
};
/**
* Matches a GTPv1 header.
*/
struct avf_gtp_hdr
{
/**
* Version (3b), protocol type (1b), reserved (1b),
* Extension header flag (1b),
* Sequence number flag (1b),
* N-PDU number flag (1b).
*/
u8 v_pt_rsv_flags;
u8 msg_type; /**< Message type. */
u16 msg_len; /**< Message length. */
u32 teid; /**< Tunnel endpoint identifier. */
};
/**
* SCTP Header
*/
struct avf_sctp_hdr
{
u16 src_port; /**< Source port. */
u16 dst_port; /**< Destin port. */
u32 tag; /**< Validation tag. */
u32 cksum; /**< Checksum. */
} __attribute__ ((__packed__));
/**
* Hash function types.
*/
enum avf_eth_hash_function
{
AVF_ETH_HASH_FUNCTION_DEFAULT = 0,
AVF_ETH_HASH_FUNCTION_TOEPLITZ, /**< Toeplitz */
AVF_ETH_HASH_FUNCTION_SIMPLE_XOR, /**< Simple XOR */
/**
* Symmetric Toeplitz: src, dst will be replaced by
* xor(src, dst). For the case with src/dst only,
* src or dst address will xor with zero pair.
*/
AVF_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ,
AVF_ETH_HASH_FUNCTION_MAX,
};
struct avf_flow_action_rss
{
enum avf_eth_hash_function func; /**< RSS hash function to apply. */
u32 level;
u64 types; /**< Specific RSS hash types (see ETH_RSS_*). */
u32 key_len; /**< Hash key length in bytes. */
u32 queue_num; /**< Number of entries in @p queue. */
const u8 *key; /**< Hash key. */
const u16 *queue; /**< Queue indices to use. */
};
struct avf_flow_action_queue
{
u16 index; /**< Queue index to use. */
};
struct avf_flow_action_mark
{
u32 id; /**< Integer value to return with packets. */
};
struct avf_flow_action
{
enum avf_flow_action_type type; /**< Action type. */
const void *conf; /**< Pointer to action configuration object. */
};
struct avf_flow_item
{
enum avf_flow_item_type type; /**< Item type. */
const void *spec; /**< Pointer to item specification structure. */
const void *mask; /**< Bit-mask applied to spec and last. */
int is_generic; /* indicate if this item is for a generic flow pattern. */
};
struct avf_fdir_conf
{
struct virtchnl_fdir_add add_fltr;
struct virtchnl_fdir_del del_fltr;
u64 input_set;
u32 flow_id;
u32 mark_flag;
u32 vsi;
u32 nb_rx_queues;
};
enum virthnl_adv_ops
{
VIRTCHNL_ADV_OP_ADD_FDIR_FILTER = 0,
VIRTCHNL_ADV_OP_DEL_FDIR_FILTER,
VIRTCHNL_ADV_OP_QUERY_FDIR_FILTER,
VIRTCHNL_ADV_OP_ADD_RSS_CFG,
VIRTCHNL_ADV_OP_DEL_RSS_CFG,
VIRTCHNL_ADV_OP_MAX
};
/* virtual channel op handler */
typedef int (*avf_flow_vc_op_t) (void *vc_hdl, enum virthnl_adv_ops vc_op,
void *in, u32 in_len, void *out, u32 out_len);
/* virtual channel context object */
struct avf_flow_vc_ctx
{
void *vc_hdl; /* virtual channel handler */
avf_flow_vc_op_t vc_op;
};
/**
* Create a rule cfg object.
*
* @param rcfg
* created rule cfg object.
* @param tunnel
* tunnel level where protocol header start from
* 0 from moster outer layer.
* 1 from first inner layer.
* 2 form second inner layer.
* ...
* @param vsi
* avf vsi id
*
* @param nrxq
* the rx queue number of the avf
*
* @return
* 0 = successful.
* < 0 = failure.
*/
int avf_fdir_rcfg_create (struct avf_fdir_conf **rcfg, int tunnel_level,
u16 vsi, u16 nrxq);
/**
* Destroy a rule cfg object.
*
* @param rcfg
* the cfg object to destroy.
*
* @return
* 0 = successful.
* < 0 = failure.
*/
int avf_fdir_rcfg_destroy (struct avf_fdir_conf *rcfg);
/**
* Set match potocol header on specific layer, it will overwrite is already be
* set.
*
* @param rcfg
* the rule cfg object
* @param layer
* layer of the protocol header.
* @param hdr
* protocol header type.
*
* @return
* 0 = successful.
* < 0 = failure.
*/
int avf_fdir_rcfg_set_hdr (struct avf_fdir_conf *rcfg, int layer,
enum virtchnl_proto_hdr_type hdr);
/**
* Set a match field on specific protocol layer, if any match field already be
* set on this layer, it will be overwritten.
*
* @param rcfg
* the rule cfg object
* @param layer
* layer of the protocol header.
* @param item
* flow item
* @param error
* save error cause
*
* @return
* 0 = successful.
* < 0 = failure.
*/
int avf_fdir_rcfg_set_field (struct avf_fdir_conf *rcfg, int layer,
struct avf_flow_item *item,
struct avf_flow_error *error);
/**
* Set action as to queue(group), conflict with drop action.
*
* @param rcfg
* rule cfg object
* @param queue
* queue id.
* @param size
* queue group size, must be 2^n. 1 means only to single queue.
* @param act_idx
* action index
*
* @return
* 0 = successful.
* < 0 = failure.
*/
int avf_fdir_rcfg_act_queue (struct avf_fdir_conf *rcfg, int queue, int size,
int act_idx);
/**
* Set action as to queue group, conflict with drop action.
*
* @param rcfg
* the rule cfg object
* @param act
* flow actions
* @param act_idx
* action index
* @error
* save error cause
*
* @return
* 0 = successful.
* < 0 = failure.
*/
int avf_fdir_parse_action_qregion (struct avf_fdir_conf *rcfg,
const struct avf_flow_action *act,
int act_idx, struct avf_flow_error *error);
/**
* Set action as as drop, conflict with to queue(gropu) action.
*
* @param rcfg
* the rule cfg object
* @param act_idx
* action index
*
* @return
* 0 = successful.
* < 0 = failure.
*/
int avf_fdir_rcfg_act_drop (struct avf_fdir_conf *rcfg, int act_idx);
/**
* Set action as mark, it can co-exist with to queue(group) or drop action.
*
* @param rcfg
* the rule cfg object
* @param mark
* a 32 bit flow mark
* @param act_idx
* action index
*
* @return
* 0 = successful.
* < 0 = failure.
*/
int avf_fdir_rcfg_act_mark (struct avf_fdir_conf *rcfg, const u32 mark,
int act_idx);
/**
* Validate a flow rule cfg, check with PF driver if the rule cfg is supportted
*or not.
*
* @param ctx
* virtual channel context
* @param rcfg
* the rule cfg object.
*
* @return
* 0 = successful.
* < 0 = failure.
*/
int avf_fdir_rcfg_validate (struct avf_flow_vc_ctx *ctx,
struct avf_fdir_conf *rcfg);
/**
* Create a flow rule, a FDIR rule is expected to be programmed into hardware
*if return success.
*
* @param ctx
* virtual channel context
* @param rcfg
* rule cfg object.
*
* @return
* 0 = successfule.
* < 0 = failure.
*/
int avf_fdir_rule_create (struct avf_flow_vc_ctx *ctx,
struct avf_fdir_conf *rcfg);
/**
* Destroy a flow rule.
*
* @param ctx
* virtual channel context
* @param rcfg
* the rule cfg object.
*
* @return
* 0 = successfule.
* < 0 = failure.
*/
int avf_fdir_rule_destroy (struct avf_flow_vc_ctx *ctx,
struct avf_fdir_conf *rcfg);
/*
* Parse avf patterns and set pattern fields.
*
* @param rcfg
* flow config
* @param avf_items
* pattern items
* @param error
* save error cause
*
* @return
* 0 = successful.
* < 0 = failure
*/
int avf_fdir_parse_pattern (struct avf_fdir_conf *rcfg,
struct avf_flow_item avf_items[],
struct avf_flow_error *error);
/*
* Parse avf patterns for generic flow and set pattern fields.
*
* @param rcfg
* flow config
* @param avf_items
* pattern items
* @param error
* save error cause
*
* @return
* 0 = successful.
* < 0 = failure
*/
int avf_fdir_parse_generic_pattern (struct avf_fdir_conf *rcfg,
struct avf_flow_item avf_items[],
struct avf_flow_error *error);
/*
* Parse flow actions, set actions.
*
* @param actions
* flow actions
* @param rcfg
* flow config
* @param error
* save error cause
*
* @return
* 0 = successful.
* < 0 = failure
*/
int avf_fdir_parse_action (const struct avf_flow_action actions[],
struct avf_fdir_conf *rcfg,
struct avf_flow_error *error);
/*
* Parse flow patterns and rss actions, set rss config.
*
* @param avf_items
* flow pattern
* @param avf_actions
* flow actions
* @param rss_cfg
* rss config
* @param error
* save error cause
*
* @return
* 0 = successful.
* < 0 = failure
*/
int avf_rss_parse_pattern_action (struct avf_flow_item avf_items[],
struct avf_flow_action avf_actions[],
struct virtchnl_rss_cfg *rss_cfg,
struct avf_flow_error *error);
/**
* Create a RSS rule cfg object.
*
* @param rss_cfg
* created rule cfg object.
* @param tunnel
* tunnel level where protocol header start from
* 0 from moster outer layer.
* 1 from first inner layer.
* 2 form second inner layer.
* Must be 0 for generic flow.
*
* @return
* 0 = successful.
* < 0 = failure.
*/
int avf_rss_cfg_create (struct virtchnl_rss_cfg **rss_cfg, int tunnel_level);
int avf_rss_rcfg_destroy (struct virtchnl_rss_cfg *rss_cfg);
/**
* Create a RSS flow rule
*
* @param ctx
* virtual channel context
* @param rss_cfg
* rule cfg object.
*
* @return
* 0 = successfule.
* < 0 = failure.
*/
int avf_rss_rule_create (struct avf_flow_vc_ctx *ctx,
struct virtchnl_rss_cfg *rss_cfg);
/**
* Destroy a RSS flow rule
*
* @param ctx
* virtual channel context
* @param rss_cfg
* rule cfg object.
*
* @return
* 0 = successfule.
* < 0 = failure.
*/
int avf_rss_rule_destroy (struct avf_flow_vc_ctx *ctx,
struct virtchnl_rss_cfg *rss_cfg);
/**
* Parse generic flow pattern to get spec and mask
*
* @param item
* flow item
* @param pkt_buf
* spec buffer.
* @param msk_buf
* mask buffer .
* @param spec_len
* length of spec.
*/
void avf_parse_generic_pattern (struct avf_flow_item *item, u8 *pkt_buf,
u8 *msk_buf, u16 spec_len);
/**
* Initialize flow error structure.
*
* @param[out] error
* Pointer to flow error structure (may be NULL).
* @param code
* Related error code
* @param type
* Cause field and error types.
* @param cause
* Object responsible for the error.
* @param message
* Human-readable error message.
*
* @return
* Negative error code (errno value)
*/
int avf_flow_error_set (struct avf_flow_error *error, int code,
enum avf_flow_error_type type, const void *cause,
const char *message);
/*
* decode the error number to Verbose error string
*
* @param err_no
* error number
*
* @return
* Verbose error string
*/
char *avf_fdir_prgm_error_decode (int err_no);
#endif /* _AVF_ADVANCED_FLOW_H_ */
/*
* fd.io coding-style-patch-verification: ON
*
* Local Variables:
* eval: (c-set-style "gnu")
* End:
*/
Reference in New Issue View Git Blame Copy Permalink