net/mlx5: link status update separation
[dpdk.git] / drivers / net / mlx5 / mlx5_flow.c
index 8b3957b..7dd3ebb 100644 (file)
@@ -52,9 +52,6 @@
 #include "mlx5.h"
 #include "mlx5_prm.h"
 
-/* Number of Work Queue necessary for the DROP queue. */
-#define MLX5_DROP_WQ_N 4
-
 static int
 mlx5_flow_create_eth(const struct rte_flow_item *item,
                     const void *default_mask,
@@ -286,7 +283,7 @@ struct mlx5_flow {
 struct rte_flow_drop {
        struct ibv_exp_rwq_ind_table *ind_table; /**< Indirection table. */
        struct ibv_qp *qp; /**< Verbs queue pair. */
-       struct ibv_exp_wq *wqs[MLX5_DROP_WQ_N]; /**< Verbs work queue. */
+       struct ibv_exp_wq *wq; /**< Verbs work queue. */
        struct ibv_cq *cq; /**< Verbs completion queue. */
 };
 
@@ -576,6 +573,8 @@ priv_flow_validate(struct priv *priv,
        }
        if (action->mark && !flow->ibv_attr && !action->drop)
                flow->offset += sizeof(struct ibv_exp_flow_spec_action_tag);
+       if (!flow->ibv_attr && action->drop)
+               flow->offset += sizeof(struct ibv_exp_flow_spec_action_drop);
        if (!action->queue && !action->drop) {
                rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_HANDLE,
                                   NULL, "no valid action");
@@ -993,6 +992,8 @@ priv_flow_create_action_queue_drop(struct priv *priv,
                                   struct rte_flow_error *error)
 {
        struct rte_flow *rte_flow;
+       struct ibv_exp_flow_spec_action_drop *drop;
+       unsigned int size = sizeof(struct ibv_exp_flow_spec_action_drop);
 
        assert(priv->pd);
        assert(priv->ctx);
@@ -1003,10 +1004,17 @@ priv_flow_create_action_queue_drop(struct priv *priv,
                return NULL;
        }
        rte_flow->drop = 1;
+       drop = (void *)((uintptr_t)flow->ibv_attr + flow->offset);
+       *drop = (struct ibv_exp_flow_spec_action_drop){
+                       .type = IBV_EXP_FLOW_SPEC_ACTION_DROP,
+                       .size = size,
+       };
+       ++flow->ibv_attr->num_of_specs;
+       flow->offset += sizeof(struct ibv_exp_flow_spec_action_drop);
        rte_flow->ibv_attr = flow->ibv_attr;
-       rte_flow->qp = priv->flow_drop_queue->qp;
        if (!priv->started)
                return rte_flow;
+       rte_flow->qp = priv->flow_drop_queue->qp;
        rte_flow->ibv_flow = ibv_exp_create_flow(rte_flow->qp,
                                                 rte_flow->ibv_attr);
        if (!rte_flow->ibv_flow) {
@@ -1258,10 +1266,6 @@ priv_flow_destroy(struct priv *priv,
                claim_zero(ibv_destroy_qp(flow->qp));
        if (flow->ind_table)
                claim_zero(ibv_exp_destroy_rwq_ind_table(flow->ind_table));
-       if (flow->drop && flow->wq)
-               claim_zero(ibv_exp_destroy_wq(flow->wq));
-       if (flow->drop && flow->cq)
-               claim_zero(ibv_destroy_cq(flow->cq));
        if (flow->mark) {
                struct rte_flow *tmp;
                struct rxq *rxq;
@@ -1369,7 +1373,6 @@ static int
 priv_flow_create_drop_queue(struct priv *priv)
 {
        struct rte_flow_drop *fdq = NULL;
-       unsigned int i;
 
        assert(priv->pd);
        assert(priv->ctx);
@@ -1386,25 +1389,23 @@ priv_flow_create_drop_queue(struct priv *priv)
                WARN("cannot allocate CQ for drop queue");
                goto error;
        }
-       for (i = 0; i != MLX5_DROP_WQ_N; ++i) {
-               fdq->wqs[i] = ibv_exp_create_wq(priv->ctx,
-                               &(struct ibv_exp_wq_init_attr){
-                               .wq_type = IBV_EXP_WQT_RQ,
-                               .max_recv_wr = 1,
-                               .max_recv_sge = 1,
-                               .pd = priv->pd,
-                               .cq = fdq->cq,
-                               });
-               if (!fdq->wqs[i]) {
-                       WARN("cannot allocate WQ for drop queue");
-                       goto error;
-               }
+       fdq->wq = ibv_exp_create_wq(priv->ctx,
+                       &(struct ibv_exp_wq_init_attr){
+                       .wq_type = IBV_EXP_WQT_RQ,
+                       .max_recv_wr = 1,
+                       .max_recv_sge = 1,
+                       .pd = priv->pd,
+                       .cq = fdq->cq,
+                       });
+       if (!fdq->wq) {
+               WARN("cannot allocate WQ for drop queue");
+               goto error;
        }
        fdq->ind_table = ibv_exp_create_rwq_ind_table(priv->ctx,
                        &(struct ibv_exp_rwq_ind_table_init_attr){
                        .pd = priv->pd,
                        .log_ind_tbl_size = 0,
-                       .ind_tbl = fdq->wqs,
+                       .ind_tbl = &fdq->wq,
                        .comp_mask = 0,
                        });
        if (!fdq->ind_table) {
@@ -1440,10 +1441,8 @@ error:
                claim_zero(ibv_destroy_qp(fdq->qp));
        if (fdq->ind_table)
                claim_zero(ibv_exp_destroy_rwq_ind_table(fdq->ind_table));
-       for (i = 0; i != MLX5_DROP_WQ_N; ++i) {
-               if (fdq->wqs[i])
-                       claim_zero(ibv_exp_destroy_wq(fdq->wqs[i]));
-       }
+       if (fdq->wq)
+               claim_zero(ibv_exp_destroy_wq(fdq->wq));
        if (fdq->cq)
                claim_zero(ibv_destroy_cq(fdq->cq));
        if (fdq)
@@ -1462,7 +1461,6 @@ static void
 priv_flow_delete_drop_queue(struct priv *priv)
 {
        struct rte_flow_drop *fdq = priv->flow_drop_queue;
-       unsigned int i;
 
        if (!fdq)
                return;
@@ -1470,10 +1468,8 @@ priv_flow_delete_drop_queue(struct priv *priv)
                claim_zero(ibv_destroy_qp(fdq->qp));
        if (fdq->ind_table)
                claim_zero(ibv_exp_destroy_rwq_ind_table(fdq->ind_table));
-       for (i = 0; i != MLX5_DROP_WQ_N; ++i) {
-               if (fdq->wqs[i])
-                       claim_zero(ibv_exp_destroy_wq(fdq->wqs[i]));
-       }
+       if (fdq->wq)
+               claim_zero(ibv_exp_destroy_wq(fdq->wq));
        if (fdq->cq)
                claim_zero(ibv_destroy_cq(fdq->cq));
        rte_free(fdq);
@@ -1579,3 +1575,30 @@ priv_flow_rxq_in_use(struct priv *priv, struct rxq *rxq)
        }
        return 0;
 }
+
+/**
+ * Isolated mode.
+ *
+ * @see rte_flow_isolate()
+ * @see rte_flow_ops
+ */
+int
+mlx5_flow_isolate(struct rte_eth_dev *dev,
+                 int enable,
+                 struct rte_flow_error *error)
+{
+       struct priv *priv = dev->data->dev_private;
+
+       priv_lock(priv);
+       if (priv->started) {
+               rte_flow_error_set(error, EBUSY,
+                                  RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
+                                  NULL,
+                                  "port must be stopped first");
+               priv_unlock(priv);
+               return -rte_errno;
+       }
+       priv->isolated = !!enable;
+       priv_unlock(priv);
+       return 0;
+}