net/bnxt: delete and flush L2 filters cleanly

Once the last filter associated with a VNIC is deleted when using
RSS action or the Queue action free the VNIC. Also free the RSS
context if the VNIC is using it.

Reviewed-by: Rahul Gupta <rahul.gupta@broadcom.com>
Reviewed-by: Venkat Duvvuru <venkatkumar.duvvuru@broadcom.com>
Signed-off-by: Kalesh AP <kalesh-anakkur.purayil@broadcom.com>
Signed-off-by: Ajit Khaparde <ajit.khaparde@broadcom.com>

diff --git a/drivers/net/bnxt/bnxt_filter.c b/drivers/net/bnxt/bnxt_filter.c
index 34db988..e95d47d 100644 (file)
--- a/drivers/net/bnxt/bnxt_filter.c
+++ b/drivers/net/bnxt/bnxt_filter.c
@@ -117,6 +117,13 @@ void bnxt_free_filter_mem(struct bnxt *bp)
        max_filters = bp->max_l2_ctx;
        for (i = 0; i < max_filters; i++) {
                filter = &bp->filter_info[i];
+               if (filter->fw_ntuple_filter_id != ((uint64_t)-1) &&
+                   filter->filter_type == HWRM_CFA_NTUPLE_FILTER) {
+                       /* Call HWRM to try to free filter again */
+                       rc = bnxt_hwrm_clear_ntuple_filter(bp, filter);
+               }
+               filter->fw_ntuple_filter_id = UINT64_MAX;
+
                if (filter->fw_l2_filter_id != ((uint64_t)-1) &&
                    filter->filter_type == HWRM_CFA_L2_FILTER) {
                        PMD_DRV_LOG(DEBUG, "L2 filter is not free\n");
@@ -129,17 +136,6 @@ void bnxt_free_filter_mem(struct bnxt *bp)
                }
                filter->fw_l2_filter_id = UINT64_MAX;
 
-               if (filter->fw_ntuple_filter_id != ((uint64_t)-1) &&
-                   filter->filter_type == HWRM_CFA_NTUPLE_FILTER) {
-                       PMD_DRV_LOG(ERR, "NTUPLE filter is not free\n");
-                       /* Call HWRM to try to free filter again */
-                       rc = bnxt_hwrm_clear_ntuple_filter(bp, filter);
-                       if (rc)
-                               PMD_DRV_LOG(ERR,
-                                           "Cannot free NTUPLE filter: %d\n",
-                                           rc);
-               }
-               filter->fw_ntuple_filter_id = UINT64_MAX;
        }
        STAILQ_INIT(&bp->free_filter_list);
 

diff --git a/drivers/net/bnxt/bnxt_flow.c b/drivers/net/bnxt/bnxt_flow.c
index 9e0ce56..33f4b07 100644 (file)
--- a/drivers/net/bnxt/bnxt_flow.c
+++ b/drivers/net/bnxt/bnxt_flow.c
@@ -1636,7 +1636,7 @@ free_flow:
                rte_flow_error_set(error, 0,
                                   RTE_FLOW_ERROR_TYPE_NONE, NULL,
                                   "Flow with pattern exists, updating destination queue");
-       else if (!rte_errno)
+       else
                rte_flow_error_set(error, -ret,
                                   RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
                                   "Failed to create flow.");
