net/mlx5: move rdma-core calls to separate file

[dpdk.git] / drivers / net / mlx5 / mlx5_flow.c

diff --git a/drivers/net/mlx5/mlx5_flow.c b/drivers/net/mlx5/mlx5_flow.c
index 6b3198a..800ec9f 100644 (file)
--- a/drivers/net/mlx5/mlx5_flow.c
+++ b/drivers/net/mlx5/mlx5_flow.c
@@ -53,6 +53,7 @@
 #include "mlx5.h"
 #include "mlx5_defs.h"
 #include "mlx5_prm.h"
+#include "mlx5_glue.h"
 
 /* Define minimal priority for control plane flows. */
 #define MLX5_CTRL_FLOW_PRIORITY 4
@@ -62,22 +63,9 @@
 #define MLX5_IPV6 6
 
 #ifndef HAVE_IBV_DEVICE_COUNTERS_SET_SUPPORT
-struct ibv_counter_set_init_attr {
-       int dummy;
-};
 struct ibv_flow_spec_counter_action {
        int dummy;
 };
-struct ibv_counter_set {
-       int dummy;
-};
-
-static inline int
-ibv_destroy_counter_set(struct ibv_counter_set *cs)
-{
-       (void)cs;
-       return -ENOTSUP;
-}
 #endif
 
 /* Dev ops structure defined in mlx5.c */
@@ -353,6 +341,7 @@ static const struct mlx5_flow_items mlx5_flow_items[] = {
                                .dst_addr = -1,
                                .type_of_service = -1,
                                .next_proto_id = -1,
+                               .time_to_live = -1,
                        },
                },
                .default_mask = &rte_flow_item_ipv4_mask,
