From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mellanox.co.il (mail-il-dmz.mellanox.com [193.47.165.129]) by dpdk.org (Postfix) with ESMTP id 5627744BE for ; Sun, 7 Oct 2018 16:27:17 +0200 (CEST) Received: from Internal Mail-Server by MTLPINE1 (envelope-from dekelp@mellanox.com) with ESMTPS (AES256-SHA encrypted); 7 Oct 2018 16:32:00 +0200 Received: from mtl-vdi-280.wap.labs.mlnx. (mtl-vdi-280.wap.labs.mlnx [10.128.130.87]) by labmailer.mlnx (8.13.8/8.13.8) with ESMTP id w97ER1DK031642; Sun, 7 Oct 2018 17:27:13 +0300 From: Dekel Peled To: yskoh@mellanox.com, shahafs@mellanox.com Cc: dev@dpdk.org, orika@mellanox.com Date: Sun, 7 Oct 2018 17:25:08 +0300 Message-Id: <1538922308-9516-5-git-send-email-dekelp@mellanox.com> X-Mailer: git-send-email 1.7.1 In-Reply-To: <1538059845-35896-1-git-send-email-dekelp@mellanox.com> References: <1538059845-35896-1-git-send-email-dekelp@mellanox.com> Subject: [dpdk-dev] [PATCH v2 4/4] net/mlx5: add L2 and L3 decap to Direct Verbs flow X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sun, 07 Oct 2018 14:27:17 -0000 This patch adds support for Direct Verbs decap operations, L2 and L3. Signed-off-by: Dekel Peled Conflicts: drivers/net/mlx5/mlx5_flow_dv.c --- drivers/net/mlx5/mlx5_flow_dv.c | 224 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 219 insertions(+), 5 deletions(-) diff --git a/drivers/net/mlx5/mlx5_flow_dv.c b/drivers/net/mlx5/mlx5_flow_dv.c index 221c76a..5b44f5b 100644 --- a/drivers/net/mlx5/mlx5_flow_dv.c +++ b/drivers/net/mlx5/mlx5_flow_dv.c @@ -120,11 +120,18 @@ RTE_FLOW_ERROR_TYPE_ACTION, NULL, "can't have 2 encap actions in same" " flow"); + if (action_flags & (MLX5_FLOW_ACTION_TUNNEL_DECAP | + MLX5_FLOW_ACTION_TUNNEL_DECAP_L3)) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, NULL, + "can't encap and decap in same" + " flow"); if (attr->ingress) return rte_flow_error_set(error, ENOTSUP, - RTE_FLOW_ERROR_TYPE_ATTR_INGRESS, NULL, - "encap action not supported for " - "ingress"); + RTE_FLOW_ERROR_TYPE_ATTR_INGRESS, + NULL, + "encap action not supported for " + "ingress"); return 0; } @@ -166,6 +173,12 @@ RTE_FLOW_ERROR_TYPE_ACTION, NULL, "can't have 2 encap actions in same" " flow"); + if (action_flags & (MLX5_FLOW_ACTION_TUNNEL_DECAP | + MLX5_FLOW_ACTION_TUNNEL_DECAP_L3)) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, NULL, + "can't encap and decap in same" + " flow"); if (attr->ingress) return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ATTR_INGRESS, @@ -176,6 +189,100 @@ } /** + * Validate the tunnel decap action + * + * @param[in] action_flags + * holds the actions detected until now. + * @param[in] attr + * Pointer to flow attributes + * @param[out] error + * Pointer to error structure. + * + * @return + * 0 on success, a negative errno value otherwise and rte_ernno is set. + */ +static int +flow_dv_validate_action_tunnel_decap(uint64_t action_flags, + const struct rte_flow_attr *attr, + struct rte_flow_error *error) +{ + if (action_flags & MLX5_FLOW_ACTION_DROP) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, NULL, + "can't drop and decap in same flow"); + if (action_flags & (MLX5_FLOW_ACTION_TUNNEL_DECAP | + MLX5_FLOW_ACTION_TUNNEL_DECAP_L3)) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, NULL, + "can't have 2 decap actions in same" + " flow"); + if (action_flags & (MLX5_FLOW_ACTION_TUNNEL_ENCAP | + MLX5_FLOW_ACTION_TUNNEL_ENCAP_L3)) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, NULL, + "can't encap and decap in same" + " flow"); + if (attr->egress) + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ATTR_EGRESS, NULL, + "decap action not supported for " + "egress"); + return 0; +} + +/** + * Validate the tunnel decap L3 action + * + * @param[in] action_flags + * holds the actions detected until now. + * @param[in] action + * Pointer to the decap action. + * @param[in] attr + * Pointer to flow attributes + * @param[out] error + * Pointer to error structure. + * + * @return + * 0 on success, a negative errno value otherwise and rte_ernno is set. + */ +static int +flow_dv_validate_action_tunnel_decap_l3(uint64_t action_flags, + const struct rte_flow_action *action, + const struct rte_flow_attr *attr, + struct rte_flow_error *error) +{ + const struct rte_flow_action_tunnel_decap_l3 *tunnel_decap_l3 = + action->conf; + + if (!tunnel_decap_l3 || !(tunnel_decap_l3->buf)) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, action, + "configuration cannot be null"); + if (action_flags & MLX5_FLOW_ACTION_DROP) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, NULL, + "can't drop and decap in same flow"); + if (action_flags & (MLX5_FLOW_ACTION_TUNNEL_DECAP | + MLX5_FLOW_ACTION_TUNNEL_DECAP_L3)) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, NULL, + "can't have 2 decap actions in same" + " flow"); + if (action_flags & (MLX5_FLOW_ACTION_TUNNEL_ENCAP | + MLX5_FLOW_ACTION_TUNNEL_ENCAP_L3)) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, NULL, + "can't encap and decap in same" + " flow"); + if (attr->egress) + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ATTR_EGRESS, NULL, + "decap action not supported for " + "egress"); + return 0; +} + +/** * Convert encap action to DV specification. * * @param[in] action @@ -245,6 +352,72 @@ } /** + * Convert decap action to DV specification. + * + * @param[in] action + * Pointer to action structure. + * @param[in] dev + * Pointer to rte_eth_dev structure. + * @param[out] error + * Pointer to the error structure. + * + * @return + * Pointer to action on success, NULL otherwise and rte_errno is set. + */ +static struct ibv_flow_action * +flow_dv_create_decap(const struct rte_flow_action *action __rte_unused, + struct rte_eth_dev *dev, + struct rte_flow_error *error) +{ + struct ibv_flow_action *decap_verb = NULL; + struct priv *priv = dev->data->dev_private; + + decap_verb = mlx5_glue->dv_create_flow_action_packet_reformat + (priv->ctx, 0, NULL, + MLX5DV_FLOW_ACTION_PACKET_REFORMAT_TYPE_L2_TUNNEL_TO_L2, + MLX5DV_FLOW_TABLE_TYPE_NIC_RX); + if (!decap_verb) + rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION, + NULL, "cannot create decap action"); + return decap_verb; +} + +/** + * Convert decap L3 action to DV specification. + * + * @param[in] action + * Pointer to action structure. + * @param[in] dev + * Pointer to rte_eth_dev structure. + * @param[out] error + * Pointer to the error structure. + * + * @return + * Pointer to action on success, NULL otherwise and rte_errno is set. + */ +static struct ibv_flow_action * +flow_dv_create_decap_l3(const struct rte_flow_action *action, + struct rte_eth_dev *dev, + struct rte_flow_error *error) +{ + struct ibv_flow_action *decap_l3_verb = NULL; + const struct rte_flow_action_tunnel_decap_l3 *decap_l3_data; + struct priv *priv = dev->data->dev_private; + + decap_l3_data = + (const struct rte_flow_action_tunnel_decap_l3 *)action->conf; + decap_l3_verb = mlx5_glue->dv_create_flow_action_packet_reformat + (priv->ctx, decap_l3_data->size, + decap_l3_data->size ? decap_l3_data->buf : NULL, + MLX5DV_FLOW_ACTION_PACKET_REFORMAT_TYPE_L3_TUNNEL_TO_L2, + MLX5DV_FLOW_TABLE_TYPE_NIC_RX); + if (!decap_l3_verb) + rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION, + NULL, "cannot create decap L3 action"); + return decap_l3_verb; +} + +/** * Verify the @p attributes will be correctly understood by the NIC and store * them in the @p flow if everything is correct. * @@ -505,6 +678,20 @@ return ret; action_flags |= MLX5_FLOW_ACTION_TUNNEL_ENCAP_L3; break; + case RTE_FLOW_ACTION_TYPE_TUNNEL_DECAP: + ret = flow_dv_validate_action_tunnel_decap + (action_flags, attr, error); + if (ret < 0) + return ret; + action_flags |= MLX5_FLOW_ACTION_TUNNEL_DECAP; + break; + case RTE_FLOW_ACTION_TYPE_TUNNEL_DECAP_L3: + ret = flow_dv_validate_action_tunnel_decap_l3 + (action_flags, actions, attr, error); + if (ret < 0) + return ret; + action_flags |= MLX5_FLOW_ACTION_TUNNEL_DECAP_L3; + break; default: return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, @@ -1300,6 +1487,30 @@ flow->actions |= MLX5_FLOW_ACTION_TUNNEL_ENCAP_L3; actions_n++; break; + case RTE_FLOW_ACTION_TYPE_TUNNEL_DECAP: + dev_flow->dv.actions[actions_n].type = + MLX5DV_FLOW_ACTION_IBV_FLOW_ACTION; + dev_flow->dv.actions[actions_n].action = + flow_dv_create_decap(action, dev, error); + if (!(dev_flow->dv.actions[actions_n].action)) + return -rte_errno; + dev_flow->dv.decap_verb = + dev_flow->dv.actions[actions_n].action; + flow->actions |= MLX5_FLOW_ACTION_TUNNEL_DECAP; + actions_n++; + break; + case RTE_FLOW_ACTION_TYPE_TUNNEL_DECAP_L3: + dev_flow->dv.actions[actions_n].type = + MLX5DV_FLOW_ACTION_IBV_FLOW_ACTION; + dev_flow->dv.actions[actions_n].action = + flow_dv_create_decap_l3(action, dev, error); + if (!(dev_flow->dv.actions[actions_n].action)) + return -rte_errno; + dev_flow->dv.decap_verb = + dev_flow->dv.actions[actions_n].action; + flow->actions |= MLX5_FLOW_ACTION_TUNNEL_DECAP_L3; + actions_n++; + break; default: break; } @@ -1655,13 +1866,16 @@ LIST_REMOVE(dev_flow, next); if (dev_flow->dv.matcher) flow_dv_matcher_release(dev, dev_flow->dv.matcher); - if (dev_flow->dv.encap_verb) { claim_zero(mlx5_glue->destroy_flow_action (dev_flow->dv.encap_verb)); dev_flow->dv.encap_verb = NULL; } - + if (dev_flow->dv.decap_verb) { + claim_zero(mlx5_glue->destroy_flow_action + (dev_flow->dv.decap_verb)); + dev_flow->dv.decap_verb = NULL; + } rte_free(dev_flow); } } -- 1.8.3.1