KVM: PPC: Book3S HV: Report VPA and DTL modifications in dirty map

At present, the KVM_GET_DIRTY_LOG ioctl doesn't report modifications
done by the host to the virtual processor areas (VPAs) and dispatch
trace logs (DTLs) registered by the guest.  This is because those
modifications are done either in real mode or in the host kernel
context, and in neither case does the access go through the guest's
HPT, and thus no change (C) bit gets set in the guest's HPT.

However, the changes done by the host do need to be tracked so that
the modified pages get transferred when doing live migration.  In
order to track these modifications, this adds a dirty flag to the
struct representing the VPA/DTL areas, and arranges to set the flag
when the VPA/DTL gets modified by the host.  Then, when we are
collecting the dirty log, we also check the dirty flags for the
VPA and DTL for each vcpu and set the relevant bit in the dirty log
if necessary.  Doing this also means we now need to keep track of
the guest physical address of the VPA/DTL areas.

So as not to lose track of modifications to a VPA/DTL area when it gets
unregistered, or when a new area gets registered in its place, we need
to transfer the dirty state to the rmap chain.  This adds code to
kvmppc_unpin_guest_page() to do that if the area was dirty.  To simplify
that code, we now require that all VPA, DTL and SLB shadow buffer areas
fit within a single host page.  Guests already comply with this
requirement because pHyp requires that these areas not cross a 4k
boundary.

Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Alexander Graf <agraf@suse.de>

1 files changed, 52 insertions, 9 deletions

diff --git a/arch/powerpc/kvm/book3s_64_mmu_hv.c b/arch/powerpc/kvm/book3s_64_mmu_hv.c
index d641a6634b02..69efe0d6cedc 100644
--- a/arch/powerpc/kvm/book3s_64_mmu_hv.c
+++ b/arch/powerpc/kvm/book3s_64_mmu_hv.c
@@ -1099,11 +1099,30 @@ static int kvm_test_clear_dirty(struct kvm *kvm, unsigned long *rmapp)
         return ret;
 }
 
+static void harvest_vpa_dirty(struct kvmppc_vpa *vpa,
+                              struct kvm_memory_slot *memslot,
+                              unsigned long *map)
+{
+        unsigned long gfn;
+
+        if (!vpa->dirty || !vpa->pinned_addr)
+                return;
+        gfn = vpa->gpa >> PAGE_SHIFT;
+        if (gfn < memslot->base_gfn ||
+            gfn >= memslot->base_gfn + memslot->npages)
+                return;
+
+        vpa->dirty = false;
+        if (map)
+                __set_bit_le(gfn - memslot->base_gfn, map);
+}
+
 long kvmppc_hv_get_dirty_log(struct kvm *kvm, struct kvm_memory_slot *memslot,
                              unsigned long *map)
 {
         unsigned long i;
         unsigned long *rmapp;
+        struct kvm_vcpu *vcpu;
 
         preempt_disable();
         rmapp = memslot->arch.rmap;
@@ -1112,6 +1131,15 @@ long kvmppc_hv_get_dirty_log(struct kvm *kvm, struct kvm_memory_slot *memslot,
                         __set_bit_le(i, map);
                 ++rmapp;
         }
+
+        /* Harvest dirty bits from VPA and DTL updates */
+        /* Note: we never modify the SLB shadow buffer areas */
+        kvm_for_each_vcpu(i, vcpu, kvm) {
+                spin_lock(&vcpu->arch.vpa_update_lock);
+                harvest_vpa_dirty(&vcpu->arch.vpa, memslot, map);
+                harvest_vpa_dirty(&vcpu->arch.dtl, memslot, map);
+                spin_unlock(&vcpu->arch.vpa_update_lock);
+        }
         preempt_enable();
         return 0;
 }
@@ -1123,7 +1151,7 @@ void *kvmppc_pin_guest_page(struct kvm *kvm, unsigned long gpa,
         unsigned long gfn = gpa >> PAGE_SHIFT;
         struct page *page, *pages[1];
         int npages;
-        unsigned long hva, psize, offset;
+        unsigned long hva, offset;
         unsigned long pa;
         unsigned long *physp;
         int srcu_idx;
@@ -1155,14 +1183,9 @@ void *kvmppc_pin_guest_page(struct kvm *kvm, unsigned long gpa,
         }
         srcu_read_unlock(&kvm->srcu, srcu_idx);
 
-        psize = PAGE_SIZE;
-        if (PageHuge(page)) {
-                page = compound_head(page);
-                psize <<= compound_order(page);
-        }
-        offset = gpa & (psize - 1);
+        offset = gpa & (PAGE_SIZE - 1);
         if (nb_ret)
-                *nb_ret = psize - offset;
+                *nb_ret = PAGE_SIZE - offset;
         return page_address(page) + offset;
 
  err:
@@ -1170,11 +1193,31 @@ void *kvmppc_pin_guest_page(struct kvm *kvm, unsigned long gpa,
         return NULL;
 }
 
-void kvmppc_unpin_guest_page(struct kvm *kvm, void *va)
+void kvmppc_unpin_guest_page(struct kvm *kvm, void *va, unsigned long gpa,
+                             bool dirty)
 {
         struct page *page = virt_to_page(va);
+        struct kvm_memory_slot *memslot;
+        unsigned long gfn;
+        unsigned long *rmap;
+        int srcu_idx;
 
         put_page(page);
+
+        if (!dirty || !kvm->arch.using_mmu_notifiers)
+                return;
+
+        /* We need to mark this page dirty in the rmap chain */
+        gfn = gpa >> PAGE_SHIFT;
+        srcu_idx = srcu_read_lock(&kvm->srcu);
+        memslot = gfn_to_memslot(kvm, gfn);
+        if (memslot) {
+                rmap = &memslot->arch.rmap[gfn - memslot->base_gfn];
+                lock_rmap(rmap);
+                *rmap |= KVMPPC_RMAP_CHANGED;
+                unlock_rmap(rmap);
+        }
+        srcu_read_unlock(&kvm->srcu, srcu_idx);
 }
 
 /*