d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

net/virtio-user: add virtual device

Browse Source 
Add a new virtual device named virtio-user, which can be used just like
eth_ring, eth_null, etc. To reuse the code of original virtio, we do
some adjustment in virtio_ethdev.c, such as remove key _static_ of
eth_virtio_dev_init() so that it can be reused in virtual device; and
we add some check to make sure it will not crash.

Configured parameters include:
  - queues (optional, 1 by default), number of queue pairs, multi-queue
    not supported for now.
  - cq (optional, 0 by default), not supported for now.
  - mac (optional), random value will be given if not specified.
  - queue_size (optional, 256 by default), size of virtqueues.
  - path (madatory), path of vhost user.

When enable CONFIG_RTE_VIRTIO_USER (enabled by default), the compiled
library can be used in both VM and container environment.

Examples:
path_vhost=<path_to_vhost_user> # use vhost-user as a backend

sudo ./examples/l2fwd/build/l2fwd -c 0x100000 -n 4 \
    --socket-mem 0,1024 --no-pci --file-prefix=l2fwd \
    --vdev=virtio-user0,mac=00:01:02:03:04:05,path=$path_vhost -- -p 0x1

Known issues:
 - Control queue and multi-queue are not supported yet.
 - Cannot work with --huge-unlink.
 - Cannot work with no-huge.
 - Cannot work when there are more than VHOST_MEMORY_MAX_NREGIONS(8)
   hugepages.
 - Root privilege is a must (mainly becase of sorting hugepages according
   to physical address).
 - Applications should not use file name like HUGEFILE_FMT ("%smap_%d").
 - Cannot work with vhost-net backend.

Signed-off-by: Huawei Xie <huawei.xie@intel.com>
Signed-off-by: Jianfeng Tan <jianfeng.tan@intel.com>
Acked-by: Neil Horman <nhorman@tuxdriver.com>
Acked-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
This commit is contained in:
Jianfeng Tan 2016-06-15 09:03:25 +00:00 committed by Yuanhan Liu
parent e9efa4d938
commit ce2eabdd43
5 changed files with 253 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
doc/guides/rel_notes/release_16_07.rst
View File

@ -51,6 +51,19 @@ New Features
The ioports are mapped in memory when using Linux UIO.
* **Virtio support for containers.**
Add a new virtual device, named virtio-user, to support virtio for containers.
Known limitations:
* Control queue and multi-queue are not supported yet.
* Cannot work with --huge-unlink.
* Cannot work with --no-huge.
* Cannot work when there are more than VHOST_MEMORY_MAX_NREGIONS(8) hugepages.
* Root privilege is a must for sorting hugepages by physical address.
* Can only be used with vhost user backend.
* **Added vhost-user client mode.**
DPDK vhost-user could be the server as well as the client. It supports

17
doc/guides/sample_app_ug/vhost.rst
View File

@ -833,3 +833,20 @@ For example:
The above message indicates that device 0 has been registered with MAC address cc:bb:bb:bb:bb:bb and VLAN tag 1000.
Any packets received on the NIC with these values is placed on the devices receive queue.
When a virtio-net device transmits packets, the VLAN tag is added to the packet by the DPDK vhost sample code.
Running virtio-user with vhost-switch
-------------------------------------
We can also use virtio-user with vhost-switch now.
Virtio-user is a virtual device that can be run in a application (container) parallelly with vhost in the same OS,
aka, there is no need to start a VM. We just run it with a different --file-prefix to avoid startup failure.
.. code-block:: console
cd ${RTE_SDK}/x86_64-native-linuxapp-gcc/app
./testpmd -c 0x3 -n 4 --socket-mem 1024 --no-pci --file-prefix=virtio-user-testpmd \
--vdev=virtio-user0,mac=00:01:02:03:04:05,path=$path_vhost \
-- -i --txqflags=0xf01 --disable-hw-vlan
There is no difference on the vhost side.
Pleae note that there are some limitations (see release note for more information) in the usage of virtio-user.

19
drivers/net/virtio/virtio_ethdev.c
View File

