net/igb: flush all the filter

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>

diff --git a/drivers/net/e1000/e1000_ethdev.h b/drivers/net/e1000/e1000_ethdev.h
index bc48df1..9266540 100644 (file)
--- a/drivers/net/e1000/e1000_ethdev.h
+++ b/drivers/net/e1000/e1000_ethdev.h
@@ -479,6 +479,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 eb5da80..a0da9d5 100644 (file)
--- a/drivers/net/e1000/igb_ethdev.c
+++ b/drivers/net/e1000/igb_ethdev.c
@@ -1012,6 +1012,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;
 }
 
@@ -3850,6 +3853,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
  *
@@ -3865,7 +3886,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;
@@ -3885,13 +3905,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;
 }
 
@@ -3954,7 +3969,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)
 {
@@ -4375,6 +4390,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
  *
@@ -4390,7 +4427,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;
@@ -4410,17 +4446,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;
 }
 
@@ -4676,7 +4703,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 085b17b..ce48c0d 100644 (file)
--- a/drivers/net/e1000/igb_flow.c
+++ b/drivers/net/e1000/igb_flow.c
@@ -1533,10 +1533,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,
 };