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>

diff --git a/arch/powerpc/include/asm/kvm_book3s.h b/arch/powerpc/include/asm/kvm_book3s.h
index bc81842ea25a3efd4a3637efc4ed1b824d562489..c55f7e6affaa2100fececb964dcfcc523f16adbe 100644 (file)
--- a/arch/powerpc/include/asm/kvm_book3s.h
+++ b/arch/powerpc/include/asm/kvm_book3s.h
@@ -156,7 +156,8 @@ void kvmppc_clear_ref_hpte(struct kvm *kvm, unsigned long *hptep,
                        unsigned long pte_index);
 extern void *kvmppc_pin_guest_page(struct kvm *kvm, unsigned long addr,
                        unsigned long *nb_ret);
-extern void kvmppc_unpin_guest_page(struct kvm *kvm, void *addr);
+extern void kvmppc_unpin_guest_page(struct kvm *kvm, void *addr,
+                       unsigned long gpa, bool dirty);
 extern long kvmppc_virtmode_h_enter(struct kvm_vcpu *vcpu, unsigned long flags,
                        long pte_index, unsigned long pteh, unsigned long ptel);
 extern long kvmppc_do_h_enter(struct kvm *kvm, unsigned long flags,

diff --git a/arch/powerpc/include/asm/kvm_host.h b/arch/powerpc/include/asm/kvm_host.h
index 8a48e686a7557df009bd781cc6181f4c3c1c9868..1443768a6588b871eb7c1d2c7377fdb8e3d699e4 100644 (file)
--- a/arch/powerpc/include/asm/kvm_host.h
+++ b/arch/powerpc/include/asm/kvm_host.h
@@ -301,11 +301,13 @@ struct kvmppc_vcore {
  * that a guest can register.
  */
 struct kvmppc_vpa {
+       unsigned long gpa;      /* Current guest phys addr */
        void *pinned_addr;      /* Address in kernel linear mapping */
        void *pinned_end;       /* End of region */
        unsigned long next_gpa; /* Guest phys addr for update */
        unsigned long len;      /* Number of bytes required */
        u8 update_pending;      /* 1 => update pinned_addr from next_gpa */
+       bool dirty;             /* true => area has been modified by kernel */
 };
 
 struct kvmppc_pte {

diff --git a/arch/powerpc/kernel/asm-offsets.c b/arch/powerpc/kernel/asm-offsets.c
index d87c90886c7516894126d94a1c750b0c76ff5d18..dbfd5498f4404e0feb353a3076d2466ca66eac1c 100644 (file)
--- a/arch/powerpc/kernel/asm-offsets.c
+++ b/arch/powerpc/kernel/asm-offsets.c
@@ -477,6 +477,7 @@ int main(void)
        DEFINE(VCPU_DSISR, offsetof(struct kvm_vcpu, arch.shregs.dsisr));
        DEFINE(VCPU_DAR, offsetof(struct kvm_vcpu, arch.shregs.dar));
        DEFINE(VCPU_VPA, offsetof(struct kvm_vcpu, arch.vpa.pinned_addr));
+       DEFINE(VCPU_VPA_DIRTY, offsetof(struct kvm_vcpu, arch.vpa.dirty));
 #endif
 #ifdef CONFIG_PPC_BOOK3S
        DEFINE(VCPU_VCPUID, offsetof(struct kvm_vcpu, vcpu_id));

diff --git a/arch/powerpc/kvm/book3s_64_mmu_hv.c b/arch/powerpc/kvm/book3s_64_mmu_hv.c
index d641a6634b02cc8662a547b98cf8deed9f8ee93a..69efe0d6cedc6eeee2211904d81a88f37d8fba99 100644 (file)
--- 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);
 }
 
 /*

diff --git a/arch/powerpc/kvm/book3s_hv.c b/arch/powerpc/kvm/book3s_hv.c
index 1e521baf9a7d30612d976e90af663a521172a328..5af0f29798332f1ca908efd8975e48f138beb5d0 100644 (file)
--- a/arch/powerpc/kvm/book3s_hv.c
+++ b/arch/powerpc/kvm/book3s_hv.c
@@ -259,7 +259,7 @@ static unsigned long do_h_register_vpa(struct kvm_vcpu *vcpu,
                        len = ((struct reg_vpa *)va)->length.hword;
                else
                        len = ((struct reg_vpa *)va)->length.word;
-               kvmppc_unpin_guest_page(kvm, va);
+               kvmppc_unpin_guest_page(kvm, va, vpa, false);
 
                /* Check length */
                if (len > nb || len < sizeof(struct reg_vpa))
@@ -359,13 +359,13 @@ static void kvmppc_update_vpa(struct kvm_vcpu *vcpu, struct kvmppc_vpa *vpap)
                va = NULL;
                nb = 0;
                if (gpa)
-                       va = kvmppc_pin_guest_page(kvm, vpap->next_gpa, &nb);
+                       va = kvmppc_pin_guest_page(kvm, gpa, &nb);
                spin_lock(&vcpu->arch.vpa_update_lock);
                if (gpa == vpap->next_gpa)
                        break;
                /* sigh... unpin that one and try again */
                if (va)
-                       kvmppc_unpin_guest_page(kvm, va);
+                       kvmppc_unpin_guest_page(kvm, va, gpa, false);
        }
 
        vpap->update_pending = 0;
