Code Review / vpp.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
API: Change ip4_address and ip6_address to use type alias.
[vpp.git] / src / plugins / avf / input.c
diff --git a/src/plugins/avf/input.c b/src/plugins/avf/input.c
index 475b207..509b497 100644 (file)
--- a/src/plugins/avf/input.c
+++ b/src/plugins/avf/input.c
@@ -48,13 +48,14 @@ static __clib_unused char *avf_input_error_strings[] = {
 #define AVF_INPUT_REFILL_TRESHOLD 32
 static_always_inline void
 avf_rxq_refill (vlib_main_t * vm, vlib_node_runtime_t * node, avf_rxq_t * rxq,
-               int use_iova)
+               int use_va_dma)
 {
   u16 n_refill, mask, n_alloc, slot;
   u32 s0, s1, s2, s3;
+  vlib_buffer_t *b[4];
   avf_rx_desc_t *d[4];
 
-  n_refill = rxq->size - 1 - rxq->n_bufs;
+  n_refill = rxq->size - 1 - rxq->n_enqueued;
   if (PREDICT_TRUE (n_refill <= AVF_INPUT_REFILL_TRESHOLD))
     return;
 
@@ -70,11 +71,11 @@ avf_rxq_refill (vlib_main_t * vm, vlib_node_runtime_t * node, avf_rxq_t * rxq,
       vlib_error_count (vm, node->node_index,
                        AVF_INPUT_ERROR_BUFFER_ALLOC, 1);
       if (n_alloc)
-       vlib_buffer_free (vm, rxq->bufs + slot, n_alloc);
+       vlib_buffer_free_from_ring (vm, rxq->bufs, slot, rxq->size, n_alloc);
       return;
     }
 
-  rxq->n_bufs += n_alloc;
+  rxq->n_enqueued += n_alloc;
 
   while (n_alloc >= 4)
     {
@@ -97,28 +98,24 @@ avf_rxq_refill (vlib_main_t * vm, vlib_node_runtime_t * node, avf_rxq_t * rxq,
       d[1] = ((avf_rx_desc_t *) rxq->descs) + s1;
       d[2] = ((avf_rx_desc_t *) rxq->descs) + s2;
       d[3] = ((avf_rx_desc_t *) rxq->descs) + s3;
-      if (use_iova)
+      b[0] = vlib_get_buffer (vm, rxq->bufs[s0]);
+      b[1] = vlib_get_buffer (vm, rxq->bufs[s1]);
+      b[2] = vlib_get_buffer (vm, rxq->bufs[s2]);
+      b[3] = vlib_get_buffer (vm, rxq->bufs[s3]);
+
+      if (use_va_dma)
        {
-         vlib_buffer_t *b;
-         b = vlib_get_buffer (vm, rxq->bufs[s0]);
-         d[0]->qword[0] = pointer_to_uword (b->data);
-         b = vlib_get_buffer (vm, rxq->bufs[s1]);
-         d[1]->qword[0] = pointer_to_uword (b->data);
-         b = vlib_get_buffer (vm, rxq->bufs[s2]);
-         d[2]->qword[0] = pointer_to_uword (b->data);
-         b = vlib_get_buffer (vm, rxq->bufs[s3]);
-         d[3]->qword[0] = pointer_to_uword (b->data);
+         d[0]->qword[0] = vlib_buffer_get_va (b[0]);
+         d[1]->qword[0] = vlib_buffer_get_va (b[1]);
+         d[2]->qword[0] = vlib_buffer_get_va (b[2]);
+         d[3]->qword[0] = vlib_buffer_get_va (b[3]);
        }
       else
        {
-         d[0]->qword[0] =
-           vlib_get_buffer_data_physical_address (vm, rxq->bufs[s0]);
-         d[1]->qword[0] =
-           vlib_get_buffer_data_physical_address (vm, rxq->bufs[s1]);
-         d[2]->qword[0] =
-           vlib_get_buffer_data_physical_address (vm, rxq->bufs[s2]);
-         d[3]->qword[0] =
-           vlib_get_buffer_data_physical_address (vm, rxq->bufs[s3]);
+         d[0]->qword[0] = vlib_buffer_get_pa (vm, b[0]);
+         d[1]->qword[0] = vlib_buffer_get_pa (vm, b[1]);
+         d[2]->qword[0] = vlib_buffer_get_pa (vm, b[2]);
+         d[3]->qword[0] = vlib_buffer_get_pa (vm, b[3]);
        }
 
       d[0]->qword[1] = 0;
@@ -134,14 +131,11 @@ avf_rxq_refill (vlib_main_t * vm, vlib_node_runtime_t * node, avf_rxq_t * rxq,
     {
       s0 = slot;
       d[0] = ((avf_rx_desc_t *) rxq->descs) + s0;
-      if (use_iova)
-       {
-         vlib_buffer_t *b = vlib_get_buffer (vm, rxq->bufs[s0]);
-         d[0]->qword[0] = pointer_to_uword (b->data);
-       }
+      b[0] = vlib_get_buffer (vm, rxq->bufs[s0]);
+      if (use_va_dma)
+       d[0]->qword[0] = vlib_buffer_get_va (b[0]);
       else
-       d[0]->qword[0] =
-         vlib_get_buffer_data_physical_address (vm, rxq->bufs[s0]);
+       d[0]->qword[0] = vlib_buffer_get_pa (vm, b[0]);
       d[0]->qword[1] = 0;
 
       /* next */
@@ -264,14 +258,14 @@ avf_process_rx_burst (vlib_main_t * vm, vlib_node_runtime_t * node,
            vnet_buffer (bt)->feature_arc_index;
        }
 
-      clib_memcpy (vnet_buffer (b[0])->sw_if_index,
-                  vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
-      clib_memcpy (vnet_buffer (b[1])->sw_if_index,
-                  vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
-      clib_memcpy (vnet_buffer (b[2])->sw_if_index,
-                  vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
-      clib_memcpy (vnet_buffer (b[3])->sw_if_index,
-                  vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
+      clib_memcpy_fast (vnet_buffer (b[0])->sw_if_index,
+                       vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
+      clib_memcpy_fast (vnet_buffer (b[1])->sw_if_index,
+                       vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
+      clib_memcpy_fast (vnet_buffer (b[2])->sw_if_index,
+                       vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
+      clib_memcpy_fast (vnet_buffer (b[3])->sw_if_index,
+                       vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
 
       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[1]);
@@ -301,10 +295,10 @@ avf_process_rx_burst (vlib_main_t * vm, vlib_node_runtime_t * node,
            vnet_buffer (bt)->feature_arc_index;
        }
 
-      clib_memcpy (vnet_buffer (b[0])->sw_if_index,
-                  vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
+      clib_memcpy_fast (vnet_buffer (b[0])->sw_if_index,
+                       vnet_buffer (bt)->sw_if_index, 2 * sizeof (u32));
 
-      VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
+      VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
 
       /* next */
       rxve += 1;
@@ -355,13 +349,13 @@ avf_device_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
       if (rxq->next + 11 < rxq->size)
        {
          int stride = 8;
-         CLIB_PREFETCH (rxq->descs + (rxq->next + stride),
+         CLIB_PREFETCH ((void *) (rxq->descs + (rxq->next + stride)),
                         CLIB_CACHE_LINE_BYTES, LOAD);
-         CLIB_PREFETCH (rxq->descs + (rxq->next + stride + 1),
+         CLIB_PREFETCH ((void *) (rxq->descs + (rxq->next + stride + 1)),
                         CLIB_CACHE_LINE_BYTES, LOAD);
-         CLIB_PREFETCH (rxq->descs + (rxq->next + stride + 2),
+         CLIB_PREFETCH ((void *) (rxq->descs + (rxq->next + stride + 2)),
                         CLIB_CACHE_LINE_BYTES, LOAD);
-         CLIB_PREFETCH (rxq->descs + (rxq->next + stride + 3),
+         CLIB_PREFETCH ((void *) (rxq->descs + (rxq->next + stride + 3)),
                         CLIB_CACHE_LINE_BYTES, LOAD);
        }
 
@@ -398,27 +392,27 @@ avf_device_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
       u64x4_store_unaligned (v, ptd->rx_vector + n_rxv);
       maybe_error |= !u64x4_is_all_zero (err4);
 
-      clib_memcpy (bi, rxq->bufs + rxq->next, 4 * sizeof (u32));
+      clib_memcpy_fast (bi, rxq->bufs + rxq->next, 4 * sizeof (u32));
 
       /* next */
       rxq->next = (rxq->next + 4) & mask;
       d = rxq->descs + rxq->next;
       n_rxv += 4;
-      rxq->n_bufs -= 4;
+      rxq->n_enqueued -= 4;
       bi += 4;
       continue;
     one_by_one:
 #endif
-      CLIB_PREFETCH (rxq->descs + ((rxq->next + 8) & mask),
+      CLIB_PREFETCH ((void *) (rxq->descs + ((rxq->next + 8) & mask)),
                     CLIB_CACHE_LINE_BYTES, LOAD);
       if ((d->qword[1] & AVF_RX_DESC_STATUS_DD) == 0)
        break;
       rxve = ptd->rx_vector + n_rxv;
       bi[0] = rxq->bufs[rxq->next];
-      rxve->status = avf_get_u64_bits (d, 8, 18, 0);
-      rxve->error = avf_get_u64_bits (d, 8, 26, 19);
-      rxve->ptype = avf_get_u64_bits (d, 8, 37, 30);
-      rxve->length = avf_get_u64_bits (d, 8, 63, 38);
+      rxve->status = avf_get_u64_bits ((void *) d, 8, 18, 0);
+      rxve->error = avf_get_u64_bits ((void *) d, 8, 26, 19);
+      rxve->ptype = avf_get_u64_bits ((void *) d, 8, 37, 30);
+      rxve->length = avf_get_u64_bits ((void *) d, 8, 63, 38);
       maybe_error |= rxve->error;
 
       /* deal with chained buffers */
@@ -431,7 +425,7 @@ avf_device_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
       rxq->next = (rxq->next + 1) & mask;
       d = rxq->descs + rxq->next;
       n_rxv++;
-      rxq->n_bufs--;
+      rxq->n_enqueued--;
       bi++;
     }
 
@@ -439,10 +433,10 @@ avf_device_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
     goto done;
 
   /* refill rx ring */
-  if (ad->flags & AVF_DEVICE_F_IOVA)
-    avf_rxq_refill (vm, node, rxq, 1 /* use_iova */ );
+  if (ad->flags & AVF_DEVICE_F_VA_DMA)
+    avf_rxq_refill (vm, node, rxq, 1 /* use_va_dma */ );
   else
-    avf_rxq_refill (vm, node, rxq, 0 /* use_iova */ );
+    avf_rxq_refill (vm, node, rxq, 0 /* use_va_dma */ );
 
   vlib_get_buffers (vm, buffer_indices, bufs, n_rxv);
   n_rx_packets = n_rxv;
@@ -492,7 +486,7 @@ avf_device_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
          tr = vlib_add_trace (vm, node, b, sizeof (*tr));
          tr->next_index = next[0];
          tr->hw_if_index = ad->hw_if_index;
-         clib_memcpy (&tr->rxve, rxve, sizeof (avf_rx_vector_entry_t));
+         clib_memcpy_fast (&tr->rxve, rxve, sizeof (avf_rx_vector_entry_t));
 
          /* next */
          n_trace--;
@@ -530,7 +524,6 @@ VLIB_NODE_FN (avf_input_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
   return n_rx;
 }
 
-#ifndef CLIB_MARCH_VARIANT
 /* *INDENT-OFF* */
 VLIB_REGISTER_NODE (avf_input_node) = {
   .name = "avf-input",
@@ -541,7 +534,6 @@ VLIB_REGISTER_NODE (avf_input_node) = {
   .n_errors = AVF_INPUT_N_ERROR,
   .error_strings = avf_input_error_strings,
 };
-#endif
 
 /* *INDENT-ON* */
 
Vector Packet Processing