1 files changed, 124 insertions, 10 deletions

diff --git a/arch/arm/kvm/mmu.c b/arch/arm/kvm/mmu.c
index 5656d79c5a44..15b050d46fc9 100644
--- a/arch/arm/kvm/mmu.c
+++ b/arch/arm/kvm/mmu.c
@@ -1330,10 +1330,51 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa,
 
 out_unlock:
         spin_unlock(&kvm->mmu_lock);
+        kvm_set_pfn_accessed(pfn);
         kvm_release_pfn_clean(pfn);
         return ret;
 }
 
+/*
+ * Resolve the access fault by making the page young again.
+ * Note that because the faulting entry is guaranteed not to be
+ * cached in the TLB, we don't need to invalidate anything.
+ */
+static void handle_access_fault(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa)
+{
+        pmd_t *pmd;
+        pte_t *pte;
+        pfn_t pfn;
+        bool pfn_valid = false;
+
+        trace_kvm_access_fault(fault_ipa);
+
+        spin_lock(&vcpu->kvm->mmu_lock);
+
+        pmd = stage2_get_pmd(vcpu->kvm, NULL, fault_ipa);
+        if (!pmd || pmd_none(*pmd))     /* Nothing there */
+                goto out;
+
+        if (kvm_pmd_huge(*pmd)) {       /* THP, HugeTLB */
+                *pmd = pmd_mkyoung(*pmd);
+                pfn = pmd_pfn(*pmd);
+                pfn_valid = true;
+                goto out;
+        }
+
+        pte = pte_offset_kernel(pmd, fault_ipa);
+        if (pte_none(*pte))             /* Nothing there either */
+                goto out;
+
+        *pte = pte_mkyoung(*pte);       /* Just a page... */
+        pfn = pte_pfn(*pte);
+        pfn_valid = true;
+out:
+        spin_unlock(&vcpu->kvm->mmu_lock);
+        if (pfn_valid)
+                kvm_set_pfn_accessed(pfn);
+}
+
 /**
  * kvm_handle_guest_abort - handles all 2nd stage aborts
  * @vcpu:       the VCPU pointer
@@ -1364,7 +1405,8 @@ int kvm_handle_guest_abort(struct kvm_vcpu *vcpu, struct kvm_run *run)
 
         /* Check the stage-2 fault is trans. fault or write fault */
         fault_status = kvm_vcpu_trap_get_fault_type(vcpu);
