net/bnxt: fix flow flush to sync with flow destroy

[dpdk.git] / drivers / net / bnxt / bnxt_flow.c

diff --git a/drivers/net/bnxt/bnxt_flow.c b/drivers/net/bnxt/bnxt_flow.c
index 7bd6811..7343b7e 100644 (file)
--- a/drivers/net/bnxt/bnxt_flow.c
+++ b/drivers/net/bnxt/bnxt_flow.c
@@ -1536,10 +1536,13 @@ bnxt_update_filter(struct bnxt *bp, struct bnxt_filter_info *old_filter,
         * filter which points to the new destination queue and so we clear
         * the previous L2 filter. For ntuple filters, we are going to reuse
         * the old L2 filter and create new NTUPLE filter with this new
-        * destination queue subsequently during bnxt_flow_create.
+        * destination queue subsequently during bnxt_flow_create. So we
+        * decrement the ref cnt of the L2 filter that would've been bumped
+        * up previously in bnxt_validate_and_parse_flow as the old n-tuple
+        * filter that was referencing it will be deleted now.
         */
+       bnxt_hwrm_clear_l2_filter(bp, old_filter);
        if (new_filter->filter_type == HWRM_CFA_L2_FILTER) {
-               bnxt_hwrm_clear_l2_filter(bp, old_filter);
                bnxt_hwrm_set_l2_filter(bp, new_filter->dst_id, new_filter);
        } else {
                if (new_filter->filter_type == HWRM_CFA_EM_FILTER)
@@ -1816,46 +1819,24 @@ static int bnxt_handle_tunnel_redirect_destroy(struct bnxt *bp,
 }
 
 static int
-bnxt_flow_destroy(struct rte_eth_dev *dev,
-                 struct rte_flow *flow,
-                 struct rte_flow_error *error)
+_bnxt_flow_destroy(struct bnxt *bp,
+                  struct rte_flow *flow,
+                   struct rte_flow_error *error)
 {
-       struct bnxt *bp = dev->data->dev_private;
        struct bnxt_filter_info *filter;
        struct bnxt_vnic_info *vnic;
        int ret = 0;
 
-       bnxt_acquire_flow_lock(bp);
-       if (!flow) {
-               rte_flow_error_set(error, EINVAL,
-                                  RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
-                                  "Invalid flow: failed to destroy flow.");
-               bnxt_release_flow_lock(bp);
-               return -EINVAL;
-       }
-
        filter = flow->filter;
        vnic = flow->vnic;
 
-       if (!filter) {
-               rte_flow_error_set(error, EINVAL,
-                                  RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
-                                  "Invalid flow: failed to destroy flow.");
-               bnxt_release_flow_lock(bp);
-               return -EINVAL;
-       }
-
        if (filter->filter_type == HWRM_CFA_TUNNEL_REDIRECT_FILTER &&
            filter->enables == filter->tunnel_type) {
-               ret = bnxt_handle_tunnel_redirect_destroy(bp,
-                                                         filter,
-                                                         error);
-               if (!ret) {
+               ret = bnxt_handle_tunnel_redirect_destroy(bp, filter, error);
+               if (!ret)
                        goto done;
-               } else {
-                       bnxt_release_flow_lock(bp);
+               else
                        return ret;
-               }
        }
 
        ret = bnxt_match_filter(bp, filter);
@@ -1902,7 +1883,36 @@ done:
                                   "Failed to destroy flow.");
        }
 
+       return ret;
+}
+
+static int
+bnxt_flow_destroy(struct rte_eth_dev *dev,
+                 struct rte_flow *flow,
+                 struct rte_flow_error *error)
+{
+       struct bnxt *bp = dev->data->dev_private;
+       int ret = 0;
+
+       bnxt_acquire_flow_lock(bp);
+       if (!flow) {
+               rte_flow_error_set(error, EINVAL,
+                                  RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
+                                  "Invalid flow: failed to destroy flow.");
+               bnxt_release_flow_lock(bp);
+               return -EINVAL;
+       }
+
+       if (!flow->filter) {
+               rte_flow_error_set(error, EINVAL,
+                                  RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
+                                  "Invalid flow: failed to destroy flow.");
+               bnxt_release_flow_lock(bp);
+               return -EINVAL;
+       }
+       ret = _bnxt_flow_destroy(bp, flow, error);
        bnxt_release_flow_lock(bp);
+
        return ret;
 }
 
@@ -1910,7 +1920,6 @@ static int
 bnxt_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
 {
        struct bnxt *bp = dev->data->dev_private;
-       struct bnxt_filter_info *filter = NULL;
        struct bnxt_vnic_info *vnic;
        struct rte_flow *flow;
        unsigned int i;
@@ -1924,66 +1933,17 @@ bnxt_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
 
                while (!STAILQ_EMPTY(&vnic->flow_list)) {
                        flow = STAILQ_FIRST(&vnic->flow_list);
-                       filter = flow->filter;
-
-                       if (filter->filter_type ==
-                           HWRM_CFA_TUNNEL_REDIRECT_FILTER &&
-                           filter->enables == filter->tunnel_type) {
-                               ret =
-                               bnxt_handle_tunnel_redirect_destroy(bp,
-                                                                   filter,
-                                                                   error);
-                               if (!ret) {
-                                       goto done;
-                               } else {
-                                       bnxt_release_flow_lock(bp);
-                                       return ret;
-                               }
-                       }
-
-                       if (filter->filter_type == HWRM_CFA_EM_FILTER)
-                               ret = bnxt_hwrm_clear_em_filter(bp, filter);
-                       if (filter->filter_type == HWRM_CFA_NTUPLE_FILTER)
-                               ret = bnxt_hwrm_clear_ntuple_filter(bp, filter);
-                       else if (i)
-                               ret = bnxt_hwrm_clear_l2_filter(bp, filter);
-
-                       if (ret) {
-                               rte_flow_error_set
-                                       (error,
-                                        -ret,
-                                        RTE_FLOW_ERROR_TYPE_HANDLE,
-                                        NULL,
-                                        "Failed to flush flow in HW.");
-                               bnxt_release_flow_lock(bp);
-                               return -rte_errno;
-                       }
-done:
-                       STAILQ_REMOVE(&vnic->flow_list, flow,
-                                     rte_flow, next);
-
-                       STAILQ_REMOVE(&vnic->filter,
-                                     filter,
-                                     bnxt_filter_info,
-                                     next);
-                       bnxt_free_filter(bp, filter);
 
-                       rte_free(flow);
+                       if (!flow->filter)
+                               continue;
 
-                       /* If this was the last flow associated with this vnic,
-                        * switch the queue back to RSS pool.
-                        */
-                       if (STAILQ_EMPTY(&vnic->flow_list)) {
-                               rte_free(vnic->fw_grp_ids);
-                               if (vnic->rx_queue_cnt > 1)
-                                       bnxt_hwrm_vnic_ctx_free(bp, vnic);
-                               bnxt_hwrm_vnic_free(bp, vnic);
-                               vnic->rx_queue_cnt = 0;
-                       }
+                       ret = _bnxt_flow_destroy(bp, flow, error);
+                       if (ret)
+                               break;
                }
        }
-
        bnxt_release_flow_lock(bp);
+
        return ret;
 }