vhost: import copy of dpdk rte_vhost v17.05

#

#  BSD LICENSE

#

#  Copyright (c) Intel Corporation.

#  All rights reserved.

#

#  Redistribution and use in source and binary forms, with or without

#  modification, are permitted provided that the following conditions

#  are met:

#

#    * Redistributions of source code must retain the above copyright

#      notice, this list of conditions and the following disclaimer.

#    * Redistributions in binary form must reproduce the above copyright

#      notice, this list of conditions and the following disclaimer in

#      the documentation and/or other materials provided with the

#      distribution.

#    * Neither the name of Intel Corporation nor the names of its

#      contributors may be used to endorse or promote products derived

#      from this software without specific prior written permission.

#

#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

#  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

#  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

#  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

#  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

#  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

#  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

#  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#

SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..)

include $(SPDK_ROOT_DIR)/mk/spdk.common.mk

CFLAGS += -I.

CFLAGS += $(ENV_CFLAGS)

# These are the DPDK vhost files copied (for now) into SPDK

C_SRCS += fd_man.c socket.c vhost_user.c virtio_net.c vhost.c

LIBNAME = rte_vhost

include $(SPDK_ROOT_DIR)/mk/spdk.lib.mk

/*-

 *   BSD LICENSE

 *

 *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.

 *   All rights reserved.

 *

 *   Redistribution and use in source and binary forms, with or without

 *   modification, are permitted provided that the following conditions

 *   are met:

 *

 *     * Redistributions of source code must retain the above copyright

 *       notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above copyright

 *       notice, this list of conditions and the following disclaimer in

 *       the documentation and/or other materials provided with the

 *       distribution.

 *     * Neither the name of Intel Corporation nor the names of its

 *       contributors may be used to endorse or promote products derived

 *       from this software without specific prior written permission.

 *

 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/socket.h>

#include <sys/time.h>

#include <sys/types.h>

#include <unistd.h>

#include <string.h>

#include <rte_common.h>

#include <rte_log.h>

#include "fd_man.h"

#define FDPOLLERR (POLLERR | POLLHUP | POLLNVAL)

static int

get_last_valid_idx(struct fdset *pfdset, int last_valid_idx)

{

	int i;

	for (i = last_valid_idx; i >= 0 && pfdset->fd[i].fd == -1; i--)

		;

	return i;

}

static void

fdset_move(struct fdset *pfdset, int dst, int src)

{

	pfdset->fd[dst]    = pfdset->fd[src];

	pfdset->rwfds[dst] = pfdset->rwfds[src];

}

static void

fdset_shrink_nolock(struct fdset *pfdset)

{

	int i;

	int last_valid_idx = get_last_valid_idx(pfdset, pfdset->num - 1);

	for (i = 0; i < last_valid_idx; i++) {

		if (pfdset->fd[i].fd != -1)

			continue;

		fdset_move(pfdset, i, last_valid_idx);

		last_valid_idx = get_last_valid_idx(pfdset, last_valid_idx - 1);

	}

	pfdset->num = last_valid_idx + 1;

}

/*

 * Find deleted fd entries and remove them

 */

static void

fdset_shrink(struct fdset *pfdset)

{

	pthread_mutex_lock(&pfdset->fd_mutex);

	fdset_shrink_nolock(pfdset);

	pthread_mutex_unlock(&pfdset->fd_mutex);

}

/**

 * Returns the index in the fdset for a given fd.

 * @return

 *   index for the fd, or -1 if fd isn't in the fdset.

 */

static int

fdset_find_fd(struct fdset *pfdset, int fd)

{

	int i;

	for (i = 0; i < pfdset->num && pfdset->fd[i].fd != fd; i++)

		;

	return i == pfdset->num ? -1 : i;

}

static void

fdset_add_fd(struct fdset *pfdset, int idx, int fd,

	fd_cb rcb, fd_cb wcb, void *dat)

{

	struct fdentry *pfdentry = &pfdset->fd[idx];

	struct pollfd *pfd = &pfdset->rwfds[idx];

	pfdentry->fd  = fd;

	pfdentry->rcb = rcb;

	pfdentry->wcb = wcb;

	pfdentry->dat = dat;

	pfd->fd = fd;

	pfd->events  = rcb ? POLLIN : 0;

	pfd->events |= wcb ? POLLOUT : 0;

	pfd->revents = 0;

}

