[dpdk-dev] [RFC PATCH 7/7] lib/librte_vhost: Add vhost-user implementation

[Tetsuya Mukawa <mukawa@igel.co.jp>]

This patch adds vhost-user implementation to librte_vhost.
To communicate with vhost-user of QEMU, speficy VHOST_DRV_USER as
a vhost_driver_type_t variable in rte_vhost_driver_register().

Signed-off-by: Tetsuya Mukawa <mukawa@igel.co.jp>
---
 lib/librte_vhost/rte_virtio_net.h  |  19 +-
 lib/librte_vhost/vhost-net-user.c  | 541 +++++++++++++++++++++++++++++++++++++
 lib/librte_vhost/vhost-net.c       |  39 ++-
 lib/librte_vhost/vhost-net.h       |   7 +
 lib/librte_vhost/virtio-net-user.c | 410 ++++++++++++++++++++++++++++
 lib/librte_vhost/virtio-net.c      |  64 ++++-
 6 files changed, 1073 insertions(+), 7 deletions(-)
 create mode 100644 lib/librte_vhost/vhost-net-user.c
 create mode 100644 lib/librte_vhost/virtio-net-user.c

diff --git a/lib/librte_vhost/rte_virtio_net.h b/lib/librte_vhost/rte_virtio_net.h
index a9e20ea..af07900 100644
--- a/lib/librte_vhost/rte_virtio_net.h
+++ b/lib/librte_vhost/rte_virtio_net.h
@@ -75,17 +75,32 @@ struct buf_vector {
  */
 typedef enum {
 	VHOST_DRV_CUSE, /* cuse driver */
+	VHOST_DRV_USER, /* vhost-user driver */
 	VHOST_DRV_NUM	/* the number of vhost driver types */
 } vhost_driver_type_t;
 
+
+/**
+ * Structure contains vhost-user session specific information
+ */
+struct vhost_user_session {
+	int		fh;		/**< session identifier */
+	pthread_t	tid;		/**< thread id of session handler */
+	int		socketfd;	/**< fd of socket */
+	int		interval;	/**< reconnection interval of session */
+};
+
 /**
  * Structure contains information relating vhost driver.
  */
 struct vhost_driver {
 	vhost_driver_type_t	type;		/**< driver type. */
 	const char		*dev_name;	/**< accessing device name. */
+	void			*priv;		/**< private data. */
 	union {
 		struct fuse_session *cuse_session;	/**< fuse session. */
+		struct vhost_user_session *user_session;
+						/**< vhost-user session. */
 	};
 };
 
@@ -199,9 +214,11 @@ struct vhost_driver *rte_vhost_driver_register(
 		const char *dev_name, vhost_driver_type_t type);
 
 /* Register callbacks. */
-int rte_vhost_driver_callback_register(struct virtio_net_device_ops const * const);
+int rte_vhost_driver_callback_register(struct vhost_driver *drv,
+			struct virtio_net_device_ops const * const, void *priv);
 /* Start vhost driver session blocking loop. */
 int rte_vhost_driver_session_start(struct vhost_driver *drv);
+void rte_vhost_driver_session_stop(struct vhost_driver *drv);
 
 /**
  * This function adds buffers to the virtio devices RX virtqueue. Buffers can
diff --git a/lib/librte_vhost/vhost-net-user.c b/lib/librte_vhost/vhost-net-user.c
new file mode 100644
index 0000000..434f20f
--- /dev/null
+++ b/lib/librte_vhost/vhost-net-user.c
@@ -0,0 +1,541 @@
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright (c) 2014 IGEL Co/.Ltd.
+ *   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 IGEL 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 <sys/types.h>
+#include <sys/socket.h>
+#include <linux/un.h>
+
+#define VHOST_USER_MAX_DEVICE		(32)
+#define VHOST_USER_MAX_FD_NUM		(3)
+
+/* start id of vhost user device */
+rte_atomic16_t vhost_user_device_id;
+
+static struct vhost_net_device_ops const *ops;
+
+typedef enum VhostUserRequest {
+	VHOST_USER_NONE = 0,
+	VHOST_USER_GET_FEATURES = 1,
+	VHOST_USER_SET_FEATURES = 2,
+	VHOST_USER_SET_OWNER = 3,
+	VHOST_USER_RESET_OWNER = 4,
+	VHOST_USER_SET_MEM_TABLE = 5,
+	VHOST_USER_SET_LOG_BASE = 6,
+	VHOST_USER_SET_LOG_FD = 7,
+	VHOST_USER_SET_VRING_NUM = 8,
+	VHOST_USER_SET_VRING_ADDR = 9,
+	VHOST_USER_SET_VRING_BASE = 10,
+	VHOST_USER_GET_VRING_BASE = 11,
+	VHOST_USER_SET_VRING_KICK = 12,
+	VHOST_USER_SET_VRING_CALL = 13,
+	VHOST_USER_SET_VRING_ERR = 14,
+	VHOST_USER_MAX
+} VhostUserRequest;
+
+#define VHOST_MEMORY_MAX_NREGIONS	8
+
+typedef struct VhostUserMemoryRegion {
+	uint64_t guest_phys_addr;
+	uint64_t memory_size;
+	uint64_t userspace_addr;
+	uint64_t mmap_offset;
+} VhostUserMemoryRegion;
+
+typedef struct VhostUserMemory {
+	uint32_t nregions;
+	uint32_t padding;
+	VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS];
+} VhostUserMemory;
+
+typedef struct VhostUserMsg {
+	VhostUserRequest request;
+
+#define VHOST_USER_VERSION_MASK		(0x3)
+#define VHOST_USER_REPLY_MASK		(0x1<<2)
+	uint32_t flags;
+	uint32_t size; /* the following payload size */
+	union {
+#define VHOST_USER_VRING_IDX_MASK	(0xff)
+#define VHOST_USER_VRING_NOFD_MASK	(0x1<<8)
+		uint64_t u64;
+		struct vhost_vring_state state;
+		struct vhost_vring_addr addr;
+		VhostUserMemory memory;
+	};
+} __attribute__((packed)) VhostUserMsg;
+
+static VhostUserMsg m __attribute__ ((unused));
+#define VHOST_USER_HDR_SIZE	(sizeof(m.request) \
+		+ sizeof(m.flags) + sizeof(m.size))
+
+/* The version of the protocol we support */
+#define VHOST_USER_VERSION		(0x1)
+
+static unsigned long int ioctl_to_vhost_user_request[VHOST_USER_MAX] = {
+	-1,			/* VHOST_USER_NONE */
+	VHOST_GET_FEATURES,	/* VHOST_USER_GET_FEATURES */
+	VHOST_SET_FEATURES,	/* VHOST_USER_SET_FEATURES */
+	VHOST_SET_OWNER,	/* VHOST_USER_SET_OWNER */
+	VHOST_RESET_OWNER,	/* VHOST_USER_RESET_OWNER */
+	VHOST_SET_MEM_TABLE,	/* VHOST_USER_SET_MEM_TABLE */
+	VHOST_SET_LOG_BASE,	/* VHOST_USER_SET_LOG_BASE */
+	VHOST_SET_LOG_FD,	/* VHOST_USER_SET_LOG_FD */
+	VHOST_SET_VRING_NUM,	/* VHOST_USER_SET_VRING_NUM */
+	VHOST_SET_VRING_ADDR,	/* VHOST_USER_SET_VRING_ADDR */
+	VHOST_SET_VRING_BASE,	/* VHOST_USER_SET_VRING_BASE */
+	VHOST_GET_VRING_BASE,	/* VHOST_USER_GET_VRING_BASE */
+	VHOST_SET_VRING_KICK,	/* VHOST_USER_SET_VRING_KICK */
+	VHOST_SET_VRING_CALL,	/* VHOST_USER_SET_VRING_CALL */
+	VHOST_SET_VRING_ERR	/* VHOST_USER_SET_VRING_ERR */
+};
+
+/**
+ * Returns vhost_device_ctx from given fuse_req_t. The index is populated later when
+ * the device is added to the device linked list.
+ */
+static struct vhost_device_ctx
+vhost_driver_to_vhost_ctx(struct vhost_driver *drv)
+{
+	struct vhost_device_ctx ctx;
+	int device_id = drv->user_session->fh;
+
+	ctx.type = VHOST_DRV_USER;
+	ctx.fh = device_id;
+	ctx.user.drv = drv;
+
+	return ctx;
+}
+
+/**
+ * When the device is created in QEMU it gets initialised here and added to the device linked list.
+ */
+static int
+vhost_user_open(struct vhost_driver *drv)
+{
+	struct vhost_device_ctx ctx = vhost_driver_to_vhost_ctx(drv);
+
+	int ret;
+
+	ret = ops->new_device(ctx);
+	if (ret == -1)
+		return -1;
+
+	RTE_LOG(INFO, VHOST_CONFIG, "(%"PRIu64") Device configuration started\n", ctx.fh);
+
+	return 0;
+}
+
+/**
+ * When QEMU is shutdown or killed the device gets released.
+ */
+static void
+vhost_user_release(struct vhost_driver *drv)
+{
+	struct vhost_device_ctx ctx = vhost_driver_to_vhost_ctx(drv);
+
+	ops->destroy_device(ctx);
+	RTE_LOG(INFO, VHOST_CONFIG, "(%"PRIu64") Device released\n", ctx.fh);
+}
+
+/**
+ * Send data to vhost-user device on a QEMU.
+ */
+static int
+vhost_user_write(struct vhost_driver *drv, VhostUserMsg *msg,
+		int *fds, size_t fd_num)
+{
+	int fd, len;
+	size_t fd_size = fd_num * sizeof(int);
+	char control[CMSG_SPACE(fd_size)];
+	struct msghdr msg_header;
+	struct iovec iov[1];
+	struct cmsghdr *cmsg_header;
+	struct vhost_device_ctx ctx = vhost_driver_to_vhost_ctx(drv);
+
+	if ((drv == NULL) || (msg == NULL))
+		return -EINVAL;
+
+	fd = drv->user_session->socketfd;
+
+	memset(&msg_header, 0, sizeof(msg_header));
+	memset(control, 0, sizeof(control));
+
+	/* set the payload */
+	iov[0].iov_base = (void *)msg;
+	iov[0].iov_len = VHOST_USER_HDR_SIZE + msg->size;
+
+	msg_header.msg_iov = iov;
+	msg_header.msg_iovlen = 1;
+
+	if (fd_num) {
+		msg_header.msg_control = control;
+		msg_header.msg_controllen = sizeof(control);
+		cmsg_header = CMSG_FIRSTHDR(&msg_header);
+		cmsg_header->cmsg_len = CMSG_LEN(fd_size);
+		cmsg_header->cmsg_level = SOL_SOCKET;
+		cmsg_header->cmsg_type = SCM_RIGHTS;
+		memcpy(CMSG_DATA(cmsg_header), fds, fd_size);
+	} else {
+		msg_header.msg_control = 0;
+		msg_header.msg_controllen = 0;
+	}
+
+	do {
+		len = sendmsg(fd, &msg_header, 0);
+	} while (len < 0 && errno == EINTR);
+
+	if (len < 0)
+		goto error;
+
+	return 0;
+
+error:
+	RTE_LOG(INFO, VHOST_CONFIG, "(%"PRIu64") Device cannot send message\n", ctx.fh);
+	return -EFAULT;
+}
+
+/**
+ * Receive data from vhost-user device on a QEMU.
+ */
+static int
+vhost_user_read(struct vhost_driver *drv, VhostUserMsg *msg,
+		int *fds, size_t *fd_num)
+{
+	int fd, len;
+	size_t fd_size = (*fd_num) * sizeof(int);
+	char control[CMSG_SPACE(fd_size)];
+	struct msghdr msg_header;
+	struct iovec iov[1];
+	struct cmsghdr *cmsg_header;
+	struct vhost_device_ctx ctx = vhost_driver_to_vhost_ctx(drv);
+
+	if ((drv == NULL) || (msg == NULL))
+		return -EINVAL;
+
+	fd = drv->user_session->socketfd;
+
+	memset(&msg_header, 0, sizeof(msg_header));
+	memset(control, 0, sizeof(control));
+	*fd_num = 0;
+
+	/* set the payload */
+	iov[0].iov_base = (void *)msg;
+	iov[0].iov_len = VHOST_USER_HDR_SIZE;
+
+	msg_header.msg_iov = iov;
+	msg_header.msg_iovlen = 1;
+	msg_header.msg_control = control;
+	msg_header.msg_controllen = sizeof(control);
+
+	if ((len = recvmsg(fd, &msg_header, 0)) <= 0)
+		goto error;
+
+	if (msg_header.msg_flags & (MSG_TRUNC | MSG_CTRUNC))
+		goto error;
+
+	cmsg_header = CMSG_FIRSTHDR(&msg_header);
+	if (cmsg_header && cmsg_header->cmsg_len > 0 &&
+			cmsg_header->cmsg_level == SOL_SOCKET &&
+			cmsg_header->cmsg_type == SCM_RIGHTS) {
+		if (fd_size >= cmsg_header->cmsg_len - CMSG_LEN(0)) {
+			fd_size = cmsg_header->cmsg_len - CMSG_LEN(0);
+			memcpy(fds, CMSG_DATA(cmsg_header), fd_size);
+			*fd_num = fd_size / sizeof(int);
+		}
+	}
+
+	if (read(fd, ((char *)msg) + len, msg->size) < 0)
+		goto error;
+
+	return 0;
+
+error:
+	RTE_LOG(INFO, VHOST_CONFIG, "(%"PRIu64") Device cannot receive message\n", ctx.fh);
+	return -EFAULT;
+}
+
+/*
+ * Boilerplate code for vhost-user IOCTL
+ * Implicit arguments: ctx, req, result.
+ */
+#define VHOST_USER_IOCTL(func) do {	\
+	result = (func)(ctx);		\
+} while (0)
+
+/*
+ * Boilerplate code for vhost-user Read IOCTL
+ * Implicit arguments: ctx, req, result, in_bufsz, in_buf.
+ */
+#define VHOST_USER_IOCTL_R(type, var, func) do {\
+	result = func(ctx, &(var));		\
+} while (0)
+
+/*
+ * Boilerplate code for vhost-user Write IOCTL
+ * Implicit arguments: ctx, req, result, out_bufsz.
+ */
+#define	VHOST_USER_IOCTL_W(type, var, func) do {\
+	result = (func)(ctx, &(var));		\
+	msg->flags |= VHOST_USER_REPLY_MASK;	\
+	msg->size = sizeof(type);		\
+	vhost_user_write(drv, msg, NULL, 0);	\
+} while (0)
+
+/*
+ * Boilerplate code for vhost-user Read/Write IOCTL
+ * Implicit arguments: ctx, req, result, in_bufsz, in_buf.
+ */
+#define VHOST_USER_IOCTL_RW(type1, var1, type2, var2, func) do {\
+	result = (func)(ctx, (var1), &(var2));			\
+	msg->flags |= VHOST_USER_REPLY_MASK;			\
+	msg->size = sizeof(type2);				\
+	vhost_user_write(drv, msg, NULL, 0);			\
+} while (0)
+
+/**
+ * The IOCTLs are handled using unix domain socket in userspace.
+ */
+	static int
+vhost_user_ioctl(struct vhost_driver *drv, VhostUserMsg *msg,
+		int *fds, int fd_num)
+{
+	struct vhost_device_ctx ctx = vhost_driver_to_vhost_ctx(drv);
+	struct vhost_vring_file file;
+	int result = 0;
+
+	switch (ioctl_to_vhost_user_request[msg->request]) {
+	case VHOST_GET_FEATURES:
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") IOCTL: VHOST_GET_FEATURES\n", ctx.fh);
+		VHOST_USER_IOCTL_W(uint64_t, msg->u64, ops->get_features);
+		break;
+
+	case VHOST_SET_FEATURES:
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") IOCTL: VHOST_SET_FEATURES\n", ctx.fh);
+		VHOST_USER_IOCTL_R(uint64_t, msg->u64, ops->set_features);
+		break;
+
+	case VHOST_RESET_OWNER:
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") IOCTL: VHOST_RESET_OWNER\n", ctx.fh);
+		VHOST_USER_IOCTL(ops->reset_owner);
+		break;
+
+	case VHOST_SET_OWNER:
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") IOCTL: VHOST_SET_OWNER\n", ctx.fh);
+		VHOST_USER_IOCTL(ops->set_owner);
+		break;
+
+	case VHOST_SET_MEM_TABLE:
+		/*TODO fix race condition.*/
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") IOCTL: VHOST_SET_MEM_TABLE\n", ctx.fh);
+		/* all fds should be same, because physical memory consist of an one file */
+		ctx.user.fds = fds;
+		ctx.user.fd_num = fd_num;
+		result = ops->set_mem_table(ctx, &msg->memory, msg->memory.nregions);
+		break;
+
+	case VHOST_SET_VRING_NUM:
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") IOCTL: VHOST_SET_VRING_NUM\n", ctx.fh);
+		VHOST_USER_IOCTL_R(struct vhost_vring_state, msg->state, ops->set_vring_num);
+		break;
+
+	case VHOST_SET_VRING_BASE:
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") IOCTL: VHOST_SET_VRING_BASE\n", ctx.fh);
+		VHOST_USER_IOCTL_R(struct vhost_vring_state, msg->state, ops->set_vring_base);
+		break;
+
+	case VHOST_GET_VRING_BASE:
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") IOCTL: VHOST_GET_VRING_BASE\n", ctx.fh);
+		VHOST_USER_IOCTL_RW(uint32_t, msg->addr.index, struct vhost_vring_state, msg->state, ops->get_vring_base);
+		break;
+
+	case VHOST_SET_VRING_ADDR:
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") IOCTL: VHOST_SET_VRING_ADDR\n", ctx.fh);
+		VHOST_USER_IOCTL_R(struct vhost_vring_addr, msg->addr, ops->set_vring_addr);
+		break;
+
+	case VHOST_SET_VRING_KICK:
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") IOCTL: VHOST_SET_VRING_KICK\n", ctx.fh);
+		ctx.user.fds = fds;
+		ctx.user.fd_num = fd_num;
+		file.index = msg->u64;
+		VHOST_USER_IOCTL_R(struct vhost_vring_file, file, ops->set_vring_kick);
+		break;
+
+	case VHOST_SET_VRING_CALL:
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") IOCTL: VHOST_SET_VRING_CALL\n", ctx.fh);
+		ctx.user.fds = fds;
+		ctx.user.fd_num = fd_num;
+		file.index = msg->u64;
+		VHOST_USER_IOCTL_R(struct vhost_vring_file, file, ops->set_vring_call);
+		break;
+
+	case VHOST_NET_SET_BACKEND:
+	default:
+		RTE_LOG(ERR, VHOST_CONFIG, "(%"PRIu64") IOCTL: DOESN NOT EXIST\n", ctx.fh);
+		result = -1;
+	}
+
+	if (result < 0)
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") IOCTL: FAIL\n", ctx.fh);
+	else
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") IOCTL: SUCCESS\n", ctx.fh);
+
+	return result;
+}
+
+/**
+ * vhost-user specific registration.
+ */
+static int
+vhost_user_driver_register(struct vhost_driver *drv)
+{
+	if ((drv == NULL) || (drv->dev_name == NULL) ||
+			(strlen(drv->dev_name) > UNIX_PATH_MAX - 1))
+		return -1;
+
+	ops = get_virtio_net_callbacks(drv->type);
+
+	drv->user_session = rte_malloc(NULL, sizeof(struct vhost_user_session), CACHE_LINE_SIZE);
+	if (drv->user_session == NULL)
+		return -1;
+
+	drv->user_session->fh =
+		rte_atomic16_add_return(&vhost_user_device_id, 1) - 1; /* fh of first device is zero */
+	drv->user_session->interval = 1;
+
+	return 0;
+}
+
+/**
+ * When vhost-user driver starts, the session handler communicates with vhost-user
+ * device on a QEMU using a unix domain sokcet.
+ */
+static void *
+vhost_user_session_handler(void *data)
+{
+	struct vhost_driver *drv = data;
+	int ret;
+	struct sockaddr_un caddr;
+	VhostUserMsg msg;
+	int fds[VHOST_USER_MAX_FD_NUM];
+	int socketfd;
+	int interval;
+	size_t fd_num;
+
+	if ((drv == NULL) || (drv->dev_name == NULL))
+		return NULL;
+
+	bzero(&caddr, sizeof(caddr));
+	caddr.sun_family = AF_LOCAL;
+	strncpy((char *)&caddr.sun_path, drv->dev_name, strlen(drv->dev_name));
+
+reconnect:
+	drv->user_session->socketfd = socket(AF_UNIX, SOCK_STREAM, 0);
+	if (drv->user_session->socketfd < 0)
+		return NULL;
+
+	socketfd = drv->user_session->socketfd;
+	interval = drv->user_session->interval;
+	while (1) {
+		ret = connect(socketfd, (struct sockaddr *)&caddr, sizeof(caddr));
+		if (ret == 0)
+			break; /* success */
+		sleep(interval);
+	}
+
+	ret = vhost_user_open(drv);
+	if (ret != 0) {
+		RTE_LOG(ERR, VHOST_CONFIG, "(Socket %s) open failuer\n", drv->dev_name);
+		return NULL;
+	}
+
+	for (;;) {
+		fd_num = VHOST_USER_MAX_FD_NUM;
+		bzero(&msg, sizeof(VhostUserMsg));
+		ret = vhost_user_read(drv, &msg, fds, &fd_num);
+		if (ret != 0) {
+			RTE_LOG(ERR, VHOST_CONFIG, "(Socket %s) read failuer\n", drv->dev_name);
+			vhost_user_release(drv);
+			goto reconnect;
+		}
+
+		ret = vhost_user_ioctl(drv, &msg, fds, fd_num);
+		if (ret != 0) {
+			RTE_LOG(ERR, VHOST_CONFIG, "(Socket %s) request failuer\n", drv->dev_name);
+			vhost_user_release(drv);
+			goto reconnect;
+		}
+	}
+
+	return NULL;
+}
+
+/**
+ * Create session handler
+ */
+static int
+vhost_user_driver_start(struct vhost_driver *drv)
+{
+	if (pthread_create(&drv->user_session->tid, NULL, vhost_user_session_handler, drv)) {
+		RTE_LOG(ERR, VHOST_CONFIG,
+				"(Socket %s) starting event handler failuer\n", drv->dev_name);
+		return -1;
+	}
+
+	/* TODO: The event handler thread may need to run on a core user speficied. */
+
+	return 0;
+}
+
+/**
+ * Destroy session handler
+ */
+static void
+vhost_user_driver_stop(struct vhost_driver *drv)
+{
+	pthread_t *tid = &drv->user_session->tid;
+
+	if (pthread_create(tid, NULL, vhost_user_session_handler, drv)) {
+		RTE_LOG(ERR, VHOST_CONFIG,
+				"(Socket %s) starting event handler failuer\n", drv->dev_name);
+		return;
+	}
+
+	/* stop event thread and wait until connection is closed */
+	if (*tid) {
+		pthread_cancel(*tid);
+		pthread_join(*tid, NULL);
+	}
+
+	vhost_user_release(drv);
+}
diff --git a/lib/librte_vhost/vhost-net.c b/lib/librte_vhost/vhost-net.c
index b0de5fd..10f41e9 100644
--- a/lib/librte_vhost/vhost-net.c
+++ b/lib/librte_vhost/vhost-net.c
@@ -42,6 +42,11 @@
  */
 #include "vhost-net-cdev.c"
 