@ -59,7 +59,6 @@
#include "virtqueue.h"
#include "virtio_rxtx.h"
static int eth_virtio_dev_init(struct rte_eth_dev *eth_dev);
static int eth_virtio_dev_uninit(struct rte_eth_dev *eth_dev);
static int virtio_dev_configure(struct rte_eth_dev *dev);
static int virtio_dev_start(struct rte_eth_dev *dev);
@ -1130,7 +1129,7 @@ rx_func_get(struct rte_eth_dev *eth_dev)
* This function is based on probe() function in virtio_pci.c
* It returns 0 on success.
*/
static int
int
eth_virtio_dev_init(struct rte_eth_dev *eth_dev)
{
struct virtio_hw *hw = eth_dev->data->dev_private;
@ -1161,9 +1160,11 @@ eth_virtio_dev_init(struct rte_eth_dev *eth_dev)
pci_dev = eth_dev->pci_dev;
ret = vtpci_init(pci_dev, hw, &dev_flags);
if (ret)
return ret;
if (pci_dev) {
ret = vtpci_init(pci_dev, hw, &dev_flags);
if (ret)
return ret;
}
/* Reset the device although not necessary at startup */
vtpci_reset(hw);
@ -1255,7 +1256,8 @@ 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);
PMD_INIT_LOG(DEBUG, "port %d vendorID=0x%x deviceID=0x%x",
if (pci_dev)
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);
@ -1543,7 +1545,10 @@ 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->pci_dev)
dev_info->driver_name = dev->driver->pci_drv.name;
else
dev_info->driver_name = "virtio-user PMD";
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;

2
drivers/net/virtio/virtio_ethdev.h
View File

