From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754742AbbCaPMB (ORCPT ); Tue, 31 Mar 2015 11:12:01 -0400 Received: from static.88-198-71-155.clients.your-server.de ([88.198.71.155]:48127 "EHLO socrates.bennee.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754582AbbCaPJB (ORCPT ); Tue, 31 Mar 2015 11:09:01 -0400 From: =?UTF-8?q?Alex=20Benn=C3=A9e?= To: kvm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, kvmarm@lists.cs.columbia.edu, christoffer.dall@linaro.org, marc.zyngier@arm.com, peter.maydell@linaro.org, agraf@suse.de, drjones@redhat.com, pbonzini@redhat.com, zhichao.huang@linaro.org Cc: jan.kiszka@siemens.com, dahi@linux.vnet.ibm.com, r65777@freescale.com, bp@suse.de, =?UTF-8?q?Alex=20Benn=C3=A9e?= , Gleb Natapov , Russell King , Catalin Marinas , Will Deacon , linux-kernel@vger.kernel.org (open list) Subject: [PATCH v2 07/10] KVM: arm64: guest debug, add support for single-step Date: Tue, 31 Mar 2015 16:08:05 +0100 Message-Id: <1427814488-28467-8-git-send-email-alex.bennee@linaro.org> X-Mailer: git-send-email 2.3.4 In-Reply-To: <1427814488-28467-1-git-send-email-alex.bennee@linaro.org> References: <1427814488-28467-1-git-send-email-alex.bennee@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-SA-Exim-Connect-IP: 127.0.0.1 X-SA-Exim-Mail-From: alex.bennee@linaro.org X-SA-Exim-Scanned: No (on socrates.bennee.com); SAEximRunCond expanded to false Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This adds support for single-stepping the guest. As userspace can and will manipulate guest registers before restarting any tweaking of the registers has to occur just before control is passed back to the guest. Furthermore while guest debugging is in effect we need to squash the ability of the guest to single-step itself as we have no easy way of re-entering the guest after the exception has been delivered to the hypervisor. Signed-off-by: Alex Bennée --- v2 - Move pstate/mdscr manipulation into C - don't export guest_debug to assembly - add accessor for saved_debug regs - tweak save/restore of mdscr_el1 diff --git a/arch/arm/kvm/arm.c b/arch/arm/kvm/arm.c index d3bc8dc..c1ed8cb 100644 --- a/arch/arm/kvm/arm.c +++ b/arch/arm/kvm/arm.c @@ -304,7 +304,21 @@ void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) kvm_arm_set_running_vcpu(NULL); } -#define KVM_GUESTDBG_VALID (KVM_GUESTDBG_ENABLE|KVM_GUESTDBG_USE_SW_BP) +#define KVM_GUESTDBG_VALID (KVM_GUESTDBG_ENABLE | \ + KVM_GUESTDBG_USE_SW_BP | \ + KVM_GUESTDBG_SINGLESTEP) + +/** + * kvm_arch_vcpu_ioctl_set_guest_debug - Setup guest debugging + * @kvm: pointer to the KVM struct + * @kvm_guest_debug: the ioctl data buffer + * + * This sets up the VM for guest debugging. Care has to be taken when + * manipulating guest registers as these will be set/cleared by the + * hyper-visor controller, typically before each kvm_run event. As a + * result modification of the guest registers needs to take place + * after they have been restored in the hyp.S trampoline code. + */ int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, struct kvm_guest_debug *dbg) diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h index 0631840..6a33647 100644 --- a/arch/arm64/include/asm/kvm_host.h +++ b/arch/arm64/include/asm/kvm_host.h @@ -121,6 +121,13 @@ struct kvm_vcpu_arch { * here. */ + /* Registers pre any guest debug manipulations */ + struct { + u32 pstate_ss_bit; + u32 mdscr_el1_bits; + + } debug_saved_regs; + /* Don't run the guest */ bool pause; @@ -143,6 +150,7 @@ struct kvm_vcpu_arch { #define vcpu_gp_regs(v) (&(v)->arch.ctxt.gp_regs) #define vcpu_sys_reg(v,r) ((v)->arch.ctxt.sys_regs[(r)]) +#define vcpu_debug_saved_reg(v, r) ((v)->arch.debug_saved_regs.r) /* * CP14 and CP15 live in the same array, as they are backed by the * same system registers. diff --git a/arch/arm64/kvm/debug.c b/arch/arm64/kvm/debug.c index cff0475..b32362c 100644 --- a/arch/arm64/kvm/debug.c +++ b/arch/arm64/kvm/debug.c @@ -19,8 +19,16 @@ #include +#include +#include #include #include +#include + +/* These are the bits of MDSCR_EL1 we may mess with */ +#define MDSCR_EL1_DEBUG_BITS (DBG_MDSCR_SS | \ + DBG_MDSCR_KDE | \ + DBG_MDSCR_MDE) /** * kvm_arch_setup_debug - set-up debug related stuff @@ -51,15 +59,46 @@ void kvm_arch_setup_debug(struct kvm_vcpu *vcpu) else vcpu->arch.mdcr_el2 &= ~MDCR_EL2_TDA; - /* Trap breakpoints? */ - if (vcpu->guest_debug & KVM_GUESTDBG_USE_SW_BP) + /* Is Guest debugging in effect? */ + if (vcpu->guest_debug) { vcpu->arch.mdcr_el2 |= MDCR_EL2_TDE; - else - vcpu->arch.mdcr_el2 &= ~MDCR_EL2_TDE; + /* Save pstate/mdscr */ + vcpu_debug_saved_reg(vcpu, pstate_ss_bit) = + *vcpu_cpsr(vcpu) & DBG_SPSR_SS; + vcpu_debug_saved_reg(vcpu, mdscr_el1_bits) = + vcpu_sys_reg(vcpu, MDSCR_EL1) & MDSCR_EL1_DEBUG_BITS; + /* + * Single Step (ARM ARM D2.12.3 The software step state + * machine) + * + * If we are doing Single Step we need to manipulate + * MDSCR_EL1.SS and PSTATE.SS. If not we need to + * suppress the guest from messing with it. + */ + if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP) { + *vcpu_cpsr(vcpu) |= DBG_SPSR_SS; + vcpu_sys_reg(vcpu, MDSCR_EL1) |= DBG_MDSCR_SS; + } else { + *vcpu_cpsr(vcpu) &= ~DBG_SPSR_SS; + vcpu_sys_reg(vcpu, MDSCR_EL1) &= ~DBG_MDSCR_SS; + } + + } else { + /* Debug operations can go straight to the guest */ + vcpu->arch.mdcr_el2 &= ~MDCR_EL2_TDE; + } } void kvm_arch_clear_debug(struct kvm_vcpu *vcpu) { - /* Nothing to do yet */ + if (vcpu->guest_debug) { + /* Restore pstate/mdscr bits we may have messed with */ + *vcpu_cpsr(vcpu) &= ~DBG_SPSR_SS; + *vcpu_cpsr(vcpu) |= vcpu_debug_saved_reg(vcpu, pstate_ss_bit); + + vcpu_sys_reg(vcpu, MDSCR_EL1) &= ~MDSCR_EL1_DEBUG_BITS; + vcpu_sys_reg(vcpu, MDSCR_EL1) |= + vcpu_debug_saved_reg(vcpu, mdscr_el1_bits); + } } diff --git a/arch/arm64/kvm/handle_exit.c b/arch/arm64/kvm/handle_exit.c index ed1bbb4..16accae 100644 --- a/arch/arm64/kvm/handle_exit.c +++ b/arch/arm64/kvm/handle_exit.c @@ -101,6 +101,7 @@ static int kvm_handle_guest_debug(struct kvm_vcpu *vcpu, struct kvm_run *run) run->debug.arch.hsr = hsr; switch (hsr >> ESR_ELx_EC_SHIFT) { + case ESR_ELx_EC_SOFTSTP_LOW: case ESR_ELx_EC_BKPT32: case ESR_ELx_EC_BRK64: run->debug.arch.pc = *vcpu_pc(vcpu); @@ -127,6 +128,7 @@ static exit_handle_fn arm_exit_handlers[] = { [ESR_ELx_EC_SYS64] = kvm_handle_sys_reg, [ESR_ELx_EC_IABT_LOW] = kvm_handle_guest_abort, [ESR_ELx_EC_DABT_LOW] = kvm_handle_guest_abort, + [ESR_ELx_EC_SOFTSTP_LOW]= kvm_handle_guest_debug, [ESR_ELx_EC_BKPT32] = kvm_handle_guest_debug, [ESR_ELx_EC_BRK64] = kvm_handle_guest_debug, }; -- 2.3.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Alex=20Benn=C3=A9e?= Subject: [PATCH v2 07/10] KVM: arm64: guest debug, add support for single-step Date: Tue, 31 Mar 2015 16:08:05 +0100 Message-ID: <1427814488-28467-8-git-send-email-alex.bennee@linaro.org> References: <1427814488-28467-1-git-send-email-alex.bennee@linaro.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Cc: Russell King , Gleb Natapov , jan.kiszka@siemens.com, Will Deacon , open list , dahi@linux.vnet.ibm.com, Catalin Marinas , r65777@freescale.com, bp@suse.de To: kvm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, kvmarm@lists.cs.columbia.edu, christoffer.dall@linaro.org, marc.zyngier@arm.com, peter.maydell@linaro.org, agraf@suse.de, drjones@redhat.com, pbonzini@redhat.com, zhichao.huang@linaro.org Return-path: In-Reply-To: <1427814488-28467-1-git-send-email-alex.bennee@linaro.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: kvmarm-bounces@lists.cs.columbia.edu Sender: kvmarm-bounces@lists.cs.columbia.edu List-Id: kvm.vger.kernel.org VGhpcyBhZGRzIHN1cHBvcnQgZm9yIHNpbmdsZS1zdGVwcGluZyB0aGUgZ3Vlc3QuIEFzIHVzZXJz cGFjZSBjYW4gYW5kCndpbGwgbWFuaXB1bGF0ZSBndWVzdCByZWdpc3RlcnMgYmVmb3JlIHJlc3Rh cnRpbmcgYW55IHR3ZWFraW5nIG9mIHRoZQpyZWdpc3RlcnMgaGFzIHRvIG9jY3VyIGp1c3QgYmVm b3JlIGNvbnRyb2wgaXMgcGFzc2VkIGJhY2sgdG8gdGhlIGd1ZXN0LgpGdXJ0aGVybW9yZSB3aGls ZSBndWVzdCBkZWJ1Z2dpbmcgaXMgaW4gZWZmZWN0IHdlIG5lZWQgdG8gc3F1YXNoIHRoZQphYmls aXR5IG9mIHRoZSBndWVzdCB0byBzaW5nbGUtc3RlcCBpdHNlbGYgYXMgd2UgaGF2ZSBubyBlYXN5 IHdheSBvZgpyZS1lbnRlcmluZyB0aGUgZ3Vlc3QgYWZ0ZXIgdGhlIGV4Y2VwdGlvbiBoYXMgYmVl biBkZWxpdmVyZWQgdG8gdGhlCmh5cGVydmlzb3IuCgpTaWduZWQtb2ZmLWJ5OiBBbGV4IEJlbm7D qWUgPGFsZXguYmVubmVlQGxpbmFyby5vcmc+CgotLS0KdjIKICAtIE1vdmUgcHN0YXRlL21kc2Ny IG1hbmlwdWxhdGlvbiBpbnRvIEMKICAtIGRvbid0IGV4cG9ydCBndWVzdF9kZWJ1ZyB0byBhc3Nl bWJseQogIC0gYWRkIGFjY2Vzc29yIGZvciBzYXZlZF9kZWJ1ZyByZWdzCiAgLSB0d2VhayBzYXZl L3Jlc3RvcmUgb2YgbWRzY3JfZWwxCgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va3ZtL2FybS5jIGIv YXJjaC9hcm0va3ZtL2FybS5jCmluZGV4IGQzYmM4ZGMuLmMxZWQ4Y2IgMTAwNjQ0Ci0tLSBhL2Fy Y2gvYXJtL2t2bS9hcm0uYworKysgYi9hcmNoL2FybS9rdm0vYXJtLmMKQEAgLTMwNCw3ICszMDQs MjEgQEAgdm9pZCBrdm1fYXJjaF92Y3B1X3B1dChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCiAJa3Zt X2FybV9zZXRfcnVubmluZ192Y3B1KE5VTEwpOwogfQogCi0jZGVmaW5lIEtWTV9HVUVTVERCR19W QUxJRCAoS1ZNX0dVRVNUREJHX0VOQUJMRXxLVk1fR1VFU1REQkdfVVNFX1NXX0JQKQorI2RlZmlu ZSBLVk1fR1VFU1REQkdfVkFMSUQgKEtWTV9HVUVTVERCR19FTkFCTEUgfCAgICBcCisJCQkgICAg S1ZNX0dVRVNUREJHX1VTRV9TV19CUCB8IFwKKwkJCSAgICBLVk1fR1VFU1REQkdfU0lOR0xFU1RF UCkKKworLyoqCisgKiBrdm1fYXJjaF92Y3B1X2lvY3RsX3NldF9ndWVzdF9kZWJ1ZyAtIFNldHVw IGd1ZXN0IGRlYnVnZ2luZworICogQGt2bToJcG9pbnRlciB0byB0aGUgS1ZNIHN0cnVjdAorICog QGt2bV9ndWVzdF9kZWJ1ZzogdGhlIGlvY3RsIGRhdGEgYnVmZmVyCisgKgorICogVGhpcyBzZXRz IHVwIHRoZSBWTSBmb3IgZ3Vlc3QgZGVidWdnaW5nLiBDYXJlIGhhcyB0byBiZSB0YWtlbiB3aGVu CisgKiBtYW5pcHVsYXRpbmcgZ3Vlc3QgcmVnaXN0ZXJzIGFzIHRoZXNlIHdpbGwgYmUgc2V0L2Ns ZWFyZWQgYnkgdGhlCisgKiBoeXBlci12aXNvciBjb250cm9sbGVyLCB0eXBpY2FsbHkgYmVmb3Jl IGVhY2gga3ZtX3J1biBldmVudC4gQXMgYQorICogcmVzdWx0IG1vZGlmaWNhdGlvbiBvZiB0aGUg Z3Vlc3QgcmVnaXN0ZXJzIG5lZWRzIHRvIHRha2UgcGxhY2UKKyAqIGFmdGVyIHRoZXkgaGF2ZSBi ZWVuIHJlc3RvcmVkIGluIHRoZSBoeXAuUyB0cmFtcG9saW5lIGNvZGUuCisgKi8KIAogaW50IGt2 bV9hcmNoX3ZjcHVfaW9jdGxfc2V0X2d1ZXN0X2RlYnVnKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwK IAkJCQkJc3RydWN0IGt2bV9ndWVzdF9kZWJ1ZyAqZGJnKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm02 NC9pbmNsdWRlL2FzbS9rdm1faG9zdC5oIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1faG9z dC5oCmluZGV4IDA2MzE4NDAuLjZhMzM2NDcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQvaW5jbHVk ZS9hc20va3ZtX2hvc3QuaAorKysgYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgK QEAgLTEyMSw2ICsxMjEsMTMgQEAgc3RydWN0IGt2bV92Y3B1X2FyY2ggewogCSAqIGhlcmUuCiAJ ICovCiAKKwkvKiBSZWdpc3RlcnMgcHJlIGFueSBndWVzdCBkZWJ1ZyBtYW5pcHVsYXRpb25zICov CisJc3RydWN0IHsKKwkJdTMyCXBzdGF0ZV9zc19iaXQ7CisJCXUzMgltZHNjcl9lbDFfYml0czsK KworCX0gZGVidWdfc2F2ZWRfcmVnczsKKwogCS8qIERvbid0IHJ1biB0aGUgZ3Vlc3QgKi8KIAli b29sIHBhdXNlOwogCkBAIC0xNDMsNiArMTUwLDcgQEAgc3RydWN0IGt2bV92Y3B1X2FyY2ggewog CiAjZGVmaW5lIHZjcHVfZ3BfcmVncyh2KQkJKCYodiktPmFyY2guY3R4dC5ncF9yZWdzKQogI2Rl ZmluZSB2Y3B1X3N5c19yZWcodixyKQkoKHYpLT5hcmNoLmN0eHQuc3lzX3JlZ3NbKHIpXSkKKyNk ZWZpbmUgdmNwdV9kZWJ1Z19zYXZlZF9yZWcodiwgcikgKCh2KS0+YXJjaC5kZWJ1Z19zYXZlZF9y ZWdzLnIpCiAvKgogICogQ1AxNCBhbmQgQ1AxNSBsaXZlIGluIHRoZSBzYW1lIGFycmF5LCBhcyB0 aGV5IGFyZSBiYWNrZWQgYnkgdGhlCiAgKiBzYW1lIHN5c3RlbSByZWdpc3RlcnMuCmRpZmYgLS1n aXQgYS9hcmNoL2FybTY0L2t2bS9kZWJ1Zy5jIGIvYXJjaC9hcm02NC9rdm0vZGVidWcuYwppbmRl eCBjZmYwNDc1Li5iMzIzNjJjIDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2t2bS9kZWJ1Zy5jCisr KyBiL2FyY2gvYXJtNjQva3ZtL2RlYnVnLmMKQEAgLTE5LDggKzE5LDE2IEBACiAKICNpbmNsdWRl IDxsaW51eC9rdm1faG9zdC5oPgogCisjaW5jbHVkZSA8YXNtL2RlYnVnLW1vbml0b3JzLmg+Cisj aW5jbHVkZSA8YXNtL2t2bV9hc20uaD4KICNpbmNsdWRlIDxhc20va3ZtX2FybS5oPgogI2luY2x1 ZGUgPGFzbS9rdm1faG9zdC5oPgorI2luY2x1ZGUgPGFzbS9rdm1fZW11bGF0ZS5oPgorCisvKiBU aGVzZSBhcmUgdGhlIGJpdHMgb2YgTURTQ1JfRUwxIHdlIG1heSBtZXNzIHdpdGggKi8KKyNkZWZp bmUgTURTQ1JfRUwxX0RFQlVHX0JJVFMJKERCR19NRFNDUl9TUyB8IFwKKwkJCQlEQkdfTURTQ1Jf S0RFIHwgXAorCQkJCURCR19NRFNDUl9NREUpCiAKIC8qKgogICoga3ZtX2FyY2hfc2V0dXBfZGVi dWcgLSBzZXQtdXAgZGVidWcgcmVsYXRlZCBzdHVmZgpAQCAtNTEsMTUgKzU5LDQ2IEBAIHZvaWQg a3ZtX2FyY2hfc2V0dXBfZGVidWcoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQogCWVsc2UKIAkJdmNw dS0+YXJjaC5tZGNyX2VsMiAmPSB+TURDUl9FTDJfVERBOwogCi0JLyogVHJhcCBicmVha3BvaW50 cz8gKi8KLQlpZiAodmNwdS0+Z3Vlc3RfZGVidWcgJiBLVk1fR1VFU1REQkdfVVNFX1NXX0JQKQor CS8qIElzIEd1ZXN0IGRlYnVnZ2luZyBpbiBlZmZlY3Q/ICovCisJaWYgKHZjcHUtPmd1ZXN0X2Rl YnVnKSB7CiAJCXZjcHUtPmFyY2gubWRjcl9lbDIgfD0gTURDUl9FTDJfVERFOwotCWVsc2UKLQkJ dmNwdS0+YXJjaC5tZGNyX2VsMiAmPSB+TURDUl9FTDJfVERFOwogCisJCS8qIFNhdmUgcHN0YXRl L21kc2NyICovCisJCXZjcHVfZGVidWdfc2F2ZWRfcmVnKHZjcHUsIHBzdGF0ZV9zc19iaXQpID0K KwkJCSp2Y3B1X2Nwc3IodmNwdSkgJiBEQkdfU1BTUl9TUzsKKwkJdmNwdV9kZWJ1Z19zYXZlZF9y ZWcodmNwdSwgbWRzY3JfZWwxX2JpdHMpID0KKwkJCXZjcHVfc3lzX3JlZyh2Y3B1LCBNRFNDUl9F TDEpICYgTURTQ1JfRUwxX0RFQlVHX0JJVFM7CisJCS8qCisJCSAqIFNpbmdsZSBTdGVwIChBUk0g QVJNIEQyLjEyLjMgVGhlIHNvZnR3YXJlIHN0ZXAgc3RhdGUKKwkJICogbWFjaGluZSkKKwkJICoK KwkJICogSWYgd2UgYXJlIGRvaW5nIFNpbmdsZSBTdGVwIHdlIG5lZWQgdG8gbWFuaXB1bGF0ZQor CQkgKiBNRFNDUl9FTDEuU1MgYW5kIFBTVEFURS5TUy4gSWYgbm90IHdlIG5lZWQgdG8KKwkJICog c3VwcHJlc3MgdGhlIGd1ZXN0IGZyb20gbWVzc2luZyB3aXRoIGl0LgorCQkgKi8KKwkJaWYgKHZj cHUtPmd1ZXN0X2RlYnVnICYgS1ZNX0dVRVNUREJHX1NJTkdMRVNURVApIHsKKwkJCSp2Y3B1X2Nw c3IodmNwdSkgfD0gIERCR19TUFNSX1NTOworCQkJdmNwdV9zeXNfcmVnKHZjcHUsIE1EU0NSX0VM MSkgfD0gREJHX01EU0NSX1NTOworCQl9IGVsc2UgeworCQkJKnZjcHVfY3Bzcih2Y3B1KSAmPSB+ REJHX1NQU1JfU1M7CisJCQl2Y3B1X3N5c19yZWcodmNwdSwgTURTQ1JfRUwxKSAmPSB+REJHX01E U0NSX1NTOworCQl9CisKKwl9IGVsc2UgeworCQkvKiBEZWJ1ZyBvcGVyYXRpb25zIGNhbiBnbyBz dHJhaWdodCB0byB0aGUgZ3Vlc3QgKi8KKwkJdmNwdS0+YXJjaC5tZGNyX2VsMiAmPSB+TURDUl9F TDJfVERFOworCX0KIH0KIAogdm9pZCBrdm1fYXJjaF9jbGVhcl9kZWJ1ZyhzdHJ1Y3Qga3ZtX3Zj cHUgKnZjcHUpCiB7Ci0JLyogTm90aGluZyB0byBkbyB5ZXQgKi8KKwlpZiAodmNwdS0+Z3Vlc3Rf ZGVidWcpIHsKKwkJLyogUmVzdG9yZSBwc3RhdGUvbWRzY3IgYml0cyB3ZSBtYXkgaGF2ZSBtZXNz ZWQgd2l0aCAqLworCQkqdmNwdV9jcHNyKHZjcHUpICY9IH5EQkdfU1BTUl9TUzsKKwkJKnZjcHVf Y3Bzcih2Y3B1KSB8PSB2Y3B1X2RlYnVnX3NhdmVkX3JlZyh2Y3B1LCBwc3RhdGVfc3NfYml0KTsK KworCQl2Y3B1X3N5c19yZWcodmNwdSwgTURTQ1JfRUwxKSAmPSB+TURTQ1JfRUwxX0RFQlVHX0JJ VFM7CisJCXZjcHVfc3lzX3JlZyh2Y3B1LCBNRFNDUl9FTDEpIHw9CisJCQl2Y3B1X2RlYnVnX3Nh dmVkX3JlZyh2Y3B1LCBtZHNjcl9lbDFfYml0cyk7CisJfQogfQpkaWZmIC0tZ2l0IGEvYXJjaC9h cm02NC9rdm0vaGFuZGxlX2V4aXQuYyBiL2FyY2gvYXJtNjQva3ZtL2hhbmRsZV9leGl0LmMKaW5k ZXggZWQxYmJiNC4uMTZhY2NhZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9rdm0vaGFuZGxlX2V4 aXQuYworKysgYi9hcmNoL2FybTY0L2t2bS9oYW5kbGVfZXhpdC5jCkBAIC0xMDEsNiArMTAxLDcg QEAgc3RhdGljIGludCBrdm1faGFuZGxlX2d1ZXN0X2RlYnVnKHN0cnVjdCBrdm1fdmNwdSAqdmNw dSwgc3RydWN0IGt2bV9ydW4gKnJ1bikKIAlydW4tPmRlYnVnLmFyY2guaHNyID0gaHNyOwogCiAJ c3dpdGNoIChoc3IgPj4gRVNSX0VMeF9FQ19TSElGVCkgeworCWNhc2UgRVNSX0VMeF9FQ19TT0ZU U1RQX0xPVzoKIAljYXNlIEVTUl9FTHhfRUNfQktQVDMyOgogCWNhc2UgRVNSX0VMeF9FQ19CUks2 NDoKIAkJcnVuLT5kZWJ1Zy5hcmNoLnBjID0gKnZjcHVfcGModmNwdSk7CkBAIC0xMjcsNiArMTI4 LDcgQEAgc3RhdGljIGV4aXRfaGFuZGxlX2ZuIGFybV9leGl0X2hhbmRsZXJzW10gPSB7CiAJW0VT Ul9FTHhfRUNfU1lTNjRdCT0ga3ZtX2hhbmRsZV9zeXNfcmVnLAogCVtFU1JfRUx4X0VDX0lBQlRf TE9XXQk9IGt2bV9oYW5kbGVfZ3Vlc3RfYWJvcnQsCiAJW0VTUl9FTHhfRUNfREFCVF9MT1ddCT0g a3ZtX2hhbmRsZV9ndWVzdF9hYm9ydCwKKwlbRVNSX0VMeF9FQ19TT0ZUU1RQX0xPV109IGt2bV9o YW5kbGVfZ3Vlc3RfZGVidWcsCiAJW0VTUl9FTHhfRUNfQktQVDMyXQk9IGt2bV9oYW5kbGVfZ3Vl c3RfZGVidWcsCiAJW0VTUl9FTHhfRUNfQlJLNjRdCT0ga3ZtX2hhbmRsZV9ndWVzdF9kZWJ1ZywK IH07Ci0tIAoyLjMuNAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18Ka3ZtYXJtIG1haWxpbmcgbGlzdAprdm1hcm1AbGlzdHMuY3MuY29sdW1iaWEuZWR1Cmh0 dHBzOi8vbGlzdHMuY3MuY29sdW1iaWEuZWR1L21haWxtYW4vbGlzdGluZm8va3ZtYXJtCg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: alex.bennee@linaro.org (=?UTF-8?q?Alex=20Benn=C3=A9e?=) Date: Tue, 31 Mar 2015 16:08:05 +0100 Subject: [PATCH v2 07/10] KVM: arm64: guest debug, add support for single-step In-Reply-To: <1427814488-28467-1-git-send-email-alex.bennee@linaro.org> References: <1427814488-28467-1-git-send-email-alex.bennee@linaro.org> Message-ID: <1427814488-28467-8-git-send-email-alex.bennee@linaro.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org This adds support for single-stepping the guest. As userspace can and will manipulate guest registers before restarting any tweaking of the registers has to occur just before control is passed back to the guest. Furthermore while guest debugging is in effect we need to squash the ability of the guest to single-step itself as we have no easy way of re-entering the guest after the exception has been delivered to the hypervisor. Signed-off-by: Alex Benn?e --- v2 - Move pstate/mdscr manipulation into C - don't export guest_debug to assembly - add accessor for saved_debug regs - tweak save/restore of mdscr_el1 diff --git a/arch/arm/kvm/arm.c b/arch/arm/kvm/arm.c index d3bc8dc..c1ed8cb 100644 --- a/arch/arm/kvm/arm.c +++ b/arch/arm/kvm/arm.c @@ -304,7 +304,21 @@ void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) kvm_arm_set_running_vcpu(NULL); } -#define KVM_GUESTDBG_VALID (KVM_GUESTDBG_ENABLE|KVM_GUESTDBG_USE_SW_BP) +#define KVM_GUESTDBG_VALID (KVM_GUESTDBG_ENABLE | \ + KVM_GUESTDBG_USE_SW_BP | \ + KVM_GUESTDBG_SINGLESTEP) + +/** + * kvm_arch_vcpu_ioctl_set_guest_debug - Setup guest debugging + * @kvm: pointer to the KVM struct + * @kvm_guest_debug: the ioctl data buffer + * + * This sets up the VM for guest debugging. Care has to be taken when + * manipulating guest registers as these will be set/cleared by the + * hyper-visor controller, typically before each kvm_run event. As a + * result modification of the guest registers needs to take place + * after they have been restored in the hyp.S trampoline code. + */ int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, struct kvm_guest_debug *dbg) diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h index 0631840..6a33647 100644 --- a/arch/arm64/include/asm/kvm_host.h +++ b/arch/arm64/include/asm/kvm_host.h @@ -121,6 +121,13 @@ struct kvm_vcpu_arch { * here. */ + /* Registers pre any guest debug manipulations */ + struct { + u32 pstate_ss_bit; + u32 mdscr_el1_bits; + + } debug_saved_regs; + /* Don't run the guest */ bool pause; @@ -143,6 +150,7 @@ struct kvm_vcpu_arch { #define vcpu_gp_regs(v) (&(v)->arch.ctxt.gp_regs) #define vcpu_sys_reg(v,r) ((v)->arch.ctxt.sys_regs[(r)]) +#define vcpu_debug_saved_reg(v, r) ((v)->arch.debug_saved_regs.r) /* * CP14 and CP15 live in the same array, as they are backed by the * same system registers. diff --git a/arch/arm64/kvm/debug.c b/arch/arm64/kvm/debug.c index cff0475..b32362c 100644 --- a/arch/arm64/kvm/debug.c +++ b/arch/arm64/kvm/debug.c @@ -19,8 +19,16 @@ #include +#include +#include #include #include +#include + +/* These are the bits of MDSCR_EL1 we may mess with */ +#define MDSCR_EL1_DEBUG_BITS (DBG_MDSCR_SS | \ + DBG_MDSCR_KDE | \ + DBG_MDSCR_MDE) /** * kvm_arch_setup_debug - set-up debug related stuff @@ -51,15 +59,46 @@ void kvm_arch_setup_debug(struct kvm_vcpu *vcpu) else vcpu->arch.mdcr_el2 &= ~MDCR_EL2_TDA; - /* Trap breakpoints? */ - if (vcpu->guest_debug & KVM_GUESTDBG_USE_SW_BP) + /* Is Guest debugging in effect? */ + if (vcpu->guest_debug) { vcpu->arch.mdcr_el2 |= MDCR_EL2_TDE; - else - vcpu->arch.mdcr_el2 &= ~MDCR_EL2_TDE; + /* Save pstate/mdscr */ + vcpu_debug_saved_reg(vcpu, pstate_ss_bit) = + *vcpu_cpsr(vcpu) & DBG_SPSR_SS; + vcpu_debug_saved_reg(vcpu, mdscr_el1_bits) = + vcpu_sys_reg(vcpu, MDSCR_EL1) & MDSCR_EL1_DEBUG_BITS; + /* + * Single Step (ARM ARM D2.12.3 The software step state + * machine) + * + * If we are doing Single Step we need to manipulate + * MDSCR_EL1.SS and PSTATE.SS. If not we need to + * suppress the guest from messing with it. + */ + if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP) { + *vcpu_cpsr(vcpu) |= DBG_SPSR_SS; + vcpu_sys_reg(vcpu, MDSCR_EL1) |= DBG_MDSCR_SS; + } else { + *vcpu_cpsr(vcpu) &= ~DBG_SPSR_SS; + vcpu_sys_reg(vcpu, MDSCR_EL1) &= ~DBG_MDSCR_SS; + } + + } else { + /* Debug operations can go straight to the guest */ + vcpu->arch.mdcr_el2 &= ~MDCR_EL2_TDE; + } } void kvm_arch_clear_debug(struct kvm_vcpu *vcpu) { - /* Nothing to do yet */ + if (vcpu->guest_debug) { + /* Restore pstate/mdscr bits we may have messed with */ + *vcpu_cpsr(vcpu) &= ~DBG_SPSR_SS; + *vcpu_cpsr(vcpu) |= vcpu_debug_saved_reg(vcpu, pstate_ss_bit); + + vcpu_sys_reg(vcpu, MDSCR_EL1) &= ~MDSCR_EL1_DEBUG_BITS; + vcpu_sys_reg(vcpu, MDSCR_EL1) |= + vcpu_debug_saved_reg(vcpu, mdscr_el1_bits); + } } diff --git a/arch/arm64/kvm/handle_exit.c b/arch/arm64/kvm/handle_exit.c index ed1bbb4..16accae 100644 --- a/arch/arm64/kvm/handle_exit.c +++ b/arch/arm64/kvm/handle_exit.c @@ -101,6 +101,7 @@ static int kvm_handle_guest_debug(struct kvm_vcpu *vcpu, struct kvm_run *run) run->debug.arch.hsr = hsr; switch (hsr >> ESR_ELx_EC_SHIFT) { + case ESR_ELx_EC_SOFTSTP_LOW: case ESR_ELx_EC_BKPT32: case ESR_ELx_EC_BRK64: run->debug.arch.pc = *vcpu_pc(vcpu); @@ -127,6 +128,7 @@ static exit_handle_fn arm_exit_handlers[] = { [ESR_ELx_EC_SYS64] = kvm_handle_sys_reg, [ESR_ELx_EC_IABT_LOW] = kvm_handle_guest_abort, [ESR_ELx_EC_DABT_LOW] = kvm_handle_guest_abort, + [ESR_ELx_EC_SOFTSTP_LOW]= kvm_handle_guest_debug, [ESR_ELx_EC_BKPT32] = kvm_handle_guest_debug, [ESR_ELx_EC_BRK64] = kvm_handle_guest_debug, }; -- 2.3.4