+/*
+ * Include vhost-user depend functions and definitions
+ */
+#include "vhost-net-user.c"
+
 /**
  * This function abstracts cuse and vhost-user driver registration.
  */
@@ -65,10 +70,17 @@ rte_vhost_driver_register(const char *dev_name, vhost_driver_type_t type)
 		if (ret != 0)
 			goto err;
 		break;
+	case VHOST_DRV_USER:
+		ret = vhost_user_driver_register(drv);
+		break;
 	default:
+		ret = -EINVAL;
 		break;
 	}
 
+	if (ret != 0)
+		goto err;
+
 	return drv;
 err:
 	free(drv);
@@ -81,17 +93,40 @@ err:
 int
 rte_vhost_driver_session_start(struct vhost_driver *drv)
 {
+	int ret;
+
 	if (drv == NULL)
 		return -ENODEV;
 
 	switch (drv->type) {
 	case VHOST_DRV_CUSE:
-		vhost_cuse_driver_session_start(drv);
+		ret = vhost_cuse_driver_session_start(drv);
+		break;
+	case VHOST_DRV_USER:
+		ret = vhost_user_driver_start(drv);
 		break;
 	default:
+		ret = -EINVAL;
 		break;
 	}
 
-	return 0;
+	return ret;
 }
 
+/**
+ * The vhost session is closed, only allow for vhost-user.
+ */
+void
+rte_vhost_driver_session_stop(struct vhost_driver *drv)
+{
+	if (drv == NULL)
+		return;
+
+	switch (drv->type) {
+	case VHOST_DRV_USER:
+		vhost_user_driver_stop(drv);
+		break;
+	default:
+		break;
+	}
+}
diff --git a/lib/librte_vhost/vhost-net.h b/lib/librte_vhost/vhost-net.h
index ef04832..0e36ba0 100644
--- a/lib/librte_vhost/vhost-net.h
+++ b/lib/librte_vhost/vhost-net.h
@@ -76,6 +76,12 @@ struct vhost_device_cuse_ctx {
 	pid_t   pid;	/* PID of process calling the IOCTL. */
 };
 
