Skip to contentSkip to conversation

Virtio fixes

PATCH Applied Tiwei Bie 3 participants 14 messages Jan 22, 2019 – Jan 23, 2019 Network drivers

lore
Share & tools
lore

Tiwei Bie

author
#0 lore raw

cover Virtio fixes

Tiwei Bie (4):
net/virtio: fix the control vq support net/virtio-user: fix the control vq support net/virtio: use virtio barrier in packed ring net/virtio-user: fix used ring update in cvq handling

 drivers/net/virtio/virtio_ethdev.c            | 73 ++++++++++---------
 drivers/net/virtio/virtio_rxtx.c              |  4 +-
 .../net/virtio/virtio_user/virtio_user_dev.c  | 39 +++++-----
 drivers/net/virtio/virtio_user_ethdev.c       |  7 +-
 drivers/net/virtio/virtqueue.h                | 12 +--
 5 files changed, 68 insertions(+), 67 deletions(-)
Signature · 1 line
2.17.1
author
#1 lore raw

PATCH 1/4 net/virtio: fix the control vq support

This patch mainly fixed below issues in the packed ring based control vq support in virtio driver:

1. When parsing the used descriptors, we have to track the number of descs that we need to skip;
2. vq->vq_free_cnt was decreased twice for a same desc;

Meanwhile, make the function name consistent with other parts.

Fixes ec194c2f1895 ("net/virtio: support packed queue in send command")
Fixes a4270ea4ff79 ("net/virtio: check head desc with correct wrap counter")
---
 drivers/net/virtio/virtio_ethdev.c | 62 ++++++++++++++----------------
 drivers/net/virtio/virtqueue.h     | 12 +-----
 2 files changed, 31 insertions(+), 43 deletions(-)
