2 *------------------------------------------------------------------
5 * Copyright (c) 2014-2018 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
21 #include <fcntl.h> /* for open */
22 #include <sys/ioctl.h>
23 #include <sys/socket.h>
26 #include <sys/types.h>
27 #include <sys/uio.h> /* for iovec */
28 #include <netinet/in.h>
31 #include <linux/if_arp.h>
32 #include <linux/if_tun.h>
34 #include <vlib/vlib.h>
35 #include <vlib/unix/unix.h>
37 #include <vnet/ip/ip.h>
39 #include <vnet/ethernet/ethernet.h>
40 #include <vnet/devices/devices.h>
41 #include <vnet/feature/feature.h>
43 #include <vnet/devices/virtio/virtio.h>
44 #include <vnet/devices/virtio/vhost_user.h>
45 #include <vnet/devices/virtio/vhost_user_inline.h>
48 * On the transmit side, we keep processing the buffers from vlib in the while
49 * loop and prepare the copy order to be executed later. However, the static
50 * array which we keep the copy order is limited to VHOST_USER_COPY_ARRAY_N
51 * entries. In order to not corrupt memory, we have to do the copy when the
52 * static array reaches the copy threshold. We subtract 40 in case the code
53 * goes into the inner loop for a maximum of 64k frames which may require
54 * more array entries. We subtract 200 because our default buffer size is
55 * 2048 and the default desc len is likely 1536. While it takes less than 40
56 * vlib buffers for the jumbo frame, it may take twice as much descriptors
57 * for the same jumbo frame. Use 200 for the extra head room.
59 #define VHOST_USER_TX_COPY_THRESHOLD (VHOST_USER_COPY_ARRAY_N - 200)
61 extern vnet_device_class_t vhost_user_device_class;
63 #define foreach_vhost_user_tx_func_error \
65 _(NOT_READY, "vhost vring not ready") \
66 _(DOWN, "vhost interface is down") \
67 _(PKT_DROP_NOBUF, "tx packet drops (no available descriptors)") \
68 _(PKT_DROP_NOMRG, "tx packet drops (cannot merge descriptors)") \
69 _(MMAP_FAIL, "mmap failure") \
70 _(INDIRECT_OVERFLOW, "indirect descriptor table overflow")
74 #define _(f,s) VHOST_USER_TX_FUNC_ERROR_##f,
75 foreach_vhost_user_tx_func_error
77 VHOST_USER_TX_FUNC_N_ERROR,
78 } vhost_user_tx_func_error_t;
80 static __clib_unused char *vhost_user_tx_func_error_strings[] = {
82 foreach_vhost_user_tx_func_error
86 static __clib_unused u8 *
87 format_vhost_user_interface_name (u8 * s, va_list * args)
89 u32 i = va_arg (*args, u32);
90 u32 show_dev_instance = ~0;
91 vhost_user_main_t *vum = &vhost_user_main;
93 if (i < vec_len (vum->show_dev_instance_by_real_dev_instance))
94 show_dev_instance = vum->show_dev_instance_by_real_dev_instance[i];
96 if (show_dev_instance != ~0)
97 i = show_dev_instance;
99 s = format (s, "VirtualEthernet0/0/%d", i);
103 static __clib_unused int
104 vhost_user_name_renumber (vnet_hw_interface_t * hi, u32 new_dev_instance)
106 // FIXME: check if the new dev instance is already used
107 vhost_user_main_t *vum = &vhost_user_main;
108 vhost_user_intf_t *vui = pool_elt_at_index (vum->vhost_user_interfaces,
111 vec_validate_init_empty (vum->show_dev_instance_by_real_dev_instance,
112 hi->dev_instance, ~0);
114 vum->show_dev_instance_by_real_dev_instance[hi->dev_instance] =
117 vu_log_debug (vui, "renumbered vhost-user interface dev_instance %d to %d",
118 hi->dev_instance, new_dev_instance);
124 * @brief Try once to lock the vring
125 * @return 0 on success, non-zero on failure.
127 static_always_inline int
128 vhost_user_vring_try_lock (vhost_user_intf_t * vui, u32 qid)
130 return clib_atomic_test_and_set (vui->vring_locks[qid]);
134 * @brief Spin until the vring is successfully locked
136 static_always_inline void
137 vhost_user_vring_lock (vhost_user_intf_t * vui, u32 qid)
139 while (vhost_user_vring_try_lock (vui, qid))
144 * @brief Unlock the vring lock
146 static_always_inline void
147 vhost_user_vring_unlock (vhost_user_intf_t * vui, u32 qid)
149 clib_atomic_release (vui->vring_locks[qid]);
152 static_always_inline void
153 vhost_user_tx_trace (vhost_trace_t * t,
154 vhost_user_intf_t * vui, u16 qid,
155 vlib_buffer_t * b, vhost_user_vring_t * rxvq)
157 vhost_user_main_t *vum = &vhost_user_main;
158 u32 last_avail_idx = rxvq->last_avail_idx;
159 u32 desc_current = rxvq->avail->ring[last_avail_idx & rxvq->qsz_mask];
160 vring_desc_t *hdr_desc = 0;
163 clib_memset (t, 0, sizeof (*t));
164 t->device_index = vui - vum->vhost_user_interfaces;
167 hdr_desc = &rxvq->desc[desc_current];
168 if (rxvq->desc[desc_current].flags & VIRTQ_DESC_F_INDIRECT)
170 t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_INDIRECT;
171 /* Header is the first here */
172 hdr_desc = map_guest_mem (vui, rxvq->desc[desc_current].addr, &hint);
174 if (rxvq->desc[desc_current].flags & VIRTQ_DESC_F_NEXT)
176 t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_SIMPLE_CHAINED;
178 if (!(rxvq->desc[desc_current].flags & VIRTQ_DESC_F_NEXT) &&
179 !(rxvq->desc[desc_current].flags & VIRTQ_DESC_F_INDIRECT))
181 t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_SINGLE_DESC;
184 t->first_desc_len = hdr_desc ? hdr_desc->len : 0;
187 static_always_inline u32
188 vhost_user_tx_copy (vhost_user_intf_t * vui, vhost_copy_t * cpy,
189 u16 copy_len, u32 * map_hint)
191 void *dst0, *dst1, *dst2, *dst3;
192 if (PREDICT_TRUE (copy_len >= 4))
194 if (PREDICT_FALSE (!(dst2 = map_guest_mem (vui, cpy[0].dst, map_hint))))
196 if (PREDICT_FALSE (!(dst3 = map_guest_mem (vui, cpy[1].dst, map_hint))))
198 while (PREDICT_TRUE (copy_len >= 4))
204 (!(dst2 = map_guest_mem (vui, cpy[2].dst, map_hint))))
207 (!(dst3 = map_guest_mem (vui, cpy[3].dst, map_hint))))
210 CLIB_PREFETCH ((void *) cpy[2].src, 64, LOAD);
211 CLIB_PREFETCH ((void *) cpy[3].src, 64, LOAD);
213 clib_memcpy_fast (dst0, (void *) cpy[0].src, cpy[0].len);
214 clib_memcpy_fast (dst1, (void *) cpy[1].src, cpy[1].len);
216 vhost_user_log_dirty_pages_2 (vui, cpy[0].dst, cpy[0].len, 1);
217 vhost_user_log_dirty_pages_2 (vui, cpy[1].dst, cpy[1].len, 1);
224 if (PREDICT_FALSE (!(dst0 = map_guest_mem (vui, cpy->dst, map_hint))))
226 clib_memcpy_fast (dst0, (void *) cpy->src, cpy->len);
227 vhost_user_log_dirty_pages_2 (vui, cpy->dst, cpy->len, 1);
234 static_always_inline void
235 vhost_user_handle_tx_offload (vhost_user_intf_t * vui, vlib_buffer_t * b,
236 virtio_net_hdr_t * hdr)
238 /* checksum offload */
239 if (b->flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM)
241 hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
242 hdr->csum_start = vnet_buffer (b)->l4_hdr_offset;
243 hdr->csum_offset = offsetof (udp_header_t, checksum);
245 else if (b->flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM)
247 hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
248 hdr->csum_start = vnet_buffer (b)->l4_hdr_offset;
249 hdr->csum_offset = offsetof (tcp_header_t, checksum);
253 if (b->flags & VNET_BUFFER_F_GSO)
255 if (b->flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM)
257 if ((b->flags & VNET_BUFFER_F_IS_IP4) &&
258 (vui->features & (1ULL << FEAT_VIRTIO_NET_F_GUEST_TSO4)))
260 hdr->gso_size = vnet_buffer2 (b)->gso_size;
261 hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
263 else if ((b->flags & VNET_BUFFER_F_IS_IP6) &&
264 (vui->features & (1ULL << FEAT_VIRTIO_NET_F_GUEST_TSO6)))
266 hdr->gso_size = vnet_buffer2 (b)->gso_size;
267 hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
270 else if ((vui->features & (1ULL << FEAT_VIRTIO_NET_F_GUEST_UFO)) &&
271 (b->flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM))
273 hdr->gso_size = vnet_buffer2 (b)->gso_size;
274 hdr->gso_type = VIRTIO_NET_HDR_GSO_UDP;
279 VNET_DEVICE_CLASS_TX_FN (vhost_user_device_class) (vlib_main_t * vm,
280 vlib_node_runtime_t *
281 node, vlib_frame_t * frame)
283 u32 *buffers = vlib_frame_vector_args (frame);
284 u32 n_left = frame->n_vectors;
285 vhost_user_main_t *vum = &vhost_user_main;
286 vnet_interface_output_runtime_t *rd = (void *) node->runtime_data;
287 vhost_user_intf_t *vui =
288 pool_elt_at_index (vum->vhost_user_interfaces, rd->dev_instance);
290 vhost_user_vring_t *rxvq;
292 u32 thread_index = vm->thread_index;
293 vhost_cpu_t *cpu = &vum->cpus[thread_index];
299 if (PREDICT_FALSE (!vui->admin_up))
301 error = VHOST_USER_TX_FUNC_ERROR_DOWN;
305 if (PREDICT_FALSE (!vui->is_ready))
307 error = VHOST_USER_TX_FUNC_ERROR_NOT_READY;
311 qid = VHOST_VRING_IDX_RX (*vec_elt_at_index (vui->per_cpu_tx_qid,
313 rxvq = &vui->vrings[qid];
314 if (PREDICT_FALSE (rxvq->avail == 0))
316 error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
320 if (PREDICT_FALSE (vui->use_tx_spinlock))
321 vhost_user_vring_lock (vui, qid);
324 error = VHOST_USER_TX_FUNC_ERROR_NONE;
329 vlib_buffer_t *b0, *current_b0;
330 u16 desc_head, desc_index, desc_len;
331 vring_desc_t *desc_table;
332 uword buffer_map_addr;
336 if (PREDICT_TRUE (n_left > 1))
337 vlib_prefetch_buffer_with_index (vm, buffers[1], LOAD);
339 b0 = vlib_get_buffer (vm, buffers[0]);
341 if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
343 cpu->current_trace = vlib_add_trace (vm, node, b0,
344 sizeof (*cpu->current_trace));
345 vhost_user_tx_trace (cpu->current_trace, vui, qid / 2, b0, rxvq);
348 if (PREDICT_FALSE (rxvq->last_avail_idx == rxvq->avail->idx))
350 error = VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOBUF;
354 desc_table = rxvq->desc;
355 desc_head = desc_index =
356 rxvq->avail->ring[rxvq->last_avail_idx & rxvq->qsz_mask];
358 /* Go deeper in case of indirect descriptor
359 * I don't know of any driver providing indirect for RX. */
360 if (PREDICT_FALSE (rxvq->desc[desc_head].flags & VIRTQ_DESC_F_INDIRECT))
363 (rxvq->desc[desc_head].len < sizeof (vring_desc_t)))
365 error = VHOST_USER_TX_FUNC_ERROR_INDIRECT_OVERFLOW;
370 map_guest_mem (vui, rxvq->desc[desc_index].addr,
373 error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
379 desc_len = vui->virtio_net_hdr_sz;
380 buffer_map_addr = desc_table[desc_index].addr;
381 buffer_len = desc_table[desc_index].len;
384 // Get a header from the header array
385 virtio_net_hdr_mrg_rxbuf_t *hdr = &cpu->tx_headers[tx_headers_len];
388 hdr->hdr.gso_type = VIRTIO_NET_HDR_GSO_NONE;
389 hdr->num_buffers = 1; //This is local, no need to check
391 /* Guest supports csum offload? */
392 if (vui->features & (1ULL << FEAT_VIRTIO_NET_F_GUEST_CSUM))
393 vhost_user_handle_tx_offload (vui, b0, &hdr->hdr);
395 // Prepare a copy order executed later for the header
396 ASSERT (copy_len < VHOST_USER_COPY_ARRAY_N);
397 vhost_copy_t *cpy = &cpu->copy[copy_len];
399 cpy->len = vui->virtio_net_hdr_sz;
400 cpy->dst = buffer_map_addr;
401 cpy->src = (uword) hdr;
404 buffer_map_addr += vui->virtio_net_hdr_sz;
405 buffer_len -= vui->virtio_net_hdr_sz;
406 bytes_left = b0->current_length;
412 if (desc_table[desc_index].flags & VIRTQ_DESC_F_NEXT)
414 //Next one is chained
415 desc_index = desc_table[desc_index].next;
416 buffer_map_addr = desc_table[desc_index].addr;
417 buffer_len = desc_table[desc_index].len;
419 else if (vui->virtio_net_hdr_sz == 12) //MRG is available
421 virtio_net_hdr_mrg_rxbuf_t *hdr =
422 &cpu->tx_headers[tx_headers_len - 1];
424 //Move from available to used buffer
425 rxvq->used->ring[rxvq->last_used_idx & rxvq->qsz_mask].id =
427 rxvq->used->ring[rxvq->last_used_idx & rxvq->qsz_mask].len =
429 vhost_user_log_dirty_ring (vui, rxvq,
430 ring[rxvq->last_used_idx &
433 rxvq->last_avail_idx++;
434 rxvq->last_used_idx++;
439 (rxvq->last_avail_idx == rxvq->avail->idx))
441 //Dequeue queued descriptors for this packet
442 rxvq->last_used_idx -= hdr->num_buffers - 1;
443 rxvq->last_avail_idx -= hdr->num_buffers - 1;
444 error = VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOBUF;
448 desc_table = rxvq->desc;
449 desc_head = desc_index =
450 rxvq->avail->ring[rxvq->last_avail_idx & rxvq->qsz_mask];
452 (rxvq->desc[desc_head].flags & VIRTQ_DESC_F_INDIRECT))
454 //It is seriously unlikely that a driver will put indirect descriptor
455 //after non-indirect descriptor.
457 (rxvq->desc[desc_head].len < sizeof (vring_desc_t)))
459 error = VHOST_USER_TX_FUNC_ERROR_INDIRECT_OVERFLOW;
465 rxvq->desc[desc_index].addr,
468 error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
473 buffer_map_addr = desc_table[desc_index].addr;
474 buffer_len = desc_table[desc_index].len;
478 error = VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOMRG;
484 ASSERT (copy_len < VHOST_USER_COPY_ARRAY_N);
485 vhost_copy_t *cpy = &cpu->copy[copy_len];
487 cpy->len = bytes_left;
488 cpy->len = (cpy->len > buffer_len) ? buffer_len : cpy->len;
489 cpy->dst = buffer_map_addr;
490 cpy->src = (uword) vlib_buffer_get_current (current_b0) +
491 current_b0->current_length - bytes_left;
493 bytes_left -= cpy->len;
494 buffer_len -= cpy->len;
495 buffer_map_addr += cpy->len;
496 desc_len += cpy->len;
498 CLIB_PREFETCH (&rxvq->desc, CLIB_CACHE_LINE_BYTES, LOAD);
501 // Check if vlib buffer has more data. If not, get more or break.
502 if (PREDICT_TRUE (!bytes_left))
505 (current_b0->flags & VLIB_BUFFER_NEXT_PRESENT))
507 current_b0 = vlib_get_buffer (vm, current_b0->next_buffer);
508 bytes_left = current_b0->current_length;
518 //Move from available to used ring
519 rxvq->used->ring[rxvq->last_used_idx & rxvq->qsz_mask].id = desc_head;
520 rxvq->used->ring[rxvq->last_used_idx & rxvq->qsz_mask].len = desc_len;
521 vhost_user_log_dirty_ring (vui, rxvq,
522 ring[rxvq->last_used_idx & rxvq->qsz_mask]);
523 rxvq->last_avail_idx++;
524 rxvq->last_used_idx++;
526 if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
528 cpu->current_trace->hdr = cpu->tx_headers[tx_headers_len - 1];
531 n_left--; //At the end for error counting when 'goto done' is invoked
534 * Do the copy periodically to prevent
535 * cpu->copy array overflow and corrupt memory
537 if (PREDICT_FALSE (copy_len >= VHOST_USER_TX_COPY_THRESHOLD))
539 if (PREDICT_FALSE (vhost_user_tx_copy (vui, cpu->copy, copy_len,
542 vlib_error_count (vm, node->node_index,
543 VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL, 1);
547 /* give buffers back to driver */
548 CLIB_MEMORY_BARRIER ();
549 rxvq->used->idx = rxvq->last_used_idx;
550 vhost_user_log_dirty_ring (vui, rxvq, idx);
556 //Do the memory copies
557 if (PREDICT_FALSE (vhost_user_tx_copy (vui, cpu->copy, copy_len,
560 vlib_error_count (vm, node->node_index,
561 VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL, 1);
564 CLIB_MEMORY_BARRIER ();
565 rxvq->used->idx = rxvq->last_used_idx;
566 vhost_user_log_dirty_ring (vui, rxvq, idx);
569 * When n_left is set, error is always set to something too.
570 * In case error is due to lack of remaining buffers, we go back up and
572 * The idea is that it is better to waste some time on packets
573 * that have been processed already than dropping them and get
574 * more fresh packets with a good likelihood that they will be dropped too.
575 * This technique also gives more time to VM driver to pick-up packets.
576 * In case the traffic flows from physical to virtual interfaces, this
577 * technique will end-up leveraging the physical NIC buffer in order to
578 * absorb the VM's CPU jitter.
580 if (n_left && (error == VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOBUF) && retry)
586 /* interrupt (call) handling */
587 if ((rxvq->callfd_idx != ~0) &&
588 !(rxvq->avail->flags & VRING_AVAIL_F_NO_INTERRUPT))
590 rxvq->n_since_last_int += frame->n_vectors - n_left;
592 if (rxvq->n_since_last_int > vum->coalesce_frames)
593 vhost_user_send_call (vm, rxvq);
596 vhost_user_vring_unlock (vui, qid);
599 if (PREDICT_FALSE (n_left && error != VHOST_USER_TX_FUNC_ERROR_NONE))
601 vlib_error_count (vm, node->node_index, error, n_left);
602 vlib_increment_simple_counter
603 (vnet_main.interface_main.sw_if_counters
604 + VNET_INTERFACE_COUNTER_DROP,
605 thread_index, vui->sw_if_index, n_left);
608 vlib_buffer_free (vm, vlib_frame_vector_args (frame), frame->n_vectors);
609 return frame->n_vectors;
612 static __clib_unused clib_error_t *
613 vhost_user_interface_rx_mode_change (vnet_main_t * vnm, u32 hw_if_index,
614 u32 qid, vnet_hw_interface_rx_mode mode)
616 vlib_main_t *vm = vnm->vlib_main;
617 vnet_hw_interface_t *hif = vnet_get_hw_interface (vnm, hw_if_index);
618 vhost_user_main_t *vum = &vhost_user_main;
619 vhost_user_intf_t *vui =
620 pool_elt_at_index (vum->vhost_user_interfaces, hif->dev_instance);
621 vhost_user_vring_t *txvq = &vui->vrings[VHOST_VRING_IDX_TX (qid)];
623 if ((mode == VNET_HW_INTERFACE_RX_MODE_INTERRUPT) ||
624 (mode == VNET_HW_INTERFACE_RX_MODE_ADAPTIVE))
626 if (txvq->kickfd_idx == ~0)
628 // We cannot support interrupt mode if the driver opts out
629 return clib_error_return (0, "Driver does not support interrupt");
631 if (txvq->mode == VNET_HW_INTERFACE_RX_MODE_POLLING)
634 // Start the timer if this is the first encounter on interrupt
636 if ((vum->ifq_count == 1) &&
637 (vum->coalesce_time > 0.0) && (vum->coalesce_frames > 0))
638 vlib_process_signal_event (vm,
639 vhost_user_send_interrupt_node.index,
640 VHOST_USER_EVENT_START_TIMER, 0);
643 else if (mode == VNET_HW_INTERFACE_RX_MODE_POLLING)
645 if (((txvq->mode == VNET_HW_INTERFACE_RX_MODE_INTERRUPT) ||
646 (txvq->mode == VNET_HW_INTERFACE_RX_MODE_ADAPTIVE)) &&
650 // Stop the timer if there is no more interrupt interface/queue
651 if ((vum->ifq_count == 0) &&
652 (vum->coalesce_time > 0.0) && (vum->coalesce_frames > 0))
653 vlib_process_signal_event (vm,
654 vhost_user_send_interrupt_node.index,
655 VHOST_USER_EVENT_STOP_TIMER, 0);
660 if (mode == VNET_HW_INTERFACE_RX_MODE_POLLING)
661 txvq->used->flags = VRING_USED_F_NO_NOTIFY;
662 else if ((mode == VNET_HW_INTERFACE_RX_MODE_ADAPTIVE) ||
663 (mode == VNET_HW_INTERFACE_RX_MODE_INTERRUPT))
664 txvq->used->flags = 0;
667 vu_log_err (vui, "unhandled mode %d changed for if %d queue %d", mode,
669 return clib_error_return (0, "unsupported");
675 static __clib_unused clib_error_t *
676 vhost_user_interface_admin_up_down (vnet_main_t * vnm, u32 hw_if_index,
679 vnet_hw_interface_t *hif = vnet_get_hw_interface (vnm, hw_if_index);
680 vhost_user_main_t *vum = &vhost_user_main;
681 vhost_user_intf_t *vui =
682 pool_elt_at_index (vum->vhost_user_interfaces, hif->dev_instance);
683 u8 link_old, link_new;
685 link_old = vui_is_link_up (vui);
687 vui->admin_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0;
689 link_new = vui_is_link_up (vui);
691 if (link_old != link_new)
692 vnet_hw_interface_set_flags (vnm, vui->hw_if_index, link_new ?
693 VNET_HW_INTERFACE_FLAG_LINK_UP : 0);
695 return /* no error */ 0;
699 VNET_DEVICE_CLASS (vhost_user_device_class) = {
700 .name = "vhost-user",
701 .tx_function_n_errors = VHOST_USER_TX_FUNC_N_ERROR,
702 .tx_function_error_strings = vhost_user_tx_func_error_strings,
703 .format_device_name = format_vhost_user_interface_name,
704 .name_renumber = vhost_user_name_renumber,
705 .admin_up_down_function = vhost_user_interface_admin_up_down,
706 .rx_mode_change_function = vhost_user_interface_rx_mode_change,
707 .format_tx_trace = format_vhost_trace,
713 * fd.io coding-style-patch-verification: ON
716 * eval: (c-set-style "gnu")