void

fdset_init(struct fdset *pfdset)

{

	int i;

	if (pfdset == NULL)

		return;

	for (i = 0; i < MAX_FDS; i++) {

		pfdset->fd[i].fd = -1;

		pfdset->fd[i].dat = NULL;

	}

	pfdset->num = 0;

}

/**

 * Register the fd in the fdset with read/write handler and context.

 */

int

fdset_add(struct fdset *pfdset, int fd, fd_cb rcb, fd_cb wcb, void *dat)

{

	int i;

	if (pfdset == NULL || fd == -1)

		return -1;

	pthread_mutex_lock(&pfdset->fd_mutex);

	i = pfdset->num < MAX_FDS ? pfdset->num++ : -1;

	if (i == -1) {

		fdset_shrink_nolock(pfdset);

		i = pfdset->num < MAX_FDS ? pfdset->num++ : -1;

		if (i == -1) {

			pthread_mutex_unlock(&pfdset->fd_mutex);

			return -2;

		}

	}

	fdset_add_fd(pfdset, i, fd, rcb, wcb, dat);

	pthread_mutex_unlock(&pfdset->fd_mutex);

	return 0;

}

/**

 *  Unregister the fd from the fdset.

 *  Returns context of a given fd or NULL.

 */

void *

fdset_del(struct fdset *pfdset, int fd)

{

	int i;

	void *dat = NULL;

	if (pfdset == NULL || fd == -1)

		return NULL;

	do {

		pthread_mutex_lock(&pfdset->fd_mutex);

		i = fdset_find_fd(pfdset, fd);

		if (i != -1 && pfdset->fd[i].busy == 0) {

			/* busy indicates r/wcb is executing! */

			dat = pfdset->fd[i].dat;

			pfdset->fd[i].fd = -1;

			pfdset->fd[i].rcb = pfdset->fd[i].wcb = NULL;

			pfdset->fd[i].dat = NULL;

			i = -1;

		}

		pthread_mutex_unlock(&pfdset->fd_mutex);

	} while (i != -1);

	return dat;

}

/**

 * This functions runs in infinite blocking loop until there is no fd in

 * pfdset. It calls corresponding r/w handler if there is event on the fd.

 *

 * Before the callback is called, we set the flag to busy status; If other

 * thread(now rte_vhost_driver_unregister) calls fdset_del concurrently, it

 * will wait until the flag is reset to zero(which indicates the callback is

 * finished), then it could free the context after fdset_del.

 */

void *

fdset_event_dispatch(void *arg)

{

	int i;

	struct pollfd *pfd;

	struct fdentry *pfdentry;

	fd_cb rcb, wcb;

	void *dat;

	int fd, numfds;

	int remove1, remove2;

	int need_shrink;

	struct fdset *pfdset = arg;

	if (pfdset == NULL)

		return NULL;

	while (1) {

		/*

		 * When poll is blocked, other threads might unregister

		 * listenfds from and register new listenfds into fdset.

		 * When poll returns, the entries for listenfds in the fdset

		 * might have been updated. It is ok if there is unwanted call

		 * for new listenfds.

		 */

		pthread_mutex_lock(&pfdset->fd_mutex);

		numfds = pfdset->num;

		pthread_mutex_unlock(&pfdset->fd_mutex);

		poll(pfdset->rwfds, numfds, 1000 /* millisecs */);

		need_shrink = 0;

		for (i = 0; i < numfds; i++) {

			pthread_mutex_lock(&pfdset->fd_mutex);

			pfdentry = &pfdset->fd[i];

			fd = pfdentry->fd;

			pfd = &pfdset->rwfds[i];

			if (fd < 0) {

				need_shrink = 1;

				pthread_mutex_unlock(&pfdset->fd_mutex);

				continue;

			}

			if (!pfd->revents) {

				pthread_mutex_unlock(&pfdset->fd_mutex);

				continue;

			}

			remove1 = remove2 = 0;

			rcb = pfdentry->rcb;

			wcb = pfdentry->wcb;

			dat = pfdentry->dat;

			pfdentry->busy = 1;

			pthread_mutex_unlock(&pfdset->fd_mutex);

			if (rcb && pfd->revents & (POLLIN | FDPOLLERR))

				rcb(fd, dat, &remove1);

			if (wcb && pfd->revents & (POLLOUT | FDPOLLERR))

				wcb(fd, dat, &remove2);

			pfdentry->busy = 0;

			/*

			 * fdset_del needs to check busy flag.

			 * We don't allow fdset_del to be called in callback

			 * directly.

			 */

			/*

			 * When we are to clean up the fd from fdset,

			 * because the fd is closed in the cb,

			 * the old fd val could be reused by when creates new

			 * listen fd in another thread, we couldn't call

			 * fd_set_del.

			 */

			if (remove1 || remove2) {

				pfdentry->fd = -1;

				need_shrink = 1;

			}

		}

		if (need_shrink)

			fdset_shrink(pfdset);

	}

	return NULL;

}

