Re: [PATCH v14 Kernel 4/7] vfio iommu: Implementation of ioctl for dirty pages tracking.

[Alex Williamson]

On Thu, 19 Mar 2020 20:22:41 +0530
Kirti Wankhede <address@hidden> wrote:

> On 3/19/2020 9:15 AM, Alex Williamson wrote:
> > On Thu, 19 Mar 2020 01:11:11 +0530
> > Kirti Wankhede <address@hidden> wrote:
> >   
> >> VFIO_IOMMU_DIRTY_PAGES ioctl performs three operations:
> >> - Start dirty pages tracking while migration is active
> >> - Stop dirty pages tracking.
> >> - Get dirty pages bitmap. Its user space application's responsibility to
> >>    copy content of dirty pages from source to destination during migration.
> >>
> >> To prevent DoS attack, memory for bitmap is allocated per vfio_dma
> >> structure. Bitmap size is calculated considering smallest supported page
> >> size. Bitmap is allocated for all vfio_dmas when dirty logging is enabled
> >>
> >> Bitmap is populated for already pinned pages when bitmap is allocated for
> >> a vfio_dma with the smallest supported page size. Update bitmap from
> >> pinning functions when tracking is enabled. When user application queries
> >> bitmap, check if requested page size is same as page size used to
> >> populated bitmap. If it is equal, copy bitmap, but if not equal, return
> >> error.
> >>
> >> Signed-off-by: Kirti Wankhede <address@hidden>
> >> Reviewed-by: Neo Jia <address@hidden>
> >> ---
> >>   drivers/vfio/vfio_iommu_type1.c | 205 
> >> +++++++++++++++++++++++++++++++++++++++-
> >>   1 file changed, 203 insertions(+), 2 deletions(-)
> >>
> >> diff --git a/drivers/vfio/vfio_iommu_type1.c 
> >> b/drivers/vfio/vfio_iommu_type1.c
> >> index 70aeab921d0f..d6417fb02174 100644
> >> --- a/drivers/vfio/vfio_iommu_type1.c
> >> +++ b/drivers/vfio/vfio_iommu_type1.c
> >> @@ -71,6 +71,7 @@ struct vfio_iommu {
> >>    unsigned int            dma_avail;
> >>    bool                    v2;
> >>    bool                    nesting;
> >> +  bool                    dirty_page_tracking;
> >>   };
> >>   
> >>   struct vfio_domain {
> >> @@ -91,6 +92,7 @@ struct vfio_dma {
> >>    bool                    lock_cap;       /* capable(CAP_IPC_LOCK) */
> >>    struct task_struct      *task;
> >>    struct rb_root          pfn_list;       /* Ex-user pinned pfn list */
> >> +  unsigned long           *bitmap;  
> > 
> > We've made the bitmap a width invariant u64 else, should be here as
> > well.
> >   
> >>   };
> >>   
> >>   struct vfio_group {
> >> @@ -125,7 +127,10 @@ struct vfio_regions {
> >>   #define IS_IOMMU_CAP_DOMAIN_IN_CONTAINER(iommu)  \
> >>                                    (!list_empty(&iommu->domain_list))
> >>   
> >> +#define DIRTY_BITMAP_BYTES(n)     (ALIGN(n, BITS_PER_TYPE(u64)) / 
> >> BITS_PER_BYTE)
> >> +
> >>   static int put_pfn(unsigned long pfn, int prot);
> >> +static unsigned long vfio_pgsize_bitmap(struct vfio_iommu *iommu);
> >>   
> >>   /*
> >>    * This code handles mapping and unmapping of user data buffers
> >> @@ -175,6 +180,55 @@ static void vfio_unlink_dma(struct vfio_iommu *iommu, 
> >> struct vfio_dma *old)
> >>    rb_erase(&old->node, &iommu->dma_list);
> >>   }
> >>   
> >> +static int vfio_dma_bitmap_alloc(struct vfio_iommu *iommu, uint64_t 
> >> pgsize)
> >> +{
> >> +  struct rb_node *n = rb_first(&iommu->dma_list);
> >> +
> >> +  for (; n; n = rb_next(n)) {
> >> +          struct vfio_dma *dma = rb_entry(n, struct vfio_dma, node);
> >> +          struct rb_node *p;
> >> +          unsigned long npages = dma->size / pgsize;
> >> +
> >> +          dma->bitmap = kvzalloc(DIRTY_BITMAP_BYTES(npages), GFP_KERNEL);
> >> +          if (!dma->bitmap) {
> >> +                  struct rb_node *p = rb_prev(n);
> >> +
> >> +                  for (; p; p = rb_prev(p)) {
> >> +                          struct vfio_dma *dma = rb_entry(n,
> >> +                                                  struct vfio_dma, node);
> >> +
> >> +                          kfree(dma->bitmap);
> >> +                          dma->bitmap = NULL;
> >> +                  }
> >> +                  return -ENOMEM;
> >> +          }
> >> +
> >> +          if (RB_EMPTY_ROOT(&dma->pfn_list))
> >> +                  continue;
> >> +
> >> +          for (p = rb_first(&dma->pfn_list); p; p = rb_next(p)) {
> >> +                  struct vfio_pfn *vpfn = rb_entry(p, struct vfio_pfn,
> >> +                                                   node);
> >> +
> >> +                  bitmap_set(dma->bitmap,
> >> +                                  (vpfn->iova - dma->iova) / pgsize, 1);
> >> +          }
> >> +  }
> >> +  return 0;
> >> +}
> >> +
> >> +static void vfio_dma_bitmap_free(struct vfio_iommu *iommu)
> >> +{
> >> +  struct rb_node *n = rb_first(&iommu->dma_list);
> >> +
> >> +  for (; n; n = rb_next(n)) {
> >> +          struct vfio_dma *dma = rb_entry(n, struct vfio_dma, node);
> >> +
> >> +          kfree(dma->bitmap);
> >> +          dma->bitmap = NULL;
> >> +  }
> >> +}
> >> +
> >>   /*
> >>    * Helper Functions for host iova-pfn list
> >>    */
> >> @@ -567,6 +621,14 @@ static int vfio_iommu_type1_pin_pages(void 
> >> *iommu_data,
> >>                    vfio_unpin_page_external(dma, iova, do_accounting);
> >>                    goto pin_unwind;
> >>            }
> >> +
> >> +          if (iommu->dirty_page_tracking) {
> >> +                  unsigned long pgshift =
> >> +                                   __ffs(vfio_pgsize_bitmap(iommu));
> >> +
> >> +                  bitmap_set(dma->bitmap,
> >> +                             (vpfn->iova - dma->iova) >> pgshift, 1);
> >> +          }
> >>    }
> >>   
> >>    ret = i;
> >> @@ -801,6 +863,7 @@ static void vfio_remove_dma(struct vfio_iommu *iommu, 
> >> struct vfio_dma *dma)
> >>    vfio_unmap_unpin(iommu, dma, true);
> >>    vfio_unlink_dma(iommu, dma);
> >>    put_task_struct(dma->task);
> >> +  kfree(dma->bitmap);
> >>    kfree(dma);
> >>    iommu->dma_avail++;
> >>   }
> >> @@ -831,6 +894,50 @@ static unsigned long vfio_pgsize_bitmap(struct 
> >> vfio_iommu *iommu)
> >>    return bitmap;
> >>   }
> >>   
> >> +static int vfio_iova_dirty_bitmap(struct vfio_iommu *iommu, dma_addr_t 
> >> iova,
> >> +                            size_t size, uint64_t pgsize,
> >> +                            unsigned char __user *bitmap)  
> > 
> > And here, why do callers cast to an unsigned char pointer when we're
> > going to cast to a void pointer anyway?  Should be a u64 __user pointer.
> >   
> >> +{
> >> +  struct vfio_dma *dma;
> >> +  unsigned long pgshift = __ffs(pgsize);
> >> +  unsigned int npages, bitmap_size;
> >> +
> >> +  dma = vfio_find_dma(iommu, iova, 1);
> >> +
> >> +  if (!dma)
> >> +          return -EINVAL;
> >> +
> >> +  if (dma->iova != iova || dma->size != size)
> >> +          return -EINVAL;
> >> +
> >> +  npages = dma->size >> pgshift;
> >> +  bitmap_size = DIRTY_BITMAP_BYTES(npages);
> >> +
> >> +  /* mark all pages dirty if all pages are pinned and mapped. */
> >> +  if (dma->iommu_mapped)
> >> +          bitmap_set(dma->bitmap, 0, npages);
> >> +
> >> +  if (copy_to_user((void __user *)bitmap, dma->bitmap, bitmap_size))
> >> +          return -EFAULT;
> >> +
> >> +  return 0;
> >> +}
> >> +
> >> +static int verify_bitmap_size(uint64_t npages, uint64_t bitmap_size)
> >> +{
> >> +  uint64_t bsize;
> >> +
> >> +  if (!npages || !bitmap_size || bitmap_size > UINT_MAX)  
> > 
> > As commented previously, how do we derive this UINT_MAX limitation?
> >   
> 
> Sorry, I missed that earlier
> 
>  > UINT_MAX seems arbitrary, is this specified in our API?  The size of a
>  > vfio_dma is limited to what the user is able to pin, and therefore
>  > their locked memory limit, but do we have an explicit limit elsewhere
>  > that results in this limit here.  I think a 4GB bitmap would track
>  > something like 2^47 bytes of memory, that's pretty excessive, but still
>  > an arbitrary limit.  
> 
> There has to be some upper limit check. In core KVM, in
> virt/kvm/kvm_main.c there is max number of pages check:
> 
> if (new.npages > KVM_MEM_MAX_NR_PAGES)
> 
> Where
> /*
>   * Some of the bitops functions do not support too long bitmaps.
>   * This number must be determined not to exceed such limits.
>   */
> #define KVM_MEM_MAX_NR_PAGES ((1UL << 31) - 1)
> 
> Though I don't know which bitops functions do not support long bitmaps.
> 
> Something similar as above can be done or same as you also mentioned of 
> 4GB bitmap limit? that is U32_MAX instead of UINT_MAX?

Let's see, we use bitmap_set():

void bitmap_set(unsigned long *map, unsigned int start, unsigned int nbits)

So we're limited to an unsigned int number of bits, but for an
unaligned, multi-bit operation this will call __bitmap_set():

void __bitmap_set(unsigned long *map, unsigned int start, int len)

So we're down to a signed int number of bits (seems like an API bug in
bitops there), so it makes sense that KVM is testing against MAX_INT
number of pages, ie. number of bits.  But that still suggests a bitmap
size of MAX_UINT is off by a factor of 16.  So we can have 2^31 bits
divided by 2^3 bits/byte yields a maximum bitmap size of 2^28 (ie.
256MB), which maps 2^31 * 2^12 = 2^43 (8TB) on a 4K system.

