KVM: arm64: nv: A couple more VNCR fixes
Subsystems (3)
Oliver Upton
maintainercover KVM: arm64: nv: A couple more VNCR fixes
Another day, another handful of ugly MMU bugs.
The first addresses an issue where the host stage-1 VNCR mapping only relies on the guest stage-1 permissions, potentially allowing RW accesses to an RO PFN.
The second avoids a BUG_ON() in the case that the output of stage-1 translation exists outside of a memslot, and instead does the usual thing and injects an SEA.
Based on kvmarm/next since the first pile of MMU changes was taken (thanks!)
Oliver Upton (2):
KVM: arm64: nv: Respect read-only PFN when mapping L1 VNCR
KVM: arm64: nv: Inject SEA if kvm_translate_vncr() can't resolve PFN
arch/arm64/include/asm/kvm_nested.h | 8 ++++++ arch/arm64/kvm/at.c | 8 ------ arch/arm64/kvm/nested.c | 40 +++++++++++++++++++++-------- 3 files changed, 38 insertions(+), 18 deletions(-)
base-commit: 406f0c31f47877db036e885f15830106b89ca950
Signature · 1 line
2.47.3
Oliver Upton
maintainerPATCH 1/2 KVM: arm64: nv: Respect read-only PFN when mapping L1 VNCR
KVM currently maps the L1 VNCR into the host stage-1 by relying entirely on the permissions of the guest stage-1. At the same time, it is entirely possible that the backing PFN is read-only (e.g. RO memslot), meaning that the L1 VNCR should use at most a read-only mapping.
Cache the writability of the PFN in the VNCR TLB and use it to constrain the resulting fixmap permissions. Promote VNCR permission faults to an SEA in the case where the guest attempts to write to a read-only endpoint. Conveniently, this also plugs a page leak found by Sashiko [*] resulting from the early return for a read-only PFN.
--- arch/arm64/kvm/nested.c | 34 +++++++++++++++++++++++++--------- 1 file changed, 25 insertions(+), 9 deletions(-)
arch/arm64/kvm/nested.c +25 -9
@@ -24,6 +24,7 @@ struct vncr_tlb {struct s1_walk_result wr;u64 hpa; +bool hpa_writable;/* -1 when not mapped on a CPU */ int cpu;
@@ -1395,7 +1396,7 @@ static int kvm_translate_vncr(struct kvm_vcpu *vcpu, bool *is_gmem)if (!*is_gmem) { pfn =__kvm_faultin_pfn (memslot, gfn, write_fault ?FOLL_WRITE :0 , &writable, &page); -if (is_error_noslot_pfn (pfn) || (write_fault && !writable)) +if (is_error_noslot_pfn (pfn))return -EFAULT ; }else { ret =kvm_gmem_get_pfn (vcpu->kvm, memslot, gfn, &pfn, &page,NULL );
@@ -1404,6 +1405,8 @@ static int kvm_translate_vncr(struct kvm_vcpu *vcpu, bool *is_gmem) write_fault, false, false);return ret; } + + writable = !(memslot->flags &KVM_MEM_READONLY ); } scoped_guard(write_lock, &vcpu->kvm->mmu_lock) {
@@ -1414,6 +1417,7 @@ static int kvm_translate_vncr(struct kvm_vcpu *vcpu, bool *is_gmem) vt->gva = va; vt->hpa = pfn <<PAGE_SHIFT ; + vt->hpa_writable = writable; vt->valid = true; vt->cpu =-1 ;
@@ -1421,21 +1425,33 @@ static int kvm_translate_vncr(struct kvm_vcpu *vcpu, bool *is_gmem)kvm_release_faultin_page (vcpu->kvm, page, false, vt->wr.pw); } -if (vt->wr.pw) +if (vt->wr.pw && vt->hpa_writable)mark_page_dirty (vcpu->kvm, gfn);return 0 ; } -static void inject_vncr_perm (struct kvm_vcpu *vcpu) +static void handle_vncr_perm (struct kvm_vcpu *vcpu) {struct vncr_tlb *vt = vcpu->arch.vncr_tlb;u64 esr =kvm_vcpu_get_esr (vcpu); +u64 fsc; + +/* +* Promote to an external abort if the stage-1 permits writes but the +* HPA is read-only (e.g. RO memslot). +*/ +if (kvm_is_write_fault (vcpu) && vt->wr.pw && !vt->hpa_writable) + fsc = ESR_ELx_FSC_EXTABT; +/* +* Otherwise, inject a permission fault using the guest's translation +* level rather than the host's. +*/ +else + fsc =ESR_ELx_FSC_PERM_L (vt->wr.level); -/* Adjust the fault level to reflect that of the guest's */ esr &= ~ESR_ELx_FSC; - esr |=FIELD_PREP (ESR_ELx_FSC, -ESR_ELx_FSC_PERM_L (vt->wr.level)); + esr |=FIELD_PREP (ESR_ELx_FSC, fsc);kvm_inject_nested_sync (vcpu, esr); }
@@ -1469,7 +1485,7 @@ int kvm_handle_vncr_abort(struct kvm_vcpu *vcpu)return kvm_handle_guest_sea (vcpu);if (esr_fsc_is_permission_fault (esr)) { -inject_vncr_perm (vcpu); +handle_vncr_perm (vcpu); }else if (esr_fsc_is_translation_fault (esr)) {bool valid, is_gmem = false;int ret;
@@ -1517,7 +1533,7 @@ int kvm_handle_vncr_abort(struct kvm_vcpu *vcpu)break ;case -EPERM :/* Hack to deal with POE until we get kernel support */ -inject_vncr_perm (vcpu); +handle_vncr_perm (vcpu);break ;case 0 :break ;
@@ -1561,7 +1577,7 @@ static void kvm_map_l1_vncr(struct kvm_vcpu *vcpu) vt->cpu =smp_processor_id (); -if (vt->wr.pw && vt->wr.pr) +if (vt->hpa_writable && vt->wr.pw && vt->wr.pr) prot =PAGE_KERNEL ;else if (vt->wr.pr) prot =PAGE_KERNEL_RO ;
Signature · 1 line
2.47.3
Oliver Upton
maintainerPATCH 2/2 KVM: arm64: nv: Inject SEA if kvm_translate_vncr() can't resolve PFN
In reply to Oliver Uptonkvm_handle_vncr_abort() assumes that s1_walk_result conveys an abort when kvm_translate_vncr() returns -EFAULT. This is not always the case as it's possible to encounter 'late' failures on the output of S1 translation, e.g. a GFN outside of the memslots.
Fix it by preparing an external abort before returning from kvm_translate_vncr().
--- arch/arm64/include/asm/kvm_nested.h | 8 ++++++++ arch/arm64/kvm/at.c | 8 -------- arch/arm64/kvm/nested.c | 8 ++++++-- 3 files changed, 14 insertions(+), 10 deletions(-)
arch/arm64/include/asm/kvm_nested.h +8 -0
@@ -388,6 +388,14 @@ struct s1_walk_result {bool failed; }; +static inline void fail_s1_walk (struct s1_walk_result *wr,u8 fst,bool s1ptw) +{ + wr->fst = fst; + wr->ptw = s1ptw; + wr->s2 = s1ptw; + wr->failed = true; +} +int __kvm_translate_va (struct kvm_vcpu *vcpu,struct s1_walk_info *wi,struct s1_walk_result *wr,u64 va); int __kvm_find_s1_desc_level(struct kvm_vcpu *vcpu, u64 va, u64 ipa,
arch/arm64/kvm/at.c +0 -8
@@ -11,14 +11,6 @@#include <asm/kvm_mmu.h> #include <asm/lsui.h> -static void fail_s1_walk (struct s1_walk_result *wr,u8 fst,bool s1ptw) -{ - wr->fst = fst; - wr->ptw = s1ptw; - wr->s2 = s1ptw; - wr->failed = true; -} -#define S1_MMU_DISABLED (-127)static int get_ia_size (struct s1_walk_info *wi)
arch/arm64/kvm/nested.c +6 -2
@@ -1389,15 +1389,19 @@ static int kvm_translate_vncr(struct kvm_vcpu *vcpu, bool *is_gmem) gfn = vt->wr.pa >>PAGE_SHIFT ; memslot =gfn_to_memslot (vcpu->kvm, gfn); -if (!memslot) +if (!memslot) { +fail_s1_walk (&vt->wr, ESR_ELx_FSC_EXTABT, false);return -EFAULT ; + } *is_gmem =kvm_slot_has_gmem (memslot);if (!*is_gmem) { pfn =__kvm_faultin_pfn (memslot, gfn, write_fault ?FOLL_WRITE :0 , &writable, &page); -if (is_error_noslot_pfn (pfn)) +if (is_error_noslot_pfn (pfn)) { +fail_s1_walk (&vt->wr, ESR_ELx_FSC_EXTABT, false);return -EFAULT ; + } }else { ret =kvm_gmem_get_pfn (vcpu->kvm, memslot, gfn, &pfn, &page,NULL );if (ret) {
Signature · 1 line
2.47.3