DPDK patches and discussions
 help / color / mirror / Atom feed
From: Pavel Fedin <p.fedin@samsung.com>
To: 'Tetsuya Mukawa' <mukawa@igel.co.jp>, dev@dpdk.org
Cc: nakajima.yoshihiro@lab.ntt.co.jp, mst@redhat.com
Subject: Re: [dpdk-dev] [PATCH v1 2/2] virtio: Extend virtio-net PMD to support	container environment
Date: Mon, 28 Dec 2015 14:57:41 +0300	[thread overview]
Message-ID: <004a01d14166$f52be7e0$df83b7a0$@samsung.com> (raw)
In-Reply-To: <1450255049-2263-3-git-send-email-mukawa@igel.co.jp>

 Hello!

> -----Original Message-----
> From: dev [mailto:dev-bounces@dpdk.org] On Behalf Of Tetsuya Mukawa
> Sent: Wednesday, December 16, 2015 11:37 AM
> To: dev@dpdk.org
> Cc: nakajima.yoshihiro@lab.ntt.co.jp; mst@redhat.com
> Subject: [dpdk-dev] [PATCH v1 2/2] virtio: Extend virtio-net PMD to support container
> environment
> 
> The patch adds a new virtio-net PMD configuration that allows the PMD to
> work on host as if the PMD is in VM.
> Here is new configuration for virtio-net PMD.
>  - CONFIG_RTE_LIBRTE_VIRTIO_HOST_MODE
> To use this mode, EAL needs physically contiguous memory. To allocate
> such memory, enable below option, and add "--contig-mem" option to
> application command line.
>  - CONFIG_RTE_EAL_SINGLE_FILE_SEGMENTS
> 
> To prepare virtio-net device on host, the users need to invoke QEMU process
> in special qtest mode. This mode is mainly used for testing QEMU devices
> from outer process. In this mode, no guest runs.
> Here is QEMU command line.
> 
>  $ qemu-system-x86_64 \
> 		-machine pc-i440fx-1.4,accel=qtest \
> 		-display none -qtest-log /dev/null \
> 		-qtest unix:/tmp/socket,server \
> 		-netdev type=tap,script=/etc/qemu-ifup,id=net0,queues=1 \
> 		-device virtio-net-pci,netdev=net0,mq=on \
> 		-chardev socket,id=chr1,path=/tmp/ivshmem,server \
> 		-device ivshmem,size=1G,chardev=chr1,vectors=1
> 
> * QEMU process is needed per port.
> * In most cases, just using above command is enough.
> * The vhost backends like vhost-net and vhost-user can be specified.
> * Only checked "pc-i440fx-1.4" machine, but may work with other
>   machines. It depends on a machine has piix3 south bridge.
>   If the machine doesn't have, virtio-net PMD cannot receive status
>   changed interrupts.
> * Should not add "--enable-kvm" to QEMU command line.
> 
> After invoking QEMU, the PMD can connect to QEMU process using unix
> domain sockets. Over these sockets, virtio-net, ivshmem and piix3
> device in QEMU are probed by the PMD.
> Here is example of command line.
> 
>  $ testpmd -c f -n 1 -m 1024 --contig-mem \
>          --vdev="eth_virtio_net0,qtest=/tmp/socket,ivshmem=/tmp/ivshmem" \
>          -- --disable-hw-vlan --txqflags=0xf00 -i
> 
> Please specify same unix domain sockets and memory size in both QEMU and
> DPDK command lines like above.
> The share memory size should be power of 2, because ivshmem only accepts
> such memry size.
> 
> Also, "--contig-mem" option is needed for the PMD like above. This option
> allocates contiguous memory, and create one hugepage file on hugetlbfs.
> If there is no enough contiguous memory, initialization will be failed.
> 
> This contiguous memory is used as shared memory between DPDK application
> and ivshmem device in QEMU.
> 
> Signed-off-by: Tetsuya Mukawa <mukawa@igel.co.jp>
> ---
>  config/common_linuxapp             |    1 +
>  drivers/net/virtio/Makefile        |    4 +
>  drivers/net/virtio/qtest.c         | 1107 ++++++++++++++++++++++++++++++++++++
>  drivers/net/virtio/virtio_ethdev.c |  341 ++++++++++-
>  drivers/net/virtio/virtio_ethdev.h |   12 +
>  drivers/net/virtio/virtio_pci.h    |   25 +
>  6 files changed, 1461 insertions(+), 29 deletions(-)
>  create mode 100644 drivers/net/virtio/qtest.c
> 
> diff --git a/config/common_linuxapp b/config/common_linuxapp
> index 74bc515..eaa720c 100644
> --- a/config/common_linuxapp
> +++ b/config/common_linuxapp
> @@ -269,6 +269,7 @@ CONFIG_RTE_LIBRTE_PMD_SZEDATA2=n
>  # Compile burst-oriented VIRTIO PMD driver
>  #
>  CONFIG_RTE_LIBRTE_VIRTIO_PMD=y
> +CONFIG_RTE_LIBRTE_VIRTIO_HOST_MODE=n
>  CONFIG_RTE_LIBRTE_VIRTIO_DEBUG_INIT=n
>  CONFIG_RTE_LIBRTE_VIRTIO_DEBUG_RX=n
>  CONFIG_RTE_LIBRTE_VIRTIO_DEBUG_TX=n
> diff --git a/drivers/net/virtio/Makefile b/drivers/net/virtio/Makefile
> index 43835ba..697e629 100644
> --- a/drivers/net/virtio/Makefile
> +++ b/drivers/net/virtio/Makefile
> @@ -52,6 +52,10 @@ SRCS-$(CONFIG_RTE_LIBRTE_VIRTIO_PMD) += virtio_rxtx.c
>  SRCS-$(CONFIG_RTE_LIBRTE_VIRTIO_PMD) += virtio_ethdev.c
>  SRCS-$(CONFIG_RTE_LIBRTE_VIRTIO_PMD) += virtio_rxtx_simple.c
> 
> +ifeq ($(CONFIG_RTE_LIBRTE_VIRTIO_HOST_MODE),y)
> +	SRCS-$(CONFIG_RTE_LIBRTE_VIRTIO_PMD) += qtest.c
> +endif
> +
>  # this lib depends upon:
>  DEPDIRS-$(CONFIG_RTE_LIBRTE_VIRTIO_PMD) += lib/librte_eal lib/librte_ether
>  DEPDIRS-$(CONFIG_RTE_LIBRTE_VIRTIO_PMD) += lib/librte_mempool lib/librte_mbuf
> diff --git a/drivers/net/virtio/qtest.c b/drivers/net/virtio/qtest.c
> new file mode 100644
> index 0000000..4ffdefb
> --- /dev/null
> +++ b/drivers/net/virtio/qtest.c
> @@ -0,0 +1,1107 @@
> +/*-
> + *   BSD LICENSE
> + *
> + *   Copyright(c) 2015 IGEL Co., Ltd. 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 IGEL Co., Ltd. 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 <stdlib.h>
> +#include <string.h>
> +#include <unistd.h>
> +#include <sys/types.h>
> +#include <sys/socket.h>
> +#include <sys/un.h>
> +#include <sys/queue.h>
> +#include <signal.h>
> +#include <pthread.h>
> +#include <sys/stat.h>
> +#include <fcntl.h>
> +
> +#include <rte_memory.h>
> +#include <rte_malloc.h>
> +#include <rte_common.h>
> +#include <rte_interrupts.h>
> +
> +#include "virtio_pci.h"
> +#include "virtio_logs.h"
> +#include "virtio_ethdev.h"
> +
> +#define NB_BUS                          256
> +#define NB_DEVICE                       32
> +#define NB_BAR                          6
> +
> +/* PCI common configuration registers */
> +#define REG_ADDR_VENDOR_ID              0x0
> +#define REG_ADDR_DEVICE_ID              0x2
> +#define REG_ADDR_COMMAND                0x4
> +#define REG_ADDR_STATUS                 0x6
> +#define REG_ADDR_REVISION_ID            0x8
> +#define REG_ADDR_CLASS_CODE             0x9
> +#define REG_ADDR_CACHE_LINE_S           0xc
> +#define REG_ADDR_LAT_TIMER              0xd
> +#define REG_ADDR_HEADER_TYPE            0xe
> +#define REG_ADDR_BIST                   0xf
> +#define REG_ADDR_BAR0                   0x10
> +#define REG_ADDR_BAR1                   0x14
> +#define REG_ADDR_BAR2                   0x18
> +#define REG_ADDR_BAR3                   0x1c
> +#define REG_ADDR_BAR4                   0x20
> +#define REG_ADDR_BAR5                   0x24
> +
> +/* PCI common configuration register values */
> +#define REG_VAL_COMMAND_IO              0x1
> +#define REG_VAL_COMMAND_MEMORY          0x2
> +#define REG_VAL_COMMAND_MASTER          0x4
> +#define REG_VAL_HEADER_TYPE_ENDPOINT    0x0
> +#define REG_VAL_BAR_MEMORY              0x0
> +#define REG_VAL_BAR_IO                  0x1
> +#define REG_VAL_BAR_LOCATE_32           0x0
> +#define REG_VAL_BAR_LOCATE_UNDER_1MB    0x2
> +#define REG_VAL_BAR_LOCATE_64           0x4
> +
> +/* PIIX3 configuration registers */
> +#define PIIX3_REG_ADDR_PIRQA            0x60
> +#define PIIX3_REG_ADDR_PIRQB            0x61
> +#define PIIX3_REG_ADDR_PIRQC            0x62
> +#define PIIX3_REG_ADDR_PIRQD            0x63
> +
> +/* Device information */
> +#define VIRTIO_NET_DEVICE_ID            0x1000
> +#define VIRTIO_NET_VENDOR_ID            0x1af4
> +#define VIRTIO_NET_IO_START             0xc000
> +#define VIRTIO_NET_IRQ_NUM              10
> +#define IVSHMEM_DEVICE_ID               0x1110
> +#define IVSHMEM_VENDOR_ID               0x1af4
> +#define IVSHMEM_MEMORY_START            0x1000
> +#define IVSHMEM_PROTOCOL_VERSION        0
> +#define PIIX3_DEVICE_ID                 0x7000
> +#define PIIX3_VENDOR_ID                 0x8086
> +
> +#define PCI_CONFIG_ADDR(_bus, _device, _function, _offset) ( \
> +	(1 << 31) | ((_bus) & 0xff) << 16 | ((_device) & 0x1f) << 11 | \
> +	((_function) & 0xf) << 8 | ((_offset) & 0xfc))
> +
> +static char interrupt_message[32];
> +
> +enum qtest_pci_bar_type {
> +	QTEST_PCI_BAR_DISABLE = 0,
> +	QTEST_PCI_BAR_IO,
> +	QTEST_PCI_BAR_MEMORY_UNDER_1MB,
> +	QTEST_PCI_BAR_MEMORY_32,
> +	QTEST_PCI_BAR_MEMORY_64
> +};
> +
> +struct qtest_pci_bar {
> +	enum qtest_pci_bar_type type;
> +	uint8_t addr;
> +	uint64_t region_start;
> +	uint64_t region_size;
> +};
> +
> +struct qtest_session;
> +TAILQ_HEAD(qtest_pci_device_list, qtest_pci_device);
> +struct qtest_pci_device {
> +	TAILQ_ENTRY(qtest_pci_device) next;
> +	const char *name;
> +	uint16_t device_id;
> +	uint16_t vendor_id;
> +	uint8_t bus_addr;
> +	uint8_t device_addr;
> +	struct qtest_pci_bar bar[NB_BAR];
> +	int (*init)(struct qtest_session *s, struct qtest_pci_device *dev);
> +};
> +
> +union qtest_pipefds {
> +	struct {
> +		int pipefd[2];
> +	};
> +	struct {
> +		int readfd;
> +		int writefd;
> +	};
> +};
> +
> +struct qtest_session {
> +	int qtest_socket;
> +	pthread_mutex_t qtest_session_lock;
> +
> +	struct qtest_pci_device_list head;
> +	int ivshmem_socket;
> +
> +	pthread_t event_th;
> +	union qtest_pipefds msgfds;
> +
> +	pthread_t intr_th;
> +	union qtest_pipefds irqfds;
> +	rte_atomic16_t enable_intr;
> +	rte_intr_callback_fn cb;
> +	void *cb_arg;
> +};
> +
> +static int
> +qtest_write(int fd, char *buf, size_t count)
> +{
> +	size_t len = count;
> +	size_t total_len = 0;
> +	int ret = 0;
> +
> +	while (len > 0) {
> +		ret = write(fd, buf, len);
> +		if (ret == (int)len)
> +			break;
> +		if (ret == -1) {
> +			if (errno == EINTR)
> +				continue;
> +			return ret;
> +		}
> +		total_len += ret;
> +		buf += ret;
> +		len -= ret;
> +	}
> +	return total_len + ret;
> +}
> +
> +static int
> +qtest_read(int fd, char *buf, size_t count)
> +{
> +	size_t len = count;
> +	size_t total_len = 0;
> +	int ret = 0;
> +
> +	while (len > 0) {
> +		ret = read(fd, buf, len);
> +		if (ret == (int)len)
> +			break;
> +		if (*(buf + ret - 1) == '\n')
> +			break;
> +		if (ret == -1) {
> +			if (errno == EINTR)
> +				continue;
> +			return ret;
> +		}
> +		total_len += ret;
> +		buf += ret;
> +		len -= ret;
> +	}
> +	return total_len + ret;
> +}
> +
> +/*
> + * To know QTest protocol specification, see below QEMU source code.
> + *  - qemu/qtest.c
> + */
> +static uint32_t
> +qtest_in(struct qtest_session *s, uint16_t addr, char type)
> +{
> +	char buf[1024];
> +	int ret;
> +
> +	if ((type != 'l') && (type != 'w') && (type != 'b'))
> +		rte_panic("Invalid value\n");
> +
> +	snprintf(buf, sizeof(buf), "in%c 0x%x\n", type, addr);
> +	/* write to qtest socket */
> +	ret = qtest_write(s->qtest_socket, buf, strlen(buf));
> +	/* read reply from event handler */
> +	ret = qtest_read(s->msgfds.readfd, buf, sizeof(buf));
> +	buf[ret] = '\0';
> +	return strtoul(buf + strlen("OK "), NULL, 16);
> +}
> +
> +static void
> +qtest_out(struct qtest_session *s, uint16_t addr, uint32_t val, char type)
> +{
> +	char buf[1024];
> +	int ret __rte_unused;
> +
> +	if ((type != 'l') && (type != 'w') && (type != 'b'))
> +		rte_panic("Invalid value\n");
> +
> +	snprintf(buf, sizeof(buf), "out%c 0x%x 0x%x\n", type, addr, val);
> +	/* write to qtest socket */
> +	ret = qtest_write(s->qtest_socket, buf, strlen(buf));
> +	/* read reply from event handler */
> +	ret = qtest_read(s->msgfds.readfd, buf, sizeof(buf));
> +}
> +
> +/*
> + * qtest_pci_read/write are based on PCI configuration space specification.
> + * Accroding to the spec, access size of read()/write() should be 4 bytes.
> + */
> +static int
> +qtest_pci_readb(struct qtest_session *s, uint8_t bus, uint8_t device,
> +		uint8_t function, uint8_t offset)
> +{
> +	uint32_t tmp;
> +
> +	tmp = PCI_CONFIG_ADDR(bus, device, function, offset);
> +
> +	if (pthread_mutex_lock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot lock mutex\n");
> +
> +	qtest_out(s, 0xcf8, tmp, 'l');
> +	tmp = qtest_in(s, 0xcfc, 'l');
> +
> +	if (pthread_mutex_unlock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot unlock mutex\n");
> +
> +	return (tmp >> ((offset & 0x3) * 8)) & 0xff;
> +}
> +
> +static void
> +qtest_pci_writeb(struct qtest_session *s, uint8_t bus, uint8_t device,
> +		uint8_t function, uint8_t offset, uint8_t value)
> +{
> +	uint32_t addr, tmp, pos;
> +
> +	addr = PCI_CONFIG_ADDR(bus, device, function, offset);
> +	pos = (offset % 4) * 8;
> +
> +	if (pthread_mutex_lock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot lock mutex\n");
> +
> +	qtest_out(s, 0xcf8, addr, 'l');
> +	tmp = qtest_in(s, 0xcfc, 'l');
> +	tmp = (tmp & ~(0xff << pos)) | (value << pos);
> +
> +	qtest_out(s, 0xcf8, addr, 'l');
> +	qtest_out(s, 0xcfc, tmp, 'l');
> +
> +	if (pthread_mutex_unlock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot unlock mutex\n");
> +}
> +
> +static uint32_t
> +qtest_pci_readl(struct qtest_session *s, uint8_t bus, uint8_t device,
> +		uint8_t function, uint8_t offset)
> +{
> +	uint32_t tmp;
> +
> +	tmp = PCI_CONFIG_ADDR(bus, device, function, offset);
> +
> +	if (pthread_mutex_lock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot lock mutex\n");
> +
> +	qtest_out(s, 0xcf8, tmp, 'l');
> +	tmp = qtest_in(s, 0xcfc, 'l');
> +
> +	if (pthread_mutex_unlock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot unlock mutex\n");
> +
> +	return tmp;
> +}
> +
> +static void
> +qtest_pci_writel(struct qtest_session *s, uint8_t bus, uint8_t device,
> +		uint8_t function, uint8_t offset, uint32_t value)
> +{
> +	uint32_t tmp;
> +
> +	tmp = PCI_CONFIG_ADDR(bus, device, function, offset);
> +
> +	if (pthread_mutex_lock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot lock mutex\n");
> +
> +	qtest_out(s, 0xcf8, tmp, 'l');
> +	qtest_out(s, 0xcfc, value, 'l');
> +
> +	if (pthread_mutex_unlock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot unlock mutex\n");
> +}
> +
> +static uint64_t
> +qtest_pci_readq(struct qtest_session *s, uint8_t bus, uint8_t device,
> +		uint8_t function, uint8_t offset)
> +{
> +	uint32_t tmp;
> +	uint64_t val;
> +
> +	tmp = PCI_CONFIG_ADDR(bus, device, function, offset);
> +
> +	if (pthread_mutex_lock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot lock mutex\n");
> +
> +	qtest_out(s, 0xcf8, tmp, 'l');
> +	val = (uint64_t)qtest_in(s, 0xcfc, 'l');
> +
> +	tmp = PCI_CONFIG_ADDR(bus, device, function, offset + 4);
> +
> +	qtest_out(s, 0xcf8, tmp, 'l');
> +	val |= (uint64_t)qtest_in(s, 0xcfc, 'l') << 32;
> +
> +	if (pthread_mutex_unlock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot unlock mutex\n");
> +
> +	return val;
> +}
> +
> +static void
> +qtest_pci_writeq(struct qtest_session *s, uint8_t bus, uint8_t device,
> +		uint8_t function, uint8_t offset, uint64_t value)
> +{
> +	uint32_t tmp;
> +
> +	tmp = PCI_CONFIG_ADDR(bus, device, function, offset);
> +
> +	if (pthread_mutex_lock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot lock mutex\n");
> +
> +	qtest_out(s, 0xcf8, tmp, 'l');
> +	qtest_out(s, 0xcfc, (uint32_t)(value & 0xffffffff), 'l');
> +
> +	tmp = PCI_CONFIG_ADDR(bus, device, function, offset + 4);
> +
> +	qtest_out(s, 0xcf8, tmp, 'l');
> +	qtest_out(s, 0xcfc, (uint32_t)(value >> 32), 'l');
> +
> +	if (pthread_mutex_unlock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot unlock mutex\n");
> +}
> +
> +/*
> + * virtio_ioport_read/write are Used by virtio-net PMD
> + */
> +void
> +virtio_ioport_write(struct virtio_hw *hw, uint64_t addr, uint64_t val, char type)
> +{
> +	struct qtest_session *s = (struct qtest_session *)hw->qsession;
> +
> +	if (pthread_mutex_lock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot lock mutex\n");
> +
> +	qtest_out(s, VIRTIO_NET_IO_START + (uint16_t)addr, val, type);
> +
> +	if (pthread_mutex_unlock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot lock mutex\n");
> +}
> +
> +uint32_t
> +virtio_ioport_read(struct virtio_hw *hw, uint64_t addr, char type)
> +{
> +	struct qtest_session *s = (struct qtest_session *)hw->qsession;
> +	uint32_t val;
> +
> +	if (pthread_mutex_lock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot lock mutex\n");
> +
> +	val = qtest_in(s, VIRTIO_NET_IO_START + (uint16_t)addr, type);
> +
> +	if (pthread_mutex_unlock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot lock mutex\n");
> +
> +	return val;
> +}
> +
> +int
> +qtest_intr_enable(void *data)
> +{
> +	struct virtio_hw *hw = ((struct rte_eth_dev_data *)data)->dev_private;
> +	struct qtest_session *s;
> +
> +	s = (struct qtest_session *)hw->qsession;
> +	rte_atomic16_set(&s->enable_intr, 1);
> +
> +	return 0;
> +}
> +
> +int
> +qtest_intr_disable(void *data)
> +{
> +	struct virtio_hw *hw = ((struct rte_eth_dev_data *)data)->dev_private;
> +	struct qtest_session *s;
> +
> +	s = (struct qtest_session *)hw->qsession;
> +	rte_atomic16_set(&s->enable_intr, 0);
> +
> +	return 0;
> +}
> +
> +void
> +qtest_intr_callback_register(void *data,
> +		rte_intr_callback_fn cb, void *cb_arg)
> +{
> +	struct virtio_hw *hw = ((struct rte_eth_dev_data *)data)->dev_private;
> +	struct qtest_session *s;
> +
> +	s = (struct qtest_session *)hw->qsession;
> +	s->cb = cb;
> +	s->cb_arg = cb_arg;
> +	rte_atomic16_set(&s->enable_intr, 1);
> +}
> +
> +void
> +qtest_intr_callback_unregister(void *data,
> +		rte_intr_callback_fn cb __rte_unused,
> +		void *cb_arg __rte_unused)
> +{
> +	struct virtio_hw *hw = ((struct rte_eth_dev_data *)data)->dev_private;
> +	struct qtest_session *s;
> +
> +	s = (struct qtest_session *)hw->qsession;
> +	rte_atomic16_set(&s->enable_intr, 0);
> +	s->cb = NULL;
> +	s->cb_arg = NULL;
> +}
> +
> +static void *
> +qtest_intr_handler(void *data) {
> +	struct qtest_session *s = (struct qtest_session *)data;
> +	char buf[1];
> +	int ret;
> +
> +	for (;;) {
> +		ret = qtest_read(s->irqfds.readfd, buf, sizeof(buf));
> +		if (ret < 0)
> +			return NULL;
> +		s->cb(NULL, s->cb_arg);
> +	}
> +	return NULL;
> +}
> +
> +static int
> +qtest_intr_initialize(void *data)
> +{
> +	struct virtio_hw *hw = ((struct rte_eth_dev_data *)data)->dev_private;
> +	struct qtest_session *s;
> +	char buf[1024];
> +	int ret;
> +
> +	s = (struct qtest_session *)hw->qsession;
> +
> +	/* This message will come when interrupt occurs */
> +	snprintf(interrupt_message, sizeof(interrupt_message),
> +			"IRQ raise %d", VIRTIO_NET_IRQ_NUM);
> +
> +	snprintf(buf, sizeof(buf), "irq_intercept_in ioapic\n");
> +
> +	if (pthread_mutex_lock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot lock mutex\n");
> +
> +	/* To enable interrupt, send "irq_intercept_in" message to QEMU */
> +	ret = qtest_write(s->qtest_socket, buf, strlen(buf));
> +	if (ret < 0) {
> +		pthread_mutex_unlock(&s->qtest_session_lock);
> +		return -1;
> +	}
> +
> +	/* just ignore QEMU response */
> +	ret = qtest_read(s->msgfds.readfd, buf, sizeof(buf));
> +	if (ret < 0) {
> +		pthread_mutex_unlock(&s->qtest_session_lock);
> +		return -1;
> +	}
> +
> +	if (pthread_mutex_unlock(&s->qtest_session_lock) < 0)
> +		rte_panic("Cannot lock mutex\n");
> +
> +	return 0;
> +}
> +
> +static void
> +qtest_handle_one_message(struct qtest_session *s, char *buf)
> +{
> +	int ret;
> +
> +	if (strncmp(buf, interrupt_message, strlen(interrupt_message)) == 0) {
> +		if (rte_atomic16_read(&s->enable_intr) == 0)
> +			return;
> +
> +		/* relay interrupt to pipe */
> +		ret = write(s->irqfds.writefd, "1", 1);
> +		if (ret < 0)
> +			rte_panic("cannot relay interrupt\n");
> +	} else {
> +		/* relay normal message to pipe */
> +		ret = qtest_write(s->msgfds.writefd, buf, strlen(buf));
> +		if (ret < 0)
> +			rte_panic("cannot relay normal message\n");
> +	}
> +}
> +
> +static char *
> +qtest_get_next_message(char *p)
> +{
> +	p = strchr(p, '\n');
> +	if ((p == NULL) || (*(p + 1) == '\0'))
> +		return NULL;
> +	return p + 1;
> +}
> +
> +static void
> +qtest_close_one_socket(int *fd)
> +{
> +	if (*fd > 0) {
> +		close(*fd);
> +		*fd = -1;
> +	}
> +}
> +
> +static void
> +qtest_close_sockets(struct qtest_session *s)
> +{
> +	qtest_close_one_socket(&s->qtest_socket);
> +	qtest_close_one_socket(&s->msgfds.readfd);
> +	qtest_close_one_socket(&s->msgfds.writefd);
> +	qtest_close_one_socket(&s->irqfds.readfd);
> +	qtest_close_one_socket(&s->irqfds.writefd);
> +	qtest_close_one_socket(&s->ivshmem_socket);
> +}
> +
> +/*
> + * This thread relays QTest response using pipe.
> + * The function is needed because we need to separate IRQ message from others.
> + */
> +static void *
> +qtest_event_handler(void *data) {
> +	struct qtest_session *s = (struct qtest_session *)data;
> +	char buf[1024];
> +	char *p;
> +	int ret;
> +
> +	for (;;) {
> +		memset(buf, 0, sizeof(buf));
> +		ret = qtest_read(s->qtest_socket, buf, sizeof(buf));
> +		if (ret < 0) {
> +			qtest_close_sockets(s);
> +			return NULL;
> +		}
> +
> +		/* may receive multiple messages at the same time */
> +		p = buf;
> +		do {
> +			qtest_handle_one_message(s, p);
> +		} while ((p = qtest_get_next_message(p)) != NULL);
> +	}
> +	return NULL;
> +}
> +
> +static int
> +qtest_init_piix3_device(struct qtest_session *s, struct qtest_pci_device *dev)
> +{
> +	uint8_t bus, device, virtio_net_slot = 0;
> +	struct qtest_pci_device *tmpdev;
> +	uint8_t pcislot2regaddr[] = {	0xff,
> +					0xff,
> +					0xff,
> +					PIIX3_REG_ADDR_PIRQC,
> +					PIIX3_REG_ADDR_PIRQD,
> +					PIIX3_REG_ADDR_PIRQA,
> +					PIIX3_REG_ADDR_PIRQB};
> +
> +	bus = dev->bus_addr;
> +	device = dev->device_addr;
> +
> +	PMD_DRV_LOG(INFO,
> +		"Find %s on virtual PCI bus: %04x:%02x:00.0\n",
> +		dev->name, bus, device);
> +
> +	/* Get slot id that is connected to virtio-net */
> +	TAILQ_FOREACH(tmpdev, &s->head, next) {
> +		if (strcmp(tmpdev->name, "virtio-net") == 0) {
> +			virtio_net_slot = tmpdev->device_addr;
> +			break;
> +		}
> +	}
> +
> +	if (virtio_net_slot == 0)
> +		return -1;
> +
> +	/*
> +	 * Set interrupt routing for virtio-net device.
> +	 * Here is i440fx/piix3 connection settings
> +	 * ---------------------------------------
> +	 * PCI Slot3 -> PIRQC
> +	 * PCI Slot4 -> PIRQD
> +	 * PCI Slot5 -> PIRQA
> +	 * PCI Slot6 -> PIRQB
> +	 */
> +	if (pcislot2regaddr[virtio_net_slot] != 0xff) {
> +		qtest_pci_writeb(s, bus, device, 0,
> +				pcislot2regaddr[virtio_net_slot],
> +				VIRTIO_NET_IRQ_NUM);
> +	}
> +
> +	return 0;
> +}
> +
> +/*
> + * Common initialization of PCI device.
> + * To know detail, see pci specification.
> + */
> +static int
> +qtest_init_pci_device(struct qtest_session *s, struct qtest_pci_device *dev)
> +{
> +	uint8_t i, bus, device;
> +	uint32_t val;
> +	uint64_t val64;
> +
> +	bus = dev->bus_addr;
> +	device = dev->device_addr;
> +
> +	PMD_DRV_LOG(INFO,
> +		"Find %s on virtual PCI bus: %04x:%02x:00.0\n",
> +		dev->name, bus, device);
> +
> +	/* Check header type */
> +	val = qtest_pci_readb(s, bus, device, 0, REG_ADDR_HEADER_TYPE);
> +	if (val != REG_VAL_HEADER_TYPE_ENDPOINT) {
> +		PMD_DRV_LOG(ERR, "Unexpected header type %d\n", val);
> +		return -1;
> +	}
> +
> +	/* Check BAR type */
> +	for (i = 0; i < NB_BAR; i++) {
> +		val = qtest_pci_readl(s, bus, device, 0, dev->bar[i].addr);
> +
> +		switch (dev->bar[i].type) {
> +		case QTEST_PCI_BAR_IO:
> +			if ((val & 0x1) != REG_VAL_BAR_IO)
> +				goto error;
> +			break;
> +		case QTEST_PCI_BAR_MEMORY_UNDER_1MB:
> +			if ((val & 0x1) != REG_VAL_BAR_MEMORY)
> +				goto error;
> +			if ((val & 0x6) != REG_VAL_BAR_LOCATE_UNDER_1MB)
> +				goto error;
> +			break;
> +		case QTEST_PCI_BAR_MEMORY_32:
> +			if ((val & 0x1) != REG_VAL_BAR_MEMORY)
> +				goto error;
> +			if ((val & 0x6) != REG_VAL_BAR_LOCATE_32)
> +				goto error;
> +			break;
> +		case QTEST_PCI_BAR_MEMORY_64:
> +			if ((val & 0x1) != REG_VAL_BAR_MEMORY)
> +				goto error;
> +			if ((val & 0x6) != REG_VAL_BAR_LOCATE_64)
> +				goto error;
> +			break;
> +		case QTEST_PCI_BAR_DISABLE:
> +			break;
> +		}
> +	}
> +
> +	/* Enable device */
> +	val = qtest_pci_readl(s, bus, device, 0, REG_ADDR_COMMAND);
> +	val |= REG_VAL_COMMAND_IO | REG_VAL_COMMAND_MEMORY | REG_VAL_COMMAND_MASTER;
> +	qtest_pci_writel(s, bus, device, 0, REG_ADDR_COMMAND, val);
> +
> +	/* Calculate BAR size */
> +	for (i = 0; i < NB_BAR; i++) {
> +		switch (dev->bar[i].type) {
> +		case QTEST_PCI_BAR_IO:
> +		case QTEST_PCI_BAR_MEMORY_UNDER_1MB:
> +		case QTEST_PCI_BAR_MEMORY_32:
> +			qtest_pci_writel(s, bus, device, 0,
> +					dev->bar[i].addr, 0xffffffff);
> +			val = qtest_pci_readl(s, bus, device,
> +					0, dev->bar[i].addr);
> +			dev->bar[i].region_size = ~(val & 0xfffffff0) + 1;
> +			break;
> +		case QTEST_PCI_BAR_MEMORY_64:
> +			qtest_pci_writeq(s, bus, device, 0,
> +					dev->bar[i].addr, 0xffffffffffffffff);
> +			val64 = qtest_pci_readq(s, bus, device,
> +					0, dev->bar[i].addr);
> +			dev->bar[i].region_size =
> +					~(val64 & 0xfffffffffffffff0) + 1;
> +			break;
> +		case QTEST_PCI_BAR_DISABLE:
> +			break;
> +		}
> +	}
> +
> +	/* Set BAR region */
> +	for (i = 0; i < NB_BAR; i++) {
> +		switch (dev->bar[i].type) {
> +		case QTEST_PCI_BAR_IO:
> +		case QTEST_PCI_BAR_MEMORY_UNDER_1MB:
> +		case QTEST_PCI_BAR_MEMORY_32:
> +			qtest_pci_writel(s, bus, device, 0, dev->bar[i].addr,
> +				dev->bar[i].region_start);
> +			PMD_DRV_LOG(INFO, "Set BAR of %s device: 0x%lx - 0x%lx\n",
> +				dev->name, dev->bar[i].region_start,
> +				dev->bar[i].region_start + dev->bar[i].region_size);
> +			break;
> +		case QTEST_PCI_BAR_MEMORY_64:
> +			qtest_pci_writeq(s, bus, device, 0, dev->bar[i].addr,
> +				dev->bar[i].region_start);
> +			PMD_DRV_LOG(INFO, "Set BAR of %s device: 0x%lx - 0x%lx\n",
> +				dev->name, dev->bar[i].region_start,
> +				dev->bar[i].region_start + dev->bar[i].region_size);
> +			break;
> +		case QTEST_PCI_BAR_DISABLE:
> +			break;
> +		}
> +	}
> +
> +	return 0;
> +
> +error:
> +	PMD_DRV_LOG(ERR, "Unexpected BAR type\n");
> +	return -1;
> +}
> +
> +static void
> +qtest_find_pci_device(struct qtest_session *s, uint16_t bus, uint8_t device)
> +{
> +	struct qtest_pci_device *dev;
> +	uint32_t val;
> +
> +	val = qtest_pci_readl(s, bus, device, 0, 0);
> +	TAILQ_FOREACH(dev, &s->head, next) {
> +		if (val == ((uint32_t)dev->device_id << 16 | dev->vendor_id)) {
> +			/* device is found, then store it */
> +			dev->bus_addr = bus;
> +			dev->device_addr = device;
> +			return;
> +		}
> +	}
> +}
> +
> +static int
> +qtest_init_pci_devices(struct qtest_session *s)
> +{
> +	struct qtest_pci_device *dev;
> +	uint16_t bus;
> +	uint8_t device;
> +	int ret;
> +
> +	/* Find devices */
> +	bus = 0;
> +	do {
> +		device = 0;
> +		do {
> +			qtest_find_pci_device(s, bus, device);
> +		} while (device++ != NB_DEVICE - 1);
> +	} while (bus++ != NB_BUS - 1);
> +
> +	/* Initialize devices */
> +	TAILQ_FOREACH(dev, &s->head, next) {
> +		ret = dev->init(s, dev);
> +		if (ret != 0)
> +			return ret;
> +	}
> +
> +	return 0;
> +}
> +
> +struct rte_pci_id
> +qtest_get_pci_id_of_virtio_net(void)
> +{
> +	struct rte_pci_id id =  {VIRTIO_NET_DEVICE_ID,
> +		VIRTIO_NET_VENDOR_ID, PCI_ANY_ID, PCI_ANY_ID};
> +
> +	return id;
> +}
> +
> +static int
> +qtest_register_target_devices(struct qtest_session *s)
> +{
> +	struct qtest_pci_device *virtio_net, *ivshmem, *piix3;
> +	const struct rte_memseg *ms;
> +
> +	ms = rte_eal_get_physmem_layout();
> +	/* if EAL memory size isn't pow of 2, ivshmem refuse it */
> +	if ((ms[0].len & (ms[0].len - 1)) != 0) {
> +		PMD_DRV_LOG(ERR, "memory size must be power of 2\n");
> +		return -1;
> +	}
> +
> +	virtio_net = malloc(sizeof(*virtio_net));
> +	if (virtio_net == NULL)
> +		return -1;
> +
> +	ivshmem = malloc(sizeof(*ivshmem));
> +	if (ivshmem == NULL)
> +		return -1;
> +
> +	piix3 = malloc(sizeof(*piix3));
> +	if (piix3 == NULL)
> +		return -1;
> +
> +	memset(virtio_net, 0, sizeof(*virtio_net));
> +	memset(ivshmem, 0, sizeof(*ivshmem));
> +
> +	TAILQ_INIT(&s->head);
> +
> +	virtio_net->name = "virtio-net";
> +	virtio_net->device_id = VIRTIO_NET_DEVICE_ID;
> +	virtio_net->vendor_id = VIRTIO_NET_VENDOR_ID;
> +	virtio_net->init = qtest_init_pci_device;
> +	virtio_net->bar[0].addr = REG_ADDR_BAR0;
> +	virtio_net->bar[0].type = QTEST_PCI_BAR_IO;
> +	virtio_net->bar[0].region_start = VIRTIO_NET_IO_START;
> +	TAILQ_INSERT_TAIL(&s->head, virtio_net, next);
> +
> +	ivshmem->name = "ivshmem";
> +	ivshmem->device_id = IVSHMEM_DEVICE_ID;
> +	ivshmem->vendor_id = IVSHMEM_VENDOR_ID;
> +	ivshmem->init = qtest_init_pci_device;
> +	ivshmem->bar[0].addr = REG_ADDR_BAR0;
> +	ivshmem->bar[0].type = QTEST_PCI_BAR_MEMORY_32;
> +	ivshmem->bar[0].region_start = IVSHMEM_MEMORY_START;
> +	ivshmem->bar[1].addr = REG_ADDR_BAR2;
> +	ivshmem->bar[1].type = QTEST_PCI_BAR_MEMORY_64;
> +	/* In host mode, only one memory segment is vaild */
> +	ivshmem->bar[1].region_start = ms[0].phys_addr;
> +	TAILQ_INSERT_TAIL(&s->head, ivshmem, next);
> +
> +	/* piix3 is needed to route irqs from virtio-net to ioapic */
> +	piix3->name = "piix3";
> +	piix3->device_id = PIIX3_DEVICE_ID;
> +	piix3->vendor_id = PIIX3_VENDOR_ID;
> +	piix3->init = qtest_init_piix3_device;
> +	TAILQ_INSERT_TAIL(&s->head, piix3, next);
> +
> +	return 0;
> +}
> +
> +static int
> +qtest_send_message_to_ivshmem(int sock_fd, uint64_t client_id, int shm_fd)
> +{
> +	struct iovec iov;
> +	struct msghdr msgh;
> +	size_t fdsize = sizeof(int);
> +	char control[CMSG_SPACE(fdsize)];
> +	struct cmsghdr *cmsg;
> +	int ret;
> +
> +	memset(&msgh, 0, sizeof(msgh));
> +	iov.iov_base = &client_id;
> +	iov.iov_len = sizeof(client_id);
> +
> +	msgh.msg_iov = &iov;
> +	msgh.msg_iovlen = 1;
> +
> +	if (shm_fd >= 0) {
> +		msgh.msg_control = &control;
> +		msgh.msg_controllen = sizeof(control);
> +		cmsg = CMSG_FIRSTHDR(&msgh);
> +		cmsg->cmsg_len = CMSG_LEN(fdsize);
> +		cmsg->cmsg_level = SOL_SOCKET;
> +		cmsg->cmsg_type = SCM_RIGHTS;
> +		memcpy(CMSG_DATA(cmsg), &shm_fd, fdsize);
> +	}
> +
> +	do {
> +		ret = sendmsg(sock_fd, &msgh, 0);
> +	} while (ret < 0 && errno == EINTR);
> +
> +	if (ret < 0) {
> +		PMD_DRV_LOG(ERR, "sendmsg error\n");
> +		return ret;
> +	}
> +
> +	return ret;
> +}
> +
> +static int
> +qtest_open_shared_memory(void)
> +{
> +	const struct rte_memseg *ms;
> +	int shm_fd = -1;
> +	uint64_t vaddr;
> +	char buf[1024];
> +	char *p;
> +	FILE *f;
> +
> +	ms = rte_eal_get_physmem_layout();
> +	f = fopen("/proc/self/maps", "r");
> +	if (f == NULL)
> +		return -1;
> +
> +	/* parse maps */
> +	while (fgets(buf, sizeof(buf), f) != NULL) {
> +		/* get vaddr */
> +		vaddr = strtoul(buf, NULL, 16);
> +
> +		/* check if this region is EAL memory */
> +		if (vaddr == ms[0].addr_64) {
> +			p = strchr(buf, '/');
> +			if (p == NULL)
> +				return -1;
> +			buf[strlen(buf) - 1] = '\0';
> +			shm_fd = open(p, O_RDWR);
> +			break;
> +		}
> +	}
> +	fclose(f);
> +
> +	return shm_fd;
> +}
> +
> +static int
> +qtest_setup_shared_memory(struct qtest_session *s)
> +{
> +	int shm_fd, ret;
> +
> +	/* To share DPDK EAL memory, open EAL memory again */
> +	shm_fd = qtest_open_shared_memory();
> +	if (shm_fd < 0) {
> +		PMD_DRV_LOG(ERR,
> +			"Failed to open EAL memory\n");
> +		return -1;
> +	}
> +
> +	/* send our protocol version first */
> +	ret = qtest_send_message_to_ivshmem(s->ivshmem_socket,
> +			IVSHMEM_PROTOCOL_VERSION, -1);
> +	if (ret < 0) {
> +		PMD_DRV_LOG(ERR,
> +			"Failed to send protocol version to ivshmem\n");
> +		return -1;
> +	}
> +
> +	/* send client id */
> +	ret = qtest_send_message_to_ivshmem(s->ivshmem_socket, 0, -1);
> +	if (ret < 0) {
> +		PMD_DRV_LOG(ERR, "Failed to send VMID to ivshmem\n");
> +		return -1;
> +	}
> +
> +	/* send message to ivshmem */
> +	ret = qtest_send_message_to_ivshmem(s->ivshmem_socket, -1, shm_fd);
> +	if (ret < 0) {
> +		PMD_DRV_LOG(ERR, "Failed to file descriptor to ivshmem\n");
> +		return -1;
> +	}
> +
> +	/* close EAL memory again */
> +	close(shm_fd);
> +
> +	return 0;
> +}
> +
> +int
> +qtest_vdev_init(struct rte_eth_dev_data *data,
> +		int qtest_socket, int ivshmem_socket)
> +{
> +	struct virtio_hw *hw = ((struct rte_eth_dev_data *)data)->dev_private;
> +	struct qtest_session *s;
> +	int ret;
> +
> +	s = rte_zmalloc(NULL, sizeof(*s), RTE_CACHE_LINE_SIZE);
> +
> +	ret = pipe(s->msgfds.pipefd);
> +	if (ret != 0) {
> +		PMD_DRV_LOG(ERR, "Failed to initialize message pipe\n");
> +		return -1;
> +	}
> +
> +	ret = pipe(s->irqfds.pipefd);
> +	if (ret != 0) {
> +		PMD_DRV_LOG(ERR, "Failed to initialize irq pipe\n");
> +		return -1;
> +	}
> +
> +	ret = qtest_register_target_devices(s);
> +	if (ret != 0) {
> +		PMD_DRV_LOG(ERR, "Failed to initialize qtest session\n");
> +		return -1;
> +	}
> +
> +	ret = pthread_mutex_init(&s->qtest_session_lock, NULL);
> +	if (ret != 0) {
> +		PMD_DRV_LOG(ERR, "Failed to initialize mutex\n");
> +		return -1;
> +	}
> +
> +	rte_atomic16_set(&s->enable_intr, 0);
> +	s->qtest_socket = qtest_socket;
> +	s->ivshmem_socket = ivshmem_socket;
> +	hw->qsession = (void *)s;
> +
> +	ret = pthread_create(&s->event_th, NULL, qtest_event_handler, s);
> +	if (ret != 0) {
> +		PMD_DRV_LOG(ERR, "Failed to create event handler\n");
> +		return -1;
> +	}
> +
> +	ret = pthread_create(&s->intr_th, NULL, qtest_intr_handler, s);
> +	if (ret != 0) {
> +		PMD_DRV_LOG(ERR, "Failed to create interrupt handler\n");
> +		return -1;
> +	}
> +
> +	ret = qtest_intr_initialize(data);
> +	if (ret != 0) {
> +		PMD_DRV_LOG(ERR, "Failed to initialize interrupt\n");
> +		return -1;
> +	}
> +
> +	ret = qtest_setup_shared_memory(s);
> +	if (ret != 0) {
> +		PMD_DRV_LOG(ERR, "Failed to setup shared memory\n");
> +		return -1;
> +	}
> +
> +	ret = qtest_init_pci_devices(s);
> +	if (ret != 0) {
> +		PMD_DRV_LOG(ERR, "Failed to initialize devices\n");
> +		return -1;
> +	}
> +
> +	return 0;
> +}
> +
> +static void
> +qtest_remove_target_devices(struct qtest_session *s)
> +{
> +	struct qtest_pci_device *dev, *next;
> +
> +	for (dev = TAILQ_FIRST(&s->head); dev != NULL; dev = next) {
> +		next = TAILQ_NEXT(dev, next);
> +		TAILQ_REMOVE(&s->head, dev, next);
> +		free(dev);
> +	}
> +}
> +
> +void
> +qtest_vdev_uninit(struct rte_eth_dev_data *data)
> +{
> +	struct virtio_hw *hw = ((struct rte_eth_dev_data *)data)->dev_private;
> +	struct qtest_session *s;
> +
> +	s = (struct qtest_session *)hw->qsession;
> +
> +	qtest_close_sockets(s);
> +
> +	pthread_cancel(s->event_th);
> +	pthread_join(s->event_th, NULL);
> +
> +	pthread_cancel(s->intr_th);
> +	pthread_join(s->intr_th, NULL);
> +
> +	pthread_mutex_destroy(&s->qtest_session_lock);
> +
> +	qtest_remove_target_devices(s);
> +
> +	rte_free(s);
> +}
> diff --git a/drivers/net/virtio/virtio_ethdev.c b/drivers/net/virtio/virtio_ethdev.c
> index d928339..234b561 100644
> --- a/drivers/net/virtio/virtio_ethdev.c
> +++ b/drivers/net/virtio/virtio_ethdev.c
> @@ -36,6 +36,11 @@
>  #include <stdio.h>
>  #include <errno.h>
>  #include <unistd.h>
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +#include <sys/types.h>
> +#include <sys/socket.h>
> +#include <sys/un.h>
> +#endif
>  #ifdef RTE_EXEC_ENV_LINUXAPP
>  #include <dirent.h>
>  #include <fcntl.h>
> @@ -56,6 +61,10 @@
>  #include <rte_memory.h>
>  #include <rte_eal.h>
>  #include <rte_dev.h>
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +#include <rte_eal_memconfig.h>
> +#include <rte_kvargs.h>
> +#endif
> 
>  #include "virtio_ethdev.h"
>  #include "virtio_pci.h"
> @@ -491,8 +500,12 @@ virtio_dev_close(struct rte_eth_dev *dev)
>  	PMD_INIT_LOG(DEBUG, "virtio_dev_close");
> 
>  	/* reset the NIC */
> -	if (pci_dev->driver->drv_flags & RTE_PCI_DRV_INTR_LSC)
> +	if (((dev->dev_type == RTE_ETH_DEV_PCI) &&
> +			(pci_dev->driver->drv_flags & RTE_PCI_DRV_INTR_LSC)) ||
> +			((dev->dev_type == RTE_ETH_DEV_VIRTUAL) &&
> +			(dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC))) {
>  		vtpci_irq_config(hw, VIRTIO_MSI_NO_VECTOR);
> +	}
>  	vtpci_reset(hw);
>  	hw->started = 0;
>  	virtio_dev_free_mbufs(dev);
> @@ -1233,15 +1246,22 @@ virtio_interrupt_handler(__rte_unused struct rte_intr_handle *handle,
>  	isr = vtpci_isr(hw);
>  	PMD_DRV_LOG(INFO, "interrupt status = %#x", isr);
> 
> -	if (rte_intr_enable(&dev->pci_dev->intr_handle) < 0)
> -		PMD_DRV_LOG(ERR, "interrupt enable failed");
> +	if (dev->dev_type == RTE_ETH_DEV_PCI) {
> +		if (rte_intr_enable(&dev->pci_dev->intr_handle) < 0)
> +			PMD_DRV_LOG(ERR, "interrupt enable failed");
> +	}
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +	else if (dev->dev_type == RTE_ETH_DEV_VIRTUAL) {
> +		if (qtest_intr_enable(dev->data) < 0)
> +			PMD_DRV_LOG(ERR, "interrupt enable failed");
> +	}
> +#endif
> 
>  	if (isr & VIRTIO_PCI_ISR_CONFIG) {
>  		if (virtio_dev_link_update(dev, 0) == 0)
>  			_rte_eth_dev_callback_process(dev,
>  						      RTE_ETH_EVENT_INTR_LSC);
>  	}
> -
>  }
> 
>  static void
> @@ -1264,7 +1284,8 @@ eth_virtio_dev_init(struct rte_eth_dev *eth_dev)
>  	struct virtio_hw *hw = eth_dev->data->dev_private;
>  	struct virtio_net_config *config;
>  	struct virtio_net_config local_config;
> -	struct rte_pci_device *pci_dev;
> +	struct rte_pci_device *pci_dev = eth_dev->pci_dev;
> +	struct rte_pci_id id;
> 
>  	RTE_BUILD_BUG_ON(RTE_PKTMBUF_HEADROOM < sizeof(struct virtio_net_hdr));
> 
> @@ -1285,13 +1306,20 @@ eth_virtio_dev_init(struct rte_eth_dev *eth_dev)
>  		return -ENOMEM;
>  	}
> 
> -	pci_dev = eth_dev->pci_dev;
> +	if (eth_dev->dev_type == RTE_ETH_DEV_PCI) {
> +		if (virtio_resource_init(pci_dev) < 0)
> +			return -1;
> 
> -	if (virtio_resource_init(pci_dev) < 0)
> -		return -1;
> -
> -	hw->use_msix = virtio_has_msix(&pci_dev->addr);
> -	hw->io_base = (uint32_t)(uintptr_t)pci_dev->mem_resource[0].addr;
> +		hw->use_msix = virtio_has_msix(&pci_dev->addr);
> +		hw->io_base = (uint32_t)(uintptr_t)pci_dev->mem_resource[0].addr;
> +	}
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +	else if (eth_dev->dev_type == RTE_ETH_DEV_VIRTUAL) {
> +		hw->use_msix = 0;
> +		hw->io_base = 0;
> +		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
> +	}
> +#endif
> 
>  	/* Reset the device although not necessary at startup */
>  	vtpci_reset(hw);
> @@ -1304,8 +1332,14 @@ eth_virtio_dev_init(struct rte_eth_dev *eth_dev)
>  	virtio_negotiate_features(hw);
> 
>  	/* If host does not support status then disable LSC */
> -	if (!vtpci_with_feature(hw, VIRTIO_NET_F_STATUS))
> -		pci_dev->driver->drv_flags &= ~RTE_PCI_DRV_INTR_LSC;
> +	if (!vtpci_with_feature(hw, VIRTIO_NET_F_STATUS)) {
> +		if (eth_dev->dev_type == RTE_ETH_DEV_PCI)
> +			pci_dev->driver->drv_flags &= ~RTE_PCI_DRV_INTR_LSC;
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +		else if (eth_dev->dev_type == RTE_ETH_DEV_VIRTUAL)
> +			eth_dev->data->dev_flags &= ~RTE_ETH_DEV_INTR_LSC;
> +#endif
> +	}
> 
>  	rte_eth_copy_pci_info(eth_dev, pci_dev);
> 
> @@ -1383,14 +1417,30 @@ eth_virtio_dev_init(struct rte_eth_dev *eth_dev)
> 
>  	PMD_INIT_LOG(DEBUG, "hw->max_rx_queues=%d   hw->max_tx_queues=%d",
>  			hw->max_rx_queues, hw->max_tx_queues);
> +
> +	memset(&id, 0, sizeof(id));
> +	if (eth_dev->dev_type == RTE_ETH_DEV_PCI)
> +		id = pci_dev->id;
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +	else if (eth_dev->dev_type == RTE_ETH_DEV_VIRTUAL)
> +		id = qtest_get_pci_id_of_virtio_net();
> +#endif
> +
>  	PMD_INIT_LOG(DEBUG, "port %d vendorID=0x%x deviceID=0x%x",
> -			eth_dev->data->port_id, pci_dev->id.vendor_id,
> -			pci_dev->id.device_id);
> +			eth_dev->data->port_id,
> +			id.vendor_id, id.device_id);
> 
>  	/* Setup interrupt callback  */
> -	if (pci_dev->driver->drv_flags & RTE_PCI_DRV_INTR_LSC)
> +	if ((eth_dev->dev_type == RTE_ETH_DEV_PCI) &&
> +			(pci_dev->driver->drv_flags & RTE_PCI_DRV_INTR_LSC))
>  		rte_intr_callback_register(&pci_dev->intr_handle,
> -				   virtio_interrupt_handler, eth_dev);
> +				virtio_interrupt_handler, eth_dev);
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +	else if ((eth_dev->dev_type == RTE_ETH_DEV_VIRTUAL) &&
> +			(eth_dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC))
> +		qtest_intr_callback_register(eth_dev->data,
> +				virtio_interrupt_handler, eth_dev);
> +#endif
> 
>  	virtio_dev_cq_start(eth_dev);
> 
> @@ -1424,10 +1474,17 @@ eth_virtio_dev_uninit(struct rte_eth_dev *eth_dev)
>  	eth_dev->data->mac_addrs = NULL;
> 
>  	/* reset interrupt callback  */
> -	if (pci_dev->driver->drv_flags & RTE_PCI_DRV_INTR_LSC)
> +	if ((eth_dev->dev_type == RTE_ETH_DEV_PCI) &&
> +			(pci_dev->driver->drv_flags & RTE_PCI_DRV_INTR_LSC))
>  		rte_intr_callback_unregister(&pci_dev->intr_handle,
>  						virtio_interrupt_handler,
>  						eth_dev);
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +	else if ((eth_dev->dev_type == RTE_ETH_DEV_VIRTUAL) &&
> +			(eth_dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC))
> +		qtest_intr_callback_unregister(eth_dev->data,
> +				virtio_interrupt_handler, eth_dev);
> +#endif
> 
>  	PMD_INIT_LOG(DEBUG, "dev_uninit completed");
> 
> @@ -1491,11 +1548,15 @@ virtio_dev_configure(struct rte_eth_dev *dev)
>  		return -ENOTSUP;
>  	}
> 
> -	if (pci_dev->driver->drv_flags & RTE_PCI_DRV_INTR_LSC)
> +	if (((dev->dev_type == RTE_ETH_DEV_PCI) &&
> +			(pci_dev->driver->drv_flags & RTE_PCI_DRV_INTR_LSC)) ||
> +			((dev->dev_type == RTE_ETH_DEV_VIRTUAL) &&
> +			(dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC))) {
>  		if (vtpci_irq_config(hw, 0) == VIRTIO_MSI_NO_VECTOR) {
>  			PMD_DRV_LOG(ERR, "failed to set config vector");
>  			return -EBUSY;
>  		}
> +	}
> 
>  	return 0;
>  }
> @@ -1510,15 +1571,31 @@ virtio_dev_start(struct rte_eth_dev *dev)
> 
>  	/* check if lsc interrupt feature is enabled */
>  	if (dev->data->dev_conf.intr_conf.lsc) {
> -		if (!(pci_dev->driver->drv_flags & RTE_PCI_DRV_INTR_LSC)) {
> -			PMD_DRV_LOG(ERR, "link status not supported by host");
> -			return -ENOTSUP;
> -		}
> +		if (dev->dev_type == RTE_ETH_DEV_PCI) {
> +			if (!(pci_dev->driver->drv_flags & RTE_PCI_DRV_INTR_LSC)) {
> +				PMD_DRV_LOG(ERR,
> +					"link status not supported by host");
> +				return -ENOTSUP;
> +			}
> 
> -		if (rte_intr_enable(&dev->pci_dev->intr_handle) < 0) {
> -			PMD_DRV_LOG(ERR, "interrupt enable failed");
> -			return -EIO;
> +			if (rte_intr_enable(&dev->pci_dev->intr_handle) < 0) {
> +				PMD_DRV_LOG(ERR, "interrupt enable failed");
> +				return -EIO;
> +			}
>  		}
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +		else if (dev->dev_type == RTE_ETH_DEV_VIRTUAL) {
> +			if (!(dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC)) {
> +				PMD_DRV_LOG(ERR,
> +					"link status not supported by host");
> +				return -ENOTSUP;
> +			}
> +			if (qtest_intr_enable(dev->data) < 0) {
> +				PMD_DRV_LOG(ERR, "interrupt enable failed");
> +				return -EIO;
> +			}
> +		}
> +#endif
>  	}
> 
>  	/* Initialize Link state */
> @@ -1615,8 +1692,15 @@ virtio_dev_stop(struct rte_eth_dev *dev)
> 
>  	PMD_INIT_LOG(DEBUG, "stop");
> 
> -	if (dev->data->dev_conf.intr_conf.lsc)
> -		rte_intr_disable(&dev->pci_dev->intr_handle);
> +	if (dev->data->dev_conf.intr_conf.lsc) {
> +		if (dev->dev_type == RTE_ETH_DEV_PCI)
> +			rte_intr_disable(&dev->pci_dev->intr_handle);
> +
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +		if (dev->dev_type == RTE_ETH_DEV_VIRTUAL)
> +			qtest_intr_disable(dev->data);
> +#endif
> +	}
> 
>  	memset(&link, 0, sizeof(link));
>  	virtio_dev_atomic_write_link_status(dev, &link);
> @@ -1661,7 +1745,13 @@ virtio_dev_info_get(struct rte_eth_dev *dev, struct rte_eth_dev_info
> *dev_info)
>  {
>  	struct virtio_hw *hw = dev->data->dev_private;
> 
> -	dev_info->driver_name = dev->driver->pci_drv.name;
> +	if (dev->dev_type == RTE_ETH_DEV_PCI)
> +		dev_info->driver_name = dev->driver->pci_drv.name;
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +	else if (dev->dev_type == RTE_ETH_DEV_VIRTUAL)
> +		dev_info->driver_name =  dev->data->drv_name;
> +#endif
> +
>  	dev_info->max_rx_queues = (uint16_t)hw->max_rx_queues;
>  	dev_info->max_tx_queues = (uint16_t)hw->max_tx_queues;
>  	dev_info->min_rx_bufsize = VIRTIO_MIN_RX_BUFSIZE;
> @@ -1689,3 +1779,196 @@ static struct rte_driver rte_virtio_driver = {
>  };
> 
>  PMD_REGISTER_DRIVER(rte_virtio_driver);
> +
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +
> +#define ETH_VIRTIO_NET_ARG_QTEST_PATH           "qtest"
> +#define ETH_VIRTIO_NET_ARG_IVSHMEM_PATH         "ivshmem"
> +
> +static const char *valid_args[] = {
> +	ETH_VIRTIO_NET_ARG_QTEST_PATH,
> +	ETH_VIRTIO_NET_ARG_IVSHMEM_PATH,
> +	NULL
> +};
> +
> +static int
> +get_string_arg(const char *key __rte_unused,
> +		const char *value, void *extra_args)
> +{
> +	int ret, fd, loop = 3;
> +	int *pfd = extra_args;
> +	struct sockaddr_un sa = {0};
> +
> +	if ((value == NULL) || (extra_args == NULL))
> +		return -EINVAL;
> +
> +	fd = socket(AF_UNIX, SOCK_STREAM, 0);
> +	if (fd < 0)
> +		return -1;
> +
> +	sa.sun_family = AF_UNIX;
> +	strncpy(sa.sun_path, value, sizeof(sa.sun_path));
> +
> +	while (loop--) {
> +		/*
> +		 * may need to wait for qtest and ivshmem
> +		 * sockets are prepared by QEMU.
> +		 */
> +		ret = connect(fd, (struct sockaddr *)&sa,
> +				sizeof(struct sockaddr_un));
> +		if (ret != 0)
> +			sleep(1);
> +		else
> +			break;
> +	}
> +
> +	if (ret != 0) {
> +		close(fd);
> +		return -1;
> +	}
> +
> +	*pfd = fd;
> +
> +	return 0;
> +}
> +
> +static struct rte_eth_dev *
> +virtio_net_eth_dev_alloc(const char *name)
> +{
> +	struct rte_eth_dev *eth_dev;
> +	struct rte_eth_dev_data *data;
> +	struct virtio_hw *hw;
> +
> +	eth_dev = rte_eth_dev_allocate(name, RTE_ETH_DEV_VIRTUAL);
> +	if (eth_dev == NULL)
> +		rte_panic("cannot alloc rte_eth_dev\n");
> +
> +	data = eth_dev->data;
> +
> +	hw = rte_zmalloc(NULL, sizeof(*hw), 0);
> +	if (!hw)
> +		rte_panic("malloc virtio_hw failed\n");
> +
> +	data->dev_private = hw;
> +	eth_dev->driver = &rte_virtio_pmd;
> +	return eth_dev;
> +}
> +
> +/*
> + * Initialization when "CONFIG_RTE_LIBRTE_VIRTIO_HOST_MODE" is enabled.
> + */
> +static int
> +rte_virtio_net_pmd_init(const char *name, const char *params)
> +{
> +	struct rte_kvargs *kvlist = NULL;
> +	struct rte_eth_dev *eth_dev = NULL;
> +	int ret, qtest_sock, ivshmem_sock;
> +	struct rte_mem_config *mcfg;
> +
> +	if (params == NULL || params[0] == '\0')
> +		goto error;
> +
> +	/* get pointer to global configuration */
> +	mcfg = rte_eal_get_configuration()->mem_config;
> +
> +	/* Check if EAL memory consists of one memory segment */
> +	if ((RTE_MAX_MEMSEG > 1) && (mcfg->memseg[1].addr != NULL)) {
> +		PMD_INIT_LOG(ERR, "Non contigious memory");
> +		goto error;
> +	}
> +
> +	kvlist = rte_kvargs_parse(params, valid_args);
> +	if (!kvlist) {
> +		PMD_INIT_LOG(ERR, "error when parsing param");
> +		goto error;
> +	}
> +
> +	if (rte_kvargs_count(kvlist, ETH_VIRTIO_NET_ARG_IVSHMEM_PATH) == 1) {
> +		ret = rte_kvargs_process(kvlist, ETH_VIRTIO_NET_ARG_IVSHMEM_PATH,
> +				&get_string_arg, &ivshmem_sock);
> +		if (ret != 0) {
> +			PMD_INIT_LOG(ERR,
> +				"Failed to connect to ivshmem socket");
> +			goto error;
> +		}
> +	} else {
> +		PMD_INIT_LOG(ERR, "No argument specified for %s",
> +				ETH_VIRTIO_NET_ARG_IVSHMEM_PATH);
> +		goto error;
> +	}
> +
> +	if (rte_kvargs_count(kvlist, ETH_VIRTIO_NET_ARG_QTEST_PATH) == 1) {
> +		ret = rte_kvargs_process(kvlist, ETH_VIRTIO_NET_ARG_QTEST_PATH,
> +				&get_string_arg, &qtest_sock);
> +		if (ret != 0) {
> +			PMD_INIT_LOG(ERR,
> +				"Failed to connect to qtest socket");
> +			goto error;
> +		}
> +	} else {
> +		PMD_INIT_LOG(ERR, "No argument specified for %s",
> +				ETH_VIRTIO_NET_ARG_QTEST_PATH);
> +		goto error;
> +	}
> +
> +	eth_dev = virtio_net_eth_dev_alloc(name);
> +
> +	qtest_vdev_init(eth_dev->data, qtest_sock, ivshmem_sock);
> +
> +	/* originally, this will be called in rte_eal_pci_probe() */
> +	eth_virtio_dev_init(eth_dev);
> +
> +	eth_dev->driver = NULL;
> +	eth_dev->data->dev_flags |= RTE_ETH_DEV_DETACHABLE;
> +	eth_dev->data->kdrv = RTE_KDRV_NONE;
> +	eth_dev->data->drv_name = "rte_virtio_pmd";
> +
> +	rte_kvargs_free(kvlist);
> +	return 0;
> +
> +error:
> +	rte_kvargs_free(kvlist);
> +	return -EFAULT;
> +}
> +
> +/*
> + * Finalization when "CONFIG_RTE_LIBRTE_VIRTIO_HOST_MODE" is enabled.
> + */
> +static int
> +rte_virtio_net_pmd_uninit(const char *name)
> +{
> +	struct rte_eth_dev *eth_dev = NULL;
> +	int ret;
> +
> +	if (name == NULL)
> +		return -EINVAL;
> +
> +	/* find the ethdev entry */
> +	eth_dev = rte_eth_dev_allocated(name);
> +	if (eth_dev == NULL)
> +		return -ENODEV;
> +
> +	ret = eth_virtio_dev_uninit(eth_dev);
> +	if (ret != 0)
> +		return -EFAULT;
> +
> +	qtest_vdev_uninit(eth_dev->data);
> +	rte_free(eth_dev->data->dev_private);
> +
> +	ret = rte_eth_dev_release_port(eth_dev);
> +	if (ret != 0)
> +		return -EFAULT;
> +
> +	return 0;
> +}
> +
> +static struct rte_driver rte_virtio_net_driver = {
> +	.name   = "eth_virtio_net",
> +	.type   = PMD_VDEV,
> +	.init   = rte_virtio_net_pmd_init,
> +	.uninit = rte_virtio_net_pmd_uninit,
> +};
> +
> +PMD_REGISTER_DRIVER(rte_virtio_net_driver);
> +
> +#endif /* RTE_LIBRTE_VIRTIO_HOST_MODE */
> diff --git a/drivers/net/virtio/virtio_ethdev.h b/drivers/net/virtio/virtio_ethdev.h
> index ae2d47d..eefc7be 100644
> --- a/drivers/net/virtio/virtio_ethdev.h
> +++ b/drivers/net/virtio/virtio_ethdev.h
> @@ -122,5 +122,17 @@ uint16_t virtio_xmit_pkts_simple(void *tx_queue, struct rte_mbuf
> **tx_pkts,
>  #define VTNET_LRO_FEATURES (VIRTIO_NET_F_GUEST_TSO4 | \
>  			    VIRTIO_NET_F_GUEST_TSO6 | VIRTIO_NET_F_GUEST_ECN)
> 
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +int qtest_vdev_init(struct rte_eth_dev_data *data,
> +		int qtest_socket, int ivshmem_socket);
> +void qtest_vdev_uninit(struct rte_eth_dev_data *data);
> +void qtest_intr_callback_register(void *data,
> +		rte_intr_callback_fn cb, void *cb_arg);
> +void qtest_intr_callback_unregister(void *data,
> +		rte_intr_callback_fn cb, void *cb_arg);
> +int qtest_intr_enable(void *data);
> +int qtest_intr_disable(void *data);
> +struct rte_pci_id qtest_get_pci_id_of_virtio_net(void);
> +#endif /* RTE_LIBRTE_VIRTIO_HOST_MODE */
> 
>  #endif /* _VIRTIO_ETHDEV_H_ */
> diff --git a/drivers/net/virtio/virtio_pci.h b/drivers/net/virtio/virtio_pci.h
> index 47f722a..d4ede73 100644
> --- a/drivers/net/virtio/virtio_pci.h
> +++ b/drivers/net/virtio/virtio_pci.h
> @@ -165,6 +165,9 @@ struct virtqueue;
> 
>  struct virtio_hw {
>  	struct virtqueue *cvq;
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +	void        *qsession;
> +#endif
>  	uint32_t    io_base;
>  	uint32_t    guest_features;
>  	uint32_t    max_tx_queues;
> @@ -226,6 +229,26 @@ outl_p(unsigned int data, unsigned int port)
>  }
>  #endif
> 
> +#ifdef RTE_LIBRTE_VIRTIO_HOST_MODE
> +
> +uint32_t virtio_ioport_read(struct virtio_hw *, uint64_t, char type);
> +void virtio_ioport_write(struct virtio_hw *, uint64_t, uint64_t, char type);
> +
> +#define VIRTIO_READ_REG_1(hw, reg) \
> +	virtio_ioport_read(hw, reg, 'b')
> +#define VIRTIO_WRITE_REG_1(hw, reg, value) \
> +	virtio_ioport_write(hw, reg, value, 'b')
> +#define VIRTIO_READ_REG_2(hw, reg) \
> +	virtio_ioport_read(hw, reg, 'w')
> +#define VIRTIO_WRITE_REG_2(hw, reg, value) \
> +	virtio_ioport_write(hw, reg, value, 'w')
> +#define VIRTIO_READ_REG_4(hw, reg) \
> +	virtio_ioport_read(hw, reg, 'l')
> +#define VIRTIO_WRITE_REG_4(hw, reg, value) \
> +	virtio_ioport_write(hw, reg, value, 'l')
> +
> +#else /* RTE_LIBRTE_VIRTIO_HOST_MODE */
> +

 I have a concern against such compile-time switches. What if we want the same code to work for both 'real' virtio and socket-based?
Shouldn't we introduce some function pointers here to be able to switch them at runtime?

>  #define VIRTIO_PCI_REG_ADDR(hw, reg) \
>  	(unsigned short)((hw)->io_base + (reg))
> 
> @@ -244,6 +267,8 @@ outl_p(unsigned int data, unsigned int port)
>  #define VIRTIO_WRITE_REG_4(hw, reg, value) \
>  	outl_p((unsigned int)(value), (VIRTIO_PCI_REG_ADDR((hw), (reg))))
> 
> +#endif /* RTE_LIBRTE_VIRTIO_HOST_MODE */
> +
>  static inline int
>  vtpci_with_feature(struct virtio_hw *hw, uint32_t bit)
>  {
> --
> 2.1.4

Kind regards,
Pavel Fedin
Expert Engineer
Samsung Electronics Research center Russia

  reply	other threads:[~2015-12-28 11:57 UTC|newest]

Thread overview: 22+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2015-11-19 10:57 [dpdk-dev] [RFC PATCH 0/2] Virtio-net PMD Extension to work on host Tetsuya Mukawa
2015-11-19 10:57 ` [dpdk-dev] [RFC PATCH 1/2] EAL: Add new EAL "--shm" option Tetsuya Mukawa
2015-12-16  8:37   ` [dpdk-dev] [PATCH v1 0/2] Virtio-net PMD Extension to work on host Tetsuya Mukawa
2015-12-16  8:37     ` [dpdk-dev] [PATCH v1 1/2] EAL: Add new EAL "--contig-mem" option Tetsuya Mukawa
2015-12-16  8:37     ` [dpdk-dev] [PATCH v1 2/2] virtio: Extend virtio-net PMD to support container environment Tetsuya Mukawa
2015-12-28 11:57       ` Pavel Fedin [this message]
2016-01-06  3:57         ` Tetsuya Mukawa
2016-01-06  5:56           ` Tan, Jianfeng
2016-01-06  7:27             ` Tetsuya Mukawa
2015-12-24 14:05     ` [dpdk-dev] [PATCH v1 0/2] Virtio-net PMD Extension to work on host Tan, Jianfeng
2015-12-28 11:06       ` Tetsuya Mukawa
2016-01-06  3:57         ` Tetsuya Mukawa
2016-01-06  5:42           ` Tan, Jianfeng
2016-01-06  7:35             ` Tetsuya Mukawa
2016-01-11  5:31               ` Tan, Jianfeng
2015-11-19 10:57 ` [dpdk-dev] [RFC PATCH 2/2] virtio: Extend virtio-net PMD to support container environment Tetsuya Mukawa
2015-11-19 18:16 ` [dpdk-dev] [RFC PATCH 0/2] Virtio-net PMD Extension to work on host Rich Lane
2015-11-20  2:00   ` Xie, Huawei
2015-11-20  2:35     ` Tetsuya Mukawa
2015-11-20  2:53       ` Tetsuya Mukawa
2015-12-28  5:15 ` Qiu, Michael
2015-12-28 11:06   ` Tetsuya Mukawa

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to='004a01d14166$f52be7e0$df83b7a0$@samsung.com' \
    --to=p.fedin@samsung.com \
    --cc=dev@dpdk.org \
    --cc=mst@redhat.com \
    --cc=mukawa@igel.co.jp \
    --cc=nakajima.yoshihiro@lab.ntt.co.jp \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).