@@ -375,12 +375,15 @@ static void kvmppc_update_vpa(struct kvm_vcpu *vcpu, struct kvmppc_vpa *vpap)
                 * has changed the mappings underlying guest memory,
                 * so unregister the region.
                 */
-               kvmppc_unpin_guest_page(kvm, va);
+               kvmppc_unpin_guest_page(kvm, va, gpa, false);
                va = NULL;
        }
        if (vpap->pinned_addr)
-               kvmppc_unpin_guest_page(kvm, vpap->pinned_addr);
+               kvmppc_unpin_guest_page(kvm, vpap->pinned_addr, vpap->gpa,
+                                       vpap->dirty);
+       vpap->gpa = gpa;
        vpap->pinned_addr = va;
+       vpap->dirty = false;
        if (va)
                vpap->pinned_end = va + vpap->len;
 }
@@ -472,6 +475,7 @@ static void kvmppc_create_dtl_entry(struct kvm_vcpu *vcpu,
        /* order writing *dt vs. writing vpa->dtl_idx */
        smp_wmb();
        vpa->dtl_idx = ++vcpu->arch.dtl_index;
+       vcpu->arch.dtl.dirty = true;
 }
 
 int kvmppc_pseries_do_hcall(struct kvm_vcpu *vcpu)
@@ -913,15 +917,19 @@ out:
        return ERR_PTR(err);
 }
 
+static void unpin_vpa(struct kvm *kvm, struct kvmppc_vpa *vpa)
+{
+       if (vpa->pinned_addr)
+               kvmppc_unpin_guest_page(kvm, vpa->pinned_addr, vpa->gpa,
+                                       vpa->dirty);
+}
+
 void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu)
 {
        spin_lock(&vcpu->arch.vpa_update_lock);
-       if (vcpu->arch.dtl.pinned_addr)
-               kvmppc_unpin_guest_page(vcpu->kvm, vcpu->arch.dtl.pinned_addr);
-       if (vcpu->arch.slb_shadow.pinned_addr)
-               kvmppc_unpin_guest_page(vcpu->kvm, vcpu->arch.slb_shadow.pinned_addr);
-       if (vcpu->arch.vpa.pinned_addr)
-               kvmppc_unpin_guest_page(vcpu->kvm, vcpu->arch.vpa.pinned_addr);
+       unpin_vpa(vcpu->kvm, &vcpu->arch.dtl);
+       unpin_vpa(vcpu->kvm, &vcpu->arch.slb_shadow);
+       unpin_vpa(vcpu->kvm, &vcpu->arch.vpa);
        spin_unlock(&vcpu->arch.vpa_update_lock);
        kvm_vcpu_uninit(vcpu);
        kmem_cache_free(kvm_vcpu_cache, vcpu);

diff --git a/arch/powerpc/kvm/book3s_hv_rmhandlers.S b/arch/powerpc/kvm/book3s_hv_rmhandlers.S
index e33d11f1b977c2ea46e3494500c17255cca9daf5..0f23bb851711aa5c98fbebaecec6b3196622a05f 100644 (file)
--- a/arch/powerpc/kvm/book3s_hv_rmhandlers.S
+++ b/arch/powerpc/kvm/book3s_hv_rmhandlers.S
@@ -260,6 +260,8 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_206)
        lwz     r5, LPPACA_YIELDCOUNT(r3)
        addi    r5, r5, 1
        stw     r5, LPPACA_YIELDCOUNT(r3)
+       li      r6, 1
+       stb     r6, VCPU_VPA_DIRTY(r4)
 25:
        /* Load up DAR and DSISR */
        ld      r5, VCPU_DAR(r4)
@@ -1018,6 +1020,8 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_206)
        lwz     r3, LPPACA_YIELDCOUNT(r8)
        addi    r3, r3, 1
        stw     r3, LPPACA_YIELDCOUNT(r8)
+       li      r3, 1
+       stb     r3, VCPU_VPA_DIRTY(r9)
 25:
        /* Save PMU registers if requested */
        /* r8 and cr0.eq are live here */