+struct vhost_device_user_ctx {
+	int			*fds;
+	int			fd_num;
+	struct vhost_driver	*drv;
+};
+
 /*
  * Structure used to identify device context.
  */
@@ -83,6 +89,7 @@ struct vhost_device_ctx {
 	vhost_driver_type_t	type;	/* driver type. */
 	uint64_t		fh;	/* Populated with fi->fh to track the device index. */
 	union {
+		struct vhost_device_user_ctx user;
 		struct vhost_device_cuse_ctx cdev;
 	};
 };
diff --git a/lib/librte_vhost/virtio-net-user.c b/lib/librte_vhost/virtio-net-user.c
new file mode 100644
index 0000000..1e78f98
--- /dev/null
+++ b/lib/librte_vhost/virtio-net-user.c
@@ -0,0 +1,410 @@
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright (c) 2014 IGEL Co.,Ltd.
+ *   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 IGEL 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 <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <stdlib.h>
+
+/* Functions defined in virtio_net.c */
+static void init_device(struct vhost_device_ctx ctx, struct virtio_net *dev);
+static void cleanup_device(struct virtio_net *dev);
+static void free_device(struct virtio_net_config_ll *ll_dev);
+static int new_device(struct vhost_device_ctx ctx);
+static void destroy_device(struct vhost_device_ctx ctx);
+static int set_owner(struct vhost_device_ctx ctx);
+static int reset_owner(struct vhost_device_ctx ctx);
+static int get_features(struct vhost_device_ctx ctx, uint64_t *pu);
+static int set_features(struct vhost_device_ctx ctx, uint64_t *pu);
+static int set_vring_num(struct vhost_device_ctx ctx, struct vhost_vring_state *state);
+static int set_vring_addr(struct vhost_device_ctx ctx, struct vhost_vring_addr *addr);
+static int set_vring_base(struct vhost_device_ctx ctx, struct vhost_vring_state *state);
+static int set_backend(struct vhost_device_ctx ctx, struct vhost_vring_file *file);
+
+/* Root address of the linked list in the configuration core. */
+static struct virtio_net_config_ll *user_ll_root;
+
+/**
+ * Retrieves an entry from the devices configuration linked list.
+ */
+static struct virtio_net_config_ll *
+user_get_config_ll_entry(struct vhost_device_ctx ctx)
+{
+	struct virtio_net_config_ll *ll_dev = user_ll_root;
+
+	/* Loop through linked list until the device_fh is found. */
+	while (ll_dev != NULL) {
+		if (ll_dev->dev.device_fh == ctx.fh)
+			return ll_dev;
+		ll_dev = ll_dev->next;
+	}
+
+	return NULL;
+}
+
+/**
+ * Searches the configuration core linked list and retrieves the device if it exists.
+ */
+static struct virtio_net *
+user_get_device(struct vhost_device_ctx ctx)
+{
+	struct virtio_net_config_ll *ll_dev;
+
+	ll_dev = user_get_config_ll_entry(ctx);
+
+	/* If a matching entry is found in the linked list, return the device in that entry. */
+	if (ll_dev)
+		return &ll_dev->dev;
+
+	RTE_LOG(ERR, VHOST_CONFIG, "(%"PRIu64") Device not found in linked list.\n", ctx.fh);
+	return NULL;
+}
+
+/**
+ * Add entry containing a device to the device configuration linked list.
+ */
+static void
+user_add_config_ll_entry(struct virtio_net_config_ll *new_ll_dev)
+{
+	struct virtio_net_config_ll *ll_dev = user_ll_root;
+
+	/* If ll_dev == NULL then this is the first device so go to else */
+	if (ll_dev) {
+		/* If the 1st device_fh != 0 then we insert our device here. */
+		if (ll_dev->dev.device_fh != 0)	{
+			new_ll_dev->dev.device_fh = 0;
+			new_ll_dev->next = ll_dev;
+			user_ll_root = new_ll_dev;
+		} else {
+			/* Increment through the ll until we find un unused device_fh. Insert the device at that entry*/
+			while ((ll_dev->next != NULL) && (ll_dev->dev.device_fh == (ll_dev->next->dev.device_fh - 1)))
+				ll_dev = ll_dev->next;
+
+			new_ll_dev->dev.device_fh = ll_dev->dev.device_fh + 1;
+			new_ll_dev->next = ll_dev->next;
+			ll_dev->next = new_ll_dev;
+		}
+	} else {
+		user_ll_root = new_ll_dev;
+		user_ll_root->dev.device_fh = 0;
+	}
+
+}
+
+/**
+ * Remove an entry from the device configuration linked list.
+ */
+static struct virtio_net_config_ll *
+user_rm_config_ll_entry(struct virtio_net_config_ll *ll_dev, struct virtio_net_config_ll *ll_dev_last)
+{
+	/* First remove the device and then clean it up. */
+	if (ll_dev == user_ll_root) {
+		user_ll_root = ll_dev->next;
+		cleanup_device(&ll_dev->dev);
+		free_device(ll_dev);
+		return user_ll_root;
+	} else {
+		if (likely(ll_dev_last != NULL)) {
+			ll_dev_last->next = ll_dev->next;
+			cleanup_device(&ll_dev->dev);
+			free_device(ll_dev);
+			return ll_dev_last->next;
+		} else {
+			cleanup_device(&ll_dev->dev);
+			free_device(ll_dev);
+			RTE_LOG(ERR, VHOST_CONFIG, "Remove entry from config_ll failed\n");
+			return NULL;
+		}
+	}
+}
+
+/**
+ * Returns the root entry of linked list
+ */
+static struct virtio_net_config_ll *
+user_get_config_ll_root(void)
+{
+	return user_ll_root;
+}
+
+/**
+ * vhost-user specific device initialization.
+ */
+static void
+user_init_device(struct vhost_device_ctx ctx, struct virtio_net *dev)
+{
+	dev->priv = ctx.user.drv->priv;
+}
+
+/**
+ * Locate the file containing QEMU's memory space and map it to our address space.
+ */
+static int
+user_host_memory_map(struct virtio_net *dev, struct virtio_memory *mem, int fd, size_t size)
+{
+	void *map;
+
+	map = mmap(0, size, PROT_READ|PROT_WRITE , MAP_POPULATE|MAP_SHARED, fd, 0);
+	close(fd);
+
+	if (map == MAP_FAILED) {
+		RTE_LOG(ERR, VHOST_CONFIG, "(%"PRIu64") Error mapping the file fd %d\n",  dev->device_fh, fd);
+		return -1;
+	}
+
+	/* Store the memory address and size in the device data structure */
+	mem->mapped_address = (uint64_t)(uintptr_t)map;
+	mem->mapped_size = size;
+
+	LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") Mem File: fd: %d - Size: %llu - VA: %p\n", dev->device_fh,
+			fd, (long long unsigned)mem->mapped_size, map);
+
+	return 0;
+}
+
+/*
+ * Called from IOCTL: VHOST_SET_MEM_TABLE
+ * This function creates and populates the memory structure for the device. This includes
+ * storing offsets used to translate buffer addresses.
+ */
+static int
+user_set_mem_table(struct vhost_device_ctx ctx, const void *mem_regions_addr, uint32_t nregions)
+{
+	struct virtio_net *dev;
+	struct vhost_memory_region *mem_regions;
+	struct virtio_memory *mem;
+	uint64_t size = offsetof(struct vhost_memory, regions);
+	uint32_t regionidx, valid_regions;
+	size_t guest_memory_size = 0;
+
+	dev = user_get_device(ctx);
+	if (dev == NULL)
+		return -1;
+
+	if (dev->mem) {
+		munmap((void *)(uintptr_t)dev->mem->mapped_address, (size_t)dev->mem->mapped_size);
+		free(dev->mem);
+	}
+
+	/* Malloc the memory structure depending on the number of regions. */
+	mem = calloc(1, sizeof(struct virtio_memory) + (sizeof(struct virtio_memory_regions) * nregions));
+	if (mem == NULL) {
+		RTE_LOG(ERR, VHOST_CONFIG, "(%"PRIu64") Failed to allocate memory for dev->mem.\n", dev->device_fh);
+		return -1;
+	}
+
+	mem->nregions = nregions;
+
+	mem_regions = (void*)(uintptr_t)((uint64_t)(uintptr_t)mem_regions_addr + size);
+
+	for (regionidx = 0; regionidx < mem->nregions; regionidx++) {
+		/* Populate the region structure for each region. */
+		mem->regions[regionidx].guest_phys_address = mem_regions[regionidx].guest_phys_addr;
+		mem->regions[regionidx].guest_phys_address_end = mem->regions[regionidx].guest_phys_address +
+			mem_regions[regionidx].memory_size;
+		mem->regions[regionidx].memory_size = mem_regions[regionidx].memory_size;
+		mem->regions[regionidx].userspace_address = mem_regions[regionidx].userspace_addr;
+		guest_memory_size += mem_regions[regionidx].memory_size;
+
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") REGION: %u - GPA: %p - QEMU VA: %p - SIZE (%"PRIu64")\n", dev->device_fh,
+				regionidx, (void*)(uintptr_t)mem->regions[regionidx].guest_phys_address,
+				(void*)(uintptr_t)mem->regions[regionidx].userspace_address,
+				mem->regions[regionidx].memory_size);
+	}
+
+	for (regionidx = 0; regionidx < mem->nregions; regionidx++) {
+		/*set the base address mapping*/
+		if (mem->regions[regionidx].guest_phys_address == 0x0) {
+			mem->base_address = mem->regions[regionidx].userspace_address;
+			/* Map VM memory file */
+			if (user_host_memory_map(dev, mem, ctx.user.fds[regionidx], guest_memory_size) != 0) {
+				free(mem);
+				return -1;
+			}
+		} else
+			close(ctx.user.fds[regionidx]);
+	}
+
+	/* Check that we have a valid base address. */
+	if (mem->base_address == 0) {
+		RTE_LOG(ERR, VHOST_CONFIG, "(%"PRIu64") Failed to find base address of qemu memory file.\n", dev->device_fh);
+		free(mem);
+		return -1;
+	}
+
+	/* Check if all of our regions have valid mappings. Usually one does not exist in the QEMU memory file. */
+	valid_regions = mem->nregions;
+	for (regionidx = 0; regionidx < mem->nregions; regionidx++) {
+		if ((mem->regions[regionidx].userspace_address < mem->base_address) ||
+				(mem->regions[regionidx].userspace_address > (mem->base_address + mem->mapped_size)))
+			valid_regions--;
+	}
+
+	/* If a region does not have a valid mapping we rebuild our memory struct to contain only valid entries. */
+	if (valid_regions != mem->nregions) {
+		LOG_DEBUG(VHOST_CONFIG, "(%"PRIu64") Not all memory regions exist in the QEMU mem file. Re-populating mem structure\n",
+				dev->device_fh);
+
+		/* Re-populate the memory structure with only valid regions. Invalid regions are over-written with memmove. */
+		valid_regions = 0;
+
+		for (regionidx = mem->nregions; 0 != regionidx--;) {
+			if ((mem->regions[regionidx].userspace_address < mem->base_address) ||
+					(mem->regions[regionidx].userspace_address > (mem->base_address + mem->mapped_size))) {
+				memmove(&mem->regions[regionidx], &mem->regions[regionidx + 1],
+						sizeof(struct virtio_memory_regions) * valid_regions);
+			} else {
+				valid_regions++;
+			}
+		}
+	}
+	mem->nregions = valid_regions;
+	dev->mem = mem;
+
+	/*
+	 * Calculate the address offset for each region. This offset is used to identify the vhost virtual address
+	 * corresponding to a QEMU guest physical address.
+	 */
+	for (regionidx = 0; regionidx < dev->mem->nregions; regionidx++)
+		dev->mem->regions[regionidx].address_offset = dev->mem->regions[regionidx].userspace_address - dev->mem->base_address
+			+ dev->mem->mapped_address - dev->mem->regions[regionidx].guest_phys_address;
+
+	return 0;
+}
+
+/**
+ * Called from IOCTL: VHOST_GET_VRING_BASE
+ * We send the virtio device our available ring last used index.
+ */
+static int
+user_get_vring_base(struct vhost_device_ctx ctx, uint32_t index, struct vhost_vring_state *state)
+{
+	struct virtio_net *dev;
+
+	dev = user_get_device(ctx);
+	if (dev == NULL)
+		return -1;
+
+	state->index = index;
+	/* State->index refers to the queue index. The TX queue is 1, RX queue is 0. */
+	state->num = dev->virtqueue[state->index]->last_used_idx;
+
+	return 0;
+}
+
+/**
+ * Called from IOCTL: VHOST_SET_VRING_CALL
+ * The virtio device sends an eventfd to interrupt the guest. This fd gets copied in
+ * to our process space.
+ * Also this message is sent when virtio-net device is reset by device driver on QEMU.
+ */
+static int
+user_set_vring_call(struct vhost_device_ctx ctx, struct vhost_vring_file *file)
+{
+	struct virtio_net *dev;
+	struct vhost_virtqueue *vq;
+
+	dev = user_get_device(ctx);
+	if (dev == NULL)
+		return -1;
+
+	/* file->index refers to the queue index. The TX queue is 1, RX queue is 0. */
+	vq = dev->virtqueue[file->index];
+
+	if (vq->kickfd)
+		close((int)vq->kickfd);
+
+	/* Populate the eventfd_copy structure and call eventfd_copy. */
+	vq->kickfd = ctx.user.fds[0];
+
+	return 0;
+}
+
+/**
+ * Called from IOCTL: VHOST_SET_VRING_KICK
+ * The virtio device sends an eventfd that it can use to notify us. This fd gets copied in
+ * to our process space.
+ */
+static int
+user_set_vring_kick(struct vhost_device_ctx ctx, struct vhost_vring_file *file)
+{
+	struct virtio_net *dev;
+	struct vhost_virtqueue *vq;
+
+	dev = user_get_device(ctx);
+	if (dev == NULL)
+		return -1;
+
+	/* file->index refers to the queue index. The TX queue is 1, RX queue is 0. */
+	vq = dev->virtqueue[file->index];
+
+	if (vq->callfd)
+		close((int)vq->callfd);
+
+	/* Populate the eventfd_copy structure and call eventfd_copy. */
+	vq->callfd = ctx.user.fds[0];
+
+	if ((dev->virtqueue[VIRTIO_RXQ] != NULL) && (dev->virtqueue[VIRTIO_TXQ]) != NULL)
+		return set_backend(ctx, file);
+
+	return 0;
+}
+
+/**
+ * Function pointers are set for the device operations to allow to call functions
+ * when an IOCTL, device_add or device_release is received.
+ */
+static const struct vhost_net_device_ops vhost_user_device_ops = {
+	.new_device = new_device,
+	.destroy_device = destroy_device,
+
+	.get_features = get_features,
+	.set_features = set_features,
+
+	.set_mem_table = user_set_mem_table,
+
+	.set_vring_num = set_vring_num,
+	.set_vring_addr = set_vring_addr,
+	.set_vring_base = set_vring_base,
+	.get_vring_base = user_get_vring_base,
+
+	.set_vring_kick = user_set_vring_kick,
+	.set_vring_call = user_set_vring_call,
+
+	.set_backend = set_backend,
+
+	.set_owner = set_owner,
+	.reset_owner = reset_owner,
+};
diff --git a/lib/librte_vhost/virtio-net.c b/lib/librte_vhost/virtio-net.c
index 13fbb6f..db810e7 100644
--- a/lib/librte_vhost/virtio-net.c
+++ b/lib/librte_vhost/virtio-net.c
@@ -96,6 +96,12 @@ qva_to_vva(struct virtio_net *dev, uint64_t qemu_va)
  */
 #include "virtio-net-cdev.c"
 
