On Thu, Sep 18, 2025 at 7:22 PM Eugenio Perez Martin <[email protected]> wrote: > > On Wed, Sep 17, 2025 at 6:40 PM Eugenio Perez Martin > <[email protected]> wrote: > > > > On Wed, Sep 17, 2025 at 10:56 AM Jason Wang <[email protected]> wrote: > > > > > > On Tue, Sep 16, 2025 at 9:09 PM Eugenio Pérez <[email protected]> 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 <[email protected]> > > > > --- > > > > 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. > > > > > > }; > > > > > > > > @@ -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. > > > > > > + 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. > > > > > > ret = 0; > > > > unlock: > > > > - mutex_unlock(&dev->as.mem_lock); > > > > + mutex_unlock(&dev->as[asid].mem_lock); > > > > return ret; > > > > } > > > > > > > > static int vduse_dev_reg_umem(struct vduse_dev *dev, > > > > - u64 iova, u64 uaddr, u64 size) > > > > + u32 asid, u64 iova, u64 uaddr, u64 size) > > > > { > > > > struct page **page_list = NULL; > > > > struct vduse_umem *umem = NULL; > > > > @@ -1115,14 +1194,14 @@ static int vduse_dev_reg_umem(struct vduse_dev > > > > *dev, > > > > unsigned long npages, lock_limit; > > > > int ret; > > > > > > > > - if (!dev->as.domain || !dev->as.domain->bounce_map || > > > > - size != dev->as.domain->bounce_size || > > > > + if (!dev->as[asid].domain || !dev->as[asid].domain->bounce_map > > > > || > > > > + size != dev->as[asid].domain->bounce_size || > > > > iova != 0 || uaddr & ~PAGE_MASK) > > > > return -EINVAL; > > > > > > > > - mutex_lock(&dev->as.mem_lock); > > > > + mutex_lock(&dev->as[asid].mem_lock); > > > > ret = -EEXIST; > > > > - if (dev->as.umem) > > > > + if (dev->as[asid].umem) > > > > goto unlock; > > > > > > > > ret = -ENOMEM; > > > > @@ -1146,7 +1225,7 @@ static int vduse_dev_reg_umem(struct vduse_dev > > > > *dev, > > > > goto out; > > > > } > > > > > > > > - ret = vduse_domain_add_user_bounce_pages(dev->as.domain, > > > > + ret = vduse_domain_add_user_bounce_pages(dev->as[asid].domain, > > > > page_list, pinned); > > > > if (ret) > > > > goto out; > > > > @@ -1159,7 +1238,7 @@ static int vduse_dev_reg_umem(struct vduse_dev > > > > *dev, > > > > umem->mm = current->mm; > > > > mmgrab(current->mm); > > > > > > > > - dev->as.umem = umem; > > > > + dev->as[asid].umem = umem; > > > > out: > > > > if (ret && pinned > 0) > > > > unpin_user_pages(page_list, pinned); > > > > @@ -1170,7 +1249,7 @@ static int vduse_dev_reg_umem(struct vduse_dev > > > > *dev, > > > > vfree(page_list); > > > > kfree(umem); > > > > } > > > > - mutex_unlock(&dev->as.mem_lock); > > > > + mutex_unlock(&dev->as[asid].mem_lock); > > > > return ret; > > > > } > > > > > > > > @@ -1202,47 +1281,66 @@ static long vduse_dev_ioctl(struct file *file, > > > > unsigned int cmd, > > > > > > > > switch (cmd) { > > > > case VDUSE_IOTLB_GET_FD: { > > > > - struct vduse_iotlb_entry entry; > > > > + struct vduse_iotlb_entry_v2 entry; > > > > struct vhost_iotlb_map *map; > > > > struct vdpa_map_file *map_file; > > > > struct file *f = NULL; > > > > + u32 asid; > > > > > > > > ret = -EFAULT; > > > > - if (copy_from_user(&entry, argp, sizeof(entry))) > > > > - break; > > > > + if (dev->api_version >= VDUSE_API_VERSION_1) { > > > > + if (copy_from_user(&entry, argp, sizeof(entry))) > > > > + break; > > > > + } else { > > > > + entry.asid = 0; > > > > + if (copy_from_user(&entry.v1, argp, > > > > + sizeof(entry.v1))) > > > > + break; > > > > + } > > > > > > > > ret = -EINVAL; > > > > - if (entry.start > entry.last) > > > > + if (entry.v1.start > entry.v1.last) > > > > + break; > > > > + > > > > + if (entry.asid >= dev->nas) > > > > break; > > > > > > > > read_lock(&dev->domain_lock); > > > > - if (!dev->as.domain) { > > > > + asid = array_index_nospec(entry.asid, dev->nas); > > > > + if (!dev->as[asid].domain) { > > > > read_unlock(&dev->domain_lock); > > > > break; > > > > } > > > > - spin_lock(&dev->as.domain->iotlb_lock); > > > > - map = vhost_iotlb_itree_first(dev->as.domain->iotlb, > > > > - entry.start, entry.last); > > > > + spin_lock(&dev->as[asid].domain->iotlb_lock); > > > > + map = > > > > vhost_iotlb_itree_first(dev->as[asid].domain->iotlb, > > > > + entry.v1.start, > > > > entry.v1.last); > > > > if (map) { > > > > map_file = (struct vdpa_map_file *)map->opaque; > > > > f = get_file(map_file->file); > > > > - entry.offset = map_file->offset; > > > > - entry.start = map->start; > > > > - entry.last = map->last; > > > > - entry.perm = map->perm; > > > > + entry.v1.offset = map_file->offset; > > > > + entry.v1.start = map->start; > > > > + entry.v1.last = map->last; > > > > + entry.v1.perm = map->perm; > > > > } > > > > - spin_unlock(&dev->as.domain->iotlb_lock); > > > > + spin_unlock(&dev->as[asid].domain->iotlb_lock); > > > > read_unlock(&dev->domain_lock); > > > > ret = -EINVAL; > > > > if (!f) > > > > break; > > > > > > > > ret = -EFAULT; > > > > - if (copy_to_user(argp, &entry, sizeof(entry))) { > > > > + if (dev->api_version >= VDUSE_API_VERSION_1) > > > > + ret = copy_to_user(argp, &entry, > > > > + sizeof(entry)); > > > > + else > > > > + ret = copy_to_user(argp, &entry.v1, > > > > + sizeof(entry.v1)); > > > > + > > > > + if (ret) { > > > > fput(f); > > > > break; > > > > } > > > > - ret = receive_fd(f, NULL, > > > > perm_to_file_flags(entry.perm)); > > > > + ret = receive_fd(f, NULL, > > > > perm_to_file_flags(entry.v1.perm)); > > > > > > Nit: if we copy_from_user() twice and stick entry for v1 format, we > > > can avoid a lot of lines of changes. > > > > > > > Let me draft something and put it as a reply here to check I'm > > understanding your proposal. > > > > We need a "struct vduse_iotlb_entry_v2" sooner or later anyway because > we need to finish with the corresponding copy_to_user. Either that, or > duplicate the copy_to_user too with something like: > copy_to_user(argp, &entry_vq, sizeof(entry_v1); > copy_to_user(argp + sizeof(struct vduse_iotlb_entry), &asid, sizeof(asid); > > Saving the struct vduse_iotlb_entry_v2, this is the only change I can > do in that direction (from this patch): > > diff --git a/drivers/vdpa/vdpa_user/vduse_dev.c > b/drivers/vdpa/vdpa_user/vduse_dev.c > index 7da248f5616c..555b0fa079de 100644 > --- a/drivers/vdpa/vdpa_user/vduse_dev.c > +++ b/drivers/vdpa/vdpa_user/vduse_dev.c > @@ -1341,14 +1341,13 @@ static long vduse_dev_ioctl(struct file *file, > unsigned int cmd, > u32 asid; > > ret = -EFAULT; > - if (dev->api_version >= VDUSE_API_VERSION_1) { > - if (copy_from_user(&entry, argp, sizeof(entry))) > - break; > - } else { > + if (copy_from_user(&entry.v1, argp, sizeof(entry.v1))) > + break; > + if (dev->api_version < VDUSE_API_VERSION_1) { > entry.asid = 0; > - if (copy_from_user(&entry.v1, argp, > - sizeof(entry.v1))) > - break; > + } else if (copy_from_user(&entry.asid, argp, > + sizeof(entry.asid))) { > + break; > } > > ret = -EINVAL;
Ok, I see, just choose the one that is easier for you. Thanks