/*-

 *   BSD LICENSE

 *

 *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.

 *   All rights reserved.

 *

 *   Redistribution and use in source and binary forms, with or without

 *   modification, are permitted provided that the following conditions

 *   are met:

 *

 *     * Redistributions of source code must retain the above copyright

 *       notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above copyright

 *       notice, this list of conditions and the following disclaimer in

 *       the documentation and/or other materials provided with the

 *       distribution.

 *     * Neither the name of Intel Corporation nor the names of its

 *       contributors may be used to endorse or promote products derived

 *       from this software without specific prior written permission.

 *

 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#ifndef _FD_MAN_H_

#define _FD_MAN_H_

#include <stdint.h>

#include <pthread.h>

#include <poll.h>

#define MAX_FDS 1024

typedef void (*fd_cb)(int fd, void *dat, int *remove);

struct fdentry {

	int fd;		/* -1 indicates this entry is empty */

	fd_cb rcb;	/* callback when this fd is readable. */

	fd_cb wcb;	/* callback when this fd is writeable.*/

	void *dat;	/* fd context */

	int busy;	/* whether this entry is being used in cb. */

};

struct fdset {

	struct pollfd rwfds[MAX_FDS];

	struct fdentry fd[MAX_FDS];

	pthread_mutex_t fd_mutex;

	int num;	/* current fd number of this fdset */

};

void fdset_init(struct fdset *pfdset);

int fdset_add(struct fdset *pfdset, int fd,

	fd_cb rcb, fd_cb wcb, void *dat);

void *fdset_del(struct fdset *pfdset, int fd);

void *fdset_event_dispatch(void *arg);

#endif

/*-

 *   BSD LICENSE

 *

 *   Copyright(c) 2010-2017 Intel Corporation. All rights reserved.

 *   All rights reserved.

 *

 *   Redistribution and use in source and binary forms, with or without

 *   modification, are permitted provided that the following conditions

 *   are met:

 *

 *     * Redistributions of source code must retain the above copyright

 *       notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above copyright

 *       notice, this list of conditions and the following disclaimer in

 *       the documentation and/or other materials provided with the

 *       distribution.

 *     * Neither the name of Intel Corporation nor the names of its

 *       contributors may be used to endorse or promote products derived

 *       from this software without specific prior written permission.

 *

 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#ifndef _RTE_VHOST_H_

#define _RTE_VHOST_H_

/**

 * @file

 * Interface to vhost-user

 */

#include <stdint.h>

#include <linux/vhost.h>

#include <linux/virtio_ring.h>

#include <sys/eventfd.h>

#include <rte_memory.h>

#include <rte_mempool.h>

#define RTE_VHOST_USER_CLIENT		(1ULL << 0)

#define RTE_VHOST_USER_NO_RECONNECT	(1ULL << 1)

#define RTE_VHOST_USER_DEQUEUE_ZERO_COPY	(1ULL << 2)

/**

 * Information relating to memory regions including offsets to

 * addresses in QEMUs memory file.

 */

struct rte_vhost_mem_region {

	uint64_t guest_phys_addr;

	uint64_t guest_user_addr;

	uint64_t host_user_addr;

	uint64_t size;

	void	 *mmap_addr;

	uint64_t mmap_size;

	int fd;

};

/**

 * Memory structure includes region and mapping information.

 */

struct rte_vhost_memory {

	uint32_t nregions;

	struct rte_vhost_mem_region regions[0];

};

struct rte_vhost_vring {

	struct vring_desc	*desc;

	struct vring_avail	*avail;

	struct vring_used	*used;

	uint64_t		log_guest_addr;

	int			callfd;

	int			kickfd;