@@ -529,7 +518,7 @@ mlx5_flow_item_validate(const struct rte_flow_item *item,
        }
        if (item->mask) {
                unsigned int i;
-               const uint8_t *spec = item->mask;
+               const uint8_t *spec = item->spec;
 
                for (i = 0; i < size; ++i)
                        if ((spec[i] | mask[i]) != mask[i])
@@ -1648,7 +1637,7 @@ mlx5_flow_create_count(struct priv *priv __rte_unused,
        };
 
        init_attr.counter_set_id = 0;
-       parser->cs = ibv_create_counter_set(priv->ctx, &init_attr);
+       parser->cs = mlx5_glue->create_counter_set(priv->ctx, &init_attr);
        if (!parser->cs)
                return EINVAL;
        counter.counter_set_handle = parser->cs->handle;
@@ -1701,8 +1690,8 @@ priv_flow_create_action_queue_drop(struct priv *priv,
                return 0;
        parser->queue[HASH_RXQ_ETH].ibv_attr = NULL;
        flow->frxq[HASH_RXQ_ETH].ibv_flow =
-               ibv_create_flow(priv->flow_drop_queue->qp,
-                               flow->frxq[HASH_RXQ_ETH].ibv_attr);
+               mlx5_glue->create_flow(priv->flow_drop_queue->qp,
+                                      flow->frxq[HASH_RXQ_ETH].ibv_attr);
        if (!flow->frxq[HASH_RXQ_ETH].ibv_flow) {
                rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE,
                                   NULL, "flow rule creation failure");
@@ -1713,7 +1702,8 @@ priv_flow_create_action_queue_drop(struct priv *priv,
 error:
        assert(flow);
        if (flow->frxq[HASH_RXQ_ETH].ibv_flow) {
-               claim_zero(ibv_destroy_flow(flow->frxq[HASH_RXQ_ETH].ibv_flow));
+               claim_zero(mlx5_glue->destroy_flow
+                          (flow->frxq[HASH_RXQ_ETH].ibv_flow));
                flow->frxq[HASH_RXQ_ETH].ibv_flow = NULL;
        }
        if (flow->frxq[HASH_RXQ_ETH].ibv_attr) {
@@ -1721,7 +1711,7 @@ error:
                flow->frxq[HASH_RXQ_ETH].ibv_attr = NULL;
        }
        if (flow->cs) {
-               claim_zero(ibv_destroy_counter_set(flow->cs));
+               claim_zero(mlx5_glue->destroy_counter_set(flow->cs));
                flow->cs = NULL;
                parser->cs = NULL;
        }
@@ -1825,8 +1815,8 @@ priv_flow_create_action_queue(struct priv *priv,
                if (!flow->frxq[i].hrxq)
                        continue;
                flow->frxq[i].ibv_flow =
-                       ibv_create_flow(flow->frxq[i].hrxq->qp,
-                                       flow->frxq[i].ibv_attr);
+                       mlx5_glue->create_flow(flow->frxq[i].hrxq->qp,
+                                              flow->frxq[i].ibv_attr);
                if (!flow->frxq[i].ibv_flow) {
                        rte_flow_error_set(error, ENOMEM,
                                           RTE_FLOW_ERROR_TYPE_HANDLE,
@@ -1852,7 +1842,7 @@ error:
                if (flow->frxq[i].ibv_flow) {
                        struct ibv_flow *ibv_flow = flow->frxq[i].ibv_flow;
 
-                       claim_zero(ibv_destroy_flow(ibv_flow));
+                       claim_zero(mlx5_glue->destroy_flow(ibv_flow));
                }
                if (flow->frxq[i].hrxq)
                        mlx5_priv_hrxq_release(priv, flow->frxq[i].hrxq);
@@ -1860,7 +1850,7 @@ error:
                        rte_free(flow->frxq[i].ibv_attr);
        }
        if (flow->cs) {
-               claim_zero(ibv_destroy_counter_set(flow->cs));
+               claim_zero(mlx5_glue->destroy_counter_set(flow->cs));
                flow->cs = NULL;
                parser->cs = NULL;
        }
@@ -2038,7 +2028,7 @@ priv_flow_destroy(struct priv *priv,
 free:
        if (flow->drop) {
                if (flow->frxq[HASH_RXQ_ETH].ibv_flow)
-                       claim_zero(ibv_destroy_flow
+                       claim_zero(mlx5_glue->destroy_flow
                                   (flow->frxq[HASH_RXQ_ETH].ibv_flow));
                rte_free(flow->frxq[HASH_RXQ_ETH].ibv_attr);
        } else {
@@ -2046,7 +2036,8 @@ free:
                        struct mlx5_flow *frxq = &flow->frxq[i];
 
                        if (frxq->ibv_flow)
-                               claim_zero(ibv_destroy_flow(frxq->ibv_flow));
+                               claim_zero(mlx5_glue->destroy_flow
+                                          (frxq->ibv_flow));
                        if (frxq->hrxq)
                                mlx5_priv_hrxq_release(priv, frxq->hrxq);
                        if (frxq->ibv_attr)
@@ -2054,7 +2045,7 @@ free:
                }
        }
        if (flow->cs) {
-               claim_zero(ibv_destroy_counter_set(flow->cs));
+               claim_zero(mlx5_glue->destroy_counter_set(flow->cs));
                flow->cs = NULL;
        }
        TAILQ_REMOVE(list, flow, next);
@@ -2102,35 +2093,38 @@ priv_flow_create_drop_queue(struct priv *priv)
                WARN("cannot allocate memory for drop queue");
                goto error;
        }
-       fdq->cq = ibv_create_cq(priv->ctx, 1, NULL, NULL, 0);
+       fdq->cq = mlx5_glue->create_cq(priv->ctx, 1, NULL, NULL, 0);
        if (!fdq->cq) {
                WARN("cannot allocate CQ for drop queue");
                goto error;
        }
-       fdq->wq = ibv_create_wq(priv->ctx,
-                       &(struct ibv_wq_init_attr){
+       fdq->wq = mlx5_glue->create_wq
+               (priv->ctx,
+                &(struct ibv_wq_init_attr){
                        .wq_type = IBV_WQT_RQ,
                        .max_wr = 1,
                        .max_sge = 1,
                        .pd = priv->pd,
                        .cq = fdq->cq,
-                       });
+                });
        if (!fdq->wq) {
                WARN("cannot allocate WQ for drop queue");
                goto error;
        }
-       fdq->ind_table = ibv_create_rwq_ind_table(priv->ctx,
-                       &(struct ibv_rwq_ind_table_init_attr){
+       fdq->ind_table = mlx5_glue->create_rwq_ind_table
+               (priv->ctx,
+                &(struct ibv_rwq_ind_table_init_attr){
                        .log_ind_tbl_size = 0,
                        .ind_tbl = &fdq->wq,
                        .comp_mask = 0,
-                       });
+                });
        if (!fdq->ind_table) {
                WARN("cannot allocate indirection table for drop queue");
                goto error;
        }
-       fdq->qp = ibv_create_qp_ex(priv->ctx,
-               &(struct ibv_qp_init_attr_ex){
+       fdq->qp = mlx5_glue->create_qp_ex
+               (priv->ctx,
+                &(struct ibv_qp_init_attr_ex){
                        .qp_type = IBV_QPT_RAW_PACKET,
                        .comp_mask =
                                IBV_QP_INIT_ATTR_PD |
@@ -2145,7 +2139,7 @@ priv_flow_create_drop_queue(struct priv *priv)
                                },
                        .rwq_ind_tbl = fdq->ind_table,
                        .pd = priv->pd
-               });
+                });
        if (!fdq->qp) {
                WARN("cannot allocate QP for drop queue");
                goto error;
@@ -2154,13 +2148,13 @@ priv_flow_create_drop_queue(struct priv *priv)
        return 0;
 error:
        if (fdq->qp)
-               claim_zero(ibv_destroy_qp(fdq->qp));
+               claim_zero(mlx5_glue->destroy_qp(fdq->qp));
        if (fdq->ind_table)
-               claim_zero(ibv_destroy_rwq_ind_table(fdq->ind_table));
+               claim_zero(mlx5_glue->destroy_rwq_ind_table(fdq->ind_table));
        if (fdq->wq)
-               claim_zero(ibv_destroy_wq(fdq->wq));
+               claim_zero(mlx5_glue->destroy_wq(fdq->wq));
        if (fdq->cq)
-               claim_zero(ibv_destroy_cq(fdq->cq));
+               claim_zero(mlx5_glue->destroy_cq(fdq->cq));
        if (fdq)
                rte_free(fdq);
        priv->flow_drop_queue = NULL;
@@ -2181,13 +2175,13 @@ priv_flow_delete_drop_queue(struct priv *priv)
        if (!fdq)
                return;
        if (fdq->qp)
-               claim_zero(ibv_destroy_qp(fdq->qp));
+               claim_zero(mlx5_glue->destroy_qp(fdq->qp));
        if (fdq->ind_table)
-               claim_zero(ibv_destroy_rwq_ind_table(fdq->ind_table));
+               claim_zero(mlx5_glue->destroy_rwq_ind_table(fdq->ind_table));
        if (fdq->wq)
-               claim_zero(ibv_destroy_wq(fdq->wq));
+               claim_zero(mlx5_glue->destroy_wq(fdq->wq));
        if (fdq->cq)
-               claim_zero(ibv_destroy_cq(fdq->cq));
+               claim_zero(mlx5_glue->destroy_cq(fdq->cq));
        rte_free(fdq);
        priv->flow_drop_queue = NULL;
 }
@@ -2211,7 +2205,7 @@ priv_flow_stop(struct priv *priv, struct mlx5_flows *list)
                if (flow->drop) {
                        if (!flow->frxq[HASH_RXQ_ETH].ibv_flow)
                                continue;
-                       claim_zero(ibv_destroy_flow
+                       claim_zero(mlx5_glue->destroy_flow
                                   (flow->frxq[HASH_RXQ_ETH].ibv_flow));
                        flow->frxq[HASH_RXQ_ETH].ibv_flow = NULL;
                        /* Next flow. */
@@ -2232,7 +2226,8 @@ priv_flow_stop(struct priv *priv, struct mlx5_flows *list)
                for (i = 0; i != hash_rxq_init_n; ++i) {
                        if (!flow->frxq[i].ibv_flow)
                                continue;
-                       claim_zero(ibv_destroy_flow(flow->frxq[i].ibv_flow));
+                       claim_zero(mlx5_glue->destroy_flow
+                                  (flow->frxq[i].ibv_flow));
                        flow->frxq[i].ibv_flow = NULL;
                        mlx5_priv_hrxq_release(priv, flow->frxq[i].hrxq);
                        flow->frxq[i].hrxq = NULL;
@@ -2262,7 +2257,7 @@ priv_flow_start(struct priv *priv, struct mlx5_flows *list)
 
                if (flow->drop) {
                        flow->frxq[HASH_RXQ_ETH].ibv_flow =
-                               ibv_create_flow
+                               mlx5_glue->create_flow
                                (priv->flow_drop_queue->qp,
                                 flow->frxq[HASH_RXQ_ETH].ibv_attr);
                        if (!flow->frxq[HASH_RXQ_ETH].ibv_flow) {
@@ -2300,8 +2295,8 @@ priv_flow_start(struct priv *priv, struct mlx5_flows *list)
                        }
 flow_create:
                        flow->frxq[i].ibv_flow =
-                               ibv_create_flow(flow->frxq[i].hrxq->qp,
-                                               flow->frxq[i].ibv_attr);
+                               mlx5_glue->create_flow(flow->frxq[i].hrxq->qp,
+                                                      flow->frxq[i].ibv_attr);
                        if (!flow->frxq[i].ibv_flow) {
                                DEBUG("Flow %p cannot be applied",
                                      (void *)flow);
@@ -2508,7 +2503,7 @@ priv_flow_query_count(struct ibv_counter_set *cs,
                .out = counters,
                .outlen = 2 * sizeof(uint64_t),
        };
-       int res = ibv_query_counter_set(&query_cs_attr, &query_out);
+       int res = mlx5_glue->query_counter_set(&query_cs_attr, &query_out);
 
        if (res) {
                rte_flow_error_set(error, -res,