drivers/net/virtio/virtio_ethdev.c +29 -33
index ee5a98b7c..a3fe65599 100644
@@ -142,16 +142,17 @@ static const struct rte_virtio_xstats_name_off rte_virtio_txq_stat_strings[] = {
 struct virtio_hw_internal virtio_hw_internal[RTE_MAX_ETHPORTS];
 
 static struct virtio_pmd_ctrl *
-virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
-		       int *dlen, int pkt_num)
+virtio_send_command_packed(struct virtnet_ctl *cvq,
+			   struct virtio_pmd_ctrl *ctrl,
+			   int *dlen, int pkt_num)
 {
 	struct virtqueue *vq = cvq->vq;
 	int head;
 	struct vring_packed_desc *desc = vq->ring_packed.desc_packed;
 	struct virtio_pmd_ctrl *result;
-	bool avail_wrap_counter, used_wrap_counter;
-	uint16_t flags;
+	bool avail_wrap_counter;
 	int sum = 0;
+	int nb_descs = 0;
 	int k;
 
 	/*
@@ -162,11 +163,10 @@ virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
 	 */
 	head = vq->vq_avail_idx;
 	avail_wrap_counter = vq->avail_wrap_counter;
-	used_wrap_counter = vq->used_wrap_counter;
-	desc[head].flags = VRING_DESC_F_NEXT;
 	desc[head].addr = cvq->virtio_net_hdr_mem;
 	desc[head].len = sizeof(struct virtio_net_ctrl_hdr);
 	vq->vq_free_cnt--;
+	nb_descs++;
 	if (++vq->vq_avail_idx >= vq->vq_nentries) {
 		vq->vq_avail_idx -= vq->vq_nentries;
 		vq->avail_wrap_counter ^= 1;
@@ -177,55 +177,51 @@ virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
 			+ sizeof(struct virtio_net_ctrl_hdr)
 			+ sizeof(ctrl->status) + sizeof(uint8_t) * sum;
 		desc[vq->vq_avail_idx].len = dlen[k];
-		flags = VRING_DESC_F_NEXT;
+		desc[vq->vq_avail_idx].flags = VRING_DESC_F_NEXT |
+			VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
+			VRING_DESC_F_USED(!vq->avail_wrap_counter);
 		sum += dlen[k];
 		vq->vq_free_cnt--;
-		flags |= VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
-			 VRING_DESC_F_USED(!vq->avail_wrap_counter);
-		desc[vq->vq_avail_idx].flags = flags;
-		rte_smp_wmb();
-		vq->vq_free_cnt--;
+		nb_descs++;
 		if (++vq->vq_avail_idx >= vq->vq_nentries) {
 			vq->vq_avail_idx -= vq->vq_nentries;
 			vq->avail_wrap_counter ^= 1;
 		}
 	}
 
-
 	desc[vq->vq_avail_idx].addr = cvq->virtio_net_hdr_mem
 		+ sizeof(struct virtio_net_ctrl_hdr);
 	desc[vq->vq_avail_idx].len = sizeof(ctrl->status);
-	flags = VRING_DESC_F_WRITE;
-	flags |= VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
-		 VRING_DESC_F_USED(!vq->avail_wrap_counter);
-	desc[vq->vq_avail_idx].flags = flags;
-	flags = VRING_DESC_F_NEXT;
-	flags |= VRING_DESC_F_AVAIL(avail_wrap_counter) |
-		 VRING_DESC_F_USED(!avail_wrap_counter);
-	desc[head].flags = flags;
-	rte_smp_wmb();
-
+	desc[vq->vq_avail_idx].flags = VRING_DESC_F_WRITE |
+		VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
+		VRING_DESC_F_USED(!vq->avail_wrap_counter);
 	vq->vq_free_cnt--;
+	nb_descs++;
 	if (++vq->vq_avail_idx >= vq->vq_nentries) {
 		vq->vq_avail_idx -= vq->vq_nentries;
 		vq->avail_wrap_counter ^= 1;
 	}
 
+	virtio_wmb(vq->hw->weak_barriers);
+	desc[head].flags = VRING_DESC_F_NEXT |
+		VRING_DESC_F_AVAIL(avail_wrap_counter) |
+		VRING_DESC_F_USED(!avail_wrap_counter);
+
+	virtio_wmb(vq->hw->weak_barriers);
 	virtqueue_notify(vq);
 
 	/* wait for used descriptors in virtqueue */
-	do {
-		rte_rmb();
+	while (!desc_is_used(&desc[head], vq))
 		usleep(100);
-	} while (!__desc_is_used(&desc[head], used_wrap_counter));
+
+	virtio_rmb(vq->hw->weak_barriers);
 
 	/* now get used descriptors */
-	while (desc_is_used(&desc[vq->vq_used_cons_idx], vq)) {
-		vq->vq_free_cnt++;
-		if (++vq->vq_used_cons_idx >= vq->vq_nentries) {
-			vq->vq_used_cons_idx -= vq->vq_nentries;
-			vq->used_wrap_counter ^= 1;
-		}
+	vq->vq_free_cnt += nb_descs;
+	vq->vq_used_cons_idx += nb_descs;
+	if (vq->vq_used_cons_idx >= vq->vq_nentries) {
+		vq->vq_used_cons_idx -= vq->vq_nentries;
+		vq->used_wrap_counter ^= 1;
 	}
 
 	result = cvq->virtio_net_hdr_mz->addr;
@@ -266,7 +262,7 @@ virtio_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
 		sizeof(struct virtio_pmd_ctrl));
 
 	if (vtpci_packed_queue(vq->hw)) {
-		result = virtio_pq_send_command(cvq, ctrl, dlen, pkt_num);
+		result = virtio_send_command_packed(cvq, ctrl, dlen, pkt_num);
 		goto out_unlock;
 	}
 
drivers/net/virtio/virtqueue.h +2 -10
index 7fcde5643..ca9d8e6e3 100644
@@ -281,7 +281,7 @@ struct virtio_tx_region {
 };
 
 static inline int
-__desc_is_used(struct vring_packed_desc *desc, bool wrap_counter)
+desc_is_used(struct vring_packed_desc *desc, struct virtqueue *vq)
 {
 	uint16_t used, avail, flags;
 
@@ -289,16 +289,9 @@ __desc_is_used(struct vring_packed_desc *desc, bool wrap_counter)
 	used = !!(flags & VRING_DESC_F_USED(1));
 	avail = !!(flags & VRING_DESC_F_AVAIL(1));
 
-	return avail == used && used == wrap_counter;
+	return avail == used && used == vq->used_wrap_counter;
 }
 
-static inline int
-desc_is_used(struct vring_packed_desc *desc, struct virtqueue *vq)
-{
-	return __desc_is_used(desc, vq->used_wrap_counter);
-}
-
-
 static inline void
 vring_desc_init_packed(struct virtqueue *vq, int n)
 {
@@ -354,7 +347,6 @@ virtqueue_enable_intr_packed(struct virtqueue *vq)
 {
 	uint16_t *event_flags = &vq->ring_packed.driver_event->desc_event_flags;
 
-
 	if (vq->event_flags_shadow == RING_EVENT_FLAGS_DISABLE) {
 		virtio_wmb(vq->hw->weak_barriers);
 		vq->event_flags_shadow = RING_EVENT_FLAGS_ENABLE;
Signature · 1 line
2.17.1
#2 lore raw

Re: [1/4] net/virtio: fix the control vq support

Quoted 58 lines · Tiwei Bie

This patch mainly fixed below issues in the packed ring based control vq support in virtio driver:

1. When parsing the used descriptors, we have to track the number of descs that we need to skip;
2. vq->vq_free_cnt was decreased twice for a same desc;

Meanwhile, make the function name consistent with other parts.

Fixes ec194c2f1895 ("net/virtio: support packed queue in send command")
Fixes a4270ea4ff79 ("net/virtio: check head desc with correct wrap counter")
---
 drivers/net/virtio/virtio_ethdev.c | 62 ++++++++++++++----------------
 drivers/net/virtio/virtqueue.h     | 12 +-----
 2 files changed, 31 insertions(+), 43 deletions(-)
drivers/net/virtio/virtio_ethdev.c +6 -6
index ee5a98b7c..a3fe65599 100644
@@ -142,16 +142,17 @@ static const struct rte_virtio_xstats_name_off rte_virtio_txq_stat_strings[] = {
 struct virtio_hw_internal virtio_hw_internal[RTE_MAX_ETHPORTS];
 
 static struct virtio_pmd_ctrl *
-virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
-		       int *dlen, int pkt_num)
+virtio_send_command_packed(struct virtnet_ctl *cvq,
+			   struct virtio_pmd_ctrl *ctrl,
+			   int *dlen, int pkt_num)
 {
 	struct virtqueue *vq = cvq->vq;
 	int head;
 	struct vring_packed_desc *desc = vq->ring_packed.desc_packed;
 	struct virtio_pmd_ctrl *result;
-	bool avail_wrap_counter, used_wrap_counter;
-	uint16_t flags;
+	bool avail_wrap_counter;
 	int sum = 0;
+	int nb_descs = 0;
 	int k;
 
 	/*
@@ -162,11 +163,10 @@ virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
 	 */
 	head = vq->vq_avail_idx;
 	avail_wrap_counter = vq->avail_wrap_counter;
-	used_wrap_counter = vq->used_wrap_counter;
-	desc[head].flags = VRING_DESC_F_NEXT;
 	desc[head].addr = cvq->virtio_net_hdr_mem;
 	desc[head].len = sizeof(struct virtio_net_ctrl_hdr);
 	vq->vq_free_cnt--;
+	nb_descs++;
 	if (++vq->vq_avail_idx >= vq->vq_nentries) {
 		vq->vq_avail_idx -= vq->vq_nentries;
 		vq->avail_wrap_counter ^= 1;

drivers/net/virtio/virtio_ethdev.c virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl, · line 180

Quoted 4 lines
drivers/net/virtio/virtio_ethdev.c +0 -1
@@ -177,55 +177,51 @@ virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
 			+ sizeof(struct virtio_net_ctrl_hdr)
 			+ sizeof(ctrl->status) + sizeof(uint8_t) * sum;
 		desc[vq->vq_avail_idx].len = dlen[k];
-		flags = VRING_DESC_F_NEXT;

Looks like barriers was badly placed here before this patch. Anyway, you need a write barrier here between {addr, len} and flags updates.

Quoted 21 lines
drivers/net/virtio/virtio_ethdev.c +4 -6
+		desc[vq->vq_avail_idx].flags = VRING_DESC_F_NEXT |
+			VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
+			VRING_DESC_F_USED(!vq->avail_wrap_counter);
 		sum += dlen[k];
 		vq->vq_free_cnt--;
-		flags |= VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
-			 VRING_DESC_F_USED(!vq->avail_wrap_counter);
-		desc[vq->vq_avail_idx].flags = flags;
-		rte_smp_wmb();
-		vq->vq_free_cnt--;
+		nb_descs++;
 		if (++vq->vq_avail_idx >= vq->vq_nentries) {
 			vq->vq_avail_idx -= vq->vq_nentries;
 			vq->avail_wrap_counter ^= 1;
 		}
 	}
 
-
 	desc[vq->vq_avail_idx].addr = cvq->virtio_net_hdr_mem
 		+ sizeof(struct virtio_net_ctrl_hdr);
 	desc[vq->vq_avail_idx].len = sizeof(ctrl->status);

drivers/net/virtio/virtio_ethdev.c virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl, · line 207

Quoted 10 lines
drivers/net/virtio/virtio_ethdev.c +0 -10
-	flags = VRING_DESC_F_WRITE;
-	flags |= VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
-		 VRING_DESC_F_USED(!vq->avail_wrap_counter);
-	desc[vq->vq_avail_idx].flags = flags;
-	flags = VRING_DESC_F_NEXT;
-	flags |= VRING_DESC_F_AVAIL(avail_wrap_counter) |
-		 VRING_DESC_F_USED(!avail_wrap_counter);
-	desc[head].flags = flags;
-	rte_smp_wmb();
-

Same here. We need a write barrier to be sure that {addr, len} written before updating flags.

Another way to avoid most of barriers is to work similar to 'flush_shadow_used_ring_packed',
i.e. update all the data in a loop - write barrier - update all the flags.

Quoted 91 lines
drivers/net/virtio/virtio_ethdev.c +19 -10
+	desc[vq->vq_avail_idx].flags = VRING_DESC_F_WRITE |
+		VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
+		VRING_DESC_F_USED(!vq->avail_wrap_counter);
 	vq->vq_free_cnt--;
+	nb_descs++;
 	if (++vq->vq_avail_idx >= vq->vq_nentries) {
 		vq->vq_avail_idx -= vq->vq_nentries;
 		vq->avail_wrap_counter ^= 1;
 	}
 
+	virtio_wmb(vq->hw->weak_barriers);
+	desc[head].flags = VRING_DESC_F_NEXT |
+		VRING_DESC_F_AVAIL(avail_wrap_counter) |
+		VRING_DESC_F_USED(!avail_wrap_counter);
+
+	virtio_wmb(vq->hw->weak_barriers);
 	virtqueue_notify(vq);
 
 	/* wait for used descriptors in virtqueue */
-	do {
-		rte_rmb();
+	while (!desc_is_used(&desc[head], vq))
 		usleep(100);
-	} while (!__desc_is_used(&desc[head], used_wrap_counter));
+
+	virtio_rmb(vq->hw->weak_barriers);
 
 	/* now get used descriptors */
-	while (desc_is_used(&desc[vq->vq_used_cons_idx], vq)) {
-		vq->vq_free_cnt++;
-		if (++vq->vq_used_cons_idx >= vq->vq_nentries) {
-			vq->vq_used_cons_idx -= vq->vq_nentries;
-			vq->used_wrap_counter ^= 1;
-		}
+	vq->vq_free_cnt += nb_descs;
+	vq->vq_used_cons_idx += nb_descs;
+	if (vq->vq_used_cons_idx >= vq->vq_nentries) {
+		vq->vq_used_cons_idx -= vq->vq_nentries;
+		vq->used_wrap_counter ^= 1;
 	}
 
 	result = cvq->virtio_net_hdr_mz->addr;
@@ -266,7 +262,7 @@ virtio_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
 		sizeof(struct virtio_pmd_ctrl));
 
 	if (vtpci_packed_queue(vq->hw)) {
-		result = virtio_pq_send_command(cvq, ctrl, dlen, pkt_num);
+		result = virtio_send_command_packed(cvq, ctrl, dlen, pkt_num);
 		goto out_unlock;
 	}
 
drivers/net/virtio/virtqueue.h +2 -10
index 7fcde5643..ca9d8e6e3 100644
@@ -281,7 +281,7 @@ struct virtio_tx_region {
 };
 
 static inline int
-__desc_is_used(struct vring_packed_desc *desc, bool wrap_counter)
+desc_is_used(struct vring_packed_desc *desc, struct virtqueue *vq)
 {
 	uint16_t used, avail, flags;
 
@@ -289,16 +289,9 @@ __desc_is_used(struct vring_packed_desc *desc, bool wrap_counter)
 	used = !!(flags & VRING_DESC_F_USED(1));
 	avail = !!(flags & VRING_DESC_F_AVAIL(1));
 
-	return avail == used && used == wrap_counter;
+	return avail == used && used == vq->used_wrap_counter;
 }
 
-static inline int
-desc_is_used(struct vring_packed_desc *desc, struct virtqueue *vq)
-{
-	return __desc_is_used(desc, vq->used_wrap_counter);
-}
-
-
 static inline void
 vring_desc_init_packed(struct virtqueue *vq, int n)
 {
@@ -354,7 +347,6 @@ virtqueue_enable_intr_packed(struct virtqueue *vq)
 {
 	uint16_t *event_flags = &vq->ring_packed.driver_event->desc_event_flags;
 
-
 	if (vq->event_flags_shadow == RING_EVENT_FLAGS_DISABLE) {
 		virtio_wmb(vq->hw->weak_barriers);
 		vq->event_flags_shadow = RING_EVENT_FLAGS_ENABLE;
#3 lore raw

Re: [1/4] net/virtio: fix the control vq support

Hmm. Nevermind.
Please, ignore my previous comments to this patch. Patch seems compliant to spec, but the spec is not very clear.

Best regards, Ilya Maximets.

Quoted 197 lines · Ilya Maximets
Quoted 58 lines · Tiwei Bie

This patch mainly fixed below issues in the packed ring based control vq support in virtio driver:

1. When parsing the used descriptors, we have to track the number of descs that we need to skip;
2. vq->vq_free_cnt was decreased twice for a same desc;

Meanwhile, make the function name consistent with other parts.

Fixes ec194c2f1895 ("net/virtio: support packed queue in send command")
Fixes a4270ea4ff79 ("net/virtio: check head desc with correct wrap counter")
---
 drivers/net/virtio/virtio_ethdev.c | 62 ++++++++++++++----------------
 drivers/net/virtio/virtqueue.h     | 12 +-----
 2 files changed, 31 insertions(+), 43 deletions(-)
drivers/net/virtio/virtio_ethdev.c +6 -6
index ee5a98b7c..a3fe65599 100644
@@ -142,16 +142,17 @@ static const struct rte_virtio_xstats_name_off rte_virtio_txq_stat_strings[] = {
 struct virtio_hw_internal virtio_hw_internal[RTE_MAX_ETHPORTS];
 
 static struct virtio_pmd_ctrl *
-virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
-		       int *dlen, int pkt_num)
+virtio_send_command_packed(struct virtnet_ctl *cvq,
+			   struct virtio_pmd_ctrl *ctrl,
+			   int *dlen, int pkt_num)
 {
 	struct virtqueue *vq = cvq->vq;
 	int head;
 	struct vring_packed_desc *desc = vq->ring_packed.desc_packed;
 	struct virtio_pmd_ctrl *result;
-	bool avail_wrap_counter, used_wrap_counter;
-	uint16_t flags;
+	bool avail_wrap_counter;
 	int sum = 0;
+	int nb_descs = 0;
 	int k;
 
 	/*
@@ -162,11 +163,10 @@ virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
 	 */
 	head = vq->vq_avail_idx;
 	avail_wrap_counter = vq->avail_wrap_counter;
-	used_wrap_counter = vq->used_wrap_counter;
-	desc[head].flags = VRING_DESC_F_NEXT;
 	desc[head].addr = cvq->virtio_net_hdr_mem;
 	desc[head].len = sizeof(struct virtio_net_ctrl_hdr);
 	vq->vq_free_cnt--;
+	nb_descs++;
 	if (++vq->vq_avail_idx >= vq->vq_nentries) {
 		vq->vq_avail_idx -= vq->vq_nentries;
 		vq->avail_wrap_counter ^= 1;

drivers/net/virtio/virtio_ethdev.c virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl, · line 180

Quoted 4 lines
drivers/net/virtio/virtio_ethdev.c +0 -1
@@ -177,55 +177,51 @@ virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
 			+ sizeof(struct virtio_net_ctrl_hdr)
 			+ sizeof(ctrl->status) + sizeof(uint8_t) * sum;
 		desc[vq->vq_avail_idx].len = dlen[k];
-		flags = VRING_DESC_F_NEXT;

Looks like barriers was badly placed here before this patch. Anyway, you need a write barrier here between {addr, len} and flags updates.

Quoted 21 lines
drivers/net/virtio/virtio_ethdev.c +4 -6
+		desc[vq->vq_avail_idx].flags = VRING_DESC_F_NEXT |
+			VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
+			VRING_DESC_F_USED(!vq->avail_wrap_counter);
 		sum += dlen[k];
 		vq->vq_free_cnt--;
-		flags |= VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
-			 VRING_DESC_F_USED(!vq->avail_wrap_counter);
-		desc[vq->vq_avail_idx].flags = flags;
-		rte_smp_wmb();
-		vq->vq_free_cnt--;
+		nb_descs++;
 		if (++vq->vq_avail_idx >= vq->vq_nentries) {
 			vq->vq_avail_idx -= vq->vq_nentries;
 			vq->avail_wrap_counter ^= 1;
 		}
 	}
 
-
 	desc[vq->vq_avail_idx].addr = cvq->virtio_net_hdr_mem
 		+ sizeof(struct virtio_net_ctrl_hdr);
 	desc[vq->vq_avail_idx].len = sizeof(ctrl->status);

drivers/net/virtio/virtio_ethdev.c virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl, · line 207

Quoted 10 lines
drivers/net/virtio/virtio_ethdev.c +0 -10
-	flags = VRING_DESC_F_WRITE;
-	flags |= VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
-		 VRING_DESC_F_USED(!vq->avail_wrap_counter);
-	desc[vq->vq_avail_idx].flags = flags;
-	flags = VRING_DESC_F_NEXT;
-	flags |= VRING_DESC_F_AVAIL(avail_wrap_counter) |
-		 VRING_DESC_F_USED(!avail_wrap_counter);
-	desc[head].flags = flags;
-	rte_smp_wmb();
-

Same here. We need a write barrier to be sure that {addr, len} written before updating flags.

Another way to avoid most of barriers is to work similar to 'flush_shadow_used_ring_packed',
i.e. update all the data in a loop - write barrier - update all the flags.

Quoted 91 lines
drivers/net/virtio/virtio_ethdev.c +19 -10
+	desc[vq->vq_avail_idx].flags = VRING_DESC_F_WRITE |
+		VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
+		VRING_DESC_F_USED(!vq->avail_wrap_counter);
 	vq->vq_free_cnt--;
+	nb_descs++;
 	if (++vq->vq_avail_idx >= vq->vq_nentries) {
 		vq->vq_avail_idx -= vq->vq_nentries;
 		vq->avail_wrap_counter ^= 1;
 	}
 
+	virtio_wmb(vq->hw->weak_barriers);
+	desc[head].flags = VRING_DESC_F_NEXT |
+		VRING_DESC_F_AVAIL(avail_wrap_counter) |
+		VRING_DESC_F_USED(!avail_wrap_counter);
+
+	virtio_wmb(vq->hw->weak_barriers);
 	virtqueue_notify(vq);
 
 	/* wait for used descriptors in virtqueue */
-	do {
-		rte_rmb();
+	while (!desc_is_used(&desc[head], vq))
 		usleep(100);
-	} while (!__desc_is_used(&desc[head], used_wrap_counter));
+
+	virtio_rmb(vq->hw->weak_barriers);
 
 	/* now get used descriptors */
-	while (desc_is_used(&desc[vq->vq_used_cons_idx], vq)) {
-		vq->vq_free_cnt++;
-		if (++vq->vq_used_cons_idx >= vq->vq_nentries) {
-			vq->vq_used_cons_idx -= vq->vq_nentries;
-			vq->used_wrap_counter ^= 1;
-		}
+	vq->vq_free_cnt += nb_descs;
+	vq->vq_used_cons_idx += nb_descs;
+	if (vq->vq_used_cons_idx >= vq->vq_nentries) {
+		vq->vq_used_cons_idx -= vq->vq_nentries;
+		vq->used_wrap_counter ^= 1;
 	}
 
 	result = cvq->virtio_net_hdr_mz->addr;
@@ -266,7 +262,7 @@ virtio_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
 		sizeof(struct virtio_pmd_ctrl));
 
 	if (vtpci_packed_queue(vq->hw)) {
-		result = virtio_pq_send_command(cvq, ctrl, dlen, pkt_num);
+		result = virtio_send_command_packed(cvq, ctrl, dlen, pkt_num);
 		goto out_unlock;
 	}
 
drivers/net/virtio/virtqueue.h +2 -10
index 7fcde5643..ca9d8e6e3 100644
@@ -281,7 +281,7 @@ struct virtio_tx_region {
 };
 
 static inline int
-__desc_is_used(struct vring_packed_desc *desc, bool wrap_counter)
+desc_is_used(struct vring_packed_desc *desc, struct virtqueue *vq)
 {
 	uint16_t used, avail, flags;
 
@@ -289,16 +289,9 @@ __desc_is_used(struct vring_packed_desc *desc, bool wrap_counter)
 	used = !!(flags & VRING_DESC_F_USED(1));
 	avail = !!(flags & VRING_DESC_F_AVAIL(1));
 
-	return avail == used && used == wrap_counter;
+	return avail == used && used == vq->used_wrap_counter;
 }
 
-static inline int
-desc_is_used(struct vring_packed_desc *desc, struct virtqueue *vq)
-{
-	return __desc_is_used(desc, vq->used_wrap_counter);
-}
-
-
 static inline void
 vring_desc_init_packed(struct virtqueue *vq, int n)
 {
@@ -354,7 +347,6 @@ virtqueue_enable_intr_packed(struct virtqueue *vq)
 {
 	uint16_t *event_flags = &vq->ring_packed.driver_event->desc_event_flags;
 
-
 	if (vq->event_flags_shadow == RING_EVENT_FLAGS_DISABLE) {
 		virtio_wmb(vq->hw->weak_barriers);
 		vq->event_flags_shadow = RING_EVENT_FLAGS_ENABLE;
#4 lore raw

Re: [1/4] net/virtio: fix the control vq support

Quoted 3 lines · Ilya Maximets

Hmm. Nevermind.
Please, ignore my previous comments to this patch. Patch seems compliant to spec, but the spec is not very clear.

Ok, thanks for the review and the folluw-up.

Maxime

Quoted 200 lines

Best regards, Ilya Maximets.

Quoted 197 lines · Ilya Maximets
Quoted 58 lines · Tiwei Bie

This patch mainly fixed below issues in the packed ring based control vq support in virtio driver:

1. When parsing the used descriptors, we have to track the

    number of descs that we need to skip;

2. vq->vq_free_cnt was decreased twice for a same desc;

Meanwhile, make the function name consistent with other parts.

Fixes ec194c2f1895 ("net/virtio: support packed queue in send command")
Fixes a4270ea4ff79 ("net/virtio: check head desc with correct wrap counter")
---
  drivers/net/virtio/virtio_ethdev.c | 62 ++++++++++++++----------------
  drivers/net/virtio/virtqueue.h     | 12 +-----
  2 files changed, 31 insertions(+), 43 deletions(-)
drivers/net/virtio/virtio_ethdev.c +6 -6
index ee5a98b7c..a3fe65599 100644
@@ -142,16 +142,17 @@ static const struct rte_virtio_xstats_name_off rte_virtio_txq_stat_strings[] = {
  struct virtio_hw_internal virtio_hw_internal[RTE_MAX_ETHPORTS];
 
  static struct virtio_pmd_ctrl *
-virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
-		       int *dlen, int pkt_num)
+virtio_send_command_packed(struct virtnet_ctl *cvq,
+			   struct virtio_pmd_ctrl *ctrl,
+			   int *dlen, int pkt_num)
  {
  	struct virtqueue *vq = cvq->vq;
  	int head;
  	struct vring_packed_desc *desc = vq->ring_packed.desc_packed;
  	struct virtio_pmd_ctrl *result;
-	bool avail_wrap_counter, used_wrap_counter;
-	uint16_t flags;
+	bool avail_wrap_counter;
  	int sum = 0;
+	int nb_descs = 0;
  	int k;
 
  	/*
@@ -162,11 +163,10 @@ virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
  	 */
  	head = vq->vq_avail_idx;
  	avail_wrap_counter = vq->avail_wrap_counter;
-	used_wrap_counter = vq->used_wrap_counter;
-	desc[head].flags = VRING_DESC_F_NEXT;
  	desc[head].addr = cvq->virtio_net_hdr_mem;
  	desc[head].len = sizeof(struct virtio_net_ctrl_hdr);
  	vq->vq_free_cnt--;
+	nb_descs++;
  	if (++vq->vq_avail_idx >= vq->vq_nentries) {
  		vq->vq_avail_idx -= vq->vq_nentries;
  		vq->avail_wrap_counter ^= 1;

drivers/net/virtio/virtio_ethdev.c virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl, · line 180

Quoted 4 lines
drivers/net/virtio/virtio_ethdev.c +0 -1
@@ -177,55 +177,51 @@ virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
  			+ sizeof(struct virtio_net_ctrl_hdr)
  			+ sizeof(ctrl->status) + sizeof(uint8_t) * sum;
  		desc[vq->vq_avail_idx].len = dlen[k];
-		flags = VRING_DESC_F_NEXT;

Looks like barriers was badly placed here before this patch. Anyway, you need a write barrier here between {addr, len} and flags updates.

Quoted 21 lines
drivers/net/virtio/virtio_ethdev.c +4 -6
+		desc[vq->vq_avail_idx].flags = VRING_DESC_F_NEXT |
+			VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
+			VRING_DESC_F_USED(!vq->avail_wrap_counter);
  		sum += dlen[k];
  		vq->vq_free_cnt--;
-		flags |= VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
-			 VRING_DESC_F_USED(!vq->avail_wrap_counter);
-		desc[vq->vq_avail_idx].flags = flags;
-		rte_smp_wmb();
-		vq->vq_free_cnt--;
+		nb_descs++;
  		if (++vq->vq_avail_idx >= vq->vq_nentries) {
  			vq->vq_avail_idx -= vq->vq_nentries;
  			vq->avail_wrap_counter ^= 1;
  		}
  	}
 
-
  	desc[vq->vq_avail_idx].addr = cvq->virtio_net_hdr_mem
  		+ sizeof(struct virtio_net_ctrl_hdr);
  	desc[vq->vq_avail_idx].len = sizeof(ctrl->status);

drivers/net/virtio/virtio_ethdev.c virtio_pq_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl, · line 207

Quoted 10 lines
drivers/net/virtio/virtio_ethdev.c +0 -10
-	flags = VRING_DESC_F_WRITE;
-	flags |= VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
-		 VRING_DESC_F_USED(!vq->avail_wrap_counter);
-	desc[vq->vq_avail_idx].flags = flags;
-	flags = VRING_DESC_F_NEXT;
-	flags |= VRING_DESC_F_AVAIL(avail_wrap_counter) |
-		 VRING_DESC_F_USED(!avail_wrap_counter);
-	desc[head].flags = flags;
-	rte_smp_wmb();
-

Same here. We need a write barrier to be sure that {addr, len} written before updating flags.

Another way to avoid most of barriers is to work similar to 'flush_shadow_used_ring_packed',
i.e. update all the data in a loop - write barrier - update all the flags.

Quoted 91 lines
drivers/net/virtio/virtio_ethdev.c +19 -10
+	desc[vq->vq_avail_idx].flags = VRING_DESC_F_WRITE |
+		VRING_DESC_F_AVAIL(vq->avail_wrap_counter) |
+		VRING_DESC_F_USED(!vq->avail_wrap_counter);
  	vq->vq_free_cnt--;
+	nb_descs++;
  	if (++vq->vq_avail_idx >= vq->vq_nentries) {
  		vq->vq_avail_idx -= vq->vq_nentries;
  		vq->avail_wrap_counter ^= 1;
  	}
 
+	virtio_wmb(vq->hw->weak_barriers);
+	desc[head].flags = VRING_DESC_F_NEXT |
+		VRING_DESC_F_AVAIL(avail_wrap_counter) |
+		VRING_DESC_F_USED(!avail_wrap_counter);
+
+	virtio_wmb(vq->hw->weak_barriers);
  	virtqueue_notify(vq);
 
  	/* wait for used descriptors in virtqueue */
-	do {
-		rte_rmb();
+	while (!desc_is_used(&desc[head], vq))
  		usleep(100);
-	} while (!__desc_is_used(&desc[head], used_wrap_counter));
+
+	virtio_rmb(vq->hw->weak_barriers);
 
  	/* now get used descriptors */
-	while (desc_is_used(&desc[vq->vq_used_cons_idx], vq)) {
-		vq->vq_free_cnt++;
-		if (++vq->vq_used_cons_idx >= vq->vq_nentries) {
-			vq->vq_used_cons_idx -= vq->vq_nentries;
-			vq->used_wrap_counter ^= 1;
-		}
+	vq->vq_free_cnt += nb_descs;
+	vq->vq_used_cons_idx += nb_descs;
+	if (vq->vq_used_cons_idx >= vq->vq_nentries) {
+		vq->vq_used_cons_idx -= vq->vq_nentries;
+		vq->used_wrap_counter ^= 1;
  	}
 
  	result = cvq->virtio_net_hdr_mz->addr;
@@ -266,7 +262,7 @@ virtio_send_command(struct virtnet_ctl *cvq, struct virtio_pmd_ctrl *ctrl,
  		sizeof(struct virtio_pmd_ctrl));
 
  	if (vtpci_packed_queue(vq->hw)) {
-		result = virtio_pq_send_command(cvq, ctrl, dlen, pkt_num);
+		result = virtio_send_command_packed(cvq, ctrl, dlen, pkt_num);
  		goto out_unlock;
  	}
 
drivers/net/virtio/virtqueue.h +2 -10
index 7fcde5643..ca9d8e6e3 100644
@@ -281,7 +281,7 @@ struct virtio_tx_region {
  };
 
  static inline int
-__desc_is_used(struct vring_packed_desc *desc, bool wrap_counter)
+desc_is_used(struct vring_packed_desc *desc, struct virtqueue *vq)
  {
  	uint16_t used, avail, flags;
 
@@ -289,16 +289,9 @@ __desc_is_used(struct vring_packed_desc *desc, bool wrap_counter)
  	used = !!(flags & VRING_DESC_F_USED(1));
  	avail = !!(flags & VRING_DESC_F_AVAIL(1));
 
-	return avail == used && used == wrap_counter;
+	return avail == used && used == vq->used_wrap_counter;
  }
 
-static inline int
-desc_is_used(struct vring_packed_desc *desc, struct virtqueue *vq)
-{
-	return __desc_is_used(desc, vq->used_wrap_counter);
-}
-
-
  static inline void
  vring_desc_init_packed(struct virtqueue *vq, int n)
  {
@@ -354,7 +347,6 @@ virtqueue_enable_intr_packed(struct virtqueue *vq)
  {
  	uint16_t *event_flags = &vq->ring_packed.driver_event->desc_event_flags;
 
-
  	if (vq->event_flags_shadow == RING_EVENT_FLAGS_DISABLE) {
  		virtio_wmb(vq->hw->weak_barriers);
  		vq->event_flags_shadow = RING_EVENT_FLAGS_ENABLE;
Reviewed-by on v1 1/4
#5 lore raw

Re: [PATCH 1/4] net/virtio: fix the control vq support

In reply to Tiwei Bie
Quoted 9 lines · Tiwei Bie

This patch mainly fixed below issues in the packed ring based control vq support in virtio driver:

1. When parsing the used descriptors, we have to track the

    number of descs that we need to skip;

2. vq->vq_free_cnt was decreased twice for a same desc;

Meanwhile, make the function name consistent with other parts.

Quoted 9 lines
Fixes ec194c2f1895 ("net/virtio: support packed queue in send command")
Fixes a4270ea4ff79 ("net/virtio: check head desc with correct wrap counter")
---
  drivers/net/virtio/virtio_ethdev.c | 62 ++++++++++++++----------------
  drivers/net/virtio/virtqueue.h     | 12 +-----
  2 files changed, 31 insertions(+), 43 deletions(-)

Thanks,
Maxime

author
#6 lore raw

PATCH 2/4 net/virtio-user: fix the control vq support

In reply to Tiwei Bie

This patch fixed below issues in the packed ring based control vq support in virtio user:

1. The idx_hdr should be used_idx instead of the id in the desc;
2. We just need to write out a single used descriptor for each descriptor list;
3. The avail/used bits should be initialized to 0;

Meanwhile, make the function name consistent with other parts.

Fixes 48a4464029a7 ("net/virtio-user: support control VQ for packed")
---
 drivers/net/virtio/virtio_ethdev.c            | 11 ++++++
 .../net/virtio/virtio_user/virtio_user_dev.c  | 37 +++++++++++--------
 drivers/net/virtio/virtio_user_ethdev.c       |  7 +---
 3 files changed, 34 insertions(+), 21 deletions(-)
drivers/net/virtio/virtio_ethdev.c +11 -0
index a3fe65599..7c4c1df00 100644
@@ -224,6 +224,17 @@ virtio_send_command_packed(struct virtnet_ctl *cvq,
 		vq->used_wrap_counter ^= 1;
 	}
 
+	PMD_INIT_LOG(DEBUG, "vq->vq_free_cnt=%d\n"
+			"vq->vq_avail_idx=%d\n"
+			"vq->vq_used_cons_idx=%d\n"
+			"vq->avail_wrap_counter=%d\n"
+			"vq->used_wrap_counter=%d\n",
+			vq->vq_free_cnt,
+			vq->vq_avail_idx,
+			vq->vq_used_cons_idx,
+			vq->avail_wrap_counter,
+			vq->used_wrap_counter);
+
 	result = cvq->virtio_net_hdr_mz->addr;
 	return result;
 }
drivers/net/virtio/virtio_user/virtio_user_dev.c +21 -16
index c1919177d..89d287a74 100644
@@ -632,9 +632,9 @@ desc_is_avail(struct vring_packed_desc *desc, bool wrap_counter)
 }
 
 static uint32_t
-virtio_user_handle_ctrl_msg_pq(struct virtio_user_dev *dev,
-			    struct vring_packed *vring,
-			    uint16_t idx_hdr)
+virtio_user_handle_ctrl_msg_packed(struct virtio_user_dev *dev,
+				   struct vring_packed *vring,
+				   uint16_t idx_hdr)
 {
 	struct virtio_net_ctrl_hdr *hdr;
 	virtio_net_ctrl_ack status = ~0;
@@ -671,6 +671,10 @@ virtio_user_handle_ctrl_msg_pq(struct virtio_user_dev *dev,
 	*(virtio_net_ctrl_ack *)(uintptr_t)
 		vring->desc_packed[idx_status].addr = status;
 
+	/* Update used descriptor */
+	vring->desc_packed[idx_hdr].id = vring->desc_packed[idx_status].id;
+	vring->desc_packed[idx_hdr].len = sizeof(status);
+
 	return n_descs;
 }
 
@@ -679,24 +683,25 @@ virtio_user_handle_cq_packed(struct virtio_user_dev *dev, uint16_t queue_idx)
 {
 	struct virtio_user_queue *vq = &dev->packed_queues[queue_idx];
 	struct vring_packed *vring = &dev->packed_vrings[queue_idx];
-	uint16_t id, n_descs;
+	uint16_t n_descs;
 
 	while (desc_is_avail(&vring->desc_packed[vq->used_idx],
 			     vq->used_wrap_counter)) {
-		id = vring->desc_packed[vq->used_idx].id;
 
-		n_descs = virtio_user_handle_ctrl_msg_pq(dev, vring, id);
+		n_descs = virtio_user_handle_ctrl_msg_packed(dev, vring,
+				vq->used_idx);
 
-		do {
-			vring->desc_packed[vq->used_idx].flags =
-				VRING_DESC_F_AVAIL(vq->used_wrap_counter) |
-				VRING_DESC_F_USED(vq->used_wrap_counter);
-			if (++vq->used_idx >= dev->queue_size) {
-				vq->used_idx -= dev->queue_size;
-				vq->used_wrap_counter ^= 1;
-			}
-			n_descs--;
-		} while (n_descs);
+		rte_smp_wmb();
+		vring->desc_packed[vq->used_idx].flags =
+			VRING_DESC_F_WRITE |
+			VRING_DESC_F_AVAIL(vq->used_wrap_counter) |
+			VRING_DESC_F_USED(vq->used_wrap_counter);
+
+		vq->used_idx += n_descs;
+		if (vq->used_idx >= dev->queue_size) {
+			vq->used_idx -= dev->queue_size;
+			vq->used_wrap_counter ^= 1;
+		}
 	}
 }
 
drivers/net/virtio/virtio_user_ethdev.c +2 -5
index c01f45cab..6423e1f61 100644
@@ -274,7 +274,6 @@ virtio_user_get_queue_num(struct virtio_hw *hw, uint16_t queue_id __rte_unused)
 static void
 virtio_user_setup_queue_packed(struct virtqueue *vq,
 			       struct virtio_user_dev *dev)
-
 {
 	uint16_t queue_idx = vq->vq_queue_index;
 	struct vring_packed *vring;
@@ -300,10 +299,8 @@ virtio_user_setup_queue_packed(struct virtqueue *vq,
 	dev->packed_queues[queue_idx].avail_wrap_counter = true;
 	dev->packed_queues[queue_idx].used_wrap_counter = true;
 
-	for (i = 0; i < vring->num; i++) {
-		vring->desc_packed[i].flags = VRING_DESC_F_USED(1) |
-					      VRING_DESC_F_AVAIL(1);
-	}
+	for (i = 0; i < vring->num; i++)
+		vring->desc_packed[i].flags = 0;
 }
 
 static void
Signature · 1 line
2.17.1
Reviewed-by on v1 2/4
#7 lore raw

Re: [PATCH 2/4] net/virtio-user: fix the control vq support

Quoted 10 lines · Tiwei Bie

This patch fixed below issues in the packed ring based control vq support in virtio user:

1. The idx_hdr should be used_idx instead of the id in the desc;
2. We just need to write out a single used descriptor for each

    descriptor list;

3. The avail/used bits should be initialized to 0;

Meanwhile, make the function name consistent with other parts.

Quoted 8 lines
Fixes 48a4464029a7 ("net/virtio-user: support control VQ for packed")
---
  drivers/net/virtio/virtio_ethdev.c            | 11 ++++++
  .../net/virtio/virtio_user/virtio_user_dev.c  | 37 +++++++++++--------
  drivers/net/virtio/virtio_user_ethdev.c       |  7 +---
  3 files changed, 34 insertions(+), 21 deletions(-)

Thanks,
Maxime

author
#8 lore raw

PATCH 3/4 net/virtio: use virtio barrier in packed ring

In reply to Tiwei Bie

Always use the virtio variants which support the platform memory ordering.

Fixes 9230ab8d7913 ("net/virtio: support platform memory ordering")
---
 drivers/net/virtio/virtio_rxtx.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/net/virtio/virtio_rxtx.c +2 -2
index ebb86ef70..cc476b898 100644
@@ -425,7 +425,7 @@ virtqueue_enqueue_recv_refill_packed(struct virtqueue *vq,
 		vq->vq_desc_head_idx = dxp->next;
 		if (vq->vq_desc_head_idx == VQ_RING_DESC_CHAIN_END)
 			vq->vq_desc_tail_idx = vq->vq_desc_head_idx;
-		rte_smp_wmb();
+		virtio_wmb(hw->weak_barriers);
 		start_dp[idx].flags = flags;
 		if (++vq->vq_avail_idx >= vq->vq_nentries) {
 			vq->vq_avail_idx -= vq->vq_nentries;
@@ -687,7 +687,7 @@ virtqueue_enqueue_xmit_packed(struct virtnet_tx *txvq, struct rte_mbuf *cookie,
 
 	vq->vq_avail_idx = idx;
 
-	rte_smp_wmb();
+	virtio_wmb(vq->hw->weak_barriers);
 	head_dp->flags = head_flags;
 }
 
Signature · 1 line
2.17.1
Acked-by on v1 3/4
#9 lore raw

Re: [3/4] net/virtio: use virtio barrier in packed ring

Quoted 7 lines · Tiwei Bie

Always use the virtio variants which support the platform memory ordering.

Fixes 9230ab8d7913 ("net/virtio: support platform memory ordering")

---

Thanks.
For some reason rte_smp_* barriers used directly here instead of virtio_*. So, I missed them while rebasing on top of packed rings.

Quoted 26 lines
 drivers/net/virtio/virtio_rxtx.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/net/virtio/virtio_rxtx.c +2 -2
index ebb86ef70..cc476b898 100644
@@ -425,7 +425,7 @@ virtqueue_enqueue_recv_refill_packed(struct virtqueue *vq,
 		vq->vq_desc_head_idx = dxp->next;
 		if (vq->vq_desc_head_idx == VQ_RING_DESC_CHAIN_END)
 			vq->vq_desc_tail_idx = vq->vq_desc_head_idx;
-		rte_smp_wmb();
+		virtio_wmb(hw->weak_barriers);
 		start_dp[idx].flags = flags;
 		if (++vq->vq_avail_idx >= vq->vq_nentries) {
 			vq->vq_avail_idx -= vq->vq_nentries;
@@ -687,7 +687,7 @@ virtqueue_enqueue_xmit_packed(struct virtnet_tx *txvq, struct rte_mbuf *cookie,
 
 	vq->vq_avail_idx = idx;
 
-	rte_smp_wmb();
+	virtio_wmb(vq->hw->weak_barriers);
 	head_dp->flags = head_flags;
 }
 
Reviewed-by on v1 3/4
#10 lore raw

Re: [PATCH 3/4] net/virtio: use virtio barrier in packed ring

In reply to Tiwei Bie
Quoted 9 lines · Tiwei Bie

Always use the virtio variants which support the platform memory ordering.

Fixes 9230ab8d7913 ("net/virtio: support platform memory ordering")
---
  drivers/net/virtio/virtio_rxtx.c | 4 ++--
  1 file changed, 2 insertions(+), 2 deletions(-)

Thanks,
Maxime

author
#11 lore raw

PATCH 4/4 net/virtio-user: fix used ring update in cvq handling

In reply to Tiwei Bie

When updating used ring, the id in used element should be the index of the first desc in the desc chain.

Fixes f9b9d1a55775 ("net/virtio-user: add multiple queues in device emulation")
---
 drivers/net/virtio/virtio_user/virtio_user_dev.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/net/virtio/virtio_user/virtio_user_dev.c +1 -1
index 89d287a74..d1157378d 100644
@@ -722,7 +722,7 @@ virtio_user_handle_cq(struct virtio_user_dev *dev, uint16_t queue_idx)
 
 		/* Update used ring */
 		uep = &vring->used->ring[avail_idx];
-		uep->id = avail_idx;
+		uep->id = desc_idx;
 		uep->len = n_descs;
 
 		vring->used->idx++;
Signature · 1 line
2.17.1
Reviewed-by on v1 4/4
#12 lore raw

Re: [PATCH 4/4] net/virtio-user: fix used ring update in cvq handling

Quoted 10 lines · Tiwei Bie

When updating used ring, the id in used element should be the index of the first desc in the desc chain.

Fixes f9b9d1a55775 ("net/virtio-user: add multiple queues in device emulation")
---
  drivers/net/virtio/virtio_user/virtio_user_dev.c | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)

Thanks,
Maxime

#13 lore raw
In reply to Tiwei Bie
Quoted 6 lines · Tiwei Bie

Tiwei Bie (4):
net/virtio: fix the control vq support net/virtio-user: fix the control vq support net/virtio: use virtio barrier in packed ring net/virtio-user: fix used ring update in cvq handling

Quoted 7 lines
  drivers/net/virtio/virtio_ethdev.c            | 73 ++++++++++---------
  drivers/net/virtio/virtio_rxtx.c              |  4 +-
  .../net/virtio/virtio_user/virtio_user_dev.c  | 39 +++++-----
  drivers/net/virtio/virtio_user_ethdev.c       |  7 +-
  drivers/net/virtio/virtqueue.h                | 12 +--
  5 files changed, 68 insertions(+), 67 deletions(-)

Applied to dpdk-next-virtio/master.

Thanks,
Maxime