	uint16_t		size;

};

/**

 * Device and vring operations.

 */

struct vhost_device_ops {

	int (*new_device)(int vid);		/**< Add device. */

	void (*destroy_device)(int vid);	/**< Remove device. */

	int (*vring_state_changed)(int vid, uint16_t queue_id, int enable);	/**< triggered when a vring is enabled or disabled */

	/**

	 * Features could be changed after the feature negotiation.

	 * For example, VHOST_F_LOG_ALL will be set/cleared at the

	 * start/end of live migration, respectively. This callback

	 * is used to inform the application on such change.

	 */

	int (*features_changed)(int vid, uint64_t features);

	void *reserved[4]; /**< Reserved for future extension */

};

/**

 * Convert guest physical address to host virtual address

 *

 * @param mem

 *  the guest memory regions

 * @param gpa

 *  the guest physical address for querying

 * @return

 *  the host virtual address on success, 0 on failure

 */

static inline uint64_t __attribute__((always_inline))

rte_vhost_gpa_to_vva(struct rte_vhost_memory *mem, uint64_t gpa)

{

	struct rte_vhost_mem_region *reg;

	uint32_t i;

	for (i = 0; i < mem->nregions; i++) {

		reg = &mem->regions[i];

		if (gpa >= reg->guest_phys_addr &&

		    gpa <  reg->guest_phys_addr + reg->size) {

			return gpa - reg->guest_phys_addr +

			       reg->host_user_addr;

		}

	}

	return 0;

}

#define RTE_VHOST_NEED_LOG(features)	((features) & (1ULL << VHOST_F_LOG_ALL))

/**

 * Log the memory write start with given address.

 *

 * This function only need be invoked when the live migration starts.

 * Therefore, we won't need call it at all in the most of time. For

 * making the performance impact be minimum, it's suggested to do a

 * check before calling it:

 *

 *        if (unlikely(RTE_VHOST_NEED_LOG(features)))

 *                rte_vhost_log_write(vid, addr, len);

 *

 * @param vid

 *  vhost device ID

 * @param addr

 *  the starting address for write

 * @param len

 *  the length to write

 */

void rte_vhost_log_write(int vid, uint64_t addr, uint64_t len);

/**

 * Log the used ring update start at given offset.

 *

 * Same as rte_vhost_log_write, it's suggested to do a check before

 * calling it:

 *

 *        if (unlikely(RTE_VHOST_NEED_LOG(features)))

 *                rte_vhost_log_used_vring(vid, vring_idx, offset, len);

 *

 * @param vid

 *  vhost device ID

 * @param vring_idx

 *  the vring index

 * @param offset

 *  the offset inside the used ring

 * @param len

 *  the length to write

 */

void rte_vhost_log_used_vring(int vid, uint16_t vring_idx,

			      uint64_t offset, uint64_t len);

int rte_vhost_enable_guest_notification(int vid, uint16_t queue_id, int enable);

/**

 * Register vhost driver. path could be different for multiple

 * instance support.

 */

int rte_vhost_driver_register(const char *path, uint64_t flags);

/* Unregister vhost driver. This is only meaningful to vhost user. */

int rte_vhost_driver_unregister(const char *path);

/**

 * Set the feature bits the vhost-user driver supports.

 *

 * @param path

 *  The vhost-user socket file path

 * @return

 *  0 on success, -1 on failure

 */

int rte_vhost_driver_set_features(const char *path, uint64_t features);

/**

 * Enable vhost-user driver features.

 *

 * Note that

 * - the param @features should be a subset of the feature bits provided

 *   by rte_vhost_driver_set_features().

 * - it must be invoked before vhost-user negotiation starts.

 *

 * @param path

 *  The vhost-user socket file path

 * @param features

 *  Features to enable

 * @return

 *  0 on success, -1 on failure

 */

int rte_vhost_driver_enable_features(const char *path, uint64_t features);

/**

 * Disable vhost-user driver features.

 *

 * The two notes at rte_vhost_driver_enable_features() also apply here.

 *

 * @param path

 *  The vhost-user socket file path

 * @param features

 *  Features to disable

 * @return

 *  0 on success, -1 on failure

 */

int rte_vhost_driver_disable_features(const char *path, uint64_t features);

/**

 * Get the feature bits before feature negotiation.

 *

 * @param path

 *  The vhost-user socket file path

 * @param features

 *  A pointer to store the queried feature bits

 * @return

 *  0 on success, -1 on failure

 */

