All of lore.kernel.org
 help / color / mirror / Atom feed
From: Wei Zhao <wei.zhao1@intel.com>
To: dev@dpdk.org
Cc: Wei Zhao <wei.zhao1@intel.com>
Subject: [PATCH 11/11] net/e1000: flush all the filter
Date: Tue, 23 May 2017 15:13:01 +0800	[thread overview]
Message-ID: <1495523581-56027-12-git-send-email-wei.zhao1@intel.com> (raw)
In-Reply-To: <1495523581-56027-1-git-send-email-wei.zhao1@intel.com>

This patch adds a function to flush all the fliter list
and filter rule on a port.

Signed-off-by: Wei Zhao <wei.zhao1@intel.com>
---
 drivers/net/e1000/e1000_ethdev.h |   9 +++
 drivers/net/e1000/igb_ethdev.c   |  67 +++++++++++++------
 drivers/net/e1000/igb_flow.c     | 141 ++++++++++++++++++++++++++++++++++++++-
 3 files changed, 196 insertions(+), 21 deletions(-)

diff --git a/drivers/net/e1000/e1000_ethdev.h b/drivers/net/e1000/e1000_ethdev.h
index dc5bbba..363a1f0 100644
--- a/drivers/net/e1000/e1000_ethdev.h
+++ b/drivers/net/e1000/e1000_ethdev.h
@@ -472,6 +472,15 @@ void em_txq_info_get(struct rte_eth_dev *dev, uint16_t queue_id,
 
 void igb_pf_host_uninit(struct rte_eth_dev *dev);
 
+void igb_filterlist_flush(struct rte_eth_dev *dev);
+int igb_delete_5tuple_filter_82576(struct rte_eth_dev *dev,
+		struct e1000_5tuple_filter *filter);
+int igb_delete_2tuple_filter(struct rte_eth_dev *dev,
+		struct e1000_2tuple_filter *filter);
+void igb_remove_flex_filter(struct rte_eth_dev *dev,
+			struct e1000_flex_filter *filter);
+int igb_ethertype_filter_remove(struct e1000_filter_info *filter_info,
+	uint8_t idx);
 int igb_add_del_ntuple_filter(struct rte_eth_dev *dev,
 		struct rte_eth_ntuple_filter *ntuple_filter, bool add);
 int igb_add_del_ethertype_filter(struct rte_eth_dev *dev,
diff --git a/drivers/net/e1000/igb_ethdev.c b/drivers/net/e1000/igb_ethdev.c
index 21ee07c..2817fbb 100644
--- a/drivers/net/e1000/igb_ethdev.c
+++ b/drivers/net/e1000/igb_ethdev.c
@@ -1017,6 +1017,9 @@ eth_igb_dev_uninit(struct rte_eth_dev *eth_dev)
 	/* remove all flex filters of the device */
 	igb_flex_filter_uninit(eth_dev);
 
+	/* clear all the filters list */
+	igb_filterlist_flush(eth_dev);
+
 	return 0;
 }
 
@@ -3859,6 +3862,24 @@ igb_add_2tuple_filter(struct rte_eth_dev *dev,
 	return 0;
 }
 
+int
+igb_delete_2tuple_filter(struct rte_eth_dev *dev,
+			struct e1000_2tuple_filter *filter)
+{
+	struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+	struct e1000_filter_info *filter_info =
+		E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
+
+	filter_info->twotuple_mask &= ~(1 << filter->index);
+	TAILQ_REMOVE(&filter_info->twotuple_list, filter, entries);
+	rte_free(filter);
+
+	E1000_WRITE_REG(hw, E1000_TTQF(filter->index), E1000_TTQF_DISABLE_MASK);
+	E1000_WRITE_REG(hw, E1000_IMIR(filter->index), 0);
+	E1000_WRITE_REG(hw, E1000_IMIREXT(filter->index), 0);
+	return 0;
+}
+
 /*
  * igb_remove_2tuple_filter - remove a 2tuple filter
  *
@@ -3874,7 +3895,6 @@ static int
 igb_remove_2tuple_filter(struct rte_eth_dev *dev,
 			struct rte_eth_ntuple_filter *ntuple_filter)
 {
-	struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 	struct e1000_filter_info *filter_info =
 		E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
 	struct e1000_2tuple_filter_info filter_2tuple;
@@ -3894,13 +3914,8 @@ igb_remove_2tuple_filter(struct rte_eth_dev *dev,
 		return -ENOENT;
 	}
 
-	filter_info->twotuple_mask &= ~(1 << filter->index);
-	TAILQ_REMOVE(&filter_info->twotuple_list, filter, entries);
-	rte_free(filter);
+	igb_delete_2tuple_filter(dev, filter);
 
-	E1000_WRITE_REG(hw, E1000_TTQF(filter->index), E1000_TTQF_DISABLE_MASK);
-	E1000_WRITE_REG(hw, E1000_IMIR(filter->index), 0);
-	E1000_WRITE_REG(hw, E1000_IMIREXT(filter->index), 0);
 	return 0;
 }
 
@@ -3963,7 +3978,7 @@ eth_igb_flex_filter_lookup(struct e1000_flex_filter_list *filter_list,
  * dev: Pointer to struct rte_eth_dev.
  * filter: the pointer of the filter will be removed.
  */
-static void
+void
 igb_remove_flex_filter(struct rte_eth_dev *dev,
 			struct e1000_flex_filter *filter)
 {
@@ -4383,6 +4398,28 @@ igb_add_5tuple_filter_82576(struct rte_eth_dev *dev,
 	return 0;
 }
 
+int
+igb_delete_5tuple_filter_82576(struct rte_eth_dev *dev,
+				struct e1000_5tuple_filter *filter)
+{
+	struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+	struct e1000_filter_info *filter_info =
+		E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
+
+	filter_info->fivetuple_mask &= ~(1 << filter->index);
+	TAILQ_REMOVE(&filter_info->fivetuple_list, filter, entries);
+	rte_free(filter);
+
+	E1000_WRITE_REG(hw, E1000_FTQF(filter->index),
+			E1000_FTQF_VF_BP | E1000_FTQF_MASK);
+	E1000_WRITE_REG(hw, E1000_DAQF(filter->index), 0);
+	E1000_WRITE_REG(hw, E1000_SAQF(filter->index), 0);
+	E1000_WRITE_REG(hw, E1000_SPQF(filter->index), 0);
+	E1000_WRITE_REG(hw, E1000_IMIR(filter->index), 0);
+	E1000_WRITE_REG(hw, E1000_IMIREXT(filter->index), 0);
+	return 0;
+}
+
 /*
  * igb_remove_5tuple_filter_82576 - remove a 5tuple filter
  *
@@ -4398,7 +4435,6 @@ static int
 igb_remove_5tuple_filter_82576(struct rte_eth_dev *dev,
 				struct rte_eth_ntuple_filter *ntuple_filter)
 {
-	struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 	struct e1000_filter_info *filter_info =
 		E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
 	struct e1000_5tuple_filter_info filter_5tuple;
@@ -4418,17 +4454,8 @@ igb_remove_5tuple_filter_82576(struct rte_eth_dev *dev,
 		return -ENOENT;
 	}
 
-	filter_info->fivetuple_mask &= ~(1 << filter->index);
-	TAILQ_REMOVE(&filter_info->fivetuple_list, filter, entries);
-	rte_free(filter);
+	igb_delete_5tuple_filter_82576(dev, filter);
 
-	E1000_WRITE_REG(hw, E1000_FTQF(filter->index),
-			E1000_FTQF_VF_BP | E1000_FTQF_MASK);
-	E1000_WRITE_REG(hw, E1000_DAQF(filter->index), 0);
-	E1000_WRITE_REG(hw, E1000_SAQF(filter->index), 0);
-	E1000_WRITE_REG(hw, E1000_SPQF(filter->index), 0);
-	E1000_WRITE_REG(hw, E1000_IMIR(filter->index), 0);
-	E1000_WRITE_REG(hw, E1000_IMIREXT(filter->index), 0);
 	return 0;
 }
 
@@ -4682,7 +4709,7 @@ igb_ethertype_filter_insert(struct e1000_filter_info *filter_info,
 	return -1;
 }
 
-static int
+int
 igb_ethertype_filter_remove(struct e1000_filter_info *filter_info,
 			uint8_t idx)
 {
diff --git a/drivers/net/e1000/igb_flow.c b/drivers/net/e1000/igb_flow.c
index af1f909..9678e19 100644
--- a/drivers/net/e1000/igb_flow.c
+++ b/drivers/net/e1000/igb_flow.c
@@ -1566,10 +1566,149 @@ igb_flow_destroy(struct rte_eth_dev *dev,
 	return ret;
 }
 
+/* remove all the n-tuple filters */
+static void
+igb_clear_all_ntuple_filter(struct rte_eth_dev *dev)
+{
+	struct e1000_filter_info *filter_info =
+		E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
+	struct e1000_5tuple_filter *p_5tuple;
+	struct e1000_2tuple_filter *p_2tuple;
+
+	while ((p_5tuple = TAILQ_FIRST(&filter_info->fivetuple_list)))
+		igb_delete_5tuple_filter_82576(dev, p_5tuple);
+
+	while ((p_2tuple = TAILQ_FIRST(&filter_info->twotuple_list)))
+		igb_delete_2tuple_filter(dev, p_2tuple);
+}
+
+/* remove all the ether type filters */
+static void
+igb_clear_all_ethertype_filter(struct rte_eth_dev *dev)
+{
+	struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+	struct e1000_filter_info *filter_info =
+		E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
+	int i;
+
+	for (i = 0; i < E1000_MAX_ETQF_FILTERS; i++) {
+		if (filter_info->ethertype_mask & (1 << i)) {
+			(void)igb_ethertype_filter_remove(filter_info,
+							    (uint8_t)i);
+			E1000_WRITE_REG(hw, E1000_ETQF(i), 0);
+			E1000_WRITE_FLUSH(hw);
+		}
+	}
+}
+
+/* remove the SYN filter */
+static void
+igb_clear_syn_filter(struct rte_eth_dev *dev)
+{
+	struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+	struct e1000_filter_info *filter_info =
+		E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
+
+	if (filter_info->syn_info & E1000_SYN_FILTER_ENABLE) {
+		filter_info->syn_info = 0;
+		E1000_WRITE_REG(hw, E1000_SYNQF(0), 0);
+		E1000_WRITE_FLUSH(hw);
+	}
+}
+
+/* remove all the flex filters */
+static void
+igb_clear_all_flex_filter(struct rte_eth_dev *dev)
+{
+	struct e1000_filter_info *filter_info =
+		E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
+	struct e1000_flex_filter *flex_filter;
+
+	while ((flex_filter = TAILQ_FIRST(&filter_info->flex_list)))
+		igb_remove_flex_filter(dev, flex_filter);
+}
+
+void
+igb_filterlist_flush(struct rte_eth_dev *dev)
+{
+	struct igb_ntuple_filter_ele *ntuple_filter_ptr;
+	struct igb_ethertype_filter_ele *ethertype_filter_ptr;
+	struct igb_eth_syn_filter_ele *syn_filter_ptr;
+	struct igb_flex_filter_ele *flex_filter_ptr;
+	struct igb_flow_mem *igb_flow_mem_ptr;
+	enum rte_filter_type filter_type;
+	struct rte_flow *pmd_flow;
+
+	TAILQ_FOREACH(igb_flow_mem_ptr, &igb_flow_list, entries) {
+		if (igb_flow_mem_ptr->dev == dev) {
+			pmd_flow = igb_flow_mem_ptr->flow;
+			filter_type = pmd_flow->filter_type;
+
+			switch (filter_type) {
+			case RTE_ETH_FILTER_NTUPLE:
+				ntuple_filter_ptr =
+				(struct igb_ntuple_filter_ele *)
+					pmd_flow->rule;
+				TAILQ_REMOVE(&igb_filter_ntuple_list,
+						ntuple_filter_ptr, entries);
+				rte_free(ntuple_filter_ptr);
+				break;
+			case RTE_ETH_FILTER_ETHERTYPE:
+				ethertype_filter_ptr =
+				(struct igb_ethertype_filter_ele *)
+					pmd_flow->rule;
+				TAILQ_REMOVE(&igb_filter_ethertype_list,
+						ethertype_filter_ptr, entries);
+				rte_free(ethertype_filter_ptr);
+				break;
+			case RTE_ETH_FILTER_SYN:
+				syn_filter_ptr =
+					(struct igb_eth_syn_filter_ele *)
+						pmd_flow->rule;
+				TAILQ_REMOVE(&igb_filter_syn_list,
+						syn_filter_ptr, entries);
+				rte_free(syn_filter_ptr);
+				break;
+			case RTE_ETH_FILTER_FLEXIBLE:
+				flex_filter_ptr =
+					(struct igb_flex_filter_ele *)
+						pmd_flow->rule;
+				TAILQ_REMOVE(&igb_filter_flex_list,
+						flex_filter_ptr, entries);
+				rte_free(flex_filter_ptr);
+				break;
+			default:
+				PMD_DRV_LOG(WARNING, "Filter type"
+					"(%d) not supported", filter_type);
+				break;
+			}
+			TAILQ_REMOVE(&igb_flow_list,
+				 igb_flow_mem_ptr,
+				 entries);
+			rte_free(igb_flow_mem_ptr->flow);
+			rte_free(igb_flow_mem_ptr);
+		}
+	}
+}
+
+/*  Destroy all flow rules associated with a port on igb. */
+static int
+igb_flow_flush(struct rte_eth_dev *dev,
+		__rte_unused struct rte_flow_error *error)
+{
+	igb_clear_all_ntuple_filter(dev);
+	igb_clear_all_ethertype_filter(dev);
+	igb_clear_syn_filter(dev);
+	igb_clear_all_flex_filter(dev);
+	igb_filterlist_flush(dev);
+
+	return 0;
+}
+
 const struct rte_flow_ops igb_flow_ops = {
 	igb_flow_validate,
 	igb_flow_create,
 	igb_flow_destroy,
-	NULL,
+	igb_flow_flush,
 	NULL,
 };
\ No newline at end of file
-- 
2.9.3

  parent reply	other threads:[~2017-05-23  7:21 UTC|newest]

Thread overview: 89+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2017-05-23  7:12 [PATCH 00/11] net/e1000: Consistent filter API Wei Zhao
2017-05-23  7:12 ` [PATCH 01/11] net/e1000: store and restore TCP SYN filter Wei Zhao
2017-05-23  7:12 ` [PATCH 02/11] net/e1000: restore n-tuple filter Wei Zhao
2017-05-23  7:12 ` [PATCH 03/11] net/e1000: restore ether type filter Wei Zhao
2017-05-23  7:12 ` [PATCH 04/11] net/e1000: restore flex " Wei Zhao
2017-05-23  7:12 ` [PATCH 05/11] net/e1000: parse n-tuple filter Wei Zhao
2017-05-23  7:12 ` [PATCH 06/11] net/e1000: parse ethertype filter Wei Zhao
2017-05-23  7:12 ` [PATCH 07/11] net/e1000: parse TCP SYN filter Wei Zhao
2017-05-23  7:12 ` [PATCH 08/11] net/e1000: parse flex filter Wei Zhao
2017-05-23  7:12 ` [PATCH 09/11] net/e1000: create consistent filter Wei Zhao
2017-05-23  7:13 ` [PATCH 10/11] net/e1000: destroy " Wei Zhao
2017-05-23  7:13 ` Wei Zhao [this message]
2017-05-29 11:01 ` [PATCH 00/11] net/e1000: Consistent filter API Ferruh Yigit
2017-05-31  3:17   ` Zhao1, Wei
2017-06-02  6:36 ` Wei Zhao
2017-06-02  6:36   ` [PATCH v2 01/11] net/e1000: store and restore TCP SYN filter Wei Zhao
2017-06-02  7:51     ` Lu, Wenzhuo
2017-06-02  6:36   ` [PATCH v2 02/11] net/e1000: restore n-tuple filter Wei Zhao
2017-06-02  7:56     ` Lu, Wenzhuo
2017-06-02  8:00       ` Zhao1, Wei
2017-06-02  6:36   ` [PATCH v2 03/11] net/e1000: restore ether type filter Wei Zhao
2017-06-02  8:08     ` Lu, Wenzhuo
2017-06-02  6:36   ` [PATCH v2 04/11] net/e1000: restore flex " Wei Zhao
2017-06-02  8:17     ` Lu, Wenzhuo
2017-06-02  6:36   ` [PATCH v2 05/11] net/e1000: parse n-tuple filter Wei Zhao
2017-06-05  1:21     ` Lu, Wenzhuo
2017-06-05  1:55       ` Zhao1, Wei
2017-06-05  2:36         ` Lu, Wenzhuo
2017-06-05  2:39           ` Zhao1, Wei
2017-06-02  6:36   ` [PATCH v2 06/11] net/e1000: parse ethertype filter Wei Zhao
2017-06-05  3:13     ` Lu, Wenzhuo
2017-06-05  3:26       ` Zhao1, Wei
2017-06-02  6:36   ` [PATCH v2 07/11] net/e1000: parse TCP SYN filter Wei Zhao
2017-06-05  3:16     ` Lu, Wenzhuo
2017-06-02  6:36   ` [PATCH v2 08/11] net/e1000: parse flex filter Wei Zhao
2017-06-05  3:38     ` Lu, Wenzhuo
2017-06-05  3:41       ` Zhao1, Wei
2017-06-02  6:36   ` [PATCH v2 09/11] net/e1000: create consistent filter Wei Zhao
2017-06-05  5:14     ` Lu, Wenzhuo
2017-06-02  6:36   ` [PATCH v2 10/11] net/e1000: destroy " Wei Zhao
2017-06-05  5:41     ` Lu, Wenzhuo
2017-06-05  6:00       ` Zhao1, Wei
2017-06-05  6:08         ` Lu, Wenzhuo
2017-06-02  6:36   ` [PATCH v2 11/11] net/e1000: flush all the filter Wei Zhao
2017-06-05  6:09     ` Lu, Wenzhuo
2017-06-09  3:11   ` [PATCH 00/11] net/e1000: Consistent filter API Wei Zhao
2017-06-09  3:11     ` [PATCH v3 01/11] net/e1000: store and restore TCP SYN filter Wei Zhao
2017-06-09  3:11     ` [PATCH v3 02/11] net/e1000: restore n-tuple filter Wei Zhao
2017-06-09  3:11     ` [PATCH v3 03/11] net/e1000: restore ether type filter Wei Zhao
2017-06-09  3:11     ` [PATCH v3 04/11] net/e1000: restore flex " Wei Zhao
2017-06-09  3:11     ` [PATCH v3 05/11] net/e1000: parse n-tuple filter Wei Zhao
2017-06-09 12:29       ` Ferruh Yigit
2017-06-12  7:47         ` Zhao1, Wei
2017-06-09  3:11     ` [PATCH v3 06/11] net/e1000: parse ethertype filter Wei Zhao
2017-06-09  3:11     ` [PATCH v3 07/11] net/e1000: parse TCP SYN filter Wei Zhao
2017-06-09  3:11     ` [PATCH v3 08/11] net/e1000: parse flex filter Wei Zhao
2017-06-09 12:23       ` Ferruh Yigit
2017-06-12  3:25         ` Zhao1, Wei
2017-06-09  3:11     ` [PATCH v3 09/11] net/e1000: create consistent filter Wei Zhao
2017-06-09  3:11     ` [PATCH v3 10/11] net/e1000: destroy " Wei Zhao
2017-06-09  3:11     ` [PATCH v3 11/11] net/e1000: flush all the filter Wei Zhao
2017-06-12  6:30     ` [PATCH 00/11] net/e1000: Consistent filter API Wei Zhao
2017-06-12  6:30       ` [PATCH v4] net/e1000: parse n-tuple filter Wei Zhao
2017-06-12  6:30       ` [PATCH v4 01/11] net/e1000: store and restore TCP SYN filter Wei Zhao
2017-06-12  6:30       ` [PATCH v4 02/11] net/e1000: restore n-tuple filter Wei Zhao
2017-06-12  6:30       ` [PATCH v4 03/11] net/e1000: restore ether type filter Wei Zhao
2017-06-12  6:30       ` [PATCH v4 04/11] net/e1000: restore flex " Wei Zhao
2017-06-12  6:30       ` [PATCH v4 05/11] net/e1000: parse n-tuple filter Wei Zhao
2017-06-12  6:30       ` [PATCH v4 06/11] net/e1000: parse ethertype filter Wei Zhao
2017-06-12  6:30       ` [PATCH v4 07/11] net/e1000: parse TCP SYN filter Wei Zhao
2017-06-12  6:30       ` [PATCH v4 08/11] net/e1000: parse flex filter Wei Zhao
2017-06-12  6:30       ` [PATCH v4 09/11] net/e1000: create consistent filter Wei Zhao
2017-06-12  6:30       ` [PATCH v4 10/11] net/e1000: destroy " Wei Zhao
2017-06-12  6:30       ` [PATCH v4 11/11] net/e1000: flush all the filter Wei Zhao
2017-06-12  6:48       ` [PATCH 00/11] net/e1000: Consistent filter API Wei Zhao
2017-06-12  6:48         ` [PATCH v5 01/11] net/e1000: store and restore TCP SYN filter Wei Zhao
2017-06-12 10:45           ` Ferruh Yigit
2017-06-14  8:59             ` Zhao1, Wei
2017-06-12  6:48         ` [PATCH v5 02/11] net/e1000: restore n-tuple filter Wei Zhao
2017-06-12  6:48         ` [PATCH v5 03/11] net/e1000: restore ether type filter Wei Zhao
2017-06-12  6:48         ` [PATCH v5 04/11] net/e1000: restore flex " Wei Zhao
2017-06-12  6:48         ` [PATCH v5 05/11] net/e1000: parse n-tuple filter Wei Zhao
2017-06-12  6:48         ` [PATCH v5 06/11] net/e1000: parse ethertype filter Wei Zhao
2017-06-12  6:48         ` [PATCH v5 07/11] net/e1000: parse TCP SYN filter Wei Zhao
2017-06-12  6:48         ` [PATCH v5 08/11] net/e1000: parse flex filter Wei Zhao
2017-06-12  6:48         ` [PATCH v5 09/11] net/e1000: create consistent filter Wei Zhao
2017-06-12  6:48         ` [PATCH v5 10/11] net/e1000: destroy " Wei Zhao
2017-06-12  6:48         ` [PATCH v5 11/11] net/e1000: flush all the filter Wei Zhao
2017-06-12 10:47         ` [PATCH 00/11] net/e1000: Consistent filter API 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=1495523581-56027-12-git-send-email-wei.zhao1@intel.com \
    --to=wei.zhao1@intel.com \
    --cc=dev@dpdk.org \
    /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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.