Skip to contentSkip to conversation

vhost: fix device IOTLB feature lifecycle

PATCH Superseded Jia Jia 3 participants 11 messages Aug 20 – Aug 21

Subsystems (6)

v7 of 9 Superseded Latest is v9 →

lore
Share & tools
lore

Jia Jia

author
#0 lore raw

v7 cover vhost: fix device IOTLB feature lifecycle

Both vhost-vsock and vhost-net can leave the device IOTLB attached when userspace clears VIRTIO_F_ACCESS_PLATFORM. They can also replace an existing IOTLB with a new empty table when a later feature update keeps ACCESS_PLATFORM enabled, for example when updating logging.

When the IOTLB mode changes, the vring addresses previously supplied by userspace no longer have the same address-space meaning. Leaving those addresses installed would allow an old IOVA to be used as a direct userspace address after the IOTLB is detached.

This series invalidates the vring access state during IOTLB transitions, makes IOTLB initialization idempotent, and uses a common teardown helper for vhost-vsock and vhost-net. IOTLB mode changes are applied even while a virtqueue backend is attached. The device-wide IOTLB is dropped first, each virtqueue then clears its IOTLB pointer and cached ring access under its own mutex, and the old table is freed only after every virtqueue has completed the handoff.

A successful live mode change leaves the backend attached but invalidates the cached vring addresses. Userspace must configure the vring addresses for the new address mode before data processing can resume. When ACCESS_PLATFORM is enabled, the usual IOTLB miss/update protocol repopulates the new table.

Changes since v6:
- rebase on the current vhost tree;
- remove blank lines between commit trailers;
- drop unrelated error propagation changes from the backend patches.

Jia Jia (3):
vhost: invalidate vring access on IOTLB transitions vhost/vsock: discard IOTLB when ACCESS_PLATFORM is cleared vhost/net: discard IOTLB when ACCESS_PLATFORM is cleared

 drivers/vhost/net.c   |  2 ++
 drivers/vhost/vhost.c | 53 ++++++++++++++++++++++++++++++++++++++++++-
 drivers/vhost/vhost.h |  1 +
 drivers/vhost/vsock.c |  4 +++-
 4 files changed, 58 insertions(+), 2 deletions(-)

base-commit: b282418bc366194677eafd1dad180d92254586ac

Signature · 1 line
2.34.1
author
#1 lore raw

PATCH v7 1/3 vhost: invalidate vring access on IOTLB transitions

When ACCESS_PLATFORM changes, the addresses cached in desc, avail, and used change meaning with the address space. Clear the cached vring access state when the device IOTLB is installed or removed so stale IOVAs cannot be reused as direct userspace addresses.

Keep device IOTLB initialization idempotent and apply the mode change even when a virtqueue backend is attached. Drop the device-wide IOTLB first, then clear each VQ state under its own mutex, and keep the old table alive until every VQ has completed the handoff.

A successful live mode change leaves the backend attached but invalidates the cached vring addresses. Userspace must configure the vring addresses for the new address mode before data processing can resume.

Fixes 6b1e6cc7855b ("vhost: new device IOTLB API")
---
 drivers/vhost/vhost.c | 53 ++++++++++++++++++++++++++++++++++++++++++-
 drivers/vhost/vhost.h |  1 +
 2 files changed, 53 insertions(+), 1 deletion(-)
drivers/vhost/vhost.c +52 -1
index 14637cff0bd4..31fff9800045 100644
@@ -344,6 +344,17 @@ static void __vhost_vq_meta_reset(struct vhost_virtqueue *vq)
 		vq->meta_iotlb[j] = NULL;
 }
 
