21 #include <sys/ioctl.h> 22 #include <sys/socket.h> 25 #include <sys/types.h> 27 #include <netinet/in.h> 30 #include <linux/if_arp.h> 31 #include <linux/if_tun.h> 84 ssize_t map_sz = (vui->
regions[
i].memory_size +
86 page_sz - 1) & ~(page_sz - 1);
93 (
"unmap memory region %d addr 0x%lx len 0x%lx page_sz 0x%x", i,
100 clib_warning (
"failed to unmap memory region (errno %d)",
114 u32 thread_index = 0;
131 if (thread_index == 0)
134 for (thread_index = 0;
163 vec_foreach (queue, vui->rx_queues)
165 rv = vnet_hw_interface_unassign_rx_thread (vnm, vui->hw_if_index,
168 clib_warning (
"Warning: unable to unassign interface %d, " 169 "queue %d: rc=%d", vui->hw_if_index, *queue, rv);
178 for (qid = 0; qid < VHOST_VRING_MAX_N / 2; qid++)
180 txvq = &vui->vrings[VHOST_VRING_IDX_TX (qid)];
183 if (txvq->mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
185 txvq->mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
186 vec_add1 (vui->rx_queues, qid);
195 vnet_hw_interface_set_input_node (vnm, vui->hw_if_index,
196 vhost_user_input_node.index);
197 vec_foreach (queue, vui->rx_queues)
199 vnet_hw_interface_assign_rx_thread (vnm, vui->hw_if_index, *queue,
201 txvq = &vui->vrings[VHOST_VRING_IDX_TX (*queue)];
202 rv = vnet_hw_interface_set_rx_mode (vnm, vui->hw_if_index, *queue,
205 clib_warning (
"Warning: unable to set rx mode for interface %d, " 206 "queue %d: rc=%d", vui->hw_if_index, *queue, rv);
216 int i, found[2] = { };
222 return found[0] && found[1];
230 if (is_up != vui->
is_up)
233 is_up ?
"ready" :
"down");
262 __attribute__ ((unused))
int n;
273 __attribute__ ((unused))
int n;
299 memset (vring, 0,
sizeof (*vring));
313 if (qid == 0 || qid == 1)
335 if (vring->
errfd != -1)
337 close (vring->
errfd);
370 int fd, number_of_fds = 0;
372 vhost_user_msg_t msg;
377 struct cmsghdr *cmsg;
386 memset (&mh, 0,
sizeof (mh));
387 memset (control, 0,
sizeof (control));
393 iov[0].iov_base = (
void *) &msg;
398 mh.msg_control = control;
399 mh.msg_controllen =
sizeof (control);
410 DBG_SOCK (
"recvmsg returned error %d %s", errno, strerror (errno));
414 DBG_SOCK (
"n (%d) != VHOST_USER_MSG_HDR_SZ (%d)",
420 if (mh.msg_flags & MSG_CTRUNC)
426 cmsg = CMSG_FIRSTHDR (&mh);
428 if (cmsg && (cmsg->cmsg_len > 0) && (cmsg->cmsg_level == SOL_SOCKET) &&
429 (cmsg->cmsg_type == SCM_RIGHTS) &&
430 (cmsg->cmsg_len - CMSG_LEN (0) <=
431 VHOST_MEMORY_MAX_NREGIONS *
sizeof (
int)))
433 number_of_fds = (cmsg->cmsg_len - CMSG_LEN (0)) /
sizeof (
int);
434 clib_memcpy (fds, CMSG_DATA (cmsg), number_of_fds *
sizeof (
int));
438 if ((msg.flags & 7) != 1)
440 DBG_SOCK (
"malformed message received. closing socket");
451 DBG_SOCK (
"read failed %s", strerror (errno));
454 else if (rv != msg.size)
456 DBG_SOCK (
"message too short (read %dB should be %dB)", rv, msg.size);
465 msg.u64 = (1ULL << FEAT_VIRTIO_NET_F_MRG_RXBUF) |
466 (1ULL << FEAT_VIRTIO_NET_F_CTRL_VQ) |
467 (1ULL << FEAT_VIRTIO_F_ANY_LAYOUT) |
468 (1ULL << FEAT_VIRTIO_F_INDIRECT_DESC) |
469 (1ULL << FEAT_VHOST_F_LOG_ALL) |
470 (1ULL << FEAT_VIRTIO_NET_F_GUEST_ANNOUNCE) |
471 (1ULL << FEAT_VIRTIO_NET_F_MQ) |
472 (1ULL << FEAT_VHOST_USER_F_PROTOCOL_FEATURES) |
473 (1ULL << FEAT_VIRTIO_F_VERSION_1);
475 msg.size =
sizeof (msg.u64);
476 DBG_SOCK (
"if %d msg VHOST_USER_GET_FEATURES - reply 0x%016llx",
481 DBG_SOCK (
"if %d msg VHOST_USER_SET_FEATURES features 0x%016llx",
487 ((1 << FEAT_VIRTIO_NET_F_MRG_RXBUF) |
488 (1ULL << FEAT_VIRTIO_F_VERSION_1)))
494 (vui->
features & (1 << FEAT_VIRTIO_F_ANY_LAYOUT)) ? 1 : 0;
506 DBG_SOCK (
"if %d msg VHOST_USER_SET_MEM_TABLE nregions %d",
509 if ((msg.memory.nregions < 1) ||
510 (msg.memory.nregions > VHOST_MEMORY_MAX_NREGIONS))
513 DBG_SOCK (
"number of mem regions must be between 1 and %i",
514 VHOST_MEMORY_MAX_NREGIONS);
519 if (msg.memory.nregions != number_of_fds)
521 DBG_SOCK (
"each memory region must have FD");
525 for (i = 0; i < msg.memory.nregions; i++)
528 sizeof (vhost_user_memory_region_t));
533 ssize_t map_sz = (vui->
regions[
i].memory_size +
535 page_sz - 1) & ~(page_sz - 1);
538 MAP_SHARED, fds[i], 0);
544 (
"map memory region %d addr 0 len 0x%lx fd %d mapped 0x%lx " 550 clib_warning (
"failed to map memory. errno is %d", errno);
561 DBG_SOCK (
"if %d msg VHOST_USER_SET_VRING_NUM idx %d num %d",
564 if ((msg.state.num > 32768) ||
565 (msg.state.num == 0) ||
566 ((msg.state.num - 1) & msg.state.num))
572 DBG_SOCK (
"if %d msg VHOST_USER_SET_VRING_ADDR idx %d",
577 DBG_SOCK (
"invalid vring index VHOST_USER_SET_VRING_ADDR:" 582 if (msg.size < sizeof (msg.addr))
584 DBG_SOCK (
"vhost message is too short (%d < %d)",
585 msg.size, sizeof (msg.addr));
589 vui->
vrings[msg.state.index].
desc = (vring_desc_t *)
591 vui->
vrings[msg.state.index].
used = (vring_used_t *)
593 vui->
vrings[msg.state.index].
avail = (vring_avail_t *)
600 DBG_SOCK (
"failed to map user memory for hw_if_index %d",
611 if (!(vui->
features & (1 << FEAT_VHOST_USER_F_PROTOCOL_FEATURES)))
633 DBG_SOCK (
"if %d msg VHOST_USER_SET_VRING_CALL %d",
636 q = (
u8) (msg.u64 & 0xFF);
649 if (number_of_fds != 1)
651 DBG_SOCK (
"More than one fd received !");
656 template.file_descriptor = fds[0];
657 template.private_data =
666 DBG_SOCK (
"if %d msg VHOST_USER_SET_VRING_KICK %d",
669 q = (
u8) (msg.u64 & 0xFF);
681 if (number_of_fds != 1)
683 DBG_SOCK (
"More than one fd received !");
688 template.file_descriptor = fds[0];
689 template.private_data =
704 DBG_SOCK (
"if %d msg VHOST_USER_SET_VRING_ERR %d",
707 q = (
u8) (msg.u64 & 0xFF);
714 if (number_of_fds != 1)
725 DBG_SOCK (
"if %d msg VHOST_USER_SET_VRING_BASE idx %d num %d",
734 DBG_SOCK (
"invalid vring index VHOST_USER_GET_VRING_BASE:" 745 msg.size =
sizeof (msg.state);
749 DBG_SOCK (
"if %d msg VHOST_USER_GET_VRING_BASE idx %d num %d",
762 if (msg.size != sizeof (msg.log))
765 (
"invalid msg size for VHOST_USER_SET_LOG_BASE: %d instead of %d",
766 msg.size, sizeof (msg.log));
774 (
"VHOST_USER_PROTOCOL_F_LOG_SHMFD not set but VHOST_USER_SET_LOG_BASE received");
782 (msg.log.size + msg.log.offset + page_sz - 1) & ~(page_sz - 1);
784 vui->
log_base_addr = mmap (0, map_sz, PROT_READ | PROT_WRITE,
788 (
"map log region addr 0 len 0x%lx off 0x%lx fd %d mapped 0x%lx",
793 clib_warning (
"failed to map memory. errno is %d", errno);
801 msg.size =
sizeof (msg.u64);
815 msg.size =
sizeof (msg.u64);
817 (
"if %d msg VHOST_USER_GET_PROTOCOL_FEATURES - reply 0x%016llx",
823 (
"if %d msg VHOST_USER_SET_PROTOCOL_FEATURES features 0x%016llx",
833 msg.size =
sizeof (msg.u64);
834 DBG_SOCK (
"if %d msg VHOST_USER_GET_QUEUE_NUM - reply %d",
839 DBG_SOCK (
"if %d VHOST_USER_SET_VRING_ENABLE: %s queue %d",
840 vui->
hw_if_index, msg.state.num ?
"enable" :
"disable",
844 DBG_SOCK (
"invalid vring index VHOST_USER_SET_VRING_ENABLE:" 853 DBG_SOCK (
"unknown vhost-user message %d received. closing socket",
865 DBG_SOCK (
"could not send message response");
900 int client_fd, client_len;
901 struct sockaddr_un client;
908 client_len =
sizeof (client);
910 (
struct sockaddr *) &client,
911 (socklen_t *) & client_len);
918 DBG_SOCK (
"Close client socket for vhost interface %d, fd %d",
923 DBG_SOCK (
"New client socket for vhost interface %d, fd %d",
927 template.file_descriptor = client_fd;
971 f64 timeout = 3153600000.0 ;
972 uword event_type, *event_data = 0;
975 f64 now, poll_time_remaining;
981 poll_time_remaining =
990 timeout = poll_time_remaining;
1011 next_timeout = timeout;
1012 vec_foreach (queue, vui->rx_queues)
1014 vhost_user_vring_t *rxvq =
1015 &vui->vrings[VHOST_VRING_IDX_RX (*queue)];
1016 vhost_user_vring_t *txvq =
1017 &vui->vrings[VHOST_VRING_IDX_TX (*queue)];
1019 if (txvq->n_since_last_int)
1021 if (now >= txvq->int_deadline)
1022 vhost_user_send_call (vm, txvq);
1024 next_timeout = txvq->int_deadline - now;
1027 if (rxvq->n_since_last_int)
1029 if (now >= rxvq->int_deadline)
1030 vhost_user_send_call (vm, rxvq);
1032 next_timeout = rxvq->int_deadline - now;
1035 if ((next_timeout < timeout) && (next_timeout > 0.0))
1036 timeout = next_timeout;
1043 clib_warning (
"BUG: unhandled event type %d", event_type);
1050 timeout = 3153600000.0;
1059 .name =
"vhost-user-send-interrupt-process",
1069 struct sockaddr_un sun;
1072 f64 timeout = 3153600000.0 ;
1073 uword *event_data = 0;
1076 sun.sun_family = AF_UNIX;
1091 if (vui->unix_server_index == ~0) {
1092 if (vui->clib_file_index == ~0)
1095 ((sockfd = socket (AF_UNIX, SOCK_STREAM, 0)) < 0))
1101 if (!vui->sock_errno || (vui->sock_errno != errno))
1104 (
"Error: Could not open unix socket for %s",
1105 vui->sock_filename);
1106 vui->sock_errno = errno;
1112 strncpy (sun.sun_path, (char *) vui->sock_filename,
1113 sizeof (sun.sun_path) - 1);
1116 if (fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0)
1117 clib_unix_warning (
"fcntl");
1119 if (connect (sockfd, (struct sockaddr *) &sun,
1120 sizeof (struct sockaddr_un)) == 0)
1123 if (fcntl(sockfd, F_SETFL, 0) < 0)
1124 clib_unix_warning (
"fcntl2");
1126 vui->sock_errno = 0;
1127 template.file_descriptor = sockfd;
1128 template.private_data =
1129 vui - vhost_user_main.vhost_user_interfaces;
1130 vui->clib_file_index = clib_file_add (&file_main, &template);
1137 vui->sock_errno = errno;
1144 socklen_t len = sizeof (error);
1145 int fd = UNIX_GET_FD(vui->clib_file_index);
1147 getsockopt (fd, SOL_SOCKET, SO_ERROR, &error, &len);
1151 DBG_SOCK (
"getsockopt returned %d", retval);
1152 vhost_user_if_disconnect (vui);
1166 .name =
"vhost-user-process",
1214 return VNET_API_ERROR_INVALID_SW_IF_INDEX;
1216 DBG_SOCK (
"Deleting vhost-user interface %s (instance %d)",
1270 vhost_user_delete_if (vnm, vm, vui->sw_if_index);
1286 struct sockaddr_un
un = { };
1289 if ((fd = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
1290 return VNET_API_ERROR_SYSCALL_ERROR_1;
1292 un.sun_family = AF_UNIX;
1293 strncpy ((
char *) un.sun_path, (
char *) sock_filename,
1294 sizeof (un.sun_path) - 1);
1297 unlink ((
char *) sock_filename);
1299 if (bind (fd, (
struct sockaddr *) &un,
sizeof (un)) == -1)
1301 rv = VNET_API_ERROR_SYSCALL_ERROR_2;
1305 if (listen (fd, 1) == -1)
1307 rv = VNET_API_ERROR_SYSCALL_ERROR_3;
1363 const char *sock_filename,
1364 u64 feature_mask,
u32 * sw_if_index)
1373 if (server_sock_fd != -1)
1377 template.file_descriptor = server_sock_fd;
1421 const char *sock_filename,
1425 u8 renumber,
u32 custom_dev_instance,
u8 * hwaddr)
1430 int server_sock_fd = -1;
1434 if (sock_filename ==
NULL || !(strlen (sock_filename) > 0))
1436 return VNET_API_ERROR_INVALID_ARGUMENT;
1447 return VNET_API_ERROR_IF_ALREADY_EXISTS;
1463 feature_mask, &sw_if_idx);
1469 *sw_if_index = sw_if_idx;
1479 const char *sock_filename,
1482 u64 feature_mask,
u8 renumber,
u32 custom_dev_instance)
1487 int server_sock_fd = -1;
1494 return VNET_API_ERROR_INVALID_SW_IF_INDEX;
1496 if (sock_filename ==
NULL || !(strlen (sock_filename) > 0))
1497 return VNET_API_ERROR_INVALID_ARGUMENT;
1506 if (if_index && (*if_index != vui->
if_index))
1507 return VNET_API_ERROR_IF_ALREADY_EXISTS;
1512 &server_sock_fd)) != 0)
1517 sock_filename, feature_mask, &sw_if_idx);
1534 u8 *sock_filename =
NULL;
1537 u64 feature_mask = (
u64) ~ (0ULL);
1539 u32 custom_dev_instance = ~0;
1550 if (
unformat (line_input,
"socket %s", &sock_filename))
1552 else if (
unformat (line_input,
"server"))
1554 else if (
unformat (line_input,
"feature-mask 0x%llx", &feature_mask))
1560 else if (
unformat (line_input,
"renumber %d", &custom_dev_instance))
1576 is_server, &sw_if_index, feature_mask,
1577 renumber, custom_dev_instance, hw)))
1599 u32 sw_if_index = ~0;
1609 if (
unformat (line_input,
"sw_if_index %d", &sw_if_index))
1649 u32 *hw_if_indices = 0;
1661 for (i = 0; i <
vec_len (hw_if_indices); i++)
1678 strncpy ((
char *) vuid->
if_name, (
char *) s,
1686 *out_vuids = r_vuids;
1700 u32 hw_if_index, *hw_if_indices = 0;
1711 struct feat_struct *feat_entry;
1713 static struct feat_struct feat_array[] = {
1714 #define _(s,b) { .str = #s, .bit = b, }, 1720 #define foreach_protocol_feature \ 1721 _(VHOST_USER_PROTOCOL_F_MQ) \ 1722 _(VHOST_USER_PROTOCOL_F_LOG_SHMFD) 1724 static struct feat_struct proto_feat_array[] = {
1725 #define _(s) { .str = #s, .bit = s}, 1743 vec_add1 (hw_if_indices, hw_if_index);
1754 if (
vec_len (hw_if_indices) == 0)
1763 vlib_cli_output (vm,
" number of rx virtqueues in interrupt mode: %d",
1766 for (i = 0; i <
vec_len (hw_if_indices); i++)
1771 hi->
name, hw_if_indices[i]);
1774 " features mask (0x%llx): \n" 1775 " features (0x%llx): \n",
1779 feat_entry = (
struct feat_struct *) &feat_array;
1780 while (feat_entry->str)
1782 if (vui->
features & (1ULL << feat_entry->bit))
1790 feat_entry = (
struct feat_struct *) &proto_feat_array;
1791 while (feat_entry->str)
1839 " region fd guest_phys_addr memory_size userspace_addr mmap_offset mmap_addr\n");
1841 " ====== ===== ================== ================== ================== ================== ==================\n");
1843 for (j = 0; j < vui->
nregions; j++)
1846 " %d %-5d 0x%016lx 0x%016lx 0x%016lx 0x%016lx 0x%016lx\n",
1848 vui->
regions[j].guest_phys_addr,
1850 vui->
regions[j].userspace_addr,
1860 (q & 1) ?
"RX" :
"TX",
1864 " qsz %d last_avail_idx %d last_used_idx %d\n",
1871 " avail.flags %x avail.idx %d used.flags %x used.idx %d\n",
1886 " id addr len flags next user_addr\n");
1888 " ===== ================== ===== ====== ===== ==================\n");
1893 " %-5d 0x%016lx %-5d 0x%04x %-5d 0x%016lx\n",
1972 .path =
"create vhost-user",
1973 .short_help =
"create vhost-user socket <socket-filename> [server] " 1974 "[feature-mask <hex>] [hwaddr <mac-addr>] [renumber <dev_instance>] ",
1993 .path =
"delete vhost-user",
1994 .short_help =
"delete vhost-user {<interface> | sw_if_index <sw_idx>}",
2133 .path =
"show vhost-user",
2134 .short_help =
"show vhost-user [<interface> [<interface> [..]]] [descriptors]",
2168 else if (
unformat (line_input,
"off"))
2191 .path =
"debug vhost-user",
2192 .short_help =
"debug vhost-user <on | off>",
2208 else if (
unformat (input,
"dont-dump-memory"))
unformat_function_t unformat_vnet_hw_interface
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
#define vec_foreach_index(var, v)
Iterate over vector indices.
static void clib_file_del(clib_file_main_t *um, clib_file_t *f)
static uword random_default_seed(void)
Default random seed (unix/linux user-mode)
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
#define VHOST_USER_PROTOCOL_F_LOG_SHMFD
static f64 vlib_process_wait_for_event_or_clock(vlib_main_t *vm, f64 dt)
Suspend a cooperative multi-tasking thread Waits for an event, or for the indicated number of seconds...
VNET_HW_INTERFACE_CLASS(vhost_interface_class, static)
vhost_cpu_t * cpus
Per-CPU data for vhost-user.
void ethernet_delete_interface(vnet_main_t *vnm, u32 hw_if_index)
static void vhost_user_tx_thread_placement(vhost_user_intf_t *vui)
vnet_main_t * vnet_get_main(void)
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
u64 region_guest_addr_hi[VHOST_MEMORY_MAX_NREGIONS]
static clib_error_t * vhost_user_socksvr_accept_ready(clib_file_t *uf)
#define VHOST_VRING_MAX_N
uword mhash_unset(mhash_t *h, void *key, uword *old_value)
static f64 vlib_time_now(vlib_main_t *vm)
#define VLIB_BUFFER_PRE_DATA_SIZE
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
vnet_device_class_t vhost_user_device_class
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
int vnet_interface_name_renumber(u32 sw_if_index, u32 new_show_dev_instance)
static void vhost_user_vui_init(vnet_main_t *vnm, vhost_user_intf_t *vui, int server_sock_fd, const char *sock_filename, u64 feature_mask, u32 *sw_if_index)
static clib_error_t * vhost_user_callfd_read_ready(clib_file_t *uf)
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
#define VHOST_USER_EVENT_START_TIMER
static_always_inline void vhost_user_vring_init(vhost_user_intf_t *vui, u32 qid)
unformat_function_t unformat_vnet_sw_interface
#define VNET_HW_INTERFACE_FLAG_LINK_UP
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
int vhost_user_modify_if(vnet_main_t *vnm, vlib_main_t *vm, const char *sock_filename, u8 is_server, u32 sw_if_index, u64 feature_mask, u8 renumber, u32 custom_dev_instance)
format_function_t format_vnet_sw_if_index_name
#define VHOST_USER_VRING_NOFD_MASK
static uword vlib_process_suspend_time_is_zero(f64 dt)
Returns TRUE if a process suspend time is less than 10us.
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
clib_file_function_t * read_function
#define vlib_worker_thread_barrier_sync(X)
static vnet_sw_interface_t * vnet_get_hw_sw_interface(vnet_main_t *vnm, u32 hw_if_index)
vnet_hw_interface_rx_mode
#define static_always_inline
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
#define VLIB_INIT_FUNCTION(x)
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
static clib_error_t * vhost_user_socket_read(clib_file_t *uf)
#define UNIX_GET_FD(unixfd_idx)
static_always_inline void * map_guest_mem(vhost_user_intf_t *vui, uword addr, u32 *hint)
static_always_inline void vnet_device_input_set_interrupt_pending(vnet_main_t *vnm, u32 hw_if_index, u16 queue_id)
#define VHOST_VRING_IDX_TX(qid)
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
#define VRING_USED_F_NO_NOTIFY
#define clib_error_return(e, args...)
clib_file_main_t file_main
static vlib_node_registration_t vhost_user_process_node
(constructor) VLIB_REGISTER_NODE (vhost_user_process_node)
#define vlib_call_init_function(vm, x)
static clib_error_t * vhost_user_kickfd_read_ready(clib_file_t *uf)
static clib_error_t * vhost_user_socket_error(clib_file_t *uf)
void vhost_user_unmap_all(void)
static void vhost_user_rx_thread_placement()
Unassign existing interface/queue to thread mappings and re-assign new interface/queue to thread mapp...
#define VHOST_USER_PROTOCOL_F_MQ
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
static_always_inline uword vnet_get_device_input_thread_index(vnet_main_t *vnm, u32 hw_if_index, u16 queue_id)
static void vhost_user_term_if(vhost_user_intf_t *vui)
Disables and reset interface structure.
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
static_always_inline int vhost_user_intf_ready(vhost_user_intf_t *vui)
Returns whether at least one TX and one RX vring are enabled.
u32 random
Pseudo random iterator.
uword mhash_set_mem(mhash_t *h, void *key, uword *new_value, uword *old_value)
int vhost_user_create_if(vnet_main_t *vnm, vlib_main_t *vm, const char *sock_filename, u8 is_server, u32 *sw_if_index, u64 feature_mask, u8 renumber, u32 custom_dev_instance, u8 *hwaddr)
#define clib_error_return_unix(e, args...)
int vnet_hw_interface_get_rx_mode(vnet_main_t *vnm, u32 hw_if_index, u16 queue_id, vnet_hw_interface_rx_mode *mode)
#define pool_put(P, E)
Free an object E in pool P.
int vhost_user_delete_if(vnet_main_t *vnm, vlib_main_t *vm, u32 sw_if_index)
format_function_t format_vnet_hw_interface_rx_mode
#define VLIB_CONFIG_FUNCTION(x, n,...)
vhost_user_main_t vhost_user_main
static void vhost_user_update_iface_state(vhost_user_intf_t *vui)
#define VHOST_USER_MSG_HDR_SZ
u32 region_mmap_fd[VHOST_MEMORY_MAX_NREGIONS]
int vhost_user_dump_ifs(vnet_main_t *vnm, vlib_main_t *vm, vhost_user_intf_details_t **out_vuids)
#define VNET_HW_INTERFACE_FLAG_SUPPORTS_INT_MODE
vhost_user_memory_region_t regions[VHOST_MEMORY_MAX_NREGIONS]
#define VHOST_VRING_IDX_RX(qid)
u32 * show_dev_instance_by_real_dev_instance
static_always_inline void vhost_user_vring_close(vhost_user_intf_t *vui, u32 qid)
vhost_user_intf_t * vhost_user_interfaces
#define VLIB_REGISTER_NODE(x,...)
static void mhash_init_c_string(mhash_t *h, uword n_value_bytes)
#define DBG_SOCK(args...)
#define vec_free(V)
Free vector's memory (no header).
static void unmap_all_mem_regions(vhost_user_intf_t *vui)
static clib_error_t * vhost_user_config(vlib_main_t *vm, unformat_input_t *input)
#define VLIB_MAIN_LOOP_EXIT_FUNCTION(x)
#define VHOST_USER_EVENT_STOP_TIMER
#define clib_warning(format, args...)
static uword vhost_user_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
#define clib_memcpy(a, b, c)
clib_error_t * vhost_user_delete_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
#define foreach_protocol_feature
static int vhost_user_init_server_sock(const char *sock_filename, int *sock_fd)
Open server unix socket on specified sock_filename.
#define VLIB_CLI_COMMAND(x,...)
uword unformat_ethernet_address(unformat_input_t *input, va_list *args)
clib_error_t * show_vhost_user_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
#define VHOST_VRING_F_LOG
static uword * mhash_get(mhash_t *h, const void *key)
static uword clib_file_add(clib_file_main_t *um, clib_file_t *template)
static_always_inline void vhost_user_if_disconnect(vhost_user_intf_t *vui)
static void clib_mem_free(void *p)
volatile u32 * vring_locks[VHOST_VRING_MAX_N]
clib_error_t * ethernet_register_interface(vnet_main_t *vnm, u32 dev_class_index, u32 dev_instance, u8 *address, u32 *hw_if_index_return, ethernet_flag_change_function_t flag_change)
mhash_t if_index_by_sock_name
static clib_error_t * vhost_user_exit(vlib_main_t *vm)
#define clib_error_report(e)
vlib_node_registration_t vhost_user_send_interrupt_node
(constructor) VLIB_REGISTER_NODE (vhost_user_send_interrupt_node)
static uword pointer_to_uword(const void *p)
static void vhost_user_create_ethernet(vnet_main_t *vnm, vlib_main_t *vm, vhost_user_intf_t *vui, u8 *hwaddress)
Create ethernet interface for vhost user interface.
clib_error_t * debug_vhost_user_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
static vlib_main_t * vlib_get_main(void)
struct _vlib_node_registration vlib_node_registration_t
void * region_mmap_addr[VHOST_MEMORY_MAX_NREGIONS]
static long get_huge_page_size(int fd)
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
vhost_user_vring_t vrings[VHOST_VRING_MAX_N]
static void vhost_user_set_interrupt_pending(vhost_user_intf_t *vui, u32 ifq)
#define VHOST_MEMORY_MAX_NREGIONS
clib_error_t * vhost_user_connect_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
void vnet_sw_interface_set_mtu(vnet_main_t *vnm, u32 sw_if_index, u32 mtu)
static void * clib_mem_alloc_aligned(uword size, uword align)
static u32 random_u32(u32 *seed)
32-bit random number generator
void vlib_worker_thread_barrier_release(vlib_main_t *vm)
static vlib_thread_main_t * vlib_get_thread_main()
u64 region_guest_addr_lo[VHOST_MEMORY_MAX_NREGIONS]
#define vec_foreach(var, vec)
Vector iterator.
static clib_error_t * vhost_user_init(vlib_main_t *vm)
static_always_inline void * map_user_mem(vhost_user_intf_t *vui, uword addr)
#define CLIB_CACHE_LINE_BYTES
static uword vhost_user_send_interrupt_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
vl_api_address_union_t un
int dont_dump_vhost_user_memory