@ -113,6 +113,8 @@ uint16_t virtio_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
uint16_t virtio_xmit_pkts_simple(void *tx_queue, struct rte_mbuf **tx_pkts,
uint16_t nb_pkts);
int eth_virtio_dev_init(struct rte_eth_dev *eth_dev);
/*
* The VIRTIO_NET_F_GUEST_TSO[46] features permit the host to send us
* frames larger than 1514 bytes. We do not yet support software LRO

209
drivers/net/virtio/virtio_user_ethdev.c
View File

@ -35,6 +35,10 @@
#include <sys/types.h>
#include <unistd.h>
#include <rte_malloc.h>
#include <rte_kvargs.h>
#include "virtio_ethdev.h"
#include "virtio_logs.h"
#include "virtio_pci.h"
#include "virtqueue.h"
@ -216,3 +220,208 @@ static const struct virtio_pci_ops virtio_user_ops = {
.del_queue = virtio_user_del_queue,
.notify_queue = virtio_user_notify_queue,
};
static const char *valid_args[] = {
#define VIRTIO_USER_ARG_QUEUES_NUM "queues"
VIRTIO_USER_ARG_QUEUES_NUM,
#define VIRTIO_USER_ARG_CQ_NUM "cq"
VIRTIO_USER_ARG_CQ_NUM,
#define VIRTIO_USER_ARG_MAC "mac"
VIRTIO_USER_ARG_MAC,
#define VIRTIO_USER_ARG_PATH "path"
VIRTIO_USER_ARG_PATH,
#define VIRTIO_USER_ARG_QUEUE_SIZE "queue_size"
VIRTIO_USER_ARG_QUEUE_SIZE,
NULL
};
#define VIRTIO_USER_DEF_CQ_EN 0
#define VIRTIO_USER_DEF_Q_NUM 1
#define VIRTIO_USER_DEF_Q_SZ 256
static int
get_string_arg(const char *key __rte_unused,
const char *value, void *extra_args)
{
if (!value || !extra_args)
return -EINVAL;
*(char **)extra_args = strdup(value);
return 0;
}
static int
get_integer_arg(const char *key __rte_unused,
const char *value, void *extra_args)
{
if (!value || !extra_args)
return -EINVAL;
*(uint64_t *)extra_args = strtoull(value, NULL, 0);
return 0;
}
static struct rte_eth_dev *
virtio_user_eth_dev_alloc(const char *name)
{
struct rte_eth_dev *eth_dev;
struct rte_eth_dev_data *data;
struct virtio_hw *hw;
struct virtio_user_dev *dev;
eth_dev = rte_eth_dev_allocate(name, RTE_ETH_DEV_VIRTUAL);
if (!eth_dev) {
PMD_INIT_LOG(ERR, "cannot alloc rte_eth_dev");
return NULL;
}
data = eth_dev->data;
hw = rte_zmalloc(NULL, sizeof(*hw), 0);
if (!hw) {
PMD_INIT_LOG(ERR, "malloc virtio_hw failed");
rte_eth_dev_release_port(eth_dev);
return NULL;
}
dev = rte_zmalloc(NULL, sizeof(*dev), 0);
if (!dev) {
PMD_INIT_LOG(ERR, "malloc virtio_user_dev failed");
rte_eth_dev_release_port(eth_dev);
rte_free(hw);
return NULL;
}
hw->vtpci_ops = &virtio_user_ops;
hw->use_msix = 0;
hw->modern = 0;
hw->virtio_user_dev = dev;
data->dev_private = hw;
data->numa_node = SOCKET_ID_ANY;
data->kdrv = RTE_KDRV_NONE;
data->dev_flags = RTE_ETH_DEV_DETACHABLE;
eth_dev->pci_dev = NULL;
eth_dev->driver = NULL;
return eth_dev;
}
/* Dev initialization routine. Invoked once for each virtio vdev at
* EAL init time, see rte_eal_dev_init().
* Returns 0 on success.
*/
static int
virtio_user_pmd_devinit(const char *name, const char *params)
{
struct rte_kvargs *kvlist;
struct rte_eth_dev *eth_dev;
struct virtio_hw *hw;
uint64_t queues = VIRTIO_USER_DEF_Q_NUM;
uint64_t cq = VIRTIO_USER_DEF_CQ_EN;
uint64_t queue_size = VIRTIO_USER_DEF_Q_SZ;
char *path = NULL;
char *mac_addr = NULL;
int ret = -1;
if (!params || params[0] == '\0') {
PMD_INIT_LOG(ERR, "arg %s is mandatory for virtio-user",
VIRTIO_USER_ARG_QUEUE_SIZE);
goto end;
}
kvlist = rte_kvargs_parse(params, valid_args);
if (!kvlist) {
PMD_INIT_LOG(ERR, "error when parsing param");
goto end;
}
if (rte_kvargs_count(kvlist, VIRTIO_USER_ARG_PATH) == 1)
rte_kvargs_process(kvlist, VIRTIO_USER_ARG_PATH,
&get_string_arg, &path);
else {
PMD_INIT_LOG(ERR, "arg %s is mandatory for virtio-user\n",
VIRTIO_USER_ARG_QUEUE_SIZE);
goto end;
}
if (rte_kvargs_count(kvlist, VIRTIO_USER_ARG_MAC) == 1)
rte_kvargs_process(kvlist, VIRTIO_USER_ARG_MAC,
&get_string_arg, &mac_addr);
if (rte_kvargs_count(kvlist, VIRTIO_USER_ARG_QUEUE_SIZE) == 1)
rte_kvargs_process(kvlist, VIRTIO_USER_ARG_QUEUE_SIZE,
&get_integer_arg, &queue_size);
if (rte_kvargs_count(kvlist, VIRTIO_USER_ARG_QUEUES_NUM) == 1)
rte_kvargs_process(kvlist, VIRTIO_USER_ARG_QUEUES_NUM,
&get_integer_arg, &queues);
if (rte_kvargs_count(kvlist, VIRTIO_USER_ARG_CQ_NUM) == 1)
rte_kvargs_process(kvlist, VIRTIO_USER_ARG_CQ_NUM,
&get_integer_arg, &cq);
eth_dev = virtio_user_eth_dev_alloc(name);
if (!eth_dev) {
PMD_INIT_LOG(ERR, "virtio-user fails to alloc device");
goto end;
}
hw = eth_dev->data->dev_private;
if (virtio_user_dev_init(hw->virtio_user_dev, path, queues, cq,
queue_size, mac_addr) < 0)
goto end;
/* previously called by rte_eal_pci_probe() for physical dev */
if (eth_virtio_dev_init(eth_dev) < 0) {
PMD_INIT_LOG(ERR, "eth_virtio_dev_init fails");
goto end;
}
ret = 0;
end:
if (path)
free(path);
if (mac_addr)
free(mac_addr);
return ret;
}
/** Called by rte_eth_dev_detach() */
static int
virtio_user_pmd_devuninit(const char *name)
{
struct rte_eth_dev *eth_dev;
struct virtio_hw *hw;
struct virtio_user_dev *dev;
if (!name)
return -EINVAL;
PMD_DRV_LOG(INFO, "Un-Initializing %s\n", name);
eth_dev = rte_eth_dev_allocated(name);
if (!eth_dev)
return -ENODEV;
/* make sure the device is stopped, queues freed */
rte_eth_dev_close(eth_dev->data->port_id);
hw = eth_dev->data->dev_private;
dev = hw->virtio_user_dev;
virtio_user_dev_uninit(dev);
rte_free(eth_dev->data->dev_private);
rte_free(eth_dev->data);
rte_eth_dev_release_port(eth_dev);
return 0;
}
static struct rte_driver virtio_user_driver = {
.name = "virtio-user",
.type = PMD_VDEV,
.init = virtio_user_pmd_devinit,
.uninit = virtio_user_pmd_devuninit,
};
PMD_REGISTER_DRIVER(virtio_user_driver);