Hi Vithal Exactly! Some types of NIC (e.g. i40e) support it.
Regards, Helin > -----Original Message----- > From: Vithal S Mohare [mailto:vmohare at arubanetworks.com] > Sent: Tuesday, January 27, 2015 12:31 PM > To: Zhang, Helin > Subject: RE: [dpdk-dev] [PATCH 5/7] ethdev: unification of flow types > > Hi Helin, > > I see a new type *_L2_PAYLOAD added for RSS types. Is this for spraying of > pure L2 packets (non-ip)? > > Thanks, > -Vithal > > -----Original Message----- > From: dev [mailto:dev-bounces at dpdk.org] On Behalf Of Helin Zhang > Sent: Monday, January 19, 2015 12:26 PM > To: dev at dpdk.org > Subject: [dpdk-dev] [PATCH 5/7] ethdev: unification of flow types > > Flow types was defined actually for i40e hardware specifically, and wasn't > able > to be used for defining RSS offload types of all PMDs. It removed the enum > flow > types, and uses macros instead with new names. The new macros can be used > for defining RSS offload types later. Also modifications are made in i40e and > testpmd accordingly. > > Signed-off-by: Helin Zhang <helin.zhang at intel.com> > --- > app/test-pmd/cmdline.c | 88 > ++++++++++++++++++++++++--------------- > app/test-pmd/config.c | 71 +++++++++++++++++++++---------- > lib/librte_ether/rte_eth_ctrl.h | 55 ++++++++++++++---------- > lib/librte_pmd_i40e/i40e_ethdev.c | 68 +++++++++++++++++------------- > lib/librte_pmd_i40e/i40e_ethdev.h | 34 +++++++-------- > lib/librte_pmd_i40e/i40e_fdir.c | 84 ++++++++++++++++++------------------- > 6 files changed, 235 insertions(+), 165 deletions(-) > > diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index > 4618b92..80b9c32 100644 > --- a/app/test-pmd/cmdline.c > +++ b/app/test-pmd/cmdline.c > @@ -707,7 +707,7 @@ static void cmd_help_long_parsed(void > *parsed_result, > " get info of a flex filter.\n\n" > > "flow_director_filter (port_id) (add|del)" > - " flow (ip4|ip4-frag|ip6|ip6-frag)" > + " flow (ipv4-other|ipv4-frag|ipv6-other|ipv6-frag)" > " src (src_ip_address) dst (dst_ip_address)" > " flexbytes (flexbytes_value)" > " (drop|fwd) queue (queue_id) fd_id (fd_id_value)\n" > @@ -733,7 +733,8 @@ static void cmd_help_long_parsed(void > *parsed_result, > " Flush all flow director entries of a device.\n\n" > > "flow_director_flex_mask (port_id)" > - " flow > (ip4|ip4-frag|tcp4|udp4|sctp4|ip6|ip6-frag|tcp6|udp6|sctp6|all)" > + " flow > (ipv4-other|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|" > + "ipv6-other|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|all)" > " (mask)\n" > " Configure mask of flex payload.\n\n" > > @@ -8158,31 +8159,34 @@ parse_flexbytes(const char *q_arg, uint8_t > *flexbytes, uint16_t max_num) > return ret; > } > > -static enum rte_eth_flow_type > +static uint16_t > str2flowtype(char *string) > { > uint8_t i = 0; > static const struct { > char str[32]; > - enum rte_eth_flow_type type; > + uint16_t type; > } flowtype_str[] = { > - {"ip4", RTE_ETH_FLOW_TYPE_IPV4_OTHER}, > - {"ip4-frag", RTE_ETH_FLOW_TYPE_FRAG_IPV4}, > - {"udp4", RTE_ETH_FLOW_TYPE_UDPV4}, > - {"tcp4", RTE_ETH_FLOW_TYPE_TCPV4}, > - {"sctp4", RTE_ETH_FLOW_TYPE_SCTPV4}, > - {"ip6", RTE_ETH_FLOW_TYPE_IPV6_OTHER}, > - {"ip6-frag", RTE_ETH_FLOW_TYPE_FRAG_IPV6}, > - {"udp6", RTE_ETH_FLOW_TYPE_UDPV6}, > - {"tcp6", RTE_ETH_FLOW_TYPE_TCPV6}, > - {"sctp6", RTE_ETH_FLOW_TYPE_TCPV6}, > + {"ipv4", ETH_FLOW_TYPE_IPV4}, > + {"ipv4-frag", ETH_FLOW_TYPE_FRAG_IPV4}, > + {"ipv4-tcp", ETH_FLOW_TYPE_NONFRAG_IPV4_TCP}, > + {"ipv4-udp", ETH_FLOW_TYPE_NONFRAG_IPV4_UDP}, > + {"ipv4-sctp", ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP}, > + {"ipv4-other", ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER}, > + {"ipv6", ETH_FLOW_TYPE_IPV6}, > + {"ipv6-frag", ETH_FLOW_TYPE_FRAG_IPV6}, > + {"ipv6-tcp", ETH_FLOW_TYPE_NONFRAG_IPV6_TCP}, > + {"ipv6-udp", ETH_FLOW_TYPE_NONFRAG_IPV6_UDP}, > + {"ipv6-sctp", ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP}, > + {"ipv6-other", ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER}, > + {"l2_payload", ETH_FLOW_TYPE_L2_PAYLOAD}, > }; > > for (i = 0; i < RTE_DIM(flowtype_str); i++) { > if (!strcmp(flowtype_str[i].str, string)) > return flowtype_str[i].type; > } > - return RTE_ETH_FLOW_TYPE_NONE; > + return ETH_FLOW_TYPE_UNKNOWN; > } > > #define IPV4_ADDR_TO_UINT(ip_addr, ip) \ @@ -8235,9 +8239,9 @@ > cmd_flow_director_filter_parsed(void *parsed_result, > > entry.input.flow_type = str2flowtype(res->flow_type); > switch (entry.input.flow_type) { > - case RTE_ETH_FLOW_TYPE_IPV4_OTHER: > - case RTE_ETH_FLOW_TYPE_UDPV4: > - case RTE_ETH_FLOW_TYPE_TCPV4: > + case ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER: > + case ETH_FLOW_TYPE_NONFRAG_IPV4_UDP: > + case ETH_FLOW_TYPE_NONFRAG_IPV4_TCP: > IPV4_ADDR_TO_UINT(res->ip_dst, > entry.input.flow.ip4_flow.dst_ip); > IPV4_ADDR_TO_UINT(res->ip_src, > @@ -8248,7 +8252,7 @@ cmd_flow_director_filter_parsed(void > *parsed_result, > entry.input.flow.udp4_flow.src_port = > rte_cpu_to_be_16(res->port_src); > break; > - case RTE_ETH_FLOW_TYPE_SCTPV4: > + case ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP: > IPV4_ADDR_TO_UINT(res->ip_dst, > entry.input.flow.sctp4_flow.ip.dst_ip); > IPV4_ADDR_TO_UINT(res->ip_src, > @@ -8257,9 +8261,9 @@ cmd_flow_director_filter_parsed(void > *parsed_result, > entry.input.flow.sctp4_flow.verify_tag = > rte_cpu_to_be_32(res->verify_tag_value); > break; > - case RTE_ETH_FLOW_TYPE_IPV6_OTHER: > - case RTE_ETH_FLOW_TYPE_UDPV6: > - case RTE_ETH_FLOW_TYPE_TCPV6: > + case ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER: > + case ETH_FLOW_TYPE_NONFRAG_IPV6_UDP: > + case ETH_FLOW_TYPE_NONFRAG_IPV6_TCP: > IPV6_ADDR_TO_ARRAY(res->ip_dst, > entry.input.flow.ipv6_flow.dst_ip); > IPV6_ADDR_TO_ARRAY(res->ip_src, > @@ -8270,7 +8274,7 @@ cmd_flow_director_filter_parsed(void > *parsed_result, > entry.input.flow.udp6_flow.src_port = > rte_cpu_to_be_16(res->port_src); > break; > - case RTE_ETH_FLOW_TYPE_SCTPV6: > + case ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP: > IPV6_ADDR_TO_ARRAY(res->ip_dst, > entry.input.flow.sctp6_flow.ip.dst_ip); > IPV6_ADDR_TO_ARRAY(res->ip_src, > @@ -8321,9 +8325,8 @@ cmdline_parse_token_string_t > cmd_flow_director_flow = > flow, "flow"); > cmdline_parse_token_string_t cmd_flow_director_flow_type = > TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, > - flow_type, > - "ip4#ip4-frag#tcp4#udp4#sctp4#" > - "ip6#ip6-frag#tcp6#udp6#sctp6"); > + flow_type, "ipv4-other#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#" > + "ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp"); > cmdline_parse_token_string_t cmd_flow_director_src = > TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, > src, "src"); > @@ -8511,7 +8514,9 @@ cmd_flow_director_flex_mask_parsed(void > *parsed_result, > struct cmd_flow_director_flex_mask_result *res = parsed_result; > struct rte_eth_fdir_flex_mask flex_mask; > struct rte_port *port; > - enum rte_eth_flow_type i; > + struct rte_eth_fdir_info fdir_info; > + uint32_t flow_type_mask; > + uint16_t i; > int ret; > > if (res->port_id > nb_ports) { > @@ -8534,10 +8539,23 @@ cmd_flow_director_flex_mask_parsed(void > *parsed_result, > printf("error: Cannot parse mask input.\n"); > return; > } > + > + memset(&fdir_info, 0, sizeof(fdir_info)); > + ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR, > + RTE_ETH_FILTER_INFO, &fdir_info); > + if (ret < 0) { > + printf("Cannot get FDir filter info\n"); > + return; > + } > + flow_type_mask = fdir_info.flow_types_mask[0]; > if (!strcmp(res->flow_type, "all")) { > - for (i = RTE_ETH_FLOW_TYPE_UDPV4; > - i <= RTE_ETH_FLOW_TYPE_FRAG_IPV6; > - i++) { > + if (!flow_type_mask) { > + printf("No flow type supported\n"); > + return; > + } > + for (i = ETH_FLOW_TYPE_UNKNOWN; i < ETH_FLOW_TYPE_MAX; i++) > { > + if (!(flow_type_mask & (1 << i))) > + continue; > flex_mask.flow_type = i; > fdir_set_flex_mask(res->port_id, &flex_mask); > } > @@ -8545,6 +8563,11 @@ cmd_flow_director_flex_mask_parsed(void > *parsed_result, > return; > } > flex_mask.flow_type = str2flowtype(res->flow_type); > + if (!(flow_type_mask & (1 << flex_mask.flow_type))) { > + printf("Flow type %s not supported on port %d\n", > + res->flow_type, res->port_id); > + return; > + } > fdir_set_flex_mask(res->port_id, &flex_mask); > cmd_reconfig_device_queue(res->port_id, 1, 1); } @@ -8561,9 +8584,8 > @@ cmdline_parse_token_string_t cmd_flow_director_flexmask_flow = > flow, "flow"); > cmdline_parse_token_string_t cmd_flow_director_flexmask_flow_type = > TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result, > - flow_type, > - "ip4#ip4-frag#tcp4#udp4#sctp4#" > - "ip6#ip6-frag#tcp6#udp6#sctp6#all"); > + flow_type, "ipv4-other#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#" > + "ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#all"); > cmdline_parse_token_string_t cmd_flow_director_flexmask_mask = > TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result, > mask, NULL); > diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c index > 87dedf9..4c61a07 100644 > --- a/app/test-pmd/config.c > +++ b/app/test-pmd/config.c > @@ -96,19 +96,7 @@ > > #include "testpmd.h" > > -static const char *flowtype_str[RTE_ETH_FLOW_TYPE_MAX] = { > - NULL, > - "udp4", > - "tcp4", > - "sctp4", > - "ip4", > - "ip4-frag", > - "udp6", > - "tcp6", > - "sctp6", > - "ip6", > - "ip6-frag", > -}; > +static char *flowtype_to_str(uint16_t flow_type); > > static void > print_ethaddr(const char *name, struct ether_addr *eth_addr) @@ -1843,15 > +1831,50 @@ print_fdir_flex_payload(struct rte_eth_fdir_flex_conf *flex_conf) > printf("\n"); > } > > +static char * > +flowtype_to_str(uint16_t flow_type) > +{ > + struct flow_type_info { > + char str[32]; > + uint16_t ftype; > + }; > + > + uint8_t i; > + static struct flow_type_info flowtype_str_table[] = { > + {"ipv4", ETH_FLOW_TYPE_IPV4}, > + {"ipv4-frag", ETH_FLOW_TYPE_FRAG_IPV4}, > + {"ipv4-tcp", ETH_FLOW_TYPE_NONFRAG_IPV4_TCP}, > + {"ipv4-udp", ETH_FLOW_TYPE_NONFRAG_IPV4_UDP}, > + {"ipv4-sctp", ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP}, > + {"ipv4-other", ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER}, > + {"ipv6", ETH_FLOW_TYPE_IPV6}, > + {"ipv6-frag", ETH_FLOW_TYPE_FRAG_IPV6}, > + {"ipv6-tcp", ETH_FLOW_TYPE_NONFRAG_IPV6_TCP}, > + {"ipv6-udp", ETH_FLOW_TYPE_NONFRAG_IPV6_UDP}, > + {"ipv6-sctp", ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP}, > + {"ipv6-other", ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER}, > + {"l2_payload", ETH_FLOW_TYPE_L2_PAYLOAD}, > + }; > + > + for (i = 0; i < RTE_DIM(flowtype_str_table); i++) { > + if (flowtype_str_table[i].ftype == flow_type) > + return flowtype_str_table[i].str; > + } > + > + return NULL; > +} > + > static inline void > print_fdir_flex_mask(struct rte_eth_fdir_flex_conf *flex_conf) { > struct rte_eth_fdir_flex_mask *mask; > int i, j; > + char *p; > > for (i = 0; i < flex_conf->nb_flexmasks; i++) { > mask = &flex_conf->flex_mask[i]; > - printf("\n %s:\t", flowtype_str[mask->flow_type]); > + p = flowtype_to_str(mask->flow_type); > + printf("\n %s:\t", p ? p : "unknown"); > for (j = 0; j < RTE_ETH_FDIR_MAX_FLEXLEN; j++) > printf(" %02x", mask->mask[j]); > } > @@ -1861,13 +1884,17 @@ print_fdir_flex_mask(struct > rte_eth_fdir_flex_conf *flex_conf) static inline void > print_fdir_flow_type(uint32_t flow_types_mask) { > - int i = 0; > + int i; > + char *p; > > - for (i = RTE_ETH_FLOW_TYPE_UDPV4; > - i <= RTE_ETH_FLOW_TYPE_FRAG_IPV6; > - i++) { > - if (flow_types_mask & (1 << i)) > - printf(" %s", flowtype_str[i]); > + for (i = ETH_FLOW_TYPE_UNKNOWN; i < ETH_FLOW_TYPE_MAX; i++) { > + if (!(flow_types_mask & (1 << i))) > + continue; > + p = flowtype_to_str(i); > + if (p) > + printf(" %s", p); > + else > + printf(" unknown"); > } > printf("\n"); > } > @@ -2028,13 +2055,13 @@ fdir_set_flex_mask(portid_t port_id, struct > rte_eth_fdir_flex_mask *cfg) > > port = &ports[port_id]; > flex_conf = &port->dev_conf.fdir_conf.flex_conf; > - for (i = 0; i < RTE_ETH_FLOW_TYPE_MAX; i++) { > + for (i = 0; i < ETH_FLOW_TYPE_MAX; i++) { > if (cfg->flow_type == flex_conf->flex_mask[i].flow_type) { > idx = i; > break; > } > } > - if (i >= RTE_ETH_FLOW_TYPE_MAX) { > + if (i >= ETH_FLOW_TYPE_MAX) { > if (flex_conf->nb_flexmasks < RTE_DIM(flex_conf->flex_mask)) { > idx = flex_conf->nb_flexmasks; > flex_conf->nb_flexmasks++; > diff --git a/lib/librte_ether/rte_eth_ctrl.h > b/lib/librte_ether/rte_eth_ctrl.h index > 1c15ed0..f2b39fc 100644 > --- a/lib/librte_ether/rte_eth_ctrl.h > +++ b/lib/librte_ether/rte_eth_ctrl.h > @@ -46,6 +46,35 @@ > extern "C" { > #endif > > +/* > + * A packet can be identified by hardware as different flow types. > +Different > + * NIC hardwares may support different flow types. > + * Basically, the NIC hardware identifies the flow type as deep > +protocol as > + * possible, and exclusively. For example, if a packet is identified as > + * 'ETH_FLOW_TYPE_NONFRAG_IPV4_TCP', it will not be any of other flow > +types, > + * though it is an actual IPV4 packet. > + * Note that the flow types are used to define RSS offload types in > + * rte_ethdev.h. > + */ > +#define ETH_FLOW_TYPE_UNKNOWN 0 > +#define ETH_FLOW_TYPE_IPV4 1 > +#define ETH_FLOW_TYPE_FRAG_IPV4 2 > +#define ETH_FLOW_TYPE_NONFRAG_IPV4_TCP 3 > +#define ETH_FLOW_TYPE_NONFRAG_IPV4_UDP 4 > +#define ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP 5 #define > +ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER 6 > +#define ETH_FLOW_TYPE_IPV6 7 > +#define ETH_FLOW_TYPE_FRAG_IPV6 8 > +#define ETH_FLOW_TYPE_NONFRAG_IPV6_TCP 9 > +#define ETH_FLOW_TYPE_NONFRAG_IPV6_UDP 10 > +#define ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP 11 #define > +ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER 12 > +#define ETH_FLOW_TYPE_L2_PAYLOAD 13 > +#define ETH_FLOW_TYPE_IPV6_EX 14 > +#define ETH_FLOW_TYPE_IPV6_TCP_EX 15 > +#define ETH_FLOW_TYPE_IPV6_UDP_EX 16 > +#define ETH_FLOW_TYPE_MAX 17 > + > /** > * Feature filter types > */ > @@ -179,24 +208,6 @@ struct rte_eth_tunnel_filter_conf { > #define RTE_ETH_FDIR_MAX_FLEXLEN 16 /** < Max length of > flexbytes. */ > > /** > - * Flow type > - */ > -enum rte_eth_flow_type { > - RTE_ETH_FLOW_TYPE_NONE = 0, > - RTE_ETH_FLOW_TYPE_UDPV4, > - RTE_ETH_FLOW_TYPE_TCPV4, > - RTE_ETH_FLOW_TYPE_SCTPV4, > - RTE_ETH_FLOW_TYPE_IPV4_OTHER, > - RTE_ETH_FLOW_TYPE_FRAG_IPV4, > - RTE_ETH_FLOW_TYPE_UDPV6, > - RTE_ETH_FLOW_TYPE_TCPV6, > - RTE_ETH_FLOW_TYPE_SCTPV6, > - RTE_ETH_FLOW_TYPE_IPV6_OTHER, > - RTE_ETH_FLOW_TYPE_FRAG_IPV6, > - RTE_ETH_FLOW_TYPE_MAX = 64, > -}; > - > -/** > * A structure used to define the input for IPV4 flow > */ > struct rte_eth_ipv4_flow { > @@ -291,7 +302,7 @@ struct rte_eth_fdir_flow_ext { > * A structure used to define the input for a flow director filter entry > */ > struct rte_eth_fdir_input { > - enum rte_eth_flow_type flow_type; /**< Type of flow */ > + uint16_t flow_type; /**< Type of flow */ > union rte_eth_fdir_flow flow; > /**< Flow fields to match, dependent on flow_type */ > struct rte_eth_fdir_flow_ext flow_ext; @@ -371,7 +382,7 @@ struct > rte_eth_flex_payload_cfg { > * for each flow type > */ > struct rte_eth_fdir_flex_mask { > - enum rte_eth_flow_type flow_type; /**< Flow type */ > + uint16_t flow_type; /**< Flow type */ > uint8_t mask[RTE_ETH_FDIR_MAX_FLEXLEN]; > /**< Mask for the whole flexible payload */ }; @@ -385,7 +396,7 @@ > struct rte_eth_fdir_flex_conf { > uint16_t nb_flexmasks; /**< The number of following mask */ > struct rte_eth_flex_payload_cfg flex_set[RTE_ETH_PAYLOAD_MAX]; > /**< Flex payload configuration for each payload type */ > - struct rte_eth_fdir_flex_mask flex_mask[RTE_ETH_FLOW_TYPE_MAX]; > + struct rte_eth_fdir_flex_mask flex_mask[ETH_FLOW_TYPE_MAX]; > /**< Flex mask configuration for each flow type */ }; > > @@ -400,7 +411,7 @@ enum rte_fdir_mode { > > #define UINT32_BIT (CHAR_BIT * sizeof(uint32_t)) #define > RTE_FLOW_TYPE_MASK_ARRAY_SIZE \ > - (RTE_ALIGN(RTE_ETH_FLOW_TYPE_MAX, UINT32_BIT)/UINT32_BIT) > + (RTE_ALIGN(ETH_FLOW_TYPE_MAX, UINT32_BIT)/UINT32_BIT) > > /** > * A structure used to get the information of flow director filter. > diff --git a/lib/librte_pmd_i40e/i40e_ethdev.c > b/lib/librte_pmd_i40e/i40e_ethdev.c > index b47a3d2..de1eff4 100644 > --- a/lib/librte_pmd_i40e/i40e_ethdev.c > +++ b/lib/librte_pmd_i40e/i40e_ethdev.c > @@ -5261,46 +5261,56 @@ i40e_dev_filter_ctrl(struct rte_eth_dev *dev, } > > enum i40e_filter_pctype > -i40e_flowtype_to_pctype(enum rte_eth_flow_type flow_type) > +i40e_flowtype_to_pctype(uint16_t flow_type) > { > static const enum i40e_filter_pctype pctype_table[] = { > - [RTE_ETH_FLOW_TYPE_UDPV4] = > I40E_FILTER_PCTYPE_NONF_IPV4_UDP, > - [RTE_ETH_FLOW_TYPE_TCPV4] = > I40E_FILTER_PCTYPE_NONF_IPV4_TCP, > - [RTE_ETH_FLOW_TYPE_SCTPV4] = > I40E_FILTER_PCTYPE_NONF_IPV4_SCTP, > - [RTE_ETH_FLOW_TYPE_IPV4_OTHER] = > - I40E_FILTER_PCTYPE_NONF_IPV4_OTHER, > - [RTE_ETH_FLOW_TYPE_FRAG_IPV4] = > - I40E_FILTER_PCTYPE_FRAG_IPV4, > - [RTE_ETH_FLOW_TYPE_UDPV6] = > I40E_FILTER_PCTYPE_NONF_IPV6_UDP, > - [RTE_ETH_FLOW_TYPE_TCPV6] = > I40E_FILTER_PCTYPE_NONF_IPV6_TCP, > - [RTE_ETH_FLOW_TYPE_SCTPV6] = > I40E_FILTER_PCTYPE_NONF_IPV6_SCTP, > - [RTE_ETH_FLOW_TYPE_IPV6_OTHER] = > - I40E_FILTER_PCTYPE_NONF_IPV6_OTHER, > - [RTE_ETH_FLOW_TYPE_FRAG_IPV6] = > - I40E_FILTER_PCTYPE_FRAG_IPV6, > + [ETH_FLOW_TYPE_FRAG_IPV4] = I40E_FILTER_PCTYPE_FRAG_IPV4, > + [ETH_FLOW_TYPE_NONFRAG_IPV4_UDP] = > + I40E_FILTER_PCTYPE_NONF_IPV4_UDP, > + [ETH_FLOW_TYPE_NONFRAG_IPV4_TCP] = > + I40E_FILTER_PCTYPE_NONF_IPV4_TCP, > + [ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP] = > + I40E_FILTER_PCTYPE_NONF_IPV4_SCTP, > + [ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER] = > + I40E_FILTER_PCTYPE_NONF_IPV4_OTHER, > + [ETH_FLOW_TYPE_FRAG_IPV6] = I40E_FILTER_PCTYPE_FRAG_IPV6, > + [ETH_FLOW_TYPE_NONFRAG_IPV6_UDP] = > + I40E_FILTER_PCTYPE_NONF_IPV6_UDP, > + [ETH_FLOW_TYPE_NONFRAG_IPV6_TCP] = > + I40E_FILTER_PCTYPE_NONF_IPV6_TCP, > + [ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP] = > + I40E_FILTER_PCTYPE_NONF_IPV6_SCTP, > + [ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER] = > + I40E_FILTER_PCTYPE_NONF_IPV6_OTHER, > + [ETH_FLOW_TYPE_L2_PAYLOAD] = > I40E_FILTER_PCTYPE_L2_PAYLOAD, > }; > > return pctype_table[flow_type]; > } > > -enum rte_eth_flow_type > +uint16_t > i40e_pctype_to_flowtype(enum i40e_filter_pctype pctype) { > - static const enum rte_eth_flow_type flowtype_table[] = { > - [I40E_FILTER_PCTYPE_NONF_IPV4_UDP] = > RTE_ETH_FLOW_TYPE_UDPV4, > - [I40E_FILTER_PCTYPE_NONF_IPV4_TCP] = > RTE_ETH_FLOW_TYPE_TCPV4, > - [I40E_FILTER_PCTYPE_NONF_IPV4_SCTP] = > RTE_ETH_FLOW_TYPE_SCTPV4, > + static const uint16_t flowtype_table[] = { > + [I40E_FILTER_PCTYPE_FRAG_IPV4] = ETH_FLOW_TYPE_FRAG_IPV4, > + [I40E_FILTER_PCTYPE_NONF_IPV4_UDP] = > + ETH_FLOW_TYPE_NONFRAG_IPV4_UDP, > + [I40E_FILTER_PCTYPE_NONF_IPV4_TCP] = > + ETH_FLOW_TYPE_NONFRAG_IPV4_TCP, > + [I40E_FILTER_PCTYPE_NONF_IPV4_SCTP] = > + ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP, > [I40E_FILTER_PCTYPE_NONF_IPV4_OTHER] = > - RTE_ETH_FLOW_TYPE_IPV4_OTHER, > - [I40E_FILTER_PCTYPE_FRAG_IPV4] = > - RTE_ETH_FLOW_TYPE_FRAG_IPV4, > - [I40E_FILTER_PCTYPE_NONF_IPV6_UDP] = > RTE_ETH_FLOW_TYPE_UDPV6, > - [I40E_FILTER_PCTYPE_NONF_IPV6_TCP] = > RTE_ETH_FLOW_TYPE_TCPV6, > - [I40E_FILTER_PCTYPE_NONF_IPV6_SCTP] = > RTE_ETH_FLOW_TYPE_SCTPV6, > + ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER, > + [I40E_FILTER_PCTYPE_FRAG_IPV6] = ETH_FLOW_TYPE_FRAG_IPV6, > + [I40E_FILTER_PCTYPE_NONF_IPV6_UDP] = > + ETH_FLOW_TYPE_NONFRAG_IPV6_UDP, > + [I40E_FILTER_PCTYPE_NONF_IPV6_TCP] = > + ETH_FLOW_TYPE_NONFRAG_IPV6_TCP, > + [I40E_FILTER_PCTYPE_NONF_IPV6_SCTP] = > + ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP, > [I40E_FILTER_PCTYPE_NONF_IPV6_OTHER] = > - RTE_ETH_FLOW_TYPE_IPV6_OTHER, > - [I40E_FILTER_PCTYPE_FRAG_IPV6] = > - RTE_ETH_FLOW_TYPE_FRAG_IPV6, > + ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER, > + [I40E_FILTER_PCTYPE_L2_PAYLOAD] = > ETH_FLOW_TYPE_L2_PAYLOAD, > }; > > return flowtype_table[pctype]; > diff --git a/lib/librte_pmd_i40e/i40e_ethdev.h > b/lib/librte_pmd_i40e/i40e_ethdev.h > index f913ea9..e2a8db3 100644 > --- a/lib/librte_pmd_i40e/i40e_ethdev.h > +++ b/lib/librte_pmd_i40e/i40e_ethdev.h > @@ -471,10 +471,8 @@ const struct rte_memzone > *i40e_memzone_reserve(const char *name, > int socket_id); > int i40e_fdir_configure(struct rte_eth_dev *dev); void > i40e_fdir_teardown(struct i40e_pf *pf); -enum i40e_filter_pctype > i40e_flowtype_to_pctype( > - enum rte_eth_flow_type flow_type); > -enum rte_eth_flow_type i40e_pctype_to_flowtype( > - enum i40e_filter_pctype pctype); > +enum i40e_filter_pctype i40e_flowtype_to_pctype(uint16_t flow_type); > +uint16_t i40e_pctype_to_flowtype(enum i40e_filter_pctype pctype); > int i40e_fdir_ctrl_func(struct rte_eth_dev *dev, > enum rte_filter_op filter_op, > void *arg); > @@ -541,27 +539,29 @@ i40e_init_adminq_parameter(struct i40e_hw > *hw) } > > #define I40E_VALID_FLOW_TYPE(flow_type) \ > - ((flow_type) == RTE_ETH_FLOW_TYPE_UDPV4 || \ > - (flow_type) == RTE_ETH_FLOW_TYPE_TCPV4 || \ > - (flow_type) == RTE_ETH_FLOW_TYPE_SCTPV4 || \ > - (flow_type) == RTE_ETH_FLOW_TYPE_IPV4_OTHER || \ > - (flow_type) == RTE_ETH_FLOW_TYPE_FRAG_IPV4 || \ > - (flow_type) == RTE_ETH_FLOW_TYPE_UDPV6 || \ > - (flow_type) == RTE_ETH_FLOW_TYPE_TCPV6 || \ > - (flow_type) == RTE_ETH_FLOW_TYPE_SCTPV6 || \ > - (flow_type) == RTE_ETH_FLOW_TYPE_IPV6_OTHER || \ > - (flow_type) == RTE_ETH_FLOW_TYPE_FRAG_IPV6) > + ((flow_type) == ETH_FLOW_TYPE_FRAG_IPV4 || \ > + (flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV4_TCP || \ > + (flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV4_UDP || \ > + (flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP || \ > + (flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER || \ > + (flow_type) == ETH_FLOW_TYPE_FRAG_IPV6 || \ > + (flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV6_TCP || \ > + (flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV6_UDP || \ > + (flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP || \ > + (flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER || \ > + (flow_type) == ETH_FLOW_TYPE_L2_PAYLOAD) > > #define I40E_VALID_PCTYPE(pctype) \ > - ((pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_UDP || \ > + ((pctype) == I40E_FILTER_PCTYPE_FRAG_IPV4 || \ > (pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_TCP || \ > + (pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_UDP || \ > (pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_SCTP || \ > (pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_OTHER || \ > - (pctype) == I40E_FILTER_PCTYPE_FRAG_IPV4 || \ > + (pctype) == I40E_FILTER_PCTYPE_FRAG_IPV6 || \ > (pctype) == I40E_FILTER_PCTYPE_NONF_IPV6_UDP || \ > (pctype) == I40E_FILTER_PCTYPE_NONF_IPV6_TCP || \ > (pctype) == I40E_FILTER_PCTYPE_NONF_IPV6_SCTP || \ > (pctype) == I40E_FILTER_PCTYPE_NONF_IPV6_OTHER || \ > - (pctype) == I40E_FILTER_PCTYPE_FRAG_IPV6) > + (pctype) == I40E_FILTER_PCTYPE_L2_PAYLOAD) > > #endif /* _I40E_ETHDEV_H_ */ > diff --git a/lib/librte_pmd_i40e/i40e_fdir.c b/lib/librte_pmd_i40e/i40e_fdir.c > index c9e535b..9bdcabf 100644 > --- a/lib/librte_pmd_i40e/i40e_fdir.c > +++ b/lib/librte_pmd_i40e/i40e_fdir.c > @@ -95,16 +95,16 @@ > I40E_PRTQF_FLX_PIT_DEST_OFF_MASK)) > > #define I40E_FDIR_FLOW_TYPES ( \ > - (1 << RTE_ETH_FLOW_TYPE_UDPV4) | \ > - (1 << RTE_ETH_FLOW_TYPE_TCPV4) | \ > - (1 << RTE_ETH_FLOW_TYPE_SCTPV4) | \ > - (1 << RTE_ETH_FLOW_TYPE_IPV4_OTHER) | \ > - (1 << RTE_ETH_FLOW_TYPE_FRAG_IPV4) | \ > - (1 << RTE_ETH_FLOW_TYPE_UDPV6) | \ > - (1 << RTE_ETH_FLOW_TYPE_TCPV6) | \ > - (1 << RTE_ETH_FLOW_TYPE_SCTPV6) | \ > - (1 << RTE_ETH_FLOW_TYPE_IPV6_OTHER) | \ > - (1 << RTE_ETH_FLOW_TYPE_FRAG_IPV6)) > + (1 << ETH_FLOW_TYPE_FRAG_IPV4) | \ > + (1 << ETH_FLOW_TYPE_NONFRAG_IPV4_UDP) | \ > + (1 << ETH_FLOW_TYPE_NONFRAG_IPV4_TCP) | \ > + (1 << ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP) | \ > + (1 << ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER) | \ > + (1 << ETH_FLOW_TYPE_FRAG_IPV6) | \ > + (1 << ETH_FLOW_TYPE_NONFRAG_IPV6_UDP) | \ > + (1 << ETH_FLOW_TYPE_NONFRAG_IPV6_TCP) | \ > + (1 << ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP) | \ > + (1 << ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER)) > > #define I40E_FLEX_WORD_MASK(off) (0x80 >> (off)) > > @@ -498,7 +498,7 @@ i40e_check_fdir_flex_conf(const struct > rte_eth_fdir_flex_conf *conf) > } > > /* check flex mask setting configuration */ > - if (conf->nb_flexmasks > RTE_ETH_FLOW_TYPE_FRAG_IPV6) { > + if (conf->nb_flexmasks >= ETH_FLOW_TYPE_MAX) { > PMD_DRV_LOG(ERR, "invalid number of flex masks."); > return -EINVAL; > } > @@ -692,24 +692,24 @@ i40e_fdir_fill_eth_ip_head(const struct > rte_eth_fdir_input *fdir_input, > struct ipv4_hdr *ip; > struct ipv6_hdr *ip6; > static const uint8_t next_proto[] = { > - [RTE_ETH_FLOW_TYPE_UDPV4] = IPPROTO_UDP, > - [RTE_ETH_FLOW_TYPE_TCPV4] = IPPROTO_TCP, > - [RTE_ETH_FLOW_TYPE_SCTPV4] = IPPROTO_SCTP, > - [RTE_ETH_FLOW_TYPE_IPV4_OTHER] = IPPROTO_IP, > - [RTE_ETH_FLOW_TYPE_FRAG_IPV4] = IPPROTO_IP, > - [RTE_ETH_FLOW_TYPE_UDPV6] = IPPROTO_UDP, > - [RTE_ETH_FLOW_TYPE_TCPV6] = IPPROTO_TCP, > - [RTE_ETH_FLOW_TYPE_SCTPV6] = IPPROTO_SCTP, > - [RTE_ETH_FLOW_TYPE_IPV6_OTHER] = IPPROTO_NONE, > - [RTE_ETH_FLOW_TYPE_FRAG_IPV6] = IPPROTO_NONE, > + [ETH_FLOW_TYPE_FRAG_IPV4] = IPPROTO_IP, > + [ETH_FLOW_TYPE_NONFRAG_IPV4_TCP] = IPPROTO_TCP, > + [ETH_FLOW_TYPE_NONFRAG_IPV4_UDP] = IPPROTO_UDP, > + [ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP] = IPPROTO_SCTP, > + [ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER] = IPPROTO_IP, > + [ETH_FLOW_TYPE_FRAG_IPV6] = IPPROTO_NONE, > + [ETH_FLOW_TYPE_NONFRAG_IPV6_TCP] = IPPROTO_TCP, > + [ETH_FLOW_TYPE_NONFRAG_IPV6_UDP] = IPPROTO_UDP, > + [ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP] = IPPROTO_SCTP, > + [ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER] = IPPROTO_NONE, > }; > > switch (fdir_input->flow_type) { > - case RTE_ETH_FLOW_TYPE_UDPV4: > - case RTE_ETH_FLOW_TYPE_TCPV4: > - case RTE_ETH_FLOW_TYPE_SCTPV4: > - case RTE_ETH_FLOW_TYPE_IPV4_OTHER: > - case RTE_ETH_FLOW_TYPE_FRAG_IPV4: > + case ETH_FLOW_TYPE_NONFRAG_IPV4_TCP: > + case ETH_FLOW_TYPE_NONFRAG_IPV4_UDP: > + case ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP: > + case ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER: > + case ETH_FLOW_TYPE_FRAG_IPV4: > ip = (struct ipv4_hdr *)(raw_pkt + sizeof(struct ether_hdr)); > > ether->ether_type = rte_cpu_to_be_16(ETHER_TYPE_IPv4); > @@ -726,11 +726,11 @@ i40e_fdir_fill_eth_ip_head(const struct > rte_eth_fdir_input *fdir_input, > ip->dst_addr = fdir_input->flow.ip4_flow.src_ip; > ip->next_proto_id = next_proto[fdir_input->flow_type]; > break; > - case RTE_ETH_FLOW_TYPE_UDPV6: > - case RTE_ETH_FLOW_TYPE_TCPV6: > - case RTE_ETH_FLOW_TYPE_SCTPV6: > - case RTE_ETH_FLOW_TYPE_IPV6_OTHER: > - case RTE_ETH_FLOW_TYPE_FRAG_IPV6: > + case ETH_FLOW_TYPE_NONFRAG_IPV6_TCP: > + case ETH_FLOW_TYPE_NONFRAG_IPV6_UDP: > + case ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP: > + case ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER: > + case ETH_FLOW_TYPE_FRAG_IPV6: > ip6 = (struct ipv6_hdr *)(raw_pkt + sizeof(struct ether_hdr)); > > ether->ether_type = rte_cpu_to_be_16(ETHER_TYPE_IPv6); > @@ -784,7 +784,7 @@ i40e_fdir_construct_pkt(struct i40e_pf *pf, > > /* fill the L4 head */ > switch (fdir_input->flow_type) { > - case RTE_ETH_FLOW_TYPE_UDPV4: > + case ETH_FLOW_TYPE_NONFRAG_IPV4_UDP: > udp = (struct udp_hdr *)(raw_pkt + sizeof(struct ether_hdr) + > sizeof(struct ipv4_hdr)); > payload = (unsigned char *)udp + sizeof(struct udp_hdr); @@ > -798,7 > +798,7 @@ i40e_fdir_construct_pkt(struct i40e_pf *pf, > udp->dgram_len = > rte_cpu_to_be_16(I40E_FDIR_UDP_DEFAULT_LEN); > break; > > - case RTE_ETH_FLOW_TYPE_TCPV4: > + case ETH_FLOW_TYPE_NONFRAG_IPV4_TCP: > tcp = (struct tcp_hdr *)(raw_pkt + sizeof(struct ether_hdr) + > sizeof(struct ipv4_hdr)); > payload = (unsigned char *)tcp + sizeof(struct tcp_hdr); @@ > -812,21 > +812,21 @@ i40e_fdir_construct_pkt(struct i40e_pf *pf, > tcp->data_off = I40E_FDIR_TCP_DEFAULT_DATAOFF; > break; > > - case RTE_ETH_FLOW_TYPE_SCTPV4: > + case ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP: > sctp = (struct sctp_hdr *)(raw_pkt + sizeof(struct ether_hdr) + > sizeof(struct ipv4_hdr)); > payload = (unsigned char *)sctp + sizeof(struct sctp_hdr); > sctp->tag = fdir_input->flow.sctp4_flow.verify_tag; > break; > > - case RTE_ETH_FLOW_TYPE_IPV4_OTHER: > - case RTE_ETH_FLOW_TYPE_FRAG_IPV4: > + case ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER: > + case ETH_FLOW_TYPE_FRAG_IPV4: > payload = raw_pkt + sizeof(struct ether_hdr) + > sizeof(struct ipv4_hdr); > set_idx = I40E_FLXPLD_L3_IDX; > break; > > - case RTE_ETH_FLOW_TYPE_UDPV6: > + case ETH_FLOW_TYPE_NONFRAG_IPV6_UDP: > udp = (struct udp_hdr *)(raw_pkt + sizeof(struct ether_hdr) + > sizeof(struct ipv6_hdr)); > payload = (unsigned char *)udp + sizeof(struct udp_hdr); @@ > -840,7 > +840,7 @@ i40e_fdir_construct_pkt(struct i40e_pf *pf, > udp->dgram_len = > rte_cpu_to_be_16(I40E_FDIR_IPv6_PAYLOAD_LEN); > break; > > - case RTE_ETH_FLOW_TYPE_TCPV6: > + case ETH_FLOW_TYPE_NONFRAG_IPV6_TCP: > tcp = (struct tcp_hdr *)(raw_pkt + sizeof(struct ether_hdr) + > sizeof(struct ipv6_hdr)); > payload = (unsigned char *)tcp + sizeof(struct tcp_hdr); @@ > -854,15 > +854,15 @@ i40e_fdir_construct_pkt(struct i40e_pf *pf, > tcp->dst_port = fdir_input->flow.udp6_flow.src_port; > break; > > - case RTE_ETH_FLOW_TYPE_SCTPV6: > + case ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP: > sctp = (struct sctp_hdr *)(raw_pkt + sizeof(struct ether_hdr) + > sizeof(struct ipv6_hdr)); > payload = (unsigned char *)sctp + sizeof(struct sctp_hdr); > sctp->tag = fdir_input->flow.sctp6_flow.verify_tag; > break; > > - case RTE_ETH_FLOW_TYPE_IPV6_OTHER: > - case RTE_ETH_FLOW_TYPE_FRAG_IPV6: > + case ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER: > + case ETH_FLOW_TYPE_FRAG_IPV6: > payload = raw_pkt + sizeof(struct ether_hdr) + > sizeof(struct ipv6_hdr); > set_idx = I40E_FLXPLD_L3_IDX; > @@ -1214,7 +1214,7 @@ i40e_fdir_info_get_flex_mask(struct i40e_pf *pf, { > struct i40e_fdir_flex_mask *mask; > struct rte_eth_fdir_flex_mask *ptr = flex_mask; > - enum rte_eth_flow_type flow_type; > + uint16_t flow_type; > uint8_t i, j; > uint16_t off_bytes, mask_tmp; > > -- > 1.9.3
