Merge branch 'linus' into core/urgent

2 files changed, 128 insertions, 57 deletions

diff --git a/virt/kvm/vtd.c b/virt/kvm/iommu.c
index a770874f3a3a..e9693a29d00e 100644
--- a/virt/kvm/vtd.c
+++ b/virt/kvm/iommu.c
@@ -25,6 +25,7 @@
 #include <linux/kvm_host.h>
 #include <linux/pci.h>
 #include <linux/dmar.h>
+#include <linux/iommu.h>
 #include <linux/intel-iommu.h>
 
 static int kvm_iommu_unmap_memslots(struct kvm *kvm);
@@ -37,7 +38,7 @@ int kvm_iommu_map_pages(struct kvm *kvm,
         gfn_t gfn = base_gfn;
         pfn_t pfn;
         int i, r = 0;
-        struct dmar_domain *domain = kvm->arch.intel_iommu_domain;
+        struct iommu_domain *domain = kvm->arch.iommu_domain;
 
         /* check if iommu exists and in use */
         if (!domain)
@@ -45,20 +46,17 @@ int kvm_iommu_map_pages(struct kvm *kvm,
 
         for (i = 0; i < npages; i++) {
                 /* check if already mapped */
-                pfn = (pfn_t)intel_iommu_iova_to_pfn(domain,
-                                                     gfn_to_gpa(gfn));
-                if (pfn)
+                if (iommu_iova_to_phys(domain, gfn_to_gpa(gfn)))
                         continue;
 
                 pfn = gfn_to_pfn(kvm, gfn);
-                r = intel_iommu_page_mapping(domain,
-                                             gfn_to_gpa(gfn),
-                                             pfn_to_hpa(pfn),
-                                             PAGE_SIZE,
-                                             DMA_PTE_READ |
-                                             DMA_PTE_WRITE);
+                r = iommu_map_range(domain,
+                                    gfn_to_gpa(gfn),
+                                    pfn_to_hpa(pfn),
+                                    PAGE_SIZE,
+                                    IOMMU_READ | IOMMU_WRITE);
                 if (r) {
-                        printk(KERN_ERR "kvm_iommu_map_pages:"
+                        printk(KERN_ERR "kvm_iommu_map_address:"
                                "iommu failed to map pfn=%lx\n", pfn);
                         goto unmap_pages;
                 }
@@ -73,7 +71,7 @@ unmap_pages:
 
 static int kvm_iommu_map_memslots(struct kvm *kvm)
 {
-        int i, r;
+        int i, r = 0;
 
         down_read(&kvm->slots_lock);
         for (i = 0; i < kvm->nmemslots; i++) {
@@ -86,50 +84,79 @@ static int kvm_iommu_map_memslots(struct kvm *kvm)
         return r;
 }
 
-int kvm_iommu_map_guest(struct kvm *kvm,
-                        struct kvm_assigned_dev_kernel *assigned_dev)
+int kvm_assign_device(struct kvm *kvm,
+                      struct kvm_assigned_dev_kernel *assigned_dev)
 {
         struct pci_dev *pdev = NULL;
+        struct iommu_domain *domain = kvm->arch.iommu_domain;
         int r;
 
-        if (!intel_iommu_found()) {
-                printk(KERN_ERR "%s: intel iommu not found\n", __func__);
+        /* check if iommu exists and in use */
+        if (!domain)
+                return 0;
+
+        pdev = assigned_dev->dev;
+        if (pdev == NULL)
                 return -ENODEV;
+
+        r = iommu_attach_device(domain, &pdev->dev);
+        if (r) {
+                printk(KERN_ERR "assign device %x:%x.%x failed",
+                        pdev->bus->number,
+                        PCI_SLOT(pdev->devfn),
+                        PCI_FUNC(pdev->devfn));
+                return r;
         }
 
-        printk(KERN_DEBUG "VT-d direct map: host bdf = %x:%x:%x\n",
-               assigned_dev->host_busnr,
-               PCI_SLOT(assigned_dev->host_devfn),
-               PCI_FUNC(assigned_dev->host_devfn));
+        printk(KERN_DEBUG "assign device: host bdf = %x:%x:%x\n",
+                assigned_dev->host_busnr,
+                PCI_SLOT(assigned_dev->host_devfn),
+                PCI_FUNC(assigned_dev->host_devfn));
+
+        return 0;
+}
+
+int kvm_deassign_device(struct kvm *kvm,
+                        struct kvm_assigned_dev_kernel *assigned_dev)
+{
+        struct iommu_domain *domain = kvm->arch.iommu_domain;
+        struct pci_dev *pdev = NULL;
+
+        /* check if iommu exists and in use */
+        if (!domain)
+                return 0;
 
         pdev = assigned_dev->dev;
+        if (pdev == NULL)
+                return -ENODEV;
 
-        if (pdev == NULL) {
-                if (kvm->arch.intel_iommu_domain) {
-                        intel_iommu_domain_exit(kvm->arch.intel_iommu_domain);
-                        kvm->arch.intel_iommu_domain = NULL;
-                }
+        iommu_detach_device(domain, &pdev->dev);
+
+        printk(KERN_DEBUG "deassign device: host bdf = %x:%x:%x\n",
+                assigned_dev->host_busnr,
+                PCI_SLOT(assigned_dev->host_devfn),
+                PCI_FUNC(assigned_dev->host_devfn));
+
+        return 0;
+}
+
+int kvm_iommu_map_guest(struct kvm *kvm)
+{
+        int r;
+
+        if (!iommu_found()) {
+                printk(KERN_ERR "%s: iommu not found\n", __func__);
                 return -ENODEV;
         }
 
-        kvm->arch.intel_iommu_domain = intel_iommu_domain_alloc(pdev);
-        if (!kvm->arch.intel_iommu_domain)
-                return -ENODEV;
+        kvm->arch.iommu_domain = iommu_domain_alloc();
+        if (!kvm->arch.iommu_domain)
+                return -ENOMEM;
 
         r = kvm_iommu_map_memslots(kvm);
         if (r)
                 goto out_unmap;
 
-        intel_iommu_detach_dev(kvm->arch.intel_iommu_domain,
-                               pdev->bus->number, pdev->devfn);
-
-        r = intel_iommu_context_mapping(kvm->arch.intel_iommu_domain,
-                                        pdev);
-        if (r) {
-                printk(KERN_ERR "Domain context map for %s failed",
-                       pci_name(pdev));
-                goto out_unmap;
-        }
         return 0;
 
 out_unmap:
@@ -138,19 +165,26 @@ out_unmap:
 }
 
 static void kvm_iommu_put_pages(struct kvm *kvm,
-                               gfn_t base_gfn, unsigned long npages)
+                                gfn_t base_gfn, unsigned long npages)
 {
         gfn_t gfn = base_gfn;
         pfn_t pfn;
-        struct dmar_domain *domain = kvm->arch.intel_iommu_domain;
-        int i;
+        struct iommu_domain *domain = kvm->arch.iommu_domain;
+        unsigned long i;
+        u64 phys;
+
+        /* check if iommu exists and in use */
+        if (!domain)
+                return;
 
         for (i = 0; i < npages; i++) {
-                pfn = (pfn_t)intel_iommu_iova_to_pfn(domain,
-                                                     gfn_to_gpa(gfn));
+                phys = iommu_iova_to_phys(domain, gfn_to_gpa(gfn));
+                pfn = phys >> PAGE_SHIFT;
                 kvm_release_pfn_clean(pfn);
                 gfn++;
         }
+
+        iommu_unmap_range(domain, gfn_to_gpa(base_gfn), PAGE_SIZE * npages);
 }
 
 static int kvm_iommu_unmap_memslots(struct kvm *kvm)
@@ -168,24 +202,13 @@ static int kvm_iommu_unmap_memslots(struct kvm *kvm)
 
 int kvm_iommu_unmap_guest(struct kvm *kvm)
 {
-        struct kvm_assigned_dev_kernel *entry;
-        struct dmar_domain *domain = kvm->arch.intel_iommu_domain;
+        struct iommu_domain *domain = kvm->arch.iommu_domain;
 
         /* check if iommu exists and in use */
         if (!domain)
                 return 0;
 
-        list_for_each_entry(entry, &kvm->arch.assigned_dev_head, list) {
-                printk(KERN_DEBUG "VT-d unmap: host bdf = %x:%x:%x\n",
-                       entry->host_busnr,
-                       PCI_SLOT(entry->host_devfn),
-                       PCI_FUNC(entry->host_devfn));
-
-                /* detach kvm dmar domain */
-                intel_iommu_detach_dev(domain, entry->host_busnr,
-                                       entry->host_devfn);
-        }
         kvm_iommu_unmap_memslots(kvm);
-        intel_iommu_domain_exit(domain);
+        iommu_domain_free(domain);
         return 0;
 }
diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index fc6127cbea1f..3a5a08298aab 100644
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -496,6 +496,7 @@ static int kvm_vm_ioctl_assign_device(struct kvm *kvm,
         match->assigned_dev_id = assigned_dev->assigned_dev_id;
         match->host_busnr = assigned_dev->busnr;
         match->host_devfn = assigned_dev->devfn;
+        match->flags = assigned_dev->flags;
         match->dev = dev;
         match->irq_source_id = -1;
         match->kvm = kvm;
@@ -503,7 +504,12 @@ static int kvm_vm_ioctl_assign_device(struct kvm *kvm,
         list_add(&match->list, &kvm->arch.assigned_dev_head);
 
         if (assigned_dev->flags & KVM_DEV_ASSIGN_ENABLE_IOMMU) {
-                r = kvm_iommu_map_guest(kvm, match);
+                if (!kvm->arch.iommu_domain) {
+                        r = kvm_iommu_map_guest(kvm);
+                        if (r)
+                                goto out_list_del;
+                }
+                r = kvm_assign_device(kvm, match);
                 if (r)
                         goto out_list_del;
         }
@@ -525,6 +531,35 @@ out_free:
 }
 #endif
 
+#ifdef KVM_CAP_DEVICE_DEASSIGNMENT
+static int kvm_vm_ioctl_deassign_device(struct kvm *kvm,
+                struct kvm_assigned_pci_dev *assigned_dev)
+{
+        int r = 0;
+        struct kvm_assigned_dev_kernel *match;
+
+        mutex_lock(&kvm->lock);
+
+        match = kvm_find_assigned_dev(&kvm->arch.assigned_dev_head,
+                                      assigned_dev->assigned_dev_id);
+        if (!match) {
+                printk(KERN_INFO "%s: device hasn't been assigned before, "
+                  "so cannot be deassigned\n", __func__);
+                r = -EINVAL;
+                goto out;
+        }
+
+        if (assigned_dev->flags & KVM_DEV_ASSIGN_ENABLE_IOMMU)
+                kvm_deassign_device(kvm, match);
+
+        kvm_free_assigned_device(kvm, match);
+
+out:
+        mutex_unlock(&kvm->lock);
+        return r;
+}
+#endif
+
 static inline int valid_vcpu(int n)
 {
         return likely(n >= 0 && n < KVM_MAX_VCPUS);
@@ -1858,6 +1893,19 @@ static long kvm_vm_ioctl(struct file *filp,
                 break;
         }
 #endif
+#ifdef KVM_CAP_DEVICE_DEASSIGNMENT
+        case KVM_DEASSIGN_PCI_DEVICE: {
+                struct kvm_assigned_pci_dev assigned_dev;
+
+                r = -EFAULT;
+                if (copy_from_user(&assigned_dev, argp, sizeof assigned_dev))
+                        goto out;
+                r = kvm_vm_ioctl_deassign_device(kvm, &assigned_dev);
+                if (r)
+                        goto out;
+                break;
+        }
+#endif
         default:
                 r = kvm_arch_vm_ioctl(filp, ioctl, arg);
         }