2017-12-19 15:49:03 +00:00
|
|
|
/* SPDX-License-Identifier: BSD-3-Clause
|
2018-04-05 16:01:30 +00:00
|
|
|
* Copyright(c) 2010-2017 Intel Corporation
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/vhost.h>
|
|
|
|
|
#include <linux/virtio_net.h>
|
|
|
|
|
#include <stddef.h>
|
|
|
|
|
#include <stdint.h>
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#ifdef RTE_LIBRTE_VHOST_NUMA
|
2018-08-10 07:24:54 +00:00
|
|
|
#include <numa.h>
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
#include <numaif.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
2017-07-06 13:30:43 +00:00
|
|
|
#include <rte_errno.h>
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
#include <rte_ethdev.h>
|
|
|
|
|
#include <rte_log.h>
|
|
|
|
|
#include <rte_string_fns.h>
|
|
|
|
|
#include <rte_memory.h>
|
|
|
|
|
#include <rte_malloc.h>
|
2017-04-01 07:22:57 +00:00
|
|
|
#include <rte_vhost.h>
|
2017-10-05 08:36:19 +00:00
|
|
|
#include <rte_rwlock.h>
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
|
2017-10-05 08:36:17 +00:00
|
|
|
#include "iotlb.h"
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
#include "vhost.h"
|
2017-10-05 08:36:19 +00:00
|
|
|
#include "vhost_user.h"
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
|
|
|
|
|
struct virtio_net *vhost_devices[MAX_VHOST_DEVICE];
|
|
|
|
|
|
2017-10-12 15:38:49 +00:00
|
|
|
/* Called with iotlb_lock read-locked */
|
2017-10-05 08:36:19 +00:00
|
|
|
uint64_t
|
|
|
|
|
__vhost_iova_to_vva(struct virtio_net *dev, struct vhost_virtqueue *vq,
|
2018-01-23 13:26:02 +00:00
|
|
|
uint64_t iova, uint64_t *size, uint8_t perm)
|
2017-10-05 08:36:19 +00:00
|
|
|
{
|
|
|
|
|
uint64_t vva, tmp_size;
|
|
|
|
|
|
2018-01-23 13:26:02 +00:00
|
|
|
if (unlikely(!*size))
|
2017-10-05 08:36:19 +00:00
|
|
|
return 0;
|
|
|
|
|
|
2018-01-23 13:26:02 +00:00
|
|
|
tmp_size = *size;
|
2017-10-05 08:36:19 +00:00
|
|
|
|
|
|
|
|
vva = vhost_user_iotlb_cache_find(vq, iova, &tmp_size, perm);
|
2018-01-23 13:26:02 +00:00
|
|
|
if (tmp_size == *size)
|
2017-10-05 08:36:19 +00:00
|
|
|
return vva;
|
|
|
|
|
|
2018-02-05 15:04:57 +00:00
|
|
|
iova += tmp_size;
|
|
|
|
|
|
|
|
|
|
if (!vhost_user_iotlb_pending_miss(vq, iova, perm)) {
|
2017-10-12 15:38:49 +00:00
|
|
|
/*
|
|
|
|
|
* iotlb_lock is read-locked for a full burst,
|
|
|
|
|
* but it only protects the iotlb cache.
|
|
|
|
|
* In case of IOTLB miss, we might block on the socket,
|
|
|
|
|
* which could cause a deadlock with QEMU if an IOTLB update
|
|
|
|
|
* is being handled. We can safely unlock here to avoid it.
|
|
|
|
|
*/
|
|
|
|
|
vhost_user_iotlb_rd_unlock(vq);
|
|
|
|
|
|
2018-02-05 15:04:57 +00:00
|
|
|
vhost_user_iotlb_pending_insert(vq, iova, perm);
|
|
|
|
|
if (vhost_user_iotlb_miss(dev, iova, perm)) {
|
|
|
|
|
RTE_LOG(ERR, VHOST_CONFIG,
|
|
|
|
|
"IOTLB miss req failed for IOVA 0x%" PRIx64 "\n",
|
|
|
|
|
iova);
|
|
|
|
|
vhost_user_iotlb_pending_remove(vq, iova, 1, perm);
|
|
|
|
|
}
|
2017-10-12 15:38:49 +00:00
|
|
|
|
|
|
|
|
vhost_user_iotlb_rd_lock(vq);
|
2017-10-05 08:36:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-13 08:51:08 +00:00
|
|
|
void
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
cleanup_vq(struct vhost_virtqueue *vq, int destroy)
|
|
|
|
|
{
|
|
|
|
|
if ((vq->callfd >= 0) && (destroy != 0))
|
|
|
|
|
close(vq->callfd);
|
|
|
|
|
if (vq->kickfd >= 0)
|
|
|
|
|
close(vq->kickfd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Unmap any memory, close any file descriptors and
|
|
|
|
|
* free any memory owned by a device.
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
cleanup_device(struct virtio_net *dev, int destroy)
|
|
|
|
|
{
|
|
|
|
|
uint32_t i;
|
|
|
|
|
|
|
|
|
|
vhost_backend_cleanup(dev);
|
|
|
|
|
|
2017-04-01 07:22:47 +00:00
|
|
|
for (i = 0; i < dev->nr_vring; i++)
|
|
|
|
|
cleanup_vq(dev->virtqueue[i], destroy);
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
}
|
|
|
|
|
|
2017-12-13 08:51:08 +00:00
|
|
|
void
|
2018-07-06 07:07:16 +00:00
|
|
|
free_vq(struct virtio_net *dev, struct vhost_virtqueue *vq)
|
2017-12-13 08:51:08 +00:00
|
|
|
{
|
2018-07-06 07:07:16 +00:00
|
|
|
if (vq_is_packed(dev))
|
|
|
|
|
rte_free(vq->shadow_used_packed);
|
|
|
|
|
else
|
|
|
|
|
rte_free(vq->shadow_used_split);
|
2017-12-13 08:51:08 +00:00
|
|
|
rte_free(vq->batch_copy_elems);
|
|
|
|
|
rte_mempool_free(vq->iotlb_pool);
|
|
|
|
|
rte_free(vq);
|
|
|
|
|
}
|
|
|
|
|
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
/*
|
|
|
|
|
* Release virtqueues and device memory.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
free_device(struct virtio_net *dev)
|
|
|
|
|
{
|
|
|
|
|
uint32_t i;
|
2016-10-14 09:34:36 +00:00
|
|
|
|
2017-12-13 08:51:08 +00:00
|
|
|
for (i = 0; i < dev->nr_vring; i++)
|
2018-07-06 07:07:16 +00:00
|
|
|
free_vq(dev, dev->virtqueue[i]);
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
|
|
|
|
|
rte_free(dev);
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-06 07:07:10 +00:00
|
|
|
static int
|
|
|
|
|
vring_translate_split(struct virtio_net *dev, struct vhost_virtqueue *vq)
|
2017-10-05 08:36:25 +00:00
|
|
|
{
|
2018-01-23 13:26:02 +00:00
|
|
|
uint64_t req_size, size;
|
2017-10-05 08:36:25 +00:00
|
|
|
|
2018-01-23 13:26:02 +00:00
|
|
|
req_size = sizeof(struct vring_desc) * vq->size;
|
|
|
|
|
size = req_size;
|
2017-10-05 08:36:25 +00:00
|
|
|
vq->desc = (struct vring_desc *)(uintptr_t)vhost_iova_to_vva(dev, vq,
|
|
|
|
|
vq->ring_addrs.desc_user_addr,
|
2018-01-23 13:26:02 +00:00
|
|
|
&size, VHOST_ACCESS_RW);
|
|
|
|
|
if (!vq->desc || size != req_size)
|
2017-10-05 08:36:25 +00:00
|
|
|
return -1;
|
|
|
|
|
|
2018-01-23 13:26:02 +00:00
|
|
|
req_size = sizeof(struct vring_avail);
|
|
|
|
|
req_size += sizeof(uint16_t) * vq->size;
|
|
|
|
|
if (dev->features & (1ULL << VIRTIO_RING_F_EVENT_IDX))
|
|
|
|
|
req_size += sizeof(uint16_t);
|
|
|
|
|
size = req_size;
|
2017-10-05 08:36:25 +00:00
|
|
|
vq->avail = (struct vring_avail *)(uintptr_t)vhost_iova_to_vva(dev, vq,
|
|
|
|
|
vq->ring_addrs.avail_user_addr,
|
2018-01-23 13:26:02 +00:00
|
|
|
&size, VHOST_ACCESS_RW);
|
|
|
|
|
if (!vq->avail || size != req_size)
|
2017-10-05 08:36:25 +00:00
|
|
|
return -1;
|
|
|
|
|
|
2018-01-23 13:26:02 +00:00
|
|
|
req_size = sizeof(struct vring_used);
|
|
|
|
|
req_size += sizeof(struct vring_used_elem) * vq->size;
|
|
|
|
|
if (dev->features & (1ULL << VIRTIO_RING_F_EVENT_IDX))
|
|
|
|
|
req_size += sizeof(uint16_t);
|
|
|
|
|
size = req_size;
|
2017-10-05 08:36:25 +00:00
|
|
|
vq->used = (struct vring_used *)(uintptr_t)vhost_iova_to_vva(dev, vq,
|
|
|
|
|
vq->ring_addrs.used_user_addr,
|
2018-01-23 13:26:02 +00:00
|
|
|
&size, VHOST_ACCESS_RW);
|
|
|
|
|
if (!vq->used || size != req_size)
|
2017-10-05 08:36:25 +00:00
|
|
|
return -1;
|
|
|
|
|
|
2018-07-06 07:07:10 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
vring_translate_packed(struct virtio_net *dev, struct vhost_virtqueue *vq)
|
|
|
|
|
{
|
|
|
|
|
uint64_t req_size, size;
|
|
|
|
|
|
|
|
|
|
req_size = sizeof(struct vring_packed_desc) * vq->size;
|
|
|
|
|
size = req_size;
|
2018-07-06 07:07:21 +00:00
|
|
|
vq->desc_packed = (struct vring_packed_desc *)(uintptr_t)
|
|
|
|
|
vhost_iova_to_vva(dev, vq, vq->ring_addrs.desc_user_addr,
|
|
|
|
|
&size, VHOST_ACCESS_RW);
|
2018-07-06 07:07:10 +00:00
|
|
|
if (!vq->desc_packed || size != req_size)
|
|
|
|
|
return -1;
|
|
|
|
|
|
2018-07-06 07:07:21 +00:00
|
|
|
req_size = sizeof(struct vring_packed_desc_event);
|
|
|
|
|
size = req_size;
|
|
|
|
|
vq->driver_event = (struct vring_packed_desc_event *)(uintptr_t)
|
|
|
|
|
vhost_iova_to_vva(dev, vq, vq->ring_addrs.avail_user_addr,
|
|
|
|
|
&size, VHOST_ACCESS_RW);
|
|
|
|
|
if (!vq->driver_event || size != req_size)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
req_size = sizeof(struct vring_packed_desc_event);
|
|
|
|
|
size = req_size;
|
|
|
|
|
vq->device_event = (struct vring_packed_desc_event *)(uintptr_t)
|
|
|
|
|
vhost_iova_to_vva(dev, vq, vq->ring_addrs.used_user_addr,
|
|
|
|
|
&size, VHOST_ACCESS_RW);
|
|
|
|
|
if (!vq->device_event || size != req_size)
|
|
|
|
|
return -1;
|
|
|
|
|
|
2018-07-06 07:07:10 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
vring_translate(struct virtio_net *dev, struct vhost_virtqueue *vq)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
if (!(dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM)))
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
if (vq_is_packed(dev)) {
|
|
|
|
|
if (vring_translate_packed(dev, vq) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
} else {
|
|
|
|
|
if (vring_translate_split(dev, vq) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2017-10-05 08:36:25 +00:00
|
|
|
out:
|
|
|
|
|
vq->access_ok = 1;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-05 08:36:26 +00:00
|
|
|
void
|
|
|
|
|
vring_invalidate(struct virtio_net *dev, struct vhost_virtqueue *vq)
|
|
|
|
|
{
|
|
|
|
|
if (dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM))
|
|
|
|
|
vhost_user_iotlb_wr_lock(vq);
|
|
|
|
|
|
|
|
|
|
vq->access_ok = 0;
|
|
|
|
|
vq->desc = NULL;
|
|
|
|
|
vq->avail = NULL;
|
|
|
|
|
vq->used = NULL;
|
|
|
|
|
|
|
|
|
|
if (dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM))
|
|
|
|
|
vhost_user_iotlb_wr_unlock(vq);
|
|
|
|
|
}
|
|
|
|
|
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
static void
|
2017-10-05 08:36:17 +00:00
|
|
|
init_vring_queue(struct virtio_net *dev, uint32_t vring_idx)
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
{
|
2017-10-05 08:36:17 +00:00
|
|
|
struct vhost_virtqueue *vq;
|
|
|
|
|
|
|
|
|
|
if (vring_idx >= VHOST_MAX_VRING) {
|
|
|
|
|
RTE_LOG(ERR, VHOST_CONFIG,
|
|
|
|
|
"Failed not init vring, out of bound (%d)\n",
|
|
|
|
|
vring_idx);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
vq = dev->virtqueue[vring_idx];
|
|
|
|
|
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
memset(vq, 0, sizeof(struct vhost_virtqueue));
|
|
|
|
|
|
|
|
|
|
vq->kickfd = VIRTIO_UNINITIALIZED_EVENTFD;
|
|
|
|
|
vq->callfd = VIRTIO_UNINITIALIZED_EVENTFD;
|
|
|
|
|
|
2017-10-05 08:36:17 +00:00
|
|
|
vhost_user_iotlb_init(dev, vring_idx);
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
/* Backends are set to -1 indicating an inactive device. */
|
|
|
|
|
vq->backend = -1;
|
|
|
|
|
|
vhost: add dequeue zero copy
The basic idea of dequeue zero copy is, instead of copying data from
the desc buf, here we let the mbuf reference the desc buf addr directly.
Doing so, however, has one major issue: we can't update the used ring
at the end of rte_vhost_dequeue_burst. Because we don't do the copy
here, an update of the used ring would let the driver to reclaim the
desc buf. As a result, DPDK might reference a stale memory region.
To update the used ring properly, this patch does several tricks:
- when mbuf references a desc buf, refcnt is added by 1.
This is to pin lock the mbuf, so that a mbuf free from the DPDK
won't actually free it, instead, refcnt is subtracted by 1.
- We chain all those mbuf together (by tailq)
And we check it every time on the rte_vhost_dequeue_burst entrance,
to see if the mbuf is freed (when refcnt equals to 1). If that
happens, it means we are the last user of this mbuf and we are
safe to update the used ring.
- "struct zcopy_mbuf" is introduced, to associate an mbuf with the
right desc idx.
Dequeue zero copy is introduced for performance reason, and some rough
tests show about 50% perfomance boost for packet size 1500B. For small
packets, (e.g. 64B), it actually slows a bit down (well, it could up to
15%). That is expected because this patch introduces some extra works,
and it outweighs the benefit from saving few bytes copy.
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
Tested-by: Qian Xu <qian.q.xu@intel.com>
2016-10-09 07:27:57 +00:00
|
|
|
TAILQ_INIT(&vq->zmbuf_list);
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2017-10-05 08:36:17 +00:00
|
|
|
reset_vring_queue(struct virtio_net *dev, uint32_t vring_idx)
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
{
|
2017-10-05 08:36:17 +00:00
|
|
|
struct vhost_virtqueue *vq;
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
int callfd;
|
|
|
|
|
|
2017-10-05 08:36:17 +00:00
|
|
|
if (vring_idx >= VHOST_MAX_VRING) {
|
|
|
|
|
RTE_LOG(ERR, VHOST_CONFIG,
|
|
|
|
|
"Failed not init vring, out of bound (%d)\n",
|
|
|
|
|
vring_idx);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
vq = dev->virtqueue[vring_idx];
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
callfd = vq->callfd;
|
2017-10-05 08:36:17 +00:00
|
|
|
init_vring_queue(dev, vring_idx);
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
vq->callfd = callfd;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
2017-04-01 07:22:47 +00:00
|
|
|
alloc_vring_queue(struct virtio_net *dev, uint32_t vring_idx)
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
{
|
2017-04-01 07:22:47 +00:00
|
|
|
struct vhost_virtqueue *vq;
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
|
2017-04-01 07:22:47 +00:00
|
|
|
vq = rte_malloc(NULL, sizeof(struct vhost_virtqueue), 0);
|
|
|
|
|
if (vq == NULL) {
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
RTE_LOG(ERR, VHOST_CONFIG,
|
2017-04-01 07:22:47 +00:00
|
|
|
"Failed to allocate memory for vring:%u.\n", vring_idx);
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-01 07:22:47 +00:00
|
|
|
dev->virtqueue[vring_idx] = vq;
|
2017-10-05 08:36:17 +00:00
|
|
|
init_vring_queue(dev, vring_idx);
|
2018-01-17 13:49:25 +00:00
|
|
|
rte_spinlock_init(&vq->access_lock);
|
2018-07-06 07:07:10 +00:00
|
|
|
vq->avail_wrap_counter = 1;
|
|
|
|
|
vq->used_wrap_counter = 1;
|
2018-07-06 07:07:21 +00:00
|
|
|
vq->signalled_used_valid = false;
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
|
2017-04-01 07:22:47 +00:00
|
|
|
dev->nr_vring += 1;
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Reset some variables in device structure, while keeping few
|
2017-04-01 07:22:47 +00:00
|
|
|
* others untouched, such as vid, ifname, nr_vring: they
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
* should be same unless the device is removed.
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
reset_device(struct virtio_net *dev)
|
|
|
|
|
{
|
|
|
|
|
uint32_t i;
|
|
|
|
|
|
|
|
|
|
dev->features = 0;
|
|
|
|
|
dev->protocol_features = 0;
|
2018-01-31 17:46:50 +00:00
|
|
|
dev->flags &= VIRTIO_DEV_BUILTIN_VIRTIO_NET;
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
|
2017-04-01 07:22:47 +00:00
|
|
|
for (i = 0; i < dev->nr_vring; i++)
|
2017-10-05 08:36:17 +00:00
|
|
|
reset_vring_queue(dev, i);
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2016-11-02 03:15:01 +00:00
|
|
|
* Invoked when there is a new vhost-user connection established (when
|
|
|
|
|
* there is a new virtio device being attached).
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
*/
|
|
|
|
|
int
|
|
|
|
|
vhost_new_device(void)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_VHOST_DEVICE; i++) {
|
|
|
|
|
if (vhost_devices[i] == NULL)
|
|
|
|
|
break;
|
|
|
|
|
}
|
2018-06-08 09:18:04 +00:00
|
|
|
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
if (i == MAX_VHOST_DEVICE) {
|
|
|
|
|
RTE_LOG(ERR, VHOST_CONFIG,
|
|
|
|
|
"Failed to find a free slot for new device.\n");
|
2018-06-08 09:18:04 +00:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
dev = rte_zmalloc(NULL, sizeof(struct virtio_net), 0);
|
|
|
|
|
if (dev == NULL) {
|
|
|
|
|
RTE_LOG(ERR, VHOST_CONFIG,
|
|
|
|
|
"Failed to allocate memory for new dev.\n");
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
vhost_devices[i] = dev;
|
|
|
|
|
dev->vid = i;
|
2018-01-31 17:46:50 +00:00
|
|
|
dev->flags = VIRTIO_DEV_BUILTIN_VIRTIO_NET;
|
2017-10-05 08:36:12 +00:00
|
|
|
dev->slave_req_fd = -1;
|
2018-04-02 11:46:54 +00:00
|
|
|
dev->vdpa_dev_id = -1;
|
2018-10-24 09:39:48 +00:00
|
|
|
dev->postcopy_ufd = -1;
|
2018-06-08 03:22:23 +00:00
|
|
|
rte_spinlock_init(&dev->slave_req_lock);
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
2018-06-13 11:54:18 +00:00
|
|
|
void
|
|
|
|
|
vhost_destroy_device_notify(struct virtio_net *dev)
|
|
|
|
|
{
|
|
|
|
|
struct rte_vdpa_device *vdpa_dev;
|
|
|
|
|
int did;
|
|
|
|
|
|
|
|
|
|
if (dev->flags & VIRTIO_DEV_RUNNING) {
|
|
|
|
|
did = dev->vdpa_dev_id;
|
|
|
|
|
vdpa_dev = rte_vdpa_get_device(did);
|
|
|
|
|
if (vdpa_dev && vdpa_dev->ops->dev_close)
|
|
|
|
|
vdpa_dev->ops->dev_close(dev->vid);
|
|
|
|
|
dev->flags &= ~VIRTIO_DEV_RUNNING;
|
|
|
|
|
dev->notify_ops->destroy_device(dev->vid);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
/*
|
2016-11-02 03:15:01 +00:00
|
|
|
* Invoked when there is the vhost-user connection is broken (when
|
|
|
|
|
* the virtio device is being detached).
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
vhost_destroy_device(int vid)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
|
|
|
|
|
if (dev == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
2018-06-13 11:54:18 +00:00
|
|
|
vhost_destroy_device_notify(dev);
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
|
|
|
|
|
cleanup_device(dev, 1);
|
|
|
|
|
free_device(dev);
|
|
|
|
|
|
|
|
|
|
vhost_devices[vid] = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-02 11:46:54 +00:00
|
|
|
void
|
|
|
|
|
vhost_attach_vdpa_device(int vid, int did)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
|
|
|
|
|
if (dev == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (rte_vdpa_get_device(did) == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
dev->vdpa_dev_id = did;
|
|
|
|
|
}
|
|
|
|
|
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
void
|
|
|
|
|
vhost_set_ifname(int vid, const char *if_name, unsigned int if_len)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev;
|
|
|
|
|
unsigned int len;
|
|
|
|
|
|
|
|
|
|
dev = get_device(vid);
|
|
|
|
|
if (dev == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
len = if_len > sizeof(dev->ifname) ?
|
|
|
|
|
sizeof(dev->ifname) : if_len;
|
|
|
|
|
|
|
|
|
|
strncpy(dev->ifname, if_name, len);
|
|
|
|
|
dev->ifname[sizeof(dev->ifname) - 1] = '\0';
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-09 07:27:58 +00:00
|
|
|
void
|
|
|
|
|
vhost_enable_dequeue_zero_copy(int vid)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
|
|
|
|
|
if (dev == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
dev->dequeue_zero_copy = 1;
|
|
|
|
|
}
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
|
2018-01-31 17:46:50 +00:00
|
|
|
void
|
|
|
|
|
vhost_set_builtin_virtio_net(int vid, bool enable)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
|
|
|
|
|
if (dev == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (enable)
|
|
|
|
|
dev->flags |= VIRTIO_DEV_BUILTIN_VIRTIO_NET;
|
|
|
|
|
else
|
|
|
|
|
dev->flags &= ~VIRTIO_DEV_BUILTIN_VIRTIO_NET;
|
|
|
|
|
}
|
|
|
|
|
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
int
|
2017-03-12 16:34:01 +00:00
|
|
|
rte_vhost_get_mtu(int vid, uint16_t *mtu)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
|
|
|
|
|
if (!dev)
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
|
|
if (!(dev->flags & VIRTIO_DEV_READY))
|
|
|
|
|
return -EAGAIN;
|
|
|
|
|
|
2017-06-29 07:58:10 +00:00
|
|
|
if (!(dev->features & (1ULL << VIRTIO_NET_F_MTU)))
|
2017-03-12 16:34:01 +00:00
|
|
|
return -ENOTSUP;
|
|
|
|
|
|
|
|
|
|
*mtu = dev->mtu;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
rte_vhost_get_numa_node(int vid)
|
|
|
|
|
{
|
|
|
|
|
#ifdef RTE_LIBRTE_VHOST_NUMA
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
int numa_node;
|
|
|
|
|
int ret;
|
|
|
|
|
|
2018-08-10 07:24:54 +00:00
|
|
|
if (dev == NULL || numa_available() != 0)
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
ret = get_mempolicy(&numa_node, NULL, 0, dev,
|
|
|
|
|
MPOL_F_NODE | MPOL_F_ADDR);
|
|
|
|
|
if (ret < 0) {
|
|
|
|
|
RTE_LOG(ERR, VHOST_CONFIG,
|
2017-07-06 13:30:43 +00:00
|
|
|
"(%d) failed to query numa node: %s\n",
|
|
|
|
|
vid, rte_strerror(errno));
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return numa_node;
|
|
|
|
|
#else
|
|
|
|
|
RTE_SET_USED(vid);
|
|
|
|
|
return -1;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint32_t
|
|
|
|
|
rte_vhost_get_queue_num(int vid)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
|
|
|
|
|
if (dev == NULL)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2017-04-01 07:22:47 +00:00
|
|
|
return dev->nr_vring / 2;
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
}
|
|
|
|
|
|
2017-04-01 07:22:48 +00:00
|
|
|
uint16_t
|
|
|
|
|
rte_vhost_get_vring_num(int vid)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
|
|
|
|
|
if (dev == NULL)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
return dev->nr_vring;
|
|
|
|
|
}
|
|
|
|
|
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
int
|
|
|
|
|
rte_vhost_get_ifname(int vid, char *buf, size_t len)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
|
|
|
|
|
if (dev == NULL)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
len = RTE_MIN(len, sizeof(dev->ifname));
|
|
|
|
|
|
|
|
|
|
strncpy(buf, dev->ifname, len);
|
|
|
|
|
buf[len - 1] = '\0';
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-01 07:22:44 +00:00
|
|
|
int
|
|
|
|
|
rte_vhost_get_negotiated_features(int vid, uint64_t *features)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev;
|
|
|
|
|
|
|
|
|
|
dev = get_device(vid);
|
|
|
|
|
if (!dev)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
*features = dev->features;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-01 07:22:43 +00:00
|
|
|
int
|
|
|
|
|
rte_vhost_get_mem_table(int vid, struct rte_vhost_memory **mem)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev;
|
|
|
|
|
struct rte_vhost_memory *m;
|
|
|
|
|
size_t size;
|
|
|
|
|
|
|
|
|
|
dev = get_device(vid);
|
|
|
|
|
if (!dev)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
size = dev->mem->nregions * sizeof(struct rte_vhost_mem_region);
|
2017-05-26 11:59:13 +00:00
|
|
|
m = malloc(sizeof(struct rte_vhost_memory) + size);
|
2017-04-01 07:22:43 +00:00
|
|
|
if (!m)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
m->nregions = dev->mem->nregions;
|
|
|
|
|
memcpy(m->regions, dev->mem->regions, size);
|
|
|
|
|
*mem = m;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-01 07:22:45 +00:00
|
|
|
int
|
|
|
|
|
rte_vhost_get_vhost_vring(int vid, uint16_t vring_idx,
|
|
|
|
|
struct rte_vhost_vring *vring)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev;
|
|
|
|
|
struct vhost_virtqueue *vq;
|
|
|
|
|
|
|
|
|
|
dev = get_device(vid);
|
|
|
|
|
if (!dev)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
if (vring_idx >= VHOST_MAX_VRING)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
vq = dev->virtqueue[vring_idx];
|
|
|
|
|
if (!vq)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
vring->desc = vq->desc;
|
|
|
|
|
vring->avail = vq->avail;
|
|
|
|
|
vring->used = vq->used;
|
|
|
|
|
vring->log_guest_addr = vq->log_guest_addr;
|
|
|
|
|
|
|
|
|
|
vring->callfd = vq->callfd;
|
|
|
|
|
vring->kickfd = vq->kickfd;
|
|
|
|
|
vring->size = vq->size;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-02 09:31:36 +00:00
|
|
|
int
|
|
|
|
|
rte_vhost_vring_call(int vid, uint16_t vring_idx)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev;
|
|
|
|
|
struct vhost_virtqueue *vq;
|
|
|
|
|
|
|
|
|
|
dev = get_device(vid);
|
|
|
|
|
if (!dev)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
if (vring_idx >= VHOST_MAX_VRING)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
vq = dev->virtqueue[vring_idx];
|
|
|
|
|
if (!vq)
|
|
|
|
|
return -1;
|
|
|
|
|
|
2018-07-06 07:07:21 +00:00
|
|
|
if (vq_is_packed(dev))
|
|
|
|
|
vhost_vring_call_packed(dev, vq);
|
|
|
|
|
else
|
|
|
|
|
vhost_vring_call_split(dev, vq);
|
|
|
|
|
|
2018-01-02 09:31:36 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
uint16_t
|
|
|
|
|
rte_vhost_avail_entries(int vid, uint16_t queue_id)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev;
|
|
|
|
|
struct vhost_virtqueue *vq;
|
|
|
|
|
|
|
|
|
|
dev = get_device(vid);
|
|
|
|
|
if (!dev)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
vq = dev->virtqueue[queue_id];
|
|
|
|
|
if (!vq->enabled)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
return *(volatile uint16_t *)&vq->avail->idx - vq->last_used_idx;
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-06 07:07:21 +00:00
|
|
|
static inline void
|
2018-09-04 23:55:55 +00:00
|
|
|
vhost_enable_notify_split(struct virtio_net *dev,
|
|
|
|
|
struct vhost_virtqueue *vq, int enable)
|
2018-07-06 07:07:21 +00:00
|
|
|
{
|
2018-09-04 23:55:55 +00:00
|
|
|
if (!(dev->features & (1ULL << VIRTIO_RING_F_EVENT_IDX))) {
|
|
|
|
|
if (enable)
|
|
|
|
|
vq->used->flags &= ~VRING_USED_F_NO_NOTIFY;
|
|
|
|
|
else
|
|
|
|
|
vq->used->flags |= VRING_USED_F_NO_NOTIFY;
|
|
|
|
|
} else {
|
|
|
|
|
if (enable)
|
|
|
|
|
vhost_avail_event(vq) = vq->last_avail_idx;
|
|
|
|
|
}
|
2018-07-06 07:07:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
vhost_enable_notify_packed(struct virtio_net *dev,
|
|
|
|
|
struct vhost_virtqueue *vq, int enable)
|
|
|
|
|
{
|
|
|
|
|
uint16_t flags;
|
|
|
|
|
|
2018-10-11 14:22:34 +00:00
|
|
|
if (!enable) {
|
2018-07-06 07:07:21 +00:00
|
|
|
vq->device_event->flags = VRING_EVENT_F_DISABLE;
|
2018-10-11 14:22:34 +00:00
|
|
|
return;
|
|
|
|
|
}
|
2018-07-06 07:07:21 +00:00
|
|
|
|
|
|
|
|
flags = VRING_EVENT_F_ENABLE;
|
|
|
|
|
if (dev->features & (1ULL << VIRTIO_RING_F_EVENT_IDX)) {
|
|
|
|
|
flags = VRING_EVENT_F_DESC;
|
|
|
|
|
vq->device_event->off_wrap = vq->last_avail_idx |
|
|
|
|
|
vq->avail_wrap_counter << 15;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
rte_smp_wmb();
|
|
|
|
|
|
|
|
|
|
vq->device_event->flags = flags;
|
|
|
|
|
}
|
|
|
|
|
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
int
|
|
|
|
|
rte_vhost_enable_guest_notification(int vid, uint16_t queue_id, int enable)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
2018-07-06 07:07:21 +00:00
|
|
|
struct vhost_virtqueue *vq;
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
|
2018-04-12 16:28:34 +00:00
|
|
|
if (!dev)
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
return -1;
|
|
|
|
|
|
2018-07-06 07:07:21 +00:00
|
|
|
vq = dev->virtqueue[queue_id];
|
|
|
|
|
|
|
|
|
|
if (vq_is_packed(dev))
|
|
|
|
|
vhost_enable_notify_packed(dev, vq, enable);
|
2018-04-12 16:28:34 +00:00
|
|
|
else
|
2018-09-04 23:55:55 +00:00
|
|
|
vhost_enable_notify_split(dev, vq, enable);
|
2018-07-06 07:07:21 +00:00
|
|
|
|
vhost: refactor code structure
The code structure is a bit messy now. For example, vhost-user message
handling is spread to three different files:
vhost-net-user.c virtio-net.c virtio-net-user.c
Where, vhost-net-user.c is the entrance to handle all those messages
and then invoke the right method for a specific message. Some of them
are stored at virtio-net.c, while others are stored at virtio-net-user.c.
The truth is all of them should be in one file, vhost_user.c.
So this patch refactors the source code structure: mainly on renaming
files and moving code from one file to another file that is more suitable
for storing it. Thus, no functional changes are made.
After the refactor, the code structure becomes to:
- socket.c handles all vhost-user socket file related stuff, such
as, socket file creation for server mode, reconnection
for client mode.
- vhost.c mainly on stuff like vhost device creation/destroy/reset.
Most of the vhost API implementation are there, too.
- vhost_user.c all stuff about vhost-user messages handling goes there.
- virtio_net.c all stuff about virtio-net should go there. It has virtio
net Rx/Tx implementation only so far: it's just a rename
from vhost_rxtx.c
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Maxime Coquelin <maxime.coquelin@redhat.com>
2016-08-18 08:48:39 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
2017-04-01 07:22:55 +00:00
|
|
|
|
|
|
|
|
void
|
|
|
|
|
rte_vhost_log_write(int vid, uint64_t addr, uint64_t len)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
|
|
|
|
|
if (dev == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
vhost_log_write(dev, addr, len);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
rte_vhost_log_used_vring(int vid, uint16_t vring_idx,
|
|
|
|
|
uint64_t offset, uint64_t len)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev;
|
|
|
|
|
struct vhost_virtqueue *vq;
|
|
|
|
|
|
|
|
|
|
dev = get_device(vid);
|
|
|
|
|
if (dev == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (vring_idx >= VHOST_MAX_VRING)
|
|
|
|
|
return;
|
|
|
|
|
vq = dev->virtqueue[vring_idx];
|
|
|
|
|
if (!vq)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
vhost_log_used_vring(dev, vq, offset, len);
|
|
|
|
|
}
|
2017-05-26 17:18:02 +00:00
|
|
|
|
|
|
|
|
uint32_t
|
|
|
|
|
rte_vhost_rx_queue_count(int vid, uint16_t qid)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev;
|
|
|
|
|
struct vhost_virtqueue *vq;
|
|
|
|
|
|
|
|
|
|
dev = get_device(vid);
|
|
|
|
|
if (dev == NULL)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (unlikely(qid >= dev->nr_vring || (qid & 1) == 0)) {
|
|
|
|
|
RTE_LOG(ERR, VHOST_DATA, "(%d) %s: invalid virtqueue idx %d.\n",
|
|
|
|
|
dev->vid, __func__, qid);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
vq = dev->virtqueue[qid];
|
|
|
|
|
if (vq == NULL)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (unlikely(vq->enabled == 0 || vq->avail == NULL))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
return *((volatile uint16_t *)&vq->avail->idx) - vq->last_avail_idx;
|
|
|
|
|
}
|
2018-04-02 11:46:54 +00:00
|
|
|
|
|
|
|
|
int rte_vhost_get_vdpa_device_id(int vid)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
|
|
|
|
|
if (dev == NULL)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
return dev->vdpa_dev_id;
|
|
|
|
|
}
|
2018-04-02 11:46:56 +00:00
|
|
|
|
|
|
|
|
int rte_vhost_get_log_base(int vid, uint64_t *log_base,
|
|
|
|
|
uint64_t *log_size)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
|
|
|
|
|
if (!dev)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
if (unlikely(!(dev->flags & VIRTIO_DEV_BUILTIN_VIRTIO_NET))) {
|
|
|
|
|
RTE_LOG(ERR, VHOST_DATA,
|
|
|
|
|
"(%d) %s: built-in vhost net backend is disabled.\n",
|
|
|
|
|
dev->vid, __func__);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*log_base = dev->log_base;
|
|
|
|
|
*log_size = dev->log_size;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int rte_vhost_get_vring_base(int vid, uint16_t queue_id,
|
|
|
|
|
uint16_t *last_avail_idx, uint16_t *last_used_idx)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
|
|
|
|
|
if (!dev)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
if (unlikely(!(dev->flags & VIRTIO_DEV_BUILTIN_VIRTIO_NET))) {
|
|
|
|
|
RTE_LOG(ERR, VHOST_DATA,
|
|
|
|
|
"(%d) %s: built-in vhost net backend is disabled.\n",
|
|
|
|
|
dev->vid, __func__);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*last_avail_idx = dev->virtqueue[queue_id]->last_avail_idx;
|
|
|
|
|
*last_used_idx = dev->virtqueue[queue_id]->last_used_idx;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int rte_vhost_set_vring_base(int vid, uint16_t queue_id,
|
|
|
|
|
uint16_t last_avail_idx, uint16_t last_used_idx)
|
|
|
|
|
{
|
|
|
|
|
struct virtio_net *dev = get_device(vid);
|
|
|
|
|
|
|
|
|
|
if (!dev)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
if (unlikely(!(dev->flags & VIRTIO_DEV_BUILTIN_VIRTIO_NET))) {
|
|
|
|
|
RTE_LOG(ERR, VHOST_DATA,
|
|
|
|
|
"(%d) %s: built-in vhost net backend is disabled.\n",
|
|
|
|
|
dev->vid, __func__);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
dev->virtqueue[queue_id]->last_avail_idx = last_avail_idx;
|
|
|
|
|
dev->virtqueue[queue_id]->last_used_idx = last_used_idx;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
