X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fbnxt%2Fbnxt_flow.c;h=cde1fa41c4bb57581c034c9e4b4553ccd879fc4a;hb=c916517f74b1dc3ccc866527598f8d624c3d2cc9;hp=4e6b4d7fce85b800976a2da4e2c1da91d21446f7;hpb=40724480038911ecc3b1c7a2b5a57ecc3e793ffd;p=dpdk.git diff --git a/drivers/net/bnxt/bnxt_flow.c b/drivers/net/bnxt/bnxt_flow.c index 4e6b4d7fce..cde1fa41c4 100644 --- a/drivers/net/bnxt/bnxt_flow.c +++ b/drivers/net/bnxt/bnxt_flow.c @@ -17,7 +17,6 @@ #include "bnxt_ring.h" #include "bnxt_rxq.h" #include "bnxt_vnic.h" -#include "bnxt_util.h" #include "hsi_struct_def_dpdk.h" static int @@ -78,7 +77,7 @@ bnxt_flow_non_void_action(const struct rte_flow_action *cur) static int bnxt_filter_type_check(const struct rte_flow_item pattern[], - struct rte_flow_error *error __rte_unused) + struct rte_flow_error *error) { const struct rte_flow_item *item = bnxt_flow_non_void_item(pattern); @@ -137,6 +136,7 @@ bnxt_validate_and_parse_flow_type(struct bnxt *bp, const struct rte_flow_item_tcp *tcp_spec, *tcp_mask; const struct rte_flow_item_udp *udp_spec, *udp_mask; const struct rte_flow_item_eth *eth_spec, *eth_mask; + const struct rte_ether_addr *dst, *src; const struct rte_flow_item_nvgre *nvgre_spec; const struct rte_flow_item_nvgre *nvgre_mask; const struct rte_flow_item_gre *gre_spec; @@ -162,7 +162,7 @@ bnxt_validate_and_parse_flow_type(struct bnxt *bp, PMD_DRV_LOG(DEBUG, "Use NTUPLE %d\n", use_ntuple); filter->filter_type = use_ntuple ? - HWRM_CFA_NTUPLE_FILTER : HWRM_CFA_EM_FILTER; + HWRM_CFA_NTUPLE_FILTER : HWRM_CFA_L2_FILTER; en_ethertype = use_ntuple ? NTUPLE_FLTR_ALLOC_INPUT_EN_ETHERTYPE : EM_FLOW_ALLOC_INPUT_EN_ETHERTYPE; @@ -219,12 +219,15 @@ bnxt_validate_and_parse_flow_type(struct bnxt *bp, } if (rte_is_broadcast_ether_addr(ð_mask->dst)) { - if (!rte_is_unicast_ether_addr(ð_spec->dst)) { + dst = ð_spec->dst; + if (!rte_is_valid_assigned_ether_addr(dst)) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "DMAC is invalid"); + PMD_DRV_LOG(ERR, + "DMAC is invalid!\n"); return -rte_errno; } rte_memcpy(filter->dst_macaddr, @@ -239,14 +242,16 @@ bnxt_validate_and_parse_flow_type(struct bnxt *bp, PMD_DRV_LOG(DEBUG, "Creating a priority flow\n"); } - if (rte_is_broadcast_ether_addr(ð_mask->src)) { - if (!rte_is_unicast_ether_addr(ð_spec->src)) { + src = ð_spec->src; + if (!rte_is_valid_assigned_ether_addr(src)) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "SMAC is invalid"); + PMD_DRV_LOG(ERR, + "SMAC is invalid!\n"); return -rte_errno; } rte_memcpy(filter->src_macaddr, @@ -267,6 +272,8 @@ bnxt_validate_and_parse_flow_type(struct bnxt *bp, rte_be_to_cpu_16(eth_spec->type); en |= en_ethertype; } + if (inner) + valid_flags |= BNXT_FLOW_PARSE_INNER_FLAG; break; case RTE_FLOW_ITEM_TYPE_VLAN: @@ -739,10 +746,9 @@ bnxt_find_matching_l2_filter(struct bnxt *bp, struct bnxt_filter_info *nf) { struct bnxt_filter_info *mf, *f0; struct bnxt_vnic_info *vnic0; - struct rte_flow *flow; int i; - vnic0 = &bp->vnic_info[0]; + vnic0 = BNXT_GET_DEFAULT_VNIC(bp); f0 = STAILQ_FIRST(&vnic0->filter); /* This flow has same DST MAC as the port/l2 filter. */ @@ -755,8 +761,7 @@ bnxt_find_matching_l2_filter(struct bnxt *bp, struct bnxt_filter_info *nf) if (vnic->fw_vnic_id == INVALID_VNIC_ID) continue; - STAILQ_FOREACH(flow, &vnic->flow_list, next) { - mf = flow->filter; + STAILQ_FOREACH(mf, &vnic->filter, next) { if (mf->matching_l2_fltr_ptr) continue; @@ -791,6 +796,8 @@ bnxt_create_l2_filter(struct bnxt *bp, struct bnxt_filter_info *nf, if (filter1 == NULL) return NULL; + memcpy(filter1, nf, sizeof(*filter1)); + filter1->flags = HWRM_CFA_L2_FILTER_ALLOC_INPUT_FLAGS_XDP_DISABLE; filter1->flags |= HWRM_CFA_L2_FILTER_ALLOC_INPUT_FLAGS_PATH_RX; if (nf->valid_flags & BNXT_FLOW_L2_SRC_VALID_FLAG || @@ -824,9 +831,36 @@ bnxt_create_l2_filter(struct bnxt *bp, struct bnxt_filter_info *nf, } } - filter1->enables = HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR | + if (nf->valid_flags & (BNXT_FLOW_L2_DST_VALID_FLAG | + BNXT_FLOW_L2_SRC_VALID_FLAG | + BNXT_FLOW_L2_INNER_SRC_VALID_FLAG | + BNXT_FLOW_L2_INNER_DST_VALID_FLAG)) { + filter1->enables = + HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR | L2_FILTER_ALLOC_INPUT_EN_L2_ADDR_MASK; - memset(filter1->l2_addr_mask, 0xff, RTE_ETHER_ADDR_LEN); + memset(filter1->l2_addr_mask, 0xff, RTE_ETHER_ADDR_LEN); + } + + if (nf->valid_flags & BNXT_FLOW_L2_DROP_FLAG) { + filter1->flags |= + HWRM_CFA_L2_FILTER_ALLOC_INPUT_FLAGS_DROP; + if (nf->ethertype == RTE_ETHER_TYPE_IPV4) { + /* Num VLANs for drop filter will/should be 0. + * If the req is memset to 0, then the count will + * be automatically set to 0. + */ + if (nf->valid_flags & BNXT_FLOW_PARSE_INNER_FLAG) { + filter1->enables |= + L2_FILTER_ALLOC_INPUT_EN_T_NUM_VLANS; + } else { + filter1->enables |= + L2_FILTER_ALLOC_INPUT_EN_NUM_VLANS; + filter1->flags |= + HWRM_CFA_L2_FILTER_ALLOC_INPUT_FLAGS_OUTERMOST; + } + } + } + rc = bnxt_hwrm_set_l2_filter(bp, vnic->fw_vnic_id, filter1); if (rc) { @@ -846,11 +880,14 @@ bnxt_get_l2_filter(struct bnxt *bp, struct bnxt_filter_info *nf, l2_filter = bnxt_find_matching_l2_filter(bp, nf); if (l2_filter) { l2_filter->l2_ref_cnt++; - nf->matching_l2_fltr_ptr = l2_filter; } else { l2_filter = bnxt_create_l2_filter(bp, nf, vnic); - nf->matching_l2_fltr_ptr = NULL; + if (l2_filter) { + STAILQ_INSERT_TAIL(&vnic->filter, l2_filter, next); + l2_filter->vnic = vnic; + } } + nf->matching_l2_fltr_ptr = l2_filter; return l2_filter; } @@ -944,7 +981,9 @@ bnxt_update_filter_flags_en(struct bnxt_filter_info *filter, ~(BNXT_FLOW_L2_DST_VALID_FLAG | BNXT_FLOW_L2_SRC_VALID_FLAG | BNXT_FLOW_L2_INNER_SRC_VALID_FLAG | - BNXT_FLOW_L2_INNER_DST_VALID_FLAG))) { + BNXT_FLOW_L2_INNER_DST_VALID_FLAG | + BNXT_FLOW_L2_DROP_FLAG | + BNXT_FLOW_PARSE_INNER_FLAG))) { filter->flags = filter1->flags; filter->enables = filter1->enables; filter->filter_type = HWRM_CFA_L2_FILTER; @@ -955,6 +994,7 @@ bnxt_update_filter_flags_en(struct bnxt_filter_info *filter, } filter->fw_l2_filter_id = filter1->fw_l2_filter_id; filter->l2_ref_cnt = filter1->l2_ref_cnt; + filter->flow_id = filter1->flow_id; PMD_DRV_LOG(DEBUG, "l2_filter: %p fw_l2_filter_id %" PRIx64 " l2_ref_cnt %u\n", filter1, filter->fw_l2_filter_id, filter->l2_ref_cnt); @@ -972,11 +1012,11 @@ bnxt_validate_and_parse_flow(struct rte_eth_dev *dev, bnxt_flow_non_void_action(actions); struct bnxt *bp = dev->data->dev_private; struct rte_eth_conf *dev_conf = &bp->eth_dev->data->dev_conf; + struct bnxt_vnic_info *vnic = NULL, *vnic0 = NULL; const struct rte_flow_action_queue *act_q; const struct rte_flow_action_vf *act_vf; struct bnxt_filter_info *filter1 = NULL; const struct rte_flow_action_rss *rss; - struct bnxt_vnic_info *vnic, *vnic0; struct bnxt_rx_queue *rxq = NULL; int dflt_vnic, vnic_id; unsigned int rss_idx; @@ -997,6 +1037,8 @@ bnxt_validate_and_parse_flow(struct rte_eth_dev *dev, filter->flags = HWRM_CFA_EM_FLOW_ALLOC_INPUT_FLAGS_PATH_RX; use_ntuple = bnxt_filter_type_check(pattern, error); + +start: switch (act->type) { case RTE_FLOW_ACTION_TYPE_QUEUE: /* Allow this flow. Redirect to a VNIC. */ @@ -1049,13 +1091,7 @@ bnxt_validate_and_parse_flow(struct rte_eth_dev *dev, vnic->fw_vnic_id != INVALID_HW_RING_ID) goto use_vnic; - //if (!rxq || - //bp->vnic_info[0].fw_grp_ids[act_q->index] != - //INVALID_HW_RING_ID || - //!rxq->rx_deferred_start) { - if (!rxq || - bp->vnic_info[0].fw_grp_ids[act_q->index] != - INVALID_HW_RING_ID) { + if (!rxq) { PMD_DRV_LOG(ERR, "Queue invalid or used with other VNIC\n"); rte_flow_error_set(error, @@ -1077,8 +1113,15 @@ bnxt_validate_and_parse_flow(struct rte_eth_dev *dev, PMD_DRV_LOG(DEBUG, "VNIC found\n"); rc = bnxt_vnic_prep(bp, vnic); - if (rc) + if (rc) { + rte_flow_error_set(error, + EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, + act, + "VNIC prep fail"); + rc = -rte_errno; goto ret; + } PMD_DRV_LOG(DEBUG, "vnic[%d] = %p vnic->fw_grp_ids = %p\n", @@ -1089,9 +1132,23 @@ use_vnic: PMD_DRV_LOG(DEBUG, "Setting vnic ff_idx %d\n", vnic->ff_pool_idx); filter->dst_id = vnic->fw_vnic_id; - filter1 = bnxt_get_l2_filter(bp, filter, vnic); + + /* For ntuple filter, create the L2 filter with default VNIC. + * The user specified redirect queue will be set while creating + * the ntuple filter in hardware. + */ + vnic0 = BNXT_GET_DEFAULT_VNIC(bp); + if (use_ntuple) + filter1 = bnxt_get_l2_filter(bp, filter, vnic0); + else + filter1 = bnxt_get_l2_filter(bp, filter, vnic); if (filter1 == NULL) { - rc = -ENOSPC; + rte_flow_error_set(error, + ENOSPC, + RTE_FLOW_ERROR_TYPE_ACTION, + act, + "Filter not available"); + rc = -rte_errno; goto ret; } @@ -1101,29 +1158,43 @@ use_vnic: break; case RTE_FLOW_ACTION_TYPE_DROP: vnic0 = &bp->vnic_info[0]; + filter->dst_id = vnic0->fw_vnic_id; + filter->valid_flags |= BNXT_FLOW_L2_DROP_FLAG; filter1 = bnxt_get_l2_filter(bp, filter, vnic0); if (filter1 == NULL) { - rc = -ENOSPC; + rte_flow_error_set(error, + ENOSPC, + RTE_FLOW_ERROR_TYPE_ACTION, + act, + "Filter not available"); + rc = -rte_errno; goto ret; } - filter->fw_l2_filter_id = filter1->fw_l2_filter_id; if (filter->filter_type == HWRM_CFA_EM_FILTER) filter->flags = HWRM_CFA_EM_FLOW_ALLOC_INPUT_FLAGS_DROP; - else + else if (filter->filter_type == HWRM_CFA_NTUPLE_FILTER) filter->flags = HWRM_CFA_NTUPLE_FILTER_ALLOC_INPUT_FLAGS_DROP; + + bnxt_update_filter_flags_en(filter, filter1, use_ntuple); break; case RTE_FLOW_ACTION_TYPE_COUNT: vnic0 = &bp->vnic_info[0]; filter1 = bnxt_get_l2_filter(bp, filter, vnic0); if (filter1 == NULL) { - rc = -ENOSPC; + rte_flow_error_set(error, + ENOSPC, + RTE_FLOW_ERROR_TYPE_ACTION, + act, + "New filter not available"); + rc = -rte_errno; goto ret; } filter->fw_l2_filter_id = filter1->fw_l2_filter_id; + filter->flow_id = filter1->flow_id; filter->flags = HWRM_CFA_NTUPLE_FILTER_ALLOC_INPUT_FLAGS_METER; break; case RTE_FLOW_ACTION_TYPE_VF: @@ -1182,11 +1253,17 @@ use_vnic: vnic0 = &bp->vnic_info[0]; filter1 = bnxt_get_l2_filter(bp, filter, vnic0); if (filter1 == NULL) { - rc = -ENOSPC; + rte_flow_error_set(error, + ENOSPC, + RTE_FLOW_ERROR_TYPE_ACTION, + act, + "New filter not available"); + rc = -rte_errno; goto ret; } filter->fw_l2_filter_id = filter1->fw_l2_filter_id; + filter->flow_id = filter1->flow_id; break; case RTE_FLOW_ACTION_TYPE_RSS: rss = (const struct rte_flow_action_rss *)act->conf; @@ -1252,9 +1329,6 @@ use_vnic: } rxq = bp->rx_queues[rss->queue[i]]; - //if (bp->vnic_info[0].fw_grp_ids[rss->queue[i]] != - //INVALID_HW_RING_ID || - //!rxq->rx_deferred_start) { if (bp->vnic_info[0].fw_grp_ids[rss->queue[i]] != INVALID_HW_RING_ID) { PMD_DRV_LOG(ERR, @@ -1278,8 +1352,15 @@ use_vnic: vnic->func_default = 0; //This is not a default VNIC. rc = bnxt_vnic_prep(bp, vnic); - if (rc) + if (rc) { + rte_flow_error_set(error, + EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, + act, + "VNIC prep fail"); + rc = -rte_errno; goto ret; + } PMD_DRV_LOG(DEBUG, "vnic[%d] = %p vnic->fw_grp_ids = %p\n", @@ -1334,13 +1415,46 @@ vnic_found: filter->dst_id = vnic->fw_vnic_id; filter1 = bnxt_get_l2_filter(bp, filter, vnic); if (filter1 == NULL) { - rc = -ENOSPC; + rte_flow_error_set(error, + ENOSPC, + RTE_FLOW_ERROR_TYPE_ACTION, + act, + "New filter not available"); + rc = -rte_errno; goto ret; } PMD_DRV_LOG(DEBUG, "L2 filter created\n"); bnxt_update_filter_flags_en(filter, filter1, use_ntuple); break; + case RTE_FLOW_ACTION_TYPE_MARK: + if (bp->flags & BNXT_FLAG_RX_VECTOR_PKT_MODE) { + PMD_DRV_LOG(DEBUG, + "Disable vector processing for mark\n"); + rte_flow_error_set(error, + ENOTSUP, + RTE_FLOW_ERROR_TYPE_ACTION, + act, + "Disable vector processing for mark"); + rc = -rte_errno; + goto ret; + } + + if (bp->mark_table == NULL) { + rte_flow_error_set(error, + ENOMEM, + RTE_FLOW_ERROR_TYPE_ACTION, + act, + "Mark table not allocated."); + rc = -rte_errno; + goto ret; + } + + filter->valid_flags |= BNXT_FLOW_MARK_FLAG; + filter->mark = ((const struct rte_flow_action_mark *) + act->conf)->id; + PMD_DRV_LOG(DEBUG, "Mark the flow %d\n", filter->mark); + break; default: rte_flow_error_set(error, EINVAL, @@ -1351,24 +1465,27 @@ vnic_found: goto ret; } - if (filter1 && !filter->matching_l2_fltr_ptr) { +done: + act = bnxt_flow_non_void_action(++act); + while (act->type != RTE_FLOW_ACTION_TYPE_END) + goto start; + + return rc; +ret: + + if (filter1) { + bnxt_hwrm_clear_l2_filter(bp, filter1); bnxt_free_filter(bp, filter1); - filter1->fw_l2_filter_id = -1; } -done: - act = bnxt_flow_non_void_action(++act); - if (act->type != RTE_FLOW_ACTION_TYPE_END) { - rte_flow_error_set(error, - EINVAL, - RTE_FLOW_ERROR_TYPE_ACTION, - act, - "Invalid action."); - rc = -rte_errno; - goto ret; + if (rte_errno) { + if (vnic && STAILQ_EMPTY(&vnic->filter)) + vnic->rx_queue_cnt = 0; + + if (rxq && !vnic->rx_queue_cnt) + rxq->vnic = &bp->vnic_info[0]; } -ret: - return rc; + return -rte_errno; } static @@ -1402,18 +1519,24 @@ bnxt_flow_validate(struct rte_eth_dev *dev, struct bnxt_filter_info *filter; int ret = 0; + bnxt_acquire_flow_lock(bp); ret = bnxt_flow_args_validate(attr, pattern, actions, error); - if (ret != 0) + if (ret != 0) { + bnxt_release_flow_lock(bp); return ret; + } filter = bnxt_get_unused_filter(bp); if (filter == NULL) { PMD_DRV_LOG(ERR, "Not enough resources for a new flow.\n"); + bnxt_release_flow_lock(bp); return -ENOMEM; } ret = bnxt_validate_and_parse_flow(dev, pattern, actions, attr, error, filter); + if (ret) + goto exit; vnic = find_matching_vnic(bp, filter); if (vnic) { @@ -1422,7 +1545,6 @@ bnxt_flow_validate(struct rte_eth_dev *dev, bnxt_hwrm_vnic_ctx_free(bp, vnic); bnxt_hwrm_vnic_free(bp, vnic); vnic->rx_queue_cnt = 0; - bp->nr_vnics--; PMD_DRV_LOG(DEBUG, "Free VNIC\n"); } } @@ -1434,9 +1556,10 @@ bnxt_flow_validate(struct rte_eth_dev *dev, else bnxt_hwrm_clear_l2_filter(bp, filter); +exit: /* No need to hold on to this filter if we are just validating flow */ - filter->fw_l2_filter_id = UINT64_MAX; bnxt_free_filter(bp, filter); + bnxt_release_flow_lock(bp); return ret; } @@ -1450,10 +1573,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) @@ -1550,6 +1676,15 @@ bnxt_flow_create(struct rte_eth_dev *dev, return NULL; } + if (!dev->data->dev_started) { + rte_flow_error_set(error, + EINVAL, + RTE_FLOW_ERROR_TYPE_UNSPECIFIED, + NULL, + "Device must be started"); + return NULL; + } + flow = rte_zmalloc("bnxt_flow", sizeof(struct rte_flow), 0); if (!flow) { rte_flow_error_set(error, ENOMEM, @@ -1558,6 +1693,7 @@ bnxt_flow_create(struct rte_eth_dev *dev, return flow; } + bnxt_acquire_flow_lock(bp); ret = bnxt_flow_args_validate(attr, pattern, actions, error); if (ret != 0) { PMD_DRV_LOG(ERR, "Not a validate flow.\n"); @@ -1643,35 +1779,31 @@ bnxt_flow_create(struct rte_eth_dev *dev, vnic = find_matching_vnic(bp, filter); done: if (!ret || update_flow) { - flow->filter = filter; - flow->vnic = vnic; - /* VNIC is set only in case of queue or RSS action */ - if (vnic) { - /* - * RxQ0 is not used for flow filters. - */ - - if (update_flow) { - ret = -EXDEV; - goto free_flow; - } - STAILQ_INSERT_TAIL(&vnic->filter, filter, next); - } - PMD_DRV_LOG(ERR, "Successfully created flow.\n"); - STAILQ_INSERT_TAIL(&vnic->flow_list, flow, next); - return flow; - } - if (!ret) { flow->filter = filter; flow->vnic = vnic; if (update_flow) { ret = -EXDEV; goto free_flow; } - PMD_DRV_LOG(ERR, "Successfully created flow.\n"); + + STAILQ_INSERT_TAIL(&vnic->filter, filter, next); + PMD_DRV_LOG(DEBUG, "Successfully created flow.\n"); STAILQ_INSERT_TAIL(&vnic->flow_list, flow, next); + if (filter->valid_flags & BNXT_FLOW_MARK_FLAG) { + PMD_DRV_LOG(DEBUG, + "Mark action: mark id 0x%x, flow id 0x%x\n", + filter->mark, filter->flow_id); + + /* TCAM and EM should be 16-bit only. + * Other modes not supported. + */ + bp->mark_table[filter->flow_id & BNXT_FLOW_ID_MASK] = + filter->mark; + } + bnxt_release_flow_lock(bp); return flow; } + free_filter: bnxt_free_filter(bp, filter); free_flow: @@ -1683,12 +1815,13 @@ free_flow: rte_flow_error_set(error, 0, RTE_FLOW_ERROR_TYPE_NONE, NULL, "Flow with pattern exists, updating destination queue"); - else + else if (!rte_errno) rte_flow_error_set(error, -ret, RTE_FLOW_ERROR_TYPE_HANDLE, NULL, "Failed to create flow."); rte_free(flow); flow = NULL; + bnxt_release_flow_lock(bp); return flow; } @@ -1734,25 +1867,20 @@ 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 = flow->filter; - struct bnxt_vnic_info *vnic = flow->vnic; + struct bnxt_filter_info *filter; + struct bnxt_vnic_info *vnic; int ret = 0; - if (!filter) { - ret = -EINVAL; - goto done; - } + filter = flow->filter; + vnic = flow->vnic; if (filter->filter_type == HWRM_CFA_TUNNEL_REDIRECT_FILTER && filter->enables == filter->tunnel_type) { - ret = bnxt_handle_tunnel_redirect_destroy(bp, - filter, - error); + ret = bnxt_handle_tunnel_redirect_destroy(bp, filter, error); if (!ret) goto done; else @@ -1763,6 +1891,11 @@ bnxt_flow_destroy(struct rte_eth_dev *dev, if (ret == 0) PMD_DRV_LOG(ERR, "Could not find matching flow\n"); + if (filter->valid_flags & BNXT_FLOW_MARK_FLAG) { + bp->mark_table[filter->flow_id & BNXT_FLOW_ID_MASK] = 0; + filter->flow_id = 0; + } + if (filter->filter_type == HWRM_CFA_EM_FILTER) ret = bnxt_hwrm_clear_em_filter(bp, filter); if (filter->filter_type == HWRM_CFA_NTUPLE_FILTER) @@ -1771,6 +1904,15 @@ bnxt_flow_destroy(struct rte_eth_dev *dev, done: if (!ret) { + /* If it is a L2 drop filter, when the filter is created, + * the FW updates the BC/MC records. + * Once this filter is removed, issue the set_rx_mask command + * to reset the BC/MC records in the HW to the settings + * before the drop counter is created. + */ + if (filter->valid_flags & BNXT_FLOW_L2_DROP_FLAG) + bnxt_set_rx_mask_no_vlan(bp, &bp->vnic_info[0]); + STAILQ_REMOVE(&vnic->filter, filter, bnxt_filter_info, next); bnxt_free_filter(bp, filter); STAILQ_REMOVE(&vnic->flow_list, flow, rte_flow, next); @@ -1779,14 +1921,14 @@ done: /* If this was the last flow associated with this vnic, * switch the queue back to RSS pool. */ - if (vnic && STAILQ_EMPTY(&vnic->flow_list)) { + if (vnic && !vnic->func_default && + 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; - bp->nr_vnics--; } } else { rte_flow_error_set(error, -ret, @@ -1797,6 +1939,36 @@ done: 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; +} + static int bnxt_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error) { @@ -1806,50 +1978,24 @@ bnxt_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error) unsigned int i; int ret = 0; + bnxt_acquire_flow_lock(bp); for (i = 0; i < bp->max_vnics; i++) { vnic = &bp->vnic_info[i]; - if (vnic->fw_vnic_id == INVALID_VNIC_ID) + if (vnic && vnic->fw_vnic_id == INVALID_VNIC_ID) continue; - STAILQ_FOREACH(flow, &vnic->flow_list, next) { - struct bnxt_filter_info *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 - return ret; - } + while (!STAILQ_EMPTY(&vnic->flow_list)) { + flow = STAILQ_FIRST(&vnic->flow_list); - 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 (!flow->filter) + continue; - if (ret) { - rte_flow_error_set - (error, - -ret, - RTE_FLOW_ERROR_TYPE_HANDLE, - NULL, - "Failed to flush flow in HW."); - return -rte_errno; - } -done: - bnxt_free_filter(bp, filter); - STAILQ_REMOVE(&vnic->flow_list, flow, - rte_flow, next); - rte_free(flow); + ret = _bnxt_flow_destroy(bp, flow, error); + if (ret) + break; } } + bnxt_release_flow_lock(bp); return ret; }