vfio iommu: Update UNMAP_DMA ioctl to get dirty bitmap before unmap

DMA mapped pages, including those pinned by mdev vendor drivers, might
get unpinned and unmapped while migration is active and device is still
running. For example, in pre-copy phase while guest driver could access
those pages, host device or vendor driver can dirty these mapped pages.
Such pages should be marked dirty so as to maintain memory consistency
for a user making use of dirty page tracking.

To get bitmap during unmap, user should allocate memory for bitmap, set
it all zeros, set size of allocated memory, set page size to be
considered for bitmap and set flag VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP.

Signed-off-by: Kirti Wankhede <kwankhede@nvidia.com>
Reviewed-by: Neo Jia <cjia@nvidia.com>
Reviewed-by: Cornelia Huck <cohuck@redhat.com>
Reviewed-by: Yan Zhao <yan.y.zhao@intel.com>
Signed-off-by: Alex Williamson <alex.williamson@redhat.com>

diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type1.c
index be6fc0d88633b8ae28cb59174b65755d462856eb..e31fcc23e81ac2ebfee07924e6aa01a028156714 100644 (file)
--- a/drivers/vfio/vfio_iommu_type1.c
+++ b/drivers/vfio/vfio_iommu_type1.c
@@ -1049,23 +1049,25 @@ static int verify_bitmap_size(uint64_t npages, uint64_t bitmap_size)
 }
 
 static int vfio_dma_do_unmap(struct vfio_iommu *iommu,
-                            struct vfio_iommu_type1_dma_unmap *unmap)
+                            struct vfio_iommu_type1_dma_unmap *unmap,
+                            struct vfio_bitmap *bitmap)
 {
-       uint64_t mask;
        struct vfio_dma *dma, *dma_last = NULL;
-       size_t unmapped = 0;
+       size_t unmapped = 0, pgsize;
        int ret = 0, retries = 0;
+       unsigned long pgshift;
 
        mutex_lock(&iommu->lock);
 
-       mask = ((uint64_t)1 << __ffs(iommu->pgsize_bitmap)) - 1;
+       pgshift = __ffs(iommu->pgsize_bitmap);
+       pgsize = (size_t)1 << pgshift;
 
-       if (unmap->iova & mask) {
+       if (unmap->iova & (pgsize - 1)) {
                ret = -EINVAL;
                goto unlock;
        }
 
-       if (!unmap->size || unmap->size & mask) {
+       if (!unmap->size || unmap->size & (pgsize - 1)) {
                ret = -EINVAL;
                goto unlock;
        }
@@ -1076,9 +1078,15 @@ static int vfio_dma_do_unmap(struct vfio_iommu *iommu,
                goto unlock;
        }
 
-       WARN_ON(mask & PAGE_MASK);
-again:
+       /* When dirty tracking is enabled, allow only min supported pgsize */
+       if ((unmap->flags & VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP) &&
+           (!iommu->dirty_page_tracking || (bitmap->pgsize != pgsize))) {
+               ret = -EINVAL;
+               goto unlock;
+       }
 
+       WARN_ON((pgsize - 1) & PAGE_MASK);
+again:
        /*
         * vfio-iommu-type1 (v1) - User mappings were coalesced together to
         * avoid tracking individual mappings.  This means that the granularity
@@ -1159,6 +1167,14 @@ again:
                        mutex_lock(&iommu->lock);
                        goto again;
                }
+
+               if (unmap->flags & VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP) {
+                       ret = update_user_bitmap(bitmap->data, dma,
+                                                unmap->iova, pgsize);
+                       if (ret)
+                               break;
+               }
+
                unmapped += dma->size;
                vfio_remove_dma(iommu, dma);
        }
@@ -2497,17 +2513,40 @@ static long vfio_iommu_type1_ioctl(void *iommu_data,
 
        } else if (cmd == VFIO_IOMMU_UNMAP_DMA) {
                struct vfio_iommu_type1_dma_unmap unmap;
-               long ret;
+               struct vfio_bitmap bitmap = { 0 };
+               int ret;
 
                minsz = offsetofend(struct vfio_iommu_type1_dma_unmap, size);
 
                if (copy_from_user(&unmap, (void __user *)arg, minsz))
                        return -EFAULT;
 
-               if (unmap.argsz < minsz || unmap.flags)
+               if (unmap.argsz < minsz ||
+                   unmap.flags & ~VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP)
                        return -EINVAL;
 
-               ret = vfio_dma_do_unmap(iommu, &unmap);
+               if (unmap.flags & VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP) {
+                       unsigned long pgshift;
+
+                       if (unmap.argsz < (minsz + sizeof(bitmap)))
+                               return -EINVAL;
+
+                       if (copy_from_user(&bitmap,
+                                          (void __user *)(arg + minsz),
+                                          sizeof(bitmap)))
+                               return -EFAULT;
+
+                       if (!access_ok((void __user *)bitmap.data, bitmap.size))
+                               return -EINVAL;
+
+                       pgshift = __ffs(bitmap.pgsize);
+                       ret = verify_bitmap_size(unmap.size >> pgshift,
+                                                bitmap.size);
+                       if (ret)
+                               return ret;
+               }
+
+               ret = vfio_dma_do_unmap(iommu, &unmap, &bitmap);
                if (ret)
                        return ret;
 

diff --git a/include/uapi/linux/vfio.h b/include/uapi/linux/vfio.h
index 009a8c80079d439805a4d48b137a38abf1bc669e..ff4b6706f7df88e0e0ce28b249759bbf8648b955 100644 (file)
--- a/include/uapi/linux/vfio.h
+++ b/include/uapi/linux/vfio.h
@@ -1048,12 +1048,23 @@ struct vfio_bitmap {
  * field.  No guarantee is made to the user that arbitrary unmaps of iova
  * or size different from those used in the original mapping call will
  * succeed.
+ * VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP should be set to get the dirty bitmap
+ * before unmapping IO virtual addresses. When this flag is set, the user must
+ * provide a struct vfio_bitmap in data[]. User must provide zero-allocated
+ * memory via vfio_bitmap.data and its size in the vfio_bitmap.size field.
+ * A bit in the bitmap represents one page, of user provided page size in
+ * vfio_bitmap.pgsize field, consecutively starting from iova offset. Bit set
+ * indicates that the page at that offset from iova is dirty. A Bitmap of the
+ * pages in the range of unmapped size is returned in the user-provided
+ * vfio_bitmap.data.
  */
 struct vfio_iommu_type1_dma_unmap {
        __u32   argsz;
        __u32   flags;
+#define VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP (1 << 0)
        __u64   iova;                           /* IO virtual address */
        __u64   size;                           /* Size of mapping (bytes) */
+       __u8    data[];
 };
 
 #define VFIO_IOMMU_UNMAP_DMA _IO(VFIO_TYPE, VFIO_BASE + 14)