-        if (fault_status != FSC_FAULT && fault_status != FSC_PERM) {
+        if (fault_status != FSC_FAULT && fault_status != FSC_PERM &&
+            fault_status != FSC_ACCESS) {
                 kvm_err("Unsupported FSC: EC=%#x xFSC=%#lx ESR_EL2=%#lx\n",
                         kvm_vcpu_trap_get_class(vcpu),
                         (unsigned long)kvm_vcpu_trap_get_fault(vcpu),
@@ -1400,6 +1442,12 @@ int kvm_handle_guest_abort(struct kvm_vcpu *vcpu, struct kvm_run *run)
         /* Userspace should not be able to register out-of-bounds IPAs */
         VM_BUG_ON(fault_ipa >= KVM_PHYS_SIZE);
 
+        if (fault_status == FSC_ACCESS) {
+                handle_access_fault(vcpu, fault_ipa);
+                ret = 1;
+                goto out_unlock;
+        }
+
         ret = user_mem_abort(vcpu, fault_ipa, memslot, hva, fault_status);
         if (ret == 0)
                 ret = 1;
@@ -1408,15 +1456,16 @@ out_unlock:
         return ret;
 }
 
-static void handle_hva_to_gpa(struct kvm *kvm,
-                              unsigned long start,
-                              unsigned long end,
-                              void (*handler)(struct kvm *kvm,
-                                              gpa_t gpa, void *data),
-                              void *data)
+static int handle_hva_to_gpa(struct kvm *kvm,
+                             unsigned long start,
+                             unsigned long end,
+                             int (*handler)(struct kvm *kvm,
+                                            gpa_t gpa, void *data),
+                             void *data)
 {
         struct kvm_memslots *slots;
         struct kvm_memory_slot *memslot;
+        int ret = 0;
 
         slots = kvm_memslots(kvm);
 
@@ -1440,14 +1489,17 @@ static void handle_hva_to_gpa(struct kvm *kvm,
 
                 for (; gfn < gfn_end; ++gfn) {
                         gpa_t gpa = gfn << PAGE_SHIFT;
-                        handler(kvm, gpa, data);
+                        ret |= handler(kvm, gpa, data);
                 }
         }
+
+        return ret;
 }
 
-static void kvm_unmap_hva_handler(struct kvm *kvm, gpa_t gpa, void *data)
+static int kvm_unmap_hva_handler(struct kvm *kvm, gpa_t gpa, void *data)
 {
         unmap_stage2_range(kvm, gpa, PAGE_SIZE);
+        return 0;
 }
 
 int kvm_unmap_hva(struct kvm *kvm, unsigned long hva)
@@ -1473,7 +1525,7 @@ int kvm_unmap_hva_range(struct kvm *kvm,
         return 0;
 }
 
-static void kvm_set_spte_handler(struct kvm *kvm, gpa_t gpa, void *data)
+static int kvm_set_spte_handler(struct kvm *kvm, gpa_t gpa, void *data)
 {
         pte_t *pte = (pte_t *)data;
 
@@ -1485,6 +1537,7 @@ static void kvm_set_spte_handler(struct kvm *kvm, gpa_t gpa, void *data)
          * through this calling path.
          */
         stage2_set_pte(kvm, NULL, gpa, pte, 0);
+        return 0;
 }
 
 
@@ -1501,6 +1554,67 @@ void kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte)
         handle_hva_to_gpa(kvm, hva, end, &kvm_set_spte_handler, &stage2_pte);
 }
 
+static int kvm_age_hva_handler(struct kvm *kvm, gpa_t gpa, void *data)
+{
+        pmd_t *pmd;
+        pte_t *pte;
+
+        pmd = stage2_get_pmd(kvm, NULL, gpa);
+        if (!pmd || pmd_none(*pmd))     /* Nothing there */
+                return 0;
+
+        if (kvm_pmd_huge(*pmd)) {       /* THP, HugeTLB */
+                if (pmd_young(*pmd)) {
+                        *pmd = pmd_mkold(*pmd);
+                        return 1;
+                }
+
+                return 0;
+        }
+
+        pte = pte_offset_kernel(pmd, gpa);
+        if (pte_none(*pte))
+                return 0;
+
+        if (pte_young(*pte)) {
+                *pte = pte_mkold(*pte); /* Just a page... */
+                return 1;
+        }
+
+        return 0;
+}
+
+static int kvm_test_age_hva_handler(struct kvm *kvm, gpa_t gpa, void *data)
+{
+        pmd_t *pmd;
+        pte_t *pte;
+
+        pmd = stage2_get_pmd(kvm, NULL, gpa);
+        if (!pmd || pmd_none(*pmd))     /* Nothing there */
+                return 0;
+
+        if (kvm_pmd_huge(*pmd))         /* THP, HugeTLB */
+                return pmd_young(*pmd);
+
+        pte = pte_offset_kernel(pmd, gpa);
+        if (!pte_none(*pte))            /* Just a page... */
+                return pte_young(*pte);
+
+        return 0;
+}
+
+int kvm_age_hva(struct kvm *kvm, unsigned long start, unsigned long end)
+{
+        trace_kvm_age_hva(start, end);
+        return handle_hva_to_gpa(kvm, start, end, kvm_age_hva_handler, NULL);
+}
+
+int kvm_test_age_hva(struct kvm *kvm, unsigned long hva)
+{
+        trace_kvm_test_age_hva(hva);
+        return handle_hva_to_gpa(kvm, hva, hva, kvm_test_age_hva_handler, NULL);
+}
+
 void kvm_mmu_free_memory_caches(struct kvm_vcpu *vcpu)
 {
         mmu_free_memory_cache(&vcpu->arch.mmu_page_cache);