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

vhost: implement cuse memory table

Browse Source 
remove set_memory_table ops

vhost-cuse or vhost-user will both implement their own set_memory_region handler.

In current vhost-cuse implementation, guest numa memory isn't supported.
Assume that guest memory is backed by only one file.

Signed-off-by: Huawei Xie <huawei.xie@intel.com>
Signed-off-by: Przemyslaw Czesnowicz <przemyslaw.czesnowicz@intel.com>
This commit is contained in:
Huawei Xie 2015-02-23 17:36:29 +00:00 committed by Thomas Monjalon
parent c89d3e5afd
commit 9464a44160
7 changed files with 213 additions and 356 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/librte_vhost/Makefile
View File

@ -41,7 +41,7 @@ LIBABIVER := 1
CFLAGS += $(WERROR_FLAGS) -I$(SRCDIR) -I vhost_cuse -O3 -D_FILE_OFFSET_BITS=64 -lfuse
LDFLAGS += -lfuse
# all source are stored in SRCS-y
SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := vhost_cuse/vhost-net-cdev.c vhost_cuse/eventfd_copy.c virtio-net.c vhost_rxtx.c
SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := virtio-net.c vhost_cuse/vhost-net-cdev.c vhost_cuse/virtio-net-cdev.c vhost_cuse/eventfd_copy.c vhost_rxtx.c
# install includes
SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_virtio_net.h

4
lib/librte_vhost/vhost-net.h
View File

