vfio: Type1 IOMMU implementation

This VFIO IOMMU backend is designed primarily for AMD-Vi and Intel
VT-d hardware, but is potentially usable by anything supporting
similar mapping functionality.  We arbitrarily call this a Type1
backend for lack of a better name.  This backend has no IOVA
or host memory mapping restrictions for the user and is optimized
for relatively static mappings.  Mapped areas are pinned into system
memory.

Signed-off-by: Alex Williamson <alex.williamson@redhat.com>

5 files changed, 821 insertions, 1 deletions

diff --git a/drivers/vfio/Kconfig b/drivers/vfio/Kconfig
index 9acb1e729bd6..128b97910b8e 100644
--- a/drivers/vfio/Kconfig
+++ b/drivers/vfio/Kconfig
@@ -1,6 +1,12 @@
+config VFIO_IOMMU_TYPE1
+        tristate
+        depends on VFIO
+        default n
+
 menuconfig VFIO
         tristate "VFIO Non-Privileged userspace driver framework"
         depends on IOMMU_API
+        select VFIO_IOMMU_TYPE1 if X86
         help
           VFIO provides a framework for secure userspace device drivers.
           See Documentation/vfio.txt for more details.
diff --git a/drivers/vfio/Makefile b/drivers/vfio/Makefile
index 7500a67a42a0..2398d4a0e38b 100644
--- a/drivers/vfio/Makefile
+++ b/drivers/vfio/Makefile
@@ -1 +1,3 @@
 obj-$(CONFIG_VFIO) += vfio.o
+obj-$(CONFIG_VFIO_IOMMU_TYPE1) += vfio_iommu_type1.o
+obj-$(CONFIG_VFIO_PCI) += pci/
diff --git a/drivers/vfio/vfio.c b/drivers/vfio/vfio.c
index 052e310aed72..9591e2b509d7 100644
--- a/drivers/vfio/vfio.c
+++ b/drivers/vfio/vfio.c
@@ -1376,6 +1376,13 @@ static int __init vfio_init(void)
 
         pr_info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
 
+        /*
+         * Attempt to load known iommu-drivers.  This gives us a working
+         * environment without the user needing to explicitly load iommu
+         * drivers.
+         */
+        request_module_nowait("vfio_iommu_type1");
+
         return 0;
 
 err_groups_cdev:
diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type1.c
new file mode 100644
index 000000000000..6f3fbc48a6c7
--- /dev/null
+++ b/drivers/vfio/vfio_iommu_type1.c
@@ -0,0 +1,753 @@
+/*
+ * VFIO: IOMMU DMA mapping support for Type1 IOMMU
+ *
+ * Copyright (C) 2012 Red Hat, Inc.  All rights reserved.
+ *     Author: Alex Williamson <alex.williamson@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Derived from original vfio:
+ * Copyright 2010 Cisco Systems, Inc.  All rights reserved.
+ * Author: Tom Lyon, pugs@cisco.com
+ *
+ * We arbitrarily define a Type1 IOMMU as one matching the below code.
+ * It could be called the x86 IOMMU as it's designed for AMD-Vi & Intel
+ * VT-d, but that makes it harder to re-use as theoretically anyone
+ * implementing a similar IOMMU could make use of this.  We expect the
+ * IOMMU to support the IOMMU API and have few to no restrictions around
+ * the IOVA range that can be mapped.  The Type1 IOMMU is currently
+ * optimized for relatively static mappings of a userspace process with
+ * userpsace pages pinned into memory.  We also assume devices and IOMMU
+ * domains are PCI based as the IOMMU API is still centered around a
+ * device/bus interface rather than a group interface.
+ */
+
+#include <linux/compat.h>
+#include <linux/device.h>
+#include <linux/fs.h>
+#include <linux/iommu.h>
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/pci.h>          /* pci_bus_type */
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/vfio.h>
+#include <linux/workqueue.h>
+
+#define DRIVER_VERSION  "0.2"
+#define DRIVER_AUTHOR   "Alex Williamson <alex.williamson@redhat.com>"
+#define DRIVER_DESC     "Type1 IOMMU driver for VFIO"
+
+static bool allow_unsafe_interrupts;
+module_param_named(allow_unsafe_interrupts,
+                   allow_unsafe_interrupts, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(allow_unsafe_interrupts,
+                 "Enable VFIO IOMMU support for on platforms without interrupt remapping support.");
+
+struct vfio_iommu {
+        struct iommu_domain     *domain;
+        struct mutex            lock;
+        struct list_head        dma_list;
+        struct list_head        group_list;
+        bool                    cache;
+};
+
+struct vfio_dma {
+        struct list_head        next;
+        dma_addr_t              iova;           /* Device address */
+        unsigned long           vaddr;          /* Process virtual addr */
+        long                    npage;          /* Number of pages */
+        int                     prot;           /* IOMMU_READ/WRITE */
+};
+
+struct vfio_group {
+        struct iommu_group      *iommu_group;
+        struct list_head        next;
+};
+
+/*
+ * This code handles mapping and unmapping of user data buffers
+ * into DMA'ble space using the IOMMU
+ */
+
+#define NPAGE_TO_SIZE(npage)    ((size_t)(npage) << PAGE_SHIFT)
+
+struct vwork {
+        struct mm_struct        *mm;
+        long                    npage;
+        struct work_struct      work;
+};
+
+/* delayed decrement/increment for locked_vm */
+static void vfio_lock_acct_bg(struct work_struct *work)
+{
+        struct vwork *vwork = container_of(work, struct vwork, work);
+        struct mm_struct *mm;
+
+        mm = vwork->mm;
+        down_write(&mm->mmap_sem);
+        mm->locked_vm += vwork->npage;
+        up_write(&mm->mmap_sem);
+        mmput(mm);
+        kfree(vwork);
+}
+
+static void vfio_lock_acct(long npage)
+{
+        struct vwork *vwork;
+        struct mm_struct *mm;
+
+        if (!current->mm)
+                return; /* process exited */
+
+        if (down_write_trylock(&current->mm->mmap_sem)) {
+                current->mm->locked_vm += npage;
+                up_write(&current->mm->mmap_sem);
+                return;
+        }
+
+        /*
+         * Couldn't get mmap_sem lock, so must setup to update
+         * mm->locked_vm later. If locked_vm were atomic, we
+         * wouldn't need this silliness
+         */
+        vwork = kmalloc(sizeof(struct vwork), GFP_KERNEL);
+        if (!vwork)
+                return;
+        mm = get_task_mm(current);
+        if (!mm) {
+                kfree(vwork);
+                return;
+        }
+        INIT_WORK(&vwork->work, vfio_lock_acct_bg);
+        vwork->mm = mm;
+        vwork->npage = npage;
+        schedule_work(&vwork->work);
+}
+
+/*
+ * Some mappings aren't backed by a struct page, for example an mmap'd
+ * MMIO range for our own or another device.  These use a different
+ * pfn conversion and shouldn't be tracked as locked pages.
+ */
+static bool is_invalid_reserved_pfn(unsigned long pfn)
+{
+        if (pfn_valid(pfn)) {
+                bool reserved;
+                struct page *tail = pfn_to_page(pfn);
+                struct page *head = compound_trans_head(tail);
+                reserved = !!(PageReserved(head));
+                if (head != tail) {
+                        /*
+                         * "head" is not a dangling pointer
+                         * (compound_trans_head takes care of that)
+                         * but the hugepage may have been split