From: Michael Baum Date: Thu, 29 Apr 2021 09:55:38 +0000 (+0300) Subject: net/mlx5: support flow count action handle X-Git-Url: http://git.droids-corp.org/?a=commitdiff_plain;h=f3191849f2c2fe15c3f2ca77adf31a42d932a442;p=dpdk.git net/mlx5: support flow count action handle Existing API supports counter action to count traffic of a single flow. The user can share the count action among different flows using the shared flag and the same counter ID in the count action configuration. Recent patch [1] introduced the indirect action API. Using this API, an action can be created as indirect, unattached to any flow rule. Multiple flows can then be created using the same indirect action. The new API also supports query operation of an indirect action. The new API is more efficient because the driver gets it's own handler for the count action instead of managing a mapping between the user ID to the driver handle. Support create, query and destroy indirect action operations for flow count action. Application will use the indirect action query operation to query this count action. In the meantime the old sharing mechanism (with the sharing flag) continues to be supported, and the user can choose the way he wants to share the counter. The new indirect action API is only supported in DevX, so sharing counter action in Verbs can only be done through the old mechanism. [1] https://mails.dpdk.org/archives/dev/2020-July/174110.html Signed-off-by: Michael Baum Acked-by: Matan Azrad --- diff --git a/doc/guides/nics/mlx5.rst b/doc/guides/nics/mlx5.rst index 2bb4f18a08..b2c357e016 100644 --- a/doc/guides/nics/mlx5.rst +++ b/doc/guides/nics/mlx5.rst @@ -1692,10 +1692,15 @@ Supported hardware offloads | | | | | rdma-core 33 | | | | | | ConnectX-5 | +-----------------------+-----------------+-----------------+ - | Age | | DPDK 20.11 | | DPDK 20.11 | - | | | OFED 5.2 | | OFED 5.2 | - | | | rdma-core 32 | | rdma-core 32 | - | | | ConnectX-6 Dx| | ConnectX-6 Dx | + | Age | | DPDK 20.11 | | DPDK 20.11 | + | | | OFED 5.2 | | OFED 5.2 | + | | | rdma-core 32 | | rdma-core 32 | + | | | ConnectX-6 Dx | | ConnectX-6 Dx | + +-----------------------+-----------------+-----------------+ + | Count | | DPDK 21.05 | | DPDK 21.05 | + | | | OFED 4.6 | | OFED 4.6 | + | | | rdma-core 24 | | rdma-core 23 | + | | | ConnectX-5 | | ConnectX-5 | +-----------------------+-----------------+-----------------+ Notes for metadata diff --git a/doc/guides/rel_notes/release_21_05.rst b/doc/guides/rel_notes/release_21_05.rst index 98f926c426..7ee8f661c2 100644 --- a/doc/guides/rel_notes/release_21_05.rst +++ b/doc/guides/rel_notes/release_21_05.rst @@ -163,6 +163,7 @@ New Features Updated the Mellanox mlx5 driver with new features and improvements, including: * Added support for VXLAN and NVGRE encap as sample actions. + * Added support for flow COUNT action handle. * Support push VLAN on ingress traffic and pop VLAN on egress traffic in E-Switch mode. * Added support for pre-defined meter policy API. * Added support for ASO (Advanced Steering Operation) meter. diff --git a/drivers/net/mlx5/mlx5.h b/drivers/net/mlx5/mlx5.h index d4aec717f0..efb80a4a49 100644 --- a/drivers/net/mlx5/mlx5.h +++ b/drivers/net/mlx5/mlx5.h @@ -291,7 +291,7 @@ struct mlx5_drop { #define MLX5_MAX_PENDING_QUERIES 4 #define MLX5_CNT_CONTAINER_RESIZE 64 #define MLX5_CNT_SHARED_OFFSET 0x80000000 -#define IS_SHARED_CNT(cnt) (!!((cnt) & MLX5_CNT_SHARED_OFFSET)) +#define IS_LEGACY_SHARED_CNT(cnt) (!!((cnt) & MLX5_CNT_SHARED_OFFSET)) #define IS_BATCH_CNT(cnt) (((cnt) & (MLX5_CNT_SHARED_OFFSET - 1)) >= \ MLX5_CNT_BATCH_OFFSET) #define MLX5_CNT_SIZE (sizeof(struct mlx5_flow_counter)) @@ -353,7 +353,10 @@ struct flow_counter_stats { /* Shared counters information for counters. */ struct mlx5_flow_counter_shared { - uint32_t id; /**< User counter ID. */ + union { + uint32_t refcnt; /* Only for shared action management. */ + uint32_t id; /* User counter ID for legacy sharing. */ + }; }; /* Shared counter configuration. */ diff --git a/drivers/net/mlx5/mlx5_defs.h b/drivers/net/mlx5/mlx5_defs.h index 6e9c4b9cdd..906aa43c5a 100644 --- a/drivers/net/mlx5/mlx5_defs.h +++ b/drivers/net/mlx5/mlx5_defs.h @@ -193,7 +193,7 @@ #define MLX5_HAIRPIN_JUMBO_LOG_SIZE (14 + 2) /* Maximum number of indirect actions supported by rte_flow */ -#define MLX5_MAX_INDIRECT_ACTIONS 2 +#define MLX5_MAX_INDIRECT_ACTIONS 3 /* * Linux definition of static_assert is found in /usr/include/assert.h. diff --git a/drivers/net/mlx5/mlx5_flow.c b/drivers/net/mlx5/mlx5_flow.c index 15ed5ec7a2..1923abe411 100644 --- a/drivers/net/mlx5/mlx5_flow.c +++ b/drivers/net/mlx5/mlx5_flow.c @@ -3540,6 +3540,12 @@ flow_action_handles_translate(struct rte_eth_dev *dev, translated[handle->index].conf = &shared_rss->origin; break; + case MLX5_INDIRECT_ACTION_TYPE_COUNT: + translated[handle->index].type = + (enum rte_flow_action_type) + MLX5_RTE_FLOW_ACTION_TYPE_COUNT; + translated[handle->index].conf = (void *)(uintptr_t)idx; + break; case MLX5_INDIRECT_ACTION_TYPE_AGE: if (priv->sh->flow_hit_aso_en) { translated[handle->index].type = diff --git a/drivers/net/mlx5/mlx5_flow.h b/drivers/net/mlx5/mlx5_flow.h index 56908ae08b..432fd25dd6 100644 --- a/drivers/net/mlx5/mlx5_flow.h +++ b/drivers/net/mlx5/mlx5_flow.h @@ -36,8 +36,8 @@ enum mlx5_rte_flow_action_type { MLX5_RTE_FLOW_ACTION_TYPE_DEFAULT_MISS, MLX5_RTE_FLOW_ACTION_TYPE_TUNNEL_SET, MLX5_RTE_FLOW_ACTION_TYPE_AGE, - MLX5_RTE_FLOW_ACTION_TYPE_JUMP, MLX5_RTE_FLOW_ACTION_TYPE_COUNT, + MLX5_RTE_FLOW_ACTION_TYPE_JUMP, }; #define MLX5_INDIRECT_ACTION_TYPE_OFFSET 30 @@ -45,6 +45,7 @@ enum mlx5_rte_flow_action_type { enum { MLX5_INDIRECT_ACTION_TYPE_RSS, MLX5_INDIRECT_ACTION_TYPE_AGE, + MLX5_INDIRECT_ACTION_TYPE_COUNT, }; /* Matches on selected register. */ diff --git a/drivers/net/mlx5/mlx5_flow_dv.c b/drivers/net/mlx5/mlx5_flow_dv.c index d810466242..b74bac1083 100644 --- a/drivers/net/mlx5/mlx5_flow_dv.c +++ b/drivers/net/mlx5/mlx5_flow_dv.c @@ -3146,13 +3146,33 @@ flow_dv_validate_action_set_tag(struct rte_eth_dev *dev, return 0; } +/** + * Check if action counter is shared by either old or new mechanism. + * + * @param[in] action + * Pointer to the action structure. + * + * @return + * True when counter is shared, false otherwise. + */ +static inline bool +is_shared_action_count(const struct rte_flow_action *action) +{ + const struct rte_flow_action_count *count = + (const struct rte_flow_action_count *)action->conf; + + if ((int)action->type == MLX5_RTE_FLOW_ACTION_TYPE_COUNT) + return true; + return !!(count && count->shared); +} + /** * Validate count action. * * @param[in] dev * Pointer to rte_eth_dev structure. - * @param[in] action - * Pointer to the action structure. + * @param[in] shared + * Indicator if action is shared. * @param[in] action_flags * Holds the actions detected until now. * @param[out] error @@ -3162,13 +3182,11 @@ flow_dv_validate_action_set_tag(struct rte_eth_dev *dev, * 0 on success, a negative errno value otherwise and rte_errno is set. */ static int -flow_dv_validate_action_count(struct rte_eth_dev *dev, - const struct rte_flow_action *action, +flow_dv_validate_action_count(struct rte_eth_dev *dev, bool shared, uint64_t action_flags, struct rte_flow_error *error) { struct mlx5_priv *priv = dev->data->dev_private; - const struct rte_flow_action_count *count; if (!priv->config.devx) goto notsup_err; @@ -3176,8 +3194,7 @@ flow_dv_validate_action_count(struct rte_eth_dev *dev, return rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION, NULL, "duplicate count actions set"); - count = (const struct rte_flow_action_count *)action->conf; - if (count && count->shared && (action_flags & MLX5_FLOW_ACTION_AGE) && + if (shared && (action_flags & MLX5_FLOW_ACTION_AGE) && !priv->sh->flow_hit_aso_en) return rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION, NULL, @@ -5254,7 +5271,7 @@ flow_dv_validate_action_sample(uint64_t *action_flags, break; case RTE_FLOW_ACTION_TYPE_COUNT: ret = flow_dv_validate_action_count - (dev, act, + (dev, is_shared_action_count(act), *action_flags | sub_action_flags, error); if (ret < 0) @@ -5424,7 +5441,7 @@ flow_dv_modify_hdr_resource_register * @param[in] idx * mlx5 flow counter index in the container. * @param[out] ppool - * mlx5 flow counter pool in the container, + * mlx5 flow counter pool in the container. * * @return * Pointer to the counter, NULL otherwise. @@ -5554,7 +5571,7 @@ flow_dv_container_resize(struct rte_eth_dev *dev) * * @param[in] dev * Pointer to the Ethernet device structure. - * @param[in] cnt + * @param[in] counter * Index to the flow counter. * @param[out] pkts * The statistics value of packets. @@ -5795,6 +5812,13 @@ flow_dv_counter_alloc(struct rte_eth_dev *dev, uint32_t age) if (!fallback && !priv->sh->cmng.query_thread_on) /* Start the asynchronous batch query by the host thread. */ mlx5_set_query_alarm(priv->sh); + /* + * When the count action isn't shared (by ID), shared_info field is + * used for indirect action API's refcnt. + * When the counter action is not shared neither by ID nor by indirect + * action API, shared info must be 1. + */ + cnt_free->shared_info.refcnt = 1; return cnt_idx; err: if (cnt_free) { @@ -5941,9 +5965,26 @@ flow_dv_counter_free(struct rte_eth_dev *dev, uint32_t counter) return; cnt = flow_dv_counter_get_by_idx(dev, counter, &pool); MLX5_ASSERT(pool); - if (IS_SHARED_CNT(counter) && + /* + * If the counter action is shared by ID, the l3t_clear_entry function + * reduces its references counter. If after the reduction the action is + * still referenced, the function returns here and does not release it. + */ + if (IS_LEGACY_SHARED_CNT(counter) && mlx5_l3t_clear_entry(priv->sh->cnt_id_tbl, cnt->shared_info.id)) return; + /* + * If the counter action is shared by indirect action API, the atomic + * function reduces its references counter. If after the reduction the + * action is still referenced, the function returns here and does not + * release it. + * When the counter action is not shared neither by ID nor by indirect + * action API, shared info is 1 before the reduction, so this condition + * is failed and function doesn't return here. + */ + if (!IS_LEGACY_SHARED_CNT(counter) && + __atomic_sub_fetch(&cnt->shared_info.refcnt, 1, __ATOMIC_RELAXED)) + return; if (pool->is_aged) flow_dv_counter_remove_from_age(dev, counter, cnt); cnt->pool = pool; @@ -5955,7 +5996,6 @@ flow_dv_counter_free(struct rte_eth_dev *dev, uint32_t counter) * container counter list. The list changes while query starts. In * this case, lock will not be needed as query callback and release * function both operate with the different list. - * */ if (!priv->sh->cmng.counter_fallback) { rte_spinlock_lock(&pool->csl); @@ -6274,7 +6314,6 @@ flow_dv_validate(struct rte_eth_dev *dev, const struct rte_flow_attr *attr, const struct rte_flow_action_raw_encap *encap; const struct rte_flow_action_rss *rss = NULL; const struct rte_flow_action_rss *sample_rss = NULL; - const struct rte_flow_action_count *count = NULL; const struct rte_flow_action_count *sample_count = NULL; const struct rte_flow_item_tcp nic_tcp_mask = { .hdr = { @@ -6653,6 +6692,7 @@ flow_dv_validate(struct rte_eth_dev *dev, const struct rte_flow_attr *attr, } for (; actions->type != RTE_FLOW_ACTION_TYPE_END; actions++) { int type = actions->type; + bool shared_count = false; if (!mlx5_flow_os_action_supported(type)) return rte_flow_error_set(error, ENOTSUP, @@ -6802,13 +6842,14 @@ flow_dv_validate(struct rte_eth_dev *dev, const struct rte_flow_attr *attr, action_flags |= MLX5_FLOW_ACTION_DEFAULT_MISS; ++actions_n; break; + case MLX5_RTE_FLOW_ACTION_TYPE_COUNT: case RTE_FLOW_ACTION_TYPE_COUNT: - ret = flow_dv_validate_action_count(dev, actions, + shared_count = is_shared_action_count(actions); + ret = flow_dv_validate_action_count(dev, shared_count, action_flags, error); if (ret < 0) return ret; - count = actions->conf; action_flags |= MLX5_FLOW_ACTION_COUNT; ++actions_n; break; @@ -7116,7 +7157,7 @@ flow_dv_validate(struct rte_eth_dev *dev, const struct rte_flow_attr *attr, * mutual exclusion with share counter actions. */ if (!priv->sh->flow_hit_aso_en) { - if (count && count->shared) + if (shared_count) return rte_flow_error_set (error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION, @@ -9932,6 +9973,8 @@ flow_dv_translate_action_port_id(struct rte_eth_dev *dev, * * @param[in] dev * Pointer to rte_eth_dev structure. + * @param[in] dev_flow + * Pointer to the mlx5_flow. * @param[out] count * Pointer to the counter action configuration. * @param[in] age @@ -9955,7 +9998,7 @@ flow_dv_translate_create_counter(struct rte_eth_dev *dev, counter = flow_dv_counter_alloc(dev, !!age); if (!counter || age == NULL) return counter; - age_param = flow_dv_counter_idx_get_age(dev, counter); + age_param = flow_dv_counter_idx_get_age(dev, counter); age_param->context = age->context ? age->context : (void *)(uintptr_t)(dev_flow->flow_idx); age_param->timeout = age->timeout; @@ -11266,12 +11309,12 @@ flow_dv_translate(struct rte_eth_dev *dev, const uint8_t *rss_key; struct mlx5_flow_tbl_resource *tbl; struct mlx5_aso_age_action *age_act; + struct mlx5_flow_counter *cnt_act; uint32_t port_id = 0; struct mlx5_flow_dv_port_id_action_resource port_id_resource; int action_type = actions->type; const struct rte_flow_action *found_action = NULL; uint32_t jump_group = 0; - struct mlx5_flow_counter *cnt; if (!mlx5_flow_os_action_supported(action_type)) return rte_flow_error_set(error, ENOTSUP, @@ -11412,6 +11455,15 @@ flow_dv_translate(struct rte_eth_dev *dev, dev_flow->dv.actions[actions_n++] = age_act->dr_action; action_flags |= MLX5_FLOW_ACTION_AGE; break; + case MLX5_RTE_FLOW_ACTION_TYPE_COUNT: + flow->counter = (uint32_t)(uintptr_t)(action->conf); + cnt_act = flow_dv_counter_get_by_idx(dev, flow->counter, + NULL); + __atomic_fetch_add(&cnt_act->shared_info.refcnt, 1, + __ATOMIC_RELAXED); + /* Save information first, will apply later. */ + action_flags |= MLX5_FLOW_ACTION_COUNT; + break; case RTE_FLOW_ACTION_TYPE_AGE: if (priv->sh->flow_hit_aso_en && attr->group) { /* @@ -11452,12 +11504,6 @@ flow_dv_translate(struct rte_eth_dev *dev, age = action->conf; action_flags |= MLX5_FLOW_ACTION_COUNT; break; - case MLX5_RTE_FLOW_ACTION_TYPE_COUNT: - cnt = flow_dv_counter_get_by_idx(dev, - (uint32_t)(uintptr_t)action->conf, NULL); - MLX5_ASSERT(cnt != NULL); - dev_flow->dv.actions[actions_n++] = cnt->action; - break; case RTE_FLOW_ACTION_TYPE_OF_POP_VLAN: dev_flow->dv.actions[actions_n++] = priv->sh->pop_vlan_action; @@ -13329,6 +13375,11 @@ flow_dv_action_create(struct rte_eth_dev *dev, (void *)(uintptr_t)idx; } break; + case RTE_FLOW_ACTION_TYPE_COUNT: + ret = flow_dv_translate_create_counter(dev, NULL, NULL, NULL); + idx = (MLX5_INDIRECT_ACTION_TYPE_COUNT << + MLX5_INDIRECT_ACTION_TYPE_OFFSET) | ret; + break; default: rte_flow_error_set(err, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, NULL, "action type not supported"); @@ -13362,11 +13413,25 @@ flow_dv_action_destroy(struct rte_eth_dev *dev, uint32_t act_idx = (uint32_t)(uintptr_t)handle; uint32_t type = act_idx >> MLX5_INDIRECT_ACTION_TYPE_OFFSET; uint32_t idx = act_idx & ((1u << MLX5_INDIRECT_ACTION_TYPE_OFFSET) - 1); + struct mlx5_flow_counter *cnt; + uint32_t no_flow_refcnt = 1; int ret; switch (type) { case MLX5_INDIRECT_ACTION_TYPE_RSS: return __flow_dv_action_rss_release(dev, idx, error); + case MLX5_INDIRECT_ACTION_TYPE_COUNT: + cnt = flow_dv_counter_get_by_idx(dev, idx, NULL); + if (!__atomic_compare_exchange_n(&cnt->shared_info.refcnt, + &no_flow_refcnt, 1, false, + __ATOMIC_ACQUIRE, + __ATOMIC_RELAXED)) + return rte_flow_error_set(error, EBUSY, + RTE_FLOW_ERROR_TYPE_ACTION, + NULL, + "Indirect count action has references"); + flow_dv_counter_free(dev, idx); + return 0; case MLX5_INDIRECT_ACTION_TYPE_AGE: ret = flow_dv_aso_age_release(dev, idx); if (ret) @@ -13494,37 +13559,6 @@ flow_dv_action_update(struct rte_eth_dev *dev, } } -static int -flow_dv_action_query(struct rte_eth_dev *dev, - const struct rte_flow_action_handle *handle, void *data, - struct rte_flow_error *error) -{ - struct mlx5_age_param *age_param; - struct rte_flow_query_age *resp; - uint32_t act_idx = (uint32_t)(uintptr_t)handle; - uint32_t type = act_idx >> MLX5_INDIRECT_ACTION_TYPE_OFFSET; - uint32_t idx = act_idx & ((1u << MLX5_INDIRECT_ACTION_TYPE_OFFSET) - 1); - - switch (type) { - case MLX5_INDIRECT_ACTION_TYPE_AGE: - age_param = &flow_aso_age_get_by_idx(dev, idx)->age_params; - resp = data; - resp->aged = __atomic_load_n(&age_param->state, - __ATOMIC_RELAXED) == AGE_TMOUT ? - 1 : 0; - resp->sec_since_last_hit_valid = !resp->aged; - if (resp->sec_since_last_hit_valid) - resp->sec_since_last_hit = __atomic_load_n - (&age_param->sec_since_last_hit, __ATOMIC_RELAXED); - return 0; - default: - return rte_flow_error_set(error, ENOTSUP, - RTE_FLOW_ERROR_TYPE_ACTION, - NULL, - "action type query not supported"); - } -} - /** * Destroy the meter sub policy table rules. * Lock free, (mutex should be acquired by caller). @@ -14076,14 +14110,14 @@ flow_dv_create_mtr_policy_acts(struct rte_eth_dev *dev, } /** - * Query a dv flow rule for its statistics via devx. + * Query a DV flow rule for its statistics via DevX. * * @param[in] dev * Pointer to Ethernet device. - * @param[in] flow - * Pointer to the sub flow. + * @param[in] cnt_idx + * Index to the flow counter. * @param[out] data - * data retrieved by the query. + * Data retrieved by the query. * @param[out] error * Perform verbose error reporting if not NULL. * @@ -14091,8 +14125,8 @@ flow_dv_create_mtr_policy_acts(struct rte_eth_dev *dev, * 0 on success, a negative errno value otherwise and rte_errno is set. */ static int -flow_dv_query_count(struct rte_eth_dev *dev, struct rte_flow *flow, - void *data, struct rte_flow_error *error) +flow_dv_query_count(struct rte_eth_dev *dev, uint32_t cnt_idx, void *data, + struct rte_flow_error *error) { struct mlx5_priv *priv = dev->data->dev_private; struct rte_flow_query_count *qc = data; @@ -14102,19 +14136,16 @@ flow_dv_query_count(struct rte_eth_dev *dev, struct rte_flow *flow, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, "counters are not supported"); - if (flow->counter) { + if (cnt_idx) { uint64_t pkts, bytes; struct mlx5_flow_counter *cnt; - - cnt = flow_dv_counter_get_by_idx(dev, flow->counter, - NULL); - int err = _flow_dv_query_count(dev, flow->counter, &pkts, - &bytes); + int err = _flow_dv_query_count(dev, cnt_idx, &pkts, &bytes); if (err) return rte_flow_error_set(error, -err, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, "cannot read counters"); + cnt = flow_dv_counter_get_by_idx(dev, cnt_idx, NULL); qc->hits_set = 1; qc->bytes_set = 1; qc->hits = pkts - cnt->hits; @@ -14131,6 +14162,38 @@ flow_dv_query_count(struct rte_eth_dev *dev, struct rte_flow *flow, "counters are not available"); } +static int +flow_dv_action_query(struct rte_eth_dev *dev, + const struct rte_flow_action_handle *handle, void *data, + struct rte_flow_error *error) +{ + struct mlx5_age_param *age_param; + struct rte_flow_query_age *resp; + uint32_t act_idx = (uint32_t)(uintptr_t)handle; + uint32_t type = act_idx >> MLX5_INDIRECT_ACTION_TYPE_OFFSET; + uint32_t idx = act_idx & ((1u << MLX5_INDIRECT_ACTION_TYPE_OFFSET) - 1); + + switch (type) { + case MLX5_INDIRECT_ACTION_TYPE_AGE: + age_param = &flow_aso_age_get_by_idx(dev, idx)->age_params; + resp = data; + resp->aged = __atomic_load_n(&age_param->state, + __ATOMIC_RELAXED) == AGE_TMOUT ? + 1 : 0; + resp->sec_since_last_hit_valid = !resp->aged; + if (resp->sec_since_last_hit_valid) + resp->sec_since_last_hit = __atomic_load_n + (&age_param->sec_since_last_hit, __ATOMIC_RELAXED); + return 0; + case MLX5_INDIRECT_ACTION_TYPE_COUNT: + return flow_dv_query_count(dev, idx, data, error); + default: + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ACTION, NULL, + "action type query not supported"); + } +} + /** * Query a flow rule AGE action for aging information. * @@ -14200,7 +14263,8 @@ flow_dv_query(struct rte_eth_dev *dev, case RTE_FLOW_ACTION_TYPE_VOID: break; case RTE_FLOW_ACTION_TYPE_COUNT: - ret = flow_dv_query_count(dev, flow, data, error); + ret = flow_dv_query_count(dev, flow->counter, data, + error); break; case RTE_FLOW_ACTION_TYPE_AGE: ret = flow_dv_query_age(dev, flow, data, error); @@ -15241,7 +15305,7 @@ flow_dv_counter_allocate(struct rte_eth_dev *dev) * @param[in] dev * Pointer to the Ethernet device structure. * @param[in] conf - * Shared action configuration. + * Indirect action configuration. * @param[in] action * The indirect action object to validate. * @param[out] error @@ -15268,22 +15332,36 @@ flow_dv_action_validate(struct rte_eth_dev *dev, * sufficient, it is set to devx_obj_ops. * Otherwise, it is set to ibv_obj_ops. * ibv_obj_ops doesn't support ind_table_modify operation. - * In this case the shared RSS action can't be used. + * In this case the indirect RSS action can't be used. */ if (priv->obj_ops.ind_table_modify == NULL) return rte_flow_error_set (err, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, NULL, - "shared RSS action not supported"); + "Indirect RSS action not supported"); return mlx5_validate_action_rss(dev, action, err); case RTE_FLOW_ACTION_TYPE_AGE: if (!priv->sh->aso_age_mng) return rte_flow_error_set(err, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, - "shared age action not supported"); + "Indirect age action not supported"); return flow_dv_validate_action_age(0, action, dev, err); + case RTE_FLOW_ACTION_TYPE_COUNT: + /* + * There are two mechanisms to share the action count. + * The old mechanism uses the shared field to share, while the + * new mechanism uses the indirect action API. + * This validation comes to make sure that the two mechanisms + * are not combined. + */ + if (is_shared_action_count(action)) + return rte_flow_error_set(err, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ACTION, + NULL, + "Mix shared and indirect counter is not supported"); + return flow_dv_validate_action_count(dev, true, 0, err); default: return rte_flow_error_set(err, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, diff --git a/drivers/net/mlx5/mlx5_flow_verbs.c b/drivers/net/mlx5/mlx5_flow_verbs.c index 0fdafbba4e..fe9673310a 100644 --- a/drivers/net/mlx5/mlx5_flow_verbs.c +++ b/drivers/net/mlx5/mlx5_flow_verbs.c @@ -357,7 +357,7 @@ flow_verbs_counter_release(struct rte_eth_dev *dev, uint32_t counter) struct mlx5_flow_counter *cnt; cnt = flow_verbs_counter_get_by_idx(dev, counter, &pool); - if (IS_SHARED_CNT(counter) && + if (IS_LEGACY_SHARED_CNT(counter) && mlx5_l3t_clear_entry(priv->sh->cnt_id_tbl, cnt->shared_info.id)) return; #if defined(HAVE_IBV_DEVICE_COUNTERS_SET_V42)