vhost: support inflight share memory protocol feature

This patch introduces two new messages VHOST_USER_GET_INFLIGHT_FD
and VHOST_USER_SET_INFLIGHT_FD to support transferring a shared
buffer between qemu and backend.

Firstly, qemu uses VHOST_USER_GET_INFLIGHT_FD to get the
shared buffer from backend. Then qemu should send it back
through VHOST_USER_SET_INFLIGHT_FD each time we start vhost-user.

This shared buffer is used to process inflight I/O when backend
reconnect.

Signed-off-by: lilin <lilin24@baidu.com>
Signed-off-by: Ni Xun <nixun@baidu.com>
Signed-off-by: Zhang Yu <zhangyu31@baidu.com>
Signed-off-by: JinYu <jin.yu@intel.com>
---
 lib/librte_vhost/rte_vhost.h           |  96 ++++++++++
 lib/librte_vhost/rte_vhost_version.map |   4 +
 lib/librte_vhost/vhost.c               |  72 ++++++++
 lib/librte_vhost/vhost.h               |  11 ++
 lib/librte_vhost/vhost_user.c          | 237 +++++++++++++++++++++++++
 lib/librte_vhost/vhost_user.h          |  17 +-
 6 files changed, 434 insertions(+), 3 deletions(-)
  

You need to specify the revision number when using git format-patch.
You can see the 'contributing' section in the documentation for more
information.

On 6/25/19 6:18 PM, JinYu wrote:
> This patch introduces two new messages VHOST_USER_GET_INFLIGHT_FD
> and VHOST_USER_SET_INFLIGHT_FD to support transferring a shared
> buffer between qemu and backend.
> 
> Firstly, qemu uses VHOST_USER_GET_INFLIGHT_FD to get the
> shared buffer from backend. Then qemu should send it back
> through VHOST_USER_SET_INFLIGHT_FD each time we start vhost-user.
> 
> This shared buffer is used to process inflight I/O when backend
> reconnect.
> 
> Signed-off-by: lilin <lilin24@baidu.com>
> Signed-off-by: Ni Xun <nixun@baidu.com>
> Signed-off-by: Zhang Yu <zhangyu31@baidu.com>
> Signed-off-by: JinYu <jin.yu@intel.com>

The correct format for names is Firstname Lastname.