@@ -1715,6 +1715,7 @@ bnxt_flow_destroy(struct rte_eth_dev *dev,
        ret = bnxt_match_filter(bp, filter);
        if (ret == 0)
                PMD_DRV_LOG(ERR, "Could not find matching flow\n");
+
        if (filter->filter_type == HWRM_CFA_EM_FILTER)
                ret = bnxt_hwrm_clear_em_filter(bp, filter);
        if (filter->filter_type == HWRM_CFA_NTUPLE_FILTER)
@@ -1723,9 +1724,40 @@ bnxt_flow_destroy(struct rte_eth_dev *dev,
 
 done:
        if (!ret) {
+               STAILQ_REMOVE(&vnic->filter, filter, bnxt_filter_info, next);
                bnxt_free_filter(bp, filter);
                STAILQ_REMOVE(&vnic->flow_list, flow, rte_flow, next);
                rte_free(flow);
+
+               /* If this was the last flow associated with this vnic,
+                * switch the queue back to RSS pool.
+                */
+               if (vnic && STAILQ_EMPTY(&vnic->flow_list)) {
+                       rte_free(vnic->fw_grp_ids);
+                       if (vnic->rx_queue_cnt > 1) {
+                               if (BNXT_CHIP_THOR(bp)) {
+                                       int j;
+
+                                       for (j = 0; j < vnic->num_lb_ctxts;
+                                            j++) {
+                                               bnxt_hwrm_vnic_ctx_free(bp,
+                                                                        vnic,
+                                                                        vnic->fw_grp_ids[j]);
+                                               vnic->fw_grp_ids[j] =
+                                                       INVALID_HW_RING_ID;
+                                       }
+                                       vnic->num_lb_ctxts = 0;
+                               } else {
+                                       bnxt_hwrm_vnic_ctx_free(bp,
+                                                               vnic,
+                                                               vnic->rss_rule);
+                                       vnic->rss_rule = INVALID_HW_RING_ID;
+                               }
+                       }
+                       bnxt_hwrm_vnic_free(bp, vnic);
+                       vnic->rx_queue_cnt = 0;
+                       bp->nr_vnics--;
+               }
        } else {
                rte_flow_error_set(error, -ret,
                                   RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
@@ -1744,8 +1776,11 @@ bnxt_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
        unsigned int i;
        int ret = 0;
 
-       for (i = 0; i < bp->nr_vnics; i++) {
+       for (i = 0; i < bp->max_vnics; i++) {
                vnic = &bp->vnic_info[i];
+               if (vnic->fw_vnic_id == INVALID_VNIC_ID)
+                       continue;
+
                STAILQ_FOREACH(flow, &vnic->flow_list, next) {
                        struct bnxt_filter_info *filter = flow->filter;
 
@@ -1766,6 +1801,8 @@ bnxt_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
                                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

diff --git a/drivers/net/bnxt/bnxt_hwrm.c b/drivers/net/bnxt/bnxt_hwrm.c
index 7c1aaa6..5cb3949 100644 (file)
--- a/drivers/net/bnxt/bnxt_hwrm.c
+++ b/drivers/net/bnxt/bnxt_hwrm.c
@@ -2362,7 +2362,8 @@ bnxt_clear_hwrm_vnic_flows(struct bnxt *bp, struct bnxt_vnic_info *vnic)
        struct rte_flow *flow;
        int rc = 0;
 
-       STAILQ_FOREACH(flow, &vnic->flow_list, next) {
+       while (!STAILQ_EMPTY(&vnic->flow_list)) {
+               flow = STAILQ_FIRST(&vnic->flow_list);
                filter = flow->filter;
                PMD_DRV_LOG(DEBUG, "filter type %d\n", filter->filter_type);
                if (filter->filter_type == HWRM_CFA_EM_FILTER)
@@ -2424,13 +2425,12 @@ void bnxt_free_all_hwrm_resources(struct bnxt *bp)
         * Cleanup VNICs in reverse order, to make sure the L2 filter
         * from vnic0 is last to be cleaned up.
         */
-       for (i = bp->nr_vnics - 1; i >= 0; i--) {
+       for (i = bp->max_vnics - 1; i >= 0; i--) {
                struct bnxt_vnic_info *vnic = &bp->vnic_info[i];
 
-               if (vnic->fw_vnic_id == INVALID_HW_RING_ID) {
-                       PMD_DRV_LOG(DEBUG, "Invalid vNIC ID\n");
-                       return;
-               }
+               // If the VNIC ID is invalid we are not currently using the VNIC
+               if (vnic->fw_vnic_id == INVALID_HW_RING_ID)
+                       continue;
 
                bnxt_clear_hwrm_vnic_flows(bp, vnic);
 
@@ -4307,23 +4307,31 @@ int bnxt_vnic_rss_configure(struct bnxt *bp, struct bnxt_vnic_info *vnic)
        if (BNXT_CHIP_THOR(bp))
                return bnxt_vnic_rss_configure_thor(bp, vnic);
 
-       /*
-        * Fill the RSS hash & redirection table with
-        * ring group ids for all VNICs
-        */
-       for (rss_idx = 0, fw_idx = 0; rss_idx < HW_HASH_INDEX_SIZE;
-               rss_idx++, fw_idx++) {
-               for (i = 0; i < bp->rx_cp_nr_rings; i++) {
-                       fw_idx %= bp->rx_cp_nr_rings;
-                       if (vnic->fw_grp_ids[fw_idx] != INVALID_HW_RING_ID)
-                               break;
-                       fw_idx++;
+       if (vnic->fw_vnic_id == INVALID_HW_RING_ID)
+               return 0;
+
+       if (vnic->rss_table && vnic->hash_type) {
+               /*
+                * Fill the RSS hash & redirection table with
+                * ring group ids for all VNICs
+                */
+               for (rss_idx = 0, fw_idx = 0; rss_idx < HW_HASH_INDEX_SIZE;
+                       rss_idx++, fw_idx++) {
+                       for (i = 0; i < bp->rx_cp_nr_rings; i++) {
+                               fw_idx %= bp->rx_cp_nr_rings;
+                               if (vnic->fw_grp_ids[fw_idx] !=
+                                   INVALID_HW_RING_ID)
+                                       break;
+                               fw_idx++;
+                       }
+                       if (i == bp->rx_cp_nr_rings)
+                               return 0;
+                       vnic->rss_table[rss_idx] = vnic->fw_grp_ids[fw_idx];
                }
-               if (i == bp->rx_cp_nr_rings)
-                       return 0;
-               vnic->rss_table[rss_idx] = vnic->fw_grp_ids[fw_idx];
+               return bnxt_hwrm_vnic_rss_cfg(bp, vnic);
        }
-       return bnxt_hwrm_vnic_rss_cfg(bp, vnic);
+
+       return 0;
 }
 
 static void bnxt_hwrm_set_coal_params(struct bnxt_coal *hw_coal,