| Message ID | 20220406034346.74409-19-xuanzhuo@linux.alibaba.com (mailing list archive) |
|---|---|
| State | Not Applicable |
| Headers | show |
| Series | virtio pci support VIRTIO_F_RING_RESET (refactor vring) | expand |
| Context | Check | Description |
|---|---|---|
| netdev/tree_selection | success | Guessing tree name failed - patch did not apply |
在 2022/4/6 上午11:43, 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> > --- > 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 06f66b15c86c..6250e19fc5bf 100644 > --- a/drivers/virtio/virtio_ring.c > +++ b/drivers/virtio/virtio_ring.c > @@ -2554,6 +2554,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. Should we document that the virtqueue is kept unchanged (still available) on (specific) failure? > + */ > +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; > + bool packed; > + void *buf; > + int err; > + > + if (!vq->we_own_ring) > + return -EINVAL; > + > + if (num > vq->vq.num_max) > + return -E2BIG; > + > + if (!num) > + return -EINVAL; > + > + packed = virtio_has_feature(vdev, VIRTIO_F_RING_PACKED) ? true : false; > + > + if ((packed ? vq->packed.vring.num : vq->split.vring.num) == num) > + return 0; > + > + if (!vdev->config->reset_vq) > + return -ENOENT; > + > + if (!vdev->config->enable_reset_vq) > + return -ENOENT; > + > + err = vdev->config->reset_vq(_vq); > + if (err) > + return err; > + > + while ((buf = virtqueue_detach_unused_buf(_vq)) != NULL) > + recycle(_vq, buf); > + > + if (packed) { > + err = virtqueue_resize_packed(_vq, num); > + if (err) > + virtqueue_reinit_packed(vq); Calling reinit here seems a little bit odd, it looks more like a reset of the virtqueue. Consider we may re-use virtqueue reset for more purpose, I wonder if we need a helper like: virtqueue_resize() { vdev->config->reset_vq(_vq); if (packed) virtqueue_reinit_packed(_vq) else virtqueue_reinit_split(_vq) } Thanks > + } else { > + err = virtqueue_resize_split(_vq, num); > + if (err) > + virtqueue_reinit_split(vq); > + } > + > + if (vdev->config->enable_reset_vq(_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 d59adc4be068..c86ff02e0ca0 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
On Tue, 12 Apr 2022 14:41:18 +0800, Jason Wang <jasowang@redhat.com> wrote: > > 在 2022/4/6 上午11:43, 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> > > --- > > 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 06f66b15c86c..6250e19fc5bf 100644 > > --- a/drivers/virtio/virtio_ring.c > > +++ b/drivers/virtio/virtio_ring.c > > @@ -2554,6 +2554,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. > > > Should we document that the virtqueue is kept unchanged (still > available) on (specific) failure? > OK. > > > + */ > > +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; > > + bool packed; > > + void *buf; > > + int err; > > + > > + if (!vq->we_own_ring) > > + return -EINVAL; > > + > > + if (num > vq->vq.num_max) > > + return -E2BIG; > > + > > + if (!num) > > + return -EINVAL; > > + > > + packed = virtio_has_feature(vdev, VIRTIO_F_RING_PACKED) ? true : false; > > + > > + if ((packed ? vq->packed.vring.num : vq->split.vring.num) == num) > > + return 0; > > + > > + if (!vdev->config->reset_vq) > > + return -ENOENT; > > + > > + if (!vdev->config->enable_reset_vq) > > + return -ENOENT; > > + > > + err = vdev->config->reset_vq(_vq); > > + if (err) > > + return err; > > + > > + while ((buf = virtqueue_detach_unused_buf(_vq)) != NULL) > > + recycle(_vq, buf); > > + > > + if (packed) { > > + err = virtqueue_resize_packed(_vq, num); > > + if (err) > > + virtqueue_reinit_packed(vq); > > > Calling reinit here seems a little bit odd, it looks more like a reset > of the virtqueue. Consider we may re-use virtqueue reset for more > purpose, I wonder if we need a helper like: > > virtqueue_resize() { > vdev->config->reset_vq(_vq); > if (packed) > virtqueue_reinit_packed(_vq) > else > virtqueue_reinit_split(_vq) > } Yes, currently we are implementing resize. This is used to implement set_ringparam() Later, when we implement virtio_net + AF_XDP, what we want is reset not resize, so we need to implement a helper: virtqueue_reset() { vdev->config->reset_vq(_vq); if (packed) virtqueue_reinit_packed(_vq) else virtqueue_reinit_split(_vq) } So I use virtqueue_reinit_* as a separate function not only to deal with the case of resize failure, but also to consider the subsequent implementation of virtqueue_reset() Thanks. > > Thanks > > > > + } else { > > + err = virtqueue_resize_split(_vq, num); > > + if (err) > > + virtqueue_reinit_split(vq); > > + } > > + > > + if (vdev->config->enable_reset_vq(_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 d59adc4be068..c86ff02e0ca0 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 >
On Tue, 12 Apr 2022 14:41:18 +0800, Jason Wang <jasowang@redhat.com> wrote: > > 在 2022/4/6 上午11:43, 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> > > --- > > 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 06f66b15c86c..6250e19fc5bf 100644 > > --- a/drivers/virtio/virtio_ring.c > > +++ b/drivers/virtio/virtio_ring.c > > @@ -2554,6 +2554,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. > > > Should we document that the virtqueue is kept unchanged (still > available) on (specific) failure? > > > > + */ > > +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; > > + bool packed; > > + void *buf; > > + int err; > > + > > + if (!vq->we_own_ring) > > + return -EINVAL; > > + > > + if (num > vq->vq.num_max) > > + return -E2BIG; > > + > > + if (!num) > > + return -EINVAL; > > + > > + packed = virtio_has_feature(vdev, VIRTIO_F_RING_PACKED) ? true : false; > > + > > + if ((packed ? vq->packed.vring.num : vq->split.vring.num) == num) > > + return 0; > > + > > + if (!vdev->config->reset_vq) > > + return -ENOENT; > > + > > + if (!vdev->config->enable_reset_vq) > > + return -ENOENT; > > + > > + err = vdev->config->reset_vq(_vq); > > + if (err) > > + return err; > > + > > + while ((buf = virtqueue_detach_unused_buf(_vq)) != NULL) > > + recycle(_vq, buf); > > + > > + if (packed) { > > + err = virtqueue_resize_packed(_vq, num); > > + if (err) > > + virtqueue_reinit_packed(vq); > > > Calling reinit here seems a little bit odd, it looks more like a reset I also feel that this is a bit odd, I will put virtqueue_reinit_* into virtqueue_resize_*. Thanks. > of the virtqueue. Consider we may re-use virtqueue reset for more > purpose, I wonder if we need a helper like: > > virtqueue_resize() { > vdev->config->reset_vq(_vq); > if (packed) > virtqueue_reinit_packed(_vq) > else > virtqueue_reinit_split(_vq) > } > > Thanks > > > > + } else { > > + err = virtqueue_resize_split(_vq, num); > > + if (err) > > + virtqueue_reinit_split(vq); > > + } > > + > > + if (vdev->config->enable_reset_vq(_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 d59adc4be068..c86ff02e0ca0 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 >
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c index 06f66b15c86c..6250e19fc5bf 100644 --- a/drivers/virtio/virtio_ring.c +++ b/drivers/virtio/virtio_ring.c @@ -2554,6 +2554,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. + */ +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; + bool packed; + void *buf; + int err; + + if (!vq->we_own_ring) + return -EINVAL; + + if (num > vq->vq.num_max) + return -E2BIG; + + if (!num) + return -EINVAL; + + packed = virtio_has_feature(vdev, VIRTIO_F_RING_PACKED) ? true : false; + + if ((packed ? vq->packed.vring.num : vq->split.vring.num) == num) + return 0; + + if (!vdev->config->reset_vq) + return -ENOENT; + + if (!vdev->config->enable_reset_vq) + return -ENOENT; + + err = vdev->config->reset_vq(_vq); + if (err) + return err; + + while ((buf = virtqueue_detach_unused_buf(_vq)) != NULL) + recycle(_vq, buf); + + if (packed) { + err = virtqueue_resize_packed(_vq, num); + if (err) + virtqueue_reinit_packed(vq); + } else { + err = virtqueue_resize_split(_vq, num); + if (err) + virtqueue_reinit_split(vq); + } + + if (vdev->config->enable_reset_vq(_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 d59adc4be068..c86ff02e0ca0 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
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(+)