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
