* [PATCH v12 01/40] virtio: record the maximum queue num supported by the device.
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
@ 2022-07-20 3:03 ` Xuan Zhuo
2022-07-21 3:36 ` Jason Wang
2022-07-20 3:03 ` [PATCH v12 02/40] virtio: struct virtio_config_ops add callbacks for queue_reset Xuan Zhuo
` (38 subsequent siblings)
39 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:03 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
virtio-net can display the maximum (supported by hardware) ring size in
ethtool -g eth0.
When the subsequent patch implements vring reset, it can judge whether
the ring size passed by the driver is legal based on this.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
arch/um/drivers/virtio_uml.c | 1 +
drivers/platform/mellanox/mlxbf-tmfifo.c | 2 ++
drivers/remoteproc/remoteproc_virtio.c | 2 ++
drivers/s390/virtio/virtio_ccw.c | 3 +++
drivers/virtio/virtio_mmio.c | 2 ++
drivers/virtio/virtio_pci_legacy.c | 2 ++
drivers/virtio/virtio_pci_modern.c | 2 ++
drivers/virtio/virtio_vdpa.c | 2 ++
include/linux/virtio.h | 2 ++
9 files changed, 18 insertions(+)
diff --git a/arch/um/drivers/virtio_uml.c b/arch/um/drivers/virtio_uml.c
index 82ff3785bf69..e719af8bdf56 100644
--- a/arch/um/drivers/virtio_uml.c
+++ b/arch/um/drivers/virtio_uml.c
@@ -958,6 +958,7 @@ static struct virtqueue *vu_setup_vq(struct virtio_device *vdev,
goto error_create;
}
vq->priv = info;
+ vq->num_max = num;
num = virtqueue_get_vring_size(vq);
if (vu_dev->protocol_features &
diff --git a/drivers/platform/mellanox/mlxbf-tmfifo.c b/drivers/platform/mellanox/mlxbf-tmfifo.c
index 38800e86ed8a..1ae3c56b66b0 100644
--- a/drivers/platform/mellanox/mlxbf-tmfifo.c
+++ b/drivers/platform/mellanox/mlxbf-tmfifo.c
@@ -959,6 +959,8 @@ static int mlxbf_tmfifo_virtio_find_vqs(struct virtio_device *vdev,
goto error;
}
+ vq->num_max = vring->num;
+
vqs[i] = vq;
vring->vq = vq;
vq->priv = vring;
diff --git a/drivers/remoteproc/remoteproc_virtio.c b/drivers/remoteproc/remoteproc_virtio.c
index d43d74733f0a..0f7706e23eb9 100644
--- a/drivers/remoteproc/remoteproc_virtio.c
+++ b/drivers/remoteproc/remoteproc_virtio.c
@@ -125,6 +125,8 @@ static struct virtqueue *rp_find_vq(struct virtio_device *vdev,
return ERR_PTR(-ENOMEM);
}
+ vq->num_max = num;
+
rvring->vq = vq;
vq->priv = rvring;
diff --git a/drivers/s390/virtio/virtio_ccw.c b/drivers/s390/virtio/virtio_ccw.c
index 161d3b141f0d..6b86d0280d6b 100644
--- a/drivers/s390/virtio/virtio_ccw.c
+++ b/drivers/s390/virtio/virtio_ccw.c
@@ -530,6 +530,9 @@ static struct virtqueue *virtio_ccw_setup_vq(struct virtio_device *vdev,
err = -ENOMEM;
goto out_err;
}
+
+ vq->num_max = info->num;
+
/* it may have been reduced */
info->num = virtqueue_get_vring_size(vq);
diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
index 083ff1eb743d..a20d5a6b5819 100644
--- a/drivers/virtio/virtio_mmio.c
+++ b/drivers/virtio/virtio_mmio.c
@@ -403,6 +403,8 @@ static struct virtqueue *vm_setup_vq(struct virtio_device *vdev, unsigned int in
goto error_new_virtqueue;
}
+ vq->num_max = num;
+
/* Activate the queue */
writel(virtqueue_get_vring_size(vq), vm_dev->base + VIRTIO_MMIO_QUEUE_NUM);
if (vm_dev->version == 1) {
diff --git a/drivers/virtio/virtio_pci_legacy.c b/drivers/virtio/virtio_pci_legacy.c
index a5e5721145c7..2257f1b3d8ae 100644
--- a/drivers/virtio/virtio_pci_legacy.c
+++ b/drivers/virtio/virtio_pci_legacy.c
@@ -135,6 +135,8 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
if (!vq)
return ERR_PTR(-ENOMEM);
+ vq->num_max = num;
+
q_pfn = virtqueue_get_desc_addr(vq) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT;
if (q_pfn >> 32) {
dev_err(&vp_dev->pci_dev->dev,
diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c
index 623906b4996c..e7e0b8c850f6 100644
--- a/drivers/virtio/virtio_pci_modern.c
+++ b/drivers/virtio/virtio_pci_modern.c
@@ -218,6 +218,8 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
if (!vq)
return ERR_PTR(-ENOMEM);
+ vq->num_max = num;
+
/* activate the queue */
vp_modern_set_queue_size(mdev, index, virtqueue_get_vring_size(vq));
vp_modern_queue_address(mdev, index, virtqueue_get_desc_addr(vq),
diff --git a/drivers/virtio/virtio_vdpa.c b/drivers/virtio/virtio_vdpa.c
index c40f7deb6b5a..9670cc79371d 100644
--- a/drivers/virtio/virtio_vdpa.c
+++ b/drivers/virtio/virtio_vdpa.c
@@ -183,6 +183,8 @@ virtio_vdpa_setup_vq(struct virtio_device *vdev, unsigned int index,
goto error_new_virtqueue;
}
+ vq->num_max = max_num;
+
/* Setup virtqueue callback */
cb.callback = callback ? virtio_vdpa_virtqueue_cb : NULL;
cb.private = info;
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index d8fdf170637c..129bde7521e3 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -19,6 +19,7 @@
* @priv: a pointer for the virtqueue implementation to use.
* @index: the zero-based ordinal number for this queue.
* @num_free: number of elements we expect to be able to fit.
+ * @num_max: the maximum number of elements supported by the device.
*
* A note on @num_free: with indirect buffers, each buffer needs one
* element in the queue, otherwise a buffer will need one element per
@@ -31,6 +32,7 @@ struct virtqueue {
struct virtio_device *vdev;
unsigned int index;
unsigned int num_free;
+ unsigned int num_max;
void *priv;
};
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v12 01/40] virtio: record the maximum queue num supported by the device.
2022-07-20 3:03 ` [PATCH v12 01/40] virtio: record the maximum queue num supported by the device Xuan Zhuo
@ 2022-07-21 3:36 ` Jason Wang
0 siblings, 0 replies; 60+ messages in thread
From: Jason Wang @ 2022-07-21 3:36 UTC (permalink / raw)
To: Xuan Zhuo, virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
在 2022/7/20 11:03, Xuan Zhuo 写道:
> virtio-net can display the maximum (supported by hardware) ring size in
> ethtool -g eth0.
>
> When the subsequent patch implements vring reset, it can judge whether
> the ring size passed by the driver is legal based on this.
>
> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
> ---
> arch/um/drivers/virtio_uml.c | 1 +
> drivers/platform/mellanox/mlxbf-tmfifo.c | 2 ++
> drivers/remoteproc/remoteproc_virtio.c | 2 ++
> drivers/s390/virtio/virtio_ccw.c | 3 +++
> drivers/virtio/virtio_mmio.c | 2 ++
> drivers/virtio/virtio_pci_legacy.c | 2 ++
> drivers/virtio/virtio_pci_modern.c | 2 ++
> drivers/virtio/virtio_vdpa.c | 2 ++
> include/linux/virtio.h | 2 ++
> 9 files changed, 18 insertions(+)
>
> diff --git a/arch/um/drivers/virtio_uml.c b/arch/um/drivers/virtio_uml.c
> index 82ff3785bf69..e719af8bdf56 100644
> --- a/arch/um/drivers/virtio_uml.c
> +++ b/arch/um/drivers/virtio_uml.c
> @@ -958,6 +958,7 @@ static struct virtqueue *vu_setup_vq(struct virtio_device *vdev,
> goto error_create;
> }
> vq->priv = info;
> + vq->num_max = num;
> num = virtqueue_get_vring_size(vq);
>
> if (vu_dev->protocol_features &
> diff --git a/drivers/platform/mellanox/mlxbf-tmfifo.c b/drivers/platform/mellanox/mlxbf-tmfifo.c
> index 38800e86ed8a..1ae3c56b66b0 100644
> --- a/drivers/platform/mellanox/mlxbf-tmfifo.c
> +++ b/drivers/platform/mellanox/mlxbf-tmfifo.c
> @@ -959,6 +959,8 @@ static int mlxbf_tmfifo_virtio_find_vqs(struct virtio_device *vdev,
> goto error;
> }
>
> + vq->num_max = vring->num;
> +
> vqs[i] = vq;
> vring->vq = vq;
> vq->priv = vring;
> diff --git a/drivers/remoteproc/remoteproc_virtio.c b/drivers/remoteproc/remoteproc_virtio.c
> index d43d74733f0a..0f7706e23eb9 100644
> --- a/drivers/remoteproc/remoteproc_virtio.c
> +++ b/drivers/remoteproc/remoteproc_virtio.c
> @@ -125,6 +125,8 @@ static struct virtqueue *rp_find_vq(struct virtio_device *vdev,
> return ERR_PTR(-ENOMEM);
> }
>
> + vq->num_max = num;
> +
> rvring->vq = vq;
> vq->priv = rvring;
>
> diff --git a/drivers/s390/virtio/virtio_ccw.c b/drivers/s390/virtio/virtio_ccw.c
> index 161d3b141f0d..6b86d0280d6b 100644
> --- a/drivers/s390/virtio/virtio_ccw.c
> +++ b/drivers/s390/virtio/virtio_ccw.c
> @@ -530,6 +530,9 @@ static struct virtqueue *virtio_ccw_setup_vq(struct virtio_device *vdev,
> err = -ENOMEM;
> goto out_err;
> }
> +
> + vq->num_max = info->num;
> +
> /* it may have been reduced */
> info->num = virtqueue_get_vring_size(vq);
>
> diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
> index 083ff1eb743d..a20d5a6b5819 100644
> --- a/drivers/virtio/virtio_mmio.c
> +++ b/drivers/virtio/virtio_mmio.c
> @@ -403,6 +403,8 @@ static struct virtqueue *vm_setup_vq(struct virtio_device *vdev, unsigned int in
> goto error_new_virtqueue;
> }
>
> + vq->num_max = num;
> +
> /* Activate the queue */
> writel(virtqueue_get_vring_size(vq), vm_dev->base + VIRTIO_MMIO_QUEUE_NUM);
> if (vm_dev->version == 1) {
> diff --git a/drivers/virtio/virtio_pci_legacy.c b/drivers/virtio/virtio_pci_legacy.c
> index a5e5721145c7..2257f1b3d8ae 100644
> --- a/drivers/virtio/virtio_pci_legacy.c
> +++ b/drivers/virtio/virtio_pci_legacy.c
> @@ -135,6 +135,8 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
> if (!vq)
> return ERR_PTR(-ENOMEM);
>
> + vq->num_max = num;
> +
> q_pfn = virtqueue_get_desc_addr(vq) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT;
> if (q_pfn >> 32) {
> dev_err(&vp_dev->pci_dev->dev,
> diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c
> index 623906b4996c..e7e0b8c850f6 100644
> --- a/drivers/virtio/virtio_pci_modern.c
> +++ b/drivers/virtio/virtio_pci_modern.c
> @@ -218,6 +218,8 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
> if (!vq)
> return ERR_PTR(-ENOMEM);
>
> + vq->num_max = num;
> +
> /* activate the queue */
> vp_modern_set_queue_size(mdev, index, virtqueue_get_vring_size(vq));
> vp_modern_queue_address(mdev, index, virtqueue_get_desc_addr(vq),
> diff --git a/drivers/virtio/virtio_vdpa.c b/drivers/virtio/virtio_vdpa.c
> index c40f7deb6b5a..9670cc79371d 100644
> --- a/drivers/virtio/virtio_vdpa.c
> +++ b/drivers/virtio/virtio_vdpa.c
> @@ -183,6 +183,8 @@ virtio_vdpa_setup_vq(struct virtio_device *vdev, unsigned int index,
> goto error_new_virtqueue;
> }
>
> + vq->num_max = max_num;
> +
> /* Setup virtqueue callback */
> cb.callback = callback ? virtio_vdpa_virtqueue_cb : NULL;
> cb.private = info;
> diff --git a/include/linux/virtio.h b/include/linux/virtio.h
> index d8fdf170637c..129bde7521e3 100644
> --- a/include/linux/virtio.h
> +++ b/include/linux/virtio.h
> @@ -19,6 +19,7 @@
> * @priv: a pointer for the virtqueue implementation to use.
> * @index: the zero-based ordinal number for this queue.
> * @num_free: number of elements we expect to be able to fit.
> + * @num_max: the maximum number of elements supported by the device.
> *
> * A note on @num_free: with indirect buffers, each buffer needs one
> * element in the queue, otherwise a buffer will need one element per
> @@ -31,6 +32,7 @@ struct virtqueue {
> struct virtio_device *vdev;
> unsigned int index;
> unsigned int num_free;
> + unsigned int num_max;
> void *priv;
> };
>
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v12 02/40] virtio: struct virtio_config_ops add callbacks for queue_reset
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
2022-07-20 3:03 ` [PATCH v12 01/40] virtio: record the maximum queue num supported by the device Xuan Zhuo
@ 2022-07-20 3:03 ` Xuan Zhuo
2022-07-21 3:39 ` Jason Wang
2022-07-20 3:03 ` [PATCH v12 03/40] virtio_ring: update the document of the virtqueue_detach_unused_buf for queue reset Xuan Zhuo
` (37 subsequent siblings)
39 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:03 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
reset can be divided into the following four steps (example):
1. transport: notify the device to reset the queue
2. vring: recycle the buffer submitted
3. vring: reset/resize the vring (may re-alloc)
4. transport: mmap vring to device, and enable the queue
In order to support queue reset, add two callbacks in struct
virtio_config_ops to implement steps 1 and 4.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
include/linux/virtio_config.h | 14 ++++++++++++++
1 file changed, 14 insertions(+)
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index b47c2e7ed0ee..36ec7be1f480 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -78,6 +78,18 @@ struct virtio_shm_region {
* @set_vq_affinity: set the affinity for a virtqueue (optional).
* @get_vq_affinity: get the affinity for a virtqueue (optional).
* @get_shm_region: get a shared memory region based on the index.
+ * @disable_vq_and_reset: reset a queue individually (optional).
+ * vq: the virtqueue
+ * Returns 0 on success or error status
+ * disable_vq_and_reset will guarantee that the callbacks are disabled and
+ * synchronized.
+ * Except for the callback, the caller should guarantee that the vring is
+ * not accessed by any functions of virtqueue.
+ * @enable_vq_after_reset: enable a reset queue
+ * vq: the virtqueue
+ * Returns 0 on success or error status
+ * If disable_vq_and_reset is set, then enable_vq_after_reset must also be
+ * set.
*/
typedef void vq_callback_t(struct virtqueue *);
struct virtio_config_ops {
@@ -104,6 +116,8 @@ struct virtio_config_ops {
int index);
bool (*get_shm_region)(struct virtio_device *vdev,
struct virtio_shm_region *region, u8 id);
+ int (*disable_vq_and_reset)(struct virtqueue *vq);
+ int (*enable_vq_after_reset)(struct virtqueue *vq);
};
/* If driver didn't advertise the feature, it will never appear. */
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v12 02/40] virtio: struct virtio_config_ops add callbacks for queue_reset
2022-07-20 3:03 ` [PATCH v12 02/40] virtio: struct virtio_config_ops add callbacks for queue_reset Xuan Zhuo
@ 2022-07-21 3:39 ` Jason Wang
0 siblings, 0 replies; 60+ messages in thread
From: Jason Wang @ 2022-07-21 3:39 UTC (permalink / raw)
To: Xuan Zhuo, virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
在 2022/7/20 11:03, Xuan Zhuo 写道:
> reset can be divided into the following four steps (example):
> 1. transport: notify the device to reset the queue
> 2. vring: recycle the buffer submitted
> 3. vring: reset/resize the vring (may re-alloc)
> 4. transport: mmap vring to device, and enable the queue
>
> In order to support queue reset, add two callbacks in struct
> virtio_config_ops to implement steps 1 and 4.
>
> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
> ---
> include/linux/virtio_config.h | 14 ++++++++++++++
> 1 file changed, 14 insertions(+)
>
> diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
> index b47c2e7ed0ee..36ec7be1f480 100644
> --- a/include/linux/virtio_config.h
> +++ b/include/linux/virtio_config.h
> @@ -78,6 +78,18 @@ struct virtio_shm_region {
> * @set_vq_affinity: set the affinity for a virtqueue (optional).
> * @get_vq_affinity: get the affinity for a virtqueue (optional).
> * @get_shm_region: get a shared memory region based on the index.
> + * @disable_vq_and_reset: reset a queue individually (optional).
> + * vq: the virtqueue
> + * Returns 0 on success or error status
> + * disable_vq_and_reset will guarantee that the callbacks are disabled and
> + * synchronized.
> + * Except for the callback, the caller should guarantee that the vring is
> + * not accessed by any functions of virtqueue.
> + * @enable_vq_after_reset: enable a reset queue
> + * vq: the virtqueue
> + * Returns 0 on success or error status
> + * If disable_vq_and_reset is set, then enable_vq_after_reset must also be
> + * set.
> */
> typedef void vq_callback_t(struct virtqueue *);
> struct virtio_config_ops {
> @@ -104,6 +116,8 @@ struct virtio_config_ops {
> int index);
> bool (*get_shm_region)(struct virtio_device *vdev,
> struct virtio_shm_region *region, u8 id);
> + int (*disable_vq_and_reset)(struct virtqueue *vq);
> + int (*enable_vq_after_reset)(struct virtqueue *vq);
> };
>
> /* If driver didn't advertise the feature, it will never appear. */
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v12 03/40] virtio_ring: update the document of the virtqueue_detach_unused_buf for queue reset
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
2022-07-20 3:03 ` [PATCH v12 01/40] virtio: record the maximum queue num supported by the device Xuan Zhuo
2022-07-20 3:03 ` [PATCH v12 02/40] virtio: struct virtio_config_ops add callbacks for queue_reset Xuan Zhuo
@ 2022-07-20 3:03 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 04/40] virtio_ring: extract the logic of freeing vring Xuan Zhuo
` (36 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:03 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Added documentation for virtqueue_detach_unused_buf, allowing it to be
called on queue reset.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/virtio/virtio_ring.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index a5ec724c01d8..17024389b62c 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -2130,8 +2130,8 @@ EXPORT_SYMBOL_GPL(virtqueue_enable_cb_delayed);
* @_vq: the struct virtqueue we're talking about.
*
* Returns NULL or the "data" token handed to virtqueue_add_*().
- * This is not valid on an active queue; it is useful only for device
- * shutdown.
+ * This is not valid on an active queue; it is useful for device
+ * shutdown or the reset queue.
*/
void *virtqueue_detach_unused_buf(struct virtqueue *_vq)
{
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 04/40] virtio_ring: extract the logic of freeing vring
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (2 preceding siblings ...)
2022-07-20 3:03 ` [PATCH v12 03/40] virtio_ring: update the document of the virtqueue_detach_unused_buf for queue reset Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 05/40] virtio_ring: split vring_virtqueue Xuan Zhuo
` (35 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Introduce vring_free() to free the vring of vq.
Subsequent patches will use vring_free() alone.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/virtio/virtio_ring.c | 18 +++++++++++++-----
1 file changed, 13 insertions(+), 5 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 17024389b62c..a3d76fd87983 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -2316,14 +2316,10 @@ struct virtqueue *vring_new_virtqueue(unsigned int index,
}
EXPORT_SYMBOL_GPL(vring_new_virtqueue);
-void vring_del_virtqueue(struct virtqueue *_vq)
+static void vring_free(struct virtqueue *_vq)
{
struct vring_virtqueue *vq = to_vvq(_vq);
- spin_lock(&vq->vq.vdev->vqs_list_lock);
- list_del(&_vq->list);
- spin_unlock(&vq->vq.vdev->vqs_list_lock);
-
if (vq->we_own_ring) {
if (vq->packed_ring) {
vring_free_queue(vq->vq.vdev,
@@ -2354,6 +2350,18 @@ void vring_del_virtqueue(struct virtqueue *_vq)
kfree(vq->split.desc_state);
kfree(vq->split.desc_extra);
}
+}
+
+void vring_del_virtqueue(struct virtqueue *_vq)
+{
+ struct vring_virtqueue *vq = to_vvq(_vq);
+
+ spin_lock(&vq->vq.vdev->vqs_list_lock);
+ list_del(&_vq->list);
+ spin_unlock(&vq->vq.vdev->vqs_list_lock);
+
+ vring_free(_vq);
+
kfree(vq);
}
EXPORT_SYMBOL_GPL(vring_del_virtqueue);
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 05/40] virtio_ring: split vring_virtqueue
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (3 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 04/40] virtio_ring: extract the logic of freeing vring Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 06/40] virtio_ring: introduce virtqueue_init() Xuan Zhuo
` (34 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Separate the two inline structures(split and packed) from the structure
vring_virtqueue.
In this way, we can use these two structures later to pass parameters
and retain temporary variables.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/virtio/virtio_ring.c | 116 ++++++++++++++++++-----------------
1 file changed, 60 insertions(+), 56 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index a3d76fd87983..1bc5794e9739 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -85,6 +85,64 @@ struct vring_desc_extra {
u16 next; /* The next desc state in a list. */
};
+struct vring_virtqueue_split {
+ /* Actual memory layout for this queue. */
+ struct vring vring;
+
+ /* Last written value to avail->flags */
+ u16 avail_flags_shadow;
+
+ /*
+ * Last written value to avail->idx in
+ * guest byte order.
+ */
+ u16 avail_idx_shadow;
+
+ /* Per-descriptor state. */
+ struct vring_desc_state_split *desc_state;
+ struct vring_desc_extra *desc_extra;
+
+ /* DMA address and size information */
+ dma_addr_t queue_dma_addr;
+ size_t queue_size_in_bytes;
+};
+
+struct vring_virtqueue_packed {
+ /* Actual memory layout for this queue. */
+ struct {
+ unsigned int num;
+ struct vring_packed_desc *desc;
+ struct vring_packed_desc_event *driver;
+ struct vring_packed_desc_event *device;
+ } vring;
+
+ /* Driver ring wrap counter. */
+ bool avail_wrap_counter;
+
+ /* Avail used flags. */
+ u16 avail_used_flags;
+
+ /* Index of the next avail descriptor. */
+ u16 next_avail_idx;
+
+ /*
+ * Last written value to driver->flags in
+ * guest byte order.
+ */
+ u16 event_flags_shadow;
+
+ /* Per-descriptor state. */
+ struct vring_desc_state_packed *desc_state;
+ struct vring_desc_extra *desc_extra;
+
+ /* DMA address and size information */
+ dma_addr_t ring_dma_addr;
+ dma_addr_t driver_event_dma_addr;
+ dma_addr_t device_event_dma_addr;
+ size_t ring_size_in_bytes;
+ size_t event_size_in_bytes;
+};
+
struct vring_virtqueue {
struct virtqueue vq;
@@ -124,64 +182,10 @@ struct vring_virtqueue {
union {
/* Available for split ring */
- struct {
- /* Actual memory layout for this queue. */
- struct vring vring;
-
- /* Last written value to avail->flags */
- u16 avail_flags_shadow;
-
- /*
- * Last written value to avail->idx in
- * guest byte order.
- */
- u16 avail_idx_shadow;
-
- /* Per-descriptor state. */
- struct vring_desc_state_split *desc_state;
- struct vring_desc_extra *desc_extra;
-
- /* DMA address and size information */
- dma_addr_t queue_dma_addr;
- size_t queue_size_in_bytes;
- } split;
+ struct vring_virtqueue_split split;
/* Available for packed ring */
- struct {
- /* Actual memory layout for this queue. */
- struct {
- unsigned int num;
- struct vring_packed_desc *desc;
- struct vring_packed_desc_event *driver;
- struct vring_packed_desc_event *device;
- } vring;
-
- /* Driver ring wrap counter. */
- bool avail_wrap_counter;
-
- /* Avail used flags. */
- u16 avail_used_flags;
-
- /* Index of the next avail descriptor. */
- u16 next_avail_idx;
-
- /*
- * Last written value to driver->flags in
- * guest byte order.
- */
- u16 event_flags_shadow;
-
- /* Per-descriptor state. */
- struct vring_desc_state_packed *desc_state;
- struct vring_desc_extra *desc_extra;
-
- /* DMA address and size information */
- dma_addr_t ring_dma_addr;
- dma_addr_t driver_event_dma_addr;
- dma_addr_t device_event_dma_addr;
- size_t ring_size_in_bytes;
- size_t event_size_in_bytes;
- } packed;
+ struct vring_virtqueue_packed packed;
};
/* How to notify other side. FIXME: commonalize hcalls! */
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 06/40] virtio_ring: introduce virtqueue_init()
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (4 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 05/40] virtio_ring: split vring_virtqueue Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-21 7:07 ` Jason Wang
2022-07-20 3:04 ` [PATCH v12 07/40] virtio_ring: split: introduce vring_free_split() Xuan Zhuo
` (33 subsequent siblings)
39 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Separate the logic of virtqueue initialization. This logic is irrelevant
to ring layout.
This logic can be called independently when implementing resize/reset
later.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 61 ++++++++++++++++++------------------
1 file changed, 31 insertions(+), 30 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 1bc5794e9739..87ce17562b29 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -368,6 +368,34 @@ static int vring_mapping_error(const struct vring_virtqueue *vq,
return dma_mapping_error(vring_dma_dev(vq), addr);
}
+static void virtqueue_init(struct vring_virtqueue *vq, u32 num)
+{
+ struct virtio_device *vdev;
+
+ vdev = vq->vq.vdev;
+
+ vq->vq.num_free = num;
+ if (vq->packed_ring)
+ vq->last_used_idx = 0 | (1 << VRING_PACKED_EVENT_F_WRAP_CTR);
+ else
+ vq->last_used_idx = 0;
+ vq->event_triggered = false;
+ vq->num_added = 0;
+ vq->use_dma_api = vring_use_dma_api(vdev);
+#ifdef DEBUG
+ vq->in_use = false;
+ vq->last_add_time_valid = false;
+#endif
+
+ vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
+
+ if (virtio_has_feature(vdev, VIRTIO_F_ORDER_PLATFORM))
+ vq->weak_barriers = false;
+
+ /* Put everything in free lists. */
+ vq->free_head = 0;
+}
+
/*
* Split ring specific functions - *_split().
@@ -1706,7 +1734,6 @@ static struct virtqueue *vring_create_virtqueue_packed(
vq->vq.callback = callback;
vq->vq.vdev = vdev;
vq->vq.name = name;
- vq->vq.num_free = num;
vq->vq.index = index;
vq->we_own_ring = true;
vq->notify = notify;
@@ -1716,22 +1743,10 @@ static struct virtqueue *vring_create_virtqueue_packed(
#else
vq->broken = false;
#endif
- vq->last_used_idx = 0 | (1 << VRING_PACKED_EVENT_F_WRAP_CTR);
- vq->event_triggered = false;
- vq->num_added = 0;
vq->packed_ring = true;
- vq->use_dma_api = vring_use_dma_api(vdev);
-#ifdef DEBUG
- vq->in_use = false;
- vq->last_add_time_valid = false;
-#endif
vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&
!context;
- vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
-
- if (virtio_has_feature(vdev, VIRTIO_F_ORDER_PLATFORM))
- vq->weak_barriers = false;
vq->packed.ring_dma_addr = ring_dma_addr;
vq->packed.driver_event_dma_addr = driver_event_dma_addr;
@@ -1759,8 +1774,7 @@ static struct virtqueue *vring_create_virtqueue_packed(
memset(vq->packed.desc_state, 0,
num * sizeof(struct vring_desc_state_packed));
- /* Put everything in free lists. */
- vq->free_head = 0;
+ virtqueue_init(vq, num);
vq->packed.desc_extra = vring_alloc_desc_extra(num);
if (!vq->packed.desc_extra)
@@ -2205,7 +2219,6 @@ struct virtqueue *__vring_new_virtqueue(unsigned int index,
vq->vq.callback = callback;
vq->vq.vdev = vdev;
vq->vq.name = name;
- vq->vq.num_free = vring.num;
vq->vq.index = index;
vq->we_own_ring = false;
vq->notify = notify;
@@ -2215,21 +2228,9 @@ struct virtqueue *__vring_new_virtqueue(unsigned int index,
#else
vq->broken = false;
#endif
- vq->last_used_idx = 0;
- vq->event_triggered = false;
- vq->num_added = 0;
- vq->use_dma_api = vring_use_dma_api(vdev);
-#ifdef DEBUG
- vq->in_use = false;
- vq->last_add_time_valid = false;
-#endif
vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&
!context;
- vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
-
- if (virtio_has_feature(vdev, VIRTIO_F_ORDER_PLATFORM))
- vq->weak_barriers = false;
vq->split.queue_dma_addr = 0;
vq->split.queue_size_in_bytes = 0;
@@ -2255,11 +2256,11 @@ struct virtqueue *__vring_new_virtqueue(unsigned int index,
if (!vq->split.desc_extra)
goto err_extra;
- /* Put everything in free lists. */
- vq->free_head = 0;
memset(vq->split.desc_state, 0, vring.num *
sizeof(struct vring_desc_state_split));
+ virtqueue_init(vq, vq->split.vring.num);
+
spin_lock(&vdev->vqs_list_lock);
list_add_tail(&vq->vq.list, &vdev->vqs);
spin_unlock(&vdev->vqs_list_lock);
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v12 06/40] virtio_ring: introduce virtqueue_init()
2022-07-20 3:04 ` [PATCH v12 06/40] virtio_ring: introduce virtqueue_init() Xuan Zhuo
@ 2022-07-21 7:07 ` Jason Wang
0 siblings, 0 replies; 60+ messages in thread
From: Jason Wang @ 2022-07-21 7:07 UTC (permalink / raw)
To: Xuan Zhuo, virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
在 2022/7/20 11:04, Xuan Zhuo 写道:
> Separate the logic of virtqueue initialization. This logic is irrelevant
> to ring layout.
>
> This logic can be called independently when implementing resize/reset
> later.
>
> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
> ---
> drivers/virtio/virtio_ring.c | 61 ++++++++++++++++++------------------
> 1 file changed, 31 insertions(+), 30 deletions(-)
>
> diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
> index 1bc5794e9739..87ce17562b29 100644
> --- a/drivers/virtio/virtio_ring.c
> +++ b/drivers/virtio/virtio_ring.c
> @@ -368,6 +368,34 @@ static int vring_mapping_error(const struct vring_virtqueue *vq,
> return dma_mapping_error(vring_dma_dev(vq), addr);
> }
>
> +static void virtqueue_init(struct vring_virtqueue *vq, u32 num)
> +{
> + struct virtio_device *vdev;
> +
> + vdev = vq->vq.vdev;
> +
> + vq->vq.num_free = num;
> + if (vq->packed_ring)
> + vq->last_used_idx = 0 | (1 << VRING_PACKED_EVENT_F_WRAP_CTR);
> + else
> + vq->last_used_idx = 0;
> + vq->event_triggered = false;
> + vq->num_added = 0;
> + vq->use_dma_api = vring_use_dma_api(vdev);
> +#ifdef DEBUG
> + vq->in_use = false;
> + vq->last_add_time_valid = false;
> +#endif
> +
> + vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
> +
> + if (virtio_has_feature(vdev, VIRTIO_F_ORDER_PLATFORM))
> + vq->weak_barriers = false;
> +
> + /* Put everything in free lists. */
> + vq->free_head = 0;
> +}
> +
>
> /*
> * Split ring specific functions - *_split().
> @@ -1706,7 +1734,6 @@ static struct virtqueue *vring_create_virtqueue_packed(
> vq->vq.callback = callback;
> vq->vq.vdev = vdev;
> vq->vq.name = name;
> - vq->vq.num_free = num;
> vq->vq.index = index;
> vq->we_own_ring = true;
> vq->notify = notify;
> @@ -1716,22 +1743,10 @@ static struct virtqueue *vring_create_virtqueue_packed(
> #else
> vq->broken = false;
> #endif
> - vq->last_used_idx = 0 | (1 << VRING_PACKED_EVENT_F_WRAP_CTR);
> - vq->event_triggered = false;
> - vq->num_added = 0;
> vq->packed_ring = true;
> - vq->use_dma_api = vring_use_dma_api(vdev);
> -#ifdef DEBUG
> - vq->in_use = false;
> - vq->last_add_time_valid = false;
> -#endif
>
> vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&
> !context;
> - vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
> -
> - if (virtio_has_feature(vdev, VIRTIO_F_ORDER_PLATFORM))
> - vq->weak_barriers = false;
>
> vq->packed.ring_dma_addr = ring_dma_addr;
> vq->packed.driver_event_dma_addr = driver_event_dma_addr;
> @@ -1759,8 +1774,7 @@ static struct virtqueue *vring_create_virtqueue_packed(
> memset(vq->packed.desc_state, 0,
> num * sizeof(struct vring_desc_state_packed));
>
> - /* Put everything in free lists. */
> - vq->free_head = 0;
> + virtqueue_init(vq, num);
>
> vq->packed.desc_extra = vring_alloc_desc_extra(num);
> if (!vq->packed.desc_extra)
> @@ -2205,7 +2219,6 @@ struct virtqueue *__vring_new_virtqueue(unsigned int index,
> vq->vq.callback = callback;
> vq->vq.vdev = vdev;
> vq->vq.name = name;
> - vq->vq.num_free = vring.num;
> vq->vq.index = index;
> vq->we_own_ring = false;
> vq->notify = notify;
> @@ -2215,21 +2228,9 @@ struct virtqueue *__vring_new_virtqueue(unsigned int index,
> #else
> vq->broken = false;
> #endif
> - vq->last_used_idx = 0;
> - vq->event_triggered = false;
> - vq->num_added = 0;
> - vq->use_dma_api = vring_use_dma_api(vdev);
> -#ifdef DEBUG
> - vq->in_use = false;
> - vq->last_add_time_valid = false;
> -#endif
>
> vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&
> !context;
> - vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
> -
> - if (virtio_has_feature(vdev, VIRTIO_F_ORDER_PLATFORM))
> - vq->weak_barriers = false;
>
> vq->split.queue_dma_addr = 0;
> vq->split.queue_size_in_bytes = 0;
> @@ -2255,11 +2256,11 @@ struct virtqueue *__vring_new_virtqueue(unsigned int index,
> if (!vq->split.desc_extra)
> goto err_extra;
>
> - /* Put everything in free lists. */
> - vq->free_head = 0;
> memset(vq->split.desc_state, 0, vring.num *
> sizeof(struct vring_desc_state_split));
>
> + virtqueue_init(vq, vq->split.vring.num);
> +
> spin_lock(&vdev->vqs_list_lock);
> list_add_tail(&vq->vq.list, &vdev->vqs);
> spin_unlock(&vdev->vqs_list_lock);
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v12 07/40] virtio_ring: split: introduce vring_free_split()
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (5 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 06/40] virtio_ring: introduce virtqueue_init() Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-21 7:08 ` Jason Wang
2022-07-20 3:04 ` [PATCH v12 08/40] virtio_ring: split: extract the logic of alloc queue Xuan Zhuo
` (32 subsequent siblings)
39 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Free the structure struct vring_vritqueue_split.
Subsequent patches require it.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 87ce17562b29..c94c5461e702 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -939,6 +939,17 @@ static void *virtqueue_detach_unused_buf_split(struct virtqueue *_vq)
return NULL;
}
+static void vring_free_split(struct vring_virtqueue_split *vring_split,
+ struct virtio_device *vdev)
+{
+ vring_free_queue(vdev, vring_split->queue_size_in_bytes,
+ vring_split->vring.desc,
+ vring_split->queue_dma_addr);
+
+ kfree(vring_split->desc_state);
+ kfree(vring_split->desc_extra);
+}
+
static struct virtqueue *vring_create_virtqueue_split(
unsigned int index,
unsigned int num,
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v12 07/40] virtio_ring: split: introduce vring_free_split()
2022-07-20 3:04 ` [PATCH v12 07/40] virtio_ring: split: introduce vring_free_split() Xuan Zhuo
@ 2022-07-21 7:08 ` Jason Wang
0 siblings, 0 replies; 60+ messages in thread
From: Jason Wang @ 2022-07-21 7:08 UTC (permalink / raw)
To: Xuan Zhuo, virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
在 2022/7/20 11:04, Xuan Zhuo 写道:
> Free the structure struct vring_vritqueue_split.
>
> Subsequent patches require it.
>
> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
> ---
> drivers/virtio/virtio_ring.c | 11 +++++++++++
> 1 file changed, 11 insertions(+)
>
> diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
> index 87ce17562b29..c94c5461e702 100644
> --- a/drivers/virtio/virtio_ring.c
> +++ b/drivers/virtio/virtio_ring.c
> @@ -939,6 +939,17 @@ static void *virtqueue_detach_unused_buf_split(struct virtqueue *_vq)
> return NULL;
> }
>
> +static void vring_free_split(struct vring_virtqueue_split *vring_split,
> + struct virtio_device *vdev)
> +{
> + vring_free_queue(vdev, vring_split->queue_size_in_bytes,
> + vring_split->vring.desc,
> + vring_split->queue_dma_addr);
> +
> + kfree(vring_split->desc_state);
> + kfree(vring_split->desc_extra);
> +}
> +
> static struct virtqueue *vring_create_virtqueue_split(
> unsigned int index,
> unsigned int num,
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v12 08/40] virtio_ring: split: extract the logic of alloc queue
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (6 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 07/40] virtio_ring: split: introduce vring_free_split() Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-21 9:13 ` Jason Wang
2022-07-20 3:04 ` [PATCH v12 09/40] virtio_ring: split: extract the logic of alloc state and extra Xuan Zhuo
` (31 subsequent siblings)
39 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Separate the logic of split to create vring queue.
This feature is required for subsequent virtuqueue reset vring.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 68 ++++++++++++++++++++++--------------
1 file changed, 42 insertions(+), 26 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index c94c5461e702..c7971438bb2c 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -950,28 +950,19 @@ static void vring_free_split(struct vring_virtqueue_split *vring_split,
kfree(vring_split->desc_extra);
}
-static struct virtqueue *vring_create_virtqueue_split(
- unsigned int index,
- unsigned int num,
- unsigned int vring_align,
- struct virtio_device *vdev,
- bool weak_barriers,
- bool may_reduce_num,
- bool context,
- bool (*notify)(struct virtqueue *),
- void (*callback)(struct virtqueue *),
- const char *name)
+static int vring_alloc_queue_split(struct vring_virtqueue_split *vring_split,
+ struct virtio_device *vdev,
+ u32 num,
+ unsigned int vring_align,
+ bool may_reduce_num)
{
- struct virtqueue *vq;
void *queue = NULL;
dma_addr_t dma_addr;
- size_t queue_size_in_bytes;
- struct vring vring;
/* We assume num is a power of 2. */
if (num & (num - 1)) {
dev_warn(&vdev->dev, "Bad virtqueue length %u\n", num);
- return NULL;
+ return -EINVAL;
}
/* TODO: allocate each queue chunk individually */
@@ -982,11 +973,11 @@ static struct virtqueue *vring_create_virtqueue_split(
if (queue)
break;
if (!may_reduce_num)
- return NULL;
+ return -ENOMEM;
}
if (!num)
- return NULL;
+ return -ENOMEM;
if (!queue) {
/* Try to get a single page. You are my only hope! */
@@ -994,21 +985,46 @@ static struct virtqueue *vring_create_virtqueue_split(
&dma_addr, GFP_KERNEL|__GFP_ZERO);
}
if (!queue)
- return NULL;
+ return -ENOMEM;
+
+ vring_init(&vring_split->vring, num, queue, vring_align);
- queue_size_in_bytes = vring_size(num, vring_align);
- vring_init(&vring, num, queue, vring_align);
+ vring_split->queue_dma_addr = dma_addr;
+ vring_split->queue_size_in_bytes = vring_size(num, vring_align);
+
+ return 0;
+}
+
+static struct virtqueue *vring_create_virtqueue_split(
+ unsigned int index,
+ unsigned int num,
+ unsigned int vring_align,
+ struct virtio_device *vdev,
+ bool weak_barriers,
+ bool may_reduce_num,
+ bool context,
+ bool (*notify)(struct virtqueue *),
+ void (*callback)(struct virtqueue *),
+ const char *name)
+{
+ struct vring_virtqueue_split vring_split = {};
+ struct virtqueue *vq;
+ int err;
+
+ err = vring_alloc_queue_split(&vring_split, vdev, num, vring_align,
+ may_reduce_num);
+ if (err)
+ return NULL;
- vq = __vring_new_virtqueue(index, vring, vdev, weak_barriers, context,
- notify, callback, name);
+ vq = __vring_new_virtqueue(index, vring_split.vring, vdev, weak_barriers,
+ context, notify, callback, name);
if (!vq) {
- vring_free_queue(vdev, queue_size_in_bytes, queue,
- dma_addr);
+ vring_free_split(&vring_split, vdev);
return NULL;
}
- to_vvq(vq)->split.queue_dma_addr = dma_addr;
- to_vvq(vq)->split.queue_size_in_bytes = queue_size_in_bytes;
+ to_vvq(vq)->split.queue_dma_addr = vring_split.queue_dma_addr;
+ to_vvq(vq)->split.queue_size_in_bytes = vring_split.queue_size_in_bytes;
to_vvq(vq)->we_own_ring = true;
return vq;
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v12 08/40] virtio_ring: split: extract the logic of alloc queue
2022-07-20 3:04 ` [PATCH v12 08/40] virtio_ring: split: extract the logic of alloc queue Xuan Zhuo
@ 2022-07-21 9:13 ` Jason Wang
2022-07-22 3:47 ` Xuan Zhuo
0 siblings, 1 reply; 60+ messages in thread
From: Jason Wang @ 2022-07-21 9:13 UTC (permalink / raw)
To: Xuan Zhuo, virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
在 2022/7/20 11:04, Xuan Zhuo 写道:
> Separate the logic of split to create vring queue.
>
> This feature is required for subsequent virtuqueue reset vring.
>
> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
> ---
> drivers/virtio/virtio_ring.c | 68 ++++++++++++++++++++++--------------
> 1 file changed, 42 insertions(+), 26 deletions(-)
>
> diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
> index c94c5461e702..c7971438bb2c 100644
> --- a/drivers/virtio/virtio_ring.c
> +++ b/drivers/virtio/virtio_ring.c
> @@ -950,28 +950,19 @@ static void vring_free_split(struct vring_virtqueue_split *vring_split,
> kfree(vring_split->desc_extra);
> }
>
> -static struct virtqueue *vring_create_virtqueue_split(
> - unsigned int index,
> - unsigned int num,
> - unsigned int vring_align,
> - struct virtio_device *vdev,
> - bool weak_barriers,
> - bool may_reduce_num,
> - bool context,
> - bool (*notify)(struct virtqueue *),
> - void (*callback)(struct virtqueue *),
> - const char *name)
> +static int vring_alloc_queue_split(struct vring_virtqueue_split *vring_split,
> + struct virtio_device *vdev,
> + u32 num,
> + unsigned int vring_align,
> + bool may_reduce_num)
> {
> - struct virtqueue *vq;
> void *queue = NULL;
> dma_addr_t dma_addr;
> - size_t queue_size_in_bytes;
> - struct vring vring;
>
> /* We assume num is a power of 2. */
> if (num & (num - 1)) {
> dev_warn(&vdev->dev, "Bad virtqueue length %u\n", num);
> - return NULL;
> + return -EINVAL;
> }
>
> /* TODO: allocate each queue chunk individually */
> @@ -982,11 +973,11 @@ static struct virtqueue *vring_create_virtqueue_split(
> if (queue)
> break;
> if (!may_reduce_num)
> - return NULL;
> + return -ENOMEM;
> }
>
> if (!num)
> - return NULL;
> + return -ENOMEM;
>
> if (!queue) {
> /* Try to get a single page. You are my only hope! */
> @@ -994,21 +985,46 @@ static struct virtqueue *vring_create_virtqueue_split(
> &dma_addr, GFP_KERNEL|__GFP_ZERO);
> }
> if (!queue)
> - return NULL;
> + return -ENOMEM;
> +
> + vring_init(&vring_split->vring, num, queue, vring_align);
>
> - queue_size_in_bytes = vring_size(num, vring_align);
> - vring_init(&vring, num, queue, vring_align);
> + vring_split->queue_dma_addr = dma_addr;
> + vring_split->queue_size_in_bytes = vring_size(num, vring_align);
> +
> + return 0;
> +}
> +
> +static struct virtqueue *vring_create_virtqueue_split(
> + unsigned int index,
> + unsigned int num,
> + unsigned int vring_align,
> + struct virtio_device *vdev,
> + bool weak_barriers,
> + bool may_reduce_num,
> + bool context,
> + bool (*notify)(struct virtqueue *),
> + void (*callback)(struct virtqueue *),
> + const char *name)
> +{
> + struct vring_virtqueue_split vring_split = {};
> + struct virtqueue *vq;
> + int err;
> +
> + err = vring_alloc_queue_split(&vring_split, vdev, num, vring_align,
> + may_reduce_num);
> + if (err)
> + return NULL;
>
> - vq = __vring_new_virtqueue(index, vring, vdev, weak_barriers, context,
> - notify, callback, name);
> + vq = __vring_new_virtqueue(index, vring_split.vring, vdev, weak_barriers,
> + context, notify, callback, name);
> if (!vq) {
> - vring_free_queue(vdev, queue_size_in_bytes, queue,
> - dma_addr);
> + vring_free_split(&vring_split, vdev);
> return NULL;
> }
>
> - to_vvq(vq)->split.queue_dma_addr = dma_addr;
> - to_vvq(vq)->split.queue_size_in_bytes = queue_size_in_bytes;
> + to_vvq(vq)->split.queue_dma_addr = vring_split.queue_dma_addr;
> + to_vvq(vq)->split.queue_size_in_bytes = vring_split.queue_size_in_bytes;
This still seems a little bit redundant since the current logic is a
little bit complicated since the vq->split is not initialized in a
single place.
I wonder if it's better to:
vring_alloc_queue_split()
vring_alloc_desc_extra() (reorder to make patch 9 come first)
then we can simply assign vring_split to vq->split in
__vring_new_virtqueue() since it has:
vq->split.queue_dma_addr = 0;
vq->split.queue_size_in_bytes = 0;
vq->split.vring = vring;
vq->split.avail_flags_shadow = 0;
vq->split.avail_idx_shadow = 0;
This seems to simplify the logic and task of e.g
virtqueue_vring_attach_split() to a simple:
vq->split= vring_split;
And if this makes sense, we can do something similar to packed ring.
Thanks
> to_vvq(vq)->we_own_ring = true;
>
> return vq;
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v12 08/40] virtio_ring: split: extract the logic of alloc queue
2022-07-21 9:13 ` Jason Wang
@ 2022-07-22 3:47 ` Xuan Zhuo
0 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-22 3:47 UTC (permalink / raw)
To: Jason Wang
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu, virtualization
On Thu, 21 Jul 2022 17:13:49 +0800, Jason Wang <jasowang@redhat.com> wrote:
>
> 在 2022/7/20 11:04, Xuan Zhuo 写道:
> > Separate the logic of split to create vring queue.
> >
> > This feature is required for subsequent virtuqueue reset vring.
> >
> > Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
> > ---
> > drivers/virtio/virtio_ring.c | 68 ++++++++++++++++++++++--------------
> > 1 file changed, 42 insertions(+), 26 deletions(-)
> >
> > diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
> > index c94c5461e702..c7971438bb2c 100644
> > --- a/drivers/virtio/virtio_ring.c
> > +++ b/drivers/virtio/virtio_ring.c
> > @@ -950,28 +950,19 @@ static void vring_free_split(struct vring_virtqueue_split *vring_split,
> > kfree(vring_split->desc_extra);
> > }
> >
> > -static struct virtqueue *vring_create_virtqueue_split(
> > - unsigned int index,
> > - unsigned int num,
> > - unsigned int vring_align,
> > - struct virtio_device *vdev,
> > - bool weak_barriers,
> > - bool may_reduce_num,
> > - bool context,
> > - bool (*notify)(struct virtqueue *),
> > - void (*callback)(struct virtqueue *),
> > - const char *name)
> > +static int vring_alloc_queue_split(struct vring_virtqueue_split *vring_split,
> > + struct virtio_device *vdev,
> > + u32 num,
> > + unsigned int vring_align,
> > + bool may_reduce_num)
> > {
> > - struct virtqueue *vq;
> > void *queue = NULL;
> > dma_addr_t dma_addr;
> > - size_t queue_size_in_bytes;
> > - struct vring vring;
> >
> > /* We assume num is a power of 2. */
> > if (num & (num - 1)) {
> > dev_warn(&vdev->dev, "Bad virtqueue length %u\n", num);
> > - return NULL;
> > + return -EINVAL;
> > }
> >
> > /* TODO: allocate each queue chunk individually */
> > @@ -982,11 +973,11 @@ static struct virtqueue *vring_create_virtqueue_split(
> > if (queue)
> > break;
> > if (!may_reduce_num)
> > - return NULL;
> > + return -ENOMEM;
> > }
> >
> > if (!num)
> > - return NULL;
> > + return -ENOMEM;
> >
> > if (!queue) {
> > /* Try to get a single page. You are my only hope! */
> > @@ -994,21 +985,46 @@ static struct virtqueue *vring_create_virtqueue_split(
> > &dma_addr, GFP_KERNEL|__GFP_ZERO);
> > }
> > if (!queue)
> > - return NULL;
> > + return -ENOMEM;
> > +
> > + vring_init(&vring_split->vring, num, queue, vring_align);
> >
> > - queue_size_in_bytes = vring_size(num, vring_align);
> > - vring_init(&vring, num, queue, vring_align);
> > + vring_split->queue_dma_addr = dma_addr;
> > + vring_split->queue_size_in_bytes = vring_size(num, vring_align);
> > +
> > + return 0;
> > +}
> > +
> > +static struct virtqueue *vring_create_virtqueue_split(
> > + unsigned int index,
> > + unsigned int num,
> > + unsigned int vring_align,
> > + struct virtio_device *vdev,
> > + bool weak_barriers,
> > + bool may_reduce_num,
> > + bool context,
> > + bool (*notify)(struct virtqueue *),
> > + void (*callback)(struct virtqueue *),
> > + const char *name)
> > +{
> > + struct vring_virtqueue_split vring_split = {};
> > + struct virtqueue *vq;
> > + int err;
> > +
> > + err = vring_alloc_queue_split(&vring_split, vdev, num, vring_align,
> > + may_reduce_num);
> > + if (err)
> > + return NULL;
> >
> > - vq = __vring_new_virtqueue(index, vring, vdev, weak_barriers, context,
> > - notify, callback, name);
> > + vq = __vring_new_virtqueue(index, vring_split.vring, vdev, weak_barriers,
> > + context, notify, callback, name);
> > if (!vq) {
> > - vring_free_queue(vdev, queue_size_in_bytes, queue,
> > - dma_addr);
> > + vring_free_split(&vring_split, vdev);
> > return NULL;
> > }
> >
> > - to_vvq(vq)->split.queue_dma_addr = dma_addr;
> > - to_vvq(vq)->split.queue_size_in_bytes = queue_size_in_bytes;
> > + to_vvq(vq)->split.queue_dma_addr = vring_split.queue_dma_addr;
> > + to_vvq(vq)->split.queue_size_in_bytes = vring_split.queue_size_in_bytes;
>
>
> This still seems a little bit redundant since the current logic is a
> little bit complicated since the vq->split is not initialized in a
> single place.
>
> I wonder if it's better to:
>
> vring_alloc_queue_split()
> vring_alloc_desc_extra() (reorder to make patch 9 come first)
>
> then we can simply assign vring_split to vq->split in
> __vring_new_virtqueue() since it has:
>
> vq->split.queue_dma_addr = 0;
> vq->split.queue_size_in_bytes = 0;
>
> vq->split.vring = vring;
> vq->split.avail_flags_shadow = 0;
> vq->split.avail_idx_shadow = 0;
>
> This seems to simplify the logic and task of e.g
> virtqueue_vring_attach_split() to a simple:
>
> vq->split= vring_split;
This does look simpler. The reason for not doing this is that the argument
accepted by __vring_new_virtqueue() is "struct vring", and
__vring_new_virtqueue() is an export symbol.
I took a look, and the only external direct call to __vring_new_virtqueue is
here.
tools/virtio/virtio_test.c
static void vq_reset(struct vq_info *info, int num, struct virtio_device *vdev)
{
if (info->vq)
vring_del_virtqueue(info->vq);
memset(info->ring, 0, vring_size(num, 4096));
vring_init(&info->vring, num, info->ring, 4096);
info->vq = __vring_new_virtqueue(info->idx, info->vring, vdev, true,
false, vq_notify, vq_callback, "test");
assert(info->vq);
info->vq->priv = info;
}
I think this could be replaced with vring_new_virtqueue() so that we don't need
to make __vring_new_virtqueue as an export function so we can make some
modifications to it.
nit: vring_alloc_desc_extra() should not have to be extract from
__vring_new_virtqueue() .
Thanks.
>
> And if this makes sense, we can do something similar to packed ring.
>
> Thanks
>
>
> > to_vvq(vq)->we_own_ring = true;
> >
> > return vq;
>
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v12 09/40] virtio_ring: split: extract the logic of alloc state and extra
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (7 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 08/40] virtio_ring: split: extract the logic of alloc queue Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 10/40] virtio_ring: split: extract the logic of attach vring Xuan Zhuo
` (30 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Separate the logic of creating desc_state, desc_extra, and subsequent
patches will call it independently.
Since only the structure vring is passed into __vring_new_virtqueue(),
when creating the function vring_alloc_state_extra_split(), we prefer to
use vring_virtqueue_split as a parameter, and it will be more convenient
to pass vring_virtqueue_split to some subsequent functions.
So a new vring_virtqueue_split variable is added in
__vring_new_virtqueue().
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 54 +++++++++++++++++++++++++-----------
1 file changed, 38 insertions(+), 16 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index c7971438bb2c..ef2077e8b38d 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -204,6 +204,7 @@ struct vring_virtqueue {
#endif
};
+static struct vring_desc_extra *vring_alloc_desc_extra(unsigned int num);
/*
* Helpers.
@@ -939,6 +940,32 @@ static void *virtqueue_detach_unused_buf_split(struct virtqueue *_vq)
return NULL;
}
+static int vring_alloc_state_extra_split(struct vring_virtqueue_split *vring_split)
+{
+ struct vring_desc_state_split *state;
+ struct vring_desc_extra *extra;
+ u32 num = vring_split->vring.num;
+
+ state = kmalloc_array(num, sizeof(struct vring_desc_state_split), GFP_KERNEL);
+ if (!state)
+ goto err_state;
+
+ extra = vring_alloc_desc_extra(num);
+ if (!extra)
+ goto err_extra;
+
+ memset(state, 0, num * sizeof(struct vring_desc_state_split));
+
+ vring_split->desc_state = state;
+ vring_split->desc_extra = extra;
+ return 0;
+
+err_extra:
+ kfree(state);
+err_state:
+ return -ENOMEM;
+}
+
static void vring_free_split(struct vring_virtqueue_split *vring_split,
struct virtio_device *vdev)
{
@@ -2233,7 +2260,9 @@ struct virtqueue *__vring_new_virtqueue(unsigned int index,
void (*callback)(struct virtqueue *),
const char *name)
{
+ struct vring_virtqueue_split vring_split = {};
struct vring_virtqueue *vq;
+ int err;
if (virtio_has_feature(vdev, VIRTIO_F_RING_PACKED))
return NULL;
@@ -2274,30 +2303,23 @@ struct virtqueue *__vring_new_virtqueue(unsigned int index,
vq->split.avail_flags_shadow);
}
- vq->split.desc_state = kmalloc_array(vring.num,
- sizeof(struct vring_desc_state_split), GFP_KERNEL);
- if (!vq->split.desc_state)
- goto err_state;
+ vring_split.vring = vring;
- vq->split.desc_extra = vring_alloc_desc_extra(vring.num);
- if (!vq->split.desc_extra)
- goto err_extra;
+ err = vring_alloc_state_extra_split(&vring_split);
+ if (err) {
+ kfree(vq);
+ return NULL;
+ }
- memset(vq->split.desc_state, 0, vring.num *
- sizeof(struct vring_desc_state_split));
+ vq->split.desc_state = vring.desc_state;
+ vq->split.desc_extra = vring.desc_extra;
- virtqueue_init(vq, vq->split.vring.num);
+ virtqueue_init(vq, vring_split.vring.num);
spin_lock(&vdev->vqs_list_lock);
list_add_tail(&vq->vq.list, &vdev->vqs);
spin_unlock(&vdev->vqs_list_lock);
return &vq->vq;
-
-err_extra:
- kfree(vq->split.desc_state);
-err_state:
- kfree(vq);
- return NULL;
}
EXPORT_SYMBOL_GPL(__vring_new_virtqueue);
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 10/40] virtio_ring: split: extract the logic of attach vring
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (8 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 09/40] virtio_ring: split: extract the logic of alloc state and extra Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 11/40] virtio_ring: split: extract the logic of vring init Xuan Zhuo
` (29 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Separate the logic of attach vring, subsequent patches will call it
separately.
Since the "struct vring_virtqueue_split split" is created on the
stack and has been initialized to 0. So using
split->queue_dma_addr/split->queue_size_in_bytes assignment for
queue_dma_addr/queue_size_in_bytes can keep the same as the original
code.
On the other hand, subsequent patches can use the "struct
vring_virtqueue_split split" obtained by vring_alloc_queue_split() to
directly complete the attach operation.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/virtio/virtio_ring.c | 21 ++++++++++++++-------
1 file changed, 14 insertions(+), 7 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index ef2077e8b38d..b2dbbf68736b 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -940,6 +940,18 @@ static void *virtqueue_detach_unused_buf_split(struct virtqueue *_vq)
return NULL;
}
+static void virtqueue_vring_attach_split(struct vring_virtqueue *vq,
+ struct vring_virtqueue_split *vring_split)
+{
+ vq->split.queue_dma_addr = vring_split->queue_dma_addr;
+ vq->split.queue_size_in_bytes = vring_split->queue_size_in_bytes;
+
+ vq->split.vring = vring_split->vring;
+
+ vq->split.desc_state = vring_split->desc_state;
+ vq->split.desc_extra = vring_split->desc_extra;
+}
+
static int vring_alloc_state_extra_split(struct vring_virtqueue_split *vring_split)
{
struct vring_desc_state_split *state;
@@ -2288,10 +2300,6 @@ struct virtqueue *__vring_new_virtqueue(unsigned int index,
vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&
!context;
- vq->split.queue_dma_addr = 0;
- vq->split.queue_size_in_bytes = 0;
-
- vq->split.vring = vring;
vq->split.avail_flags_shadow = 0;
vq->split.avail_idx_shadow = 0;
@@ -2311,10 +2319,9 @@ struct virtqueue *__vring_new_virtqueue(unsigned int index,
return NULL;
}
- vq->split.desc_state = vring.desc_state;
- vq->split.desc_extra = vring.desc_extra;
-
virtqueue_init(vq, vring_split.vring.num);
+ virtqueue_vring_attach_split(vq, &vring_split);
+ virtqueue_vring_init_split(vq);
spin_lock(&vdev->vqs_list_lock);
list_add_tail(&vq->vq.list, &vdev->vqs);
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 11/40] virtio_ring: split: extract the logic of vring init
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (9 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 10/40] virtio_ring: split: extract the logic of attach vring Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 12/40] virtio_ring: split: introduce virtqueue_reinit_split() Xuan Zhuo
` (28 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Separate the logic of initializing vring, and subsequent patches will
call it separately.
This function completes the variable initialization of split vring. It
together with the logic of atatch constitutes the initialization of
vring.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/virtio/virtio_ring.c | 29 ++++++++++++++++++-----------
1 file changed, 18 insertions(+), 11 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index b2dbbf68736b..0c952281264f 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -940,6 +940,24 @@ static void *virtqueue_detach_unused_buf_split(struct virtqueue *_vq)
return NULL;
}
+static void virtqueue_vring_init_split(struct vring_virtqueue *vq)
+{
+ struct virtio_device *vdev;
+
+ vdev = vq->vq.vdev;
+
+ vq->split.avail_flags_shadow = 0;
+ vq->split.avail_idx_shadow = 0;
+
+ /* No callback? Tell other side not to bother us. */
+ if (!vq->vq.callback) {
+ vq->split.avail_flags_shadow |= VRING_AVAIL_F_NO_INTERRUPT;
+ if (!vq->event)
+ vq->split.vring.avail->flags = cpu_to_virtio16(vdev,
+ vq->split.avail_flags_shadow);
+ }
+}
+
static void virtqueue_vring_attach_split(struct vring_virtqueue *vq,
struct vring_virtqueue_split *vring_split)
{
@@ -2300,17 +2318,6 @@ struct virtqueue *__vring_new_virtqueue(unsigned int index,
vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&
!context;
- vq->split.avail_flags_shadow = 0;
- vq->split.avail_idx_shadow = 0;
-
- /* No callback? Tell other side not to bother us. */
- if (!callback) {
- vq->split.avail_flags_shadow |= VRING_AVAIL_F_NO_INTERRUPT;
- if (!vq->event)
- vq->split.vring.avail->flags = cpu_to_virtio16(vdev,
- vq->split.avail_flags_shadow);
- }
-
vring_split.vring = vring;
err = vring_alloc_state_extra_split(&vring_split);
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 12/40] virtio_ring: split: introduce virtqueue_reinit_split()
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (10 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 11/40] virtio_ring: split: extract the logic of vring init Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 13/40] virtio_ring: split: reserve vring_align, may_reduce_num Xuan Zhuo
` (27 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Introduce a function to initialize vq without allocating new ring,
desc_state, desc_extra.
Subsequent patches will call this function after reset vq to
reinitialize vq.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/virtio/virtio_ring.c | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 0c952281264f..2d5e8aec6685 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -958,6 +958,25 @@ static void virtqueue_vring_init_split(struct vring_virtqueue *vq)
}
}
+static void virtqueue_reinit_split(struct vring_virtqueue *vq)
+{
+ int size, i;
+
+ memset(vq->split.vring.desc, 0, vq->split.queue_size_in_bytes);
+
+ size = sizeof(struct vring_desc_state_split) * vq->split.vring.num;
+ memset(vq->split.desc_state, 0, size);
+
+ size = sizeof(struct vring_desc_extra) * vq->split.vring.num;
+ memset(vq->split.desc_extra, 0, size);
+
+ for (i = 0; i < vq->split.vring.num - 1; i++)
+ vq->split.desc_extra[i].next = i + 1;
+
+ virtqueue_init(vq, vq->split.vring.num);
+ virtqueue_vring_init_split(vq);
+}
+
static void virtqueue_vring_attach_split(struct vring_virtqueue *vq,
struct vring_virtqueue_split *vring_split)
{
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 13/40] virtio_ring: split: reserve vring_align, may_reduce_num
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (11 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 12/40] virtio_ring: split: introduce virtqueue_reinit_split() Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 14/40] virtio_ring: split: introduce virtqueue_resize_split() Xuan Zhuo
` (26 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
In vring_create_virtqueue_split() save vring_align, may_reduce_num to
structure vring_virtqueue_split. Used to create a new vring when
implementing resize .
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/virtio/virtio_ring.c | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 2d5e8aec6685..6de1129e2aa6 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -105,6 +105,13 @@ struct vring_virtqueue_split {
/* DMA address and size information */
dma_addr_t queue_dma_addr;
size_t queue_size_in_bytes;
+
+ /*
+ * The parameters for creating vrings are reserved for creating new
+ * vring.
+ */
+ u32 vring_align;
+ bool may_reduce_num;
};
struct vring_virtqueue_packed {
@@ -1099,6 +1106,8 @@ static struct virtqueue *vring_create_virtqueue_split(
return NULL;
}
+ to_vvq(vq)->split.vring_align = vring_align;
+ to_vvq(vq)->split.may_reduce_num = may_reduce_num;
to_vvq(vq)->split.queue_dma_addr = vring_split.queue_dma_addr;
to_vvq(vq)->split.queue_size_in_bytes = vring_split.queue_size_in_bytes;
to_vvq(vq)->we_own_ring = true;
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 14/40] virtio_ring: split: introduce virtqueue_resize_split()
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (12 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 13/40] virtio_ring: split: reserve vring_align, may_reduce_num Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 15/40] virtio_ring: packed: introduce vring_free_packed Xuan Zhuo
` (25 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
virtio ring split supports resize.
Only after the new vring is successfully allocated based on the new num,
we will release the old vring. In any case, an error is returned,
indicating that the vring still points to the old vring.
In the case of an error, re-initialize(virtqueue_reinit_split()) the
virtqueue to ensure that the vring can be used.
In addition, vring_align, may_reduce_num are necessary for reallocating
vring, so they are retained for creating vq.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/virtio/virtio_ring.c | 33 +++++++++++++++++++++++++++++++++
1 file changed, 33 insertions(+)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 6de1129e2aa6..2ea6d022cbd7 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -212,6 +212,7 @@ struct vring_virtqueue {
};
static struct vring_desc_extra *vring_alloc_desc_extra(unsigned int num);
+static void vring_free(struct virtqueue *_vq);
/*
* Helpers.
@@ -1115,6 +1116,38 @@ static struct virtqueue *vring_create_virtqueue_split(
return vq;
}
+static int virtqueue_resize_split(struct virtqueue *_vq, u32 num)
+{
+ struct vring_virtqueue_split vring_split = {};
+ struct vring_virtqueue *vq = to_vvq(_vq);
+ struct virtio_device *vdev = _vq->vdev;
+ int err;
+
+ err = vring_alloc_queue_split(&vring_split, vdev, num,
+ vq->split.vring_align,
+ vq->split.may_reduce_num);
+ if (err)
+ goto err;
+
+ err = vring_alloc_state_extra_split(&vring_split);
+ if (err) {
+ vring_free_split(&vring_split, vdev);
+ goto err;
+ }
+
+ vring_free(&vq->vq);
+
+ virtqueue_init(vq, vring_split.vring.num);
+ virtqueue_vring_attach_split(vq, &vring_split);
+ virtqueue_vring_init_split(vq);
+
+ return 0;
+
+err:
+ virtqueue_reinit_split(vq);
+ return -ENOMEM;
+}
+
/*
* Packed ring specific functions - *_packed().
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 15/40] virtio_ring: packed: introduce vring_free_packed
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (13 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 14/40] virtio_ring: split: introduce virtqueue_resize_split() Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 16/40] virtio_ring: packed: extract the logic of alloc queue Xuan Zhuo
` (24 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Free the structure struct vring_vritqueue_packed.
Subsequent patches require it.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 22 ++++++++++++++++++++++
1 file changed, 22 insertions(+)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 2ea6d022cbd7..207a2b57270c 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -1832,6 +1832,28 @@ static struct vring_desc_extra *vring_alloc_desc_extra(unsigned int num)
return desc_extra;
}
+static void vring_free_packed(struct vring_virtqueue_packed *vring_packed,
+ struct virtio_device *vdev)
+{
+ if (vring_packed->vring.desc)
+ vring_free_queue(vdev, vring_packed->ring_size_in_bytes,
+ vring_packed->vring.desc,
+ vring_packed->ring_dma_addr);
+
+ if (vring_packed->vring.driver)
+ vring_free_queue(vdev, vring_packed->event_size_in_bytes,
+ vring_packed->vring.driver,
+ vring_packed->driver_event_dma_addr);
+
+ if (vring_packed->vring.device)
+ vring_free_queue(vdev, vring_packed->event_size_in_bytes,
+ vring_packed->vring.device,
+ vring_packed->device_event_dma_addr);
+
+ kfree(vring_packed->desc_state);
+ kfree(vring_packed->desc_extra);
+}
+
static struct virtqueue *vring_create_virtqueue_packed(
unsigned int index,
unsigned int num,
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 16/40] virtio_ring: packed: extract the logic of alloc queue
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (14 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 15/40] virtio_ring: packed: introduce vring_free_packed Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 17/40] virtio_ring: packed: extract the logic of alloc state and extra Xuan Zhuo
` (23 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Separate the logic of packed to create vring queue.
For the convenience of passing parameters, add a structure
vring_packed.
This feature is required for subsequent virtuqueue reset vring.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 80 +++++++++++++++++++++++-------------
1 file changed, 51 insertions(+), 29 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 207a2b57270c..a495f1cb7fe4 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -1854,19 +1854,10 @@ static void vring_free_packed(struct vring_virtqueue_packed *vring_packed,
kfree(vring_packed->desc_extra);
}
-static struct virtqueue *vring_create_virtqueue_packed(
- unsigned int index,
- unsigned int num,
- unsigned int vring_align,
- struct virtio_device *vdev,
- bool weak_barriers,
- bool may_reduce_num,
- bool context,
- bool (*notify)(struct virtqueue *),
- void (*callback)(struct virtqueue *),
- const char *name)
+static int vring_alloc_queue_packed(struct vring_virtqueue_packed *vring_packed,
+ struct virtio_device *vdev,
+ u32 num)
{
- struct vring_virtqueue *vq;
struct vring_packed_desc *ring;
struct vring_packed_desc_event *driver, *device;
dma_addr_t ring_dma_addr, driver_event_dma_addr, device_event_dma_addr;
@@ -1878,7 +1869,11 @@ static struct virtqueue *vring_create_virtqueue_packed(
&ring_dma_addr,
GFP_KERNEL|__GFP_NOWARN|__GFP_ZERO);
if (!ring)
- goto err_ring;
+ goto err;
+
+ vring_packed->vring.desc = ring;
+ vring_packed->ring_dma_addr = ring_dma_addr;
+ vring_packed->ring_size_in_bytes = ring_size_in_bytes;
event_size_in_bytes = sizeof(struct vring_packed_desc_event);
@@ -1886,13 +1881,47 @@ static struct virtqueue *vring_create_virtqueue_packed(
&driver_event_dma_addr,
GFP_KERNEL|__GFP_NOWARN|__GFP_ZERO);
if (!driver)
- goto err_driver;
+ goto err;
+
+ vring_packed->vring.driver = driver;
+ vring_packed->event_size_in_bytes = event_size_in_bytes;
+ vring_packed->driver_event_dma_addr = driver_event_dma_addr;
device = vring_alloc_queue(vdev, event_size_in_bytes,
&device_event_dma_addr,
GFP_KERNEL|__GFP_NOWARN|__GFP_ZERO);
if (!device)
- goto err_device;
+ goto err;
+
+ vring_packed->vring.device = device;
+ vring_packed->device_event_dma_addr = device_event_dma_addr;
+
+ vring_packed->vring.num = num;
+
+ return 0;
+
+err:
+ vring_free_packed(vring_packed, vdev);
+ return -ENOMEM;
+}
+
+static struct virtqueue *vring_create_virtqueue_packed(
+ unsigned int index,
+ unsigned int num,
+ unsigned int vring_align,
+ struct virtio_device *vdev,
+ bool weak_barriers,
+ bool may_reduce_num,
+ bool context,
+ bool (*notify)(struct virtqueue *),
+ void (*callback)(struct virtqueue *),
+ const char *name)
+{
+ struct vring_virtqueue_packed vring_packed = {};
+ struct vring_virtqueue *vq;
+
+ if (vring_alloc_queue_packed(&vring_packed, vdev, num))
+ goto err_ring;
vq = kmalloc(sizeof(*vq), GFP_KERNEL);
if (!vq)
@@ -1915,17 +1944,14 @@ static struct virtqueue *vring_create_virtqueue_packed(
vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&
!context;
- vq->packed.ring_dma_addr = ring_dma_addr;
- vq->packed.driver_event_dma_addr = driver_event_dma_addr;
- vq->packed.device_event_dma_addr = device_event_dma_addr;
+ vq->packed.ring_dma_addr = vring_packed.ring_dma_addr;
+ vq->packed.driver_event_dma_addr = vring_packed.driver_event_dma_addr;
+ vq->packed.device_event_dma_addr = vring_packed.device_event_dma_addr;
- vq->packed.ring_size_in_bytes = ring_size_in_bytes;
- vq->packed.event_size_in_bytes = event_size_in_bytes;
+ vq->packed.ring_size_in_bytes = vring_packed.ring_size_in_bytes;
+ vq->packed.event_size_in_bytes = vring_packed.event_size_in_bytes;
- vq->packed.vring.num = num;
- vq->packed.vring.desc = ring;
- vq->packed.vring.driver = driver;
- vq->packed.vring.device = device;
+ vq->packed.vring = vring_packed.vring;
vq->packed.next_avail_idx = 0;
vq->packed.avail_wrap_counter = 1;
@@ -1964,11 +1990,7 @@ static struct virtqueue *vring_create_virtqueue_packed(
err_desc_state:
kfree(vq);
err_vq:
- vring_free_queue(vdev, event_size_in_bytes, device, device_event_dma_addr);
-err_device:
- vring_free_queue(vdev, event_size_in_bytes, driver, driver_event_dma_addr);
-err_driver:
- vring_free_queue(vdev, ring_size_in_bytes, ring, ring_dma_addr);
+ vring_free_packed(&vring_packed, vdev);
err_ring:
return NULL;
}
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 17/40] virtio_ring: packed: extract the logic of alloc state and extra
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (15 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 16/40] virtio_ring: packed: extract the logic of alloc queue Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 18/40] virtio_ring: packed: extract the logic of attach vring Xuan Zhuo
` (22 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Separate the logic for alloc desc_state and desc_extra, which will
be called separately by subsequent patches.
Use struct vring_packed to pass desc_state, desc_extra.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 48 +++++++++++++++++++++++++-----------
1 file changed, 34 insertions(+), 14 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index a495f1cb7fe4..1f8d6417b46a 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -1905,6 +1905,33 @@ static int vring_alloc_queue_packed(struct vring_virtqueue_packed *vring_packed,
return -ENOMEM;
}
+static int vring_alloc_state_extra_packed(struct vring_virtqueue_packed *vring_packed)
+{
+ struct vring_desc_state_packed *state;
+ struct vring_desc_extra *extra;
+ u32 num = vring_packed->vring.num;
+
+ state = kmalloc_array(num, sizeof(struct vring_desc_state_packed), GFP_KERNEL);
+ if (!state)
+ goto err_desc_state;
+
+ memset(state, 0, num * sizeof(struct vring_desc_state_packed));
+
+ extra = vring_alloc_desc_extra(num);
+ if (!extra)
+ goto err_desc_extra;
+
+ vring_packed->desc_state = state;
+ vring_packed->desc_extra = extra;
+
+ return 0;
+
+err_desc_extra:
+ kfree(state);
+err_desc_state:
+ return -ENOMEM;
+}
+
static struct virtqueue *vring_create_virtqueue_packed(
unsigned int index,
unsigned int num,
@@ -1919,6 +1946,7 @@ static struct virtqueue *vring_create_virtqueue_packed(
{
struct vring_virtqueue_packed vring_packed = {};
struct vring_virtqueue *vq;
+ int err;
if (vring_alloc_queue_packed(&vring_packed, vdev, num))
goto err_ring;
@@ -1958,21 +1986,15 @@ static struct virtqueue *vring_create_virtqueue_packed(
vq->packed.event_flags_shadow = 0;
vq->packed.avail_used_flags = 1 << VRING_PACKED_DESC_F_AVAIL;
- vq->packed.desc_state = kmalloc_array(num,
- sizeof(struct vring_desc_state_packed),
- GFP_KERNEL);
- if (!vq->packed.desc_state)
- goto err_desc_state;
+ err = vring_alloc_state_extra_packed(&vring_packed);
+ if (err)
+ goto err_state_extra;
- memset(vq->packed.desc_state, 0,
- num * sizeof(struct vring_desc_state_packed));
+ vq->packed.desc_state = vring.desc_state;
+ vq->packed.desc_extra = vring.desc_extra;
virtqueue_init(vq, num);
- vq->packed.desc_extra = vring_alloc_desc_extra(num);
- if (!vq->packed.desc_extra)
- goto err_desc_extra;
-
/* No callback? Tell other side not to bother us. */
if (!callback) {
vq->packed.event_flags_shadow = VRING_PACKED_EVENT_FLAG_DISABLE;
@@ -1985,9 +2007,7 @@ static struct virtqueue *vring_create_virtqueue_packed(
spin_unlock(&vdev->vqs_list_lock);
return &vq->vq;
-err_desc_extra:
- kfree(vq->packed.desc_state);
-err_desc_state:
+err_state_extra:
kfree(vq);
err_vq:
vring_free_packed(&vring_packed, vdev);
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 18/40] virtio_ring: packed: extract the logic of attach vring
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (16 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 17/40] virtio_ring: packed: extract the logic of alloc state and extra Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 19/40] virtio_ring: packed: extract the logic of vring init Xuan Zhuo
` (21 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Separate the logic of attach vring, the subsequent patch will call it
separately.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 29 +++++++++++++++++------------
1 file changed, 17 insertions(+), 12 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 1f8d6417b46a..19ed20d7d433 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -1932,6 +1932,22 @@ static int vring_alloc_state_extra_packed(struct vring_virtqueue_packed *vring_p
return -ENOMEM;
}
+static void virtqueue_vring_attach_packed(struct vring_virtqueue *vq,
+ struct vring_virtqueue_packed *vring_packed)
+{
+ vq->packed.ring_dma_addr = vring_packed->ring_dma_addr;
+ vq->packed.driver_event_dma_addr = vring_packed->driver_event_dma_addr;
+ vq->packed.device_event_dma_addr = vring_packed->device_event_dma_addr;
+
+ vq->packed.ring_size_in_bytes = vring_packed->ring_size_in_bytes;
+ vq->packed.event_size_in_bytes = vring_packed->event_size_in_bytes;
+
+ vq->packed.vring = vring_packed->vring;
+
+ vq->packed.desc_state = vring_packed->desc_state;
+ vq->packed.desc_extra = vring_packed->desc_extra;
+}
+
static struct virtqueue *vring_create_virtqueue_packed(
unsigned int index,
unsigned int num,
@@ -1972,15 +1988,6 @@ static struct virtqueue *vring_create_virtqueue_packed(
vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&
!context;
- vq->packed.ring_dma_addr = vring_packed.ring_dma_addr;
- vq->packed.driver_event_dma_addr = vring_packed.driver_event_dma_addr;
- vq->packed.device_event_dma_addr = vring_packed.device_event_dma_addr;
-
- vq->packed.ring_size_in_bytes = vring_packed.ring_size_in_bytes;
- vq->packed.event_size_in_bytes = vring_packed.event_size_in_bytes;
-
- vq->packed.vring = vring_packed.vring;
-
vq->packed.next_avail_idx = 0;
vq->packed.avail_wrap_counter = 1;
vq->packed.event_flags_shadow = 0;
@@ -1990,10 +1997,8 @@ static struct virtqueue *vring_create_virtqueue_packed(
if (err)
goto err_state_extra;
- vq->packed.desc_state = vring.desc_state;
- vq->packed.desc_extra = vring.desc_extra;
-
virtqueue_init(vq, num);
+ virtqueue_vring_attach_packed(vq, &vring_packed);
/* No callback? Tell other side not to bother us. */
if (!callback) {
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 19/40] virtio_ring: packed: extract the logic of vring init
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (17 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 18/40] virtio_ring: packed: extract the logic of attach vring Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 20/40] virtio_ring: packed: introduce virtqueue_reinit_packed() Xuan Zhuo
` (20 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Separate the logic of initializing vring, and subsequent patches will
call it separately.
This function completes the variable initialization of packed vring. It
together with the logic of atatch constitutes the initialization of
vring.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 28 ++++++++++++++++------------
1 file changed, 16 insertions(+), 12 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 19ed20d7d433..3bbeb385fb8c 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -1948,6 +1948,21 @@ static void virtqueue_vring_attach_packed(struct vring_virtqueue *vq,
vq->packed.desc_extra = vring_packed->desc_extra;
}
+static void virtqueue_vring_init_packed(struct vring_virtqueue *vq)
+{
+ vq->packed.next_avail_idx = 0;
+ vq->packed.avail_wrap_counter = 1;
+ vq->packed.event_flags_shadow = 0;
+ vq->packed.avail_used_flags = 1 << VRING_PACKED_DESC_F_AVAIL;
+
+ /* No callback? Tell other side not to bother us. */
+ if (!vq->vq.callback) {
+ vq->packed.event_flags_shadow = VRING_PACKED_EVENT_FLAG_DISABLE;
+ vq->packed.vring.driver->flags =
+ cpu_to_le16(vq->packed.event_flags_shadow);
+ }
+}
+
static struct virtqueue *vring_create_virtqueue_packed(
unsigned int index,
unsigned int num,
@@ -1988,24 +2003,13 @@ static struct virtqueue *vring_create_virtqueue_packed(
vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&
!context;
- vq->packed.next_avail_idx = 0;
- vq->packed.avail_wrap_counter = 1;
- vq->packed.event_flags_shadow = 0;
- vq->packed.avail_used_flags = 1 << VRING_PACKED_DESC_F_AVAIL;
-
err = vring_alloc_state_extra_packed(&vring_packed);
if (err)
goto err_state_extra;
virtqueue_init(vq, num);
virtqueue_vring_attach_packed(vq, &vring_packed);
-
- /* No callback? Tell other side not to bother us. */
- if (!callback) {
- vq->packed.event_flags_shadow = VRING_PACKED_EVENT_FLAG_DISABLE;
- vq->packed.vring.driver->flags =
- cpu_to_le16(vq->packed.event_flags_shadow);
- }
+ virtqueue_vring_init_packed(vq);
spin_lock(&vdev->vqs_list_lock);
list_add_tail(&vq->vq.list, &vdev->vqs);
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 20/40] virtio_ring: packed: introduce virtqueue_reinit_packed()
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (18 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 19/40] virtio_ring: packed: extract the logic of vring init Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 21/40] virtio_ring: packed: introduce virtqueue_resize_packed() Xuan Zhuo
` (19 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Introduce a function to initialize vq without allocating new ring,
desc_state, desc_extra.
Subsequent patches will call this function after reset vq to
reinitialize vq.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 21 +++++++++++++++++++++
1 file changed, 21 insertions(+)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 3bbeb385fb8c..5802cd373fd1 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -1963,6 +1963,27 @@ static void virtqueue_vring_init_packed(struct vring_virtqueue *vq)
}
}
+static void virtqueue_reinit_packed(struct vring_virtqueue *vq)
+{
+ int size, i;
+
+ memset(vq->packed.vring.device, 0, vq->packed.event_size_in_bytes);
+ memset(vq->packed.vring.driver, 0, vq->packed.event_size_in_bytes);
+ memset(vq->packed.vring.desc, 0, vq->packed.ring_size_in_bytes);
+
+ size = sizeof(struct vring_desc_state_packed) * vq->packed.vring.num;
+ memset(vq->packed.desc_state, 0, size);
+
+ size = sizeof(struct vring_desc_extra) * vq->packed.vring.num;
+ memset(vq->packed.desc_extra, 0, size);
+
+ for (i = 0; i < vq->packed.vring.num - 1; i++)
+ vq->packed.desc_extra[i].next = i + 1;
+
+ virtqueue_init(vq, vq->packed.vring.num);
+ virtqueue_vring_init_packed(vq);
+}
+
static struct virtqueue *vring_create_virtqueue_packed(
unsigned int index,
unsigned int num,
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 21/40] virtio_ring: packed: introduce virtqueue_resize_packed()
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (19 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 20/40] virtio_ring: packed: introduce virtqueue_reinit_packed() Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 22/40] virtio_ring: introduce virtqueue_resize() Xuan Zhuo
` (18 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
virtio ring packed supports resize.
Only after the new vring is successfully allocated based on the new num,
we will release the old vring. In any case, an error is returned,
indicating that the vring still points to the old vring.
In the case of an error, re-initialize(by virtqueue_reinit_packed()) the
virtqueue to ensure that the vring can be used.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/virtio/virtio_ring.c | 29 +++++++++++++++++++++++++++++
1 file changed, 29 insertions(+)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 5802cd373fd1..b092914e9dcd 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -2045,6 +2045,35 @@ static struct virtqueue *vring_create_virtqueue_packed(
return NULL;
}
+static int virtqueue_resize_packed(struct virtqueue *_vq, u32 num)
+{
+ struct vring_virtqueue_packed vring_packed = {};
+ struct vring_virtqueue *vq = to_vvq(_vq);
+ struct virtio_device *vdev = _vq->vdev;
+ int err;
+
+ if (vring_alloc_queue_packed(&vring_packed, vdev, num))
+ goto err_ring;
+
+ err = vring_alloc_state_extra_packed(&vring_packed);
+ if (err)
+ goto err_state_extra;
+
+ vring_free(&vq->vq);
+
+ virtqueue_init(vq, vring_packed.vring.num);
+ virtqueue_vring_attach_packed(vq, &vring_packed);
+ virtqueue_vring_init_packed(vq);
+
+ return 0;
+
+err_state_extra:
+ vring_free_packed(&vring_packed, vdev);
+err_ring:
+ virtqueue_reinit_packed(vq);
+ return -ENOMEM;
+}
+
/*
* Generic functions and exported symbols.
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 22/40] virtio_ring: introduce virtqueue_resize()
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (20 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 21/40] virtio_ring: packed: introduce virtqueue_resize_packed() Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-21 9:15 ` Jason Wang
2022-07-20 3:04 ` [PATCH v12 23/40] virtio_pci: struct virtio_pci_common_cfg add queue_notify_data Xuan Zhuo
` (17 subsequent siblings)
39 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Introduce virtqueue_resize() to implement the resize of vring.
Based on these, the driver can dynamically adjust the size of the vring.
For example: ethtool -G.
virtqueue_resize() implements resize based on the vq reset function. In
case of failure to allocate a new vring, it will give up resize and use
the original vring.
During this process, if the re-enable reset vq fails, the vq can no
longer be used. Although the probability of this situation is not high.
The parameter recycle is used to recycle the buffer that is no longer
used.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 69 ++++++++++++++++++++++++++++++++++++
include/linux/virtio.h | 3 ++
2 files changed, 72 insertions(+)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index b092914e9dcd..cf4379175163 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -2545,6 +2545,75 @@ struct virtqueue *vring_create_virtqueue(
}
EXPORT_SYMBOL_GPL(vring_create_virtqueue);
+/**
+ * virtqueue_resize - resize the vring of vq
+ * @_vq: the struct virtqueue we're talking about.
+ * @num: new ring num
+ * @recycle: callback for recycle the useless buffer
+ *
+ * When it is really necessary to create a new vring, it will set the current vq
+ * into the reset state. Then call the passed callback to recycle the buffer
+ * that is no longer used. Only after the new vring is successfully created, the
+ * old vring will be released.
+ *
+ * Caller must ensure we don't call this with other virtqueue operations
+ * at the same time (except where noted).
+ *
+ * Returns zero or a negative error.
+ * 0: success.
+ * -ENOMEM: Failed to allocate a new ring, fall back to the original ring size.
+ * vq can still work normally
+ * -EBUSY: Failed to sync with device, vq may not work properly
+ * -ENOENT: Transport or device not supported
+ * -E2BIG/-EINVAL: num error
+ * -EPERM: Operation not permitted
+ *
+ */
+int virtqueue_resize(struct virtqueue *_vq, u32 num,
+ void (*recycle)(struct virtqueue *vq, void *buf))
+{
+ struct vring_virtqueue *vq = to_vvq(_vq);
+ struct virtio_device *vdev = vq->vq.vdev;
+ void *buf;
+ int err;
+
+ if (!vq->we_own_ring)
+ return -EPERM;
+
+ if (num > vq->vq.num_max)
+ return -E2BIG;
+
+ if (!num)
+ return -EINVAL;
+
+ if ((vq->packed_ring ? vq->packed.vring.num : vq->split.vring.num) == num)
+ return 0;
+
+ if (!vdev->config->disable_vq_and_reset)
+ return -ENOENT;
+
+ if (!vdev->config->enable_vq_after_reset)
+ return -ENOENT;
+
+ err = vdev->config->disable_vq_and_reset(_vq);
+ if (err)
+ return err;
+
+ while ((buf = virtqueue_detach_unused_buf(_vq)) != NULL)
+ recycle(_vq, buf);
+
+ if (vq->packed_ring)
+ err = virtqueue_resize_packed(_vq, num);
+ else
+ err = virtqueue_resize_split(_vq, num);
+
+ if (vdev->config->enable_vq_after_reset(_vq))
+ return -EBUSY;
+
+ return err;
+}
+EXPORT_SYMBOL_GPL(virtqueue_resize);
+
/* Only available for split ring */
struct virtqueue *vring_new_virtqueue(unsigned int index,
unsigned int num,
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index 129bde7521e3..62e31bca5602 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -91,6 +91,9 @@ dma_addr_t virtqueue_get_desc_addr(struct virtqueue *vq);
dma_addr_t virtqueue_get_avail_addr(struct virtqueue *vq);
dma_addr_t virtqueue_get_used_addr(struct virtqueue *vq);
+int virtqueue_resize(struct virtqueue *vq, u32 num,
+ void (*recycle)(struct virtqueue *vq, void *buf));
+
/**
* virtio_device - representation of a device using virtio
* @index: unique position on the virtio bus
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v12 22/40] virtio_ring: introduce virtqueue_resize()
2022-07-20 3:04 ` [PATCH v12 22/40] virtio_ring: introduce virtqueue_resize() Xuan Zhuo
@ 2022-07-21 9:15 ` Jason Wang
0 siblings, 0 replies; 60+ messages in thread
From: Jason Wang @ 2022-07-21 9:15 UTC (permalink / raw)
To: Xuan Zhuo, virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
在 2022/7/20 11:04, Xuan Zhuo 写道:
> Introduce virtqueue_resize() to implement the resize of vring.
> Based on these, the driver can dynamically adjust the size of the vring.
> For example: ethtool -G.
>
> virtqueue_resize() implements resize based on the vq reset function. In
> case of failure to allocate a new vring, it will give up resize and use
> the original vring.
>
> During this process, if the re-enable reset vq fails, the vq can no
> longer be used. Although the probability of this situation is not high.
>
> The parameter recycle is used to recycle the buffer that is no longer
> used.
>
> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
> ---
> drivers/virtio/virtio_ring.c | 69 ++++++++++++++++++++++++++++++++++++
> include/linux/virtio.h | 3 ++
> 2 files changed, 72 insertions(+)
>
> diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
> index b092914e9dcd..cf4379175163 100644
> --- a/drivers/virtio/virtio_ring.c
> +++ b/drivers/virtio/virtio_ring.c
> @@ -2545,6 +2545,75 @@ struct virtqueue *vring_create_virtqueue(
> }
> EXPORT_SYMBOL_GPL(vring_create_virtqueue);
>
> +/**
> + * virtqueue_resize - resize the vring of vq
> + * @_vq: the struct virtqueue we're talking about.
> + * @num: new ring num
> + * @recycle: callback for recycle the useless buffer
> + *
> + * When it is really necessary to create a new vring, it will set the current vq
> + * into the reset state. Then call the passed callback to recycle the buffer
> + * that is no longer used. Only after the new vring is successfully created, the
> + * old vring will be released.
> + *
> + * Caller must ensure we don't call this with other virtqueue operations
> + * at the same time (except where noted).
> + *
> + * Returns zero or a negative error.
> + * 0: success.
> + * -ENOMEM: Failed to allocate a new ring, fall back to the original ring size.
> + * vq can still work normally
> + * -EBUSY: Failed to sync with device, vq may not work properly
> + * -ENOENT: Transport or device not supported
> + * -E2BIG/-EINVAL: num error
> + * -EPERM: Operation not permitted
> + *
> + */
> +int virtqueue_resize(struct virtqueue *_vq, u32 num,
> + void (*recycle)(struct virtqueue *vq, void *buf))
> +{
> + struct vring_virtqueue *vq = to_vvq(_vq);
> + struct virtio_device *vdev = vq->vq.vdev;
> + void *buf;
> + int err;
> +
> + if (!vq->we_own_ring)
> + return -EPERM;
> +
> + if (num > vq->vq.num_max)
> + return -E2BIG;
> +
> + if (!num)
> + return -EINVAL;
> +
> + if ((vq->packed_ring ? vq->packed.vring.num : vq->split.vring.num) == num)
> + return 0;
> +
> + if (!vdev->config->disable_vq_and_reset)
> + return -ENOENT;
> +
> + if (!vdev->config->enable_vq_after_reset)
> + return -ENOENT;
> +
> + err = vdev->config->disable_vq_and_reset(_vq);
> + if (err)
> + return err;
> +
> + while ((buf = virtqueue_detach_unused_buf(_vq)) != NULL)
> + recycle(_vq, buf);
> +
> + if (vq->packed_ring)
> + err = virtqueue_resize_packed(_vq, num);
> + else
> + err = virtqueue_resize_split(_vq, num);
> +
> + if (vdev->config->enable_vq_after_reset(_vq))
> + return -EBUSY;
> +
> + return err;
> +}
> +EXPORT_SYMBOL_GPL(virtqueue_resize);
> +
> /* Only available for split ring */
> struct virtqueue *vring_new_virtqueue(unsigned int index,
> unsigned int num,
> diff --git a/include/linux/virtio.h b/include/linux/virtio.h
> index 129bde7521e3..62e31bca5602 100644
> --- a/include/linux/virtio.h
> +++ b/include/linux/virtio.h
> @@ -91,6 +91,9 @@ dma_addr_t virtqueue_get_desc_addr(struct virtqueue *vq);
> dma_addr_t virtqueue_get_avail_addr(struct virtqueue *vq);
> dma_addr_t virtqueue_get_used_addr(struct virtqueue *vq);
>
> +int virtqueue_resize(struct virtqueue *vq, u32 num,
> + void (*recycle)(struct virtqueue *vq, void *buf));
> +
> /**
> * virtio_device - representation of a device using virtio
> * @index: unique position on the virtio bus
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v12 23/40] virtio_pci: struct virtio_pci_common_cfg add queue_notify_data
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (21 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 22/40] virtio_ring: introduce virtqueue_resize() Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 24/40] virtio: allow to unbreak/break virtqueue individually Xuan Zhuo
` (16 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Add queue_notify_data in struct virtio_pci_common_cfg, which comes from
here https://github.com/oasis-tcs/virtio-spec/issues/89
Since I want to add queue_reset after queue_notify_data, I submitted
this patch first.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
include/linux/virtio_pci_modern.h | 7 +++++++
include/uapi/linux/virtio_pci.h | 1 +
2 files changed, 8 insertions(+)
diff --git a/include/linux/virtio_pci_modern.h b/include/linux/virtio_pci_modern.h
index eb2bd9b4077d..41f5a018bd94 100644
--- a/include/linux/virtio_pci_modern.h
+++ b/include/linux/virtio_pci_modern.h
@@ -5,6 +5,13 @@
#include <linux/pci.h>
#include <linux/virtio_pci.h>
+struct virtio_pci_modern_common_cfg {
+ struct virtio_pci_common_cfg cfg;
+
+ __le16 queue_notify_data; /* read-write */
+ __le16 padding;
+};
+
struct virtio_pci_modern_device {
struct pci_dev *pci_dev;
diff --git a/include/uapi/linux/virtio_pci.h b/include/uapi/linux/virtio_pci.h
index 3a86f36d7e3d..f5981a874481 100644
--- a/include/uapi/linux/virtio_pci.h
+++ b/include/uapi/linux/virtio_pci.h
@@ -202,6 +202,7 @@ struct virtio_pci_cfg_cap {
#define VIRTIO_PCI_COMMON_Q_AVAILHI 44
#define VIRTIO_PCI_COMMON_Q_USEDLO 48
#define VIRTIO_PCI_COMMON_Q_USEDHI 52
+#define VIRTIO_PCI_COMMON_Q_NDATA 56
#endif /* VIRTIO_PCI_NO_MODERN */
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 24/40] virtio: allow to unbreak/break virtqueue individually
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (22 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 23/40] virtio_pci: struct virtio_pci_common_cfg add queue_notify_data Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-21 9:14 ` Jason Wang
2022-07-20 3:04 ` [PATCH v12 25/40] virtio: queue_reset: add VIRTIO_F_RING_RESET Xuan Zhuo
` (15 subsequent siblings)
39 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
This patch allows the new introduced
__virtqueue_break()/__virtqueue_unbreak() to break/unbreak the
virtqueue.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 24 ++++++++++++++++++++++++
include/linux/virtio.h | 3 +++
2 files changed, 27 insertions(+)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index cf4379175163..bf666dad9904 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -2730,6 +2730,30 @@ unsigned int virtqueue_get_vring_size(struct virtqueue *_vq)
}
EXPORT_SYMBOL_GPL(virtqueue_get_vring_size);
+/*
+ * This function should only be called by the core, not directly by the driver.
+ */
+void __virtqueue_break(struct virtqueue *_vq)
+{
+ struct vring_virtqueue *vq = to_vvq(_vq);
+
+ /* Pairs with READ_ONCE() in virtqueue_is_broken(). */
+ WRITE_ONCE(vq->broken, true);
+}
+EXPORT_SYMBOL_GPL(__virtqueue_break);
+
+/*
+ * This function should only be called by the core, not directly by the driver.
+ */
+void __virtqueue_unbreak(struct virtqueue *_vq)
+{
+ struct vring_virtqueue *vq = to_vvq(_vq);
+
+ /* Pairs with READ_ONCE() in virtqueue_is_broken(). */
+ WRITE_ONCE(vq->broken, false);
+}
+EXPORT_SYMBOL_GPL(__virtqueue_unbreak);
+
bool virtqueue_is_broken(struct virtqueue *_vq)
{
struct vring_virtqueue *vq = to_vvq(_vq);
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index 62e31bca5602..d45ee82a4470 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -138,6 +138,9 @@ bool is_virtio_device(struct device *dev);
void virtio_break_device(struct virtio_device *dev);
void __virtio_unbreak_device(struct virtio_device *dev);
+void __virtqueue_break(struct virtqueue *_vq);
+void __virtqueue_unbreak(struct virtqueue *_vq);
+
void virtio_config_changed(struct virtio_device *dev);
#ifdef CONFIG_PM_SLEEP
int virtio_device_freeze(struct virtio_device *dev);
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v12 24/40] virtio: allow to unbreak/break virtqueue individually
2022-07-20 3:04 ` [PATCH v12 24/40] virtio: allow to unbreak/break virtqueue individually Xuan Zhuo
@ 2022-07-21 9:14 ` Jason Wang
0 siblings, 0 replies; 60+ messages in thread
From: Jason Wang @ 2022-07-21 9:14 UTC (permalink / raw)
To: Xuan Zhuo, virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
在 2022/7/20 11:04, Xuan Zhuo 写道:
> This patch allows the new introduced
> __virtqueue_break()/__virtqueue_unbreak() to break/unbreak the
> virtqueue.
>
> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
> ---
> drivers/virtio/virtio_ring.c | 24 ++++++++++++++++++++++++
> include/linux/virtio.h | 3 +++
> 2 files changed, 27 insertions(+)
>
> diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
> index cf4379175163..bf666dad9904 100644
> --- a/drivers/virtio/virtio_ring.c
> +++ b/drivers/virtio/virtio_ring.c
> @@ -2730,6 +2730,30 @@ unsigned int virtqueue_get_vring_size(struct virtqueue *_vq)
> }
> EXPORT_SYMBOL_GPL(virtqueue_get_vring_size);
>
> +/*
> + * This function should only be called by the core, not directly by the driver.
> + */
> +void __virtqueue_break(struct virtqueue *_vq)
> +{
> + struct vring_virtqueue *vq = to_vvq(_vq);
> +
> + /* Pairs with READ_ONCE() in virtqueue_is_broken(). */
> + WRITE_ONCE(vq->broken, true);
> +}
> +EXPORT_SYMBOL_GPL(__virtqueue_break);
> +
> +/*
> + * This function should only be called by the core, not directly by the driver.
> + */
> +void __virtqueue_unbreak(struct virtqueue *_vq)
> +{
> + struct vring_virtqueue *vq = to_vvq(_vq);
> +
> + /* Pairs with READ_ONCE() in virtqueue_is_broken(). */
> + WRITE_ONCE(vq->broken, false);
> +}
> +EXPORT_SYMBOL_GPL(__virtqueue_unbreak);
> +
> bool virtqueue_is_broken(struct virtqueue *_vq)
> {
> struct vring_virtqueue *vq = to_vvq(_vq);
> diff --git a/include/linux/virtio.h b/include/linux/virtio.h
> index 62e31bca5602..d45ee82a4470 100644
> --- a/include/linux/virtio.h
> +++ b/include/linux/virtio.h
> @@ -138,6 +138,9 @@ bool is_virtio_device(struct device *dev);
> void virtio_break_device(struct virtio_device *dev);
> void __virtio_unbreak_device(struct virtio_device *dev);
>
> +void __virtqueue_break(struct virtqueue *_vq);
> +void __virtqueue_unbreak(struct virtqueue *_vq);
> +
> void virtio_config_changed(struct virtio_device *dev);
> #ifdef CONFIG_PM_SLEEP
> int virtio_device_freeze(struct virtio_device *dev);
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v12 25/40] virtio: queue_reset: add VIRTIO_F_RING_RESET
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (23 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 24/40] virtio: allow to unbreak/break virtqueue individually Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 26/40] virtio_ring: struct virtqueue introduce reset Xuan Zhuo
` (14 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Added VIRTIO_F_RING_RESET, it came from here
https://github.com/oasis-tcs/virtio-spec/issues/124
https://github.com/oasis-tcs/virtio-spec/issues/139
This feature indicates that the driver can reset a queue individually.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
include/uapi/linux/virtio_config.h | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/include/uapi/linux/virtio_config.h b/include/uapi/linux/virtio_config.h
index f0fb0ae021c0..3c05162bc988 100644
--- a/include/uapi/linux/virtio_config.h
+++ b/include/uapi/linux/virtio_config.h
@@ -52,7 +52,7 @@
* rest are per-device feature bits.
*/
#define VIRTIO_TRANSPORT_F_START 28
-#define VIRTIO_TRANSPORT_F_END 38
+#define VIRTIO_TRANSPORT_F_END 41
#ifndef VIRTIO_CONFIG_NO_LEGACY
/* Do we get callbacks when the ring is completely used, even if we've
@@ -98,4 +98,9 @@
* Does the device support Single Root I/O Virtualization?
*/
#define VIRTIO_F_SR_IOV 37
+
+/*
+ * This feature indicates that the driver can reset a queue individually.
+ */
+#define VIRTIO_F_RING_RESET 40
#endif /* _UAPI_LINUX_VIRTIO_CONFIG_H */
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 26/40] virtio_ring: struct virtqueue introduce reset
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (24 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 25/40] virtio: queue_reset: add VIRTIO_F_RING_RESET Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-21 9:14 ` Jason Wang
2022-07-20 3:04 ` [PATCH v12 27/40] virtio_pci: struct virtio_pci_common_cfg add queue_reset Xuan Zhuo
` (13 subsequent siblings)
39 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Introduce a new member reset to the structure virtqueue to determine
whether the current vq is in the reset state. Subsequent patches will
use it.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 2 ++
include/linux/virtio.h | 2 ++
2 files changed, 4 insertions(+)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index bf666dad9904..8278b917ad64 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -2011,6 +2011,7 @@ static struct virtqueue *vring_create_virtqueue_packed(
vq->vq.vdev = vdev;
vq->vq.name = name;
vq->vq.index = index;
+ vq->vq.reset = false;
vq->we_own_ring = true;
vq->notify = notify;
vq->weak_barriers = weak_barriers;
@@ -2490,6 +2491,7 @@ struct virtqueue *__vring_new_virtqueue(unsigned int index,
vq->vq.vdev = vdev;
vq->vq.name = name;
vq->vq.index = index;
+ vq->vq.reset = false;
vq->we_own_ring = false;
vq->notify = notify;
vq->weak_barriers = weak_barriers;
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index d45ee82a4470..a3f73bb6733e 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -20,6 +20,7 @@
* @index: the zero-based ordinal number for this queue.
* @num_free: number of elements we expect to be able to fit.
* @num_max: the maximum number of elements supported by the device.
+ * @reset: vq is in reset state or not.
*
* A note on @num_free: with indirect buffers, each buffer needs one
* element in the queue, otherwise a buffer will need one element per
@@ -34,6 +35,7 @@ struct virtqueue {
unsigned int num_free;
unsigned int num_max;
void *priv;
+ bool reset;
};
int virtqueue_add_outbuf(struct virtqueue *vq,
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v12 26/40] virtio_ring: struct virtqueue introduce reset
2022-07-20 3:04 ` [PATCH v12 26/40] virtio_ring: struct virtqueue introduce reset Xuan Zhuo
@ 2022-07-21 9:14 ` Jason Wang
0 siblings, 0 replies; 60+ messages in thread
From: Jason Wang @ 2022-07-21 9:14 UTC (permalink / raw)
To: Xuan Zhuo, virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
在 2022/7/20 11:04, Xuan Zhuo 写道:
> Introduce a new member reset to the structure virtqueue to determine
> whether the current vq is in the reset state. Subsequent patches will
> use it.
>
> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
> ---
> drivers/virtio/virtio_ring.c | 2 ++
> include/linux/virtio.h | 2 ++
> 2 files changed, 4 insertions(+)
>
> diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
> index bf666dad9904..8278b917ad64 100644
> --- a/drivers/virtio/virtio_ring.c
> +++ b/drivers/virtio/virtio_ring.c
> @@ -2011,6 +2011,7 @@ static struct virtqueue *vring_create_virtqueue_packed(
> vq->vq.vdev = vdev;
> vq->vq.name = name;
> vq->vq.index = index;
> + vq->vq.reset = false;
> vq->we_own_ring = true;
> vq->notify = notify;
> vq->weak_barriers = weak_barriers;
> @@ -2490,6 +2491,7 @@ struct virtqueue *__vring_new_virtqueue(unsigned int index,
> vq->vq.vdev = vdev;
> vq->vq.name = name;
> vq->vq.index = index;
> + vq->vq.reset = false;
> vq->we_own_ring = false;
> vq->notify = notify;
> vq->weak_barriers = weak_barriers;
> diff --git a/include/linux/virtio.h b/include/linux/virtio.h
> index d45ee82a4470..a3f73bb6733e 100644
> --- a/include/linux/virtio.h
> +++ b/include/linux/virtio.h
> @@ -20,6 +20,7 @@
> * @index: the zero-based ordinal number for this queue.
> * @num_free: number of elements we expect to be able to fit.
> * @num_max: the maximum number of elements supported by the device.
> + * @reset: vq is in reset state or not.
> *
> * A note on @num_free: with indirect buffers, each buffer needs one
> * element in the queue, otherwise a buffer will need one element per
> @@ -34,6 +35,7 @@ struct virtqueue {
> unsigned int num_free;
> unsigned int num_max;
> void *priv;
> + bool reset;
> };
>
> int virtqueue_add_outbuf(struct virtqueue *vq,
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v12 27/40] virtio_pci: struct virtio_pci_common_cfg add queue_reset
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (25 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 26/40] virtio_ring: struct virtqueue introduce reset Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-21 9:14 ` Jason Wang
2022-07-20 3:04 ` [PATCH v12 28/40] virtio_pci: introduce helper to get/set queue reset Xuan Zhuo
` (12 subsequent siblings)
39 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Add queue_reset in virtio_pci_common_cfg.
https://github.com/oasis-tcs/virtio-spec/issues/124
https://github.com/oasis-tcs/virtio-spec/issues/139
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
include/linux/virtio_pci_modern.h | 2 +-
include/uapi/linux/virtio_pci.h | 1 +
2 files changed, 2 insertions(+), 1 deletion(-)
diff --git a/include/linux/virtio_pci_modern.h b/include/linux/virtio_pci_modern.h
index 41f5a018bd94..05123b9a606f 100644
--- a/include/linux/virtio_pci_modern.h
+++ b/include/linux/virtio_pci_modern.h
@@ -9,7 +9,7 @@ struct virtio_pci_modern_common_cfg {
struct virtio_pci_common_cfg cfg;
__le16 queue_notify_data; /* read-write */
- __le16 padding;
+ __le16 queue_reset; /* read-write */
};
struct virtio_pci_modern_device {
diff --git a/include/uapi/linux/virtio_pci.h b/include/uapi/linux/virtio_pci.h
index f5981a874481..f703afc7ad31 100644
--- a/include/uapi/linux/virtio_pci.h
+++ b/include/uapi/linux/virtio_pci.h
@@ -203,6 +203,7 @@ struct virtio_pci_cfg_cap {
#define VIRTIO_PCI_COMMON_Q_USEDLO 48
#define VIRTIO_PCI_COMMON_Q_USEDHI 52
#define VIRTIO_PCI_COMMON_Q_NDATA 56
+#define VIRTIO_PCI_COMMON_Q_RESET 58
#endif /* VIRTIO_PCI_NO_MODERN */
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v12 27/40] virtio_pci: struct virtio_pci_common_cfg add queue_reset
2022-07-20 3:04 ` [PATCH v12 27/40] virtio_pci: struct virtio_pci_common_cfg add queue_reset Xuan Zhuo
@ 2022-07-21 9:14 ` Jason Wang
0 siblings, 0 replies; 60+ messages in thread
From: Jason Wang @ 2022-07-21 9:14 UTC (permalink / raw)
To: Xuan Zhuo, virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
在 2022/7/20 11:04, Xuan Zhuo 写道:
> Add queue_reset in virtio_pci_common_cfg.
>
> https://github.com/oasis-tcs/virtio-spec/issues/124
> https://github.com/oasis-tcs/virtio-spec/issues/139
>
> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
> ---
> include/linux/virtio_pci_modern.h | 2 +-
> include/uapi/linux/virtio_pci.h | 1 +
> 2 files changed, 2 insertions(+), 1 deletion(-)
>
> diff --git a/include/linux/virtio_pci_modern.h b/include/linux/virtio_pci_modern.h
> index 41f5a018bd94..05123b9a606f 100644
> --- a/include/linux/virtio_pci_modern.h
> +++ b/include/linux/virtio_pci_modern.h
> @@ -9,7 +9,7 @@ struct virtio_pci_modern_common_cfg {
> struct virtio_pci_common_cfg cfg;
>
> __le16 queue_notify_data; /* read-write */
> - __le16 padding;
> + __le16 queue_reset; /* read-write */
> };
>
> struct virtio_pci_modern_device {
> diff --git a/include/uapi/linux/virtio_pci.h b/include/uapi/linux/virtio_pci.h
> index f5981a874481..f703afc7ad31 100644
> --- a/include/uapi/linux/virtio_pci.h
> +++ b/include/uapi/linux/virtio_pci.h
> @@ -203,6 +203,7 @@ struct virtio_pci_cfg_cap {
> #define VIRTIO_PCI_COMMON_Q_USEDLO 48
> #define VIRTIO_PCI_COMMON_Q_USEDHI 52
> #define VIRTIO_PCI_COMMON_Q_NDATA 56
> +#define VIRTIO_PCI_COMMON_Q_RESET 58
>
> #endif /* VIRTIO_PCI_NO_MODERN */
>
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v12 28/40] virtio_pci: introduce helper to get/set queue reset
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (26 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 27/40] virtio_pci: struct virtio_pci_common_cfg add queue_reset Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 29/40] virtio_pci: extract the logic of active vq for modern pci Xuan Zhuo
` (11 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Introduce new helpers to implement queue reset and get queue reset
status.
https://github.com/oasis-tcs/virtio-spec/issues/124
https://github.com/oasis-tcs/virtio-spec/issues/139
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/virtio/virtio_pci_modern_dev.c | 39 ++++++++++++++++++++++++++
include/linux/virtio_pci_modern.h | 2 ++
2 files changed, 41 insertions(+)
diff --git a/drivers/virtio/virtio_pci_modern_dev.c b/drivers/virtio/virtio_pci_modern_dev.c
index fa2a9445bb18..869cb46bef96 100644
--- a/drivers/virtio/virtio_pci_modern_dev.c
+++ b/drivers/virtio/virtio_pci_modern_dev.c
@@ -3,6 +3,7 @@
#include <linux/virtio_pci_modern.h>
#include <linux/module.h>
#include <linux/pci.h>
+#include <linux/delay.h>
/*
* vp_modern_map_capability - map a part of virtio pci capability
@@ -474,6 +475,44 @@ void vp_modern_set_status(struct virtio_pci_modern_device *mdev,
}
EXPORT_SYMBOL_GPL(vp_modern_set_status);
+/*
+ * vp_modern_get_queue_reset - get the queue reset status
+ * @mdev: the modern virtio-pci device
+ * @index: queue index
+ */
+int vp_modern_get_queue_reset(struct virtio_pci_modern_device *mdev, u16 index)
+{
+ struct virtio_pci_modern_common_cfg __iomem *cfg;
+
+ cfg = (struct virtio_pci_modern_common_cfg __iomem *)mdev->common;
+
+ vp_iowrite16(index, &cfg->cfg.queue_select);
+ return vp_ioread16(&cfg->queue_reset);
+}
+EXPORT_SYMBOL_GPL(vp_modern_get_queue_reset);
+
+/*
+ * vp_modern_set_queue_reset - reset the queue
+ * @mdev: the modern virtio-pci device
+ * @index: queue index
+ */
+void vp_modern_set_queue_reset(struct virtio_pci_modern_device *mdev, u16 index)
+{
+ struct virtio_pci_modern_common_cfg __iomem *cfg;
+
+ cfg = (struct virtio_pci_modern_common_cfg __iomem *)mdev->common;
+
+ vp_iowrite16(index, &cfg->cfg.queue_select);
+ vp_iowrite16(1, &cfg->queue_reset);
+
+ while (vp_ioread16(&cfg->queue_reset))
+ msleep(1);
+
+ while (vp_ioread16(&cfg->cfg.queue_enable))
+ msleep(1);
+}
+EXPORT_SYMBOL_GPL(vp_modern_set_queue_reset);
+
/*
* vp_modern_queue_vector - set the MSIX vector for a specific virtqueue
* @mdev: the modern virtio-pci device
diff --git a/include/linux/virtio_pci_modern.h b/include/linux/virtio_pci_modern.h
index 05123b9a606f..c4eeb79b0139 100644
--- a/include/linux/virtio_pci_modern.h
+++ b/include/linux/virtio_pci_modern.h
@@ -113,4 +113,6 @@ void __iomem * vp_modern_map_vq_notify(struct virtio_pci_modern_device *mdev,
u16 index, resource_size_t *pa);
int vp_modern_probe(struct virtio_pci_modern_device *mdev);
void vp_modern_remove(struct virtio_pci_modern_device *mdev);
+int vp_modern_get_queue_reset(struct virtio_pci_modern_device *mdev, u16 index);
+void vp_modern_set_queue_reset(struct virtio_pci_modern_device *mdev, u16 index);
#endif
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 29/40] virtio_pci: extract the logic of active vq for modern pci
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (27 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 28/40] virtio_pci: introduce helper to get/set queue reset Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 30/40] virtio_pci: support VIRTIO_F_RING_RESET Xuan Zhuo
` (10 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Introduce vp_active_vq() to configure vring to backend after vq attach
vring. And configure vq vector if necessary.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/virtio/virtio_pci_modern.c | 46 ++++++++++++++++++------------
1 file changed, 28 insertions(+), 18 deletions(-)
diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c
index e7e0b8c850f6..9041d9a41b7d 100644
--- a/drivers/virtio/virtio_pci_modern.c
+++ b/drivers/virtio/virtio_pci_modern.c
@@ -176,6 +176,29 @@ static void vp_reset(struct virtio_device *vdev)
vp_synchronize_vectors(vdev);
}
+static int vp_active_vq(struct virtqueue *vq, u16 msix_vec)
+{
+ struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
+ struct virtio_pci_modern_device *mdev = &vp_dev->mdev;
+ unsigned long index;
+
+ index = vq->index;
+
+ /* activate the queue */
+ vp_modern_set_queue_size(mdev, index, virtqueue_get_vring_size(vq));
+ vp_modern_queue_address(mdev, index, virtqueue_get_desc_addr(vq),
+ virtqueue_get_avail_addr(vq),
+ virtqueue_get_used_addr(vq));
+
+ if (msix_vec != VIRTIO_MSI_NO_VECTOR) {
+ msix_vec = vp_modern_queue_vector(mdev, index, msix_vec);
+ if (msix_vec == VIRTIO_MSI_NO_VECTOR)
+ return -EBUSY;
+ }
+
+ return 0;
+}
+
static u16 vp_config_vector(struct virtio_pci_device *vp_dev, u16 vector)
{
return vp_modern_config_vector(&vp_dev->mdev, vector);
@@ -220,32 +243,19 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
vq->num_max = num;
- /* activate the queue */
- vp_modern_set_queue_size(mdev, index, virtqueue_get_vring_size(vq));
- vp_modern_queue_address(mdev, index, virtqueue_get_desc_addr(vq),
- virtqueue_get_avail_addr(vq),
- virtqueue_get_used_addr(vq));
+ err = vp_active_vq(vq, msix_vec);
+ if (err)
+ goto err;
vq->priv = (void __force *)vp_modern_map_vq_notify(mdev, index, NULL);
if (!vq->priv) {
err = -ENOMEM;
- goto err_map_notify;
- }
-
- if (msix_vec != VIRTIO_MSI_NO_VECTOR) {
- msix_vec = vp_modern_queue_vector(mdev, index, msix_vec);
- if (msix_vec == VIRTIO_MSI_NO_VECTOR) {
- err = -EBUSY;
- goto err_assign_vector;
- }
+ goto err;
}
return vq;
-err_assign_vector:
- if (!mdev->notify_base)
- pci_iounmap(mdev->pci_dev, (void __iomem __force *)vq->priv);
-err_map_notify:
+err:
vring_del_virtqueue(vq);
return ERR_PTR(err);
}
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 30/40] virtio_pci: support VIRTIO_F_RING_RESET
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (28 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 29/40] virtio_pci: extract the logic of active vq for modern pci Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-21 9:15 ` Jason Wang
2022-07-20 3:04 ` [PATCH v12 31/40] virtio: find_vqs() add arg sizes Xuan Zhuo
` (9 subsequent siblings)
39 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
This patch implements virtio pci support for QUEUE RESET.
Performing reset on a queue is divided into these steps:
1. notify the device to reset the queue
2. recycle the buffer submitted
3. reset the vring (may re-alloc)
4. mmap vring to device, and enable the queue
This patch implements virtio_reset_vq(), virtio_enable_resetq() in the
pci scenario.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/virtio/virtio_pci_common.c | 12 +++-
drivers/virtio/virtio_pci_modern.c | 96 ++++++++++++++++++++++++++++++
2 files changed, 105 insertions(+), 3 deletions(-)
diff --git a/drivers/virtio/virtio_pci_common.c b/drivers/virtio/virtio_pci_common.c
index ca51fcc9daab..ad258a9d3b9f 100644
--- a/drivers/virtio/virtio_pci_common.c
+++ b/drivers/virtio/virtio_pci_common.c
@@ -214,9 +214,15 @@ static void vp_del_vq(struct virtqueue *vq)
struct virtio_pci_vq_info *info = vp_dev->vqs[vq->index];
unsigned long flags;
- spin_lock_irqsave(&vp_dev->lock, flags);
- list_del(&info->node);
- spin_unlock_irqrestore(&vp_dev->lock, flags);
+ /*
+ * If it fails during re-enable reset vq. This way we won't rejoin
+ * info->node to the queue. Prevent unexpected irqs.
+ */
+ if (!vq->reset) {
+ spin_lock_irqsave(&vp_dev->lock, flags);
+ list_del(&info->node);
+ spin_unlock_irqrestore(&vp_dev->lock, flags);
+ }
vp_dev->del_vq(info);
kfree(info);
diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c
index 9041d9a41b7d..4d28b6918c80 100644
--- a/drivers/virtio/virtio_pci_modern.c
+++ b/drivers/virtio/virtio_pci_modern.c
@@ -34,6 +34,9 @@ static void vp_transport_features(struct virtio_device *vdev, u64 features)
if ((features & BIT_ULL(VIRTIO_F_SR_IOV)) &&
pci_find_ext_capability(pci_dev, PCI_EXT_CAP_ID_SRIOV))
__virtio_set_bit(vdev, VIRTIO_F_SR_IOV);
+
+ if (features & BIT_ULL(VIRTIO_F_RING_RESET))
+ __virtio_set_bit(vdev, VIRTIO_F_RING_RESET);
}
/* virtio config->finalize_features() implementation */
@@ -199,6 +202,95 @@ static int vp_active_vq(struct virtqueue *vq, u16 msix_vec)
return 0;
}
+static int vp_modern_reset_vq(struct virtqueue *vq)
+{
+ struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
+ struct virtio_pci_modern_device *mdev = &vp_dev->mdev;
+ struct virtio_pci_vq_info *info;
+ unsigned long flags;
+
+ if (!virtio_has_feature(vq->vdev, VIRTIO_F_RING_RESET))
+ return -ENOENT;
+
+ vp_modern_set_queue_reset(mdev, vq->index);
+
+ info = vp_dev->vqs[vq->index];
+
+ /* delete vq from irq handler */
+ spin_lock_irqsave(&vp_dev->lock, flags);
+ list_del(&info->node);
+ spin_unlock_irqrestore(&vp_dev->lock, flags);
+
+ INIT_LIST_HEAD(&info->node);
+
+ /* For the case where vq has an exclusive irq, to prevent the irq from
+ * being received again and the pending irq, call synchronize_irq(), and
+ * break it.
+ *
+ * We can't use disable_irq() since it conflicts with the affinity
+ * managed IRQ that is used by some drivers. So this is done on top of
+ * IRQ hardening.
+ *
+ * In the scenario based on shared interrupts, vq will be searched from
+ * the queue virtqueues. Since the previous list_del() has been deleted
+ * from the queue, it is impossible for vq to be called in this case.
+ * There is no need to close the corresponding interrupt.
+ */
+ if (vp_dev->per_vq_vectors && info->msix_vector != VIRTIO_MSI_NO_VECTOR) {
+#ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION
+ __virtqueue_break(vq);
+#endif
+ synchronize_irq(pci_irq_vector(vp_dev->pci_dev, info->msix_vector));
+ }
+
+ vq->reset = true;
+
+ return 0;
+}
+
+static int vp_modern_enable_reset_vq(struct virtqueue *vq)
+{
+ struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
+ struct virtio_pci_modern_device *mdev = &vp_dev->mdev;
+ struct virtio_pci_vq_info *info;
+ unsigned long flags, index;
+ int err;
+
+ if (!vq->reset)
+ return -EBUSY;
+
+ index = vq->index;
+ info = vp_dev->vqs[index];
+
+ if (vp_modern_get_queue_reset(mdev, index))
+ return -EBUSY;
+
+ if (vp_modern_get_queue_enable(mdev, index))
+ return -EBUSY;
+
+ err = vp_active_vq(vq, info->msix_vector);
+ if (err)
+ return err;
+
+ if (vq->callback) {
+ spin_lock_irqsave(&vp_dev->lock, flags);
+ list_add(&info->node, &vp_dev->virtqueues);
+ spin_unlock_irqrestore(&vp_dev->lock, flags);
+ } else {
+ INIT_LIST_HEAD(&info->node);
+ }
+
+#ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION
+ if (vp_dev->per_vq_vectors && info->msix_vector != VIRTIO_MSI_NO_VECTOR)
+ __virtqueue_unbreak(vq);
+#endif
+
+ vp_modern_set_queue_enable(&vp_dev->mdev, index, true);
+ vq->reset = false;
+
+ return 0;
+}
+
static u16 vp_config_vector(struct virtio_pci_device *vp_dev, u16 vector)
{
return vp_modern_config_vector(&vp_dev->mdev, vector);
@@ -413,6 +505,8 @@ static const struct virtio_config_ops virtio_pci_config_nodev_ops = {
.set_vq_affinity = vp_set_vq_affinity,
.get_vq_affinity = vp_get_vq_affinity,
.get_shm_region = vp_get_shm_region,
+ .disable_vq_and_reset = vp_modern_reset_vq,
+ .enable_vq_after_reset = vp_modern_enable_reset_vq,
};
static const struct virtio_config_ops virtio_pci_config_ops = {
@@ -431,6 +525,8 @@ static const struct virtio_config_ops virtio_pci_config_ops = {
.set_vq_affinity = vp_set_vq_affinity,
.get_vq_affinity = vp_get_vq_affinity,
.get_shm_region = vp_get_shm_region,
+ .disable_vq_and_reset = vp_modern_reset_vq,
+ .enable_vq_after_reset = vp_modern_enable_reset_vq,
};
/* the PCI probing function */
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v12 30/40] virtio_pci: support VIRTIO_F_RING_RESET
2022-07-20 3:04 ` [PATCH v12 30/40] virtio_pci: support VIRTIO_F_RING_RESET Xuan Zhuo
@ 2022-07-21 9:15 ` Jason Wang
2022-07-22 3:05 ` Xuan Zhuo
0 siblings, 1 reply; 60+ messages in thread
From: Jason Wang @ 2022-07-21 9:15 UTC (permalink / raw)
To: Xuan Zhuo, virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
在 2022/7/20 11:04, Xuan Zhuo 写道:
> This patch implements virtio pci support for QUEUE RESET.
>
> Performing reset on a queue is divided into these steps:
>
> 1. notify the device to reset the queue
> 2. recycle the buffer submitted
> 3. reset the vring (may re-alloc)
> 4. mmap vring to device, and enable the queue
>
> This patch implements virtio_reset_vq(), virtio_enable_resetq() in the
> pci scenario.
>
> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
> ---
> drivers/virtio/virtio_pci_common.c | 12 +++-
> drivers/virtio/virtio_pci_modern.c | 96 ++++++++++++++++++++++++++++++
> 2 files changed, 105 insertions(+), 3 deletions(-)
>
> diff --git a/drivers/virtio/virtio_pci_common.c b/drivers/virtio/virtio_pci_common.c
> index ca51fcc9daab..ad258a9d3b9f 100644
> --- a/drivers/virtio/virtio_pci_common.c
> +++ b/drivers/virtio/virtio_pci_common.c
> @@ -214,9 +214,15 @@ static void vp_del_vq(struct virtqueue *vq)
> struct virtio_pci_vq_info *info = vp_dev->vqs[vq->index];
> unsigned long flags;
>
> - spin_lock_irqsave(&vp_dev->lock, flags);
> - list_del(&info->node);
> - spin_unlock_irqrestore(&vp_dev->lock, flags);
> + /*
> + * If it fails during re-enable reset vq. This way we won't rejoin
> + * info->node to the queue. Prevent unexpected irqs.
> + */
> + if (!vq->reset) {
> + spin_lock_irqsave(&vp_dev->lock, flags);
> + list_del(&info->node);
> + spin_unlock_irqrestore(&vp_dev->lock, flags);
> + }
>
> vp_dev->del_vq(info);
> kfree(info);
> diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c
> index 9041d9a41b7d..4d28b6918c80 100644
> --- a/drivers/virtio/virtio_pci_modern.c
> +++ b/drivers/virtio/virtio_pci_modern.c
> @@ -34,6 +34,9 @@ static void vp_transport_features(struct virtio_device *vdev, u64 features)
> if ((features & BIT_ULL(VIRTIO_F_SR_IOV)) &&
> pci_find_ext_capability(pci_dev, PCI_EXT_CAP_ID_SRIOV))
> __virtio_set_bit(vdev, VIRTIO_F_SR_IOV);
> +
> + if (features & BIT_ULL(VIRTIO_F_RING_RESET))
> + __virtio_set_bit(vdev, VIRTIO_F_RING_RESET);
> }
>
> /* virtio config->finalize_features() implementation */
> @@ -199,6 +202,95 @@ static int vp_active_vq(struct virtqueue *vq, u16 msix_vec)
> return 0;
> }
>
> +static int vp_modern_reset_vq(struct virtqueue *vq)
> +{
> + struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
> + struct virtio_pci_modern_device *mdev = &vp_dev->mdev;
> + struct virtio_pci_vq_info *info;
> + unsigned long flags;
> +
> + if (!virtio_has_feature(vq->vdev, VIRTIO_F_RING_RESET))
> + return -ENOENT;
> +
> + vp_modern_set_queue_reset(mdev, vq->index);
> +
> + info = vp_dev->vqs[vq->index];
> +
> + /* delete vq from irq handler */
> + spin_lock_irqsave(&vp_dev->lock, flags);
> + list_del(&info->node);
> + spin_unlock_irqrestore(&vp_dev->lock, flags);
> +
> + INIT_LIST_HEAD(&info->node);
> +
> + /* For the case where vq has an exclusive irq, to prevent the irq from
> + * being received again and the pending irq, call synchronize_irq(), and
> + * break it.
> + *
> + * We can't use disable_irq() since it conflicts with the affinity
> + * managed IRQ that is used by some drivers. So this is done on top of
> + * IRQ hardening.
> + *
> + * In the scenario based on shared interrupts, vq will be searched from
> + * the queue virtqueues. Since the previous list_del() has been deleted
> + * from the queue, it is impossible for vq to be called in this case.
> + * There is no need to close the corresponding interrupt.
> + */
> + if (vp_dev->per_vq_vectors && info->msix_vector != VIRTIO_MSI_NO_VECTOR) {
> +#ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION
> + __virtqueue_break(vq);
> +#endif
I think we should do this unconditionally since it's an independent
feature, though the list_del() above should be sufficient.
> + synchronize_irq(pci_irq_vector(vp_dev->pci_dev, info->msix_vector));
> + }
> +
> + vq->reset = true;
> +
> + return 0;
> +}
> +
> +static int vp_modern_enable_reset_vq(struct virtqueue *vq)
> +{
> + struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
> + struct virtio_pci_modern_device *mdev = &vp_dev->mdev;
> + struct virtio_pci_vq_info *info;
> + unsigned long flags, index;
> + int err;
> +
> + if (!vq->reset)
> + return -EBUSY;
> +
> + index = vq->index;
> + info = vp_dev->vqs[index];
> +
> + if (vp_modern_get_queue_reset(mdev, index))
> + return -EBUSY;
> +
> + if (vp_modern_get_queue_enable(mdev, index))
> + return -EBUSY;
> +
> + err = vp_active_vq(vq, info->msix_vector);
> + if (err)
> + return err;
> +
> + if (vq->callback) {
> + spin_lock_irqsave(&vp_dev->lock, flags);
> + list_add(&info->node, &vp_dev->virtqueues);
> + spin_unlock_irqrestore(&vp_dev->lock, flags);
> + } else {
> + INIT_LIST_HEAD(&info->node);
> + }
> +
> +#ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION
> + if (vp_dev->per_vq_vectors && info->msix_vector != VIRTIO_MSI_NO_VECTOR)
> + __virtqueue_unbreak(vq);
> +#endif
> +
> + vp_modern_set_queue_enable(&vp_dev->mdev, index, true);
> + vq->reset = false;
> +
> + return 0;
> +}
> +
> static u16 vp_config_vector(struct virtio_pci_device *vp_dev, u16 vector)
> {
> return vp_modern_config_vector(&vp_dev->mdev, vector);
> @@ -413,6 +505,8 @@ static const struct virtio_config_ops virtio_pci_config_nodev_ops = {
> .set_vq_affinity = vp_set_vq_affinity,
> .get_vq_affinity = vp_get_vq_affinity,
> .get_shm_region = vp_get_shm_region,
> + .disable_vq_and_reset = vp_modern_reset_vq,
> + .enable_vq_after_reset = vp_modern_enable_reset_vq,
Nit:
To be consistent, let's use vp_modern_disable_vq_and_reset() and
vp_modern_enable_vq_after_reset()
Thanks
> };
>
> static const struct virtio_config_ops virtio_pci_config_ops = {
> @@ -431,6 +525,8 @@ static const struct virtio_config_ops virtio_pci_config_ops = {
> .set_vq_affinity = vp_set_vq_affinity,
> .get_vq_affinity = vp_get_vq_affinity,
> .get_shm_region = vp_get_shm_region,
> + .disable_vq_and_reset = vp_modern_reset_vq,
> + .enable_vq_after_reset = vp_modern_enable_reset_vq,
> };
>
> /* the PCI probing function */
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v12 30/40] virtio_pci: support VIRTIO_F_RING_RESET
2022-07-21 9:15 ` Jason Wang
@ 2022-07-22 3:05 ` Xuan Zhuo
0 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-22 3:05 UTC (permalink / raw)
To: Jason Wang
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu, virtualization
On Thu, 21 Jul 2022 17:15:11 +0800, Jason Wang <jasowang@redhat.com> wrote:
>
> 在 2022/7/20 11:04, Xuan Zhuo 写道:
> > This patch implements virtio pci support for QUEUE RESET.
> >
> > Performing reset on a queue is divided into these steps:
> >
> > 1. notify the device to reset the queue
> > 2. recycle the buffer submitted
> > 3. reset the vring (may re-alloc)
> > 4. mmap vring to device, and enable the queue
> >
> > This patch implements virtio_reset_vq(), virtio_enable_resetq() in the
> > pci scenario.
> >
> > Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
> > ---
> > drivers/virtio/virtio_pci_common.c | 12 +++-
> > drivers/virtio/virtio_pci_modern.c | 96 ++++++++++++++++++++++++++++++
> > 2 files changed, 105 insertions(+), 3 deletions(-)
> >
> > diff --git a/drivers/virtio/virtio_pci_common.c b/drivers/virtio/virtio_pci_common.c
> > index ca51fcc9daab..ad258a9d3b9f 100644
> > --- a/drivers/virtio/virtio_pci_common.c
> > +++ b/drivers/virtio/virtio_pci_common.c
> > @@ -214,9 +214,15 @@ static void vp_del_vq(struct virtqueue *vq)
> > struct virtio_pci_vq_info *info = vp_dev->vqs[vq->index];
> > unsigned long flags;
> >
> > - spin_lock_irqsave(&vp_dev->lock, flags);
> > - list_del(&info->node);
> > - spin_unlock_irqrestore(&vp_dev->lock, flags);
> > + /*
> > + * If it fails during re-enable reset vq. This way we won't rejoin
> > + * info->node to the queue. Prevent unexpected irqs.
> > + */
> > + if (!vq->reset) {
> > + spin_lock_irqsave(&vp_dev->lock, flags);
> > + list_del(&info->node);
> > + spin_unlock_irqrestore(&vp_dev->lock, flags);
> > + }
> >
> > vp_dev->del_vq(info);
> > kfree(info);
> > diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c
> > index 9041d9a41b7d..4d28b6918c80 100644
> > --- a/drivers/virtio/virtio_pci_modern.c
> > +++ b/drivers/virtio/virtio_pci_modern.c
> > @@ -34,6 +34,9 @@ static void vp_transport_features(struct virtio_device *vdev, u64 features)
> > if ((features & BIT_ULL(VIRTIO_F_SR_IOV)) &&
> > pci_find_ext_capability(pci_dev, PCI_EXT_CAP_ID_SRIOV))
> > __virtio_set_bit(vdev, VIRTIO_F_SR_IOV);
> > +
> > + if (features & BIT_ULL(VIRTIO_F_RING_RESET))
> > + __virtio_set_bit(vdev, VIRTIO_F_RING_RESET);
> > }
> >
> > /* virtio config->finalize_features() implementation */
> > @@ -199,6 +202,95 @@ static int vp_active_vq(struct virtqueue *vq, u16 msix_vec)
> > return 0;
> > }
> >
> > +static int vp_modern_reset_vq(struct virtqueue *vq)
> > +{
> > + struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
> > + struct virtio_pci_modern_device *mdev = &vp_dev->mdev;
> > + struct virtio_pci_vq_info *info;
> > + unsigned long flags;
> > +
> > + if (!virtio_has_feature(vq->vdev, VIRTIO_F_RING_RESET))
> > + return -ENOENT;
> > +
> > + vp_modern_set_queue_reset(mdev, vq->index);
> > +
> > + info = vp_dev->vqs[vq->index];
> > +
> > + /* delete vq from irq handler */
> > + spin_lock_irqsave(&vp_dev->lock, flags);
> > + list_del(&info->node);
> > + spin_unlock_irqrestore(&vp_dev->lock, flags);
> > +
> > + INIT_LIST_HEAD(&info->node);
> > +
> > + /* For the case where vq has an exclusive irq, to prevent the irq from
> > + * being received again and the pending irq, call synchronize_irq(), and
> > + * break it.
> > + *
> > + * We can't use disable_irq() since it conflicts with the affinity
> > + * managed IRQ that is used by some drivers. So this is done on top of
> > + * IRQ hardening.
> > + *
> > + * In the scenario based on shared interrupts, vq will be searched from
> > + * the queue virtqueues. Since the previous list_del() has been deleted
> > + * from the queue, it is impossible for vq to be called in this case.
> > + * There is no need to close the corresponding interrupt.
> > + */
> > + if (vp_dev->per_vq_vectors && info->msix_vector != VIRTIO_MSI_NO_VECTOR) {
> > +#ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION
> > + __virtqueue_break(vq);
> > +#endif
>
>
> I think we should do this unconditionally since it's an independent
> feature, though the list_del() above should be sufficient.
Yes.
>
>
> > + synchronize_irq(pci_irq_vector(vp_dev->pci_dev, info->msix_vector));
> > + }
> > +
> > + vq->reset = true;
> > +
> > + return 0;
> > +}
> > +
> > +static int vp_modern_enable_reset_vq(struct virtqueue *vq)
> > +{
> > + struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
> > + struct virtio_pci_modern_device *mdev = &vp_dev->mdev;
> > + struct virtio_pci_vq_info *info;
> > + unsigned long flags, index;
> > + int err;
> > +
> > + if (!vq->reset)
> > + return -EBUSY;
> > +
> > + index = vq->index;
> > + info = vp_dev->vqs[index];
> > +
> > + if (vp_modern_get_queue_reset(mdev, index))
> > + return -EBUSY;
> > +
> > + if (vp_modern_get_queue_enable(mdev, index))
> > + return -EBUSY;
> > +
> > + err = vp_active_vq(vq, info->msix_vector);
> > + if (err)
> > + return err;
> > +
> > + if (vq->callback) {
> > + spin_lock_irqsave(&vp_dev->lock, flags);
> > + list_add(&info->node, &vp_dev->virtqueues);
> > + spin_unlock_irqrestore(&vp_dev->lock, flags);
> > + } else {
> > + INIT_LIST_HEAD(&info->node);
> > + }
> > +
> > +#ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION
> > + if (vp_dev->per_vq_vectors && info->msix_vector != VIRTIO_MSI_NO_VECTOR)
> > + __virtqueue_unbreak(vq);
> > +#endif
> > +
> > + vp_modern_set_queue_enable(&vp_dev->mdev, index, true);
> > + vq->reset = false;
> > +
> > + return 0;
> > +}
> > +
> > static u16 vp_config_vector(struct virtio_pci_device *vp_dev, u16 vector)
> > {
> > return vp_modern_config_vector(&vp_dev->mdev, vector);
> > @@ -413,6 +505,8 @@ static const struct virtio_config_ops virtio_pci_config_nodev_ops = {
> > .set_vq_affinity = vp_set_vq_affinity,
> > .get_vq_affinity = vp_get_vq_affinity,
> > .get_shm_region = vp_get_shm_region,
> > + .disable_vq_and_reset = vp_modern_reset_vq,
> > + .enable_vq_after_reset = vp_modern_enable_reset_vq,
>
>
> Nit:
>
> To be consistent, let's use vp_modern_disable_vq_and_reset() and
> vp_modern_enable_vq_after_reset()
Will fix.
Thanks.
>
> Thanks
>
>
> > };
> >
> > static const struct virtio_config_ops virtio_pci_config_ops = {
> > @@ -431,6 +525,8 @@ static const struct virtio_config_ops virtio_pci_config_ops = {
> > .set_vq_affinity = vp_set_vq_affinity,
> > .get_vq_affinity = vp_get_vq_affinity,
> > .get_shm_region = vp_get_shm_region,
> > + .disable_vq_and_reset = vp_modern_reset_vq,
> > + .enable_vq_after_reset = vp_modern_enable_reset_vq,
> > };
> >
> > /* the PCI probing function */
>
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v12 31/40] virtio: find_vqs() add arg sizes
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (29 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 30/40] virtio_pci: support VIRTIO_F_RING_RESET Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-21 9:17 ` Jason Wang
2022-07-20 3:04 ` [PATCH v12 32/40] virtio_pci: support the arg sizes of find_vqs() Xuan Zhuo
` (8 subsequent siblings)
39 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
find_vqs() adds a new parameter sizes to specify the size of each vq
vring.
NULL as sizes means that all queues in find_vqs() use the maximum size.
A value in the array is 0, which means that the corresponding queue uses
the maximum size.
In the split scenario, the meaning of size is the largest size, because
it may be limited by memory, the virtio core will try a smaller size.
And the size is power of 2.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Hans de Goede <hdegoede@redhat.com>
Reviewed-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
arch/um/drivers/virtio_uml.c | 2 +-
drivers/platform/mellanox/mlxbf-tmfifo.c | 1 +
drivers/remoteproc/remoteproc_virtio.c | 1 +
drivers/s390/virtio/virtio_ccw.c | 1 +
drivers/virtio/virtio_mmio.c | 1 +
drivers/virtio/virtio_pci_common.c | 2 +-
drivers/virtio/virtio_pci_common.h | 2 +-
drivers/virtio/virtio_pci_modern.c | 7 +++++--
drivers/virtio/virtio_vdpa.c | 1 +
include/linux/virtio_config.h | 14 +++++++++-----
10 files changed, 22 insertions(+), 10 deletions(-)
diff --git a/arch/um/drivers/virtio_uml.c b/arch/um/drivers/virtio_uml.c
index e719af8bdf56..79e38afd4b91 100644
--- a/arch/um/drivers/virtio_uml.c
+++ b/arch/um/drivers/virtio_uml.c
@@ -1011,7 +1011,7 @@ static struct virtqueue *vu_setup_vq(struct virtio_device *vdev,
static int vu_find_vqs(struct virtio_device *vdev, unsigned nvqs,
struct virtqueue *vqs[], vq_callback_t *callbacks[],
- const char * const names[], const bool *ctx,
+ const char * const names[], u32 sizes[], const bool *ctx,
struct irq_affinity *desc)
{
struct virtio_uml_device *vu_dev = to_virtio_uml_device(vdev);
diff --git a/drivers/platform/mellanox/mlxbf-tmfifo.c b/drivers/platform/mellanox/mlxbf-tmfifo.c
index 1ae3c56b66b0..8be13d416f48 100644
--- a/drivers/platform/mellanox/mlxbf-tmfifo.c
+++ b/drivers/platform/mellanox/mlxbf-tmfifo.c
@@ -928,6 +928,7 @@ static int mlxbf_tmfifo_virtio_find_vqs(struct virtio_device *vdev,
struct virtqueue *vqs[],
vq_callback_t *callbacks[],
const char * const names[],
+ u32 sizes[],
const bool *ctx,
struct irq_affinity *desc)
{
diff --git a/drivers/remoteproc/remoteproc_virtio.c b/drivers/remoteproc/remoteproc_virtio.c
index 0f7706e23eb9..81c4f5776109 100644
--- a/drivers/remoteproc/remoteproc_virtio.c
+++ b/drivers/remoteproc/remoteproc_virtio.c
@@ -158,6 +158,7 @@ static int rproc_virtio_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
struct virtqueue *vqs[],
vq_callback_t *callbacks[],
const char * const names[],
+ u32 sizes[],
const bool * ctx,
struct irq_affinity *desc)
{
diff --git a/drivers/s390/virtio/virtio_ccw.c b/drivers/s390/virtio/virtio_ccw.c
index 6b86d0280d6b..72500cd2dbf5 100644
--- a/drivers/s390/virtio/virtio_ccw.c
+++ b/drivers/s390/virtio/virtio_ccw.c
@@ -635,6 +635,7 @@ static int virtio_ccw_find_vqs(struct virtio_device *vdev, unsigned nvqs,
struct virtqueue *vqs[],
vq_callback_t *callbacks[],
const char * const names[],
+ u32 sizes[],
const bool *ctx,
struct irq_affinity *desc)
{
diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
index a20d5a6b5819..5e3ba3cc7fd0 100644
--- a/drivers/virtio/virtio_mmio.c
+++ b/drivers/virtio/virtio_mmio.c
@@ -474,6 +474,7 @@ static int vm_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
struct virtqueue *vqs[],
vq_callback_t *callbacks[],
const char * const names[],
+ u32 sizes[],
const bool *ctx,
struct irq_affinity *desc)
{
diff --git a/drivers/virtio/virtio_pci_common.c b/drivers/virtio/virtio_pci_common.c
index ad258a9d3b9f..7ad734584823 100644
--- a/drivers/virtio/virtio_pci_common.c
+++ b/drivers/virtio/virtio_pci_common.c
@@ -396,7 +396,7 @@ static int vp_find_vqs_intx(struct virtio_device *vdev, unsigned int nvqs,
/* the config->find_vqs() implementation */
int vp_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
struct virtqueue *vqs[], vq_callback_t *callbacks[],
- const char * const names[], const bool *ctx,
+ const char * const names[], u32 sizes[], const bool *ctx,
struct irq_affinity *desc)
{
int err;
diff --git a/drivers/virtio/virtio_pci_common.h b/drivers/virtio/virtio_pci_common.h
index 23112d84218f..a5ff838b85a5 100644
--- a/drivers/virtio/virtio_pci_common.h
+++ b/drivers/virtio/virtio_pci_common.h
@@ -110,7 +110,7 @@ void vp_del_vqs(struct virtio_device *vdev);
/* the config->find_vqs() implementation */
int vp_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
struct virtqueue *vqs[], vq_callback_t *callbacks[],
- const char * const names[], const bool *ctx,
+ const char * const names[], u32 sizes[], const bool *ctx,
struct irq_affinity *desc);
const char *vp_bus_name(struct virtio_device *vdev);
diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c
index 4d28b6918c80..19ec491d515a 100644
--- a/drivers/virtio/virtio_pci_modern.c
+++ b/drivers/virtio/virtio_pci_modern.c
@@ -355,12 +355,15 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
static int vp_modern_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
struct virtqueue *vqs[],
vq_callback_t *callbacks[],
- const char * const names[], const bool *ctx,
+ const char * const names[],
+ u32 sizes[],
+ const bool *ctx,
struct irq_affinity *desc)
{
struct virtio_pci_device *vp_dev = to_vp_device(vdev);
struct virtqueue *vq;
- int rc = vp_find_vqs(vdev, nvqs, vqs, callbacks, names, ctx, desc);
+ int rc = vp_find_vqs(vdev, nvqs, vqs, callbacks, names, sizes, ctx,
+ desc);
if (rc)
return rc;
diff --git a/drivers/virtio/virtio_vdpa.c b/drivers/virtio/virtio_vdpa.c
index 9670cc79371d..832d2c5b1b19 100644
--- a/drivers/virtio/virtio_vdpa.c
+++ b/drivers/virtio/virtio_vdpa.c
@@ -269,6 +269,7 @@ static int virtio_vdpa_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
struct virtqueue *vqs[],
vq_callback_t *callbacks[],
const char * const names[],
+ u32 sizes[],
const bool *ctx,
struct irq_affinity *desc)
{
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index 36ec7be1f480..888f7e96f0c7 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -55,6 +55,7 @@ struct virtio_shm_region {
* include a NULL entry for vqs that do not need a callback
* names: array of virtqueue names (mainly for debugging)
* include a NULL entry for vqs unused by driver
+ * sizes: array of virtqueue sizes
* Returns 0 on success or error status
* @del_vqs: free virtqueues found by find_vqs().
* @synchronize_cbs: synchronize with the virtqueue callbacks (optional)
@@ -103,7 +104,9 @@ struct virtio_config_ops {
void (*reset)(struct virtio_device *vdev);
int (*find_vqs)(struct virtio_device *, unsigned nvqs,
struct virtqueue *vqs[], vq_callback_t *callbacks[],
- const char * const names[], const bool *ctx,
+ const char * const names[],
+ u32 sizes[],
+ const bool *ctx,
struct irq_affinity *desc);
void (*del_vqs)(struct virtio_device *);
void (*synchronize_cbs)(struct virtio_device *);
@@ -212,7 +215,7 @@ struct virtqueue *virtio_find_single_vq(struct virtio_device *vdev,
const char *names[] = { n };
struct virtqueue *vq;
int err = vdev->config->find_vqs(vdev, 1, &vq, callbacks, names, NULL,
- NULL);
+ NULL, NULL);
if (err < 0)
return ERR_PTR(err);
return vq;
@@ -224,7 +227,8 @@ int virtio_find_vqs(struct virtio_device *vdev, unsigned nvqs,
const char * const names[],
struct irq_affinity *desc)
{
- return vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names, NULL, desc);
+ return vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names, NULL,
+ NULL, desc);
}
static inline
@@ -233,8 +237,8 @@ int virtio_find_vqs_ctx(struct virtio_device *vdev, unsigned nvqs,
const char * const names[], const bool *ctx,
struct irq_affinity *desc)
{
- return vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names, ctx,
- desc);
+ return vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names, NULL,
+ ctx, desc);
}
/**
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v12 31/40] virtio: find_vqs() add arg sizes
2022-07-20 3:04 ` [PATCH v12 31/40] virtio: find_vqs() add arg sizes Xuan Zhuo
@ 2022-07-21 9:17 ` Jason Wang
0 siblings, 0 replies; 60+ messages in thread
From: Jason Wang @ 2022-07-21 9:17 UTC (permalink / raw)
To: Xuan Zhuo, virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
在 2022/7/20 11:04, Xuan Zhuo 写道:
> find_vqs() adds a new parameter sizes to specify the size of each vq
> vring.
>
> NULL as sizes means that all queues in find_vqs() use the maximum size.
> A value in the array is 0, which means that the corresponding queue uses
> the maximum size.
>
> In the split scenario, the meaning of size is the largest size, because
> it may be limited by memory, the virtio core will try a smaller size.
> And the size is power of 2.
>
> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
> Acked-by: Hans de Goede <hdegoede@redhat.com>
> Reviewed-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Acked-by: Jason Wang <jasowang@redhat.com>
> ---
> arch/um/drivers/virtio_uml.c | 2 +-
> drivers/platform/mellanox/mlxbf-tmfifo.c | 1 +
> drivers/remoteproc/remoteproc_virtio.c | 1 +
> drivers/s390/virtio/virtio_ccw.c | 1 +
> drivers/virtio/virtio_mmio.c | 1 +
> drivers/virtio/virtio_pci_common.c | 2 +-
> drivers/virtio/virtio_pci_common.h | 2 +-
> drivers/virtio/virtio_pci_modern.c | 7 +++++--
> drivers/virtio/virtio_vdpa.c | 1 +
> include/linux/virtio_config.h | 14 +++++++++-----
> 10 files changed, 22 insertions(+), 10 deletions(-)
>
> diff --git a/arch/um/drivers/virtio_uml.c b/arch/um/drivers/virtio_uml.c
> index e719af8bdf56..79e38afd4b91 100644
> --- a/arch/um/drivers/virtio_uml.c
> +++ b/arch/um/drivers/virtio_uml.c
> @@ -1011,7 +1011,7 @@ static struct virtqueue *vu_setup_vq(struct virtio_device *vdev,
>
> static int vu_find_vqs(struct virtio_device *vdev, unsigned nvqs,
> struct virtqueue *vqs[], vq_callback_t *callbacks[],
> - const char * const names[], const bool *ctx,
> + const char * const names[], u32 sizes[], const bool *ctx,
> struct irq_affinity *desc)
> {
> struct virtio_uml_device *vu_dev = to_virtio_uml_device(vdev);
> diff --git a/drivers/platform/mellanox/mlxbf-tmfifo.c b/drivers/platform/mellanox/mlxbf-tmfifo.c
> index 1ae3c56b66b0..8be13d416f48 100644
> --- a/drivers/platform/mellanox/mlxbf-tmfifo.c
> +++ b/drivers/platform/mellanox/mlxbf-tmfifo.c
> @@ -928,6 +928,7 @@ static int mlxbf_tmfifo_virtio_find_vqs(struct virtio_device *vdev,
> struct virtqueue *vqs[],
> vq_callback_t *callbacks[],
> const char * const names[],
> + u32 sizes[],
> const bool *ctx,
> struct irq_affinity *desc)
> {
> diff --git a/drivers/remoteproc/remoteproc_virtio.c b/drivers/remoteproc/remoteproc_virtio.c
> index 0f7706e23eb9..81c4f5776109 100644
> --- a/drivers/remoteproc/remoteproc_virtio.c
> +++ b/drivers/remoteproc/remoteproc_virtio.c
> @@ -158,6 +158,7 @@ static int rproc_virtio_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
> struct virtqueue *vqs[],
> vq_callback_t *callbacks[],
> const char * const names[],
> + u32 sizes[],
> const bool * ctx,
> struct irq_affinity *desc)
> {
> diff --git a/drivers/s390/virtio/virtio_ccw.c b/drivers/s390/virtio/virtio_ccw.c
> index 6b86d0280d6b..72500cd2dbf5 100644
> --- a/drivers/s390/virtio/virtio_ccw.c
> +++ b/drivers/s390/virtio/virtio_ccw.c
> @@ -635,6 +635,7 @@ static int virtio_ccw_find_vqs(struct virtio_device *vdev, unsigned nvqs,
> struct virtqueue *vqs[],
> vq_callback_t *callbacks[],
> const char * const names[],
> + u32 sizes[],
> const bool *ctx,
> struct irq_affinity *desc)
> {
> diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
> index a20d5a6b5819..5e3ba3cc7fd0 100644
> --- a/drivers/virtio/virtio_mmio.c
> +++ b/drivers/virtio/virtio_mmio.c
> @@ -474,6 +474,7 @@ static int vm_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
> struct virtqueue *vqs[],
> vq_callback_t *callbacks[],
> const char * const names[],
> + u32 sizes[],
> const bool *ctx,
> struct irq_affinity *desc)
> {
> diff --git a/drivers/virtio/virtio_pci_common.c b/drivers/virtio/virtio_pci_common.c
> index ad258a9d3b9f..7ad734584823 100644
> --- a/drivers/virtio/virtio_pci_common.c
> +++ b/drivers/virtio/virtio_pci_common.c
> @@ -396,7 +396,7 @@ static int vp_find_vqs_intx(struct virtio_device *vdev, unsigned int nvqs,
> /* the config->find_vqs() implementation */
> int vp_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
> struct virtqueue *vqs[], vq_callback_t *callbacks[],
> - const char * const names[], const bool *ctx,
> + const char * const names[], u32 sizes[], const bool *ctx,
> struct irq_affinity *desc)
> {
> int err;
> diff --git a/drivers/virtio/virtio_pci_common.h b/drivers/virtio/virtio_pci_common.h
> index 23112d84218f..a5ff838b85a5 100644
> --- a/drivers/virtio/virtio_pci_common.h
> +++ b/drivers/virtio/virtio_pci_common.h
> @@ -110,7 +110,7 @@ void vp_del_vqs(struct virtio_device *vdev);
> /* the config->find_vqs() implementation */
> int vp_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
> struct virtqueue *vqs[], vq_callback_t *callbacks[],
> - const char * const names[], const bool *ctx,
> + const char * const names[], u32 sizes[], const bool *ctx,
> struct irq_affinity *desc);
> const char *vp_bus_name(struct virtio_device *vdev);
>
> diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c
> index 4d28b6918c80..19ec491d515a 100644
> --- a/drivers/virtio/virtio_pci_modern.c
> +++ b/drivers/virtio/virtio_pci_modern.c
> @@ -355,12 +355,15 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
> static int vp_modern_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
> struct virtqueue *vqs[],
> vq_callback_t *callbacks[],
> - const char * const names[], const bool *ctx,
> + const char * const names[],
> + u32 sizes[],
> + const bool *ctx,
> struct irq_affinity *desc)
> {
> struct virtio_pci_device *vp_dev = to_vp_device(vdev);
> struct virtqueue *vq;
> - int rc = vp_find_vqs(vdev, nvqs, vqs, callbacks, names, ctx, desc);
> + int rc = vp_find_vqs(vdev, nvqs, vqs, callbacks, names, sizes, ctx,
> + desc);
>
> if (rc)
> return rc;
> diff --git a/drivers/virtio/virtio_vdpa.c b/drivers/virtio/virtio_vdpa.c
> index 9670cc79371d..832d2c5b1b19 100644
> --- a/drivers/virtio/virtio_vdpa.c
> +++ b/drivers/virtio/virtio_vdpa.c
> @@ -269,6 +269,7 @@ static int virtio_vdpa_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
> struct virtqueue *vqs[],
> vq_callback_t *callbacks[],
> const char * const names[],
> + u32 sizes[],
> const bool *ctx,
> struct irq_affinity *desc)
> {
> diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
> index 36ec7be1f480..888f7e96f0c7 100644
> --- a/include/linux/virtio_config.h
> +++ b/include/linux/virtio_config.h
> @@ -55,6 +55,7 @@ struct virtio_shm_region {
> * include a NULL entry for vqs that do not need a callback
> * names: array of virtqueue names (mainly for debugging)
> * include a NULL entry for vqs unused by driver
> + * sizes: array of virtqueue sizes
> * Returns 0 on success or error status
> * @del_vqs: free virtqueues found by find_vqs().
> * @synchronize_cbs: synchronize with the virtqueue callbacks (optional)
> @@ -103,7 +104,9 @@ struct virtio_config_ops {
> void (*reset)(struct virtio_device *vdev);
> int (*find_vqs)(struct virtio_device *, unsigned nvqs,
> struct virtqueue *vqs[], vq_callback_t *callbacks[],
> - const char * const names[], const bool *ctx,
> + const char * const names[],
> + u32 sizes[],
> + const bool *ctx,
> struct irq_affinity *desc);
> void (*del_vqs)(struct virtio_device *);
> void (*synchronize_cbs)(struct virtio_device *);
> @@ -212,7 +215,7 @@ struct virtqueue *virtio_find_single_vq(struct virtio_device *vdev,
> const char *names[] = { n };
> struct virtqueue *vq;
> int err = vdev->config->find_vqs(vdev, 1, &vq, callbacks, names, NULL,
> - NULL);
> + NULL, NULL);
> if (err < 0)
> return ERR_PTR(err);
> return vq;
> @@ -224,7 +227,8 @@ int virtio_find_vqs(struct virtio_device *vdev, unsigned nvqs,
> const char * const names[],
> struct irq_affinity *desc)
> {
> - return vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names, NULL, desc);
> + return vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names, NULL,
> + NULL, desc);
> }
>
> static inline
> @@ -233,8 +237,8 @@ int virtio_find_vqs_ctx(struct virtio_device *vdev, unsigned nvqs,
> const char * const names[], const bool *ctx,
> struct irq_affinity *desc)
> {
> - return vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names, ctx,
> - desc);
> + return vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names, NULL,
> + ctx, desc);
> }
>
> /**
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v12 32/40] virtio_pci: support the arg sizes of find_vqs()
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (30 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 31/40] virtio: find_vqs() add arg sizes Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 33/40] virtio_mmio: " Xuan Zhuo
` (7 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Virtio PCI supports new parameter sizes of find_vqs().
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/virtio/virtio_pci_common.c | 18 ++++++++++--------
drivers/virtio/virtio_pci_common.h | 1 +
drivers/virtio/virtio_pci_legacy.c | 6 +++++-
drivers/virtio/virtio_pci_modern.c | 10 +++++++---
4 files changed, 23 insertions(+), 12 deletions(-)
diff --git a/drivers/virtio/virtio_pci_common.c b/drivers/virtio/virtio_pci_common.c
index 7ad734584823..00ad476a815d 100644
--- a/drivers/virtio/virtio_pci_common.c
+++ b/drivers/virtio/virtio_pci_common.c
@@ -174,6 +174,7 @@ static int vp_request_msix_vectors(struct virtio_device *vdev, int nvectors,
static struct virtqueue *vp_setup_vq(struct virtio_device *vdev, unsigned int index,
void (*callback)(struct virtqueue *vq),
const char *name,
+ u32 size,
bool ctx,
u16 msix_vec)
{
@@ -186,7 +187,7 @@ static struct virtqueue *vp_setup_vq(struct virtio_device *vdev, unsigned int in
if (!info)
return ERR_PTR(-ENOMEM);
- vq = vp_dev->setup_vq(vp_dev, info, index, callback, name, ctx,
+ vq = vp_dev->setup_vq(vp_dev, info, index, callback, name, size, ctx,
msix_vec);
if (IS_ERR(vq))
goto out_info;
@@ -283,7 +284,7 @@ void vp_del_vqs(struct virtio_device *vdev)
static int vp_find_vqs_msix(struct virtio_device *vdev, unsigned int nvqs,
struct virtqueue *vqs[], vq_callback_t *callbacks[],
- const char * const names[], bool per_vq_vectors,
+ const char * const names[], u32 sizes[], bool per_vq_vectors,
const bool *ctx,
struct irq_affinity *desc)
{
@@ -326,8 +327,8 @@ static int vp_find_vqs_msix(struct virtio_device *vdev, unsigned int nvqs,
else
msix_vec = VP_MSIX_VQ_VECTOR;
vqs[i] = vp_setup_vq(vdev, queue_idx++, callbacks[i], names[i],
- ctx ? ctx[i] : false,
- msix_vec);
+ sizes ? sizes[i] : 0,
+ ctx ? ctx[i] : false, msix_vec);
if (IS_ERR(vqs[i])) {
err = PTR_ERR(vqs[i]);
goto error_find;
@@ -357,7 +358,7 @@ static int vp_find_vqs_msix(struct virtio_device *vdev, unsigned int nvqs,
static int vp_find_vqs_intx(struct virtio_device *vdev, unsigned int nvqs,
struct virtqueue *vqs[], vq_callback_t *callbacks[],
- const char * const names[], const bool *ctx)
+ const char * const names[], u32 sizes[], const bool *ctx)
{
struct virtio_pci_device *vp_dev = to_vp_device(vdev);
int i, err, queue_idx = 0;
@@ -379,6 +380,7 @@ static int vp_find_vqs_intx(struct virtio_device *vdev, unsigned int nvqs,
continue;
}
vqs[i] = vp_setup_vq(vdev, queue_idx++, callbacks[i], names[i],
+ sizes ? sizes[i] : 0,
ctx ? ctx[i] : false,
VIRTIO_MSI_NO_VECTOR);
if (IS_ERR(vqs[i])) {
@@ -402,15 +404,15 @@ int vp_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
int err;
/* Try MSI-X with one vector per queue. */
- err = vp_find_vqs_msix(vdev, nvqs, vqs, callbacks, names, true, ctx, desc);
+ err = vp_find_vqs_msix(vdev, nvqs, vqs, callbacks, names, sizes, true, ctx, desc);
if (!err)
return 0;
/* Fallback: MSI-X with one vector for config, one shared for queues. */
- err = vp_find_vqs_msix(vdev, nvqs, vqs, callbacks, names, false, ctx, desc);
+ err = vp_find_vqs_msix(vdev, nvqs, vqs, callbacks, names, sizes, false, ctx, desc);
if (!err)
return 0;
/* Finally fall back to regular interrupts. */
- return vp_find_vqs_intx(vdev, nvqs, vqs, callbacks, names, ctx);
+ return vp_find_vqs_intx(vdev, nvqs, vqs, callbacks, names, sizes, ctx);
}
const char *vp_bus_name(struct virtio_device *vdev)
diff --git a/drivers/virtio/virtio_pci_common.h b/drivers/virtio/virtio_pci_common.h
index a5ff838b85a5..c0448378b698 100644
--- a/drivers/virtio/virtio_pci_common.h
+++ b/drivers/virtio/virtio_pci_common.h
@@ -80,6 +80,7 @@ struct virtio_pci_device {
unsigned int idx,
void (*callback)(struct virtqueue *vq),
const char *name,
+ u32 size,
bool ctx,
u16 msix_vec);
void (*del_vq)(struct virtio_pci_vq_info *info);
diff --git a/drivers/virtio/virtio_pci_legacy.c b/drivers/virtio/virtio_pci_legacy.c
index 2257f1b3d8ae..d75e5c4e637f 100644
--- a/drivers/virtio/virtio_pci_legacy.c
+++ b/drivers/virtio/virtio_pci_legacy.c
@@ -112,6 +112,7 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
unsigned int index,
void (*callback)(struct virtqueue *vq),
const char *name,
+ u32 size,
bool ctx,
u16 msix_vec)
{
@@ -125,10 +126,13 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
if (!num || vp_legacy_get_queue_enable(&vp_dev->ldev, index))
return ERR_PTR(-ENOENT);
+ if (!size || size > num)
+ size = num;
+
info->msix_vector = msix_vec;
/* create the vring */
- vq = vring_create_virtqueue(index, num,
+ vq = vring_create_virtqueue(index, size,
VIRTIO_PCI_VRING_ALIGN, &vp_dev->vdev,
true, false, ctx,
vp_notify, callback, name);
diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c
index 19ec491d515a..11607bf71b40 100644
--- a/drivers/virtio/virtio_pci_modern.c
+++ b/drivers/virtio/virtio_pci_modern.c
@@ -301,6 +301,7 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
unsigned int index,
void (*callback)(struct virtqueue *vq),
const char *name,
+ u32 size,
bool ctx,
u16 msix_vec)
{
@@ -318,15 +319,18 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
if (!num || vp_modern_get_queue_enable(mdev, index))
return ERR_PTR(-ENOENT);
- if (num & (num - 1)) {
- dev_warn(&vp_dev->pci_dev->dev, "bad queue size %u", num);
+ if (!size || size > num)
+ size = num;
+
+ if (size & (size - 1)) {
+ dev_warn(&vp_dev->pci_dev->dev, "bad queue size %u", size);
return ERR_PTR(-EINVAL);
}
info->msix_vector = msix_vec;
/* create the vring */
- vq = vring_create_virtqueue(index, num,
+ vq = vring_create_virtqueue(index, size,
SMP_CACHE_BYTES, &vp_dev->vdev,
true, true, ctx,
vp_notify, callback, name);
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 33/40] virtio_mmio: support the arg sizes of find_vqs()
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (31 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 32/40] virtio_pci: support the arg sizes of find_vqs() Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 34/40] virtio: add helper virtio_find_vqs_ctx_size() Xuan Zhuo
` (6 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Virtio MMIO support the new parameter sizes of find_vqs().
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/virtio/virtio_mmio.c | 8 ++++++--
1 file changed, 6 insertions(+), 2 deletions(-)
diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
index 5e3ba3cc7fd0..c888fee18caf 100644
--- a/drivers/virtio/virtio_mmio.c
+++ b/drivers/virtio/virtio_mmio.c
@@ -360,7 +360,7 @@ static void vm_synchronize_cbs(struct virtio_device *vdev)
static struct virtqueue *vm_setup_vq(struct virtio_device *vdev, unsigned int index,
void (*callback)(struct virtqueue *vq),
- const char *name, bool ctx)
+ const char *name, u32 size, bool ctx)
{
struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
struct virtio_mmio_vq_info *info;
@@ -395,8 +395,11 @@ static struct virtqueue *vm_setup_vq(struct virtio_device *vdev, unsigned int in
goto error_new_virtqueue;
}
+ if (!size || size > num)
+ size = num;
+
/* Create the vring */
- vq = vring_create_virtqueue(index, num, VIRTIO_MMIO_VRING_ALIGN, vdev,
+ vq = vring_create_virtqueue(index, size, VIRTIO_MMIO_VRING_ALIGN, vdev,
true, true, ctx, vm_notify, callback, name);
if (!vq) {
err = -ENOMEM;
@@ -497,6 +500,7 @@ static int vm_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
}
vqs[i] = vm_setup_vq(vdev, queue_idx++, callbacks[i], names[i],
+ sizes ? sizes[i] : 0,
ctx ? ctx[i] : false);
if (IS_ERR(vqs[i])) {
vm_del_vqs(vdev);
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 34/40] virtio: add helper virtio_find_vqs_ctx_size()
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (32 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 33/40] virtio_mmio: " Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 35/40] virtio_net: set the default max ring size by find_vqs() Xuan Zhuo
` (5 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Introduce helper virtio_find_vqs_ctx_size() to call find_vqs and specify
the maximum size of each vq ring.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
include/linux/virtio_config.h | 12 ++++++++++++
1 file changed, 12 insertions(+)
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index 888f7e96f0c7..6adff09f7170 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -241,6 +241,18 @@ int virtio_find_vqs_ctx(struct virtio_device *vdev, unsigned nvqs,
ctx, desc);
}
+static inline
+int virtio_find_vqs_ctx_size(struct virtio_device *vdev, u32 nvqs,
+ struct virtqueue *vqs[],
+ vq_callback_t *callbacks[],
+ const char * const names[],
+ u32 sizes[],
+ const bool *ctx, struct irq_affinity *desc)
+{
+ return vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names, sizes,
+ ctx, desc);
+}
+
/**
* virtio_synchronize_cbs - synchronize with virtqueue callbacks
* @vdev: the device
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 35/40] virtio_net: set the default max ring size by find_vqs()
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (33 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 34/40] virtio: add helper virtio_find_vqs_ctx_size() Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 36/40] virtio_net: get ringparam by virtqueue_get_vring_max_size() Xuan Zhuo
` (4 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Use virtio_find_vqs_ctx_size() to specify the maximum ring size of tx,
rx at the same time.
| rx/tx ring size
-------------------------------------------
speed == UNKNOWN or < 10G| 1024
speed < 40G | 4096
speed >= 40G | 8192
Call virtnet_update_settings() once before calling init_vqs() to update
speed.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/net/virtio_net.c | 42 ++++++++++++++++++++++++++++++++++++----
1 file changed, 38 insertions(+), 4 deletions(-)
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 8a5810bcb839..40532ecbe7fc 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -3208,6 +3208,29 @@ static unsigned int mergeable_min_buf_len(struct virtnet_info *vi, struct virtqu
(unsigned int)GOOD_PACKET_LEN);
}
+static void virtnet_config_sizes(struct virtnet_info *vi, u32 *sizes)
+{
+ u32 i, rx_size, tx_size;
+
+ if (vi->speed == SPEED_UNKNOWN || vi->speed < SPEED_10000) {
+ rx_size = 1024;
+ tx_size = 1024;
+
+ } else if (vi->speed < SPEED_40000) {
+ rx_size = 1024 * 4;
+ tx_size = 1024 * 4;
+
+ } else {
+ rx_size = 1024 * 8;
+ tx_size = 1024 * 8;
+ }
+
+ for (i = 0; i < vi->max_queue_pairs; i++) {
+ sizes[rxq2vq(i)] = rx_size;
+ sizes[txq2vq(i)] = tx_size;
+ }
+}
+
static int virtnet_find_vqs(struct virtnet_info *vi)
{
vq_callback_t **callbacks;
@@ -3215,6 +3238,7 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
int ret = -ENOMEM;
int i, total_vqs;
const char **names;
+ u32 *sizes;
bool *ctx;
/* We expect 1 RX virtqueue followed by 1 TX virtqueue, followed by
@@ -3242,10 +3266,15 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
ctx = NULL;
}
+ sizes = kmalloc_array(total_vqs, sizeof(*sizes), GFP_KERNEL);
+ if (!sizes)
+ goto err_sizes;
+
/* Parameters for control virtqueue, if any */
if (vi->has_cvq) {
callbacks[total_vqs - 1] = NULL;
names[total_vqs - 1] = "control";
+ sizes[total_vqs - 1] = 64;
}
/* Allocate/initialize parameters for send/receive virtqueues */
@@ -3260,8 +3289,10 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
ctx[rxq2vq(i)] = true;
}
- ret = virtio_find_vqs_ctx(vi->vdev, total_vqs, vqs, callbacks,
- names, ctx, NULL);
+ virtnet_config_sizes(vi, sizes);
+
+ ret = virtio_find_vqs_ctx_size(vi->vdev, total_vqs, vqs, callbacks,
+ names, sizes, ctx, NULL);
if (ret)
goto err_find;
@@ -3281,6 +3312,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
err_find:
+ kfree(sizes);
+err_sizes:
kfree(ctx);
err_ctx:
kfree(names);
@@ -3630,6 +3663,9 @@ static int virtnet_probe(struct virtio_device *vdev)
vi->curr_queue_pairs = num_online_cpus();
vi->max_queue_pairs = max_queue_pairs;
+ virtnet_init_settings(dev);
+ virtnet_update_settings(vi);
+
/* Allocate/initialize the rx/tx queues, and invoke find_vqs */
err = init_vqs(vi);
if (err)
@@ -3642,8 +3678,6 @@ static int virtnet_probe(struct virtio_device *vdev)
netif_set_real_num_tx_queues(dev, vi->curr_queue_pairs);
netif_set_real_num_rx_queues(dev, vi->curr_queue_pairs);
- virtnet_init_settings(dev);
-
if (virtio_has_feature(vdev, VIRTIO_NET_F_STANDBY)) {
vi->failover = net_failover_create(vi->dev);
if (IS_ERR(vi->failover)) {
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 36/40] virtio_net: get ringparam by virtqueue_get_vring_max_size()
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (34 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 35/40] virtio_net: set the default max ring size by find_vqs() Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 37/40] virtio_net: split free_unused_bufs() Xuan Zhuo
` (3 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Use virtqueue_get_vring_max_size() in virtnet_get_ringparam() to set
tx,rx_max_pending.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/net/virtio_net.c | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 40532ecbe7fc..981ef8ea4d58 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -2254,10 +2254,10 @@ static void virtnet_get_ringparam(struct net_device *dev,
{
struct virtnet_info *vi = netdev_priv(dev);
- ring->rx_max_pending = virtqueue_get_vring_size(vi->rq[0].vq);
- ring->tx_max_pending = virtqueue_get_vring_size(vi->sq[0].vq);
- ring->rx_pending = ring->rx_max_pending;
- ring->tx_pending = ring->tx_max_pending;
+ ring->rx_max_pending = vi->rq[0].vq->num_max;
+ ring->tx_max_pending = vi->sq[0].vq->num_max;
+ ring->rx_pending = virtqueue_get_vring_size(vi->rq[0].vq);
+ ring->tx_pending = virtqueue_get_vring_size(vi->sq[0].vq);
}
static bool virtnet_commit_rss_command(struct virtnet_info *vi)
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 37/40] virtio_net: split free_unused_bufs()
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (35 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 36/40] virtio_net: get ringparam by virtqueue_get_vring_max_size() Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 38/40] virtio_net: support rx queue resize Xuan Zhuo
` (2 subsequent siblings)
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
This patch separates two functions for freeing sq buf and rq buf from
free_unused_bufs().
When supporting the enable/disable tx/rq queue in the future, it is
necessary to support separate recovery of a sq buf or a rq buf.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/net/virtio_net.c | 41 ++++++++++++++++++++++++----------------
1 file changed, 25 insertions(+), 16 deletions(-)
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 981ef8ea4d58..fe4dc43c05a1 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -3151,6 +3151,27 @@ static void free_receive_page_frags(struct virtnet_info *vi)
put_page(vi->rq[i].alloc_frag.page);
}
+static void virtnet_sq_free_unused_buf(struct virtqueue *vq, void *buf)
+{
+ if (!is_xdp_frame(buf))
+ dev_kfree_skb(buf);
+ else
+ xdp_return_frame(ptr_to_xdp(buf));
+}
+
+static void virtnet_rq_free_unused_buf(struct virtqueue *vq, void *buf)
+{
+ struct virtnet_info *vi = vq->vdev->priv;
+ int i = vq2rxq(vq);
+
+ if (vi->mergeable_rx_bufs)
+ put_page(virt_to_head_page(buf));
+ else if (vi->big_packets)
+ give_pages(&vi->rq[i], buf);
+ else
+ put_page(virt_to_head_page(buf));
+}
+
static void free_unused_bufs(struct virtnet_info *vi)
{
void *buf;
@@ -3158,26 +3179,14 @@ static void free_unused_bufs(struct virtnet_info *vi)
for (i = 0; i < vi->max_queue_pairs; i++) {
struct virtqueue *vq = vi->sq[i].vq;
- while ((buf = virtqueue_detach_unused_buf(vq)) != NULL) {
- if (!is_xdp_frame(buf))
- dev_kfree_skb(buf);
- else
- xdp_return_frame(ptr_to_xdp(buf));
- }
+ while ((buf = virtqueue_detach_unused_buf(vq)) != NULL)
+ virtnet_sq_free_unused_buf(vq, buf);
}
for (i = 0; i < vi->max_queue_pairs; i++) {
struct virtqueue *vq = vi->rq[i].vq;
-
- while ((buf = virtqueue_detach_unused_buf(vq)) != NULL) {
- if (vi->mergeable_rx_bufs) {
- put_page(virt_to_head_page(buf));
- } else if (vi->big_packets) {
- give_pages(&vi->rq[i], buf);
- } else {
- put_page(virt_to_head_page(buf));
- }
- }
+ while ((buf = virtqueue_detach_unused_buf(vq)) != NULL)
+ virtnet_rq_free_unused_buf(vq, buf);
}
}
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v12 38/40] virtio_net: support rx queue resize
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (36 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 37/40] virtio_net: split free_unused_bufs() Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-21 9:25 ` Jason Wang
2022-07-20 3:04 ` [PATCH v12 39/40] virtio_net: support tx " Xuan Zhuo
2022-07-20 3:04 ` [PATCH v12 40/40] virtio_net: support set_ringparam Xuan Zhuo
39 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
This patch implements the resize function of the rx queues.
Based on this function, it is possible to modify the ring num of the
queue.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/net/virtio_net.c | 22 ++++++++++++++++++++++
1 file changed, 22 insertions(+)
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index fe4dc43c05a1..1115a8b59a08 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -278,6 +278,8 @@ struct padded_vnet_hdr {
char padding[12];
};
+static void virtnet_rq_free_unused_buf(struct virtqueue *vq, void *buf);
+
static bool is_xdp_frame(void *ptr)
{
return (unsigned long)ptr & VIRTIO_XDP_FLAG;
@@ -1846,6 +1848,26 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
return NETDEV_TX_OK;
}
+static int virtnet_rx_resize(struct virtnet_info *vi,
+ struct receive_queue *rq, u32 ring_num)
+{
+ int err, qindex;
+
+ qindex = rq - vi->rq;
+
+ napi_disable(&rq->napi);
+
+ err = virtqueue_resize(rq->vq, ring_num, virtnet_rq_free_unused_buf);
+ if (err)
+ netdev_err(vi->dev, "resize rx fail: rx queue index: %d err: %d\n", qindex, err);
+
+ if (!try_fill_recv(vi, rq, GFP_KERNEL))
+ schedule_delayed_work(&vi->refill, 0);
+
+ virtnet_napi_enable(rq->vq, &rq->napi);
+ return err;
+}
+
/*
* Send command via the control virtqueue and check status. Commands
* supported by the hypervisor, as indicated by feature bits, should
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v12 38/40] virtio_net: support rx queue resize
2022-07-20 3:04 ` [PATCH v12 38/40] virtio_net: support rx queue resize Xuan Zhuo
@ 2022-07-21 9:25 ` Jason Wang
2022-07-25 6:38 ` Xuan Zhuo
0 siblings, 1 reply; 60+ messages in thread
From: Jason Wang @ 2022-07-21 9:25 UTC (permalink / raw)
To: Xuan Zhuo, virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
在 2022/7/20 11:04, Xuan Zhuo 写道:
> This patch implements the resize function of the rx queues.
> Based on this function, it is possible to modify the ring num of the
> queue.
>
> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
> ---
> drivers/net/virtio_net.c | 22 ++++++++++++++++++++++
> 1 file changed, 22 insertions(+)
>
> diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
> index fe4dc43c05a1..1115a8b59a08 100644
> --- a/drivers/net/virtio_net.c
> +++ b/drivers/net/virtio_net.c
> @@ -278,6 +278,8 @@ struct padded_vnet_hdr {
> char padding[12];
> };
>
> +static void virtnet_rq_free_unused_buf(struct virtqueue *vq, void *buf);
> +
> static bool is_xdp_frame(void *ptr)
> {
> return (unsigned long)ptr & VIRTIO_XDP_FLAG;
> @@ -1846,6 +1848,26 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
> return NETDEV_TX_OK;
> }
>
> +static int virtnet_rx_resize(struct virtnet_info *vi,
> + struct receive_queue *rq, u32 ring_num)
> +{
> + int err, qindex;
> +
> + qindex = rq - vi->rq;
> +
> + napi_disable(&rq->napi);
We need to disable refill work as well. So this series might need
rebasing on top of
https://lore.kernel.org/netdev/20220704074859.16912-1-jasowang@redhat.com/
I will send a new version (probably tomorrow).
Thanks
> +
> + err = virtqueue_resize(rq->vq, ring_num, virtnet_rq_free_unused_buf);
> + if (err)
> + netdev_err(vi->dev, "resize rx fail: rx queue index: %d err: %d\n", qindex, err);
> +
> + if (!try_fill_recv(vi, rq, GFP_KERNEL))
> + schedule_delayed_work(&vi->refill, 0);
> +
> + virtnet_napi_enable(rq->vq, &rq->napi);
> + return err;
> +}
> +
> /*
> * Send command via the control virtqueue and check status. Commands
> * supported by the hypervisor, as indicated by feature bits, should
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v12 38/40] virtio_net: support rx queue resize
2022-07-21 9:25 ` Jason Wang
@ 2022-07-25 6:38 ` Xuan Zhuo
2022-07-25 6:57 ` Jason Wang
0 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-25 6:38 UTC (permalink / raw)
To: Jason Wang
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu, virtualization
On Thu, 21 Jul 2022 17:25:59 +0800, Jason Wang <jasowang@redhat.com> wrote:
>
> 在 2022/7/20 11:04, Xuan Zhuo 写道:
> > This patch implements the resize function of the rx queues.
> > Based on this function, it is possible to modify the ring num of the
> > queue.
> >
> > Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
> > ---
> > drivers/net/virtio_net.c | 22 ++++++++++++++++++++++
> > 1 file changed, 22 insertions(+)
> >
> > diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
> > index fe4dc43c05a1..1115a8b59a08 100644
> > --- a/drivers/net/virtio_net.c
> > +++ b/drivers/net/virtio_net.c
> > @@ -278,6 +278,8 @@ struct padded_vnet_hdr {
> > char padding[12];
> > };
> >
> > +static void virtnet_rq_free_unused_buf(struct virtqueue *vq, void *buf);
> > +
> > static bool is_xdp_frame(void *ptr)
> > {
> > return (unsigned long)ptr & VIRTIO_XDP_FLAG;
> > @@ -1846,6 +1848,26 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
> > return NETDEV_TX_OK;
> > }
> >
> > +static int virtnet_rx_resize(struct virtnet_info *vi,
> > + struct receive_queue *rq, u32 ring_num)
> > +{
> > + int err, qindex;
> > +
> > + qindex = rq - vi->rq;
> > +
> > + napi_disable(&rq->napi);
>
>
> We need to disable refill work as well. So this series might need
> rebasing on top of
>
> https://lore.kernel.org/netdev/20220704074859.16912-1-jasowang@redhat.com/
I understand that your patch is used to solve the situation where dev is
destoryed but refill work is running.
And is there such a possibility here? Or is there any other scenario that I'm
not expecting?
Thanks.
>
> I will send a new version (probably tomorrow).
>
> Thanks
>
>
> > +
> > + err = virtqueue_resize(rq->vq, ring_num, virtnet_rq_free_unused_buf);
> > + if (err)
> > + netdev_err(vi->dev, "resize rx fail: rx queue index: %d err: %d\n", qindex, err);
> > +
> > + if (!try_fill_recv(vi, rq, GFP_KERNEL))
> > + schedule_delayed_work(&vi->refill, 0);
> > +
> > + virtnet_napi_enable(rq->vq, &rq->napi);
> > + return err;
> > +}
> > +
> > /*
> > * Send command via the control virtqueue and check status. Commands
> > * supported by the hypervisor, as indicated by feature bits, should
>
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v12 38/40] virtio_net: support rx queue resize
2022-07-25 6:38 ` Xuan Zhuo
@ 2022-07-25 6:57 ` Jason Wang
2022-07-25 7:21 ` Xuan Zhuo
0 siblings, 1 reply; 60+ messages in thread
From: Jason Wang @ 2022-07-25 6:57 UTC (permalink / raw)
To: Xuan Zhuo
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm,
open list:XDP (eXpress Data Path),
Kangjie Xu, virtualization
On Mon, Jul 25, 2022 at 2:43 PM Xuan Zhuo <xuanzhuo@linux.alibaba.com> wrote:
>
> On Thu, 21 Jul 2022 17:25:59 +0800, Jason Wang <jasowang@redhat.com> wrote:
> >
> > 在 2022/7/20 11:04, Xuan Zhuo 写道:
> > > This patch implements the resize function of the rx queues.
> > > Based on this function, it is possible to modify the ring num of the
> > > queue.
> > >
> > > Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
> > > ---
> > > drivers/net/virtio_net.c | 22 ++++++++++++++++++++++
> > > 1 file changed, 22 insertions(+)
> > >
> > > diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
> > > index fe4dc43c05a1..1115a8b59a08 100644
> > > --- a/drivers/net/virtio_net.c
> > > +++ b/drivers/net/virtio_net.c
> > > @@ -278,6 +278,8 @@ struct padded_vnet_hdr {
> > > char padding[12];
> > > };
> > >
> > > +static void virtnet_rq_free_unused_buf(struct virtqueue *vq, void *buf);
> > > +
> > > static bool is_xdp_frame(void *ptr)
> > > {
> > > return (unsigned long)ptr & VIRTIO_XDP_FLAG;
> > > @@ -1846,6 +1848,26 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
> > > return NETDEV_TX_OK;
> > > }
> > >
> > > +static int virtnet_rx_resize(struct virtnet_info *vi,
> > > + struct receive_queue *rq, u32 ring_num)
> > > +{
> > > + int err, qindex;
> > > +
> > > + qindex = rq - vi->rq;
> > > +
> > > + napi_disable(&rq->napi);
> >
> >
> > We need to disable refill work as well. So this series might need
> > rebasing on top of
> >
> > https://lore.kernel.org/netdev/20220704074859.16912-1-jasowang@redhat.com/
>
> I understand that your patch is used to solve the situation where dev is
> destoryed but refill work is running.
>
> And is there such a possibility here?
E.g the refill work runs in parallel with this function?
Thanks
> Or is there any other scenario that I'm
> not expecting?
>
> Thanks.
>
>
> >
> > I will send a new version (probably tomorrow).
> >
> > Thanks
> >
> >
> > > +
> > > + err = virtqueue_resize(rq->vq, ring_num, virtnet_rq_free_unused_buf);
> > > + if (err)
> > > + netdev_err(vi->dev, "resize rx fail: rx queue index: %d err: %d\n", qindex, err);
> > > +
> > > + if (!try_fill_recv(vi, rq, GFP_KERNEL))
> > > + schedule_delayed_work(&vi->refill, 0);
> > > +
> > > + virtnet_napi_enable(rq->vq, &rq->napi);
> > > + return err;
> > > +}
> > > +
> > > /*
> > > * Send command via the control virtqueue and check status. Commands
> > > * supported by the hypervisor, as indicated by feature bits, should
> >
>
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v12 38/40] virtio_net: support rx queue resize
2022-07-25 6:57 ` Jason Wang
@ 2022-07-25 7:21 ` Xuan Zhuo
2022-07-25 7:28 ` Jason Wang
0 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-25 7:21 UTC (permalink / raw)
To: Jason Wang
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm,
open list:XDP (eXpress Data Path),
Kangjie Xu, virtualization
On Mon, 25 Jul 2022 14:57:11 +0800, Jason Wang <jasowang@redhat.com> wrote:
> On Mon, Jul 25, 2022 at 2:43 PM Xuan Zhuo <xuanzhuo@linux.alibaba.com> wrote:
> >
> > On Thu, 21 Jul 2022 17:25:59 +0800, Jason Wang <jasowang@redhat.com> wrote:
> > >
> > > 在 2022/7/20 11:04, Xuan Zhuo 写道:
> > > > This patch implements the resize function of the rx queues.
> > > > Based on this function, it is possible to modify the ring num of the
> > > > queue.
> > > >
> > > > Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
> > > > ---
> > > > drivers/net/virtio_net.c | 22 ++++++++++++++++++++++
> > > > 1 file changed, 22 insertions(+)
> > > >
> > > > diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
> > > > index fe4dc43c05a1..1115a8b59a08 100644
> > > > --- a/drivers/net/virtio_net.c
> > > > +++ b/drivers/net/virtio_net.c
> > > > @@ -278,6 +278,8 @@ struct padded_vnet_hdr {
> > > > char padding[12];
> > > > };
> > > >
> > > > +static void virtnet_rq_free_unused_buf(struct virtqueue *vq, void *buf);
> > > > +
> > > > static bool is_xdp_frame(void *ptr)
> > > > {
> > > > return (unsigned long)ptr & VIRTIO_XDP_FLAG;
> > > > @@ -1846,6 +1848,26 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
> > > > return NETDEV_TX_OK;
> > > > }
> > > >
> > > > +static int virtnet_rx_resize(struct virtnet_info *vi,
> > > > + struct receive_queue *rq, u32 ring_num)
> > > > +{
> > > > + int err, qindex;
> > > > +
> > > > + qindex = rq - vi->rq;
> > > > +
> > > > + napi_disable(&rq->napi);
> > >
> > >
> > > We need to disable refill work as well. So this series might need
> > > rebasing on top of
> > >
> > > https://lore.kernel.org/netdev/20220704074859.16912-1-jasowang@redhat.com/
> >
> > I understand that your patch is used to solve the situation where dev is
> > destoryed but refill work is running.
> >
> > And is there such a possibility here?
>
> E.g the refill work runs in parallel with this function?
napi_disable enables lock-like functionality. So I think it's safe.
Thanks.
>
> Thanks
>
> > Or is there any other scenario that I'm
> > not expecting?
> >
> > Thanks.
> >
> >
> > >
> > > I will send a new version (probably tomorrow).
> > >
> > > Thanks
> > >
> > >
> > > > +
> > > > + err = virtqueue_resize(rq->vq, ring_num, virtnet_rq_free_unused_buf);
> > > > + if (err)
> > > > + netdev_err(vi->dev, "resize rx fail: rx queue index: %d err: %d\n", qindex, err);
> > > > +
> > > > + if (!try_fill_recv(vi, rq, GFP_KERNEL))
> > > > + schedule_delayed_work(&vi->refill, 0);
> > > > +
> > > > + virtnet_napi_enable(rq->vq, &rq->napi);
> > > > + return err;
> > > > +}
> > > > +
> > > > /*
> > > > * Send command via the control virtqueue and check status. Commands
> > > > * supported by the hypervisor, as indicated by feature bits, should
> > >
> >
>
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v12 38/40] virtio_net: support rx queue resize
2022-07-25 7:21 ` Xuan Zhuo
@ 2022-07-25 7:28 ` Jason Wang
0 siblings, 0 replies; 60+ messages in thread
From: Jason Wang @ 2022-07-25 7:28 UTC (permalink / raw)
To: Xuan Zhuo
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm,
open list:XDP (eXpress Data Path),
Kangjie Xu, virtualization
On Mon, Jul 25, 2022 at 3:23 PM Xuan Zhuo <xuanzhuo@linux.alibaba.com> wrote:
>
> On Mon, 25 Jul 2022 14:57:11 +0800, Jason Wang <jasowang@redhat.com> wrote:
> > On Mon, Jul 25, 2022 at 2:43 PM Xuan Zhuo <xuanzhuo@linux.alibaba.com> wrote:
> > >
> > > On Thu, 21 Jul 2022 17:25:59 +0800, Jason Wang <jasowang@redhat.com> wrote:
> > > >
> > > > 在 2022/7/20 11:04, Xuan Zhuo 写道:
> > > > > This patch implements the resize function of the rx queues.
> > > > > Based on this function, it is possible to modify the ring num of the
> > > > > queue.
> > > > >
> > > > > Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
> > > > > ---
> > > > > drivers/net/virtio_net.c | 22 ++++++++++++++++++++++
> > > > > 1 file changed, 22 insertions(+)
> > > > >
> > > > > diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
> > > > > index fe4dc43c05a1..1115a8b59a08 100644
> > > > > --- a/drivers/net/virtio_net.c
> > > > > +++ b/drivers/net/virtio_net.c
> > > > > @@ -278,6 +278,8 @@ struct padded_vnet_hdr {
> > > > > char padding[12];
> > > > > };
> > > > >
> > > > > +static void virtnet_rq_free_unused_buf(struct virtqueue *vq, void *buf);
> > > > > +
> > > > > static bool is_xdp_frame(void *ptr)
> > > > > {
> > > > > return (unsigned long)ptr & VIRTIO_XDP_FLAG;
> > > > > @@ -1846,6 +1848,26 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
> > > > > return NETDEV_TX_OK;
> > > > > }
> > > > >
> > > > > +static int virtnet_rx_resize(struct virtnet_info *vi,
> > > > > + struct receive_queue *rq, u32 ring_num)
> > > > > +{
> > > > > + int err, qindex;
> > > > > +
> > > > > + qindex = rq - vi->rq;
> > > > > +
> > > > > + napi_disable(&rq->napi);
> > > >
> > > >
> > > > We need to disable refill work as well. So this series might need
> > > > rebasing on top of
> > > >
> > > > https://lore.kernel.org/netdev/20220704074859.16912-1-jasowang@redhat.com/
> > >
> > > I understand that your patch is used to solve the situation where dev is
> > > destoryed but refill work is running.
> > >
> > > And is there such a possibility here?
> >
> > E.g the refill work runs in parallel with this function?
>
> napi_disable enables lock-like functionality. So I think it's safe.
>
Ok, right, since there will be a napi_enable() soon afterwards.
So
Acked-by: Jason Wang <jasowang@redhat.com>
Thanks
> Thanks.
>
> >
> > Thanks
> >
> > > Or is there any other scenario that I'm
> > > not expecting?
> > >
> > > Thanks.
> > >
> > >
> > > >
> > > > I will send a new version (probably tomorrow).
> > > >
> > > > Thanks
> > > >
> > > >
> > > > > +
> > > > > + err = virtqueue_resize(rq->vq, ring_num, virtnet_rq_free_unused_buf);
> > > > > + if (err)
> > > > > + netdev_err(vi->dev, "resize rx fail: rx queue index: %d err: %d\n", qindex, err);
> > > > > +
> > > > > + if (!try_fill_recv(vi, rq, GFP_KERNEL))
> > > > > + schedule_delayed_work(&vi->refill, 0);
> > > > > +
> > > > > + virtnet_napi_enable(rq->vq, &rq->napi);
> > > > > + return err;
> > > > > +}
> > > > > +
> > > > > /*
> > > > > * Send command via the control virtqueue and check status. Commands
> > > > > * supported by the hypervisor, as indicated by feature bits, should
> > > >
> > >
> >
>
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v12 39/40] virtio_net: support tx queue resize
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (37 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 38/40] virtio_net: support rx queue resize Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
2022-07-21 9:30 ` Jason Wang
2022-07-20 3:04 ` [PATCH v12 40/40] virtio_net: support set_ringparam Xuan Zhuo
39 siblings, 1 reply; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
This patch implements the resize function of the tx queues.
Based on this function, it is possible to modify the ring num of the
queue.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
drivers/net/virtio_net.c | 47 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 47 insertions(+)
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 1115a8b59a08..d1e6940b46d8 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -135,6 +135,9 @@ struct send_queue {
struct virtnet_sq_stats stats;
struct napi_struct napi;
+
+ /* Record whether sq is in reset state. */
+ bool reset;
};
/* Internal representation of a receive virtqueue */
@@ -279,6 +282,7 @@ struct padded_vnet_hdr {
};
static void virtnet_rq_free_unused_buf(struct virtqueue *vq, void *buf);
+static void virtnet_sq_free_unused_buf(struct virtqueue *vq, void *buf);
static bool is_xdp_frame(void *ptr)
{
@@ -1603,6 +1607,11 @@ static void virtnet_poll_cleantx(struct receive_queue *rq)
return;
if (__netif_tx_trylock(txq)) {
+ if (sq->reset) {
+ __netif_tx_unlock(txq);
+ return;
+ }
+
do {
virtqueue_disable_cb(sq->vq);
free_old_xmit_skbs(sq, true);
@@ -1868,6 +1877,44 @@ static int virtnet_rx_resize(struct virtnet_info *vi,
return err;
}
+static int virtnet_tx_resize(struct virtnet_info *vi,
+ struct send_queue *sq, u32 ring_num)
+{
+ struct netdev_queue *txq;
+ int err, qindex;
+
+ qindex = sq - vi->sq;
+
+ virtnet_napi_tx_disable(&sq->napi);
+
+ txq = netdev_get_tx_queue(vi->dev, qindex);
+
+ /* 1. wait all ximt complete
+ * 2. fix the race of netif_stop_subqueue() vs netif_start_subqueue()
+ */
+ __netif_tx_lock_bh(txq);
+
+ /* Prevent rx poll from accessing sq. */
+ sq->reset = true;
+
+ /* Prevent the upper layer from trying to send packets. */
+ netif_stop_subqueue(vi->dev, qindex);
+
+ __netif_tx_unlock_bh(txq);
+
+ err = virtqueue_resize(sq->vq, ring_num, virtnet_sq_free_unused_buf);
+ if (err)
+ netdev_err(vi->dev, "resize tx fail: tx queue index: %d err: %d\n", qindex, err);
+
+ __netif_tx_lock_bh(txq);
+ sq->reset = false;
+ netif_tx_wake_queue(txq);
+ __netif_tx_unlock_bh(txq);
+
+ virtnet_napi_tx_enable(vi, sq->vq, &sq->napi);
+ return err;
+}
+
/*
* Send command via the control virtqueue and check status. Commands
* supported by the hypervisor, as indicated by feature bits, should
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v12 39/40] virtio_net: support tx queue resize
2022-07-20 3:04 ` [PATCH v12 39/40] virtio_net: support tx " Xuan Zhuo
@ 2022-07-21 9:30 ` Jason Wang
0 siblings, 0 replies; 60+ messages in thread
From: Jason Wang @ 2022-07-21 9:30 UTC (permalink / raw)
To: Xuan Zhuo, virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
在 2022/7/20 11:04, Xuan Zhuo 写道:
> This patch implements the resize function of the tx queues.
> Based on this function, it is possible to modify the ring num of the
> queue.
>
> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
> ---
> drivers/net/virtio_net.c | 47 ++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 47 insertions(+)
>
> diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
> index 1115a8b59a08..d1e6940b46d8 100644
> --- a/drivers/net/virtio_net.c
> +++ b/drivers/net/virtio_net.c
> @@ -135,6 +135,9 @@ struct send_queue {
> struct virtnet_sq_stats stats;
>
> struct napi_struct napi;
> +
> + /* Record whether sq is in reset state. */
> + bool reset;
> };
>
> /* Internal representation of a receive virtqueue */
> @@ -279,6 +282,7 @@ struct padded_vnet_hdr {
> };
>
> static void virtnet_rq_free_unused_buf(struct virtqueue *vq, void *buf);
> +static void virtnet_sq_free_unused_buf(struct virtqueue *vq, void *buf);
>
> static bool is_xdp_frame(void *ptr)
> {
> @@ -1603,6 +1607,11 @@ static void virtnet_poll_cleantx(struct receive_queue *rq)
> return;
>
> if (__netif_tx_trylock(txq)) {
> + if (sq->reset) {
> + __netif_tx_unlock(txq);
> + return;
> + }
> +
> do {
> virtqueue_disable_cb(sq->vq);
> free_old_xmit_skbs(sq, true);
> @@ -1868,6 +1877,44 @@ static int virtnet_rx_resize(struct virtnet_info *vi,
> return err;
> }
>
> +static int virtnet_tx_resize(struct virtnet_info *vi,
> + struct send_queue *sq, u32 ring_num)
> +{
> + struct netdev_queue *txq;
> + int err, qindex;
> +
> + qindex = sq - vi->sq;
> +
> + virtnet_napi_tx_disable(&sq->napi);
> +
> + txq = netdev_get_tx_queue(vi->dev, qindex);
> +
> + /* 1. wait all ximt complete
> + * 2. fix the race of netif_stop_subqueue() vs netif_start_subqueue()
> + */
> + __netif_tx_lock_bh(txq);
> +
> + /* Prevent rx poll from accessing sq. */
> + sq->reset = true;
> +
> + /* Prevent the upper layer from trying to send packets. */
> + netif_stop_subqueue(vi->dev, qindex);
> +
> + __netif_tx_unlock_bh(txq);
> +
> + err = virtqueue_resize(sq->vq, ring_num, virtnet_sq_free_unused_buf);
> + if (err)
> + netdev_err(vi->dev, "resize tx fail: tx queue index: %d err: %d\n", qindex, err);
> +
> + __netif_tx_lock_bh(txq);
> + sq->reset = false;
> + netif_tx_wake_queue(txq);
> + __netif_tx_unlock_bh(txq);
> +
> + virtnet_napi_tx_enable(vi, sq->vq, &sq->napi);
> + return err;
> +}
> +
> /*
> * Send command via the control virtqueue and check status. Commands
> * supported by the hypervisor, as indicated by feature bits, should
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v12 40/40] virtio_net: support set_ringparam
2022-07-20 3:03 [PATCH v12 00/40] virtio pci support VIRTIO_F_RING_RESET Xuan Zhuo
` (38 preceding siblings ...)
2022-07-20 3:04 ` [PATCH v12 39/40] virtio_net: support tx " Xuan Zhuo
@ 2022-07-20 3:04 ` Xuan Zhuo
39 siblings, 0 replies; 60+ messages in thread
From: Xuan Zhuo @ 2022-07-20 3:04 UTC (permalink / raw)
To: virtualization
Cc: Richard Weinberger, Anton Ivanov, Johannes Berg,
Michael S. Tsirkin, Jason Wang, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Hans de Goede, Mark Gross,
Vadim Pasternak, Bjorn Andersson, Mathieu Poirier, Cornelia Huck,
Halil Pasic, Eric Farman, Heiko Carstens, Vasily Gorbik,
Alexander Gordeev, Christian Borntraeger, Sven Schnelle,
Alexei Starovoitov, Daniel Borkmann, Jesper Dangaard Brouer,
John Fastabend, Xuan Zhuo, Vincent Whitchurch, linux-um, netdev,
platform-driver-x86, linux-remoteproc, linux-s390, kvm, bpf,
kangjie.xu
Support set_ringparam based on virtio queue reset.
Users can use ethtool -G eth0 <ring_num> to modify the ring size of
virtio-net.
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
---
drivers/net/virtio_net.c | 48 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 48 insertions(+)
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index d1e6940b46d8..59fc48c60403 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -2329,6 +2329,53 @@ static void virtnet_get_ringparam(struct net_device *dev,
ring->tx_pending = virtqueue_get_vring_size(vi->sq[0].vq);
}
+static int virtnet_set_ringparam(struct net_device *dev,
+ struct ethtool_ringparam *ring,
+ struct kernel_ethtool_ringparam *kernel_ring,
+ struct netlink_ext_ack *extack)
+{
+ struct virtnet_info *vi = netdev_priv(dev);
+ u32 rx_pending, tx_pending;
+ struct receive_queue *rq;
+ struct send_queue *sq;
+ int i, err;
+
+ if (ring->rx_mini_pending || ring->rx_jumbo_pending)
+ return -EINVAL;
+
+ rx_pending = virtqueue_get_vring_size(vi->rq[0].vq);
+ tx_pending = virtqueue_get_vring_size(vi->sq[0].vq);
+
+ if (ring->rx_pending == rx_pending &&
+ ring->tx_pending == tx_pending)
+ return 0;
+
+ if (ring->rx_pending > vi->rq[0].vq->num_max)
+ return -EINVAL;
+
+ if (ring->tx_pending > vi->sq[0].vq->num_max)
+ return -EINVAL;
+
+ for (i = 0; i < vi->max_queue_pairs; i++) {
+ rq = vi->rq + i;
+ sq = vi->sq + i;
+
+ if (ring->tx_pending != tx_pending) {
+ err = virtnet_tx_resize(vi, sq, ring->tx_pending);
+ if (err)
+ return err;
+ }
+
+ if (ring->rx_pending != rx_pending) {
+ err = virtnet_rx_resize(vi, rq, ring->rx_pending);
+ if (err)
+ return err;
+ }
+ }
+
+ return 0;
+}
+
static bool virtnet_commit_rss_command(struct virtnet_info *vi)
{
struct net_device *dev = vi->dev;
@@ -2816,6 +2863,7 @@ static const struct ethtool_ops virtnet_ethtool_ops = {
.get_drvinfo = virtnet_get_drvinfo,
.get_link = ethtool_op_get_link,
.get_ringparam = virtnet_get_ringparam,
+ .set_ringparam = virtnet_set_ringparam,
.get_strings = virtnet_get_strings,
.get_sset_count = virtnet_get_sset_count,
.get_ethtool_stats = virtnet_get_ethtool_stats,
--
2.31.0
^ permalink raw reply related [flat|nested] 60+ messages in thread