#include <vnet/devices/virtio/vhost-user.h>
+/**
+ * @file
+ * @brief vHost User Device Driver.
+ *
+ * This file contains the source code for vHost User interface.
+ */
+
+
#define VHOST_USER_DEBUG_SOCKET 0
#define VHOST_DEBUG_VQ 0
#define DBG_VQ(args...)
#endif
+#define UNIX_GET_FD(unixfd_idx) \
+ (unixfd_idx != ~0) ? \
+ pool_elt_at_index (unix_main.file_pool, \
+ unixfd_idx)->file_descriptor : -1;
+
#define foreach_virtio_trace_flags \
_ (SIMPLE_CHAINED, 0, "Simple descriptor chaining") \
_ (SINGLE_DESC, 1, "Single descriptor packet") \
static int
vhost_user_name_renumber (vnet_hw_interface_t * hi, u32 new_dev_instance)
{
+ // FIXME: check if the new dev instance is already used
vhost_user_main_t *vum = &vhost_user_main;
-
vec_validate_init_empty (vum->show_dev_instance_by_real_dev_instance,
hi->dev_instance, ~0);
}
i = 0;
- vec_foreach (vui, vum->vhost_user_interfaces)
- {
- if (!vui->active)
- continue;
+ vhost_iface_and_queue_t iaq;
+ /* *INDENT-OFF* */
+ pool_foreach (vui, vum->vhost_user_interfaces, {
+ u32 *vui_workers = vec_len (vui->workers) ? vui->workers : workers;
+ u32 qid;
+ for (qid = 0; qid < VHOST_VRING_MAX_N / 2; qid++)
+ {
+ vhost_user_vring_t *txvq =
+ &vui->vrings[VHOST_VRING_IDX_TX (qid)];
+ if (!txvq->started)
+ continue;
- u32 *vui_workers = vec_len (vui->workers) ? vui->workers : workers;
- u32 qid;
- for (qid = 0; qid < VHOST_VRING_MAX_N / 2; qid++)
- {
- vhost_user_vring_t *txvq = &vui->vrings[VHOST_VRING_IDX_TX (qid)];
- if (!txvq->started)
- continue;
-
- i %= vec_len (vui_workers);
- u32 cpu_index = vui_workers[i];
- i++;
- vhc = &vum->cpus[cpu_index];
-
- vhost_iface_and_queue_t iaq = {
- .qid = qid,
- .vhost_iface_index = vui - vum->vhost_user_interfaces,
- };
- vec_add1 (vhc->rx_queues, iaq);
- vlib_node_set_state (vlib_mains ? vlib_mains[cpu_index] :
- &vlib_global_main, vhost_user_input_node.index,
- VLIB_NODE_STATE_POLLING);
- }
- }
+ i %= vec_len (vui_workers);
+ u32 cpu_index = vui_workers[i];
+ i++;
+ vhc = &vum->cpus[cpu_index];
+
+ iaq.qid = qid;
+ iaq.vhost_iface_index = vui - vum->vhost_user_interfaces;
+ vec_add1 (vhc->rx_queues, iaq);
+ vlib_node_set_state (vlib_mains ? vlib_mains[cpu_index] :
+ &vlib_global_main, vhost_user_input_node.index,
+ VLIB_NODE_STATE_POLLING);
+ }
+ });
+ /* *INDENT-ON* */
}
static int
if (!(hw = vnet_get_sup_hw_interface (vnet_get_main (), sw_if_index)))
return -2;
- vui = vec_elt_at_index (vum->vhost_user_interfaces, hw->dev_instance);
+ vui = pool_elt_at_index (vum->vhost_user_interfaces, hw->dev_instance);
u32 found = ~0, *w;
vec_foreach (w, vui->workers)
{
__attribute__ ((unused)) int n;
u8 buff[8];
vhost_user_intf_t *vui =
- vec_elt_at_index (vhost_user_main.vhost_user_interfaces,
- uf->private_data >> 8);
+ pool_elt_at_index (vhost_user_main.vhost_user_interfaces,
+ uf->private_data >> 8);
u32 qid = uf->private_data & 0xff;
n = read (uf->file_descriptor, ((char *) &buff), 8);
DBG_SOCK ("if %d KICK queue %d", uf->private_data >> 8, qid);
{
vhost_user_vring_t *vring = &vui->vrings[qid];
memset (vring, 0, sizeof (*vring));
- vring->kickfd = -1;
- vring->callfd = -1;
+ vring->kickfd_idx = ~0;
+ vring->callfd_idx = ~0;
vring->errfd = -1;
/*
vhost_user_vring_close (vhost_user_intf_t * vui, u32 qid)
{
vhost_user_vring_t *vring = &vui->vrings[qid];
- if (vring->kickfd != -1)
+ if (vring->kickfd_idx != ~0)
{
unix_file_t *uf = pool_elt_at_index (unix_main.file_pool,
vring->kickfd_idx);
unix_file_del (&unix_main, uf);
+ vring->kickfd_idx = ~0;
}
- if (vring->callfd != -1)
+ if (vring->callfd_idx != ~0)
{
unix_file_t *uf = pool_elt_at_index (unix_main.file_pool,
vring->callfd_idx);
unix_file_del (&unix_main, uf);
+ vring->callfd_idx = ~0;
}
if (vring->errfd != -1)
close (vring->errfd);
static inline void
vhost_user_if_disconnect (vhost_user_intf_t * vui)
{
- vhost_user_main_t *vum = &vhost_user_main;
vnet_main_t *vnm = vnet_get_main ();
int q;
unix_file_del (&unix_main, unix_main.file_pool + vui->unix_file_index);
vui->unix_file_index = ~0;
}
- else
- close (vui->unix_fd);
- hash_unset (vum->vhost_user_interface_index_by_sock_fd, vui->unix_fd);
- hash_unset (vum->vhost_user_interface_index_by_listener_fd, vui->unix_fd);
- vui->unix_fd = -1;
vui->is_up = 0;
for (q = 0; q < VHOST_VRING_MAX_N; q++)
vhost_user_main_t *vum = &vhost_user_main;
vhost_user_intf_t *vui;
struct cmsghdr *cmsg;
- uword *p;
u8 q;
unix_file_t template = { 0 };
vnet_main_t *vnm = vnet_get_main ();
- p = hash_get (vum->vhost_user_interface_index_by_sock_fd,
- uf->file_descriptor);
- if (p == 0)
- {
- DBG_SOCK ("FD %d doesn't belong to any interface", uf->file_descriptor);
- return 0;
- }
- else
- vui = vec_elt_at_index (vum->vhost_user_interfaces, p[0]);
+ vui = pool_elt_at_index (vum->vhost_user_interfaces, uf->private_data);
char control[CMSG_SPACE (VHOST_MEMORY_MAX_NREGIONS * sizeof (int))];
q = (u8) (msg.u64 & 0xFF);
/* if there is old fd, delete and close it */
- if (vui->vrings[q].callfd != -1)
+ if (vui->vrings[q].callfd_idx != ~0)
{
unix_file_t *uf = pool_elt_at_index (unix_main.file_pool,
vui->vrings[q].callfd_idx);
unix_file_del (&unix_main, uf);
+ vui->vrings[q].callfd_idx = ~0;
}
if (!(msg.u64 & 0x100))
goto close_socket;
}
- vui->vrings[q].callfd = fds[0];
template.read_function = vhost_user_callfd_read_ready;
template.file_descriptor = fds[0];
+ template.private_data =
+ ((vui - vhost_user_main.vhost_user_interfaces) << 8) + q;
vui->vrings[q].callfd_idx = unix_file_add (&unix_main, &template);
}
else
- vui->vrings[q].callfd = -1;
+ vui->vrings[q].callfd_idx = ~0;
break;
case VHOST_USER_SET_VRING_KICK:
q = (u8) (msg.u64 & 0xFF);
- if (vui->vrings[q].kickfd != -1)
+ if (vui->vrings[q].kickfd_idx != ~0)
{
unix_file_t *uf = pool_elt_at_index (unix_main.file_pool,
- vui->vrings[q].kickfd);
+ vui->vrings[q].kickfd_idx);
unix_file_del (&unix_main, uf);
+ vui->vrings[q].kickfd_idx = ~0;
}
if (!(msg.u64 & 0x100))
goto close_socket;
}
- if (vui->vrings[q].kickfd > -1)
- close (vui->vrings[q].kickfd);
-
- vui->vrings[q].kickfd = fds[0];
template.read_function = vhost_user_kickfd_read_ready;
template.file_descriptor = fds[0];
template.private_data =
- ((vui - vhost_user_main.vhost_user_interfaces) << 8) + q;
+ (((uword) (vui - vhost_user_main.vhost_user_interfaces)) << 8) +
+ q;
vui->vrings[q].kickfd_idx = unix_file_add (&unix_main, &template);
}
else
{
- vui->vrings[q].kickfd = -1;
+ //When no kickfd is set, the queue is initialized as started
+ vui->vrings[q].kickfd_idx = ~0;
vui->vrings[q].started = 1;
}
- //TODO: When kickfd is specified, 'started' is set when the first kick
- //is received.
break;
case VHOST_USER_SET_VRING_ERR:
{
vlib_main_t *vm = vlib_get_main ();
vhost_user_main_t *vum = &vhost_user_main;
- vhost_user_intf_t *vui;
- uword *p;
-
- p = hash_get (vum->vhost_user_interface_index_by_sock_fd,
- uf->file_descriptor);
- if (p == 0)
- {
- DBG_SOCK ("fd %d doesn't belong to any interface", uf->file_descriptor);
- return 0;
- }
- else
- vui = vec_elt_at_index (vum->vhost_user_interfaces, p[0]);
+ vhost_user_intf_t *vui =
+ pool_elt_at_index (vum->vhost_user_interfaces, uf->private_data);
DBG_SOCK ("socket error on if %d", vui->sw_if_index);
vlib_worker_thread_barrier_sync (vm);
unix_file_t template = { 0 };
vhost_user_main_t *vum = &vhost_user_main;
vhost_user_intf_t *vui;
- uword *p;
- p = hash_get (vum->vhost_user_interface_index_by_listener_fd,
- uf->file_descriptor);
- if (p == 0)
- {
- DBG_SOCK ("fd %d doesn't belong to any interface", uf->file_descriptor);
- return 0;
- }
- else
- vui = vec_elt_at_index (vum->vhost_user_interfaces, p[0]);
+ vui = pool_elt_at_index (vum->vhost_user_interfaces, uf->private_data);
client_len = sizeof (client);
client_fd = accept (uf->file_descriptor,
template.read_function = vhost_user_socket_read;
template.error_function = vhost_user_socket_error;
template.file_descriptor = client_fd;
+ template.private_data = vui - vhost_user_main.vhost_user_interfaces;
vui->unix_file_index = unix_file_add (&unix_main, &template);
-
- vui->client_fd = client_fd;
- hash_set (vum->vhost_user_interface_index_by_sock_fd, vui->client_fd,
- vui - vum->vhost_user_interfaces);
-
return 0;
}
if (error)
return error;
- vum->vhost_user_interface_index_by_listener_fd =
- hash_create (0, sizeof (uword));
- vum->vhost_user_interface_index_by_sock_fd =
- hash_create (0, sizeof (uword));
- vum->vhost_user_interface_index_by_sw_if_index =
- hash_create (0, sizeof (uword));
vum->coalesce_frames = 32;
vum->coalesce_time = 1e-3;
vum->input_cpu_count = tr->count;
}
+ vum->random = random_default_seed ();
+
return 0;
}
CLIB_UNUSED (vnet_main_t * vnm) = vnet_get_main ();
vhost_user_main_t *vum = &vhost_user_main;
vhost_trace_t *t = va_arg (*va, vhost_trace_t *);
- vhost_user_intf_t *vui = vec_elt_at_index (vum->vhost_user_interfaces,
- t->device_index);
+ vhost_user_intf_t *vui = pool_elt_at_index (vum->vhost_user_interfaces,
+ t->device_index);
vnet_sw_interface_t *sw = vnet_get_sw_interface (vnm, vui->sw_if_index);
{
vhost_user_main_t *vum = &vhost_user_main;
u64 x = 1;
+ int fd = UNIX_GET_FD (vq->callfd_idx);
int rv __attribute__ ((unused));
- /* $$$$ pay attention to rv */
- rv = write (vq->callfd, &x, sizeof (x));
+ /* TODO: pay attention to rv */
+ rv = write (fd, &x, sizeof (x));
vq->n_since_last_int = 0;
vq->int_deadline = vlib_time_now (vm) + vum->coalesce_time;
}
vhost_user_log_dirty_ring (vui, txvq, idx);
/* interrupt (call) handling */
- if ((txvq->callfd > -1) && !(txvq->avail->flags & 1))
+ if ((txvq->callfd_idx != ~0) && !(txvq->avail->flags & 1))
{
txvq->n_since_last_int += n_rx_packets;
}
static uword
-vhost_user_intfc_tx (vlib_main_t * vm,
- vlib_node_runtime_t * node, vlib_frame_t * frame)
+vhost_user_tx (vlib_main_t * vm,
+ vlib_node_runtime_t * node, vlib_frame_t * frame)
{
u32 *buffers = vlib_frame_args (frame);
u32 n_left = 0;
uword n_packets = 0;
vnet_interface_output_runtime_t *rd = (void *) node->runtime_data;
vhost_user_intf_t *vui =
- vec_elt_at_index (vum->vhost_user_interfaces, rd->dev_instance);
+ pool_elt_at_index (vum->vhost_user_interfaces, rd->dev_instance);
u32 qid = ~0;
vhost_user_vring_t *rxvq;
u16 qsz_mask;
u32 map_guest_hint_indirect = 0;
u32 *map_guest_hint_p = &map_guest_hint_desc;
vhost_trace_t *current_trace = 0;
+ int n_retry;
if (PREDICT_FALSE (!vui->is_up || !vui->admin_up))
{
}
qsz_mask = rxvq->qsz - 1; /* qsz is always power of 2 */
+ n_retry = 8;
- while (n_left > 0)
+ while (n_left > 0 && n_retry--)
{
- vlib_buffer_t *b0, *current_b0;
- u16 desc_head, desc_index, desc_len;
- vring_desc_t *desc_table;
- void *buffer_addr;
- u32 buffer_len;
-
- b0 = vlib_get_buffer (vm, buffers[0]);
- buffers++;
- if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
+ while (n_left > 0)
{
- current_trace = vlib_add_trace (vm, node, b0,
- sizeof (*current_trace));
- vhost_user_tx_trace (current_trace, vui, qid / 2, b0, rxvq);
- }
+ vlib_buffer_t *b0, *current_b0;
+ u16 desc_head, desc_index, desc_len;
+ vring_desc_t *desc_table;
+ void *buffer_addr;
+ u32 buffer_len;
- if (PREDICT_FALSE (rxvq->last_avail_idx == rxvq->avail->idx))
- {
- error = VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOBUF;
- goto done;
- }
+ b0 = vlib_get_buffer (vm, buffers[0]);
- desc_table = rxvq->desc;
- map_guest_hint_p = &map_guest_hint_desc;
- desc_head = desc_index =
- rxvq->avail->ring[rxvq->last_avail_idx & qsz_mask];
- if (rxvq->desc[desc_head].flags & VIRTQ_DESC_F_INDIRECT)
- {
- if (PREDICT_FALSE
- (rxvq->desc[desc_head].len < sizeof (vring_desc_t)))
+ if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
{
- error = VHOST_USER_TX_FUNC_ERROR_INDIRECT_OVERFLOW;
- goto done;
+ current_trace = vlib_add_trace (vm, node, b0,
+ sizeof (*current_trace));
+ vhost_user_tx_trace (current_trace, vui, qid / 2, b0, rxvq);
}
- if (PREDICT_FALSE
- (!(desc_table =
- map_guest_mem (vui, rxvq->desc[desc_index].addr,
- &map_guest_hint_desc))))
+
+ if (PREDICT_FALSE (rxvq->last_avail_idx == rxvq->avail->idx))
{
- error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
+ error = VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOBUF;
goto done;
}
- desc_index = 0;
- map_guest_hint_p = &map_guest_hint_indirect;
- }
-
- desc_len = vui->virtio_net_hdr_sz;
-
- if (PREDICT_FALSE
- (!(buffer_addr =
- map_guest_mem (vui, desc_table[desc_index].addr,
- map_guest_hint_p))))
- {
- error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
- goto done;
- }
- buffer_len = desc_table[desc_index].len;
-
- CLIB_PREFETCH (buffer_addr, CLIB_CACHE_LINE_BYTES, STORE);
-
- virtio_net_hdr_mrg_rxbuf_t *hdr =
- (virtio_net_hdr_mrg_rxbuf_t *) buffer_addr;
- hdr->hdr.flags = 0;
- hdr->hdr.gso_type = 0;
- if (vui->virtio_net_hdr_sz == 12)
- hdr->num_buffers = 1;
- vhost_user_log_dirty_pages (vui, desc_table[desc_index].addr,
- vui->virtio_net_hdr_sz);
-
- u16 bytes_left = b0->current_length;
- buffer_addr += vui->virtio_net_hdr_sz;
- buffer_len -= vui->virtio_net_hdr_sz;
- current_b0 = b0;
- while (1)
- {
- if (!bytes_left)
- { //Get new input
- if (current_b0->flags & VLIB_BUFFER_NEXT_PRESENT)
+ desc_table = rxvq->desc;
+ map_guest_hint_p = &map_guest_hint_desc;
+ desc_head = desc_index =
+ rxvq->avail->ring[rxvq->last_avail_idx & qsz_mask];
+ if (rxvq->desc[desc_head].flags & VIRTQ_DESC_F_INDIRECT)
+ {
+ if (PREDICT_FALSE
+ (rxvq->desc[desc_head].len < sizeof (vring_desc_t)))
{
- current_b0 = vlib_get_buffer (vm, current_b0->next_buffer);
- bytes_left = current_b0->current_length;
+ error = VHOST_USER_TX_FUNC_ERROR_INDIRECT_OVERFLOW;
+ goto done;
}
- else
+ if (PREDICT_FALSE
+ (!(desc_table =
+ map_guest_mem (vui, rxvq->desc[desc_index].addr,
+ &map_guest_hint_desc))))
{
- //End of packet
- break;
+ error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
+ goto done;
}
+ desc_index = 0;
+ map_guest_hint_p = &map_guest_hint_indirect;
}
- if (buffer_len == 0)
- { //Get new output
- if (desc_table[desc_index].flags & VIRTQ_DESC_F_NEXT)
- {
- //Next one is chained
- desc_index = desc_table[desc_index].next;
- if (PREDICT_FALSE
- (!(buffer_addr =
- map_guest_mem (vui, desc_table[desc_index].addr,
- map_guest_hint_p))))
+ desc_len = vui->virtio_net_hdr_sz;
+
+ if (PREDICT_FALSE
+ (!(buffer_addr =
+ map_guest_mem (vui, desc_table[desc_index].addr,
+ map_guest_hint_p))))
+ {
+ error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
+ goto done;
+ }
+ buffer_len = desc_table[desc_index].len;
+
+ CLIB_PREFETCH (buffer_addr, CLIB_CACHE_LINE_BYTES, STORE);
+
+ virtio_net_hdr_mrg_rxbuf_t *hdr =
+ (virtio_net_hdr_mrg_rxbuf_t *) buffer_addr;
+ hdr->hdr.flags = 0;
+ hdr->hdr.gso_type = 0;
+ if (vui->virtio_net_hdr_sz == 12)
+ hdr->num_buffers = 1;
+
+ vhost_user_log_dirty_pages (vui, desc_table[desc_index].addr,
+ vui->virtio_net_hdr_sz);
+
+ u16 bytes_left = b0->current_length;
+ buffer_addr += vui->virtio_net_hdr_sz;
+ buffer_len -= vui->virtio_net_hdr_sz;
+ current_b0 = b0;
+ while (1)
+ {
+ if (!bytes_left)
+ { //Get new input
+ if (current_b0->flags & VLIB_BUFFER_NEXT_PRESENT)
{
- rxvq->last_used_idx -= hdr->num_buffers - 1;
- rxvq->last_avail_idx -= hdr->num_buffers - 1;
- error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
- goto done;
+ current_b0 =
+ vlib_get_buffer (vm, current_b0->next_buffer);
+ bytes_left = current_b0->current_length;
}
- buffer_len = desc_table[desc_index].len;
- }
- else if (vui->virtio_net_hdr_sz == 12) //MRG is available
- {
- //Move from available to used buffer
- rxvq->used->ring[rxvq->last_used_idx & qsz_mask].id =
- desc_head;
- rxvq->used->ring[rxvq->last_used_idx & qsz_mask].len =
- desc_len;
- vhost_user_log_dirty_ring (vui, rxvq,
- ring[rxvq->last_used_idx &
- qsz_mask]);
- rxvq->last_avail_idx++;
- rxvq->last_used_idx++;
- hdr->num_buffers++;
-
- if (PREDICT_FALSE
- (rxvq->last_avail_idx == rxvq->avail->idx))
+ else
{
- //Dequeue queued descriptors for this packet
- rxvq->last_used_idx -= hdr->num_buffers - 1;
- rxvq->last_avail_idx -= hdr->num_buffers - 1;
- error = VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOBUF;
- goto done;
+ //End of packet
+ break;
}
+ }
- desc_table = rxvq->desc;
- map_guest_hint_p = &map_guest_hint_desc;
- desc_head = desc_index =
- rxvq->avail->ring[rxvq->last_avail_idx & qsz_mask];
- if (PREDICT_FALSE
- (rxvq->desc[desc_head].flags & VIRTQ_DESC_F_INDIRECT))
+ if (buffer_len == 0)
+ { //Get new output
+ if (desc_table[desc_index].flags & VIRTQ_DESC_F_NEXT)
+ {
+ //Next one is chained
+ desc_index = desc_table[desc_index].next;
+ if (PREDICT_FALSE
+ (!(buffer_addr =
+ map_guest_mem (vui, desc_table[desc_index].addr,
+ map_guest_hint_p))))
+ {
+ rxvq->last_used_idx -= hdr->num_buffers - 1;
+ rxvq->last_avail_idx -= hdr->num_buffers - 1;
+ error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
+ goto done;
+ }
+ buffer_len = desc_table[desc_index].len;
+ }
+ else if (vui->virtio_net_hdr_sz == 12) //MRG is available
{
- //It is seriously unlikely that a driver will put indirect descriptor
- //after non-indirect descriptor.
+ //Move from available to used buffer
+ rxvq->used->ring[rxvq->last_used_idx & qsz_mask].id =
+ desc_head;
+ rxvq->used->ring[rxvq->last_used_idx & qsz_mask].len =
+ desc_len;
+ vhost_user_log_dirty_ring (vui, rxvq,
+ ring[rxvq->last_used_idx &
+ qsz_mask]);
+ rxvq->last_avail_idx++;
+ rxvq->last_used_idx++;
+ hdr->num_buffers++;
+
if (PREDICT_FALSE
- (rxvq->desc[desc_head].len < sizeof (vring_desc_t)))
+ (rxvq->last_avail_idx == rxvq->avail->idx))
{
- error = VHOST_USER_TX_FUNC_ERROR_INDIRECT_OVERFLOW;
+ //Dequeue queued descriptors for this packet
+ rxvq->last_used_idx -= hdr->num_buffers - 1;
+ rxvq->last_avail_idx -= hdr->num_buffers - 1;
+ error = VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOBUF;
goto done;
}
+
+ desc_table = rxvq->desc;
+ map_guest_hint_p = &map_guest_hint_desc;
+ desc_head = desc_index =
+ rxvq->avail->ring[rxvq->last_avail_idx & qsz_mask];
if (PREDICT_FALSE
- (!(desc_table =
- map_guest_mem (vui,
- rxvq->desc[desc_index].addr,
- &map_guest_hint_desc))))
+ (rxvq->
+ desc[desc_head].flags & VIRTQ_DESC_F_INDIRECT))
+ {
+ //It is seriously unlikely that a driver will put indirect descriptor
+ //after non-indirect descriptor.
+ if (PREDICT_FALSE
+ (rxvq->desc[desc_head].len <
+ sizeof (vring_desc_t)))
+ {
+ error =
+ VHOST_USER_TX_FUNC_ERROR_INDIRECT_OVERFLOW;
+ goto done;
+ }
+ if (PREDICT_FALSE
+ (!(desc_table =
+ map_guest_mem (vui,
+ rxvq->desc[desc_index].addr,
+ &map_guest_hint_desc))))
+ {
+ error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
+ goto done;
+ }
+ desc_index = 0;
+ map_guest_hint_p = &map_guest_hint_indirect;
+ }
+
+ if (PREDICT_FALSE
+ (!(buffer_addr =
+ map_guest_mem (vui, desc_table[desc_index].addr,
+ map_guest_hint_p))))
{
error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
goto done;
}
- desc_index = 0;
- map_guest_hint_p = &map_guest_hint_indirect;
+ buffer_len = desc_table[desc_index].len;
+ CLIB_PREFETCH (buffer_addr, CLIB_CACHE_LINE_BYTES,
+ STORE);
}
-
- if (PREDICT_FALSE
- (!(buffer_addr =
- map_guest_mem (vui, desc_table[desc_index].addr,
- map_guest_hint_p))))
+ else
{
- error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
+ error = VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOMRG;
goto done;
}
- buffer_len = desc_table[desc_index].len;
- CLIB_PREFETCH (buffer_addr, CLIB_CACHE_LINE_BYTES, STORE);
- }
- else
- {
- error = VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOMRG;
- goto done;
}
+
+ u16 bytes_to_copy = bytes_left;
+ bytes_to_copy =
+ (bytes_to_copy > buffer_len) ? buffer_len : bytes_to_copy;
+ clib_memcpy (buffer_addr,
+ vlib_buffer_get_current (current_b0) +
+ current_b0->current_length - bytes_left,
+ bytes_to_copy);
+
+ vhost_user_log_dirty_pages (vui,
+ desc_table[desc_index].addr +
+ desc_table[desc_index].len -
+ bytes_left - bytes_to_copy,
+ bytes_to_copy);
+
+ CLIB_PREFETCH (rxvq, sizeof (*rxvq), STORE);
+ bytes_left -= bytes_to_copy;
+ buffer_len -= bytes_to_copy;
+ buffer_addr += bytes_to_copy;
+ desc_len += bytes_to_copy;
}
- u16 bytes_to_copy = bytes_left;
- bytes_to_copy =
- (bytes_to_copy > buffer_len) ? buffer_len : bytes_to_copy;
- clib_memcpy (buffer_addr,
- vlib_buffer_get_current (current_b0) +
- current_b0->current_length - bytes_left,
- bytes_to_copy);
-
- vhost_user_log_dirty_pages (vui,
- desc_table[desc_index].addr +
- desc_table[desc_index].len -
- bytes_left - bytes_to_copy,
- bytes_to_copy);
-
- CLIB_PREFETCH (rxvq, sizeof (*rxvq), STORE);
- bytes_left -= bytes_to_copy;
- buffer_len -= bytes_to_copy;
- buffer_addr += bytes_to_copy;
- desc_len += bytes_to_copy;
- }
+ //Move from available to used ring
+ rxvq->used->ring[rxvq->last_used_idx & qsz_mask].id = desc_head;
+ rxvq->used->ring[rxvq->last_used_idx & qsz_mask].len = desc_len;
+ vhost_user_log_dirty_ring (vui, rxvq,
+ ring[rxvq->last_used_idx & qsz_mask]);
- //Move from available to used ring
- rxvq->used->ring[rxvq->last_used_idx & qsz_mask].id = desc_head;
- rxvq->used->ring[rxvq->last_used_idx & qsz_mask].len = desc_len;
- vhost_user_log_dirty_ring (vui, rxvq,
- ring[rxvq->last_used_idx & qsz_mask]);
+ rxvq->last_avail_idx++;
+ rxvq->last_used_idx++;
- rxvq->last_avail_idx++;
- rxvq->last_used_idx++;
+ if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
+ current_trace->hdr = *hdr;
- if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
- current_trace->hdr = *hdr;
+ buffers++;
+ n_left--; //At the end for error counting when 'goto done' is invoked
+ }
- n_left--; //At the end for error counting when 'goto done' is invoked
+ done:
+ CLIB_MEMORY_BARRIER ();
+ rxvq->used->idx = rxvq->last_used_idx;
+ vhost_user_log_dirty_ring (vui, rxvq, idx);
}
-done:
- CLIB_MEMORY_BARRIER ();
- rxvq->used->idx = rxvq->last_used_idx;
- vhost_user_log_dirty_ring (vui, rxvq, idx);
-
/* interrupt (call) handling */
- if ((rxvq->callfd > -1) && !(rxvq->avail->flags & 1))
+ if ((rxvq->callfd_idx != ~0) && !(rxvq->avail->flags & 1))
{
rxvq->n_since_last_int += n_packets - n_left;
uword is_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0;
vhost_user_main_t *vum = &vhost_user_main;
vhost_user_intf_t *vui =
- vec_elt_at_index (vum->vhost_user_interfaces, hif->dev_instance);
+ pool_elt_at_index (vum->vhost_user_interfaces, hif->dev_instance);
vui->admin_up = is_up;
/* *INDENT-OFF* */
VNET_DEVICE_CLASS (vhost_user_dev_class,static) = {
.name = "vhost-user",
- .tx_function = vhost_user_intfc_tx,
+ .tx_function = vhost_user_tx,
.tx_function_n_errors = VHOST_USER_TX_FUNC_N_ERROR,
.tx_function_error_strings = vhost_user_tx_func_error_strings,
.format_device_name = format_vhost_user_interface_name,
.name_renumber = vhost_user_name_renumber,
.admin_up_down_function = vhost_user_interface_admin_up_down,
- .no_flatten_output_chains = 1,
.format_tx_trace = format_vhost_trace,
};
VLIB_DEVICE_TX_FUNCTION_MULTIARCH (vhost_user_dev_class,
- vhost_user_intfc_tx)
+ vhost_user_tx)
/* *INDENT-ON* */
static uword
template.read_function = vhost_user_socket_read;
template.error_function = vhost_user_socket_error;
-
if (sockfd < 0)
return 0;
timeout = 3.0;
- vec_foreach (vui, vum->vhost_user_interfaces)
- {
+ /* *INDENT-OFF* */
+ pool_foreach (vui, vum->vhost_user_interfaces, {
- if (vui->sock_is_server || !vui->active)
- continue;
+ if (vui->unix_server_index == ~0) { //Nothing to do for server sockets
+ if (vui->unix_file_index == ~0)
+ {
+ /* try to connect */
+ strncpy (sun.sun_path, (char *) vui->sock_filename,
+ sizeof (sun.sun_path) - 1);
- if (vui->unix_fd == -1)
- {
- /* try to connect */
-
- strncpy (sun.sun_path, (char *) vui->sock_filename,
- sizeof (sun.sun_path) - 1);
-
- if (connect
- (sockfd, (struct sockaddr *) &sun,
- sizeof (struct sockaddr_un)) == 0)
- {
- vui->sock_errno = 0;
- vui->unix_fd = sockfd;
- template.file_descriptor = sockfd;
- vui->unix_file_index = unix_file_add (&unix_main, &template);
- hash_set (vum->vhost_user_interface_index_by_sock_fd, sockfd,
- vui - vum->vhost_user_interfaces);
-
- sockfd = socket (AF_UNIX, SOCK_STREAM, 0);
- if (sockfd < 0)
- return 0;
- }
- else
- {
- vui->sock_errno = errno;
- }
- }
- else
- {
- /* check if socket is alive */
- int error = 0;
- socklen_t len = sizeof (error);
- int retval =
- getsockopt (vui->unix_fd, SOL_SOCKET, SO_ERROR, &error, &len);
-
- if (retval)
- {
- DBG_SOCK ("getsockopt returned %d", retval);
- vhost_user_if_disconnect (vui);
- }
+ if (connect (sockfd, (struct sockaddr *) &sun,
+ sizeof (struct sockaddr_un)) == 0)
+ {
+ vui->sock_errno = 0;
+ template.file_descriptor = sockfd;
+ template.private_data =
+ vui - vhost_user_main.vhost_user_interfaces;
+ vui->unix_file_index = unix_file_add (&unix_main, &template);
+
+ //Re-open for next connect
+ if ((sockfd = socket (AF_UNIX, SOCK_STREAM, 0)) < 0) {
+ clib_warning("Critical: Could not open unix socket");
+ return 0;
+ }
+ }
+ else
+ {
+ vui->sock_errno = errno;
+ }
+ }
+ else
+ {
+ /* check if socket is alive */
+ int error = 0;
+ socklen_t len = sizeof (error);
+ int fd = UNIX_GET_FD(vui->unix_file_index);
+ int retval =
+ getsockopt (fd, SOL_SOCKET, SO_ERROR, &error, &len);
+
+ if (retval)
+ {
+ DBG_SOCK ("getsockopt returned %d", retval);
+ vhost_user_if_disconnect (vui);
+ }
+ }
}
- }
+ });
+ /* *INDENT-ON* */
}
return 0;
}
};
/* *INDENT-ON* */
+/**
+ * Disables and reset interface structure.
+ * It can then be either init again, or removed from used interfaces.
+ */
+static void
+vhost_user_term_if (vhost_user_intf_t * vui)
+{
+ // Delete configured thread pinning
+ vec_reset_length (vui->workers);
+ // disconnect interface sockets
+ vhost_user_if_disconnect (vui);
+ vhost_user_update_iface_state (vui);
+
+ if (vui->unix_server_index != ~0)
+ {
+ //Close server socket
+ unix_file_t *uf = pool_elt_at_index (unix_main.file_pool,
+ vui->unix_server_index);
+ unix_file_del (&unix_main, uf);
+ vui->unix_server_index = ~0;
+ }
+}
+
int
vhost_user_delete_if (vnet_main_t * vnm, vlib_main_t * vm, u32 sw_if_index)
{
vhost_user_main_t *vum = &vhost_user_main;
vhost_user_intf_t *vui;
- uword *p = NULL;
int rv = 0;
+ vnet_hw_interface_t *hwif;
- p = hash_get (vum->vhost_user_interface_index_by_sw_if_index, sw_if_index);
- if (p == 0)
- {
- return VNET_API_ERROR_INVALID_SW_IF_INDEX;
- }
- else
- {
- vui = vec_elt_at_index (vum->vhost_user_interfaces, p[0]);
- }
+ if (!(hwif = vnet_get_sup_hw_interface (vnm, sw_if_index)) ||
+ hwif->dev_class_index != vhost_user_dev_class.index)
+ return VNET_API_ERROR_INVALID_SW_IF_INDEX;
- // interface is inactive
- vui->active = 0;
- // disconnect interface sockets
- vhost_user_if_disconnect (vui);
- // add to inactive interface list
- vec_add1 (vum->vhost_user_inactive_interfaces_index, p[0]);
+ DBG_SOCK ("Deleting vhost-user interface %s (instance %d)",
+ hwif->name, hwif->dev_instance);
- // reset renumbered iface
- if (p[0] < vec_len (vum->show_dev_instance_by_real_dev_instance))
- vum->show_dev_instance_by_real_dev_instance[p[0]] = ~0;
+ vui = pool_elt_at_index (vum->vhost_user_interfaces, hwif->dev_instance);
- ethernet_delete_interface (vnm, vui->hw_if_index);
- DBG_SOCK ("deleted (deactivated) vhost-user interface instance %d", p[0]);
+ // Disable and reset interface
+ vhost_user_term_if (vui);
+
+ // Back to pool
+ pool_put (vum->vhost_user_interfaces, vui);
+
+ // Reset renumbered iface
+ if (hwif->dev_instance <
+ vec_len (vum->show_dev_instance_by_real_dev_instance))
+ vum->show_dev_instance_by_real_dev_instance[hwif->dev_instance] = ~0;
+ // Delete ethernet interface
+ ethernet_delete_interface (vnm, vui->hw_if_index);
return rv;
}
-// init server socket on specified sock_filename
+/**
+ * Open server unix socket on specified sock_filename.
+ */
static int
-vhost_user_init_server_sock (const char *sock_filename, int *sockfd)
+vhost_user_init_server_sock (const char *sock_filename, int *sock_fd)
{
int rv = 0;
struct sockaddr_un un = { };
int fd;
/* create listening socket */
- fd = socket (AF_UNIX, SOCK_STREAM, 0);
-
- if (fd < 0)
- {
- return VNET_API_ERROR_SYSCALL_ERROR_1;
- }
+ if ((fd = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
+ return VNET_API_ERROR_SYSCALL_ERROR_1;
un.sun_family = AF_UNIX;
strncpy ((char *) un.sun_path, (char *) sock_filename,
goto error;
}
- unix_file_t template = { 0 };
- template.read_function = vhost_user_socksvr_accept_ready;
- template.file_descriptor = fd;
- unix_file_add (&unix_main, &template);
- *sockfd = fd;
- return rv;
+ *sock_fd = fd;
+ return 0;
error:
close (fd);
return rv;
}
-// get new vhost_user_intf_t from inactive interfaces or create new one
-static vhost_user_intf_t *
-vhost_user_vui_new ()
-{
- vhost_user_main_t *vum = &vhost_user_main;
- vhost_user_intf_t *vui = NULL;
- int inactive_cnt = vec_len (vum->vhost_user_inactive_interfaces_index);
- // if there are any inactive ifaces
- if (inactive_cnt > 0)
- {
- // take last
- u32 vui_idx =
- vum->vhost_user_inactive_interfaces_index[inactive_cnt - 1];
- if (vec_len (vum->vhost_user_interfaces) > vui_idx)
- {
- vui = vec_elt_at_index (vum->vhost_user_interfaces, vui_idx);
- DBG_SOCK ("reusing inactive vhost-user interface index %d",
- vui_idx);
- }
- // "remove" from inactive list
- _vec_len (vum->vhost_user_inactive_interfaces_index) -= 1;
- }
-
- // vui was not retrieved from inactive ifaces - create new
- if (!vui)
- vec_add2 (vum->vhost_user_interfaces, vui, 1);
-
- return vui;
-}
-
-// create ethernet interface for vhost user intf
+/**
+ * Create ethernet interface for vhost user interface.
+ */
static void
vhost_user_create_ethernet (vnet_main_t * vnm, vlib_main_t * vm,
vhost_user_intf_t * vui, u8 * hwaddress)
}
else
{
- f64 now = vlib_time_now (vm);
- u32 rnd;
- rnd = (u32) (now * 1e6);
- rnd = random_u32 (&rnd);
-
- clib_memcpy (hwaddr + 2, &rnd, sizeof (rnd));
+ random_u32 (&vum->random);
+ clib_memcpy (hwaddr + 2, &vum->random, sizeof (vum->random));
hwaddr[0] = 2;
hwaddr[1] = 0xfe;
}
vui - vum->vhost_user_interfaces /* device instance */ ,
hwaddr /* ethernet address */ ,
&vui->hw_if_index, 0 /* flag change */ );
+
if (error)
clib_error_report (error);
hi->max_l3_packet_bytes[VLIB_RX] = hi->max_l3_packet_bytes[VLIB_TX] = 9000;
}
-// initialize vui with specified attributes
+/*
+ * Initialize vui with specified attributes
+ */
static void
vhost_user_vui_init (vnet_main_t * vnm,
- vhost_user_intf_t * vui, int sockfd,
+ vhost_user_intf_t * vui,
+ int server_sock_fd,
const char *sock_filename,
- u8 is_server, u64 feature_mask, u32 * sw_if_index)
+ u64 feature_mask, u32 * sw_if_index)
{
vnet_sw_interface_t *sw;
sw = vnet_get_hw_sw_interface (vnm, vui->hw_if_index);
int q;
- vui->unix_fd = sockfd;
+ if (server_sock_fd != -1)
+ {
+ unix_file_t template = { 0 };
+ template.read_function = vhost_user_socksvr_accept_ready;
+ template.file_descriptor = server_sock_fd;
+ template.private_data = vui - vhost_user_main.vhost_user_interfaces; //hw index
+ vui->unix_server_index = unix_file_add (&unix_main, &template);
+ }
+ else
+ {
+ vui->unix_server_index = ~0;
+ }
+
vui->sw_if_index = sw->sw_if_index;
- vui->sock_is_server = is_server;
strncpy (vui->sock_filename, sock_filename,
ARRAY_LEN (vui->sock_filename) - 1);
vui->sock_errno = 0;
vui->is_up = 0;
vui->feature_mask = feature_mask;
- vui->active = 1;
vui->unix_file_index = ~0;
vui->log_base_addr = 0;
vhost_user_tx_thread_placement (vui);
}
-// register vui and start polling on it
-static void
-vhost_user_vui_register (vlib_main_t * vm, vhost_user_intf_t * vui)
-{
- vhost_user_main_t *vum = &vhost_user_main;
- int cpu_index;
- vlib_thread_main_t *tm = vlib_get_thread_main ();
-
- hash_set (vum->vhost_user_interface_index_by_listener_fd, vui->unix_fd,
- vui - vum->vhost_user_interfaces);
- hash_set (vum->vhost_user_interface_index_by_sw_if_index, vui->sw_if_index,
- vui - vum->vhost_user_interfaces);
-
- /* start polling */
- cpu_index = vum->input_cpu_first_index +
- (vui - vum->vhost_user_interfaces) % vum->input_cpu_count;
-
- if (tm->n_vlib_mains == 1)
- vlib_node_set_state (vm, vhost_user_input_node.index,
- VLIB_NODE_STATE_POLLING);
- else
- vlib_node_set_state (vlib_mains[cpu_index], vhost_user_input_node.index,
- VLIB_NODE_STATE_POLLING);
-
- /* tell process to start polling for sockets */
- vlib_process_signal_event (vm, vhost_user_process_node.index, 0, 0);
-}
-
int
vhost_user_create_if (vnet_main_t * vnm, vlib_main_t * vm,
const char *sock_filename,
{
vhost_user_intf_t *vui = NULL;
u32 sw_if_idx = ~0;
- int sockfd = -1;
int rv = 0;
+ int server_sock_fd = -1;
if (is_server)
{
- if ((rv = vhost_user_init_server_sock (sock_filename, &sockfd)) != 0)
+ if ((rv =
+ vhost_user_init_server_sock (sock_filename, &server_sock_fd)) != 0)
{
return rv;
}
}
- vui = vhost_user_vui_new ();
- ASSERT (vui != NULL);
+ pool_get (vhost_user_main.vhost_user_interfaces, vui);
vhost_user_create_ethernet (vnm, vm, vui, hwaddr);
- vhost_user_vui_init (vnm, vui, sockfd, sock_filename, is_server,
+ vhost_user_vui_init (vnm, vui, server_sock_fd, sock_filename,
feature_mask, &sw_if_idx);
if (renumber)
- {
- vnet_interface_name_renumber (sw_if_idx, custom_dev_instance);
- }
-
- vhost_user_vui_register (vm, vui);
+ vnet_interface_name_renumber (sw_if_idx, custom_dev_instance);
if (sw_if_index)
*sw_if_index = sw_if_idx;
+ // Process node must connect
+ vlib_process_signal_event (vm, vhost_user_process_node.index, 0, 0);
return rv;
}
vhost_user_main_t *vum = &vhost_user_main;
vhost_user_intf_t *vui = NULL;
u32 sw_if_idx = ~0;
- int sockfd = -1;
+ int server_sock_fd = -1;
int rv = 0;
- uword *p = NULL;
+ vnet_hw_interface_t *hwif;
- p = hash_get (vum->vhost_user_interface_index_by_sw_if_index, sw_if_index);
- if (p == 0)
- {
- return VNET_API_ERROR_INVALID_SW_IF_INDEX;
- }
- else
- {
- vui = vec_elt_at_index (vum->vhost_user_interfaces, p[0]);
- }
+ if (!(hwif = vnet_get_sup_hw_interface (vnm, sw_if_index)) ||
+ hwif->dev_class_index != vhost_user_dev_class.index)
+ return VNET_API_ERROR_INVALID_SW_IF_INDEX;
- // interface is inactive
- vui->active = 0;
- // disconnect interface sockets
- vhost_user_if_disconnect (vui);
+ vui = vec_elt_at_index (vum->vhost_user_interfaces, hwif->dev_instance);
+ // First try to open server socket
if (is_server)
- {
- if ((rv = vhost_user_init_server_sock (sock_filename, &sockfd)) != 0)
- {
- return rv;
- }
- }
+ if ((rv = vhost_user_init_server_sock (sock_filename,
+ &server_sock_fd)) != 0)
+ return rv;
- vhost_user_vui_init (vnm, vui, sockfd, sock_filename, is_server,
- feature_mask, &sw_if_idx);
+ vhost_user_term_if (vui);
+ vhost_user_vui_init (vnm, vui, server_sock_fd,
+ sock_filename, feature_mask, &sw_if_idx);
if (renumber)
- {
- vnet_interface_name_renumber (sw_if_idx, custom_dev_instance);
- }
-
- vhost_user_vui_register (vm, vui);
+ vnet_interface_name_renumber (sw_if_idx, custom_dev_instance);
+ // Process node must connect
+ vlib_process_signal_event (vm, vhost_user_process_node.index, 0, 0);
return rv;
}
{
unformat_input_t _line_input, *line_input = &_line_input;
u32 sw_if_index = ~0;
+ vnet_main_t *vnm = vnet_get_main ();
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
{
if (unformat (line_input, "sw_if_index %d", &sw_if_index))
;
+ else if (unformat
+ (line_input, "%U", unformat_vnet_sw_interface, vnm,
+ &sw_if_index))
+ {
+ vnet_hw_interface_t *hwif =
+ vnet_get_sup_hw_interface (vnm, sw_if_index);
+ if (hwif == NULL ||
+ vhost_user_dev_class.index != hwif->dev_class_index)
+ return clib_error_return (0, "Not a vhost interface");
+ }
else
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
}
unformat_free (line_input);
-
- vnet_main_t *vnm = vnet_get_main ();
-
vhost_user_delete_if (vnm, vm, sw_if_index);
-
return 0;
}
if (!out_vuids)
return -1;
- vec_foreach (vui, vum->vhost_user_interfaces)
- {
- if (vui->active)
- vec_add1 (hw_if_indices, vui->hw_if_index);
- }
+ pool_foreach (vui, vum->vhost_user_interfaces,
+ vec_add1 (hw_if_indices, vui->hw_if_index);
+ );
for (i = 0; i < vec_len (hw_if_indices); i++)
{
hi = vnet_get_hw_interface (vnm, hw_if_indices[i]);
- vui = vec_elt_at_index (vum->vhost_user_interfaces, hi->dev_instance);
+ vui = pool_elt_at_index (vum->vhost_user_interfaces, hi->dev_instance);
vec_add2 (r_vuids, vuid, 1);
vuid->sw_if_index = vui->sw_if_index;
vuid->virtio_net_hdr_sz = vui->virtio_net_hdr_sz;
vuid->features = vui->features;
- vuid->is_server = vui->sock_is_server;
vuid->num_regions = vui->nregions;
vuid->sock_errno = vui->sock_errno;
strncpy ((char *) vuid->sock_filename, (char *) vui->sock_filename,
}
if (vec_len (hw_if_indices) == 0)
{
- vec_foreach (vui, vum->vhost_user_interfaces)
- {
- if (vui->active)
- vec_add1 (hw_if_indices, vui->hw_if_index);
- }
+ pool_foreach (vui, vum->vhost_user_interfaces,
+ vec_add1 (hw_if_indices, vui->hw_if_index);
+ );
}
vlib_cli_output (vm, "Virtio vhost-user interfaces");
vlib_cli_output (vm, "Global:\n coalesce frames %d time %e",
for (i = 0; i < vec_len (hw_if_indices); i++)
{
hi = vnet_get_hw_interface (vnm, hw_if_indices[i]);
- vui = vec_elt_at_index (vum->vhost_user_interfaces, hi->dev_instance);
+ vui = pool_elt_at_index (vum->vhost_user_interfaces, hi->dev_instance);
vlib_cli_output (vm, "Interface: %s (ifindex %d)",
hi->name, hw_if_indices[i]);
vlib_cli_output (vm, " socket filename %s type %s errno \"%s\"\n\n",
vui->sock_filename,
- vui->sock_is_server ? "server" : "client",
+ (vui->unix_server_index != ~0) ? "server" : "client",
strerror (vui->sock_errno));
vlib_cli_output (vm, " rx placement: ");
vui->vrings[q].used->flags,
vui->vrings[q].used->idx);
+ int kickfd = UNIX_GET_FD (vui->vrings[q].kickfd_idx);
+ int callfd = UNIX_GET_FD (vui->vrings[q].callfd_idx);
vlib_cli_output (vm, " kickfd %d callfd %d errfd %d\n",
- vui->vrings[q].kickfd,
- vui->vrings[q].callfd, vui->vrings[q].errfd);
+ kickfd, callfd, vui->vrings[q].errfd);
if (show_descr)
{
* CLI functions
*/
+/*?
+ * Create a vHost User interface. Once created, a new virtual interface
+ * will exist with the name '<em>VirtualEthernet0/0/x</em>', where '<em>x</em>'
+ * is the next free index.
+ *
+ * There are several parameters associated with a vHost interface:
+ *
+ * - <b>socket <socket-filename></b> - Name of the linux socket used by QEMU/VM and
+ * VPP to manage the vHost interface. If socket does not already exist, VPP will
+ * create the socket.
+ *
+ * - <b>server</b> - Optional flag to indicate that VPP should be the server for the
+ * linux socket. If not provided, VPP will be the client.
+ *
+ * - <b>feature-mask <hex></b> - Optional virtio/vhost feature set negotiated at
+ * startup. By default, all supported features will be advertised. Otherwise,
+ * provide the set of features desired.
+ * - 0x000008000 (15) - VIRTIO_NET_F_MRG_RXBUF
+ * - 0x000020000 (17) - VIRTIO_NET_F_CTRL_VQ
+ * - 0x000200000 (21) - VIRTIO_NET_F_GUEST_ANNOUNCE
+ * - 0x000400000 (22) - VIRTIO_NET_F_MQ
+ * - 0x004000000 (26) - VHOST_F_LOG_ALL
+ * - 0x008000000 (27) - VIRTIO_F_ANY_LAYOUT
+ * - 0x010000000 (28) - VIRTIO_F_INDIRECT_DESC
+ * - 0x040000000 (30) - VHOST_USER_F_PROTOCOL_FEATURES
+ * - 0x100000000 (32) - VIRTIO_F_VERSION_1
+ *
+ * - <b>hwaddr <mac-addr></b> - Optional ethernet address, can be in either
+ * X:X:X:X:X:X unix or X.X.X cisco format.
+ *
+ * - <b>renumber <dev_instance></b> - Optional parameter which allows the instance
+ * in the name to be specified. If instance already exists, name will be used
+ * anyway and multiple instances will have the same name. Use with caution.
+ *
+ * @cliexpar
+ * Example of how to create a vhost interface with VPP as the client and all features enabled:
+ * @cliexstart{create vhost-user socket /tmp/vhost1.sock}
+ * VirtualEthernet0/0/0
+ * @cliexend
+ * Example of how to create a vhost interface with VPP as the server and with just
+ * multiple queues enabled:
+ * @cliexstart{create vhost-user socket /tmp/vhost2.sock server feature-mask 0x40400000}
+ * VirtualEthernet0/0/1
+ * @cliexend
+ * Once the vHost interface is created, enable the interface using:
+ * @cliexcmd{set interface state VirtualEthernet0/0/0 up}
+?*/
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (vhost_user_connect_command, static) = {
.path = "create vhost-user",
- .short_help = "create vhost-user socket <socket-filename> [server] [feature-mask <hex>] [renumber <dev_instance>]",
+ .short_help = "create vhost-user socket <socket-filename> [server] [feature-mask <hex>] [hwaddr <mac-addr>] [renumber <dev_instance>]",
.function = vhost_user_connect_command_fn,
};
+/* *INDENT-ON* */
+/*?
+ * Delete a vHost User interface using the interface name or the
+ * software interface index. Use the '<em>show interfaces</em>'
+ * command to determine the software interface index. On deletion,
+ * the linux socket will not be deleted.
+ *
+ * @cliexpar
+ * Example of how to delete a vhost interface by name:
+ * @cliexcmd{delete vhost-user VirtualEthernet0/0/1}
+ * Example of how to delete a vhost interface by software interface index:
+ * @cliexcmd{delete vhost-user sw_if_index 1}
+?*/
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (vhost_user_delete_command, static) = {
.path = "delete vhost-user",
- .short_help = "delete vhost-user sw_if_index <nn>",
+ .short_help = "delete vhost-user {<interface> | sw_if_index <sw_idx>}",
.function = vhost_user_delete_command_fn,
};
+/*?
+ * Display the attributes of a single vHost User interface (provide interface
+ * name), multiple vHost User interfaces (provide a list of interface names seperated
+ * by spaces) or all Vhost User interfaces (omit an interface name to display all
+ * vHost interfaces).
+ *
+ * @cliexpar
+ * @parblock
+ * Example of how to display a vhost interface:
+ * @cliexstart{show vhost-user VirtualEthernet0/0/0}
+ * Virtio vhost-user interfaces
+ * Global:
+ * coalesce frames 32 time 1e-3
+ * Interface: VirtualEthernet0/0/0 (ifindex 1)
+ * virtio_net_hdr_sz 12
+ * features mask (0xffffffffffffffff):
+ * features (0x50408000):
+ * VIRTIO_NET_F_MRG_RXBUF (15)
+ * VIRTIO_NET_F_MQ (22)
+ * VIRTIO_F_INDIRECT_DESC (28)
+ * VHOST_USER_F_PROTOCOL_FEATURES (30)
+ * protocol features (0x3)
+ * VHOST_USER_PROTOCOL_F_MQ (0)
+ * VHOST_USER_PROTOCOL_F_LOG_SHMFD (1)
+ *
+ * socket filename /tmp/vhost1.sock type client errno "Success"
+ *
+ * rx placement:
+ * thread 1 on vring 1
+ * thread 1 on vring 5
+ * thread 2 on vring 3
+ * thread 2 on vring 7
+ * tx placement: spin-lock
+ * thread 0 on vring 0
+ * thread 1 on vring 2
+ * thread 2 on vring 0
+ *
+ * Memory regions (total 2)
+ * region fd guest_phys_addr memory_size userspace_addr mmap_offset mmap_addr
+ * ====== ===== ================== ================== ================== ================== ==================
+ * 0 60 0x0000000000000000 0x00000000000a0000 0x00002aaaaac00000 0x0000000000000000 0x00002aab2b400000
+ * 1 61 0x00000000000c0000 0x000000003ff40000 0x00002aaaaacc0000 0x00000000000c0000 0x00002aababcc0000
+ *
+ * Virtqueue 0 (TX)
+ * qsz 256 last_avail_idx 0 last_used_idx 0
+ * avail.flags 1 avail.idx 128 used.flags 1 used.idx 0
+ * kickfd 62 callfd 64 errfd -1
+ *
+ * Virtqueue 1 (RX)
+ * qsz 256 last_avail_idx 0 last_used_idx 0
+ * avail.flags 1 avail.idx 0 used.flags 1 used.idx 0
+ * kickfd 65 callfd 66 errfd -1
+ *
+ * Virtqueue 2 (TX)
+ * qsz 256 last_avail_idx 0 last_used_idx 0
+ * avail.flags 1 avail.idx 128 used.flags 1 used.idx 0
+ * kickfd 63 callfd 70 errfd -1
+ *
+ * Virtqueue 3 (RX)
+ * qsz 256 last_avail_idx 0 last_used_idx 0
+ * avail.flags 1 avail.idx 0 used.flags 1 used.idx 0
+ * kickfd 72 callfd 74 errfd -1
+ *
+ * Virtqueue 4 (TX disabled)
+ * qsz 256 last_avail_idx 0 last_used_idx 0
+ * avail.flags 1 avail.idx 0 used.flags 1 used.idx 0
+ * kickfd 76 callfd 78 errfd -1
+ *
+ * Virtqueue 5 (RX disabled)
+ * qsz 256 last_avail_idx 0 last_used_idx 0
+ * avail.flags 1 avail.idx 0 used.flags 1 used.idx 0
+ * kickfd 80 callfd 82 errfd -1
+ *
+ * Virtqueue 6 (TX disabled)
+ * qsz 256 last_avail_idx 0 last_used_idx 0
+ * avail.flags 1 avail.idx 0 used.flags 1 used.idx 0
+ * kickfd 84 callfd 86 errfd -1
+ *
+ * Virtqueue 7 (RX disabled)
+ * qsz 256 last_avail_idx 0 last_used_idx 0
+ * avail.flags 1 avail.idx 0 used.flags 1 used.idx 0
+ * kickfd 88 callfd 90 errfd -1
+ *
+ * @cliexend
+ *
+ * The optional '<em>descriptors</em>' parameter will display the same output as
+ * the previous example but will include the descriptor table for each queue.
+ * The output is truncated below:
+ * @cliexstart{show vhost-user VirtualEthernet0/0/0 descriptors}
+ * Virtio vhost-user interfaces
+ * Global:
+ * coalesce frames 32 time 1e-3
+ * Interface: VirtualEthernet0/0/0 (ifindex 1)
+ * virtio_net_hdr_sz 12
+ * features mask (0xffffffffffffffff):
+ * features (0x50408000):
+ * VIRTIO_NET_F_MRG_RXBUF (15)
+ * VIRTIO_NET_F_MQ (22)
+ * :
+ * Virtqueue 0 (TX)
+ * qsz 256 last_avail_idx 0 last_used_idx 0
+ * avail.flags 1 avail.idx 128 used.flags 1 used.idx 0
+ * kickfd 62 callfd 64 errfd -1
+ *
+ * descriptor table:
+ * id addr len flags next user_addr
+ * ===== ================== ===== ====== ===== ==================
+ * 0 0x0000000010b6e974 2060 0x0002 1 0x00002aabbc76e974
+ * 1 0x0000000010b6e034 2060 0x0002 2 0x00002aabbc76e034
+ * 2 0x0000000010b6d6f4 2060 0x0002 3 0x00002aabbc76d6f4
+ * 3 0x0000000010b6cdb4 2060 0x0002 4 0x00002aabbc76cdb4
+ * 4 0x0000000010b6c474 2060 0x0002 5 0x00002aabbc76c474
+ * 5 0x0000000010b6bb34 2060 0x0002 6 0x00002aabbc76bb34
+ * 6 0x0000000010b6b1f4 2060 0x0002 7 0x00002aabbc76b1f4
+ * 7 0x0000000010b6a8b4 2060 0x0002 8 0x00002aabbc76a8b4
+ * 8 0x0000000010b69f74 2060 0x0002 9 0x00002aabbc769f74
+ * 9 0x0000000010b69634 2060 0x0002 10 0x00002aabbc769634
+ * 10 0x0000000010b68cf4 2060 0x0002 11 0x00002aabbc768cf4
+ * :
+ * 249 0x0000000000000000 0 0x0000 250 0x00002aab2b400000
+ * 250 0x0000000000000000 0 0x0000 251 0x00002aab2b400000
+ * 251 0x0000000000000000 0 0x0000 252 0x00002aab2b400000
+ * 252 0x0000000000000000 0 0x0000 253 0x00002aab2b400000
+ * 253 0x0000000000000000 0 0x0000 254 0x00002aab2b400000
+ * 254 0x0000000000000000 0 0x0000 255 0x00002aab2b400000
+ * 255 0x0000000000000000 0 0x0000 32768 0x00002aab2b400000
+ *
+ * Virtqueue 1 (RX)
+ * qsz 256 last_avail_idx 0 last_used_idx 0
+ * :
+ * @cliexend
+ * @endparblock
+?*/
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (show_vhost_user_command, static) = {
.path = "show vhost-user",
- .short_help = "show vhost-user interface",
+ .short_help = "show vhost-user [<interface> [<interface> [..]]] [descriptors]",
.function = show_vhost_user_command_fn,
};
/* *INDENT-ON* */
if (vum->dont_dump_vhost_user_memory)
{
- vec_foreach (vui, vum->vhost_user_interfaces)
- {
- unmap_all_mem_regions (vui);
- }
+ pool_foreach (vui, vum->vhost_user_interfaces,
+ unmap_all_mem_regions (vui);
+ );
}
}
}
+/*?
+ * This command is used to move the RX processing for the given
+ * interfaces to the provided thread. If the '<em>del</em>' option is used,
+ * the forced thread assignment is removed and the thread assigment is
+ * reassigned automatically. Use '<em>show vhost-user <interface></em>'
+ * to see the thread assignment.
+ *
+ * @cliexpar
+ * Example of how to move the RX processing for a given interface to a given thread:
+ * @cliexcmd{vhost thread VirtualEthernet0/0/0 1}
+ * Example of how to remove the forced thread assignment for a given interface:
+ * @cliexcmd{vhost thread VirtualEthernet0/0/0 1 del}
+?*/
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (vhost_user_thread_command, static) = {
.path = "vhost thread",
Code Review / vpp.git / blobdiff