#include "mlx5_common_os.h"
#include "rte_pmd_mlx5.h"
+struct tunnel_default_miss_ctx {
+ uint16_t *queue;
+ __extension__
+ union {
+ struct rte_flow_action_rss action_rss;
+ struct rte_flow_action_queue miss_queue;
+ struct rte_flow_action_jump miss_jump;
+ uint8_t raw[0];
+ };
+};
+
+static int
+flow_tunnel_add_default_miss(struct rte_eth_dev *dev,
+ struct rte_flow *flow,
+ const struct rte_flow_attr *attr,
+ const struct rte_flow_action *app_actions,
+ uint32_t flow_idx,
+ struct tunnel_default_miss_ctx *ctx,
+ struct rte_flow_error *error);
static struct mlx5_flow_tunnel *
mlx5_find_tunnel_id(struct rte_eth_dev *dev, uint32_t id);
static void
mlx5_flow_tunnel_free(struct rte_eth_dev *dev, struct mlx5_flow_tunnel *tunnel);
-static const struct mlx5_flow_tbl_data_entry *
-tunnel_mark_decode(struct rte_eth_dev *dev, uint32_t mark);
-static int
-mlx5_get_flow_tunnel(struct rte_eth_dev *dev,
- const struct rte_flow_tunnel *app_tunnel,
- struct mlx5_flow_tunnel **tunnel);
+static uint32_t
+tunnel_flow_group_to_flow_table(struct rte_eth_dev *dev,
+ const struct mlx5_flow_tunnel *tunnel,
+ uint32_t group, uint32_t *table,
+ struct rte_flow_error *error);
+
+static struct mlx5_flow_workspace *mlx5_flow_push_thread_workspace(void);
+static void mlx5_flow_pop_thread_workspace(void);
/** Device flow drivers. */
user_pattern_size);
addr = (void *)(((uintptr_t)addr) + user_pattern_size);
rte_memcpy(addr, flow_items, elt * sizeof(*item));
- addr = (void *)(((uintptr_t)addr) +
- elt * sizeof(*item));
}
}
return lsize;
const struct rte_flow_shared_action *action,
void *data,
struct rte_flow_error *error);
-static inline bool
-mlx5_flow_tunnel_validate(struct rte_eth_dev *dev,
- struct rte_flow_tunnel *tunnel,
- const char *err_msg)
-{
- err_msg = NULL;
- if (!is_tunnel_offload_active(dev)) {
- err_msg = "tunnel offload was not activated";
- goto out;
- } else if (!tunnel) {
- err_msg = "no application tunnel";
- goto out;
- }
-
- switch (tunnel->type) {
- default:
- err_msg = "unsupported tunnel type";
- goto out;
- case RTE_FLOW_ITEM_TYPE_VXLAN:
- break;
- }
-
-out:
- return !err_msg;
-}
-
-
static int
mlx5_flow_tunnel_decap_set(struct rte_eth_dev *dev,
struct rte_flow_tunnel *app_tunnel,
struct rte_flow_action **actions,
uint32_t *num_of_actions,
- struct rte_flow_error *error)
-{
- int ret;
- struct mlx5_flow_tunnel *tunnel;
- const char *err_msg = NULL;
- bool verdict = mlx5_flow_tunnel_validate(dev, app_tunnel, err_msg);
-
- if (!verdict)
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ACTION_CONF, NULL,
- err_msg);
- ret = mlx5_get_flow_tunnel(dev, app_tunnel, &tunnel);
- if (ret < 0) {
- return rte_flow_error_set(error, ret,
- RTE_FLOW_ERROR_TYPE_ACTION_CONF, NULL,
- "failed to initialize pmd tunnel");
- }
- *actions = &tunnel->action;
- *num_of_actions = 1;
- return 0;
-}
-
+ struct rte_flow_error *error);
static int
mlx5_flow_tunnel_match(struct rte_eth_dev *dev,
struct rte_flow_tunnel *app_tunnel,
struct rte_flow_item **items,
uint32_t *num_of_items,
- struct rte_flow_error *error)
-{
- int ret;
- struct mlx5_flow_tunnel *tunnel;
- const char *err_msg = NULL;
- bool verdict = mlx5_flow_tunnel_validate(dev, app_tunnel, err_msg);
-
- if (!verdict)
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
- err_msg);
- ret = mlx5_get_flow_tunnel(dev, app_tunnel, &tunnel);
- if (ret < 0) {
- return rte_flow_error_set(error, ret,
- RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
- "failed to initialize pmd tunnel");
- }
- *items = &tunnel->item;
- *num_of_items = 1;
- return 0;
-}
-
+ struct rte_flow_error *error);
static int
-mlx5_flow_item_release(struct rte_eth_dev *dev,
- struct rte_flow_item *pmd_items,
- uint32_t num_items, struct rte_flow_error *err)
-{
- struct mlx5_flow_tunnel_hub *thub = mlx5_tunnel_hub(dev);
- struct mlx5_flow_tunnel *tun;
-
- LIST_FOREACH(tun, &thub->tunnels, chain) {
- if (&tun->item == pmd_items)
- break;
- }
- if (!tun || num_items != 1)
- return rte_flow_error_set(err, EINVAL,
- RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
- "invalid argument");
- if (!__atomic_sub_fetch(&tun->refctn, 1, __ATOMIC_RELAXED))
- mlx5_flow_tunnel_free(dev, tun);
- return 0;
-}
-
+mlx5_flow_tunnel_item_release(struct rte_eth_dev *dev,
+ struct rte_flow_item *pmd_items,
+ uint32_t num_items, struct rte_flow_error *err);
static int
-mlx5_flow_action_release(struct rte_eth_dev *dev,
- struct rte_flow_action *pmd_actions,
- uint32_t num_actions, struct rte_flow_error *err)
-{
- struct mlx5_flow_tunnel_hub *thub = mlx5_tunnel_hub(dev);
- struct mlx5_flow_tunnel *tun;
-
- LIST_FOREACH(tun, &thub->tunnels, chain) {
- if (&tun->action == pmd_actions)
- break;
- }
- if (!tun || num_actions != 1)
- return rte_flow_error_set(err, EINVAL,
- RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
- "invalid argument");
- if (!__atomic_sub_fetch(&tun->refctn, 1, __ATOMIC_RELAXED))
- mlx5_flow_tunnel_free(dev, tun);
-
- return 0;
-}
-
+mlx5_flow_tunnel_action_release(struct rte_eth_dev *dev,
+ struct rte_flow_action *pmd_actions,
+ uint32_t num_actions,
+ struct rte_flow_error *err);
static int
mlx5_flow_tunnel_get_restore_info(struct rte_eth_dev *dev,
struct rte_mbuf *m,
struct rte_flow_restore_info *info,
- struct rte_flow_error *err)
-{
- uint64_t ol_flags = m->ol_flags;
- const struct mlx5_flow_tbl_data_entry *tble;
- const uint64_t mask = PKT_RX_FDIR | PKT_RX_FDIR_ID;
-
- if ((ol_flags & mask) != mask)
- goto err;
- tble = tunnel_mark_decode(dev, m->hash.fdir.hi);
- if (!tble) {
- DRV_LOG(DEBUG, "port %u invalid miss tunnel mark %#x",
- dev->data->port_id, m->hash.fdir.hi);
- goto err;
- }
- MLX5_ASSERT(tble->tunnel);
- memcpy(&info->tunnel, &tble->tunnel->app_tunnel, sizeof(info->tunnel));
- info->group_id = tble->group_id;
- info->flags = RTE_FLOW_RESTORE_INFO_TUNNEL |
- RTE_FLOW_RESTORE_INFO_GROUP_ID |
- RTE_FLOW_RESTORE_INFO_ENCAPSULATED;
-
- return 0;
-
-err:
- return rte_flow_error_set(err, EINVAL,
- RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
- "failed to get restore info");
-}
+ struct rte_flow_error *err);
static const struct rte_flow_ops mlx5_flow_ops = {
.validate = mlx5_flow_validate,
.shared_action_query = mlx5_shared_action_query,
.tunnel_decap_set = mlx5_flow_tunnel_decap_set,
.tunnel_match = mlx5_flow_tunnel_match,
- .tunnel_action_decap_release = mlx5_flow_action_release,
- .tunnel_item_release = mlx5_flow_item_release,
+ .tunnel_action_decap_release = mlx5_flow_tunnel_action_release,
+ .tunnel_item_release = mlx5_flow_tunnel_item_release,
.get_restore_info = mlx5_flow_tunnel_get_restore_info,
};
-/* Convert FDIR request to Generic flow. */
-struct mlx5_fdir {
- struct rte_flow_attr attr;
- struct rte_flow_item items[4];
- struct rte_flow_item_eth l2;
- struct rte_flow_item_eth l2_mask;
- union {
- struct rte_flow_item_ipv4 ipv4;
- struct rte_flow_item_ipv6 ipv6;
- } l3;
- union {
- struct rte_flow_item_ipv4 ipv4;
- struct rte_flow_item_ipv6 ipv6;
- } l3_mask;
- union {
- struct rte_flow_item_udp udp;
- struct rte_flow_item_tcp tcp;
- } l4;
- union {
- struct rte_flow_item_udp udp;
- struct rte_flow_item_tcp tcp;
- } l4_mask;
- struct rte_flow_action actions[2];
- struct rte_flow_action_queue queue;
-};
-
/* Tunnel information. */
struct mlx5_flow_tunnel_info {
uint64_t tunnel; /**< Tunnel bit (see MLX5_FLOW_*). */
return priv->mtr_color_reg != REG_C_2 ? REG_C_2 :
REG_C_3;
case MLX5_MTR_COLOR:
+ case MLX5_ASO_FLOW_HIT: /* Both features use the same REG_C. */
MLX5_ASSERT(priv->mtr_color_reg != REG_NON);
return priv->mtr_color_reg;
case MLX5_COPY_MARK:
{
struct mlx5_priv *priv = dev->data->dev_private;
const struct rte_flow_action_rss *rss = action->conf;
+ enum mlx5_rxq_type rxq_type = MLX5_RXQ_TYPE_UNDEFINED;
unsigned int i;
if (rss->func != RTE_ETH_HASH_FUNCTION_DEFAULT &&
RTE_FLOW_ERROR_TYPE_ACTION_CONF,
NULL, "No queues configured");
for (i = 0; i != rss->queue_num; ++i) {
+ struct mlx5_rxq_ctrl *rxq_ctrl;
+
if (rss->queue[i] >= priv->rxqs_n)
return rte_flow_error_set
(error, EINVAL,
return rte_flow_error_set
(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION_CONF,
&rss->queue[i], "queue is not configured");
+ rxq_ctrl = container_of((*priv->rxqs)[rss->queue[i]],
+ struct mlx5_rxq_ctrl, rxq);
+ if (i == 0)
+ rxq_type = rxq_ctrl->type;
+ if (rxq_type != rxq_ctrl->type)
+ return rte_flow_error_set
+ (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION_CONF,
+ &rss->queue[i],
+ "combining hairpin and regular RSS queues is not supported");
}
return 0;
}
/* MPLS over IP, UDP, GRE is allowed */
if (!(prev_layer & (MLX5_FLOW_LAYER_OUTER_L3 |
MLX5_FLOW_LAYER_OUTER_L4_UDP |
- MLX5_FLOW_LAYER_GRE)))
+ MLX5_FLOW_LAYER_GRE |
+ MLX5_FLOW_LAYER_GRE_KEY)))
return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM, item,
"protocol filtering not compatible"
MLX5_FLOW_LAYER_OUTER_VLAN);
struct rte_flow_item_ecpri mask_lo;
+ if (!(last_item & outer_l2_vlan) &&
+ last_item != MLX5_FLOW_LAYER_OUTER_L4_UDP)
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "eCPRI can only follow L2/VLAN layer or UDP layer");
if ((last_item & outer_l2_vlan) && ether_type &&
ether_type != RTE_ETHER_TYPE_ECPRI)
return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM, item,
- "eCPRI cannot follow L2/VLAN layer "
- "which ether type is not 0xAEFE.");
+ "eCPRI cannot follow L2/VLAN layer which ether type is not 0xAEFE");
if (item_flags & MLX5_FLOW_LAYER_TUNNEL)
return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM, item,
- "eCPRI with tunnel is not supported "
- "right now.");
+ "eCPRI with tunnel is not supported right now");
if (item_flags & MLX5_FLOW_LAYER_OUTER_L3)
return rte_flow_error_set(error, ENOTSUP,
RTE_FLOW_ERROR_TYPE_ITEM, item,
else if (item_flags & MLX5_FLOW_LAYER_OUTER_L4_TCP)
return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM, item,
- "eCPRI cannot follow a TCP layer.");
+ "eCPRI cannot coexist with a TCP layer");
/* In specification, eCPRI could be over UDP layer. */
else if (item_flags & MLX5_FLOW_LAYER_OUTER_L4_UDP)
return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM, item,
- "eCPRI over UDP layer is not yet "
- "supported right now.");
+ "eCPRI over UDP layer is not yet supported right now");
/* Mask for type field in common header could be zero. */
if (!mask)
mask = &rte_flow_item_ecpri_mask;
if (mask_lo.hdr.common.type != 0 && mask_lo.hdr.common.type != 0xff)
return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM_MASK, mask,
- "partial mask is not supported "
- "for protocol");
+ "partial mask is not supported for protocol");
else if (mask_lo.hdr.common.type == 0 && mask->hdr.dummy[0] != 0)
return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM_MASK, mask,
- "message header mask must be after "
- "a type mask");
+ "message header mask must be after a type mask");
return mlx5_flow_item_acceptable(item, (const uint8_t *)mask,
acc_mask ? (const uint8_t *)acc_mask
: (const uint8_t *)&nic_mask,
MLX5_ITEM_RANGE_NOT_ACCEPTED, error);
}
-/* Allocate unique ID for the split Q/RSS subflows. */
-static uint32_t
-flow_qrss_get_id(struct rte_eth_dev *dev)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
- uint32_t qrss_id, ret;
-
- ret = mlx5_flow_id_get(priv->qrss_id_pool, &qrss_id);
- if (ret)
- return 0;
- MLX5_ASSERT(qrss_id);
- return qrss_id;
-}
-
-/* Free unique ID for the split Q/RSS subflows. */
-static void
-flow_qrss_free_id(struct rte_eth_dev *dev, uint32_t qrss_id)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
-
- if (qrss_id)
- mlx5_flow_id_release(priv->qrss_id_pool, qrss_id);
-}
-
/**
* Release resource related QUEUE/RSS action split.
*
SILIST_FOREACH(priv->sh->ipool[MLX5_IPOOL_MLX5_FLOW], flow->dev_handles,
handle_idx, dev_handle, next)
if (dev_handle->split_flow_id)
- flow_qrss_free_id(dev, dev_handle->split_flow_id);
+ mlx5_ipool_free(priv->sh->ipool
+ [MLX5_IPOOL_RSS_EXPANTION_FLOW_ID],
+ dev_handle->split_flow_id);
}
static int
return fops->apply(dev, flow, error);
}
-/**
- * Flow driver remove API. This abstracts calling driver specific functions.
- * Parent flow (rte_flow) should have driver type (drv_type). It removes a flow
- * on device. All the resources of the flow should be freed by calling
- * flow_drv_destroy().
- *
- * @param[in] dev
- * Pointer to Ethernet device.
- * @param[in, out] flow
- * Pointer to flow structure.
- */
-static inline void
-flow_drv_remove(struct rte_eth_dev *dev, struct rte_flow *flow)
-{
- const struct mlx5_flow_driver_ops *fops;
- enum mlx5_flow_drv_type type = flow->drv_type;
-
- MLX5_ASSERT(type > MLX5_FLOW_TYPE_MIN && type < MLX5_FLOW_TYPE_MAX);
- fops = flow_get_drv_ops(type);
- fops->remove(dev, flow);
-}
-
/**
* Flow driver destroy API. This abstracts calling driver specific functions.
* Parent flow (rte_flow) should have driver type (drv_type). It removes a flow
return NULL;
}
+/**
+ * Get ASO age action by index.
+ *
+ * @param[in] dev
+ * Pointer to the Ethernet device structure.
+ * @param[in] age_idx
+ * Index to the ASO age action.
+ *
+ * @return
+ * The specified ASO age action.
+ */
+struct mlx5_aso_age_action*
+flow_aso_age_get_by_idx(struct rte_eth_dev *dev, uint32_t age_idx)
+{
+ uint16_t pool_idx = age_idx & UINT16_MAX;
+ uint16_t offset = (age_idx >> 16) & UINT16_MAX;
+ struct mlx5_priv *priv = dev->data->dev_private;
+ struct mlx5_aso_age_mng *mng = priv->sh->aso_age_mng;
+ struct mlx5_aso_age_pool *pool = mng->pools[pool_idx];
+
+ return &pool->actions[offset - 1];
+}
+
/* maps shared action to translated non shared in some actions array */
struct mlx5_translated_shared_action {
struct rte_flow_shared_action *action; /**< Shared action */
* action handling should be preformed on *shared* actions list returned
* from this call.
*
+ * @param[in] dev
+ * Pointer to Ethernet device.
* @param[in] actions
* List of actions to translate.
* @param[out] shared
* 0 on success, a negative errno value otherwise and rte_errno is set.
*/
static int
-flow_shared_actions_translate(const struct rte_flow_action actions[],
- struct mlx5_translated_shared_action *shared,
- int *shared_n,
- struct rte_flow_action **translated_actions,
- struct rte_flow_error *error)
+flow_shared_actions_translate(struct rte_eth_dev *dev,
+ const struct rte_flow_action actions[],
+ struct mlx5_translated_shared_action *shared,
+ int *shared_n,
+ struct rte_flow_action **translated_actions,
+ struct rte_flow_error *error)
{
+ struct mlx5_priv *priv = dev->data->dev_private;
struct rte_flow_action *translated = NULL;
size_t actions_size;
int n;
}
memcpy(translated, actions, actions_size);
for (shared_end = shared + copied_n; shared < shared_end; shared++) {
- const struct rte_flow_shared_action *shared_action;
-
- shared_action = shared->action;
- switch (shared_action->type) {
- case MLX5_RTE_FLOW_ACTION_TYPE_SHARED_RSS:
+ struct mlx5_shared_action_rss *shared_rss;
+ uint32_t act_idx = (uint32_t)(uintptr_t)shared->action;
+ uint32_t type = act_idx >> MLX5_SHARED_ACTION_TYPE_OFFSET;
+ uint32_t idx = act_idx & ((1u << MLX5_SHARED_ACTION_TYPE_OFFSET)
+ - 1);
+
+ switch (type) {
+ case MLX5_SHARED_ACTION_TYPE_RSS:
+ shared_rss = mlx5_ipool_get
+ (priv->sh->ipool[MLX5_IPOOL_RSS_SHARED_ACTIONS], idx);
translated[shared->index].type =
RTE_FLOW_ACTION_TYPE_RSS;
translated[shared->index].conf =
- &shared_action->rss.origin;
+ &shared_rss->origin;
break;
+ case MLX5_SHARED_ACTION_TYPE_AGE:
+ if (priv->sh->flow_hit_aso_en) {
+ translated[shared->index].type =
+ (enum rte_flow_action_type)
+ MLX5_RTE_FLOW_ACTION_TYPE_AGE;
+ translated[shared->index].conf =
+ (void *)(uintptr_t)idx;
+ break;
+ }
+ /* Fall-through */
default:
mlx5_free(translated);
return rte_flow_error_set
/**
* Get Shared RSS action from the action list.
*
+ * @param[in] dev
+ * Pointer to Ethernet device.
* @param[in] shared
* Pointer to the list of actions.
* @param[in] shared_n
* Actions list length.
*
* @return
- * Pointer to the MLX5 RSS action if exists, otherwise return NULL.
+ * The MLX5 RSS action ID if exists, otherwise return 0.
*/
-static struct mlx5_shared_action_rss *
-flow_get_shared_rss_action(struct mlx5_translated_shared_action *shared,
+static uint32_t
+flow_get_shared_rss_action(struct rte_eth_dev *dev,
+ struct mlx5_translated_shared_action *shared,
int shared_n)
{
struct mlx5_translated_shared_action *shared_end;
+ struct mlx5_priv *priv = dev->data->dev_private;
+ struct mlx5_shared_action_rss *shared_rss;
- for (shared_end = shared + shared_n; shared < shared_end; shared++) {
- struct rte_flow_shared_action *shared_action;
- shared_action = shared->action;
- switch (shared_action->type) {
- case MLX5_RTE_FLOW_ACTION_TYPE_SHARED_RSS:
- __atomic_add_fetch(&shared_action->refcnt, 1,
+ for (shared_end = shared + shared_n; shared < shared_end; shared++) {
+ uint32_t act_idx = (uint32_t)(uintptr_t)shared->action;
+ uint32_t type = act_idx >> MLX5_SHARED_ACTION_TYPE_OFFSET;
+ uint32_t idx = act_idx &
+ ((1u << MLX5_SHARED_ACTION_TYPE_OFFSET) - 1);
+ switch (type) {
+ case MLX5_SHARED_ACTION_TYPE_RSS:
+ shared_rss = mlx5_ipool_get
+ (priv->sh->ipool[MLX5_IPOOL_RSS_SHARED_ACTIONS],
+ idx);
+ __atomic_add_fetch(&shared_rss->refcnt, 1,
__ATOMIC_RELAXED);
- return &shared_action->rss;
+ return idx;
default:
break;
}
}
- return NULL;
-}
-
-struct rte_flow_shared_action *
-mlx5_flow_get_shared_rss(struct rte_flow *flow)
-{
- if (flow->shared_rss)
- return container_of(flow->shared_rss,
- struct rte_flow_shared_action, rss);
- else
- return NULL;
+ return 0;
}
static unsigned int
break;
case RTE_FLOW_ACTION_TYPE_RAW_ENCAP:
raw_encap = actions->conf;
- if (raw_encap->size >
- (sizeof(struct rte_flow_item_eth) +
- sizeof(struct rte_flow_item_ipv4)))
+ if (raw_encap->size > MLX5_ENCAPSULATION_DECISION_SIZE)
split++;
action_n++;
break;
flow_list_destroy(struct rte_eth_dev *dev, uint32_t *list,
uint32_t flow_idx);
-/**
- * Add a flow of copying flow metadata registers in RX_CP_TBL.
- *
- * As mark_id is unique, if there's already a registered flow for the mark_id,
- * return by increasing the reference counter of the resource. Otherwise, create
- * the resource (mcp_res) and flow.
- *
- * Flow looks like,
- * - If ingress port is ANY and reg_c[1] is mark_id,
- * flow_tag := mark_id, reg_b := reg_c[0] and jump to RX_ACT_TBL.
- *
- * For default flow (zero mark_id), flow is like,
- * - If ingress port is ANY,
- * reg_b := reg_c[0] and jump to RX_ACT_TBL.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param mark_id
- * ID of MARK action, zero means default flow for META.
- * @param[out] error
- * Perform verbose error reporting if not NULL.
- *
- * @return
- * Associated resource on success, NULL otherwise and rte_errno is set.
- */
-static struct mlx5_flow_mreg_copy_resource *
-flow_mreg_add_copy_action(struct rte_eth_dev *dev, uint32_t mark_id,
- struct rte_flow_error *error)
+struct mlx5_hlist_entry *
+flow_dv_mreg_create_cb(struct mlx5_hlist *list, uint64_t key,
+ void *cb_ctx)
{
+ struct rte_eth_dev *dev = list->ctx;
struct mlx5_priv *priv = dev->data->dev_private;
+ struct mlx5_flow_cb_ctx *ctx = cb_ctx;
+ struct mlx5_flow_mreg_copy_resource *mcp_res;
+ struct rte_flow_error *error = ctx->error;
+ uint32_t idx = 0;
+ int ret;
+ uint32_t mark_id = key;
struct rte_flow_attr attr = {
.group = MLX5_FLOW_MREG_CP_TABLE_GROUP,
.ingress = 1,
struct rte_flow_action actions[] = {
[3] = { .type = RTE_FLOW_ACTION_TYPE_END, },
};
- struct mlx5_flow_mreg_copy_resource *mcp_res;
- uint32_t idx = 0;
- int ret;
/* Fill the register fileds in the flow. */
ret = mlx5_flow_get_reg_id(dev, MLX5_FLOW_MARK, 0, error);
if (ret < 0)
return NULL;
cp_mreg.src = ret;
- /* Check if already registered. */
- MLX5_ASSERT(priv->mreg_cp_tbl);
- mcp_res = (void *)mlx5_hlist_lookup(priv->mreg_cp_tbl, mark_id);
- if (mcp_res) {
- /* For non-default rule. */
- if (mark_id != MLX5_DEFAULT_COPY_ID)
- mcp_res->refcnt++;
- MLX5_ASSERT(mark_id != MLX5_DEFAULT_COPY_ID ||
- mcp_res->refcnt == 1);
- return mcp_res;
- }
/* Provide the full width of FLAG specific value. */
if (mark_id == (priv->sh->dv_regc0_mask & MLX5_FLOW_MARK_DEFAULT))
tag_spec.data = MLX5_FLOW_MARK_DEFAULT;
*/
mcp_res->rix_flow = flow_list_create(dev, NULL, &attr, items,
actions, false, error);
- if (!mcp_res->rix_flow)
- goto error;
- mcp_res->refcnt++;
- mcp_res->hlist_ent.key = mark_id;
- ret = mlx5_hlist_insert(priv->mreg_cp_tbl,
- &mcp_res->hlist_ent);
- MLX5_ASSERT(!ret);
- if (ret)
- goto error;
- return mcp_res;
-error:
- if (mcp_res->rix_flow)
- flow_list_destroy(dev, NULL, mcp_res->rix_flow);
- mlx5_ipool_free(priv->sh->ipool[MLX5_IPOOL_MCP], mcp_res->idx);
- return NULL;
+ if (!mcp_res->rix_flow) {
+ mlx5_ipool_free(priv->sh->ipool[MLX5_IPOOL_MCP], idx);
+ return NULL;
+ }
+ return &mcp_res->hlist_ent;
}
/**
- * Release flow in RX_CP_TBL.
+ * Add a flow of copying flow metadata registers in RX_CP_TBL.
+ *
+ * As mark_id is unique, if there's already a registered flow for the mark_id,
+ * return by increasing the reference counter of the resource. Otherwise, create
+ * the resource (mcp_res) and flow.
+ *
+ * Flow looks like,
+ * - If ingress port is ANY and reg_c[1] is mark_id,
+ * flow_tag := mark_id, reg_b := reg_c[0] and jump to RX_ACT_TBL.
+ *
+ * For default flow (zero mark_id), flow is like,
+ * - If ingress port is ANY,
+ * reg_b := reg_c[0] and jump to RX_ACT_TBL.
*
* @param dev
* Pointer to Ethernet device.
- * @flow
- * Parent flow for wich copying is provided.
+ * @param mark_id
+ * ID of MARK action, zero means default flow for META.
+ * @param[out] error
+ * Perform verbose error reporting if not NULL.
+ *
+ * @return
+ * Associated resource on success, NULL otherwise and rte_errno is set.
*/
-static void
-flow_mreg_del_copy_action(struct rte_eth_dev *dev,
- struct rte_flow *flow)
+static struct mlx5_flow_mreg_copy_resource *
+flow_mreg_add_copy_action(struct rte_eth_dev *dev, uint32_t mark_id,
+ struct rte_flow_error *error)
{
- struct mlx5_flow_mreg_copy_resource *mcp_res;
struct mlx5_priv *priv = dev->data->dev_private;
+ struct mlx5_hlist_entry *entry;
+ struct mlx5_flow_cb_ctx ctx = {
+ .dev = dev,
+ .error = error,
+ };
- if (!flow->rix_mreg_copy)
- return;
- mcp_res = mlx5_ipool_get(priv->sh->ipool[MLX5_IPOOL_MCP],
- flow->rix_mreg_copy);
- if (!mcp_res || !priv->mreg_cp_tbl)
- return;
- if (flow->copy_applied) {
- MLX5_ASSERT(mcp_res->appcnt);
- flow->copy_applied = 0;
- --mcp_res->appcnt;
- if (!mcp_res->appcnt) {
- struct rte_flow *mcp_flow = mlx5_ipool_get
- (priv->sh->ipool[MLX5_IPOOL_RTE_FLOW],
- mcp_res->rix_flow);
-
- if (mcp_flow)
- flow_drv_remove(dev, mcp_flow);
- }
- }
- /*
- * We do not check availability of metadata registers here,
- * because copy resources are not allocated in this case.
- */
- if (--mcp_res->refcnt)
- return;
- MLX5_ASSERT(mcp_res->rix_flow);
- flow_list_destroy(dev, NULL, mcp_res->rix_flow);
- mlx5_hlist_remove(priv->mreg_cp_tbl, &mcp_res->hlist_ent);
- mlx5_ipool_free(priv->sh->ipool[MLX5_IPOOL_MCP], mcp_res->idx);
- flow->rix_mreg_copy = 0;
+ /* Check if already registered. */
+ MLX5_ASSERT(priv->mreg_cp_tbl);
+ entry = mlx5_hlist_register(priv->mreg_cp_tbl, mark_id, &ctx);
+ if (!entry)
+ return NULL;
+ return container_of(entry, struct mlx5_flow_mreg_copy_resource,
+ hlist_ent);
}
-/**
- * Start flow in RX_CP_TBL.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @flow
- * Parent flow for wich copying is provided.
- *
- * @return
- * 0 on success, a negative errno value otherwise and rte_errno is set.
- */
-static int
-flow_mreg_start_copy_action(struct rte_eth_dev *dev,
- struct rte_flow *flow)
+void
+flow_dv_mreg_remove_cb(struct mlx5_hlist *list, struct mlx5_hlist_entry *entry)
{
- struct mlx5_flow_mreg_copy_resource *mcp_res;
+ struct mlx5_flow_mreg_copy_resource *mcp_res =
+ container_of(entry, typeof(*mcp_res), hlist_ent);
+ struct rte_eth_dev *dev = list->ctx;
struct mlx5_priv *priv = dev->data->dev_private;
- int ret;
- if (!flow->rix_mreg_copy || flow->copy_applied)
- return 0;
- mcp_res = mlx5_ipool_get(priv->sh->ipool[MLX5_IPOOL_MCP],
- flow->rix_mreg_copy);
- if (!mcp_res)
- return 0;
- if (!mcp_res->appcnt) {
- struct rte_flow *mcp_flow = mlx5_ipool_get
- (priv->sh->ipool[MLX5_IPOOL_RTE_FLOW],
- mcp_res->rix_flow);
-
- if (mcp_flow) {
- ret = flow_drv_apply(dev, mcp_flow, NULL);
- if (ret)
- return ret;
- }
- }
- ++mcp_res->appcnt;
- flow->copy_applied = 1;
- return 0;
+ MLX5_ASSERT(mcp_res->rix_flow);
+ flow_list_destroy(dev, NULL, mcp_res->rix_flow);
+ mlx5_ipool_free(priv->sh->ipool[MLX5_IPOOL_MCP], mcp_res->idx);
}
/**
- * Stop flow in RX_CP_TBL.
+ * Release flow in RX_CP_TBL.
*
* @param dev
* Pointer to Ethernet device.
* Parent flow for wich copying is provided.
*/
static void
-flow_mreg_stop_copy_action(struct rte_eth_dev *dev,
- struct rte_flow *flow)
+flow_mreg_del_copy_action(struct rte_eth_dev *dev,
+ struct rte_flow *flow)
{
struct mlx5_flow_mreg_copy_resource *mcp_res;
struct mlx5_priv *priv = dev->data->dev_private;
- if (!flow->rix_mreg_copy || !flow->copy_applied)
+ if (!flow->rix_mreg_copy)
return;
mcp_res = mlx5_ipool_get(priv->sh->ipool[MLX5_IPOOL_MCP],
flow->rix_mreg_copy);
- if (!mcp_res)
+ if (!mcp_res || !priv->mreg_cp_tbl)
return;
- MLX5_ASSERT(mcp_res->appcnt);
- --mcp_res->appcnt;
- flow->copy_applied = 0;
- if (!mcp_res->appcnt) {
- struct rte_flow *mcp_flow = mlx5_ipool_get
- (priv->sh->ipool[MLX5_IPOOL_RTE_FLOW],
- mcp_res->rix_flow);
-
- if (mcp_flow)
- flow_drv_remove(dev, mcp_flow);
- }
+ MLX5_ASSERT(mcp_res->rix_flow);
+ mlx5_hlist_unregister(priv->mreg_cp_tbl, &mcp_res->hlist_ent);
+ flow->rix_mreg_copy = 0;
}
/**
* Remove the default copy action from RX_CP_TBL.
*
+ * This functions is called in the mlx5_dev_start(). No thread safe
+ * is guaranteed.
+ *
* @param dev
* Pointer to Ethernet device.
*/
static void
flow_mreg_del_default_copy_action(struct rte_eth_dev *dev)
{
- struct mlx5_flow_mreg_copy_resource *mcp_res;
+ struct mlx5_hlist_entry *entry;
struct mlx5_priv *priv = dev->data->dev_private;
/* Check if default flow is registered. */
if (!priv->mreg_cp_tbl)
return;
- mcp_res = (void *)mlx5_hlist_lookup(priv->mreg_cp_tbl,
- MLX5_DEFAULT_COPY_ID);
- if (!mcp_res)
+ entry = mlx5_hlist_lookup(priv->mreg_cp_tbl,
+ MLX5_DEFAULT_COPY_ID, NULL);
+ if (!entry)
return;
- MLX5_ASSERT(mcp_res->rix_flow);
- flow_list_destroy(dev, NULL, mcp_res->rix_flow);
- mlx5_hlist_remove(priv->mreg_cp_tbl, &mcp_res->hlist_ent);
- mlx5_ipool_free(priv->sh->ipool[MLX5_IPOOL_MCP], mcp_res->idx);
+ mlx5_hlist_unregister(priv->mreg_cp_tbl, entry);
}
/**
* Add the default copy action in in RX_CP_TBL.
*
+ * This functions is called in the mlx5_dev_start(). No thread safe
+ * is guaranteed.
+ *
* @param dev
* Pointer to Ethernet device.
* @param[out] error
!mlx5_flow_ext_mreg_supported(dev) ||
!priv->sh->dv_regc0_mask)
return 0;
+ /*
+ * Add default mreg copy flow may be called multiple time, but
+ * only be called once in stop. Avoid register it twice.
+ */
+ if (mlx5_hlist_lookup(priv->mreg_cp_tbl, MLX5_DEFAULT_COPY_ID, NULL))
+ return 0;
mcp_res = flow_mreg_add_copy_action(dev, MLX5_DEFAULT_COPY_ID, error);
if (!mcp_res)
return -rte_errno;
if (!mcp_res)
return -rte_errno;
flow->rix_mreg_copy = mcp_res->idx;
- if (dev->data->dev_started) {
- mcp_res->appcnt++;
- flow->copy_applied = 1;
- }
return 0;
case RTE_FLOW_ACTION_TYPE_MARK:
mark = (const struct rte_flow_action_mark *)
if (!mcp_res)
return -rte_errno;
flow->rix_mreg_copy = mcp_res->idx;
- if (dev->data->dev_started) {
- mcp_res->appcnt++;
- flow->copy_applied = 1;
- }
return 0;
default:
break;
struct rte_flow_action actions_rx[],
struct rte_flow_action actions_tx[],
struct rte_flow_item pattern_tx[],
- uint32_t *flow_id)
+ uint32_t flow_id)
{
- struct mlx5_priv *priv = dev->data->dev_private;
const struct rte_flow_action_raw_encap *raw_encap;
const struct rte_flow_action_raw_decap *raw_decap;
struct mlx5_rte_flow_action_set_tag *set_tag;
char *addr;
int encap = 0;
- mlx5_flow_id_get(priv->sh->flow_id_pool, flow_id);
for (; actions->type != RTE_FLOW_ACTION_TYPE_END; actions++) {
switch (actions->type) {
case RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP:
break;
case RTE_FLOW_ACTION_TYPE_RAW_ENCAP:
raw_encap = actions->conf;
- if (raw_encap->size >
- (sizeof(struct rte_flow_item_eth) +
- sizeof(struct rte_flow_item_ipv4))) {
+ if (raw_encap->size > MLX5_ENCAPSULATION_DECISION_SIZE) {
memcpy(actions_tx, actions,
sizeof(struct rte_flow_action));
actions_tx++;
break;
case RTE_FLOW_ACTION_TYPE_RAW_DECAP:
raw_decap = actions->conf;
- if (raw_decap->size <
- (sizeof(struct rte_flow_item_eth) +
- sizeof(struct rte_flow_item_ipv4))) {
+ if (raw_decap->size < MLX5_ENCAPSULATION_DECISION_SIZE) {
memcpy(actions_tx, actions,
sizeof(struct rte_flow_action));
actions_tx++;
set_tag = (void *)actions_rx;
set_tag->id = mlx5_flow_get_reg_id(dev, MLX5_HAIRPIN_RX, 0, NULL);
MLX5_ASSERT(set_tag->id > REG_NON);
- set_tag->data = *flow_id;
+ set_tag->data = flow_id;
tag_action->conf = set_tag;
/* Create Tx item list. */
rte_memcpy(actions_tx, actions, sizeof(struct rte_flow_action));
item->type = (enum rte_flow_item_type)
MLX5_RTE_FLOW_ITEM_TYPE_TAG;
tag_item = (void *)addr;
- tag_item->data = *flow_id;
+ tag_item->data = flow_id;
tag_item->id = mlx5_flow_get_reg_id(dev, MLX5_HAIRPIN_TX, 0, NULL);
MLX5_ASSERT(set_tag->id > REG_NON);
item->spec = tag_item;
return 0;
}
-__extension__
-union tunnel_offload_mark {
- uint32_t val;
- struct {
- uint32_t app_reserve:8;
- uint32_t table_id:15;
- uint32_t transfer:1;
- uint32_t _unused_:8;
- };
-};
-
-struct tunnel_default_miss_ctx {
- uint16_t *queue;
- __extension__
- union {
- struct rte_flow_action_rss action_rss;
- struct rte_flow_action_queue miss_queue;
- struct rte_flow_action_jump miss_jump;
- uint8_t raw[0];
- };
-};
-
-static int
-flow_tunnel_add_default_miss(struct rte_eth_dev *dev,
- struct rte_flow *flow,
- const struct rte_flow_attr *attr,
- const struct rte_flow_action *app_actions,
- uint32_t flow_idx,
- struct tunnel_default_miss_ctx *ctx,
- struct rte_flow_error *error)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
- struct mlx5_flow *dev_flow;
- struct rte_flow_attr miss_attr = *attr;
- const struct mlx5_flow_tunnel *tunnel = app_actions[0].conf;
- const struct rte_flow_item miss_items[2] = {
- {
- .type = RTE_FLOW_ITEM_TYPE_ETH,
- .spec = NULL,
- .last = NULL,
- .mask = NULL
- },
- {
- .type = RTE_FLOW_ITEM_TYPE_END,
- .spec = NULL,
- .last = NULL,
- .mask = NULL
- }
- };
- union tunnel_offload_mark mark_id;
- struct rte_flow_action_mark miss_mark;
- struct rte_flow_action miss_actions[3] = {
- [0] = { .type = RTE_FLOW_ACTION_TYPE_MARK, .conf = &miss_mark },
- [2] = { .type = RTE_FLOW_ACTION_TYPE_END, .conf = NULL }
- };
- const struct rte_flow_action_jump *jump_data;
- uint32_t i, flow_table = 0; /* prevent compilation warning */
- struct flow_grp_info grp_info = {
- .external = 1,
- .transfer = attr->transfer,
- .fdb_def_rule = !!priv->fdb_def_rule,
- .std_tbl_fix = 0,
- };
- int ret;
-
- if (!attr->transfer) {
- uint32_t q_size;
-
- miss_actions[1].type = RTE_FLOW_ACTION_TYPE_RSS;
- q_size = priv->reta_idx_n * sizeof(ctx->queue[0]);
- ctx->queue = mlx5_malloc(MLX5_MEM_SYS | MLX5_MEM_ZERO, q_size,
- 0, SOCKET_ID_ANY);
- if (!ctx->queue)
- return rte_flow_error_set
- (error, ENOMEM,
- RTE_FLOW_ERROR_TYPE_ACTION_CONF,
- NULL, "invalid default miss RSS");
- ctx->action_rss.func = RTE_ETH_HASH_FUNCTION_DEFAULT,
- ctx->action_rss.level = 0,
- ctx->action_rss.types = priv->rss_conf.rss_hf,
- ctx->action_rss.key_len = priv->rss_conf.rss_key_len,
- ctx->action_rss.queue_num = priv->reta_idx_n,
- ctx->action_rss.key = priv->rss_conf.rss_key,
- ctx->action_rss.queue = ctx->queue;
- if (!priv->reta_idx_n || !priv->rxqs_n)
- return rte_flow_error_set
- (error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ACTION_CONF,
- NULL, "invalid port configuration");
- if (!(dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS_FLAG))
- ctx->action_rss.types = 0;
- for (i = 0; i != priv->reta_idx_n; ++i)
- ctx->queue[i] = (*priv->reta_idx)[i];
- } else {
- miss_actions[1].type = RTE_FLOW_ACTION_TYPE_JUMP;
- ctx->miss_jump.group = MLX5_TNL_MISS_FDB_JUMP_GRP;
- }
- miss_actions[1].conf = (typeof(miss_actions[1].conf))ctx->raw;
- for (; app_actions->type != RTE_FLOW_ACTION_TYPE_JUMP; app_actions++);
- jump_data = app_actions->conf;
- miss_attr.priority = MLX5_TNL_MISS_RULE_PRIORITY;
- miss_attr.group = jump_data->group;
- ret = mlx5_flow_group_to_table(dev, tunnel, jump_data->group,
- &flow_table, grp_info, error);
- if (ret)
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ACTION_CONF,
- NULL, "invalid tunnel id");
- mark_id.app_reserve = 0;
- mark_id.table_id = tunnel_flow_tbl_to_id(flow_table);
- mark_id.transfer = !!attr->transfer;
- mark_id._unused_ = 0;
- miss_mark.id = mark_id.val;
- dev_flow = flow_drv_prepare(dev, flow, &miss_attr,
- miss_items, miss_actions, flow_idx, error);
- if (!dev_flow)
- return -rte_errno;
- dev_flow->flow = flow;
- dev_flow->external = true;
- dev_flow->tunnel = tunnel;
- /* Subflow object was created, we must include one in the list. */
- SILIST_INSERT(&flow->dev_handles, dev_flow->handle_idx,
- dev_flow->handle, next);
- DRV_LOG(DEBUG,
- "port %u tunnel type=%d id=%u miss rule priority=%u group=%u",
- dev->data->port_id, tunnel->app_tunnel.type,
- tunnel->tunnel_id, miss_attr.priority, miss_attr.group);
- ret = flow_drv_translate(dev, dev_flow, &miss_attr, miss_items,
- miss_actions, error);
- if (!ret)
- ret = flow_mreg_update_copy_table(dev, flow, miss_actions,
- error);
-
- return ret;
-}
-
/**
* The last stage of splitting chain, just creates the subflow
* without any modification.
* Parent flow structure pointer.
* @param[in, out] sub_flow
* Pointer to return the created subflow, may be NULL.
- * @param[in] prefix_layers
- * Prefix subflow layers, may be 0.
- * @param[in] prefix_mark
- * Prefix subflow mark flag, may be 0.
* @param[in] attr
* Flow rule attributes.
* @param[in] items
* Pattern specification (list terminated by the END pattern item).
* @param[in] actions
* Associated actions (list terminated by the END action).
- * @param[in] external
- * This flow rule is created by request external to PMD.
- * @param[in] flow_idx
- * This memory pool index to the flow.
+ * @param[in] flow_split_info
+ * Pointer to flow split info structure.
* @param[out] error
* Perform verbose error reporting if not NULL.
* @return
flow_create_split_inner(struct rte_eth_dev *dev,
struct rte_flow *flow,
struct mlx5_flow **sub_flow,
- uint64_t prefix_layers,
- uint32_t prefix_mark,
const struct rte_flow_attr *attr,
const struct rte_flow_item items[],
const struct rte_flow_action actions[],
- bool external, uint32_t flow_idx,
+ struct mlx5_flow_split_info *flow_split_info,
struct rte_flow_error *error)
{
struct mlx5_flow *dev_flow;
dev_flow = flow_drv_prepare(dev, flow, attr, items, actions,
- flow_idx, error);
+ flow_split_info->flow_idx, error);
if (!dev_flow)
return -rte_errno;
dev_flow->flow = flow;
- dev_flow->external = external;
+ dev_flow->external = flow_split_info->external;
+ dev_flow->skip_scale = flow_split_info->skip_scale;
/* Subflow object was created, we must include one in the list. */
SILIST_INSERT(&flow->dev_handles, dev_flow->handle_idx,
dev_flow->handle, next);
* flow may need some user defined item layer flags, and pass the
* Metadate rxq mark flag to suffix flow as well.
*/
- if (prefix_layers)
- dev_flow->handle->layers = prefix_layers;
- if (prefix_mark)
+ if (flow_split_info->prefix_layers)
+ dev_flow->handle->layers = flow_split_info->prefix_layers;
+ if (flow_split_info->prefix_mark)
dev_flow->handle->mark = 1;
if (sub_flow)
*sub_flow = dev_flow;
struct rte_flow_action actions_sfx[],
struct rte_flow_action actions_pre[])
{
+ struct mlx5_priv *priv = dev->data->dev_private;
struct rte_flow_action *tag_action = NULL;
struct rte_flow_item *tag_item;
struct mlx5_rte_flow_action_set_tag *set_tag;
const struct rte_flow_action_raw_decap *raw_decap;
struct mlx5_rte_flow_item_tag *tag_spec;
struct mlx5_rte_flow_item_tag *tag_mask;
- uint32_t tag_id;
+ uint32_t tag_id = 0;
bool copy_vlan = false;
/* Prepare the actions for prefix and suffix flow. */
/* Set the tag. */
set_tag = (void *)actions_pre;
set_tag->id = mlx5_flow_get_reg_id(dev, MLX5_MTR_SFX, 0, &error);
- /*
- * Get the id from the qrss_pool to make qrss share the id with meter.
- */
- tag_id = flow_qrss_get_id(dev);
- set_tag->data = tag_id << MLX5_MTR_COLOR_BITS;
- assert(tag_action);
+ mlx5_ipool_malloc(priv->sh->ipool[MLX5_IPOOL_RSS_EXPANTION_FLOW_ID],
+ &tag_id);
+ if (tag_id >= (1 << (sizeof(tag_id) * 8 - MLX5_MTR_COLOR_BITS))) {
+ DRV_LOG(ERR, "Port %u meter flow id exceed max limit.",
+ dev->data->port_id);
+ mlx5_ipool_free(priv->sh->ipool
+ [MLX5_IPOOL_RSS_EXPANTION_FLOW_ID], tag_id);
+ return 0;
+ } else if (!tag_id) {
+ return 0;
+ }
+ set_tag->data = tag_id << MLX5_MTR_COLOR_BITS;
+ assert(tag_action);
tag_action->conf = set_tag;
/* Prepare the suffix subflow items. */
tag_item = sfx_items++;
const struct rte_flow_action *qrss,
int actions_n, struct rte_flow_error *error)
{
+ struct mlx5_priv *priv = dev->data->dev_private;
struct mlx5_rte_flow_action_set_tag *set_tag;
struct rte_flow_action_jump *jump;
const int qrss_idx = qrss - actions;
* representors) domain even if they have coinciding
* IDs.
*/
- flow_id = flow_qrss_get_id(dev);
+ mlx5_ipool_malloc(priv->sh->ipool
+ [MLX5_IPOOL_RSS_EXPANTION_FLOW_ID], &flow_id);
if (!flow_id)
return rte_flow_error_set(error, ENOMEM,
RTE_FLOW_ERROR_TYPE_ACTION,
int qrss_action_pos,
struct rte_flow_error *error)
{
+ struct mlx5_priv *priv = dev->data->dev_private;
struct mlx5_rte_flow_action_set_tag *set_tag;
struct mlx5_rte_flow_item_tag *tag_spec;
struct mlx5_rte_flow_item_tag *tag_mask;
if (ret < 0)
return ret;
set_tag->id = ret;
- tag_id = flow_qrss_get_id(dev);
+ mlx5_ipool_malloc(priv->sh->ipool
+ [MLX5_IPOOL_RSS_EXPANTION_FLOW_ID], &tag_id);
set_tag->data = tag_id;
/* Prepare the suffix subflow items. */
tag_spec = (void *)(sfx_items + SAMPLE_SUFFIX_ITEM);
* Pointer to Ethernet device.
* @param[in] flow
* Parent flow structure pointer.
- * @param[in] prefix_layers
- * Prefix flow layer flags.
- * @param[in] prefix_mark
- * Prefix subflow mark flag, may be 0.
* @param[in] attr
* Flow rule attributes.
* @param[in] items
* Pattern specification (list terminated by the END pattern item).
* @param[in] actions
* Associated actions (list terminated by the END action).
- * @param[in] external
- * This flow rule is created by request external to PMD.
- * @param[in] flow_idx
- * This memory pool index to the flow.
+ * @param[in] flow_split_info
+ * Pointer to flow split info structure.
* @param[out] error
* Perform verbose error reporting if not NULL.
* @return
static int
flow_create_split_metadata(struct rte_eth_dev *dev,
struct rte_flow *flow,
- uint64_t prefix_layers,
- uint32_t prefix_mark,
const struct rte_flow_attr *attr,
const struct rte_flow_item items[],
const struct rte_flow_action actions[],
- bool external, uint32_t flow_idx,
+ struct mlx5_flow_split_info *flow_split_info,
struct rte_flow_error *error)
{
struct mlx5_priv *priv = dev->data->dev_private;
if (!config->dv_flow_en ||
config->dv_xmeta_en == MLX5_XMETA_MODE_LEGACY ||
!mlx5_flow_ext_mreg_supported(dev))
- return flow_create_split_inner(dev, flow, NULL, prefix_layers,
- prefix_mark, attr, items,
- actions, external, flow_idx,
- error);
+ return flow_create_split_inner(dev, flow, NULL, attr, items,
+ actions, flow_split_info, error);
actions_n = flow_parse_metadata_split_actions_info(actions, &qrss,
&encap_idx);
if (qrss) {
goto exit;
}
/* Add the unmodified original or prefix subflow. */
- ret = flow_create_split_inner(dev, flow, &dev_flow, prefix_layers,
- prefix_mark, attr,
+ ret = flow_create_split_inner(dev, flow, &dev_flow, attr,
items, ext_actions ? ext_actions :
- actions, external, flow_idx, error);
+ actions, flow_split_info, error);
if (ret < 0)
goto exit;
MLX5_ASSERT(dev_flow);
}
dev_flow = NULL;
/* Add suffix subflow to execute Q/RSS. */
- ret = flow_create_split_inner(dev, flow, &dev_flow, layers, 0,
+ flow_split_info->prefix_layers = layers;
+ flow_split_info->prefix_mark = 0;
+ ret = flow_create_split_inner(dev, flow, &dev_flow,
&q_attr, mtr_sfx ? items :
q_items, q_actions,
- external, flow_idx, error);
+ flow_split_info, error);
if (ret < 0)
goto exit;
/* qrss ID should be freed if failed. */
* These ones are included into parent flow list and will be destroyed
* by flow_drv_destroy.
*/
- flow_qrss_free_id(dev, qrss_id);
+ mlx5_ipool_free(priv->sh->ipool[MLX5_IPOOL_RSS_EXPANTION_FLOW_ID],
+ qrss_id);
mlx5_free(ext_actions);
return ret;
}
* Pointer to Ethernet device.
* @param[in] flow
* Parent flow structure pointer.
- * @param[in] prefix_layers
- * Prefix subflow layers, may be 0.
- * @param[in] prefix_mark
- * Prefix subflow mark flag, may be 0.
* @param[in] attr
* Flow rule attributes.
* @param[in] items
* Pattern specification (list terminated by the END pattern item).
* @param[in] actions
* Associated actions (list terminated by the END action).
- * @param[in] external
- * This flow rule is created by request external to PMD.
- * @param[in] flow_idx
- * This memory pool index to the flow.
+ * @param[in] flow_split_info
+ * Pointer to flow split info structure.
* @param[out] error
* Perform verbose error reporting if not NULL.
* @return
static int
flow_create_split_meter(struct rte_eth_dev *dev,
struct rte_flow *flow,
- uint64_t prefix_layers,
- uint32_t prefix_mark,
const struct rte_flow_attr *attr,
const struct rte_flow_item items[],
const struct rte_flow_action actions[],
- bool external, uint32_t flow_idx,
+ struct mlx5_flow_split_info *flow_split_info,
struct rte_flow_error *error)
{
struct mlx5_priv *priv = dev->data->dev_private;
goto exit;
}
/* Add the prefix subflow. */
+ flow_split_info->prefix_mark = 0;
ret = flow_create_split_inner(dev, flow, &dev_flow,
- prefix_layers, 0,
- attr, items,
- pre_actions, external,
- flow_idx, error);
+ attr, items, pre_actions,
+ flow_split_info, error);
if (ret) {
ret = -rte_errno;
goto exit;
sfx_attr.group = sfx_attr.transfer ?
(MLX5_FLOW_TABLE_LEVEL_SUFFIX - 1) :
MLX5_FLOW_TABLE_LEVEL_SUFFIX;
+ flow_split_info->prefix_layers =
+ flow_get_prefix_layer_flags(dev_flow);
+ flow_split_info->prefix_mark = dev_flow->handle->mark;
}
/* Add the prefix subflow. */
- ret = flow_create_split_metadata(dev, flow, dev_flow ?
- flow_get_prefix_layer_flags(dev_flow) :
- prefix_layers, dev_flow ?
- dev_flow->handle->mark : prefix_mark,
+ ret = flow_create_split_metadata(dev, flow,
&sfx_attr, sfx_items ?
sfx_items : items,
sfx_actions ? sfx_actions : actions,
- external, flow_idx, error);
+ flow_split_info, error);
exit:
if (sfx_actions)
mlx5_free(sfx_actions);
* Pattern specification (list terminated by the END pattern item).
* @param[in] actions
* Associated actions (list terminated by the END action).
- * @param[in] external
- * This flow rule is created by request external to PMD.
- * @param[in] flow_idx
- * This memory pool index to the flow.
+ * @param[in] flow_split_info
+ * Pointer to flow split info structure.
* @param[out] error
* Perform verbose error reporting if not NULL.
* @return
const struct rte_flow_attr *attr,
const struct rte_flow_item items[],
const struct rte_flow_action actions[],
- bool external, uint32_t flow_idx,
+ struct mlx5_flow_split_info *flow_split_info,
struct rte_flow_error *error)
{
struct mlx5_priv *priv = dev->data->dev_private;
goto exit;
}
/* Add the prefix subflow. */
- ret = flow_create_split_inner(dev, flow, &dev_flow, 0, 0, attr,
- items, pre_actions, external,
- flow_idx, error);
+ ret = flow_create_split_inner(dev, flow, &dev_flow, attr,
+ items, pre_actions,
+ flow_split_info, error);
if (ret) {
ret = -rte_errno;
goto exit;
sfx_attr.group = sfx_attr.transfer ?
(sfx_table_key.table_id - 1) :
sfx_table_key.table_id;
+ flow_split_info->prefix_layers =
+ flow_get_prefix_layer_flags(dev_flow);
+ flow_split_info->prefix_mark = dev_flow->handle->mark;
+ /* Suffix group level already be scaled with factor, set
+ * skip_scale to 1 to avoid scale again in translation.
+ */
+ flow_split_info->skip_scale = 1;
#endif
}
/* Add the suffix subflow. */
- ret = flow_create_split_meter(dev, flow, dev_flow ?
- flow_get_prefix_layer_flags(dev_flow) : 0,
- dev_flow ? dev_flow->handle->mark : 0,
- &sfx_attr, sfx_items ? sfx_items : items,
- sfx_actions ? sfx_actions : actions,
- external, flow_idx, error);
+ ret = flow_create_split_meter(dev, flow, &sfx_attr,
+ sfx_items ? sfx_items : items,
+ sfx_actions ? sfx_actions : actions,
+ flow_split_info, error);
exit:
if (sfx_actions)
mlx5_free(sfx_actions);
* Pattern specification (list terminated by the END pattern item).
* @param[in] actions
* Associated actions (list terminated by the END action).
- * @param[in] external
- * This flow rule is created by request external to PMD.
- * @param[in] flow_idx
- * This memory pool index to the flow.
+ * @param[in] flow_split_info
+ * Pointer to flow split info structure.
* @param[out] error
* Perform verbose error reporting if not NULL.
* @return
const struct rte_flow_attr *attr,
const struct rte_flow_item items[],
const struct rte_flow_action actions[],
- bool external, uint32_t flow_idx,
+ struct mlx5_flow_split_info *flow_split_info,
struct rte_flow_error *error)
{
int ret;
ret = flow_create_split_sample(dev, flow, attr, items,
- actions, external, flow_idx, error);
+ actions, flow_split_info, error);
MLX5_ASSERT(ret <= 0);
return ret;
}
struct mlx5_flow_rss_desc *rss_desc,
uint32_t nrssq_num)
{
- bool fidx = !!wks->flow_idx;
-
- if (likely(nrssq_num <= wks->rssq_num[fidx]))
+ if (likely(nrssq_num <= wks->rssq_num))
return 0;
rss_desc->queue = realloc(rss_desc->queue,
- sizeof(rss_desc->queue[0]) * RTE_ALIGN(nrssq_num, 2));
+ sizeof(*rss_desc->queue) * RTE_ALIGN(nrssq_num, 2));
if (!rss_desc->queue) {
rte_errno = ENOMEM;
return -1;
}
- wks->rssq_num[fidx] = RTE_ALIGN(nrssq_num, 2);
+ wks->rssq_num = RTE_ALIGN(nrssq_num, 2);
return 0;
}
uint32_t i;
uint32_t idx = 0;
int hairpin_flow;
- uint32_t hairpin_id = 0;
struct rte_flow_attr attr_tx = { .priority = 0 };
- struct rte_flow_attr attr_factor = {0};
const struct rte_flow_action *actions;
struct rte_flow_action *translated_actions = NULL;
struct mlx5_flow_tunnel *tunnel;
struct tunnel_default_miss_ctx default_miss_ctx = { 0, };
- struct mlx5_flow_workspace *wks = mlx5_flow_get_thread_workspace();
- bool fidx = !!wks->flow_idx;
+ struct mlx5_flow_workspace *wks = mlx5_flow_push_thread_workspace();
+ struct mlx5_flow_split_info flow_split_info = {
+ .external = !!external,
+ .skip_scale = 0,
+ .flow_idx = 0,
+ .prefix_mark = 0,
+ .prefix_layers = 0
+ };
int ret;
MLX5_ASSERT(wks);
- rss_desc = &wks->rss_desc[fidx];
- ret = flow_shared_actions_translate(original_actions,
+ rss_desc = &wks->rss_desc;
+ ret = flow_shared_actions_translate(dev, original_actions,
shared_actions,
&shared_actions_n,
&translated_actions, error);
return 0;
}
actions = translated_actions ? translated_actions : original_actions;
- memcpy((void *)&attr_factor, (const void *)attr, sizeof(*attr));
p_actions_rx = actions;
- hairpin_flow = flow_check_hairpin_split(dev, &attr_factor, actions);
- ret = flow_drv_validate(dev, &attr_factor, items, p_actions_rx,
+ hairpin_flow = flow_check_hairpin_split(dev, attr, actions);
+ ret = flow_drv_validate(dev, attr, items, p_actions_rx,
external, hairpin_flow, error);
if (ret < 0)
goto error_before_hairpin_split;
+ flow = mlx5_ipool_zmalloc(priv->sh->ipool[MLX5_IPOOL_RTE_FLOW], &idx);
+ if (!flow) {
+ rte_errno = ENOMEM;
+ goto error_before_hairpin_split;
+ }
if (hairpin_flow > 0) {
if (hairpin_flow > MLX5_MAX_SPLIT_ACTIONS) {
rte_errno = EINVAL;
}
flow_hairpin_split(dev, actions, actions_rx.actions,
actions_hairpin_tx.actions, items_tx.items,
- &hairpin_id);
+ idx);
p_actions_rx = actions_rx.actions;
}
- flow = mlx5_ipool_zmalloc(priv->sh->ipool[MLX5_IPOOL_RTE_FLOW], &idx);
- if (!flow) {
- rte_errno = ENOMEM;
- goto error_before_flow;
- }
- flow->drv_type = flow_get_drv_type(dev, &attr_factor);
- if (hairpin_id != 0)
- flow->hairpin_flow_id = hairpin_id;
+ flow_split_info.flow_idx = idx;
+ flow->drv_type = flow_get_drv_type(dev, attr);
MLX5_ASSERT(flow->drv_type > MLX5_FLOW_TYPE_MIN &&
flow->drv_type < MLX5_FLOW_TYPE_MAX);
memset(rss_desc, 0, offsetof(struct mlx5_flow_rss_desc, queue));
buf->entries = 1;
buf->entry[0].pattern = (void *)(uintptr_t)items;
}
- flow->shared_rss = flow_get_shared_rss_action(shared_actions,
+ rss_desc->shared_rss = flow_get_shared_rss_action(dev, shared_actions,
shared_actions_n);
- /*
- * Record the start index when there is a nested call. All sub-flows
- * need to be translated before another calling.
- * No need to use ping-pong buffer to save memory here.
- */
- if (fidx) {
- MLX5_ASSERT(!wks->flow_nested_idx);
- wks->flow_nested_idx = fidx;
- }
for (i = 0; i < buf->entries; ++i) {
+ /* Initialize flow split data. */
+ flow_split_info.prefix_layers = 0;
+ flow_split_info.prefix_mark = 0;
+ flow_split_info.skip_scale = 0;
/*
* The splitter may create multiple dev_flows,
* depending on configuration. In the simplest
* case it just creates unmodified original flow.
*/
- ret = flow_create_split_outer(dev, flow, &attr_factor,
+ ret = flow_create_split_outer(dev, flow, attr,
buf->entry[i].pattern,
- p_actions_rx, external, idx,
+ p_actions_rx, &flow_split_info,
error);
if (ret < 0)
goto error;
* the egress Flows belong to the different device and
* copy table should be updated in peer NIC Rx domain.
*/
- if (attr_factor.ingress &&
- (external || attr_factor.group != MLX5_FLOW_MREG_CP_TABLE_GROUP)) {
+ if (attr->ingress &&
+ (external || attr->group != MLX5_FLOW_MREG_CP_TABLE_GROUP)) {
ret = flow_mreg_update_copy_table(dev, flow, actions, error);
if (ret)
goto error;
}
/*
- * If the flow is external (from application) OR device is started, then
- * the flow will be applied immediately.
+ * If the flow is external (from application) OR device is started,
+ * OR mreg discover, then apply immediately.
*/
- if (external || dev->data->dev_started) {
+ if (external || dev->data->dev_started ||
+ (attr->group == MLX5_FLOW_MREG_CP_TABLE_GROUP &&
+ attr->priority == MLX5_FLOW_PRIO_RSVD)) {
ret = flow_drv_apply(dev, flow, error);
if (ret < 0)
goto error;
}
- if (list)
+ if (list) {
+ rte_spinlock_lock(&priv->flow_list_lock);
ILIST_INSERT(priv->sh->ipool[MLX5_IPOOL_RTE_FLOW], list, idx,
flow, next);
+ rte_spinlock_unlock(&priv->flow_list_lock);
+ }
flow_rxq_flags_set(dev, flow);
rte_free(translated_actions);
- /* Nested flow creation index recovery. */
- wks->flow_idx = wks->flow_nested_idx;
- if (wks->flow_nested_idx)
- wks->flow_nested_idx = 0;
tunnel = flow_tunnel_from_rule(dev, attr, items, actions);
if (tunnel) {
flow->tunnel = 1;
__atomic_add_fetch(&tunnel->refctn, 1, __ATOMIC_RELAXED);
mlx5_free(default_miss_ctx.queue);
}
+ mlx5_flow_pop_thread_workspace();
return idx;
error:
MLX5_ASSERT(flow);
ret = rte_errno; /* Save rte_errno before cleanup. */
flow_mreg_del_copy_action(dev, flow);
flow_drv_destroy(dev, flow);
+ if (rss_desc->shared_rss)
+ __atomic_sub_fetch(&((struct mlx5_shared_action_rss *)
+ mlx5_ipool_get
+ (priv->sh->ipool[MLX5_IPOOL_RSS_SHARED_ACTIONS],
+ rss_desc->shared_rss))->refcnt, 1, __ATOMIC_RELAXED);
mlx5_ipool_free(priv->sh->ipool[MLX5_IPOOL_RTE_FLOW], idx);
rte_errno = ret; /* Restore rte_errno. */
-error_before_flow:
ret = rte_errno;
- if (hairpin_id)
- mlx5_flow_id_release(priv->sh->flow_id_pool,
- hairpin_id);
rte_errno = ret;
- wks->flow_idx = wks->flow_nested_idx;
- if (wks->flow_nested_idx)
- wks->flow_nested_idx = 0;
+ mlx5_flow_pop_thread_workspace();
error_before_hairpin_split:
rte_free(translated_actions);
return 0;
int shared_actions_n = MLX5_MAX_SHARED_ACTIONS;
const struct rte_flow_action *actions;
struct rte_flow_action *translated_actions = NULL;
- int ret = flow_shared_actions_translate(original_actions,
+ int ret = flow_shared_actions_translate(dev, original_actions,
shared_actions,
&shared_actions_n,
&translated_actions, error);
uint32_t flow_idx)
{
struct mlx5_priv *priv = dev->data->dev_private;
- struct mlx5_fdir_flow *priv_fdir_flow = NULL;
struct rte_flow *flow = mlx5_ipool_get(priv->sh->ipool
[MLX5_IPOOL_RTE_FLOW], flow_idx);
*/
if (dev->data->dev_started)
flow_rxq_flags_trim(dev, flow);
- if (flow->hairpin_flow_id)
- mlx5_flow_id_release(priv->sh->flow_id_pool,
- flow->hairpin_flow_id);
flow_drv_destroy(dev, flow);
- if (list)
+ if (list) {
+ rte_spinlock_lock(&priv->flow_list_lock);
ILIST_REMOVE(priv->sh->ipool[MLX5_IPOOL_RTE_FLOW], list,
flow_idx, flow, next);
- flow_mreg_del_copy_action(dev, flow);
- if (flow->fdir) {
- LIST_FOREACH(priv_fdir_flow, &priv->fdir_flows, next) {
- if (priv_fdir_flow->rix_flow == flow_idx)
- break;
- }
- if (priv_fdir_flow) {
- LIST_REMOVE(priv_fdir_flow, next);
- mlx5_free(priv_fdir_flow->fdir);
- mlx5_free(priv_fdir_flow);
- }
+ rte_spinlock_unlock(&priv->flow_list_lock);
}
- mlx5_ipool_free(priv->sh->ipool[MLX5_IPOOL_RTE_FLOW], flow_idx);
if (flow->tunnel) {
struct mlx5_flow_tunnel *tunnel;
+
tunnel = mlx5_find_tunnel_id(dev, flow->tunnel_id);
RTE_VERIFY(tunnel);
if (!__atomic_sub_fetch(&tunnel->refctn, 1, __ATOMIC_RELAXED))
mlx5_flow_tunnel_free(dev, tunnel);
}
+ flow_mreg_del_copy_action(dev, flow);
+ mlx5_ipool_free(priv->sh->ipool[MLX5_IPOOL_RTE_FLOW], flow_idx);
}
/**
}
}
-/**
- * Remove all flows.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param list
- * Pointer to the Indexed flow list.
- */
-void
-mlx5_flow_stop(struct rte_eth_dev *dev, uint32_t *list)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
- struct rte_flow *flow = NULL;
- uint32_t idx;
-
- ILIST_FOREACH(priv->sh->ipool[MLX5_IPOOL_RTE_FLOW], *list, idx,
- flow, next) {
- flow_drv_remove(dev, flow);
- flow_mreg_stop_copy_action(dev, flow);
- }
- flow_mreg_del_default_copy_action(dev);
- flow_rxq_flags_clear(dev);
-}
-
-/**
- * Add all flows.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param list
- * Pointer to the Indexed flow list.
- *
- * @return
- * 0 on success, a negative errno value otherwise and rte_errno is set.
- */
-int
-mlx5_flow_start(struct rte_eth_dev *dev, uint32_t *list)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
- struct rte_flow *flow = NULL;
- struct rte_flow_error error;
- uint32_t idx;
- int ret = 0;
-
- /* Make sure default copy action (reg_c[0] -> reg_b) is created. */
- ret = flow_mreg_add_default_copy_action(dev, &error);
- if (ret < 0)
- return -rte_errno;
- /* Apply Flows created by application. */
- ILIST_FOREACH(priv->sh->ipool[MLX5_IPOOL_RTE_FLOW], *list, idx,
- flow, next) {
- ret = flow_mreg_start_copy_action(dev, flow);
- if (ret < 0)
- goto error;
- ret = flow_drv_apply(dev, flow, &error);
- if (ret < 0)
- goto error;
- flow_rxq_flags_set(dev, flow);
- }
- return 0;
-error:
- ret = rte_errno; /* Save rte_errno before cleanup. */
- mlx5_flow_stop(dev, list);
- rte_errno = ret; /* Restore rte_errno. */
- return -rte_errno;
-}
-
/**
* Stop all default actions for flows.
*
flow_release_workspace(void *data)
{
struct mlx5_flow_workspace *wks = data;
+ struct mlx5_flow_workspace *next;
- if (!wks)
- return;
- free(wks->rss_desc[0].queue);
- free(wks->rss_desc[1].queue);
- free(wks);
+ while (wks) {
+ next = wks->next;
+ free(wks->rss_desc.queue);
+ free(wks);
+ wks = next;
+ }
}
/**
}
/**
- * Get thread specific flow workspace.
+ * Get thread specific current flow workspace.
*
- * @return pointer to thread specific flowworkspace data, NULL on error.
+ * @return pointer to thread specific flow workspace data, NULL on error.
*/
struct mlx5_flow_workspace*
mlx5_flow_get_thread_workspace(void)
{
struct mlx5_flow_workspace *data;
- if (pthread_once(&key_workspace_init, flow_alloc_workspace)) {
- DRV_LOG(ERR, "Failed to init flow workspace data thread key.");
- return NULL;
- }
data = pthread_getspecific(key_workspace);
+ MLX5_ASSERT(data && data->inuse);
+ if (!data || !data->inuse)
+ DRV_LOG(ERR, "flow workspace not initialized.");
+ return data;
+}
+
+/**
+ * Allocate and init new flow workspace.
+ *
+ * @return pointer to flow workspace data, NULL on error.
+ */
+static struct mlx5_flow_workspace*
+flow_alloc_thread_workspace(void)
+{
+ struct mlx5_flow_workspace *data = calloc(1, sizeof(*data));
+
if (!data) {
- data = calloc(1, sizeof(*data));
- if (!data) {
- DRV_LOG(ERR, "Failed to allocate flow workspace "
- "memory.");
- return NULL;
- }
- data->rss_desc[0].queue = calloc(1,
- sizeof(uint16_t) * MLX5_RSSQ_DEFAULT_NUM);
- if (!data->rss_desc[0].queue)
- goto err;
- data->rss_desc[1].queue = calloc(1,
- sizeof(uint16_t) * MLX5_RSSQ_DEFAULT_NUM);
- if (!data->rss_desc[1].queue)
- goto err;
- data->rssq_num[0] = MLX5_RSSQ_DEFAULT_NUM;
- data->rssq_num[1] = MLX5_RSSQ_DEFAULT_NUM;
- if (pthread_setspecific(key_workspace, data)) {
- DRV_LOG(ERR, "Failed to set flow workspace to thread.");
- goto err;
- }
+ DRV_LOG(ERR, "Failed to allocate flow workspace "
+ "memory.");
+ return NULL;
}
+ data->rss_desc.queue = calloc(1,
+ sizeof(uint16_t) * MLX5_RSSQ_DEFAULT_NUM);
+ if (!data->rss_desc.queue)
+ goto err;
+ data->rssq_num = MLX5_RSSQ_DEFAULT_NUM;
return data;
err:
- if (data->rss_desc[0].queue)
- free(data->rss_desc[0].queue);
- if (data->rss_desc[1].queue)
- free(data->rss_desc[1].queue);
+ if (data->rss_desc.queue)
+ free(data->rss_desc.queue);
free(data);
return NULL;
}
+/**
+ * Get new thread specific flow workspace.
+ *
+ * If current workspace inuse, create new one and set as current.
+ *
+ * @return pointer to thread specific flow workspace data, NULL on error.
+ */
+static struct mlx5_flow_workspace*
+mlx5_flow_push_thread_workspace(void)
+{
+ struct mlx5_flow_workspace *curr;
+ struct mlx5_flow_workspace *data;
+
+ if (pthread_once(&key_workspace_init, flow_alloc_workspace)) {
+ DRV_LOG(ERR, "Failed to init flow workspace data thread key.");
+ return NULL;
+ }
+ curr = pthread_getspecific(key_workspace);
+ if (!curr) {
+ data = flow_alloc_thread_workspace();
+ if (!data)
+ return NULL;
+ } else if (!curr->inuse) {
+ data = curr;
+ } else if (curr->next) {
+ data = curr->next;
+ } else {
+ data = flow_alloc_thread_workspace();
+ if (!data)
+ return NULL;
+ curr->next = data;
+ data->prev = curr;
+ }
+ data->inuse = 1;
+ data->flow_idx = 0;
+ /* Set as current workspace */
+ if (pthread_setspecific(key_workspace, data))
+ DRV_LOG(ERR, "Failed to set flow workspace to thread.");
+ return data;
+}
+
+/**
+ * Close current thread specific flow workspace.
+ *
+ * If previous workspace available, set it as current.
+ *
+ * @return pointer to thread specific flow workspace data, NULL on error.
+ */
+static void
+mlx5_flow_pop_thread_workspace(void)
+{
+ struct mlx5_flow_workspace *data = mlx5_flow_get_thread_workspace();
+
+ if (!data)
+ return;
+ if (!data->inuse) {
+ DRV_LOG(ERR, "Failed to close unused flow workspace.");
+ return;
+ }
+ data->inuse = 0;
+ if (!data->prev)
+ return;
+ if (pthread_setspecific(key_workspace, data->prev))
+ DRV_LOG(ERR, "Failed to set flow workspace to thread.");
+}
+
/**
* Verify the flow list is empty
*
}
/**
- * Convert a flow director filter to a generic flow.
+ * Manage filter operations.
*
* @param dev
- * Pointer to Ethernet device.
- * @param fdir_filter
- * Flow director filter to add.
- * @param attributes
- * Generic flow parameters structure.
+ * Pointer to Ethernet device structure.
+ * @param filter_type
+ * Filter type.
+ * @param filter_op
+ * Operation to perform.
+ * @param arg
+ * Pointer to operation-specific structure.
*
* @return
* 0 on success, a negative errno value otherwise and rte_errno is set.
*/
-static int
-flow_fdir_filter_convert(struct rte_eth_dev *dev,
- const struct rte_eth_fdir_filter *fdir_filter,
- struct mlx5_fdir *attributes)
+int
+mlx5_dev_filter_ctrl(struct rte_eth_dev *dev,
+ enum rte_filter_type filter_type,
+ enum rte_filter_op filter_op,
+ void *arg)
{
- struct mlx5_priv *priv = dev->data->dev_private;
- const struct rte_eth_fdir_input *input = &fdir_filter->input;
- const struct rte_eth_fdir_masks *mask =
- &dev->data->dev_conf.fdir_conf.mask;
-
- /* Validate queue number. */
- if (fdir_filter->action.rx_queue >= priv->rxqs_n) {
- DRV_LOG(ERR, "port %u invalid queue number %d",
- dev->data->port_id, fdir_filter->action.rx_queue);
- rte_errno = EINVAL;
- return -rte_errno;
- }
- attributes->attr.ingress = 1;
- attributes->items[0] = (struct rte_flow_item) {
- .type = RTE_FLOW_ITEM_TYPE_ETH,
- .spec = &attributes->l2,
- .mask = &attributes->l2_mask,
- };
- switch (fdir_filter->action.behavior) {
- case RTE_ETH_FDIR_ACCEPT:
- attributes->actions[0] = (struct rte_flow_action){
- .type = RTE_FLOW_ACTION_TYPE_QUEUE,
- .conf = &attributes->queue,
- };
- break;
- case RTE_ETH_FDIR_REJECT:
- attributes->actions[0] = (struct rte_flow_action){
- .type = RTE_FLOW_ACTION_TYPE_DROP,
- };
- break;
- default:
- DRV_LOG(ERR, "port %u invalid behavior %d",
- dev->data->port_id,
- fdir_filter->action.behavior);
- rte_errno = ENOTSUP;
- return -rte_errno;
- }
- attributes->queue.index = fdir_filter->action.rx_queue;
- /* Handle L3. */
- switch (fdir_filter->input.flow_type) {
- case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
- case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
- case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
- attributes->l3.ipv4.hdr = (struct rte_ipv4_hdr){
- .src_addr = input->flow.ip4_flow.src_ip,
- .dst_addr = input->flow.ip4_flow.dst_ip,
- .time_to_live = input->flow.ip4_flow.ttl,
- .type_of_service = input->flow.ip4_flow.tos,
- };
- attributes->l3_mask.ipv4.hdr = (struct rte_ipv4_hdr){
- .src_addr = mask->ipv4_mask.src_ip,
- .dst_addr = mask->ipv4_mask.dst_ip,
- .time_to_live = mask->ipv4_mask.ttl,
- .type_of_service = mask->ipv4_mask.tos,
- .next_proto_id = mask->ipv4_mask.proto,
- };
- attributes->items[1] = (struct rte_flow_item){
- .type = RTE_FLOW_ITEM_TYPE_IPV4,
- .spec = &attributes->l3,
- .mask = &attributes->l3_mask,
- };
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
- case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
- case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
- attributes->l3.ipv6.hdr = (struct rte_ipv6_hdr){
- .hop_limits = input->flow.ipv6_flow.hop_limits,
- .proto = input->flow.ipv6_flow.proto,
- };
-
- memcpy(attributes->l3.ipv6.hdr.src_addr,
- input->flow.ipv6_flow.src_ip,
- RTE_DIM(attributes->l3.ipv6.hdr.src_addr));
- memcpy(attributes->l3.ipv6.hdr.dst_addr,
- input->flow.ipv6_flow.dst_ip,
- RTE_DIM(attributes->l3.ipv6.hdr.src_addr));
- memcpy(attributes->l3_mask.ipv6.hdr.src_addr,
- mask->ipv6_mask.src_ip,
- RTE_DIM(attributes->l3_mask.ipv6.hdr.src_addr));
- memcpy(attributes->l3_mask.ipv6.hdr.dst_addr,
- mask->ipv6_mask.dst_ip,
- RTE_DIM(attributes->l3_mask.ipv6.hdr.src_addr));
- attributes->items[1] = (struct rte_flow_item){
- .type = RTE_FLOW_ITEM_TYPE_IPV6,
- .spec = &attributes->l3,
- .mask = &attributes->l3_mask,
- };
- break;
- default:
- DRV_LOG(ERR, "port %u invalid flow type%d",
- dev->data->port_id, fdir_filter->input.flow_type);
- rte_errno = ENOTSUP;
- return -rte_errno;
- }
- /* Handle L4. */
- switch (fdir_filter->input.flow_type) {
- case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
- attributes->l4.udp.hdr = (struct rte_udp_hdr){
- .src_port = input->flow.udp4_flow.src_port,
- .dst_port = input->flow.udp4_flow.dst_port,
- };
- attributes->l4_mask.udp.hdr = (struct rte_udp_hdr){
- .src_port = mask->src_port_mask,
- .dst_port = mask->dst_port_mask,
- };
- attributes->items[2] = (struct rte_flow_item){
- .type = RTE_FLOW_ITEM_TYPE_UDP,
- .spec = &attributes->l4,
- .mask = &attributes->l4_mask,
- };
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
- attributes->l4.tcp.hdr = (struct rte_tcp_hdr){
- .src_port = input->flow.tcp4_flow.src_port,
- .dst_port = input->flow.tcp4_flow.dst_port,
- };
- attributes->l4_mask.tcp.hdr = (struct rte_tcp_hdr){
- .src_port = mask->src_port_mask,
- .dst_port = mask->dst_port_mask,
- };
- attributes->items[2] = (struct rte_flow_item){
- .type = RTE_FLOW_ITEM_TYPE_TCP,
- .spec = &attributes->l4,
- .mask = &attributes->l4_mask,
- };
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
- attributes->l4.udp.hdr = (struct rte_udp_hdr){
- .src_port = input->flow.udp6_flow.src_port,
- .dst_port = input->flow.udp6_flow.dst_port,
- };
- attributes->l4_mask.udp.hdr = (struct rte_udp_hdr){
- .src_port = mask->src_port_mask,
- .dst_port = mask->dst_port_mask,
- };
- attributes->items[2] = (struct rte_flow_item){
- .type = RTE_FLOW_ITEM_TYPE_UDP,
- .spec = &attributes->l4,
- .mask = &attributes->l4_mask,
- };
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
- attributes->l4.tcp.hdr = (struct rte_tcp_hdr){
- .src_port = input->flow.tcp6_flow.src_port,
- .dst_port = input->flow.tcp6_flow.dst_port,
- };
- attributes->l4_mask.tcp.hdr = (struct rte_tcp_hdr){
- .src_port = mask->src_port_mask,
- .dst_port = mask->dst_port_mask,
- };
- attributes->items[2] = (struct rte_flow_item){
- .type = RTE_FLOW_ITEM_TYPE_TCP,
- .spec = &attributes->l4,
- .mask = &attributes->l4_mask,
- };
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
- case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
- break;
+ switch (filter_type) {
+ case RTE_ETH_FILTER_GENERIC:
+ if (filter_op != RTE_ETH_FILTER_GET) {
+ rte_errno = EINVAL;
+ return -rte_errno;
+ }
+ *(const void **)arg = &mlx5_flow_ops;
+ return 0;
default:
- DRV_LOG(ERR, "port %u invalid flow type%d",
- dev->data->port_id, fdir_filter->input.flow_type);
+ DRV_LOG(ERR, "port %u filter type (%d) not supported",
+ dev->data->port_id, filter_type);
rte_errno = ENOTSUP;
return -rte_errno;
}
return 0;
}
-#define FLOW_FDIR_CMP(f1, f2, fld) \
- memcmp(&(f1)->fld, &(f2)->fld, sizeof(f1->fld))
-
/**
- * Compare two FDIR flows. If items and actions are identical, the two flows are
- * regarded as same.
+ * Create the needed meter and suffix tables.
*
- * @param dev
+ * @param[in] dev
* Pointer to Ethernet device.
- * @param f1
- * FDIR flow to compare.
- * @param f2
- * FDIR flow to compare.
+ * @param[in] fm
+ * Pointer to the flow meter.
*
* @return
- * Zero on match, 1 otherwise.
+ * Pointer to table set on success, NULL otherwise.
*/
-static int
-flow_fdir_cmp(const struct mlx5_fdir *f1, const struct mlx5_fdir *f2)
-{
- if (FLOW_FDIR_CMP(f1, f2, attr) ||
- FLOW_FDIR_CMP(f1, f2, l2) ||
- FLOW_FDIR_CMP(f1, f2, l2_mask) ||
- FLOW_FDIR_CMP(f1, f2, l3) ||
- FLOW_FDIR_CMP(f1, f2, l3_mask) ||
- FLOW_FDIR_CMP(f1, f2, l4) ||
- FLOW_FDIR_CMP(f1, f2, l4_mask) ||
- FLOW_FDIR_CMP(f1, f2, actions[0].type))
- return 1;
- if (f1->actions[0].type == RTE_FLOW_ACTION_TYPE_QUEUE &&
- FLOW_FDIR_CMP(f1, f2, queue))
- return 1;
- return 0;
+struct mlx5_meter_domains_infos *
+mlx5_flow_create_mtr_tbls(struct rte_eth_dev *dev,
+ const struct mlx5_flow_meter *fm)
+{
+ const struct mlx5_flow_driver_ops *fops;
+
+ fops = flow_get_drv_ops(MLX5_FLOW_TYPE_DV);
+ return fops->create_mtr_tbls(dev, fm);
}
/**
- * Search device flow list to find out a matched FDIR flow.
+ * Destroy the meter table set.
*
- * @param dev
+ * @param[in] dev
* Pointer to Ethernet device.
- * @param fdir_flow
- * FDIR flow to lookup.
+ * @param[in] tbl
+ * Pointer to the meter table set.
*
* @return
- * Index of flow if found, 0 otherwise.
+ * 0 on success.
*/
-static uint32_t
-flow_fdir_filter_lookup(struct rte_eth_dev *dev, struct mlx5_fdir *fdir_flow)
+int
+mlx5_flow_destroy_mtr_tbls(struct rte_eth_dev *dev,
+ struct mlx5_meter_domains_infos *tbls)
{
- struct mlx5_priv *priv = dev->data->dev_private;
- uint32_t flow_idx = 0;
- struct mlx5_fdir_flow *priv_fdir_flow = NULL;
-
- MLX5_ASSERT(fdir_flow);
- LIST_FOREACH(priv_fdir_flow, &priv->fdir_flows, next) {
- if (!flow_fdir_cmp(priv_fdir_flow->fdir, fdir_flow)) {
- DRV_LOG(DEBUG, "port %u found FDIR flow %u",
- dev->data->port_id, flow_idx);
- flow_idx = priv_fdir_flow->rix_flow;
- break;
- }
- }
- return flow_idx;
+ const struct mlx5_flow_driver_ops *fops;
+
+ fops = flow_get_drv_ops(MLX5_FLOW_TYPE_DV);
+ return fops->destroy_mtr_tbls(dev, tbls);
}
/**
- * Add new flow director filter and store it in list.
+ * Create policer rules.
*
- * @param dev
- * Pointer to Ethernet device.
- * @param fdir_filter
- * Flow director filter to add.
- *
- * @return
- * 0 on success, a negative errno value otherwise and rte_errno is set.
- */
-static int
-flow_fdir_filter_add(struct rte_eth_dev *dev,
- const struct rte_eth_fdir_filter *fdir_filter)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
- struct mlx5_fdir *fdir_flow;
- struct rte_flow *flow;
- struct mlx5_fdir_flow *priv_fdir_flow = NULL;
- uint32_t flow_idx;
- int ret;
-
- fdir_flow = mlx5_malloc(MLX5_MEM_ZERO, sizeof(*fdir_flow), 0,
- SOCKET_ID_ANY);
- if (!fdir_flow) {
- rte_errno = ENOMEM;
- return -rte_errno;
- }
- ret = flow_fdir_filter_convert(dev, fdir_filter, fdir_flow);
- if (ret)
- goto error;
- flow_idx = flow_fdir_filter_lookup(dev, fdir_flow);
- if (flow_idx) {
- rte_errno = EEXIST;
- goto error;
- }
- priv_fdir_flow = mlx5_malloc(MLX5_MEM_ZERO,
- sizeof(struct mlx5_fdir_flow),
- 0, SOCKET_ID_ANY);
- if (!priv_fdir_flow) {
- rte_errno = ENOMEM;
- goto error;
- }
- flow_idx = flow_list_create(dev, &priv->flows, &fdir_flow->attr,
- fdir_flow->items, fdir_flow->actions, true,
- NULL);
- flow = mlx5_ipool_get(priv->sh->ipool[MLX5_IPOOL_RTE_FLOW], flow_idx);
- if (!flow)
- goto error;
- flow->fdir = 1;
- priv_fdir_flow->fdir = fdir_flow;
- priv_fdir_flow->rix_flow = flow_idx;
- LIST_INSERT_HEAD(&priv->fdir_flows, priv_fdir_flow, next);
- DRV_LOG(DEBUG, "port %u created FDIR flow %p",
- dev->data->port_id, (void *)flow);
- return 0;
-error:
- mlx5_free(priv_fdir_flow);
- mlx5_free(fdir_flow);
- return -rte_errno;
-}
-
-/**
- * Delete specific filter.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param fdir_filter
- * Filter to be deleted.
- *
- * @return
- * 0 on success, a negative errno value otherwise and rte_errno is set.
- */
-static int
-flow_fdir_filter_delete(struct rte_eth_dev *dev,
- const struct rte_eth_fdir_filter *fdir_filter)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
- uint32_t flow_idx;
- struct mlx5_fdir fdir_flow = {
- .attr.group = 0,
- };
- struct mlx5_fdir_flow *priv_fdir_flow = NULL;
- int ret;
-
- ret = flow_fdir_filter_convert(dev, fdir_filter, &fdir_flow);
- if (ret)
- return -rte_errno;
- LIST_FOREACH(priv_fdir_flow, &priv->fdir_flows, next) {
- /* Find the fdir in priv list */
- if (!flow_fdir_cmp(priv_fdir_flow->fdir, &fdir_flow))
- break;
- }
- if (!priv_fdir_flow)
- return 0;
- LIST_REMOVE(priv_fdir_flow, next);
- flow_idx = priv_fdir_flow->rix_flow;
- flow_list_destroy(dev, &priv->flows, flow_idx);
- mlx5_free(priv_fdir_flow->fdir);
- mlx5_free(priv_fdir_flow);
- DRV_LOG(DEBUG, "port %u deleted FDIR flow %u",
- dev->data->port_id, flow_idx);
- return 0;
-}
-
-/**
- * Update queue for specific filter.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param fdir_filter
- * Filter to be updated.
- *
- * @return
- * 0 on success, a negative errno value otherwise and rte_errno is set.
- */
-static int
-flow_fdir_filter_update(struct rte_eth_dev *dev,
- const struct rte_eth_fdir_filter *fdir_filter)
-{
- int ret;
-
- ret = flow_fdir_filter_delete(dev, fdir_filter);
- if (ret)
- return ret;
- return flow_fdir_filter_add(dev, fdir_filter);
-}
-
-/**
- * Flush all filters.
- *
- * @param dev
- * Pointer to Ethernet device.
- */
-static void
-flow_fdir_filter_flush(struct rte_eth_dev *dev)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
- struct mlx5_fdir_flow *priv_fdir_flow = NULL;
-
- while (!LIST_EMPTY(&priv->fdir_flows)) {
- priv_fdir_flow = LIST_FIRST(&priv->fdir_flows);
- LIST_REMOVE(priv_fdir_flow, next);
- flow_list_destroy(dev, &priv->flows, priv_fdir_flow->rix_flow);
- mlx5_free(priv_fdir_flow->fdir);
- mlx5_free(priv_fdir_flow);
- }
-}
-
-/**
- * Get flow director information.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param[out] fdir_info
- * Resulting flow director information.
- */
-static void
-flow_fdir_info_get(struct rte_eth_dev *dev, struct rte_eth_fdir_info *fdir_info)
-{
- struct rte_eth_fdir_masks *mask =
- &dev->data->dev_conf.fdir_conf.mask;
-
- fdir_info->mode = dev->data->dev_conf.fdir_conf.mode;
- fdir_info->guarant_spc = 0;
- rte_memcpy(&fdir_info->mask, mask, sizeof(fdir_info->mask));
- fdir_info->max_flexpayload = 0;
- fdir_info->flow_types_mask[0] = 0;
- fdir_info->flex_payload_unit = 0;
- fdir_info->max_flex_payload_segment_num = 0;
- fdir_info->flex_payload_limit = 0;
- memset(&fdir_info->flex_conf, 0, sizeof(fdir_info->flex_conf));
-}
-
-/**
- * Deal with flow director operations.
- *
- * @param dev
- * Pointer to Ethernet device.
- * @param filter_op
- * Operation to perform.
- * @param arg
- * Pointer to operation-specific structure.
- *
- * @return
- * 0 on success, a negative errno value otherwise and rte_errno is set.
- */
-static int
-flow_fdir_ctrl_func(struct rte_eth_dev *dev, enum rte_filter_op filter_op,
- void *arg)
-{
- enum rte_fdir_mode fdir_mode =
- dev->data->dev_conf.fdir_conf.mode;
-
- if (filter_op == RTE_ETH_FILTER_NOP)
- return 0;
- if (fdir_mode != RTE_FDIR_MODE_PERFECT &&
- fdir_mode != RTE_FDIR_MODE_PERFECT_MAC_VLAN) {
- DRV_LOG(ERR, "port %u flow director mode %d not supported",
- dev->data->port_id, fdir_mode);
- rte_errno = EINVAL;
- return -rte_errno;
- }
- switch (filter_op) {
- case RTE_ETH_FILTER_ADD:
- return flow_fdir_filter_add(dev, arg);
- case RTE_ETH_FILTER_UPDATE:
- return flow_fdir_filter_update(dev, arg);
- case RTE_ETH_FILTER_DELETE:
- return flow_fdir_filter_delete(dev, arg);
- case RTE_ETH_FILTER_FLUSH:
- flow_fdir_filter_flush(dev);
- break;
- case RTE_ETH_FILTER_INFO:
- flow_fdir_info_get(dev, arg);
- break;
- default:
- DRV_LOG(DEBUG, "port %u unknown operation %u",
- dev->data->port_id, filter_op);
- rte_errno = EINVAL;
- return -rte_errno;
- }
- return 0;
-}
-
-/**
- * Manage filter operations.
- *
- * @param dev
- * Pointer to Ethernet device structure.
- * @param filter_type
- * Filter type.
- * @param filter_op
- * Operation to perform.
- * @param arg
- * Pointer to operation-specific structure.
- *
- * @return
- * 0 on success, a negative errno value otherwise and rte_errno is set.
- */
-int
-mlx5_dev_filter_ctrl(struct rte_eth_dev *dev,
- enum rte_filter_type filter_type,
- enum rte_filter_op filter_op,
- void *arg)
-{
- switch (filter_type) {
- case RTE_ETH_FILTER_GENERIC:
- if (filter_op != RTE_ETH_FILTER_GET) {
- rte_errno = EINVAL;
- return -rte_errno;
- }
- *(const void **)arg = &mlx5_flow_ops;
- return 0;
- case RTE_ETH_FILTER_FDIR:
- return flow_fdir_ctrl_func(dev, filter_op, arg);
- default:
- DRV_LOG(ERR, "port %u filter type (%d) not supported",
- dev->data->port_id, filter_type);
- rte_errno = ENOTSUP;
- return -rte_errno;
- }
- return 0;
-}
-
-/**
- * Create the needed meter and suffix tables.
- *
- * @param[in] dev
- * Pointer to Ethernet device.
- * @param[in] fm
- * Pointer to the flow meter.
- *
- * @return
- * Pointer to table set on success, NULL otherwise.
- */
-struct mlx5_meter_domains_infos *
-mlx5_flow_create_mtr_tbls(struct rte_eth_dev *dev,
- const struct mlx5_flow_meter *fm)
-{
- const struct mlx5_flow_driver_ops *fops;
-
- fops = flow_get_drv_ops(MLX5_FLOW_TYPE_DV);
- return fops->create_mtr_tbls(dev, fm);
-}
-
-/**
- * Destroy the meter table set.
- *
- * @param[in] dev
- * Pointer to Ethernet device.
- * @param[in] tbl
- * Pointer to the meter table set.
- *
- * @return
- * 0 on success.
- */
-int
-mlx5_flow_destroy_mtr_tbls(struct rte_eth_dev *dev,
- struct mlx5_meter_domains_infos *tbls)
-{
- const struct mlx5_flow_driver_ops *fops;
-
- fops = flow_get_drv_ops(MLX5_FLOW_TYPE_DV);
- return fops->destroy_mtr_tbls(dev, tbls);
-}
-
-/**
- * Create policer rules.
- *
- * @param[in] dev
+ * @param[in] dev
* Pointer to Ethernet device.
* @param[in] fm
* Pointer to flow meter structure.
mkey_attr.pg_access = 0;
mkey_attr.klm_array = NULL;
mkey_attr.klm_num = 0;
- mkey_attr.relaxed_ordering = sh->cmng.relaxed_ordering;
+ mkey_attr.relaxed_ordering_write = sh->cmng.relaxed_ordering_write;
+ mkey_attr.relaxed_ordering_read = sh->cmng.relaxed_ordering_read;
mem_mng->dm = mlx5_devx_cmd_mkey_create(sh->ctx, &mkey_attr);
if (!mem_mng->dm) {
mlx5_glue->devx_umem_dereg(mem_mng->umem);
}
rte_spinlock_unlock(&age_info->aged_sl);
}
- for (i = 0; i < sh->max_port; i++) {
- age_info = &sh->port[i].age_info;
- if (!MLX5_AGE_GET(age_info, MLX5_AGE_EVENT_NEW))
- continue;
- if (MLX5_AGE_GET(age_info, MLX5_AGE_TRIGGER))
- rte_eth_dev_callback_process
- (&rte_eth_devices[sh->port[i].devx_ih_port_id],
- RTE_ETH_EVENT_FLOW_AGED, NULL);
- age_info->flags = 0;
- }
+ mlx5_age_event_prepare(sh);
}
/**
sh->cmng.pending_queries--;
}
-static const struct mlx5_flow_tbl_data_entry *
-tunnel_mark_decode(struct rte_eth_dev *dev, uint32_t mark)
-{
- struct mlx5_priv *priv = dev->data->dev_private;
- struct mlx5_dev_ctx_shared *sh = priv->sh;
- struct mlx5_hlist_entry *he;
- union tunnel_offload_mark mbits = { .val = mark };
- union mlx5_flow_tbl_key table_key = {
- {
- .table_id = tunnel_id_to_flow_tbl(mbits.table_id),
- .reserved = 0,
- .domain = !!mbits.transfer,
- .direction = 0,
- }
- };
- he = mlx5_hlist_lookup(sh->flow_tbls, table_key.v64);
- return he ?
- container_of(he, struct mlx5_flow_tbl_data_entry, entry) : NULL;
-}
-
-static uint32_t
-tunnel_flow_group_to_flow_table(struct rte_eth_dev *dev,
- const struct mlx5_flow_tunnel *tunnel,
- uint32_t group, uint32_t *table,
- struct rte_flow_error *error)
-{
- struct mlx5_hlist_entry *he;
- struct tunnel_tbl_entry *tte;
- union tunnel_tbl_key key = {
- .tunnel_id = tunnel ? tunnel->tunnel_id : 0,
- .group = group
- };
- struct mlx5_flow_tunnel_hub *thub = mlx5_tunnel_hub(dev);
- struct mlx5_hlist *group_hash;
-
- group_hash = tunnel ? tunnel->groups : thub->groups;
- he = mlx5_hlist_lookup(group_hash, key.val);
- if (!he) {
- int ret;
- tte = mlx5_malloc(MLX5_MEM_SYS | MLX5_MEM_ZERO,
- sizeof(*tte), 0,
- SOCKET_ID_ANY);
- if (!tte)
- goto err;
- tte->hash.key = key.val;
- ret = mlx5_flow_id_get(thub->table_ids, &tte->flow_table);
- if (ret) {
- mlx5_free(tte);
- goto err;
- }
- tte->flow_table = tunnel_id_to_flow_tbl(tte->flow_table);
- mlx5_hlist_insert(group_hash, &tte->hash);
- } else {
- tte = container_of(he, typeof(*tte), hash);
- }
- *table = tte->flow_table;
- DRV_LOG(DEBUG, "port %u tunnel %u group=%#x table=%#x",
- dev->data->port_id, key.tunnel_id, group, *table);
- return 0;
-
-err:
- return rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
- NULL, "tunnel group index not supported");
-}
-
static int
flow_group_to_table(uint32_t port_id, uint32_t group, uint32_t *table,
- struct flow_grp_info grp_info, struct rte_flow_error *error)
+ const struct flow_grp_info *grp_info,
+ struct rte_flow_error *error)
{
- if (grp_info.transfer && grp_info.external && grp_info.fdb_def_rule) {
+ if (grp_info->transfer && grp_info->external &&
+ grp_info->fdb_def_rule) {
if (group == UINT32_MAX)
return rte_flow_error_set
(error, EINVAL,
mlx5_flow_group_to_table(struct rte_eth_dev *dev,
const struct mlx5_flow_tunnel *tunnel,
uint32_t group, uint32_t *table,
- struct flow_grp_info grp_info,
+ const struct flow_grp_info *grp_info,
struct rte_flow_error *error)
{
int ret;
bool standard_translation;
- if (grp_info.external && group < MLX5_MAX_TABLES_EXTERNAL)
+ if (!grp_info->skip_scale && grp_info->external &&
+ group < MLX5_MAX_TABLES_EXTERNAL)
group *= MLX5_FLOW_TABLE_FACTOR;
if (is_tunnel_offload_active(dev)) {
- standard_translation = !grp_info.external ||
- grp_info.std_tbl_fix;
+ standard_translation = !grp_info->external ||
+ grp_info->std_tbl_fix;
} else {
standard_translation = true;
}
DRV_LOG(DEBUG,
- "port %u group=%#x transfer=%d external=%d fdb_def_rule=%d translate=%s",
- dev->data->port_id, group, grp_info.transfer,
- grp_info.external, grp_info.fdb_def_rule,
+ "port %u group=%u transfer=%d external=%d fdb_def_rule=%d translate=%s",
+ dev->data->port_id, group, grp_info->transfer,
+ grp_info->external, grp_info->fdb_def_rule,
standard_translation ? "STANDARD" : "TUNNEL");
if (standard_translation)
ret = flow_group_to_table(dev->data->port_id, group, table,
flow_idx);
if (!flow)
continue;
- if (dev->data->dev_started || !flow_drv_apply(dev, flow, NULL))
- config->flow_mreg_c[n++] = idx;
+ config->flow_mreg_c[n++] = idx;
flow_list_destroy(dev, NULL, flow_idx);
}
for (; n < MLX5_MREG_C_NUM; ++n)
return fops->action_update(dev, action, action_conf, error);
}
+/* Wrapper for driver action_destroy op callback */
+static int
+flow_drv_action_query(struct rte_eth_dev *dev,
+ const struct rte_flow_shared_action *action,
+ void *data,
+ const struct mlx5_flow_driver_ops *fops,
+ struct rte_flow_error *error)
+{
+ static const char err_msg[] = "shared action query unsupported";
+
+ if (!fops->action_query) {
+ DRV_LOG(ERR, "port %u %s.", dev->data->port_id, err_msg);
+ rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION,
+ NULL, err_msg);
+ return -rte_errno;
+ }
+ return fops->action_query(dev, action, data, error);
+}
+
/**
* Create shared action for reuse in multiple flow rules.
*
flow_get_drv_ops(flow_get_drv_type(dev, &attr));
int ret;
- switch (shared_action->type) {
- case MLX5_RTE_FLOW_ACTION_TYPE_SHARED_RSS:
- if (action->type != RTE_FLOW_ACTION_TYPE_RSS) {
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ACTION,
- NULL,
- "update action type invalid");
- }
- ret = flow_drv_action_validate(dev, NULL, action, fops, error);
- if (ret)
- return ret;
- return flow_drv_action_update(dev, shared_action, action->conf,
- fops, error);
- default:
- return rte_flow_error_set(error, ENOTSUP,
- RTE_FLOW_ERROR_TYPE_ACTION,
- NULL,
- "action type not supported");
- }
+ ret = flow_drv_action_validate(dev, NULL, action, fops, error);
+ if (ret)
+ return ret;
+ return flow_drv_action_update(dev, shared_action, action->conf, fops,
+ error);
}
/**
void *data,
struct rte_flow_error *error)
{
- (void)dev;
- switch (action->type) {
- case MLX5_RTE_FLOW_ACTION_TYPE_SHARED_RSS:
- __atomic_load(&action->refcnt, (uint32_t *)data,
- __ATOMIC_RELAXED);
- return 0;
- default:
- return rte_flow_error_set(error, ENOTSUP,
- RTE_FLOW_ERROR_TYPE_ACTION,
- NULL,
- "action type not supported");
- }
+ struct rte_flow_attr attr = { .transfer = 0 };
+ const struct mlx5_flow_driver_ops *fops =
+ flow_get_drv_ops(flow_get_drv_type(dev, &attr));
+
+ return flow_drv_action_query(dev, action, data, fops, error);
}
/**
{
struct rte_flow_error error;
struct mlx5_priv *priv = dev->data->dev_private;
- struct rte_flow_shared_action *action;
+ struct mlx5_shared_action_rss *action;
int ret = 0;
+ uint32_t idx;
+
+ ILIST_FOREACH(priv->sh->ipool[MLX5_IPOOL_RSS_SHARED_ACTIONS],
+ priv->rss_shared_actions, idx, action, next) {
+ ret |= mlx5_shared_action_destroy(dev,
+ (struct rte_flow_shared_action *)(uintptr_t)idx, &error);
+ }
+ return ret;
+}
+
+#ifndef HAVE_MLX5DV_DR
+#define MLX5_DOMAIN_SYNC_FLOW ((1 << 0) | (1 << 1))
+#else
+#define MLX5_DOMAIN_SYNC_FLOW \
+ (MLX5DV_DR_DOMAIN_SYNC_FLAGS_SW | MLX5DV_DR_DOMAIN_SYNC_FLAGS_HW)
+#endif
+
+int rte_pmd_mlx5_sync_flow(uint16_t port_id, uint32_t domains)
+{
+ struct rte_eth_dev *dev = &rte_eth_devices[port_id];
+ const struct mlx5_flow_driver_ops *fops;
+ int ret;
+ struct rte_flow_attr attr = { .transfer = 0 };
+
+ fops = flow_get_drv_ops(flow_get_drv_type(dev, &attr));
+ ret = fops->sync_domain(dev, domains, MLX5_DOMAIN_SYNC_FLOW);
+ if (ret > 0)
+ ret = -ret;
+ return ret;
+}
+
+/**
+ * tunnel offload functionalilty is defined for DV environment only
+ */
+#ifdef HAVE_IBV_FLOW_DV_SUPPORT
+__extension__
+union tunnel_offload_mark {
+ uint32_t val;
+ struct {
+ uint32_t app_reserve:8;
+ uint32_t table_id:15;
+ uint32_t transfer:1;
+ uint32_t _unused_:8;
+ };
+};
+
+static bool
+mlx5_access_tunnel_offload_db
+ (struct rte_eth_dev *dev,
+ bool (*match)(struct rte_eth_dev *,
+ struct mlx5_flow_tunnel *, const void *),
+ void (*hit)(struct rte_eth_dev *, struct mlx5_flow_tunnel *, void *),
+ void (*miss)(struct rte_eth_dev *, void *),
+ void *ctx, bool lock_op);
+
+static int
+flow_tunnel_add_default_miss(struct rte_eth_dev *dev,
+ struct rte_flow *flow,
+ const struct rte_flow_attr *attr,
+ const struct rte_flow_action *app_actions,
+ uint32_t flow_idx,
+ struct tunnel_default_miss_ctx *ctx,
+ struct rte_flow_error *error)
+{
+ struct mlx5_priv *priv = dev->data->dev_private;
+ struct mlx5_flow *dev_flow;
+ struct rte_flow_attr miss_attr = *attr;
+ const struct mlx5_flow_tunnel *tunnel = app_actions[0].conf;
+ const struct rte_flow_item miss_items[2] = {
+ {
+ .type = RTE_FLOW_ITEM_TYPE_ETH,
+ .spec = NULL,
+ .last = NULL,
+ .mask = NULL
+ },
+ {
+ .type = RTE_FLOW_ITEM_TYPE_END,
+ .spec = NULL,
+ .last = NULL,
+ .mask = NULL
+ }
+ };
+ union tunnel_offload_mark mark_id;
+ struct rte_flow_action_mark miss_mark;
+ struct rte_flow_action miss_actions[3] = {
+ [0] = { .type = RTE_FLOW_ACTION_TYPE_MARK, .conf = &miss_mark },
+ [2] = { .type = RTE_FLOW_ACTION_TYPE_END, .conf = NULL }
+ };
+ const struct rte_flow_action_jump *jump_data;
+ uint32_t i, flow_table = 0; /* prevent compilation warning */
+ struct flow_grp_info grp_info = {
+ .external = 1,
+ .transfer = attr->transfer,
+ .fdb_def_rule = !!priv->fdb_def_rule,
+ .std_tbl_fix = 0,
+ };
+ int ret;
+
+ if (!attr->transfer) {
+ uint32_t q_size;
- while (!LIST_EMPTY(&priv->shared_actions)) {
- action = LIST_FIRST(&priv->shared_actions);
- ret = mlx5_shared_action_destroy(dev, action, &error);
+ miss_actions[1].type = RTE_FLOW_ACTION_TYPE_RSS;
+ q_size = priv->reta_idx_n * sizeof(ctx->queue[0]);
+ ctx->queue = mlx5_malloc(MLX5_MEM_SYS | MLX5_MEM_ZERO, q_size,
+ 0, SOCKET_ID_ANY);
+ if (!ctx->queue)
+ return rte_flow_error_set
+ (error, ENOMEM,
+ RTE_FLOW_ERROR_TYPE_ACTION_CONF,
+ NULL, "invalid default miss RSS");
+ ctx->action_rss.func = RTE_ETH_HASH_FUNCTION_DEFAULT,
+ ctx->action_rss.level = 0,
+ ctx->action_rss.types = priv->rss_conf.rss_hf,
+ ctx->action_rss.key_len = priv->rss_conf.rss_key_len,
+ ctx->action_rss.queue_num = priv->reta_idx_n,
+ ctx->action_rss.key = priv->rss_conf.rss_key,
+ ctx->action_rss.queue = ctx->queue;
+ if (!priv->reta_idx_n || !priv->rxqs_n)
+ return rte_flow_error_set
+ (error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ACTION_CONF,
+ NULL, "invalid port configuration");
+ if (!(dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS_FLAG))
+ ctx->action_rss.types = 0;
+ for (i = 0; i != priv->reta_idx_n; ++i)
+ ctx->queue[i] = (*priv->reta_idx)[i];
+ } else {
+ miss_actions[1].type = RTE_FLOW_ACTION_TYPE_JUMP;
+ ctx->miss_jump.group = MLX5_TNL_MISS_FDB_JUMP_GRP;
}
+ miss_actions[1].conf = (typeof(miss_actions[1].conf))ctx->raw;
+ for (; app_actions->type != RTE_FLOW_ACTION_TYPE_JUMP; app_actions++);
+ jump_data = app_actions->conf;
+ miss_attr.priority = MLX5_TNL_MISS_RULE_PRIORITY;
+ miss_attr.group = jump_data->group;
+ ret = mlx5_flow_group_to_table(dev, tunnel, jump_data->group,
+ &flow_table, &grp_info, error);
+ if (ret)
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ACTION_CONF,
+ NULL, "invalid tunnel id");
+ mark_id.app_reserve = 0;
+ mark_id.table_id = tunnel_flow_tbl_to_id(flow_table);
+ mark_id.transfer = !!attr->transfer;
+ mark_id._unused_ = 0;
+ miss_mark.id = mark_id.val;
+ dev_flow = flow_drv_prepare(dev, flow, &miss_attr,
+ miss_items, miss_actions, flow_idx, error);
+ if (!dev_flow)
+ return -rte_errno;
+ dev_flow->flow = flow;
+ dev_flow->external = true;
+ dev_flow->tunnel = tunnel;
+ /* Subflow object was created, we must include one in the list. */
+ SILIST_INSERT(&flow->dev_handles, dev_flow->handle_idx,
+ dev_flow->handle, next);
+ DRV_LOG(DEBUG,
+ "port %u tunnel type=%d id=%u miss rule priority=%u group=%u",
+ dev->data->port_id, tunnel->app_tunnel.type,
+ tunnel->tunnel_id, miss_attr.priority, miss_attr.group);
+ ret = flow_drv_translate(dev, dev_flow, &miss_attr, miss_items,
+ miss_actions, error);
+ if (!ret)
+ ret = flow_mreg_update_copy_table(dev, flow, miss_actions,
+ error);
+
return ret;
}
+static const struct mlx5_flow_tbl_data_entry *
+tunnel_mark_decode(struct rte_eth_dev *dev, uint32_t mark)
+{
+ struct mlx5_priv *priv = dev->data->dev_private;
+ struct mlx5_dev_ctx_shared *sh = priv->sh;
+ struct mlx5_hlist_entry *he;
+ union tunnel_offload_mark mbits = { .val = mark };
+ union mlx5_flow_tbl_key table_key = {
+ {
+ .table_id = tunnel_id_to_flow_tbl(mbits.table_id),
+ .dummy = 0,
+ .domain = !!mbits.transfer,
+ .direction = 0,
+ }
+ };
+ he = mlx5_hlist_lookup(sh->flow_tbls, table_key.v64, NULL);
+ return he ?
+ container_of(he, struct mlx5_flow_tbl_data_entry, entry) : NULL;
+}
+
+static void
+mlx5_flow_tunnel_grp2tbl_remove_cb(struct mlx5_hlist *list,
+ struct mlx5_hlist_entry *entry)
+{
+ struct mlx5_dev_ctx_shared *sh = list->ctx;
+ struct tunnel_tbl_entry *tte = container_of(entry, typeof(*tte), hash);
+
+ mlx5_ipool_free(sh->ipool[MLX5_IPOOL_TNL_TBL_ID],
+ tunnel_flow_tbl_to_id(tte->flow_table));
+ mlx5_free(tte);
+}
+
+static struct mlx5_hlist_entry *
+mlx5_flow_tunnel_grp2tbl_create_cb(struct mlx5_hlist *list,
+ uint64_t key __rte_unused,
+ void *ctx __rte_unused)
+{
+ struct mlx5_dev_ctx_shared *sh = list->ctx;
+ struct tunnel_tbl_entry *tte;
+
+ tte = mlx5_malloc(MLX5_MEM_SYS | MLX5_MEM_ZERO,
+ sizeof(*tte), 0,
+ SOCKET_ID_ANY);
+ if (!tte)
+ goto err;
+ mlx5_ipool_malloc(sh->ipool[MLX5_IPOOL_TNL_TBL_ID],
+ &tte->flow_table);
+ if (tte->flow_table >= MLX5_MAX_TABLES) {
+ DRV_LOG(ERR, "Tunnel TBL ID %d exceed max limit.",
+ tte->flow_table);
+ mlx5_ipool_free(sh->ipool[MLX5_IPOOL_TNL_TBL_ID],
+ tte->flow_table);
+ goto err;
+ } else if (!tte->flow_table) {
+ goto err;
+ }
+ tte->flow_table = tunnel_id_to_flow_tbl(tte->flow_table);
+ return &tte->hash;
+err:
+ if (tte)
+ mlx5_free(tte);
+ return NULL;
+}
+
+static uint32_t
+tunnel_flow_group_to_flow_table(struct rte_eth_dev *dev,
+ const struct mlx5_flow_tunnel *tunnel,
+ uint32_t group, uint32_t *table,
+ struct rte_flow_error *error)
+{
+ struct mlx5_hlist_entry *he;
+ struct tunnel_tbl_entry *tte;
+ union tunnel_tbl_key key = {
+ .tunnel_id = tunnel ? tunnel->tunnel_id : 0,
+ .group = group
+ };
+ struct mlx5_flow_tunnel_hub *thub = mlx5_tunnel_hub(dev);
+ struct mlx5_hlist *group_hash;
+
+ group_hash = tunnel ? tunnel->groups : thub->groups;
+ he = mlx5_hlist_register(group_hash, key.val, NULL);
+ if (!he)
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
+ NULL,
+ "tunnel group index not supported");
+ tte = container_of(he, typeof(*tte), hash);
+ *table = tte->flow_table;
+ DRV_LOG(DEBUG, "port %u tunnel %u group=%#x table=%#x",
+ dev->data->port_id, key.tunnel_id, group, *table);
+ return 0;
+}
+
static void
mlx5_flow_tunnel_free(struct rte_eth_dev *dev,
struct mlx5_flow_tunnel *tunnel)
{
- struct mlx5_flow_tunnel_hub *thub = mlx5_tunnel_hub(dev);
- struct mlx5_flow_id_pool *id_pool = thub->tunnel_ids;
+ struct mlx5_priv *priv = dev->data->dev_private;
+ struct mlx5_indexed_pool *ipool;
DRV_LOG(DEBUG, "port %u release pmd tunnel id=0x%x",
dev->data->port_id, tunnel->tunnel_id);
- RTE_VERIFY(!__atomic_load_n(&tunnel->refctn, __ATOMIC_RELAXED));
- LIST_REMOVE(tunnel, chain);
- mlx5_flow_id_release(id_pool, tunnel->tunnel_id);
- mlx5_hlist_destroy(tunnel->groups, NULL, NULL);
- mlx5_free(tunnel);
+ mlx5_hlist_destroy(tunnel->groups);
+ ipool = priv->sh->ipool[MLX5_IPOOL_TUNNEL_ID];
+ mlx5_ipool_free(ipool, tunnel->tunnel_id);
}
-static struct mlx5_flow_tunnel *
-mlx5_find_tunnel_id(struct rte_eth_dev *dev, uint32_t id)
+static bool
+mlx5_access_tunnel_offload_db
+ (struct rte_eth_dev *dev,
+ bool (*match)(struct rte_eth_dev *,
+ struct mlx5_flow_tunnel *, const void *),
+ void (*hit)(struct rte_eth_dev *, struct mlx5_flow_tunnel *, void *),
+ void (*miss)(struct rte_eth_dev *, void *),
+ void *ctx, bool lock_op)
{
+ bool verdict = false;
struct mlx5_flow_tunnel_hub *thub = mlx5_tunnel_hub(dev);
- struct mlx5_flow_tunnel *tun;
+ struct mlx5_flow_tunnel *tunnel;
- LIST_FOREACH(tun, &thub->tunnels, chain) {
- if (tun->tunnel_id == id)
+ rte_spinlock_lock(&thub->sl);
+ LIST_FOREACH(tunnel, &thub->tunnels, chain) {
+ verdict = match(dev, tunnel, (const void *)ctx);
+ if (verdict)
break;
}
+ if (!lock_op)
+ rte_spinlock_unlock(&thub->sl);
+ if (verdict && hit)
+ hit(dev, tunnel, ctx);
+ if (!verdict && miss)
+ miss(dev, ctx);
+ if (lock_op)
+ rte_spinlock_unlock(&thub->sl);
- return tun;
+ return verdict;
+}
+
+struct tunnel_db_find_tunnel_id_ctx {
+ uint32_t tunnel_id;
+ struct mlx5_flow_tunnel *tunnel;
+};
+
+static bool
+find_tunnel_id_match(struct rte_eth_dev *dev,
+ struct mlx5_flow_tunnel *tunnel, const void *x)
+{
+ const struct tunnel_db_find_tunnel_id_ctx *ctx = x;
+
+ RTE_SET_USED(dev);
+ return tunnel->tunnel_id == ctx->tunnel_id;
+}
+
+static void
+find_tunnel_id_hit(struct rte_eth_dev *dev,
+ struct mlx5_flow_tunnel *tunnel, void *x)
+{
+ struct tunnel_db_find_tunnel_id_ctx *ctx = x;
+ RTE_SET_USED(dev);
+ ctx->tunnel = tunnel;
+}
+
+static struct mlx5_flow_tunnel *
+mlx5_find_tunnel_id(struct rte_eth_dev *dev, uint32_t id)
+{
+ struct tunnel_db_find_tunnel_id_ctx ctx = {
+ .tunnel_id = id,
+ };
+
+ mlx5_access_tunnel_offload_db(dev, find_tunnel_id_match,
+ find_tunnel_id_hit, NULL, &ctx, true);
+
+ return ctx.tunnel;
}
static struct mlx5_flow_tunnel *
mlx5_flow_tunnel_allocate(struct rte_eth_dev *dev,
const struct rte_flow_tunnel *app_tunnel)
{
- int ret;
+ struct mlx5_priv *priv = dev->data->dev_private;
+ struct mlx5_indexed_pool *ipool;
struct mlx5_flow_tunnel *tunnel;
- struct mlx5_flow_tunnel_hub *thub = mlx5_tunnel_hub(dev);
- struct mlx5_flow_id_pool *id_pool = thub->tunnel_ids;
uint32_t id;
- ret = mlx5_flow_id_get(id_pool, &id);
- if (ret)
+ ipool = priv->sh->ipool[MLX5_IPOOL_TUNNEL_ID];
+ tunnel = mlx5_ipool_zmalloc(ipool, &id);
+ if (!tunnel)
return NULL;
- /**
- * mlx5 flow tunnel is an auxlilary data structure
- * It's not part of IO. No need to allocate it from
- * huge pages pools dedicated for IO
- */
- tunnel = mlx5_malloc(MLX5_MEM_SYS | MLX5_MEM_ZERO, sizeof(*tunnel),
- 0, SOCKET_ID_ANY);
- if (!tunnel) {
- mlx5_flow_id_pool_release(id_pool);
+ if (id >= MLX5_MAX_TUNNELS) {
+ mlx5_ipool_free(ipool, id);
+ DRV_LOG(ERR, "Tunnel ID %d exceed max limit.", id);
return NULL;
}
- tunnel->groups = mlx5_hlist_create("tunnel groups", 1024);
+ tunnel->groups = mlx5_hlist_create("tunnel groups", 1024, 0, 0,
+ mlx5_flow_tunnel_grp2tbl_create_cb,
+ NULL,
+ mlx5_flow_tunnel_grp2tbl_remove_cb);
if (!tunnel->groups) {
- mlx5_flow_id_pool_release(id_pool);
- mlx5_free(tunnel);
+ mlx5_ipool_free(ipool, id);
return NULL;
}
+ tunnel->groups->ctx = priv->sh;
/* initiate new PMD tunnel */
memcpy(&tunnel->app_tunnel, app_tunnel, sizeof(*app_tunnel));
tunnel->tunnel_id = id;
return tunnel;
}
+struct tunnel_db_get_tunnel_ctx {
+ const struct rte_flow_tunnel *app_tunnel;
+ struct mlx5_flow_tunnel *tunnel;
+};
+
+static bool get_tunnel_match(struct rte_eth_dev *dev,
+ struct mlx5_flow_tunnel *tunnel, const void *x)
+{
+ const struct tunnel_db_get_tunnel_ctx *ctx = x;
+
+ RTE_SET_USED(dev);
+ return !memcmp(ctx->app_tunnel, &tunnel->app_tunnel,
+ sizeof(*ctx->app_tunnel));
+}
+
+static void get_tunnel_hit(struct rte_eth_dev *dev,
+ struct mlx5_flow_tunnel *tunnel, void *x)
+{
+ /* called under tunnel spinlock protection */
+ struct tunnel_db_get_tunnel_ctx *ctx = x;
+
+ RTE_SET_USED(dev);
+ tunnel->refctn++;
+ ctx->tunnel = tunnel;
+}
+
+static void get_tunnel_miss(struct rte_eth_dev *dev, void *x)
+{
+ /* called under tunnel spinlock protection */
+ struct mlx5_flow_tunnel_hub *thub = mlx5_tunnel_hub(dev);
+ struct tunnel_db_get_tunnel_ctx *ctx = x;
+
+ rte_spinlock_unlock(&thub->sl);
+ ctx->tunnel = mlx5_flow_tunnel_allocate(dev, ctx->app_tunnel);
+ ctx->tunnel->refctn = 1;
+ rte_spinlock_lock(&thub->sl);
+ if (ctx->tunnel)
+ LIST_INSERT_HEAD(&thub->tunnels, ctx->tunnel, chain);
+}
+
+
static int
mlx5_get_flow_tunnel(struct rte_eth_dev *dev,
const struct rte_flow_tunnel *app_tunnel,
struct mlx5_flow_tunnel **tunnel)
{
- int ret;
- struct mlx5_flow_tunnel_hub *thub = mlx5_tunnel_hub(dev);
- struct mlx5_flow_tunnel *tun;
-
- LIST_FOREACH(tun, &thub->tunnels, chain) {
- if (!memcmp(app_tunnel, &tun->app_tunnel,
- sizeof(*app_tunnel))) {
- *tunnel = tun;
- ret = 0;
- break;
- }
- }
- if (!tun) {
- tun = mlx5_flow_tunnel_allocate(dev, app_tunnel);
- if (tun) {
- LIST_INSERT_HEAD(&thub->tunnels, tun, chain);
- *tunnel = tun;
- } else {
- ret = -ENOMEM;
- }
- }
- if (tun)
- __atomic_add_fetch(&tun->refctn, 1, __ATOMIC_RELAXED);
+ struct tunnel_db_get_tunnel_ctx ctx = {
+ .app_tunnel = app_tunnel,
+ };
- return ret;
+ mlx5_access_tunnel_offload_db(dev, get_tunnel_match, get_tunnel_hit,
+ get_tunnel_miss, &ctx, true);
+ *tunnel = ctx.tunnel;
+ return ctx.tunnel ? 0 : -ENOMEM;
}
void mlx5_release_tunnel_hub(struct mlx5_dev_ctx_shared *sh, uint16_t port_id)
return;
if (!LIST_EMPTY(&thub->tunnels))
DRV_LOG(WARNING, "port %u tunnels present\n", port_id);
- mlx5_flow_id_pool_release(thub->tunnel_ids);
- mlx5_flow_id_pool_release(thub->table_ids);
- mlx5_hlist_destroy(thub->groups, NULL, NULL);
+ mlx5_hlist_destroy(thub->groups);
mlx5_free(thub);
}
if (!thub)
return -ENOMEM;
LIST_INIT(&thub->tunnels);
- thub->tunnel_ids = mlx5_flow_id_pool_alloc(MLX5_MAX_TUNNELS);
- if (!thub->tunnel_ids) {
- err = -rte_errno;
- goto err;
- }
- thub->table_ids = mlx5_flow_id_pool_alloc(MLX5_MAX_TABLES);
- if (!thub->table_ids) {
- err = -rte_errno;
- goto err;
- }
- thub->groups = mlx5_hlist_create("flow groups", MLX5_MAX_TABLES);
+ rte_spinlock_init(&thub->sl);
+ thub->groups = mlx5_hlist_create("flow groups", MLX5_MAX_TABLES, 0,
+ 0, mlx5_flow_tunnel_grp2tbl_create_cb,
+ NULL,
+ mlx5_flow_tunnel_grp2tbl_remove_cb);
if (!thub->groups) {
err = -rte_errno;
goto err;
}
+ thub->groups->ctx = sh;
sh->tunnel_hub = thub;
return 0;
err:
if (thub->groups)
- mlx5_hlist_destroy(thub->groups, NULL, NULL);
- if (thub->table_ids)
- mlx5_flow_id_pool_release(thub->table_ids);
- if (thub->tunnel_ids)
- mlx5_flow_id_pool_release(thub->tunnel_ids);
+ mlx5_hlist_destroy(thub->groups);
if (thub)
mlx5_free(thub);
return err;
}
-#ifndef HAVE_MLX5DV_DR
-#define MLX5_DOMAIN_SYNC_FLOW ((1 << 0) | (1 << 1))
-#else
-#define MLX5_DOMAIN_SYNC_FLOW \
- (MLX5DV_DR_DOMAIN_SYNC_FLAGS_SW | MLX5DV_DR_DOMAIN_SYNC_FLAGS_HW)
-#endif
+static inline bool
+mlx5_flow_tunnel_validate(struct rte_eth_dev *dev,
+ struct rte_flow_tunnel *tunnel,
+ const char *err_msg)
+{
+ err_msg = NULL;
+ if (!is_tunnel_offload_active(dev)) {
+ err_msg = "tunnel offload was not activated";
+ goto out;
+ } else if (!tunnel) {
+ err_msg = "no application tunnel";
+ goto out;
+ }
-int rte_pmd_mlx5_sync_flow(uint16_t port_id, uint32_t domains)
+ switch (tunnel->type) {
+ default:
+ err_msg = "unsupported tunnel type";
+ goto out;
+ case RTE_FLOW_ITEM_TYPE_VXLAN:
+ break;
+ }
+
+out:
+ return !err_msg;
+}
+
+static int
+mlx5_flow_tunnel_decap_set(struct rte_eth_dev *dev,
+ struct rte_flow_tunnel *app_tunnel,
+ struct rte_flow_action **actions,
+ uint32_t *num_of_actions,
+ struct rte_flow_error *error)
{
- struct rte_eth_dev *dev = &rte_eth_devices[port_id];
- const struct mlx5_flow_driver_ops *fops;
int ret;
- struct rte_flow_attr attr = { .transfer = 0 };
+ struct mlx5_flow_tunnel *tunnel;
+ const char *err_msg = NULL;
+ bool verdict = mlx5_flow_tunnel_validate(dev, app_tunnel, err_msg);
- fops = flow_get_drv_ops(flow_get_drv_type(dev, &attr));
- ret = fops->sync_domain(dev, domains, MLX5_DOMAIN_SYNC_FLOW);
- if (ret > 0)
- ret = -ret;
- return ret;
+ if (!verdict)
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ACTION_CONF, NULL,
+ err_msg);
+ ret = mlx5_get_flow_tunnel(dev, app_tunnel, &tunnel);
+ if (ret < 0) {
+ return rte_flow_error_set(error, ret,
+ RTE_FLOW_ERROR_TYPE_ACTION_CONF, NULL,
+ "failed to initialize pmd tunnel");
+ }
+ *actions = &tunnel->action;
+ *num_of_actions = 1;
+ return 0;
}
+
+static int
+mlx5_flow_tunnel_match(struct rte_eth_dev *dev,
+ struct rte_flow_tunnel *app_tunnel,
+ struct rte_flow_item **items,
+ uint32_t *num_of_items,
+ struct rte_flow_error *error)
+{
+ int ret;
+ struct mlx5_flow_tunnel *tunnel;
+ const char *err_msg = NULL;
+ bool verdict = mlx5_flow_tunnel_validate(dev, app_tunnel, err_msg);
+
+ if (!verdict)
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
+ err_msg);
+ ret = mlx5_get_flow_tunnel(dev, app_tunnel, &tunnel);
+ if (ret < 0) {
+ return rte_flow_error_set(error, ret,
+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
+ "failed to initialize pmd tunnel");
+ }
+ *items = &tunnel->item;
+ *num_of_items = 1;
+ return 0;
+}
+
+struct tunnel_db_element_release_ctx {
+ struct rte_flow_item *items;
+ struct rte_flow_action *actions;
+ uint32_t num_elements;
+ struct rte_flow_error *error;
+ int ret;
+};
+
+static bool
+tunnel_element_release_match(struct rte_eth_dev *dev,
+ struct mlx5_flow_tunnel *tunnel, const void *x)
+{
+ const struct tunnel_db_element_release_ctx *ctx = x;
+
+ RTE_SET_USED(dev);
+ if (ctx->num_elements != 1)
+ return false;
+ else if (ctx->items)
+ return ctx->items == &tunnel->item;
+ else if (ctx->actions)
+ return ctx->actions == &tunnel->action;
+
+ return false;
+}
+
+static void
+tunnel_element_release_hit(struct rte_eth_dev *dev,
+ struct mlx5_flow_tunnel *tunnel, void *x)
+{
+ struct tunnel_db_element_release_ctx *ctx = x;
+ ctx->ret = 0;
+ if (!__atomic_sub_fetch(&tunnel->refctn, 1, __ATOMIC_RELAXED))
+ mlx5_flow_tunnel_free(dev, tunnel);
+}
+
+static void
+tunnel_element_release_miss(struct rte_eth_dev *dev, void *x)
+{
+ struct tunnel_db_element_release_ctx *ctx = x;
+ RTE_SET_USED(dev);
+ ctx->ret = rte_flow_error_set(ctx->error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
+ "invalid argument");
+}
+
+static int
+mlx5_flow_tunnel_item_release(struct rte_eth_dev *dev,
+ struct rte_flow_item *pmd_items,
+ uint32_t num_items, struct rte_flow_error *err)
+{
+ struct tunnel_db_element_release_ctx ctx = {
+ .items = pmd_items,
+ .actions = NULL,
+ .num_elements = num_items,
+ .error = err,
+ };
+
+ mlx5_access_tunnel_offload_db(dev, tunnel_element_release_match,
+ tunnel_element_release_hit,
+ tunnel_element_release_miss, &ctx, false);
+
+ return ctx.ret;
+}
+
+static int
+mlx5_flow_tunnel_action_release(struct rte_eth_dev *dev,
+ struct rte_flow_action *pmd_actions,
+ uint32_t num_actions, struct rte_flow_error *err)
+{
+ struct tunnel_db_element_release_ctx ctx = {
+ .items = NULL,
+ .actions = pmd_actions,
+ .num_elements = num_actions,
+ .error = err,
+ };
+
+ mlx5_access_tunnel_offload_db(dev, tunnel_element_release_match,
+ tunnel_element_release_hit,
+ tunnel_element_release_miss, &ctx, false);
+
+ return ctx.ret;
+}
+
+static int
+mlx5_flow_tunnel_get_restore_info(struct rte_eth_dev *dev,
+ struct rte_mbuf *m,
+ struct rte_flow_restore_info *info,
+ struct rte_flow_error *err)
+{
+ uint64_t ol_flags = m->ol_flags;
+ const struct mlx5_flow_tbl_data_entry *tble;
+ const uint64_t mask = PKT_RX_FDIR | PKT_RX_FDIR_ID;
+
+ if (!is_tunnel_offload_active(dev)) {
+ info->flags = 0;
+ return 0;
+ }
+
+ if ((ol_flags & mask) != mask)
+ goto err;
+ tble = tunnel_mark_decode(dev, m->hash.fdir.hi);
+ if (!tble) {
+ DRV_LOG(DEBUG, "port %u invalid miss tunnel mark %#x",
+ dev->data->port_id, m->hash.fdir.hi);
+ goto err;
+ }
+ MLX5_ASSERT(tble->tunnel);
+ memcpy(&info->tunnel, &tble->tunnel->app_tunnel, sizeof(info->tunnel));
+ info->group_id = tble->group_id;
+ info->flags = RTE_FLOW_RESTORE_INFO_TUNNEL |
+ RTE_FLOW_RESTORE_INFO_GROUP_ID |
+ RTE_FLOW_RESTORE_INFO_ENCAPSULATED;
+
+ return 0;
+
+err:
+ return rte_flow_error_set(err, EINVAL,
+ RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
+ "failed to get restore info");
+}
+
+#else /* HAVE_IBV_FLOW_DV_SUPPORT */
+static int
+mlx5_flow_tunnel_decap_set(__rte_unused struct rte_eth_dev *dev,
+ __rte_unused struct rte_flow_tunnel *app_tunnel,
+ __rte_unused struct rte_flow_action **actions,
+ __rte_unused uint32_t *num_of_actions,
+ __rte_unused struct rte_flow_error *error)
+{
+ return -ENOTSUP;
+}
+
+static int
+mlx5_flow_tunnel_match(__rte_unused struct rte_eth_dev *dev,
+ __rte_unused struct rte_flow_tunnel *app_tunnel,
+ __rte_unused struct rte_flow_item **items,
+ __rte_unused uint32_t *num_of_items,
+ __rte_unused struct rte_flow_error *error)
+{
+ return -ENOTSUP;
+}
+
+static int
+mlx5_flow_tunnel_item_release(__rte_unused struct rte_eth_dev *dev,
+ __rte_unused struct rte_flow_item *pmd_items,
+ __rte_unused uint32_t num_items,
+ __rte_unused struct rte_flow_error *err)
+{
+ return -ENOTSUP;
+}
+
+static int
+mlx5_flow_tunnel_action_release(__rte_unused struct rte_eth_dev *dev,
+ __rte_unused struct rte_flow_action *pmd_action,
+ __rte_unused uint32_t num_actions,
+ __rte_unused struct rte_flow_error *err)
+{
+ return -ENOTSUP;
+}
+
+static int
+mlx5_flow_tunnel_get_restore_info(__rte_unused struct rte_eth_dev *dev,
+ __rte_unused struct rte_mbuf *m,
+ __rte_unused struct rte_flow_restore_info *i,
+ __rte_unused struct rte_flow_error *err)
+{
+ return -ENOTSUP;
+}
+
+static int
+flow_tunnel_add_default_miss(__rte_unused struct rte_eth_dev *dev,
+ __rte_unused struct rte_flow *flow,
+ __rte_unused const struct rte_flow_attr *attr,
+ __rte_unused const struct rte_flow_action *actions,
+ __rte_unused uint32_t flow_idx,
+ __rte_unused struct tunnel_default_miss_ctx *ctx,
+ __rte_unused struct rte_flow_error *error)
+{
+ return -ENOTSUP;
+}
+
+static struct mlx5_flow_tunnel *
+mlx5_find_tunnel_id(__rte_unused struct rte_eth_dev *dev,
+ __rte_unused uint32_t id)
+{
+ return NULL;
+}
+
+static void
+mlx5_flow_tunnel_free(__rte_unused struct rte_eth_dev *dev,
+ __rte_unused struct mlx5_flow_tunnel *tunnel)
+{
+}
+
+static uint32_t
+tunnel_flow_group_to_flow_table(__rte_unused struct rte_eth_dev *dev,
+ __rte_unused const struct mlx5_flow_tunnel *t,
+ __rte_unused uint32_t group,
+ __rte_unused uint32_t *table,
+ struct rte_flow_error *error)
+{
+ return rte_flow_error_set(error, ENOTSUP,
+ RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
+ "tunnel offload requires DV support");
+}
+
+void
+mlx5_release_tunnel_hub(__rte_unused struct mlx5_dev_ctx_shared *sh,
+ __rte_unused uint16_t port_id)
+{
+}
+#endif /* HAVE_IBV_FLOW_DV_SUPPORT */
+