Packed virtqueue for virtio
PATCH v6 8/9 virtio: add some rcu comments
In reply to Eugenio Pérez--- hw/virtio/virtio.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
hw/virtio/virtio.c +2 -1
@@ -278,6 +278,7 @@ static void vring_packed_flags_write(VirtIODevice *vdev,address_space_cache_invalidate (cache, off,sizeof (flags)); } +/* Called within rcu_read_lock(). */ static VRingMemoryRegionCaches *vring_get_region_caches (struct VirtQueue *vq) {VRingMemoryRegionCaches *caches =atomic_rcu_read (&vq->vring.caches);
@@ -721,7 +722,6 @@ bool virtqueue_rewind(VirtQueue *vq, unsigned int num)return true; } -/* Called within rcu_read_lock(). */ static void virtqueue_split_fill (VirtQueue *vq,const VirtQueueElement *elem,unsigned int len,unsigned int idx) {
@@ -780,6 +780,7 @@ static void virtqueue_packed_fill_desc(VirtQueue *vq,vring_packed_desc_write (vq->vdev, &desc, &caches->desc, head, strict_order); } +/* Called within rcu_read_lock(). */ void virtqueue_fill (VirtQueue *vq,const VirtQueueElement *elem,unsigned int len,unsigned int idx) {
Signature · 1 line
2.16.5
PATCH v6 5/9 virtio: event suppression support for packed ring
In reply to Eugenio PérezFrom: Jason Wang <[email protected]>
This patch implements event suppression through device/driver area. Please refer virtio specification for more information.
--- hw/virtio/virtio.c | 142 +++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 133 insertions(+), 9 deletions(-)
hw/virtio/virtio.c +133 -9
@@ -240,6 +240,44 @@ static void vring_split_desc_read(VirtIODevice *vdev, VRingDesc *desc,virtio_tswap16s (vdev, &desc->next); } +static void vring_packed_event_read (VirtIODevice *vdev, +MemoryRegionCache *cache, +VRingPackedDescEvent *e) +{ +hwaddr off_off = offsetof(VRingPackedDescEvent , off_wrap); +hwaddr off_flags = offsetof(VRingPackedDescEvent , flags); + +address_space_read_cached (cache, off_flags, &e->flags, +sizeof (e->flags)); +/* Make sure flags is seen before off_wrap */ +smp_rmb (); +address_space_read_cached (cache, off_off, &e->off_wrap, +sizeof (e->off_wrap)); +virtio_tswap16s (vdev, &e->off_wrap); +virtio_tswap16s (vdev, &e->flags); +} + +static void vring_packed_off_wrap_write (VirtIODevice *vdev, +MemoryRegionCache *cache, +uint16_t off_wrap) +{ +hwaddr off = offsetof(VRingPackedDescEvent , off_wrap); + +virtio_tswap16s (vdev, &off_wrap); +address_space_write_cached (cache, off, &off_wrap,sizeof (off_wrap)); +address_space_cache_invalidate (cache, off,sizeof (off_wrap)); +} + +static void vring_packed_flags_write (VirtIODevice *vdev, +MemoryRegionCache *cache,uint16_t flags) +{ +hwaddr off = offsetof(VRingPackedDescEvent , flags); + +virtio_tswap16s (vdev, &flags); +address_space_write_cached (cache, off, &flags,sizeof (flags)); +address_space_cache_invalidate (cache, off,sizeof (flags)); +} +static VRingMemoryRegionCaches *vring_get_region_caches (struct VirtQueue *vq) {VRingMemoryRegionCaches *caches =atomic_rcu_read (&vq->vring.caches);
@@ -346,14 +384,8 @@ static inline void vring_set_avail_event(VirtQueue *vq, uint16_t val)address_space_cache_invalidate (&caches->used, pa,sizeof (val)); } -void virtio_queue_set_notification (VirtQueue *vq,int enable) +static void virtio_queue_split_set_notification (VirtQueue *vq,int enable) { - vq->notification = enable; - -if (!vq->vring.desc) { -return ; - } -rcu_read_lock ();if (virtio_vdev_has_feature (vq->vdev,VIRTIO_RING_F_EVENT_IDX )) {vring_set_avail_event (vq,vring_avail_idx (vq));
@@ -369,6 +401,51 @@ void virtio_queue_set_notification(VirtQueue *vq, int enable)rcu_read_unlock (); } +static void virtio_queue_packed_set_notification (VirtQueue *vq,int enable) +{ +uint16_t off_wrap; +VRingPackedDescEvent e; +VRingMemoryRegionCaches *caches; + +rcu_read_lock (); + caches =vring_get_region_caches (vq); +vring_packed_event_read (vq->vdev, &caches->used, &e); + +if (!enable) { + e.flags =VRING_PACKED_EVENT_FLAG_DISABLE ; + }else if (virtio_vdev_has_feature (vq->vdev,VIRTIO_RING_F_EVENT_IDX )) { + off_wrap = vq->shadow_avail_idx | vq->shadow_avail_wrap_counter <<15 ; +vring_packed_off_wrap_write (vq->vdev, &caches->used, off_wrap); +/* Make sure off_wrap is wrote before flags */ +smp_wmb (); + e.flags =VRING_PACKED_EVENT_FLAG_DESC ; + }else { + e.flags =VRING_PACKED_EVENT_FLAG_ENABLE ; + } + +vring_packed_flags_write (vq->vdev, &caches->used, e.flags); +if (enable) { +/* Expose avail event/used flags before caller checks the avail idx. */ +smp_mb (); + } +rcu_read_unlock (); +} + +void virtio_queue_set_notification (VirtQueue *vq,int enable) +{ + vq->notification = enable; + +if (!vq->vring.desc) { +return ; + } + +if (virtio_vdev_has_feature (vq->vdev,VIRTIO_F_RING_PACKED )) { +virtio_queue_packed_set_notification (vq, enable); + }else { +virtio_queue_split_set_notification (vq, enable); + } +} +int virtio_queue_ready (VirtQueue *vq) {return vq->vring.avail !=0 ;
@@ -2290,8 +2367,7 @@ static void virtio_set_isr(VirtIODevice *vdev, int value) } } -/* Called within rcu_read_lock(). */ -static bool virtio_should_notify (VirtIODevice *vdev,VirtQueue *vq) +static bool virtio_split_should_notify (VirtIODevice *vdev,VirtQueue *vq) {uint16_t old, new;bool v;
@@ -2314,6 +2390,54 @@ static bool virtio_should_notify(VirtIODevice *vdev, VirtQueue *vq)return !v ||vring_need_event (vring_get_used_event (vq), new, old); } +static bool vring_packed_need_event (VirtQueue *vq,bool wrap, +uint16_t off_wrap,uint16_t new, +uint16_t old) +{ +int off = off_wrap & ~(1 <<15 ); + +if (wrap != off_wrap >>15 ) { + off -= vq->vring.num; + } + +return vring_need_event (off, new, old); +} + +static bool virtio_packed_should_notify (VirtIODevice *vdev,VirtQueue *vq) +{ +VRingPackedDescEvent e; +uint16_t old, new; +bool v; +VRingMemoryRegionCaches *caches; + + caches =vring_get_region_caches (vq); +vring_packed_event_read (vdev, &caches->avail, &e); + + old = vq->signalled_used; + new = vq->signalled_used = vq->used_idx; + v = vq->signalled_used_valid; + vq->signalled_used_valid = true; + +if (e.flags ==VRING_PACKED_EVENT_FLAG_DISABLE ) { +return false; + }else if (e.flags ==VRING_PACKED_EVENT_FLAG_ENABLE ) { +return true; + } + +return !v ||vring_packed_need_event (vq, vq->used_wrap_counter, + e.off_wrap, new, old); +} + +/* Called within rcu_read_lock(). */ +static bool virtio_should_notify (VirtIODevice *vdev,VirtQueue *vq) +{ +if (virtio_vdev_has_feature (vdev,VIRTIO_F_RING_PACKED )) { +return virtio_packed_should_notify (vdev, vq); + }else { +return virtio_split_should_notify (vdev, vq); + } +} +void virtio_notify_irqfd (VirtIODevice *vdev,VirtQueue *vq) {bool should_notify;
Signature · 1 line
2.16.5
PATCH v6 6/9 vhost_net: enable packed ring support
In reply to Eugenio PérezFrom: Jason Wang <[email protected]>
--- hw/net/vhost_net.c | 2 ++ 1 file changed, 2 insertions(+)
hw/net/vhost_net.c +2 -0
@@ -49,6 +49,7 @@ static const int kernel_feature_bits[] = {VIRTIO_F_VERSION_1 ,VIRTIO_NET_F_MTU ,VIRTIO_F_IOMMU_PLATFORM , +VIRTIO_F_RING_PACKED , VHOST_INVALID_FEATURE_BIT };
@@ -74,6 +75,7 @@ static const int user_feature_bits[] = {VIRTIO_NET_F_MRG_RXBUF ,VIRTIO_NET_F_MTU ,VIRTIO_F_IOMMU_PLATFORM , +VIRTIO_F_RING_PACKED ,/* This bit implies RARP isn't sent by QEMU out of band */ VIRTIO_NET_F_GUEST_ANNOUNCE,
Signature · 1 line
2.16.5
PATCH v6 9/9 virtio: Move vdev->broken check to dispatch drop_all
In reply to Eugenio PérezPrevious commits did the same with others virtqueue_ functions, but this check was repeated in the split and the packed version.
--- hw/virtio/virtio.c | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)
hw/virtio/virtio.c +4 -8
@@ -1631,10 +1631,6 @@ static unsigned int virtqueue_packed_drop_all(VirtQueue *vq)VirtIODevice *vdev = vq->vdev;VRingPackedDesc desc; -if (unlikely (vdev->broken)) { -return 0 ; - } - caches =vring_get_region_caches (vq); desc_cache = &caches->desc;
@@ -1680,10 +1676,6 @@ static unsigned int virtqueue_split_drop_all(VirtQueue *vq)VirtIODevice *vdev = vq->vdev;bool fEventIdx =virtio_vdev_has_feature (vdev,VIRTIO_RING_F_EVENT_IDX ); -if (unlikely (vdev->broken)) { -return 0 ; - } -while (!virtio_queue_empty (vq) && vq->inuse < vq->vring.num) {/* works similar to virtqueue_pop but does not map buffers * and does not allocate any memory */
@@ -1715,6 +1707,10 @@ unsigned int virtqueue_drop_all(VirtQueue *vq) {struct VirtIODevice *vdev = vq->vdev; +if (unlikely (vdev->broken)) { +return 0 ; + } +if (virtio_vdev_has_feature (vdev,VIRTIO_F_RING_PACKED )) {return virtqueue_packed_drop_all (vq); }else {
Signature · 1 line
2.16.5
v6 cover Packed virtqueue for virtio
Hi:
This is an updated version of packed virtqueue support based on Wei and Jason's V5, mainly solving the clang leak detector error CI gave.
Please review.
Changes from V5:
- Fix qemu's CI asan error.
- Move/copy rcu comments.
- Merge duplicated vdev->broken check between split and packet version.
Eugenio Pérez (3):
virtio: Free rng and blk virqueues
virtio: add some rcu comments
virtio: Move vdev->broken check to dispatch drop_all
Jason Wang (4):
virtio: basic packed virtqueue support
virtio: event suppression support for packed ring
vhost_net: enable packed ring support
virtio: add property to enable packed virtqueue
Wei Xu (2):
virtio: basic structure for packed ring
virtio: device/driverr area size calculation refactor for split ring
hw/block/virtio-blk.c | 7 +- hw/char/virtio-serial-bus.c | 2 +- hw/net/vhost_net.c | 2 + hw/scsi/virtio-scsi.c | 3 +- hw/virtio/virtio-rng.c | 1 + hw/virtio/virtio.c | 1154 ++++++++++++++++++++++++++++++++++++++----- include/hw/virtio/virtio.h | 14 +- 7 files changed, 1045 insertions(+), 138 deletions(-)
Signature · 1 line
2.16.5
PATCH v6 1/9 virtio: basic structure for packed ring
From: Wei Xu <[email protected]>
Define packed ring structure according to Qemu nomenclature, field data(wrap counter, etc) are also included.
--- hw/virtio/virtio.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
hw/virtio/virtio.c +15 -0
@@ -43,6 +43,13 @@ typedef struct VRingDescuint16_t next; } VRingDesc; +typedef struct VRingPackedDesc { +uint64_t addr; +uint32_t len; +uint16_t id; +uint16_t flags; +}VRingPackedDesc ; + typedef struct VRingAvail { uint16_t flags;
@@ -81,17 +88,25 @@ typedef struct VRingVRingMemoryRegionCaches *caches; } VRing; +typedef struct VRingPackedDescEvent { +uint16_t off_wrap; +uint16_t flags; +}VRingPackedDescEvent ; +struct VirtQueue {VRing vring;/* Next head to pop */ uint16_t last_avail_idx; +bool last_avail_wrap_counter;/* Last avail_idx read from VQ. */ uint16_t shadow_avail_idx; +bool shadow_avail_wrap_counter;uint16_t used_idx; +bool used_wrap_counter;/* Last used index value we have signalled on */ uint16_t signalled_used;
Signature · 1 line
2.16.5
PATCH v6 2/9 virtio: device/driver area size calculation refactor for split ring
In reply to Eugenio PérezFrom: Wei Xu <[email protected]>
There is slight size difference between split/packed rings.
This is the refactor of split ring as well as a helper to expanding device and driver area size calculation for packed ring.
--- hw/virtio/virtio.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-)
hw/virtio/virtio.c +10 -6
@@ -159,10 +159,8 @@ static void virtio_init_region_cache(VirtIODevice *vdev, int n)VRingMemoryRegionCaches *old = vq->vring.caches;VRingMemoryRegionCaches *new =NULL ;hwaddr addr, size; -int event_size;int64_t len; - event_size =virtio_vdev_has_feature (vq->vdev,VIRTIO_RING_F_EVENT_IDX ) ?2 :0 ; addr = vq->vring.desc;if (!addr) {
@@ -177,7 +175,7 @@ static void virtio_init_region_cache(VirtIODevice *vdev, int n) goto err_desc; } - size =virtio_queue_get_used_size (vdev, n) + event_size; + size =virtio_queue_get_used_size (vdev, n); len =address_space_cache_init (&new->used, vdev->dma_as, vq->vring.used, size, true);if (len < size) {
@@ -185,7 +183,7 @@ static void virtio_init_region_cache(VirtIODevice *vdev, int n) goto err_used; } - size =virtio_queue_get_avail_size (vdev, n) + event_size; + size =virtio_queue_get_avail_size (vdev, n); len =address_space_cache_init (&new->avail, vdev->dma_as, vq->vring.avail, size, false);if (len < size) {
@@ -2414,14 +2412,20 @@ hwaddr virtio_queue_get_desc_size(VirtIODevice *vdev, int n)hwaddr virtio_queue_get_avail_size (VirtIODevice *vdev,int n) { +int s; + + s =virtio_vdev_has_feature (vdev,VIRTIO_RING_F_EVENT_IDX ) ?2 :0 ;return offsetof(VRingAvail , ring) + -sizeof (uint16_t ) * vdev->vq[n].vring.num; +sizeof (uint16_t ) * vdev->vq[n].vring.num + s; }hwaddr virtio_queue_get_used_size (VirtIODevice *vdev,int n) { +int s; + + s =virtio_vdev_has_feature (vdev,VIRTIO_RING_F_EVENT_IDX ) ?2 :0 ;return offsetof(VRingUsed , ring) + -sizeof (VRingUsedElem) * vdev->vq[n].vring.num; +sizeof (VRingUsedElem) * vdev->vq[n].vring.num + s; }uint16_t virtio_queue_get_last_avail_idx (VirtIODevice *vdev,int n)
Signature · 1 line
2.16.5
PATCH v6 3/9 virtio: Free rng and blk virqueues
In reply to Eugenio PérezThe function virtio_del_queue was not called at these devices unrealize() callbacks.
This was detected due to add an allocated element on the next commit (used_elems) and running address sanitizer memory leak detector.
--- hw/block/virtio-blk.c | 5 +++++ hw/virtio/virtio-rng.c | 1 + 2 files changed, 6 insertions(+)
hw/block/virtio-blk.c +5 -0
@@ -1206,9 +1206,14 @@ static void virtio_blk_device_unrealize(DeviceState *dev, Error **errp) {VirtIODevice *vdev =VIRTIO_DEVICE (dev);VirtIOBlock *s =VIRTIO_BLK (dev); +VirtIOBlkConf *conf = &s->conf; +unsigned i;virtio_blk_data_plane_destroy (s->dataplane); s->dataplane =NULL ; +for (i =0 ; i < conf->num_queues; i++) { +virtio_del_queue (vdev, i); + }qemu_del_vm_change_state_handler (s->change);blockdev_mark_auto_del (s->blk);virtio_cleanup (vdev);
hw/virtio/virtio-rng.c +1 -0
@@ -238,6 +238,7 @@ static void virtio_rng_device_unrealize(DeviceState *dev, Error **errp)qemu_del_vm_change_state_handler (vrng->vmstate);timer_del (vrng->rate_limit_timer);timer_free (vrng->rate_limit_timer); +virtio_del_queue (vdev,0 );virtio_cleanup (vdev); }
Signature · 1 line
2.16.5
PATCH v6 4/9 virtio: basic packed virtqueue support
In reply to Eugenio PérezFrom: Jason Wang <[email protected]>
This patch implements basic support for the packed virtqueue. Compare the split virtqueue which has three rings, packed virtqueue only have one which is supposed to have better cache utilization and more hardware friendly.
Please refer virtio specification for more information.
--- hw/block/virtio-blk.c | 2 +- hw/char/virtio-serial-bus.c | 2 +- hw/scsi/virtio-scsi.c | 3 +- hw/virtio/virtio.c | 900 ++++++++++++++++++++++++++++++++++++++++---- include/hw/virtio/virtio.h | 10 +- 5 files changed, 837 insertions(+), 80 deletions(-)
hw/block/virtio-blk.c +1 -1
@@ -1052,7 +1052,7 @@ static void virtio_blk_save_device(VirtIODevice *vdev, QEMUFile *f)qemu_put_be32 (f,virtio_get_queue_index (req->vq)); } -qemu_put_virtqueue_element (f, &req->elem); +qemu_put_virtqueue_element (vdev, f, &req->elem); req = req->next; }qemu_put_sbyte (f,0 );
hw/char/virtio-serial-bus.c +1 -1
@@ -708,7 +708,7 @@ static void virtio_serial_save_device(VirtIODevice *vdev, QEMUFile *f)if (elem_popped) {qemu_put_be32s (f, &port->iov_idx);qemu_put_be64s (f, &port->iov_offset); -qemu_put_virtqueue_element (f, port->elem); +qemu_put_virtqueue_element (vdev, f, port->elem); } } }
hw/scsi/virtio-scsi.c +2 -1
@@ -190,11 +190,12 @@ static void virtio_scsi_save_request(QEMUFile *f, SCSIRequest *sreq) {VirtIOSCSIReq *req = sreq->hba_private;VirtIOSCSICommon *vs =VIRTIO_SCSI_COMMON (req->dev); +VirtIODevice *vdev =VIRTIO_DEVICE (req->dev);uint32_t n =virtio_get_queue_index (req->vq) -2 ;assert (n < vs->conf.num_queues);qemu_put_be32s (f, &n); -qemu_put_virtqueue_element (f, &req->elem); +qemu_put_virtqueue_element (vdev, f, &req->elem); }static void *virtio_scsi_load_request (QEMUFile *f,SCSIRequest *sreq)
hw/virtio/virtio.c +826 -74
1,193 lines not on this page · raw message
include/hw/virtio/virtio.h +7 -3
@@ -59,6 +59,8 @@ typedef struct VirtQueue VirtQueue; typedef struct VirtQueueElement { unsigned int index; + unsigned int len; + unsigned int ndescs; unsigned int out_num; unsigned int in_num; hwaddr *in_addr;
@@ -196,7 +198,8 @@ void virtqueue_map(VirtIODevice *vdev, VirtQueueElement *elem);void *virtqueue_pop (VirtQueue *vq,size_t sz);unsigned int virtqueue_drop_all (VirtQueue *vq);void *qemu_get_virtqueue_element (VirtIODevice *vdev,QEMUFile *f,size_t sz); -void qemu_put_virtqueue_element (QEMUFile *f,VirtQueueElement *elem); +void qemu_put_virtqueue_element (VirtIODevice *vdev,QEMUFile *f, +VirtQueueElement *elem);int virtqueue_avail_bytes (VirtQueue *vq,unsigned int in_bytes,unsigned int out_bytes); void virtqueue_get_avail_bytes(VirtQueue *vq, unsigned int *in_bytes,
@@ -291,8 +294,9 @@ hwaddr virtio_queue_get_used_addr(VirtIODevice *vdev, int n);hwaddr virtio_queue_get_desc_size (VirtIODevice *vdev,int n);hwaddr virtio_queue_get_avail_size (VirtIODevice *vdev,int n);hwaddr virtio_queue_get_used_size (VirtIODevice *vdev,int n); -uint16_t virtio_queue_get_last_avail_idx (VirtIODevice *vdev,int n); -void virtio_queue_set_last_avail_idx (VirtIODevice *vdev,int n,uint16_t idx); +unsigned int virtio_queue_get_last_avail_idx (VirtIODevice *vdev,int n); +void virtio_queue_set_last_avail_idx (VirtIODevice *vdev,int n, +unsigned int idx);void virtio_queue_restore_last_avail_idx (VirtIODevice *vdev,int n);void virtio_queue_invalidate_signalled_used (VirtIODevice *vdev,int n);void virtio_queue_update_used_idx (VirtIODevice *vdev,int n);
Signature · 1 line
2.16.5
PATCH v6 7/9 virtio: add property to enable packed virtqueue
In reply to Eugenio PérezFrom: Jason Wang <[email protected]>
--- include/hw/virtio/virtio.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
include/hw/virtio/virtio.h +3 -1
@@ -285,7 +285,9 @@ typedef struct VirtIORNGConf VirtIORNGConf;DEFINE_PROP_BIT64 ("any_layout" , _state, _field, \VIRTIO_F_ANY_LAYOUT , true), \DEFINE_PROP_BIT64 ("iommu_platform" , _state, _field, \ - VIRTIO_F_IOMMU_PLATFORM, false) +VIRTIO_F_IOMMU_PLATFORM , false), \ +DEFINE_PROP_BIT64 ("packed" , _state, _field, \ + VIRTIO_F_RING_PACKED, false)hwaddr virtio_queue_get_desc_addr (VirtIODevice *vdev,int n);bool virtio_queue_enabled (VirtIODevice *vdev,int n);
Signature · 1 line
2.16.5
Quoted 23 lines · Eugenio Pérez
Hi:
This is an updated version of packed virtqueue support based on Wei and Jason's V5, mainly solving the clang leak detector error CI gave.
Please review.
Changes from V5:
- Fix qemu's CI asan error.
- Move/copy rcu comments.
- Merge duplicatedvdev->brokencheck between split and packet version.Eugenio Pérez (3):
virtio: Free rng and blk virqueues
virtio: add some rcu comments
virtio: Movevdev->brokencheck to dispatchdrop_allJason Wang (4):
virtio: basic packed virtqueue support
virtio: event suppression support for packed ring
vhost_net: enable packed ring support
virtio: add property to enable packed virtqueue
Quoted 3 lines
Wei Xu (2):
virtio: basic structure for packed ring
virtio: device/driverr area size calculation refactor for split ring
Looks good to me.
Just two nits:
I tend to squash patch 8 and patch 9 into the patch that introduces those issues and split patch 3 into two parts.
Btw, if you wish you can add your s-o-b to the series.
Do you want to post a new version or I can tweak them by myself?
Thanks
Quoted 10 lines
hw/block/virtio-blk.c | 7 +- hw/char/virtio-serial-bus.c | 2 +- hw/net/vhost_net.c | 2 + hw/scsi/virtio-scsi.c | 3 +- hw/virtio/virtio-rng.c | 1 + hw/virtio/virtio.c | 1154 ++++++++++++++++++++++++++++++++++++++----- include/hw/virtio/virtio.h | 14 +- 7 files changed, 1045 insertions(+), 138 deletions(-)
Hi Jason!
I can post a new version. You will have it in a moment.
Thanks!
Quoted 55 lines · Jason Wang
Quoted 23 lines · Eugenio Pérez
Hi:
This is an updated version of packed virtqueue support based on Wei and Jason's V5, mainly solving the clang leak detector error CI gave.
Please review.
Changes from V5:
- Fix qemu's CI asan error.
- Move/copy rcu comments.
- Merge duplicatedvdev->brokencheck between split and packet version.Eugenio Pérez (3):
virtio: Free rng and blk virqueues
virtio: add some rcu comments
virtio: Movevdev->brokencheck to dispatchdrop_allJason Wang (4):
virtio: basic packed virtqueue support
virtio: event suppression support for packed ring
vhost_net: enable packed ring support
virtio: add property to enable packed virtqueueQuoted 3 lines
Wei Xu (2):
virtio: basic structure for packed ring
virtio: device/driverr area size calculation refactor for split ringLooks good to me.
Just two nits:
I tend to squash patch 8 and patch 9 into the patch that introduces those issues and split patch 3 into two parts.
Btw, if you wish you can add your s-o-b to the series.
Do you want to post a new version or I can tweak them by myself?
Thanks
Quoted 10 lines
hw/block/virtio-blk.c | 7 +- hw/char/virtio-serial-bus.c | 2 +- hw/net/vhost_net.c | 2 + hw/scsi/virtio-scsi.c | 3 +- hw/virtio/virtio-rng.c | 1 + hw/virtio/virtio.c | 1154 ++++++++++++++++++++++++++++++++++++++----- include/hw/virtio/virtio.h | 14 +- 7 files changed, 1045 insertions(+), 138 deletions(-)