+/**
+ * Include vhost-user depend functions and definitions.
+ */
+#include "virtio-net-user.c"
+
+
 /*
  * Retrieves an entry from the devices configuration linked list.
  */
@@ -105,6 +111,8 @@ get_config_ll_entry(struct vhost_device_ctx ctx)
 	switch (ctx.type) {
 	case VHOST_DRV_CUSE:
 		return cdev_get_config_ll_entry(ctx);
+	case VHOST_DRV_USER:
+		return user_get_config_ll_entry(ctx);
 	default:
 		break;
 	}
@@ -120,6 +128,8 @@ get_device(struct vhost_device_ctx ctx)
 	switch (ctx.type) {
 	case VHOST_DRV_CUSE:
 		return cdev_get_device(ctx);
+	case VHOST_DRV_USER:
+		return user_get_device(ctx);
 	default:
 		break;
 	}
@@ -136,6 +146,8 @@ add_config_ll_entry(vhost_driver_type_t type,
 	switch (type) {
 	case VHOST_DRV_CUSE:
 		return cdev_add_config_ll_entry(new_ll_dev);
+	case VHOST_DRV_USER:
+		return user_add_config_ll_entry(new_ll_dev);
 	default:
 		break;
 	}
@@ -149,8 +161,39 @@ cleanup_device(struct virtio_net *dev)
 {
 	/* Unmap QEMU memory file if mapped. */
 	if (dev->mem) {
-		munmap((void *)(uintptr_t)dev->mem->mapped_address,
-			(size_t)dev->mem->mapped_size);
+		{
+			/*
+			 * 'munmap()' will be failed when mapped_size isn't
+			 * aligned with hugepage size.
+			 * Usually a file size of QEMU physical memory is
+			 * aligned by hugepage size. So In a case of CUSE,
+			 * there is no problem. But with vhost-user, there is
+			 * no way to get physical memory size.
+			 *
+			 * Let's assume hugepage size is 2MB or 1GB here.
+			 * BTW, 'mmap()' automatically fixed size parameter
+			 * to be aligned. Why does 'munmap()' do like so?
+			 */
+			int ret = 0;
+			size_t hugepagesize, size = dev->mem->mapped_size;
+
+			/* assume hugepage size is 2MB */
+			hugepagesize = 2 * 1024 * 1024;
+			size = (size + hugepagesize - 1) /
+						hugepagesize * hugepagesize;
+			ret = munmap((void *)(uintptr_t)
+						dev->mem->mapped_address,
+						size);
+			if (ret) {
+				/* assume hugepage size is 1GB, try again */
+				hugepagesize = 1024 * 1024 * 1024;
+				size = (size + hugepagesize - 1) /
+						hugepagesize * hugepagesize;
+				munmap((void *)(uintptr_t)
+						dev->mem->mapped_address,
+						size);
+			}
+		}
 		free(dev->mem);
 	}
 
@@ -187,6 +230,8 @@ rm_config_ll_entry(vhost_driver_type_t type,
 	switch (type) {
 	case VHOST_DRV_CUSE:
 		return cdev_rm_config_ll_entry(ll_dev, ll_dev_last);
+	case VHOST_DRV_USER:
+		return user_rm_config_ll_entry(ll_dev, ll_dev_last);
 	default:
 		break;
 	}
@@ -201,7 +246,9 @@ get_config_ll_root(struct vhost_device_ctx ctx)
 {
 	switch (ctx.type) {
 	case VHOST_DRV_CUSE:
-		return cdev_get_config_ll_root(ctx);
+		return cdev_get_config_ll_root();
+	case VHOST_DRV_USER:
+		return user_get_config_ll_root();
 	default:
 		break;
 	}
@@ -232,6 +279,8 @@ init_device(struct vhost_device_ctx ctx, struct virtio_net *dev)
 	switch (ctx.type) {
 	case VHOST_DRV_CUSE:
 		return cdev_init_device(ctx, dev);
+	case VHOST_DRV_USER:
+		return user_init_device(ctx, dev);
 	default:
 		break;
 	}
@@ -527,6 +576,8 @@ get_virtio_net_callbacks(vhost_driver_type_t type)
 	switch (type) {
 	case VHOST_DRV_CUSE:
 		return &vhost_cuse_device_ops;
+	case VHOST_DRV_USER:
+		return &vhost_user_device_ops;
 	default:
 		break;
 	}
@@ -570,9 +621,14 @@ int rte_vhost_feature_enable(uint64_t feature_mask)
  * Register ops so that we can add/remove device to data core.
  */
 int
-rte_vhost_driver_callback_register(struct virtio_net_device_ops const * const ops)
+rte_vhost_driver_callback_register(struct vhost_driver *drv,
+		struct virtio_net_device_ops const * const ops, void *priv)
 {
+	if (drv == NULL || ops == NULL)
+		return -1;
+
 	notify_ops = ops;
+	drv->priv = priv;
 
 	return 0;
 }
-- 
1.9.1