rdma: add Mellanox mlx5 Direct Verbs receive support

Type: feature
Change-Id: I3f287ab536a482c366ad7df47e1c04e640992ebc
Signed-off-by: Damjan Marion <damarion@cisco.com>

1 files changed, 352 insertions, 27 deletions

diff --git a/src/plugins/rdma/input.c b/src/plugins/rdma/input.c
index f4ef6505a0f..cf0b6bffe7d 100644
--- a/src/plugins/rdma/input.c
+++ b/src/plugins/rdma/input.c
@@ -55,7 +55,7 @@ ibv_set_recv_wr_and_sge (struct ibv_recv_wr *w, struct ibv_sge *s, u64 va,
 
 static_always_inline void
 rdma_device_input_refill (vlib_main_t * vm, rdma_device_t * rd,
-			  rdma_rxq_t * rxq)
+			  rdma_rxq_t * rxq, int is_mlx5dv)
 {
   u32 n_alloc, n;
   struct ibv_recv_wr wr[VLIB_FRAME_SIZE], *w = wr;
@@ -101,6 +101,41 @@ rdma_device_input_refill (vlib_main_t * vm, rdma_device_t * rd,
 
   n_alloc = n;
 
+  if (is_mlx5dv)
+    {
+      u64 va[8];
+      mlx5dv_rwq_t *wqe = rxq->wqes + slot;
+
+      while (n >= 1)
+	{
+	  vlib_get_buffers_with_offset (vm, rxq->bufs + slot, (void **) va, 8,
+					sizeof (vlib_buffer_t));
+#ifdef CLIB_HAVE_VEC256
+	  *(u64x4 *) va = u64x4_byte_swap (*(u64x4 *) va);
+	  *(u64x4 *) (va + 4) = u64x4_byte_swap (*(u64x4 *) (va + 4));
+#else
+	  for (int i = 0; i < 8; i++)
+	    va[i] = clib_host_to_net_u64 (va[i]);
+#endif
+	  wqe[0].addr = va[0];
+	  wqe[1].addr = va[1];
+	  wqe[2].addr = va[2];
+	  wqe[3].addr = va[3];
+	  wqe[4].addr = va[4];
+	  wqe[5].addr = va[5];
+	  wqe[6].addr = va[6];
+	  wqe[7].addr = va[7];
+	  wqe += 8;
+	  slot += 8;
+	  n -= 8;
+	}
+
+      CLIB_MEMORY_STORE_BARRIER ();
+      rxq->tail += n_alloc;
+      rxq->wq_db[MLX5_RCV_DBR] = clib_host_to_net_u32 (rxq->tail);
+      return;
+    }
+
   while (n >= 8)
     {
       u64 va[8];
@@ -142,7 +177,7 @@ rdma_device_input_refill (vlib_main_t * vm, rdma_device_t * rd,
 static_always_inline void
 rdma_device_input_trace (vlib_main_t * vm, vlib_node_runtime_t * node,
 			 const rdma_device_t * rd, u32 n_left, const u32 * bi,
-			 u32 next_index)
+			 u32 next_index, u16 * cqe_flags, int is_mlx5dv)
 {
   u32 n_trace, i;
 
@@ -160,10 +195,12 @@ rdma_device_input_trace (vlib_main_t * vm, vlib_node_runtime_t * node,
       tr = vlib_add_trace (vm, node, b, sizeof (*tr));
       tr->next_index = next_index;
       tr->hw_if_index = rd->hw_if_index;
+      tr->cqe_flags = is_mlx5dv ? clib_net_to_host_u16 (cqe_flags[0]) : 0;
 
       /* next */
       n_trace--;
       n_left--;
+      cqe_flags++;
       bi++;
       i++;
     }
@@ -172,7 +209,8 @@ rdma_device_input_trace (vlib_main_t * vm, vlib_node_runtime_t * node,
 
 static_always_inline void
 rdma_device_input_ethernet (vlib_main_t * vm, vlib_node_runtime_t * node,
-			    const rdma_device_t * rd, u32 next_index)
+			    const rdma_device_t * rd, u32 next_index,
+			    int skip_ip4_cksum)
 {
   vlib_next_frame_t *nf;
   vlib_frame_t *f;
@@ -186,7 +224,8 @@ rdma_device_input_ethernet (vlib_main_t * vm, vlib_node_runtime_t * node,
 				      VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT);
   f = vlib_get_frame (vm, nf->frame);
   f->flags = ETH_INPUT_FRAME_F_SINGLE_SW_IF_IDX;
-  /* FIXME: f->flags |= ETH_INPUT_FRAME_F_IP4_CKSUM_OK; */
+  if (skip_ip4_cksum)
+    f->flags |= ETH_INPUT_FRAME_F_IP4_CKSUM_OK;
 
   ef = vlib_frame_scalar_args (f);
   ef->sw_if_index = rd->sw_if_index;
@@ -194,16 +233,12 @@ rdma_device_input_ethernet (vlib_main_t * vm, vlib_node_runtime_t * node,
 }
 
 static_always_inline u32
-rdma_device_input_bufs (vlib_main_t * vm, const rdma_device_t * rd, u32 * bi,
-			struct ibv_wc * wc, u32 n_left_from,
-			vlib_buffer_t * bt)
+rdma_device_input_bufs (vlib_main_t * vm, const rdma_device_t * rd,
+			vlib_buffer_t ** b, struct ibv_wc *wc,
+			u32 n_left_from, vlib_buffer_t * bt)
 {
-  vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
   u32 n_rx_bytes = 0;
 
-  vlib_get_buffers (vm, bi, bufs, n_left_from);
-  ASSERT (bt->buffer_pool_index == bufs[0]->buffer_pool_index);
-
   while (n_left_from >= 4)
     {
       if (PREDICT_TRUE (n_left_from >= 8))
@@ -246,26 +281,224 @@ rdma_device_input_bufs (vlib_main_t * vm, const rdma_device_t * rd, u32 * bi,
   return n_rx_bytes;
 }
 
+static_always_inline void
+process_mini_cqes (rdma_rxq_t * rxq, u32 skip, u32 n_left, u32 cq_ci,
+		   u32 mask, u32 * byte_cnt)
+{
+  mlx5dv_mini_cqe_t *mcqe;
+  u32 mcqe_array_index = (cq_ci + 1) & mask;
+  mcqe = (mlx5dv_mini_cqe_t *) (rxq->cqes + mcqe_array_index);
+
+  mcqe_array_index = cq_ci;
+
+  if (skip)
+    {
+      u32 n = skip & ~7;
+
+      if (n)
+	{
+	  mcqe_array_index = (mcqe_array_index + n) & mask;
+	  mcqe = (mlx5dv_mini_cqe_t *) (rxq->cqes + mcqe_array_index);
+	  skip -= n;
+	}
+
+      if (skip)
+	{
+	  n = clib_min (8 - skip, n_left);
+	  for (int i = 0; i < n; i++)
+	    byte_cnt[i] = mcqe[skip + i].byte_count;
+	  mcqe_array_index = (mcqe_array_index + 8) & mask;
+	  mcqe = (mlx5dv_mini_cqe_t *) (rxq->cqes + mcqe_array_index);
+	  n_left -= n;
+	  byte_cnt += n;
+	}
+
+    }
+
+  while (n_left >= 8)
+    {
+      for (int i = 0; i < 8; i++)
+	byte_cnt[i] = mcqe[i].byte_count;
+
+      n_left -= 8;
+      byte_cnt += 8;
+      mcqe_array_index = (mcqe_array_index + 8) & mask;
+      mcqe = (mlx5dv_mini_cqe_t *) (rxq->cqes + mcqe_array_index);
+    }
+
+  if (n_left)
+    {
+      for (int i = 0; i < n_left; i++)
+	byte_cnt[i] = mcqe[i].byte_count;
+    }
+}
+
+static_always_inline void
+cqe_set_owner (mlx5dv_cqe_t * cqe, u32 n_left, u8 owner)
+{
+  while (n_left >= 8)
+    {
+      cqe[0].opcode_cqefmt_se_owner = owner;
+      cqe[1].opcode_cqefmt_se_owner = owner;
+      cqe[2].opcode_cqefmt_se_owner = owner;
+      cqe[3].opcode_cqefmt_se_owner = owner;
+      cqe[4].opcode_cqefmt_se_owner = owner;
+      cqe[5].opcode_cqefmt_se_owner = owner;
+      cqe[6].opcode_cqefmt_se_owner = owner;
+      cqe[7].opcode_cqefmt_se_owner = owner;
+      n_left -= 8;
+      cqe += 8;
+    }
+  while (n_left)
+    {
+      cqe[0].opcode_cqefmt_se_owner = owner;
+      n_left--;
+      cqe++;
+    }
+}
+
+static_always_inline void
+compressed_cqe_reset_owner (rdma_rxq_t * rxq, u32 n_mini_cqes, u32 cq_ci,
+			    u32 mask, u32 log2_cq_size)
+{
+  u8 owner;
+  u32 offset, cq_size = 1 << log2_cq_size;
+
+
+  /* first CQE is reset by hardware */
+  cq_ci++;
+  n_mini_cqes--;
+
+  offset = cq_ci & mask;
+  owner = 0xf0 | ((cq_ci >> log2_cq_size) & 1);
+
+  if (offset + n_mini_cqes < cq_size)
+    {
+      cqe_set_owner (rxq->cqes + offset, n_mini_cqes, owner);
+    }
+  else
+    {
+      u32 n = cq_size - offset;
+      cqe_set_owner (rxq->cqes + offset, n, owner);
+      cqe_set_owner (rxq->cqes, n_mini_cqes - n, owner ^ 1);
+    }
+
+}
+
+static_always_inline uword
+rdma_device_poll_cq_mlx5dv (rdma_device_t * rd, rdma_rxq_t * rxq,
+			    u32 * byte_cnt, u16 * cqe_flags)
+{
+  u32 n_rx_packets = 0;
+  u32 log2_cq_size = rxq->log2_cq_size;
+  u32 mask = pow2_mask (log2_cq_size);
+  u32 cq_ci = rxq->cq_ci;
+
+  if (rxq->n_mini_cqes_left)
+    {
+      /* partially processed mini-cqe array */
+      u32 n_mini_cqes = rxq->n_mini_cqes;
+      u32 n_mini_cqes_left = rxq->n_mini_cqes_left;
+      process_mini_cqes (rxq, n_mini_cqes - n_mini_cqes_left,
+			 n_mini_cqes_left, cq_ci, mask, byte_cnt);
+      compressed_cqe_reset_owner (rxq, n_mini_cqes, cq_ci, mask,
+				  log2_cq_size);
+      clib_memset_u16 (cqe_flags, rxq->last_cqe_flags, n_mini_cqes_left);
+      n_rx_packets = n_mini_cqes_left;
+      byte_cnt += n_mini_cqes_left;
+      cqe_flags += n_mini_cqes_left;
+      rxq->n_mini_cqes_left = 0;
+      rxq->cq_ci = cq_ci = cq_ci + n_mini_cqes;
+    }
+
+  while (n_rx_packets < VLIB_FRAME_SIZE)
+    {
+      u8 cqe_last_byte, owner;
+      mlx5dv_cqe_t *cqe = rxq->cqes + (cq_ci & mask);
+
+      clib_prefetch_load (rxq->cqes + ((cq_ci + 8) & mask));
+
+      owner = (cq_ci >> log2_cq_size) & 1;
+      cqe_last_byte = cqe->opcode_cqefmt_se_owner;
+
+      if ((cqe_last_byte & 0x1) != owner)
+	break;
+
+      cqe_last_byte &= 0xfe;	/* remove owner bit */
+
+      if (cqe_last_byte == 0x2c)
+	{
+	  u32 n_mini_cqes = clib_net_to_host_u32 (cqe->mini_cqe_num);
+	  u32 n_left = VLIB_FRAME_SIZE - n_rx_packets;
+	  u16 flags = cqe->flags;
+
+	  if (n_left >= n_mini_cqes)
+	    {
+	      process_mini_cqes (rxq, 0, n_mini_cqes, cq_ci, mask, byte_cnt);
+	      clib_memset_u16 (cqe_flags, flags, n_mini_cqes);
+	      compressed_cqe_reset_owner (rxq, n_mini_cqes, cq_ci, mask,
+					  log2_cq_size);
+	      n_rx_packets += n_mini_cqes;
+	      byte_cnt += n_mini_cqes;
+	      cqe_flags += n_mini_cqes;
+	      cq_ci += n_mini_cqes;
+	    }
+	  else
+	    {
+	      process_mini_cqes (rxq, 0, n_left, cq_ci, mask, byte_cnt);
+	      clib_memset_u16 (cqe_flags, flags, n_left);
+	      n_rx_packets = VLIB_FRAME_SIZE;
+	      rxq->n_mini_cqes = n_mini_cqes;
+	      rxq->n_mini_cqes_left = n_mini_cqes - n_left;
+	      rxq->last_cqe_flags = flags;
+	      goto done;
+	    }
+	  continue;
+	}
+
+      if (cqe_last_byte == 0x20)
+	{
+	  byte_cnt[0] = cqe->byte_cnt;
+	  cqe_flags[0] = cqe->flags;
+	  n_rx_packets++;
+	  cq_ci++;
+	  byte_cnt++;
+	  continue;
+	}
+
+      rd->flags |= RDMA_DEVICE_F_ERROR;
+      break;
+    }
+
+done:
+  if (n_rx_packets)
+    rxq->cq_db[0] = rxq->cq_ci = cq_ci;
+  return n_rx_packets;
+}
+
 static_always_inline uword
 rdma_device_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
-			  vlib_frame_t * frame, rdma_device_t * rd, u16 qid)
+			  vlib_frame_t * frame, rdma_device_t * rd, u16 qid,
+			  int use_mlx5dv)
 {
   rdma_main_t *rm = &rdma_main;
   vnet_main_t *vnm = vnet_get_main ();
   rdma_per_thread_data_t *ptd = vec_elt_at_index (rm->per_thread_data,
 						  vm->thread_index);
   rdma_rxq_t *rxq = vec_elt_at_index (rd->rxqs, qid);
+  vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
   struct ibv_wc wc[VLIB_FRAME_SIZE];
+  u32 byte_cnts[VLIB_FRAME_SIZE];
   vlib_buffer_t bt;
-  u32 next_index, *to_next, n_left_to_next;
-  u32 n_rx_packets, n_rx_bytes;
+  u32 next_index, *to_next, n_left_to_next, n_rx_bytes = 0;
+  int n_rx_packets, skip_ip4_cksum = 0;
   u32 mask = rxq->size - 1;
 
-  ASSERT (rxq->size >= VLIB_FRAME_SIZE && is_pow2 (rxq->size));
-  ASSERT (rxq->tail - rxq->head <= rxq->size);
-
-  n_rx_packets = ibv_poll_cq (rxq->cq, VLIB_FRAME_SIZE, wc);
-  ASSERT (n_rx_packets <= rxq->tail - rxq->head);
+  if (use_mlx5dv)
+    n_rx_packets = rdma_device_poll_cq_mlx5dv (rd, rxq, byte_cnts,
+					       ptd->cqe_flags);
+  else
+    n_rx_packets = ibv_poll_cq (rxq->cq, VLIB_FRAME_SIZE, wc);
 
   if (PREDICT_FALSE (n_rx_packets <= 0))
     goto refill;
@@ -281,20 +514,104 @@ rdma_device_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
     vnet_feature_start_device_input_x1 (rd->sw_if_index, &next_index, &bt);
 
   vlib_get_new_next_frame (vm, node, next_index, to_next, n_left_to_next);
-  ASSERT (n_rx_packets <= n_left_to_next);
 
   vlib_buffer_copy_indices_from_ring (to_next, rxq->bufs, rxq->head & mask,
 				      rxq->size, n_rx_packets);
-  n_rx_bytes = rdma_device_input_bufs (vm, rd, to_next, wc, n_rx_packets,
-				       &bt);
 
-  rdma_device_input_ethernet (vm, node, rd, next_index);
+  vlib_get_buffers (vm, to_next, bufs, n_rx_packets);
+
+  if (use_mlx5dv)
+    {
+      u16 mask = CQE_FLAG_L3_HDR_TYPE_MASK | CQE_FLAG_L3_OK;
+      u16 match = CQE_FLAG_L3_HDR_TYPE_IP4 << CQE_FLAG_L3_HDR_TYPE_SHIFT;
+      u32 n_left = n_rx_packets;
+      u32 *bc = byte_cnts;
+
+      /* verify that all ip4 packets have l3_ok flag set and convert packet
+         length from network to host byte order */
+      skip_ip4_cksum = 1;
+
+#if defined CLIB_HAVE_VEC256
+      u16x16 mask16 = u16x16_splat (mask);
+      u16x16 match16 = u16x16_splat (match);
+      u16x16 r = { };
+
+      for (int i = 0; i * 16 < n_rx_packets; i++)
+	r |= (ptd->cqe_flags16[i] & mask16) != match16;
+
+      if (!u16x16_is_all_zero (r))
+	skip_ip4_cksum = 0;
+
+      for (int i = 0; i < n_rx_packets; i += 8)
+	*(u32x8 *) (bc + i) = u32x8_byte_swap (*(u32x8 *) (bc + i));
+#elif defined CLIB_HAVE_VEC128
+      u16x8 mask8 = u16x8_splat (mask);
+      u16x8 match8 = u16x8_splat (match);
+      u16x8 r = { };
+
+      for (int i = 0; i * 8 < n_rx_packets; i++)
+	r |= (ptd->cqe_flags8[i] & mask8) != match8;
+
+      if (!u16x8_is_all_zero (r))
+	skip_ip4_cksum = 0;
+
+      for (int i = 0; i < n_rx_packets; i += 4)
+	*(u32x4 *) (bc + i) = u32x4_byte_swap (*(u32x4 *) (bc + i));
+#else
+      for (int i = 0; i < n_rx_packets; i++)
+	if ((ptd->cqe_flags[i] & mask) == match)
+	  skip_ip4_cksum = 0;
+
+      for (int i = 0; i < n_rx_packets; i++)
+	bc[i] = clib_net_to_host_u32 (bc[i]);
+#endif
+
+      while (n_left >= 8)
+	{
+	  clib_prefetch_store (b[4]);
+	  vlib_buffer_copy_template (b[0], &bt);
+	  n_rx_bytes += b[0]->current_length = bc[0];
+	  clib_prefetch_store (b[5]);
+	  vlib_buffer_copy_template (b[1], &bt);
+	  n_rx_bytes += b[1]->current_length = bc[1];
+	  clib_prefetch_store (b[6]);
+	  vlib_buffer_copy_template (b[2], &bt);
+	  n_rx_bytes += b[2]->current_length = bc[2];
+	  clib_prefetch_store (b[7]);
+	  vlib_buffer_copy_template (b[3], &bt);
+	  n_rx_bytes += b[3]->current_length = bc[3];
+
+	  /* next */
+	  bc += 4;
+	  b += 4;
+	  n_left -= 4;
+	}
+      while (n_left)
+	{
+	  vlib_buffer_copy_template (b[0], &bt);
+	  n_rx_bytes += b[0]->current_length = bc[0];
+
+	  /* next */
+	  bc++;
+	  b++;
+	  n_left--;
+	}
+    }
+  else
+    n_rx_bytes = rdma_device_input_bufs (vm, rd, bufs, wc, n_rx_packets, &bt);
+
+  rdma_device_input_ethernet (vm, node, rd, next_index, skip_ip4_cksum);
 
   vlib_put_next_frame (vm, node, next_index, n_left_to_next - n_rx_packets);
 
   rxq->head += n_rx_packets;
 
-  rdma_device_input_trace (vm, node, rd, n_rx_packets, to_next, next_index);
+  rdma_device_input_trace (vm, node, rd, n_rx_packets, to_next, next_index,
+			   ptd->cqe_flags, use_mlx5dv);
+
+  /* reset flags to zero for the next run */
+  if (use_mlx5dv)
+    clib_memset_u16 (ptd->cqe_flags, 0, VLIB_FRAME_SIZE);
 
   vlib_increment_combined_counter
     (vnm->interface_main.combined_sw_if_counters +
@@ -302,7 +619,7 @@ rdma_device_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
      rd->hw_if_index, n_rx_packets, n_rx_bytes);
 
 refill:
-  rdma_device_input_refill (vm, rd, rxq);
+  rdma_device_input_refill (vm, rd, rxq, use_mlx5dv);
 
   return n_rx_packets;
 }
@@ -320,8 +637,16 @@ VLIB_NODE_FN (rdma_input_node) (vlib_main_t * vm,
   {
     rdma_device_t *rd;
     rd = vec_elt_at_index (rm->devices, dq->dev_instance);
-    if (PREDICT_TRUE (rd->flags & RDMA_DEVICE_F_ADMIN_UP))
-      n_rx += rdma_device_input_inline (vm, node, frame, rd, dq->queue_id);
+    if (PREDICT_TRUE (rd->flags & RDMA_DEVICE_F_ADMIN_UP) == 0)
+      continue;
+
+    if (PREDICT_TRUE (rd->flags & RDMA_DEVICE_F_ERROR))
+      continue;
+
+    if (PREDICT_TRUE (rd->flags & RDMA_DEVICE_F_MLX5DV))
+      n_rx += rdma_device_input_inline (vm, node, frame, rd, dq->queue_id, 1);
+    else
+      n_rx += rdma_device_input_inline (vm, node, frame, rd, dq->queue_id, 0);
   }
   return n_rx;
 }