src/plugins/rdma/input.c

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2018 Cisco and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *------------------------------------------------------------------
  16  */
  17
  18 #include <vlib/vlib.h>
  19 #include <vlib/unix/unix.h>
  20 #include <vlib/pci/pci.h>
  21 #include <vnet/ethernet/ethernet.h>
  22 #include <vnet/devices/devices.h>
  23 #include <vnet/interface/rx_queue_funcs.h>
  24
  25 #include <rdma/rdma.h>
  26
  27 #define foreach_rdma_input_error \
  28   _(BUFFER_ALLOC, "buffer alloc error")
  29
  30 typedef enum
  31 {
  32 #define _(f,s) RDMA_INPUT_ERROR_##f,
  33   foreach_rdma_input_error
  34 #undef _
  35     RDMA_INPUT_N_ERROR,
  36 } rdma_input_error_t;
  37
  38 static __clib_unused char *rdma_input_error_strings[] = {
  39 #define _(n,s) s,
  40   foreach_rdma_input_error
  41 #undef _
  42 };
  43
  44
  45 static_always_inline void
  46 ibv_set_recv_wr_and_sge (struct ibv_recv_wr *w, struct ibv_sge *s, u64 va,
  47                          u32 data_size, u32 lkey)
  48 {
  49   s[0].addr = va;
  50   s[0].length = data_size;
  51   s[0].lkey = lkey;
  52   w[0].next = w + 1;
  53   w[0].sg_list = s;
  54   w[0].num_sge = 1;
  55 }
  56
  57 static_always_inline u32
  58 rdma_device_legacy_input_refill_additional (vlib_main_t * vm,
  59                                             rdma_device_t * rd,
  60                                             rdma_rxq_t * rxq,
  61                                             rdma_per_thread_data_t * ptd,
  62                                             vlib_buffer_t * bt,
  63                                             u32 first_slot, u32 n_alloc)
  64 {
  65   int i;
  66   u8 log_wqe_sz = rxq->log_wqe_sz;
  67   u32 *bi = ptd->tmp_bi;
  68   vlib_buffer_t **bufs = ptd->tmp_bufs;
  69
  70   for (i = 0; i < n_alloc; i++)
  71     {
  72       u8 chain_sz = rxq->n_used_per_chain[first_slot + i];
  73       u8 chain_sz_alloc;
  74       mlx5dv_wqe_ds_t *current_wqe =
  75         rxq->wqes + ((first_slot + i) << log_wqe_sz);
  76       if (chain_sz == 0)
  77         continue;
  78       if (PREDICT_FALSE ((chain_sz_alloc =
  79                           vlib_buffer_alloc_from_pool (vm, bi, chain_sz,
  80                                                        rd->pool)) !=
  81                          chain_sz))
  82         {
  83           vlib_buffer_free (vm, bi, chain_sz_alloc);
  84           break;
  85         }
  86       /*Build the chain */
  87       vlib_get_buffers (vm, bi, bufs, chain_sz);
  88       for (int j = 0; j < chain_sz - 1; j++)
  89         {
  90           vlib_buffer_copy_template (bufs[j], bt);
  91           bufs[j]->next_buffer = bi[j + 1];
  92           bufs[j]->flags |= VLIB_BUFFER_NEXT_PRESENT;
  93         }
  94       /* The chain starting at the second buffer is pre-initialised */
  95       vlib_buffer_copy_template (bufs[chain_sz - 1], bt);
  96       /* Stick with the already existing chain */
  97       if (chain_sz < rxq->n_ds_per_wqe - 1)
  98         {
  99           bufs[chain_sz - 1]->next_buffer = rxq->second_bufs[first_slot + i];
 100           bufs[chain_sz - 1]->flags |= VLIB_BUFFER_NEXT_PRESENT;
 101         }
 102       else
 103         {
 104           bufs[chain_sz - 1]->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
 105         }
 106
 107       /* Update the wqes */
 108       for (int j = 0; j < chain_sz; j++)
 109         {
 110           u64 addr;
 111           vlib_get_buffers_with_offset (vm, bi + j,
 112                                         (void *) &addr, 1,
 113                                         sizeof (vlib_buffer_t));
 114           current_wqe[j + 1].addr = clib_host_to_net_u64 (addr);
 115         }
 116       rxq->n_used_per_chain[first_slot + i] = 0;
 117       rxq->n_total_additional_segs -= chain_sz;
 118       rxq->second_bufs[first_slot + i] = bi[0];
 119     }
 120   return i;
 121 }
 122
 123 static_always_inline void
 124 rdma_device_input_refill (vlib_main_t * vm, rdma_device_t * rd,
 125                           rdma_rxq_t * rxq, vlib_buffer_t * bt,
 126                           const int is_mlx5dv, const int is_striding)
 127 {
 128   u32 n_alloc, n;
 129   u16 ring_space;
 130   struct ibv_recv_wr wr[VLIB_FRAME_SIZE], *w = wr;
 131   struct ibv_sge sge[VLIB_FRAME_SIZE], *s = sge;
 132   rdma_per_thread_data_t *ptd =
 133     &rdma_main.per_thread_data[vlib_get_thread_index ()];
 134   u32 mask = rxq->size - 1;
 135   u32 slot = rxq->tail & mask;
 136   u32 *bufs = rxq->bufs + slot;
 137   u32 data_size = rxq->buf_sz;
 138   u32 lkey = rd->lkey;
 139   const int log_stride_per_wqe = is_striding ? rxq->log_stride_per_wqe : 0;
 140   const int log_wqe_sz = rxq->log_wqe_sz;
 141
 142   /*In legacy mode, maybe some buffers chains are incomplete? */
 143   if (PREDICT_FALSE
 144       (is_mlx5dv && !is_striding && (rxq->incomplete_tail != rxq->tail)))
 145     {
 146       int n_incomplete = rxq->incomplete_tail - rxq->tail;
 147       int n_completed =
 148         rdma_device_legacy_input_refill_additional (vm, rd, rxq, ptd, bt,
 149                                                     slot,
 150                                                     n_incomplete);
 151       rxq->tail += n_completed;
 152       slot = rxq->tail & mask;
 153       /* Don't start recycling head buffers if there are incomplete chains */
 154       if (n_completed != n_incomplete)
 155         return;
 156     }
 157
 158   /* refilled buffers must be a multiple of 8 and of strides per WQE */
 159   u32 alloc_multiple = 1 << (clib_max (3, log_stride_per_wqe));
 160
 161   ring_space = rxq->size - (rxq->tail - rxq->head);
 162
 163   n_alloc = clib_min (VLIB_FRAME_SIZE, ring_space);
 164
 165   /* do not bother to allocate if too small */
 166   if (n_alloc < 2 * alloc_multiple)
 167     return;
 168
 169   /* avoid wrap-around logic in core loop */
 170   n_alloc = clib_min (n_alloc, rxq->size - slot);
 171
 172   n_alloc &= ~(alloc_multiple - 1);     /* round to alloc_multiple */
 173
 174   n = vlib_buffer_alloc_to_ring_from_pool (vm, rxq->bufs, slot, rxq->size,
 175                                            n_alloc, rd->pool);
 176
 177   if (PREDICT_FALSE (n != n_alloc))
 178     {
 179       u32 n_free;
 180       if (n < alloc_multiple)
 181         {
 182           if (n)
 183             vlib_buffer_free_from_ring (vm, rxq->bufs, slot, rxq->size, n);
 184           return;
 185         }
 186
 187       /* partial allocation, round and return rest */
 188       n_free = n & (alloc_multiple - 1);
 189       n -= n_free;
 190       if (n_free)
 191         vlib_buffer_free_from_ring (vm, rxq->bufs, (slot + n) & mask,
 192                                     rxq->size, n_free);
 193     }
 194
 195   n_alloc = n;
 196
 197   if (is_mlx5dv)
 198     {
 199       u64 __clib_aligned (32) va[8];
 200
 201       /* slot does not necessarily correspond to the slot
 202          in the wqes ring (in 16B words) */
 203       u32 wqes_slot = slot << (log_wqe_sz - log_stride_per_wqe);
 204       const u32 wqe_cnt = rxq->wqe_cnt;
 205       mlx5dv_wqe_ds_t *wqe = rxq->wqes + wqes_slot;
 206       const int wqe_sz = 1 << log_wqe_sz;
 207       const int stride_per_wqe = 1 << log_stride_per_wqe;
 208       int current_data_seg = 0;
 209
 210       /* In legacy mode, this function only refills head descriptors for each
 211          WQE, so RDMA_RXQ_MAX_CHAIN_SZ-1 data segments are skipped per WQE */
 212       const int log_skip_wqe = is_striding ? 0 : log_wqe_sz;
 213
 214       while (n >= 1)
 215         {
 216           vlib_get_buffers_with_offset (vm, rxq->bufs + slot, (void **) va, 8,
 217                                         sizeof (vlib_buffer_t));
 218 #ifdef CLIB_HAVE_VEC256
 219           *(u64x4 *) va = u64x4_byte_swap (*(u64x4 *) va);
 220           *(u64x4 *) (va + 4) = u64x4_byte_swap (*(u64x4 *) (va + 4));
 221 #else
 222           for (int i = 0; i < 8; i++)
 223             va[i] = clib_host_to_net_u64 (va[i]);
 224 #endif
 225
 226           /*In striding RQ mode, the first 16B-word of the WQE is the SRQ header.
 227              It is initialised as if it were a LINKED_LIST, as we have no guarantee
 228              about what RDMA core does (CYCLIC_RQ or LINKED_LIST_RQ). In cyclic
 229              mode, the SRQ header is ignored anyways... */
 230
 231 /* *INDENT-OFF* */
 232           if (is_striding && !(current_data_seg & (wqe_sz - 1)))
 233             *(mlx5dv_wqe_srq_next_t *) wqe = (mlx5dv_wqe_srq_next_t)
 234             {
 235               .rsvd0 = {0},
 236               .next_wqe_index = clib_host_to_net_u16 (((wqes_slot >> log_wqe_sz) + 1) & (wqe_cnt - 1)),
 237               .signature = 0,
 238               .rsvd1 = {0}
 239             };
 240 /* *INDENT-ON* */
 241
 242           /* TODO: when log_skip_wqe > 2, hw_prefetcher doesn't work, lots of LLC store
 243              misses occur for wqes, to be fixed... */
 244           if (!is_striding || !(current_data_seg & ~(stride_per_wqe - 1)))
 245             {
 246               wqe[(0 << log_skip_wqe) + is_striding].addr = va[0];
 247               wqe[(1 << log_skip_wqe) + is_striding].addr = va[1];
 248               wqe[(2 << log_skip_wqe) + is_striding].addr = va[2];
 249               wqe[(3 << log_skip_wqe) + is_striding].addr = va[3];
 250               wqe[(4 << log_skip_wqe) + is_striding].addr = va[4];
 251               wqe[(5 << log_skip_wqe) + is_striding].addr = va[5];
 252               wqe[(6 << log_skip_wqe) + is_striding].addr = va[6];
 253               wqe[(7 << log_skip_wqe) + is_striding].addr = va[7];
 254               slot += 8;
 255               n -= 8;
 256             }
 257           wqe += 8 << log_skip_wqe;
 258           wqes_slot += 8 << log_skip_wqe;
 259           current_data_seg += 8;
 260           current_data_seg &= wqe_sz - 1;
 261         }
 262
 263       /* In legacy mode, there is some work required to finish building the SG lists */
 264       if (!is_striding)
 265         {
 266           int first_slot = slot - n_alloc;
 267           rxq->incomplete_tail += n_alloc;
 268           if (PREDICT_FALSE (rxq->n_total_additional_segs))
 269             n_alloc =
 270               rdma_device_legacy_input_refill_additional (vm, rd, rxq, ptd,
 271                                                           bt, first_slot,
 272                                                           n_alloc);
 273         }
 274       CLIB_MEMORY_STORE_BARRIER ();
 275       rxq->tail += n_alloc;
 276       if (is_striding)
 277         {
 278           rxq->striding_wqe_tail += n_alloc >> log_stride_per_wqe;
 279           rxq->wq_db[MLX5_RCV_DBR] =
 280             clib_host_to_net_u32 (rxq->striding_wqe_tail);
 281         }
 282       else
 283         rxq->wq_db[MLX5_RCV_DBR] = clib_host_to_net_u32 (rxq->tail);
 284       return;
 285     }
 286
 287   while (n >= 8)
 288     {
 289       u64 va[8];
 290       if (PREDICT_TRUE (n >= 16))
 291         {
 292           clib_prefetch_store (s + 16);
 293           clib_prefetch_store (w + 16);
 294         }
 295
 296       vlib_get_buffers_with_offset (vm, bufs, (void **) va, 8,
 297                                     sizeof (vlib_buffer_t));
 298
 299       ibv_set_recv_wr_and_sge (w++, s++, va[0], data_size, lkey);
 300       ibv_set_recv_wr_and_sge (w++, s++, va[1], data_size, lkey);
 301       ibv_set_recv_wr_and_sge (w++, s++, va[2], data_size, lkey);
 302       ibv_set_recv_wr_and_sge (w++, s++, va[3], data_size, lkey);
 303       ibv_set_recv_wr_and_sge (w++, s++, va[4], data_size, lkey);
 304       ibv_set_recv_wr_and_sge (w++, s++, va[5], data_size, lkey);
 305       ibv_set_recv_wr_and_sge (w++, s++, va[6], data_size, lkey);
 306       ibv_set_recv_wr_and_sge (w++, s++, va[7], data_size, lkey);
 307
 308       bufs += 8;
 309       n -= 8;
 310     }
 311
 312   w[-1].next = 0;               /* fix next pointer in WR linked-list last item */
 313
 314   n = n_alloc;
 315   if (ibv_post_wq_recv (rxq->wq, wr, &w) != 0)
 316     {
 317       n = w - wr;
 318       vlib_buffer_free_from_ring (vm, rxq->bufs, slot + n, rxq->size,
 319                                   n_alloc - n);
 320     }
 321
 322   rxq->tail += n;
 323 }
 324
 325 static_always_inline void
 326 rdma_device_input_trace (vlib_main_t * vm, vlib_node_runtime_t * node,
 327                          const rdma_device_t * rd, u32 n_left,
 328                          const u32 * bi, u32 next_index, u16 * cqe_flags,
 329                          int is_mlx5dv)
 330 {
 331   u32 n_trace = vlib_get_trace_count (vm, node);
 332
 333   if (PREDICT_TRUE (0 == n_trace))
 334     return;
 335
 336   while (n_trace && n_left)
 337     {
 338       vlib_buffer_t *b = vlib_get_buffer (vm, bi[0]);
 339       if (PREDICT_TRUE
 340           (vlib_trace_buffer (vm, node, next_index, b, /* follow_chain */ 0)))
 341         {
 342           rdma_input_trace_t *tr = vlib_add_trace (vm, node, b, sizeof (*tr));
 343           tr->next_index = next_index;
 344           tr->hw_if_index = rd->hw_if_index;
 345           tr->cqe_flags = is_mlx5dv ? clib_net_to_host_u16 (cqe_flags[0]) : 0;
 346           n_trace--;
 347         }
 348       /* next */
 349       n_left--;
 350       cqe_flags++;
 351       bi++;
 352     }
 353   vlib_set_trace_count (vm, node, n_trace);
 354 }
 355
 356 static_always_inline void
 357 rdma_device_input_ethernet (vlib_main_t * vm, vlib_node_runtime_t * node,
 358                             const rdma_device_t * rd, u32 next_index,
 359                             int skip_ip4_cksum)
 360 {
 361   vlib_next_frame_t *nf;
 362   vlib_frame_t *f;
 363   ethernet_input_frame_t *ef;
 364
 365   if (PREDICT_FALSE (VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT != next_index))
 366     return;
 367
 368   nf =
 369     vlib_node_runtime_get_next_frame (vm, node,
 370                                       VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT);
 371   f = vlib_get_frame (vm, nf->frame);
 372   f->flags = ETH_INPUT_FRAME_F_SINGLE_SW_IF_IDX;
 373   if (skip_ip4_cksum)
 374     f->flags |= ETH_INPUT_FRAME_F_IP4_CKSUM_OK;
 375
 376   ef = vlib_frame_scalar_args (f);
 377   ef->sw_if_index = rd->sw_if_index;
 378   ef->hw_if_index = rd->hw_if_index;
 379 }
 380
 381 static_always_inline u32
 382 rdma_device_input_bufs (vlib_main_t * vm, const rdma_device_t * rd,
 383                         vlib_buffer_t ** b, struct ibv_wc *wc,
 384                         u32 n_left_from, vlib_buffer_t * bt)
 385 {
 386   u32 n_rx_bytes = 0;
 387
 388   while (n_left_from >= 4)
 389     {
 390       if (PREDICT_TRUE (n_left_from >= 8))
 391         {
 392           clib_prefetch_load (&wc[4 + 0]);
 393           clib_prefetch_load (&wc[4 + 1]);
 394           clib_prefetch_load (&wc[4 + 2]);
 395           clib_prefetch_load (&wc[4 + 3]);
 396           vlib_prefetch_buffer_header (b[4 + 0], STORE);
 397           vlib_prefetch_buffer_header (b[4 + 1], STORE);
 398           vlib_prefetch_buffer_header (b[4 + 2], STORE);
 399           vlib_prefetch_buffer_header (b[4 + 3], STORE);
 400         }
 401
 402       vlib_buffer_copy_template (b[0], bt);
 403       vlib_buffer_copy_template (b[1], bt);
 404       vlib_buffer_copy_template (b[2], bt);
 405       vlib_buffer_copy_template (b[3], bt);
 406
 407       n_rx_bytes += b[0]->current_length = wc[0].byte_len;
 408       n_rx_bytes += b[1]->current_length = wc[1].byte_len;
 409       n_rx_bytes += b[2]->current_length = wc[2].byte_len;
 410       n_rx_bytes += b[3]->current_length = wc[3].byte_len;
 411
 412       b += 4;
 413       wc += 4;
 414       n_left_from -= 4;
 415     }
 416
 417   while (n_left_from >= 1)
 418     {
 419       vlib_buffer_copy_template (b[0], bt);
 420       n_rx_bytes += b[0]->current_length = wc[0].byte_len;
 421
 422       b += 1;
 423       wc += 1;
 424       n_left_from -= 1;
 425     }
 426
 427   return n_rx_bytes;
 428 }
 429
 430 static_always_inline void
 431 process_mini_cqes (rdma_rxq_t * rxq, u32 skip, u32 n_left, u32 cq_ci,
 432                    u32 mask, u32 * byte_cnt)
 433 {
 434   mlx5dv_mini_cqe_t *mcqe;
 435   u32 mcqe_array_index = (cq_ci + 1) & mask;
 436   mcqe = (mlx5dv_mini_cqe_t *) (rxq->cqes + mcqe_array_index);
 437
 438   mcqe_array_index = cq_ci;
 439
 440   if (skip)
 441     {
 442       u32 n = skip & ~7;
 443
 444       if (n)
 445         {
 446           mcqe_array_index = (mcqe_array_index + n) & mask;
 447           mcqe = (mlx5dv_mini_cqe_t *) (rxq->cqes + mcqe_array_index);
 448           skip -= n;
 449         }
 450
 451       if (skip)
 452         {
 453           n = clib_min (8 - skip, n_left);
 454           for (int i = 0; i < n; i++)
 455             byte_cnt[i] = mcqe[skip + i].byte_count;
 456           mcqe_array_index = (mcqe_array_index + 8) & mask;
 457           mcqe = (mlx5dv_mini_cqe_t *) (rxq->cqes + mcqe_array_index);
 458           n_left -= n;
 459           byte_cnt += n;
 460         }
 461
 462     }
 463
 464   while (n_left >= 8)
 465     {
 466       for (int i = 0; i < 8; i++)
 467         byte_cnt[i] = mcqe[i].byte_count;
 468
 469       n_left -= 8;
 470       byte_cnt += 8;
 471       mcqe_array_index = (mcqe_array_index + 8) & mask;
 472       mcqe = (mlx5dv_mini_cqe_t *) (rxq->cqes + mcqe_array_index);
 473     }
 474
 475   if (n_left)
 476     {
 477       for (int i = 0; i < n_left; i++)
 478         byte_cnt[i] = mcqe[i].byte_count;
 479     }
 480 }
 481
 482 static_always_inline void
 483 cqe_set_owner (mlx5dv_cqe_t * cqe, u32 n_left, u8 owner)
 484 {
 485   while (n_left >= 8)
 486     {
 487       cqe[0].opcode_cqefmt_se_owner = owner;
 488       cqe[1].opcode_cqefmt_se_owner = owner;
 489       cqe[2].opcode_cqefmt_se_owner = owner;
 490       cqe[3].opcode_cqefmt_se_owner = owner;
 491       cqe[4].opcode_cqefmt_se_owner = owner;
 492       cqe[5].opcode_cqefmt_se_owner = owner;
 493       cqe[6].opcode_cqefmt_se_owner = owner;
 494       cqe[7].opcode_cqefmt_se_owner = owner;
 495       n_left -= 8;
 496       cqe += 8;
 497     }
 498   while (n_left)
 499     {
 500       cqe[0].opcode_cqefmt_se_owner = owner;
 501       n_left--;
 502       cqe++;
 503     }
 504 }
 505
 506 static_always_inline void
 507 compressed_cqe_reset_owner (rdma_rxq_t * rxq, u32 n_mini_cqes, u32 cq_ci,
 508                             u32 mask, u32 log2_cq_size)
 509 {
 510   u8 owner;
 511   u32 offset, cq_size = 1 << log2_cq_size;
 512
 513
 514   /* first CQE is reset by hardware */
 515   cq_ci++;
 516   n_mini_cqes--;
 517
 518   offset = cq_ci & mask;
 519   owner = 0xf0 | ((cq_ci >> log2_cq_size) & 1);
 520
 521   if (offset + n_mini_cqes < cq_size)
 522     {
 523       cqe_set_owner (rxq->cqes + offset, n_mini_cqes, owner);
 524     }
 525   else
 526     {
 527       u32 n = cq_size - offset;
 528       cqe_set_owner (rxq->cqes + offset, n, owner);
 529       cqe_set_owner (rxq->cqes, n_mini_cqes - n, owner ^ 1);
 530     }
 531
 532 }
 533
 534 static_always_inline uword
 535 rdma_device_poll_cq_mlx5dv (rdma_device_t * rd, rdma_rxq_t * rxq,
 536                             u32 * byte_cnt, u16 * cqe_flags)
 537 {
 538   u32 n_rx_packets = 0;
 539   u32 log2_cq_size = rxq->log2_cq_size;
 540   u32 mask = pow2_mask (log2_cq_size);
 541   u32 cq_ci = rxq->cq_ci;
 542
 543   if (rxq->n_mini_cqes_left)
 544     {
 545       /* partially processed mini-cqe array */
 546       u32 n_mini_cqes = rxq->n_mini_cqes;
 547       u32 n_mini_cqes_left = rxq->n_mini_cqes_left;
 548       process_mini_cqes (rxq, n_mini_cqes - n_mini_cqes_left,
 549                          n_mini_cqes_left, cq_ci, mask, byte_cnt);
 550       compressed_cqe_reset_owner (rxq, n_mini_cqes, cq_ci, mask,
 551                                   log2_cq_size);
 552       clib_memset_u16 (cqe_flags, rxq->last_cqe_flags, n_mini_cqes_left);
 553       n_rx_packets = n_mini_cqes_left;
 554       byte_cnt += n_mini_cqes_left;
 555       cqe_flags += n_mini_cqes_left;
 556       rxq->n_mini_cqes_left = 0;
 557       rxq->cq_ci = cq_ci = cq_ci + n_mini_cqes;
 558     }
 559
 560   while (n_rx_packets < VLIB_FRAME_SIZE)
 561     {
 562       u8 cqe_last_byte, owner;
 563       mlx5dv_cqe_t *cqe = rxq->cqes + (cq_ci & mask);
 564
 565       clib_prefetch_load (rxq->cqes + ((cq_ci + 8) & mask));
 566
 567       owner = (cq_ci >> log2_cq_size) & 1;
 568       cqe_last_byte = cqe->opcode_cqefmt_se_owner;
 569
 570       if ((cqe_last_byte & 0x1) != owner)
 571         break;
 572
 573       cqe_last_byte &= 0xfc;    /* remove owner and solicited bits */
 574
 575       if (cqe_last_byte == 0x2c)        /* OPCODE = 0x2 (Responder Send), Format = 0x3 (Compressed CQE) */
 576         {
 577           u32 n_mini_cqes = clib_net_to_host_u32 (cqe->mini_cqe_num);
 578           u32 n_left = VLIB_FRAME_SIZE - n_rx_packets;
 579           u16 flags = cqe->flags;
 580
 581           if (n_left >= n_mini_cqes)
 582             {
 583               process_mini_cqes (rxq, 0, n_mini_cqes, cq_ci, mask, byte_cnt);
 584               clib_memset_u16 (cqe_flags, flags, n_mini_cqes);
 585               compressed_cqe_reset_owner (rxq, n_mini_cqes, cq_ci, mask,
 586                                           log2_cq_size);
 587               n_rx_packets += n_mini_cqes;
 588               byte_cnt += n_mini_cqes;
 589               cqe_flags += n_mini_cqes;
 590               cq_ci += n_mini_cqes;
 591             }
 592           else
 593             {
 594               process_mini_cqes (rxq, 0, n_left, cq_ci, mask, byte_cnt);
 595               clib_memset_u16 (cqe_flags, flags, n_left);
 596               n_rx_packets = VLIB_FRAME_SIZE;
 597               rxq->n_mini_cqes = n_mini_cqes;
 598               rxq->n_mini_cqes_left = n_mini_cqes - n_left;
 599               rxq->last_cqe_flags = flags;
 600               goto done;
 601             }
 602           continue;
 603         }
 604
 605       if (cqe_last_byte == 0x20)        /* OPCODE = 0x2 (Responder Send), Format = 0x0 (no inline data) */
 606         {
 607           byte_cnt[0] = cqe->byte_cnt;
 608           cqe_flags[0] = cqe->flags;
 609           n_rx_packets++;
 610           cq_ci++;
 611           byte_cnt++;
 612           cqe_flags++;
 613           continue;
 614         }
 615
 616       rd->flags |= RDMA_DEVICE_F_ERROR;
 617       break;
 618     }
 619
 620 done:
 621   if (n_rx_packets)
 622     rxq->cq_db[0] = rxq->cq_ci = cq_ci;
 623   return n_rx_packets;
 624 }
 625
 626 static_always_inline int
 627 rdma_device_mlx5dv_striding_rq_parse_bc (int n_rx_packets, int *n_rx_segs,
 628                                          u32 * bc)
 629 {
 630 /* Determine if slow path is needed  */
 631   int filler = 0;
 632   for (int i = 0; i < n_rx_packets; i++)
 633     {
 634       *n_rx_segs +=
 635         (bc[i] & CQE_BC_CONSUMED_STRIDES_MASK) >>
 636         CQE_BC_CONSUMED_STRIDES_SHIFT;
 637       filler |= ! !(bc[i] & CQE_BC_FILLER_MASK);
 638     }
 639   return n_rx_packets != *n_rx_segs || filler;
 640 }
 641
 642 static_always_inline int
 643 rdma_device_mlx5dv_legacy_rq_slow_path_needed (u32 buf_sz, int n_rx_packets,
 644                                                u32 * bc)
 645 {
 646 #if defined CLIB_HAVE_VEC256
 647   u32x8 thresh8 = u32x8_splat (buf_sz);
 648   for (int i = 0; i < n_rx_packets; i += 8)
 649     if (!u32x8_is_all_zero (*(u32x8 *) (bc + i) > thresh8))
 650       return 1;
 651 #elif defined CLIB_HAVE_VEC128
 652   u32x4 thresh4 = u32x4_splat (buf_sz);
 653   for (int i = 0; i < n_rx_packets; i += 4)
 654     if (!u32x4_is_all_zero (*(u32x4 *) (bc + i) > thresh4))
 655       return 1;
 656 #else
 657   while (n_rx_packets)
 658     {
 659       if (*bc > buf_sz)
 660         return 1;
 661       bc++;
 662       n_rx_packets--;
 663     }
 664 #endif
 665
 666   return 0;
 667 }
 668
 669 static_always_inline int
 670 rdma_device_mlx5dv_l3_validate_and_swap_bc (rdma_per_thread_data_t
 671                                             * ptd, int n_rx_packets, u32 * bc)
 672 {
 673   u16 mask = CQE_FLAG_L3_HDR_TYPE_MASK | CQE_FLAG_L3_OK;
 674   u16 match =
 675     CQE_FLAG_L3_HDR_TYPE_IP4 << CQE_FLAG_L3_HDR_TYPE_SHIFT | CQE_FLAG_L3_OK;
 676
 677   /* convert mask/match to big endian for subsequant comparison */
 678   mask = clib_host_to_net_u16 (mask);
 679   match = clib_host_to_net_u16 (match);
 680
 681   /* verify that all ip4 packets have l3_ok flag set and convert packet
 682      length from network to host byte order */
 683   int skip_ip4_cksum = 1;
 684   int n_left = n_rx_packets;
 685   u16 *cqe_flags = ptd->cqe_flags;
 686
 687 #if defined CLIB_HAVE_VEC256
 688   if (n_left >= 16)
 689     {
 690       u16x16 mask16 = u16x16_splat (mask);
 691       u16x16 match16 = u16x16_splat (match);
 692       u16x16 r16 = {};
 693
 694       while (n_left >= 16)
 695         {
 696           r16 |= (*(u16x16 *) cqe_flags & mask16) != match16;
 697
 698           *(u32x8 *) bc = u32x8_byte_swap (*(u32x8 *) bc);
 699           *(u32x8 *) (bc + 8) = u32x8_byte_swap (*(u32x8 *) (bc + 8));
 700
 701           cqe_flags += 16;
 702           bc += 16;
 703           n_left -= 16;
 704         }
 705
 706       if (!u16x16_is_all_zero (r16))
 707         skip_ip4_cksum = 0;
 708     }
 709 #elif defined CLIB_HAVE_VEC128
 710   if (n_left >= 8)
 711     {
 712       u16x8 mask8 = u16x8_splat (mask);
 713       u16x8 match8 = u16x8_splat (match);
 714       u16x8 r8 = {};
 715
 716       while (n_left >= 8)
 717         {
 718           r8 |= (*(u16x8 *) cqe_flags & mask8) != match8;
 719
 720           *(u32x4 *) bc = u32x4_byte_swap (*(u32x4 *) bc);
 721           *(u32x4 *) (bc + 4) = u32x4_byte_swap (*(u32x4 *) (bc + 4));
 722
 723           cqe_flags += 8;
 724           bc += 8;
 725           n_left -= 8;
 726         }
 727
 728       if (!u16x8_is_all_zero (r8))
 729         skip_ip4_cksum = 0;
 730     }
 731 #endif
 732
 733   while (n_left >= 1)
 734     {
 735       if ((cqe_flags[0] & mask) != match)
 736         skip_ip4_cksum = 0;
 737
 738       bc[0] = clib_net_to_host_u32 (bc[0]);
 739
 740       cqe_flags += 1;
 741       bc += 1;
 742       n_left -= 1;
 743     }
 744
 745   return skip_ip4_cksum;
 746 }
 747
 748 static_always_inline u32
 749 rdma_device_mlx5dv_fast_input (vlib_main_t * vm, rdma_rxq_t * rxq,
 750                                vlib_buffer_t ** bufs,
 751                                u32 qs_mask, vlib_buffer_t * bt,
 752                                u32 * to_next, u32 n_rx_segs, u32 * bc,
 753                                u32 bc_mask)
 754 {
 755   vlib_buffer_t **b = bufs;
 756   u32 n_left = n_rx_segs;
 757   u32 n_rx_bytes = 0;
 758   vlib_buffer_copy_indices_from_ring (to_next, rxq->bufs,
 759                                       rxq->head & qs_mask, rxq->size,
 760                                       n_rx_segs);
 761   rxq->head += n_rx_segs;
 762   vlib_get_buffers (vm, to_next, bufs, n_rx_segs);
 763   while (n_left >= 8)
 764     {
 765       clib_prefetch_store (b[4]);
 766       vlib_buffer_copy_template (b[0], bt);
 767       n_rx_bytes += b[0]->current_length = bc[0] & bc_mask;
 768       clib_prefetch_store (b[5]);
 769       vlib_buffer_copy_template (b[1], bt);
 770       n_rx_bytes += b[1]->current_length = bc[1] & bc_mask;
 771       clib_prefetch_store (b[6]);
 772       vlib_buffer_copy_template (b[2], bt);
 773       n_rx_bytes += b[2]->current_length = bc[2] & bc_mask;
 774       clib_prefetch_store (b[7]);
 775       vlib_buffer_copy_template (b[3], bt);
 776       n_rx_bytes += b[3]->current_length = bc[3] & bc_mask;
 777       /* next */
 778       bc += 4;
 779       b += 4;
 780       n_left -= 4;
 781     }
 782   while (n_left)
 783     {
 784       vlib_buffer_copy_template (b[0], bt);
 785       n_rx_bytes += b[0]->current_length = bc[0] & bc_mask;
 786       /* next */
 787       bc++;
 788       b++;
 789       n_left--;
 790     }
 791   return n_rx_bytes;
 792 }
 793
 794 static_always_inline void
 795 rdma_device_mlx5dv_legacy_rq_fix_chains (vlib_main_t * vm, rdma_rxq_t * rxq,
 796                                          vlib_buffer_t ** bufs, u32 qs_mask,
 797                                          u32 n)
 798 {
 799   u32 buf_sz = rxq->buf_sz;
 800   uword slot = (rxq->head - n) & qs_mask;
 801   u32 *second = &rxq->second_bufs[slot];
 802   u32 n_wrap_around = (slot + n) & (qs_mask + 1) ? (slot + n) & qs_mask : 0;
 803   u8 *n_used_per_chain = &rxq->n_used_per_chain[slot];
 804   n -= n_wrap_around;
 805 wrap_around:
 806   while (n > 0)
 807     {
 808       u16 total_length = bufs[0]->current_length;
 809       if (total_length > buf_sz)
 810         {
 811           vlib_buffer_t *current_buf = bufs[0];
 812           u8 current_chain_sz = 0;
 813           current_buf->current_length = buf_sz;
 814           total_length -= buf_sz;
 815           current_buf->total_length_not_including_first_buffer = total_length;
 816           current_buf->flags |= VLIB_BUFFER_NEXT_PRESENT;
 817           current_buf->next_buffer = second[0];
 818           do
 819             {
 820               current_buf = vlib_get_buffer (vm, current_buf->next_buffer);
 821               current_buf->current_length = clib_min (buf_sz, total_length);
 822               total_length -= current_buf->current_length;
 823               current_chain_sz++;
 824             }
 825           while (total_length > 0);
 826           current_buf->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
 827           second[0] = current_buf->next_buffer;
 828           current_buf->next_buffer = 0;
 829           rxq->n_total_additional_segs += current_chain_sz;
 830           n_used_per_chain[0] = current_chain_sz;
 831         }
 832       bufs++;
 833       second++;
 834       n_used_per_chain++;
 835       n--;
 836     }
 837   if (PREDICT_FALSE (n_wrap_around))
 838     {
 839       n = n_wrap_around;
 840       n_wrap_around = 0;
 841       second = rxq->second_bufs;
 842       n_used_per_chain = rxq->n_used_per_chain;
 843       goto wrap_around;
 844     }
 845 }
 846
 847 static_always_inline u32
 848 rdma_device_mlx5dv_striding_rq_input (vlib_main_t * vm,
 849                                       rdma_per_thread_data_t * ptd,
 850                                       rdma_rxq_t * rxq,
 851                                       vlib_buffer_t * bt, u32 * to_next,
 852                                       int n_rx_segs, int *n_rx_packets,
 853                                       u32 * bc, int slow_path_needed)
 854 {
 855   u32 mask = rxq->size - 1;
 856   u32 n_rx_bytes = 0;
 857   if (PREDICT_TRUE (!slow_path_needed))
 858     {
 859       vlib_buffer_t *bufs[VLIB_FRAME_SIZE];
 860       n_rx_bytes +=
 861         rdma_device_mlx5dv_fast_input (vm, rxq, bufs, mask, bt, to_next,
 862                                        n_rx_segs, bc, CQE_BC_BYTE_COUNT_MASK);
 863     }
 864   else                          /* Slow path with multiseg */
 865     {
 866       vlib_buffer_t *pkt_head;  /*Current head buffer */
 867       vlib_buffer_t *pkt_prev;  /* Buffer processed at the previous iteration */
 868       u32 pkt_head_idx;
 869       vlib_buffer_t **pkt;
 870       uword n_segs_remaining = 0;       /*Remaining strides in current buffer */
 871       u32 n_bytes_remaining = 0;        /*Remaining bytes in current buffer */
 872       u32 *next_in_frame = to_next;
 873       u32 *next_to_free = ptd->to_free_buffers;
 874       bt->current_length = vlib_buffer_get_default_data_size (vm);
 875       do
 876         {
 877           vlib_buffer_t *bufs[VLIB_FRAME_SIZE];
 878           u32 n_left = clib_min (n_rx_segs, VLIB_FRAME_SIZE);
 879           n_rx_segs -= n_left;
 880           vlib_buffer_copy_indices_from_ring (ptd->current_segs,
 881                                               rxq->bufs, rxq->head & mask,
 882                                               rxq->size, n_left);
 883           rxq->head += n_left;
 884           vlib_get_buffers (vm, ptd->current_segs, bufs, n_left);
 885           pkt = bufs;
 886           while (n_left > 0)
 887             {
 888               /* Initialize the current buffer as full size */
 889               vlib_buffer_copy_template (pkt[0], bt);
 890               if (!n_segs_remaining)    /* No pending chain */
 891                 {
 892                   n_segs_remaining =
 893                     (bc[0] & CQE_BC_CONSUMED_STRIDES_MASK) >>
 894                     CQE_BC_CONSUMED_STRIDES_SHIFT;
 895                   pkt_head = pkt[0];
 896                   pkt_head_idx = ptd->current_segs[pkt - bufs];
 897                   n_bytes_remaining = bc[0] & CQE_BC_BYTE_COUNT_MASK;
 898                   pkt_head->total_length_not_including_first_buffer =
 899                     n_segs_remaining >
 900                     1 ? n_bytes_remaining - pkt[0]->current_length : 0;
 901                 }
 902               else              /* Perform chaining if it's a continuation buffer */
 903                 {
 904                   pkt_prev->next_buffer = ptd->current_segs[pkt - bufs];
 905                   pkt_prev->flags |= VLIB_BUFFER_NEXT_PRESENT;
 906                   pkt[0]->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
 907                 }
 908               if (n_segs_remaining == 1)        /* Last buffer of the chain */
 909                 {
 910                   pkt[0]->current_length = n_bytes_remaining;
 911                   if (bc[0] & CQE_BC_FILLER_MASK)
 912                     {
 913                       (next_to_free++)[0] = pkt_head_idx;
 914                       (*n_rx_packets)--;
 915                     }
 916
 917                   else
 918                     {
 919                       (next_in_frame++)[0] = pkt_head_idx;
 920                       n_rx_bytes +=
 921                         pkt_head->current_length +
 922                         pkt_head->total_length_not_including_first_buffer;
 923                     }
 924                   /*Go to next CQE */
 925                   bc++;
 926                 }
 927               else
 928                 {
 929                   n_bytes_remaining -= pkt[0]->current_length;
 930                   pkt_prev = pkt[0];
 931                 }
 932               n_segs_remaining--;
 933               n_left--;
 934               pkt++;
 935             }
 936
 937         }
 938       while (n_rx_segs > 0);
 939       vlib_buffer_free (vm, ptd->to_free_buffers,
 940                         next_to_free - ptd->to_free_buffers);
 941     }
 942   return n_rx_bytes;
 943 }
 944
 945 static_always_inline uword
 946 rdma_device_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 947                           vlib_frame_t * frame, rdma_device_t * rd,
 948                           u16 qid, const int use_mlx5dv)
 949 {
 950   rdma_main_t *rm = &rdma_main;
 951   vnet_main_t *vnm = vnet_get_main ();
 952   rdma_per_thread_data_t *ptd = vec_elt_at_index (rm->per_thread_data,
 953                                                   vm->thread_index);
 954   rdma_rxq_t *rxq = vec_elt_at_index (rd->rxqs, qid);
 955   struct ibv_wc wc[VLIB_FRAME_SIZE];
 956   u32 __clib_aligned (32) byte_cnts[VLIB_FRAME_SIZE];
 957   vlib_buffer_t bt;
 958   u32 next_index, *to_next, n_left_to_next, n_rx_bytes = 0;
 959   int n_rx_packets, skip_ip4_cksum = 0;
 960   u32 mask = rxq->size - 1;
 961   const int is_striding = ! !(rd->flags & RDMA_DEVICE_F_STRIDING_RQ);
 962
 963   if (use_mlx5dv)
 964     n_rx_packets = rdma_device_poll_cq_mlx5dv (rd, rxq, byte_cnts,
 965                                                ptd->cqe_flags);
 966   else
 967     n_rx_packets = ibv_poll_cq (rxq->cq, VLIB_FRAME_SIZE, wc);
 968
 969   /* init buffer template */
 970   vlib_buffer_copy_template (&bt, &ptd->buffer_template);
 971   vnet_buffer (&bt)->sw_if_index[VLIB_RX] = rd->sw_if_index;
 972   bt.buffer_pool_index = rd->pool;
 973
 974   if (PREDICT_FALSE (n_rx_packets <= 0))
 975     goto refill;
 976
 977   /* update buffer template for input feature arcs if any */
 978   next_index = rd->per_interface_next_index;
 979   if (PREDICT_FALSE (vnet_device_input_have_features (rd->sw_if_index)))
 980     vnet_feature_start_device_input (rd->sw_if_index, &next_index, &bt);
 981
 982   vlib_get_new_next_frame (vm, node, next_index, to_next, n_left_to_next);
 983
 984   if (use_mlx5dv)
 985     {
 986       u32 *bc = byte_cnts;
 987       int slow_path_needed;
 988       skip_ip4_cksum =
 989         rdma_device_mlx5dv_l3_validate_and_swap_bc (ptd, n_rx_packets, bc);
 990       if (is_striding)
 991         {
 992           int n_rx_segs = 0;
 993           slow_path_needed =
 994             rdma_device_mlx5dv_striding_rq_parse_bc (n_rx_packets,
 995                                                      &n_rx_segs, bc);
 996           n_rx_bytes =
 997             rdma_device_mlx5dv_striding_rq_input (vm, ptd, rxq, &bt,
 998                                                   to_next, n_rx_segs,
 999                                                   &n_rx_packets, bc,
1000                                                   slow_path_needed);
1001         }
1002       else
1003         {
1004           vlib_buffer_t *bufs[VLIB_FRAME_SIZE];
1005           slow_path_needed =
1006             rdma_device_mlx5dv_legacy_rq_slow_path_needed (rxq->buf_sz,
1007                                                            n_rx_packets, bc);
1008           n_rx_bytes = rdma_device_mlx5dv_fast_input (
1009             vm, rxq, bufs, mask, &bt, to_next, n_rx_packets, bc, ~0);
1010
1011           /* If there are chained buffers, some of the head buffers have a current length
1012              higher than buf_sz: it needs to be fixed */
1013           if (PREDICT_FALSE (slow_path_needed))
1014             rdma_device_mlx5dv_legacy_rq_fix_chains (vm, rxq, bufs, mask,
1015                                                      n_rx_packets);
1016         }
1017     }
1018   else
1019     {
1020       vlib_buffer_t *bufs[VLIB_FRAME_SIZE];
1021       vlib_buffer_copy_indices_from_ring (to_next, rxq->bufs,
1022                                           rxq->head & mask,
1023                                           rxq->size, n_rx_packets);
1024       vlib_get_buffers (vm, to_next, bufs, n_rx_packets);
1025       rxq->head += n_rx_packets;
1026       n_rx_bytes =
1027         rdma_device_input_bufs (vm, rd, bufs, wc, n_rx_packets, &bt);
1028
1029     }
1030
1031   rdma_device_input_ethernet (vm, node, rd, next_index, skip_ip4_cksum);
1032   vlib_put_next_frame (vm, node, next_index, n_left_to_next - n_rx_packets);
1033   rdma_device_input_trace (vm, node, rd, n_rx_packets, to_next,
1034                            next_index, ptd->cqe_flags, use_mlx5dv);
1035   /* reset flags to zero for the next run */
1036   if (use_mlx5dv)
1037     clib_memset_u16 (ptd->cqe_flags, 0, VLIB_FRAME_SIZE);
1038   vlib_increment_combined_counter (vnm->interface_main.
1039                                    combined_sw_if_counters +
1040                                    VNET_INTERFACE_COUNTER_RX,
1041                                    vm->thread_index, rd->hw_if_index,
1042                                    n_rx_packets, n_rx_bytes);
1043 refill:
1044   rdma_device_input_refill (vm, rd, rxq, &bt, use_mlx5dv, is_striding);
1045   return n_rx_packets;
1046 }
1047
1048 VLIB_NODE_FN (rdma_input_node) (vlib_main_t * vm,
1049                                 vlib_node_runtime_t * node,
1050                                 vlib_frame_t * frame)
1051 {
1052   u32 n_rx = 0;
1053   rdma_main_t *rm = &rdma_main;
1054   vnet_hw_if_rxq_poll_vector_t *pv;
1055   pv = vnet_hw_if_get_rxq_poll_vector (vm, node);
1056   for (int i = 0; i < vec_len (pv); i++)
1057     {
1058       rdma_device_t *rd;
1059       rd = vec_elt_at_index (rm->devices, pv[i].dev_instance);
1060       if (PREDICT_TRUE (rd->flags & RDMA_DEVICE_F_ADMIN_UP) == 0)
1061         continue;
1062
1063       if (PREDICT_FALSE (rd->flags & RDMA_DEVICE_F_ERROR))
1064         continue;
1065
1066       if (PREDICT_TRUE (rd->flags & RDMA_DEVICE_F_MLX5DV))
1067         n_rx +=
1068           rdma_device_input_inline (vm, node, frame, rd, pv[i].queue_id, 1);
1069       else
1070         n_rx +=
1071           rdma_device_input_inline (vm, node, frame, rd, pv[i].queue_id, 0);
1072     }
1073   return n_rx;
1074 }
1075
1076 /* *INDENT-OFF* */
1077 VLIB_REGISTER_NODE (rdma_input_node) = {
1078   .name = "rdma-input",
1079   .flags = VLIB_NODE_FLAG_TRACE_SUPPORTED,
1080   .sibling_of = "device-input",
1081   .format_trace = format_rdma_input_trace,
1082   .type = VLIB_NODE_TYPE_INPUT,
1083   .state = VLIB_NODE_STATE_DISABLED,
1084   .n_errors = RDMA_INPUT_N_ERROR,
1085   .error_strings = rdma_input_error_strings,
1086 };
1087
1088 /* *INDENT-ON* */
1089
1090
1091 /*
1092  * fd.io coding-style-patch-verification: ON
1093  *
1094  * Local Variables:
1095  * eval: (c-set-style "gnu")
1096  * End:
1097  */