| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <CAJaqyWc725Ep6MJR8=7jJdqSnJs25X++qPx0tRfGOnQr=5H2yw@mail.gmail.com>
Date: Thu, 18 Sep 2025 08:57:25 +0200
From: Eugenio Perez Martin <eperezma@...hat.com>
To: Jason Wang <jasowang@...hat.com>
Cc: "Michael S . Tsirkin" <mst@...hat.com>, Stefano Garzarella <sgarzare@...hat.com>,
Xuan Zhuo <xuanzhuo@...ux.alibaba.com>, linux-kernel@...r.kernel.org,
Maxime Coquelin <mcoqueli@...hat.com>, Yongji Xie <xieyongji@...edance.com>,
Cindy Lu <lulu@...hat.com>, Laurent Vivier <lvivier@...hat.com>, virtualization@...ts.linux.dev
Subject: Re: [PATCH v2 6/7] vduse: add vq group asid support
On Thu, Sep 18, 2025 at 8:07 AM Jason Wang <jasowang@...hat.com> wrote:
>
> On Thu, Sep 18, 2025 at 12:41 AM Eugenio Perez Martin
> <eperezma@...hat.com> wrote:
> >
> > On Wed, Sep 17, 2025 at 10:56 AM Jason Wang <jasowang@...hat.com> wrote:
> > >
> > > On Tue, Sep 16, 2025 at 9:09 PM Eugenio Pérez <eperezma@...hat.com> wrote:
> > > >
> > > > Add support for assigning Address Space Identifiers (ASIDs) to each VQ
> > > > group. This enables mapping each group into a distinct memory space.
> > > >
> > > > Now that the driver can change ASID in the middle of operation, the
> > > > domain that each vq address point is also protected by domain_lock.
> > > >
> > > > Signed-off-by: Eugenio Pérez <eperezma@...hat.com>
> > > > ---
> > > > v2:
> > > > * Convert the use of mutex to rwlock.
> > > >
> > > > RFC v3:
> > > > * Increase VDUSE_MAX_VQ_GROUPS to 0xffff (Jason). It was set to a lower
> > > > value to reduce memory consumption, but vqs are already limited to
> > > > that value and userspace VDUSE is able to allocate that many vqs.
> > > > * Remove TODO about merging VDUSE_IOTLB_GET_FD ioctl with
> > > > VDUSE_IOTLB_GET_INFO.
> > > > * Use of array_index_nospec in VDUSE device ioctls.
> > > > * Embed vduse_iotlb_entry into vduse_iotlb_entry_v2.
> > > > * Move the umem mutex to asid struct so there is no contention between
> > > > ASIDs.
> > > >
> > > > RFC v2:
> > > > * Make iotlb entry the last one of vduse_iotlb_entry_v2 so the first
> > > > part of the struct is the same.
> > > > ---
> > > > drivers/vdpa/vdpa_user/vduse_dev.c | 324 +++++++++++++++++++++--------
> > > > include/uapi/linux/vduse.h | 51 ++++-
> > > > 2 files changed, 284 insertions(+), 91 deletions(-)
> > > >
> > > > diff --git a/drivers/vdpa/vdpa_user/vduse_dev.c b/drivers/vdpa/vdpa_user/vduse_dev.c
> > > > index b45b1d22784f..06b7790380b7 100644
> > > > --- a/drivers/vdpa/vdpa_user/vduse_dev.c
> > > > +++ b/drivers/vdpa/vdpa_user/vduse_dev.c
> > > > @@ -93,6 +93,7 @@ struct vduse_as {
> > > > };
> > > >
> > > > struct vduse_vq_group_int {
> > > > + struct vduse_iova_domain *domain;
> > > > struct vduse_dev *dev;
> > >
> > > This confuses me, I think it should be an asid. And the vduse_dev
> > > pointer seems to be useless here.
> > >
> >
> > The *dev pointer is used to take the rwlock, in case the vhost driver
> > calls VHOST_VDPA_SET_GROUP_ASID (or equivalent) at the same time
> > vduse_dev_sync_single_for_device (or _for_cpu, or equivalent) run.
>
> Ok, but having it in a group seems odd. A better place is to move it to the as?
>
If we move to the as, we need to take the lock this way:
read_lock(vduse_vq_group->as->dev->domain_lock)
But the lock is protecting the vduse_vq_group->as change itself, as
other ioctls (SET_GROUP_ASID mainly) can modify it concurrently.
We can assume that *as will always point to a valid as, its change
will be atomic, and all the as->dev points to the exact same
vduse_dev. I can buy that, but it is a race anyway.
> >
> > > > };
> > > >
> > > > @@ -100,7 +101,7 @@ struct vduse_dev {
> > > > struct vduse_vdpa *vdev;
> > > > struct device *dev;
> > > > struct vduse_virtqueue **vqs;
> > > > - struct vduse_as as;
> > > > + struct vduse_as *as;
> > > > char *name;
> > > > struct mutex lock;
> > > > spinlock_t msg_lock;
> > > > @@ -128,6 +129,7 @@ struct vduse_dev {
> > > > u32 vq_num;
> > > > u32 vq_align;
> > > > u32 ngroups;
> > > > + u32 nas;
> > > > struct vduse_vq_group_int *groups;
> > > > unsigned int bounce_size;
> > > > rwlock_t domain_lock;
> > > > @@ -318,7 +320,7 @@ static int vduse_dev_set_status(struct vduse_dev *dev, u8 status)
> > > > return vduse_dev_msg_sync(dev, &msg);
> > > > }
> > > >
> > > > -static int vduse_dev_update_iotlb(struct vduse_dev *dev,
> > > > +static int vduse_dev_update_iotlb(struct vduse_dev *dev, u32 asid,
> > > > u64 start, u64 last)
> > > > {
> > > > struct vduse_dev_msg msg = { 0 };
> > > > @@ -327,8 +329,14 @@ static int vduse_dev_update_iotlb(struct vduse_dev *dev,
> > > > return -EINVAL;
> > > >
> > > > msg.req.type = VDUSE_UPDATE_IOTLB;
> > > > - msg.req.iova.start = start;
> > > > - msg.req.iova.last = last;
> > > > + if (dev->api_version < VDUSE_API_VERSION_1) {
> > > > + msg.req.iova.start = start;
> > > > + msg.req.iova.last = last;
> > > > + } else {
> > > > + msg.req.iova_v2.start = start;
> > > > + msg.req.iova_v2.last = last;
> > > > + msg.req.iova_v2.asid = asid;
> > > > + }
> > > >
> > > > return vduse_dev_msg_sync(dev, &msg);
> > > > }
> > > > @@ -440,14 +448,29 @@ static __poll_t vduse_dev_poll(struct file *file, poll_table *wait)
> > > > return mask;
> > > > }
> > > >
> > > > +/* Force set the asid to a vq group without a message to the VDUSE device */
> > > > +static void vduse_set_group_asid_nomsg(struct vduse_dev *dev,
> > > > + unsigned int group, unsigned int asid)
> > > > +{
> > > > + write_lock(&dev->domain_lock);
> > > > + dev->groups[group].domain = dev->as[asid].domain;
> > >
> > > I think it would be better to stick the group->as an indirection which
> > > should be .
> > >
> > > dev->groups.asid = asid;
> > >
> > > Or
> > >
> > > dev->group->as = as;
> > >
> >
> > That involves an extra memory jump for functions that may be in the
> > hot path. I've not profiled it, but I'm ok with changing it that way
> > if you prefer.
>
> I think it would be better if we can change (see my reply in previous patch).
>
> >
> > > > + write_unlock(&dev->domain_lock);
> > > > +}
> > > > +
> > > > static void vduse_dev_reset(struct vduse_dev *dev)
> > > > {
> > > > int i;
> > > > - struct vduse_iova_domain *domain = dev->as.domain;
> > > >
> > > > /* The coherent mappings are handled in vduse_dev_free_coherent() */
> > > > - if (domain && domain->bounce_map)
> > > > - vduse_domain_reset_bounce_map(domain);
> > > > + for (i = 0; i < dev->nas; i++) {
> > > > + struct vduse_iova_domain *domain = dev->as[i].domain;
> > > > +
> > > > + if (domain && domain->bounce_map)
> > > > + vduse_domain_reset_bounce_map(domain);
> > > > + }
> > > > +
> > > > + for (i = 0; i < dev->ngroups; i++)
> > > > + vduse_set_group_asid_nomsg(dev, i, 0);
> > > >
> > > > down_write(&dev->rwsem);
> > > >
> > > > @@ -621,6 +644,29 @@ static union virtio_map vduse_get_vq_map(struct vdpa_device *vdpa, u16 idx)
> > > > return ret;
> > > > }
> > > >
> > > > +static int vduse_set_group_asid(struct vdpa_device *vdpa, unsigned int group,
> > > > + unsigned int asid)
> > > > +{
> > > > + struct vduse_dev *dev = vdpa_to_vduse(vdpa);
> > > > + struct vduse_dev_msg msg = { 0 };
> > > > + int r;
> > > > +
> > > > + if (dev->api_version < VDUSE_API_VERSION_1 ||
> > > > + group >= dev->ngroups || asid >= dev->nas)
> > > > + return -EINVAL;
> > > > +
> > > > + msg.req.type = VDUSE_SET_VQ_GROUP_ASID;
> > > > + msg.req.vq_group_asid.group = group;
> > > > + msg.req.vq_group_asid.asid = asid;
> > > > +
> > > > + r = vduse_dev_msg_sync(dev, &msg);
> > > > + if (r < 0)
> > > > + return r;
> > > > +
> > > > + vduse_set_group_asid_nomsg(dev, group, asid);
> > > > + return 0;
> > > > +}
> > > > +
> > > > static int vduse_vdpa_get_vq_state(struct vdpa_device *vdpa, u16 idx,
> > > > struct vdpa_vq_state *state)
> > > > {
> > > > @@ -792,13 +838,13 @@ static int vduse_vdpa_set_map(struct vdpa_device *vdpa,
> > > > struct vduse_dev *dev = vdpa_to_vduse(vdpa);
> > > > int ret;
> > > >
> > > > - ret = vduse_domain_set_map(dev->as.domain, iotlb);
> > > > + ret = vduse_domain_set_map(dev->as[asid].domain, iotlb);
> > > > if (ret)
> > > > return ret;
> > > >
> > > > - ret = vduse_dev_update_iotlb(dev, 0ULL, ULLONG_MAX);
> > > > + ret = vduse_dev_update_iotlb(dev, asid, 0ULL, ULLONG_MAX);
> > > > if (ret) {
> > > > - vduse_domain_clear_map(dev->as.domain, iotlb);
> > > > + vduse_domain_clear_map(dev->as[asid].domain, iotlb);
> > > > return ret;
> > > > }
> > > >
> > > > @@ -841,6 +887,7 @@ static const struct vdpa_config_ops vduse_vdpa_config_ops = {
> > > > .get_vq_affinity = vduse_vdpa_get_vq_affinity,
> > > > .reset = vduse_vdpa_reset,
> > > > .set_map = vduse_vdpa_set_map,
> > > > + .set_group_asid = vduse_set_group_asid,
> > > > .get_vq_map = vduse_get_vq_map,
> > > > .free = vduse_vdpa_free,
> > > > };
> > > > @@ -850,9 +897,12 @@ static void vduse_dev_sync_single_for_device(union virtio_map token,
> > > > enum dma_data_direction dir)
> > > > {
> > > > struct vduse_dev *vdev = token.group->dev;
> > > > - struct vduse_iova_domain *domain = vdev->as.domain;
> > > > + struct vduse_iova_domain *domain;
> > > >
> > > > + read_lock(&vdev->domain_lock);
> > > > + domain = token.group->domain;
> > > > vduse_domain_sync_single_for_device(domain, dma_addr, size, dir);
> > > > + read_unlock(&vdev->domain_lock);
> > > > }
> > > >
> > > > static void vduse_dev_sync_single_for_cpu(union virtio_map token,
> > > > @@ -860,9 +910,12 @@ static void vduse_dev_sync_single_for_cpu(union virtio_map token,
> > > > enum dma_data_direction dir)
> > > > {
> > > > struct vduse_dev *vdev = token.group->dev;
> > > > - struct vduse_iova_domain *domain = vdev->as.domain;
> > > > + struct vduse_iova_domain *domain;
> > > >
> > > > + read_lock(&vdev->domain_lock);
> > > > + domain = token.group->domain;
> > >
> > > I think the domain is better fetched via vduse_as.
> > >
> > > > vduse_domain_sync_single_for_cpu(domain, dma_addr, size, dir);
> > > > + read_unlock(&vdev->domain_lock);
> > > > }
> > > >
> > > > static dma_addr_t vduse_dev_map_page(union virtio_map token, struct page *page,
> > > > @@ -871,9 +924,15 @@ static dma_addr_t vduse_dev_map_page(union virtio_map token, struct page *page,
> > > > unsigned long attrs)
> > > > {
> > > > struct vduse_dev *vdev = token.group->dev;
> > > > - struct vduse_iova_domain *domain = vdev->as.domain;
> > > > + struct vduse_iova_domain *domain;
> > > > + dma_addr_t r;
> > > >
> > > > - return vduse_domain_map_page(domain, page, offset, size, dir, attrs);
> > > > + read_lock(&vdev->domain_lock);
> > > > + domain = token.group->domain;
> > > > + r = vduse_domain_map_page(domain, page, offset, size, dir, attrs);
> > > > + read_unlock(&vdev->domain_lock);
> > > > +
> > > > + return r;
> > > > }
> > > >
> > > > static void vduse_dev_unmap_page(union virtio_map token, dma_addr_t dma_addr,
> > > > @@ -881,27 +940,31 @@ static void vduse_dev_unmap_page(union virtio_map token, dma_addr_t dma_addr,
> > > > unsigned long attrs)
> > > > {
> > > > struct vduse_dev *vdev = token.group->dev;
> > > > - struct vduse_iova_domain *domain = vdev->as.domain;
> > > > + struct vduse_iova_domain *domain;
> > > >
> > > > - return vduse_domain_unmap_page(domain, dma_addr, size, dir, attrs);
> > > > + read_lock(&vdev->domain_lock);
> > > > + domain = token.group->domain;
> > > > + vduse_domain_unmap_page(domain, dma_addr, size, dir, attrs);
> > > > + read_unlock(&vdev->domain_lock);
> > > > }
> > > >
> > > > static void *vduse_dev_alloc_coherent(union virtio_map token, size_t size,
> > > > dma_addr_t *dma_addr, gfp_t flag)
> > > > {
> > > > struct vduse_dev *vdev = token.group->dev;
> > > > - struct vduse_iova_domain *domain = vdev->as.domain;
> > > > + struct vduse_iova_domain *domain;
> > > > unsigned long iova;
> > > > - void *addr;
> > > > + void *addr = NULL;
> > > >
> > > > *dma_addr = DMA_MAPPING_ERROR;
> > > > + read_lock(&vdev->domain_lock);
> > > > + domain = token.group->domain;
> > > > addr = vduse_domain_alloc_coherent(domain, size,
> > > > (dma_addr_t *)&iova, flag);
> > > > - if (!addr)
> > > > - return NULL;
> > > > -
> > > > - *dma_addr = (dma_addr_t)iova;
> > > > + if (addr)
> > > > + *dma_addr = (dma_addr_t)iova;
> > > >
> > > > + read_unlock(&vdev->domain_lock);
> > > > return addr;
> > > > }
> > > >
> > > > @@ -910,17 +973,26 @@ static void vduse_dev_free_coherent(union virtio_map token, size_t size,
> > > > unsigned long attrs)
> > > > {
> > > > struct vduse_dev *vdev = token.group->dev;
> > > > - struct vduse_iova_domain *domain = vdev->as.domain;
> > > > + struct vduse_iova_domain *domain;
> > > >
> > > > + read_lock(&vdev->domain_lock);
> > > > + domain = token.group->domain;
> > > > vduse_domain_free_coherent(domain, size, vaddr, dma_addr, attrs);
> > > > + read_unlock(&vdev->domain_lock);
> > > > }
> > > >
> > > > static bool vduse_dev_need_sync(union virtio_map token, dma_addr_t dma_addr)
> > > > {
> > > > struct vduse_dev *vdev = token.group->dev;
> > > > - struct vduse_iova_domain *domain = vdev->as.domain;
> > > > + struct vduse_iova_domain *domain;
> > > > + size_t bounce_size;
> > > >
> > > > - return dma_addr < domain->bounce_size;
> > > > + read_lock(&vdev->domain_lock);
> > > > + domain = token.group->domain;
> > > > + bounce_size = domain->bounce_size;
> > > > + read_unlock(&vdev->domain_lock);
> > > > +
> > > > + return dma_addr < bounce_size;
> > > > }
> > > >
> > > > static int vduse_dev_mapping_error(union virtio_map token, dma_addr_t dma_addr)
> > > > @@ -933,9 +1005,15 @@ static int vduse_dev_mapping_error(union virtio_map token, dma_addr_t dma_addr)
> > > > static size_t vduse_dev_max_mapping_size(union virtio_map token)
> > > > {
> > > > struct vduse_dev *vdev = token.group->dev;
> > > > - struct vduse_iova_domain *domain = vdev->as.domain;
> > > > + struct vduse_iova_domain *domain;
> > > > + size_t bounce_size;
> > > > +
> > > > + read_lock(&vdev->domain_lock);
> > > > + domain = token.group->domain;
> > > > + bounce_size = domain->bounce_size;
> > > > + read_unlock(&vdev->domain_lock);
> > > >
> > > > - return domain->bounce_size;
> > > > + return bounce_size;
> > > > }
> > > >
> > > > static const struct virtio_map_ops vduse_map_ops = {
> > > > @@ -1075,39 +1153,40 @@ static int vduse_dev_queue_irq_work(struct vduse_dev *dev,
> > > > return ret;
> > > > }
> > > >
> > > > -static int vduse_dev_dereg_umem(struct vduse_dev *dev,
> > > > +static int vduse_dev_dereg_umem(struct vduse_dev *dev, u32 asid,
> > > > u64 iova, u64 size)
> > > > {
> > > > int ret;
> > > >
> > > > - mutex_lock(&dev->as.mem_lock);
> > > > + mutex_lock(&dev->as[asid].mem_lock);
> > > > ret = -ENOENT;
> > > > - if (!dev->as.umem)
> > > > + if (!dev->as[asid].umem)
> > > > goto unlock;
> > > >
> > > > ret = -EINVAL;
> > > > - if (!dev->as.domain)
> > > > + if (!dev->as[asid].domain)
> > > > goto unlock;
> > > >
> > > > - if (dev->as.umem->iova != iova || size != dev->as.domain->bounce_size)
> > > > + if (dev->as[asid].umem->iova != iova ||
> > > > + size != dev->as[asid].domain->bounce_size)
> > > > goto unlock;
> > > >
> > > > - vduse_domain_remove_user_bounce_pages(dev->as.domain);
> > > > - unpin_user_pages_dirty_lock(dev->as.umem->pages,
> > > > - dev->as.umem->npages, true);
> > > > - atomic64_sub(dev->as.umem->npages, &dev->as.umem->mm->pinned_vm);
> > > > - mmdrop(dev->as.umem->mm);
> > > > - vfree(dev->as.umem->pages);
> > > > - kfree(dev->as.umem);
> > > > - dev->as.umem = NULL;
> > > > + vduse_domain_remove_user_bounce_pages(dev->as[asid].domain);
> > > > + unpin_user_pages_dirty_lock(dev->as[asid].umem->pages,
> > > > + dev->as[asid].umem->npages, true);
> > > > + atomic64_sub(dev->as[asid].umem->npages, &dev->as[asid].umem->mm->pinned_vm);
> > > > + mmdrop(dev->as[asid].umem->mm);
> > > > + vfree(dev->as[asid].umem->pages);
> > > > + kfree(dev->as[asid].umem);
> > > > + dev->as[asid].umem = NULL;
> > >
> > > We can avoid those changeset if we do those in the previous correctly
> > > as it said it would make as an array.
> > >
> >
> > I'm not following it. Is that different from squashing this patch with
> > the previous one? I'm ok with doing it, but this changes are needed
> > either way.
>
> See my reply for whether we need to make it as an array in the last
> patch. I meant basically we only need to change them once, but this
> series touches this twice.
>
> Thanks
>
Powered by blists - more mailing lists