list(APPEND VNET_HEADERS
devices/virtio/pci.h
devices/virtio/virtio.h
+ devices/virtio/virtio_std.h
devices/virtio/virtio_pci_legacy.h
devices/virtio/virtio_pci_modern.h
+ devices/virtio/vhost_std.h
devices/virtio/vhost_user.h
devices/virtio/virtio_types_api.h
)
devices/tap/tap.h
)
-list(APPEND VNET_API_FILES devices/tap/tapv2.api)
+list(APPEND VNET_API_FILES
+ devices/tap/tapv2.api
+)
##############################################################################
# tap interface (with virtio backend)
#include <vnet/ip/ip4_packet.h>
#include <vnet/ip/ip6_packet.h>
#include <vnet/ip/format.h>
-#include <linux/virtio_net.h>
-#include <linux/vhost.h>
#include <vnet/devices/virtio/virtio.h>
#include <vnet/devices/tap/tap.h>
#include <net/if.h>
#include <linux/if_tun.h>
#include <sys/ioctl.h>
-#include <linux/virtio_net.h>
-#include <linux/vhost.h>
#include <sys/eventfd.h>
#include <net/if_arp.h>
#include <sched.h>
struct ifreq ifr = {.ifr_flags = IFF_NO_PI | IFF_VNET_HDR };
struct ifreq get_ifr = {.ifr_flags = 0 };
size_t hdrsz;
- struct vhost_memory *vhost_mem = 0;
+ vhost_memory_t *vhost_mem = 0;
virtio_if_t *vif = 0;
clib_error_t *err = 0;
unsigned int tap_features;
else
ifr.ifr_flags |= IFF_MULTI_QUEUE;
- hdrsz = sizeof (struct virtio_net_hdr_v1);
+ hdrsz = sizeof (virtio_net_hdr_v1_t);
if (args->tap_flags & TAP_FLAG_GSO)
{
offload = TUN_F_CSUM | TUN_F_TSO4 | TUN_F_TSO6;
}
/* setup features and memtable */
- i = sizeof (struct vhost_memory) + sizeof (struct vhost_memory_region);
+ i = sizeof (vhost_memory_t) + sizeof (vhost_memory_region_t);
vhost_mem = clib_mem_alloc (i);
clib_memset (vhost_mem, 0, i);
vhost_mem->nregions = 1;
/* finish initializing queue pair */
for (i = 0; i < num_vhost_queues * 2; i++)
{
- struct vhost_vring_addr addr = { 0 };
- struct vhost_vring_state state = { 0 };
- struct vhost_vring_file file = { 0 };
+ vhost_vring_addr_t addr = { 0 };
+ vhost_vring_state_t state = { 0 };
+ vhost_vring_file_t file = { 0 };
virtio_vring_t *vring;
u16 qp = i >> 1;
int fd = vif->vhost_fds[qp];
while (n_left)
{
- struct vring_used_elem *e = &vring->used->ring[last & mask];
+ vring_used_elem_t *e = &vring->used->ring[last & mask];
u16 slot, n_buffers;
slot = n_buffers = e->id;
n_left--;
last++;
n_buffers++;
- struct vring_desc *d = &vring->desc[e->id];
+ vring_desc_t *d = &vring->desc[e->id];
u16 next;
while (d->flags & VRING_DESC_F_NEXT)
{
}
static_always_inline void
-set_checksum_offsets (vlib_buffer_t * b, struct virtio_net_hdr_v1 *hdr,
- int is_l2)
+set_checksum_offsets (vlib_buffer_t * b, virtio_net_hdr_v1_t * hdr, int is_l2)
{
if (b->flags & VNET_BUFFER_F_IS_IP4)
{
}
static_always_inline void
-set_gso_offsets (vlib_buffer_t * b, struct virtio_net_hdr_v1 *hdr, int is_l2)
+set_gso_offsets (vlib_buffer_t * b, virtio_net_hdr_v1_t * hdr, int is_l2)
{
if (b->flags & VNET_BUFFER_F_IS_IP4)
{
{
u16 n_added = 0;
int hdr_sz = vif->virtio_net_hdr_sz;
- struct vring_desc *d;
+ vring_desc_t *d;
d = &vring->desc[next];
vlib_buffer_t *b = vlib_get_buffer (vm, bi);
- struct virtio_net_hdr_v1 *hdr = vlib_buffer_get_current (b) - hdr_sz;
+ virtio_net_hdr_v1_t *hdr = vlib_buffer_get_current (b) - hdr_sz;
int is_l2 = (type & (VIRTIO_IF_TYPE_TAP | VIRTIO_IF_TYPE_PCI));
clib_memset (hdr, 0, hdr_sz);
indirect_desc->next_buffer = bi;
bi = indirect_buffer;
- struct vring_desc *id =
- (struct vring_desc *) vlib_buffer_get_current (indirect_desc);
+ vring_desc_t *id =
+ (vring_desc_t *) vlib_buffer_get_current (indirect_desc);
u32 count = 1;
if (type == VIRTIO_IF_TYPE_PCI)
{
}
id->flags = 0;
id->next = 0;
- d->len = count * sizeof (struct vring_desc);
+ d->len = count * sizeof (vring_desc_t);
d->flags = VRING_DESC_F_INDIRECT;
}
else if (type == VIRTIO_IF_TYPE_PCI)
clib_spinlock_lock_if_init (&vring->lockp);
- if ((vring->used->flags & VIRTIO_RING_FLAG_MASK_INT) == 0 &&
+ if ((vring->used->flags & VRING_USED_F_NO_NOTIFY) == 0 &&
(vring->last_kick_avail_idx != vring->avail->idx))
virtio_kick (vm, vring, vif);
vring->avail->idx = avail;
vring->desc_next = next;
vring->desc_in_use = used;
- if ((vring->used->flags & VIRTIO_RING_FLAG_MASK_INT) == 0)
+ if ((vring->used->flags & VRING_USED_F_NO_NOTIFY) == 0)
virtio_kick (vm, vring, vif);
}
if (vif->type == VIRTIO_IF_TYPE_PCI && !(vif->support_int_mode))
{
- vring->avail->flags |= VIRTIO_RING_FLAG_MASK_INT;
+ vring->avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
return clib_error_return (0, "interrupt mode is not supported");
}
{
/* only enable packet coalesce in poll mode */
gro_flow_table_set_is_enable (vring->flow_table, 1);
- vring->avail->flags |= VIRTIO_RING_FLAG_MASK_INT;
+ vring->avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
}
else
{
gro_flow_table_set_is_enable (vring->flow_table, 0);
- vring->avail->flags &= ~VIRTIO_RING_FLAG_MASK_INT;
+ vring->avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
}
return 0;
u32 hw_if_index;
u16 ring;
u16 len;
- struct virtio_net_hdr_v1 hdr;
+ virtio_net_hdr_v1_t hdr;
} virtio_input_trace_t;
static u8 *
while (n_slots)
{
- struct vring_desc *d = &vring->desc[next];;
+ vring_desc_t *d = &vring->desc[next];;
vlib_buffer_t *b = vlib_get_buffer (vm, vring->buffers[next]);
/*
* current_data may not be initialized with 0 and may contain
vring->desc_next = next;
vring->desc_in_use = used;
- if ((vring->used->flags & VIRTIO_RING_FLAG_MASK_INT) == 0)
+ if ((vring->used->flags & VRING_USED_F_NO_NOTIFY) == 0)
{
virtio_kick (vm, vring, vif);
}
}
static_always_inline void
-virtio_needs_csum (vlib_buffer_t * b0, struct virtio_net_hdr_v1 *hdr,
+virtio_needs_csum (vlib_buffer_t * b0, virtio_net_hdr_v1_t * hdr,
u8 * l4_proto, u8 * l4_hdr_sz, virtio_if_type_t type)
{
if (hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM)
}
static_always_inline void
-fill_gso_buffer_flags (vlib_buffer_t * b0, struct virtio_net_hdr_v1 *hdr,
+fill_gso_buffer_flags (vlib_buffer_t * b0, virtio_net_hdr_v1_t * hdr,
u8 l4_proto, u8 l4_hdr_sz)
{
if (hdr->gso_type == VIRTIO_NET_HDR_GSO_TCPV4)
txq_vring->flow_table);
}
- if ((vring->used->flags & VIRTIO_RING_FLAG_MASK_INT) == 0 &&
+ if ((vring->used->flags & VRING_USED_F_NO_NOTIFY) == 0 &&
vring->last_kick_avail_idx != vring->avail->idx)
virtio_kick (vm, vring, vif);
{
u8 l4_proto = 0, l4_hdr_sz = 0;
u16 num_buffers = 1;
- struct vring_used_elem *e = &vring->used->ring[last & mask];
- struct virtio_net_hdr_v1 *hdr;
+ vring_used_elem_t *e = &vring->used->ring[last & mask];
+ virtio_net_hdr_v1_t *hdr;
u16 slot = e->id;
u16 len = e->len - hdr_sz;
u32 bi0 = vring->buffers[slot];
vlib_buffer_t *b0 = vlib_get_buffer (vm, bi0);
hdr = vlib_buffer_get_current (b0);
- if (hdr_sz == sizeof (struct virtio_net_hdr_v1))
+ if (hdr_sz == sizeof (virtio_net_hdr_v1_t))
num_buffers = hdr->num_buffers;
b0->flags = VLIB_BUFFER_TOTAL_LENGTH_VALID;
}
}
-struct virtio_ctrl_msg
-{
- struct virtio_net_ctrl_hdr ctrl;
- virtio_net_ctrl_ack status;
- u8 data[1024];
-};
-
static int
virtio_pci_send_ctrl_msg (vlib_main_t * vm, virtio_if_t * vif,
- struct virtio_ctrl_msg *data, u32 len)
+ virtio_ctrl_msg_t * data, u32 len)
{
virtio_vring_t *vring = vif->cxq_vring;
- virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
- struct virtio_ctrl_msg result;
+ virtio_net_ctrl_ack_t status = VIRTIO_NET_ERR;
+ virtio_ctrl_msg_t result;
u32 buffer_index;
vlib_buffer_t *b;
u16 used, next, avail;
used = vring->desc_in_use;
next = vring->desc_next;
avail = vring->avail->idx;
- struct vring_desc *d = &vring->desc[next];
+ vring_desc_t *d = &vring->desc[next];
if (vlib_buffer_alloc (vm, &buffer_index, 1))
b = vlib_get_buffer (vm, buffer_index);
* previous offset.
*/
b->current_data = 0;
- clib_memcpy (vlib_buffer_get_current (b), data,
- sizeof (struct virtio_ctrl_msg));
+ clib_memcpy (vlib_buffer_get_current (b), data, sizeof (virtio_ctrl_msg_t));
d->flags = VRING_DESC_F_NEXT;
d->addr = vlib_buffer_get_current_pa (vm, b);
- d->len = sizeof (struct virtio_net_ctrl_hdr);
+ d->len = sizeof (virtio_net_ctrl_hdr_t);
vring->avail->ring[avail & mask] = next;
avail++;
next = (next + 1) & mask;
d = &vring->desc[next];
d->flags = VRING_DESC_F_NEXT;
d->addr = vlib_buffer_get_current_pa (vm, b) +
- STRUCT_OFFSET_OF (struct virtio_ctrl_msg, data);
+ STRUCT_OFFSET_OF (virtio_ctrl_msg_t, data);
d->len = len;
next = (next + 1) & mask;
d->next = next;
d = &vring->desc[next];
d->flags = VRING_DESC_F_WRITE;
d->addr = vlib_buffer_get_current_pa (vm, b) +
- STRUCT_OFFSET_OF (struct virtio_ctrl_msg, status);
+ STRUCT_OFFSET_OF (virtio_ctrl_msg_t, status);
d->len = sizeof (data->status);
next = (next + 1) & mask;
used++;
while (n_left)
{
- struct vring_used_elem *e = &vring->used->ring[last & mask];
+ vring_used_elem_t *e = &vring->used->ring[last & mask];
u16 slot = e->id;
d = &vring->desc[slot];
CLIB_MEMORY_BARRIER ();
clib_memcpy (&result, vlib_buffer_get_current (b),
- sizeof (struct virtio_ctrl_msg));
+ sizeof (virtio_ctrl_msg_t));
virtio_log_debug (vif, "ctrl-queue: status %u", result.status);
status = result.status;
vlib_buffer_free (vm, &buffer_index, 1);
static int
virtio_pci_disable_offload (vlib_main_t * vm, virtio_if_t * vif)
{
- struct virtio_ctrl_msg offload_hdr;
- virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
+ virtio_ctrl_msg_t offload_hdr;
+ virtio_net_ctrl_ack_t status = VIRTIO_NET_ERR;
offload_hdr.ctrl.class = VIRTIO_NET_CTRL_GUEST_OFFLOADS;
offload_hdr.ctrl.cmd = VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET;
static int
virtio_pci_enable_checksum_offload (vlib_main_t * vm, virtio_if_t * vif)
{
- struct virtio_ctrl_msg csum_offload_hdr;
- virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
+ virtio_ctrl_msg_t csum_offload_hdr;
+ virtio_net_ctrl_ack_t status = VIRTIO_NET_ERR;
csum_offload_hdr.ctrl.class = VIRTIO_NET_CTRL_GUEST_OFFLOADS;
csum_offload_hdr.ctrl.cmd = VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET;
static int
virtio_pci_enable_gso (vlib_main_t * vm, virtio_if_t * vif)
{
- struct virtio_ctrl_msg gso_hdr;
- virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
+ virtio_ctrl_msg_t gso_hdr;
+ virtio_net_ctrl_ack_t status = VIRTIO_NET_ERR;
gso_hdr.ctrl.class = VIRTIO_NET_CTRL_GUEST_OFFLOADS;
gso_hdr.ctrl.cmd = VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET;
virtio_pci_enable_multiqueue (vlib_main_t * vm, virtio_if_t * vif,
u16 num_queues)
{
- struct virtio_ctrl_msg mq_hdr;
- virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
+ virtio_ctrl_msg_t mq_hdr;
+ virtio_net_ctrl_ack_t status = VIRTIO_NET_ERR;
mq_hdr.ctrl.class = VIRTIO_NET_CTRL_MQ;
mq_hdr.ctrl.cmd = VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET;
clib_error_t *error = 0;
u16 queue_size = 0;
virtio_vring_t *vring;
- struct vring vr;
+ vring_t vr;
u32 i = 0;
void *ptr = NULL;
clib_error_t *error = 0;
u16 queue_size = 0;
virtio_vring_t *vring;
- struct vring vr;
+ vring_t vr;
u32 i = 0;
void *ptr = NULL;
virtio_pci_read_caps (vlib_main_t * vm, virtio_if_t * vif, void **bar)
{
clib_error_t *error = 0;
- struct virtio_pci_cap cap;
+ virtio_pci_cap_t cap;
u8 pos, common_cfg = 0, notify = 0, dev_cfg = 0, isr = 0, pci_cfg = 0;
vlib_pci_dev_handle_t h = vif->pci_dev_handle;
/* VirtIO ABI version, this must match exactly. */
#define VIRTIO_PCI_ABI_VERSION 0
+/* VirtIO device IDs. */
+#define VIRTIO_ID_NETWORK 0x01
+
/*
* Vector value used to disable MSI for queue.
* define in include/linux/virtio_pci.h
- * #define VIRTIO_MSI_NO_VECTOR 0xFFFF
*/
+#define VIRTIO_MSI_NO_VECTOR 0xFFFF
/* The bit of the ISR which indicates a device has an interrupt. */
#define VIRTIO_PCI_ISR_INTR 0x1
/* The bit of the ISR which indicates a device configuration change. */
#define VIRTIO_PCI_ISR_CONFIG 0x2
-/* VirtIO device IDs. */
-#define VIRTIO_ID_NETWORK 0x01
-
/* Status byte for guest to report progress. */
#define foreach_virtio_config_status_flags \
_ (VIRTIO_CONFIG_STATUS_RESET, 0x00) \
#undef _
} virtio_config_status_flags_t;
-#define foreach_virtio_net_feature_flags \
- _ (VIRTIO_NET_F_CSUM, 0) /* Host handles pkts w/ partial csum */ \
- _ (VIRTIO_NET_F_GUEST_CSUM, 1) /* Guest handles pkts w/ partial csum */ \
- _ (VIRTIO_NET_F_CTRL_GUEST_OFFLOADS, 2) /* Dynamic offload configuration. */ \
- _ (VIRTIO_NET_F_MTU, 3) /* Initial MTU advice. */ \
- _ (VIRTIO_NET_F_MAC, 5) /* Host has given MAC address. */ \
- _ (VIRTIO_NET_F_GSO, 6) /* Host handles pkts w/ any GSO. */ \
- _ (VIRTIO_NET_F_GUEST_TSO4, 7) /* Guest can handle TSOv4 in. */ \
- _ (VIRTIO_NET_F_GUEST_TSO6, 8) /* Guest can handle TSOv6 in. */ \
- _ (VIRTIO_NET_F_GUEST_ECN, 9) /* Guest can handle TSO[6] w/ ECN in. */ \
- _ (VIRTIO_NET_F_GUEST_UFO, 10) /* Guest can handle UFO in. */ \
- _ (VIRTIO_NET_F_HOST_TSO4, 11) /* Host can handle TSOv4 in. */ \
- _ (VIRTIO_NET_F_HOST_TSO6, 12) /* Host can handle TSOv6 in. */ \
- _ (VIRTIO_NET_F_HOST_ECN, 13) /* Host can handle TSO[6] w/ ECN in. */ \
- _ (VIRTIO_NET_F_HOST_UFO, 14) /* Host can handle UFO in. */ \
- _ (VIRTIO_NET_F_MRG_RXBUF, 15) /* Host can merge receive buffers. */ \
- _ (VIRTIO_NET_F_STATUS, 16) /* virtio_net_config.status available */ \
- _ (VIRTIO_NET_F_CTRL_VQ, 17) /* Control channel available */ \
- _ (VIRTIO_NET_F_CTRL_RX, 18) /* Control channel RX mode support */ \
- _ (VIRTIO_NET_F_CTRL_VLAN, 19) /* Control channel VLAN filtering */ \
- _ (VIRTIO_NET_F_CTRL_RX_EXTRA, 20) /* Extra RX mode control support */ \
- _ (VIRTIO_NET_F_GUEST_ANNOUNCE, 21) /* Guest can announce device on the network */ \
- _ (VIRTIO_NET_F_MQ, 22) /* Device supports Receive Flow Steering */ \
- _ (VIRTIO_NET_F_CTRL_MAC_ADDR, 23) /* Set MAC address */ \
- _ (VIRTIO_F_NOTIFY_ON_EMPTY, 24) \
- _ (VHOST_F_LOG_ALL, 26) /* Log all write descriptors */ \
- _ (VIRTIO_F_ANY_LAYOUT, 27) /* Can the device handle any descripor layout */ \
- _ (VIRTIO_RING_F_INDIRECT_DESC, 28) /* Support indirect buffer descriptors */ \
- _ (VIRTIO_RING_F_EVENT_IDX, 29) /* The Guest publishes the used index for which it expects an interrupt \
- * at the end of the avail ring. Host should ignore the avail->flags field. */ \
-/* The Host publishes the avail index for which it expects a kick \
- * at the end of the used ring. Guest should ignore the used->flags field. */ \
- _ (VHOST_USER_F_PROTOCOL_FEATURES, 30) \
- _ (VIRTIO_F_VERSION_1, 32) \
-
-#define VIRTIO_NET_F_CTRL_GUEST_OFFLOADS 2
-#define VIRTIO_NET_F_MTU 3
+
#define VIRTIO_NET_S_LINK_UP 1 /* Link is up */
#define VIRTIO_NET_S_ANNOUNCE 2 /* Announcement is needed */
+#define VIRTIO_NET_OK 0
+#define VIRTIO_NET_ERR 1
+
+/* If multiqueue is provided by host, then we support it. */
+#define VIRTIO_NET_CTRL_MQ 4
+#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET 0
+#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN 1
+#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX 0x8000
+
/*
* Control network offloads
* Reconfigures the network offloads that Guest can handle.
typedef struct
{
- struct virtio_pci_cap cap;
+ virtio_pci_cap_t cap;
u32 notify_off_multiplier; /* Multiplier for queue_notify_off. */
} virtio_pci_notify_cap_t;
u16 mtu;
} virtio_net_config_t;
-typedef struct
-{
- u64 addr;
- u32 len;
- u16 flags;
- u16 next;
-} vring_desc_t;
-
-typedef struct
+/*
+ * Control virtqueue data structures
+ *
+ * The control virtqueue expects a header in the first sg entry
+ * and an ack/status response in the last entry. Data for the
+ * command goes in between.
+ */
+/* *INDENT-OFF* */
+typedef CLIB_PACKED (struct
{
- u16 flags;
- u16 idx;
- u16 ring[0];
- /* u16 used_event; */
-} vring_avail_t;
+ u8 class;
+ u8 cmd;
+}) virtio_net_ctrl_hdr_t;
+/* *INDENT-ON* */
-typedef struct
-{
- u32 id;
- u32 len;
-} vring_used_elem_t;
+typedef u8 virtio_net_ctrl_ack_t;
typedef struct
{
- u16 flags;
- u16 idx;
- vring_used_elem_t ring[0];
- /* u16 avail_event; */
-} vring_used_t;
+ virtio_net_ctrl_hdr_t ctrl;
+ virtio_net_ctrl_ack_t status;
+ u8 data[1024];
+} virtio_ctrl_msg_t;
typedef struct _virtio_pci_func
{
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef __VIRTIO_VHOST_STD_H__
+#define __VIRTIO_VHOST_STD_H__
+
+typedef struct
+{
+ u64 guest_phys_addr;
+ u64 memory_size;
+ u64 userspace_addr;
+ u64 mmap_offset;
+} vhost_memory_region_t;
+
+typedef struct
+{
+ u32 nregions;
+ u32 padding;
+ vhost_memory_region_t regions[0];
+} vhost_memory_t;
+
+typedef struct
+{
+ u32 index;
+ u32 num;
+} vhost_vring_state_t;
+
+typedef struct
+{
+ u32 index;
+ int fd;
+} vhost_vring_file_t;
+
+typedef struct
+{
+ u32 index;
+ u32 flags;
+ u64 desc_user_addr;
+ u64 used_user_addr;
+ u64 avail_user_addr;
+ u64 log_guest_addr;
+} vhost_vring_addr_t;
+
+typedef struct
+{
+ u64 size;
+ u64 offset;
+} vhost_user_log_t;
+
+/* vhost kernel ioctls */
+#define VHOST_VIRTIO 0xAF
+#define VHOST_GET_FEATURES _IOR(VHOST_VIRTIO, 0x00, u64)
+#define VHOST_SET_FEATURES _IOW(VHOST_VIRTIO, 0x00, u64)
+#define VHOST_SET_OWNER _IO(VHOST_VIRTIO, 0x01)
+#define VHOST_RESET_OWNER _IO(VHOST_VIRTIO, 0x02)
+#define VHOST_SET_MEM_TABLE _IOW(VHOST_VIRTIO, 0x03, vhost_memory_t)
+#define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, u64)
+#define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int)
+#define VHOST_SET_VRING_NUM _IOW(VHOST_VIRTIO, 0x10, vhost_vring_state_t)
+#define VHOST_SET_VRING_ADDR _IOW(VHOST_VIRTIO, 0x11, vhost_vring_addr_t)
+#define VHOST_SET_VRING_BASE _IOW(VHOST_VIRTIO, 0x12, vhost_vring_state_t)
+#define VHOST_GET_VRING_BASE _IOWR(VHOST_VIRTIO, 0x12, vhost_vring_state_t)
+#define VHOST_SET_VRING_KICK _IOW(VHOST_VIRTIO, 0x20, vhost_vring_file_t)
+#define VHOST_SET_VRING_CALL _IOW(VHOST_VIRTIO, 0x21, vhost_vring_file_t)
+#define VHOST_SET_VRING_ERR _IOW(VHOST_VIRTIO, 0x22, vhost_vring_file_t)
+#define VHOST_NET_SET_BACKEND _IOW(VHOST_VIRTIO, 0x30, vhost_vring_file_t)
+
+#endif
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
{
case VHOST_USER_GET_FEATURES:
msg.flags |= 4;
- msg.u64 = (1ULL << FEAT_VIRTIO_NET_F_MRG_RXBUF) |
- (1ULL << FEAT_VIRTIO_NET_F_CTRL_VQ) |
- (1ULL << FEAT_VIRTIO_F_ANY_LAYOUT) |
- (1ULL << FEAT_VIRTIO_F_INDIRECT_DESC) |
- (1ULL << FEAT_VHOST_F_LOG_ALL) |
- (1ULL << FEAT_VIRTIO_NET_F_GUEST_ANNOUNCE) |
- (1ULL << FEAT_VIRTIO_NET_F_MQ) |
- (1ULL << FEAT_VHOST_USER_F_PROTOCOL_FEATURES) |
- (1ULL << FEAT_VIRTIO_F_VERSION_1);
+ msg.u64 = VIRTIO_FEATURE (VIRTIO_NET_F_MRG_RXBUF) |
+ VIRTIO_FEATURE (VIRTIO_NET_F_CTRL_VQ) |
+ VIRTIO_FEATURE (VIRTIO_F_ANY_LAYOUT) |
+ VIRTIO_FEATURE (VIRTIO_RING_F_INDIRECT_DESC) |
+ VIRTIO_FEATURE (VHOST_F_LOG_ALL) |
+ VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_ANNOUNCE) |
+ VIRTIO_FEATURE (VIRTIO_NET_F_MQ) |
+ VIRTIO_FEATURE (VHOST_USER_F_PROTOCOL_FEATURES) |
+ VIRTIO_FEATURE (VIRTIO_F_VERSION_1);
msg.u64 &= vui->feature_mask;
if (vui->enable_gso)
msg.u64 |= FEATURE_VIRTIO_NET_F_HOST_GUEST_TSO_FEATURE_BITS;
if (vui->enable_packed)
- msg.u64 |= (1ULL << FEAT_VIRTIO_F_RING_PACKED);
+ msg.u64 |= VIRTIO_FEATURE (VIRTIO_F_RING_PACKED);
msg.size = sizeof (msg.u64);
vu_log_debug (vui, "if %d msg VHOST_USER_GET_FEATURES - reply "
vui->features = msg.u64;
if (vui->features &
- ((1 << FEAT_VIRTIO_NET_F_MRG_RXBUF) |
- (1ULL << FEAT_VIRTIO_F_VERSION_1)))
+ (VIRTIO_FEATURE (VIRTIO_NET_F_MRG_RXBUF) |
+ VIRTIO_FEATURE (VIRTIO_F_VERSION_1)))
vui->virtio_net_hdr_sz = 12;
else
vui->virtio_net_hdr_sz = 10;
vui->is_any_layout =
- (vui->features & (1 << FEAT_VIRTIO_F_ANY_LAYOUT)) ? 1 : 0;
+ (vui->features & VIRTIO_FEATURE (VIRTIO_F_ANY_LAYOUT)) ? 1 : 0;
ASSERT (vui->virtio_net_hdr_sz < VLIB_BUFFER_PRE_DATA_SIZE);
vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, vui->hw_if_index);
/* Spec says: If VHOST_USER_F_PROTOCOL_FEATURES has not been negotiated,
the ring is initialized in an enabled state. */
- if (!(vui->features & (1 << FEAT_VHOST_USER_F_PROTOCOL_FEATURES)))
+ if (!(vui->features & VIRTIO_FEATURE (VHOST_USER_F_PROTOCOL_FEATURES)))
vui->vrings[msg.state.index].enabled = 1;
vui->vrings[msg.state.index].last_used_idx =
if (vui->vrings[msg.state.index].avail_wrap_counter == 1)
vui->vrings[msg.state.index].avail_wrap_counter =
- VIRTQ_DESC_F_AVAIL;
+ VRING_DESC_F_AVAIL;
}
vlib_worker_thread_barrier_release (vm);
break;
/* GSO feature is disable by default */
feature_mask &= ~FEATURE_VIRTIO_NET_F_HOST_GUEST_TSO_FEATURE_BITS;
/* packed-ring feature is disable by default */
- feature_mask &= ~(1ULL << FEAT_VIRTIO_F_RING_PACKED);
+ feature_mask &= ~VIRTIO_FEATURE (VIRTIO_F_RING_PACKED);
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (line_input, "socket %s", &sock_filename))
vlib_cli_output (vm, "%U", format_vhost_user_desc,
" %-5d 0x%016lx %-5d 0x%04x %-5d 0x%016lx\n", vui,
desc_table, j, &mem_hint);
- if (show_verbose && (desc_table[j].flags & VIRTQ_DESC_F_INDIRECT))
+ if (show_verbose && (desc_table[j].flags & VRING_DESC_F_INDIRECT))
{
n_entries = desc_table[j].len / sizeof (vring_desc_t);
desc_table = map_guest_mem (vui, desc_table[j].addr, &mem_hint);
vlib_cli_output (vm, "%U", format_vhost_user_packed_desc,
" %-5u 0x%016lx %-5u 0x%04x %-5u 0x%016lx\n", vui,
desc_table, j, &mem_hint);
- if (show_verbose && (desc_table[j].flags & VIRTQ_DESC_F_INDIRECT))
+ if (show_verbose && (desc_table[j].flags & VRING_DESC_F_INDIRECT))
{
n_entries = desc_table[j].len >> 4;
desc_table = map_guest_mem (vui, desc_table[j].addr, &mem_hint);
static struct feat_struct feat_array[] = {
#define _(s,b) { .str = #s, .bit = b, },
- foreach_virtio_net_feature
+ foreach_virtio_net_features
#undef _
{.str = NULL}
};
*/
#ifndef __VIRTIO_VHOST_USER_H__
#define __VIRTIO_VHOST_USER_H__
+
+#include <vnet/devices/virtio/virtio_std.h>
+#include <vnet/devices/virtio/vhost_std.h>
+
/* vhost-user data structures */
#define VHOST_MEMORY_MAX_NREGIONS 8
#define VHOST_USER_MSG_HDR_SZ 12
-#define VHOST_VRING_MAX_SIZE 32768
#define VHOST_VRING_MAX_N 16 //8TX + 8RX
#define VHOST_VRING_IDX_RX(qid) (2*qid)
#define VHOST_VRING_IDX_TX(qid) (2*qid + 1)
#define VHOST_USER_VRING_NOFD_MASK 0x100
-#define VIRTQ_DESC_F_NEXT 1
-#define VIRTQ_DESC_F_WRITE 2
-#define VIRTQ_DESC_F_INDIRECT 4
-
-#define VIRTQ_DESC_F_AVAIL (1 << 7)
-#define VIRTQ_DESC_F_USED (1 << 15)
-
-#define VRING_EVENT_F_ENABLE 0x0
-#define VRING_EVENT_F_DISABLE 0x1
-#define VRING_EVENT_F_DESC 0x2
#define VHOST_USER_PROTOCOL_F_MQ 0
#define VHOST_USER_PROTOCOL_F_LOG_SHMFD 1
#define VHOST_VRING_F_LOG 0
-#define VHOST_USER_F_PROTOCOL_FEATURES 30
#define VHOST_USER_PROTOCOL_FEATURES ((1ULL << VHOST_USER_PROTOCOL_F_MQ) | \
(1ULL << VHOST_USER_PROTOCOL_F_LOG_SHMFD))
-/* If multiqueue is provided by host, then we support it. */
-#define VIRTIO_NET_CTRL_MQ 4
-#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET 0
-#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN 1
-#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX 0x8000
-
-#define VRING_USED_F_NO_NOTIFY 1
-#define VRING_AVAIL_F_NO_INTERRUPT 1
-
#define vu_log_debug(dev, f, ...) \
{ \
vlib_log(VLIB_LOG_LEVEL_DEBUG, vhost_user_main.log_default, "%U: " f, \
#undef _
} virtio_trace_flag_t;
-#define foreach_virtio_net_feature \
- _ (VIRTIO_NET_F_CSUM, 0) \
- _ (VIRTIO_NET_F_GUEST_CSUM, 1) \
- _ (VIRTIO_NET_F_GUEST_TSO4, 7) \
- _ (VIRTIO_NET_F_GUEST_TSO6, 8) \
- _ (VIRTIO_NET_F_GUEST_UFO, 10) \
- _ (VIRTIO_NET_F_HOST_TSO4, 11) \
- _ (VIRTIO_NET_F_HOST_TSO6, 12) \
- _ (VIRTIO_NET_F_HOST_UFO, 14) \
- _ (VIRTIO_NET_F_MRG_RXBUF, 15) \
- _ (VIRTIO_NET_F_CTRL_VQ, 17) \
- _ (VIRTIO_NET_F_GUEST_ANNOUNCE, 21) \
- _ (VIRTIO_NET_F_MQ, 22) \
- _ (VHOST_F_LOG_ALL, 26) \
- _ (VIRTIO_F_ANY_LAYOUT, 27) \
- _ (VIRTIO_F_INDIRECT_DESC, 28) \
- _ (VIRTIO_F_EVENT_IDX, 29) \
- _ (VHOST_USER_F_PROTOCOL_FEATURES, 30) \
- _ (VIRTIO_F_VERSION_1, 32) \
- _ (VIRTIO_F_RING_PACKED, 34) \
- _ (VIRTIO_F_IN_ORDER, 35)
-
-typedef enum
-{
-#define _(f,n) FEAT_##f = (n),
- foreach_virtio_net_feature
-#undef _
-} virtio_net_feature_t;
-
#define FEATURE_VIRTIO_NET_F_HOST_TSO_FEATURE_BITS \
- ((1ULL << FEAT_VIRTIO_NET_F_CSUM) | \
- (1ULL << FEAT_VIRTIO_NET_F_HOST_UFO) | \
- (1ULL << FEAT_VIRTIO_NET_F_HOST_TSO4) | \
- (1ULL << FEAT_VIRTIO_NET_F_HOST_TSO6))
+ (VIRTIO_FEATURE (VIRTIO_NET_F_CSUM) | \
+ VIRTIO_FEATURE (VIRTIO_NET_F_HOST_UFO) | \
+ VIRTIO_FEATURE (VIRTIO_NET_F_HOST_TSO4) | \
+ VIRTIO_FEATURE (VIRTIO_NET_F_HOST_TSO6))
#define FEATURE_VIRTIO_NET_F_GUEST_TSO_FEATURE_BITS \
- ((1ULL << FEAT_VIRTIO_NET_F_GUEST_CSUM) | \
- (1ULL << FEAT_VIRTIO_NET_F_GUEST_UFO) | \
- (1ULL << FEAT_VIRTIO_NET_F_GUEST_TSO4) | \
- (1ULL << FEAT_VIRTIO_NET_F_GUEST_TSO6))
+ (VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_CSUM) | \
+ VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_UFO) | \
+ VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_TSO4) | \
+ VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_TSO6))
#define FEATURE_VIRTIO_NET_F_HOST_GUEST_TSO_FEATURE_BITS \
(FEATURE_VIRTIO_NET_F_HOST_TSO_FEATURE_BITS | \
vhost_user_memory_region_t regions[VHOST_MEMORY_MAX_NREGIONS];
} __attribute ((packed)) vhost_user_memory_t;
-typedef struct
-{
- u32 index, num;
-} __attribute ((packed)) vhost_vring_state_t;
-
-typedef struct
-{
- u32 index, flags;
- u64 desc_user_addr, used_user_addr, avail_user_addr, log_guest_addr;
-} __attribute ((packed)) vhost_vring_addr_t;
-
-typedef struct vhost_user_log
-{
- u64 size;
- u64 offset;
-} __attribute ((packed)) vhost_user_log_t;
-
typedef enum vhost_user_req
{
VHOST_USER_NONE = 0,
VHOST_USER_MAX
} vhost_user_req_t;
-// vring_desc I/O buffer descriptor
-typedef struct
-{
- uint64_t addr; // packet data buffer address
- uint32_t len; // packet data buffer size
- uint16_t flags; // (see below)
- uint16_t next; // optional index next descriptor in chain
-} __attribute ((packed)) vring_desc_t;
-
-typedef struct
-{
- uint16_t flags;
- volatile uint16_t idx;
- uint16_t ring[VHOST_VRING_MAX_SIZE];
-} __attribute ((packed)) vring_avail_t;
-
-typedef struct
-{
- uint16_t flags;
- uint16_t idx;
- struct /* vring_used_elem */
- {
- uint32_t id;
- uint32_t len;
- } ring[VHOST_VRING_MAX_SIZE];
-} __attribute ((packed)) vring_used_t;
-
-typedef CLIB_PACKED (struct
-{
- u64 addr; // packet data buffer address
- u32 len; // packet data buffer size
- u16 id; // buffer id
- u16 flags; // flags
-}) vring_packed_desc_t;
-
-STATIC_ASSERT_SIZEOF (vring_packed_desc_t, 16);
-
-typedef CLIB_PACKED (struct
-{
- u16 off_wrap;
- u16 flags;
-}) vring_desc_event_t;
-
-typedef struct
-{
- u8 flags;
- u8 gso_type;
- u16 hdr_len;
- u16 gso_size;
- u16 csum_start;
- u16 csum_offset;
-} __attribute ((packed)) virtio_net_hdr_t;
-
-typedef struct {
- virtio_net_hdr_t hdr;
- u16 num_buffers;
-} __attribute ((packed)) virtio_net_hdr_mrg_rxbuf_t;
-
typedef struct vhost_user_msg {
vhost_user_req_t request;
u32 flags;
u8 *mac_p = NULL;
if (mp->disable_mrg_rxbuf)
- disabled_features = (1ULL << FEAT_VIRTIO_NET_F_MRG_RXBUF);
+ disabled_features = VIRTIO_FEATURE (VIRTIO_NET_F_MRG_RXBUF);
if (mp->disable_indirect_desc)
- disabled_features |= (1ULL << FEAT_VIRTIO_F_INDIRECT_DESC);
+ disabled_features |= VIRTIO_FEATURE (VIRTIO_RING_F_INDIRECT_DESC);
/*
* GSO and PACKED are not supported by feature mask via binary API. We
* explicitly via enable_gso and enable_packed argument
*/
disabled_features |= FEATURE_VIRTIO_NET_F_HOST_GUEST_TSO_FEATURE_BITS |
- (1ULL << FEAT_VIRTIO_F_RING_PACKED);
+ VIRTIO_FEATURE (VIRTIO_F_RING_PACKED);
features &= ~disabled_features;
if (mp->use_custom_mac)
* explicitly via enable_gso and enable_packed argument
*/
disabled_features |= FEATURE_VIRTIO_NET_F_HOST_GUEST_TSO_FEATURE_BITS |
- (1ULL << FEAT_VIRTIO_F_RING_PACKED);
+ VIRTIO_FEATURE (VIRTIO_F_RING_PACKED);
features &= ~disabled_features;
rv = vhost_user_modify_if (vnm, vm, (char *) mp->sock_filename,
u64 addr, u64 len, u8 is_host_address)
{
if (PREDICT_TRUE (vui->log_base_addr == 0
- || !(vui->features & (1 << FEAT_VHOST_F_LOG_ALL))))
+ || !(vui->features & VIRTIO_FEATURE (VHOST_F_LOG_ALL))))
{
return;
}
static_always_inline u8
vhost_user_packed_desc_available (vhost_user_vring_t * vring, u16 idx)
{
- return (((vring->packed_desc[idx].flags & VIRTQ_DESC_F_AVAIL) ==
+ return (((vring->packed_desc[idx].flags & VRING_DESC_F_AVAIL) ==
vring->avail_wrap_counter));
}
{
vring->last_avail_idx++;
if (PREDICT_FALSE ((vring->last_avail_idx & vring->qsz_mask) == 0))
- vring->avail_wrap_counter ^= VIRTQ_DESC_F_AVAIL;
+ vring->avail_wrap_counter ^= VRING_DESC_F_AVAIL;
}
static_always_inline void
/* pick up the slot of the next avail idx */
while (desc_table[vring->last_avail_idx & vring->qsz_mask].flags &
- VIRTQ_DESC_F_NEXT)
+ VRING_DESC_F_NEXT)
vhost_user_advance_last_avail_idx (vring);
}
vhost_user_undo_advanced_last_avail_idx (vhost_user_vring_t * vring)
{
if (PREDICT_FALSE ((vring->last_avail_idx & vring->qsz_mask) == 0))
- vring->avail_wrap_counter ^= VIRTQ_DESC_F_AVAIL;
+ vring->avail_wrap_counter ^= VRING_DESC_F_AVAIL;
vring->last_avail_idx--;
}
static_always_inline u64
vhost_user_is_packed_ring_supported (vhost_user_intf_t * vui)
{
- return (vui->features & (1ULL << FEAT_VIRTIO_F_RING_PACKED));
+ return (vui->features & VIRTIO_FEATURE (VIRTIO_F_RING_PACKED));
}
#endif
#include <vnet/devices/devices.h>
#include <vnet/feature/feature.h>
-#include <vnet/devices/virtio/virtio.h>
#include <vnet/devices/virtio/vhost_user.h>
#include <vnet/devices/virtio/vhost_user_inline.h>
t->qid = qid;
hdr_desc = &txvq->desc[desc_current];
- if (txvq->desc[desc_current].flags & VIRTQ_DESC_F_INDIRECT)
+ if (txvq->desc[desc_current].flags & VRING_DESC_F_INDIRECT)
{
t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_INDIRECT;
/* Header is the first here */
hdr_desc = map_guest_mem (vui, txvq->desc[desc_current].addr, &hint);
}
- if (txvq->desc[desc_current].flags & VIRTQ_DESC_F_NEXT)
+ if (txvq->desc[desc_current].flags & VRING_DESC_F_NEXT)
{
t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_SIMPLE_CHAINED;
}
- if (!(txvq->desc[desc_current].flags & VIRTQ_DESC_F_NEXT) &&
- !(txvq->desc[desc_current].flags & VIRTQ_DESC_F_INDIRECT))
+ if (!(txvq->desc[desc_current].flags & VRING_DESC_F_NEXT) &&
+ !(txvq->desc[desc_current].flags & VRING_DESC_F_INDIRECT))
{
t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_SINGLE_DESC;
}
/* This depends on the setup but is very consistent
* So I think the CPU branch predictor will make a pretty good job
* at optimizing the decision. */
- if (txvq->desc[desc_current].flags & VIRTQ_DESC_F_INDIRECT)
+ if (txvq->desc[desc_current].flags & VRING_DESC_F_INDIRECT)
{
desc_table = map_guest_mem (vui, txvq->desc[desc_current].addr,
&map_hint);
if (hdr->hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM)
{
if ((desc_data_offset == desc_table[desc_current].len) &&
- (desc_table[desc_current].flags & VIRTQ_DESC_F_NEXT))
+ (desc_table[desc_current].flags & VRING_DESC_F_NEXT))
{
current = desc_table[desc_current].next;
b_data = map_guest_mem (vui, desc_table[current].addr,
if (desc_data_offset == desc_table[desc_current].len)
{
if (PREDICT_FALSE (desc_table[desc_current].flags &
- VIRTQ_DESC_F_NEXT))
+ VRING_DESC_F_NEXT))
{
desc_current = desc_table[desc_current].next;
desc_data_offset = 0;
{
if (txvq->used_wrap_counter)
desc_table[(desc_head + desc_idx) & mask].flags |=
- (VIRTQ_DESC_F_AVAIL | VIRTQ_DESC_F_USED);
+ (VRING_DESC_F_AVAIL | VRING_DESC_F_USED);
else
desc_table[(desc_head + desc_idx) & mask].flags &=
- ~(VIRTQ_DESC_F_AVAIL | VIRTQ_DESC_F_USED);
+ ~(VRING_DESC_F_AVAIL | VRING_DESC_F_USED);
vhost_user_advance_last_used_idx (txvq);
}
}
t->qid = qid;
hdr_desc = &txvq->packed_desc[desc_current];
- if (txvq->packed_desc[desc_current].flags & VIRTQ_DESC_F_INDIRECT)
+ if (txvq->packed_desc[desc_current].flags & VRING_DESC_F_INDIRECT)
{
t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_INDIRECT;
/* Header is the first here */
hdr_desc = map_guest_mem (vui, txvq->packed_desc[desc_current].addr,
&hint);
}
- if (txvq->packed_desc[desc_current].flags & VIRTQ_DESC_F_NEXT)
+ if (txvq->packed_desc[desc_current].flags & VRING_DESC_F_NEXT)
t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_SIMPLE_CHAINED;
- if (!(txvq->packed_desc[desc_current].flags & VIRTQ_DESC_F_NEXT) &&
- !(txvq->packed_desc[desc_current].flags & VIRTQ_DESC_F_INDIRECT))
+ if (!(txvq->packed_desc[desc_current].flags & VRING_DESC_F_NEXT) &&
+ !(txvq->packed_desc[desc_current].flags & VRING_DESC_F_INDIRECT))
t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_SINGLE_DESC;
t->first_desc_len = hdr_desc ? hdr_desc->len : 0;
u32 desc_len = 0;
u16 mask = txvq->qsz_mask;
- while (desc_table[*current].flags & VIRTQ_DESC_F_NEXT)
+ while (desc_table[*current].flags & VRING_DESC_F_NEXT)
{
desc_len += desc_table[*current].len;
(*n_left)++;
while (vhost_user_packed_desc_available (txvq, current) &&
(n_left < VLIB_FRAME_SIZE))
{
- if (desc_table[current].flags & VIRTQ_DESC_F_INDIRECT)
+ if (desc_table[current].flags & VRING_DESC_F_INDIRECT)
{
buffers_required +=
vhost_user_compute_indirect_desc_len (vui, txvq, buffer_data_size,
desc_data_offset = vui->virtio_net_hdr_sz;
n_descs_to_process = 1;
- if (desc_table[desc_idx].flags & VIRTQ_DESC_F_INDIRECT)
+ if (desc_table[desc_idx].flags & VRING_DESC_F_INDIRECT)
{
n_descs = desc_table[desc_idx].len >> 4;
desc_table = map_guest_mem (vui, desc_table[desc_idx].addr,
* loop. So count how many descriptors in the chain.
*/
n_descs_to_process = 1;
- while (desc_table[desc_idx].flags & VIRTQ_DESC_F_NEXT)
+ while (desc_table[desc_idx].flags & VRING_DESC_F_NEXT)
{
vhost_user_assemble_packet (desc_table, &desc_idx, b_head,
&b_current, &next, &b, &bi_current,
pool_elt_at_index (vum->vhost_user_interfaces, dq->dev_instance);
if (vhost_user_is_packed_ring_supported (vui))
{
- if (vui->features & (1ULL << FEAT_VIRTIO_NET_F_CSUM))
+ if (vui->features & VIRTIO_FEATURE (VIRTIO_NET_F_CSUM))
n_rx_packets += vhost_user_if_input_packed (vm, vum, vui,
dq->queue_id, node,
dq->mode, 1);
}
else
{
- if (vui->features & (1ULL << FEAT_VIRTIO_NET_F_CSUM))
+ if (vui->features & VIRTIO_FEATURE (VIRTIO_NET_F_CSUM))
n_rx_packets += vhost_user_if_input (vm, vum, vui, dq->queue_id,
node, dq->mode, 1);
else
#include <vnet/devices/devices.h>
#include <vnet/feature/feature.h>
-#include <vnet/devices/virtio/virtio.h>
#include <vnet/devices/virtio/vhost_user.h>
#include <vnet/devices/virtio/vhost_user_inline.h>
t->qid = qid;
hdr_desc = &rxvq->desc[desc_current];
- if (rxvq->desc[desc_current].flags & VIRTQ_DESC_F_INDIRECT)
+ if (rxvq->desc[desc_current].flags & VRING_DESC_F_INDIRECT)
{
t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_INDIRECT;
/* Header is the first here */
hdr_desc = map_guest_mem (vui, rxvq->desc[desc_current].addr, &hint);
}
- if (rxvq->desc[desc_current].flags & VIRTQ_DESC_F_NEXT)
+ if (rxvq->desc[desc_current].flags & VRING_DESC_F_NEXT)
{
t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_SIMPLE_CHAINED;
}
- if (!(rxvq->desc[desc_current].flags & VIRTQ_DESC_F_NEXT) &&
- !(rxvq->desc[desc_current].flags & VIRTQ_DESC_F_INDIRECT))
+ if (!(rxvq->desc[desc_current].flags & VRING_DESC_F_NEXT) &&
+ !(rxvq->desc[desc_current].flags & VRING_DESC_F_INDIRECT))
{
t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_SINGLE_DESC;
}
if (b->flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM)
{
if (is_ip4 &&
- (vui->features & (1ULL << FEAT_VIRTIO_NET_F_GUEST_TSO4)))
+ (vui->features & VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_TSO4)))
{
hdr->gso_size = vnet_buffer2 (b)->gso_size;
hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
}
else if (is_ip6 &&
- (vui->features & (1ULL << FEAT_VIRTIO_NET_F_GUEST_TSO6)))
+ (vui->features & VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_TSO6)))
{
hdr->gso_size = vnet_buffer2 (b)->gso_size;
hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
}
}
- else if ((vui->features & (1ULL << FEAT_VIRTIO_NET_F_GUEST_UFO)) &&
+ else if ((vui->features & VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_UFO)) &&
(b->flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM))
{
hdr->gso_size = vnet_buffer2 (b)->gso_size;
if (rxvq->used_wrap_counter)
flags = desc_table[last_used_idx & rxvq->qsz_mask].flags |
- (VIRTQ_DESC_F_AVAIL | VIRTQ_DESC_F_USED);
+ (VRING_DESC_F_AVAIL | VRING_DESC_F_USED);
else
flags = desc_table[last_used_idx & rxvq->qsz_mask].flags &
- ~(VIRTQ_DESC_F_AVAIL | VIRTQ_DESC_F_USED);
+ ~(VRING_DESC_F_AVAIL | VRING_DESC_F_USED);
vhost_user_advance_last_used_idx (rxvq);
{
if (rxvq->used_wrap_counter)
desc_table[rxvq->last_used_idx & rxvq->qsz_mask].flags |=
- (VIRTQ_DESC_F_AVAIL | VIRTQ_DESC_F_USED);
+ (VRING_DESC_F_AVAIL | VRING_DESC_F_USED);
else
desc_table[rxvq->last_used_idx & rxvq->qsz_mask].flags &=
- ~(VIRTQ_DESC_F_AVAIL | VIRTQ_DESC_F_USED);
+ ~(VRING_DESC_F_AVAIL | VRING_DESC_F_USED);
vhost_user_advance_last_used_idx (rxvq);
}
vring_packed_desc_t *desc_table = rxvq->packed_desc;
while (desc_table[rxvq->last_used_idx & rxvq->qsz_mask].flags &
- VIRTQ_DESC_F_NEXT)
+ VRING_DESC_F_NEXT)
vhost_user_advance_last_used_idx (rxvq);
/* Advance past the current chained table entries */
t->qid = qid;
hdr_desc = &rxvq->packed_desc[desc_current];
- if (rxvq->packed_desc[desc_current].flags & VIRTQ_DESC_F_INDIRECT)
+ if (rxvq->packed_desc[desc_current].flags & VRING_DESC_F_INDIRECT)
{
t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_INDIRECT;
/* Header is the first here */
hdr_desc = map_guest_mem (vui, rxvq->packed_desc[desc_current].addr,
&hint);
}
- if (rxvq->packed_desc[desc_current].flags & VIRTQ_DESC_F_NEXT)
+ if (rxvq->packed_desc[desc_current].flags & VRING_DESC_F_NEXT)
{
t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_SIMPLE_CHAINED;
}
- if (!(rxvq->packed_desc[desc_current].flags & VIRTQ_DESC_F_NEXT) &&
- !(rxvq->packed_desc[desc_current].flags & VIRTQ_DESC_F_INDIRECT))
+ if (!(rxvq->packed_desc[desc_current].flags & VRING_DESC_F_NEXT) &&
+ !(rxvq->packed_desc[desc_current].flags & VRING_DESC_F_INDIRECT))
{
t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_SINGLE_DESC;
}
* Go deeper in case of indirect descriptor.
* To test it, turn off mrg_rxbuf.
*/
- if (desc_table[desc_head].flags & VIRTQ_DESC_F_INDIRECT)
+ if (desc_table[desc_head].flags & VRING_DESC_F_INDIRECT)
{
indirect = 1;
if (PREDICT_FALSE (desc_table[desc_head].len <
}
desc_index = 0;
}
- else if (rxvq->packed_desc[desc_head].flags & VIRTQ_DESC_F_NEXT)
+ else if (rxvq->packed_desc[desc_head].flags & VRING_DESC_F_NEXT)
chained = 1;
desc_len = vui->virtio_net_hdr_sz;
/* Guest supports csum offload and buffer requires checksum offload? */
if (or_flags &&
- (vui->features & (1ULL << FEAT_VIRTIO_NET_F_GUEST_CSUM)))
+ (vui->features & VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_CSUM)))
vhost_user_handle_tx_offload (vui, b0, &hdr->hdr);
/* Prepare a copy order executed later for the header */
* Test it with both indirect and mrg_rxbuf off
*/
if (PREDICT_FALSE (!(desc_table[desc_index].flags &
- VIRTQ_DESC_F_NEXT)))
+ VRING_DESC_F_NEXT)))
{
/*
* Last descriptor in chain.
/* Go deeper in case of indirect descriptor
* I don't know of any driver providing indirect for RX. */
- if (PREDICT_FALSE (rxvq->desc[desc_head].flags & VIRTQ_DESC_F_INDIRECT))
+ if (PREDICT_FALSE (rxvq->desc[desc_head].flags & VRING_DESC_F_INDIRECT))
{
if (PREDICT_FALSE
(rxvq->desc[desc_head].len < sizeof (vring_desc_t)))
/* Guest supports csum offload and buffer requires checksum offload? */
if (or_flags
- && (vui->features & (1ULL << FEAT_VIRTIO_NET_F_GUEST_CSUM)))
+ && (vui->features & VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_CSUM)))
vhost_user_handle_tx_offload (vui, b0, &hdr->hdr);
// Prepare a copy order executed later for the header
{
if (buffer_len == 0)
{ //Get new output
- if (desc_table[desc_index].flags & VIRTQ_DESC_F_NEXT)
+ if (desc_table[desc_index].flags & VRING_DESC_F_NEXT)
{
//Next one is chained
desc_index = desc_table[desc_index].next;
desc_head = desc_index =
rxvq->avail->ring[rxvq->last_avail_idx & rxvq->qsz_mask];
if (PREDICT_FALSE
- (rxvq->desc[desc_head].flags & VIRTQ_DESC_F_INDIRECT))
+ (rxvq->desc[desc_head].flags & VRING_DESC_F_INDIRECT))
{
//It is seriously unlikely that a driver will put indirect descriptor
//after non-indirect descriptor.
#include <net/if.h>
#include <linux/if_tun.h>
#include <sys/ioctl.h>
-#include <linux/virtio_net.h>
-#include <linux/vhost.h>
#include <sys/eventfd.h>
#include <vlib/vlib.h>
CLIB_CACHE_LINE_BYTES);
vring = vec_elt_at_index (vif->rxq_vrings, RX_QUEUE_ACCESS (idx));
}
- i = sizeof (struct vring_desc) * sz;
+ i = sizeof (vring_desc_t) * sz;
i = round_pow2 (i, CLIB_CACHE_LINE_BYTES);
vring->desc = clib_mem_alloc_aligned (i, CLIB_CACHE_LINE_BYTES);
clib_memset (vring->desc, 0, i);
- i = sizeof (struct vring_avail) + sz * sizeof (vring->avail->ring[0]);
+ i = sizeof (vring_avail_t) + sz * sizeof (vring->avail->ring[0]);
i = round_pow2 (i, CLIB_CACHE_LINE_BYTES);
vring->avail = clib_mem_alloc_aligned (i, CLIB_CACHE_LINE_BYTES);
clib_memset (vring->avail, 0, i);
// tell kernel that we don't need interrupt
- vring->avail->flags = VIRTIO_RING_FLAG_MASK_INT;
+ vring->avail->flags = VRING_AVAIL_F_NO_INTERRUPT;
- i = sizeof (struct vring_used) + sz * sizeof (struct vring_used_elem);
+ i = sizeof (vring_used_t) + sz * sizeof (vring_used_elem_t);
i = round_pow2 (i, CLIB_CACHE_LINE_BYTES);
vring->used = clib_mem_alloc_aligned (i, CLIB_CACHE_LINE_BYTES);
clib_memset (vring->used, 0, i);
while (n_left)
{
- struct vring_used_elem *e = &vring->used->ring[last & mask];
+ vring_used_elem_t *e = &vring->used->ring[last & mask];
u16 slot = e->id;
vlib_buffer_free (vm, &vring->buffers[slot], 1);
{
if (vif->features & VIRTIO_FEATURE (VIRTIO_NET_F_MRG_RXBUF) ||
vif->features & VIRTIO_FEATURE (VIRTIO_F_VERSION_1))
- vif->virtio_net_hdr_sz = sizeof (struct virtio_net_hdr_v1);
+ vif->virtio_net_hdr_sz = sizeof (virtio_net_hdr_v1_t);
else
- vif->virtio_net_hdr_sz = sizeof (struct virtio_net_hdr);
+ vif->virtio_net_hdr_sz = sizeof (virtio_net_hdr_t);
}
inline void
" ===== ================== ===== ====== ===== ==================\n");
for (j = 0; j < vring->size; j++)
{
- struct vring_desc *desc = &vring->desc[j];
+ vring_desc_t *desc = &vring->desc[j];
vlib_cli_output (vm,
" %-5d 0x%016lx %-5d 0x%04x %-5d 0x%016lx\n",
j, desc->addr,
" ===== ================== ===== ====== ===== ==================\n");
for (j = 0; j < vring->size; j++)
{
- struct vring_desc *desc = &vring->desc[j];
+ vring_desc_t *desc = &vring->desc[j];
vlib_cli_output (vm,
" %-5d 0x%016lx %-5d 0x%04x %-5d 0x%016lx\n",
j, desc->addr,
" ===== ================== ===== ====== ===== ==================\n");
for (j = 0; j < vring->size; j++)
{
- struct vring_desc *desc = &vring->desc[j];
+ vring_desc_t *desc = &vring->desc[j];
vlib_cli_output (vm,
" %-5d 0x%016lx %-5d 0x%04x %-5d 0x%016lx\n",
j, desc->addr,
#ifndef _VNET_DEVICES_VIRTIO_VIRTIO_H_
#define _VNET_DEVICES_VIRTIO_VIRTIO_H_
-#include <linux/virtio_config.h>
-#include <linux/virtio_net.h>
-#include <linux/virtio_pci.h>
-#include <linux/virtio_ring.h>
+#include <vnet/devices/virtio/virtio_std.h>
+#include <vnet/devices/virtio/vhost_std.h>
#include <vnet/gso/gro.h>
-#define foreach_virtio_net_features \
- _ (VIRTIO_NET_F_CSUM, 0) /* Host handles pkts w/ partial csum */ \
- _ (VIRTIO_NET_F_GUEST_CSUM, 1) /* Guest handles pkts w/ partial csum */ \
- _ (VIRTIO_NET_F_CTRL_GUEST_OFFLOADS, 2) /* Dynamic offload configuration. */ \
- _ (VIRTIO_NET_F_MTU, 3) /* Initial MTU advice. */ \
- _ (VIRTIO_NET_F_MAC, 5) /* Host has given MAC address. */ \
- _ (VIRTIO_NET_F_GSO, 6) /* Host handles pkts w/ any GSO. */ \
- _ (VIRTIO_NET_F_GUEST_TSO4, 7) /* Guest can handle TSOv4 in. */ \
- _ (VIRTIO_NET_F_GUEST_TSO6, 8) /* Guest can handle TSOv6 in. */ \
- _ (VIRTIO_NET_F_GUEST_ECN, 9) /* Guest can handle TSO[6] w/ ECN in. */ \
- _ (VIRTIO_NET_F_GUEST_UFO, 10) /* Guest can handle UFO in. */ \
- _ (VIRTIO_NET_F_HOST_TSO4, 11) /* Host can handle TSOv4 in. */ \
- _ (VIRTIO_NET_F_HOST_TSO6, 12) /* Host can handle TSOv6 in. */ \
- _ (VIRTIO_NET_F_HOST_ECN, 13) /* Host can handle TSO[6] w/ ECN in. */ \
- _ (VIRTIO_NET_F_HOST_UFO, 14) /* Host can handle UFO in. */ \
- _ (VIRTIO_NET_F_MRG_RXBUF, 15) /* Host can merge receive buffers. */ \
- _ (VIRTIO_NET_F_STATUS, 16) /* virtio_net_config.status available */ \
- _ (VIRTIO_NET_F_CTRL_VQ, 17) /* Control channel available */ \
- _ (VIRTIO_NET_F_CTRL_RX, 18) /* Control channel RX mode support */ \
- _ (VIRTIO_NET_F_CTRL_VLAN, 19) /* Control channel VLAN filtering */ \
- _ (VIRTIO_NET_F_CTRL_RX_EXTRA, 20) /* Extra RX mode control support */ \
- _ (VIRTIO_NET_F_GUEST_ANNOUNCE, 21) /* Guest can announce device on the network */ \
- _ (VIRTIO_NET_F_MQ, 22) /* Device supports Receive Flow Steering */ \
- _ (VIRTIO_NET_F_CTRL_MAC_ADDR, 23) /* Set MAC address */ \
- _ (VIRTIO_F_NOTIFY_ON_EMPTY, 24) \
- _ (VHOST_F_LOG_ALL, 26) /* Log all write descriptors */ \
- _ (VIRTIO_F_ANY_LAYOUT, 27) /* Can the device handle any descriptor layout */ \
- _ (VIRTIO_RING_F_INDIRECT_DESC, 28) /* Support indirect buffer descriptors */ \
- _ (VIRTIO_RING_F_EVENT_IDX, 29) /* The Guest publishes the used index for which it expects an interrupt \
- * at the end of the avail ring. Host should ignore the avail->flags field. */ \
-/* The Host publishes the avail index for which it expects a kick \
- * at the end of the used ring. Guest should ignore the used->flags field. */ \
- _ (VHOST_USER_F_PROTOCOL_FEATURES, 30) \
- _ (VIRTIO_F_VERSION_1, 32) /* v1.0 compliant. */ \
-
#define foreach_virtio_if_flag \
_(0, ADMIN_UP, "admin-up") \
_(1, DELETING, "deleting")
#undef _
} virtio_if_flag_t;
-#define VIRTIO_FEATURE(X) (1ULL << X)
-
#define TX_QUEUE(X) ((X*2) + 1)
#define RX_QUEUE(X) (X*2)
#define TX_QUEUE_ACCESS(X) (X/2)
{
CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
clib_spinlock_t lockp;
- struct vring_desc *desc;
- struct vring_used *used;
- struct vring_avail *avail;
+ vring_desc_t *desc;
+ vring_used_t *used;
+ vring_avail_t *avail;
u16 desc_in_use;
u16 desc_next;
int kick_fd;
virtio_pci_modern_setup_queue (vlib_main_t * vm, virtio_if_t * vif,
u16 queue_id, void *p)
{
- struct vring vr;
+ vring_t vr;
u16 queue_size = 0;
virtio_pci_modern_set_queue_select (vif, queue_id);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef __VIRTIO_STD_H__
+#define __VIRTIO_STD_H__
+
+#define foreach_virtio_net_features \
+ _ (VIRTIO_NET_F_CSUM, 0) /* Host handles pkts w/ partial csum */ \
+ _ (VIRTIO_NET_F_GUEST_CSUM, 1) /* Guest handles pkts w/ partial csum */ \
+ _ (VIRTIO_NET_F_CTRL_GUEST_OFFLOADS, 2) /* Dynamic offload configuration. */ \
+ _ (VIRTIO_NET_F_MTU, 3) /* Initial MTU advice. */ \
+ _ (VIRTIO_NET_F_MAC, 5) /* Host has given MAC address. */ \
+ _ (VIRTIO_NET_F_GSO, 6) /* Host handles pkts w/ any GSO. */ \
+ _ (VIRTIO_NET_F_GUEST_TSO4, 7) /* Guest can handle TSOv4 in. */ \
+ _ (VIRTIO_NET_F_GUEST_TSO6, 8) /* Guest can handle TSOv6 in. */ \
+ _ (VIRTIO_NET_F_GUEST_ECN, 9) /* Guest can handle TSO[6] w/ ECN in. */ \
+ _ (VIRTIO_NET_F_GUEST_UFO, 10) /* Guest can handle UFO in. */ \
+ _ (VIRTIO_NET_F_HOST_TSO4, 11) /* Host can handle TSOv4 in. */ \
+ _ (VIRTIO_NET_F_HOST_TSO6, 12) /* Host can handle TSOv6 in. */ \
+ _ (VIRTIO_NET_F_HOST_ECN, 13) /* Host can handle TSO[6] w/ ECN in. */ \
+ _ (VIRTIO_NET_F_HOST_UFO, 14) /* Host can handle UFO in. */ \
+ _ (VIRTIO_NET_F_MRG_RXBUF, 15) /* Host can merge receive buffers. */ \
+ _ (VIRTIO_NET_F_STATUS, 16) /* virtio_net_config.status available */ \
+ _ (VIRTIO_NET_F_CTRL_VQ, 17) /* Control channel available */ \
+ _ (VIRTIO_NET_F_CTRL_RX, 18) /* Control channel RX mode support */ \
+ _ (VIRTIO_NET_F_CTRL_VLAN, 19) /* Control channel VLAN filtering */ \
+ _ (VIRTIO_NET_F_CTRL_RX_EXTRA, 20) /* Extra RX mode control support */ \
+ _ (VIRTIO_NET_F_GUEST_ANNOUNCE, 21) /* Guest can announce device on the network */ \
+ _ (VIRTIO_NET_F_MQ, 22) /* Device supports Receive Flow Steering */ \
+ _ (VIRTIO_NET_F_CTRL_MAC_ADDR, 23) /* Set MAC address */ \
+ _ (VIRTIO_F_NOTIFY_ON_EMPTY, 24) \
+ _ (VHOST_F_LOG_ALL, 26) /* Log all write descriptors */ \
+ _ (VIRTIO_F_ANY_LAYOUT, 27) /* Can the device handle any descriptor layout */ \
+ _ (VIRTIO_RING_F_INDIRECT_DESC, 28) /* Support indirect buffer descriptors */ \
+ _ (VIRTIO_RING_F_EVENT_IDX, 29) /* The Guest publishes the used index for which it expects an interrupt \
+ * at the end of the avail ring. Host should ignore the avail->flags field. */ \
+/* The Host publishes the avail index for which it expects a kick \
+ * at the end of the used ring. Guest should ignore the used->flags field. */ \
+ _ (VHOST_USER_F_PROTOCOL_FEATURES, 30) \
+ _ (VIRTIO_F_VERSION_1, 32) /* v1.0 compliant. */ \
+ _ (VIRTIO_F_IOMMU_PLATFORM, 33) \
+ _ (VIRTIO_F_RING_PACKED, 34) \
+ _ (VIRTIO_F_IN_ORDER, 35) /* all buffers are used by the device in the */ \
+ /* same order in which they have been made available */ \
+ _ (VIRTIO_F_ORDER_PLATFORM, 36) /* memory accesses by the driver and the */ \
+ /* device are ordered in a way described by the platfor */ \
+ _ (VIRTIO_F_NOTIFICATION_DATA, 38) /* the driver passes extra data (besides */ \
+ /* identifying the virtqueue) in its device notifications. */ \
+ _ (VIRTIO_NET_F_SPEED_DUPLEX, 63) /* Device set linkspeed and duplex */
+
+typedef enum
+{
+#define _(f,n) f = n,
+ foreach_virtio_net_features
+#undef _
+} virtio_net_feature_t;
+
+#define VIRTIO_FEATURE(X) (1ULL << X)
+
+#define VRING_MAX_SIZE 32768
+
+#define VRING_DESC_F_NEXT 1
+#define VRING_DESC_F_WRITE 2
+#define VRING_DESC_F_INDIRECT 4
+
+#define VRING_DESC_F_AVAIL (1 << 7)
+#define VRING_DESC_F_USED (1 << 15)
+
+#define VRING_EVENT_F_ENABLE 0x0
+#define VRING_EVENT_F_DISABLE 0x1
+#define VRING_EVENT_F_DESC 0x2
+
+#define VRING_USED_F_NO_NOTIFY 1
+#define VRING_AVAIL_F_NO_INTERRUPT 1
+
+typedef struct
+{
+ u64 addr;
+ u32 len;
+ u16 flags;
+ u16 next;
+} vring_desc_t;
+
+typedef struct
+{
+ u16 flags;
+ u16 idx;
+ u16 ring[0];
+ /* u16 used_event; */
+} vring_avail_t;
+
+typedef struct
+{
+ u32 id;
+ u32 len;
+} vring_used_elem_t;
+
+typedef struct
+{
+ u16 flags;
+ u16 idx;
+ vring_used_elem_t ring[0];
+ /* u16 avail_event; */
+} vring_used_t;
+
+/* *INDENT-OFF* */
+typedef CLIB_PACKED (struct
+{
+ u64 addr; // packet data buffer address
+ u32 len; // packet data buffer size
+ u16 id; // buffer id
+ u16 flags; // flags
+}) vring_packed_desc_t;
+
+STATIC_ASSERT_SIZEOF (vring_packed_desc_t, 16);
+
+typedef CLIB_PACKED (struct
+{
+ u16 off_wrap;
+ u16 flags;
+}) vring_desc_event_t;
+
+#define VIRTIO_NET_HDR_F_NEEDS_CSUM 1 /* Use csum_start, csum_offset */
+#define VIRTIO_NET_HDR_F_DATA_VALID 2 /* Csum is valid */
+
+#define VIRTIO_NET_HDR_GSO_NONE 0 /* Not a GSO frame */
+#define VIRTIO_NET_HDR_GSO_TCPV4 1 /* GSO frame, IPv4 TCP (TSO) */
+#define VIRTIO_NET_HDR_GSO_UDP 3 /* GSO frame, IPv4 UDP (UFO) */
+#define VIRTIO_NET_HDR_GSO_TCPV6 4 /* GSO frame, IPv6 TCP */
+#define VIRTIO_NET_HDR_GSO_ECN 0x80 /* TCP has ECN set */
+
+typedef CLIB_PACKED (struct
+{
+ u8 flags;
+ u8 gso_type;
+ u16 hdr_len; /* Ethernet + IP + tcp/udp hdrs */
+ u16 gso_size; /* Bytes to append to hdr_len per frame */
+ u16 csum_start; /* Position to start checksumming from */
+ u16 csum_offset; /* Offset after that to place checksum */
+ u16 num_buffers; /* Number of merged rx buffers */
+}) virtio_net_hdr_v1_t;
+
+typedef CLIB_PACKED (struct
+{
+ u8 flags;
+ u8 gso_type;
+ u16 hdr_len;
+ u16 gso_size;
+ u16 csum_start;
+ u16 csum_offset;
+}) virtio_net_hdr_t;
+
+typedef CLIB_PACKED (struct
+{
+ virtio_net_hdr_t hdr;
+ u16 num_buffers;
+}) virtio_net_hdr_mrg_rxbuf_t;
+
+/* *INDENT-ON* */
+
+typedef struct
+{
+ u16 num;
+ vring_desc_t *desc;
+ vring_avail_t *avail;
+ vring_used_t *used;
+} vring_t;
+
+static_always_inline void
+vring_init (vring_t * vr, u32 num, void *p, u32 align)
+{
+ vr->num = num;
+ vr->desc = p;
+ vr->avail = (vring_avail_t *) ((char *) p + num * sizeof (vring_desc_t));
+ vr->used =
+ (vring_used_t *) ((char *) p +
+ ((sizeof (vring_desc_t) * num +
+ sizeof (u16) * (3 + num) + align - 1) & ~(align -
+ 1)));
+}
+
+static_always_inline u16
+vring_size (u32 num, u32 align)
+{
+ return ((sizeof (vring_desc_t) * num + sizeof (u16) * (3 + num)
+ + align - 1) & ~(align - 1))
+ + sizeof (u16) * 3 + sizeof (vring_used_elem_t) * num;
+}
+#endif
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
Code Review / vpp.git / commitdiff