drivers/vfio/vfio_iommu_type1.c

   1 /*
   2  * VFIO: IOMMU DMA mapping support for Type1 IOMMU
   3  *
   4  * Copyright (C) 2012 Red Hat, Inc.  All rights reserved.
   5  *     Author: Alex Williamson <alex.williamson@redhat.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * Derived from original vfio:
  12  * Copyright 2010 Cisco Systems, Inc.  All rights reserved.
  13  * Author: Tom Lyon, pugs@cisco.com
  14  *
  15  * We arbitrarily define a Type1 IOMMU as one matching the below code.
  16  * It could be called the x86 IOMMU as it's designed for AMD-Vi & Intel
  17  * VT-d, but that makes it harder to re-use as theoretically anyone
  18  * implementing a similar IOMMU could make use of this.  We expect the
  19  * IOMMU to support the IOMMU API and have few to no restrictions around
  20  * the IOVA range that can be mapped.  The Type1 IOMMU is currently
  21  * optimized for relatively static mappings of a userspace process with
  22  * userpsace pages pinned into memory.  We also assume devices and IOMMU
  23  * domains are PCI based as the IOMMU API is still centered around a
  24  * device/bus interface rather than a group interface.
  25  */
  26
  27 #include <linux/compat.h>
  28 #include <linux/device.h>
  29 #include <linux/fs.h>
  30 #include <linux/iommu.h>
  31 #include <linux/module.h>
  32 #include <linux/mm.h>
  33 #include <linux/rbtree.h>
  34 #include <linux/sched.h>
  35 #include <linux/slab.h>
  36 #include <linux/uaccess.h>
  37 #include <linux/vfio.h>
  38 #include <linux/workqueue.h>
  39 #include <linux/pid_namespace.h>
  40 #include <linux/mdev.h>
  41 #include <linux/notifier.h>
  42 #include <linux/dma-iommu.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 struct vfio_iommu {
  61         struct list_head        domain_list;
  62         struct vfio_domain      *external_domain; /* domain for external user */
  63         struct mutex            lock;
  64         struct rb_root          dma_list;
  65         struct blocking_notifier_head notifier;
  66         bool                    v2;
  67         bool                    nesting;
  68 };
  69
  70 struct vfio_domain {
  71         struct iommu_domain     *domain;
  72         struct list_head        next;
  73         struct list_head        group_list;
  74         int                     prot;           /* IOMMU_CACHE */
  75         bool                    fgsp;           /* Fine-grained super pages */
  76 };
  77
  78 struct vfio_dma {
  79         struct rb_node          node;
  80         dma_addr_t              iova;           /* Device address */
  81         unsigned long           vaddr;          /* Process virtual addr */
  82         size_t                  size;           /* Map size (bytes) */
  83         int                     prot;           /* IOMMU_READ/WRITE */
  84         bool                    iommu_mapped;
  85         struct task_struct      *task;
  86         struct rb_root          pfn_list;       /* Ex-user pinned pfn list */
  87 };
  88
  89 struct vfio_group {
  90         struct iommu_group      *iommu_group;
  91         struct list_head        next;
  92 };
  93
  94 /*
  95  * Guest RAM pinning working set or DMA target
  96  */
  97 struct vfio_pfn {
  98         struct rb_node          node;
  99         dma_addr_t              iova;           /* Device address */
 100         unsigned long           pfn;            /* Host pfn */
 101         atomic_t                ref_count;
 102 };
 103
 104 #define IS_IOMMU_CAP_DOMAIN_IN_CONTAINER(iommu) \
 105                                         (!list_empty(&iommu->domain_list))
 106
 107 static int put_pfn(unsigned long pfn, int prot);
 108
 109 /*
 110  * This code handles mapping and unmapping of user data buffers
 111  * into DMA'ble space using the IOMMU
 112  */
 113
 114 static struct vfio_dma *vfio_find_dma(struct vfio_iommu *iommu,
 115                                       dma_addr_t start, size_t size)
 116 {
 117         struct rb_node *node = iommu->dma_list.rb_node;
 118
 119         while (node) {
 120                 struct vfio_dma *dma = rb_entry(node, struct vfio_dma, node);
 121
 122                 if (start + size <= dma->iova)
 123                         node = node->rb_left;
 124                 else if (start >= dma->iova + dma->size)
 125                         node = node->rb_right;
 126                 else
 127                         return dma;
 128         }
 129
 130         return NULL;
 131 }
 132
 133 static void vfio_link_dma(struct vfio_iommu *iommu, struct vfio_dma *new)
 134 {
 135         struct rb_node **link = &iommu->dma_list.rb_node, *parent = NULL;
 136         struct vfio_dma *dma;
 137
 138         while (*link) {
 139                 parent = *link;
 140                 dma = rb_entry(parent, struct vfio_dma, node);
 141
 142                 if (new->iova + new->size <= dma->iova)
 143                         link = &(*link)->rb_left;
 144                 else
 145                         link = &(*link)->rb_right;
 146         }
 147
 148         rb_link_node(&new->node, parent, link);
 149         rb_insert_color(&new->node, &iommu->dma_list);
 150 }
 151
 152 static void vfio_unlink_dma(struct vfio_iommu *iommu, struct vfio_dma *old)
 153 {
 154         rb_erase(&old->node, &iommu->dma_list);
 155 }
 156
 157 /*
 158  * Helper Functions for host iova-pfn list
 159  */
 160 static struct vfio_pfn *vfio_find_vpfn(struct vfio_dma *dma, dma_addr_t iova)
 161 {
 162         struct vfio_pfn *vpfn;
 163         struct rb_node *node = dma->pfn_list.rb_node;
 164
 165         while (node) {
 166                 vpfn = rb_entry(node, struct vfio_pfn, node);
 167
 168                 if (iova < vpfn->iova)
 169                         node = node->rb_left;
 170                 else if (iova > vpfn->iova)
 171                         node = node->rb_right;
 172                 else
 173                         return vpfn;
 174         }
 175         return NULL;
 176 }
 177
 178 static void vfio_link_pfn(struct vfio_dma *dma,
 179                           struct vfio_pfn *new)
 180 {
 181         struct rb_node **link, *parent = NULL;
 182         struct vfio_pfn *vpfn;
 183
 184         link = &dma->pfn_list.rb_node;
 185         while (*link) {
 186                 parent = *link;
 187                 vpfn = rb_entry(parent, struct vfio_pfn, node);
 188
 189                 if (new->iova < vpfn->iova)
 190                         link = &(*link)->rb_left;
 191                 else
 192                         link = &(*link)->rb_right;
 193         }
 194
 195         rb_link_node(&new->node, parent, link);
 196         rb_insert_color(&new->node, &dma->pfn_list);
 197 }
 198
 199 static void vfio_unlink_pfn(struct vfio_dma *dma, struct vfio_pfn *old)
 200 {
 201         rb_erase(&old->node, &dma->pfn_list);
 202 }
 203
 204 static int vfio_add_to_pfn_list(struct vfio_dma *dma, dma_addr_t iova,
 205                                 unsigned long pfn)
 206 {
 207         struct vfio_pfn *vpfn;
 208
 209         vpfn = kzalloc(sizeof(*vpfn), GFP_KERNEL);
 210         if (!vpfn)
 211                 return -ENOMEM;
 212
 213         vpfn->iova = iova;
 214         vpfn->pfn = pfn;
 215         atomic_set(&vpfn->ref_count, 1);
 216         vfio_link_pfn(dma, vpfn);
 217         return 0;
 218 }
 219
 220 static void vfio_remove_from_pfn_list(struct vfio_dma *dma,
 221                                       struct vfio_pfn *vpfn)
 222 {
 223         vfio_unlink_pfn(dma, vpfn);
 224         kfree(vpfn);
 225 }
 226
 227 static struct vfio_pfn *vfio_iova_get_vfio_pfn(struct vfio_dma *dma,
 228                                                unsigned long iova)
 229 {
 230         struct vfio_pfn *vpfn = vfio_find_vpfn(dma, iova);
 231
 232         if (vpfn)
 233                 atomic_inc(&vpfn->ref_count);
 234         return vpfn;
 235 }
 236
 237 static int vfio_iova_put_vfio_pfn(struct vfio_dma *dma, struct vfio_pfn *vpfn)
 238 {
 239         int ret = 0;
 240
 241         if (atomic_dec_and_test(&vpfn->ref_count)) {
 242                 ret = put_pfn(vpfn->pfn, dma->prot);
 243                 vfio_remove_from_pfn_list(dma, vpfn);
 244         }
 245         return ret;
 246 }
 247
 248 struct vwork {
 249         struct mm_struct        *mm;
 250         long                    npage;
 251         struct work_struct      work;
 252 };
 253
 254 /* delayed decrement/increment for locked_vm */
 255 static void vfio_lock_acct_bg(struct work_struct *work)
 256 {
 257         struct vwork *vwork = container_of(work, struct vwork, work);
 258         struct mm_struct *mm;
 259
 260         mm = vwork->mm;
 261         down_write(&mm->mmap_sem);
 262         mm->locked_vm += vwork->npage;
 263         up_write(&mm->mmap_sem);
 264         mmput(mm);
 265         kfree(vwork);
 266 }
 267
 268 static void vfio_lock_acct(struct task_struct *task, long npage)
 269 {
 270         struct vwork *vwork;
 271         struct mm_struct *mm;
 272         bool is_current;
 273
 274         if (!npage)
 275                 return;
 276
 277         is_current = (task->mm == current->mm);
 278
 279         mm = is_current ? task->mm : get_task_mm(task);
 280         if (!mm)
 281                 return; /* process exited */
 282
 283         if (down_write_trylock(&mm->mmap_sem)) {
 284                 mm->locked_vm += npage;
 285                 up_write(&mm->mmap_sem);
 286                 if (!is_current)
 287                         mmput(mm);
 288                 return;
 289         }
 290
 291         if (is_current) {
 292                 mm = get_task_mm(task);
 293                 if (!mm)
 294                         return;
 295         }
 296
 297         /*
 298          * Couldn't get mmap_sem lock, so must setup to update
 299          * mm->locked_vm later. If locked_vm were atomic, we
 300          * wouldn't need this silliness
 301          */
 302         vwork = kmalloc(sizeof(struct vwork), GFP_KERNEL);
 303         if (WARN_ON(!vwork)) {
 304                 mmput(mm);
 305                 return;
 306         }
 307         INIT_WORK(&vwork->work, vfio_lock_acct_bg);
 308         vwork->mm = mm;
 309         vwork->npage = npage;
 310         schedule_work(&vwork->work);
 311 }
 312
 313 /*
 314  * Some mappings aren't backed by a struct page, for example an mmap'd
 315  * MMIO range for our own or another device.  These use a different
 316  * pfn conversion and shouldn't be tracked as locked pages.
 317  */
 318 static bool is_invalid_reserved_pfn(unsigned long pfn)
 319 {
 320         if (pfn_valid(pfn)) {
 321                 bool reserved;
 322                 struct page *tail = pfn_to_page(pfn);
 323                 struct page *head = compound_head(tail);
 324                 reserved = !!(PageReserved(head));
 325                 if (head != tail) {
 326                         /*
 327                          * "head" is not a dangling pointer
 328                          * (compound_head takes care of that)
 329                          * but the hugepage may have been split
 330                          * from under us (and we may not hold a
 331                          * reference count on the head page so it can
 332                          * be reused before we run PageReferenced), so
 333                          * we've to check PageTail before returning
 334                          * what we just read.
 335                          */
 336                         smp_rmb();
 337                         if (PageTail(tail))
 338                                 return reserved;
 339                 }
 340                 return PageReserved(tail);
 341         }
 342
 343         return true;
 344 }
 345
 346 static int put_pfn(unsigned long pfn, int prot)
 347 {
 348         if (!is_invalid_reserved_pfn(pfn)) {
 349                 struct page *page = pfn_to_page(pfn);
 350                 if (prot & IOMMU_WRITE)
 351                         SetPageDirty(page);
 352                 put_page(page);
 353                 return 1;
 354         }
 355         return 0;
 356 }
 357
 358 static int vaddr_get_pfn(struct mm_struct *mm, unsigned long vaddr,
 359                          int prot, unsigned long *pfn)
 360 {
 361         struct page *page[1];
 362         struct vm_area_struct *vma;
 363         int ret;
 364
 365         if (mm == current->mm) {
 366                 ret = get_user_pages_fast(vaddr, 1, !!(prot & IOMMU_WRITE),
 367                                           page);
 368         } else {
 369                 unsigned int flags = 0;
 370
 371                 if (prot & IOMMU_WRITE)
 372                         flags |= FOLL_WRITE;
 373
 374                 down_read(&mm->mmap_sem);
 375                 ret = get_user_pages_remote(NULL, mm, vaddr, 1, flags, page,
 376                                             NULL, NULL);
 377                 up_read(&mm->mmap_sem);
 378         }
 379
 380         if (ret == 1) {
 381                 *pfn = page_to_pfn(page[0]);
 382                 return 0;
 383         }
 384
 385         down_read(&mm->mmap_sem);
 386
 387         vma = find_vma_intersection(mm, vaddr, vaddr + 1);
 388
 389         if (vma && vma->vm_flags & VM_PFNMAP) {
 390                 *pfn = ((vaddr - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
 391                 if (is_invalid_reserved_pfn(*pfn))
 392                         ret = 0;
 393         }
 394
 395         up_read(&mm->mmap_sem);
 396         return ret;
 397 }
 398
 399 /*
 400  * Attempt to pin pages.  We really don't want to track all the pfns and
 401  * the iommu can only map chunks of consecutive pfns anyway, so get the
 402  * first page and all consecutive pages with the same locking.
 403  */
 404 static long vfio_pin_pages_remote(struct vfio_dma *dma, unsigned long vaddr,
 405                                   long npage, unsigned long *pfn_base)
 406 {
 407         unsigned long limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
 408         bool lock_cap = capable(CAP_IPC_LOCK);
 409         long ret, pinned = 0, lock_acct = 0;
 410         bool rsvd;
 411         dma_addr_t iova = vaddr - dma->vaddr + dma->iova;
 412
 413         /* This code path is only user initiated */
 414         if (!current->mm)
 415                 return -ENODEV;
 416
 417         ret = vaddr_get_pfn(current->mm, vaddr, dma->prot, pfn_base);
 418         if (ret)
 419                 return ret;
 420
 421         pinned++;
 422         rsvd = is_invalid_reserved_pfn(*pfn_base);
 423
 424         /*
 425          * Reserved pages aren't counted against the user, externally pinned
 426          * pages are already counted against the user.
 427          */
 428         if (!rsvd && !vfio_find_vpfn(dma, iova)) {
 429                 if (!lock_cap && current->mm->locked_vm + 1 > limit) {
 430                         put_pfn(*pfn_base, dma->prot);
 431                         pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n", __func__,
 432                                         limit << PAGE_SHIFT);
 433                         return -ENOMEM;
 434                 }
 435                 lock_acct++;
 436         }
 437
 438         if (unlikely(disable_hugepages))
 439                 goto out;
 440
 441         /* Lock all the consecutive pages from pfn_base */
 442         for (vaddr += PAGE_SIZE, iova += PAGE_SIZE; pinned < npage;
 443              pinned++, vaddr += PAGE_SIZE, iova += PAGE_SIZE) {
 444                 unsigned long pfn = 0;
 445
 446                 ret = vaddr_get_pfn(current->mm, vaddr, dma->prot, &pfn);
 447                 if (ret)
 448                         break;
 449
 450                 if (pfn != *pfn_base + pinned ||
 451                     rsvd != is_invalid_reserved_pfn(pfn)) {
 452                         put_pfn(pfn, dma->prot);
 453                         break;
 454                 }
 455
 456                 if (!rsvd && !vfio_find_vpfn(dma, iova)) {
 457                         if (!lock_cap &&
 458                             current->mm->locked_vm + lock_acct + 1 > limit) {
 459                                 put_pfn(pfn, dma->prot);
 460                                 pr_warn("%s: RLIMIT_MEMLOCK (%ld) exceeded\n",
 461                                         __func__, limit << PAGE_SHIFT);
 462                                 break;
 463                         }
 464                         lock_acct++;
 465                 }
 466         }
 467
 468 out:
 469         vfio_lock_acct(current, lock_acct);
 470
 471         return pinned;
 472 }
 473
 474 static long vfio_unpin_pages_remote(struct vfio_dma *dma, dma_addr_t iova,
 475                                     unsigned long pfn, long npage,
 476                                     bool do_accounting)
 477 {
 478         long unlocked = 0, locked = 0;
 479         long i;
 480
 481         for (i = 0; i < npage; i++, iova += PAGE_SIZE) {
 482                 if (put_pfn(pfn++, dma->prot)) {
 483                         unlocked++;
 484                         if (vfio_find_vpfn(dma, iova))
 485                                 locked++;
 486                 }
 487         }
 488
 489         if (do_accounting)
 490                 vfio_lock_acct(dma->task, locked - unlocked);
 491
 492         return unlocked;
 493 }
 494
 495 static int vfio_pin_page_external(struct vfio_dma *dma, unsigned long vaddr,
 496                                   unsigned long *pfn_base, bool do_accounting)
 497 {
 498         unsigned long limit;
 499         bool lock_cap = ns_capable(task_active_pid_ns(dma->task)->user_ns,
 500                                    CAP_IPC_LOCK);
 501         struct mm_struct *mm;
 502         int ret;
 503         bool rsvd;
 504
 505         mm = get_task_mm(dma->task);
 506         if (!mm)
 507                 return -ENODEV;
 508
 509         ret = vaddr_get_pfn(mm, vaddr, dma->prot, pfn_base);
 510         if (ret)
 511                 goto pin_page_exit;
 512
 513         rsvd = is_invalid_reserved_pfn(*pfn_base);
 514         limit = task_rlimit(dma->task, RLIMIT_MEMLOCK) >> PAGE_SHIFT;
 515
 516         if (!rsvd && !lock_cap && mm->locked_vm + 1 > limit) {
 517                 put_pfn(*pfn_base, dma->prot);
 518                 pr_warn("%s: Task %s (%d) RLIMIT_MEMLOCK (%ld) exceeded\n",
 519                         __func__, dma->task->comm, task_pid_nr(dma->task),
 520                         limit << PAGE_SHIFT);
 521                 ret = -ENOMEM;
 522                 goto pin_page_exit;
 523         }
 524
 525         if (!rsvd && do_accounting)
 526                 vfio_lock_acct(dma->task, 1);
 527         ret = 1;
 528
 529 pin_page_exit:
 530         mmput(mm);
 531         return ret;
 532 }
 533
 534 static int vfio_unpin_page_external(struct vfio_dma *dma, dma_addr_t iova,
 535                                     bool do_accounting)
 536 {
 537         int unlocked;
 538         struct vfio_pfn *vpfn = vfio_find_vpfn(dma, iova);
 539
 540         if (!vpfn)
 541                 return 0;
 542
 543         unlocked = vfio_iova_put_vfio_pfn(dma, vpfn);
 544
 545         if (do_accounting)
 546                 vfio_lock_acct(dma->task, -unlocked);
 547
 548         return unlocked;
 549 }
 550
 551 static int vfio_iommu_type1_pin_pages(void *iommu_data,
 552                                       unsigned long *user_pfn,
 553                                       int npage, int prot,
 554                                       unsigned long *phys_pfn)
 555 {
 556         struct vfio_iommu *iommu = iommu_data;
 557         int i, j, ret;
 558         unsigned long remote_vaddr;
 559         struct vfio_dma *dma;
 560         bool do_accounting;
 561
 562         if (!iommu || !user_pfn || !phys_pfn)
 563                 return -EINVAL;
 564
 565         /* Supported for v2 version only */
 566         if (!iommu->v2)
 567                 return -EACCES;
 568
 569         mutex_lock(&iommu->lock);
 570
 571         /* Fail if notifier list is empty */
 572         if ((!iommu->external_domain) || (!iommu->notifier.head)) {
 573                 ret = -EINVAL;
 574                 goto pin_done;
 575         }
 576
 577         /*
 578          * If iommu capable domain exist in the container then all pages are
 579          * already pinned and accounted. Accouting should be done if there is no
 580          * iommu capable domain in the container.
 581          */
 582         do_accounting = !IS_IOMMU_CAP_DOMAIN_IN_CONTAINER(iommu);
 583
 584         for (i = 0; i < npage; i++) {
 585                 dma_addr_t iova;
 586                 struct vfio_pfn *vpfn;
 587
 588                 iova = user_pfn[i] << PAGE_SHIFT;
 589                 dma = vfio_find_dma(iommu, iova, PAGE_SIZE);
 590                 if (!dma) {
 591                         ret = -EINVAL;
 592                         goto pin_unwind;
 593                 }
 594
 595                 if ((dma->prot & prot) != prot) {
 596                         ret = -EPERM;
 597                         goto pin_unwind;
 598                 }
 599
 600                 vpfn = vfio_iova_get_vfio_pfn(dma, iova);
 601                 if (vpfn) {
 602                         phys_pfn[i] = vpfn->pfn;
 603                         continue;
 604                 }
 605
 606                 remote_vaddr = dma->vaddr + iova - dma->iova;
 607                 ret = vfio_pin_page_external(dma, remote_vaddr, &phys_pfn[i],
 608                                              do_accounting);
 609                 if (ret <= 0) {
 610                         WARN_ON(!ret);
 611                         goto pin_unwind;
 612                 }
 613
 614                 ret = vfio_add_to_pfn_list(dma, iova, phys_pfn[i]);
 615                 if (ret) {
 616                         vfio_unpin_page_external(dma, iova, do_accounting);
 617                         goto pin_unwind;
 618                 }
 619         }
 620
 621         ret = i;
 622         goto pin_done;
 623
 624 pin_unwind:
 625         phys_pfn[i] = 0;
 626         for (j = 0; j < i; j++) {
 627                 dma_addr_t iova;
 628
 629                 iova = user_pfn[j] << PAGE_SHIFT;
 630                 dma = vfio_find_dma(iommu, iova, PAGE_SIZE);
 631                 vfio_unpin_page_external(dma, iova, do_accounting);
 632                 phys_pfn[j] = 0;
 633         }
 634 pin_done:
 635         mutex_unlock(&iommu->lock);
 636         return ret;
 637 }
 638
 639 static int vfio_iommu_type1_unpin_pages(void *iommu_data,
 640                                         unsigned long *user_pfn,
 641                                         int npage)
 642 {
 643         struct vfio_iommu *iommu = iommu_data;
 644         bool do_accounting;
 645         int i;
 646
 647         if (!iommu || !user_pfn)
 648                 return -EINVAL;
 649
 650         /* Supported for v2 version only */
 651         if (!iommu->v2)
 652                 return -EACCES;
 653
 654         mutex_lock(&iommu->lock);
 655
 656         if (!iommu->external_domain) {
 657                 mutex_unlock(&iommu->lock);
 658                 return -EINVAL;
 659         }
 660
 661         do_accounting = !IS_IOMMU_CAP_DOMAIN_IN_CONTAINER(iommu);
 662         for (i = 0; i < npage; i++) {
 663                 struct vfio_dma *dma;
 664                 dma_addr_t iova;
 665
 666                 iova = user_pfn[i] << PAGE_SHIFT;
 667                 dma = vfio_find_dma(iommu, iova, PAGE_SIZE);
 668                 if (!dma)
 669                         goto unpin_exit;
 670                 vfio_unpin_page_external(dma, iova, do_accounting);
 671         }
 672
 673 unpin_exit:
 674         mutex_unlock(&iommu->lock);
 675         return i > npage ? npage : (i > 0 ? i : -EINVAL);
 676 }
 677
 678 static long vfio_unmap_unpin(struct vfio_iommu *iommu, struct vfio_dma *dma,
 679                              bool do_accounting)
 680 {
 681         dma_addr_t iova = dma->iova, end = dma->iova + dma->size;
 682         struct vfio_domain *domain, *d;
 683         long unlocked = 0;
 684
 685         if (!dma->size)
 686                 return 0;
 687
 688         if (!IS_IOMMU_CAP_DOMAIN_IN_CONTAINER(iommu))
 689                 return 0;
 690
 691         /*
 692          * We use the IOMMU to track the physical addresses, otherwise we'd
 693          * need a much more complicated tracking system.  Unfortunately that
 694          * means we need to use one of the iommu domains to figure out the
 695          * pfns to unpin.  The rest need to be unmapped in advance so we have
 696          * no iommu translations remaining when the pages are unpinned.
 697          */
 698         domain = d = list_first_entry(&iommu->domain_list,
 699                                       struct vfio_domain, next);
 700
 701         list_for_each_entry_continue(d, &iommu->domain_list, next) {
 702                 iommu_unmap(d->domain, dma->iova, dma->size);
 703                 cond_resched();
 704         }
 705
 706         while (iova < end) {
 707                 size_t unmapped, len;
 708                 phys_addr_t phys, next;
 709
 710                 phys = iommu_iova_to_phys(domain->domain, iova);
 711                 if (WARN_ON(!phys)) {
 712                         iova += PAGE_SIZE;
 713                         continue;
 714                 }
 715
 716                 /*
 717                  * To optimize for fewer iommu_unmap() calls, each of which
 718                  * may require hardware cache flushing, try to find the
 719                  * largest contiguous physical memory chunk to unmap.
 720                  */
 721                 for (len = PAGE_SIZE;
 722                      !domain->fgsp && iova + len < end; len += PAGE_SIZE) {
 723                         next = iommu_iova_to_phys(domain->domain, iova + len);
 724                         if (next != phys + len)
 725                                 break;
 726                 }
 727
 728                 unmapped = iommu_unmap(domain->domain, iova, len);
 729                 if (WARN_ON(!unmapped))
 730                         break;
 731
 732                 unlocked += vfio_unpin_pages_remote(dma, iova,
 733                                                     phys >> PAGE_SHIFT,
 734                                                     unmapped >> PAGE_SHIFT,
 735                                                     false);
 736                 iova += unmapped;
 737
 738                 cond_resched();
 739         }
 740
 741         dma->iommu_mapped = false;
 742         if (do_accounting) {
 743                 vfio_lock_acct(dma->task, -unlocked);
 744                 return 0;
 745         }
 746         return unlocked;
 747 }
 748
 749 static void vfio_remove_dma(struct vfio_iommu *iommu, struct vfio_dma *dma)
 750 {
 751         vfio_unmap_unpin(iommu, dma, true);
 752         vfio_unlink_dma(iommu, dma);
 753         put_task_struct(dma->task);
 754         kfree(dma);
 755 }
 756
 757 static unsigned long vfio_pgsize_bitmap(struct vfio_iommu *iommu)
 758 {
 759         struct vfio_domain *domain;
 760         unsigned long bitmap = ULONG_MAX;
 761
 762         mutex_lock(&iommu->lock);
 763         list_for_each_entry(domain, &iommu->domain_list, next)
 764                 bitmap &= domain->domain->pgsize_bitmap;
 765         mutex_unlock(&iommu->lock);
 766
 767         /*
 768          * In case the IOMMU supports page sizes smaller than PAGE_SIZE
 769          * we pretend PAGE_SIZE is supported and hide sub-PAGE_SIZE sizes.
 770          * That way the user will be able to map/unmap buffers whose size/
 771          * start address is aligned with PAGE_SIZE. Pinning code uses that
 772          * granularity while iommu driver can use the sub-PAGE_SIZE size
 773          * to map the buffer.
 774          */
 775         if (bitmap & ~PAGE_MASK) {
 776                 bitmap &= PAGE_MASK;
 777                 bitmap |= PAGE_SIZE;
 778         }
 779
 780         return bitmap;
 781 }
 782
 783 static int vfio_dma_do_unmap(struct vfio_iommu *iommu,
 784                              struct vfio_iommu_type1_dma_unmap *unmap)
 785 {
 786         uint64_t mask;
 787         struct vfio_dma *dma, *dma_last = NULL;
 788         size_t unmapped = 0;
 789         int ret = 0, retries = 0;
 790
 791         mask = ((uint64_t)1 << __ffs(vfio_pgsize_bitmap(iommu))) - 1;
 792
 793         if (unmap->iova & mask)
 794                 return -EINVAL;
 795         if (!unmap->size || unmap->size & mask)
 796                 return -EINVAL;
 797
 798         WARN_ON(mask & PAGE_MASK);
 799 again:
 800         mutex_lock(&iommu->lock);
 801
 802         /*
 803          * vfio-iommu-type1 (v1) - User mappings were coalesced together to
 804          * avoid tracking individual mappings.  This means that the granularity
 805          * of the original mapping was lost and the user was allowed to attempt
 806          * to unmap any range.  Depending on the contiguousness of physical
 807          * memory and page sizes supported by the IOMMU, arbitrary unmaps may
 808          * or may not have worked.  We only guaranteed unmap granularity
 809          * matching the original mapping; even though it was untracked here,
 810          * the original mappings are reflected in IOMMU mappings.  This
 811          * resulted in a couple unusual behaviors.  First, if a range is not
 812          * able to be unmapped, ex. a set of 4k pages that was mapped as a
 813          * 2M hugepage into the IOMMU, the unmap ioctl returns success but with
 814          * a zero sized unmap.  Also, if an unmap request overlaps the first
 815          * address of a hugepage, the IOMMU will unmap the entire hugepage.
 816          * This also returns success and the returned unmap size reflects the
 817          * actual size unmapped.
 818          *
 819          * We attempt to maintain compatibility with this "v1" interface, but
 820          * we take control out of the hands of the IOMMU.  Therefore, an unmap
 821          * request offset from the beginning of the original mapping will
 822          * return success with zero sized unmap.  And an unmap request covering
 823          * the first iova of mapping will unmap the entire range.
 824          *
 825          * The v2 version of this interface intends to be more deterministic.
 826          * Unmap requests must fully cover previous mappings.  Multiple
 827          * mappings may still be unmaped by specifying large ranges, but there
 828          * must not be any previous mappings bisected by the range.  An error
 829          * will be returned if these conditions are not met.  The v2 interface
 830          * will only return success and a size of zero if there were no
 831          * mappings within the range.
 832          */
 833         if (iommu->v2) {
 834                 dma = vfio_find_dma(iommu, unmap->iova, 1);
 835                 if (dma && dma->iova != unmap->iova) {
 836                         ret = -EINVAL;
 837                         goto unlock;
 838                 }
 839                 dma = vfio_find_dma(iommu, unmap->iova + unmap->size - 1, 0);
 840                 if (dma && dma->iova + dma->size != unmap->iova + unmap->size) {
 841                         ret = -EINVAL;
 842                         goto unlock;
 843                 }
 844         }
 845
 846         while ((dma = vfio_find_dma(iommu, unmap->iova, unmap->size))) {
 847                 if (!iommu->v2 && unmap->iova > dma->iova)
 848                         break;
 849                 /*
 850                  * Task with same address space who mapped this iova range is
 851                  * allowed to unmap the iova range.
 852                  */
 853                 if (dma->task->mm != current->mm)
 854                         break;
 855
 856                 if (!RB_EMPTY_ROOT(&dma->pfn_list)) {
 857                         struct vfio_iommu_type1_dma_unmap nb_unmap;
 858
 859                         if (dma_last == dma) {
 860                                 BUG_ON(++retries > 10);
 861                         } else {
 862                                 dma_last = dma;
 863                                 retries = 0;
 864                         }
 865
 866                         nb_unmap.iova = dma->iova;
 867                         nb_unmap.size = dma->size;
 868
 869                         /*
 870                          * Notify anyone (mdev vendor drivers) to invalidate and
 871                          * unmap iovas within the range we're about to unmap.
 872                          * Vendor drivers MUST unpin pages in response to an
 873                          * invalidation.
 874                          */
 875                         mutex_unlock(&iommu->lock);
 876                         blocking_notifier_call_chain(&iommu->notifier,
 877                                                     VFIO_IOMMU_NOTIFY_DMA_UNMAP,
 878                                                     &nb_unmap);
 879                         goto again;
 880                 }
 881                 unmapped += dma->size;
 882                 vfio_remove_dma(iommu, dma);
 883         }
 884
 885 unlock:
 886         mutex_unlock(&iommu->lock);
 887
 888         /* Report how much was unmapped */
 889         unmap->size = unmapped;
 890
 891         return ret;
 892 }
 893
 894 /*
 895  * Turns out AMD IOMMU has a page table bug where it won't map large pages
 896  * to a region that previously mapped smaller pages.  This should be fixed
 897  * soon, so this is just a temporary workaround to break mappings down into
 898  * PAGE_SIZE.  Better to map smaller pages than nothing.
 899  */
 900 static int map_try_harder(struct vfio_domain *domain, dma_addr_t iova,
 901                           unsigned long pfn, long npage, int prot)
 902 {
 903         long i;
 904         int ret = 0;
 905
 906         for (i = 0; i < npage; i++, pfn++, iova += PAGE_SIZE) {
 907                 ret = iommu_map(domain->domain, iova,
 908                                 (phys_addr_t)pfn << PAGE_SHIFT,
 909                                 PAGE_SIZE, prot | domain->prot);
 910                 if (ret)
 911                         break;
 912         }
 913
 914         for (; i < npage && i > 0; i--, iova -= PAGE_SIZE)
 915                 iommu_unmap(domain->domain, iova, PAGE_SIZE);
 916
 917         return ret;
 918 }
 919
 920 static int vfio_iommu_map(struct vfio_iommu *iommu, dma_addr_t iova,
 921                           unsigned long pfn, long npage, int prot)
 922 {
 923         struct vfio_domain *d;
 924         int ret;
 925
 926         list_for_each_entry(d, &iommu->domain_list, next) {
 927                 ret = iommu_map(d->domain, iova, (phys_addr_t)pfn << PAGE_SHIFT,
 928                                 npage << PAGE_SHIFT, prot | d->prot);
 929                 if (ret) {
 930                         if (ret != -EBUSY ||
 931                             map_try_harder(d, iova, pfn, npage, prot))
 932                                 goto unwind;
 933                 }
 934
 935                 cond_resched();
 936         }
 937
 938         return 0;
 939
 940 unwind:
 941         list_for_each_entry_continue_reverse(d, &iommu->domain_list, next)
 942                 iommu_unmap(d->domain, iova, npage << PAGE_SHIFT);
 943
 944         return ret;
 945 }
 946
 947 static int vfio_pin_map_dma(struct vfio_iommu *iommu, struct vfio_dma *dma,
 948                             size_t map_size)
 949 {
 950         dma_addr_t iova = dma->iova;
 951         unsigned long vaddr = dma->vaddr;
 952         size_t size = map_size;
 953         long npage;
 954         unsigned long pfn;
 955         int ret = 0;
 956
 957         while (size) {
 958                 /* Pin a contiguous chunk of memory */
 959                 npage = vfio_pin_pages_remote(dma, vaddr + dma->size,
 960                                               size >> PAGE_SHIFT, &pfn);
 961                 if (npage <= 0) {
 962                         WARN_ON(!npage);
 963                         ret = (int)npage;
 964                         break;
 965                 }
 966
 967                 /* Map it! */
 968                 ret = vfio_iommu_map(iommu, iova + dma->size, pfn, npage,
 969                                      dma->prot);
 970                 if (ret) {
 971                         vfio_unpin_pages_remote(dma, iova + dma->size, pfn,
 972                                                 npage, true);
 973                         break;
 974                 }
 975
 976                 size -= npage << PAGE_SHIFT;
 977                 dma->size += npage << PAGE_SHIFT;
 978         }
 979
 980         dma->iommu_mapped = true;
 981
 982         if (ret)
 983                 vfio_remove_dma(iommu, dma);
 984
 985         return ret;
 986 }
 987
 988 static int vfio_dma_do_map(struct vfio_iommu *iommu,
 989                            struct vfio_iommu_type1_dma_map *map)
 990 {
 991         dma_addr_t iova = map->iova;
 992         unsigned long vaddr = map->vaddr;
 993         size_t size = map->size;
 994         int ret = 0, prot = 0;
 995         uint64_t mask;
 996         struct vfio_dma *dma;
 997
 998         /* Verify that none of our __u64 fields overflow */
 999         if (map->size != size || map->vaddr != vaddr || map->iova != iova)
1000                 return -EINVAL;
1001
1002         mask = ((uint64_t)1 << __ffs(vfio_pgsize_bitmap(iommu))) - 1;
1003
1004         WARN_ON(mask & PAGE_MASK);
1005
1006         /* READ/WRITE from device perspective */
1007         if (map->flags & VFIO_DMA_MAP_FLAG_WRITE)
1008                 prot |= IOMMU_WRITE;
1009         if (map->flags & VFIO_DMA_MAP_FLAG_READ)
1010                 prot |= IOMMU_READ;
1011
1012         if (!prot || !size || (size | iova | vaddr) & mask)
1013                 return -EINVAL;
1014
1015         /* Don't allow IOVA or virtual address wrap */
1016         if (iova + size - 1 < iova || vaddr + size - 1 < vaddr)
1017                 return -EINVAL;
1018
1019         mutex_lock(&iommu->lock);
1020
1021         if (vfio_find_dma(iommu, iova, size)) {
1022                 ret = -EEXIST;
1023                 goto out_unlock;
1024         }
1025
1026         dma = kzalloc(sizeof(*dma), GFP_KERNEL);
1027         if (!dma) {
1028                 ret = -ENOMEM;
1029                 goto out_unlock;
1030         }
1031
1032         dma->iova = iova;
1033         dma->vaddr = vaddr;
1034         dma->prot = prot;
1035         get_task_struct(current);
1036         dma->task = current;
1037         dma->pfn_list = RB_ROOT;
1038
1039         /* Insert zero-sized and grow as we map chunks of it */
1040         vfio_link_dma(iommu, dma);
1041
1042         /* Don't pin and map if container doesn't contain IOMMU capable domain*/
1043         if (!IS_IOMMU_CAP_DOMAIN_IN_CONTAINER(iommu))
1044                 dma->size = size;
1045         else
1046                 ret = vfio_pin_map_dma(iommu, dma, size);
1047
1048 out_unlock:
1049         mutex_unlock(&iommu->lock);
1050         return ret;
1051 }
1052
1053 static int vfio_bus_type(struct device *dev, void *data)
1054 {
1055         struct bus_type **bus = data;
1056
1057         if (*bus && *bus != dev->bus)
1058                 return -EINVAL;
1059
1060         *bus = dev->bus;
1061
1062         return 0;
1063 }
1064
1065 static int vfio_iommu_replay(struct vfio_iommu *iommu,
1066                              struct vfio_domain *domain)
1067 {
1068         struct vfio_domain *d;
1069         struct rb_node *n;
1070         int ret;
1071
1072         /* Arbitrarily pick the first domain in the list for lookups */
1073         d = list_first_entry(&iommu->domain_list, struct vfio_domain, next);
1074         n = rb_first(&iommu->dma_list);
1075
1076         for (; n; n = rb_next(n)) {
1077                 struct vfio_dma *dma;
1078                 dma_addr_t iova;
1079
1080                 dma = rb_entry(n, struct vfio_dma, node);
1081                 iova = dma->iova;
1082
1083                 while (iova < dma->iova + dma->size) {
1084                         phys_addr_t phys;
1085                         size_t size;
1086
1087                         if (dma->iommu_mapped) {
1088                                 phys_addr_t p;
1089                                 dma_addr_t i;
1090
1091                                 phys = iommu_iova_to_phys(d->domain, iova);
1092
1093                                 if (WARN_ON(!phys)) {
1094                                         iova += PAGE_SIZE;
1095                                         continue;
1096                                 }
1097
1098                                 size = PAGE_SIZE;
1099                                 p = phys + size;
1100                                 i = iova + size;
1101                                 while (i < dma->iova + dma->size &&
1102                                        p == iommu_iova_to_phys(d->domain, i)) {
1103                                         size += PAGE_SIZE;
1104                                         p += PAGE_SIZE;
1105                                         i += PAGE_SIZE;
1106                                 }
1107                         } else {
1108                                 unsigned long pfn;
1109                                 unsigned long vaddr = dma->vaddr +
1110                                                      (iova - dma->iova);
1111                                 size_t n = dma->iova + dma->size - iova;
1112                                 long npage;
1113
1114                                 npage = vfio_pin_pages_remote(dma, vaddr,
1115                                                               n >> PAGE_SHIFT,
1116                                                               &pfn);
1117                                 if (npage <= 0) {
1118                                         WARN_ON(!npage);
1119                                         ret = (int)npage;
1120                                         return ret;
1121                                 }
1122
1123                                 phys = pfn << PAGE_SHIFT;
1124                                 size = npage << PAGE_SHIFT;
1125                         }
1126
1127                         ret = iommu_map(domain->domain, iova, phys,
1128                                         size, dma->prot | domain->prot);
1129                         if (ret)
1130                                 return ret;
1131
1132                         iova += size;
1133                 }
1134                 dma->iommu_mapped = true;
1135         }
1136         return 0;
1137 }
1138
1139 /*
1140  * We change our unmap behavior slightly depending on whether the IOMMU
1141  * supports fine-grained superpages.  IOMMUs like AMD-Vi will use a superpage
1142  * for practically any contiguous power-of-two mapping we give it.  This means
1143  * we don't need to look for contiguous chunks ourselves to make unmapping
1144  * more efficient.  On IOMMUs with coarse-grained super pages, like Intel VT-d
1145  * with discrete 2M/1G/512G/1T superpages, identifying contiguous chunks
1146  * significantly boosts non-hugetlbfs mappings and doesn't seem to hurt when
1147  * hugetlbfs is in use.
1148  */
1149 static void vfio_test_domain_fgsp(struct vfio_domain *domain)
1150 {
1151         struct page *pages;
1152         int ret, order = get_order(PAGE_SIZE * 2);
1153
1154         pages = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
1155         if (!pages)
1156                 return;
1157
1158         ret = iommu_map(domain->domain, 0, page_to_phys(pages), PAGE_SIZE * 2,
1159                         IOMMU_READ | IOMMU_WRITE | domain->prot);
1160         if (!ret) {
1161                 size_t unmapped = iommu_unmap(domain->domain, 0, PAGE_SIZE);
1162
1163                 if (unmapped == PAGE_SIZE)
1164                         iommu_unmap(domain->domain, PAGE_SIZE, PAGE_SIZE);
1165                 else
1166                         domain->fgsp = true;
1167         }
1168
1169         __free_pages(pages, order);
1170 }
1171
1172 static struct vfio_group *find_iommu_group(struct vfio_domain *domain,
1173                                            struct iommu_group *iommu_group)
1174 {
1175         struct vfio_group *g;
1176
1177         list_for_each_entry(g, &domain->group_list, next) {
1178                 if (g->iommu_group == iommu_group)
1179                         return g;
1180         }
1181
1182         return NULL;
1183 }
1184
1185 static bool vfio_iommu_has_resv_msi(struct iommu_group *group,
1186                                     phys_addr_t *base)
1187 {
1188         struct list_head group_resv_regions;
1189         struct iommu_resv_region *region, *next;
1190         bool ret = false;
1191
1192         INIT_LIST_HEAD(&group_resv_regions);
1193         iommu_get_group_resv_regions(group, &group_resv_regions);
1194         list_for_each_entry(region, &group_resv_regions, list) {
1195                 if (region->type & IOMMU_RESV_MSI) {
1196                         *base = region->start;
1197                         ret = true;
1198                         goto out;
1199                 }
1200         }
1201 out:
1202         list_for_each_entry_safe(region, next, &group_resv_regions, list)
1203                 kfree(region);
1204         return ret;
1205 }
1206
1207 static int vfio_iommu_type1_attach_group(void *iommu_data,
1208                                          struct iommu_group *iommu_group)
1209 {
1210         struct vfio_iommu *iommu = iommu_data;
1211         struct vfio_group *group;
1212         struct vfio_domain *domain, *d;
1213         struct bus_type *bus = NULL, *mdev_bus;
1214         int ret;
1215         bool resv_msi;
1216         phys_addr_t resv_msi_base;
1217
1218         mutex_lock(&iommu->lock);
1219
1220         list_for_each_entry(d, &iommu->domain_list, next) {
1221                 if (find_iommu_group(d, iommu_group)) {
1222                         mutex_unlock(&iommu->lock);
1223                         return -EINVAL;
1224                 }
1225         }
1226
1227         if (iommu->external_domain) {
1228                 if (find_iommu_group(iommu->external_domain, iommu_group)) {
1229                         mutex_unlock(&iommu->lock);
1230                         return -EINVAL;
1231                 }
1232         }
1233
1234         group = kzalloc(sizeof(*group), GFP_KERNEL);
1235         domain = kzalloc(sizeof(*domain), GFP_KERNEL);
1236         if (!group || !domain) {
1237                 ret = -ENOMEM;
1238                 goto out_free;
1239         }
1240
1241         group->iommu_group = iommu_group;
1242
1243         /* Determine bus_type in order to allocate a domain */
1244         ret = iommu_group_for_each_dev(iommu_group, &bus, vfio_bus_type);
1245         if (ret)
1246                 goto out_free;
1247
1248         mdev_bus = symbol_get(mdev_bus_type);
1249
1250         if (mdev_bus) {
1251                 if ((bus == mdev_bus) && !iommu_present(bus)) {
1252                         symbol_put(mdev_bus_type);
1253                         if (!iommu->external_domain) {
1254                                 INIT_LIST_HEAD(&domain->group_list);
1255                                 iommu->external_domain = domain;
1256                         } else
1257                                 kfree(domain);
1258
1259                         list_add(&group->next,
1260                                  &iommu->external_domain->group_list);
1261                         mutex_unlock(&iommu->lock);
1262                         return 0;
1263                 }
1264                 symbol_put(mdev_bus_type);
1265         }
1266
1267         domain->domain = iommu_domain_alloc(bus);
1268         if (!domain->domain) {
1269                 ret = -EIO;
1270                 goto out_free;
1271         }
1272
1273         if (iommu->nesting) {
1274                 int attr = 1;
1275
1276                 ret = iommu_domain_set_attr(domain->domain, DOMAIN_ATTR_NESTING,
1277                                             &attr);
1278                 if (ret)
1279                         goto out_domain;
1280         }
1281
1282         ret = iommu_attach_group(domain->domain, iommu_group);
1283         if (ret)
1284                 goto out_domain;
1285
1286         resv_msi = vfio_iommu_has_resv_msi(iommu_group, &resv_msi_base);
1287
1288         INIT_LIST_HEAD(&domain->group_list);
1289         list_add(&group->next, &domain->group_list);
1290
1291         if (!allow_unsafe_interrupts &&
1292             !iommu_capable(bus, IOMMU_CAP_INTR_REMAP)) {
1293                 pr_warn("%s: No interrupt remapping support.  Use the module param \"allow_unsafe_interrupts\" to enable VFIO IOMMU support on this platform\n",
1294                        __func__);
1295                 ret = -EPERM;
1296                 goto out_detach;
1297         }
1298
1299         if (iommu_capable(bus, IOMMU_CAP_CACHE_COHERENCY))
1300                 domain->prot |= IOMMU_CACHE;
1301
1302         /*
1303          * Try to match an existing compatible domain.  We don't want to
1304          * preclude an IOMMU driver supporting multiple bus_types and being
1305          * able to include different bus_types in the same IOMMU domain, so
1306          * we test whether the domains use the same iommu_ops rather than
1307          * testing if they're on the same bus_type.
1308          */
1309         list_for_each_entry(d, &iommu->domain_list, next) {
1310                 if (d->domain->ops == domain->domain->ops &&
1311                     d->prot == domain->prot) {
1312                         iommu_detach_group(domain->domain, iommu_group);
1313                         if (!iommu_attach_group(d->domain, iommu_group)) {
1314                                 list_add(&group->next, &d->group_list);
1315                                 iommu_domain_free(domain->domain);
1316                                 kfree(domain);
1317                                 mutex_unlock(&iommu->lock);
1318                                 return 0;
1319                         }
1320
1321                         ret = iommu_attach_group(domain->domain, iommu_group);
1322                         if (ret)
1323                                 goto out_domain;
1324                 }
1325         }
1326
1327         vfio_test_domain_fgsp(domain);
1328
1329         /* replay mappings on new domains */
1330         ret = vfio_iommu_replay(iommu, domain);
1331         if (ret)
1332                 goto out_detach;
1333
1334         if (resv_msi && iommu_get_msi_cookie(domain->domain, resv_msi_base))
1335                 goto out_detach;
1336
1337         list_add(&domain->next, &iommu->domain_list);
1338
1339         mutex_unlock(&iommu->lock);
1340
1341         return 0;
1342
1343 out_detach:
1344         iommu_detach_group(domain->domain, iommu_group);
1345 out_domain:
1346         iommu_domain_free(domain->domain);
1347 out_free:
1348         kfree(domain);
1349         kfree(group);
1350         mutex_unlock(&iommu->lock);
1351         return ret;
1352 }
1353
1354 static void vfio_iommu_unmap_unpin_all(struct vfio_iommu *iommu)
1355 {
1356         struct rb_node *node;
1357
1358         while ((node = rb_first(&iommu->dma_list)))
1359                 vfio_remove_dma(iommu, rb_entry(node, struct vfio_dma, node));
1360 }
1361
1362 static void vfio_iommu_unmap_unpin_reaccount(struct vfio_iommu *iommu)
1363 {
1364         struct rb_node *n, *p;
1365
1366         n = rb_first(&iommu->dma_list);
1367         for (; n; n = rb_next(n)) {
1368                 struct vfio_dma *dma;
1369                 long locked = 0, unlocked = 0;
1370
1371                 dma = rb_entry(n, struct vfio_dma, node);
1372                 unlocked += vfio_unmap_unpin(iommu, dma, false);
1373                 p = rb_first(&dma->pfn_list);
1374                 for (; p; p = rb_next(p)) {
1375                         struct vfio_pfn *vpfn = rb_entry(p, struct vfio_pfn,
1376                                                          node);
1377
1378                         if (!is_invalid_reserved_pfn(vpfn->pfn))
1379                                 locked++;
1380                 }
1381                 vfio_lock_acct(dma->task, locked - unlocked);
1382         }
1383 }
1384
1385 static void vfio_sanity_check_pfn_list(struct vfio_iommu *iommu)
1386 {
1387         struct rb_node *n;
1388
1389         n = rb_first(&iommu->dma_list);
1390         for (; n; n = rb_next(n)) {
1391                 struct vfio_dma *dma;
1392
1393                 dma = rb_entry(n, struct vfio_dma, node);
1394
1395                 if (WARN_ON(!RB_EMPTY_ROOT(&dma->pfn_list)))
1396                         break;
1397         }
1398         /* mdev vendor driver must unregister notifier */
1399         WARN_ON(iommu->notifier.head);
1400 }
1401
1402 static void vfio_iommu_type1_detach_group(void *iommu_data,
1403                                           struct iommu_group *iommu_group)
1404 {
1405         struct vfio_iommu *iommu = iommu_data;
1406         struct vfio_domain *domain;
1407         struct vfio_group *group;
1408
1409         mutex_lock(&iommu->lock);
1410
1411         if (iommu->external_domain) {
1412                 group = find_iommu_group(iommu->external_domain, iommu_group);
1413                 if (group) {
1414                         list_del(&group->next);
1415                         kfree(group);
1416
1417                         if (list_empty(&iommu->external_domain->group_list)) {
1418                                 vfio_sanity_check_pfn_list(iommu);
1419
1420                                 if (!IS_IOMMU_CAP_DOMAIN_IN_CONTAINER(iommu))
1421                                         vfio_iommu_unmap_unpin_all(iommu);
1422
1423                                 kfree(iommu->external_domain);
1424                                 iommu->external_domain = NULL;
1425                         }
1426                         goto detach_group_done;
1427                 }
1428         }
1429
1430         list_for_each_entry(domain, &iommu->domain_list, next) {
1431                 group = find_iommu_group(domain, iommu_group);
1432                 if (!group)
1433                         continue;
1434
1435                 iommu_detach_group(domain->domain, iommu_group);
1436                 list_del(&group->next);
1437                 kfree(group);
1438                 /*
1439                  * Group ownership provides privilege, if the group list is
1440                  * empty, the domain goes away. If it's the last domain with
1441                  * iommu and external domain doesn't exist, then all the
1442                  * mappings go away too. If it's the last domain with iommu and
1443                  * external domain exist, update accounting
1444                  */
1445                 if (list_empty(&domain->group_list)) {
1446                         if (list_is_singular(&iommu->domain_list)) {
1447                                 if (!iommu->external_domain)
1448                                         vfio_iommu_unmap_unpin_all(iommu);
1449                                 else
1450                                         vfio_iommu_unmap_unpin_reaccount(iommu);
1451                         }
1452                         iommu_domain_free(domain->domain);
1453                         list_del(&domain->next);
1454                         kfree(domain);
1455                 }
1456                 break;
1457         }
1458
1459 detach_group_done:
1460         mutex_unlock(&iommu->lock);
1461 }
1462
1463 static void *vfio_iommu_type1_open(unsigned long arg)
1464 {
1465         struct vfio_iommu *iommu;
1466
1467         iommu = kzalloc(sizeof(*iommu), GFP_KERNEL);
1468         if (!iommu)
1469                 return ERR_PTR(-ENOMEM);
1470
1471         switch (arg) {
1472         case VFIO_TYPE1_IOMMU:
1473                 break;
1474         case VFIO_TYPE1_NESTING_IOMMU:
1475                 iommu->nesting = true;
1476         case VFIO_TYPE1v2_IOMMU:
1477                 iommu->v2 = true;
1478                 break;
1479         default:
1480                 kfree(iommu);
1481                 return ERR_PTR(-EINVAL);
1482         }
1483
1484         INIT_LIST_HEAD(&iommu->domain_list);
1485         iommu->dma_list = RB_ROOT;
1486         mutex_init(&iommu->lock);
1487         BLOCKING_INIT_NOTIFIER_HEAD(&iommu->notifier);
1488
1489         return iommu;
1490 }
1491
1492 static void vfio_release_domain(struct vfio_domain *domain, bool external)
1493 {
1494         struct vfio_group *group, *group_tmp;
1495
1496         list_for_each_entry_safe(group, group_tmp,
1497                                  &domain->group_list, next) {
1498                 if (!external)
1499                         iommu_detach_group(domain->domain, group->iommu_group);
1500                 list_del(&group->next);
1501                 kfree(group);
1502         }
1503
1504         if (!external)
1505                 iommu_domain_free(domain->domain);
1506 }
1507
1508 static void vfio_iommu_type1_release(void *iommu_data)
1509 {
1510         struct vfio_iommu *iommu = iommu_data;
1511         struct vfio_domain *domain, *domain_tmp;
1512
1513         if (iommu->external_domain) {
1514                 vfio_release_domain(iommu->external_domain, true);
1515                 vfio_sanity_check_pfn_list(iommu);
1516                 kfree(iommu->external_domain);
1517         }
1518
1519         vfio_iommu_unmap_unpin_all(iommu);
1520
1521         list_for_each_entry_safe(domain, domain_tmp,
1522                                  &iommu->domain_list, next) {
1523                 vfio_release_domain(domain, false);
1524                 list_del(&domain->next);
1525                 kfree(domain);
1526         }
1527         kfree(iommu);
1528 }
1529
1530 static int vfio_domains_have_iommu_cache(struct vfio_iommu *iommu)
1531 {
1532         struct vfio_domain *domain;
1533         int ret = 1;
1534
1535         mutex_lock(&iommu->lock);
1536         list_for_each_entry(domain, &iommu->domain_list, next) {
1537                 if (!(domain->prot & IOMMU_CACHE)) {
1538                         ret = 0;
1539                         break;
1540                 }
1541         }
1542         mutex_unlock(&iommu->lock);
1543
1544         return ret;
1545 }
1546
1547 static long vfio_iommu_type1_ioctl(void *iommu_data,
1548                                    unsigned int cmd, unsigned long arg)
1549 {
1550         struct vfio_iommu *iommu = iommu_data;
1551         unsigned long minsz;
1552
1553         if (cmd == VFIO_CHECK_EXTENSION) {
1554                 switch (arg) {
1555                 case VFIO_TYPE1_IOMMU:
1556                 case VFIO_TYPE1v2_IOMMU:
1557                 case VFIO_TYPE1_NESTING_IOMMU:
1558                         return 1;
1559                 case VFIO_DMA_CC_IOMMU:
1560                         if (!iommu)
1561                                 return 0;
1562                         return vfio_domains_have_iommu_cache(iommu);
1563                 default:
1564                         return 0;
1565                 }
1566         } else if (cmd == VFIO_IOMMU_GET_INFO) {
1567                 struct vfio_iommu_type1_info info;
1568
1569                 minsz = offsetofend(struct vfio_iommu_type1_info, iova_pgsizes);
1570
1571                 if (copy_from_user(&info, (void __user *)arg, minsz))
1572                         return -EFAULT;
1573
1574                 if (info.argsz < minsz)
1575                         return -EINVAL;
1576
1577                 info.flags = VFIO_IOMMU_INFO_PGSIZES;
1578
1579                 info.iova_pgsizes = vfio_pgsize_bitmap(iommu);
1580
1581                 return copy_to_user((void __user *)arg, &info, minsz) ?
1582                         -EFAULT : 0;
1583
1584         } else if (cmd == VFIO_IOMMU_MAP_DMA) {
1585                 struct vfio_iommu_type1_dma_map map;
1586                 uint32_t mask = VFIO_DMA_MAP_FLAG_READ |
1587                                 VFIO_DMA_MAP_FLAG_WRITE;
1588
1589                 minsz = offsetofend(struct vfio_iommu_type1_dma_map, size);
1590
1591                 if (copy_from_user(&map, (void __user *)arg, minsz))
1592                         return -EFAULT;
1593
1594                 if (map.argsz < minsz || map.flags & ~mask)
1595                         return -EINVAL;
1596
1597                 return vfio_dma_do_map(iommu, &map);
1598
1599         } else if (cmd == VFIO_IOMMU_UNMAP_DMA) {
1600                 struct vfio_iommu_type1_dma_unmap unmap;
1601                 long ret;
1602
1603                 minsz = offsetofend(struct vfio_iommu_type1_dma_unmap, size);
1604
1605                 if (copy_from_user(&unmap, (void __user *)arg, minsz))
1606                         return -EFAULT;
1607
1608                 if (unmap.argsz < minsz || unmap.flags)
1609                         return -EINVAL;
1610
1611                 ret = vfio_dma_do_unmap(iommu, &unmap);
1612                 if (ret)
1613                         return ret;
1614
1615                 return copy_to_user((void __user *)arg, &unmap, minsz) ?
1616                         -EFAULT : 0;
1617         }
1618
1619         return -ENOTTY;
1620 }
1621
1622 static int vfio_iommu_type1_register_notifier(void *iommu_data,
1623                                               unsigned long *events,
1624                                               struct notifier_block *nb)
1625 {
1626         struct vfio_iommu *iommu = iommu_data;
1627
1628         /* clear known events */
1629         *events &= ~VFIO_IOMMU_NOTIFY_DMA_UNMAP;
1630
1631         /* refuse to register if still events remaining */
1632         if (*events)
1633                 return -EINVAL;
1634
1635         return blocking_notifier_chain_register(&iommu->notifier, nb);
1636 }
1637
1638 static int vfio_iommu_type1_unregister_notifier(void *iommu_data,
1639                                                 struct notifier_block *nb)
1640 {
1641         struct vfio_iommu *iommu = iommu_data;
1642
1643         return blocking_notifier_chain_unregister(&iommu->notifier, nb);
1644 }
1645
1646 static const struct vfio_iommu_driver_ops vfio_iommu_driver_ops_type1 = {
1647         .name                   = "vfio-iommu-type1",
1648         .owner                  = THIS_MODULE,
1649         .open                   = vfio_iommu_type1_open,
1650         .release                = vfio_iommu_type1_release,
1651         .ioctl                  = vfio_iommu_type1_ioctl,
1652         .attach_group           = vfio_iommu_type1_attach_group,
1653         .detach_group           = vfio_iommu_type1_detach_group,
1654         .pin_pages              = vfio_iommu_type1_pin_pages,
1655         .unpin_pages            = vfio_iommu_type1_unpin_pages,
1656         .register_notifier      = vfio_iommu_type1_register_notifier,
1657         .unregister_notifier    = vfio_iommu_type1_unregister_notifier,
1658 };
1659
1660 static int __init vfio_iommu_type1_init(void)
1661 {
1662         return vfio_register_iommu_driver(&vfio_iommu_driver_ops_type1);
1663 }
1664
1665 static void __exit vfio_iommu_type1_cleanup(void)
1666 {
1667         vfio_unregister_iommu_driver(&vfio_iommu_driver_ops_type1);
1668 }
1669
1670 module_init(vfio_iommu_type1_init);
1671 module_exit(vfio_iommu_type1_cleanup);
1672
1673 MODULE_VERSION(DRIVER_VERSION);
1674 MODULE_LICENSE("GPL v2");
1675 MODULE_AUTHOR(DRIVER_AUTHOR);
1676 MODULE_DESCRIPTION(DRIVER_DESC);