#include <vlib/vlib.h>
#include <vlib/unix/unix.h>
#include <vnet/ethernet/ethernet.h>
+#include <vnet/gso/gso.h>
#include <vnet/ip/ip4_packet.h>
#include <vnet/ip/ip6_packet.h>
+#include <vnet/tcp/tcp_packet.h>
+#include <vnet/udp/udp_packet.h>
#include <vnet/devices/virtio/virtio.h>
#define foreach_virtio_tx_func_error \
_(NO_FREE_SLOTS, "no free tx slots") \
_(TRUNC_PACKET, "packet > buffer size -- truncated in tx ring") \
_(PENDING_MSGS, "pending msgs in tx ring") \
-_(NO_TX_QUEUES, "no tx queues")
+_(INDIRECT_DESC_ALLOC_FAILED, "indirect descriptor allocation failed - packet drop") \
+_(OUT_OF_ORDER, "out-of-order buffers in used ring") \
+_(GSO_PACKET_DROP, "gso disabled on itf -- gso packet drop") \
+_(CSUM_OFFLOAD_PACKET_DROP, "checksum offload disabled on itf -- csum offload packet drop")
typedef enum
{
}
static_always_inline void
-virtio_free_used_device_desc (vlib_main_t * vm, virtio_vring_t * vring)
+virtio_interface_drop_inline (vlib_main_t * vm, uword node_index,
+ u32 * buffers, u16 n,
+ virtio_tx_func_error_t error)
+{
+ vlib_error_count (vm, node_index, error, n);
+ vlib_buffer_free (vm, buffers, n);
+}
+
+static_always_inline void
+virtio_memset_ring_u32 (u32 * ring, u32 start, u32 ring_size, u32 n_buffers)
+{
+ ASSERT (n_buffers <= ring_size);
+
+ if (PREDICT_TRUE (start + n_buffers <= ring_size))
+ {
+ clib_memset_u32 (ring + start, ~0, n_buffers);
+ }
+ else
+ {
+ clib_memset_u32 (ring + start, ~0, ring_size - start);
+ clib_memset_u32 (ring, ~0, n_buffers - (ring_size - start));
+ }
+}
+
+static_always_inline void
+virtio_free_used_device_desc (vlib_main_t * vm, virtio_vring_t * vring,
+ uword node_index)
{
u16 used = vring->desc_in_use;
u16 sz = vring->size;
u16 mask = sz - 1;
u16 last = vring->last_used_idx;
u16 n_left = vring->used->idx - last;
+ u16 out_of_order_count = 0;
if (n_left == 0)
return;
u16 slot, n_buffers;
slot = n_buffers = e->id;
- while (e->id == n_buffers)
+ while (e->id == (n_buffers & mask))
{
n_left--;
last++;
}
vlib_buffer_free_from_ring (vm, vring->buffers, slot,
sz, (n_buffers - slot));
+ virtio_memset_ring_u32 (vring->buffers, slot, sz, (n_buffers - slot));
used -= (n_buffers - slot);
if (n_left > 0)
{
- slot = e->id;
-
- vlib_buffer_free (vm, &vring->buffers[slot], 1);
+ vlib_buffer_free (vm, &vring->buffers[e->id], 1);
+ vring->buffers[e->id] = ~0;
used--;
last++;
n_left--;
+ out_of_order_count++;
+ vring->flags |= VRING_TX_OUT_OF_ORDER;
}
}
+
+ /*
+ * Some vhost-backends give buffers back in out-of-order fashion in used ring.
+ * It impacts the overall virtio-performance.
+ */
+ if (out_of_order_count)
+ vlib_error_count (vm, node_index, VIRTIO_TX_ERROR_OUT_OF_ORDER,
+ out_of_order_count);
+
vring->desc_in_use = used;
vring->last_used_idx = last;
}
+static_always_inline void
+set_checksum_offsets (vlib_buffer_t * b, struct virtio_net_hdr_v1 *hdr)
+{
+ if (b->flags & VNET_BUFFER_F_IS_IP4)
+ {
+ ip4_header_t *ip4;
+ gso_header_offset_t gho = vnet_gso_header_offset_parser (b, 0);
+ hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
+ hdr->csum_start = gho.l4_hdr_offset; // 0x22;
+ if (b->flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM)
+ {
+ hdr->csum_offset = STRUCT_OFFSET_OF (tcp_header_t, checksum);
+ }
+ else if (b->flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM)
+ {
+ hdr->csum_offset = STRUCT_OFFSET_OF (udp_header_t, checksum);
+ }
+
+ /*
+ * virtio devices do not support IP4 checksum offload. So driver takes care
+ * of it while doing tx.
+ */
+ ip4 =
+ (ip4_header_t *) (vlib_buffer_get_current (b) + gho.l3_hdr_offset);
+ if (b->flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM)
+ ip4->checksum = ip4_header_checksum (ip4);
+ }
+ else if (b->flags & VNET_BUFFER_F_IS_IP6)
+ {
+ gso_header_offset_t gho = vnet_gso_header_offset_parser (b, 1);
+ hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
+ hdr->csum_start = gho.l4_hdr_offset; // 0x36;
+ if (b->flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM)
+ {
+ hdr->csum_offset = STRUCT_OFFSET_OF (tcp_header_t, checksum);
+ }
+ else if (b->flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM)
+ {
+ hdr->csum_offset = STRUCT_OFFSET_OF (udp_header_t, checksum);
+ }
+ }
+}
+
+static_always_inline void
+set_gso_offsets (vlib_buffer_t * b, struct virtio_net_hdr_v1 *hdr)
+{
+ if (b->flags & VNET_BUFFER_F_IS_IP4)
+ {
+ ip4_header_t *ip4;
+ gso_header_offset_t gho = vnet_gso_header_offset_parser (b, 0);
+ hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
+ hdr->gso_size = vnet_buffer2 (b)->gso_size;
+ hdr->hdr_len = gho.l4_hdr_offset + gho.l4_hdr_sz;
+ hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
+ hdr->csum_start = gho.l4_hdr_offset; // 0x22;
+ hdr->csum_offset = STRUCT_OFFSET_OF (tcp_header_t, checksum);
+ ip4 =
+ (ip4_header_t *) (vlib_buffer_get_current (b) + gho.l3_hdr_offset);
+ /*
+ * virtio devices do not support IP4 checksum offload. So driver takes care
+ * of it while doing tx.
+ */
+ if (b->flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM)
+ ip4->checksum = ip4_header_checksum (ip4);
+ }
+ else if (b->flags & VNET_BUFFER_F_IS_IP6)
+ {
+ gso_header_offset_t gho = vnet_gso_header_offset_parser (b, 1);
+ hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
+ hdr->gso_size = vnet_buffer2 (b)->gso_size;
+ hdr->hdr_len = gho.l4_hdr_offset + gho.l4_hdr_sz;
+ hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
+ hdr->csum_start = gho.l4_hdr_offset; // 0x36;
+ hdr->csum_offset = STRUCT_OFFSET_OF (tcp_header_t, checksum);
+ }
+}
+
static_always_inline u16
add_buffer_to_slot (vlib_main_t * vm, virtio_if_t * vif,
virtio_vring_t * vring, u32 bi, u16 avail, u16 next,
- u16 mask, int do_gso)
+ u16 mask, int do_gso, int csum_offload, uword node_index)
{
u16 n_added = 0;
int hdr_sz = vif->virtio_net_hdr_sz;
struct virtio_net_hdr_v1 *hdr = vlib_buffer_get_current (b) - hdr_sz;
clib_memset (hdr, 0, hdr_sz);
- if (do_gso && (b->flags & VNET_BUFFER_F_GSO))
+
+ if (b->flags & VNET_BUFFER_F_GSO)
{
- if (b->flags & VNET_BUFFER_F_IS_IP4)
+ if (do_gso)
+ set_gso_offsets (b, hdr);
+ else
{
- hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
- hdr->gso_size = vnet_buffer2 (b)->gso_size;
- hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
- hdr->csum_start = vnet_buffer (b)->l4_hdr_offset; // 0x22;
- hdr->csum_offset = 0x10;
+ virtio_interface_drop_inline (vm, node_index, &bi, 1,
+ VIRTIO_TX_ERROR_GSO_PACKET_DROP);
+ return n_added;
}
+ }
+ else if (b->flags & (VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
+ VNET_BUFFER_F_OFFLOAD_UDP_CKSUM))
+ {
+ if (csum_offload)
+ set_checksum_offsets (b, hdr);
else
{
- hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
- hdr->gso_size = vnet_buffer2 (b)->gso_size;
- hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
- hdr->csum_start = vnet_buffer (b)->l4_hdr_offset; // 0x36;
- hdr->csum_offset = 0x10;
+ virtio_interface_drop_inline (vm, node_index, &bi, 1,
+ VIRTIO_TX_ERROR_CSUM_OFFLOAD_PACKET_DROP);
+ return n_added;
}
}
*/
u32 indirect_buffer = 0;
if (PREDICT_FALSE (vlib_buffer_alloc (vm, &indirect_buffer, 1) == 0))
- return n_added;
+ {
+ virtio_interface_drop_inline (vm, node_index, &bi, 1,
+ VIRTIO_TX_ERROR_INDIRECT_DESC_ALLOC_FAILED);
+ return n_added;
+ }
vlib_buffer_t *indirect_desc = vlib_get_buffer (vm, indirect_buffer);
indirect_desc->current_data = 0;
return n_added;
}
+static_always_inline void
+virtio_find_free_desc (virtio_vring_t * vring, u16 size, u16 mask,
+ u16 req, u16 next, u32 * first_free_desc_index,
+ u16 * free_desc_count)
+{
+ u16 start = 0;
+ /* next is used as hint: from where to start looking */
+ for (u16 i = 0; i < size; i++, next++)
+ {
+ if (vring->buffers[next & mask] == ~0)
+ {
+ if (*first_free_desc_index == ~0)
+ {
+ *first_free_desc_index = (next & mask);
+ start = i;
+ (*free_desc_count)++;
+ req--;
+ if (req == 0)
+ break;
+ }
+ else
+ {
+ if (start + *free_desc_count == i)
+ {
+ (*free_desc_count)++;
+ req--;
+ if (req == 0)
+ break;
+ }
+ else
+ break;
+ }
+ }
+ }
+}
+
static_always_inline uword
virtio_interface_tx_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
vlib_frame_t * frame, virtio_if_t * vif,
- int do_gso)
+ int do_gso, int csum_offload)
{
u16 n_left = frame->n_vectors;
virtio_vring_t *vring;
u16 used, next, avail;
u16 sz = vring->size;
u16 mask = sz - 1;
+ u16 retry_count = 2;
u32 *buffers = vlib_frame_vector_args (frame);
clib_spinlock_lock_if_init (&vring->lockp);
(vring->last_kick_avail_idx != vring->avail->idx))
virtio_kick (vm, vring, vif);
+retry:
/* free consumed buffers */
- virtio_free_used_device_desc (vm, vring);
+ virtio_free_used_device_desc (vm, vring, node->node_index);
used = vring->desc_in_use;
next = vring->desc_next;
avail = vring->avail->idx;
- while (n_left && used < sz)
+ u16 free_desc_count = 0;
+
+ if (PREDICT_FALSE (vring->flags & VRING_TX_OUT_OF_ORDER))
+ {
+ u32 first_free_desc_index = ~0;
+
+ virtio_find_free_desc (vring, sz, mask, n_left, next,
+ &first_free_desc_index, &free_desc_count);
+
+ if (free_desc_count)
+ next = first_free_desc_index;
+ }
+ else
+ free_desc_count = sz - used;
+
+ while (n_left && free_desc_count)
{
u16 n_added = 0;
n_added =
add_buffer_to_slot (vm, vif, vring, buffers[0], avail, next, mask,
- do_gso);
- if (!n_added)
- break;
+ do_gso, csum_offload, node->node_index);
+
+ if (PREDICT_FALSE (n_added == 0))
+ {
+ buffers++;
+ n_left--;
+ continue;
+ }
+
avail += n_added;
next = (next + n_added) & mask;
used += n_added;
buffers++;
n_left--;
+ free_desc_count--;
}
if (n_left != frame->n_vectors)
if (n_left)
{
- vlib_error_count (vm, node->node_index, VIRTIO_TX_ERROR_NO_FREE_SLOTS,
- n_left);
- vlib_buffer_free (vm, buffers, n_left);
+ if (retry_count--)
+ goto retry;
+
+ virtio_interface_drop_inline (vm, node->node_index, buffers, n_left,
+ VIRTIO_TX_ERROR_NO_FREE_SLOTS);
}
clib_spinlock_unlock_if_init (&vring->lockp);
vlib_node_runtime_t * node,
vlib_frame_t * frame)
{
+ vnet_main_t *vnm = vnet_get_main ();
virtio_main_t *nm = &virtio_main;
vnet_interface_output_runtime_t *rund = (void *) node->runtime_data;
virtio_if_t *vif = pool_elt_at_index (nm->interfaces, rund->dev_instance);
+ vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, vif->hw_if_index);
- if (vif->gso_enabled > 0)
- return virtio_interface_tx_inline (vm, node, frame, vif, 1 /* do_gso */ );
+ if (hw->flags & VNET_HW_INTERFACE_FLAG_SUPPORTS_GSO)
+ return virtio_interface_tx_inline (vm, node, frame, vif, 1 /* do_gso */ ,
+ 1);
+ else if (hw->flags & VNET_HW_INTERFACE_FLAG_SUPPORTS_TX_L4_CKSUM_OFFLOAD)
+ return virtio_interface_tx_inline (vm, node, frame, vif,
+ 0 /* no do_gso */ , 1);
else
return virtio_interface_tx_inline (vm, node, frame, vif,
- 0 /* no do_gso */ );
+ 0 /* no do_gso */ , 0);
}
static void
virtio_if_t *vif = pool_elt_at_index (mm->interfaces, hw->dev_instance);
if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
- vif->flags |= VIRTIO_IF_FLAG_ADMIN_UP;
+ {
+ vif->flags |= VIRTIO_IF_FLAG_ADMIN_UP;
+ vnet_hw_interface_set_flags (vnm, vif->hw_if_index,
+ VNET_HW_INTERFACE_FLAG_LINK_UP);
+ }
else
- vif->flags &= ~VIRTIO_IF_FLAG_ADMIN_UP;
-
+ {
+ vif->flags &= ~VIRTIO_IF_FLAG_ADMIN_UP;
+ vnet_hw_interface_set_flags (vnm, vif->hw_if_index, 0);
+ }
return 0;
}
Code Review / vpp.git / blobdiff