arch/arm64/kvm/hyp/debug-sr.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2015 - ARM Ltd
   4  * Author: Marc Zyngier <marc.zyngier@arm.com>
   5  */
   6
   7 #include <linux/compiler.h>
   8 #include <linux/kvm_host.h>
   9
  10 #include <asm/debug-monitors.h>
  11 #include <asm/kvm_asm.h>
  12 #include <asm/kvm_hyp.h>
  13 #include <asm/kvm_mmu.h>
  14
  15 #define read_debug(r,n)         read_sysreg(r##n##_el1)
  16 #define write_debug(v,r,n)      write_sysreg(v, r##n##_el1)
  17
  18 #define save_debug(ptr,reg,nr)                                          \
  19         switch (nr) {                                                   \
  20         case 15:        ptr[15] = read_debug(reg, 15);                  \
  21         case 14:        ptr[14] = read_debug(reg, 14);                  \
  22         case 13:        ptr[13] = read_debug(reg, 13);                  \
  23         case 12:        ptr[12] = read_debug(reg, 12);                  \
  24         case 11:        ptr[11] = read_debug(reg, 11);                  \
  25         case 10:        ptr[10] = read_debug(reg, 10);                  \
  26         case 9:         ptr[9] = read_debug(reg, 9);                    \
  27         case 8:         ptr[8] = read_debug(reg, 8);                    \
  28         case 7:         ptr[7] = read_debug(reg, 7);                    \
  29         case 6:         ptr[6] = read_debug(reg, 6);                    \
  30         case 5:         ptr[5] = read_debug(reg, 5);                    \
  31         case 4:         ptr[4] = read_debug(reg, 4);                    \
  32         case 3:         ptr[3] = read_debug(reg, 3);                    \
  33         case 2:         ptr[2] = read_debug(reg, 2);                    \
  34         case 1:         ptr[1] = read_debug(reg, 1);                    \
  35         default:        ptr[0] = read_debug(reg, 0);                    \
  36         }
  37
  38 #define restore_debug(ptr,reg,nr)                                       \
  39         switch (nr) {                                                   \
  40         case 15:        write_debug(ptr[15], reg, 15);                  \
  41         case 14:        write_debug(ptr[14], reg, 14);                  \
  42         case 13:        write_debug(ptr[13], reg, 13);                  \
  43         case 12:        write_debug(ptr[12], reg, 12);                  \
  44         case 11:        write_debug(ptr[11], reg, 11);                  \
  45         case 10:        write_debug(ptr[10], reg, 10);                  \
  46         case 9:         write_debug(ptr[9], reg, 9);                    \
  47         case 8:         write_debug(ptr[8], reg, 8);                    \
  48         case 7:         write_debug(ptr[7], reg, 7);                    \
  49         case 6:         write_debug(ptr[6], reg, 6);                    \
  50         case 5:         write_debug(ptr[5], reg, 5);                    \
  51         case 4:         write_debug(ptr[4], reg, 4);                    \
  52         case 3:         write_debug(ptr[3], reg, 3);                    \
  53         case 2:         write_debug(ptr[2], reg, 2);                    \
  54         case 1:         write_debug(ptr[1], reg, 1);                    \
  55         default:        write_debug(ptr[0], reg, 0);                    \
  56         }
  57
  58 static void __hyp_text __debug_save_spe_nvhe(u64 *pmscr_el1)
  59 {
  60         u64 reg;
  61
  62         /* Clear pmscr in case of early return */
  63         *pmscr_el1 = 0;
  64
  65         /* SPE present on this CPU? */
  66         if (!cpuid_feature_extract_unsigned_field(read_sysreg(id_aa64dfr0_el1),
  67                                                   ID_AA64DFR0_PMSVER_SHIFT))
  68                 return;
  69
  70         /* Yes; is it owned by EL3? */
  71         reg = read_sysreg_s(SYS_PMBIDR_EL1);
  72         if (reg & BIT(SYS_PMBIDR_EL1_P_SHIFT))
  73                 return;
  74
  75         /* No; is the host actually using the thing? */
  76         reg = read_sysreg_s(SYS_PMBLIMITR_EL1);
  77         if (!(reg & BIT(SYS_PMBLIMITR_EL1_E_SHIFT)))
  78                 return;
  79
  80         /* Yes; save the control register and disable data generation */
  81         *pmscr_el1 = read_sysreg_s(SYS_PMSCR_EL1);
  82         write_sysreg_s(0, SYS_PMSCR_EL1);
  83         isb();
  84
  85         /* Now drain all buffered data to memory */
  86         psb_csync();
  87         dsb(nsh);
  88 }
  89
  90 static void __hyp_text __debug_restore_spe_nvhe(u64 pmscr_el1)
  91 {
  92         if (!pmscr_el1)
  93                 return;
  94
  95         /* The host page table is installed, but not yet synchronised */
  96         isb();
  97
  98         /* Re-enable data generation */
  99         write_sysreg_s(pmscr_el1, SYS_PMSCR_EL1);
 100 }
 101
 102 static void __hyp_text __debug_save_state(struct kvm_vcpu *vcpu,
 103                                           struct kvm_guest_debug_arch *dbg,
 104                                           struct kvm_cpu_context *ctxt)
 105 {
 106         u64 aa64dfr0;
 107         int brps, wrps;
 108
 109         aa64dfr0 = read_sysreg(id_aa64dfr0_el1);
 110         brps = (aa64dfr0 >> 12) & 0xf;
 111         wrps = (aa64dfr0 >> 20) & 0xf;
 112
 113         save_debug(dbg->dbg_bcr, dbgbcr, brps);
 114         save_debug(dbg->dbg_bvr, dbgbvr, brps);
 115         save_debug(dbg->dbg_wcr, dbgwcr, wrps);
 116         save_debug(dbg->dbg_wvr, dbgwvr, wrps);
 117
 118         ctxt->sys_regs[MDCCINT_EL1] = read_sysreg(mdccint_el1);
 119 }
 120
 121 static void __hyp_text __debug_restore_state(struct kvm_vcpu *vcpu,
 122                                              struct kvm_guest_debug_arch *dbg,
 123                                              struct kvm_cpu_context *ctxt)
 124 {
 125         u64 aa64dfr0;
 126         int brps, wrps;
 127
 128         aa64dfr0 = read_sysreg(id_aa64dfr0_el1);
 129
 130         brps = (aa64dfr0 >> 12) & 0xf;
 131         wrps = (aa64dfr0 >> 20) & 0xf;
 132
 133         restore_debug(dbg->dbg_bcr, dbgbcr, brps);
 134         restore_debug(dbg->dbg_bvr, dbgbvr, brps);
 135         restore_debug(dbg->dbg_wcr, dbgwcr, wrps);
 136         restore_debug(dbg->dbg_wvr, dbgwvr, wrps);
 137
 138         write_sysreg(ctxt->sys_regs[MDCCINT_EL1], mdccint_el1);
 139 }
 140
 141 void __hyp_text __debug_switch_to_guest(struct kvm_vcpu *vcpu)
 142 {
 143         struct kvm_cpu_context *host_ctxt;
 144         struct kvm_cpu_context *guest_ctxt;
 145         struct kvm_guest_debug_arch *host_dbg;
 146         struct kvm_guest_debug_arch *guest_dbg;
 147
 148         /*
 149          * Non-VHE: Disable and flush SPE data generation
 150          * VHE: The vcpu can run, but it can't hide.
 151          */
 152         if (!has_vhe())
 153                 __debug_save_spe_nvhe(&vcpu->arch.host_debug_state.pmscr_el1);
 154
 155         if (!(vcpu->arch.flags & KVM_ARM64_DEBUG_DIRTY))
 156                 return;
 157
 158         host_ctxt = kern_hyp_va(vcpu->arch.host_cpu_context);
 159         guest_ctxt = &vcpu->arch.ctxt;
 160         host_dbg = &vcpu->arch.host_debug_state.regs;
 161         guest_dbg = kern_hyp_va(vcpu->arch.debug_ptr);
 162
 163         __debug_save_state(vcpu, host_dbg, host_ctxt);
 164         __debug_restore_state(vcpu, guest_dbg, guest_ctxt);
 165 }
 166
 167 void __hyp_text __debug_switch_to_host(struct kvm_vcpu *vcpu)
 168 {
 169         struct kvm_cpu_context *host_ctxt;
 170         struct kvm_cpu_context *guest_ctxt;
 171         struct kvm_guest_debug_arch *host_dbg;
 172         struct kvm_guest_debug_arch *guest_dbg;
 173
 174         if (!has_vhe())
 175                 __debug_restore_spe_nvhe(vcpu->arch.host_debug_state.pmscr_el1);
 176
 177         if (!(vcpu->arch.flags & KVM_ARM64_DEBUG_DIRTY))
 178                 return;
 179
 180         host_ctxt = kern_hyp_va(vcpu->arch.host_cpu_context);
 181         guest_ctxt = &vcpu->arch.ctxt;
 182         host_dbg = &vcpu->arch.host_debug_state.regs;
 183         guest_dbg = kern_hyp_va(vcpu->arch.debug_ptr);
 184
 185         __debug_save_state(vcpu, guest_dbg, guest_ctxt);
 186         __debug_restore_state(vcpu, host_dbg, host_ctxt);
 187
 188         vcpu->arch.flags &= ~KVM_ARM64_DEBUG_DIRTY;
 189 }
 190
 191 u32 __hyp_text __kvm_get_mdcr_el2(void)
 192 {
 193         return read_sysreg(mdcr_el2);
 194 }