From: Andrew Rybchenko <arybchenko@solarflare.com>
To: Wenzhuo Lu <wenzhuo.lu@intel.com>,
Beilei Xing <beilei.xing@intel.com>,
Bernard Iremonger <bernard.iremonger@intel.com>,
Ray Kinsella <mdr@ashroe.eu>, Neil Horman <nhorman@tuxdriver.com>,
Ajit Khaparde <ajit.khaparde@broadcom.com>,
Somnath Kotur <somnath.kotur@broadcom.com>,
John Daley <johndale@cisco.com>,
Hyong Youb Kim <hyonkim@cisco.com>, Jeff Guo <jia.guo@intel.com>,
Haiyue Wang <haiyue.wang@intel.com>,
Matan Azrad <matan@nvidia.com>,
Shahaf Shuler <shahafs@nvidia.com>,
Viacheslav Ovsiienko <viacheslavo@nvidia.com>,
Rasesh Mody <rmody@marvell.com>,
Shahed Shaikh <shshaikh@marvell.com>,
Andrew Rybchenko <andrew.rybchenko@oktetlabs.ru>,
Thomas Monjalon <thomas@monjalon.net>,
Ferruh Yigit <ferruh.yigit@intel.com>
Cc: <dev@dpdk.org>
Subject: [dpdk-dev] [PATCH 12/14] ethdev: remove legacy FDIR filter type support
Date: Sun, 18 Oct 2020 15:09:09 +0100 [thread overview]
Message-ID: <1603030152-13451-13-git-send-email-arybchenko@solarflare.com> (raw)
In-Reply-To: <1603030152-13451-1-git-send-email-arybchenko@solarflare.com>
RTE flow API should be used for filtering.
Signed-off-by: Andrew Rybchenko <arybchenko@solarflare.com>
---
app/test-pmd/cmdline.c | 897 +++------------------------
app/test-pmd/config.c | 15 +-
app/test-pmd/testpmd.h | 2 +
doc/guides/rel_notes/deprecation.rst | 4 +-
drivers/net/bnxt/bnxt_ethdev.c | 396 ------------
drivers/net/enic/enic.h | 7 -
drivers/net/enic/enic_clsf.c | 168 -----
drivers/net/enic/enic_ethdev.c | 48 --
drivers/net/i40e/i40e_ethdev.c | 86 ---
drivers/net/i40e/i40e_ethdev.h | 11 +-
drivers/net/i40e/i40e_fdir.c | 539 ----------------
drivers/net/ixgbe/ixgbe_ethdev.c | 5 +-
drivers/net/ixgbe/ixgbe_ethdev.h | 2 -
drivers/net/ixgbe/ixgbe_fdir.c | 220 -------
drivers/net/mlx5/mlx5.h | 1 -
drivers/net/mlx5/mlx5_flow.c | 516 ---------------
drivers/net/mlx5/mlx5_flow.h | 8 -
drivers/net/qede/qede_ethdev.h | 5 -
drivers/net/qede/qede_filter.c | 171 -----
drivers/net/sfc/sfc_ethdev.c | 3 -
lib/librte_ethdev/rte_eth_ctrl.h | 27 +-
21 files changed, 81 insertions(+), 3050 deletions(-)
diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index 9abe8659f5..9ce6c09567 100644
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -959,62 +959,12 @@ static void cmd_help_long_parsed(void *parsed_result,
"filters:\n"
"--------\n\n"
- "flow_director_filter (port_id) mode IP (add|del|update)"
- " flow (ipv4-other|ipv4-frag|ipv6-other|ipv6-frag)"
- " src (src_ip_address) dst (dst_ip_address)"
- " tos (tos_value) proto (proto_value) ttl (ttl_value)"
- " vlan (vlan_value) flexbytes (flexbytes_value)"
- " (drop|fwd) pf|vf(vf_id) queue (queue_id)"
- " fd_id (fd_id_value)\n"
- " Add/Del an IP type flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode IP (add|del|update)"
- " flow (ipv4-tcp|ipv4-udp|ipv6-tcp|ipv6-udp)"
- " src (src_ip_address) (src_port)"
- " dst (dst_ip_address) (dst_port)"
- " tos (tos_value) ttl (ttl_value)"
- " vlan (vlan_value) flexbytes (flexbytes_value)"
- " (drop|fwd) pf|vf(vf_id) queue (queue_id)"
- " fd_id (fd_id_value)\n"
- " Add/Del an UDP/TCP type flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode IP (add|del|update)"
- " flow (ipv4-sctp|ipv6-sctp)"
- " src (src_ip_address) (src_port)"
- " dst (dst_ip_address) (dst_port)"
- " tag (verification_tag) "
- " tos (tos_value) ttl (ttl_value)"
- " vlan (vlan_value)"
- " flexbytes (flexbytes_value) (drop|fwd)"
- " pf|vf(vf_id) queue (queue_id) fd_id (fd_id_value)\n"
- " Add/Del a SCTP type flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode IP (add|del|update)"
- " flow l2_payload ether (ethertype)"
- " flexbytes (flexbytes_value) (drop|fwd)"
- " pf|vf(vf_id) queue (queue_id) fd_id (fd_id_value)\n"
- " Add/Del a l2 payload type flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode MAC-VLAN (add|del|update)"
- " mac (mac_address) vlan (vlan_value)"
- " flexbytes (flexbytes_value) (drop|fwd)"
- " queue (queue_id) fd_id (fd_id_value)\n"
- " Add/Del a MAC-VLAN flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode Tunnel (add|del|update)"
- " mac (mac_address) vlan (vlan_value)"
- " tunnel (NVGRE|VxLAN) tunnel-id (tunnel_id_value)"
- " flexbytes (flexbytes_value) (drop|fwd)"
- " queue (queue_id) fd_id (fd_id_value)\n"
- " Add/Del a Tunnel flow director filter.\n\n"
-
+#ifdef RTE_LIBRTE_I40E_PMD
"flow_director_filter (port_id) mode raw (add|del|update)"
" flow (flow_id) (drop|fwd) queue (queue_id)"
" fd_id (fd_id_value) packet (packet file name)\n"
" Add/Del a raw type flow director filter.\n\n"
-
- "flush_flow_director (port_id)\n"
- " Flush all flow director entries of a device.\n\n"
+#endif
"flow_director_mask (port_id) mode IP vlan (vlan_value)"
" src_mask (ipv4_src) (ipv6_src) (src_port)"
@@ -1041,17 +991,6 @@ static void cmd_help_long_parsed(void *parsed_result,
" (raw|l2|l3|l4) (config)\n"
" Configure flex payload selection.\n\n"
- "set_fdir_input_set (port_id) "
- "(ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
- "ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|"
- "l2_payload) (ivlan|ethertype|src-ipv4|dst-ipv4|src-ipv6|"
- "dst-ipv6|ipv4-tos|ipv4-proto|ipv4-ttl|ipv6-tc|"
- "ipv6-next-header|ipv6-hop-limits|udp-src-port|"
- "udp-dst-port|tcp-src-port|tcp-dst-port|"
- "sctp-src-port|sctp-dst-port|sctp-veri-tag|none)"
- " (select|add)\n"
- " Set the input set for FDir.\n\n"
-
"flow validate {port_id}"
" [group {group_id}] [priority {level}]"
" [ingress] [egress]"
@@ -7628,9 +7567,11 @@ static void cmd_showportall_parsed(void *parsed_result,
else if (!strcmp(res->what, "xstats"))
RTE_ETH_FOREACH_DEV(i)
nic_xstats_display(i);
+#if defined(RTE_LIBRTE_I40E_PMD) || defined(RTE_LIBRTE_IXGBE_PMD)
else if (!strcmp(res->what, "fdir"))
RTE_ETH_FOREACH_DEV(i)
fdir_get_infos(i);
+#endif
else if (!strcmp(res->what, "stat_qmap"))
RTE_ETH_FOREACH_DEV(i)
nic_stats_mapping_display(i);
@@ -7694,8 +7635,10 @@ static void cmd_showport_parsed(void *parsed_result,
nic_stats_display(res->portnum);
else if (!strcmp(res->what, "xstats"))
nic_xstats_display(res->portnum);
+#if defined(RTE_LIBRTE_I40E_PMD) || defined(RTE_LIBRTE_IXGBE_PMD)
else if (!strcmp(res->what, "fdir"))
fdir_get_infos(res->portnum);
+#endif
else if (!strcmp(res->what, "stat_qmap"))
nic_stats_mapping_display(res->portnum);
else if (!strcmp(res->what, "dcb_tc"))
@@ -10157,51 +10100,6 @@ cmdline_parse_inst_t cmd_show_queue_region_info_all = {
/* *** Filters Control *** */
-/* *** deal with flow director filter *** */
-struct cmd_flow_director_result {
- cmdline_fixed_string_t flow_director_filter;
- portid_t port_id;
- cmdline_fixed_string_t mode;
- cmdline_fixed_string_t mode_value;
- cmdline_fixed_string_t ops;
- cmdline_fixed_string_t flow;
- cmdline_fixed_string_t flow_type;
- cmdline_fixed_string_t ether;
- uint16_t ether_type;
- cmdline_fixed_string_t src;
- cmdline_ipaddr_t ip_src;
- uint16_t port_src;
- cmdline_fixed_string_t dst;
- cmdline_ipaddr_t ip_dst;
- uint16_t port_dst;
- cmdline_fixed_string_t verify_tag;
- uint32_t verify_tag_value;
- cmdline_fixed_string_t tos;
- uint8_t tos_value;
- cmdline_fixed_string_t proto;
- uint8_t proto_value;
- cmdline_fixed_string_t ttl;
- uint8_t ttl_value;
- cmdline_fixed_string_t vlan;
- uint16_t vlan_value;
- cmdline_fixed_string_t flexbytes;
- cmdline_fixed_string_t flexbytes_value;
- cmdline_fixed_string_t pf_vf;
- cmdline_fixed_string_t drop;
- cmdline_fixed_string_t queue;
- uint16_t queue_id;
- cmdline_fixed_string_t fd_id;
- uint32_t fd_id_value;
- cmdline_fixed_string_t mac;
- struct rte_ether_addr mac_addr;
- cmdline_fixed_string_t tunnel;
- cmdline_fixed_string_t tunnel_type;
- cmdline_fixed_string_t tunnel_id;
- uint32_t tunnel_id_value;
- cmdline_fixed_string_t packet;
- char filepath[];
-};
-
static inline int
parse_flexbytes(const char *q_arg, uint8_t *flexbytes, uint16_t max_num)
{
@@ -10275,26 +10173,6 @@ str2flowtype(char *string)
return RTE_ETH_FLOW_UNKNOWN;
}
-static enum rte_eth_fdir_tunnel_type
-str2fdir_tunneltype(char *string)
-{
- uint8_t i = 0;
-
- static const struct {
- char str[32];
- enum rte_eth_fdir_tunnel_type type;
- } tunneltype_str[] = {
- {"NVGRE", RTE_FDIR_TUNNEL_TYPE_NVGRE},
- {"VxLAN", RTE_FDIR_TUNNEL_TYPE_VXLAN},
- };
-
- for (i = 0; i < RTE_DIM(tunneltype_str); i++) {
- if (!strcmp(tunneltype_str[i].str, string))
- return tunneltype_str[i].type;
- }
- return RTE_FDIR_TUNNEL_TYPE_UNKNOWN;
-}
-
#define IPV4_ADDR_TO_UINT(ip_addr, ip) \
do { \
if ((ip_addr).family == AF_INET) \
@@ -10317,252 +10195,83 @@ do { \
} \
} while (0)
+#ifdef RTE_LIBRTE_I40E_PMD
+
+/* *** deal with flow director filter *** */
+struct cmd_flow_director_result {
+ cmdline_fixed_string_t flow_director_filter;
+ portid_t port_id;
+ cmdline_fixed_string_t mode;
+ cmdline_fixed_string_t mode_value;
+ cmdline_fixed_string_t ops;
+ cmdline_fixed_string_t flow;
+ cmdline_fixed_string_t flow_type;
+ cmdline_fixed_string_t drop;
+ cmdline_fixed_string_t queue;
+ uint16_t queue_id;
+ cmdline_fixed_string_t fd_id;
+ uint32_t fd_id_value;
+ cmdline_fixed_string_t packet;
+ char filepath[];
+};
+
static void
cmd_flow_director_filter_parsed(void *parsed_result,
__rte_unused struct cmdline *cl,
__rte_unused void *data)
{
struct cmd_flow_director_result *res = parsed_result;
- struct rte_eth_fdir_filter entry;
- uint8_t flexbytes[RTE_ETH_FDIR_MAX_FLEXLEN];
- char *end;
- unsigned long vf_id;
int ret = 0;
+ struct rte_pmd_i40e_flow_type_mapping
+ mapping[RTE_PMD_I40E_FLOW_TYPE_MAX];
+ struct rte_pmd_i40e_pkt_template_conf conf;
+ uint16_t flow_type = str2flowtype(res->flow_type);
+ uint16_t i, port = res->port_id;
+ uint8_t add;
- ret = rte_eth_dev_filter_supported(res->port_id, RTE_ETH_FILTER_FDIR);
- if (ret < 0) {
- printf("flow director is not supported on port %u.\n",
- res->port_id);
- return;
- }
- memset(flexbytes, 0, sizeof(flexbytes));
- memset(&entry, 0, sizeof(struct rte_eth_fdir_filter));
-
- if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) {
- if (strcmp(res->mode_value, "MAC-VLAN")) {
- printf("Please set mode to MAC-VLAN.\n");
- return;
- }
- } else if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) {
- if (strcmp(res->mode_value, "Tunnel")) {
- printf("Please set mode to Tunnel.\n");
- return;
- }
- } else {
- if (!strcmp(res->mode_value, "raw")) {
-#ifdef RTE_LIBRTE_I40E_PMD
- struct rte_pmd_i40e_flow_type_mapping
- mapping[RTE_PMD_I40E_FLOW_TYPE_MAX];
- struct rte_pmd_i40e_pkt_template_conf conf;
- uint16_t flow_type = str2flowtype(res->flow_type);
- uint16_t i, port = res->port_id;
- uint8_t add;
-
- memset(&conf, 0, sizeof(conf));
+ memset(&conf, 0, sizeof(conf));
- if (flow_type == RTE_ETH_FLOW_UNKNOWN) {
- printf("Invalid flow type specified.\n");
- return;
- }
- ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id,
- mapping);
- if (ret)
- return;
- if (mapping[flow_type].pctype == 0ULL) {
- printf("Invalid flow type specified.\n");
- return;
- }
- for (i = 0; i < RTE_PMD_I40E_PCTYPE_MAX; i++) {
- if (mapping[flow_type].pctype & (1ULL << i)) {
- conf.input.pctype = i;
- break;
- }
- }
-
- conf.input.packet = open_file(res->filepath,
- &conf.input.length);
- if (!conf.input.packet)
- return;
- if (!strcmp(res->drop, "drop"))
- conf.action.behavior =
- RTE_PMD_I40E_PKT_TEMPLATE_REJECT;
- else
- conf.action.behavior =
- RTE_PMD_I40E_PKT_TEMPLATE_ACCEPT;
- conf.action.report_status =
- RTE_PMD_I40E_PKT_TEMPLATE_REPORT_ID;
- conf.action.rx_queue = res->queue_id;
- conf.soft_id = res->fd_id_value;
- add = strcmp(res->ops, "del") ? 1 : 0;
- ret = rte_pmd_i40e_flow_add_del_packet_template(port,
- &conf,
- add);
- if (ret < 0)
- printf("flow director config error: (%s)\n",
- strerror(-ret));
- close_file(conf.input.packet);
-#endif
- return;
- } else if (strcmp(res->mode_value, "IP")) {
- printf("Please set mode to IP or raw.\n");
- return;
- }
- entry.input.flow_type = str2flowtype(res->flow_type);
- }
-
- ret = parse_flexbytes(res->flexbytes_value,
- flexbytes,
- RTE_ETH_FDIR_MAX_FLEXLEN);
- if (ret < 0) {
- printf("error: Cannot parse flexbytes input.\n");
+ if (flow_type == RTE_ETH_FLOW_UNKNOWN) {
+ printf("Invalid flow type specified.\n");
return;
}
-
- switch (entry.input.flow_type) {
- case RTE_ETH_FLOW_FRAG_IPV4:
- case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
- entry.input.flow.ip4_flow.proto = res->proto_value;
- /* fall-through */
- case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
- case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
- IPV4_ADDR_TO_UINT(res->ip_dst,
- entry.input.flow.ip4_flow.dst_ip);
- IPV4_ADDR_TO_UINT(res->ip_src,
- entry.input.flow.ip4_flow.src_ip);
- entry.input.flow.ip4_flow.tos = res->tos_value;
- entry.input.flow.ip4_flow.ttl = res->ttl_value;
- /* need convert to big endian. */
- entry.input.flow.udp4_flow.dst_port =
- rte_cpu_to_be_16(res->port_dst);
- entry.input.flow.udp4_flow.src_port =
- rte_cpu_to_be_16(res->port_src);
- break;
- case RTE_ETH_FLOW_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,
- entry.input.flow.sctp4_flow.ip.src_ip);
- entry.input.flow.ip4_flow.tos = res->tos_value;
- entry.input.flow.ip4_flow.ttl = res->ttl_value;
- /* need convert to big endian. */
- entry.input.flow.sctp4_flow.dst_port =
- rte_cpu_to_be_16(res->port_dst);
- entry.input.flow.sctp4_flow.src_port =
- rte_cpu_to_be_16(res->port_src);
- entry.input.flow.sctp4_flow.verify_tag =
- rte_cpu_to_be_32(res->verify_tag_value);
- break;
- case RTE_ETH_FLOW_FRAG_IPV6:
- case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
- entry.input.flow.ipv6_flow.proto = res->proto_value;
- /* fall-through */
- case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
- case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
- IPV6_ADDR_TO_ARRAY(res->ip_dst,
- entry.input.flow.ipv6_flow.dst_ip);
- IPV6_ADDR_TO_ARRAY(res->ip_src,
- entry.input.flow.ipv6_flow.src_ip);
- entry.input.flow.ipv6_flow.tc = res->tos_value;
- entry.input.flow.ipv6_flow.hop_limits = res->ttl_value;
- /* need convert to big endian. */
- entry.input.flow.udp6_flow.dst_port =
- rte_cpu_to_be_16(res->port_dst);
- entry.input.flow.udp6_flow.src_port =
- rte_cpu_to_be_16(res->port_src);
- break;
- case RTE_ETH_FLOW_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,
- entry.input.flow.sctp6_flow.ip.src_ip);
- entry.input.flow.ipv6_flow.tc = res->tos_value;
- entry.input.flow.ipv6_flow.hop_limits = res->ttl_value;
- /* need convert to big endian. */
- entry.input.flow.sctp6_flow.dst_port =
- rte_cpu_to_be_16(res->port_dst);
- entry.input.flow.sctp6_flow.src_port =
- rte_cpu_to_be_16(res->port_src);
- entry.input.flow.sctp6_flow.verify_tag =
- rte_cpu_to_be_32(res->verify_tag_value);
- break;
- case RTE_ETH_FLOW_L2_PAYLOAD:
- entry.input.flow.l2_flow.ether_type =
- rte_cpu_to_be_16(res->ether_type);
- break;
- default:
- break;
- }
-
- if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN)
- rte_memcpy(&entry.input.flow.mac_vlan_flow.mac_addr,
- &res->mac_addr,
- sizeof(struct rte_ether_addr));
-
- if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) {
- rte_memcpy(&entry.input.flow.tunnel_flow.mac_addr,
- &res->mac_addr,
- sizeof(struct rte_ether_addr));
- entry.input.flow.tunnel_flow.tunnel_type =
- str2fdir_tunneltype(res->tunnel_type);
- entry.input.flow.tunnel_flow.tunnel_id =
- rte_cpu_to_be_32(res->tunnel_id_value);
+ ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id,
+ mapping);
+ if (ret)
+ return;
+ if (mapping[flow_type].pctype == 0ULL) {
+ printf("Invalid flow type specified.\n");
+ return;
}
-
- rte_memcpy(entry.input.flow_ext.flexbytes,
- flexbytes,
- RTE_ETH_FDIR_MAX_FLEXLEN);
-
- entry.input.flow_ext.vlan_tci = rte_cpu_to_be_16(res->vlan_value);
-
- entry.action.flex_off = 0; /*use 0 by default */
- if (!strcmp(res->drop, "drop"))
- entry.action.behavior = RTE_ETH_FDIR_REJECT;
- else
- entry.action.behavior = RTE_ETH_FDIR_ACCEPT;
-
- if (fdir_conf.mode != RTE_FDIR_MODE_PERFECT_MAC_VLAN &&
- fdir_conf.mode != RTE_FDIR_MODE_PERFECT_TUNNEL) {
- if (!strcmp(res->pf_vf, "pf"))
- entry.input.flow_ext.is_vf = 0;
- else if (!strncmp(res->pf_vf, "vf", 2)) {
- struct rte_eth_dev_info dev_info;
-
- ret = eth_dev_info_get_print_err(res->port_id,
- &dev_info);
- if (ret != 0)
- return;
-
- errno = 0;
- vf_id = strtoul(res->pf_vf + 2, &end, 10);
- if (errno != 0 || *end != '\0' ||
- vf_id >= dev_info.max_vfs) {
- printf("invalid parameter %s.\n", res->pf_vf);
- return;
- }
- entry.input.flow_ext.is_vf = 1;
- entry.input.flow_ext.dst_id = (uint16_t)vf_id;
- } else {
- printf("invalid parameter %s.\n", res->pf_vf);
- return;
+ for (i = 0; i < RTE_PMD_I40E_PCTYPE_MAX; i++) {
+ if (mapping[flow_type].pctype & (1ULL << i)) {
+ conf.input.pctype = i;
+ break;
}
}
- /* set to report FD ID by default */
- entry.action.report_status = RTE_ETH_FDIR_REPORT_ID;
- entry.action.rx_queue = res->queue_id;
- entry.soft_id = res->fd_id_value;
- if (!strcmp(res->ops, "add"))
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_ADD, &entry);
- else if (!strcmp(res->ops, "del"))
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_DELETE, &entry);
+ conf.input.packet = open_file(res->filepath,
+ &conf.input.length);
+ if (!conf.input.packet)
+ return;
+ if (!strcmp(res->drop, "drop"))
+ conf.action.behavior =
+ RTE_PMD_I40E_PKT_TEMPLATE_REJECT;
else
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_UPDATE, &entry);
+ conf.action.behavior =
+ RTE_PMD_I40E_PKT_TEMPLATE_ACCEPT;
+ conf.action.report_status =
+ RTE_PMD_I40E_PKT_TEMPLATE_REPORT_ID;
+ conf.action.rx_queue = res->queue_id;
+ conf.soft_id = res->fd_id_value;
+ add = strcmp(res->ops, "del") ? 1 : 0;
+ ret = rte_pmd_i40e_flow_add_del_packet_template(port,
+ &conf,
+ add);
if (ret < 0)
- printf("flow director programming error: (%s)\n",
- strerror(-ret));
+ printf("flow director config error: (%s)\n",
+ strerror(-ret));
+ close_file(conf.input.packet);
}
cmdline_parse_token_string_t cmd_flow_director_filter =
@@ -10580,72 +10289,9 @@ cmdline_parse_token_string_t cmd_flow_director_flow =
cmdline_parse_token_string_t cmd_flow_director_flow_type =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
flow_type, NULL);
-cmdline_parse_token_string_t cmd_flow_director_ether =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- ether, "ether");
-cmdline_parse_token_num_t cmd_flow_director_ether_type =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- ether_type, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_src =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- src, "src");
-cmdline_parse_token_ipaddr_t cmd_flow_director_ip_src =
- TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_result,
- ip_src);
-cmdline_parse_token_num_t cmd_flow_director_port_src =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- port_src, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_dst =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- dst, "dst");
-cmdline_parse_token_ipaddr_t cmd_flow_director_ip_dst =
- TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_result,
- ip_dst);
-cmdline_parse_token_num_t cmd_flow_director_port_dst =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- port_dst, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_verify_tag =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- verify_tag, "verify_tag");
-cmdline_parse_token_num_t cmd_flow_director_verify_tag_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- verify_tag_value, UINT32);
-cmdline_parse_token_string_t cmd_flow_director_tos =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- tos, "tos");
-cmdline_parse_token_num_t cmd_flow_director_tos_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- tos_value, UINT8);
-cmdline_parse_token_string_t cmd_flow_director_proto =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- proto, "proto");
-cmdline_parse_token_num_t cmd_flow_director_proto_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- proto_value, UINT8);
-cmdline_parse_token_string_t cmd_flow_director_ttl =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- ttl, "ttl");
-cmdline_parse_token_num_t cmd_flow_director_ttl_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- ttl_value, UINT8);
-cmdline_parse_token_string_t cmd_flow_director_vlan =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- vlan, "vlan");
-cmdline_parse_token_num_t cmd_flow_director_vlan_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- vlan_value, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_flexbytes =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- flexbytes, "flexbytes");
-cmdline_parse_token_string_t cmd_flow_director_flexbytes_value =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- flexbytes_value, NULL);
cmdline_parse_token_string_t cmd_flow_director_drop =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
drop, "drop#fwd");
-cmdline_parse_token_string_t cmd_flow_director_pf_vf =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- pf_vf, NULL);
cmdline_parse_token_string_t cmd_flow_director_queue =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
queue, "queue");
@@ -10662,36 +10308,9 @@ cmdline_parse_token_num_t cmd_flow_director_fd_id_value =
cmdline_parse_token_string_t cmd_flow_director_mode =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
mode, "mode");
-cmdline_parse_token_string_t cmd_flow_director_mode_ip =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- mode_value, "IP");
-cmdline_parse_token_string_t cmd_flow_director_mode_mac_vlan =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- mode_value, "MAC-VLAN");
-cmdline_parse_token_string_t cmd_flow_director_mode_tunnel =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- mode_value, "Tunnel");
cmdline_parse_token_string_t cmd_flow_director_mode_raw =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
mode_value, "raw");
-cmdline_parse_token_string_t cmd_flow_director_mac =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- mac, "mac");
-cmdline_parse_token_etheraddr_t cmd_flow_director_mac_addr =
- TOKEN_ETHERADDR_INITIALIZER(struct cmd_flow_director_result,
- mac_addr);
-cmdline_parse_token_string_t cmd_flow_director_tunnel =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- tunnel, "tunnel");
-cmdline_parse_token_string_t cmd_flow_director_tunnel_type =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- tunnel_type, "NVGRE#VxLAN");
-cmdline_parse_token_string_t cmd_flow_director_tunnel_id =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- tunnel_id, "tunnel-id");
-cmdline_parse_token_num_t cmd_flow_director_tunnel_id_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- tunnel_id_value, UINT32);
cmdline_parse_token_string_t cmd_flow_director_packet =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
packet, "packet");
@@ -10699,208 +10318,6 @@ cmdline_parse_token_string_t cmd_flow_director_filepath =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
filepath, NULL);
-cmdline_parse_inst_t cmd_add_del_ip_flow_director = {
- .f = cmd_flow_director_filter_parsed,
- .data = NULL,
- .help_str = "flow_director_filter <port_id> mode IP add|del|update flow"
- " ipv4-other|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|"
- "ipv6-other|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|"
- "l2_payload src <src_ip> dst <dst_ip> tos <tos_value> "
- "proto <proto_value> ttl <ttl_value> vlan <vlan_value> "
- "flexbytes <flexbyte_values> drop|fw <pf_vf> queue <queue_id> "
- "fd_id <fd_id_value>: "
- "Add or delete an ip flow director entry on NIC",
- .tokens = {
- (void *)&cmd_flow_director_filter,
- (void *)&cmd_flow_director_port_id,
- (void *)&cmd_flow_director_mode,
- (void *)&cmd_flow_director_mode_ip,
- (void *)&cmd_flow_director_ops,
- (void *)&cmd_flow_director_flow,
- (void *)&cmd_flow_director_flow_type,
- (void *)&cmd_flow_director_src,
- (void *)&cmd_flow_director_ip_src,
- (void *)&cmd_flow_director_dst,
- (void *)&cmd_flow_director_ip_dst,
- (void *)&cmd_flow_director_tos,
- (void *)&cmd_flow_director_tos_value,
- (void *)&cmd_flow_director_proto,
- (void *)&cmd_flow_director_proto_value,
- (void *)&cmd_flow_director_ttl,
- (void *)&cmd_flow_director_ttl_value,
- (void *)&cmd_flow_director_vlan,
- (void *)&cmd_flow_director_vlan_value,
- (void *)&cmd_flow_director_flexbytes,
- (void *)&cmd_flow_director_flexbytes_value,
- (void *)&cmd_flow_director_drop,
- (void *)&cmd_flow_director_pf_vf,
- (void *)&cmd_flow_director_queue,
- (void *)&cmd_flow_director_queue_id,
- (void *)&cmd_flow_director_fd_id,
- (void *)&cmd_flow_director_fd_id_value,
- NULL,
- },
-};
-
-cmdline_parse_inst_t cmd_add_del_udp_flow_director = {
- .f = cmd_flow_director_filter_parsed,
- .data = NULL,
- .help_str = "flow_director_filter ... : Add or delete an udp/tcp flow "
- "director entry on NIC",
- .tokens = {
- (void *)&cmd_flow_director_filter,
- (void *)&cmd_flow_director_port_id,
- (void *)&cmd_flow_director_mode,
- (void *)&cmd_flow_director_mode_ip,
- (void *)&cmd_flow_director_ops,
- (void *)&cmd_flow_director_flow,
- (void *)&cmd_flow_director_flow_type,
- (void *)&cmd_flow_director_src,
- (void *)&cmd_flow_director_ip_src,
- (void *)&cmd_flow_director_port_src,
- (void *)&cmd_flow_director_dst,
- (void *)&cmd_flow_director_ip_dst,
- (void *)&cmd_flow_director_port_dst,
- (void *)&cmd_flow_director_tos,
- (void *)&cmd_flow_director_tos_value,
- (void *)&cmd_flow_director_ttl,
- (void *)&cmd_flow_director_ttl_value,
- (void *)&cmd_flow_director_vlan,
- (void *)&cmd_flow_director_vlan_value,
- (void *)&cmd_flow_director_flexbytes,
- (void *)&cmd_flow_director_flexbytes_value,
- (void *)&cmd_flow_director_drop,
- (void *)&cmd_flow_director_pf_vf,
- (void *)&cmd_flow_director_queue,
- (void *)&cmd_flow_director_queue_id,
- (void *)&cmd_flow_director_fd_id,
- (void *)&cmd_flow_director_fd_id_value,
- NULL,
- },
-};
-
-cmdline_parse_inst_t cmd_add_del_sctp_flow_director = {
- .f = cmd_flow_director_filter_parsed,
- .data = NULL,
- .help_str = "flow_director_filter ... : Add or delete a sctp flow "
- "director entry on NIC",
- .tokens = {
- (void *)&cmd_flow_director_filter,
- (void *)&cmd_flow_director_port_id,
- (void *)&cmd_flow_director_mode,
- (void *)&cmd_flow_director_mode_ip,
- (void *)&cmd_flow_director_ops,
- (void *)&cmd_flow_director_flow,
- (void *)&cmd_flow_director_flow_type,
- (void *)&cmd_flow_director_src,
- (void *)&cmd_flow_director_ip_src,
- (void *)&cmd_flow_director_port_src,
- (void *)&cmd_flow_director_dst,
- (void *)&cmd_flow_director_ip_dst,
- (void *)&cmd_flow_director_port_dst,
- (void *)&cmd_flow_director_verify_tag,
- (void *)&cmd_flow_director_verify_tag_value,
- (void *)&cmd_flow_director_tos,
- (void *)&cmd_flow_director_tos_value,
- (void *)&cmd_flow_director_ttl,
- (void *)&cmd_flow_director_ttl_value,
- (void *)&cmd_flow_director_vlan,
- (void *)&cmd_flow_director_vlan_value,
- (void *)&cmd_flow_director_flexbytes,
- (void *)&cmd_flow_director_flexbytes_value,
- (void *)&cmd_flow_director_drop,
- (void *)&cmd_flow_director_pf_vf,
- (void *)&cmd_flow_director_queue,
- (void *)&cmd_flow_director_queue_id,
- (void *)&cmd_flow_director_fd_id,
- (void *)&cmd_flow_director_fd_id_value,
- NULL,
- },
-};
-
-cmdline_parse_inst_t cmd_add_del_l2_flow_director = {
- .f = cmd_flow_director_filter_parsed,
- .data = NULL,
- .help_str = "flow_director_filter ... : Add or delete a L2 flow "
- "director entry on NIC",
- .tokens = {
- (void *)&cmd_flow_director_filter,
- (void *)&cmd_flow_director_port_id,
- (void *)&cmd_flow_director_mode,
- (void *)&cmd_flow_director_mode_ip,
- (void *)&cmd_flow_director_ops,
- (void *)&cmd_flow_director_flow,
- (void *)&cmd_flow_director_flow_type,
- (void *)&cmd_flow_director_ether,
- (void *)&cmd_flow_director_ether_type,
- (void *)&cmd_flow_director_flexbytes,
- (void *)&cmd_flow_director_flexbytes_value,
- (void *)&cmd_flow_director_drop,
- (void *)&cmd_flow_director_pf_vf,
- (void *)&cmd_flow_director_queue,
- (void *)&cmd_flow_director_queue_id,
- (void *)&cmd_flow_director_fd_id,
- (void *)&cmd_flow_director_fd_id_value,
- NULL,
- },
-};
-
-cmdline_parse_inst_t cmd_add_del_mac_vlan_flow_director = {
- .f = cmd_flow_director_filter_parsed,
- .data = NULL,
- .help_str = "flow_director_filter ... : Add or delete a MAC VLAN flow "
- "director entry on NIC",
- .tokens = {
- (void *)&cmd_flow_director_filter,
- (void *)&cmd_flow_director_port_id,
- (void *)&cmd_flow_director_mode,
- (void *)&cmd_flow_director_mode_mac_vlan,
- (void *)&cmd_flow_director_ops,
- (void *)&cmd_flow_director_mac,
- (void *)&cmd_flow_director_mac_addr,
- (void *)&cmd_flow_director_vlan,
- (void *)&cmd_flow_director_vlan_value,
- (void *)&cmd_flow_director_flexbytes,
- (void *)&cmd_flow_director_flexbytes_value,
- (void *)&cmd_flow_director_drop,
- (void *)&cmd_flow_director_queue,
- (void *)&cmd_flow_director_queue_id,
- (void *)&cmd_flow_director_fd_id,
- (void *)&cmd_flow_director_fd_id_value,
- NULL,
- },
-};
-
-cmdline_parse_inst_t cmd_add_del_tunnel_flow_director = {
- .f = cmd_flow_director_filter_parsed,
- .data = NULL,
- .help_str = "flow_director_filter ... : Add or delete a tunnel flow "
- "director entry on NIC",
- .tokens = {
- (void *)&cmd_flow_director_filter,
- (void *)&cmd_flow_director_port_id,
- (void *)&cmd_flow_director_mode,
- (void *)&cmd_flow_director_mode_tunnel,
- (void *)&cmd_flow_director_ops,
- (void *)&cmd_flow_director_mac,
- (void *)&cmd_flow_director_mac_addr,
- (void *)&cmd_flow_director_vlan,
- (void *)&cmd_flow_director_vlan_value,
- (void *)&cmd_flow_director_tunnel,
- (void *)&cmd_flow_director_tunnel_type,
- (void *)&cmd_flow_director_tunnel_id,
- (void *)&cmd_flow_director_tunnel_id_value,
- (void *)&cmd_flow_director_flexbytes,
- (void *)&cmd_flow_director_flexbytes_value,
- (void *)&cmd_flow_director_drop,
- (void *)&cmd_flow_director_queue,
- (void *)&cmd_flow_director_queue_id,
- (void *)&cmd_flow_director_fd_id,
- (void *)&cmd_flow_director_fd_id_value,
- NULL,
- },
-};
-
cmdline_parse_inst_t cmd_add_del_raw_flow_director = {
.f = cmd_flow_director_filter_parsed,
.data = NULL,
@@ -10925,51 +10342,7 @@ cmdline_parse_inst_t cmd_add_del_raw_flow_director = {
},
};
-struct cmd_flush_flow_director_result {
- cmdline_fixed_string_t flush_flow_director;
- portid_t port_id;
-};
-
-cmdline_parse_token_string_t cmd_flush_flow_director_flush =
- TOKEN_STRING_INITIALIZER(struct cmd_flush_flow_director_result,
- flush_flow_director, "flush_flow_director");
-cmdline_parse_token_num_t cmd_flush_flow_director_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_flush_flow_director_result,
- port_id, UINT16);
-
-static void
-cmd_flush_flow_director_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_flow_director_result *res = parsed_result;
- int ret = 0;
-
- ret = rte_eth_dev_filter_supported(res->port_id, RTE_ETH_FILTER_FDIR);
- if (ret < 0) {
- printf("flow director is not supported on port %u.\n",
- res->port_id);
- return;
- }
-
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_FLUSH, NULL);
- if (ret < 0)
- printf("flow director table flushing error: (%s)\n",
- strerror(-ret));
-}
-
-cmdline_parse_inst_t cmd_flush_flow_director = {
- .f = cmd_flush_flow_director_parsed,
- .data = NULL,
- .help_str = "flush_flow_director <port_id>: "
- "Flush all flow director entries of a device on NIC",
- .tokens = {
- (void *)&cmd_flush_flow_director_flush,
- (void *)&cmd_flush_flow_director_port_id,
- NULL,
- },
-};
+#endif /* RTE_LIBRTE_I40E_PMD */
/* *** deal with flow director mask *** */
struct cmd_flow_director_mask_result {
@@ -11411,132 +10784,6 @@ cmdline_parse_inst_t cmd_set_flow_director_flex_payload = {
/* Generic flow interface command. */
extern cmdline_parse_inst_t cmd_flow;
-/* *** Classification Filters Control *** */
-
-static enum rte_eth_input_set_field
-str2inset(char *string)
-{
- uint16_t i;
-
- static const struct {
- char str[32];
- enum rte_eth_input_set_field inset;
- } inset_table[] = {
- {"ethertype", RTE_ETH_INPUT_SET_L2_ETHERTYPE},
- {"ovlan", RTE_ETH_INPUT_SET_L2_OUTER_VLAN},
- {"ivlan", RTE_ETH_INPUT_SET_L2_INNER_VLAN},
- {"src-ipv4", RTE_ETH_INPUT_SET_L3_SRC_IP4},
- {"dst-ipv4", RTE_ETH_INPUT_SET_L3_DST_IP4},
- {"ipv4-tos", RTE_ETH_INPUT_SET_L3_IP4_TOS},
- {"ipv4-proto", RTE_ETH_INPUT_SET_L3_IP4_PROTO},
- {"ipv4-ttl", RTE_ETH_INPUT_SET_L3_IP4_TTL},
- {"src-ipv6", RTE_ETH_INPUT_SET_L3_SRC_IP6},
- {"dst-ipv6", RTE_ETH_INPUT_SET_L3_DST_IP6},
- {"ipv6-tc", RTE_ETH_INPUT_SET_L3_IP6_TC},
- {"ipv6-next-header", RTE_ETH_INPUT_SET_L3_IP6_NEXT_HEADER},
- {"ipv6-hop-limits", RTE_ETH_INPUT_SET_L3_IP6_HOP_LIMITS},
- {"udp-src-port", RTE_ETH_INPUT_SET_L4_UDP_SRC_PORT},
- {"udp-dst-port", RTE_ETH_INPUT_SET_L4_UDP_DST_PORT},
- {"tcp-src-port", RTE_ETH_INPUT_SET_L4_TCP_SRC_PORT},
- {"tcp-dst-port", RTE_ETH_INPUT_SET_L4_TCP_DST_PORT},
- {"sctp-src-port", RTE_ETH_INPUT_SET_L4_SCTP_SRC_PORT},
- {"sctp-dst-port", RTE_ETH_INPUT_SET_L4_SCTP_DST_PORT},
- {"sctp-veri-tag", RTE_ETH_INPUT_SET_L4_SCTP_VERIFICATION_TAG},
- {"udp-key", RTE_ETH_INPUT_SET_TUNNEL_L4_UDP_KEY},
- {"gre-key", RTE_ETH_INPUT_SET_TUNNEL_GRE_KEY},
- {"fld-1st", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_1ST_WORD},
- {"fld-2nd", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_2ND_WORD},
- {"fld-3rd", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_3RD_WORD},
- {"fld-4th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_4TH_WORD},
- {"fld-5th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_5TH_WORD},
- {"fld-6th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_6TH_WORD},
- {"fld-7th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_7TH_WORD},
- {"fld-8th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_8TH_WORD},
- {"none", RTE_ETH_INPUT_SET_NONE},
- };
-
- for (i = 0; i < RTE_DIM(inset_table); i++) {
- if (!strcmp(string, inset_table[i].str))
- return inset_table[i].inset;
- }
-
- return RTE_ETH_INPUT_SET_UNKNOWN;
-}
-
-/* Set flow director input set */
-struct cmd_set_fdir_input_set_result {
- cmdline_fixed_string_t set_fdir_input_set;
- portid_t port_id;
- cmdline_fixed_string_t flow_type;
- cmdline_fixed_string_t inset_field;
- cmdline_fixed_string_t select;
-};
-
-static void
-cmd_set_fdir_input_set_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_set_fdir_input_set_result *res = parsed_result;
- struct rte_eth_fdir_filter_info info;
-
- memset(&info, 0, sizeof(info));
- info.info_type = RTE_ETH_FDIR_FILTER_INPUT_SET_SELECT;
- info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
- info.info.input_set_conf.field[0] = str2inset(res->inset_field);
- info.info.input_set_conf.inset_size = 1;
- if (!strcmp(res->select, "select"))
- info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
- else if (!strcmp(res->select, "add"))
- info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
- rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_SET, &info);
-}
-
-cmdline_parse_token_string_t cmd_set_fdir_input_set_cmd =
- TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
- set_fdir_input_set, "set_fdir_input_set");
-cmdline_parse_token_num_t cmd_set_fdir_input_set_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_set_fdir_input_set_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_fdir_input_set_flow_type =
- TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
- flow_type,
- "ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#ipv4-other#"
- "ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#ipv6-other#l2_payload");
-cmdline_parse_token_string_t cmd_set_fdir_input_set_field =
- TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
- inset_field,
- "ivlan#ethertype#src-ipv4#dst-ipv4#src-ipv6#dst-ipv6#"
- "ipv4-tos#ipv4-proto#ipv4-ttl#ipv6-tc#ipv6-next-header#"
- "ipv6-hop-limits#udp-src-port#udp-dst-port#"
- "tcp-src-port#tcp-dst-port#sctp-src-port#sctp-dst-port#"
- "sctp-veri-tag#none");
-cmdline_parse_token_string_t cmd_set_fdir_input_set_select =
- TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
- select, "select#add");
-
-cmdline_parse_inst_t cmd_set_fdir_input_set = {
- .f = cmd_set_fdir_input_set_parsed,
- .data = NULL,
- .help_str = "set_fdir_input_set <port_id> "
- "ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
- "ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
- "ivlan|ethertype|src-ipv4|dst-ipv4|src-ipv6|dst-ipv6|"
- "ipv4-tos|ipv4-proto|ipv4-ttl|ipv6-tc|ipv6-next-header|"
- "ipv6-hop-limits|udp-src-port|udp-dst-port|"
- "tcp-src-port|tcp-dst-port|sctp-src-port|sctp-dst-port|"
- "sctp-veri-tag|none select|add",
- .tokens = {
- (void *)&cmd_set_fdir_input_set_cmd,
- (void *)&cmd_set_fdir_input_set_port_id,
- (void *)&cmd_set_fdir_input_set_flow_type,
- (void *)&cmd_set_fdir_input_set_field,
- (void *)&cmd_set_fdir_input_set_select,
- NULL,
- },
-};
-
/* *** ADD/REMOVE A MULTICAST MAC ADDRESS TO/FROM A PORT *** */
struct cmd_mcast_addr_result {
cmdline_fixed_string_t mcast_addr_cmd;
@@ -18406,20 +17653,14 @@ cmdline_parse_ctx_t main_ctx[] = {
(cmdline_parse_inst_t *)&cmd_config_rss_hash_key,
(cmdline_parse_inst_t *)&cmd_dump,
(cmdline_parse_inst_t *)&cmd_dump_one,
- (cmdline_parse_inst_t *)&cmd_add_del_ip_flow_director,
- (cmdline_parse_inst_t *)&cmd_add_del_udp_flow_director,
- (cmdline_parse_inst_t *)&cmd_add_del_sctp_flow_director,
- (cmdline_parse_inst_t *)&cmd_add_del_l2_flow_director,
- (cmdline_parse_inst_t *)&cmd_add_del_mac_vlan_flow_director,
- (cmdline_parse_inst_t *)&cmd_add_del_tunnel_flow_director,
+#ifdef RTE_LIBRTE_I40E_PMD
(cmdline_parse_inst_t *)&cmd_add_del_raw_flow_director,
- (cmdline_parse_inst_t *)&cmd_flush_flow_director,
+#endif
(cmdline_parse_inst_t *)&cmd_set_flow_director_ip_mask,
(cmdline_parse_inst_t *)&cmd_set_flow_director_mac_vlan_mask,
(cmdline_parse_inst_t *)&cmd_set_flow_director_tunnel_mask,
(cmdline_parse_inst_t *)&cmd_set_flow_director_flex_mask,
(cmdline_parse_inst_t *)&cmd_set_flow_director_flex_payload,
- (cmdline_parse_inst_t *)&cmd_set_fdir_input_set,
(cmdline_parse_inst_t *)&cmd_flow,
(cmdline_parse_inst_t *)&cmd_show_port_meter_cap,
(cmdline_parse_inst_t *)&cmd_add_port_meter_profile_srtcm,
diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c
index ba17f3b0c2..8c01c0891b 100644
--- a/app/test-pmd/config.c
+++ b/app/test-pmd/config.c
@@ -4711,6 +4711,8 @@ flowtype_to_str(uint16_t flow_type)
return NULL;
}
+#if defined(RTE_LIBRTE_I40E_PMD) || defined(RTE_LIBRTE_IXGBE_PMD)
+
static inline void
print_fdir_flex_mask(struct rte_eth_fdir_flex_conf *flex_conf, uint32_t num)
{
@@ -4750,16 +4752,7 @@ static int
get_fdir_info(portid_t port_id, struct rte_eth_fdir_info *fdir_info,
struct rte_eth_fdir_stats *fdir_stat)
{
- int ret;
-
- ret = rte_eth_dev_filter_supported(port_id, RTE_ETH_FILTER_FDIR);
- if (!ret) {
- rte_eth_dev_filter_ctrl(port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_INFO, fdir_info);
- rte_eth_dev_filter_ctrl(port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_STATS, fdir_stat);
- return 0;
- }
+ int ret = -ENOTSUP;
#ifdef RTE_LIBRTE_I40E_PMD
if (ret == -ENOTSUP) {
@@ -4857,6 +4850,8 @@ fdir_get_infos(portid_t port_id)
fdir_stats_border, fdir_stats_border);
}
+#endif /* RTE_LIBRTE_I40E_PMD || RTE_LIBRTE_IXGBE_PMD */
+
void
fdir_set_flex_mask(portid_t port_id, struct rte_eth_fdir_flex_mask *cfg)
{
diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h
index 833ca149cd..d8cbf07c4f 100644
--- a/app/test-pmd/testpmd.h
+++ b/app/test-pmd/testpmd.h
@@ -921,7 +921,9 @@ int all_ports_stopped(void);
int port_is_stopped(portid_t port_id);
int port_is_started(portid_t port_id);
void pmd_test_exit(void);
+#if defined(RTE_LIBRTE_I40E_PMD) || defined(RTE_LIBRTE_IXGBE_PMD)
void fdir_get_infos(portid_t port_id);
+#endif
void fdir_set_flex_mask(portid_t port_id,
struct rte_eth_fdir_flex_mask *cfg);
void fdir_set_flex_payload(portid_t port_id,
diff --git a/doc/guides/rel_notes/deprecation.rst b/doc/guides/rel_notes/deprecation.rst
index 3d241c08e8..18a748bc88 100644
--- a/doc/guides/rel_notes/deprecation.rst
+++ b/doc/guides/rel_notes/deprecation.rst
@@ -107,8 +107,8 @@ Deprecation Notices
* ethdev: the legacy filter API, including
- ``rte_eth_dev_filter_supported()``, ``rte_eth_dev_filter_ctrl()`` as well
- as filter types FDIR, is superseded by the generic flow API (rte_flow) in
+ ``rte_eth_dev_filter_supported()``, ``rte_eth_dev_filter_ctrl()``
+ is superseded by the generic flow API (rte_flow) in
PMDs that implement the latter.
The legacy API will be removed in DPDK 20.11.
diff --git a/drivers/net/bnxt/bnxt_ethdev.c b/drivers/net/bnxt/bnxt_ethdev.c
index 8b68b5fe76..a59fd2e17d 100644
--- a/drivers/net/bnxt/bnxt_ethdev.c
+++ b/drivers/net/bnxt/bnxt_ethdev.c
@@ -2987,399 +2987,6 @@ bnxt_tx_descriptor_status_op(void *tx_queue, uint16_t offset)
return RTE_ETH_TX_DESC_FULL;
}
-static int
-bnxt_parse_fdir_filter(struct bnxt *bp,
- struct rte_eth_fdir_filter *fdir,
- struct bnxt_filter_info *filter)
-{
- enum rte_fdir_mode fdir_mode =
- bp->eth_dev->data->dev_conf.fdir_conf.mode;
- struct bnxt_vnic_info *vnic0, *vnic;
- struct bnxt_filter_info *filter1;
- uint32_t en = 0;
- int i;
-
- if (fdir_mode == RTE_FDIR_MODE_PERFECT_TUNNEL)
- return -EINVAL;
-
- filter->l2_ovlan = fdir->input.flow_ext.vlan_tci;
- en |= EM_FLOW_ALLOC_INPUT_EN_OVLAN_VID;
-
- switch (fdir->input.flow_type) {
- case RTE_ETH_FLOW_IPV4:
- case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
- /* FALLTHROUGH */
- filter->src_ipaddr[0] = fdir->input.flow.ip4_flow.src_ip;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR;
- filter->dst_ipaddr[0] = fdir->input.flow.ip4_flow.dst_ip;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR;
- filter->ip_protocol = fdir->input.flow.ip4_flow.proto;
- en |= NTUPLE_FLTR_ALLOC_IN_EN_IP_PROTO;
- filter->ip_addr_type =
- NTUPLE_FLTR_ALLOC_INPUT_IP_ADDR_TYPE_IPV4;
- filter->src_ipaddr_mask[0] = 0xffffffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR_MASK;
- filter->dst_ipaddr_mask[0] = 0xffffffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR_MASK;
- filter->ethertype = 0x800;
- filter->enables |= NTUPLE_FLTR_ALLOC_INPUT_EN_ETHERTYPE;
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
- filter->src_port = fdir->input.flow.tcp4_flow.src_port;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_PORT;
- filter->dst_port = fdir->input.flow.tcp4_flow.dst_port;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_PORT;
- filter->dst_port_mask = 0xffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_PORT_MASK;
- filter->src_port_mask = 0xffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_PORT_MASK;
- filter->src_ipaddr[0] = fdir->input.flow.tcp4_flow.ip.src_ip;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR;
- filter->dst_ipaddr[0] = fdir->input.flow.tcp4_flow.ip.dst_ip;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR;
- filter->ip_protocol = 6;
- en |= NTUPLE_FLTR_ALLOC_IN_EN_IP_PROTO;
- filter->ip_addr_type =
- NTUPLE_FLTR_ALLOC_INPUT_IP_ADDR_TYPE_IPV4;
- filter->src_ipaddr_mask[0] = 0xffffffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR_MASK;
- filter->dst_ipaddr_mask[0] = 0xffffffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR_MASK;
- filter->ethertype = 0x800;
- filter->enables |= NTUPLE_FLTR_ALLOC_INPUT_EN_ETHERTYPE;
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
- filter->src_port = fdir->input.flow.udp4_flow.src_port;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_PORT;
- filter->dst_port = fdir->input.flow.udp4_flow.dst_port;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_PORT;
- filter->dst_port_mask = 0xffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_PORT_MASK;
- filter->src_port_mask = 0xffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_PORT_MASK;
- filter->src_ipaddr[0] = fdir->input.flow.udp4_flow.ip.src_ip;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR;
- filter->dst_ipaddr[0] = fdir->input.flow.udp4_flow.ip.dst_ip;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR;
- filter->ip_protocol = 17;
- en |= NTUPLE_FLTR_ALLOC_IN_EN_IP_PROTO;
- filter->ip_addr_type =
- NTUPLE_FLTR_ALLOC_INPUT_IP_ADDR_TYPE_IPV4;
- filter->src_ipaddr_mask[0] = 0xffffffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR_MASK;
- filter->dst_ipaddr_mask[0] = 0xffffffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR_MASK;
- filter->ethertype = 0x800;
- filter->enables |= NTUPLE_FLTR_ALLOC_INPUT_EN_ETHERTYPE;
- break;
- case RTE_ETH_FLOW_IPV6:
- case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
- /* FALLTHROUGH */
- filter->ip_addr_type =
- NTUPLE_FLTR_ALLOC_INPUT_IP_ADDR_TYPE_IPV6;
- filter->ip_protocol = fdir->input.flow.ipv6_flow.proto;
- en |= NTUPLE_FLTR_ALLOC_IN_EN_IP_PROTO;
- rte_memcpy(filter->src_ipaddr,
- fdir->input.flow.ipv6_flow.src_ip, 16);
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR;
- rte_memcpy(filter->dst_ipaddr,
- fdir->input.flow.ipv6_flow.dst_ip, 16);
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR;
- memset(filter->dst_ipaddr_mask, 0xff, 16);
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR_MASK;
- memset(filter->src_ipaddr_mask, 0xff, 16);
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR_MASK;
- filter->ethertype = 0x86dd;
- filter->enables |= NTUPLE_FLTR_ALLOC_INPUT_EN_ETHERTYPE;
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
- filter->src_port = fdir->input.flow.tcp6_flow.src_port;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_PORT;
- filter->dst_port = fdir->input.flow.tcp6_flow.dst_port;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_PORT;
- filter->dst_port_mask = 0xffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_PORT_MASK;
- filter->src_port_mask = 0xffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_PORT_MASK;
- filter->ip_addr_type =
- NTUPLE_FLTR_ALLOC_INPUT_IP_ADDR_TYPE_IPV6;
- filter->ip_protocol = fdir->input.flow.tcp6_flow.ip.proto;
- en |= NTUPLE_FLTR_ALLOC_IN_EN_IP_PROTO;
- rte_memcpy(filter->src_ipaddr,
- fdir->input.flow.tcp6_flow.ip.src_ip, 16);
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR;
- rte_memcpy(filter->dst_ipaddr,
- fdir->input.flow.tcp6_flow.ip.dst_ip, 16);
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR;
- memset(filter->dst_ipaddr_mask, 0xff, 16);
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR_MASK;
- memset(filter->src_ipaddr_mask, 0xff, 16);
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR_MASK;
- filter->ethertype = 0x86dd;
- filter->enables |= NTUPLE_FLTR_ALLOC_INPUT_EN_ETHERTYPE;
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
- filter->src_port = fdir->input.flow.udp6_flow.src_port;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_PORT;
- filter->dst_port = fdir->input.flow.udp6_flow.dst_port;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_PORT;
- filter->dst_port_mask = 0xffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_PORT_MASK;
- filter->src_port_mask = 0xffff;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_PORT_MASK;
- filter->ip_addr_type =
- NTUPLE_FLTR_ALLOC_INPUT_IP_ADDR_TYPE_IPV6;
- filter->ip_protocol = fdir->input.flow.udp6_flow.ip.proto;
- en |= NTUPLE_FLTR_ALLOC_IN_EN_IP_PROTO;
- rte_memcpy(filter->src_ipaddr,
- fdir->input.flow.udp6_flow.ip.src_ip, 16);
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR;
- rte_memcpy(filter->dst_ipaddr,
- fdir->input.flow.udp6_flow.ip.dst_ip, 16);
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR;
- memset(filter->dst_ipaddr_mask, 0xff, 16);
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR_MASK;
- memset(filter->src_ipaddr_mask, 0xff, 16);
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR_MASK;
- filter->ethertype = 0x86dd;
- filter->enables |= NTUPLE_FLTR_ALLOC_INPUT_EN_ETHERTYPE;
- break;
- case RTE_ETH_FLOW_L2_PAYLOAD:
- filter->ethertype = fdir->input.flow.l2_flow.ether_type;
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_ETHERTYPE;
- break;
- case RTE_ETH_FLOW_VXLAN:
- if (fdir->action.behavior == RTE_ETH_FDIR_REJECT)
- return -EINVAL;
- filter->vni = fdir->input.flow.tunnel_flow.tunnel_id;
- filter->tunnel_type =
- CFA_NTUPLE_FILTER_ALLOC_REQ_TUNNEL_TYPE_VXLAN;
- en |= HWRM_CFA_NTUPLE_FILTER_ALLOC_INPUT_ENABLES_TUNNEL_TYPE;
- break;
- case RTE_ETH_FLOW_NVGRE:
- if (fdir->action.behavior == RTE_ETH_FDIR_REJECT)
- return -EINVAL;
- filter->vni = fdir->input.flow.tunnel_flow.tunnel_id;
- filter->tunnel_type =
- CFA_NTUPLE_FILTER_ALLOC_REQ_TUNNEL_TYPE_NVGRE;
- en |= HWRM_CFA_NTUPLE_FILTER_ALLOC_INPUT_ENABLES_TUNNEL_TYPE;
- break;
- case RTE_ETH_FLOW_UNKNOWN:
- case RTE_ETH_FLOW_RAW:
- case RTE_ETH_FLOW_FRAG_IPV4:
- case RTE_ETH_FLOW_NONFRAG_IPV4_SCTP:
- case RTE_ETH_FLOW_FRAG_IPV6:
- case RTE_ETH_FLOW_NONFRAG_IPV6_SCTP:
- case RTE_ETH_FLOW_IPV6_EX:
- case RTE_ETH_FLOW_IPV6_TCP_EX:
- case RTE_ETH_FLOW_IPV6_UDP_EX:
- case RTE_ETH_FLOW_GENEVE:
- /* FALLTHROUGH */
- default:
- return -EINVAL;
- }
-
- vnic0 = BNXT_GET_DEFAULT_VNIC(bp);
- vnic = &bp->vnic_info[fdir->action.rx_queue];
- if (vnic == NULL) {
- PMD_DRV_LOG(ERR, "Invalid queue %d\n", fdir->action.rx_queue);
- return -EINVAL;
- }
-
- if (fdir_mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) {
- rte_memcpy(filter->dst_macaddr,
- fdir->input.flow.mac_vlan_flow.mac_addr.addr_bytes, 6);
- en |= NTUPLE_FLTR_ALLOC_INPUT_EN_DST_MACADDR;
- }
-
- if (fdir->action.behavior == RTE_ETH_FDIR_REJECT) {
- filter->flags = HWRM_CFA_NTUPLE_FILTER_ALLOC_INPUT_FLAGS_DROP;
- filter1 = STAILQ_FIRST(&vnic0->filter);
- //filter1 = bnxt_get_l2_filter(bp, filter, vnic0);
- } else {
- filter->dst_id = vnic->fw_vnic_id;
- for (i = 0; i < RTE_ETHER_ADDR_LEN; i++)
- if (filter->dst_macaddr[i] == 0x00)
- filter1 = STAILQ_FIRST(&vnic0->filter);
- else
- filter1 = bnxt_get_l2_filter(bp, filter, vnic);
- }
-
- if (filter1 == NULL)
- return -EINVAL;
-
- en |= HWRM_CFA_NTUPLE_FILTER_ALLOC_INPUT_ENABLES_L2_FILTER_ID;
- filter->fw_l2_filter_id = filter1->fw_l2_filter_id;
-
- filter->enables = en;
-
- return 0;
-}
-
-static struct bnxt_filter_info *
-bnxt_match_fdir(struct bnxt *bp, struct bnxt_filter_info *nf,
- struct bnxt_vnic_info **mvnic)
-{
- struct bnxt_filter_info *mf = NULL;
- int i;
-
- for (i = bp->nr_vnics - 1; i >= 0; i--) {
- struct bnxt_vnic_info *vnic = &bp->vnic_info[i];
-
- STAILQ_FOREACH(mf, &vnic->filter, next) {
- if (mf->filter_type == nf->filter_type &&
- mf->flags == nf->flags &&
- mf->src_port == nf->src_port &&
- mf->src_port_mask == nf->src_port_mask &&
- mf->dst_port == nf->dst_port &&
- mf->dst_port_mask == nf->dst_port_mask &&
- mf->ip_protocol == nf->ip_protocol &&
- mf->ip_addr_type == nf->ip_addr_type &&
- mf->ethertype == nf->ethertype &&
- mf->vni == nf->vni &&
- mf->tunnel_type == nf->tunnel_type &&
- mf->l2_ovlan == nf->l2_ovlan &&
- mf->l2_ovlan_mask == nf->l2_ovlan_mask &&
- mf->l2_ivlan == nf->l2_ivlan &&
- mf->l2_ivlan_mask == nf->l2_ivlan_mask &&
- !memcmp(mf->l2_addr, nf->l2_addr,
- RTE_ETHER_ADDR_LEN) &&
- !memcmp(mf->l2_addr_mask, nf->l2_addr_mask,
- RTE_ETHER_ADDR_LEN) &&
- !memcmp(mf->src_macaddr, nf->src_macaddr,
- RTE_ETHER_ADDR_LEN) &&
- !memcmp(mf->dst_macaddr, nf->dst_macaddr,
- RTE_ETHER_ADDR_LEN) &&
- !memcmp(mf->src_ipaddr, nf->src_ipaddr,
- sizeof(nf->src_ipaddr)) &&
- !memcmp(mf->src_ipaddr_mask, nf->src_ipaddr_mask,
- sizeof(nf->src_ipaddr_mask)) &&
- !memcmp(mf->dst_ipaddr, nf->dst_ipaddr,
- sizeof(nf->dst_ipaddr)) &&
- !memcmp(mf->dst_ipaddr_mask, nf->dst_ipaddr_mask,
- sizeof(nf->dst_ipaddr_mask))) {
- if (mvnic)
- *mvnic = vnic;
- return mf;
- }
- }
- }
- return NULL;
-}
-
-static int
-bnxt_fdir_filter(struct rte_eth_dev *dev,
- enum rte_filter_op filter_op,
- void *arg)
-{
- struct bnxt *bp = dev->data->dev_private;
- struct rte_eth_fdir_filter *fdir = (struct rte_eth_fdir_filter *)arg;
- struct bnxt_filter_info *filter, *match;
- struct bnxt_vnic_info *vnic, *mvnic;
- int ret = 0, i;
-
- if (filter_op == RTE_ETH_FILTER_NOP)
- return 0;
-
- if (arg == NULL && filter_op != RTE_ETH_FILTER_FLUSH)
- return -EINVAL;
-
- switch (filter_op) {
- case RTE_ETH_FILTER_ADD:
- case RTE_ETH_FILTER_DELETE:
- /* FALLTHROUGH */
- filter = bnxt_get_unused_filter(bp);
- if (filter == NULL) {
- PMD_DRV_LOG(ERR,
- "Not enough resources for a new flow.\n");
- return -ENOMEM;
- }
-
- ret = bnxt_parse_fdir_filter(bp, fdir, filter);
- if (ret != 0)
- goto free_filter;
- filter->filter_type = HWRM_CFA_NTUPLE_FILTER;
-
- if (fdir->action.behavior == RTE_ETH_FDIR_REJECT)
- vnic = &bp->vnic_info[0];
- else
- vnic = &bp->vnic_info[fdir->action.rx_queue];
-
- match = bnxt_match_fdir(bp, filter, &mvnic);
- if (match != NULL && filter_op == RTE_ETH_FILTER_ADD) {
- if (match->dst_id == vnic->fw_vnic_id) {
- PMD_DRV_LOG(ERR, "Flow already exists.\n");
- ret = -EEXIST;
- goto free_filter;
- } else {
- match->dst_id = vnic->fw_vnic_id;
- ret = bnxt_hwrm_set_ntuple_filter(bp,
- match->dst_id,
- match);
- STAILQ_REMOVE(&mvnic->filter, match,
- bnxt_filter_info, next);
- STAILQ_INSERT_TAIL(&vnic->filter, match, next);
- PMD_DRV_LOG(ERR,
- "Filter with matching pattern exist\n");
- PMD_DRV_LOG(ERR,
- "Updated it to new destination q\n");
- goto free_filter;
- }
- }
- if (match == NULL && filter_op == RTE_ETH_FILTER_DELETE) {
- PMD_DRV_LOG(ERR, "Flow does not exist.\n");
- ret = -ENOENT;
- goto free_filter;
- }
-
- if (filter_op == RTE_ETH_FILTER_ADD) {
- ret = bnxt_hwrm_set_ntuple_filter(bp,
- filter->dst_id,
- filter);
- if (ret)
- goto free_filter;
- STAILQ_INSERT_TAIL(&vnic->filter, filter, next);
- } else {
- ret = bnxt_hwrm_clear_ntuple_filter(bp, match);
- STAILQ_REMOVE(&vnic->filter, match,
- bnxt_filter_info, next);
- bnxt_free_filter(bp, match);
- bnxt_free_filter(bp, filter);
- }
- break;
- case RTE_ETH_FILTER_FLUSH:
- for (i = bp->nr_vnics - 1; i >= 0; i--) {
- struct bnxt_vnic_info *vnic = &bp->vnic_info[i];
-
- STAILQ_FOREACH(filter, &vnic->filter, next) {
- if (filter->filter_type ==
- HWRM_CFA_NTUPLE_FILTER) {
- ret =
- bnxt_hwrm_clear_ntuple_filter(bp,
- filter);
- STAILQ_REMOVE(&vnic->filter, filter,
- bnxt_filter_info, next);
- }
- }
- }
- return ret;
- case RTE_ETH_FILTER_UPDATE:
- case RTE_ETH_FILTER_STATS:
- case RTE_ETH_FILTER_INFO:
- PMD_DRV_LOG(ERR, "operation %u not implemented", filter_op);
- break;
- default:
- PMD_DRV_LOG(ERR, "unknown operation %u", filter_op);
- ret = -EINVAL;
- break;
- }
- return ret;
-
-free_filter:
- bnxt_free_filter(bp, filter);
- return ret;
-}
-
int
bnxt_filter_ctrl_op(struct rte_eth_dev *dev,
enum rte_filter_type filter_type,
@@ -3409,9 +3016,6 @@ bnxt_filter_ctrl_op(struct rte_eth_dev *dev,
return ret;
switch (filter_type) {
- case RTE_ETH_FILTER_FDIR:
- ret = bnxt_fdir_filter(dev, filter_op, arg);
- break;
case RTE_ETH_FILTER_GENERIC:
if (filter_op != RTE_ETH_FILTER_GET)
return -EINVAL;
diff --git a/drivers/net/enic/enic.h b/drivers/net/enic/enic.h
index 5f0ae395da..079f194275 100644
--- a/drivers/net/enic/enic.h
+++ b/drivers/net/enic/enic.h
@@ -394,12 +394,6 @@ enic_ring_incr(uint32_t n_descriptors, uint32_t idx)
}
int dev_is_enic(struct rte_eth_dev *dev);
-void enic_fdir_stats_get(struct enic *enic,
- struct rte_eth_fdir_stats *stats);
-int enic_fdir_add_fltr(struct enic *enic,
- struct rte_eth_fdir_filter *params);
-int enic_fdir_del_fltr(struct enic *enic,
- struct rte_eth_fdir_filter *params);
void enic_free_wq(void *txq);
int enic_alloc_intr_resources(struct enic *enic);
int enic_setup_finish(struct enic *enic);
@@ -464,7 +458,6 @@ bool enic_use_vector_rx_handler(struct rte_eth_dev *eth_dev);
void enic_pick_rx_handler(struct rte_eth_dev *eth_dev);
void enic_pick_tx_handler(struct rte_eth_dev *eth_dev);
void enic_fdir_info(struct enic *enic);
-void enic_fdir_info_get(struct enic *enic, struct rte_eth_fdir_info *stats);
int enic_vf_representor_init(struct rte_eth_dev *eth_dev, void *init_params);
int enic_vf_representor_uninit(struct rte_eth_dev *ethdev);
int enic_fm_allocate_switch_domain(struct enic *pf);
diff --git a/drivers/net/enic/enic_clsf.c b/drivers/net/enic/enic_clsf.c
index e206123ba5..1c837a4d09 100644
--- a/drivers/net/enic/enic_clsf.c
+++ b/drivers/net/enic/enic_clsf.c
@@ -42,17 +42,6 @@ static void copy_fltr_v2(struct filter_v2 *fltr,
const struct rte_eth_fdir_input *input,
const struct rte_eth_fdir_masks *masks);
-void enic_fdir_stats_get(struct enic *enic, struct rte_eth_fdir_stats *stats)
-{
- *stats = enic->fdir.stats;
-}
-
-void enic_fdir_info_get(struct enic *enic, struct rte_eth_fdir_info *info)
-{
- info->mode = (enum rte_fdir_mode)enic->fdir.modes;
- info->flow_types_mask[0] = enic->fdir.types_mask;
-}
-
void enic_fdir_info(struct enic *enic)
{
enic->fdir.modes = (uint32_t)RTE_FDIR_MODE_PERFECT;
@@ -305,163 +294,6 @@ copy_fltr_v2(struct filter_v2 *fltr, const struct rte_eth_fdir_input *input,
}
}
-int enic_fdir_del_fltr(struct enic *enic, struct rte_eth_fdir_filter *params)
-{
- int32_t pos;
- struct enic_fdir_node *key;
- /* See if the key is in the table */
- pos = rte_hash_del_key(enic->fdir.hash, params);
- switch (pos) {
- case -EINVAL:
- case -ENOENT:
- enic->fdir.stats.f_remove++;
- return -EINVAL;
- default:
- /* The entry is present in the table */
- key = enic->fdir.nodes[pos];
-
- /* Delete the filter */
- vnic_dev_classifier(enic->vdev, CLSF_DEL,
- &key->fltr_id, NULL, NULL);
- rte_free(key);
- enic->fdir.nodes[pos] = NULL;
- enic->fdir.stats.free++;
- enic->fdir.stats.remove++;
- break;
- }
- return 0;
-}
-
-int enic_fdir_add_fltr(struct enic *enic, struct rte_eth_fdir_filter *params)
-{
- struct enic_fdir_node *key;
- struct filter_v2 fltr;
- int32_t pos;
- uint8_t do_free = 0;
- uint16_t old_fltr_id = 0;
- uint32_t flowtype_supported;
- uint16_t flex_bytes;
- uint16_t queue;
- struct filter_action_v2 action;
-
- memset(&fltr, 0, sizeof(fltr));
- memset(&action, 0, sizeof(action));
- flowtype_supported = enic->fdir.types_mask
- & (1 << params->input.flow_type);
-
- flex_bytes = ((params->input.flow_ext.flexbytes[1] << 8 & 0xFF00) |
- (params->input.flow_ext.flexbytes[0] & 0xFF));
-
- if (!enic->fdir.hash ||
- (params->input.flow_ext.vlan_tci & 0xFFF) ||
- !flowtype_supported || flex_bytes ||
- params->action.behavior /* drop */) {
- enic->fdir.stats.f_add++;
- return -ENOTSUP;
- }
-
- /* Get the enicpmd RQ from the DPDK Rx queue */
- queue = enic_rte_rq_idx_to_sop_idx(params->action.rx_queue);
-
- if (!enic->rq[queue].in_use)
- return -EINVAL;
-
- /* See if the key is already there in the table */
- pos = rte_hash_del_key(enic->fdir.hash, params);
- switch (pos) {
- case -EINVAL:
- enic->fdir.stats.f_add++;
- return -EINVAL;
- case -ENOENT:
- /* Add a new classifier entry */
- if (!enic->fdir.stats.free) {
- enic->fdir.stats.f_add++;
- return -ENOSPC;
- }
- key = rte_zmalloc("enic_fdir_node",
- sizeof(struct enic_fdir_node), 0);
- if (!key) {
- enic->fdir.stats.f_add++;
- return -ENOMEM;
- }
- break;
- default:
- /* The entry is already present in the table.
- * Check if there is a change in queue
- */
- key = enic->fdir.nodes[pos];
- enic->fdir.nodes[pos] = NULL;
- if (unlikely(key->rq_index == queue)) {
- /* Nothing to be done */
- enic->fdir.stats.f_add++;
- pos = rte_hash_add_key(enic->fdir.hash, params);
- if (pos < 0) {
- dev_err(enic, "Add hash key failed\n");
- return pos;
- }
- enic->fdir.nodes[pos] = key;
- dev_warning(enic,
- "FDIR rule is already present\n");
- return 0;
- }
-
- if (likely(enic->fdir.stats.free)) {
- /* Add the filter and then delete the old one.
- * This is to avoid packets from going into the
- * default queue during the window between
- * delete and add
- */
- do_free = 1;
- old_fltr_id = key->fltr_id;
- } else {
- /* No free slots in the classifier.
- * Delete the filter and add the modified one later
- */
- vnic_dev_classifier(enic->vdev, CLSF_DEL,
- &key->fltr_id, NULL, NULL);
- enic->fdir.stats.free++;
- }
-
- break;
- }
-
- key->filter = *params;
- key->rq_index = queue;
-
- enic->fdir.copy_fltr_fn(&fltr, ¶ms->input,
- &enic->rte_dev->data->dev_conf.fdir_conf.mask);
- action.type = FILTER_ACTION_RQ_STEERING;
- action.rq_idx = queue;
-
- if (!vnic_dev_classifier(enic->vdev, CLSF_ADD, &queue, &fltr,
- &action)) {
- key->fltr_id = queue;
- } else {
- dev_err(enic, "Add classifier entry failed\n");
- enic->fdir.stats.f_add++;
- rte_free(key);
- return -1;
- }
-
- if (do_free)
- vnic_dev_classifier(enic->vdev, CLSF_DEL, &old_fltr_id, NULL,
- NULL);
- else{
- enic->fdir.stats.free--;
- enic->fdir.stats.add++;
- }
-
- pos = rte_hash_add_key(enic->fdir.hash, params);
- if (pos < 0) {
- enic->fdir.stats.f_add++;
- dev_err(enic, "Add hash key failed\n");
- return pos;
- }
-
- enic->fdir.nodes[pos] = key;
- return 0;
-}
-
void enic_clsf_destroy(struct enic *enic)
{
uint32_t index;
diff --git a/drivers/net/enic/enic_ethdev.c b/drivers/net/enic/enic_ethdev.c
index 8d0054ffec..d041a6bee9 100644
--- a/drivers/net/enic/enic_ethdev.c
+++ b/drivers/net/enic/enic_ethdev.c
@@ -72,51 +72,6 @@ static const struct vic_speed_capa {
RTE_LOG_REGISTER(enic_pmd_logtype, pmd.net.enic, INFO);
-static int
-enicpmd_fdir_ctrl_func(struct rte_eth_dev *eth_dev,
- enum rte_filter_op filter_op, void *arg)
-{
- struct enic *enic = pmd_priv(eth_dev);
- int ret = 0;
-
- ENICPMD_FUNC_TRACE();
- if (filter_op == RTE_ETH_FILTER_NOP)
- return 0;
-
- if (arg == NULL && filter_op != RTE_ETH_FILTER_FLUSH)
- return -EINVAL;
-
- switch (filter_op) {
- case RTE_ETH_FILTER_ADD:
- case RTE_ETH_FILTER_UPDATE:
- ret = enic_fdir_add_fltr(enic,
- (struct rte_eth_fdir_filter *)arg);
- break;
-
- case RTE_ETH_FILTER_DELETE:
- ret = enic_fdir_del_fltr(enic,
- (struct rte_eth_fdir_filter *)arg);
- break;
-
- case RTE_ETH_FILTER_STATS:
- enic_fdir_stats_get(enic, (struct rte_eth_fdir_stats *)arg);
- break;
-
- case RTE_ETH_FILTER_FLUSH:
- dev_warning(enic, "unsupported operation %u", filter_op);
- ret = -ENOTSUP;
- break;
- case RTE_ETH_FILTER_INFO:
- enic_fdir_info_get(enic, (struct rte_eth_fdir_info *)arg);
- break;
- default:
- dev_err(enic, "unknown operation %u", filter_op);
- ret = -EINVAL;
- break;
- }
- return ret;
-}
-
static int
enicpmd_dev_filter_ctrl(struct rte_eth_dev *dev,
enum rte_filter_type filter_type,
@@ -143,9 +98,6 @@ enicpmd_dev_filter_ctrl(struct rte_eth_dev *dev,
else
*(const void **)arg = &enic_flow_ops;
break;
- case RTE_ETH_FILTER_FDIR:
- ret = enicpmd_fdir_ctrl_func(dev, filter_op, arg);
- break;
default:
dev_warning(enic, "Filter type (%d) not supported",
filter_type);
diff --git a/drivers/net/i40e/i40e_ethdev.c b/drivers/net/i40e/i40e_ethdev.c
index 9d6d482aba..f54769c29d 100644
--- a/drivers/net/i40e/i40e_ethdev.c
+++ b/drivers/net/i40e/i40e_ethdev.c
@@ -9685,89 +9685,6 @@ i40e_hash_filter_inset_select(struct i40e_hw *hw,
return 0;
}
-int
-i40e_fdir_filter_inset_select(struct i40e_pf *pf,
- struct rte_eth_input_set_conf *conf)
-{
- struct i40e_hw *hw = I40E_PF_TO_HW(pf);
- enum i40e_filter_pctype pctype;
- uint64_t input_set, inset_reg = 0;
- uint32_t mask_reg[I40E_INSET_MASK_NUM_REG] = {0};
- int ret, i, num;
-
- if (!hw || !conf) {
- PMD_DRV_LOG(ERR, "Invalid pointer");
- return -EFAULT;
- }
- if (conf->op != RTE_ETH_INPUT_SET_SELECT &&
- conf->op != RTE_ETH_INPUT_SET_ADD) {
- PMD_DRV_LOG(ERR, "Unsupported input set operation");
- return -EINVAL;
- }
-
- pctype = i40e_flowtype_to_pctype(pf->adapter, conf->flow_type);
-
- if (pctype == I40E_FILTER_PCTYPE_INVALID) {
- PMD_DRV_LOG(ERR, "invalid flow_type input.");
- return -EINVAL;
- }
-
- ret = i40e_parse_input_set(&input_set, pctype, conf->field,
- conf->inset_size);
- if (ret) {
- PMD_DRV_LOG(ERR, "Failed to parse input set");
- return -EINVAL;
- }
-
- /* get inset value in register */
- inset_reg = i40e_read_rx_ctl(hw, I40E_PRTQF_FD_INSET(pctype, 1));
- inset_reg <<= I40E_32_BIT_WIDTH;
- inset_reg |= i40e_read_rx_ctl(hw, I40E_PRTQF_FD_INSET(pctype, 0));
-
- /* Can not change the inset reg for flex payload for fdir,
- * it is done by writing I40E_PRTQF_FD_FLXINSET
- * in i40e_set_flex_mask_on_pctype.
- */
- if (conf->op == RTE_ETH_INPUT_SET_SELECT)
- inset_reg &= I40E_REG_INSET_FLEX_PAYLOAD_WORDS;
- else
- input_set |= pf->fdir.input_set[pctype];
- num = i40e_generate_inset_mask_reg(input_set, mask_reg,
- I40E_INSET_MASK_NUM_REG);
- if (num < 0)
- return -EINVAL;
- if (pf->support_multi_driver && num > 0) {
- PMD_DRV_LOG(ERR, "FDIR bit mask is not supported.");
- return -ENOTSUP;
- }
-
- inset_reg |= i40e_translate_input_set_reg(hw->mac.type, input_set);
-
- i40e_check_write_reg(hw, I40E_PRTQF_FD_INSET(pctype, 0),
- (uint32_t)(inset_reg & UINT32_MAX));
- i40e_check_write_reg(hw, I40E_PRTQF_FD_INSET(pctype, 1),
- (uint32_t)((inset_reg >>
- I40E_32_BIT_WIDTH) & UINT32_MAX));
-
- if (!pf->support_multi_driver) {
- for (i = 0; i < num; i++)
- i40e_check_write_global_reg(hw,
- I40E_GLQF_FD_MSK(i, pctype),
- mask_reg[i]);
- /*clear unused mask registers of the pctype */
- for (i = num; i < I40E_INSET_MASK_NUM_REG; i++)
- i40e_check_write_global_reg(hw,
- I40E_GLQF_FD_MSK(i, pctype),
- 0);
- } else {
- PMD_DRV_LOG(ERR, "FDIR bit mask is not supported.");
- }
- I40E_WRITE_FLUSH(hw);
-
- pf->fdir.input_set[pctype] = input_set;
- return 0;
-}
-
/* Convert ethertype filter structure */
static int
i40e_ethertype_filter_convert(const struct rte_eth_ethertype_filter *input,
@@ -9945,9 +9862,6 @@ i40e_dev_filter_ctrl(struct rte_eth_dev *dev,
return -EINVAL;
switch (filter_type) {
- case RTE_ETH_FILTER_FDIR:
- ret = i40e_fdir_ctrl_func(dev, filter_op, arg);
- break;
case RTE_ETH_FILTER_GENERIC:
if (filter_op != RTE_ETH_FILTER_GET)
return -EINVAL;
diff --git a/drivers/net/i40e/i40e_ethdev.h b/drivers/net/i40e/i40e_ethdev.h
index 458219c784..e74f758f6a 100644
--- a/drivers/net/i40e/i40e_ethdev.h
+++ b/drivers/net/i40e/i40e_ethdev.h
@@ -664,8 +664,7 @@ struct i40e_fdir_action {
};
/* A structure used to define the flow director filter entry by filter_ctrl API
- * It supports RTE_ETH_FILTER_FDIR with RTE_ETH_FILTER_ADD and
- * RTE_ETH_FILTER_DELETE operations.
+ * It supports RTE_ETH_FILTER_FDIR data representation.
*/
struct i40e_fdir_filter_conf {
uint32_t soft_id;
@@ -1368,17 +1367,12 @@ void i40e_fdir_info_get(struct rte_eth_dev *dev,
struct rte_eth_fdir_info *fdir);
void i40e_fdir_stats_get(struct rte_eth_dev *dev,
struct rte_eth_fdir_stats *stat);
-int i40e_fdir_ctrl_func(struct rte_eth_dev *dev,
- enum rte_filter_op filter_op,
- void *arg);
int i40e_select_filter_input_set(struct i40e_hw *hw,
struct rte_eth_input_set_conf *conf,
enum rte_filter_type filter);
void i40e_fdir_filter_restore(struct i40e_pf *pf);
int i40e_hash_filter_inset_select(struct i40e_hw *hw,
struct rte_eth_input_set_conf *conf);
-int i40e_fdir_filter_inset_select(struct i40e_pf *pf,
- struct rte_eth_input_set_conf *conf);
int i40e_pf_host_send_msg_to_vf(struct i40e_pf_vf *vf, uint32_t opcode,
uint32_t retval, uint8_t *msg,
uint16_t msglen);
@@ -1406,9 +1400,6 @@ uint64_t i40e_get_default_input_set(uint16_t pctype);
int i40e_ethertype_filter_set(struct i40e_pf *pf,
struct rte_eth_ethertype_filter *filter,
bool add);
-int i40e_add_del_fdir_filter(struct rte_eth_dev *dev,
- const struct rte_eth_fdir_filter *filter,
- bool add);
struct rte_flow *
i40e_fdir_entry_pool_get(struct i40e_fdir_info *fdir_info);
void i40e_fdir_entry_pool_put(struct i40e_fdir_info *fdir_info,
diff --git a/drivers/net/i40e/i40e_fdir.c b/drivers/net/i40e/i40e_fdir.c
index aa8e729495..b61e605364 100644
--- a/drivers/net/i40e/i40e_fdir.c
+++ b/drivers/net/i40e/i40e_fdir.c
@@ -85,10 +85,6 @@
(1ULL << RTE_ETH_FLOW_NONFRAG_IPV6_OTHER) | \
(1ULL << RTE_ETH_FLOW_L2_PAYLOAD))
-static int i40e_fdir_filter_programming(struct i40e_pf *pf,
- enum i40e_filter_pctype pctype,
- const struct rte_eth_fdir_filter *filter,
- bool add);
static int i40e_fdir_filter_convert(const struct i40e_fdir_filter_conf *input,
struct i40e_fdir_filter *filter);
static struct i40e_fdir_filter *
@@ -731,263 +727,6 @@ i40e_fdir_configure(struct rte_eth_dev *dev)
return ret;
}
-static inline int
-i40e_fdir_fill_eth_ip_head(const struct rte_eth_fdir_input *fdir_input,
- unsigned char *raw_pkt,
- bool vlan)
-{
- static uint8_t vlan_frame[] = {0x81, 0, 0, 0};
- uint16_t *ether_type;
- uint8_t len = 2 * sizeof(struct rte_ether_addr);
- struct rte_ipv4_hdr *ip;
- struct rte_ipv6_hdr *ip6;
- static const uint8_t next_proto[] = {
- [RTE_ETH_FLOW_FRAG_IPV4] = IPPROTO_IP,
- [RTE_ETH_FLOW_NONFRAG_IPV4_TCP] = IPPROTO_TCP,
- [RTE_ETH_FLOW_NONFRAG_IPV4_UDP] = IPPROTO_UDP,
- [RTE_ETH_FLOW_NONFRAG_IPV4_SCTP] = IPPROTO_SCTP,
- [RTE_ETH_FLOW_NONFRAG_IPV4_OTHER] = IPPROTO_IP,
- [RTE_ETH_FLOW_FRAG_IPV6] = IPPROTO_NONE,
- [RTE_ETH_FLOW_NONFRAG_IPV6_TCP] = IPPROTO_TCP,
- [RTE_ETH_FLOW_NONFRAG_IPV6_UDP] = IPPROTO_UDP,
- [RTE_ETH_FLOW_NONFRAG_IPV6_SCTP] = IPPROTO_SCTP,
- [RTE_ETH_FLOW_NONFRAG_IPV6_OTHER] = IPPROTO_NONE,
- };
-
- raw_pkt += 2 * sizeof(struct rte_ether_addr);
- if (vlan && fdir_input->flow_ext.vlan_tci) {
- rte_memcpy(raw_pkt, vlan_frame, sizeof(vlan_frame));
- rte_memcpy(raw_pkt + sizeof(uint16_t),
- &fdir_input->flow_ext.vlan_tci,
- sizeof(uint16_t));
- raw_pkt += sizeof(vlan_frame);
- len += sizeof(vlan_frame);
- }
- ether_type = (uint16_t *)raw_pkt;
- raw_pkt += sizeof(uint16_t);
- len += sizeof(uint16_t);
-
- switch (fdir_input->flow_type) {
- case RTE_ETH_FLOW_L2_PAYLOAD:
- *ether_type = fdir_input->flow.l2_flow.ether_type;
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
- case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
- case RTE_ETH_FLOW_NONFRAG_IPV4_SCTP:
- case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
- case RTE_ETH_FLOW_FRAG_IPV4:
- ip = (struct rte_ipv4_hdr *)raw_pkt;
-
- *ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
- ip->version_ihl = I40E_FDIR_IP_DEFAULT_VERSION_IHL;
- /* set len to by default */
- ip->total_length = rte_cpu_to_be_16(I40E_FDIR_IP_DEFAULT_LEN);
- ip->next_proto_id = fdir_input->flow.ip4_flow.proto ?
- fdir_input->flow.ip4_flow.proto :
- next_proto[fdir_input->flow_type];
- ip->time_to_live = fdir_input->flow.ip4_flow.ttl ?
- fdir_input->flow.ip4_flow.ttl :
- I40E_FDIR_IP_DEFAULT_TTL;
- ip->type_of_service = fdir_input->flow.ip4_flow.tos;
- /*
- * The source and destination fields in the transmitted packet
- * need to be presented in a reversed order with respect
- * to the expected received packets.
- */
- ip->src_addr = fdir_input->flow.ip4_flow.dst_ip;
- ip->dst_addr = fdir_input->flow.ip4_flow.src_ip;
- len += sizeof(struct rte_ipv4_hdr);
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
- case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
- case RTE_ETH_FLOW_NONFRAG_IPV6_SCTP:
- case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
- case RTE_ETH_FLOW_FRAG_IPV6:
- ip6 = (struct rte_ipv6_hdr *)raw_pkt;
-
- *ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
- ip6->vtc_flow =
- rte_cpu_to_be_32(I40E_FDIR_IPv6_DEFAULT_VTC_FLOW |
- (fdir_input->flow.ipv6_flow.tc <<
- I40E_FDIR_IPv6_TC_OFFSET));
- ip6->payload_len =
- rte_cpu_to_be_16(I40E_FDIR_IPv6_PAYLOAD_LEN);
- ip6->proto = fdir_input->flow.ipv6_flow.proto ?
- fdir_input->flow.ipv6_flow.proto :
- next_proto[fdir_input->flow_type];
- ip6->hop_limits = fdir_input->flow.ipv6_flow.hop_limits ?
- fdir_input->flow.ipv6_flow.hop_limits :
- I40E_FDIR_IPv6_DEFAULT_HOP_LIMITS;
- /*
- * The source and destination fields in the transmitted packet
- * need to be presented in a reversed order with respect
- * to the expected received packets.
- */
- rte_memcpy(&(ip6->src_addr),
- &(fdir_input->flow.ipv6_flow.dst_ip),
- IPV6_ADDR_LEN);
- rte_memcpy(&(ip6->dst_addr),
- &(fdir_input->flow.ipv6_flow.src_ip),
- IPV6_ADDR_LEN);
- len += sizeof(struct rte_ipv6_hdr);
- break;
- default:
- PMD_DRV_LOG(ERR, "unknown flow type %u.",
- fdir_input->flow_type);
- return -1;
- }
- return len;
-}
-
-
-/*
- * i40e_fdir_construct_pkt - construct packet based on fields in input
- * @pf: board private structure
- * @fdir_input: input set of the flow director entry
- * @raw_pkt: a packet to be constructed
- */
-static int
-i40e_fdir_construct_pkt(struct i40e_pf *pf,
- const struct rte_eth_fdir_input *fdir_input,
- unsigned char *raw_pkt)
-{
- unsigned char *payload, *ptr;
- struct rte_udp_hdr *udp;
- struct rte_tcp_hdr *tcp;
- struct rte_sctp_hdr *sctp;
- uint8_t size, dst = 0;
- uint8_t i, pit_idx, set_idx = I40E_FLXPLD_L4_IDX; /* use l4 by default*/
- int len;
-
- /* fill the ethernet and IP head */
- len = i40e_fdir_fill_eth_ip_head(fdir_input, raw_pkt,
- !!fdir_input->flow_ext.vlan_tci);
- if (len < 0)
- return -EINVAL;
-
- /* fill the L4 head */
- switch (fdir_input->flow_type) {
- case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
- udp = (struct rte_udp_hdr *)(raw_pkt + len);
- payload = (unsigned char *)udp + sizeof(struct rte_udp_hdr);
- /*
- * The source and destination fields in the transmitted packet
- * need to be presented in a reversed order with respect
- * to the expected received packets.
- */
- udp->src_port = fdir_input->flow.udp4_flow.dst_port;
- udp->dst_port = fdir_input->flow.udp4_flow.src_port;
- udp->dgram_len = rte_cpu_to_be_16(I40E_FDIR_UDP_DEFAULT_LEN);
- break;
-
- case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
- tcp = (struct rte_tcp_hdr *)(raw_pkt + len);
- payload = (unsigned char *)tcp + sizeof(struct rte_tcp_hdr);
- /*
- * The source and destination fields in the transmitted packet
- * need to be presented in a reversed order with respect
- * to the expected received packets.
- */
- tcp->src_port = fdir_input->flow.tcp4_flow.dst_port;
- tcp->dst_port = fdir_input->flow.tcp4_flow.src_port;
- tcp->data_off = I40E_FDIR_TCP_DEFAULT_DATAOFF;
- break;
-
- case RTE_ETH_FLOW_NONFRAG_IPV4_SCTP:
- sctp = (struct rte_sctp_hdr *)(raw_pkt + len);
- payload = (unsigned char *)sctp + sizeof(struct rte_sctp_hdr);
- /*
- * The source and destination fields in the transmitted packet
- * need to be presented in a reversed order with respect
- * to the expected received packets.
- */
- sctp->src_port = fdir_input->flow.sctp4_flow.dst_port;
- sctp->dst_port = fdir_input->flow.sctp4_flow.src_port;
- sctp->tag = fdir_input->flow.sctp4_flow.verify_tag;
- break;
-
- case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
- case RTE_ETH_FLOW_FRAG_IPV4:
- payload = raw_pkt + len;
- set_idx = I40E_FLXPLD_L3_IDX;
- break;
-
- case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
- udp = (struct rte_udp_hdr *)(raw_pkt + len);
- payload = (unsigned char *)udp + sizeof(struct rte_udp_hdr);
- /*
- * The source and destination fields in the transmitted packet
- * need to be presented in a reversed order with respect
- * to the expected received packets.
- */
- udp->src_port = fdir_input->flow.udp6_flow.dst_port;
- udp->dst_port = fdir_input->flow.udp6_flow.src_port;
- udp->dgram_len = rte_cpu_to_be_16(I40E_FDIR_IPv6_PAYLOAD_LEN);
- break;
-
- case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
- tcp = (struct rte_tcp_hdr *)(raw_pkt + len);
- payload = (unsigned char *)tcp + sizeof(struct rte_tcp_hdr);
- /*
- * The source and destination fields in the transmitted packet
- * need to be presented in a reversed order with respect
- * to the expected received packets.
- */
- tcp->data_off = I40E_FDIR_TCP_DEFAULT_DATAOFF;
- tcp->src_port = fdir_input->flow.udp6_flow.dst_port;
- tcp->dst_port = fdir_input->flow.udp6_flow.src_port;
- break;
-
- case RTE_ETH_FLOW_NONFRAG_IPV6_SCTP:
- sctp = (struct rte_sctp_hdr *)(raw_pkt + len);
- payload = (unsigned char *)sctp + sizeof(struct rte_sctp_hdr);
- /*
- * The source and destination fields in the transmitted packet
- * need to be presented in a reversed order with respect
- * to the expected received packets.
- */
- sctp->src_port = fdir_input->flow.sctp6_flow.dst_port;
- sctp->dst_port = fdir_input->flow.sctp6_flow.src_port;
- sctp->tag = fdir_input->flow.sctp6_flow.verify_tag;
- break;
-
- case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
- case RTE_ETH_FLOW_FRAG_IPV6:
- payload = raw_pkt + len;
- set_idx = I40E_FLXPLD_L3_IDX;
- break;
- case RTE_ETH_FLOW_L2_PAYLOAD:
- payload = raw_pkt + len;
- /*
- * ARP packet is a special case on which the payload
- * starts after the whole ARP header
- */
- if (fdir_input->flow.l2_flow.ether_type ==
- rte_cpu_to_be_16(RTE_ETHER_TYPE_ARP))
- payload += sizeof(struct rte_arp_hdr);
- set_idx = I40E_FLXPLD_L2_IDX;
- break;
- default:
- PMD_DRV_LOG(ERR, "unknown flow type %u.", fdir_input->flow_type);
- return -EINVAL;
- }
-
- /* fill the flexbytes to payload */
- for (i = 0; i < I40E_MAX_FLXPLD_FIED; i++) {
- pit_idx = set_idx * I40E_MAX_FLXPLD_FIED + i;
- size = pf->fdir.flex_set[pit_idx].size;
- if (size == 0)
- continue;
- dst = pf->fdir.flex_set[pit_idx].dst_offset * sizeof(uint16_t);
- ptr = payload +
- pf->fdir.flex_set[pit_idx].src_offset * sizeof(uint16_t);
- rte_memcpy(ptr,
- &fdir_input->flow_ext.flexbytes[dst],
- size * sizeof(uint16_t));
- }
-
- return 0;
-}
static struct i40e_customized_pctype *
i40e_flow_fdir_find_customized_pctype(struct i40e_pf *pf, uint8_t pctype)
@@ -1703,68 +1442,6 @@ i40e_fdir_entry_pool_put(struct i40e_fdir_info *fdir_info,
rte_bitmap_set(fdir_info->fdir_flow_pool.bitmap, f->idx);
}
-/*
- * i40e_add_del_fdir_filter - add or remove a flow director filter.
- * @pf: board private structure
- * @filter: fdir filter entry
- * @add: 0 - delete, 1 - add
- */
-int
-i40e_add_del_fdir_filter(struct rte_eth_dev *dev,
- const struct rte_eth_fdir_filter *filter,
- bool add)
-{
- struct i40e_hw *hw = I40E_DEV_PRIVATE_TO_HW(dev->data->dev_private);
- struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
- unsigned char *pkt = (unsigned char *)pf->fdir.prg_pkt[0];
- enum i40e_filter_pctype pctype;
- int ret = 0;
-
- if (dev->data->dev_conf.fdir_conf.mode != RTE_FDIR_MODE_PERFECT) {
- PMD_DRV_LOG(ERR, "FDIR is not enabled, please"
- " check the mode in fdir_conf.");
- return -ENOTSUP;
- }
-
- pctype = i40e_flowtype_to_pctype(pf->adapter, filter->input.flow_type);
- if (pctype == I40E_FILTER_PCTYPE_INVALID) {
- PMD_DRV_LOG(ERR, "invalid flow_type input.");
- return -EINVAL;
- }
- if (filter->action.rx_queue >= pf->dev_data->nb_rx_queues) {
- PMD_DRV_LOG(ERR, "Invalid queue ID");
- return -EINVAL;
- }
- if (filter->input.flow_ext.is_vf &&
- filter->input.flow_ext.dst_id >= pf->vf_num) {
- PMD_DRV_LOG(ERR, "Invalid VF ID");
- return -EINVAL;
- }
-
- memset(pkt, 0, I40E_FDIR_PKT_LEN);
-
- ret = i40e_fdir_construct_pkt(pf, &filter->input, pkt);
- if (ret < 0) {
- PMD_DRV_LOG(ERR, "construct packet for fdir fails.");
- return ret;
- }
-
- if (hw->mac.type == I40E_MAC_X722) {
- /* get translated pctype value in fd pctype register */
- pctype = (enum i40e_filter_pctype)i40e_read_rx_ctl(
- hw, I40E_GLQF_FD_PCTYPES((int)pctype));
- }
-
- ret = i40e_fdir_filter_programming(pf, pctype, filter, add);
- if (ret < 0) {
- PMD_DRV_LOG(ERR, "fdir programming fails for PCTYPE(%u).",
- pctype);
- return ret;
- }
-
- return ret;
-}
-
static inline unsigned char *
i40e_find_available_buffer(struct rte_eth_dev *dev)
{
@@ -1939,141 +1616,6 @@ i40e_flow_add_del_fdir_filter(struct rte_eth_dev *dev,
return ret;
}
-/*
- * i40e_fdir_filter_programming - Program a flow director filter rule.
- * Is done by Flow Director Programming Descriptor followed by packet
- * structure that contains the filter fields need to match.
- * @pf: board private structure
- * @pctype: pctype
- * @filter: fdir filter entry
- * @add: 0 - delete, 1 - add
- */
-static int
-i40e_fdir_filter_programming(struct i40e_pf *pf,
- enum i40e_filter_pctype pctype,
- const struct rte_eth_fdir_filter *filter,
- bool add)
-{
- struct i40e_tx_queue *txq = pf->fdir.txq;
- struct i40e_rx_queue *rxq = pf->fdir.rxq;
- const struct rte_eth_fdir_action *fdir_action = &filter->action;
- volatile struct i40e_tx_desc *txdp;
- volatile struct i40e_filter_program_desc *fdirdp;
- uint32_t td_cmd;
- uint16_t vsi_id, i;
- uint8_t dest;
-
- PMD_DRV_LOG(INFO, "filling filter programming descriptor.");
- fdirdp = (volatile struct i40e_filter_program_desc *)
- (&(txq->tx_ring[txq->tx_tail]));
-
- fdirdp->qindex_flex_ptype_vsi =
- rte_cpu_to_le_32((fdir_action->rx_queue <<
- I40E_TXD_FLTR_QW0_QINDEX_SHIFT) &
- I40E_TXD_FLTR_QW0_QINDEX_MASK);
-
- fdirdp->qindex_flex_ptype_vsi |=
- rte_cpu_to_le_32((fdir_action->flex_off <<
- I40E_TXD_FLTR_QW0_FLEXOFF_SHIFT) &
- I40E_TXD_FLTR_QW0_FLEXOFF_MASK);
-
- fdirdp->qindex_flex_ptype_vsi |=
- rte_cpu_to_le_32((pctype <<
- I40E_TXD_FLTR_QW0_PCTYPE_SHIFT) &
- I40E_TXD_FLTR_QW0_PCTYPE_MASK);
-
- if (filter->input.flow_ext.is_vf)
- vsi_id = pf->vfs[filter->input.flow_ext.dst_id].vsi->vsi_id;
- else
- /* Use LAN VSI Id by default */
- vsi_id = pf->main_vsi->vsi_id;
- fdirdp->qindex_flex_ptype_vsi |=
- rte_cpu_to_le_32(((uint32_t)vsi_id <<
- I40E_TXD_FLTR_QW0_DEST_VSI_SHIFT) &
- I40E_TXD_FLTR_QW0_DEST_VSI_MASK);
-
- fdirdp->dtype_cmd_cntindex =
- rte_cpu_to_le_32(I40E_TX_DESC_DTYPE_FILTER_PROG);
-
- if (add)
- fdirdp->dtype_cmd_cntindex |= rte_cpu_to_le_32(
- I40E_FILTER_PROGRAM_DESC_PCMD_ADD_UPDATE <<
- I40E_TXD_FLTR_QW1_PCMD_SHIFT);
- else
- fdirdp->dtype_cmd_cntindex |= rte_cpu_to_le_32(
- I40E_FILTER_PROGRAM_DESC_PCMD_REMOVE <<
- I40E_TXD_FLTR_QW1_PCMD_SHIFT);
-
- if (fdir_action->behavior == RTE_ETH_FDIR_REJECT)
- dest = I40E_FILTER_PROGRAM_DESC_DEST_DROP_PACKET;
- else if (fdir_action->behavior == RTE_ETH_FDIR_ACCEPT)
- dest = I40E_FILTER_PROGRAM_DESC_DEST_DIRECT_PACKET_QINDEX;
- else if (fdir_action->behavior == RTE_ETH_FDIR_PASSTHRU)
- dest = I40E_FILTER_PROGRAM_DESC_DEST_DIRECT_PACKET_OTHER;
- else {
- PMD_DRV_LOG(ERR, "Failed to program FDIR filter:"
- " unsupported fdir behavior.");
- return -EINVAL;
- }
-
- fdirdp->dtype_cmd_cntindex |= rte_cpu_to_le_32((dest <<
- I40E_TXD_FLTR_QW1_DEST_SHIFT) &
- I40E_TXD_FLTR_QW1_DEST_MASK);
-
- fdirdp->dtype_cmd_cntindex |=
- rte_cpu_to_le_32((fdir_action->report_status<<
- I40E_TXD_FLTR_QW1_FD_STATUS_SHIFT) &
- I40E_TXD_FLTR_QW1_FD_STATUS_MASK);
-
- fdirdp->dtype_cmd_cntindex |=
- rte_cpu_to_le_32(I40E_TXD_FLTR_QW1_CNT_ENA_MASK);
- fdirdp->dtype_cmd_cntindex |=
- rte_cpu_to_le_32(
- ((uint32_t)pf->fdir.match_counter_index <<
- I40E_TXD_FLTR_QW1_CNTINDEX_SHIFT) &
- I40E_TXD_FLTR_QW1_CNTINDEX_MASK);
-
- fdirdp->fd_id = rte_cpu_to_le_32(filter->soft_id);
-
- PMD_DRV_LOG(INFO, "filling transmit descriptor.");
- txdp = &(txq->tx_ring[txq->tx_tail + 1]);
- txdp->buffer_addr = rte_cpu_to_le_64(pf->fdir.dma_addr[0]);
- td_cmd = I40E_TX_DESC_CMD_EOP |
- I40E_TX_DESC_CMD_RS |
- I40E_TX_DESC_CMD_DUMMY;
-
- txdp->cmd_type_offset_bsz =
- i40e_build_ctob(td_cmd, 0, I40E_FDIR_PKT_LEN, 0);
-
- txq->tx_tail += 2; /* set 2 descriptors above, fdirdp and txdp */
- if (txq->tx_tail >= txq->nb_tx_desc)
- txq->tx_tail = 0;
- /* Update the tx tail register */
- rte_wmb();
- I40E_PCI_REG_WRITE(txq->qtx_tail, txq->tx_tail);
- for (i = 0; i < I40E_FDIR_MAX_WAIT_US; i++) {
- if ((txdp->cmd_type_offset_bsz &
- rte_cpu_to_le_64(I40E_TXD_QW1_DTYPE_MASK)) ==
- rte_cpu_to_le_64(I40E_TX_DESC_DTYPE_DESC_DONE))
- break;
- rte_delay_us(1);
- }
- if (i >= I40E_FDIR_MAX_WAIT_US) {
- PMD_DRV_LOG(ERR, "Failed to program FDIR filter:"
- " time out to get DD on tx queue.");
- return -ETIMEDOUT;
- }
- /* totally delay 10 ms to check programming status*/
- for (; i < I40E_FDIR_MAX_WAIT_US; i++) {
- if (i40e_check_fdir_programming_status(rxq) >= 0)
- return 0;
- rte_delay_us(1);
- }
- PMD_DRV_LOG(ERR,
- "Failed to program FDIR filter: programming status reported.");
- return -ETIMEDOUT;
-}
-
/*
* i40e_flow_fdir_filter_programming - Program a flow director filter rule.
* Is done by Flow Director Programming Descriptor followed by packet
@@ -2401,87 +1943,6 @@ i40e_fdir_stats_get(struct rte_eth_dev *dev, struct rte_eth_fdir_stats *stat)
I40E_PFQF_FDSTAT_BEST_CNT_SHIFT);
}
-static int
-i40e_fdir_filter_set(struct rte_eth_dev *dev,
- struct rte_eth_fdir_filter_info *info)
-{
- struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
- int ret = 0;
-
- if (!info) {
- PMD_DRV_LOG(ERR, "Invalid pointer");
- return -EFAULT;
- }
-
- switch (info->info_type) {
- case RTE_ETH_FDIR_FILTER_INPUT_SET_SELECT:
- ret = i40e_fdir_filter_inset_select(pf,
- &(info->info.input_set_conf));
- break;
- default:
- PMD_DRV_LOG(ERR, "FD filter info type (%d) not supported",
- info->info_type);
- return -EINVAL;
- }
-
- return ret;
-}
-
-/*
- * i40e_fdir_ctrl_func - deal with all operations on flow director.
- * @pf: board private structure
- * @filter_op:operation will be taken.
- * @arg: a pointer to specific structure corresponding to the filter_op
- */
-int
-i40e_fdir_ctrl_func(struct rte_eth_dev *dev,
- enum rte_filter_op filter_op,
- void *arg)
-{
- struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
- int ret = 0;
-
- if ((pf->flags & I40E_FLAG_FDIR) == 0)
- return -ENOTSUP;
-
- if (filter_op == RTE_ETH_FILTER_NOP)
- return 0;
-
- if (arg == NULL && filter_op != RTE_ETH_FILTER_FLUSH)
- return -EINVAL;
-
- switch (filter_op) {
- case RTE_ETH_FILTER_ADD:
- ret = i40e_add_del_fdir_filter(dev,
- (struct rte_eth_fdir_filter *)arg,
- TRUE);
- break;
- case RTE_ETH_FILTER_DELETE:
- ret = i40e_add_del_fdir_filter(dev,
- (struct rte_eth_fdir_filter *)arg,
- FALSE);
- break;
- case RTE_ETH_FILTER_FLUSH:
- ret = i40e_fdir_flush(dev);
- break;
- case RTE_ETH_FILTER_INFO:
- i40e_fdir_info_get(dev, (struct rte_eth_fdir_info *)arg);
- break;
- case RTE_ETH_FILTER_SET:
- ret = i40e_fdir_filter_set(dev,
- (struct rte_eth_fdir_filter_info *)arg);
- break;
- case RTE_ETH_FILTER_STATS:
- i40e_fdir_stats_get(dev, (struct rte_eth_fdir_stats *)arg);
- break;
- default:
- PMD_DRV_LOG(ERR, "unknown operation %u.", filter_op);
- ret = -EINVAL;
- break;
- }
- return ret;
-}
-
/* Restore flow director filter */
void
i40e_fdir_filter_restore(struct i40e_pf *pf)
diff --git a/drivers/net/ixgbe/ixgbe_ethdev.c b/drivers/net/ixgbe/ixgbe_ethdev.c
index 2a0f1761ba..e82f7baa2b 100644
--- a/drivers/net/ixgbe/ixgbe_ethdev.c
+++ b/drivers/net/ixgbe/ixgbe_ethdev.c
@@ -6799,7 +6799,7 @@ ixgbe_add_del_ethertype_filter(struct rte_eth_dev *dev,
}
static int
-ixgbe_dev_filter_ctrl(struct rte_eth_dev *dev,
+ixgbe_dev_filter_ctrl(__rte_unused struct rte_eth_dev *dev,
enum rte_filter_type filter_type,
enum rte_filter_op filter_op,
void *arg)
@@ -6807,9 +6807,6 @@ ixgbe_dev_filter_ctrl(struct rte_eth_dev *dev,
int ret = 0;
switch (filter_type) {
- case RTE_ETH_FILTER_FDIR:
- ret = ixgbe_fdir_ctrl_func(dev, filter_op, arg);
- break;
case RTE_ETH_FILTER_GENERIC:
if (filter_op != RTE_ETH_FILTER_GET)
return -EINVAL;
diff --git a/drivers/net/ixgbe/ixgbe_ethdev.h b/drivers/net/ixgbe/ixgbe_ethdev.h
index 9bdef87fbd..b342d70b8b 100644
--- a/drivers/net/ixgbe/ixgbe_ethdev.h
+++ b/drivers/net/ixgbe/ixgbe_ethdev.h
@@ -727,8 +727,6 @@ int ixgbe_pf_host_configure(struct rte_eth_dev *eth_dev);
uint32_t ixgbe_convert_vm_rx_mask_to_val(uint16_t rx_mask, uint32_t orig_val);
-int ixgbe_fdir_ctrl_func(struct rte_eth_dev *dev,
- enum rte_filter_op filter_op, void *arg);
void ixgbe_fdir_filter_restore(struct rte_eth_dev *dev);
int ixgbe_clear_all_fdir_filter(struct rte_eth_dev *dev);
diff --git a/drivers/net/ixgbe/ixgbe_fdir.c b/drivers/net/ixgbe/ixgbe_fdir.c
index 6faaa8f067..a0fab5070d 100644
--- a/drivers/net/ixgbe/ixgbe_fdir.c
+++ b/drivers/net/ixgbe/ixgbe_fdir.c
@@ -87,10 +87,6 @@ static int fdir_set_input_mask_x550(struct rte_eth_dev *dev);
static int ixgbe_set_fdir_flex_conf(struct rte_eth_dev *dev,
const struct rte_eth_fdir_flex_conf *conf, uint32_t *fdirctrl);
static int fdir_enable_82599(struct ixgbe_hw *hw, uint32_t fdirctrl);
-static int ixgbe_fdir_filter_to_atr_input(
- const struct rte_eth_fdir_filter *fdir_filter,
- union ixgbe_atr_input *input,
- enum rte_fdir_mode mode);
static uint32_t ixgbe_atr_compute_hash_82599(union ixgbe_atr_input *atr_input,
uint32_t key);
static uint32_t atr_compute_sig_hash_82599(union ixgbe_atr_input *input,
@@ -104,10 +100,6 @@ static int fdir_write_perfect_filter_82599(struct ixgbe_hw *hw,
static int fdir_add_signature_filter_82599(struct ixgbe_hw *hw,
union ixgbe_atr_input *input, u8 queue, uint32_t fdircmd,
uint32_t fdirhash);
-static int ixgbe_add_del_fdir_filter(struct rte_eth_dev *dev,
- const struct rte_eth_fdir_filter *fdir_filter,
- bool del,
- bool update);
static int ixgbe_fdir_flush(struct rte_eth_dev *dev);
/**
@@ -679,114 +671,6 @@ ixgbe_fdir_configure(struct rte_eth_dev *dev)
return 0;
}
-/*
- * Convert DPDK rte_eth_fdir_filter struct to ixgbe_atr_input union that is used
- * by the IXGBE driver code.
- */
-static int
-ixgbe_fdir_filter_to_atr_input(const struct rte_eth_fdir_filter *fdir_filter,
- union ixgbe_atr_input *input, enum rte_fdir_mode mode)
-{
- input->formatted.vlan_id = fdir_filter->input.flow_ext.vlan_tci;
- input->formatted.flex_bytes = (uint16_t)(
- (fdir_filter->input.flow_ext.flexbytes[1] << 8 & 0xFF00) |
- (fdir_filter->input.flow_ext.flexbytes[0] & 0xFF));
-
- switch (fdir_filter->input.flow_type) {
- case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
- input->formatted.flow_type = IXGBE_ATR_FLOW_TYPE_UDPV4;
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
- input->formatted.flow_type = IXGBE_ATR_FLOW_TYPE_TCPV4;
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV4_SCTP:
- input->formatted.flow_type = IXGBE_ATR_FLOW_TYPE_SCTPV4;
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
- input->formatted.flow_type = IXGBE_ATR_FLOW_TYPE_IPV4;
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
- input->formatted.flow_type = IXGBE_ATR_FLOW_TYPE_UDPV6;
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
- input->formatted.flow_type = IXGBE_ATR_FLOW_TYPE_TCPV6;
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_SCTP:
- input->formatted.flow_type = IXGBE_ATR_FLOW_TYPE_SCTPV6;
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
- input->formatted.flow_type = IXGBE_ATR_FLOW_TYPE_IPV6;
- break;
- default:
- break;
- }
-
- switch (fdir_filter->input.flow_type) {
- case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
- case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
- input->formatted.src_port =
- fdir_filter->input.flow.udp4_flow.src_port;
- input->formatted.dst_port =
- fdir_filter->input.flow.udp4_flow.dst_port;
- /* fall-through */
- /*for SCTP flow type, port and verify_tag are meaningless in ixgbe.*/
- case RTE_ETH_FLOW_NONFRAG_IPV4_SCTP:
- case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
- input->formatted.src_ip[0] =
- fdir_filter->input.flow.ip4_flow.src_ip;
- input->formatted.dst_ip[0] =
- fdir_filter->input.flow.ip4_flow.dst_ip;
- break;
-
- case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
- case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
- input->formatted.src_port =
- fdir_filter->input.flow.udp6_flow.src_port;
- input->formatted.dst_port =
- fdir_filter->input.flow.udp6_flow.dst_port;
- /* fall-through */
- /*for SCTP flow type, port and verify_tag are meaningless in ixgbe.*/
- case RTE_ETH_FLOW_NONFRAG_IPV6_SCTP:
- case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
- rte_memcpy(input->formatted.src_ip,
- fdir_filter->input.flow.ipv6_flow.src_ip,
- sizeof(input->formatted.src_ip));
- rte_memcpy(input->formatted.dst_ip,
- fdir_filter->input.flow.ipv6_flow.dst_ip,
- sizeof(input->formatted.dst_ip));
- break;
- default:
- break;
- }
-
- if (mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) {
- rte_memcpy(
- input->formatted.inner_mac,
- fdir_filter->input.flow.mac_vlan_flow.mac_addr.addr_bytes,
- sizeof(input->formatted.inner_mac));
- } else if (mode == RTE_FDIR_MODE_PERFECT_TUNNEL) {
- rte_memcpy(
- input->formatted.inner_mac,
- fdir_filter->input.flow.tunnel_flow.mac_addr.addr_bytes,
- sizeof(input->formatted.inner_mac));
- if (fdir_filter->input.flow.tunnel_flow.tunnel_type ==
- RTE_FDIR_TUNNEL_TYPE_VXLAN)
- input->formatted.tunnel_type =
- IXGBE_FDIR_VXLAN_TUNNEL_TYPE;
- else if (fdir_filter->input.flow.tunnel_flow.tunnel_type ==
- RTE_FDIR_TUNNEL_TYPE_NVGRE)
- input->formatted.tunnel_type =
- IXGBE_FDIR_NVGRE_TUNNEL_TYPE;
- else
- PMD_DRV_LOG(ERR, " invalid tunnel type arguments.");
-
- input->formatted.tni_vni =
- fdir_filter->input.flow.tunnel_flow.tunnel_id >> 8;
- }
-
- return 0;
-}
-
/*
* The below function is taken from the FreeBSD IXGBE drivers release
* 2.3.8. The only change is not to mask hash_result with IXGBE_ATR_HASH_MASK
@@ -1194,31 +1078,6 @@ ixgbe_remove_fdir_filter(struct ixgbe_hw_fdir_info *fdir_info,
return 0;
}
-static int
-ixgbe_interpret_fdir_filter(struct rte_eth_dev *dev,
- const struct rte_eth_fdir_filter *fdir_filter,
- struct ixgbe_fdir_rule *rule)
-{
- enum rte_fdir_mode fdir_mode = dev->data->dev_conf.fdir_conf.mode;
- int err;
-
- memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
-
- err = ixgbe_fdir_filter_to_atr_input(fdir_filter,
- &rule->ixgbe_fdir,
- fdir_mode);
- if (err)
- return err;
-
- rule->mode = fdir_mode;
- if (fdir_filter->action.behavior == RTE_ETH_FDIR_REJECT)
- rule->fdirflags = IXGBE_FDIRCMD_DROP;
- rule->queue = fdir_filter->action.rx_queue;
- rule->soft_id = fdir_filter->soft_id;
-
- return 0;
-}
-
int
ixgbe_fdir_filter_program(struct rte_eth_dev *dev,
struct ixgbe_fdir_rule *rule,
@@ -1364,29 +1223,6 @@ ixgbe_fdir_filter_program(struct rte_eth_dev *dev,
return err;
}
-/* ixgbe_add_del_fdir_filter - add or remove a flow diretor filter.
- * @dev: pointer to the structure rte_eth_dev
- * @fdir_filter: fdir filter entry
- * @del: 1 - delete, 0 - add
- * @update: 1 - update
- */
-static int
-ixgbe_add_del_fdir_filter(struct rte_eth_dev *dev,
- const struct rte_eth_fdir_filter *fdir_filter,
- bool del,
- bool update)
-{
- struct ixgbe_fdir_rule rule;
- int err;
-
- err = ixgbe_interpret_fdir_filter(dev, fdir_filter, &rule);
-
- if (err)
- return err;
-
- return ixgbe_fdir_filter_program(dev, &rule, del, update);
-}
-
static int
ixgbe_fdir_flush(struct rte_eth_dev *dev)
{
@@ -1524,62 +1360,6 @@ ixgbe_fdir_stats_get(struct rte_eth_dev *dev, struct rte_eth_fdir_stats *fdir_st
}
-/*
- * ixgbe_fdir_ctrl_func - deal with all operations on flow director.
- * @dev: pointer to the structure rte_eth_dev
- * @filter_op:operation will be taken
- * @arg: a pointer to specific structure corresponding to the filter_op
- */
-int
-ixgbe_fdir_ctrl_func(struct rte_eth_dev *dev,
- enum rte_filter_op filter_op, void *arg)
-{
- struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
- int ret = 0;
-
- if (hw->mac.type != ixgbe_mac_82599EB &&
- hw->mac.type != ixgbe_mac_X540 &&
- hw->mac.type != ixgbe_mac_X550 &&
- hw->mac.type != ixgbe_mac_X550EM_x &&
- hw->mac.type != ixgbe_mac_X550EM_a)
- return -ENOTSUP;
-
- if (filter_op == RTE_ETH_FILTER_NOP)
- return 0;
-
- if (arg == NULL && filter_op != RTE_ETH_FILTER_FLUSH)
- return -EINVAL;
-
- switch (filter_op) {
- case RTE_ETH_FILTER_ADD:
- ret = ixgbe_add_del_fdir_filter(dev,
- (struct rte_eth_fdir_filter *)arg, FALSE, FALSE);
- break;
- case RTE_ETH_FILTER_UPDATE:
- ret = ixgbe_add_del_fdir_filter(dev,
- (struct rte_eth_fdir_filter *)arg, FALSE, TRUE);
- break;
- case RTE_ETH_FILTER_DELETE:
- ret = ixgbe_add_del_fdir_filter(dev,
- (struct rte_eth_fdir_filter *)arg, TRUE, FALSE);
- break;
- case RTE_ETH_FILTER_FLUSH:
- ret = ixgbe_fdir_flush(dev);
- break;
- case RTE_ETH_FILTER_INFO:
- ixgbe_fdir_info_get(dev, (struct rte_eth_fdir_info *)arg);
- break;
- case RTE_ETH_FILTER_STATS:
- ixgbe_fdir_stats_get(dev, (struct rte_eth_fdir_stats *)arg);
- break;
- default:
- PMD_DRV_LOG(ERR, "unknown operation %u", filter_op);
- ret = -EINVAL;
- break;
- }
- return ret;
-}
-
/* restore flow director filter */
void
ixgbe_fdir_filter_restore(struct rte_eth_dev *dev)
diff --git a/drivers/net/mlx5/mlx5.h b/drivers/net/mlx5/mlx5.h
index 1408cf94d6..a0082e4f71 100644
--- a/drivers/net/mlx5/mlx5.h
+++ b/drivers/net/mlx5/mlx5.h
@@ -878,7 +878,6 @@ struct mlx5_priv {
uint8_t skip_default_rss_reta; /* Skip configuration of default reta. */
uint8_t fdb_def_rule; /* Whether fdb jump to table 1 is configured. */
struct mlx5_mp_id mp_id; /* ID of a multi-process process */
- LIST_HEAD(fdir, mlx5_fdir_flow) fdir_flows; /* fdir flows. */
};
#define PORT_ID(priv) ((priv)->dev_data->port_id)
diff --git a/drivers/net/mlx5/mlx5_flow.c b/drivers/net/mlx5/mlx5_flow.c
index 3d38e11c87..afe3149495 100644
--- a/drivers/net/mlx5/mlx5_flow.c
+++ b/drivers/net/mlx5/mlx5_flow.c
@@ -557,32 +557,6 @@ static const struct rte_flow_ops mlx5_flow_ops = {
.get_aged_flows = mlx5_flow_get_aged_flows,
};
-/* Convert FDIR request to Generic flow. */
-struct mlx5_fdir {
- struct rte_flow_attr attr;
- struct rte_flow_item items[4];
- struct rte_flow_item_eth l2;
- struct rte_flow_item_eth l2_mask;
- union {
- struct rte_flow_item_ipv4 ipv4;
- struct rte_flow_item_ipv6 ipv6;
- } l3;
- union {
- struct rte_flow_item_ipv4 ipv4;
- struct rte_flow_item_ipv6 ipv6;
- } l3_mask;
- union {
- struct rte_flow_item_udp udp;
- struct rte_flow_item_tcp tcp;
- } l4;
- union {
- struct rte_flow_item_udp udp;
- struct rte_flow_item_tcp tcp;
- } l4_mask;
- struct rte_flow_action actions[2];
- struct rte_flow_action_queue queue;
-};
-
/* Tunnel information. */
struct mlx5_flow_tunnel_info {
uint64_t tunnel; /**< Tunnel bit (see MLX5_FLOW_*). */
@@ -5310,7 +5284,6 @@ flow_list_destroy(struct rte_eth_dev *dev, uint32_t *list,
uint32_t flow_idx)
{
struct mlx5_priv *priv = dev->data->dev_private;
- struct mlx5_fdir_flow *priv_fdir_flow = NULL;
struct rte_flow *flow = mlx5_ipool_get(priv->sh->ipool
[MLX5_IPOOL_RTE_FLOW], flow_idx);
@@ -5330,17 +5303,6 @@ flow_list_destroy(struct rte_eth_dev *dev, uint32_t *list,
ILIST_REMOVE(priv->sh->ipool[MLX5_IPOOL_RTE_FLOW], list,
flow_idx, flow, next);
flow_mreg_del_copy_action(dev, flow);
- if (flow->fdir) {
- LIST_FOREACH(priv_fdir_flow, &priv->fdir_flows, next) {
- if (priv_fdir_flow->rix_flow == flow_idx)
- break;
- }
- if (priv_fdir_flow) {
- LIST_REMOVE(priv_fdir_flow, next);
- mlx5_free(priv_fdir_flow->fdir);
- mlx5_free(priv_fdir_flow);
- }
- }
mlx5_ipool_free(priv->sh->ipool[MLX5_IPOOL_RTE_FLOW], flow_idx);
}
@@ -5878,482 +5840,6 @@ mlx5_flow_query(struct rte_eth_dev *dev,
return 0;
}
-/**
- * Convert a flow director filter to a generic flow.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param fdir_filter
- * Flow director filter to add.
- * @param attributes
- * Generic flow parameters structure.
- *
- * @return
- * 0 on success, a negative errno value otherwise and rte_errno is set.
- */
-static int
-flow_fdir_filter_convert(struct rte_eth_dev *dev,
- const struct rte_eth_fdir_filter *fdir_filter,
- struct mlx5_fdir *attributes)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
- const struct rte_eth_fdir_input *input = &fdir_filter->input;
- const struct rte_eth_fdir_masks *mask =
- &dev->data->dev_conf.fdir_conf.mask;
-
- /* Validate queue number. */
- if (fdir_filter->action.rx_queue >= priv->rxqs_n) {
- DRV_LOG(ERR, "port %u invalid queue number %d",
- dev->data->port_id, fdir_filter->action.rx_queue);
- rte_errno = EINVAL;
- return -rte_errno;
- }
- attributes->attr.ingress = 1;
- attributes->items[0] = (struct rte_flow_item) {
- .type = RTE_FLOW_ITEM_TYPE_ETH,
- .spec = &attributes->l2,
- .mask = &attributes->l2_mask,
- };
- switch (fdir_filter->action.behavior) {
- case RTE_ETH_FDIR_ACCEPT:
- attributes->actions[0] = (struct rte_flow_action){
- .type = RTE_FLOW_ACTION_TYPE_QUEUE,
- .conf = &attributes->queue,
- };
- break;
- case RTE_ETH_FDIR_REJECT:
- attributes->actions[0] = (struct rte_flow_action){
- .type = RTE_FLOW_ACTION_TYPE_DROP,
- };
- break;
- default:
- DRV_LOG(ERR, "port %u invalid behavior %d",
- dev->data->port_id,
- fdir_filter->action.behavior);
- rte_errno = ENOTSUP;
- return -rte_errno;
- }
- attributes->queue.index = fdir_filter->action.rx_queue;
- /* Handle L3. */
- switch (fdir_filter->input.flow_type) {
- case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
- case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
- case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
- attributes->l3.ipv4.hdr = (struct rte_ipv4_hdr){
- .src_addr = input->flow.ip4_flow.src_ip,
- .dst_addr = input->flow.ip4_flow.dst_ip,
- .time_to_live = input->flow.ip4_flow.ttl,
- .type_of_service = input->flow.ip4_flow.tos,
- };
- attributes->l3_mask.ipv4.hdr = (struct rte_ipv4_hdr){
- .src_addr = mask->ipv4_mask.src_ip,
- .dst_addr = mask->ipv4_mask.dst_ip,
- .time_to_live = mask->ipv4_mask.ttl,
- .type_of_service = mask->ipv4_mask.tos,
- .next_proto_id = mask->ipv4_mask.proto,
- };
- attributes->items[1] = (struct rte_flow_item){
- .type = RTE_FLOW_ITEM_TYPE_IPV4,
- .spec = &attributes->l3,
- .mask = &attributes->l3_mask,
- };
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
- case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
- case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
- attributes->l3.ipv6.hdr = (struct rte_ipv6_hdr){
- .hop_limits = input->flow.ipv6_flow.hop_limits,
- .proto = input->flow.ipv6_flow.proto,
- };
-
- memcpy(attributes->l3.ipv6.hdr.src_addr,
- input->flow.ipv6_flow.src_ip,
- RTE_DIM(attributes->l3.ipv6.hdr.src_addr));
- memcpy(attributes->l3.ipv6.hdr.dst_addr,
- input->flow.ipv6_flow.dst_ip,
- RTE_DIM(attributes->l3.ipv6.hdr.src_addr));
- memcpy(attributes->l3_mask.ipv6.hdr.src_addr,
- mask->ipv6_mask.src_ip,
- RTE_DIM(attributes->l3_mask.ipv6.hdr.src_addr));
- memcpy(attributes->l3_mask.ipv6.hdr.dst_addr,
- mask->ipv6_mask.dst_ip,
- RTE_DIM(attributes->l3_mask.ipv6.hdr.src_addr));
- attributes->items[1] = (struct rte_flow_item){
- .type = RTE_FLOW_ITEM_TYPE_IPV6,
- .spec = &attributes->l3,
- .mask = &attributes->l3_mask,
- };
- break;
- default:
- DRV_LOG(ERR, "port %u invalid flow type%d",
- dev->data->port_id, fdir_filter->input.flow_type);
- rte_errno = ENOTSUP;
- return -rte_errno;
- }
- /* Handle L4. */
- switch (fdir_filter->input.flow_type) {
- case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
- attributes->l4.udp.hdr = (struct rte_udp_hdr){
- .src_port = input->flow.udp4_flow.src_port,
- .dst_port = input->flow.udp4_flow.dst_port,
- };
- attributes->l4_mask.udp.hdr = (struct rte_udp_hdr){
- .src_port = mask->src_port_mask,
- .dst_port = mask->dst_port_mask,
- };
- attributes->items[2] = (struct rte_flow_item){
- .type = RTE_FLOW_ITEM_TYPE_UDP,
- .spec = &attributes->l4,
- .mask = &attributes->l4_mask,
- };
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
- attributes->l4.tcp.hdr = (struct rte_tcp_hdr){
- .src_port = input->flow.tcp4_flow.src_port,
- .dst_port = input->flow.tcp4_flow.dst_port,
- };
- attributes->l4_mask.tcp.hdr = (struct rte_tcp_hdr){
- .src_port = mask->src_port_mask,
- .dst_port = mask->dst_port_mask,
- };
- attributes->items[2] = (struct rte_flow_item){
- .type = RTE_FLOW_ITEM_TYPE_TCP,
- .spec = &attributes->l4,
- .mask = &attributes->l4_mask,
- };
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
- attributes->l4.udp.hdr = (struct rte_udp_hdr){
- .src_port = input->flow.udp6_flow.src_port,
- .dst_port = input->flow.udp6_flow.dst_port,
- };
- attributes->l4_mask.udp.hdr = (struct rte_udp_hdr){
- .src_port = mask->src_port_mask,
- .dst_port = mask->dst_port_mask,
- };
- attributes->items[2] = (struct rte_flow_item){
- .type = RTE_FLOW_ITEM_TYPE_UDP,
- .spec = &attributes->l4,
- .mask = &attributes->l4_mask,
- };
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
- attributes->l4.tcp.hdr = (struct rte_tcp_hdr){
- .src_port = input->flow.tcp6_flow.src_port,
- .dst_port = input->flow.tcp6_flow.dst_port,
- };
- attributes->l4_mask.tcp.hdr = (struct rte_tcp_hdr){
- .src_port = mask->src_port_mask,
- .dst_port = mask->dst_port_mask,
- };
- attributes->items[2] = (struct rte_flow_item){
- .type = RTE_FLOW_ITEM_TYPE_TCP,
- .spec = &attributes->l4,
- .mask = &attributes->l4_mask,
- };
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
- case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
- break;
- default:
- DRV_LOG(ERR, "port %u invalid flow type%d",
- dev->data->port_id, fdir_filter->input.flow_type);
- rte_errno = ENOTSUP;
- return -rte_errno;
- }
- return 0;
-}
-
-#define FLOW_FDIR_CMP(f1, f2, fld) \
- memcmp(&(f1)->fld, &(f2)->fld, sizeof(f1->fld))
-
-/**
- * Compare two FDIR flows. If items and actions are identical, the two flows are
- * regarded as same.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param f1
- * FDIR flow to compare.
- * @param f2
- * FDIR flow to compare.
- *
- * @return
- * Zero on match, 1 otherwise.
- */
-static int
-flow_fdir_cmp(const struct mlx5_fdir *f1, const struct mlx5_fdir *f2)
-{
- if (FLOW_FDIR_CMP(f1, f2, attr) ||
- FLOW_FDIR_CMP(f1, f2, l2) ||
- FLOW_FDIR_CMP(f1, f2, l2_mask) ||
- FLOW_FDIR_CMP(f1, f2, l3) ||
- FLOW_FDIR_CMP(f1, f2, l3_mask) ||
- FLOW_FDIR_CMP(f1, f2, l4) ||
- FLOW_FDIR_CMP(f1, f2, l4_mask) ||
- FLOW_FDIR_CMP(f1, f2, actions[0].type))
- return 1;
- if (f1->actions[0].type == RTE_FLOW_ACTION_TYPE_QUEUE &&
- FLOW_FDIR_CMP(f1, f2, queue))
- return 1;
- return 0;
-}
-
-/**
- * Search device flow list to find out a matched FDIR flow.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param fdir_flow
- * FDIR flow to lookup.
- *
- * @return
- * Index of flow if found, 0 otherwise.
- */
-static uint32_t
-flow_fdir_filter_lookup(struct rte_eth_dev *dev, struct mlx5_fdir *fdir_flow)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
- uint32_t flow_idx = 0;
- struct mlx5_fdir_flow *priv_fdir_flow = NULL;
-
- MLX5_ASSERT(fdir_flow);
- LIST_FOREACH(priv_fdir_flow, &priv->fdir_flows, next) {
- if (!flow_fdir_cmp(priv_fdir_flow->fdir, fdir_flow)) {
- DRV_LOG(DEBUG, "port %u found FDIR flow %u",
- dev->data->port_id, flow_idx);
- flow_idx = priv_fdir_flow->rix_flow;
- break;
- }
- }
- return flow_idx;
-}
-
-/**
- * Add new flow director filter and store it in list.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param fdir_filter
- * Flow director filter to add.
- *
- * @return
- * 0 on success, a negative errno value otherwise and rte_errno is set.
- */
-static int
-flow_fdir_filter_add(struct rte_eth_dev *dev,
- const struct rte_eth_fdir_filter *fdir_filter)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
- struct mlx5_fdir *fdir_flow;
- struct rte_flow *flow;
- struct mlx5_fdir_flow *priv_fdir_flow = NULL;
- uint32_t flow_idx;
- int ret;
-
- fdir_flow = mlx5_malloc(MLX5_MEM_ZERO, sizeof(*fdir_flow), 0,
- SOCKET_ID_ANY);
- if (!fdir_flow) {
- rte_errno = ENOMEM;
- return -rte_errno;
- }
- ret = flow_fdir_filter_convert(dev, fdir_filter, fdir_flow);
- if (ret)
- goto error;
- flow_idx = flow_fdir_filter_lookup(dev, fdir_flow);
- if (flow_idx) {
- rte_errno = EEXIST;
- goto error;
- }
- priv_fdir_flow = mlx5_malloc(MLX5_MEM_ZERO,
- sizeof(struct mlx5_fdir_flow),
- 0, SOCKET_ID_ANY);
- if (!priv_fdir_flow) {
- rte_errno = ENOMEM;
- goto error;
- }
- flow_idx = flow_list_create(dev, &priv->flows, &fdir_flow->attr,
- fdir_flow->items, fdir_flow->actions, true,
- NULL);
- flow = mlx5_ipool_get(priv->sh->ipool[MLX5_IPOOL_RTE_FLOW], flow_idx);
- if (!flow)
- goto error;
- flow->fdir = 1;
- priv_fdir_flow->fdir = fdir_flow;
- priv_fdir_flow->rix_flow = flow_idx;
- LIST_INSERT_HEAD(&priv->fdir_flows, priv_fdir_flow, next);
- DRV_LOG(DEBUG, "port %u created FDIR flow %p",
- dev->data->port_id, (void *)flow);
- return 0;
-error:
- mlx5_free(priv_fdir_flow);
- mlx5_free(fdir_flow);
- return -rte_errno;
-}
-
-/**
- * Delete specific filter.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param fdir_filter
- * Filter to be deleted.
- *
- * @return
- * 0 on success, a negative errno value otherwise and rte_errno is set.
- */
-static int
-flow_fdir_filter_delete(struct rte_eth_dev *dev,
- const struct rte_eth_fdir_filter *fdir_filter)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
- uint32_t flow_idx;
- struct mlx5_fdir fdir_flow = {
- .attr.group = 0,
- };
- struct mlx5_fdir_flow *priv_fdir_flow = NULL;
- int ret;
-
- ret = flow_fdir_filter_convert(dev, fdir_filter, &fdir_flow);
- if (ret)
- return -rte_errno;
- LIST_FOREACH(priv_fdir_flow, &priv->fdir_flows, next) {
- /* Find the fdir in priv list */
- if (!flow_fdir_cmp(priv_fdir_flow->fdir, &fdir_flow))
- break;
- }
- if (!priv_fdir_flow)
- return 0;
- LIST_REMOVE(priv_fdir_flow, next);
- flow_idx = priv_fdir_flow->rix_flow;
- flow_list_destroy(dev, &priv->flows, flow_idx);
- mlx5_free(priv_fdir_flow->fdir);
- mlx5_free(priv_fdir_flow);
- DRV_LOG(DEBUG, "port %u deleted FDIR flow %u",
- dev->data->port_id, flow_idx);
- return 0;
-}
-
-/**
- * Update queue for specific filter.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param fdir_filter
- * Filter to be updated.
- *
- * @return
- * 0 on success, a negative errno value otherwise and rte_errno is set.
- */
-static int
-flow_fdir_filter_update(struct rte_eth_dev *dev,
- const struct rte_eth_fdir_filter *fdir_filter)
-{
- int ret;
-
- ret = flow_fdir_filter_delete(dev, fdir_filter);
- if (ret)
- return ret;
- return flow_fdir_filter_add(dev, fdir_filter);
-}
-
-/**
- * Flush all filters.
- *
- * @param dev
- * Pointer to Ethernet device.
- */
-static void
-flow_fdir_filter_flush(struct rte_eth_dev *dev)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
- struct mlx5_fdir_flow *priv_fdir_flow = NULL;
-
- while (!LIST_EMPTY(&priv->fdir_flows)) {
- priv_fdir_flow = LIST_FIRST(&priv->fdir_flows);
- LIST_REMOVE(priv_fdir_flow, next);
- flow_list_destroy(dev, &priv->flows, priv_fdir_flow->rix_flow);
- mlx5_free(priv_fdir_flow->fdir);
- mlx5_free(priv_fdir_flow);
- }
-}
-
-/**
- * Get flow director information.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param[out] fdir_info
- * Resulting flow director information.
- */
-static void
-flow_fdir_info_get(struct rte_eth_dev *dev, struct rte_eth_fdir_info *fdir_info)
-{
- struct rte_eth_fdir_masks *mask =
- &dev->data->dev_conf.fdir_conf.mask;
-
- fdir_info->mode = dev->data->dev_conf.fdir_conf.mode;
- fdir_info->guarant_spc = 0;
- rte_memcpy(&fdir_info->mask, mask, sizeof(fdir_info->mask));
- fdir_info->max_flexpayload = 0;
- fdir_info->flow_types_mask[0] = 0;
- fdir_info->flex_payload_unit = 0;
- fdir_info->max_flex_payload_segment_num = 0;
- fdir_info->flex_payload_limit = 0;
- memset(&fdir_info->flex_conf, 0, sizeof(fdir_info->flex_conf));
-}
-
-/**
- * Deal with flow director operations.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param filter_op
- * Operation to perform.
- * @param arg
- * Pointer to operation-specific structure.
- *
- * @return
- * 0 on success, a negative errno value otherwise and rte_errno is set.
- */
-static int
-flow_fdir_ctrl_func(struct rte_eth_dev *dev, enum rte_filter_op filter_op,
- void *arg)
-{
- enum rte_fdir_mode fdir_mode =
- dev->data->dev_conf.fdir_conf.mode;
-
- if (filter_op == RTE_ETH_FILTER_NOP)
- return 0;
- if (fdir_mode != RTE_FDIR_MODE_PERFECT &&
- fdir_mode != RTE_FDIR_MODE_PERFECT_MAC_VLAN) {
- DRV_LOG(ERR, "port %u flow director mode %d not supported",
- dev->data->port_id, fdir_mode);
- rte_errno = EINVAL;
- return -rte_errno;
- }
- switch (filter_op) {
- case RTE_ETH_FILTER_ADD:
- return flow_fdir_filter_add(dev, arg);
- case RTE_ETH_FILTER_UPDATE:
- return flow_fdir_filter_update(dev, arg);
- case RTE_ETH_FILTER_DELETE:
- return flow_fdir_filter_delete(dev, arg);
- case RTE_ETH_FILTER_FLUSH:
- flow_fdir_filter_flush(dev);
- break;
- case RTE_ETH_FILTER_INFO:
- flow_fdir_info_get(dev, arg);
- break;
- default:
- DRV_LOG(DEBUG, "port %u unknown operation %u",
- dev->data->port_id, filter_op);
- rte_errno = EINVAL;
- return -rte_errno;
- }
- return 0;
-}
-
/**
* Manage filter operations.
*
@@ -6383,8 +5869,6 @@ mlx5_dev_filter_ctrl(struct rte_eth_dev *dev,
}
*(const void **)arg = &mlx5_flow_ops;
return 0;
- case RTE_ETH_FILTER_FDIR:
- return flow_fdir_ctrl_func(dev, filter_op, arg);
default:
DRV_LOG(ERR, "port %u filter type (%d) not supported",
dev->data->port_id, filter_type);
diff --git a/drivers/net/mlx5/mlx5_flow.h b/drivers/net/mlx5/mlx5_flow.h
index 0dc76c42e2..57fadb442d 100644
--- a/drivers/net/mlx5/mlx5_flow.h
+++ b/drivers/net/mlx5/mlx5_flow.h
@@ -892,13 +892,6 @@ struct mlx5_flow_meter_profile {
uint32_t ref_cnt; /**< Use count. */
};
-/* Fdir flow structure */
-struct mlx5_fdir_flow {
- LIST_ENTRY(mlx5_fdir_flow) next; /* Pointer to the next element. */
- struct mlx5_fdir *fdir; /* Pointer to fdir. */
- uint32_t rix_flow; /* Index to flow. */
-};
-
#define HAIRPIN_FLOW_ID_BITS 28
/* Flow structure. */
@@ -907,7 +900,6 @@ struct rte_flow {
uint32_t dev_handles;
/**< Device flow handles that are part of the flow. */
uint32_t drv_type:2; /**< Driver type. */
- uint32_t fdir:1; /**< Identifier of associated FDIR if any. */
uint32_t hairpin_flow_id:HAIRPIN_FLOW_ID_BITS;
/**< The flow id used for hairpin. */
uint32_t copy_applied:1; /**< The MARK copy Flow os applied. */
diff --git a/drivers/net/qede/qede_ethdev.h b/drivers/net/qede/qede_ethdev.h
index 4fb77b05c2..61a65ac42e 100644
--- a/drivers/net/qede/qede_ethdev.h
+++ b/drivers/net/qede/qede_ethdev.h
@@ -293,11 +293,6 @@ int qede_ntuple_filter_conf(struct rte_eth_dev *eth_dev,
int qede_check_fdir_support(struct rte_eth_dev *eth_dev);
-uint16_t qede_fdir_construct_pkt(struct rte_eth_dev *eth_dev,
- struct rte_eth_fdir_filter *fdir,
- void *buff,
- struct ecore_arfs_config_params *params);
-
void qede_fdir_dealloc_resc(struct rte_eth_dev *eth_dev);
int qede_activate_vport(struct rte_eth_dev *eth_dev, bool flg);
diff --git a/drivers/net/qede/qede_filter.c b/drivers/net/qede/qede_filter.c
index a9870338aa..71c1f68b90 100644
--- a/drivers/net/qede/qede_filter.c
+++ b/drivers/net/qede/qede_filter.c
@@ -130,14 +130,6 @@ const struct _qede_udp_tunn_types {
*/
#define QEDE_MAX_FDIR_PKT_LEN (86)
-static inline bool qede_valid_flow(uint16_t flow_type)
-{
- return ((flow_type == RTE_ETH_FLOW_NONFRAG_IPV4_TCP) ||
- (flow_type == RTE_ETH_FLOW_NONFRAG_IPV4_UDP) ||
- (flow_type == RTE_ETH_FLOW_NONFRAG_IPV6_TCP) ||
- (flow_type == RTE_ETH_FLOW_NONFRAG_IPV6_UDP));
-}
-
static uint16_t
qede_arfs_construct_pkt(struct rte_eth_dev *eth_dev,
struct qede_arfs_entry *arfs,
@@ -197,74 +189,6 @@ void qede_fdir_dealloc_resc(struct rte_eth_dev *eth_dev)
}
}
-static int
-qede_fdir_to_arfs_filter(struct rte_eth_dev *eth_dev,
- struct rte_eth_fdir_filter *fdir,
- struct qede_arfs_entry *arfs)
-{
- struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev);
- struct ecore_dev *edev = QEDE_INIT_EDEV(qdev);
- struct rte_eth_fdir_input *input;
-
- static const uint8_t next_proto[] = {
- [RTE_ETH_FLOW_NONFRAG_IPV4_TCP] = IPPROTO_TCP,
- [RTE_ETH_FLOW_NONFRAG_IPV4_UDP] = IPPROTO_UDP,
- [RTE_ETH_FLOW_NONFRAG_IPV6_TCP] = IPPROTO_TCP,
- [RTE_ETH_FLOW_NONFRAG_IPV6_UDP] = IPPROTO_UDP,
- };
-
- input = &fdir->input;
-
- DP_INFO(edev, "flow_type %d\n", input->flow_type);
-
- switch (input->flow_type) {
- case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
- case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
- /* fill the common ip header */
- arfs->tuple.eth_proto = RTE_ETHER_TYPE_IPV4;
- arfs->tuple.dst_ipv4 = input->flow.ip4_flow.dst_ip;
- arfs->tuple.src_ipv4 = input->flow.ip4_flow.src_ip;
- arfs->tuple.ip_proto = next_proto[input->flow_type];
-
- /* UDP */
- if (input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV4_UDP) {
- arfs->tuple.dst_port = input->flow.udp4_flow.dst_port;
- arfs->tuple.src_port = input->flow.udp4_flow.src_port;
- } else { /* TCP */
- arfs->tuple.dst_port = input->flow.tcp4_flow.dst_port;
- arfs->tuple.src_port = input->flow.tcp4_flow.src_port;
- }
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
- case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
- arfs->tuple.eth_proto = RTE_ETHER_TYPE_IPV6;
- arfs->tuple.ip_proto = next_proto[input->flow_type];
- rte_memcpy(arfs->tuple.dst_ipv6,
- &input->flow.ipv6_flow.dst_ip,
- IPV6_ADDR_LEN);
- rte_memcpy(arfs->tuple.src_ipv6,
- &input->flow.ipv6_flow.src_ip,
- IPV6_ADDR_LEN);
-
- /* UDP */
- if (input->flow_type == RTE_ETH_FLOW_NONFRAG_IPV6_UDP) {
- arfs->tuple.dst_port = input->flow.udp6_flow.dst_port;
- arfs->tuple.src_port = input->flow.udp6_flow.src_port;
- } else { /* TCP */
- arfs->tuple.dst_port = input->flow.tcp6_flow.dst_port;
- arfs->tuple.src_port = input->flow.tcp6_flow.src_port;
- }
- break;
- default:
- DP_ERR(edev, "Unsupported flow_type %u\n",
- input->flow_type);
- return -ENOTSUP;
- }
-
- arfs->rx_queue = fdir->action.rx_queue;
- return 0;
-}
-
static int
qede_config_arfs_filter(struct rte_eth_dev *eth_dev,
struct qede_arfs_entry *arfs,
@@ -397,61 +321,6 @@ qede_config_arfs_filter(struct rte_eth_dev *eth_dev,
return rc;
}
-static int
-qede_config_cmn_fdir_filter(struct rte_eth_dev *eth_dev,
- struct rte_eth_fdir_filter *fdir_filter,
- bool add)
-{
- struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev);
- struct ecore_dev *edev = QEDE_INIT_EDEV(qdev);
- struct qede_arfs_entry *arfs = NULL;
- int rc = 0;
-
- arfs = rte_malloc(NULL, sizeof(struct qede_arfs_entry),
- RTE_CACHE_LINE_SIZE);
- if (!arfs) {
- DP_ERR(edev, "Did not allocate memory for arfs\n");
- return -ENOMEM;
- }
-
- rc = qede_fdir_to_arfs_filter(eth_dev, fdir_filter, arfs);
- if (rc < 0)
- return rc;
-
- rc = qede_config_arfs_filter(eth_dev, arfs, add);
- if (rc < 0)
- rte_free(arfs);
-
- return rc;
-}
-
-static int
-qede_fdir_filter_add(struct rte_eth_dev *eth_dev,
- struct rte_eth_fdir_filter *fdir,
- bool add)
-{
- struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev);
- struct ecore_dev *edev = QEDE_INIT_EDEV(qdev);
-
- if (!qede_valid_flow(fdir->input.flow_type)) {
- DP_ERR(edev, "invalid flow_type input\n");
- return -EINVAL;
- }
-
- if (fdir->action.rx_queue >= QEDE_RSS_COUNT(eth_dev)) {
- DP_ERR(edev, "invalid queue number %u\n",
- fdir->action.rx_queue);
- return -EINVAL;
- }
-
- if (fdir->input.flow_ext.is_vf) {
- DP_ERR(edev, "flowdir is not supported over VF\n");
- return -EINVAL;
- }
-
- return qede_config_cmn_fdir_filter(eth_dev, fdir, add);
-}
-
/* Fills the L3/L4 headers and returns the actual length of flowdir packet */
static uint16_t
qede_arfs_construct_pkt(struct rte_eth_dev *eth_dev,
@@ -552,44 +421,6 @@ qede_arfs_construct_pkt(struct rte_eth_dev *eth_dev,
return len;
}
-static int
-qede_fdir_filter_conf(struct rte_eth_dev *eth_dev,
- enum rte_filter_op filter_op,
- void *arg)
-{
- struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev);
- struct ecore_dev *edev = QEDE_INIT_EDEV(qdev);
- struct rte_eth_fdir_filter *fdir;
- int ret;
-
- fdir = (struct rte_eth_fdir_filter *)arg;
- switch (filter_op) {
- case RTE_ETH_FILTER_NOP:
- /* Typically used to query flowdir support */
- if (ECORE_IS_CMT(edev)) {
- DP_ERR(edev, "flowdir is not supported in 100G mode\n");
- return -ENOTSUP;
- }
- return 0; /* means supported */
- case RTE_ETH_FILTER_ADD:
- ret = qede_fdir_filter_add(eth_dev, fdir, 1);
- break;
- case RTE_ETH_FILTER_DELETE:
- ret = qede_fdir_filter_add(eth_dev, fdir, 0);
- break;
- case RTE_ETH_FILTER_FLUSH:
- case RTE_ETH_FILTER_UPDATE:
- case RTE_ETH_FILTER_INFO:
- return -ENOTSUP;
- break;
- default:
- DP_ERR(edev, "unknown operation %u", filter_op);
- ret = -EINVAL;
- }
-
- return ret;
-}
-
static int
qede_tunnel_update(struct qede_dev *qdev,
struct ecore_tunnel_info *tunn_info)
@@ -1228,8 +1059,6 @@ int qede_dev_filter_ctrl(struct rte_eth_dev *eth_dev,
struct ecore_dev *edev = QEDE_INIT_EDEV(qdev);
switch (filter_type) {
- case RTE_ETH_FILTER_FDIR:
- return qede_fdir_filter_conf(eth_dev, filter_op, arg);
case RTE_ETH_FILTER_GENERIC:
if (ECORE_IS_CMT(edev)) {
DP_ERR(edev, "flowdir is not supported in 100G mode\n");
diff --git a/drivers/net/sfc/sfc_ethdev.c b/drivers/net/sfc/sfc_ethdev.c
index 1437af15e0..26988579a5 100644
--- a/drivers/net/sfc/sfc_ethdev.c
+++ b/drivers/net/sfc/sfc_ethdev.c
@@ -1745,9 +1745,6 @@ sfc_dev_filter_ctrl(struct rte_eth_dev *dev, enum rte_filter_type filter_type,
sfc_log_init(sa, "entry");
switch (filter_type) {
- case RTE_ETH_FILTER_FDIR:
- sfc_err(sa, "Flow Director filters not supported");
- break;
case RTE_ETH_FILTER_GENERIC:
if (filter_op != RTE_ETH_FILTER_GET) {
rc = EINVAL;
diff --git a/lib/librte_ethdev/rte_eth_ctrl.h b/lib/librte_ethdev/rte_eth_ctrl.h
index 4c9bd9b0fa..6911ff7f77 100644
--- a/lib/librte_ethdev/rte_eth_ctrl.h
+++ b/lib/librte_ethdev/rte_eth_ctrl.h
@@ -443,9 +443,7 @@ struct rte_eth_fdir_action {
};
/**
- * A structure used to define the flow director filter entry by filter_ctrl API
- * It supports RTE_ETH_FILTER_FDIR with RTE_ETH_FILTER_ADD and
- * RTE_ETH_FILTER_DELETE operations.
+ * A structure used to define the flow director filter entry by filter_ctrl API.
*/
struct rte_eth_fdir_filter {
uint32_t soft_id;
@@ -593,29 +591,6 @@ struct rte_eth_fdir_stats {
uint32_t best_cnt; /**< Number of filters in best effort spaces. */
};
-/**
- * Flow Director filter information types.
- */
-enum rte_eth_fdir_filter_info_type {
- RTE_ETH_FDIR_FILTER_INFO_TYPE_UNKNOWN = 0,
- /** Flow Director filter input set configuration */
- RTE_ETH_FDIR_FILTER_INPUT_SET_SELECT,
- RTE_ETH_FDIR_FILTER_INFO_TYPE_MAX,
-};
-
-/**
- * A structure used to set FDIR filter information, to support filter type
- * of 'RTE_ETH_FILTER_FDIR' RTE_ETH_FDIR_FILTER_INPUT_SET_SELECT operation.
- */
-struct rte_eth_fdir_filter_info {
- enum rte_eth_fdir_filter_info_type info_type; /**< Information type */
- /** Details of fdir filter information */
- union {
- /** Flow Director input set configuration per port */
- struct rte_eth_input_set_conf input_set_conf;
- } info;
-};
-
/**
* l2 tunnel configuration.
*/
--
2.17.1
next prev parent reply other threads:[~2020-10-18 14:14 UTC|newest]
Thread overview: 67+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-10-18 14:08 [dpdk-dev] [PATCH 00/14] ethdev: remove legacy filter API Andrew Rybchenko
2020-10-18 14:08 ` [dpdk-dev] [PATCH 01/14] ethdev: remove legacy MACVLAN filter type support Andrew Rybchenko
2020-10-20 11:07 ` David Marchand
2020-10-21 16:34 ` Andrew Rybchenko
2020-10-21 3:31 ` Guo, Jia
2020-10-21 16:05 ` Andrew Rybchenko
2020-10-22 1:59 ` Guo, Jia
2020-10-18 14:08 ` [dpdk-dev] [PATCH 02/14] ethdev: move MAC filter type to i40e driver Andrew Rybchenko
2020-10-21 4:01 ` Guo, Jia
2020-10-21 16:09 ` Andrew Rybchenko
2020-10-22 2:58 ` Guo, Jia
2020-10-22 7:19 ` Andrew Rybchenko
2020-10-18 14:09 ` [dpdk-dev] [PATCH 03/14] ethdev: remove legacy EtherType filter type support Andrew Rybchenko
2020-10-18 22:13 ` Ajit Khaparde
2020-10-19 6:40 ` Wang, Haiyue
[not found] ` <BYAPR11MB3493BE2EB0D5B91DDDCD99758C1C0@BYAPR11MB3493.namprd11.prod.outlook.com>
2020-10-21 5:38 ` Guo, Jia
2020-10-21 16:12 ` Andrew Rybchenko
2020-10-18 14:09 ` [dpdk-dev] [PATCH 04/14] ethdev: remove legacy flexible " Andrew Rybchenko
2020-10-19 6:29 ` Wang, Haiyue
2020-10-18 14:09 ` [dpdk-dev] [PATCH 05/14] ethdev: move flexible filter type to e1000 driver Andrew Rybchenko
2020-10-19 6:20 ` Wang, Haiyue
2020-10-18 14:09 ` [dpdk-dev] [PATCH 06/14] ethdev: remove legacy SYN filter type support Andrew Rybchenko
2020-10-19 6:45 ` Wang, Haiyue
2020-10-18 14:09 ` [dpdk-dev] [PATCH 07/14] ethdev: remove legacy N-tuple " Andrew Rybchenko
2020-10-18 22:13 ` Ajit Khaparde
2020-10-19 6:47 ` Wang, Haiyue
2020-10-18 14:09 ` [dpdk-dev] [PATCH 08/14] ethdev: remove legacy TUNNEL " Andrew Rybchenko
2020-10-18 22:14 ` Ajit Khaparde
2020-10-19 8:01 ` Li, Xiaoyun
2020-10-18 14:09 ` [dpdk-dev] [PATCH 09/14] ethdev: remove legacy HASH " Andrew Rybchenko
2020-10-18 14:09 ` [dpdk-dev] [PATCH 10/14] ethdev: remove legacy L2_TUNNEL " Andrew Rybchenko
2020-10-19 6:42 ` Wang, Haiyue
2020-10-18 14:09 ` [dpdk-dev] [PATCH 11/14] ethdev: remove legacy global filter configuration support Andrew Rybchenko
2020-10-21 5:42 ` Guo, Jia
2020-10-18 14:09 ` Andrew Rybchenko [this message]
2020-10-18 22:15 ` [dpdk-dev] [PATCH 12/14] ethdev: remove legacy FDIR filter type support Ajit Khaparde
2020-10-19 6:53 ` Wang, Haiyue
2020-10-21 5:45 ` Guo, Jia
2020-10-21 16:17 ` Andrew Rybchenko
2020-10-22 2:45 ` Guo, Jia
2020-10-18 14:09 ` [dpdk-dev] [PATCH 13/14] app/testpmd: remove flow_director_flex_mask command Andrew Rybchenko
2020-10-20 10:53 ` David Marchand
2020-10-22 9:01 ` Andrew Rybchenko
2020-10-18 14:09 ` [dpdk-dev] [PATCH 14/14] ethdev: remove legacy filter API functions Andrew Rybchenko
2020-10-20 10:47 ` David Marchand
2020-10-20 14:52 ` Ferruh Yigit
2020-10-22 9:12 ` Andrew Rybchenko
2020-10-22 9:33 ` Ferruh Yigit
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 00/14] ethdev: remove legacy filter API Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 01/14] ethdev: remove legacy MACVLAN filter type support Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 02/14] ethdev: move MAC filter type to i40e driver Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 03/14] ethdev: remove legacy EtherType filter type support Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 04/14] ethdev: remove legacy flexible " Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 05/14] ethdev: move flexible filter type to e1000 driver Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 06/14] ethdev: remove legacy SYN filter type support Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 07/14] ethdev: remove legacy N-tuple " Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 08/14] ethdev: remove legacy TUNNEL " Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 09/14] ethdev: remove legacy HASH " Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 10/14] ethdev: remove legacy L2_TUNNEL " Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 11/14] ethdev: remove legacy global filter configuration support Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 12/14] ethdev: remove legacy FDIR filter type support Andrew Rybchenko
2020-10-23 3:32 ` Hyong Youb Kim (hyonkim)
2020-10-23 6:41 ` Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 13/14] app/testpmd: remove command to set FDIR flexible filter mask Andrew Rybchenko
2020-10-22 9:42 ` [dpdk-dev] [PATCH v2 14/14] ethdev: remove legacy filter API functions Andrew Rybchenko
2020-10-23 16:03 ` [dpdk-dev] [PATCH v2 00/14] ethdev: remove legacy filter API Ferruh Yigit
2020-10-29 21:36 ` Ferruh Yigit
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1603030152-13451-13-git-send-email-arybchenko@solarflare.com \
--to=arybchenko@solarflare.com \
--cc=ajit.khaparde@broadcom.com \
--cc=andrew.rybchenko@oktetlabs.ru \
--cc=beilei.xing@intel.com \
--cc=bernard.iremonger@intel.com \
--cc=dev@dpdk.org \
--cc=ferruh.yigit@intel.com \
--cc=haiyue.wang@intel.com \
--cc=hyonkim@cisco.com \
--cc=jia.guo@intel.com \
--cc=johndale@cisco.com \
--cc=matan@nvidia.com \
--cc=mdr@ashroe.eu \
--cc=nhorman@tuxdriver.com \
--cc=rmody@marvell.com \
--cc=shahafs@nvidia.com \
--cc=shshaikh@marvell.com \
--cc=somnath.kotur@broadcom.com \
--cc=thomas@monjalon.net \
--cc=viacheslavo@nvidia.com \
--cc=wenzhuo.lu@intel.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).