int rte_vhost_driver_get_features(const char *path, uint64_t *features);

/**

 * Get the feature bits after negotiation

 *

 * @param vid

 *  Vhost device ID

 * @param features

 *  A pointer to store the queried feature bits

 * @return

 *  0 on success, -1 on failure

 */

int rte_vhost_get_negotiated_features(int vid, uint64_t *features);

/* Register callbacks. */

int rte_vhost_driver_callback_register(const char *path,

	struct vhost_device_ops const * const ops);

/**

 *

 * Start the vhost-user driver.

 *

 * This function triggers the vhost-user negotiation.

 *

 * @param path

 *  The vhost-user socket file path

 * @return

 *  0 on success, -1 on failure

 */

int rte_vhost_driver_start(const char *path);

/**

 * Get the MTU value of the device if set in QEMU.

 *

 * @param vid

 *  virtio-net device ID

 * @param mtu

 *  The variable to store the MTU value

 *

 * @return

 *  0: success

 *  -EAGAIN: device not yet started

 *  -ENOTSUP: device does not support MTU feature

 */

int rte_vhost_get_mtu(int vid, uint16_t *mtu);

/**

 * Get the numa node from which the virtio net device's memory

 * is allocated.

 *

 * @param vid

 *  vhost device ID

 *

 * @return

 *  The numa node, -1 on failure

 */

int rte_vhost_get_numa_node(int vid);

/**

 * @deprecated

 * Get the number of queues the device supports.

 *

 * Note this function is deprecated, as it returns a queue pair number,

 * which is vhost specific. Instead, rte_vhost_get_vring_num should

 * be used.

 *

 * @param vid

 *  vhost device ID

 *

 * @return

 *  The number of queues, 0 on failure

 */

__rte_deprecated

uint32_t rte_vhost_get_queue_num(int vid);

/**

 * Get the number of vrings the device supports.

 *

 * @param vid

 *  vhost device ID

 *

 * @return

 *  The number of vrings, 0 on failure

 */

uint16_t rte_vhost_get_vring_num(int vid);

/**

 * Get the virtio net device's ifname, which is the vhost-user socket

 * file path.

 *

 * @param vid

 *  vhost device ID

 * @param buf

 *  The buffer to stored the queried ifname

 * @param len

 *  The length of buf

 *

 * @return

 *  0 on success, -1 on failure

 */

int rte_vhost_get_ifname(int vid, char *buf, size_t len);

/**

 * Get how many avail entries are left in the queue

 *

 * @param vid

 *  vhost device ID

 * @param queue_id

 *  virtio queue index

 *

 * @return

 *  num of avail entires left

 */

uint16_t rte_vhost_avail_entries(int vid, uint16_t queue_id);

struct rte_mbuf;

struct rte_mempool;

/**

 * This function adds buffers to the virtio devices RX virtqueue. Buffers can

 * be received from the physical port or from another virtual device. A packet

 * count is returned to indicate the number of packets that were succesfully

 * added to the RX queue.

 * @param vid

 *  vhost device ID

 * @param queue_id

 *  virtio queue index in mq case

 * @param pkts

 *  array to contain packets to be enqueued

 * @param count

 *  packets num to be enqueued

 * @return

 *  num of packets enqueued

 */

uint16_t rte_vhost_enqueue_burst(int vid, uint16_t queue_id,

	struct rte_mbuf **pkts, uint16_t count);

/**

 * This function gets guest buffers from the virtio device TX virtqueue,

 * construct host mbufs, copies guest buffer content to host mbufs and

 * store them in pkts to be processed.

 * @param vid

 *  vhost device ID

 * @param queue_id

 *  virtio queue index in mq case

 * @param mbuf_pool

 *  mbuf_pool where host mbuf is allocated.

 * @param pkts

 *  array to contain packets to be dequeued

 * @param count

 *  packets num to be dequeued

 * @return

 *  num of packets dequeued

 */

uint16_t rte_vhost_dequeue_burst(int vid, uint16_t queue_id,

	struct rte_mempool *mbuf_pool, struct rte_mbuf **pkts, uint16_t count);

/**

 * Get guest mem table: a list of memory regions.

 *

 * An rte_vhost_vhost_memory object will be allocated internaly, to hold the