> ---
>   lib/librte_vhost/rte_vhost.h           |  96 ++++++++++
>   lib/librte_vhost/rte_vhost_version.map |   4 +
>   lib/librte_vhost/vhost.c               |  72 ++++++++
>   lib/librte_vhost/vhost.h               |  11 ++
>   lib/librte_vhost/vhost_user.c          | 237 +++++++++++++++++++++++++
>   lib/librte_vhost/vhost_user.h          |  17 +-
>   6 files changed, 434 insertions(+), 3 deletions(-)
> 
> diff --git a/lib/librte_vhost/rte_vhost.h b/lib/librte_vhost/rte_vhost.h
> index 0226b3eff..57cb1abaa 100644
> --- a/lib/librte_vhost/rte_vhost.h
> +++ b/lib/librte_vhost/rte_vhost.h
> @@ -71,6 +71,10 @@ extern "C" {
>   #define VHOST_USER_PROTOCOL_F_HOST_NOTIFIER 11
>   #endif
>   
> +#ifndef VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD
> +#define VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD 12
> +#endif
> +
>   /** Indicate whether protocol features negotiation is supported. */
>   #ifndef VHOST_USER_F_PROTOCOL_FEATURES
>   #define VHOST_USER_F_PROTOCOL_FEATURES	30
> @@ -98,12 +102,53 @@ struct rte_vhost_memory {
>   	struct rte_vhost_mem_region regions[];
>   };
>   
> +typedef struct VhostUserInflightEntry {
> +	/* Indicate whether this descriptor is inflight or not.
> +    	 * Only available for head-descriptor. */
> +	uint8_t		inflight;
> +
> +	uint8_t		padding[5];
> +
> +	/* Maintain a list for the last batch of used descriptors.
> +    	 * Only available when batching is used for submitting */
> +	uint16_t	next;
> +
> +	/* Used to preserve the order of fetching available descriptors.
> +     	 * Only available for head-descriptor. */
> +	uint64_t	counter;
> +} VhostUserInflightEntry;
> +
> +typedef struct VhostInflightInfo {
> +	/* The feature flags of this region. Now it's initialized to 0. */
> +	uint64_t		feature;
> +
> +	/* The version of this region. It's 1 currently.
> +    	 * Zero value indicates an uninitialized buffer */
> +	uint16_t 		version;
> +
> +	/* The size of DescStateSplit array. It's equal to the virtqueue
> +     	 * size. Slave could get it from queue size field of VhostUserInflight. */
> +	uint16_t		desc_num;
> +
> +	/* The head of list that track the last batch of used descriptors. */
> +	uint16_t		last_batch_head;
> +
> +	/* Store the idx value of used ring */
> +	uint16_t 		used_idx;
> +
> +	/* Used to track the state of each descriptor in descriptor table */
> +	VhostUserInflightEntry	desc[0];
> +} VhostInflightInfo;
> +
>   struct rte_vhost_vring {
>   	struct vring_desc	*desc;
>   	struct vring_avail	*avail;
>   	struct vring_used	*used;
>   	uint64_t		log_guest_addr;
>   
> +	VhostInflightInfo       *inflight;
> +	int                	inflight_flag;
> +
>   	/** Deprecated, use rte_vhost_vring_call() instead. */
>   	int			callfd;
>   
> @@ -603,6 +648,22 @@ uint16_t rte_vhost_dequeue_burst(int vid, uint16_t queue_id,
>    */
>   int rte_vhost_get_mem_table(int vid, struct rte_vhost_memory **mem);
>   
> +/**
> + * Get guest vring info including the vring address, vring size, inflight, etc.
> + *
> + * @param vid
> + *  vhost device ID
> + * @param vring_idx
> + *  vring index
> + * @param vring
> + *  the structure to hold the requested vring info
> + * @return
> + *  0 on success, -1 on failure
> + */
> +int __rte_experimental
> +rte_vhost_get_vhost_vring_with_inflight(int vid, uint16_t vring_idx,
> +				struct rte_vhost_vring *vring);
> +
>   /**
>    * Get guest vring info, including the vring address, vring size, etc.
>    *
> @@ -631,6 +692,41 @@ int rte_vhost_get_vhost_vring(int vid, uint16_t vring_idx,
>    */
>   int rte_vhost_vring_call(int vid, uint16_t vring_idx);
>   
> +/**
> + * set inflight flag for a entry.
> + *
> + * @param vring
> + *  the structure to hold the requested vring info
> + * @param idx
> + *  inflight entry index
> + */
> +void __rte_experimental rte_vhost_set_inflight(struct rte_vhost_vring *vring,
> +		uint16_t idx);

You didn't took comments made on previous revision into account.

> +
> +/**
> + * clear inflight flag for a entry.
> + *
> + * @param vring
> + *  the structure to hold the requested vring info
> + * @param last_used_idx
> + *  next free used_idx
> + * @param idx
> + *  inflight entry index
> + */
> +void __rte_experimental rte_vhost_clr_inflight(struct rte_vhost_vring *vring,
> +		uint16_t last_used_idx, uint16_t idx);
> +
> +/**
> + * set last inflight io index.
> + *
> + * @param vring
> + *  the structure to hold the requested vring info
> + * @param idx
> + *  inflight entry index
> + */
> +void __rte_experimental rte_vhost_set_last_inflight_io(struct rte_vhost_vring *vring,
> +		uint16_t idx);
> +
>   /**
>    * Get vhost RX queue avail count.
>    *
> diff --git a/lib/librte_vhost/rte_vhost_version.map b/lib/librte_vhost/rte_vhost_version.map
> index 5f1d4a75c..bea1e9ab6 100644
> --- a/lib/librte_vhost/rte_vhost_version.map
> +++ b/lib/librte_vhost/rte_vhost_version.map
> @@ -87,4 +87,8 @@ EXPERIMENTAL {
>   	rte_vdpa_relay_vring_used;
>   	rte_vhost_extern_callback_register;
>   	rte_vhost_driver_set_protocol_features;
> +	rte_vhost_set_inflight;
> +	rte_vhost_clr_inflight;
> +	rte_vhost_set_last_inflight_io;
> +	rte_vhost_get_vhost_with_inflight;
>   };
> diff --git a/lib/librte_vhost/vhost.c b/lib/librte_vhost/vhost.c
> index 981837b5d..a2604a5d4 100644
> --- a/lib/librte_vhost/vhost.c
> +++ b/lib/librte_vhost/vhost.c
> @@ -240,6 +240,8 @@ cleanup_vq(struct vhost_virtqueue *vq, int destroy)
>   		close(vq->callfd);
>   	if (vq->kickfd >= 0)
>   		close(vq->kickfd);
> +	if (vq->inflight)
> +		vq->inflight = NULL;
>   }
>   
>   /*
> @@ -726,6 +728,41 @@ rte_vhost_get_mem_table(int vid, struct rte_vhost_memory **mem)
>   	return 0;
>   }
>   
> +int __rte_experimental
> +rte_vhost_get_vhost_vring_with_inflight(int vid, uint16_t vring_idx,
> +			  struct rte_vhost_vring *vring)
> +{
> +	struct virtio_net *dev;
> +	struct vhost_virtqueue *vq;
> +
> +	dev = get_device(vid);
> +	if (dev == NULL || vring == NULL)
> +		return -1;
> +
> +	if (vring_idx >= VHOST_MAX_VRING)
> +		return -1;
> +
> +	vq = dev->virtqueue[vring_idx];
> +	if (!vq)
> +		return -1;
> +
> +	vring->desc  = vq->desc;
> +	vring->avail = vq->avail;
> +	vring->used  = vq->used;
> +	vring->log_guest_addr  = vq->log_guest_addr;
> +
> +	vring->callfd  = vq->callfd;
> +	vring->kickfd  = vq->kickfd;
> +	vring->size    = vq->size;
> +
> +	vring->inflight = vq->inflight;
> +
> +	vring->inflight_flag = vq->inflight_flag;
> +	vq->inflight_flag = 0;
> +
> +	return 0;
> +}
> +
>   int
>   rte_vhost_get_vhost_vring(int vid, uint16_t vring_idx,
>   			  struct rte_vhost_vring *vring)
> @@ -781,6 +818,41 @@ rte_vhost_vring_call(int vid, uint16_t vring_idx)
>   	return 0;
>   }
>   
> +void __rte_experimental
> +rte_vhost_set_inflight(struct rte_vhost_vring *vring, uint16_t idx)
> +{
> +	VhostInflightInfo *inflight = vring->inflight;
> +	if (unlikely(!inflight))
> +		return;
> +	inflight->desc[idx].inflight = 1;
> +}
> +
> +void __rte_experimental
> +rte_vhost_clr_inflight(struct rte_vhost_vring *vring,
> +	uint16_t last_used_idx, uint16_t idx)
> +{
> +	VhostInflightInfo *inflight = vring->inflight;
> +
> +	if (unlikely(!inflight))
> +		return;
> +
> +	rte_compiler_barrier();
> +	inflight->desc[idx].inflight = 0;
> +	rte_compiler_barrier();
> +	inflight->used_idx = last_used_idx;
> +}
> +
> +void __rte_experimental
> +rte_vhost_set_last_inflight_io(struct rte_vhost_vring *vring, uint16_t idx)
> +{
> +	VhostInflightInfo *inflight = vring->inflight;
> +
> +	if (unlikely(!inflight))
> +		return;
> +
> +	inflight->last_batch_head = idx;
> +}
> +
>   uint16_t
>   rte_vhost_avail_entries(int vid, uint16_t queue_id)
>   {
> diff --git a/lib/librte_vhost/vhost.h b/lib/librte_vhost/vhost.h
> index 884befa85..c4790f1ce 100644
> --- a/lib/librte_vhost/vhost.h
> +++ b/lib/librte_vhost/vhost.h
> @@ -128,6 +128,10 @@ struct vhost_virtqueue {
>   	/* Physical address of used ring, for logging */
>   	uint64_t		log_guest_addr;
>   
> +	/* Inflight share memory info */
> +	VhostInflightInfo       *inflight;
> +	bool                	inflight_flag;
> +
>   	uint16_t		nr_zmbuf;
>   	uint16_t		zmbuf_size;
>   	uint16_t		last_zmbuf_idx;
> @@ -286,6 +290,12 @@ struct guest_page {
>   	uint64_t size;
>   };
>   
> +typedef struct VuDevInflightInfo {
> +	int 		fd;
> +	void 		*addr;
> +	uint64_t 	size;
> +} VuDevInflightInfo;
> +
>   /**
>    * Device structure contains all configuration information relating
>    * to the device.
> @@ -303,6 +313,7 @@ struct virtio_net {
>   	uint32_t		nr_vring;
>   	int			dequeue_zero_copy;
>   	struct vhost_virtqueue	*virtqueue[VHOST_MAX_QUEUE_PAIRS * 2];
> +	VuDevInflightInfo 	inflight_info;
>   #define IF_NAME_SZ (PATH_MAX > IFNAMSIZ ? PATH_MAX : IFNAMSIZ)
>   	char			ifname[IF_NAME_SZ];
>   	uint64_t		log_size;
> diff --git a/lib/librte_vhost/vhost_user.c b/lib/librte_vhost/vhost_user.c
> index c9e29ece8..d7293250d 100644
> --- a/lib/librte_vhost/vhost_user.c
> +++ b/lib/librte_vhost/vhost_user.c
> @@ -31,6 +31,8 @@
>   #include <sys/stat.h>
>   #include <sys/syscall.h>
>   #include <assert.h>
> +#include <sys/syscall.h>
> +#include <asm/unistd.h>
>   #ifdef RTE_LIBRTE_VHOST_NUMA
>   #include <numaif.h>
>   #endif
> @@ -49,6 +51,14 @@
>   #define VIRTIO_MIN_MTU 68
>   #define VIRTIO_MAX_MTU 65535
>   
> +#define INFLIGHT_ALIGNMENT 64
> +#define INFLIGHT_VERSION 0xabcd
> +
> +#define CLOEXEC 0x0001U
> +
> +#define ALIGN_DOWN(n, m) ((n) / (m) * (m))
> +#define ALIGN_UP(n, m) ALIGN_DOWN((n) + (m) - 1, (m))
> +
>   static const char *vhost_message_str[VHOST_USER_MAX] = {
>   	[VHOST_USER_NONE] = "VHOST_USER_NONE",
>   	[VHOST_USER_GET_FEATURES] = "VHOST_USER_GET_FEATURES",
> @@ -78,6 +88,8 @@ static const char *vhost_message_str[VHOST_USER_MAX] = {
>   	[VHOST_USER_POSTCOPY_ADVISE]  = "VHOST_USER_POSTCOPY_ADVISE",
>   	[VHOST_USER_POSTCOPY_LISTEN]  = "VHOST_USER_POSTCOPY_LISTEN",
>   	[VHOST_USER_POSTCOPY_END]  = "VHOST_USER_POSTCOPY_END",
> +	[VHOST_USER_GET_INFLIGHT_FD] = "VHOST_USER_GET_INFLIGHT_FD",
> +	[VHOST_USER_SET_INFLIGHT_FD] = "VHOST_USER_SET_INFLIGHT_FD",
>   };
>   
>   static int send_vhost_reply(int sockfd, struct VhostUserMsg *msg);
> @@ -160,6 +172,16 @@ vhost_backend_cleanup(struct virtio_net *dev)
>   		dev->log_addr = 0;
>   	}
>   
> +	if (dev->inflight_info.addr) {
> +		munmap(dev->inflight_info.addr, dev->inflight_info.size);
> +		dev->inflight_info.addr = NULL;
> +	}
> +
> +	if (dev->inflight_info.fd > 0) {
> +		close(dev->inflight_info.fd);
> +		dev->inflight_info.fd = -1;
> +	}
> +
>   	if (dev->slave_req_fd >= 0) {
>   		close(dev->slave_req_fd);
>   		dev->slave_req_fd = -1;
> @@ -1165,6 +1187,184 @@ virtio_is_ready(struct virtio_net *dev)
>   	return 1;
>   }
>   
> +static int mem_create(const char *name, unsigned int flags)
> +{
> +#ifdef __NR_memfd_create
> +	return syscall(__NR_memfd_create, name, flags);
> +#else
> +	return -1;
> +#endif
> +}
> +
> +void *inflight_mem_alloc(const char *name, size_t size, int *fd)
> +{
> +	void *ptr;
> +	int mfd = -1;
> +	char fname[20] = "/tmp/memfd-XXXXXX";
> +
> +	*fd = -1;
> +	mfd = mem_create(name, CLOEXEC);
> +	if (mfd != -1) {
> +		if (ftruncate(mfd, size) == -1) {
> +			RTE_LOG(ERR, VHOST_CONFIG,
> +					"ftruncate fail for alloc inflight buffer\n");
> +			close(mfd);
> +			return NULL;
> +		}
> +	} else {
> +		mfd = mkstemp(fname);
> +		unlink(fname);
> +
> +		if (mfd == -1) {
> +			RTE_LOG(ERR, VHOST_CONFIG,
> +					"mkstemp fail for alloc inflight buffer\n");
> +			return NULL;
> +		}
> +
> +		if (ftruncate(mfd, size) == -1) {
> +			RTE_LOG(ERR, VHOST_CONFIG,
> +					"ftruncate fail for alloc inflight buffer\n");
> +			close(mfd);
> +			return NULL;
> +		}
> +	}
> +
> +	ptr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, mfd, 0);
> +	if (ptr == MAP_FAILED) {
> +		RTE_LOG(ERR, VHOST_CONFIG,
> +				"mmap fail for alloc inflight buffer\n");
> +		close(mfd);
> +		return NULL;
> +	}
> +
> +	*fd = mfd;
> +	return ptr;
> +}
> +
> +static uint32_t get_pervq_shm_size(uint16_t queue_size)
> +{
> +	return ALIGN_UP(sizeof(VhostUserInflightEntry) * queue_size +
> +		sizeof(uint16_t) * 4 + sizeof(uint64_t), INFLIGHT_ALIGNMENT);
> +}
> +
> +static int
> +vhost_user_get_inflight_fd(struct virtio_net **pdev, VhostUserMsg *msg,
> +		int main_fd __rte_unused)
> +{
> +	int fd;
> +	uint64_t mmap_size;
> +	void *addr;
> +	uint16_t num_queues, queue_size;
> +	struct virtio_net *dev = *pdev;
> +
> +	if (msg->size != sizeof(msg->payload.inflight)) {
> +		RTE_LOG(ERR, VHOST_CONFIG,
> +			"Invalid get_inflight_fd message size is %d",
> +			msg->size);
> +		msg->payload.inflight.mmap_size = 0;
> +		return RTE_VHOST_MSG_RESULT_OK;
> +	}
> +
> +	num_queues = msg->payload.inflight.num_queues;
> +	queue_size = msg->payload.inflight.queue_size;
> +
> +	RTE_LOG(INFO, VHOST_CONFIG, "get_inflight_fd num_queues: %u\n",
> +			msg->payload.inflight.num_queues);
> +	RTE_LOG(INFO, VHOST_CONFIG, "get_inflight_fd queue_size: %u\n",
> +			msg->payload.inflight.queue_size);
> +	mmap_size = num_queues * get_pervq_shm_size(queue_size);
> +
> +	addr = inflight_mem_alloc("vhost-inflight", mmap_size, &fd);
> +	if (!addr) {
> +		RTE_LOG(ERR, VHOST_CONFIG, "Failed to alloc vhost inflight area");
> +			msg->payload.inflight.mmap_size = 0;
> +		return RTE_VHOST_MSG_RESULT_OK;
> +	}
> +	memset(addr, 0, mmap_size);
> +
> +	dev->inflight_info.addr = addr;
> +	dev->inflight_info.size = msg->payload.inflight.mmap_size = mmap_size;
> +	dev->inflight_info.fd = msg->fds[0] = fd;
> +	msg->payload.inflight.mmap_offset = 0;
> +	msg->fd_num = 1;
> +
> +	RTE_LOG(INFO, VHOST_CONFIG,
> +			"send inflight mmap_size: %lu\n",
> +			msg->payload.inflight.mmap_size);
> +	RTE_LOG(INFO, VHOST_CONFIG,
> +			"send inflight mmap_offset: %lu\n",
> +			msg->payload.inflight.mmap_offset);
> +	RTE_LOG(INFO, VHOST_CONFIG,
> +			"send inflight fd: %d\n", msg->fds[0]);
> +
> +	return RTE_VHOST_MSG_RESULT_REPLY;
> +}
> +
> +static int
> +vhost_user_set_inflight_fd(struct virtio_net **pdev, VhostUserMsg *msg,
> +		int main_fd __rte_unused)
> +{
> +	int fd, i;
> +	uint64_t mmap_size, mmap_offset;
> +	uint16_t num_queues, queue_size;
> +	uint32_t pervq_inflight_size;
> +	void *addr;
> +	struct vhost_virtqueue *vq;
> +	struct virtio_net *dev = *pdev;
> +
> +	fd = msg->fds[0];
> +	if (msg->size != sizeof(msg->payload.inflight) || fd < 0) {
> +		RTE_LOG(ERR, VHOST_CONFIG, "Invalid set_inflight_fd message size is %d,fd is %d\n",
> +			msg->size, fd);
> +		return RTE_VHOST_MSG_RESULT_ERR;
> +	}
> +
> +	mmap_size = msg->payload.inflight.mmap_size;
> +	mmap_offset = msg->payload.inflight.mmap_offset;
> +	num_queues = msg->payload.inflight.num_queues;
> +	queue_size = msg->payload.inflight.queue_size;
> +	pervq_inflight_size = get_pervq_shm_size(queue_size);
> +
> +	RTE_LOG(INFO, VHOST_CONFIG,
> +		"set_inflight_fd mmap_size: %lu\n", mmap_size);
> +	RTE_LOG(INFO, VHOST_CONFIG,
> +		"set_inflight_fd mmap_offset: %lu\n", mmap_offset);
> +	RTE_LOG(INFO, VHOST_CONFIG,
> +		"set_inflight_fd num_queues: %u\n", num_queues);
> +	RTE_LOG(INFO, VHOST_CONFIG,
> +		"set_inflight_fd queue_size: %u\n", queue_size);
> +	RTE_LOG(INFO, VHOST_CONFIG,
> +		"set_inflight_fd fd: %d\n", fd);
> +	RTE_LOG(INFO, VHOST_CONFIG,
> +		"set_inflight_fd pervq_inflight_size: %d\n",
> +		pervq_inflight_size);
> +
> +	if (dev->inflight_info.addr)
> +		munmap(dev->inflight_info.addr, dev->inflight_info.size);
> +
> +	addr = mmap(0, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED,
> +			fd, mmap_offset);
> +	if (addr == MAP_FAILED) {
> +		RTE_LOG(ERR, VHOST_CONFIG, "failed to mmap share memory.\n");
> +		return RTE_VHOST_MSG_RESULT_ERR;
> +	}
> +
> +	if (dev->inflight_info.fd)
> +		close(dev->inflight_info.fd);
> +
> +	dev->inflight_info.fd = fd;
> +	dev->inflight_info.addr = addr;
> +	dev->inflight_info.size = mmap_size;
> +
> +	for (i = 0; i < num_queues; i++) {
> +		vq = dev->virtqueue[i];
> +		vq->inflight = (VhostInflightInfo *)addr;
> +		addr = (void *)((char *)addr + pervq_inflight_size);
> +	}
> +
> +	return RTE_VHOST_MSG_RESULT_OK;
> +}
> +
>   static int
>   vhost_user_set_vring_call(struct virtio_net **pdev, struct VhostUserMsg *msg,
>   			int main_fd __rte_unused)
> @@ -1201,6 +1401,35 @@ static int vhost_user_set_vring_err(struct virtio_net **pdev __rte_unused,
>   	return RTE_VHOST_MSG_RESULT_OK;
>   }
>   
> +static int
> +vhost_check_queue_inflights(struct virtio_net *dev, struct vhost_virtqueue *vq)
> +{
> +	uint16_t i = 0;
> +
> +	if (!(dev->protocol_features & VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD))
> +		return RTE_VHOST_MSG_RESULT_OK;
> +
> +	if ((!vq->inflight))
> +		return RTE_VHOST_MSG_RESULT_ERR;
> +
> +	/* TODO */
> +	/* should check whether the feature is negotiated first. */

Why not just do the feature check now?

> +
> +	if (!vq->inflight->version) {
> +		vq->inflight->version = INFLIGHT_VERSION;
> +		return RTE_VHOST_MSG_RESULT_OK;
> +	}
> +
> +	for (i = 0; i < vq->size; i++) {
> +		if (vq->inflight->desc[i].inflight == 1) {
> +			vq->inflight_flag = 1;
> +			break;
> +		}
> +	}
> +
> +	return RTE_VHOST_MSG_RESULT_OK;
> +}
> +
>   static int
>   vhost_user_set_vring_kick(struct virtio_net **pdev, struct VhostUserMsg *msg,
>   			int main_fd __rte_unused)
> @@ -1242,6 +1471,12 @@ vhost_user_set_vring_kick(struct virtio_net **pdev, struct VhostUserMsg *msg,
>   		close(vq->kickfd);
>   	vq->kickfd = file.fd;
>   
> +	if (vhost_check_queue_inflights(dev, vq)) {
> +		RTE_LOG(ERR, VHOST_CONFIG,
> +			"Failed to inflights for vq: %d\n", file.index);
> +		return RTE_VHOST_MSG_RESULT_ERR;
> +	}
> +
>   	return RTE_VHOST_MSG_RESULT_OK;
>   }
>   
> @@ -1762,6 +1997,8 @@ static vhost_message_handler_t vhost_message_handlers[VHOST_USER_MAX] = {
>   	[VHOST_USER_POSTCOPY_ADVISE] = vhost_user_set_postcopy_advise,
>   	[VHOST_USER_POSTCOPY_LISTEN] = vhost_user_set_postcopy_listen,
>   	[VHOST_USER_POSTCOPY_END] = vhost_user_postcopy_end,
> +	[VHOST_USER_GET_INFLIGHT_FD] = vhost_user_get_inflight_fd,
> +	[VHOST_USER_SET_INFLIGHT_FD] = vhost_user_set_inflight_fd,
>   };
>   
>   
> diff --git a/lib/librte_vhost/vhost_user.h b/lib/librte_vhost/vhost_user.h
> index 2a650fe4b..837ee6c5d 100644
> --- a/lib/librte_vhost/vhost_user.h
> +++ b/lib/librte_vhost/vhost_user.h
> @@ -22,8 +22,8 @@
>   					 (1ULL << VHOST_USER_PROTOCOL_F_SLAVE_REQ) | \
>   					 (1ULL << VHOST_USER_PROTOCOL_F_CRYPTO_SESSION) | \
>   					 (1ULL << VHOST_USER_PROTOCOL_F_SLAVE_SEND_FD) | \
> -					 (1ULL << VHOST_USER_PROTOCOL_F_HOST_NOTIFIER) | \
> -					 (1ULL << VHOST_USER_PROTOCOL_F_PAGEFAULT))
> +					 (1ULL << VHOST_USER_PROTOCOL_F_HOST_NOTIFIER))
> +	
>   
>   typedef enum VhostUserRequest {
>   	VHOST_USER_NONE = 0,
> @@ -54,7 +54,9 @@ typedef enum VhostUserRequest {
>   	VHOST_USER_POSTCOPY_ADVISE = 28,
>   	VHOST_USER_POSTCOPY_LISTEN = 29,
>   	VHOST_USER_POSTCOPY_END = 30,
> -	VHOST_USER_MAX = 31
> +	VHOST_USER_GET_INFLIGHT_FD = 31,
> +	VHOST_USER_SET_INFLIGHT_FD = 32,
> +	VHOST_USER_MAX = 33
>   } VhostUserRequest;
>   
>   typedef enum VhostUserSlaveRequest {
> @@ -112,6 +114,13 @@ typedef struct VhostUserVringArea {
>   	uint64_t offset;
>   } VhostUserVringArea;
>   
> +typedef struct VhostUserInflight {
> +	uint64_t mmap_size;
> +	uint64_t mmap_offset;
> +	uint16_t num_queues;
> +	uint16_t queue_size;
> +} VhostUserInflight;
> +
>   typedef struct VhostUserMsg {
>   	union {
>   		uint32_t master; /* a VhostUserRequest value */
> @@ -131,6 +140,7 @@ typedef struct VhostUserMsg {
>   		struct vhost_vring_addr addr;
>   		VhostUserMemory memory;
>   		VhostUserLog    log;
> +		VhostUserInflight inflight;
>   		struct vhost_iotlb_msg iotlb;
>   		VhostUserCryptoSessionParam crypto_session;
>   		VhostUserVringArea area;
> @@ -148,6 +158,7 @@ typedef struct VhostUserMsg {
>   /* vhost_user.c */
>   int vhost_user_msg_handler(int vid, int fd);
>   int vhost_user_iotlb_miss(struct virtio_net *dev, uint64_t iova, uint8_t perm);
> +void *inflight_mem_alloc(const char *name, size_t size, int *fd);
>   
>   /* socket.c */
>   int read_fd_message(int sockfd, char *buf, int buflen, int *fds, int max_fds,
>