+/* Caller must hold the virtqueue mutex. */
+static void vhost_vq_invalidate_access(struct vhost_virtqueue *vq)
+{
+	vq->desc = NULL;
+	vq->avail = NULL;
+	vq->used = NULL;
+	vq->log_used = false;
+	vq->log_addr = -1ull;
+	__vhost_vq_meta_reset(vq);
+}
+
 static void vhost_vq_meta_reset(struct vhost_dev *d)
 {
 	int i;
@@ -1918,6 +1929,9 @@ int vq_meta_prefetch(struct vhost_virtqueue *vq)
 {
 	unsigned int num = vq->num;
 
+	if (!vq->desc || !vq->avail || !vq->used)
+		return 0;
+
 	if (!vq->iotlb)
 		return 1;
 
@@ -2287,11 +2301,48 @@ long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg
 }
 EXPORT_SYMBOL_GPL(vhost_vring_ioctl);
 
+/* Caller must hold the device mutex. */
+void vhost_clear_device_iotlb(struct vhost_dev *d)
+{
+	struct vhost_iotlb *iotlb;
+	int i;
+
+	iotlb = d->iotlb;
+	if (!iotlb)
+		return;
+
+	/*
+	 * Drop the device-wide view first.  Each VQ then drops its
+	 * per-VQ view and its cached ring access under its own mutex.
+	 * Keep the old table alive until every VQ has completed this
+	 * handoff, since a worker may still be using it while waiting
+	 * for its VQ mutex.
+	 */
+	d->iotlb = NULL;
+
+	for (i = 0; i < d->nvqs; ++i) {
+		struct vhost_virtqueue *vq = d->vqs[i];
+
+		mutex_lock(&vq->mutex);
+		vq->iotlb = NULL;
+		vhost_vq_invalidate_access(vq);
+		mutex_unlock(&vq->mutex);
+	}
+
+	vhost_clear_msg(d);
+	vhost_iotlb_free(iotlb);
+	wake_up_interruptible_poll(&d->wait, EPOLLIN | EPOLLRDNORM);
+}
+EXPORT_SYMBOL_GPL(vhost_clear_device_iotlb);
+
 int vhost_init_device_iotlb(struct vhost_dev *d)
 {
 	struct vhost_iotlb *niotlb, *oiotlb;
 	int i;
 
+	if (d->iotlb)
+		return 0;
+
 	if (max_iotlb_entries <= 0)
 		return -EINVAL;
 
@@ -2307,7 +2358,7 @@ int vhost_init_device_iotlb(struct vhost_dev *d)
 
 		mutex_lock(&vq->mutex);
 		vq->iotlb = niotlb;
-		__vhost_vq_meta_reset(vq);
+		vhost_vq_invalidate_access(vq);
 		mutex_unlock(&vq->mutex);
 	}
 
drivers/vhost/vhost.h +1 -0
index 0192ade6e749..3c75e8089373 100644
@@ -277,6 +277,7 @@ ssize_t vhost_chr_read_iter(struct vhost_dev *dev, struct iov_iter *to,
 			    int noblock);
 ssize_t vhost_chr_write_iter(struct vhost_dev *dev,
 			     struct iov_iter *from);
+void vhost_clear_device_iotlb(struct vhost_dev *d);
 int vhost_init_device_iotlb(struct vhost_dev *d);
 
 void vhost_iotlb_map_free(struct vhost_iotlb *iotlb,
Signature · 1 line
2.34.1
#2 lore raw

Re: [PATCH v7 1/3] vhost: invalidate vring access on IOTLB transitions

Quoted 54 lines · Jia Jia

When ACCESS_PLATFORM changes, the addresses cached in desc, avail, and used change meaning with the address space. Clear the cached vring access state when the device IOTLB is installed or removed so stale IOVAs cannot be reused as direct userspace addresses.

Keep device IOTLB initialization idempotent and apply the mode change even when a virtqueue backend is attached. Drop the device-wide IOTLB first, then clear each VQ state under its own mutex, and keep the old table alive until every VQ has completed the handoff.

A successful live mode change leaves the backend attached but invalidates the cached vring addresses. Userspace must configure the vring addresses for the new address mode before data processing can resume.

Fixes 6b1e6cc7855b ("vhost: new device IOTLB API")

---
drivers/vhost/vhost.c | 53 ++++++++++++++++++++++++++++++++++++++++++- drivers/vhost/vhost.h | 1 +

2 files changed, 53 insertions(+), 1 deletion(-)
drivers/vhost/vhost.c +14 -0
index 14637cff0bd4..31fff9800045 100644
@@ -344,6 +344,17 @@ static void __vhost_vq_meta_reset(struct vhost_virtqueue *vq)
 		vq->meta_iotlb[j] = NULL;
 }
 
+/* Caller must hold the virtqueue mutex. */
+static void vhost_vq_invalidate_access(struct vhost_virtqueue *vq)
+{
+	vq->desc = NULL;
+	vq->avail = NULL;
+	vq->used = NULL;
+	vq->log_used = false;
+	vq->log_addr = -1ull;
+	__vhost_vq_meta_reset(vq);
+}
+
 static void vhost_vq_meta_reset(struct vhost_dev *d)
 {
 	int i;
@@ -1918,6 +1929,9 @@ int vq_meta_prefetch(struct vhost_virtqueue *vq)
 {
 	unsigned int num = vq->num;
 
+	if (!vq->desc || !vq->avail || !vq->used)
+		return 0;
+
 	if (!vq->iotlb)
 		return 1;
 

drivers/vhost/vhost.c long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg · line 2305

Quoted 5 lines
drivers/vhost/vhost.c +2 -0
@@ -2287,11 +2301,48 @@ long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg
 }
 EXPORT_SYMBOL_GPL(vhost_vring_ioctl);
 
+/* Caller must hold the device mutex. */
+void vhost_clear_device_iotlb(struct vhost_dev *d)

Is this the right patch where introduce this function?

IMO should be introduced when we use it.

About that I'm not sure if it is better to squash the other 2 patches with this one, otherwise will be this bisectable? I mean with just this patch applied (and without the other 2) who is going to free the old iotlb?

Quoted 30 lines
drivers/vhost/vhost.c +30 -0
+{
+	struct vhost_iotlb *iotlb;
+	int i;
+
+	iotlb = d->iotlb;
+	if (!iotlb)
+		return;
+
+	/*
+	 * Drop the device-wide view first.  Each VQ then drops its
+	 * per-VQ view and its cached ring access under its own mutex.
+	 * Keep the old table alive until every VQ has completed this
+	 * handoff, since a worker may still be using it while waiting
+	 * for its VQ mutex.
+	 */
+	d->iotlb = NULL;
+
+	for (i = 0; i < d->nvqs; ++i) {
+		struct vhost_virtqueue *vq = d->vqs[i];
+
+		mutex_lock(&vq->mutex);
+		vq->iotlb = NULL;
+		vhost_vq_invalidate_access(vq);
+		mutex_unlock(&vq->mutex);
+	}
+
+	vhost_clear_msg(d);
+	vhost_iotlb_free(iotlb);
+	wake_up_interruptible_poll(&d->wait, EPOLLIN | EPOLLRDNORM);
+}

drivers/vhost/vhost.c long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg · line 2345

Quoted 10 lines
drivers/vhost/vhost.c +5 -0
+EXPORT_SYMBOL_GPL(vhost_clear_device_iotlb);
+
 int vhost_init_device_iotlb(struct vhost_dev *d)
 {
 	struct vhost_iotlb *niotlb, *oiotlb;
 	int i;
 
+	if (d->iotlb)
+		return 0;
+

IIUC after this patch oiotlb is always NULL, can we remove it?

Thanks,
Stefano

Quoted 27 lines
drivers/vhost/vhost.c +1 -1
 	if (max_iotlb_entries <= 0)
 		return -EINVAL;
 
@@ -2307,7 +2358,7 @@ int vhost_init_device_iotlb(struct vhost_dev *d)
 
 		mutex_lock(&vq->mutex);
 		vq->iotlb = niotlb;
-		__vhost_vq_meta_reset(vq);
+		vhost_vq_invalidate_access(vq);
 		mutex_unlock(&vq->mutex);
 	}
 
drivers/vhost/vhost.h +1 -0
index 0192ade6e749..3c75e8089373 100644
@@ -277,6 +277,7 @@ ssize_t vhost_chr_read_iter(struct vhost_dev *dev, struct iov_iter *to,
 			    int noblock);
 ssize_t vhost_chr_write_iter(struct vhost_dev *dev,
 			     struct iov_iter *from);
+void vhost_clear_device_iotlb(struct vhost_dev *d);
 int vhost_init_device_iotlb(struct vhost_dev *d);
 
 void vhost_iotlb_map_free(struct vhost_iotlb *iotlb,
Signature · 1 line
2.34.1
author
#3 lore raw

Re: [PATCH v7 1/3] vhost: invalidate vring access on IOTLB transitions

Quoted 64 lines · Jia Jia
Quoted 54 lines

When ACCESS_PLATFORM changes, the addresses cached in desc, avail, and used change meaning with the address space. Clear the cached vring access state when the device IOTLB is installed or removed so stale IOVAs cannot be reused as direct userspace addresses.

Keep device IOTLB initialization idempotent and apply the mode change even when a virtqueue backend is attached. Drop the device-wide IOTLB first, then clear each VQ state under its own mutex, and keep the old table alive until every VQ has completed the handoff.

A successful live mode change leaves the backend attached but invalidates the cached vring addresses. Userspace must configure the vring addresses for the new address mode before data processing can resume.

Fixes 6b1e6cc7855b ("vhost: new device IOTLB API")

---
drivers/vhost/vhost.c | 53 ++++++++++++++++++++++++++++++++++++++++++- drivers/vhost/vhost.h | 1 +

2 files changed, 53 insertions(+), 1 deletion(-)
drivers/vhost/vhost.c +14 -0
index 14637cff0bd4..31fff9800045 100644
@@ -344,6 +344,17 @@ static void __vhost_vq_meta_reset(struct vhost_virtqueue *vq)
              vq->meta_iotlb[j] = NULL;
 }
 
+/* Caller must hold the virtqueue mutex. */
+static void vhost_vq_invalidate_access(struct vhost_virtqueue *vq)
+{
+      vq->desc = NULL;
+      vq->avail = NULL;
+      vq->used = NULL;
+      vq->log_used = false;
+      vq->log_addr = -1ull;
+      __vhost_vq_meta_reset(vq);
+}
+
 static void vhost_vq_meta_reset(struct vhost_dev *d)
 {
      int i;
@@ -1918,6 +1929,9 @@ int vq_meta_prefetch(struct vhost_virtqueue *vq)
 {
      unsigned int num = vq->num;
 
+      if (!vq->desc || !vq->avail || !vq->used)
+              return 0;
+
      if (!vq->iotlb)
              return 1;
 

drivers/vhost/vhost.c long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg · line 2305

Quoted 5 lines
drivers/vhost/vhost.c +2 -0
@@ -2287,11 +2301,48 @@ long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg
 }
 EXPORT_SYMBOL_GPL(vhost_vring_ioctl);
 
+/* Caller must hold the device mutex. */
+void vhost_clear_device_iotlb(struct vhost_dev *d)

Is this the right patch where introduce this function?

Quoted 7 lines

IMO should be introduced when we use it.

About that I'm not sure if it is better to squash the other 2 patches with this one, otherwise will be this bisectable?
I mean with just this patch applied (and without the other 2) who is going to free the old iotlb?

I'll rework the series so that the helper is introduced together with the vhost-net and vhost-vsock callers, most likely by squashing the three patches. I'm also reviewing the existing IOTLB replacement semantics before preparing the next revision.

Quoted 37 lines
Quoted 37 lines
drivers/vhost/vhost.c +32 -0
+{
+      struct vhost_iotlb *iotlb;
+      int i;
+
+      iotlb = d->iotlb;
+      if (!iotlb)
+              return;
+
+      /*
+       * Drop the device-wide view first.  Each VQ then drops its
+       * per-VQ view and its cached ring access under its own mutex.
+       * Keep the old table alive until every VQ has completed this
+       * handoff, since a worker may still be using it while waiting
+       * for its VQ mutex.
+       */
+      d->iotlb = NULL;
+
+      for (i = 0; i < d->nvqs; ++i) {
+              struct vhost_virtqueue *vq = d->vqs[i];
+
+              mutex_lock(&vq->mutex);
+              vq->iotlb = NULL;
+              vhost_vq_invalidate_access(vq);
+              mutex_unlock(&vq->mutex);
+      }
+
+      vhost_clear_msg(d);
+      vhost_iotlb_free(iotlb);
+      wake_up_interruptible_poll(&d->wait, EPOLLIN | EPOLLRDNORM);
+}
+EXPORT_SYMBOL_GPL(vhost_clear_device_iotlb);
+
 int vhost_init_device_iotlb(struct vhost_dev *d)
 {
      struct vhost_iotlb *niotlb, *oiotlb;
      int i;
 
Quoted 8 lines

drivers/vhost/vhost.c long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg · line 2345

Quoted 3 lines
drivers/vhost/vhost.c +3 -0
+      if (d->iotlb)
+              return 0;
+

IIUC after this patch oiotlb is always NULL, can we remove it?

Thanks,
Stefano

Thanks, I took another look. I don't think we should simply remove oiotlb while keeping the early return, since the early return itself may be too broad.

One case I need to examine more carefully is vhost stop/start. QEMU unregisters the IOMMU listener while vhost is stopped. If an IOVA mapping changes during that interval, preserving the existing kernel IOTLB on the next VHOST_SET_FEATURES may retain an entry pointing to the old HVA. A later lookup could hit that stale entry, so no IOTLB miss would be reported and no replacement update would be triggered through the miss path for that IOVA.

The original replacement path, including oiotlb, installs a new empty table and safely keeps the old table alive until all VQs have switched. I need to review this lifecycle more carefully before deciding whether that replacement semantic can be removed. A logging-only feature update may want to preserve the IOTLB, while a restart boundary may need a new one, and d->iotlb != NULL alone does not distinguish those cases.

Quoted 29 lines
Quoted 28 lines
drivers/vhost/vhost.c +1 -1
      if (max_iotlb_entries <= 0)
              return -EINVAL;
 
@@ -2307,7 +2358,7 @@ int vhost_init_device_iotlb(struct vhost_dev *d)
 
              mutex_lock(&vq->mutex);
              vq->iotlb = niotlb;
-              __vhost_vq_meta_reset(vq);
+              vhost_vq_invalidate_access(vq);
              mutex_unlock(&vq->mutex);
      }
 
drivers/vhost/vhost.h +1 -1
index 0192ade6e749..3c75e8089373 100644
@@ -277,6 +277,7 @@ ssize_t vhost_chr_read_iter(struct vhost_dev *dev, struct iov_iter *to,
                          int noblock);
 ssize_t vhost_chr_write_iter(struct vhost_dev *dev,
                           struct iov_iter *from);
+void vhost_clear_device_iotlb(struct vhost_dev *d);
 int vhost_init_device_iotlb(struct vhost_dev *d);
 
 void vhost_iotlb_map_free(struct vhost_iotlb *iotlb,
--

2.34.1

#4 lore raw

Re: [PATCH v7 1/3] vhost: invalidate vring access on IOTLB transitions

In reply to Jia Jia
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] Race condition in vhost_clear_device_iotlb() causes NULL pointer dereference or IOMMU bypass --

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Race condition in vhost_clear_device_iotlb() causes NULL pointer dereference or IOMMU bypass --

--- Patch [1]: [PATCH v7 1/3] vhost: invalidate vring access on IOTLB transitions --- commit da0274e257afa43e8d844051613c8dcc1f9d744f
Author: Jia Jia <[email protected]>

vhost: invalidate vring access on IOTLB transitions

When ACCESS_PLATFORM changes, the addresses cached in desc, avail, and used change meaning with the address space. Clear the cached vring access state when the device IOTLB is installed or removed so stale IOVAs cannot be reused as direct userspace addresses.

Quoted 4 lines
drivers/vhost/vhost.c +0 -0
index 14637cff0bd46..31fff98000450 100644

[ ... ]

Quoted 12 lines
drivers/vhost/vhost.c +8 -0
@@ -2287,11 +2301,48 @@ long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg
 }
 EXPORT_SYMBOL_GPL(vhost_vring_ioctl);
 
+/* Caller must hold the device mutex. */
+void vhost_clear_device_iotlb(struct vhost_dev *d)
+{
+	struct vhost_iotlb *iotlb;
+	int i;
+
+	iotlb = d->iotlb;
+	if (!iotlb)

drivers/vhost/vhost.c long vhost_vring_ioctl(struct vhost_dev *d, unsigned int ioctl, void __user *arg · line 2321

Quoted 10 lines
drivers/vhost/vhost.c +10 -0
+		return;
+
+	/*
+	 * Drop the device-wide view first.  Each VQ then drops its
+	 * per-VQ view and its cached ring access under its own mutex.
+	 * Keep the old table alive until every VQ has completed this
+	 * handoff, since a worker may still be using it while waiting
+	 * for its VQ mutex.
+	 */
+	d->iotlb = NULL;

[Severity: High]
Does clearing d->iotlb here without holding vq->mutex introduce a race condition with the vhost worker thread?

If a userspace process dynamically clears the VIRTIO_F_ACCESS_PLATFORM feature, this function clears d->iotlb without synchronization against concurrent vhost worker threads.

Meanwhile, an active worker thread holding vq->mutex might be calling translate_desc():

drivers/vhost/vhost.c:translate_desc() {
    ...
    struct vhost_iotlb *umem = dev->iotlb ? dev->iotlb : dev->umem;
    ...
}

Because there is no READ_ONCE() or other synchronization on dev->iotlb, could the compiler double-read dev->iotlb, observing a non-NULL value for the condition but NULL for the assignment, leaving umem = NULL?

Alternatively, if dev->umem was never populated, reading dev->iotlb as NULL also leaves umem as NULL. The worker then calls vhost_iotlb_itree_first() which dereferences umem->root, potentially causing a host kernel panic.

Quoted 9 lines
drivers/vhost/vhost.c +9 -0
+
+	for (i = 0; i < d->nvqs; ++i) {
+		struct vhost_virtqueue *vq = d->vqs[i];
+
+		mutex_lock(&vq->mutex);
+		vq->iotlb = NULL;
+		vhost_vq_invalidate_access(vq);
+		mutex_unlock(&vq->mutex);
+	}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
author
#5 lore raw

PATCH v7 2/3 vhost/vsock: discard IOTLB when ACCESS_PLATFORM is cleared

In reply to Jia Jia

Clear the device IOTLB when userspace clears VIRTIO_F_ACCESS_PLATFORM. Otherwise descriptor translation can continue to use mappings installed before the feature change.

The common helper invalidates cached vring access and applies the transition even while a backend is attached. The backend remains attached, but userspace must configure the vring addresses for the new address mode after a successful live transition.

Fixes e13a6915a03f ("vhost/vsock: add IOTLB API support")
---
 drivers/vhost/vsock.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/vhost/vsock.c +3 -1
index 9aaab6bb8061..e1e9d002d6ae 100644
@@ -865,9 +865,11 @@ static int vhost_vsock_set_features(struct vhost_vsock *vsock, u64 features)
 		goto err;
 	}
 
-	if ((features & (1ULL << VIRTIO_F_ACCESS_PLATFORM))) {
+	if (features & (1ULL << VIRTIO_F_ACCESS_PLATFORM)) {
 		if (vhost_init_device_iotlb(&vsock->dev))
 			goto err;
+	} else {
+		vhost_clear_device_iotlb(&vsock->dev);
 	}
 
 	vsock->seqpacket_allow = features & (1ULL << VIRTIO_VSOCK_F_SEQPACKET);
Signature · 1 line
2.34.1
#6 lore raw

Re: [PATCH v7 2/3] vhost/vsock: discard IOTLB when ACCESS_PLATFORM is cleared

Quoted 21 lines · Jia Jia

Clear the device IOTLB when userspace clears VIRTIO_F_ACCESS_PLATFORM. Otherwise descriptor translation can continue to use mappings installed before the feature change.

The common helper invalidates cached vring access and applies the transition even while a backend is attached. The backend remains attached, but userspace must configure the vring addresses for the new address mode after a successful live transition.

Fixes e13a6915a03f ("vhost/vsock: add IOTLB API support")

---
drivers/vhost/vsock.c | 4 +++-

1 file changed, 3 insertions(+), 1 deletion(-)
drivers/vhost/vsock.c +0 -0
index 9aaab6bb8061..e1e9d002d6ae 100644

drivers/vhost/vsock.c static int vhost_vsock_set_features(struct vhost_vsock *vsock, u64 features) · line 868

Quoted 5 lines
drivers/vhost/vsock.c +1 -1
@@ -865,9 +865,11 @@ static int vhost_vsock_set_features(struct vhost_vsock *vsock, u64 features)
 		goto err;
 	}
 
-	if ((features & (1ULL << VIRTIO_F_ACCESS_PLATFORM))) {
+	if (features & (1ULL << VIRTIO_F_ACCESS_PLATFORM)) {

Unrelated change...

I think I've already pointed something like this in previous versions: for a patch that fixes a specific issue, these unrelated changes should be avoided. Please keep this in mind.

Stefano

Quoted 10 lines
drivers/vhost/vsock.c +2 -0
 		if (vhost_init_device_iotlb(&vsock->dev))
 			goto err;
+	} else {
+		vhost_clear_device_iotlb(&vsock->dev);
 	}
 
 	vsock->seqpacket_allow = features & (1ULL << VIRTIO_VSOCK_F_SEQPACKET);
Signature · 1 line
2.34.1
author
#7 lore raw

Re: [PATCH v7 2/3] vhost/vsock: discard IOTLB when ACCESS_PLATFORM is cleared

Quoted 31 lines · Jia Jia
Quoted 21 lines

Clear the device IOTLB when userspace clears VIRTIO_F_ACCESS_PLATFORM. Otherwise descriptor translation can continue to use mappings installed before the feature change.

The common helper invalidates cached vring access and applies the transition even while a backend is attached. The backend remains attached, but userspace must configure the vring addresses for the new address mode after a successful live transition.

Fixes e13a6915a03f ("vhost/vsock: add IOTLB API support")

---
drivers/vhost/vsock.c | 4 +++-

1 file changed, 3 insertions(+), 1 deletion(-)
drivers/vhost/vsock.c +0 -0
index 9aaab6bb8061..e1e9d002d6ae 100644

drivers/vhost/vsock.c static int vhost_vsock_set_features(struct vhost_vsock *vsock, u64 features) · line 868

Quoted 5 lines
drivers/vhost/vsock.c +1 -1
@@ -865,9 +865,11 @@ static int vhost_vsock_set_features(struct vhost_vsock *vsock, u64 features)
              goto err;
      }
 
-      if ((features & (1ULL << VIRTIO_F_ACCESS_PLATFORM))) {
+      if (features & (1ULL << VIRTIO_F_ACCESS_PLATFORM)) {

Unrelated change...

Quoted 5 lines

I think I've already pointed something like this in previous versions:
for a patch that fixes a specific issue, these unrelated changes should be avoided. Please keep this in mind.

Stefano

You're right, thanks for the reminder. That was my oversight—I should have cleaned it up more carefully. I'll remember that going forward.

Quoted 12 lines
Quoted 11 lines
drivers/vhost/vsock.c +2 -1
              if (vhost_init_device_iotlb(&vsock->dev))
                      goto err;
+      } else {
+              vhost_clear_device_iotlb(&vsock->dev);
      }
 
      vsock->seqpacket_allow = features & (1ULL << VIRTIO_VSOCK_F_SEQPACKET);
--

2.34.1

#8 lore raw

Re: [PATCH v7 2/3] vhost/vsock: discard IOTLB when ACCESS_PLATFORM is cleared

In reply to Jia Jia
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Critical] Concurrent lockless clearing of dev->iotlb causes a TOCTOU race in translate_desc(), leading…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Critical] Concurrent lockless clearing of dev->iotlb causes a TOCTOU race in translate_desc(), leading to a NULL pointer dereference or out-of-bounds memory corruption. --

--- Patch [2]: [PATCH v7 2/3] vhost/vsock: discard IOTLB when ACCESS_PLATFORM is cleared --- commit feb57c09c27392564744aed50569fa28daa5a083
Author: Jia Jia <[email protected]>

vhost/vsock: discard IOTLB when ACCESS_PLATFORM is cleared

Clear the device IOTLB when userspace clears VIRTIO_F_ACCESS_PLATFORM. Otherwise descriptor translation can continue to use mappings installed before the feature change.

Quoted 5 lines
drivers/vhost/vsock.c +0 -0
index 9aaab6bb8061c..e1e9d002d6aeb 100644

drivers/vhost/vsock.c static int vhost_vsock_set_features(struct vhost_vsock *vsock, u64 features) · line 872

Quoted 9 lines
drivers/vhost/vsock.c +3 -1
@@ -865,9 +865,11 @@ static int vhost_vsock_set_features(struct vhost_vsock *vsock, u64 features)
 		goto err;
 	}
 
-	if ((features & (1ULL << VIRTIO_F_ACCESS_PLATFORM))) {
+	if (features & (1ULL << VIRTIO_F_ACCESS_PLATFORM)) {
 		if (vhost_init_device_iotlb(&vsock->dev))
 			goto err;
+	} else {
+		vhost_clear_device_iotlb(&vsock->dev);

[Severity: Critical]
Does this concurrent clearing of the IOTLB introduce a regression with active backend workers?

Looking at vhost_clear_device_iotlb(), it sets d->iotlb to NULL locklessly before acquiring the vq->mutex:

drivers/vhost/vhost.c:vhost_clear_device_iotlb() {
    ...
    d->iotlb = NULL;

    for (i = 0; i < d->nvqs; ++i) {
        struct vhost_virtqueue *vq = d->vqs[i];
        mutex_lock(&vq->mutex);
    ...
}

If a virtqueue backend worker is actively processing descriptors via translate_desc() concurrently, it evaluates dev->iotlb without a READ_ONCE():

drivers/vhost/vhost.c:translate_desc() {
    ...
    struct vhost_iotlb *umem = dev->iotlb ? dev->iotlb : dev->umem;
    ...
}

Can the compiler emit multiple fetches here, such that the first fetch is non-NULL but the second fetch returns NULL? If umem becomes NULL, passing it to vhost_iotlb_itree_first() could cause a NULL pointer dereference.

Additionally, if the worker sees dev->iotlb as NULL immediately, will it incorrectly fall back to dev->umem and mistakenly translate the IOVA using the GPA memory map, leading to memory corruption?

Quoted 3 lines
drivers/vhost/vsock.c +0 -0
 	}
 
 	vsock->seqpacket_allow = features & (1ULL << VIRTIO_VSOCK_F_SEQPACKET);
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
author
#9 lore raw

PATCH v7 3/3 vhost/net: discard IOTLB when ACCESS_PLATFORM is cleared

In reply to Jia Jia

Apply the common device IOTLB teardown when userspace clears VIRTIO_F_ACCESS_PLATFORM. This drops stale translations and avoids rebuilding an existing IOTLB during feature updates that keep ACCESS_PLATFORM enabled.

The transition invalidates cached vring access even with an attached backend. The backend remains attached, but userspace must configure the vring addresses for the new address mode after a successful live transition.

Fixes 6b1e6cc7855b ("vhost: new device IOTLB API")
---
 drivers/vhost/net.c | 2 ++
 1 file changed, 2 insertions(+)
drivers/vhost/net.c +2 -0
index 38d9c184082d..4d9d7c2216ed 100644
@@ -1696,6 +1696,8 @@ static int vhost_net_set_features(struct vhost_net *n, const u64 *features)
 	if (virtio_features_test_bit(features, VIRTIO_F_ACCESS_PLATFORM)) {
 		if (vhost_init_device_iotlb(&n->dev))
 			goto out_unlock;
+	} else {
+		vhost_clear_device_iotlb(&n->dev);
 	}
 
 	for (i = 0; i < VHOST_NET_VQ_MAX; ++i) {
Signature · 1 line
2.34.1
#10 lore raw

Re: [PATCH v7 3/3] vhost/net: discard IOTLB when ACCESS_PLATFORM is cleared

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Critical] Concurrent execution of vhost_clear_device_iotlb() and translate_desc() causes the vhost…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Critical] Concurrent execution of vhost_clear_device_iotlb() and translate_desc() causes the vhost worker thread to mistakenly translate IOVAs using the guest physical memory map (GPA map), leading to arbitrary guest memory corruption. --

--- Patch [3]: [PATCH v7 3/3] vhost/net: discard IOTLB when ACCESS_PLATFORM is cleared --- commit 4247ba53ba530a29217ab642534cab65e8a1846d
Author: Jia Jia <[email protected]>
vhost/net: discard IOTLB when ACCESS_PLATFORM is cleared

This commit applies common device IOTLB teardown when userspace clears VIRTIO_F_ACCESS_PLATFORM. This avoids rebuilding an existing IOTLB during feature updates that keep it enabled, while requiring userspace to reconfigure vring addresses for the new address mode.

drivers/vhost/net.c static int vhost_net_set_features(struct vhost_net *n, const u64 *features) · line 1700

Quoted 10 lines
drivers/vhost/net.c +2 -0
index 38d9c184082d0..4d9d7c2216ed5 100644
@@ -1696,6 +1696,8 @@ static int vhost_net_set_features(struct vhost_net *n, const u64 *features)
 	if (virtio_features_test_bit(features, VIRTIO_F_ACCESS_PLATFORM)) {
 		if (vhost_init_device_iotlb(&n->dev))
 			goto out_unlock;
+	} else {
+		vhost_clear_device_iotlb(&n->dev);

[Severity: Critical]
Does this introduce a race condition with the vhost worker thread that could lead to guest memory corruption?

When userspace clears VIRTIO_F_ACCESS_PLATFORM on a running device, this code calls vhost_clear_device_iotlb() while the backend remains attached. Looking at vhost_clear_device_iotlb() in drivers/vhost/vhost.c, it drops the global device IOTLB pointer before taking the per-VQ mutex:

drivers/vhost/vhost.c:vhost_clear_device_iotlb() {
	...
	d->iotlb = NULL;

	for (i = 0; i < d->nvqs; ++i) {
		struct vhost_virtqueue *vq = d->vqs[i];

		mutex_lock(&vq->mutex);
		vq->iotlb = NULL;
	...
}

Concurrently, if the vhost worker thread is active, it will have acquired vq->mutex and proceed to translate addresses. However, translate_desc() evaluates the global dev->iotlb pointer rather than the protected vq->iotlb pointer:

drivers/vhost/vhost.c:translate_desc() {
	...
	struct vhost_iotlb *umem = dev->iotlb ? dev->iotlb : dev->umem;
	...
}

Since d->iotlb was cleared without the per-VQ mutex, the active worker thread might observe dev->iotlb as NULL and incorrectly fall back to dev->umem (the guest physical memory map).

Could this cause IOVAs to be mistakenly translated as GPAs, leading the kernel to read or write network payloads to the wrong Host Virtual Addresses?

Quoted 3 lines
drivers/vhost/net.c +0 -0
 	}
 
 	for (i = 0; i < VHOST_NET_VQ_MAX; ++i) {
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3