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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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 *------------------------------------------------------------------
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>
25 #include <rdma/rdma.h>
27 #define foreach_rdma_input_error \
28 _(BUFFER_ALLOC, "buffer alloc error")
32 #define _(f,s) RDMA_INPUT_ERROR_##f,
33 foreach_rdma_input_error
38 static __clib_unused char *rdma_input_error_strings[] = {
40 foreach_rdma_input_error
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)
50 s[0].length = data_size;
57 static_always_inline u32
58 rdma_device_legacy_input_refill_additional (vlib_main_t * vm,
61 rdma_per_thread_data_t * ptd,
63 u32 first_slot, u32 n_alloc)
66 u8 log_wqe_sz = rxq->log_wqe_sz;
67 u32 *bi = ptd->tmp_bi;
68 vlib_buffer_t **bufs = ptd->tmp_bufs;
70 for (i = 0; i < n_alloc; i++)
72 u8 chain_sz = rxq->n_used_per_chain[first_slot + i];
74 mlx5dv_wqe_ds_t *current_wqe =
75 rxq->wqes + ((first_slot + i) << log_wqe_sz);
78 if (PREDICT_FALSE ((chain_sz_alloc =
79 vlib_buffer_alloc_from_pool (vm, bi, chain_sz,
83 vlib_buffer_free (vm, bi, chain_sz_alloc);
87 vlib_get_buffers (vm, bi, bufs, chain_sz);
88 for (int j = 0; j < chain_sz - 1; j++)
90 vlib_buffer_copy_template (bufs[j], bt);
91 bufs[j]->next_buffer = bi[j + 1];
92 bufs[j]->flags |= VLIB_BUFFER_NEXT_PRESENT;
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)
99 bufs[chain_sz - 1]->next_buffer = rxq->second_bufs[first_slot + i];
100 bufs[chain_sz - 1]->flags |= VLIB_BUFFER_NEXT_PRESENT;
104 bufs[chain_sz - 1]->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
107 /* Update the wqes */
108 for (int j = 0; j < chain_sz; j++)
111 vlib_get_buffers_with_offset (vm, bi + j,
113 sizeof (vlib_buffer_t));
114 current_wqe[j + 1].addr = clib_host_to_net_u64 (addr);
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];
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)
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;
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;
142 /*In legacy mode, maybe some buffers chains are incomplete? */
144 (is_mlx5dv && !is_striding && (rxq->incomplete_tail != rxq->tail)))
146 int n_incomplete = rxq->incomplete_tail - rxq->tail;
148 rdma_device_legacy_input_refill_additional (vm, rd, rxq, ptd, bt,
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)
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));
161 ring_space = rxq->size - (rxq->tail - rxq->head);
163 n_alloc = clib_min (VLIB_FRAME_SIZE, ring_space);
165 /* do not bother to allocate if too small */
166 if (n_alloc < 2 * alloc_multiple)
169 /* avoid wrap-around logic in core loop */
170 n_alloc = clib_min (n_alloc, rxq->size - slot);
172 n_alloc &= ~(alloc_multiple - 1); /* round to alloc_multiple */
174 n = vlib_buffer_alloc_to_ring_from_pool (vm, rxq->bufs, slot, rxq->size,
177 if (PREDICT_FALSE (n != n_alloc))
180 if (n < alloc_multiple)
183 vlib_buffer_free_from_ring (vm, rxq->bufs, slot, rxq->size, n);
187 /* partial allocation, round and return rest */
188 n_free = n & (alloc_multiple - 1);
191 vlib_buffer_free_from_ring (vm, rxq->bufs, (slot + n) & mask,
199 u64 __clib_aligned (32) va[8];
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;
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;
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));
222 for (int i = 0; i < 8; i++)
223 va[i] = clib_host_to_net_u64 (va[i]);
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... */
232 if (is_striding && !(current_data_seg & (wqe_sz - 1)))
233 *(mlx5dv_wqe_srq_next_t *) wqe = (mlx5dv_wqe_srq_next_t)
236 .next_wqe_index = clib_host_to_net_u16 (((wqes_slot >> log_wqe_sz) + 1) & (wqe_cnt - 1)),
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)))
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];
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;
263 /* In legacy mode, there is some work required to finish building the SG lists */
266 int first_slot = slot - n_alloc;
267 rxq->incomplete_tail += n_alloc;
268 if (PREDICT_FALSE (rxq->n_total_additional_segs))
270 rdma_device_legacy_input_refill_additional (vm, rd, rxq, ptd,
274 CLIB_MEMORY_STORE_BARRIER ();
275 rxq->tail += n_alloc;
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);
283 rxq->wq_db[MLX5_RCV_DBR] = clib_host_to_net_u32 (rxq->tail);
290 if (PREDICT_TRUE (n >= 16))
292 clib_prefetch_store (s + 16);
293 clib_prefetch_store (w + 16);
296 vlib_get_buffers_with_offset (vm, bufs, (void **) va, 8,
297 sizeof (vlib_buffer_t));
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);
312 w[-1].next = 0; /* fix next pointer in WR linked-list last item */
315 if (ibv_post_wq_recv (rxq->wq, wr, &w) != 0)
318 vlib_buffer_free_from_ring (vm, rxq->bufs, slot + n, rxq->size,
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,
331 u32 n_trace = vlib_get_trace_count (vm, node);
333 if (PREDICT_TRUE (0 == n_trace))
336 while (n_trace && n_left)
338 vlib_buffer_t *b = vlib_get_buffer (vm, bi[0]);
340 (vlib_trace_buffer (vm, node, next_index, b, /* follow_chain */ 0)))
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;
353 vlib_set_trace_count (vm, node, n_trace);
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,
361 vlib_next_frame_t *nf;
363 ethernet_input_frame_t *ef;
365 if (PREDICT_FALSE (VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT != next_index))
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;
374 f->flags |= ETH_INPUT_FRAME_F_IP4_CKSUM_OK;
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;
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)
388 while (n_left_from >= 4)
390 if (PREDICT_TRUE (n_left_from >= 8))
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);
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);
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;
417 while (n_left_from >= 1)
419 vlib_buffer_copy_template (b[0], bt);
420 n_rx_bytes += b[0]->current_length = wc[0].byte_len;
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)
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);
438 mcqe_array_index = cq_ci;
446 mcqe_array_index = (mcqe_array_index + n) & mask;
447 mcqe = (mlx5dv_mini_cqe_t *) (rxq->cqes + mcqe_array_index);
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);
466 for (int i = 0; i < 8; i++)
467 byte_cnt[i] = mcqe[i].byte_count;
471 mcqe_array_index = (mcqe_array_index + 8) & mask;
472 mcqe = (mlx5dv_mini_cqe_t *) (rxq->cqes + mcqe_array_index);
477 for (int i = 0; i < n_left; i++)
478 byte_cnt[i] = mcqe[i].byte_count;
482 static_always_inline void
483 cqe_set_owner (mlx5dv_cqe_t * cqe, u32 n_left, u8 owner)
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;
500 cqe[0].opcode_cqefmt_se_owner = owner;
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)
511 u32 offset, cq_size = 1 << log2_cq_size;
514 /* first CQE is reset by hardware */
518 offset = cq_ci & mask;
519 owner = 0xf0 | ((cq_ci >> log2_cq_size) & 1);
521 if (offset + n_mini_cqes < cq_size)
523 cqe_set_owner (rxq->cqes + offset, n_mini_cqes, owner);
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);
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)
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;
543 if (rxq->n_mini_cqes_left)
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,
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;
560 while (n_rx_packets < VLIB_FRAME_SIZE)
562 u8 cqe_last_byte, owner;
563 mlx5dv_cqe_t *cqe = rxq->cqes + (cq_ci & mask);
565 clib_prefetch_load (rxq->cqes + ((cq_ci + 8) & mask));
567 owner = (cq_ci >> log2_cq_size) & 1;
568 cqe_last_byte = cqe->opcode_cqefmt_se_owner;
570 if ((cqe_last_byte & 0x1) != owner)
573 cqe_last_byte &= 0xfc; /* remove owner and solicited bits */
575 if (cqe_last_byte == 0x2c) /* OPCODE = 0x2 (Responder Send), Format = 0x3 (Compressed CQE) */
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;
581 if (n_left >= n_mini_cqes)
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,
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;
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;
605 if (cqe_last_byte == 0x20) /* OPCODE = 0x2 (Responder Send), Format = 0x0 (no inline data) */
607 byte_cnt[0] = cqe->byte_cnt;
608 cqe_flags[0] = cqe->flags;
616 rd->flags |= RDMA_DEVICE_F_ERROR;
622 rxq->cq_db[0] = rxq->cq_ci = cq_ci;
626 static_always_inline int
627 rdma_device_mlx5dv_striding_rq_parse_bc (int n_rx_packets, int *n_rx_segs,
630 /* Determine if slow path is needed */
632 for (int i = 0; i < n_rx_packets; i++)
635 (bc[i] & CQE_BC_CONSUMED_STRIDES_MASK) >>
636 CQE_BC_CONSUMED_STRIDES_SHIFT;
637 filler |= ! !(bc[i] & CQE_BC_FILLER_MASK);
639 return n_rx_packets != *n_rx_segs || filler;
642 static_always_inline int
643 rdma_device_mlx5dv_legacy_rq_slow_path_needed (u32 buf_sz, int n_rx_packets,
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))
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))
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)
673 u16 mask = CQE_FLAG_L3_HDR_TYPE_MASK | CQE_FLAG_L3_OK;
675 CQE_FLAG_L3_HDR_TYPE_IP4 << CQE_FLAG_L3_HDR_TYPE_SHIFT | CQE_FLAG_L3_OK;
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);
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;
686 #if defined CLIB_HAVE_VEC256
687 if (n_rx_packets >= 16)
689 u16x16 mask16 = u16x16_splat (mask);
690 u16x16 match16 = u16x16_splat (match);
693 n_left = n_rx_packets % 16;
695 for (int i = 0; i < n_rx_packets / 16; i++)
696 r16 |= (ptd->cqe_flags16[i] & mask16) != match16;
698 if (!u16x16_is_all_zero (r16))
701 for (int i = 0; i < (n_rx_packets - n_left); i += 8)
702 *(u32x8 *) (bc + i) = u32x8_byte_swap (*(u32x8 *) (bc + i));
704 #elif defined CLIB_HAVE_VEC128
705 if (n_rx_packets >= 8)
707 u16x8 mask8 = u16x8_splat (mask);
708 u16x8 match8 = u16x8_splat (match);
711 n_left = n_rx_packets % 8;
713 for (int i = 0; i < n_rx_packets / 8; i++)
714 r8 |= (ptd->cqe_flags8[i] & mask8) != match8;
716 if (!u16x8_is_all_zero (r8))
719 for (int i = 0; i < (n_rx_packets - n_left); i += 4)
720 *(u32x4 *) (bc + i) = u32x4_byte_swap (*(u32x4 *) (bc + i));
723 for (int i = (n_rx_packets - n_left); i < n_rx_packets; i++)
724 if ((ptd->cqe_flags[i] & mask) != match)
727 for (int i = (n_rx_packets - n_left); i < n_rx_packets; i++)
728 bc[i] = clib_net_to_host_u32 (bc[i]);
730 return skip_ip4_cksum;
733 static_always_inline u32
734 rdma_device_mlx5dv_fast_input (vlib_main_t * vm, rdma_rxq_t * rxq,
735 vlib_buffer_t ** bufs,
736 u32 qs_mask, vlib_buffer_t * bt,
737 u32 * to_next, u32 n_rx_segs, u32 * bc,
740 vlib_buffer_t **b = bufs;
741 u32 n_left = n_rx_segs;
743 vlib_buffer_copy_indices_from_ring (to_next, rxq->bufs,
744 rxq->head & qs_mask, rxq->size,
746 rxq->head += n_rx_segs;
747 vlib_get_buffers (vm, to_next, bufs, n_rx_segs);
750 clib_prefetch_store (b[4]);
751 vlib_buffer_copy_template (b[0], bt);
752 n_rx_bytes += b[0]->current_length = bc[0] & bc_mask;
753 clib_prefetch_store (b[5]);
754 vlib_buffer_copy_template (b[1], bt);
755 n_rx_bytes += b[1]->current_length = bc[1] & bc_mask;
756 clib_prefetch_store (b[6]);
757 vlib_buffer_copy_template (b[2], bt);
758 n_rx_bytes += b[2]->current_length = bc[2] & bc_mask;
759 clib_prefetch_store (b[7]);
760 vlib_buffer_copy_template (b[3], bt);
761 n_rx_bytes += b[3]->current_length = bc[3] & bc_mask;
769 vlib_buffer_copy_template (b[0], bt);
770 n_rx_bytes += b[0]->current_length = bc[0] & bc_mask;
779 static_always_inline void
780 rdma_device_mlx5dv_legacy_rq_fix_chains (vlib_main_t * vm, rdma_rxq_t * rxq,
781 vlib_buffer_t ** bufs, u32 qs_mask,
784 u32 buf_sz = rxq->buf_sz;
785 uword slot = (rxq->head - n) & qs_mask;
786 u32 *second = &rxq->second_bufs[slot];
787 u32 n_wrap_around = (slot + n) & (qs_mask + 1) ? (slot + n) & qs_mask : 0;
788 u8 *n_used_per_chain = &rxq->n_used_per_chain[slot];
793 u16 total_length = bufs[0]->current_length;
794 if (total_length > buf_sz)
796 vlib_buffer_t *current_buf = bufs[0];
797 u8 current_chain_sz = 0;
798 current_buf->current_length = buf_sz;
799 total_length -= buf_sz;
800 current_buf->total_length_not_including_first_buffer = total_length;
801 current_buf->flags |= VLIB_BUFFER_NEXT_PRESENT;
802 current_buf->next_buffer = second[0];
805 current_buf = vlib_get_buffer (vm, current_buf->next_buffer);
806 current_buf->current_length = clib_min (buf_sz, total_length);
807 total_length -= current_buf->current_length;
810 while (total_length > 0);
811 current_buf->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
812 second[0] = current_buf->next_buffer;
813 current_buf->next_buffer = 0;
814 rxq->n_total_additional_segs += current_chain_sz;
815 n_used_per_chain[0] = current_chain_sz;
822 if (PREDICT_FALSE (n_wrap_around))
826 second = rxq->second_bufs;
827 n_used_per_chain = rxq->n_used_per_chain;
832 static_always_inline u32
833 rdma_device_mlx5dv_striding_rq_input (vlib_main_t * vm,
834 rdma_per_thread_data_t * ptd,
836 vlib_buffer_t * bt, u32 * to_next,
837 int n_rx_segs, int *n_rx_packets,
838 u32 * bc, int slow_path_needed)
840 u32 mask = rxq->size - 1;
842 if (PREDICT_TRUE (!slow_path_needed))
844 vlib_buffer_t *bufs[VLIB_FRAME_SIZE];
846 rdma_device_mlx5dv_fast_input (vm, rxq, bufs, mask, bt, to_next,
847 n_rx_segs, bc, CQE_BC_BYTE_COUNT_MASK);
849 else /* Slow path with multiseg */
851 vlib_buffer_t *pkt_head; /*Current head buffer */
852 vlib_buffer_t *pkt_prev; /* Buffer processed at the previous iteration */
855 uword n_segs_remaining = 0; /*Remaining strides in current buffer */
856 u32 n_bytes_remaining = 0; /*Remaining bytes in current buffer */
857 u32 *next_in_frame = to_next;
858 u32 *next_to_free = ptd->to_free_buffers;
859 bt->current_length = vlib_buffer_get_default_data_size (vm);
862 vlib_buffer_t *bufs[VLIB_FRAME_SIZE];
863 u32 n_left = clib_min (n_rx_segs, VLIB_FRAME_SIZE);
865 vlib_buffer_copy_indices_from_ring (ptd->current_segs,
866 rxq->bufs, rxq->head & mask,
869 vlib_get_buffers (vm, ptd->current_segs, bufs, n_left);
873 /* Initialize the current buffer as full size */
874 vlib_buffer_copy_template (pkt[0], bt);
875 if (!n_segs_remaining) /* No pending chain */
878 (bc[0] & CQE_BC_CONSUMED_STRIDES_MASK) >>
879 CQE_BC_CONSUMED_STRIDES_SHIFT;
881 pkt_head_idx = ptd->current_segs[pkt - bufs];
882 n_bytes_remaining = bc[0] & CQE_BC_BYTE_COUNT_MASK;
883 pkt_head->total_length_not_including_first_buffer =
885 1 ? n_bytes_remaining - pkt[0]->current_length : 0;
887 else /* Perform chaining if it's a continuation buffer */
889 pkt_prev->next_buffer = ptd->current_segs[pkt - bufs];
890 pkt_prev->flags |= VLIB_BUFFER_NEXT_PRESENT;
891 pkt[0]->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
893 if (n_segs_remaining == 1) /* Last buffer of the chain */
895 pkt[0]->current_length = n_bytes_remaining;
896 if (bc[0] & CQE_BC_FILLER_MASK)
898 (next_to_free++)[0] = pkt_head_idx;
904 (next_in_frame++)[0] = pkt_head_idx;
906 pkt_head->current_length +
907 pkt_head->total_length_not_including_first_buffer;
914 n_bytes_remaining -= pkt[0]->current_length;
923 while (n_rx_segs > 0);
924 vlib_buffer_free (vm, ptd->to_free_buffers,
925 next_to_free - ptd->to_free_buffers);
930 static_always_inline uword
931 rdma_device_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
932 vlib_frame_t * frame, rdma_device_t * rd,
933 u16 qid, const int use_mlx5dv)
935 rdma_main_t *rm = &rdma_main;
936 vnet_main_t *vnm = vnet_get_main ();
937 rdma_per_thread_data_t *ptd = vec_elt_at_index (rm->per_thread_data,
939 rdma_rxq_t *rxq = vec_elt_at_index (rd->rxqs, qid);
940 struct ibv_wc wc[VLIB_FRAME_SIZE];
941 u32 __clib_aligned (32) byte_cnts[VLIB_FRAME_SIZE];
943 u32 next_index, *to_next, n_left_to_next, n_rx_bytes = 0;
944 int n_rx_packets, skip_ip4_cksum = 0;
945 u32 mask = rxq->size - 1;
946 const int is_striding = ! !(rd->flags & RDMA_DEVICE_F_STRIDING_RQ);
949 n_rx_packets = rdma_device_poll_cq_mlx5dv (rd, rxq, byte_cnts,
952 n_rx_packets = ibv_poll_cq (rxq->cq, VLIB_FRAME_SIZE, wc);
954 /* init buffer template */
955 vlib_buffer_copy_template (&bt, &ptd->buffer_template);
956 vnet_buffer (&bt)->sw_if_index[VLIB_RX] = rd->sw_if_index;
957 bt.buffer_pool_index = rd->pool;
959 if (PREDICT_FALSE (n_rx_packets <= 0))
962 /* update buffer template for input feature arcs if any */
963 next_index = rd->per_interface_next_index;
964 if (PREDICT_FALSE (vnet_device_input_have_features (rd->sw_if_index)))
965 vnet_feature_start_device_input_x1 (rd->sw_if_index, &next_index, &bt);
967 vlib_get_new_next_frame (vm, node, next_index, to_next, n_left_to_next);
972 int slow_path_needed;
974 rdma_device_mlx5dv_l3_validate_and_swap_bc (ptd, n_rx_packets, bc);
979 rdma_device_mlx5dv_striding_rq_parse_bc (n_rx_packets,
982 rdma_device_mlx5dv_striding_rq_input (vm, ptd, rxq, &bt,
989 vlib_buffer_t *bufs[VLIB_FRAME_SIZE];
991 rdma_device_mlx5dv_legacy_rq_slow_path_needed (rxq->buf_sz,
993 n_rx_bytes = rdma_device_mlx5dv_fast_input (
994 vm, rxq, bufs, mask, &bt, to_next, n_rx_packets, bc, ~0);
996 /* If there are chained buffers, some of the head buffers have a current length
997 higher than buf_sz: it needs to be fixed */
998 if (PREDICT_FALSE (slow_path_needed))
999 rdma_device_mlx5dv_legacy_rq_fix_chains (vm, rxq, bufs, mask,
1005 vlib_buffer_t *bufs[VLIB_FRAME_SIZE];
1006 vlib_buffer_copy_indices_from_ring (to_next, rxq->bufs,
1008 rxq->size, n_rx_packets);
1009 vlib_get_buffers (vm, to_next, bufs, n_rx_packets);
1010 rxq->head += n_rx_packets;
1012 rdma_device_input_bufs (vm, rd, bufs, wc, n_rx_packets, &bt);
1016 rdma_device_input_ethernet (vm, node, rd, next_index, skip_ip4_cksum);
1017 vlib_put_next_frame (vm, node, next_index, n_left_to_next - n_rx_packets);
1018 rdma_device_input_trace (vm, node, rd, n_rx_packets, to_next,
1019 next_index, ptd->cqe_flags, use_mlx5dv);
1020 /* reset flags to zero for the next run */
1022 clib_memset_u16 (ptd->cqe_flags, 0, VLIB_FRAME_SIZE);
1023 vlib_increment_combined_counter (vnm->interface_main.
1024 combined_sw_if_counters +
1025 VNET_INTERFACE_COUNTER_RX,
1026 vm->thread_index, rd->hw_if_index,
1027 n_rx_packets, n_rx_bytes);
1029 rdma_device_input_refill (vm, rd, rxq, &bt, use_mlx5dv, is_striding);
1030 return n_rx_packets;
1033 VLIB_NODE_FN (rdma_input_node) (vlib_main_t * vm,
1034 vlib_node_runtime_t * node,
1035 vlib_frame_t * frame)
1038 rdma_main_t *rm = &rdma_main;
1039 vnet_hw_if_rxq_poll_vector_t *pv;
1040 pv = vnet_hw_if_get_rxq_poll_vector (vm, node);
1041 for (int i = 0; i < vec_len (pv); i++)
1044 rd = vec_elt_at_index (rm->devices, pv[i].dev_instance);
1045 if (PREDICT_TRUE (rd->flags & RDMA_DEVICE_F_ADMIN_UP) == 0)
1048 if (PREDICT_FALSE (rd->flags & RDMA_DEVICE_F_ERROR))
1051 if (PREDICT_TRUE (rd->flags & RDMA_DEVICE_F_MLX5DV))
1053 rdma_device_input_inline (vm, node, frame, rd, pv[i].queue_id, 1);
1056 rdma_device_input_inline (vm, node, frame, rd, pv[i].queue_id, 0);
1062 VLIB_REGISTER_NODE (rdma_input_node) = {
1063 .name = "rdma-input",
1064 .flags = VLIB_NODE_FLAG_TRACE_SUPPORTED,
1065 .sibling_of = "device-input",
1066 .format_trace = format_rdma_input_trace,
1067 .type = VLIB_NODE_TYPE_INPUT,
1068 .state = VLIB_NODE_STATE_DISABLED,
1069 .n_errors = RDMA_INPUT_N_ERROR,
1070 .error_strings = rdma_input_error_strings,
1077 * fd.io coding-style-patch-verification: ON
1080 * eval: (c-set-style "gnu")