X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=lib%2Flibrte_ethdev%2Frte_flow.h;h=6cc57136ac6b6e0382f48ab02999c9ad043575ad;hb=89813a522e68076e6f50ec18b075fa57cc5ae937;hp=1288e76ae3bbbf88c44e37cc7a65b8455e8230ac;hpb=063911ee1df4950bc6af387b89ee9fdb39aa0650;p=dpdk.git diff --git a/lib/librte_ethdev/rte_flow.h b/lib/librte_ethdev/rte_flow.h index 1288e76ae3..6cc57136ac 100644 --- a/lib/librte_ethdev/rte_flow.h +++ b/lib/librte_ethdev/rte_flow.h @@ -20,14 +20,18 @@ #include #include #include -#include #include #include #include #include #include +#include #include #include +#include +#include +#include +#include #ifdef __cplusplus extern "C" { @@ -414,7 +418,162 @@ enum rte_flow_item_type { * See struct rte_flow_item_mark. */ RTE_FLOW_ITEM_TYPE_MARK, + + /** + * [META] + * + * Matches a metadata value. + * + * See struct rte_flow_item_meta. + */ + RTE_FLOW_ITEM_TYPE_META, + + /** + * Matches a GRE optional key field. + * + * The value should a big-endian 32bit integer. + * + * When this item present the K bit is implicitly matched as "1" + * in the default mask. + * + * @p spec/mask type: + * @code rte_be32_t * @endcode + */ + RTE_FLOW_ITEM_TYPE_GRE_KEY, + + /** + * Matches a GTP extension header: PDU session container. + * + * Configure flow for GTP packets with extension header type 0x85. + * + * See struct rte_flow_item_gtp_psc. + */ + RTE_FLOW_ITEM_TYPE_GTP_PSC, + + /** + * Matches a PPPoE header. + * + * Configure flow for PPPoE session packets. + * + * See struct rte_flow_item_pppoe. + */ + RTE_FLOW_ITEM_TYPE_PPPOES, + + /** + * Matches a PPPoE header. + * + * Configure flow for PPPoE discovery packets. + * + * See struct rte_flow_item_pppoe. + */ + RTE_FLOW_ITEM_TYPE_PPPOED, + + /** + * Matches a PPPoE optional proto_id field. + * + * It only applies to PPPoE session packets. + * + * See struct rte_flow_item_pppoe_proto_id. + */ + RTE_FLOW_ITEM_TYPE_PPPOE_PROTO_ID, + + /** + * Matches Network service header (NSH). + * See struct rte_flow_item_nsh. + * + */ + RTE_FLOW_ITEM_TYPE_NSH, + + /** + * Matches Internet Group Management Protocol (IGMP). + * See struct rte_flow_item_igmp. + * + */ + RTE_FLOW_ITEM_TYPE_IGMP, + + /** + * Matches IP Authentication Header (AH). + * See struct rte_flow_item_ah. + * + */ + RTE_FLOW_ITEM_TYPE_AH, + + /** + * Matches a HIGIG header. + * see struct rte_flow_item_higig2_hdr. + */ + RTE_FLOW_ITEM_TYPE_HIGIG2, + + /** + * [META] + * + * Matches a tag value. + * + * See struct rte_flow_item_tag. + */ + RTE_FLOW_ITEM_TYPE_TAG, + + /** + * Matches a L2TPv3 over IP header. + * + * Configure flow for L2TPv3 over IP packets. + * + * See struct rte_flow_item_l2tpv3oip. + */ + RTE_FLOW_ITEM_TYPE_L2TPV3OIP, + + /** + * Matches PFCP Header. + * See struct rte_flow_item_pfcp. + * + */ + RTE_FLOW_ITEM_TYPE_PFCP, + + /** + * Matches eCPRI Header. + * + * Configure flow for eCPRI over ETH or UDP packets. + * + * See struct rte_flow_item_ecpri. + */ + RTE_FLOW_ITEM_TYPE_ECPRI, + + /** + * Matches the presence of IPv6 fragment extension header. + * + * See struct rte_flow_item_ipv6_frag_ext. + */ + RTE_FLOW_ITEM_TYPE_IPV6_FRAG_EXT, + + /** + * Matches Geneve Variable Length Option + * + * See struct rte_flow_item_geneve_opt + */ + RTE_FLOW_ITEM_TYPE_GENEVE_OPT, +}; + +/** + * + * RTE_FLOW_ITEM_TYPE_HIGIG2 + * Matches higig2 header + */ +RTE_STD_C11 +struct rte_flow_item_higig2_hdr { + struct rte_higig2_hdr hdr; +}; + +/** Default mask for RTE_FLOW_ITEM_TYPE_HIGIG2. */ +#ifndef __cplusplus +static const struct rte_flow_item_higig2_hdr rte_flow_item_higig2_hdr_mask = { + .hdr = { + .ppt1 = { + .classification = 0xffff, + .vid = 0xfff, + }, + }, }; +#endif /** * RTE_FLOW_ITEM_TYPE_ANY @@ -570,24 +729,42 @@ static const struct rte_flow_item_raw rte_flow_item_raw_mask = { * * Matches an Ethernet header. * - * The @p type field either stands for "EtherType" or "TPID" when followed - * by so-called layer 2.5 pattern items such as RTE_FLOW_ITEM_TYPE_VLAN. In - * the latter case, @p type refers to that of the outer header, with the - * inner EtherType/TPID provided by the subsequent pattern item. This is the - * same order as on the wire. + * Inside @p hdr field, the sub-field @p ether_type stands either for EtherType + * or TPID, depending on whether the item is followed by a VLAN item or not. If + * two VLAN items follow, the sub-field refers to the outer one, which, in turn, + * contains the inner TPID in the similar header field. The innermost VLAN item + * contains a layer-3 EtherType. All of that follows the order seen on the wire. + * + * If the field in question contains a TPID value, only tagged packets with the + * specified TPID will match the pattern. Alternatively, it's possible to match + * any type of tagged packets by means of the field @p has_vlan rather than use + * the EtherType/TPID field. Also, it's possible to leave the two fields unused. + * If this is the case, both tagged and untagged packets will match the pattern. */ +RTE_STD_C11 struct rte_flow_item_eth { - struct ether_addr dst; /**< Destination MAC. */ - struct ether_addr src; /**< Source MAC. */ - rte_be16_t type; /**< EtherType or TPID. */ + union { + struct { + /* + * These fields are retained for compatibility. + * Please switch to the new header field below. + */ + struct rte_ether_addr dst; /**< Destination MAC. */ + struct rte_ether_addr src; /**< Source MAC. */ + rte_be16_t type; /**< EtherType or TPID. */ + }; + struct rte_ether_hdr hdr; + }; + uint32_t has_vlan:1; /**< Packet header contains at least one VLAN. */ + uint32_t reserved:31; /**< Reserved, must be zero. */ }; /** Default mask for RTE_FLOW_ITEM_TYPE_ETH. */ #ifndef __cplusplus static const struct rte_flow_item_eth rte_flow_item_eth_mask = { - .dst.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .src.addr_bytes = "\xff\xff\xff\xff\xff\xff", - .type = RTE_BE16(0x0000), + .hdr.d_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.s_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff", + .hdr.ether_type = RTE_BE16(0x0000), }; #endif @@ -597,19 +774,38 @@ static const struct rte_flow_item_eth rte_flow_item_eth_mask = { * Matches an 802.1Q/ad VLAN tag. * * The corresponding standard outer EtherType (TPID) values are - * ETHER_TYPE_VLAN or ETHER_TYPE_QINQ. It can be overridden by the preceding - * pattern item. + * RTE_ETHER_TYPE_VLAN or RTE_ETHER_TYPE_QINQ. It can be overridden by + * the preceding pattern item. + * If a @p VLAN item is present in the pattern, then only tagged packets will + * match the pattern. + * The field @p has_more_vlan can be used to match any type of tagged packets, + * instead of using the @p eth_proto field of @p hdr. + * If the @p eth_proto of @p hdr and @p has_more_vlan fields are not specified, + * then any tagged packets will match the pattern. */ +RTE_STD_C11 struct rte_flow_item_vlan { - rte_be16_t tci; /**< Tag control information. */ - rte_be16_t inner_type; /**< Inner EtherType or TPID. */ + union { + struct { + /* + * These fields are retained for compatibility. + * Please switch to the new header field below. + */ + rte_be16_t tci; /**< Tag control information. */ + rte_be16_t inner_type; /**< Inner EtherType or TPID. */ + }; + struct rte_vlan_hdr hdr; + }; + uint32_t has_more_vlan:1; + /**< Packet header contains at least one more VLAN, after this VLAN. */ + uint32_t reserved:31; /**< Reserved, must be zero. */ }; /** Default mask for RTE_FLOW_ITEM_TYPE_VLAN. */ #ifndef __cplusplus static const struct rte_flow_item_vlan rte_flow_item_vlan_mask = { - .tci = RTE_BE16(0x0fff), - .inner_type = RTE_BE16(0x0000), + .hdr.vlan_tci = RTE_BE16(0x0fff), + .hdr.eth_proto = RTE_BE16(0x0000), }; #endif @@ -621,7 +817,7 @@ static const struct rte_flow_item_vlan rte_flow_item_vlan_mask = { * Note: IPv4 options are handled by dedicated pattern items. */ struct rte_flow_item_ipv4 { - struct ipv4_hdr hdr; /**< IPv4 header definition. */ + struct rte_ipv4_hdr hdr; /**< IPv4 header definition. */ }; /** Default mask for RTE_FLOW_ITEM_TYPE_IPV4. */ @@ -639,11 +835,30 @@ static const struct rte_flow_item_ipv4 rte_flow_item_ipv4_mask = { * * Matches an IPv6 header. * - * Note: IPv6 options are handled by dedicated pattern items, see - * RTE_FLOW_ITEM_TYPE_IPV6_EXT. + * Dedicated flags indicate if header contains specific extension headers. */ struct rte_flow_item_ipv6 { - struct ipv6_hdr hdr; /**< IPv6 header definition. */ + struct rte_ipv6_hdr hdr; /**< IPv6 header definition. */ + uint32_t has_hop_ext:1; + /**< Header contains Hop-by-Hop Options extension header. */ + uint32_t has_route_ext:1; + /**< Header contains Routing extension header. */ + uint32_t has_frag_ext:1; + /**< Header contains Fragment extension header. */ + uint32_t has_auth_ext:1; + /**< Header contains Authentication extension header. */ + uint32_t has_esp_ext:1; + /**< Header contains Encapsulation Security Payload extension header. */ + uint32_t has_dest_ext:1; + /**< Header contains Destination Options extension header. */ + uint32_t has_mobil_ext:1; + /**< Header contains Mobility extension header. */ + uint32_t has_hip_ext:1; + /**< Header contains Host Identity Protocol extension header. */ + uint32_t has_shim6_ext:1; + /**< Header contains Shim6 Protocol extension header. */ + uint32_t reserved:23; + /**< Reserved for future extension headers, must be zero. */ }; /** Default mask for RTE_FLOW_ITEM_TYPE_IPV6. */ @@ -666,7 +881,7 @@ static const struct rte_flow_item_ipv6 rte_flow_item_ipv6_mask = { * Matches an ICMP header. */ struct rte_flow_item_icmp { - struct icmp_hdr hdr; /**< ICMP header definition. */ + struct rte_icmp_hdr hdr; /**< ICMP header definition. */ }; /** Default mask for RTE_FLOW_ITEM_TYPE_ICMP. */ @@ -685,7 +900,7 @@ static const struct rte_flow_item_icmp rte_flow_item_icmp_mask = { * Matches a UDP header. */ struct rte_flow_item_udp { - struct udp_hdr hdr; /**< UDP header definition. */ + struct rte_udp_hdr hdr; /**< UDP header definition. */ }; /** Default mask for RTE_FLOW_ITEM_TYPE_UDP. */ @@ -704,7 +919,7 @@ static const struct rte_flow_item_udp rte_flow_item_udp_mask = { * Matches a TCP header. */ struct rte_flow_item_tcp { - struct tcp_hdr hdr; /**< TCP header definition. */ + struct rte_tcp_hdr hdr; /**< TCP header definition. */ }; /** Default mask for RTE_FLOW_ITEM_TYPE_TCP. */ @@ -723,7 +938,7 @@ static const struct rte_flow_item_tcp rte_flow_item_tcp_mask = { * Matches a SCTP header. */ struct rte_flow_item_sctp { - struct sctp_hdr hdr; /**< SCTP header definition. */ + struct rte_sctp_hdr hdr; /**< SCTP header definition. */ }; /** Default mask for RTE_FLOW_ITEM_TYPE_SCTP. */ @@ -741,17 +956,27 @@ static const struct rte_flow_item_sctp rte_flow_item_sctp_mask = { * * Matches a VXLAN header (RFC 7348). */ +RTE_STD_C11 struct rte_flow_item_vxlan { - uint8_t flags; /**< Normally 0x08 (I flag). */ - uint8_t rsvd0[3]; /**< Reserved, normally 0x000000. */ - uint8_t vni[3]; /**< VXLAN identifier. */ - uint8_t rsvd1; /**< Reserved, normally 0x00. */ + union { + struct { + /* + * These fields are retained for compatibility. + * Please switch to the new header field below. + */ + uint8_t flags; /**< Normally 0x08 (I flag). */ + uint8_t rsvd0[3]; /**< Reserved, normally 0x000000. */ + uint8_t vni[3]; /**< VXLAN identifier. */ + uint8_t rsvd1; /**< Reserved, normally 0x00. */ + }; + struct rte_vxlan_hdr hdr; + }; }; /** Default mask for RTE_FLOW_ITEM_TYPE_VXLAN. */ #ifndef __cplusplus static const struct rte_flow_item_vxlan rte_flow_item_vxlan_mask = { - .vni = "\xff\xff\xff", + .hdr.vx_vni = RTE_BE32(__builtin_constant_p(0xffffff << 8)), }; #endif @@ -761,7 +986,7 @@ static const struct rte_flow_item_vxlan rte_flow_item_vxlan_mask = { * Matches a E-tag header. * * The corresponding standard outer EtherType (TPID) value is - * ETHER_TYPE_ETAG. It can be overridden by the preceding pattern item. + * RTE_ETHER_TYPE_ETAG. It can be overridden by the preceding pattern item. */ struct rte_flow_item_e_tag { /** @@ -908,14 +1133,14 @@ static const struct rte_flow_item_gtp rte_flow_item_gtp_mask = { * Matches an ESP header. */ struct rte_flow_item_esp { - struct esp_hdr hdr; /**< ESP header definition. */ + struct rte_esp_hdr hdr; /**< ESP header definition. */ }; /** Default mask for RTE_FLOW_ITEM_TYPE_ESP. */ #ifndef __cplusplus static const struct rte_flow_item_esp rte_flow_item_esp_mask = { .hdr = { - .spi = 0xffffffff, + .spi = RTE_BE32(0xffffffff), }, }; #endif @@ -974,9 +1199,9 @@ struct rte_flow_item_arp_eth_ipv4 { uint8_t hln; /**< Hardware address length, normally 6. */ uint8_t pln; /**< Protocol address length, normally 4. */ rte_be16_t op; /**< Opcode (1 for request, 2 for reply). */ - struct ether_addr sha; /**< Sender hardware address. */ + struct rte_ether_addr sha; /**< Sender hardware address. */ rte_be32_t spa; /**< Sender IPv4 address. */ - struct ether_addr tha; /**< Target hardware address. */ + struct rte_ether_addr tha; /**< Target hardware address. */ rte_be32_t tpa; /**< Target IPv4 address. */ }; @@ -1013,6 +1238,20 @@ struct rte_flow_item_ipv6_ext rte_flow_item_ipv6_ext_mask = { }; #endif +/** + * RTE_FLOW_ITEM_TYPE_IPV6_FRAG_EXT + * + * Matches the presence of IPv6 fragment extension header. + * + * Preceded by any of: + * + * - RTE_FLOW_ITEM_TYPE_IPV6 + * - RTE_FLOW_ITEM_TYPE_IPV6_EXT + */ +struct rte_flow_item_ipv6_frag_ext { + struct rte_ipv6_fragment_ext hdr; +}; + /** * RTE_FLOW_ITEM_TYPE_ICMP6 * @@ -1120,7 +1359,7 @@ rte_flow_item_icmp6_nd_opt_mask = { struct rte_flow_item_icmp6_nd_opt_sla_eth { uint8_t type; /**< ND option type, normally 1. */ uint8_t length; /**< ND option length, normally 1. */ - struct ether_addr sla; /**< Source Ethernet LLA. */ + struct rte_ether_addr sla; /**< Source Ethernet LLA. */ }; /** Default mask for RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT_SLA_ETH. */ @@ -1145,7 +1384,7 @@ rte_flow_item_icmp6_nd_opt_sla_eth_mask = { struct rte_flow_item_icmp6_nd_opt_tla_eth { uint8_t type; /**< ND option type, normally 2. */ uint8_t length; /**< ND option length, normally 1. */ - struct ether_addr tla; /**< Target Ethernet LLA. */ + struct rte_ether_addr tla; /**< Target Ethernet LLA. */ }; /** Default mask for RTE_FLOW_ITEM_TYPE_ICMP6_ND_OPT_TLA_ETH. */ @@ -1156,6 +1395,122 @@ rte_flow_item_icmp6_nd_opt_tla_eth_mask = { }; #endif +/** + * RTE_FLOW_ITEM_TYPE_META + * + * Matches a specified metadata value. On egress, metadata can be set + * either by mbuf dynamic metadata field with PKT_TX_DYNF_METADATA flag or + * RTE_FLOW_ACTION_TYPE_SET_META. On ingress, RTE_FLOW_ACTION_TYPE_SET_META + * sets metadata for a packet and the metadata will be reported via mbuf + * metadata dynamic field with PKT_RX_DYNF_METADATA flag. The dynamic mbuf + * field must be registered in advance by rte_flow_dynf_metadata_register(). + */ +struct rte_flow_item_meta { + uint32_t data; +}; + +/** Default mask for RTE_FLOW_ITEM_TYPE_META. */ +#ifndef __cplusplus +static const struct rte_flow_item_meta rte_flow_item_meta_mask = { + .data = UINT32_MAX, +}; +#endif + +/** + * RTE_FLOW_ITEM_TYPE_GTP_PSC. + * + * Matches a GTP PDU extension header with type 0x85. + */ +struct rte_flow_item_gtp_psc { + uint8_t pdu_type; /**< PDU type. */ + uint8_t qfi; /**< QoS flow identifier. */ +}; + +/** Default mask for RTE_FLOW_ITEM_TYPE_GTP_PSC. */ +#ifndef __cplusplus +static const struct rte_flow_item_gtp_psc +rte_flow_item_gtp_psc_mask = { + .qfi = 0x3f, +}; +#endif + +/** + * RTE_FLOW_ITEM_TYPE_PPPOE. + * + * Matches a PPPoE header. + */ +struct rte_flow_item_pppoe { + /** + * Version (4b), type (4b). + */ + uint8_t version_type; + uint8_t code; /**< Message type. */ + rte_be16_t session_id; /**< Session identifier. */ + rte_be16_t length; /**< Payload length. */ +}; + +/** + * RTE_FLOW_ITEM_TYPE_PPPOE_PROTO_ID. + * + * Matches a PPPoE optional proto_id field. + * + * It only applies to PPPoE session packets. + * + * Normally preceded by any of: + * + * - RTE_FLOW_ITEM_TYPE_PPPOE + * - RTE_FLOW_ITEM_TYPE_PPPOE_PROTO_ID + */ +struct rte_flow_item_pppoe_proto_id { + rte_be16_t proto_id; /**< PPP protocol identifier. */ +}; + +/** Default mask for RTE_FLOW_ITEM_TYPE_PPPOE_PROTO_ID. */ +#ifndef __cplusplus +static const struct rte_flow_item_pppoe_proto_id +rte_flow_item_pppoe_proto_id_mask = { + .proto_id = RTE_BE16(0xffff), +}; +#endif + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ITEM_TYPE_TAG + * + * Matches a specified tag value at the specified index. + */ +struct rte_flow_item_tag { + uint32_t data; + uint8_t index; +}; + +/** Default mask for RTE_FLOW_ITEM_TYPE_TAG. */ +#ifndef __cplusplus +static const struct rte_flow_item_tag rte_flow_item_tag_mask = { + .data = 0xffffffff, + .index = 0xff, +}; +#endif + +/** + * RTE_FLOW_ITEM_TYPE_L2TPV3OIP. + * + * Matches a L2TPv3 over IP header. + */ +struct rte_flow_item_l2tpv3oip { + rte_be32_t session_id; /**< Session ID. */ +}; + +/** Default mask for RTE_FLOW_ITEM_TYPE_L2TPV3OIP. */ +#ifndef __cplusplus +static const struct rte_flow_item_l2tpv3oip rte_flow_item_l2tpv3oip_mask = { + .session_id = RTE_BE32(UINT32_MAX), +}; +#endif + + /** * @warning * @b EXPERIMENTAL: this structure may change without prior notice @@ -1178,6 +1533,158 @@ struct rte_flow_item_mark { uint32_t id; /**< Integer value to match against. */ }; +/** Default mask for RTE_FLOW_ITEM_TYPE_MARK. */ +#ifndef __cplusplus +static const struct rte_flow_item_mark rte_flow_item_mark_mask = { + .id = 0xffffffff, +}; +#endif + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ITEM_TYPE_NSH + * + * Match network service header (NSH), RFC 8300 + * + */ +struct rte_flow_item_nsh { + uint32_t version:2; + uint32_t oam_pkt:1; + uint32_t reserved:1; + uint32_t ttl:6; + uint32_t length:6; + uint32_t reserved1:4; + uint32_t mdtype:4; + uint32_t next_proto:8; + uint32_t spi:24; + uint32_t sindex:8; +}; + +/** Default mask for RTE_FLOW_ITEM_TYPE_NSH. */ +#ifndef __cplusplus +static const struct rte_flow_item_nsh rte_flow_item_nsh_mask = { + .mdtype = 0xf, + .next_proto = 0xff, + .spi = 0xffffff, + .sindex = 0xff, +}; +#endif + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ITEM_TYPE_IGMP + * + * Match Internet Group Management Protocol (IGMP), RFC 2236 + * + */ +struct rte_flow_item_igmp { + uint32_t type:8; + uint32_t max_resp_time:8; + uint32_t checksum:16; + uint32_t group_addr; +}; + +/** Default mask for RTE_FLOW_ITEM_TYPE_IGMP. */ +#ifndef __cplusplus +static const struct rte_flow_item_igmp rte_flow_item_igmp_mask = { + .group_addr = 0xffffffff, +}; +#endif + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ITEM_TYPE_AH + * + * Match IP Authentication Header (AH), RFC 4302 + * + */ +struct rte_flow_item_ah { + uint32_t next_hdr:8; + uint32_t payload_len:8; + uint32_t reserved:16; + uint32_t spi; + uint32_t seq_num; +}; + +/** Default mask for RTE_FLOW_ITEM_TYPE_AH. */ +#ifndef __cplusplus +static const struct rte_flow_item_ah rte_flow_item_ah_mask = { + .spi = 0xffffffff, +}; +#endif + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ITEM_TYPE_PFCP + * + * Match PFCP Header + */ +struct rte_flow_item_pfcp { + uint8_t s_field; + uint8_t msg_type; + rte_be16_t msg_len; + rte_be64_t seid; +}; + +/** Default mask for RTE_FLOW_ITEM_TYPE_PFCP. */ +#ifndef __cplusplus +static const struct rte_flow_item_pfcp rte_flow_item_pfcp_mask = { + .s_field = 0x01, + .seid = RTE_BE64(UINT64_C(0xffffffffffffffff)), +}; +#endif + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ITEM_TYPE_ECPRI + * + * Match eCPRI Header + */ +struct rte_flow_item_ecpri { + struct rte_ecpri_combined_msg_hdr hdr; +}; + +/** Default mask for RTE_FLOW_ITEM_TYPE_ECPRI. */ +#ifndef __cplusplus +static const struct rte_flow_item_ecpri rte_flow_item_ecpri_mask = { + .hdr = { + .common = { + .u32 = 0x0, + }, + }, +}; +#endif + +/** + * RTE_FLOW_ITEM_TYPE_GENEVE_OPT + * + * Matches a GENEVE Variable Length Option + */ +struct rte_flow_item_geneve_opt { + rte_be16_t option_class; + uint8_t option_type; + uint8_t option_len; + uint32_t *data; +}; + +/** Default mask for RTE_FLOW_ITEM_TYPE_GENEVE_OPT. */ +#ifndef __cplusplus +static const struct rte_flow_item_geneve_opt +rte_flow_item_geneve_opt_mask = { + .option_type = 0xff, +}; +#endif + /** * Matching pattern item definition. * @@ -1221,9 +1728,10 @@ struct rte_flow_item { /** * Action types. * - * Each possible action is represented by a type. Some have associated - * configuration structures. Several actions combined in a list can be - * assigned to a flow rule and are performed in order. + * Each possible action is represented by a type. + * An action can have an associated configuration object. + * Several actions combined in a list can be assigned + * to a flow rule and are performed in order. * * They fall in three categories: * @@ -1312,7 +1820,8 @@ enum rte_flow_action_type { /** * Enables counters for this flow rule. * - * These counters can be retrieved and reset through rte_flow_query(), + * These counters can be retrieved and reset through rte_flow_query() or + * rte_flow_shared_action_query() if the action provided via handle, * see struct rte_flow_query_count. * * See struct rte_flow_action_count. @@ -1506,12 +2015,264 @@ enum rte_flow_action_type { * error. */ RTE_FLOW_ACTION_TYPE_NVGRE_DECAP, -}; -/** - * RTE_FLOW_ACTION_TYPE_MARK - * - * Attaches an integer value to packets and sets PKT_RX_FDIR and + /** + * Add outer header whose template is provided in its data buffer + * + * See struct rte_flow_action_raw_encap. + */ + RTE_FLOW_ACTION_TYPE_RAW_ENCAP, + + /** + * Remove outer header whose template is provided in its data buffer. + * + * See struct rte_flow_action_raw_decap + */ + RTE_FLOW_ACTION_TYPE_RAW_DECAP, + + /** + * Modify IPv4 source address in the outermost IPv4 header. + * + * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_IPV4, + * then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error. + * + * See struct rte_flow_action_set_ipv4. + */ + RTE_FLOW_ACTION_TYPE_SET_IPV4_SRC, + + /** + * Modify IPv4 destination address in the outermost IPv4 header. + * + * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_IPV4, + * then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error. + * + * See struct rte_flow_action_set_ipv4. + */ + RTE_FLOW_ACTION_TYPE_SET_IPV4_DST, + + /** + * Modify IPv6 source address in the outermost IPv6 header. + * + * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_IPV6, + * then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error. + * + * See struct rte_flow_action_set_ipv6. + */ + RTE_FLOW_ACTION_TYPE_SET_IPV6_SRC, + + /** + * Modify IPv6 destination address in the outermost IPv6 header. + * + * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_IPV6, + * then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error. + * + * See struct rte_flow_action_set_ipv6. + */ + RTE_FLOW_ACTION_TYPE_SET_IPV6_DST, + + /** + * Modify source port number in the outermost TCP/UDP header. + * + * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_TCP + * or RTE_FLOW_ITEM_TYPE_UDP, then the PMD should return a + * RTE_FLOW_ERROR_TYPE_ACTION error. + * + * See struct rte_flow_action_set_tp. + */ + RTE_FLOW_ACTION_TYPE_SET_TP_SRC, + + /** + * Modify destination port number in the outermost TCP/UDP header. + * + * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_TCP + * or RTE_FLOW_ITEM_TYPE_UDP, then the PMD should return a + * RTE_FLOW_ERROR_TYPE_ACTION error. + * + * See struct rte_flow_action_set_tp. + */ + RTE_FLOW_ACTION_TYPE_SET_TP_DST, + + /** + * Swap the source and destination MAC addresses in the outermost + * Ethernet header. + * + * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_ETH, + * then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error. + * + * No associated configuration structure. + */ + RTE_FLOW_ACTION_TYPE_MAC_SWAP, + + /** + * Decrease TTL value directly + * + * No associated configuration structure. + */ + RTE_FLOW_ACTION_TYPE_DEC_TTL, + + /** + * Set TTL value + * + * See struct rte_flow_action_set_ttl + */ + RTE_FLOW_ACTION_TYPE_SET_TTL, + + /** + * Set source MAC address from matched flow. + * + * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_ETH, + * the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error. + * + * See struct rte_flow_action_set_mac. + */ + RTE_FLOW_ACTION_TYPE_SET_MAC_SRC, + + /** + * Set destination MAC address from matched flow. + * + * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_ETH, + * the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error. + * + * See struct rte_flow_action_set_mac. + */ + RTE_FLOW_ACTION_TYPE_SET_MAC_DST, + + /** + * Increase sequence number in the outermost TCP header. + * + * Action configuration specifies the value to increase + * TCP sequence number as a big-endian 32 bit integer. + * + * @p conf type: + * @code rte_be32_t * @endcode + * + * Using this action on non-matching traffic will result in + * undefined behavior. + */ + RTE_FLOW_ACTION_TYPE_INC_TCP_SEQ, + + /** + * Decrease sequence number in the outermost TCP header. + * + * Action configuration specifies the value to decrease + * TCP sequence number as a big-endian 32 bit integer. + * + * @p conf type: + * @code rte_be32_t * @endcode + * + * Using this action on non-matching traffic will result in + * undefined behavior. + */ + RTE_FLOW_ACTION_TYPE_DEC_TCP_SEQ, + + /** + * Increase acknowledgment number in the outermost TCP header. + * + * Action configuration specifies the value to increase + * TCP acknowledgment number as a big-endian 32 bit integer. + * + * @p conf type: + * @code rte_be32_t * @endcode + + * Using this action on non-matching traffic will result in + * undefined behavior. + */ + RTE_FLOW_ACTION_TYPE_INC_TCP_ACK, + + /** + * Decrease acknowledgment number in the outermost TCP header. + * + * Action configuration specifies the value to decrease + * TCP acknowledgment number as a big-endian 32 bit integer. + * + * @p conf type: + * @code rte_be32_t * @endcode + * + * Using this action on non-matching traffic will result in + * undefined behavior. + */ + RTE_FLOW_ACTION_TYPE_DEC_TCP_ACK, + + /** + * Set Tag. + * + * Tag is for internal flow usage only and + * is not delivered to the application. + * + * See struct rte_flow_action_set_tag. + */ + RTE_FLOW_ACTION_TYPE_SET_TAG, + + /** + * Set metadata on ingress or egress path. + * + * See struct rte_flow_action_set_meta. + */ + RTE_FLOW_ACTION_TYPE_SET_META, + + /** + * Modify IPv4 DSCP in the outermost IP header. + * + * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_IPV4, + * then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error. + * + * See struct rte_flow_action_set_dscp. + */ + RTE_FLOW_ACTION_TYPE_SET_IPV4_DSCP, + + /** + * Modify IPv6 DSCP in the outermost IP header. + * + * If flow pattern does not define a valid RTE_FLOW_ITEM_TYPE_IPV6, + * then the PMD should return a RTE_FLOW_ERROR_TYPE_ACTION error. + * + * See struct rte_flow_action_set_dscp. + */ + RTE_FLOW_ACTION_TYPE_SET_IPV6_DSCP, + + /** + * Report as aged flow if timeout passed without any matching on the + * flow. + * + * See struct rte_flow_action_age. + * See function rte_flow_get_aged_flows + * see enum RTE_ETH_EVENT_FLOW_AGED + * See struct rte_flow_query_age + */ + RTE_FLOW_ACTION_TYPE_AGE, + + /** + * The matching packets will be duplicated with specified ratio and + * applied with own set of actions with a fate action. + * + * See struct rte_flow_action_sample. + */ + RTE_FLOW_ACTION_TYPE_SAMPLE, + + /** + * Describe action shared across multiple flow rules. + * + * Allow multiple rules reference the same action by handle (see + * struct rte_flow_shared_action). + */ + RTE_FLOW_ACTION_TYPE_SHARED, + + /** + * Modify a packet header field, tag, mark or metadata. + * + * Allow the modification of an arbitrary header field via + * set, add and sub operations or copying its content into + * tag, meta or mark for future processing. + * + * See struct rte_flow_action_modify_field. + */ + RTE_FLOW_ACTION_TYPE_MODIFY_FIELD, +}; + +/** + * RTE_FLOW_ACTION_TYPE_MARK + * + * Attaches an integer value to packets and sets PKT_RX_FDIR and * PKT_RX_FDIR_ID mbuf flags. * * This value is arbitrary and application-defined. Maximum allowed value @@ -1547,6 +2308,39 @@ struct rte_flow_action_queue { uint16_t index; /**< Queue index to use. */ }; +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ACTION_TYPE_AGE + * + * Report flow as aged-out if timeout passed without any matching + * on the flow. RTE_ETH_EVENT_FLOW_AGED event is triggered when a + * port detects new aged-out flows. + * + * The flow context and the flow handle will be reported by the + * rte_flow_get_aged_flows API. + */ +struct rte_flow_action_age { + uint32_t timeout:24; /**< Time in seconds. */ + uint32_t reserved:8; /**< Reserved, must be zero. */ + void *context; + /**< The user flow context, NULL means the rte_flow pointer. */ +}; + +/** + * RTE_FLOW_ACTION_TYPE_AGE (query) + * + * Query structure to retrieve the aging status information of a + * shared AGE action, or a flow rule using the AGE action. + */ +struct rte_flow_query_age { + uint32_t reserved:6; /**< Reserved, must be zero. */ + uint32_t aged:1; /**< 1 if aging timeout expired, 0 otherwise. */ + uint32_t sec_since_last_hit_valid:1; + /**< sec_since_last_hit value is valid. */ + uint32_t sec_since_last_hit:24; /**< Seconds since last traffic hit. */ +}; /** * @warning @@ -1562,6 +2356,9 @@ struct rte_flow_action_queue { * Counters can be retrieved and reset through ``rte_flow_query()``, see * ``struct rte_flow_query_count``. * + * @deprecated Shared attribute is deprecated, use generic + * RTE_FLOW_ACTION_TYPE_SHARED action. + * * The shared flag indicates whether the counter is unique to the flow rule the * action is specified with, or whether it is a shared counter. * @@ -1574,7 +2371,8 @@ struct rte_flow_action_queue { * to all ports within that switch domain. */ struct rte_flow_action_count { - uint32_t shared:1; /**< Share counter ID with other flow rules. */ + /** @deprecated Share counter ID with other flow rules. */ + uint32_t shared:1; uint32_t reserved:31; /**< Reserved, must be zero. */ uint32_t id; /**< Counter ID. */ }; @@ -1593,6 +2391,22 @@ struct rte_flow_query_count { uint64_t bytes; /**< Number of bytes through this rule [out]. */ }; +/** + * Hash function types. + */ +enum rte_eth_hash_function { + RTE_ETH_HASH_FUNCTION_DEFAULT = 0, + RTE_ETH_HASH_FUNCTION_TOEPLITZ, /**< Toeplitz */ + RTE_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. + */ + RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ, + RTE_ETH_HASH_FUNCTION_MAX, +}; + /** * RTE_FLOW_ACTION_TYPE_RSS * @@ -1725,6 +2539,11 @@ struct rte_flow_action_meter { * direction. * * Multiple flows can be configured to use the same security session. + * + * The NULL value is allowed for security session. If security session is NULL, + * then SPI field in ESP flow item and IP addresses in flow items 'IPv4' and + * 'IPv6' will be allowed to be a range. The rule thus created can enable + * security processing on multiple flows. */ struct rte_flow_action_security { void *security_session; /**< Pointer to security session structure. */ @@ -1869,16 +2688,297 @@ struct rte_flow_action_nvgre_encap { struct rte_flow_item *definition; }; +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ACTION_TYPE_RAW_ENCAP + * + * Raw tunnel end-point encapsulation data definition. + * + * The data holds the headers definitions to be applied on the packet. + * The data must start with ETH header up to the tunnel item header itself. + * When used right after RAW_DECAP (for decapsulating L3 tunnel type for + * example MPLSoGRE) the data will just hold layer 2 header. + * + * The preserve parameter holds which bits in the packet the PMD is not allowed + * to change, this parameter can also be NULL and then the PMD is allowed + * to update any field. + * + * size holds the number of bytes in @p data and @p preserve. + */ +struct rte_flow_action_raw_encap { + uint8_t *data; /**< Encapsulation data. */ + uint8_t *preserve; /**< Bit-mask of @p data to preserve on output. */ + size_t size; /**< Size of @p data and @p preserve. */ +}; + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ACTION_TYPE_RAW_DECAP + * + * Raw tunnel end-point decapsulation data definition. + * + * The data holds the headers definitions to be removed from the packet. + * The data must start with ETH header up to the tunnel item header itself. + * When used right before RAW_DECAP (for encapsulating L3 tunnel type for + * example MPLSoGRE) the data will just hold layer 2 header. + * + * size holds the number of bytes in @p data. + */ +struct rte_flow_action_raw_decap { + uint8_t *data; /**< Encapsulation data. */ + size_t size; /**< Size of @p data and @p preserve. */ +}; + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ACTION_TYPE_SET_IPV4_SRC + * RTE_FLOW_ACTION_TYPE_SET_IPV4_DST + * + * Allows modification of IPv4 source (RTE_FLOW_ACTION_TYPE_SET_IPV4_SRC) + * and destination address (RTE_FLOW_ACTION_TYPE_SET_IPV4_DST) in the + * specified outermost IPv4 header. + */ +struct rte_flow_action_set_ipv4 { + rte_be32_t ipv4_addr; +}; + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ACTION_TYPE_SET_IPV6_SRC + * RTE_FLOW_ACTION_TYPE_SET_IPV6_DST + * + * Allows modification of IPv6 source (RTE_FLOW_ACTION_TYPE_SET_IPV6_SRC) + * and destination address (RTE_FLOW_ACTION_TYPE_SET_IPV6_DST) in the + * specified outermost IPv6 header. + */ +struct rte_flow_action_set_ipv6 { + uint8_t ipv6_addr[16]; +}; + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ACTION_TYPE_SET_TP_SRC + * RTE_FLOW_ACTION_TYPE_SET_TP_DST + * + * Allows modification of source (RTE_FLOW_ACTION_TYPE_SET_TP_SRC) + * and destination (RTE_FLOW_ACTION_TYPE_SET_TP_DST) port numbers + * in the specified outermost TCP/UDP header. + */ +struct rte_flow_action_set_tp { + rte_be16_t port; +}; + +/** + * RTE_FLOW_ACTION_TYPE_SET_TTL + * + * Set the TTL value directly for IPv4 or IPv6 + */ +struct rte_flow_action_set_ttl { + uint8_t ttl_value; +}; + +/** + * RTE_FLOW_ACTION_TYPE_SET_MAC + * + * Set MAC address from the matched flow + */ +struct rte_flow_action_set_mac { + uint8_t mac_addr[RTE_ETHER_ADDR_LEN]; +}; + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ACTION_TYPE_SET_TAG + * + * Set a tag which is a transient data used during flow matching. This is not + * delivered to application. Multiple tags are supported by specifying index. + */ +struct rte_flow_action_set_tag { + uint32_t data; + uint32_t mask; + uint8_t index; +}; + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ACTION_TYPE_SET_META + * + * Set metadata. Metadata set by mbuf metadata dynamic field with + * PKT_TX_DYNF_DATA flag on egress will be overridden by this action. On + * ingress, the metadata will be carried by mbuf metadata dynamic field + * with PKT_RX_DYNF_METADATA flag if set. The dynamic mbuf field must be + * registered in advance by rte_flow_dynf_metadata_register(). + * + * Altering partial bits is supported with mask. For bits which have never + * been set, unpredictable value will be seen depending on driver + * implementation. For loopback/hairpin packet, metadata set on Rx/Tx may + * or may not be propagated to the other path depending on HW capability. + * + * RTE_FLOW_ITEM_TYPE_META matches metadata. + */ +struct rte_flow_action_set_meta { + uint32_t data; + uint32_t mask; +}; + +/** + * RTE_FLOW_ACTION_TYPE_SET_IPV4_DSCP + * RTE_FLOW_ACTION_TYPE_SET_IPV6_DSCP + * + * Set the DSCP value for IPv4/IPv6 header. + * DSCP in low 6 bits, rest ignored. + */ +struct rte_flow_action_set_dscp { + uint8_t dscp; +}; + +/** + * RTE_FLOW_ACTION_TYPE_SHARED + * + * Opaque type returned after successfully creating a shared action. + * + * This handle can be used to manage and query the related action: + * - share it across multiple flow rules + * - update action configuration + * - query action data + * - destroy action + */ +struct rte_flow_shared_action; + +/** + * Field IDs for MODIFY_FIELD action. + */ +enum rte_flow_field_id { + RTE_FLOW_FIELD_START = 0, /**< Start of a packet. */ + RTE_FLOW_FIELD_MAC_DST, /**< Destination MAC Address. */ + RTE_FLOW_FIELD_MAC_SRC, /**< Source MAC Address. */ + RTE_FLOW_FIELD_VLAN_TYPE, /**< 802.1Q Tag Identifier. */ + RTE_FLOW_FIELD_VLAN_ID, /**< 802.1Q VLAN Identifier. */ + RTE_FLOW_FIELD_MAC_TYPE, /**< EtherType. */ + RTE_FLOW_FIELD_IPV4_DSCP, /**< IPv4 DSCP. */ + RTE_FLOW_FIELD_IPV4_TTL, /**< IPv4 Time To Live. */ + RTE_FLOW_FIELD_IPV4_SRC, /**< IPv4 Source Address. */ + RTE_FLOW_FIELD_IPV4_DST, /**< IPv4 Destination Address. */ + RTE_FLOW_FIELD_IPV6_DSCP, /**< IPv6 DSCP. */ + RTE_FLOW_FIELD_IPV6_HOPLIMIT, /**< IPv6 Hop Limit. */ + RTE_FLOW_FIELD_IPV6_SRC, /**< IPv6 Source Address. */ + RTE_FLOW_FIELD_IPV6_DST, /**< IPv6 Destination Address. */ + RTE_FLOW_FIELD_TCP_PORT_SRC, /**< TCP Source Port Number. */ + RTE_FLOW_FIELD_TCP_PORT_DST, /**< TCP Destination Port Number. */ + RTE_FLOW_FIELD_TCP_SEQ_NUM, /**< TCP Sequence Number. */ + RTE_FLOW_FIELD_TCP_ACK_NUM, /**< TCP Acknowledgment Number. */ + RTE_FLOW_FIELD_TCP_FLAGS, /**< TCP Flags. */ + RTE_FLOW_FIELD_UDP_PORT_SRC, /**< UDP Source Port Number. */ + RTE_FLOW_FIELD_UDP_PORT_DST, /**< UDP Destination Port Number. */ + RTE_FLOW_FIELD_VXLAN_VNI, /**< VXLAN Network Identifier. */ + RTE_FLOW_FIELD_GENEVE_VNI, /**< GENEVE Network Identifier. */ + RTE_FLOW_FIELD_GTP_TEID, /**< GTP Tunnel Endpoint Identifier. */ + RTE_FLOW_FIELD_TAG, /**< Tag value. */ + RTE_FLOW_FIELD_MARK, /**< Mark value. */ + RTE_FLOW_FIELD_META, /**< Metadata value. */ + RTE_FLOW_FIELD_POINTER, /**< Memory pointer. */ + RTE_FLOW_FIELD_VALUE, /**< Immediate value. */ +}; + +/** + * Field description for MODIFY_FIELD action. + */ +struct rte_flow_action_modify_data { + enum rte_flow_field_id field; /**< Field or memory type ID. */ + RTE_STD_C11 + union { + struct { + /**< Encapsulation level or tag index. */ + uint32_t level; + /**< Number of bits to skip from a field. */ + uint32_t offset; + }; + /** + * Immediate value for RTE_FLOW_FIELD_VALUE or + * memory address for RTE_FLOW_FIELD_POINTER. + */ + uint64_t value; + }; +}; + +/** + * Operation types for MODIFY_FIELD action. + */ +enum rte_flow_modify_op { + RTE_FLOW_MODIFY_SET = 0, /**< Set a new value. */ + RTE_FLOW_MODIFY_ADD, /**< Add a value to a field. */ + RTE_FLOW_MODIFY_SUB, /**< Subtract a value from a field. */ +}; + +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ACTION_TYPE_MODIFY_FIELD + * + * Modify a destination header field according to the specified + * operation. Another packet field can be used as a source as well + * as tag, mark, metadata, immediate value or a pointer to it. + */ +struct rte_flow_action_modify_field { + enum rte_flow_modify_op operation; /**< Operation to perform. */ + struct rte_flow_action_modify_data dst; /**< Destination field. */ + struct rte_flow_action_modify_data src; /**< Source field. */ + uint32_t width; /**< Number of bits to use from a source field. */ +}; + +/* Mbuf dynamic field offset for metadata. */ +extern int32_t rte_flow_dynf_metadata_offs; + +/* Mbuf dynamic field flag mask for metadata. */ +extern uint64_t rte_flow_dynf_metadata_mask; + +/* Mbuf dynamic field pointer for metadata. */ +#define RTE_FLOW_DYNF_METADATA(m) \ + RTE_MBUF_DYNFIELD((m), rte_flow_dynf_metadata_offs, uint32_t *) + +/* Mbuf dynamic flags for metadata. */ +#define PKT_RX_DYNF_METADATA (rte_flow_dynf_metadata_mask) +#define PKT_TX_DYNF_METADATA (rte_flow_dynf_metadata_mask) + +__rte_experimental +static inline uint32_t +rte_flow_dynf_metadata_get(struct rte_mbuf *m) +{ + return *RTE_FLOW_DYNF_METADATA(m); +} + +__rte_experimental +static inline void +rte_flow_dynf_metadata_set(struct rte_mbuf *m, uint32_t v) +{ + *RTE_FLOW_DYNF_METADATA(m) = v; +} + /* * Definition of a single action. * * A list of actions is terminated by a END action. * - * For simple actions without a configuration structure, conf remains NULL. + * For simple actions without a configuration object, conf remains NULL. */ struct rte_flow_action { enum rte_flow_action_type type; /**< Action type. */ - const void *conf; /**< Pointer to action configuration structure. */ + const void *conf; /**< Pointer to action configuration object. */ }; /** @@ -1889,6 +2989,28 @@ struct rte_flow_action { */ struct rte_flow; +/** + * @warning + * @b EXPERIMENTAL: this structure may change without prior notice + * + * RTE_FLOW_ACTION_TYPE_SAMPLE + * + * Adds a sample action to a matched flow. + * + * The matching packets will be duplicated with specified ratio and applied + * with own set of actions with a fate action, the sampled packet could be + * redirected to queue or port. All the packets continue processing on the + * default flow path. + * + * When the sample ratio is set to 1 then the packets will be 100% mirrored. + * Additional action list be supported to add for sampled or mirrored packets. + */ +struct rte_flow_action_sample { + uint32_t ratio; /**< packets sampled equals to '1/ratio'. */ + const struct rte_flow_action *actions; + /**< sub-action list specific for the sampling hit cases. */ +}; + /** * Verbose error types. * @@ -2043,8 +3165,112 @@ enum rte_flow_conv_op { * @code struct rte_flow_conv_rule * @endcode */ RTE_FLOW_CONV_OP_RULE, + + /** + * Convert item type to its name string. + * + * Writes a NUL-terminated string to @p dst. Like snprintf(), the + * returned value excludes the terminator which is always written + * nonetheless. + * + * - @p src type: + * @code (const void *)enum rte_flow_item_type @endcode + * - @p dst type: + * @code char * @endcode + **/ + RTE_FLOW_CONV_OP_ITEM_NAME, + + /** + * Convert action type to its name string. + * + * Writes a NUL-terminated string to @p dst. Like snprintf(), the + * returned value excludes the terminator which is always written + * nonetheless. + * + * - @p src type: + * @code (const void *)enum rte_flow_action_type @endcode + * - @p dst type: + * @code char * @endcode + **/ + RTE_FLOW_CONV_OP_ACTION_NAME, + + /** + * Convert item type to pointer to item name. + * + * Retrieves item name pointer from its type. The string itself is + * not copied; instead, a unique pointer to an internal static + * constant storage is written to @p dst. + * + * - @p src type: + * @code (const void *)enum rte_flow_item_type @endcode + * - @p dst type: + * @code const char ** @endcode + */ + RTE_FLOW_CONV_OP_ITEM_NAME_PTR, + + /** + * Convert action type to pointer to action name. + * + * Retrieves action name pointer from its type. The string itself is + * not copied; instead, a unique pointer to an internal static + * constant storage is written to @p dst. + * + * - @p src type: + * @code (const void *)enum rte_flow_action_type @endcode + * - @p dst type: + * @code const char ** @endcode + */ + RTE_FLOW_CONV_OP_ACTION_NAME_PTR, }; +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Dump hardware internal representation information of + * rte flow to file. + * + * @param[in] port_id + * The port identifier of the Ethernet device. + * @param[in] file + * A pointer to a file for output. + * @param[out] error + * Perform verbose error reporting if not NULL. PMDs initialize this + * structure in case of error only. + * @return + * 0 on success, a nagative value otherwise. + */ +__rte_experimental +int +rte_flow_dev_dump(uint16_t port_id, FILE *file, struct rte_flow_error *error); + +/** + * Check if mbuf dynamic field for metadata is registered. + * + * @return + * True if registered, false otherwise. + */ +__rte_experimental +static inline int +rte_flow_dynf_metadata_avail(void) +{ + return !!rte_flow_dynf_metadata_mask; +} + +/** + * Register mbuf dynamic field and flag for metadata. + * + * This function must be called prior to use SET_META action in order to + * register the dynamic mbuf field. Otherwise, the data cannot be delivered to + * application. + * + * @return + * 0 on success, a negative errno value otherwise and rte_errno is set. + */ +__rte_experimental +int +rte_flow_dynf_metadata_register(void); + /** * Check whether a flow rule can be created on a given port. * @@ -2276,6 +3502,7 @@ rte_flow_error_set(struct rte_flow_error *error, const char *message); /** + * @deprecated * @see rte_flow_copy() */ struct rte_flow_desc { @@ -2287,10 +3514,13 @@ struct rte_flow_desc { }; /** + * @deprecated * Copy an rte_flow rule description. * * This interface is kept for compatibility with older applications but is - * implemented as a wrapper to rte_flow_conv(). + * implemented as a wrapper to rte_flow_conv(). It is deprecated due to its + * lack of flexibility and reliance on a type unusable with C++ programs + * (struct rte_flow_desc). * * @param[in] fd * Flow rule description. @@ -2309,6 +3539,7 @@ struct rte_flow_desc { * If len is lower than the size of the flow, the number of bytes that would * have been written to desc had it been sufficient. Nothing is written. */ +__rte_deprecated size_t rte_flow_copy(struct rte_flow_desc *fd, size_t len, const struct rte_flow_attr *attr, @@ -2363,6 +3594,388 @@ rte_flow_conv(enum rte_flow_conv_op op, const void *src, struct rte_flow_error *error); +/** + * Get aged-out flows of a given port. + * + * RTE_ETH_EVENT_FLOW_AGED event will be triggered when at least one new aged + * out flow was detected after the last call to rte_flow_get_aged_flows. + * This function can be called to get the aged flows usynchronously from the + * event callback or synchronously regardless the event. + * This is not safe to call rte_flow_get_aged_flows function with other flow + * functions from multiple threads simultaneously. + * + * @param port_id + * Port identifier of Ethernet device. + * @param[in, out] contexts + * The address of an array of pointers to the aged-out flows contexts. + * @param[in] nb_contexts + * The length of context array pointers. + * @param[out] error + * Perform verbose error reporting if not NULL. Initialized in case of + * error only. + * + * @return + * if nb_contexts is 0, return the amount of all aged contexts. + * if nb_contexts is not 0 , return the amount of aged flows reported + * in the context array, otherwise negative errno value. + * + * @see rte_flow_action_age + * @see RTE_ETH_EVENT_FLOW_AGED + */ +__rte_experimental +int +rte_flow_get_aged_flows(uint16_t port_id, void **contexts, + uint32_t nb_contexts, struct rte_flow_error *error); + +/** + * Specify shared action configuration + */ +struct rte_flow_shared_action_conf { + /** + * Flow direction for shared action configuration. + * + * Shared action should be valid at least for one flow direction, + * otherwise it is invalid for both ingress and egress rules. + */ + uint32_t ingress:1; + /**< Action valid for rules applied to ingress traffic. */ + uint32_t egress:1; + /**< Action valid for rules applied to egress traffic. */ + + /** + * When set to 1, indicates that the action is valid for + * transfer traffic; otherwise, for non-transfer traffic. + * + * See struct rte_flow_attr. + */ + uint32_t transfer:1; +}; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Create shared action for reuse in multiple flow rules. + * The created shared action has single state and configuration + * across all flow rules using it. + * + * @param[in] port_id + * The port identifier of the Ethernet device. + * @param[in] conf + * Shared action configuration. + * @param[in] action + * Action configuration for shared action creation. + * @param[out] error + * Perform verbose error reporting if not NULL. PMDs initialize this + * structure in case of error only. + * @return + * A valid handle in case of success, NULL otherwise and rte_errno is set + * to one of the error codes defined: + * - (ENODEV) if *port_id* invalid. + * - (ENOSYS) if underlying device does not support this functionality. + * - (EIO) if underlying device is removed. + * - (EINVAL) if *action* invalid. + * - (ENOTSUP) if *action* valid but unsupported. + */ +__rte_experimental +struct rte_flow_shared_action * +rte_flow_shared_action_create(uint16_t port_id, + const struct rte_flow_shared_action_conf *conf, + const struct rte_flow_action *action, + struct rte_flow_error *error); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Destroy the shared action by handle. + * + * @param[in] port_id + * The port identifier of the Ethernet device. + * @param[in] action + * Handle for the shared action to be destroyed. + * @param[out] error + * Perform verbose error reporting if not NULL. PMDs initialize this + * structure in case of error only. + * @return + * - (0) if success. + * - (-ENODEV) if *port_id* invalid. + * - (-ENOSYS) if underlying device does not support this functionality. + * - (-EIO) if underlying device is removed. + * - (-ENOENT) if action pointed by *action* handle was not found. + * - (-EBUSY) if action pointed by *action* handle still used by some rules + * rte_errno is also set. + */ +__rte_experimental +int +rte_flow_shared_action_destroy(uint16_t port_id, + struct rte_flow_shared_action *action, + struct rte_flow_error *error); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Update in-place the shared action configuration pointed by *action* handle + * with the configuration provided as *update* argument. + * The update of the shared action configuration effects all flow rules reusing + * the action via handle. + * + * @param[in] port_id + * The port identifier of the Ethernet device. + * @param[in] action + * Handle for the shared action to be updated. + * @param[in] update + * Action specification used to modify the action pointed by handle. + * *update* should be of same type with the action pointed by the *action* + * handle argument, otherwise considered as invalid. + * @param[out] error + * Perform verbose error reporting if not NULL. PMDs initialize this + * structure in case of error only. + * @return + * - (0) if success. + * - (-ENODEV) if *port_id* invalid. + * - (-ENOSYS) if underlying device does not support this functionality. + * - (-EIO) if underlying device is removed. + * - (-EINVAL) if *update* invalid. + * - (-ENOTSUP) if *update* valid but unsupported. + * - (-ENOENT) if action pointed by *ctx* was not found. + * rte_errno is also set. + */ +__rte_experimental +int +rte_flow_shared_action_update(uint16_t port_id, + struct rte_flow_shared_action *action, + const struct rte_flow_action *update, + struct rte_flow_error *error); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Query the shared action by handle. + * + * Retrieve action-specific data such as counters. + * Data is gathered by special action which may be present/referenced in + * more than one flow rule definition. + * + * \see RTE_FLOW_ACTION_TYPE_COUNT + * + * @param port_id + * Port identifier of Ethernet device. + * @param[in] action + * Handle for the shared action to query. + * @param[in, out] data + * Pointer to storage for the associated query data type. + * @param[out] error + * Perform verbose error reporting if not NULL. PMDs initialize this + * structure in case of error only. + * + * @return + * 0 on success, a negative errno value otherwise and rte_errno is set. + */ +__rte_experimental +int +rte_flow_shared_action_query(uint16_t port_id, + const struct rte_flow_shared_action *action, + void *data, + struct rte_flow_error *error); + +/* Tunnel has a type and the key information. */ +struct rte_flow_tunnel { + /** + * Tunnel type, for example RTE_FLOW_ITEM_TYPE_VXLAN, + * RTE_FLOW_ITEM_TYPE_NVGRE etc. + */ + enum rte_flow_item_type type; + uint64_t tun_id; /**< Tunnel identification. */ + + RTE_STD_C11 + union { + struct { + rte_be32_t src_addr; /**< IPv4 source address. */ + rte_be32_t dst_addr; /**< IPv4 destination address. */ + } ipv4; + struct { + uint8_t src_addr[16]; /**< IPv6 source address. */ + uint8_t dst_addr[16]; /**< IPv6 destination address. */ + } ipv6; + }; + rte_be16_t tp_src; /**< Tunnel port source. */ + rte_be16_t tp_dst; /**< Tunnel port destination. */ + uint16_t tun_flags; /**< Tunnel flags. */ + + bool is_ipv6; /**< True for valid IPv6 fields. Otherwise IPv4. */ + + /** + * the following members are required to restore packet + * after miss + */ + uint8_t tos; /**< TOS for IPv4, TC for IPv6. */ + uint8_t ttl; /**< TTL for IPv4, HL for IPv6. */ + uint32_t label; /**< Flow Label for IPv6. */ +}; + +/** + * Indicate that the packet has a tunnel. + */ +#define RTE_FLOW_RESTORE_INFO_TUNNEL (1ULL << 0) + +/** + * Indicate that the packet has a non decapsulated tunnel header. + */ +#define RTE_FLOW_RESTORE_INFO_ENCAPSULATED (1ULL << 1) + +/** + * Indicate that the packet has a group_id. + */ +#define RTE_FLOW_RESTORE_INFO_GROUP_ID (1ULL << 2) + +/** + * Restore information structure to communicate the current packet processing + * state when some of the processing pipeline is done in hardware and should + * continue in software. + */ +struct rte_flow_restore_info { + /** + * Bitwise flags (RTE_FLOW_RESTORE_INFO_*) to indicate validation of + * other fields in struct rte_flow_restore_info. + */ + uint64_t flags; + uint32_t group_id; /**< Group ID where packed missed */ + struct rte_flow_tunnel tunnel; /**< Tunnel information. */ +}; + +/** + * Allocate an array of actions to be used in rte_flow_create, to implement + * tunnel-decap-set for the given tunnel. + * Sample usage: + * actions vxlan_decap / tunnel-decap-set(tunnel properties) / + * jump group 0 / end + * + * @param port_id + * Port identifier of Ethernet device. + * @param[in] tunnel + * Tunnel properties. + * @param[out] actions + * Array of actions to be allocated by the PMD. This array should be + * concatenated with the actions array provided to rte_flow_create. + * @param[out] num_of_actions + * Number of actions allocated. + * @param[out] error + * Perform verbose error reporting if not NULL. PMDs initialize this + * structure in case of error only. + * + * @return + * 0 on success, a negative errno value otherwise and rte_errno is set. + */ +__rte_experimental +int +rte_flow_tunnel_decap_set(uint16_t port_id, + struct rte_flow_tunnel *tunnel, + struct rte_flow_action **actions, + uint32_t *num_of_actions, + struct rte_flow_error *error); + +/** + * Allocate an array of items to be used in rte_flow_create, to implement + * tunnel-match for the given tunnel. + * Sample usage: + * pattern tunnel-match(tunnel properties) / outer-header-matches / + * inner-header-matches / end + * + * @param port_id + * Port identifier of Ethernet device. + * @param[in] tunnel + * Tunnel properties. + * @param[out] items + * Array of items to be allocated by the PMD. This array should be + * concatenated with the items array provided to rte_flow_create. + * @param[out] num_of_items + * Number of items allocated. + * @param[out] error + * Perform verbose error reporting if not NULL. PMDs initialize this + * structure in case of error only. + * + * @return + * 0 on success, a negative errno value otherwise and rte_errno is set. + */ +__rte_experimental +int +rte_flow_tunnel_match(uint16_t port_id, + struct rte_flow_tunnel *tunnel, + struct rte_flow_item **items, + uint32_t *num_of_items, + struct rte_flow_error *error); + +/** + * Populate the current packet processing state, if exists, for the given mbuf. + * + * @param port_id + * Port identifier of Ethernet device. + * @param[in] m + * Mbuf struct. + * @param[out] info + * Restore information. Upon success contains the HW state. + * @param[out] error + * Perform verbose error reporting if not NULL. PMDs initialize this + * structure in case of error only. + * + * @return + * 0 on success, a negative errno value otherwise and rte_errno is set. + */ +__rte_experimental +int +rte_flow_get_restore_info(uint16_t port_id, + struct rte_mbuf *m, + struct rte_flow_restore_info *info, + struct rte_flow_error *error); + +/** + * Release the action array as allocated by rte_flow_tunnel_decap_set. + * + * @param port_id + * Port identifier of Ethernet device. + * @param[in] actions + * Array of actions to be released. + * @param[in] num_of_actions + * Number of elements in actions array. + * @param[out] error + * Perform verbose error reporting if not NULL. PMDs initialize this + * structure in case of error only. + * + * @return + * 0 on success, a negative errno value otherwise and rte_errno is set. + */ +__rte_experimental +int +rte_flow_tunnel_action_decap_release(uint16_t port_id, + struct rte_flow_action *actions, + uint32_t num_of_actions, + struct rte_flow_error *error); + +/** + * Release the item array as allocated by rte_flow_tunnel_match. + * + * @param port_id + * Port identifier of Ethernet device. + * @param[in] items + * Array of items to be released. + * @param[in] num_of_items + * Number of elements in item array. + * @param[out] error + * Perform verbose error reporting if not NULL. PMDs initialize this + * structure in case of error only. + * + * @return + * 0 on success, a negative errno value otherwise and rte_errno is set. + */ +__rte_experimental +int +rte_flow_tunnel_item_release(uint16_t port_id, + struct rte_flow_item *items, + uint32_t num_of_items, + struct rte_flow_error *error); #ifdef __cplusplus } #endif