KVM: PPC: Allow I/O mappings in memory slots

This provides for the case where userspace maps an I/O device into the
address range of a memory slot using a VM_PFNMAP mapping.  In that
case, we work out the pfn from vma->vm_pgoff, and record the cache
enable bits from vma->vm_page_prot in two low-order bits in the
slot_phys array entries.  Then, in kvmppc_h_enter() we check that the
cache bits in the HPTE that the guest wants to insert match the cache
bits in the slot_phys array entry.  However, we do allow the guest to
create what it thinks is a non-cacheable or write-through mapping to
memory that is actually cacheable, so that we can use normal system
memory as part of an emulated device later on.  In that case the actual
HPTE we insert is a cacheable HPTE.

Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
Signed-off-by: Avi Kivity <avi@redhat.com>

1 files changed, 44 insertions, 21 deletions

diff --git a/arch/powerpc/kvm/book3s_64_mmu_hv.c b/arch/powerpc/kvm/book3s_64_mmu_hv.c
index cc18f3d67a57..b904c40a17bc 100644
--- a/arch/powerpc/kvm/book3s_64_mmu_hv.c
+++ b/arch/powerpc/kvm/book3s_64_mmu_hv.c
@@ -199,7 +199,8 @@ static long kvmppc_get_guest_page(struct kvm *kvm, unsigned long gfn,
         struct page *page, *hpage, *pages[1];
         unsigned long s, pgsize;
         unsigned long *physp;
-        unsigned int got, pgorder;
+        unsigned int is_io, got, pgorder;
+        struct vm_area_struct *vma;
         unsigned long pfn, i, npages;
 
         physp = kvm->arch.slot_phys[memslot->id];
@@ -208,34 +209,51 @@ static long kvmppc_get_guest_page(struct kvm *kvm, unsigned long gfn,
         if (physp[gfn - memslot->base_gfn])
                 return 0;
 
+        is_io = 0;
+        got = 0;
         page = NULL;
         pgsize = psize;
+        err = -EINVAL;
         start = gfn_to_hva_memslot(memslot, gfn);
 
         /* Instantiate and get the page we want access to */
         np = get_user_pages_fast(start, 1, 1, pages);
-        if (np != 1)
-                return -EINVAL;
-        page = pages[0];
-        got = KVMPPC_GOT_PAGE;
+        if (np != 1) {
+                /* Look up the vma for the page */
+                down_read(&current->mm->mmap_sem);
+                vma = find_vma(current->mm, start);
+                if (!vma || vma->vm_start > start ||
+                    start + psize > vma->vm_end ||
+                    !(vma->vm_flags & VM_PFNMAP))
+                        goto up_err;
+                is_io = hpte_cache_bits(pgprot_val(vma->vm_page_prot));
+                pfn = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT);
+                /* check alignment of pfn vs. requested page size */
+                if (psize > PAGE_SIZE && (pfn & ((psize >> PAGE_SHIFT) - 1)))
+                        goto up_err;
+                up_read(&current->mm->mmap_sem);
 
-        /* See if this is a large page */
-        s = PAGE_SIZE;
-        if (PageHuge(page)) {
-                hpage = compound_head(page);
-                s <<= compound_order(hpage);
-                /* Get the whole large page if slot alignment is ok */
-                if (s > psize && slot_is_aligned(memslot, s) &&
-                    !(memslot->userspace_addr & (s - 1))) {
-                        start &= ~(s - 1);
-                        pgsize = s;
-                        page = hpage;
+        } else {
+                page = pages[0];
+                got = KVMPPC_GOT_PAGE;
+
+                /* See if this is a large page */
+                s = PAGE_SIZE;
+                if (PageHuge(page)) {
+                        hpage = compound_head(page);
+                        s <<= compound_order(hpage);
+                        /* Get the whole large page if slot alignment is ok */
+                        if (s > psize && slot_is_aligned(memslot, s) &&
+                            !(memslot->userspace_addr & (s - 1))) {
+                                start &= ~(s - 1);
+                                pgsize = s;
+                                page = hpage;
+                        }
                 }
+                if (s < psize)
+                        goto out;
+                pfn = page_to_pfn(page);
         }
-        err = -EINVAL;
-        if (s < psize)
-                goto out;
-        pfn = page_to_pfn(page);
 
         npages = pgsize >> PAGE_SHIFT;
         pgorder = __ilog2(npages);
@@ -243,7 +261,8 @@ static long kvmppc_get_guest_page(struct kvm *kvm, unsigned long gfn,
         spin_lock(&kvm->arch.slot_phys_lock);
         for (i = 0; i < npages; ++i) {
                 if (!physp[i]) {
-                        physp[i] = ((pfn + i) << PAGE_SHIFT) + got + pgorder;
+                        physp[i] = ((pfn + i) << PAGE_SHIFT) +
+                                got + is_io + pgorder;
                         got = 0;
                 }
         }
@@ -257,6 +276,10 @@ static long kvmppc_get_guest_page(struct kvm *kvm, unsigned long gfn,
                 put_page(page);
         }
         return err;
+
+ up_err:
+        up_read(&current->mm->mmap_sem);
+        return err;
 }
 
 /*