Let's fix the limit check and put a nice comment explaining it.  Thanks,

Alex

> >> +          return -EINVAL;
> >> +
> >> +  bsize = DIRTY_BITMAP_BYTES(npages);
> >> +
> >> +  if (bitmap_size < bsize)
> >> +          return -EINVAL;
> >> +
> >> +  return 0;
> >> +}
> >> +
> >>   static int vfio_dma_do_unmap(struct vfio_iommu *iommu,
> >>                         struct vfio_iommu_type1_dma_unmap *unmap)
> >>   {  
> > 
> > We didn't address that vfio_dma_do_map() needs to kvzalloc a bitmap for
> > any new vfio_dma created while iommu->dirty_page_tracking = true.
> >   
> 
> Good point. Adding it.
> 
> Thanks,
> Kirti
> 
> >> @@ -2278,6 +2385,93 @@ static long vfio_iommu_type1_ioctl(void *iommu_data,
> >>   
> >>            return copy_to_user((void __user *)arg, &unmap, minsz) ?
> >>                    -EFAULT : 0;
> >> +  } else if (cmd == VFIO_IOMMU_DIRTY_PAGES) {
> >> +          struct vfio_iommu_type1_dirty_bitmap dirty;
> >> +          uint32_t mask = VFIO_IOMMU_DIRTY_PAGES_FLAG_START |
> >> +                          VFIO_IOMMU_DIRTY_PAGES_FLAG_STOP |
> >> +                          VFIO_IOMMU_DIRTY_PAGES_FLAG_GET_BITMAP;
> >> +          int ret = 0;
> >> +
> >> +          if (!iommu->v2)
> >> +                  return -EACCES;
> >> +
> >> +          minsz = offsetofend(struct vfio_iommu_type1_dirty_bitmap,
> >> +                              flags);
> >> +
> >> +          if (copy_from_user(&dirty, (void __user *)arg, minsz))
> >> +                  return -EFAULT;
> >> +
> >> +          if (dirty.argsz < minsz || dirty.flags & ~mask)
> >> +                  return -EINVAL;
> >> +
> >> +          /* only one flag should be set at a time */
> >> +          if (__ffs(dirty.flags) != __fls(dirty.flags))
> >> +                  return -EINVAL;
> >> +
> >> +          if (dirty.flags & VFIO_IOMMU_DIRTY_PAGES_FLAG_START) {
> >> +                  uint64_t pgsize = 1 << __ffs(vfio_pgsize_bitmap(iommu));
> >> +
> >> +                  mutex_lock(&iommu->lock);
> >> +                  if (!iommu->dirty_page_tracking) {
> >> +                          ret = vfio_dma_bitmap_alloc(iommu, pgsize);
> >> +                          if (!ret)
> >> +                                  iommu->dirty_page_tracking = true;
> >> +                  }
> >> +                  mutex_unlock(&iommu->lock);
> >> +                  return ret;
> >> +          } else if (dirty.flags & VFIO_IOMMU_DIRTY_PAGES_FLAG_STOP) {
> >> +                  mutex_lock(&iommu->lock);
> >> +                  if (iommu->dirty_page_tracking) {
> >> +                          iommu->dirty_page_tracking = false;
> >> +                          vfio_dma_bitmap_free(iommu);
> >> +                  }
> >> +                  mutex_unlock(&iommu->lock);
> >> +                  return 0;
> >> +          } else if (dirty.flags &
> >> +                           VFIO_IOMMU_DIRTY_PAGES_FLAG_GET_BITMAP) {
> >> +                  struct vfio_iommu_type1_dirty_bitmap_get range;
> >> +                  unsigned long pgshift;
> >> +                  size_t data_size = dirty.argsz - minsz;
> >> +                  uint64_t iommu_pgsize =
> >> +                                   1 << __ffs(vfio_pgsize_bitmap(iommu));
> >> +
> >> +                  if (!data_size || data_size < sizeof(range))
> >> +                          return -EINVAL;
> >> +
> >> +                  if (copy_from_user(&range, (void __user *)(arg + minsz),
> >> +                                     sizeof(range)))
> >> +                          return -EFAULT;
> >> +
> >> +                  /* allow only min supported pgsize */
> >> +                  if (range.bitmap.pgsize != iommu_pgsize)
> >> +                          return -EINVAL;
> >> +                  if (range.iova & (iommu_pgsize - 1))
> >> +                          return -EINVAL;
> >> +                  if (!range.size || range.size & (iommu_pgsize - 1))
> >> +                          return -EINVAL;
> >> +                  if (range.iova + range.size < range.iova)
> >> +                          return -EINVAL;
> >> +                  if (!access_ok((void __user *)range.bitmap.data,
> >> +                                 range.bitmap.size))
> >> +                          return -EINVAL;
> >> +
> >> +                  pgshift = __ffs(range.bitmap.pgsize);
> >> +                  ret = verify_bitmap_size(range.size >> pgshift,
> >> +                                           range.bitmap.size);
> >> +                  if (ret)
> >> +                          return ret;
> >> +
> >> +                  mutex_lock(&iommu->lock);
> >> +                  if (iommu->dirty_page_tracking)
> >> +                          ret = vfio_iova_dirty_bitmap(iommu, range.iova,
> >> +                                   range.size, range.bitmap.pgsize,
> >> +                              (unsigned char __user *)range.bitmap.data);
> >> +                  else
> >> +                          ret = -EINVAL;
> >> +                  mutex_unlock(&iommu->lock);
> >> +
> >> +                  return ret;
> >> +          }
> >>    }
> >>   
> >>    return -ENOTTY;
> >> @@ -2345,10 +2539,17 @@ static int vfio_iommu_type1_dma_rw_chunk(struct 
> >> vfio_iommu *iommu,
> >>   
> >>    vaddr = dma->vaddr + offset;
> >>   
> >> -  if (write)
> >> +  if (write) {
> >>            *copied = __copy_to_user((void __user *)vaddr, data,
> >>                                     count) ? 0 : count;
> >> -  else
> >> +          if (*copied && iommu->dirty_page_tracking) {
> >> +                  unsigned long pgshift =
> >> +                          __ffs(vfio_pgsize_bitmap(iommu));
> >> +
> >> +                  bitmap_set(dma->bitmap, offset >> pgshift,
> >> +                             *copied >> pgshift);
> >> +          }
> >> +  } else  
> > 
> > Great, thanks for adding this!
> >   
> >>            *copied = __copy_from_user(data, (void __user *)vaddr,
> >>                                       count) ? 0 : count;
> >>    if (kthread)  
> >   
>