2b36145944572725d8d74177c8e94fcd89436327
[linux-2.6.git] / virt / kvm / iommu.c
1 /*
2  * Copyright (c) 2006, Intel Corporation.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms and conditions of the GNU General Public License,
6  * version 2, as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  *
13  * You should have received a copy of the GNU General Public License along with
14  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15  * Place - Suite 330, Boston, MA 02111-1307 USA.
16  *
17  * Copyright (C) 2006-2008 Intel Corporation
18  * Copyright IBM Corporation, 2008
19  * Copyright 2010 Red Hat, Inc. and/or its affiliates.
20  *
21  * Author: Allen M. Kay <allen.m.kay@intel.com>
22  * Author: Weidong Han <weidong.han@intel.com>
23  * Author: Ben-Ami Yassour <benami@il.ibm.com>
24  */
25
26 #include <linux/list.h>
27 #include <linux/kvm_host.h>
28 #include <linux/pci.h>
29 #include <linux/stat.h>
30 #include <linux/dmar.h>
31 #include <linux/iommu.h>
32 #include <linux/intel-iommu.h>
33
34 static int allow_unsafe_assigned_interrupts;
35 module_param_named(allow_unsafe_assigned_interrupts,
36                    allow_unsafe_assigned_interrupts, bool, S_IRUGO | S_IWUSR);
37 MODULE_PARM_DESC(allow_unsafe_assigned_interrupts,
38  "Enable device assignment on platforms without interrupt remapping support.");
39
40 static int kvm_iommu_unmap_memslots(struct kvm *kvm);
41 static void kvm_iommu_put_pages(struct kvm *kvm,
42                                 gfn_t base_gfn, unsigned long npages);
43
44 static pfn_t kvm_pin_pages(struct kvm *kvm, struct kvm_memory_slot *slot,
45                            gfn_t gfn, unsigned long size)
46 {
47         gfn_t end_gfn;
48         pfn_t pfn;
49
50         pfn     = gfn_to_pfn_memslot(kvm, slot, gfn);
51         end_gfn = gfn + (size >> PAGE_SHIFT);
52         gfn    += 1;
53
54         if (is_error_pfn(pfn))
55                 return pfn;
56
57         while (gfn < end_gfn)
58                 gfn_to_pfn_memslot(kvm, slot, gfn++);
59
60         return pfn;
61 }
62
63 int kvm_iommu_map_pages(struct kvm *kvm, struct kvm_memory_slot *slot)
64 {
65         gfn_t gfn, end_gfn;
66         pfn_t pfn;
67         int r = 0;
68         struct iommu_domain *domain = kvm->arch.iommu_domain;
69         int flags;
70
71         /* check if iommu exists and in use */
72         if (!domain)
73                 return 0;
74
75         gfn     = slot->base_gfn;
76         end_gfn = gfn + slot->npages;
77
78         flags = IOMMU_READ | IOMMU_WRITE;
79         if (kvm->arch.iommu_flags & KVM_IOMMU_CACHE_COHERENCY)
80                 flags |= IOMMU_CACHE;
81
82
83         while (gfn < end_gfn) {
84                 unsigned long page_size;
85
86                 /* Check if already mapped */
87                 if (iommu_iova_to_phys(domain, gfn_to_gpa(gfn))) {
88                         gfn += 1;
89                         continue;
90                 }
91
92                 /* Get the page size we could use to map */
93                 page_size = kvm_host_page_size(kvm, gfn);
94
95                 /* Make sure the page_size does not exceed the memslot */
96                 while ((gfn + (page_size >> PAGE_SHIFT)) > end_gfn)
97                         page_size >>= 1;
98
99                 /* Make sure gfn is aligned to the page size we want to map */
100                 while ((gfn << PAGE_SHIFT) & (page_size - 1))
101                         page_size >>= 1;
102
103                 /*
104                  * Pin all pages we are about to map in memory. This is
105                  * important because we unmap and unpin in 4kb steps later.
106                  */
107                 pfn = kvm_pin_pages(kvm, slot, gfn, page_size);
108                 if (is_error_pfn(pfn)) {
109                         gfn += 1;
110                         continue;
111                 }
112
113                 /* Map into IO address space */
114                 r = iommu_map(domain, gfn_to_gpa(gfn), pfn_to_hpa(pfn),
115                               get_order(page_size), flags);
116                 if (r) {
117                         printk(KERN_ERR "kvm_iommu_map_address:"
118                                "iommu failed to map pfn=%llx\n", pfn);
119                         goto unmap_pages;
120                 }
121
122                 gfn += page_size >> PAGE_SHIFT;
123
124
125         }
126
127         return 0;
128
129 unmap_pages:
130         kvm_iommu_put_pages(kvm, slot->base_gfn, gfn);
131         return r;
132 }
133
134 static int kvm_iommu_map_memslots(struct kvm *kvm)
135 {
136         int i, idx, r = 0;
137         struct kvm_memslots *slots;
138
139         idx = srcu_read_lock(&kvm->srcu);
140         slots = kvm_memslots(kvm);
141
142         for (i = 0; i < slots->nmemslots; i++) {
143                 r = kvm_iommu_map_pages(kvm, &slots->memslots[i]);
144                 if (r)
145                         break;
146         }
147         srcu_read_unlock(&kvm->srcu, idx);
148
149         return r;
150 }
151
152 int kvm_assign_device(struct kvm *kvm,
153                       struct kvm_assigned_dev_kernel *assigned_dev)
154 {
155         struct pci_dev *pdev = NULL;
156         struct iommu_domain *domain = kvm->arch.iommu_domain;
157         int r, last_flags;
158
159         /* check if iommu exists and in use */
160         if (!domain)
161                 return 0;
162
163         pdev = assigned_dev->dev;
164         if (pdev == NULL)
165                 return -ENODEV;
166
167         r = iommu_attach_device(domain, &pdev->dev);
168         if (r) {
169                 printk(KERN_ERR "assign device %x:%x:%x.%x failed",
170                         pci_domain_nr(pdev->bus),
171                         pdev->bus->number,
172                         PCI_SLOT(pdev->devfn),
173                         PCI_FUNC(pdev->devfn));
174                 return r;
175         }
176
177         last_flags = kvm->arch.iommu_flags;
178         if (iommu_domain_has_cap(kvm->arch.iommu_domain,
179                                  IOMMU_CAP_CACHE_COHERENCY))
180                 kvm->arch.iommu_flags |= KVM_IOMMU_CACHE_COHERENCY;
181
182         /* Check if need to update IOMMU page table for guest memory */
183         if ((last_flags ^ kvm->arch.iommu_flags) ==
184                         KVM_IOMMU_CACHE_COHERENCY) {
185                 kvm_iommu_unmap_memslots(kvm);
186                 r = kvm_iommu_map_memslots(kvm);
187                 if (r)
188                         goto out_unmap;
189         }
190
191         pdev->dev_flags |= PCI_DEV_FLAGS_ASSIGNED;
192
193         printk(KERN_DEBUG "assign device %x:%x:%x.%x\n",
194                 assigned_dev->host_segnr,
195                 assigned_dev->host_busnr,
196                 PCI_SLOT(assigned_dev->host_devfn),
197                 PCI_FUNC(assigned_dev->host_devfn));
198
199         return 0;
200 out_unmap:
201         kvm_iommu_unmap_memslots(kvm);
202         return r;
203 }
204
205 int kvm_deassign_device(struct kvm *kvm,
206                         struct kvm_assigned_dev_kernel *assigned_dev)
207 {
208         struct iommu_domain *domain = kvm->arch.iommu_domain;
209         struct pci_dev *pdev = NULL;
210
211         /* check if iommu exists and in use */
212         if (!domain)
213                 return 0;
214
215         pdev = assigned_dev->dev;
216         if (pdev == NULL)
217                 return -ENODEV;
218
219         iommu_detach_device(domain, &pdev->dev);
220
221         pdev->dev_flags &= ~PCI_DEV_FLAGS_ASSIGNED;
222
223         printk(KERN_DEBUG "deassign device %x:%x:%x.%x\n",
224                 assigned_dev->host_segnr,
225                 assigned_dev->host_busnr,
226                 PCI_SLOT(assigned_dev->host_devfn),
227                 PCI_FUNC(assigned_dev->host_devfn));
228
229         return 0;
230 }
231
232 int kvm_iommu_map_guest(struct kvm *kvm)
233 {
234         int r;
235
236         if (!iommu_present(&pci_bus_type)) {
237                 printk(KERN_ERR "%s: iommu not found\n", __func__);
238                 return -ENODEV;
239         }
240
241         kvm->arch.iommu_domain = iommu_domain_alloc(&pci_bus_type);
242         if (!kvm->arch.iommu_domain)
243                 return -ENOMEM;
244
245         if (!allow_unsafe_assigned_interrupts &&
246             !iommu_domain_has_cap(kvm->arch.iommu_domain,
247                                   IOMMU_CAP_INTR_REMAP)) {
248                 printk(KERN_WARNING "%s: No interrupt remapping support,"
249                        " disallowing device assignment."
250                        " Re-enble with \"allow_unsafe_assigned_interrupts=1\""
251                        " module option.\n", __func__);
252                 iommu_domain_free(kvm->arch.iommu_domain);
253                 kvm->arch.iommu_domain = NULL;
254                 return -EPERM;
255         }
256
257         r = kvm_iommu_map_memslots(kvm);
258         if (r)
259                 goto out_unmap;
260
261         return 0;
262
263 out_unmap:
264         kvm_iommu_unmap_memslots(kvm);
265         return r;
266 }
267
268 static void kvm_unpin_pages(struct kvm *kvm, pfn_t pfn, unsigned long npages)
269 {
270         unsigned long i;
271
272         for (i = 0; i < npages; ++i)
273                 kvm_release_pfn_clean(pfn + i);
274 }
275
276 static void kvm_iommu_put_pages(struct kvm *kvm,
277                                 gfn_t base_gfn, unsigned long npages)
278 {
279         struct iommu_domain *domain;
280         gfn_t end_gfn, gfn;
281         pfn_t pfn;
282         u64 phys;
283
284         domain  = kvm->arch.iommu_domain;
285         end_gfn = base_gfn + npages;
286         gfn     = base_gfn;
287
288         /* check if iommu exists and in use */
289         if (!domain)
290                 return;
291
292         while (gfn < end_gfn) {
293                 unsigned long unmap_pages;
294                 int order;
295
296                 /* Get physical address */
297                 phys = iommu_iova_to_phys(domain, gfn_to_gpa(gfn));
298                 pfn  = phys >> PAGE_SHIFT;
299
300                 /* Unmap address from IO address space */
301                 order       = iommu_unmap(domain, gfn_to_gpa(gfn), 0);
302                 unmap_pages = 1ULL << order;
303
304                 /* Unpin all pages we just unmapped to not leak any memory */
305                 kvm_unpin_pages(kvm, pfn, unmap_pages);
306
307                 gfn += unmap_pages;
308         }
309 }
310
311 static int kvm_iommu_unmap_memslots(struct kvm *kvm)
312 {
313         int i, idx;
314         struct kvm_memslots *slots;
315
316         idx = srcu_read_lock(&kvm->srcu);
317         slots = kvm_memslots(kvm);
318
319         for (i = 0; i < slots->nmemslots; i++) {
320                 kvm_iommu_put_pages(kvm, slots->memslots[i].base_gfn,
321                                     slots->memslots[i].npages);
322         }
323         srcu_read_unlock(&kvm->srcu, idx);
324
325         return 0;
326 }
327
328 int kvm_iommu_unmap_guest(struct kvm *kvm)
329 {
330         struct iommu_domain *domain = kvm->arch.iommu_domain;
331
332         /* check if iommu exists and in use */
333         if (!domain)
334                 return 0;
335
336         kvm_iommu_unmap_memslots(kvm);
337         iommu_domain_free(domain);
338         return 0;
339 }