drivers/vfio/vfio_iommu_type1.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * VFIO: IOMMU DMA mapping support for Type1 IOMMU
   4  *
   5  * Copyright (C) 2012 Red Hat, Inc.  All rights reserved.
   6  *     Author: Alex Williamson <alex.williamson@redhat.com>
   7  *
   8  * Derived from original vfio:
   9  * Copyright 2010 Cisco Systems, Inc.  All rights reserved.
  10  * Author: Tom Lyon, pugs@cisco.com
  11  *
  12  * We arbitrarily define a Type1 IOMMU as one matching the below code.
  13  * It could be called the x86 IOMMU as it's designed for AMD-Vi & Intel
  14  * VT-d, but that makes it harder to re-use as theoretically anyone
  15  * implementing a similar IOMMU could make use of this.  We expect the
  16  * IOMMU to support the IOMMU API and have few to no restrictions around
  17  * the IOVA range that can be mapped.  The Type1 IOMMU is currently
  18  * optimized for relatively static mappings of a userspace process with
  19  * userpsace pages pinned into memory.  We also assume devices and IOMMU
  20  * domains are PCI based as the IOMMU API is still centered around a
  21  * device/bus interface rather than a group interface.
  22  */
  23
  24 #include <linux/compat.h>
  25 #include <linux/device.h>
  26 #include <linux/fs.h>
  27 #include <linux/highmem.h>
  28 #include <linux/iommu.h>
  29 #include <linux/module.h>
  30 #include <linux/mm.h>
  31 #include <linux/kthread.h>
  32 #include <linux/rbtree.h>
  33 #include <linux/sched/signal.h>
  34 #include <linux/sched/mm.h>
  35 #include <linux/slab.h>
  36 #include <linux/uaccess.h>
  37 #include <linux/vfio.h>
  38 #include <linux/workqueue.h>
  39 #include <linux/mdev.h>
  40 #include <linux/notifier.h>
  41 #include <linux/dma-iommu.h>
  42 #include <linux/irqdomain.h>
  43
  44 #define DRIVER_VERSION  "0.2"
  45 #define DRIVER_AUTHOR   "Alex Williamson <alex.williamson@redhat.com>"
  46 #define DRIVER_DESC     "Type1 IOMMU driver for VFIO"
  47
  48 static bool allow_unsafe_interrupts;
  49 module_param_named(allow_unsafe_interrupts,
  50                    allow_unsafe_interrupts, bool, S_IRUGO | S_IWUSR);
  51 MODULE_PARM_DESC(allow_unsafe_interrupts,
  52                  "Enable VFIO IOMMU support for on platforms without interrupt remapping support.");
  53
  54 static bool disable_hugepages;
  55 module_param_named(disable_hugepages,
  56                    disable_hugepages, bool, S_IRUGO | S_IWUSR);
  57 MODULE_PARM_DESC(disable_hugepages,
  58                  "Disable VFIO IOMMU support for IOMMU hugepages.");
  59
  60 static unsigned int dma_entry_limit __read_mostly = U16_MAX;
  61 module_param_named(dma_entry_limit, dma_entry_limit, uint, 0644);
  62 MODULE_PARM_DESC(dma_entry_limit,
  63                  "Maximum number of user DMA mappings per container (65535).");
  64
  65 struct vfio_iommu {
  66         struct list_head        domain_list;
  67         struct list_head        iova_list;
  68         struct vfio_domain      *external_domain; /* domain for external user */
  69         struct mutex            lock;
  70         struct rb_root          dma_list;
  71         struct blocking_notifier_head notifier;
  72         unsigned int            dma_avail;
  73         unsigned int            vaddr_invalid_count;
  74         uint64_t                pgsize_bitmap;
  75         uint64_t                num_non_pinned_groups;
  76         wait_queue_head_t       vaddr_wait;
  77         bool                    v2;
  78         bool                    nesting;
  79         bool                    dirty_page_tracking;
  80         bool                    pinned_page_dirty_scope;
  81         bool                    container_open;
  82 };
  83
  84 struct vfio_domain {
  85         struct iommu_domain     *domain;
  86         struct list_head        next;
  87         struct list_head        group_list;
  88         int                     prot;           /* IOMMU_CACHE */
  89         bool                    fgsp;           /* Fine-grained super pages */
  90 };
  91
  92 struct vfio_dma {
  93         struct rb_node          node;
  94         dma_addr_t              iova;           /* Device address */
  95         unsigned long           vaddr;          /* Process virtual addr */
  96         size_t                  size;           /* Map size (bytes) */
  97         int                     prot;           /* IOMMU_READ/WRITE */
  98         bool                    iommu_mapped;
  99         bool                    lock_cap;       /* capable(CAP_IPC_LOCK) */
 100         bool                    vaddr_invalid;
 101         struct task_struct      *task;
 102         struct rb_root          pfn_list;       /* Ex-user pinned pfn list */
 103         unsigned long           *bitmap;
 104 };
 105
 106 struct vfio_batch {
 107         struct page             **pages;        /* for pin_user_pages_remote */
 108         struct page             *fallback_page; /* if pages alloc fails */
 109         int                     capacity;       /* length of pages array */
 110         int                     size;           /* of batch currently */
 111         int                     offset;         /* of next entry in pages */
 112 };
 113
 114 struct vfio_group {
 115         struct iommu_group      *iommu_group;
 116         struct list_head        next;
 117         bool                    mdev_group;     /* An mdev group */
 118         bool                    pinned_page_dirty_scope;
 119 };
 120
 121 struct vfio_iova {
 122         struct list_head        list;
 123         dma_addr_t              start;
 124         dma_addr_t              end;
 125 };
 126
 127 /*
 128  * Guest RAM pinning working set or DMA target
 129  */
 130 struct vfio_pfn {
 131         struct rb_node          node;
 132         dma_addr_t              iova;           /* Device address */
 133         unsigned long           pfn;            /* Host pfn */
 134         unsigned int            ref_count;
 135 };
 136
 137 struct vfio_regions {
 138         struct list_head list;
 139         dma_addr_t iova;
 140         phys_addr_t phys;
 141         size_t len;
 142 };
 143
 144 #define IS_IOMMU_CAP_DOMAIN_IN_CONTAINER(iommu) \
 145                                         (!list_empty(&iommu->domain_list))
 146
 147 #define DIRTY_BITMAP_BYTES(n)   (ALIGN(n, BITS_PER_TYPE(u64)) / BITS_PER_BYTE)
 148
 149 /*
 150  * Input argument of number of bits to bitmap_set() is unsigned integer, which
 151  * further casts to signed integer for unaligned multi-bit operation,
 152  * __bitmap_set().
 153  * Then maximum bitmap size supported is 2^31 bits divided by 2^3 bits/byte,
 154  * that is 2^28 (256 MB) which maps to 2^31 * 2^12 = 2^43 (8TB) on 4K page
 155  * system.
 156  */
 157 #define DIRTY_BITMAP_PAGES_MAX   ((u64)INT_MAX)
 158 #define DIRTY_BITMAP_SIZE_MAX    DIRTY_BITMAP_BYTES(DIRTY_BITMAP_PAGES_MAX)
 159
 160 #define WAITED 1
 161
 162 static int put_pfn(unsigned long pfn, int prot);
 163
 164 static struct vfio_group *vfio_iommu_find_iommu_group(struct vfio_iommu *iommu,
 165                                                struct iommu_group *iommu_group);
 166
 167 /*
 168  * This code handles mapping and unmapping of user data buffers
 169  * into DMA'ble space using the IOMMU
 170  */
 171
 172 static struct vfio_dma *vfio_find_dma(struct vfio_iommu *iommu,
 173                                       dma_addr_t start, size_t size)
 174 {
 175         struct rb_node *node = iommu->dma_list.rb_node;
 176
 177         while (node) {
 178                 struct vfio_dma *dma = rb_entry(node, struct vfio_dma, node);
 179
 180                 if (start + size <= dma->iova)
 181                         node = node->rb_left;
 182                 else if (start >= dma->iova + dma->size)
 183                         node = node->rb_right;
 184                 else
 185                         return dma;
 186         }
 187
 188         return NULL;
 189 }
 190
 191 static struct rb_node *vfio_find_dma_first_node(struct vfio_iommu *iommu,
 192                                                 dma_addr_t start, u64 size)
 193 {
 194         struct rb_node *res = NULL;
 195         struct rb_node *node = iommu->dma_list.rb_node;
 196         struct vfio_dma *dma_res = NULL;
 197
 198         while (node) {
 199                 struct vfio_dma *dma = rb_entry(node, struct vfio_dma, node);
 200
 201                 if (start < dma->iova + dma->size) {
 202                         res = node;
 203                         dma_res = dma;
 204                         if (start >= dma->iova)
 205                                 break;
 206                         node = node->rb_left;
 207                 } else {
 208                         node = node->rb_right;
 209                 }
 210         }
 211         if (res && size && dma_res->iova >= start + size)
 212                 res = NULL;
 213         return res;
 214 }
 215
 216 static void vfio_link_dma(struct vfio_iommu *iommu, struct vfio_dma *new)
 217 {
 218         struct rb_node **link = &iommu->dma_list.rb_node, *parent = NULL;
 219         struct vfio_dma *dma;
 220
 221         while (*link) {
 222                 parent = *link;
 223                 dma = rb_entry(parent, struct vfio_dma, node);
 224
 225                 if (new->iova + new->size <= dma->iova)
 226                         link = &(*link)->rb_left;
 227                 else
 228                         link = &(*link)->rb_right;
 229         }
 230
 231         rb_link_node(&new->node, parent, link);
 232         rb_insert_color(&new->node, &iommu->dma_list);
 233 }
 234
 235 static void vfio_unlink_dma(struct vfio_iommu *iommu, struct vfio_dma *old)
 236 {
 237         rb_erase(&old->node, &iommu->dma_list);
 238 }
 239
 240
 241 static int vfio_dma_bitmap_alloc(struct vfio_dma *dma, size_t pgsize)
 242 {
 243         uint64_t npages = dma->size / pgsize;
 244
 245         if (npages > DIRTY_BITMAP_PAGES_MAX)
 246                 return -EINVAL;
 247
 248         /*
 249          * Allocate extra 64 bits that are used to calculate shift required for
 250          * bitmap_shift_left() to manipulate and club unaligned number of pages
 251          * in adjacent vfio_dma ranges.
 252          */
 253         dma->bitmap = kvzalloc(DIRTY_BITMAP_BYTES(npages) + sizeof(u64),
 254                                GFP_KERNEL);
 255         if (!dma->bitmap)
 256                 return -ENOMEM;
 257
 258         return 0;
 259 }
 260
 261 static void vfio_dma_bitmap_free(struct vfio_dma *dma)
 262 {
 263         kfree(dma->bitmap);
 264         dma->bitmap = NULL;
 265 }
 266
 267 static void vfio_dma_populate_bitmap(struct vfio_dma *dma, size_t pgsize)
 268 {
 269         struct rb_node *p;
 270         unsigned long pgshift = __ffs(pgsize);
 271
 272         for (p = rb_first(&dma->pfn_list); p; p = rb_next(p)) {
 273                 struct vfio_pfn *vpfn = rb_entry(p, struct vfio_pfn, node);
 274
 275                 bitmap_set(dma->bitmap, (vpfn->iova - dma->iova) >> pgshift, 1);
 276         }
 277 }
 278
 279 static void vfio_iommu_populate_bitmap_full(struct vfio_iommu *iommu)
 280 {
 281         struct rb_node *n;
 282         unsigned long pgshift = __ffs(iommu->pgsize_bitmap);
 283
 284         for (n = rb_first(&iommu->dma_list); n; n = rb_next(n)) {
 285                 struct vfio_dma *dma = rb_entry(n, struct vfio_dma, node);
 286
 287                 bitmap_set(dma->bitmap, 0, dma->size >> pgshift);
 288         }
 289 }
 290
 291 static int vfio_dma_bitmap_alloc_all(struct vfio_iommu *iommu, size_t pgsize)
 292 {
 293         struct rb_node *n;
 294
 295         for (n = rb_first(&iommu->dma_list); n; n = rb_next(n)) {
 296                 struct vfio_dma *dma = rb_entry(n, struct vfio_dma, node);
 297                 int ret;
 298
 299                 ret = vfio_dma_bitmap_alloc(dma, pgsize);
 300                 if (ret) {
 301                         struct rb_node *p;
 302
 303                         for (p = rb_prev(n); p; p = rb_prev(p)) {
 304                                 struct vfio_dma *dma = rb_entry(n,
 305                                                         struct vfio_dma, node);
 306
 307                                 vfio_dma_bitmap_free(dma);
 308                         }
 309                         return ret;
 310                 }
 311                 vfio_dma_populate_bitmap(dma, pgsize);
 312         }
 313         return 0;
 314 }
 315
 316 static void vfio_dma_bitmap_free_all(struct vfio_iommu *iommu)
 317 {
 318         struct rb_node *n;
 319
 320         for (n = rb_first(&iommu->dma_list); n; n = rb_next(n)) {
 321                 struct vfio_dma *dma = rb_entry(n, struct vfio_dma, node);
 322
 323                 vfio_dma_bitmap_free(dma);
 324         }
 325 }
 326
 327 /*
 328  * Helper Functions for host iova-pfn list
 329  */
 330 static struct vfio_pfn *vfio_find_vpfn(struct vfio_dma *dma, dma_addr_t iova)
 331 {
 332         struct vfio_pfn *vpfn;
 333         struct rb_node *node = dma->pfn_list.rb_node;
 334
 335         while (node) {
 336                 vpfn = rb_entry(node, struct vfio_pfn, node);
 337
 338                 if (iova < vpfn->iova)
 339                         node = node->rb_left;
 340                 else if (iova > vpfn->iova)
 341                         node = node->rb_right;
 342                 else
 343                         return vpfn;
 344         }
 345         return NULL;
 346 }
 347
 348 static void vfio_link_pfn(struct vfio_dma *dma,
 349                           struct vfio_pfn *new)
 350 {
 351         struct rb_node **link, *parent = NULL;
 352         struct vfio_pfn *vpfn;
 353
 354         link = &dma->pfn_list.rb_node;
 355         while (*link) {
 356                 parent = *link;
 357                 vpfn = rb_entry(parent, struct vfio_pfn, node);
 358
 359                 if (new->iova < vpfn->iova)
 360                         link = &(*link)->rb_left;
 361                 else
 362                         link = &(*link)->rb_right;
 363         }
 364
 365         rb_link_node(&new->node, parent, link);
 366         rb_insert_color(&new->node, &dma->pfn_list);
 367 }
 368
 369 static void vfio_unlink_pfn(struct vfio_dma *dma, struct vfio_pfn *old)
 370 {
 371         rb_erase(&old->node, &dma->pfn_list);
 372 }
 373
 374 static int vfio_add_to_pfn_list(struct vfio_dma *dma, dma_addr_t iova,
 375                                 unsigned long pfn)
 376 {
 377         struct vfio_pfn *vpfn;
 378
 379         vpfn = kzalloc(sizeof(*vpfn), GFP_KERNEL);
 380         if (!vpfn)
 381                 return -ENOMEM;
 382
 383         vpfn->iova = iova;
 384         vpfn->pfn = pfn;
 385         vpfn->ref_count = 1;
 386         vfio_link_pfn(dma, vpfn);
 387         return 0;
 388 }
 389
 390 static void vfio_remove_from_pfn_list(struct vfio_dma *dma,
 391                                       struct vfio_pfn *vpfn)
 392 {
 393         vfio_unlink_pfn(dma, vpfn);
 394         kfree(vpfn);
 395 }
 396
 397 static struct vfio_pfn *vfio_iova_get_vfio_pfn(struct vfio_dma *dma,
 398                                                unsigned long iova)
 399 {
 400         struct vfio_pfn *vpfn = vfio_find_vpfn(dma, iova);
 401
 402         if (vpfn)
 403                 vpfn->ref_count++;
 404         return vpfn;
 405 }
 406
 407 static int vfio_iova_put_vfio_pfn(struct vfio_dma *dma, struct vfio_pfn *vpfn)
 408 {
 409         int ret = 0;
 410
 411         vpfn->ref_count--;
 412         if (!vpfn->ref_count) {
 413                 ret = put_pfn(vpfn->pfn, dma->prot);
 414                 vfio_remove_from_pfn_list(dma, vpfn);
 415         }
 416         return ret;
 417 }
 418
 419 static int vfio_lock_acct(struct vfio_dma *dma, long npage, bool async)
 420 {
 421         struct mm_struct *mm;
 422         int ret;
 423
 424         if (!npage)
 425                 return 0;
 426
 427         mm = async ? get_task_mm(dma->task) : dma->task->mm;
 428         if (!mm)
 429                 return -ESRCH; /* process exited */
 430
 431         ret = mmap_write_lock_killable(mm);
 432         if (!ret) {
 433                 ret = __account_locked_vm(mm, abs(npage), npage > 0, dma->task,
 434                                           dma->lock_cap);
 435                 mmap_write_unlock(mm);
 436         }
 437
 438         if (async)
 439                 mmput(mm);
 440
 441         return ret;
 442 }
 443
 444 /*
 445  * Some mappings aren't backed by a struct page, for example an mmap'd
 446  * MMIO range for our own or another device.  These use a different
 447  * pfn conversion and shouldn't be tracked as locked pages.
 448  * For compound pages, any driver that sets the reserved bit in head
 449  * page needs to set the reserved bit in all subpages to be safe.
 450  */
 451 static bool is_invalid_reserved_pfn(unsigned long pfn)
 452 {
 453         if (pfn_valid(pfn))
 454                 return PageReserved(pfn_to_page(pfn));
 455
 456         return true;
 457 }
 458
 459 static int put_pfn(unsigned long pfn, int prot)
 460 {
 461         if (!is_invalid_reserved_pfn(pfn)) {
 462                 struct page *page = pfn_to_page(pfn);
 463
 464                 unpin_user_pages_dirty_lock(&page, 1, prot & IOMMU_WRITE);
 465                 return 1;
 466         }
 467         return 0;
 468 }
 469
 470 #define VFIO_BATCH_MAX_CAPACITY (PAGE_SIZE / sizeof(struct page *))
 471
 472 static void vfio_batch_init(struct vfio_batch *batch)
 473 {
 474         batch->size = 0;
 475         batch->offset = 0;
 476
 477         if (unlikely(disable_hugepages))
 478                 goto fallback;
 479
 480         batch->pages = (struct page **) __get_free_page(GFP_KERNEL);
 481         if (!batch->pages)
 482                 goto fallback;
 483
 484         batch->capacity = VFIO_BATCH_MAX_CAPACITY;
 485         return;
 486
 487 fallback:
 488         batch->pages = &batch->fallback_page;
 489         batch->capacity = 1;
 490 }
 491
 492 static void vfio_batch_unpin(struct vfio_batch *batch, struct vfio_dma *dma)
 493 {
 494         while (batch->size) {
 495                 unsigned long pfn = page_to_pfn(batch->pages[batch->offset]);
 496
 497                 put_pfn(pfn, dma->prot);
 498                 batch->offset++;
 499                 batch->size--;
 500         }
 501 }
 502
 503 static void vfio_batch_fini(struct vfio_batch *batch)
 504 {
 505         if (batch->capacity == VFIO_BATCH_MAX_CAPACITY)
 506                 free_page((unsigned long)batch->pages);
 507 }
 508
 509 static int follow_fault_pfn(struct vm_area_struct *vma, struct mm_struct *mm,
 510                             unsigned long vaddr, unsigned long *pfn,
 511                             bool write_fault)
 512 {
 513         pte_t *ptep;
 514         spinlock_t *ptl;
 515         int ret;
 516
 517         ret = follow_pte(vma->vm_mm, vaddr, &ptep, &ptl);
 518         if (ret) {
 519                 bool unlocked = false;
 520
 521                 ret = fixup_user_fault(mm, vaddr,
 522                                        FAULT_FLAG_REMOTE |
 523                                        (write_fault ?  FAULT_FLAG_WRITE : 0),
 524                                        &unlocked);
 525                 if (unlocked)
 526                         return -EAGAIN;
 527
 528                 if (ret)
 529                         return ret;
 530
 531                 ret = follow_pte(vma->vm_mm, vaddr, &ptep, &ptl);
 532                 if (ret)
 533                         return ret;
 534         }
 535
 536         if (write_fault && !pte_write(*ptep))
 537                 ret = -EFAULT;
 538         else
 539                 *pfn = pte_pfn(*ptep);
 540
 541         pte_unmap_unlock(ptep, ptl);
 542         return ret;
 543 }
 544
 545 /*
 546  * Returns the positive number of pfns successfully obtained or a negative
 547  * error code.
 548  */
 549 static int vaddr_get_pfns(struct mm_struct *mm, unsigned long vaddr,
 550                           long npages, int prot, unsigned long *pfn,
 551                           struct page **pages)
 552 {
 553         struct vm_area_struct *vma;
 554         unsigned int flags = 0;
 555         int ret;
 556
 557         if (prot & IOMMU_WRITE)
 558                 flags |= FOLL_WRITE;
 559
 560         mmap_read_lock(mm);
 561         ret = pin_user_pages_remote(mm, vaddr, npages, flags | FOLL_LONGTERM,
 562                                     pages, NULL, NULL);
 563         if (ret > 0) {
 564                 *pfn = page_to_pfn(pages[0]);
 565                 goto done;
 566         }
 567
 568         vaddr = untagged_addr(vaddr);
 569
 570 retry:
 571         vma = find_vma_intersection(mm, vaddr, vaddr + 1);
 572
 573         if (vma && vma->vm_flags & VM_PFNMAP) {
 574                 ret = follow_fault_pfn(vma, mm, vaddr, pfn, prot & IOMMU_WRITE);
 575                 if (ret == -EAGAIN)
 576                         goto retry;
 577
 578                 if (!ret) {
 579                         if (is_invalid_reserved_pfn(*pfn))
 580                                 ret = 1;
 581                         else
 582                                 ret = -EFAULT;
 583                 }
 584         }
 585 done:
 586         mmap_read_unlock(mm);
 587         return ret;
 588 }
 589
 590 static int vfio_wait(struct vfio_iommu *iommu)
 591 {
 592         DEFINE_WAIT(wait);
 593
 594         prepare_to_wait(&iommu->vaddr_wait, &wait, TASK_KILLABLE);
 595         mutex_unlock(&iommu->lock);
 596         schedule();
 597         mutex_lock(&iommu->lock);
 598         finish_wait(&iommu->vaddr_wait, &wait);
 599         if (kthread_should_stop() || !iommu->container_open ||
 600             fatal_signal_pending(current)) {
 601                 return -EFAULT;
 602         }
 603         return WAITED;
 604 }
 605
 606 /*
 607  * Find dma struct and wait for its vaddr to be valid.  iommu lock is dropped
 608  * if the task waits, but is re-locked on return.  Return result in *dma_p.
 609  * Return 0 on success with no waiting, WAITED on success if waited, and -errno
 610  * on error.
 611  */
 612 static int vfio_find_dma_valid(struct vfio_iommu *iommu, dma_addr_t start,
 613                                size_t size, struct vfio_dma **dma_p)
 614 {
 615         int ret;
 616
 617         do {
 618                 *dma_p = vfio_find_dma(iommu, start, size);
 619                 if (!*dma_p)
 620                         ret = -EINVAL;
 621                 else if (!(*dma_p)->vaddr_invalid)
 622                         ret = 0;
 623                 else
 624                         ret = vfio_wait(iommu);
 625         } while (ret > 0);
 626
 627         return ret;
 628 }
 629
 630 /*
 631  * Wait for all vaddr in the dma_list to become valid.  iommu lock is dropped
 632  * if the task waits, but is re-locked on return.  Return 0 on success with no
 633  * waiting, WAITED on success if waited, and -errno on error.
 634  */
 635 static int vfio_wait_all_valid(struct vfio_iommu *iommu)
 636 {
 637         int ret = 0;
 638
 639         while (iommu->vaddr_invalid_count && ret >= 0)
 640                 ret = vfio_wait(iommu);
 641
 642         return ret;
 643 }
 644
 645 /*
 646  * Attempt to pin pages.  We really don't want to track all the pfns and
 647  * the iommu can only map chunks of consecutive pfns anyway, so get the
 648  * first page and all consecutive pages with the same locking.
 649  */
 650 static long vfio_pin_pages_remote(struct vfio_dma *dma, unsigned long vaddr,
 651                                   long npage, unsigned long *pfn_base,
 652                                   unsigned long limit, struct vfio_batch *batch)
 653 {
 654         unsigned long pfn;
 655         struct mm_struct *mm = current->mm;
 656         long ret, pinned = 0, lock_acct = 0;
 657         bool rsvd;
 658         dma_addr_t iova = vaddr - dma->vaddr + dma->iova;
 659
 660         /* This code path is only user initiated */
 661         if (!mm)
 662                 return -ENODEV;
 663
 664         if (batch->size) {
 665                 /* Leftover pages in batch from an earlier call. */
 666                 *pfn_base = page_to_pfn(batch->pages[batch->offset]);
 667                 pfn = *pfn_base;
 668                 rsvd = is_invalid_reserved_pfn(*pfn_base);
 669         } else {
 670                 *pfn_base = 0;
 671         }
 672
 673         while (npage) {
 674                 if (!batch->size) {
 675                         /* Empty batch, so refill it. */
 676                         long req_pages = min_t(long, npage, batch->capacity);
 677
 678                         ret = vaddr_get_pfns(mm, vaddr, req_pages, dma->prot,
 679                                              &pfn, batch->pages);
 680                         if (ret < 0)
 681                                 goto unpin_out;
 682
 683                         batch->size = ret;
 684                         batch->offset = 0;
 685
 686                         if (!*pfn_base) {
 687                                 *pfn_base = pfn;
 688                                 rsvd = is_invalid_reserved_pfn(*pfn_base);
 689                         }
 690                 }
 691
 692                 /*
 693                  * pfn is preset for the first iteration of this inner loop and
 694                  * updated at the end to handle a VM_PFNMAP pfn.  In that case,
 695                  * batch->pages isn't valid (there's no struct page), so allow
 696                  * batch->pages to be touched only when there's more than one
 697                  * pfn to check, which guarantees the pfns are from a
 698                  * !VM_PFNMAP vma.
 699                  */
 700                 while (true) {
 701                         if (pfn != *pfn_base + pinned ||
 702                             rsvd != is_invalid_reserved_pfn(pfn))
 703                                 goto out;
 704
 705                         /*
 706                          * Reserved pages aren't counted against the user,
 707                          * externally pinned pages are already counted against
 708                          * the user.
 709                          */
 710                         if (!rsvd && !vfio_find_vpfn(dma, iova)) {
 711                                 if (!dma->lock_cap &&
 712                                     mm->locked_vm + lock_acct + 1 > limit) {
 713                                         pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n",
 714                                                 __func__, limit << PAGE_SHIFT);
 715                                         ret = -ENOMEM;
 716                                         goto unpin_out;
 717                                 }
 718                                 lock_acct++;
 719                         }
 720
 721                         pinned++;
 722                         npage--;
 723                         vaddr += PAGE_SIZE;
 724                         iova += PAGE_SIZE;
 725                         batch->offset++;
 726                         batch->size--;
 727
 728                         if (!batch->size)
 729                                 break;
 730
 731                         pfn = page_to_pfn(batch->pages[batch->offset]);
 732                 }
 733
 734                 if (unlikely(disable_hugepages))
 735                         break;
 736         }
 737
 738 out:
 739         ret = vfio_lock_acct(dma, lock_acct, false);
 740
 741 unpin_out:
 742         if (batch->size == 1 && !batch->offset) {
 743                 /* May be a VM_PFNMAP pfn, which the batch can't remember. */
 744                 put_pfn(pfn, dma->prot);
 745                 batch->size = 0;
 746         }
 747
 748         if (ret < 0) {
 749                 if (pinned && !rsvd) {
 750                         for (pfn = *pfn_base ; pinned ; pfn++, pinned--)
 751                                 put_pfn(pfn, dma->prot);
 752                 }
 753                 vfio_batch_unpin(batch, dma);
 754
 755                 return ret;
 756         }
 757
 758         return pinned;
 759 }
 760
 761 static long vfio_unpin_pages_remote(struct vfio_dma *dma, dma_addr_t iova,
 762                                     unsigned long pfn, long npage,
 763                                     bool do_accounting)
 764 {
 765         long unlocked = 0, locked = 0;
 766         long i;
 767
 768         for (i = 0; i < npage; i++, iova += PAGE_SIZE) {
 769                 if (put_pfn(pfn++, dma->prot)) {
 770                         unlocked++;
 771                         if (vfio_find_vpfn(dma, iova))
 772                                 locked++;
 773                 }
 774         }
 775
 776         if (do_accounting)
 777                 vfio_lock_acct(dma, locked - unlocked, true);
 778
 779         return unlocked;
 780 }
 781
 782 static int vfio_pin_page_external(struct vfio_dma *dma, unsigned long vaddr,
 783                                   unsigned long *pfn_base, bool do_accounting)
 784 {
 785         struct page *pages[1];
 786         struct mm_struct *mm;
 787         int ret;
 788
 789         mm = get_task_mm(dma->task);
 790         if (!mm)
 791                 return -ENODEV;
 792
 793         ret = vaddr_get_pfns(mm, vaddr, 1, dma->prot, pfn_base, pages);
 794         if (ret != 1)
 795                 goto out;
 796
 797         ret = 0;
 798
 799         if (do_accounting && !is_invalid_reserved_pfn(*pfn_base)) {
 800                 ret = vfio_lock_acct(dma, 1, true);
 801                 if (ret) {
 802                         put_pfn(*pfn_base, dma->prot);
 803                         if (ret == -ENOMEM)
 804                                 pr_warn("%s: Task %s (%d) RLIMIT_MEMLOCK "
 805                                         "(%ld) exceeded\n", __func__,
 806                                         dma->task->comm, task_pid_nr(dma->task),
 807                                         task_rlimit(dma->task, RLIMIT_MEMLOCK));
 808                 }
 809         }
 810
 811 out:
 812         mmput(mm);
 813         return ret;
 814 }
 815
 816 static int vfio_unpin_page_external(struct vfio_dma *dma, dma_addr_t iova,
 817                                     bool do_accounting)
 818 {
 819         int unlocked;
 820         struct vfio_pfn *vpfn = vfio_find_vpfn(dma, iova);
 821
 822         if (!vpfn)
 823                 return 0;
 824
 825         unlocked = vfio_iova_put_vfio_pfn(dma, vpfn);
 826
 827         if (do_accounting)
 828                 vfio_lock_acct(dma, -unlocked, true);
 829
 830         return unlocked;
 831 }
 832
 833 static int vfio_iommu_type1_pin_pages(void *iommu_data,
 834                                       struct iommu_group *iommu_group,
 835                                       unsigned long *user_pfn,
 836                                       int npage, int prot,
 837                                       unsigned long *phys_pfn)
 838 {
 839         struct vfio_iommu *iommu = iommu_data;
 840         struct vfio_group *group;
 841         int i, j, ret;
 842         unsigned long remote_vaddr;
 843         struct vfio_dma *dma;
 844         bool do_accounting;
 845         dma_addr_t iova;
 846
 847         if (!iommu || !user_pfn || !phys_pfn)
 848                 return -EINVAL;
 849
 850         /* Supported for v2 version only */
 851         if (!iommu->v2)
 852                 return -EACCES;
 853
 854         mutex_lock(&iommu->lock);
 855
 856         /*
 857          * Wait for all necessary vaddr's to be valid so they can be used in
 858          * the main loop without dropping the lock, to avoid racing vs unmap.
 859          */
 860 again:
 861         if (iommu->vaddr_invalid_count) {
 862                 for (i = 0; i < npage; i++) {
 863                         iova = user_pfn[i] << PAGE_SHIFT;
 864                         ret = vfio_find_dma_valid(iommu, iova, PAGE_SIZE, &dma);
 865                         if (ret < 0)
 866                                 goto pin_done;
 867                         if (ret == WAITED)
 868                                 goto again;
 869                 }
 870         }
 871
 872         /* Fail if notifier list is empty */
 873         if (!iommu->notifier.head) {
 874                 ret = -EINVAL;
 875                 goto pin_done;
 876         }
 877
 878         /*
 879          * If iommu capable domain exist in the container then all pages are
 880          * already pinned and accounted. Accouting should be done if there is no
 881          * iommu capable domain in the container.
 882          */
 883         do_accounting = !IS_IOMMU_CAP_DOMAIN_IN_CONTAINER(iommu);
 884
 885         for (i = 0; i < npage; i++) {
 886                 struct vfio_pfn *vpfn;
 887
 888                 iova = user_pfn[i] << PAGE_SHIFT;
 889                 dma = vfio_find_dma(iommu, iova, PAGE_SIZE);
 890                 if (!dma) {
 891                         ret = -EINVAL;
 892                         goto pin_unwind;
 893                 }
 894
 895                 if ((dma->prot & prot) != prot) {
 896                         ret = -EPERM;
 897                         goto pin_unwind;
 898                 }
 899
 900                 vpfn = vfio_iova_get_vfio_pfn(dma, iova);
 901                 if (vpfn) {
 902                         phys_pfn[i] = vpfn->pfn;
 903                         continue;
 904                 }
 905
 906                 remote_vaddr = dma->vaddr + (iova - dma->iova);
 907                 ret = vfio_pin_page_external(dma, remote_vaddr, &phys_pfn[i],
 908                                              do_accounting);
 909                 if (ret)
 910                         goto pin_unwind;
 911
 912                 ret = vfio_add_to_pfn_list(dma, iova, phys_pfn[i]);
 913                 if (ret) {
 914                         if (put_pfn(phys_pfn[i], dma->prot) && do_accounting)
 915                                 vfio_lock_acct(dma, -1, true);
 916                         goto pin_unwind;
 917                 }
 918
 919                 if (iommu->dirty_page_tracking) {
 920                         unsigned long pgshift = __ffs(iommu->pgsize_bitmap);
 921
 922                         /*
 923                          * Bitmap populated with the smallest supported page
 924                          * size
 925                          */
 926                         bitmap_set(dma->bitmap,
 927                                    (iova - dma->iova) >> pgshift, 1);
 928                 }
 929         }
 930         ret = i;
 931
 932         group = vfio_iommu_find_iommu_group(iommu, iommu_group);
 933         if (!group->pinned_page_dirty_scope) {
 934                 group->pinned_page_dirty_scope = true;
 935                 iommu->num_non_pinned_groups--;
 936         }
 937
 938         goto pin_done;
 939
 940 pin_unwind:
 941         phys_pfn[i] = 0;
 942         for (j = 0; j < i; j++) {
 943                 dma_addr_t iova;
 944
 945                 iova = user_pfn[j] << PAGE_SHIFT;
 946                 dma = vfio_find_dma(iommu, iova, PAGE_SIZE);
 947                 vfio_unpin_page_external(dma, iova, do_accounting);
 948                 phys_pfn[j] = 0;
 949         }
 950 pin_done:
 951         mutex_unlock(&iommu->lock);
 952         return ret;
 953 }
 954
 955 static int vfio_iommu_type1_unpin_pages(void *iommu_data,
 956                                         unsigned long *user_pfn,
 957                                         int npage)
 958 {
 959         struct vfio_iommu *iommu = iommu_data;
 960         bool do_accounting;
 961         int i;
 962
 963         if (!iommu || !user_pfn)
 964                 return -EINVAL;
 965
 966         /* Supported for v2 version only */
 967         if (!iommu->v2)
 968                 return -EACCES;
 969
 970         mutex_lock(&iommu->lock);
 971
 972         do_accounting = !IS_IOMMU_CAP_DOMAIN_IN_CONTAINER(iommu);
 973         for (i = 0; i < npage; i++) {
 974                 struct vfio_dma *dma;
 975                 dma_addr_t iova;
 976
 977                 iova = user_pfn[i] << PAGE_SHIFT;
 978                 dma = vfio_find_dma(iommu, iova, PAGE_SIZE);
 979                 if (!dma)
 980                         goto unpin_exit;
 981                 vfio_unpin_page_external(dma, iova, do_accounting);
 982         }
 983
 984 unpin_exit:
 985         mutex_unlock(&iommu->lock);
 986         return i > npage ? npage : (i > 0 ? i : -EINVAL);
 987 }
 988
 989 static long vfio_sync_unpin(struct vfio_dma *dma, struct vfio_domain *domain,
 990                             struct list_head *regions,
 991                             struct iommu_iotlb_gather *iotlb_gather)
 992 {
 993         long unlocked = 0;
 994         struct vfio_regions *entry, *next;
 995
 996         iommu_iotlb_sync(domain->domain, iotlb_gather);
 997
 998         list_for_each_entry_safe(entry, next, regions, list) {
 999                 unlocked += vfio_unpin_pages_remote(dma,
1000                                                     entry->iova,
1001                                                     entry->phys >> PAGE_SHIFT,
1002                                                     entry->len >> PAGE_SHIFT,
1003                                                     false);
1004                 list_del(&entry->list);
1005                 kfree(entry);
1006         }
1007
1008         cond_resched();
1009
1010         return unlocked;
1011 }
1012
1013 /*
1014  * Generally, VFIO needs to unpin remote pages after each IOTLB flush.
1015  * Therefore, when using IOTLB flush sync interface, VFIO need to keep track
1016  * of these regions (currently using a list).
1017  *
1018  * This value specifies maximum number of regions for each IOTLB flush sync.
1019  */
1020 #define VFIO_IOMMU_TLB_SYNC_MAX         512
1021
1022 static size_t unmap_unpin_fast(struct vfio_domain *domain,
1023                                struct vfio_dma *dma, dma_addr_t *iova,
1024                                size_t len, phys_addr_t phys, long *unlocked,
1025                                struct list_head *unmapped_list,
1026                                int *unmapped_cnt,
1027                                struct iommu_iotlb_gather *iotlb_gather)
1028 {
1029         size_t unmapped = 0;
1030         struct vfio_regions *entry = kzalloc(sizeof(*entry), GFP_KERNEL);
1031
1032         if (entry) {
1033                 unmapped = iommu_unmap_fast(domain->domain, *iova, len,
1034                                             iotlb_gather);
1035
1036                 if (!unmapped) {
1037                         kfree(entry);
1038                 } else {
1039                         entry->iova = *iova;
1040                         entry->phys = phys;
1041                         entry->len  = unmapped;
1042                         list_add_tail(&entry->list, unmapped_list);
1043
1044                         *iova += unmapped;
1045                         (*unmapped_cnt)++;
1046                 }
1047         }
1048
1049         /*
1050          * Sync if the number of fast-unmap regions hits the limit
1051          * or in case of errors.
1052          */
1053         if (*unmapped_cnt >= VFIO_IOMMU_TLB_SYNC_MAX || !unmapped) {
1054                 *unlocked += vfio_sync_unpin(dma, domain, unmapped_list,
1055                                              iotlb_gather);
1056                 *unmapped_cnt = 0;
1057         }
1058
1059         return unmapped;
1060 }
1061
1062 static size_t unmap_unpin_slow(struct vfio_domain *domain,
1063                                struct vfio_dma *dma, dma_addr_t *iova,
1064                                size_t len, phys_addr_t phys,
1065                                long *unlocked)
1066 {
1067         size_t unmapped = iommu_unmap(domain->domain, *iova, len);
1068
1069         if (unmapped) {
1070                 *unlocked += vfio_unpin_pages_remote(dma, *iova,
1071                                                      phys >> PAGE_SHIFT,
1072                                                      unmapped >> PAGE_SHIFT,
1073                                                      false);
1074                 *iova += unmapped;
1075                 cond_resched();
1076         }
1077         return unmapped;
1078 }
1079
1080 static long vfio_unmap_unpin(struct vfio_iommu *iommu, struct vfio_dma *dma,
1081                              bool do_accounting)
1082 {
1083         dma_addr_t iova = dma->iova, end = dma->iova + dma->size;
1084         struct vfio_domain *domain, *d;
1085         LIST_HEAD(unmapped_region_list);
1086         struct iommu_iotlb_gather iotlb_gather;
1087         int unmapped_region_cnt = 0;
1088         long unlocked = 0;
1089
1090         if (!dma->size)
1091                 return 0;
1092
1093         if (!IS_IOMMU_CAP_DOMAIN_IN_CONTAINER(iommu))
1094                 return 0;
1095
1096         /*
1097          * We use the IOMMU to track the physical addresses, otherwise we'd
1098          * need a much more complicated tracking system.  Unfortunately that
1099          * means we need to use one of the iommu domains to figure out the
1100          * pfns to unpin.  The rest need to be unmapped in advance so we have
1101          * no iommu translations remaining when the pages are unpinned.
1102          */
1103         domain = d = list_first_entry(&iommu->domain_list,
1104                                       struct vfio_domain, next);
1105
1106         list_for_each_entry_continue(d, &iommu->domain_list, next) {
1107                 iommu_unmap(d->domain, dma->iova, dma->size);
1108                 cond_resched();
1109         }
1110
1111         iommu_iotlb_gather_init(&iotlb_gather);
1112         while (iova < end) {
1113                 size_t unmapped, len;
1114                 phys_addr_t phys, next;
1115
1116                 phys = iommu_iova_to_phys(domain->domain, iova);
1117                 if (WARN_ON(!phys)) {
1118                         iova += PAGE_SIZE;
1119                         continue;
1120                 }
1121
1122                 /*
1123                  * To optimize for fewer iommu_unmap() calls, each of which
1124                  * may require hardware cache flushing, try to find the
1125                  * largest contiguous physical memory chunk to unmap.
1126                  */
1127                 for (len = PAGE_SIZE;
1128                      !domain->fgsp && iova + len < end; len += PAGE_SIZE) {
1129                         next = iommu_iova_to_phys(domain->domain, iova + len);
1130                         if (next != phys + len)
1131                                 break;
1132                 }
1133
1134                 /*
1135                  * First, try to use fast unmap/unpin. In case of failure,
1136                  * switch to slow unmap/unpin path.
1137                  */
1138                 unmapped = unmap_unpin_fast(domain, dma, &iova, len, phys,
1139                                             &unlocked, &unmapped_region_list,
1140                                             &unmapped_region_cnt,
1141                                             &iotlb_gather);
1142                 if (!unmapped) {
1143                         unmapped = unmap_unpin_slow(domain, dma, &iova, len,
1144                                                     phys, &unlocked);
1145                         if (WARN_ON(!unmapped))
1146                                 break;
1147                 }
1148         }
1149
1150         dma->iommu_mapped = false;
1151
1152         if (unmapped_region_cnt) {
1153                 unlocked += vfio_sync_unpin(dma, domain, &unmapped_region_list,
1154                                             &iotlb_gather);
1155         }
1156
1157         if (do_accounting) {
1158                 vfio_lock_acct(dma, -unlocked, true);
1159                 return 0;
1160         }
1161         return unlocked;
1162 }
1163
1164 static void vfio_remove_dma(struct vfio_iommu *iommu, struct vfio_dma *dma)
1165 {
1166         WARN_ON(!RB_EMPTY_ROOT(&dma->pfn_list));
1167         vfio_unmap_unpin(iommu, dma, true);
1168         vfio_unlink_dma(iommu, dma);
1169         put_task_struct(dma->task);
1170         vfio_dma_bitmap_free(dma);
1171         if (dma->vaddr_invalid) {
1172                 iommu->vaddr_invalid_count--;
1173                 wake_up_all(&iommu->vaddr_wait);
1174         }
1175         kfree(dma);
1176         iommu->dma_avail++;
1177 }
1178
1179 static void vfio_update_pgsize_bitmap(struct vfio_iommu *iommu)
1180 {
1181         struct vfio_domain *domain;
1182
1183         iommu->pgsize_bitmap = ULONG_MAX;
1184
1185         list_for_each_entry(domain, &iommu->domain_list, next)
1186                 iommu->pgsize_bitmap &= domain->domain->pgsize_bitmap;
1187
1188         /*
1189          * In case the IOMMU supports page sizes smaller than PAGE_SIZE
1190          * we pretend PAGE_SIZE is supported and hide sub-PAGE_SIZE sizes.
1191          * That way the user will be able to map/unmap buffers whose size/
1192          * start address is aligned with PAGE_SIZE. Pinning code uses that
1193          * granularity while iommu driver can use the sub-PAGE_SIZE size
1194          * to map the buffer.
1195          */
1196         if (iommu->pgsize_bitmap & ~PAGE_MASK) {
1197                 iommu->pgsize_bitmap &= PAGE_MASK;
1198                 iommu->pgsize_bitmap |= PAGE_SIZE;
1199         }
1200 }
1201
1202 static int update_user_bitmap(u64 __user *bitmap, struct vfio_iommu *iommu,
1203                               struct vfio_dma *dma, dma_addr_t base_iova,
1204                               size_t pgsize)
1205 {
1206         unsigned long pgshift = __ffs(pgsize);
1207         unsigned long nbits = dma->size >> pgshift;
1208         unsigned long bit_offset = (dma->iova - base_iova) >> pgshift;
1209         unsigned long copy_offset = bit_offset / BITS_PER_LONG;
1210         unsigned long shift = bit_offset % BITS_PER_LONG;
1211         unsigned long leftover;
1212
1213         /*
1214          * mark all pages dirty if any IOMMU capable device is not able
1215          * to report dirty pages and all pages are pinned and mapped.
1216          */
1217         if (iommu->num_non_pinned_groups && dma->iommu_mapped)
1218                 bitmap_set(dma->bitmap, 0, nbits);
1219
1220         if (shift) {
1221                 bitmap_shift_left(dma->bitmap, dma->bitmap, shift,
1222                                   nbits + shift);
1223
1224                 if (copy_from_user(&leftover,
1225                                    (void __user *)(bitmap + copy_offset),
1226                                    sizeof(leftover)))
1227                         return -EFAULT;
1228
1229                 bitmap_or(dma->bitmap, dma->bitmap, &leftover, shift);
1230         }
1231
1232         if (copy_to_user((void __user *)(bitmap + copy_offset), dma->bitmap,
1233                          DIRTY_BITMAP_BYTES(nbits + shift)))
1234                 return -EFAULT;
1235
1236         return 0;
1237 }
1238
1239 static int vfio_iova_dirty_bitmap(u64 __user *bitmap, struct vfio_iommu *iommu,
1240                                   dma_addr_t iova, size_t size, size_t pgsize)
1241 {
1242         struct vfio_dma *dma;
1243         struct rb_node *n;
1244         unsigned long pgshift = __ffs(pgsize);
1245         int ret;
1246
1247         /*
1248          * GET_BITMAP request must fully cover vfio_dma mappings.  Multiple
1249          * vfio_dma mappings may be clubbed by specifying large ranges, but
1250          * there must not be any previous mappings bisected by the range.
1251          * An error will be returned if these conditions are not met.
1252          */
1253         dma = vfio_find_dma(iommu, iova, 1);
1254         if (dma && dma->iova != iova)
1255                 return -EINVAL;
1256
1257         dma = vfio_find_dma(iommu, iova + size - 1, 0);
1258         if (dma && dma->iova + dma->size != iova + size)
1259                 return -EINVAL;
1260
1261         for (n = rb_first(&iommu->dma_list); n; n = rb_next(n)) {
1262                 struct vfio_dma *dma = rb_entry(n, struct vfio_dma, node);
1263
1264                 if (dma->iova < iova)
1265                         continue;
1266
1267                 if (dma->iova > iova + size - 1)
1268                         break;
1269
1270                 ret = update_user_bitmap(bitmap, iommu, dma, iova, pgsize);
1271                 if (ret)
1272                         return ret;
1273
1274                 /*
1275                  * Re-populate bitmap to include all pinned pages which are
1276                  * considered as dirty but exclude pages which are unpinned and
1277                  * pages which are marked dirty by vfio_dma_rw()
1278                  */
1279                 bitmap_clear(dma->bitmap, 0, dma->size >> pgshift);
1280                 vfio_dma_populate_bitmap(dma, pgsize);
1281         }
1282         return 0;
1283 }
1284
1285 static int verify_bitmap_size(uint64_t npages, uint64_t bitmap_size)
1286 {
1287         if (!npages || !bitmap_size || (bitmap_size > DIRTY_BITMAP_SIZE_MAX) ||
1288             (bitmap_size < DIRTY_BITMAP_BYTES(npages)))
1289                 return -EINVAL;
1290
1291         return 0;
1292 }
1293
1294 static int vfio_dma_do_unmap(struct vfio_iommu *iommu,
1295                              struct vfio_iommu_type1_dma_unmap *unmap,
1296                              struct vfio_bitmap *bitmap)
1297 {
1298         struct vfio_dma *dma, *dma_last = NULL;
1299         size_t unmapped = 0, pgsize;
1300         int ret = -EINVAL, retries = 0;
1301         unsigned long pgshift;
1302         dma_addr_t iova = unmap->iova;
1303         u64 size = unmap->size;
1304         bool unmap_all = unmap->flags & VFIO_DMA_UNMAP_FLAG_ALL;
1305         bool invalidate_vaddr = unmap->flags & VFIO_DMA_UNMAP_FLAG_VADDR;
1306         struct rb_node *n, *first_n;
1307
1308         mutex_lock(&iommu->lock);
1309
1310         pgshift = __ffs(iommu->pgsize_bitmap);
1311         pgsize = (size_t)1 << pgshift;
1312
1313         if (iova & (pgsize - 1))
1314                 goto unlock;
1315
1316         if (unmap_all) {
1317                 if (iova || size)
1318                         goto unlock;
1319                 size = U64_MAX;
1320         } else if (!size || size & (pgsize - 1) ||
1321                    iova + size - 1 < iova || size > SIZE_MAX) {
1322                 goto unlock;
1323         }
1324
1325         /* When dirty tracking is enabled, allow only min supported pgsize */
1326         if ((unmap->flags & VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP) &&
1327             (!iommu->dirty_page_tracking || (bitmap->pgsize != pgsize))) {
1328                 goto unlock;
1329         }
1330
1331         WARN_ON((pgsize - 1) & PAGE_MASK);
1332 again:
1333         /*
1334          * vfio-iommu-type1 (v1) - User mappings were coalesced together to
1335          * avoid tracking individual mappings.  This means that the granularity
1336          * of the original mapping was lost and the user was allowed to attempt
1337          * to unmap any range.  Depending on the contiguousness of physical
1338          * memory and page sizes supported by the IOMMU, arbitrary unmaps may
1339          * or may not have worked.  We only guaranteed unmap granularity
1340          * matching the original mapping; even though it was untracked here,
1341          * the original mappings are reflected in IOMMU mappings.  This
1342          * resulted in a couple unusual behaviors.  First, if a range is not
1343          * able to be unmapped, ex. a set of 4k pages that was mapped as a
1344          * 2M hugepage into the IOMMU, the unmap ioctl returns success but with
1345          * a zero sized unmap.  Also, if an unmap request overlaps the first
1346          * address of a hugepage, the IOMMU will unmap the entire hugepage.
1347          * This also returns success and the returned unmap size reflects the
1348          * actual size unmapped.
1349          *
1350          * We attempt to maintain compatibility with this "v1" interface, but
1351          * we take control out of the hands of the IOMMU.  Therefore, an unmap
1352          * request offset from the beginning of the original mapping will
1353          * return success with zero sized unmap.  And an unmap request covering
1354          * the first iova of mapping will unmap the entire range.
1355          *
1356          * The v2 version of this interface intends to be more deterministic.
1357          * Unmap requests must fully cover previous mappings.  Multiple
1358          * mappings may still be unmaped by specifying large ranges, but there
1359          * must not be any previous mappings bisected by the range.  An error
1360          * will be returned if these conditions are not met.  The v2 interface
1361          * will only return success and a size of zero if there were no
1362          * mappings within the range.
1363          */
1364         if (iommu->v2 && !unmap_all) {
1365                 dma = vfio_find_dma(iommu, iova, 1);
1366                 if (dma && dma->iova != iova)
1367                         goto unlock;
1368
1369                 dma = vfio_find_dma(iommu, iova + size - 1, 0);
1370                 if (dma && dma->iova + dma->size != iova + size)
1371                         goto unlock;
1372         }
1373
1374         ret = 0;
1375         n = first_n = vfio_find_dma_first_node(iommu, iova, size);
1376
1377         while (n) {
1378                 dma = rb_entry(n, struct vfio_dma, node);
1379                 if (dma->iova >= iova + size)
1380                         break;
1381
1382                 if (!iommu->v2 && iova > dma->iova)
1383                         break;
1384                 /*
1385                  * Task with same address space who mapped this iova range is
1386                  * allowed to unmap the iova range.
1387                  */
1388                 if (dma->task->mm != current->mm)
1389                         break;
1390
1391                 if (invalidate_vaddr) {
1392                         if (dma->vaddr_invalid) {
1393                                 struct rb_node *last_n = n;
1394
1395                                 for (n = first_n; n != last_n; n = rb_next(n)) {
1396                                         dma = rb_entry(n,
1397                                                        struct vfio_dma, node);
1398                                         dma->vaddr_invalid = false;
1399                                         iommu->vaddr_invalid_count--;
1400                                 }
1401                                 ret = -EINVAL;
1402                                 unmapped = 0;
1403                                 break;
1404                         }
1405                         dma->vaddr_invalid = true;
1406                         iommu->vaddr_invalid_count++;
1407                         unmapped += dma->size;
1408                         n = rb_next(n);
1409                         continue;
1410                 }
1411
1412                 if (!RB_EMPTY_ROOT(&dma->pfn_list)) {
1413                         struct vfio_iommu_type1_dma_unmap nb_unmap;
1414
1415                         if (dma_last == dma) {
1416                                 BUG_ON(++retries > 10);
1417                         } else {
1418                                 dma_last = dma;
1419                                 retries = 0;
1420                         }
1421
1422                         nb_unmap.iova = dma->iova;
1423                         nb_unmap.size = dma->size;
1424
1425                         /*
1426                          * Notify anyone (mdev vendor drivers) to invalidate and
1427                          * unmap iovas within the range we're about to unmap.
1428                          * Vendor drivers MUST unpin pages in response to an
1429                          * invalidation.
1430                          */
1431                         mutex_unlock(&iommu->lock);
1432                         blocking_notifier_call_chain(&iommu->notifier,
1433                                                     VFIO_IOMMU_NOTIFY_DMA_UNMAP,
1434                                                     &nb_unmap);
1435                         mutex_lock(&iommu->lock);
1436                         goto again;
1437                 }
1438
1439                 if (unmap->flags & VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP) {
1440                         ret = update_user_bitmap(bitmap->data, iommu, dma,
1441                                                  iova, pgsize);
1442                         if (ret)
1443                                 break;
1444                 }
1445
1446                 unmapped += dma->size;
1447                 n = rb_next(n);
1448                 vfio_remove_dma(iommu, dma);
1449         }
1450
1451 unlock:
1452         mutex_unlock(&iommu->lock);
1453
1454         /* Report how much was unmapped */
1455         unmap->size = unmapped;
1456
1457         return ret;
1458 }
1459
1460 static int vfio_iommu_map(struct vfio_iommu *iommu, dma_addr_t iova,
1461                           unsigned long pfn, long npage, int prot)
1462 {
1463         struct vfio_domain *d;
1464         int ret;
1465
1466         list_for_each_entry(d, &iommu->domain_list, next) {
1467                 ret = iommu_map(d->domain, iova, (phys_addr_t)pfn << PAGE_SHIFT,
1468                                 npage << PAGE_SHIFT, prot | d->prot);
1469                 if (ret)
1470                         goto unwind;
1471
1472                 cond_resched();
1473         }
1474
1475         return 0;
1476
1477 unwind:
1478         list_for_each_entry_continue_reverse(d, &iommu->domain_list, next) {
1479                 iommu_unmap(d->domain, iova, npage << PAGE_SHIFT);
1480                 cond_resched();
1481         }
1482
1483         return ret;
1484 }
1485
1486 static int vfio_pin_map_dma(struct vfio_iommu *iommu, struct vfio_dma *dma,
1487                             size_t map_size)
1488 {
1489         dma_addr_t iova = dma->iova;
1490         unsigned long vaddr = dma->vaddr;
1491         struct vfio_batch batch;
1492         size_t size = map_size;
1493         long npage;
1494         unsigned long pfn, limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
1495         int ret = 0;
1496
1497         vfio_batch_init(&batch);
1498
1499         while (size) {
1500                 /* Pin a contiguous chunk of memory */
1501                 npage = vfio_pin_pages_remote(dma, vaddr + dma->size,
1502                                               size >> PAGE_SHIFT, &pfn, limit,
1503                                               &batch);
1504                 if (npage <= 0) {
1505                         WARN_ON(!npage);
1506                         ret = (int)npage;
1507                         break;
1508                 }
1509
1510                 /* Map it! */
1511                 ret = vfio_iommu_map(iommu, iova + dma->size, pfn, npage,
1512                                      dma->prot);
1513                 if (ret) {
1514                         vfio_unpin_pages_remote(dma, iova + dma->size, pfn,
1515                                                 npage, true);
1516                         vfio_batch_unpin(&batch, dma);
1517                         break;
1518                 }
1519
1520                 size -= npage << PAGE_SHIFT;
1521                 dma->size += npage << PAGE_SHIFT;
1522         }
1523
1524         vfio_batch_fini(&batch);
1525         dma->iommu_mapped = true;
1526
1527         if (ret)
1528                 vfio_remove_dma(iommu, dma);
1529
1530         return ret;
1531 }
1532
1533 /*
1534  * Check dma map request is within a valid iova range
1535  */
1536 static bool vfio_iommu_iova_dma_valid(struct vfio_iommu *iommu,
1537                                       dma_addr_t start, dma_addr_t end)
1538 {
1539         struct list_head *iova = &iommu->iova_list;
1540         struct vfio_iova *node;
1541
1542         list_for_each_entry(node, iova, list) {
1543                 if (start >= node->start && end <= node->end)
1544                         return true;
1545         }
1546
1547         /*
1548          * Check for list_empty() as well since a container with
1549          * a single mdev device will have an empty list.
1550          */
1551         return list_empty(iova);
1552 }
1553
1554 static int vfio_dma_do_map(struct vfio_iommu *iommu,
1555                            struct vfio_iommu_type1_dma_map *map)
1556 {
1557         bool set_vaddr = map->flags & VFIO_DMA_MAP_FLAG_VADDR;
1558         dma_addr_t iova = map->iova;
1559         unsigned long vaddr = map->vaddr;
1560         size_t size = map->size;
1561         int ret = 0, prot = 0;
1562         size_t pgsize;
1563         struct vfio_dma *dma;
1564
1565         /* Verify that none of our __u64 fields overflow */
1566         if (map->size != size || map->vaddr != vaddr || map->iova != iova)
1567                 return -EINVAL;
1568
1569         /* READ/WRITE from device perspective */
1570         if (map->flags & VFIO_DMA_MAP_FLAG_WRITE)
1571                 prot |= IOMMU_WRITE;
1572         if (map->flags & VFIO_DMA_MAP_FLAG_READ)
1573                 prot |= IOMMU_READ;
1574
1575         if ((prot && set_vaddr) || (!prot && !set_vaddr))
1576                 return -EINVAL;
1577
1578         mutex_lock(&iommu->lock);
1579
1580         pgsize = (size_t)1 << __ffs(iommu->pgsize_bitmap);
1581
1582         WARN_ON((pgsize - 1) & PAGE_MASK);
1583
1584         if (!size || (size | iova | vaddr) & (pgsize - 1)) {
1585                 ret = -EINVAL;
1586                 goto out_unlock;
1587         }
1588
1589         /* Don't allow IOVA or virtual address wrap */
1590         if (iova + size - 1 < iova || vaddr + size - 1 < vaddr) {
1591                 ret = -EINVAL;
1592                 goto out_unlock;
1593         }
1594
1595         dma = vfio_find_dma(iommu, iova, size);
1596         if (set_vaddr) {
1597                 if (!dma) {
1598                         ret = -ENOENT;
1599                 } else if (!dma->vaddr_invalid || dma->iova != iova ||
1600                            dma->size != size) {
1601                         ret = -EINVAL;
1602                 } else {
1603                         dma->vaddr = vaddr;
1604                         dma->vaddr_invalid = false;
1605                         iommu->vaddr_invalid_count--;
1606                         wake_up_all(&iommu->vaddr_wait);
1607                 }
1608                 goto out_unlock;
1609         } else if (dma) {
1610                 ret = -EEXIST;
1611                 goto out_unlock;
1612         }
1613
1614         if (!iommu->dma_avail) {
1615                 ret = -ENOSPC;
1616                 goto out_unlock;
1617         }
1618
1619         if (!vfio_iommu_iova_dma_valid(iommu, iova, iova + size - 1)) {
1620                 ret = -EINVAL;
1621                 goto out_unlock;
1622         }
1623
1624         dma = kzalloc(sizeof(*dma), GFP_KERNEL);
1625         if (!dma) {
1626                 ret = -ENOMEM;
1627                 goto out_unlock;
1628         }
1629
1630         iommu->dma_avail--;
1631         dma->iova = iova;
1632         dma->vaddr = vaddr;
1633         dma->prot = prot;
1634
1635         /*
1636          * We need to be able to both add to a task's locked memory and test
1637          * against the locked memory limit and we need to be able to do both
1638          * outside of this call path as pinning can be asynchronous via the
1639          * external interfaces for mdev devices.  RLIMIT_MEMLOCK requires a
1640          * task_struct and VM locked pages requires an mm_struct, however
1641          * holding an indefinite mm reference is not recommended, therefore we
1642          * only hold a reference to a task.  We could hold a reference to
1643          * current, however QEMU uses this call path through vCPU threads,
1644          * which can be killed resulting in a NULL mm and failure in the unmap
1645          * path when called via a different thread.  Avoid this problem by
1646          * using the group_leader as threads within the same group require
1647          * both CLONE_THREAD and CLONE_VM and will therefore use the same
1648          * mm_struct.
1649          *
1650          * Previously we also used the task for testing CAP_IPC_LOCK at the
1651          * time of pinning and accounting, however has_capability() makes use
1652          * of real_cred, a copy-on-write field, so we can't guarantee that it
1653          * matches group_leader, or in fact that it might not change by the
1654          * time it's evaluated.  If a process were to call MAP_DMA with
1655          * CAP_IPC_LOCK but later drop it, it doesn't make sense that they
1656          * possibly see different results for an iommu_mapped vfio_dma vs
1657          * externally mapped.  Therefore track CAP_IPC_LOCK in vfio_dma at the
1658          * time of calling MAP_DMA.
1659          */
1660         get_task_struct(current->group_leader);
1661         dma->task = current->group_leader;
1662         dma->lock_cap = capable(CAP_IPC_LOCK);
1663
1664         dma->pfn_list = RB_ROOT;
1665
1666         /* Insert zero-sized and grow as we map chunks of it */
1667         vfio_link_dma(iommu, dma);
1668
1669         /* Don't pin and map if container doesn't contain IOMMU capable domain*/
1670         if (!IS_IOMMU_CAP_DOMAIN_IN_CONTAINER(iommu))
1671                 dma->size = size;
1672         else
1673                 ret = vfio_pin_map_dma(iommu, dma, size);
1674
1675         if (!ret && iommu->dirty_page_tracking) {
1676                 ret = vfio_dma_bitmap_alloc(dma, pgsize);
1677                 if (ret)
1678                         vfio_remove_dma(iommu, dma);
1679         }
1680
1681 out_unlock:
1682         mutex_unlock(&iommu->lock);
1683         return ret;
1684 }
1685
1686 static int vfio_bus_type(struct device *dev, void *data)
1687 {
1688         struct bus_type **bus = data;
1689
1690         if (*bus && *bus != dev->bus)
1691                 return -EINVAL;
1692
1693         *bus = dev->bus;
1694
1695         return 0;
1696 }
1697
1698 static int vfio_iommu_replay(struct vfio_iommu *iommu,
1699                              struct vfio_domain *domain)
1700 {
1701         struct vfio_batch batch;
1702         struct vfio_domain *d = NULL;
1703         struct rb_node *n;
1704         unsigned long limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
1705         int ret;
1706
1707         ret = vfio_wait_all_valid(iommu);
1708         if (ret < 0)
1709                 return ret;
1710
1711         /* Arbitrarily pick the first domain in the list for lookups */
1712         if (!list_empty(&iommu->domain_list))
1713                 d = list_first_entry(&iommu->domain_list,
1714                                      struct vfio_domain, next);
1715
1716         vfio_batch_init(&batch);
1717
1718         n = rb_first(&iommu->dma_list);
1719
1720         for (; n; n = rb_next(n)) {
1721                 struct vfio_dma *dma;
1722                 dma_addr_t iova;
1723
1724                 dma = rb_entry(n, struct vfio_dma, node);
1725                 iova = dma->iova;
1726
1727                 while (iova < dma->iova + dma->size) {
1728                         phys_addr_t phys;
1729                         size_t size;
1730
1731                         if (dma->iommu_mapped) {
1732                                 phys_addr_t p;
1733                                 dma_addr_t i;
1734
1735                                 if (WARN_ON(!d)) { /* mapped w/o a domain?! */
1736                                         ret = -EINVAL;
1737                                         goto unwind;
1738                                 }
1739
1740                                 phys = iommu_iova_to_phys(d->domain, iova);
1741
1742                                 if (WARN_ON(!phys)) {
1743                                         iova += PAGE_SIZE;
1744                                         continue;
1745                                 }
1746
1747                                 size = PAGE_SIZE;
1748                                 p = phys + size;
1749                                 i = iova + size;
1750                                 while (i < dma->iova + dma->size &&
1751                                        p == iommu_iova_to_phys(d->domain, i)) {
1752                                         size += PAGE_SIZE;
1753                                         p += PAGE_SIZE;
1754                                         i += PAGE_SIZE;
1755                                 }
1756                         } else {
1757                                 unsigned long pfn;
1758                                 unsigned long vaddr = dma->vaddr +
1759                                                      (iova - dma->iova);
1760                                 size_t n = dma->iova + dma->size - iova;
1761                                 long npage;
1762
1763                                 npage = vfio_pin_pages_remote(dma, vaddr,
1764                                                               n >> PAGE_SHIFT,
1765                                                               &pfn, limit,
1766                                                               &batch);
1767                                 if (npage <= 0) {
1768                                         WARN_ON(!npage);
1769                                         ret = (int)npage;
1770                                         goto unwind;
1771                                 }
1772
1773                                 phys = pfn << PAGE_SHIFT;
1774                                 size = npage << PAGE_SHIFT;
1775                         }
1776
1777                         ret = iommu_map(domain->domain, iova, phys,
1778                                         size, dma->prot | domain->prot);
1779                         if (ret) {
1780                                 if (!dma->iommu_mapped) {
1781                                         vfio_unpin_pages_remote(dma, iova,
1782                                                         phys >> PAGE_SHIFT,
1783                                                         size >> PAGE_SHIFT,
1784                                                         true);
1785                                         vfio_batch_unpin(&batch, dma);
1786                                 }
1787                                 goto unwind;
1788                         }
1789
1790                         iova += size;
1791                 }
1792         }
1793
1794         /* All dmas are now mapped, defer to second tree walk for unwind */
1795         for (n = rb_first(&iommu->dma_list); n; n = rb_next(n)) {
1796                 struct vfio_dma *dma = rb_entry(n, struct vfio_dma, node);
1797
1798                 dma->iommu_mapped = true;
1799         }
1800
1801         vfio_batch_fini(&batch);
1802         return 0;
1803
1804 unwind:
1805         for (; n; n = rb_prev(n)) {
1806                 struct vfio_dma *dma = rb_entry(n, struct vfio_dma, node);
1807                 dma_addr_t iova;
1808
1809                 if (dma->iommu_mapped) {
1810                         iommu_unmap(domain->domain, dma->iova, dma->size);
1811                         continue;
1812                 }
1813
1814                 iova = dma->iova;
1815                 while (iova < dma->iova + dma->size) {
1816                         phys_addr_t phys, p;
1817                         size_t size;
1818                         dma_addr_t i;
1819
1820                         phys = iommu_iova_to_phys(domain->domain, iova);
1821                         if (!phys) {
1822                                 iova += PAGE_SIZE;
1823                                 continue;
1824                         }
1825
1826                         size = PAGE_SIZE;
1827                         p = phys + size;
1828                         i = iova + size;
1829                         while (i < dma->iova + dma->size &&
1830                                p == iommu_iova_to_phys(domain->domain, i)) {
1831                                 size += PAGE_SIZE;
1832                                 p += PAGE_SIZE;
1833                                 i += PAGE_SIZE;
1834                         }
1835
1836                         iommu_unmap(domain->domain, iova, size);
1837                         vfio_unpin_pages_remote(dma, iova, phys >> PAGE_SHIFT,
1838                                                 size >> PAGE_SHIFT, true);
1839                 }
1840         }
1841
1842         vfio_batch_fini(&batch);
1843         return ret;
1844 }
1845
1846 /*
1847  * We change our unmap behavior slightly depending on whether the IOMMU
1848  * supports fine-grained superpages.  IOMMUs like AMD-Vi will use a superpage
1849  * for practically any contiguous power-of-two mapping we give it.  This means
1850  * we don't need to look for contiguous chunks ourselves to make unmapping
1851  * more efficient.  On IOMMUs with coarse-grained super pages, like Intel VT-d
1852  * with discrete 2M/1G/512G/1T superpages, identifying contiguous chunks
1853  * significantly boosts non-hugetlbfs mappings and doesn't seem to hurt when
1854  * hugetlbfs is in use.
1855  */
1856 static void vfio_test_domain_fgsp(struct vfio_domain *domain)
1857 {
1858         struct page *pages;
1859         int ret, order = get_order(PAGE_SIZE * 2);
1860
1861         pages = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
1862         if (!pages)
1863                 return;
1864
1865         ret = iommu_map(domain->domain, 0, page_to_phys(pages), PAGE_SIZE * 2,
1866                         IOMMU_READ | IOMMU_WRITE | domain->prot);
1867         if (!ret) {
1868                 size_t unmapped = iommu_unmap(domain->domain, 0, PAGE_SIZE);
1869
1870                 if (unmapped == PAGE_SIZE)
1871                         iommu_unmap(domain->domain, PAGE_SIZE, PAGE_SIZE);
1872                 else
1873                         domain->fgsp = true;
1874         }
1875
1876         __free_pages(pages, order);
1877 }
1878
1879 static struct vfio_group *find_iommu_group(struct vfio_domain *domain,
1880                                            struct iommu_group *iommu_group)
1881 {
1882         struct vfio_group *g;
1883
1884         list_for_each_entry(g, &domain->group_list, next) {
1885                 if (g->iommu_group == iommu_group)
1886                         return g;
1887         }
1888
1889         return NULL;
1890 }
1891
1892 static struct vfio_group *vfio_iommu_find_iommu_group(struct vfio_iommu *iommu,
1893                                                struct iommu_group *iommu_group)
1894 {
1895         struct vfio_domain *domain;
1896         struct vfio_group *group = NULL;
1897
1898         list_for_each_entry(domain, &iommu->domain_list, next) {
1899                 group = find_iommu_group(domain, iommu_group);
1900                 if (group)
1901                         return group;
1902         }
1903
1904         if (iommu->external_domain)
1905                 group = find_iommu_group(iommu->external_domain, iommu_group);
1906
1907         return group;
1908 }
1909
1910 static bool vfio_iommu_has_sw_msi(struct list_head *group_resv_regions,
1911                                   phys_addr_t *base)
1912 {
1913         struct iommu_resv_region *region;
1914         bool ret = false;
1915
1916         list_for_each_entry(region, group_resv_regions, list) {
1917                 /*
1918                  * The presence of any 'real' MSI regions should take
1919                  * precedence over the software-managed one if the
1920                  * IOMMU driver happens to advertise both types.
1921                  */
1922                 if (region->type == IOMMU_RESV_MSI) {
1923                         ret = false;
1924                         break;
1925                 }
1926
1927                 if (region->type == IOMMU_RESV_SW_MSI) {
1928                         *base = region->start;
1929                         ret = true;
1930                 }
1931         }
1932
1933         return ret;
1934 }
1935
1936 static struct device *vfio_mdev_get_iommu_device(struct device *dev)
1937 {
1938         struct device *(*fn)(struct device *dev);
1939         struct device *iommu_device;
1940
1941         fn = symbol_get(mdev_get_iommu_device);
1942         if (fn) {
1943                 iommu_device = fn(dev);
1944                 symbol_put(mdev_get_iommu_device);
1945
1946                 return iommu_device;
1947         }
1948
1949         return NULL;
1950 }
1951
1952 static int vfio_mdev_attach_domain(struct device *dev, void *data)
1953 {
1954         struct iommu_domain *domain = data;
1955         struct device *iommu_device;
1956
1957         iommu_device = vfio_mdev_get_iommu_device(dev);
1958         if (iommu_device) {
1959                 if (iommu_dev_feature_enabled(iommu_device, IOMMU_DEV_FEAT_AUX))
1960                         return iommu_aux_attach_device(domain, iommu_device);
1961                 else
1962                         return iommu_attach_device(domain, iommu_device);
1963         }
1964
1965         return -EINVAL;
1966 }
1967
1968 static int vfio_mdev_detach_domain(struct device *dev, void *data)
1969 {
1970         struct iommu_domain *domain = data;
1971         struct device *iommu_device;
1972
1973         iommu_device = vfio_mdev_get_iommu_device(dev);
1974         if (iommu_device) {
1975                 if (iommu_dev_feature_enabled(iommu_device, IOMMU_DEV_FEAT_AUX))
1976                         iommu_aux_detach_device(domain, iommu_device);
1977                 else
1978                         iommu_detach_device(domain, iommu_device);
1979         }
1980
1981         return 0;
1982 }
1983
1984 static int vfio_iommu_attach_group(struct vfio_domain *domain,
1985                                    struct vfio_group *group)
1986 {
1987         if (group->mdev_group)
1988                 return iommu_group_for_each_dev(group->iommu_group,
1989                                                 domain->domain,
1990                                                 vfio_mdev_attach_domain);
1991         else
1992                 return iommu_attach_group(domain->domain, group->iommu_group);
1993 }
1994
1995 static void vfio_iommu_detach_group(struct vfio_domain *domain,
1996                                     struct vfio_group *group)
1997 {
1998         if (group->mdev_group)
1999                 iommu_group_for_each_dev(group->iommu_group, domain->domain,
2000                                          vfio_mdev_detach_domain);
2001         else
2002                 iommu_detach_group(domain->domain, group->iommu_group);
2003 }
2004
2005 static bool vfio_bus_is_mdev(struct bus_type *bus)
2006 {
2007         struct bus_type *mdev_bus;
2008         bool ret = false;
2009
2010         mdev_bus = symbol_get(mdev_bus_type);
2011         if (mdev_bus) {
2012                 ret = (bus == mdev_bus);
2013                 symbol_put(mdev_bus_type);
2014         }
2015
2016         return ret;
2017 }
2018
2019 static int vfio_mdev_iommu_device(struct device *dev, void *data)
2020 {
2021         struct device **old = data, *new;
2022
2023         new = vfio_mdev_get_iommu_device(dev);
2024         if (!new || (*old && *old != new))
2025                 return -EINVAL;
2026
2027         *old = new;
2028
2029         return 0;
2030 }
2031
2032 /*
2033  * This is a helper function to insert an address range to iova list.
2034  * The list is initially created with a single entry corresponding to
2035  * the IOMMU domain geometry to which the device group is attached.
2036  * The list aperture gets modified when a new domain is added to the
2037  * container if the new aperture doesn't conflict with the current one
2038  * or with any existing dma mappings. The list is also modified to
2039  * exclude any reserved regions associated with the device group.
2040  */
2041 static int vfio_iommu_iova_insert(struct list_head *head,
2042                                   dma_addr_t start, dma_addr_t end)
2043 {
2044         struct vfio_iova *region;
2045
2046         region = kmalloc(sizeof(*region), GFP_KERNEL);
2047         if (!region)
2048                 return -ENOMEM;
2049
2050         INIT_LIST_HEAD(&region->list);
2051         region->start = start;
2052         region->end = end;
2053
2054         list_add_tail(&region->list, head);
2055         return 0;
2056 }
2057
2058 /*
2059  * Check the new iommu aperture conflicts with existing aper or with any
2060  * existing dma mappings.
2061  */
2062 static bool vfio_iommu_aper_conflict(struct vfio_iommu *iommu,
2063                                      dma_addr_t start, dma_addr_t end)
2064 {
2065         struct vfio_iova *first, *last;
2066         struct list_head *iova = &iommu->iova_list;
2067
2068         if (list_empty(iova))
2069                 return false;
2070
2071         /* Disjoint sets, return conflict */
2072         first = list_first_entry(iova, struct vfio_iova, list);
2073         last = list_last_entry(iova, struct vfio_iova, list);
2074         if (start > last->end || end < first->start)
2075                 return true;
2076
2077         /* Check for any existing dma mappings below the new start */
2078         if (start > first->start) {
2079                 if (vfio_find_dma(iommu, first->start, start - first->start))
2080                         return true;
2081         }
2082
2083         /* Check for any existing dma mappings beyond the new end */
2084         if (end < last->end) {
2085                 if (vfio_find_dma(iommu, end + 1, last->end - end))
2086                         return true;
2087         }
2088
2089         return false;
2090 }
2091
2092 /*
2093  * Resize iommu iova aperture window. This is called only if the new
2094  * aperture has no conflict with existing aperture and dma mappings.
2095  */
2096 static int vfio_iommu_aper_resize(struct list_head *iova,
2097                                   dma_addr_t start, dma_addr_t end)
2098 {
2099         struct vfio_iova *node, *next;
2100
2101         if (list_empty(iova))
2102                 return vfio_iommu_iova_insert(iova, start, end);
2103
2104         /* Adjust iova list start */
2105         list_for_each_entry_safe(node, next, iova, list) {
2106                 if (start < node->start)
2107                         break;
2108                 if (start >= node->start && start < node->end) {
2109                         node->start = start;
2110                         break;
2111                 }
2112                 /* Delete nodes before new start */
2113                 list_del(&node->list);
2114                 kfree(node);
2115         }
2116
2117         /* Adjust iova list end */
2118         list_for_each_entry_safe(node, next, iova, list) {
2119                 if (end > node->end)
2120                         continue;
2121                 if (end > node->start && end <= node->end) {
2122                         node->end = end;
2123                         continue;
2124                 }
2125                 /* Delete nodes after new end */
2126                 list_del(&node->list);
2127                 kfree(node);
2128         }
2129
2130         return 0;
2131 }
2132
2133 /*
2134  * Check reserved region conflicts with existing dma mappings
2135  */
2136 static bool vfio_iommu_resv_conflict(struct vfio_iommu *iommu,
2137                                      struct list_head *resv_regions)
2138 {
2139         struct iommu_resv_region *region;
2140
2141         /* Check for conflict with existing dma mappings */
2142         list_for_each_entry(region, resv_regions, list) {
2143                 if (region->type == IOMMU_RESV_DIRECT_RELAXABLE)
2144                         continue;
2145
2146                 if (vfio_find_dma(iommu, region->start, region->length))
2147                         return true;
2148         }
2149
2150         return false;
2151 }
2152
2153 /*
2154  * Check iova region overlap with  reserved regions and
2155  * exclude them from the iommu iova range
2156  */
2157 static int vfio_iommu_resv_exclude(struct list_head *iova,
2158                                    struct list_head *resv_regions)
2159 {
2160         struct iommu_resv_region *resv;
2161         struct vfio_iova *n, *next;
2162
2163         list_for_each_entry(resv, resv_regions, list) {
2164                 phys_addr_t start, end;
2165
2166                 if (resv->type == IOMMU_RESV_DIRECT_RELAXABLE)
2167                         continue;
2168
2169                 start = resv->start;
2170                 end = resv->start + resv->length - 1;
2171
2172                 list_for_each_entry_safe(n, next, iova, list) {
2173                         int ret = 0;
2174
2175                         /* No overlap */
2176                         if (start > n->end || end < n->start)
2177                                 continue;
2178                         /*
2179                          * Insert a new node if current node overlaps with the
2180                          * reserve region to exlude that from valid iova range.
2181                          * Note that, new node is inserted before the current
2182                          * node and finally the current node is deleted keeping
2183                          * the list updated and sorted.
2184                          */
2185                         if (start > n->start)
2186                                 ret = vfio_iommu_iova_insert(&n->list, n->start,
2187                                                              start - 1);
2188                         if (!ret && end < n->end)
2189                                 ret = vfio_iommu_iova_insert(&n->list, end + 1,
2190                                                              n->end);
2191                         if (ret)
2192                                 return ret;
2193
2194                         list_del(&n->list);
2195                         kfree(n);
2196                 }
2197         }
2198
2199         if (list_empty(iova))
2200                 return -EINVAL;
2201
2202         return 0;
2203 }
2204
2205 static void vfio_iommu_resv_free(struct list_head *resv_regions)
2206 {
2207         struct iommu_resv_region *n, *next;
2208
2209         list_for_each_entry_safe(n, next, resv_regions, list) {
2210                 list_del(&n->list);
2211                 kfree(n);
2212         }
2213 }
2214
2215 static void vfio_iommu_iova_free(struct list_head *iova)
2216 {
2217         struct vfio_iova *n, *next;
2218
2219         list_for_each_entry_safe(n, next, iova, list) {
2220                 list_del(&n->list);
2221                 kfree(n);
2222         }
2223 }
2224
2225 static int vfio_iommu_iova_get_copy(struct vfio_iommu *iommu,
2226                                     struct list_head *iova_copy)
2227 {
2228         struct list_head *iova = &iommu->iova_list;
2229         struct vfio_iova *n;
2230         int ret;
2231
2232         list_for_each_entry(n, iova, list) {
2233                 ret = vfio_iommu_iova_insert(iova_copy, n->start, n->end);
2234                 if (ret)
2235                         goto out_free;
2236         }
2237
2238         return 0;
2239
2240 out_free:
2241         vfio_iommu_iova_free(iova_copy);
2242         return ret;
2243 }
2244
2245 static void vfio_iommu_iova_insert_copy(struct vfio_iommu *iommu,
2246                                         struct list_head *iova_copy)
2247 {
2248         struct list_head *iova = &iommu->iova_list;
2249
2250         vfio_iommu_iova_free(iova);
2251
2252         list_splice_tail(iova_copy, iova);
2253 }
2254
2255 static int vfio_iommu_type1_attach_group(void *iommu_data,
2256                                          struct iommu_group *iommu_group)
2257 {
2258         struct vfio_iommu *iommu = iommu_data;
2259         struct vfio_group *group;
2260         struct vfio_domain *domain, *d;
2261         struct bus_type *bus = NULL;
2262         int ret;
2263         bool resv_msi, msi_remap;
2264         phys_addr_t resv_msi_base = 0;
2265         struct iommu_domain_geometry geo;
2266         LIST_HEAD(iova_copy);
2267         LIST_HEAD(group_resv_regions);
2268
2269         mutex_lock(&iommu->lock);
2270
2271         /* Check for duplicates */
2272         if (vfio_iommu_find_iommu_group(iommu, iommu_group)) {
2273                 mutex_unlock(&iommu->lock);
2274                 return -EINVAL;
2275         }
2276
2277         group = kzalloc(sizeof(*group), GFP_KERNEL);
2278         domain = kzalloc(sizeof(*domain), GFP_KERNEL);
2279         if (!group || !domain) {
2280                 ret = -ENOMEM;
2281                 goto out_free;
2282         }
2283
2284         group->iommu_group = iommu_group;
2285
2286         /* Determine bus_type in order to allocate a domain */
2287         ret = iommu_group_for_each_dev(iommu_group, &bus, vfio_bus_type);
2288         if (ret)
2289                 goto out_free;
2290
2291         if (vfio_bus_is_mdev(bus)) {
2292                 struct device *iommu_device = NULL;
2293
2294                 group->mdev_group = true;
2295
2296                 /* Determine the isolation type */
2297                 ret = iommu_group_for_each_dev(iommu_group, &iommu_device,
2298                                                vfio_mdev_iommu_device);
2299                 if (ret || !iommu_device) {
2300                         if (!iommu->external_domain) {
2301                                 INIT_LIST_HEAD(&domain->group_list);
2302                                 iommu->external_domain = domain;
2303                                 vfio_update_pgsize_bitmap(iommu);
2304                         } else {
2305                                 kfree(domain);
2306                         }
2307
2308                         list_add(&group->next,
2309                                  &iommu->external_domain->group_list);
2310                         /*
2311                          * Non-iommu backed group cannot dirty memory directly,
2312                          * it can only use interfaces that provide dirty
2313                          * tracking.
2314                          * The iommu scope can only be promoted with the
2315                          * addition of a dirty tracking group.
2316                          */
2317                         group->pinned_page_dirty_scope = true;
2318                         mutex_unlock(&iommu->lock);
2319
2320                         return 0;
2321                 }
2322
2323                 bus = iommu_device->bus;
2324         }
2325
2326         domain->domain = iommu_domain_alloc(bus);
2327         if (!domain->domain) {
2328                 ret = -EIO;
2329                 goto out_free;
2330         }
2331
2332         if (iommu->nesting) {
2333                 int attr = 1;
2334
2335                 ret = iommu_domain_set_attr(domain->domain, DOMAIN_ATTR_NESTING,
2336                                             &attr);
2337                 if (ret)
2338                         goto out_domain;
2339         }
2340
2341         ret = vfio_iommu_attach_group(domain, group);
2342         if (ret)
2343                 goto out_domain;
2344
2345         /* Get aperture info */
2346         iommu_domain_get_attr(domain->domain, DOMAIN_ATTR_GEOMETRY, &geo);
2347
2348         if (vfio_iommu_aper_conflict(iommu, geo.aperture_start,
2349                                      geo.aperture_end)) {
2350                 ret = -EINVAL;
2351                 goto out_detach;
2352         }
2353
2354         ret = iommu_get_group_resv_regions(iommu_group, &group_resv_regions);
2355         if (ret)
2356                 goto out_detach;
2357
2358         if (vfio_iommu_resv_conflict(iommu, &group_resv_regions)) {
2359                 ret = -EINVAL;
2360                 goto out_detach;
2361         }
2362
2363         /*
2364          * We don't want to work on the original iova list as the list
2365          * gets modified and in case of failure we have to retain the
2366          * original list. Get a copy here.
2367          */
2368         ret = vfio_iommu_iova_get_copy(iommu, &iova_copy);
2369         if (ret)
2370                 goto out_detach;
2371
2372         ret = vfio_iommu_aper_resize(&iova_copy, geo.aperture_start,
2373                                      geo.aperture_end);
2374         if (ret)
2375                 goto out_detach;
2376
2377         ret = vfio_iommu_resv_exclude(&iova_copy, &group_resv_regions);
2378         if (ret)
2379                 goto out_detach;
2380
2381         resv_msi = vfio_iommu_has_sw_msi(&group_resv_regions, &resv_msi_base);
2382
2383         INIT_LIST_HEAD(&domain->group_list);
2384         list_add(&group->next, &domain->group_list);
2385
2386         msi_remap = irq_domain_check_msi_remap() ||
2387                     iommu_capable(bus, IOMMU_CAP_INTR_REMAP);
2388
2389         if (!allow_unsafe_interrupts && !msi_remap) {
2390                 pr_warn("%s: No interrupt remapping support.  Use the module param \"allow_unsafe_interrupts\" to enable VFIO IOMMU support on this platform\n",
2391                        __func__);
2392                 ret = -EPERM;
2393                 goto out_detach;
2394         }
2395
2396         if (iommu_capable(bus, IOMMU_CAP_CACHE_COHERENCY))
2397                 domain->prot |= IOMMU_CACHE;
2398
2399         /*
2400          * Try to match an existing compatible domain.  We don't want to
2401          * preclude an IOMMU driver supporting multiple bus_types and being
2402          * able to include different bus_types in the same IOMMU domain, so
2403          * we test whether the domains use the same iommu_ops rather than
2404          * testing if they're on the same bus_type.
2405          */
2406         list_for_each_entry(d, &iommu->domain_list, next) {
2407                 if (d->domain->ops == domain->domain->ops &&
2408                     d->prot == domain->prot) {
2409                         vfio_iommu_detach_group(domain, group);
2410                         if (!vfio_iommu_attach_group(d, group)) {
2411                                 list_add(&group->next, &d->group_list);
2412                                 iommu_domain_free(domain->domain);
2413                                 kfree(domain);
2414                                 goto done;
2415                         }
2416
2417                         ret = vfio_iommu_attach_group(domain, group);
2418                         if (ret)
2419                                 goto out_domain;
2420                 }
2421         }
2422
2423         vfio_test_domain_fgsp(domain);
2424
2425         /* replay mappings on new domains */
2426         ret = vfio_iommu_replay(iommu, domain);
2427         if (ret)
2428                 goto out_detach;
2429
2430         if (resv_msi) {
2431                 ret = iommu_get_msi_cookie(domain->domain, resv_msi_base);
2432                 if (ret && ret != -ENODEV)
2433                         goto out_detach;
2434         }
2435
2436         list_add(&domain->next, &iommu->domain_list);
2437         vfio_update_pgsize_bitmap(iommu);
2438 done:
2439         /* Delete the old one and insert new iova list */
2440         vfio_iommu_iova_insert_copy(iommu, &iova_copy);
2441
2442         /*
2443          * An iommu backed group can dirty memory directly and therefore
2444          * demotes the iommu scope until it declares itself dirty tracking
2445          * capable via the page pinning interface.
2446          */
2447         iommu->num_non_pinned_groups++;
2448         mutex_unlock(&iommu->lock);
2449         vfio_iommu_resv_free(&group_resv_regions);
2450
2451         return 0;
2452
2453 out_detach:
2454         vfio_iommu_detach_group(domain, group);
2455 out_domain:
2456         iommu_domain_free(domain->domain);
2457         vfio_iommu_iova_free(&iova_copy);
2458         vfio_iommu_resv_free(&group_resv_regions);
2459 out_free:
2460         kfree(domain);
2461         kfree(group);
2462         mutex_unlock(&iommu->lock);
2463         return ret;
2464 }
2465
2466 static void vfio_iommu_unmap_unpin_all(struct vfio_iommu *iommu)
2467 {
2468         struct rb_node *node;
2469
2470         while ((node = rb_first(&iommu->dma_list)))
2471                 vfio_remove_dma(iommu, rb_entry(node, struct vfio_dma, node));
2472 }
2473
2474 static void vfio_iommu_unmap_unpin_reaccount(struct vfio_iommu *iommu)
2475 {
2476         struct rb_node *n, *p;
2477
2478         n = rb_first(&iommu->dma_list);
2479         for (; n; n = rb_next(n)) {
2480                 struct vfio_dma *dma;
2481                 long locked = 0, unlocked = 0;
2482
2483                 dma = rb_entry(n, struct vfio_dma, node);
2484                 unlocked += vfio_unmap_unpin(iommu, dma, false);
2485                 p = rb_first(&dma->pfn_list);
2486                 for (; p; p = rb_next(p)) {
2487                         struct vfio_pfn *vpfn = rb_entry(p, struct vfio_pfn,
2488                                                          node);
2489
2490                         if (!is_invalid_reserved_pfn(vpfn->pfn))
2491                                 locked++;
2492                 }
2493                 vfio_lock_acct(dma, locked - unlocked, true);
2494         }
2495 }
2496
2497 /*
2498  * Called when a domain is removed in detach. It is possible that
2499  * the removed domain decided the iova aperture window. Modify the
2500  * iova aperture with the smallest window among existing domains.
2501  */
2502 static void vfio_iommu_aper_expand(struct vfio_iommu *iommu,
2503                                    struct list_head *iova_copy)
2504 {
2505         struct vfio_domain *domain;
2506         struct iommu_domain_geometry geo;
2507         struct vfio_iova *node;
2508         dma_addr_t start = 0;
2509         dma_addr_t end = (dma_addr_t)~0;
2510
2511         if (list_empty(iova_copy))
2512                 return;
2513
2514         list_for_each_entry(domain, &iommu->domain_list, next) {
2515                 iommu_domain_get_attr(domain->domain, DOMAIN_ATTR_GEOMETRY,
2516                                       &geo);
2517                 if (geo.aperture_start > start)
2518                         start = geo.aperture_start;
2519                 if (geo.aperture_end < end)
2520                         end = geo.aperture_end;
2521         }
2522
2523         /* Modify aperture limits. The new aper is either same or bigger */
2524         node = list_first_entry(iova_copy, struct vfio_iova, list);
2525         node->start = start;
2526         node = list_last_entry(iova_copy, struct vfio_iova, list);
2527         node->end = end;
2528 }
2529
2530 /*
2531  * Called when a group is detached. The reserved regions for that
2532  * group can be part of valid iova now. But since reserved regions
2533  * may be duplicated among groups, populate the iova valid regions
2534  * list again.
2535  */
2536 static int vfio_iommu_resv_refresh(struct vfio_iommu *iommu,
2537                                    struct list_head *iova_copy)
2538 {
2539         struct vfio_domain *d;
2540         struct vfio_group *g;
2541         struct vfio_iova *node;
2542         dma_addr_t start, end;
2543         LIST_HEAD(resv_regions);
2544         int ret;
2545
2546         if (list_empty(iova_copy))
2547                 return -EINVAL;
2548
2549         list_for_each_entry(d, &iommu->domain_list, next) {
2550                 list_for_each_entry(g, &d->group_list, next) {
2551                         ret = iommu_get_group_resv_regions(g->iommu_group,
2552                                                            &resv_regions);
2553                         if (ret)
2554                                 goto done;
2555                 }
2556         }
2557
2558         node = list_first_entry(iova_copy, struct vfio_iova, list);
2559         start = node->start;
2560         node = list_last_entry(iova_copy, struct vfio_iova, list);
2561         end = node->end;
2562
2563         /* purge the iova list and create new one */
2564         vfio_iommu_iova_free(iova_copy);
2565
2566         ret = vfio_iommu_aper_resize(iova_copy, start, end);
2567         if (ret)
2568                 goto done;
2569
2570         /* Exclude current reserved regions from iova ranges */
2571         ret = vfio_iommu_resv_exclude(iova_copy, &resv_regions);
2572 done:
2573         vfio_iommu_resv_free(&resv_regions);
2574         return ret;
2575 }
2576
2577 static void vfio_iommu_type1_detach_group(void *iommu_data,
2578                                           struct iommu_group *iommu_group)
2579 {
2580         struct vfio_iommu *iommu = iommu_data;
2581         struct vfio_domain *domain;
2582         struct vfio_group *group;
2583         bool update_dirty_scope = false;
2584         LIST_HEAD(iova_copy);
2585
2586         mutex_lock(&iommu->lock);
2587
2588         if (iommu->external_domain) {
2589                 group = find_iommu_group(iommu->external_domain, iommu_group);
2590                 if (group) {
2591                         update_dirty_scope = !group->pinned_page_dirty_scope;
2592                         list_del(&group->next);
2593                         kfree(group);
2594
2595                         if (list_empty(&iommu->external_domain->group_list)) {
2596                                 if (!IS_IOMMU_CAP_DOMAIN_IN_CONTAINER(iommu)) {
2597                                         WARN_ON(iommu->notifier.head);
2598                                         vfio_iommu_unmap_unpin_all(iommu);
2599                                 }
2600
2601                                 kfree(iommu->external_domain);
2602                                 iommu->external_domain = NULL;
2603                         }
2604                         goto detach_group_done;
2605                 }
2606         }
2607
2608         /*
2609          * Get a copy of iova list. This will be used to update
2610          * and to replace the current one later. Please note that
2611          * we will leave the original list as it is if update fails.
2612          */
2613         vfio_iommu_iova_get_copy(iommu, &iova_copy);
2614
2615         list_for_each_entry(domain, &iommu->domain_list, next) {
2616                 group = find_iommu_group(domain, iommu_group);
2617                 if (!group)
2618                         continue;
2619
2620                 vfio_iommu_detach_group(domain, group);
2621                 update_dirty_scope = !group->pinned_page_dirty_scope;
2622                 list_del(&group->next);
2623                 kfree(group);
2624                 /*
2625                  * Group ownership provides privilege, if the group list is
2626                  * empty, the domain goes away. If it's the last domain with
2627                  * iommu and external domain doesn't exist, then all the
2628                  * mappings go away too. If it's the last domain with iommu and
2629                  * external domain exist, update accounting
2630                  */
2631                 if (list_empty(&domain->group_list)) {
2632                         if (list_is_singular(&iommu->domain_list)) {
2633                                 if (!iommu->external_domain) {
2634                                         WARN_ON(iommu->notifier.head);
2635                                         vfio_iommu_unmap_unpin_all(iommu);
2636                                 } else {
2637                                         vfio_iommu_unmap_unpin_reaccount(iommu);
2638                                 }
2639                         }
2640                         iommu_domain_free(domain->domain);
2641                         list_del(&domain->next);
2642                         kfree(domain);
2643                         vfio_iommu_aper_expand(iommu, &iova_copy);
2644                         vfio_update_pgsize_bitmap(iommu);
2645                 }
2646                 break;
2647         }
2648
2649         if (!vfio_iommu_resv_refresh(iommu, &iova_copy))
2650                 vfio_iommu_iova_insert_copy(iommu, &iova_copy);
2651         else
2652                 vfio_iommu_iova_free(&iova_copy);
2653
2654 detach_group_done:
2655         /*
2656          * Removal of a group without dirty tracking may allow the iommu scope
2657          * to be promoted.
2658          */
2659         if (update_dirty_scope) {
2660                 iommu->num_non_pinned_groups--;
2661                 if (iommu->dirty_page_tracking)
2662                         vfio_iommu_populate_bitmap_full(iommu);
2663         }
2664         mutex_unlock(&iommu->lock);
2665 }
2666
2667 static void *vfio_iommu_type1_open(unsigned long arg)
2668 {
2669         struct vfio_iommu *iommu;
2670
2671         iommu = kzalloc(sizeof(*iommu), GFP_KERNEL);
2672         if (!iommu)
2673                 return ERR_PTR(-ENOMEM);
2674
2675         switch (arg) {
2676         case VFIO_TYPE1_IOMMU:
2677                 break;
2678         case VFIO_TYPE1_NESTING_IOMMU:
2679                 iommu->nesting = true;
2680                 fallthrough;
2681         case VFIO_TYPE1v2_IOMMU:
2682                 iommu->v2 = true;
2683                 break;
2684         default:
2685                 kfree(iommu);
2686                 return ERR_PTR(-EINVAL);
2687         }
2688
2689         INIT_LIST_HEAD(&iommu->domain_list);
2690         INIT_LIST_HEAD(&iommu->iova_list);
2691         iommu->dma_list = RB_ROOT;
2692         iommu->dma_avail = dma_entry_limit;
2693         iommu->container_open = true;
2694         mutex_init(&iommu->lock);
2695         BLOCKING_INIT_NOTIFIER_HEAD(&iommu->notifier);
2696         init_waitqueue_head(&iommu->vaddr_wait);
2697
2698         return iommu;
2699 }
2700
2701 static void vfio_release_domain(struct vfio_domain *domain, bool external)
2702 {
2703         struct vfio_group *group, *group_tmp;
2704
2705         list_for_each_entry_safe(group, group_tmp,
2706                                  &domain->group_list, next) {
2707                 if (!external)
2708                         vfio_iommu_detach_group(domain, group);
2709                 list_del(&group->next);
2710                 kfree(group);
2711         }
2712
2713         if (!external)
2714                 iommu_domain_free(domain->domain);
2715 }
2716
2717 static void vfio_iommu_type1_release(void *iommu_data)
2718 {
2719         struct vfio_iommu *iommu = iommu_data;
2720         struct vfio_domain *domain, *domain_tmp;
2721
2722         if (iommu->external_domain) {
2723                 vfio_release_domain(iommu->external_domain, true);
2724                 kfree(iommu->external_domain);
2725         }
2726
2727         vfio_iommu_unmap_unpin_all(iommu);
2728
2729         list_for_each_entry_safe(domain, domain_tmp,
2730                                  &iommu->domain_list, next) {
2731                 vfio_release_domain(domain, false);
2732                 list_del(&domain->next);
2733                 kfree(domain);
2734         }
2735
2736         vfio_iommu_iova_free(&iommu->iova_list);
2737
2738         kfree(iommu);
2739 }
2740
2741 static int vfio_domains_have_iommu_cache(struct vfio_iommu *iommu)
2742 {
2743         struct vfio_domain *domain;
2744         int ret = 1;
2745
2746         mutex_lock(&iommu->lock);
2747         list_for_each_entry(domain, &iommu->domain_list, next) {
2748                 if (!(domain->prot & IOMMU_CACHE)) {
2749                         ret = 0;
2750                         break;
2751                 }
2752         }
2753         mutex_unlock(&iommu->lock);
2754
2755         return ret;
2756 }
2757
2758 static int vfio_iommu_type1_check_extension(struct vfio_iommu *iommu,
2759                                             unsigned long arg)
2760 {
2761         switch (arg) {
2762         case VFIO_TYPE1_IOMMU:
2763         case VFIO_TYPE1v2_IOMMU:
2764         case VFIO_TYPE1_NESTING_IOMMU:
2765         case VFIO_UNMAP_ALL:
2766         case VFIO_UPDATE_VADDR:
2767                 return 1;
2768         case VFIO_DMA_CC_IOMMU:
2769                 if (!iommu)
2770                         return 0;
2771                 return vfio_domains_have_iommu_cache(iommu);
2772         default:
2773                 return 0;
2774         }
2775 }
2776
2777 static int vfio_iommu_iova_add_cap(struct vfio_info_cap *caps,
2778                  struct vfio_iommu_type1_info_cap_iova_range *cap_iovas,
2779                  size_t size)
2780 {
2781         struct vfio_info_cap_header *header;
2782         struct vfio_iommu_type1_info_cap_iova_range *iova_cap;
2783
2784         header = vfio_info_cap_add(caps, size,
2785                                    VFIO_IOMMU_TYPE1_INFO_CAP_IOVA_RANGE, 1);
2786         if (IS_ERR(header))
2787                 return PTR_ERR(header);
2788
2789         iova_cap = container_of(header,
2790                                 struct vfio_iommu_type1_info_cap_iova_range,
2791                                 header);
2792         iova_cap->nr_iovas = cap_iovas->nr_iovas;
2793         memcpy(iova_cap->iova_ranges, cap_iovas->iova_ranges,
2794                cap_iovas->nr_iovas * sizeof(*cap_iovas->iova_ranges));
2795         return 0;
2796 }
2797
2798 static int vfio_iommu_iova_build_caps(struct vfio_iommu *iommu,
2799                                       struct vfio_info_cap *caps)
2800 {
2801         struct vfio_iommu_type1_info_cap_iova_range *cap_iovas;
2802         struct vfio_iova *iova;
2803         size_t size;
2804         int iovas = 0, i = 0, ret;
2805
2806         list_for_each_entry(iova, &iommu->iova_list, list)
2807                 iovas++;
2808
2809         if (!iovas) {
2810                 /*
2811                  * Return 0 as a container with a single mdev device
2812                  * will have an empty list
2813                  */
2814                 return 0;
2815         }
2816
2817         size = sizeof(*cap_iovas) + (iovas * sizeof(*cap_iovas->iova_ranges));
2818
2819         cap_iovas = kzalloc(size, GFP_KERNEL);
2820         if (!cap_iovas)
2821                 return -ENOMEM;
2822
2823         cap_iovas->nr_iovas = iovas;
2824
2825         list_for_each_entry(iova, &iommu->iova_list, list) {
2826                 cap_iovas->iova_ranges[i].start = iova->start;
2827                 cap_iovas->iova_ranges[i].end = iova->end;
2828                 i++;
2829         }
2830
2831         ret = vfio_iommu_iova_add_cap(caps, cap_iovas, size);
2832
2833         kfree(cap_iovas);
2834         return ret;
2835 }
2836
2837 static int vfio_iommu_migration_build_caps(struct vfio_iommu *iommu,
2838                                            struct vfio_info_cap *caps)
2839 {
2840         struct vfio_iommu_type1_info_cap_migration cap_mig;
2841
2842         cap_mig.header.id = VFIO_IOMMU_TYPE1_INFO_CAP_MIGRATION;
2843         cap_mig.header.version = 1;
2844
2845         cap_mig.flags = 0;
2846         /* support minimum pgsize */
2847         cap_mig.pgsize_bitmap = (size_t)1 << __ffs(iommu->pgsize_bitmap);
2848         cap_mig.max_dirty_bitmap_size = DIRTY_BITMAP_SIZE_MAX;
2849
2850         return vfio_info_add_capability(caps, &cap_mig.header, sizeof(cap_mig));
2851 }
2852
2853 static int vfio_iommu_dma_avail_build_caps(struct vfio_iommu *iommu,
2854                                            struct vfio_info_cap *caps)
2855 {
2856         struct vfio_iommu_type1_info_dma_avail cap_dma_avail;
2857
2858         cap_dma_avail.header.id = VFIO_IOMMU_TYPE1_INFO_DMA_AVAIL;
2859         cap_dma_avail.header.version = 1;
2860
2861         cap_dma_avail.avail = iommu->dma_avail;
2862
2863         return vfio_info_add_capability(caps, &cap_dma_avail.header,
2864                                         sizeof(cap_dma_avail));
2865 }
2866
2867 static int vfio_iommu_type1_get_info(struct vfio_iommu *iommu,
2868                                      unsigned long arg)
2869 {
2870         struct vfio_iommu_type1_info info;
2871         unsigned long minsz;
2872         struct vfio_info_cap caps = { .buf = NULL, .size = 0 };
2873         unsigned long capsz;
2874         int ret;
2875
2876         minsz = offsetofend(struct vfio_iommu_type1_info, iova_pgsizes);
2877
2878         /* For backward compatibility, cannot require this */
2879         capsz = offsetofend(struct vfio_iommu_type1_info, cap_offset);
2880
2881         if (copy_from_user(&info, (void __user *)arg, minsz))
2882                 return -EFAULT;
2883
2884         if (info.argsz < minsz)
2885                 return -EINVAL;
2886
2887         if (info.argsz >= capsz) {
2888                 minsz = capsz;
2889                 info.cap_offset = 0; /* output, no-recopy necessary */
2890         }
2891
2892         mutex_lock(&iommu->lock);
2893         info.flags = VFIO_IOMMU_INFO_PGSIZES;
2894
2895         info.iova_pgsizes = iommu->pgsize_bitmap;
2896
2897         ret = vfio_iommu_migration_build_caps(iommu, &caps);
2898
2899         if (!ret)
2900                 ret = vfio_iommu_dma_avail_build_caps(iommu, &caps);
2901
2902         if (!ret)
2903                 ret = vfio_iommu_iova_build_caps(iommu, &caps);
2904
2905         mutex_unlock(&iommu->lock);
2906
2907         if (ret)
2908                 return ret;
2909
2910         if (caps.size) {
2911                 info.flags |= VFIO_IOMMU_INFO_CAPS;
2912
2913                 if (info.argsz < sizeof(info) + caps.size) {
2914                         info.argsz = sizeof(info) + caps.size;
2915                 } else {
2916                         vfio_info_cap_shift(&caps, sizeof(info));
2917                         if (copy_to_user((void __user *)arg +
2918                                         sizeof(info), caps.buf,
2919                                         caps.size)) {
2920                                 kfree(caps.buf);
2921                                 return -EFAULT;
2922                         }
2923                         info.cap_offset = sizeof(info);
2924                 }
2925
2926                 kfree(caps.buf);
2927         }
2928
2929         return copy_to_user((void __user *)arg, &info, minsz) ?
2930                         -EFAULT : 0;
2931 }
2932
2933 static int vfio_iommu_type1_map_dma(struct vfio_iommu *iommu,
2934                                     unsigned long arg)
2935 {
2936         struct vfio_iommu_type1_dma_map map;
2937         unsigned long minsz;
2938         uint32_t mask = VFIO_DMA_MAP_FLAG_READ | VFIO_DMA_MAP_FLAG_WRITE |
2939                         VFIO_DMA_MAP_FLAG_VADDR;
2940
2941         minsz = offsetofend(struct vfio_iommu_type1_dma_map, size);
2942
2943         if (copy_from_user(&map, (void __user *)arg, minsz))
2944                 return -EFAULT;
2945
2946         if (map.argsz < minsz || map.flags & ~mask)
2947                 return -EINVAL;
2948
2949         return vfio_dma_do_map(iommu, &map);
2950 }
2951
2952 static int vfio_iommu_type1_unmap_dma(struct vfio_iommu *iommu,
2953                                       unsigned long arg)
2954 {
2955         struct vfio_iommu_type1_dma_unmap unmap;
2956         struct vfio_bitmap bitmap = { 0 };
2957         uint32_t mask = VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP |
2958                         VFIO_DMA_UNMAP_FLAG_VADDR |
2959                         VFIO_DMA_UNMAP_FLAG_ALL;
2960         unsigned long minsz;
2961         int ret;
2962
2963         minsz = offsetofend(struct vfio_iommu_type1_dma_unmap, size);
2964
2965         if (copy_from_user(&unmap, (void __user *)arg, minsz))
2966                 return -EFAULT;
2967
2968         if (unmap.argsz < minsz || unmap.flags & ~mask)
2969                 return -EINVAL;
2970
2971         if ((unmap.flags & VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP) &&
2972             (unmap.flags & (VFIO_DMA_UNMAP_FLAG_ALL |
2973                             VFIO_DMA_UNMAP_FLAG_VADDR)))
2974                 return -EINVAL;
2975
2976         if (unmap.flags & VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP) {
2977                 unsigned long pgshift;
2978
2979                 if (unmap.argsz < (minsz + sizeof(bitmap)))
2980                         return -EINVAL;
2981
2982                 if (copy_from_user(&bitmap,
2983                                    (void __user *)(arg + minsz),
2984                                    sizeof(bitmap)))
2985                         return -EFAULT;
2986
2987                 if (!access_ok((void __user *)bitmap.data, bitmap.size))
2988                         return -EINVAL;
2989
2990                 pgshift = __ffs(bitmap.pgsize);
2991                 ret = verify_bitmap_size(unmap.size >> pgshift,
2992                                          bitmap.size);
2993                 if (ret)
2994                         return ret;
2995         }
2996
2997         ret = vfio_dma_do_unmap(iommu, &unmap, &bitmap);
2998         if (ret)
2999                 return ret;
3000
3001         return copy_to_user((void __user *)arg, &unmap, minsz) ?
3002                         -EFAULT : 0;
3003 }
3004
3005 static int vfio_iommu_type1_dirty_pages(struct vfio_iommu *iommu,
3006                                         unsigned long arg)
3007 {
3008         struct vfio_iommu_type1_dirty_bitmap dirty;
3009         uint32_t mask = VFIO_IOMMU_DIRTY_PAGES_FLAG_START |
3010                         VFIO_IOMMU_DIRTY_PAGES_FLAG_STOP |
3011                         VFIO_IOMMU_DIRTY_PAGES_FLAG_GET_BITMAP;
3012         unsigned long minsz;
3013         int ret = 0;
3014
3015         if (!iommu->v2)
3016                 return -EACCES;
3017
3018         minsz = offsetofend(struct vfio_iommu_type1_dirty_bitmap, flags);
3019
3020         if (copy_from_user(&dirty, (void __user *)arg, minsz))
3021                 return -EFAULT;
3022
3023         if (dirty.argsz < minsz || dirty.flags & ~mask)
3024                 return -EINVAL;
3025
3026         /* only one flag should be set at a time */
3027         if (__ffs(dirty.flags) != __fls(dirty.flags))
3028                 return -EINVAL;
3029
3030         if (dirty.flags & VFIO_IOMMU_DIRTY_PAGES_FLAG_START) {
3031                 size_t pgsize;
3032
3033                 mutex_lock(&iommu->lock);
3034                 pgsize = 1 << __ffs(iommu->pgsize_bitmap);
3035                 if (!iommu->dirty_page_tracking) {
3036                         ret = vfio_dma_bitmap_alloc_all(iommu, pgsize);
3037                         if (!ret)
3038                                 iommu->dirty_page_tracking = true;
3039                 }
3040                 mutex_unlock(&iommu->lock);
3041                 return ret;
3042         } else if (dirty.flags & VFIO_IOMMU_DIRTY_PAGES_FLAG_STOP) {
3043                 mutex_lock(&iommu->lock);
3044                 if (iommu->dirty_page_tracking) {
3045                         iommu->dirty_page_tracking = false;
3046                         vfio_dma_bitmap_free_all(iommu);
3047                 }
3048                 mutex_unlock(&iommu->lock);
3049                 return 0;
3050         } else if (dirty.flags & VFIO_IOMMU_DIRTY_PAGES_FLAG_GET_BITMAP) {
3051                 struct vfio_iommu_type1_dirty_bitmap_get range;
3052                 unsigned long pgshift;
3053                 size_t data_size = dirty.argsz - minsz;
3054                 size_t iommu_pgsize;
3055
3056                 if (!data_size || data_size < sizeof(range))
3057                         return -EINVAL;
3058
3059                 if (copy_from_user(&range, (void __user *)(arg + minsz),
3060                                    sizeof(range)))
3061                         return -EFAULT;
3062
3063                 if (range.iova + range.size < range.iova)
3064                         return -EINVAL;
3065                 if (!access_ok((void __user *)range.bitmap.data,
3066                                range.bitmap.size))
3067                         return -EINVAL;
3068
3069                 pgshift = __ffs(range.bitmap.pgsize);
3070                 ret = verify_bitmap_size(range.size >> pgshift,
3071                                          range.bitmap.size);
3072                 if (ret)
3073                         return ret;
3074
3075                 mutex_lock(&iommu->lock);
3076
3077                 iommu_pgsize = (size_t)1 << __ffs(iommu->pgsize_bitmap);
3078
3079                 /* allow only smallest supported pgsize */
3080                 if (range.bitmap.pgsize != iommu_pgsize) {
3081                         ret = -EINVAL;
3082                         goto out_unlock;
3083                 }
3084                 if (range.iova & (iommu_pgsize - 1)) {
3085                         ret = -EINVAL;
3086                         goto out_unlock;
3087                 }
3088                 if (!range.size || range.size & (iommu_pgsize - 1)) {
3089                         ret = -EINVAL;
3090                         goto out_unlock;
3091                 }
3092
3093                 if (iommu->dirty_page_tracking)
3094                         ret = vfio_iova_dirty_bitmap(range.bitmap.data,
3095                                                      iommu, range.iova,
3096                                                      range.size,
3097                                                      range.bitmap.pgsize);
3098                 else
3099                         ret = -EINVAL;
3100 out_unlock:
3101                 mutex_unlock(&iommu->lock);
3102
3103                 return ret;
3104         }
3105
3106         return -EINVAL;
3107 }
3108
3109 static long vfio_iommu_type1_ioctl(void *iommu_data,
3110                                    unsigned int cmd, unsigned long arg)
3111 {
3112         struct vfio_iommu *iommu = iommu_data;
3113
3114         switch (cmd) {
3115         case VFIO_CHECK_EXTENSION:
3116                 return vfio_iommu_type1_check_extension(iommu, arg);
3117         case VFIO_IOMMU_GET_INFO:
3118                 return vfio_iommu_type1_get_info(iommu, arg);
3119         case VFIO_IOMMU_MAP_DMA:
3120                 return vfio_iommu_type1_map_dma(iommu, arg);
3121         case VFIO_IOMMU_UNMAP_DMA:
3122                 return vfio_iommu_type1_unmap_dma(iommu, arg);
3123         case VFIO_IOMMU_DIRTY_PAGES:
3124                 return vfio_iommu_type1_dirty_pages(iommu, arg);
3125         default:
3126                 return -ENOTTY;
3127         }
3128 }
3129
3130 static int vfio_iommu_type1_register_notifier(void *iommu_data,
3131                                               unsigned long *events,
3132                                               struct notifier_block *nb)
3133 {
3134         struct vfio_iommu *iommu = iommu_data;
3135
3136         /* clear known events */
3137         *events &= ~VFIO_IOMMU_NOTIFY_DMA_UNMAP;
3138
3139         /* refuse to register if still events remaining */
3140         if (*events)
3141                 return -EINVAL;
3142
3143         return blocking_notifier_chain_register(&iommu->notifier, nb);
3144 }
3145
3146 static int vfio_iommu_type1_unregister_notifier(void *iommu_data,
3147                                                 struct notifier_block *nb)
3148 {
3149         struct vfio_iommu *iommu = iommu_data;
3150
3151         return blocking_notifier_chain_unregister(&iommu->notifier, nb);
3152 }
3153
3154 static int vfio_iommu_type1_dma_rw_chunk(struct vfio_iommu *iommu,
3155                                          dma_addr_t user_iova, void *data,
3156                                          size_t count, bool write,
3157                                          size_t *copied)
3158 {
3159         struct mm_struct *mm;
3160         unsigned long vaddr;
3161         struct vfio_dma *dma;
3162         bool kthread = current->mm == NULL;
3163         size_t offset;
3164         int ret;
3165
3166         *copied = 0;
3167
3168         ret = vfio_find_dma_valid(iommu, user_iova, 1, &dma);
3169         if (ret < 0)
3170                 return ret;
3171
3172         if ((write && !(dma->prot & IOMMU_WRITE)) ||
3173                         !(dma->prot & IOMMU_READ))
3174                 return -EPERM;
3175
3176         mm = get_task_mm(dma->task);
3177
3178         if (!mm)
3179                 return -EPERM;
3180
3181         if (kthread)
3182                 kthread_use_mm(mm);
3183         else if (current->mm != mm)
3184                 goto out;
3185
3186         offset = user_iova - dma->iova;
3187
3188         if (count > dma->size - offset)
3189                 count = dma->size - offset;
3190
3191         vaddr = dma->vaddr + offset;
3192
3193         if (write) {
3194                 *copied = copy_to_user((void __user *)vaddr, data,
3195                                          count) ? 0 : count;
3196                 if (*copied && iommu->dirty_page_tracking) {
3197                         unsigned long pgshift = __ffs(iommu->pgsize_bitmap);
3198                         /*
3199                          * Bitmap populated with the smallest supported page
3200                          * size
3201                          */
3202                         bitmap_set(dma->bitmap, offset >> pgshift,
3203                                    ((offset + *copied - 1) >> pgshift) -
3204                                    (offset >> pgshift) + 1);
3205                 }
3206         } else
3207                 *copied = copy_from_user(data, (void __user *)vaddr,
3208                                            count) ? 0 : count;
3209         if (kthread)
3210                 kthread_unuse_mm(mm);
3211 out:
3212         mmput(mm);
3213         return *copied ? 0 : -EFAULT;
3214 }
3215
3216 static int vfio_iommu_type1_dma_rw(void *iommu_data, dma_addr_t user_iova,
3217                                    void *data, size_t count, bool write)
3218 {
3219         struct vfio_iommu *iommu = iommu_data;
3220         int ret = 0;
3221         size_t done;
3222
3223         mutex_lock(&iommu->lock);
3224         while (count > 0) {
3225                 ret = vfio_iommu_type1_dma_rw_chunk(iommu, user_iova, data,
3226                                                     count, write, &done);
3227                 if (ret)
3228                         break;
3229
3230                 count -= done;
3231                 data += done;
3232                 user_iova += done;
3233         }
3234
3235         mutex_unlock(&iommu->lock);
3236         return ret;
3237 }
3238
3239 static struct iommu_domain *
3240 vfio_iommu_type1_group_iommu_domain(void *iommu_data,
3241                                     struct iommu_group *iommu_group)
3242 {
3243         struct iommu_domain *domain = ERR_PTR(-ENODEV);
3244         struct vfio_iommu *iommu = iommu_data;
3245         struct vfio_domain *d;
3246
3247         if (!iommu || !iommu_group)
3248                 return ERR_PTR(-EINVAL);
3249
3250         mutex_lock(&iommu->lock);
3251         list_for_each_entry(d, &iommu->domain_list, next) {
3252                 if (find_iommu_group(d, iommu_group)) {
3253                         domain = d->domain;
3254                         break;
3255                 }
3256         }
3257         mutex_unlock(&iommu->lock);
3258
3259         return domain;
3260 }
3261
3262 static void vfio_iommu_type1_notify(void *iommu_data,
3263                                     enum vfio_iommu_notify_type event)
3264 {
3265         struct vfio_iommu *iommu = iommu_data;
3266
3267         if (event != VFIO_IOMMU_CONTAINER_CLOSE)
3268                 return;
3269         mutex_lock(&iommu->lock);
3270         iommu->container_open = false;
3271         mutex_unlock(&iommu->lock);
3272         wake_up_all(&iommu->vaddr_wait);
3273 }
3274
3275 static const struct vfio_iommu_driver_ops vfio_iommu_driver_ops_type1 = {
3276         .name                   = "vfio-iommu-type1",
3277         .owner                  = THIS_MODULE,
3278         .open                   = vfio_iommu_type1_open,
3279         .release                = vfio_iommu_type1_release,
3280         .ioctl                  = vfio_iommu_type1_ioctl,
3281         .attach_group           = vfio_iommu_type1_attach_group,
3282         .detach_group           = vfio_iommu_type1_detach_group,
3283         .pin_pages              = vfio_iommu_type1_pin_pages,
3284         .unpin_pages            = vfio_iommu_type1_unpin_pages,
3285         .register_notifier      = vfio_iommu_type1_register_notifier,
3286         .unregister_notifier    = vfio_iommu_type1_unregister_notifier,
3287         .dma_rw                 = vfio_iommu_type1_dma_rw,
3288         .group_iommu_domain     = vfio_iommu_type1_group_iommu_domain,
3289         .notify                 = vfio_iommu_type1_notify,
3290 };
3291
3292 static int __init vfio_iommu_type1_init(void)
3293 {
3294         return vfio_register_iommu_driver(&vfio_iommu_driver_ops_type1);
3295 }
3296
3297 static void __exit vfio_iommu_type1_cleanup(void)
3298 {
3299         vfio_unregister_iommu_driver(&vfio_iommu_driver_ops_type1);
3300 }
3301
3302 module_init(vfio_iommu_type1_init);
3303 module_exit(vfio_iommu_type1_cleanup);
3304
3305 MODULE_VERSION(DRIVER_VERSION);
3306 MODULE_LICENSE("GPL v2");
3307 MODULE_AUTHOR(DRIVER_AUTHOR);
3308 MODULE_DESCRIPTION(DRIVER_DESC);