interface: shorten vnet_hw_if_rx_mode

[vpp.git] / src / vnet / devices / virtio / device.c

diff --git a/src/vnet/devices/virtio/device.c b/src/vnet/devices/virtio/device.c
index dcd565d..32c1eab 100644 (file)
--- a/src/vnet/devices/virtio/device.c
+++ b/src/vnet/devices/virtio/device.c
@@ -312,11 +312,11 @@ set_gso_offsets (vlib_buffer_t * b, virtio_net_hdr_v1_t * hdr, int is_l2)
 }
 
 static_always_inline u16
-add_buffer_to_slot (vlib_main_t * vm, virtio_if_t * vif,
-                   virtio_if_type_t type, virtio_vring_t * vring,
-                   u32 bi, u16 free_desc_count,
+add_buffer_to_slot (vlib_main_t * vm, vlib_node_runtime_t * node,
+                   virtio_if_t * vif, virtio_if_type_t type,
+                   virtio_vring_t * vring, u32 bi, u16 free_desc_count,
                    u16 avail, u16 next, u16 mask, int do_gso,
-                   int csum_offload, uword node_index)
+                   int csum_offload)
 {
   u16 n_added = 0;
   int hdr_sz = vif->virtio_net_hdr_sz;
@@ -334,7 +334,7 @@ add_buffer_to_slot (vlib_main_t * vm, virtio_if_t * vif,
        set_gso_offsets (b, hdr, is_l2);
       else
        {
-         virtio_interface_drop_inline (vm, node_index, &bi, 1,
+         virtio_interface_drop_inline (vm, node->node_index, &bi, 1,
                                        VIRTIO_TX_ERROR_GSO_PACKET_DROP);
          return n_added;
        }
@@ -346,12 +346,17 @@ add_buffer_to_slot (vlib_main_t * vm, virtio_if_t * vif,
        set_checksum_offsets (b, hdr, is_l2);
       else
        {
-         virtio_interface_drop_inline (vm, node_index, &bi, 1,
+         virtio_interface_drop_inline (vm, node->node_index, &bi, 1,
                                        VIRTIO_TX_ERROR_CSUM_OFFLOAD_PACKET_DROP);
          return n_added;
        }
     }
 
+  if (PREDICT_FALSE (b->flags & VLIB_BUFFER_IS_TRACED))
+    {
+      virtio_tx_trace (vm, node, type, b, bi);
+    }
+
   if (PREDICT_TRUE ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0))
     {
       d->addr =
@@ -374,7 +379,7 @@ add_buffer_to_slot (vlib_main_t * vm, virtio_if_t * vif,
       u32 indirect_buffer = 0;
       if (PREDICT_FALSE (vlib_buffer_alloc (vm, &indirect_buffer, 1) == 0))
        {
-         virtio_interface_drop_inline (vm, node_index, &bi, 1,
+         virtio_interface_drop_inline (vm, node->node_index, &bi, 1,
                                        VIRTIO_TX_ERROR_INDIRECT_DESC_ALLOC_FAILED);
          return n_added;
        }
@@ -546,7 +551,7 @@ virtio_interface_tx_gso_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
   virtio_vring_t *vring;
   u16 qid = vm->thread_index % vif->num_txqs;
   vring = vec_elt_at_index (vif->txq_vrings, qid);
-  u16 used, next, avail;
+  u16 used, next, avail, n_buffers = 0, n_buffers_left = 0;
   u16 sz = vring->size;
   u16 mask = sz - 1;
   u16 retry_count = 2;
@@ -588,19 +593,46 @@ retry:
   else
     free_desc_count = sz - used;
 
-  while (n_left && free_desc_count)
+  if (vif->packet_buffering)
     {
-      u16 n_added = 0;
+      n_buffers = n_buffers_left = virtio_vring_n_buffers (vring->buffering);
 
-      vlib_buffer_t *b0 = vlib_get_buffer (vm, buffers[0]);
-      if (b0->flags & VLIB_BUFFER_IS_TRACED)
+      while (n_buffers_left && free_desc_count)
        {
-         virtio_tx_trace (vm, node, type, b0, buffers[0]);
+         u16 n_added = 0;
+
+         u32 bi = virtio_vring_buffering_read_from_front (vring->buffering);
+         if (bi == ~0)
+           break;
+
+         n_added =
+           add_buffer_to_slot (vm, node, vif, type, vring, bi,
+                               free_desc_count, avail, next, mask, do_gso,
+                               csum_offload);
+         if (PREDICT_FALSE (n_added == 0))
+           {
+             n_buffers_left--;
+             continue;
+           }
+         else if (PREDICT_FALSE (n_added > free_desc_count))
+           break;
+
+         avail++;
+         next = (next + n_added) & mask;
+         used += n_added;
+         n_buffers_left--;
+         free_desc_count -= n_added;
        }
+    }
+
+  while (n_left && free_desc_count)
+    {
+      u16 n_added = 0;
+
       n_added =
-       add_buffer_to_slot (vm, vif, type, vring, buffers[0], free_desc_count,
-                           avail, next, mask, do_gso, csum_offload,
-                           node->node_index);
+       add_buffer_to_slot (vm, node, vif, type, vring, buffers[0],
+                           free_desc_count, avail, next, mask, do_gso,
+                           csum_offload);
 
       if (PREDICT_FALSE (n_added == 0))
        {
@@ -619,7 +651,7 @@ retry:
       free_desc_count -= n_added;
     }
 
-  if (n_left != frame->n_vectors)
+  if (n_left != frame->n_vectors || n_buffers != n_buffers_left)
     {
       CLIB_MEMORY_STORE_BARRIER ();
       vring->avail->idx = avail;
@@ -634,9 +666,19 @@ retry:
       if (retry_count--)
        goto retry;
 
-      virtio_interface_drop_inline (vm, node->node_index,
-                                   buffers, n_left,
-                                   VIRTIO_TX_ERROR_NO_FREE_SLOTS);
+      if (vif->packet_buffering)
+       {
+
+         u16 n_buffered =
+           virtio_vring_buffering_store_packets (vring->buffering, buffers,
+                                                 n_left);
+         buffers += n_buffered;
+         n_left -= n_buffered;
+       }
+      if (n_left)
+       virtio_interface_drop_inline (vm, node->node_index,
+                                     buffers, n_left,
+                                     VIRTIO_TX_ERROR_NO_FREE_SLOTS);
     }
 
   clib_spinlock_unlock_if_init (&vring->lockp);
@@ -720,7 +762,7 @@ virtio_clear_hw_interface_counters (u32 instance)
 
 static clib_error_t *
 virtio_interface_rx_mode_change (vnet_main_t * vnm, u32 hw_if_index, u32 qid,
-                                vnet_hw_interface_rx_mode mode)
+                                vnet_hw_if_rx_mode mode)
 {
   virtio_main_t *mm = &virtio_main;
   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
@@ -734,26 +776,29 @@ virtio_interface_rx_mode_change (vnet_main_t * vnm, u32 hw_if_index, u32 qid,
       return clib_error_return (0, "interrupt mode is not supported");
     }
 
-  if (mode == VNET_HW_INTERFACE_RX_MODE_POLLING)
+  if (mode == VNET_HW_IF_RX_MODE_POLLING)
     {
       vec_foreach (tx_vring, vif->txq_vrings)
       {
        /* only enable packet coalesce in poll mode */
        gro_flow_table_set_is_enable (tx_vring->flow_table, 1);
+       /* only enable packet buffering in poll mode */
+       virtio_vring_buffering_set_is_enable (tx_vring->buffering, 1);
       }
       rx_vring->avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
     }
   else
     {
-      if (vif->packet_coalesce)
+      if (vif->packet_coalesce || vif->packet_buffering)
        {
          virtio_log_warning (vif,
-                             "interface %U is in interrupt mode, disabling packet coalescing",
+                             "interface %U is in interrupt mode, disabling packet coalescing or buffering",
                              format_vnet_sw_if_index_name, vnet_get_main (),
                              vif->sw_if_index);
          vec_foreach (tx_vring, vif->txq_vrings)
          {
            gro_flow_table_set_is_enable (tx_vring->flow_table, 0);
+           virtio_vring_buffering_set_is_enable (tx_vring->buffering, 0);
          }
        }
       rx_vring->avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;