@ -41,6 +41,8 @@
#include <rte_log.h>
#define VHOST_MEMORY_MAX_NREGIONS 8
/* Macros for printing using RTE_LOG */
#define RTE_LOGTYPE_VHOST_CONFIG RTE_LOGTYPE_USER1
#define RTE_LOGTYPE_VHOST_DATA RTE_LOGTYPE_USER1
@ -92,8 +94,6 @@ struct vhost_net_device_ops {
int (*get_features)(struct vhost_device_ctx, uint64_t *);
int (*set_features)(struct vhost_device_ctx, uint64_t *);
int (*set_mem_table)(struct vhost_device_ctx, const void *, uint32_t);
int (*set_vring_num)(struct vhost_device_ctx, struct vhost_vring_state *);
int (*set_vring_addr)(struct vhost_device_ctx, struct vhost_vring_addr *);
int (*set_vring_base)(struct vhost_device_ctx, struct vhost_vring_state *);

7
lib/librte_vhost/vhost_cuse/vhost-net-cdev.c
View File

@ -44,6 +44,7 @@
#include <rte_string_fns.h>
#include <rte_virtio_net.h>
#include "virtio-net-cdev.h"
#include "vhost-net.h"
#include "eventfd_copy.h"
@ -57,7 +58,7 @@ static const char cuse_device_name[] = "/dev/cuse";
static const char default_cdev[] = "vhost-net";
static struct fuse_session *session;
static struct vhost_net_device_ops const *ops;
struct vhost_net_device_ops const *ops;
/*
* Returns vhost_device_ctx from given fuse_req_t. The index is populated later
@ -247,8 +248,8 @@ vhost_net_ioctl(fuse_req_t req, int cmd, void *arg,
break;
default:
result = ops->set_mem_table(ctx,
in_buf, mem_temp.nregions);
result = cuse_set_mem_table(ctx, in_buf,
mem_temp.nregions);
if (result)
fuse_reply_err(req, EINVAL);
else

115
lib/librte_vhost/vhost_cuse/virtio-net-cdev.c
View File

@ -47,7 +47,10 @@
#include <rte_log.h>
#include "rte_virtio_net.h"
#include "vhost-net.h"
#include "virtio-net-cdev.h"
#include "virtio-net.h"
/* Line size for reading maps file. */
static const uint32_t BUFSIZE = PATH_MAX;
@ -253,3 +256,115 @@ host_memory_map(pid_t pid, uint64_t addr,
return 0;
}
int
cuse_set_mem_table(struct vhost_device_ctx ctx,
const struct vhost_memory *mem_regions_addr, uint32_t nregions)
{
uint64_t size = offsetof(struct vhost_memory, regions);
uint32_t idx, valid_regions;
struct virtio_memory_regions *pregion;
struct vhost_memory_region *mem_regions = (void *)(uintptr_t)
((uint64_t)(uintptr_t)mem_regions_addr + size);
uint64_t base_address = 0, mapped_address, mapped_size;
struct virtio_net *dev;
dev = get_device(ctx);
if (dev == NULL)
return -1;
if (dev->mem && dev->mem->mapped_address) {
munmap((void *)(uintptr_t)dev->mem->mapped_address,
(size_t)dev->mem->mapped_size);
free(dev->mem);
dev->mem = NULL;
}
dev->mem = calloc(1, sizeof(struct virtio_memory) +
sizeof(struct virtio_memory_regions) * nregions);
if (dev->mem == NULL) {
RTE_LOG(ERR, VHOST_CONFIG,
"(%"PRIu64") Failed to allocate memory for dev->mem\n",
dev->device_fh);
return -1;
}
pregion = &dev->mem->regions[0];
for (idx = 0; idx < nregions; idx++) {
pregion[idx].guest_phys_address =
mem_regions[idx].guest_phys_addr;
pregion[idx].guest_phys_address_end =
pregion[idx].guest_phys_address +
mem_regions[idx].memory_size;
pregion[idx].memory_size =
mem_regions[idx].memory_size;
pregion[idx].userspace_address =
mem_regions[idx].userspace_addr;
LOG_DEBUG(VHOST_CONFIG,
"REGION: %u - GPA: %p - QVA: %p - SIZE (%"PRIu64")\n",
idx,
(void *)(uintptr_t)pregion[idx].guest_phys_address,
(void *)(uintptr_t)pregion[idx].userspace_address,
pregion[idx].memory_size);
/*set the base address mapping*/
if (pregion[idx].guest_phys_address == 0x0) {
base_address =
pregion[idx].userspace_address;
/* Map VM memory file */
if (host_memory_map(ctx.pid, base_address,
&mapped_address, &mapped_size) != 0) {
free(dev->mem);
dev->mem = NULL;
return -1;
}
dev->mem->mapped_address = mapped_address;
dev->mem->base_address = base_address;
dev->mem->mapped_size = mapped_size;
}
}
/* Check that we have a valid base address. */
if (base_address == 0) {
RTE_LOG(ERR, VHOST_CONFIG,
"Failed to find base address of qemu memory file.\n");
free(dev->mem);
dev->mem = NULL;
return -1;
}
valid_regions = nregions;
for (idx = 0; idx < nregions; idx++) {
if ((pregion[idx].userspace_address < base_address) ||
(pregion[idx].userspace_address >
(base_address + mapped_size)))
valid_regions--;
}
if (valid_regions != nregions) {
valid_regions = 0;
for (idx = nregions; 0 != idx--; ) {
if ((pregion[idx].userspace_address < base_address) ||
(pregion[idx].userspace_address >
(base_address + mapped_size))) {
memmove(&pregion[idx], &pregion[idx + 1],
sizeof(struct virtio_memory_regions) *
valid_regions);
} else
valid_regions++;
}
}
for (idx = 0; idx < valid_regions; idx++) {
pregion[idx].address_offset =
mapped_address - base_address +
pregion[idx].userspace_address -
pregion[idx].guest_phys_address;
}
dev->mem->nregions = valid_regions;
return 0;
}

45
lib/librte_vhost/vhost_cuse/virtio-net-cdev.h Normal file
View File

@ -0,0 +1,45 @@
/*-
* BSD LICENSE
*
* Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _VIRTIO_NET_CDEV_H
#define _VIRTIO_NET_CDEV_H
#include <stdint.h>
#include <linux/vhost.h>
#include "vhost-net.h"
int
cuse_set_mem_table(struct vhost_device_ctx ctx,
const struct vhost_memory *mem_regions_addr, uint32_t nregions);
#endif

353
lib/librte_vhost/virtio-net.c
View File

@ -31,8 +31,6 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <dirent.h>
#include <fuse/cuse_lowlevel.h>
#include <linux/vhost.h>
#include <linux/virtio_net.h>
#include <stddef.h>
@ -55,6 +53,7 @@
#include "vhost_cuse/eventfd_copy.h"
#include "vhost-net.h"
#include "virtio-net.h"
/*
* Device linked list structure for configuration.
@ -65,7 +64,7 @@ struct virtio_net_config_ll {
};
/* device ops to add/remove device to/from data core. */
static struct virtio_net_device_ops const *notify_ops;
struct virtio_net_device_ops const *notify_ops;
/* root address of the linked list of managed virtio devices */
static struct virtio_net_config_ll *ll_root;
@ -75,26 +74,6 @@ static struct virtio_net_config_ll *ll_root;
(1ULL << VIRTIO_NET_F_CTRL_RX))
static uint64_t VHOST_FEATURES = VHOST_SUPPORTED_FEATURES;
/* Line size for reading maps file. */
static const uint32_t BUFSIZE = PATH_MAX;
/* Size of prot char array in procmap. */
#define PROT_SZ 5
/* Number of elements in procmap struct. */
#define PROCMAP_SZ 8
/* Structure containing information gathered from maps file. */
struct procmap {
uint64_t va_start; /* Start virtual address in file. */
uint64_t len; /* Size of file. */
uint64_t pgoff; /* Not used. */
uint32_t maj; /* Not used. */
uint32_t min; /* Not used. */
uint32_t ino; /* Not used. */
char prot[PROT_SZ]; /* Not used. */
char fname[PATH_MAX]; /* File name. */
};
/*
* Converts QEMU virtual address to Vhost virtual address. This function is
@ -121,191 +100,6 @@ qva_to_vva(struct virtio_net *dev, uint64_t qemu_va)
return vhost_va;
}
/*
* Locate the file containing QEMU's memory space and
* map it to our address space.
*/
static int
host_memory_map(struct virtio_net *dev, struct virtio_memory *mem,
pid_t pid, uint64_t addr)
{
struct dirent *dptr = NULL;
struct procmap procmap;
DIR *dp = NULL;
int fd;
int i;
char memfile[PATH_MAX];
char mapfile[PATH_MAX];
char procdir[PATH_MAX];
char resolved_path[PATH_MAX];
char *path = NULL;
FILE *fmap;
void *map;
uint8_t found = 0;
char line[BUFSIZE];
char dlm[] = "- : ";
char *str, *sp, *in[PROCMAP_SZ];
char *end = NULL;
/* Path where mem files are located. */
snprintf(procdir, PATH_MAX, "/proc/%u/fd/", pid);
/* Maps file used to locate mem file. */
snprintf(mapfile, PATH_MAX, "/proc/%u/maps", pid);
fmap = fopen(mapfile, "r");
if (fmap == NULL) {
RTE_LOG(ERR, VHOST_CONFIG,
"(%"PRIu64") Failed to open maps file for pid %d\n",
dev->device_fh, pid);
return -1;
}
/* Read through maps file until we find out base_address. */
while (fgets(line, BUFSIZE, fmap) != 0) {
str = line;
errno = 0;
/* Split line into fields. */
for (i = 0; i < PROCMAP_SZ; i++) {
in[i] = strtok_r(str, &dlm[i], &sp);
if ((in[i] == NULL) || (errno != 0)) {
fclose(fmap);
return -1;
}
str = NULL;
}
/* Convert/Copy each field as needed. */
procmap.va_start = strtoull(in[0], &end, 16);
if ((in[0] == '\0') || (end == NULL) || (*end != '\0') ||
(errno != 0)) {
fclose(fmap);
return -1;
}
procmap.len = strtoull(in[1], &end, 16);
if ((in[1] == '\0') || (end == NULL) || (*end != '\0') ||
(errno != 0)) {
fclose(fmap);
return -1;
}
procmap.pgoff = strtoull(in[3], &end, 16);
if ((in[3] == '\0') || (end == NULL) || (*end != '\0') ||
(errno != 0)) {
fclose(fmap);
return -1;
}
procmap.maj = strtoul(in[4], &end, 16);
if ((in[4] == '\0') || (end == NULL) || (*end != '\0') ||
(errno != 0)) {
fclose(fmap);
return -1;
}
procmap.min = strtoul(in[5], &end, 16);
if ((in[5] == '\0') || (end == NULL) || (*end != '\0') ||
(errno != 0)) {
fclose(fmap);
return -1;
}
procmap.ino = strtoul(in[6], &end, 16);
if ((in[6] == '\0') || (end == NULL) || (*end != '\0') ||
(errno != 0)) {
fclose(fmap);
return -1;
}
memcpy(&procmap.prot, in[2], PROT_SZ);
memcpy(&procmap.fname, in[7], PATH_MAX);
if (procmap.va_start == addr) {
procmap.len = procmap.len - procmap.va_start;
found = 1;
break;
}
}
fclose(fmap);
if (!found) {
RTE_LOG(ERR, VHOST_CONFIG,
"(%"PRIu64") Failed to find memory file in pid %d maps file\n",
dev->device_fh, pid);
return -1;
}
/* Find the guest memory file among the process fds. */
dp = opendir(procdir);
if (dp == NULL) {
RTE_LOG(ERR, VHOST_CONFIG,
"(%"PRIu64") Cannot open pid %d process directory\n",
dev->device_fh, pid);
return -1;
}
found = 0;
/* Read the fd directory contents. */
while (NULL != (dptr = readdir(dp))) {
snprintf(memfile, PATH_MAX, "/proc/%u/fd/%s",
pid, dptr->d_name);
path = realpath(memfile, resolved_path);
if ((path == NULL) && (strlen(resolved_path) == 0)) {
RTE_LOG(ERR, VHOST_CONFIG,
"(%"PRIu64") Failed to resolve fd directory\n",
dev->device_fh);
closedir(dp);
return -1;
}
if (strncmp(resolved_path, procmap.fname,
strnlen(procmap.fname, PATH_MAX)) == 0) {
found = 1;
break;
}
}
closedir(dp);
if (found == 0) {
RTE_LOG(ERR, VHOST_CONFIG,
"(%"PRIu64") Failed to find memory file for pid %d\n",
dev->device_fh, pid);
return -1;
}
/* Open the shared memory file and map the memory into this process. */
fd = open(memfile, O_RDWR);
if (fd == -1) {
RTE_LOG(ERR, VHOST_CONFIG,
"(%"PRIu64") Failed to open %s for pid %d\n",
dev->device_fh, memfile, pid);
return -1;
}
map = mmap(0, (size_t)procmap.len, 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 %s for pid %d\n",
dev->device_fh, memfile, pid);
return -1;
}
/* Store the memory address and size in the device data structure */
mem->mapped_address = (uint64_t)(uintptr_t)map;
mem->mapped_size = procmap.len;
LOG_DEBUG(VHOST_CONFIG,
"(%"PRIu64") Mem File: %s->%s - Size: %llu - VA: %p\n",
dev->device_fh,
memfile, resolved_path,
(unsigned long long)mem->mapped_size, map);
return 0;
}
/*
* Retrieves an entry from the devices configuration linked list.
@ -329,7 +123,7 @@ get_config_ll_entry(struct vhost_device_ctx ctx)
* Searches the configuration core linked list and
* retrieves the device if it exists.
*/
static struct virtio_net *
struct virtio_net *
get_device(struct vhost_device_ctx ctx)
{
struct virtio_net_config_ll *ll_dev;
@ -647,145 +441,6 @@ set_features(struct vhost_device_ctx ctx, uint64_t *pu)
return 0;
}
/*
* Called from CUSE 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
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;
dev = 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;
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);
/*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 (host_memory_map(dev, mem, ctx.pid,
mem->base_address) != 0) {
free(mem);
return -1;
}
}
}
/* 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 CUSE IOCTL: VHOST_SET_VRING_NUM
* The virtio device sends us the size of the descriptor ring.
@ -1040,8 +695,6 @@ static const struct vhost_net_device_ops vhost_device_ops = {
.get_features = get_features,
.set_features = set_features,
.set_mem_table = set_mem_table,
.set_vring_num = set_vring_num,
.set_vring_addr = set_vring_addr,
.set_vring_base = set_vring_base,

43
lib/librte_vhost/virtio-net.h Normal file
View File

@ -0,0 +1,43 @@
/*-
* BSD LICENSE
*
* Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _VIRTIO_NET_H
#define _VIRTIO_NET_H
#include "vhost-net.h"
#include "rte_virtio_net.h"
struct virtio_net_device_ops const *notify_ops;
struct virtio_net *get_device(struct vhost_device_ctx ctx);
#endif