From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752007AbbEGJIT (ORCPT ); Thu, 7 May 2015 05:08:19 -0400 Received: from static.88-198-71-155.clients.your-server.de ([88.198.71.155]:38263 "EHLO socrates.bennee.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750863AbbEGJIK (ORCPT ); Thu, 7 May 2015 05:08:10 -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 , Jonathan Corbet , Russell King , Catalin Marinas , Will Deacon , Ard Biesheuvel , Lorenzo Pieralisi , Andre Przywara , Richard Weinberger , Peter Zijlstra , Ingo Molnar , AKASHI Takahiro , linux-doc@vger.kernel.org (open list:DOCUMENTATION), linux-kernel@vger.kernel.org (open list), linux-api@vger.kernel.org (open list:ABI/API) Subject: [PATCH v3 09/12] KVM: arm64: guest debug, HW assisted debug support Date: Thu, 7 May 2015 10:07:12 +0100 Message-Id: <1430989647-22501-2-git-send-email-alex.bennee@linaro.org> X-Mailer: git-send-email 2.3.5 In-Reply-To: <1430929407-3487-1-git-send-email-alex.bennee@linaro.org> References: <1430929407-3487-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 userspace to control the HW debug registers for guest debug. In the debug ioctl we copy the IMPDEF defined number of registers into a new register set called host_debug_state. There is now a new vcpu parameter called debug_ptr which selects which register set is to copied into the real registers when world switch occurs. I've moved some helper functions into the hw_breakpoint.h header for re-use. As with single step we need to tweak the guest registers to enable the exceptions so we need to save and restore those bits. Two new capabilities have been added to the KVM_EXTENSION ioctl to allow userspace to query the number of hardware break and watch points available on the host hardware. Signed-off-by: Alex Bennée --- v2 - switched to C setup - replace host debug registers directly into context - minor tweak to api docs - setup right register for debug - add FAR_EL2 to debug exit structure - add support for trapping debug register access v3 - remove stray trace statement - fix spacing around operators (various) - clean-up usage of trap_debug - introduce debug_ptr, replace excessive memcpy stuff - don't use memcpy in ioctl, just assign - update cap ioctl documentation - reword a number comments - rename host_debug_state->external_debug_state diff --git a/Documentation/virtual/kvm/api.txt b/Documentation/virtual/kvm/api.txt index 5ef937c..419f7a8 100644 --- a/Documentation/virtual/kvm/api.txt +++ b/Documentation/virtual/kvm/api.txt @@ -2668,7 +2668,7 @@ The top 16 bits of the control field are architecture specific control flags which can include the following: - KVM_GUESTDBG_USE_SW_BP: using software breakpoints [x86, arm64] - - KVM_GUESTDBG_USE_HW_BP: using hardware breakpoints [x86, s390] + - KVM_GUESTDBG_USE_HW_BP: using hardware breakpoints [x86, s390, arm64] - KVM_GUESTDBG_INJECT_DB: inject DB type exception [x86] - KVM_GUESTDBG_INJECT_BP: inject BP type exception [x86] - KVM_GUESTDBG_EXIT_PENDING: trigger an immediate guest exit [s390] @@ -2683,6 +2683,11 @@ updated to the correct (supplied) values. The second part of the structure is architecture specific and typically contains a set of debug registers. +For arm64 the number of debug registers is implementation defined and +can be determined by querying the KVM_CAP_GUEST_DEBUG_HW_BPS and +KVM_CAP_GUEST_DEBUG_HW_WPS capabilities which returns a +ve number +indicating the number of supported registers. + When debug events exit the main run loop with the reason KVM_EXIT_DEBUG with the kvm_debug_exit_arch part of the kvm_run structure containing architecture specific debug information. diff --git a/arch/arm/kvm/arm.c b/arch/arm/kvm/arm.c index 9b3ed6d..2920185 100644 --- a/arch/arm/kvm/arm.c +++ b/arch/arm/kvm/arm.c @@ -279,6 +279,10 @@ int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) /* Set up the timer */ kvm_timer_vcpu_init(vcpu); + /* Set the debug registers to be the guests */ + vcpu->arch.debug_ptr = (struct kvm_guest_debug_arch *) + &vcpu_sys_reg(vcpu, DBGBCR0_EL1); + return 0; } @@ -304,6 +308,7 @@ void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) #define KVM_GUESTDBG_VALID_MASK (KVM_GUESTDBG_ENABLE | \ KVM_GUESTDBG_USE_SW_BP | \ + KVM_GUESTDBG_USE_HW_BP | \ KVM_GUESTDBG_SINGLESTEP) /** @@ -324,6 +329,12 @@ int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, if (dbg->control & KVM_GUESTDBG_ENABLE) { vcpu->guest_debug = dbg->control; + + /* Hardware assisted Break and Watch points */ + if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) { + vcpu->arch.external_debug_state = dbg->arch; + } + } else { /* If not enabled clear all flags */ vcpu->guest_debug = 0; diff --git a/arch/arm64/include/asm/hw_breakpoint.h b/arch/arm64/include/asm/hw_breakpoint.h index 52b484b..c450552 100644 --- a/arch/arm64/include/asm/hw_breakpoint.h +++ b/arch/arm64/include/asm/hw_breakpoint.h @@ -130,6 +130,18 @@ static inline void ptrace_hw_copy_thread(struct task_struct *task) } #endif +/* Determine number of BRP registers available. */ +static inline int get_num_brps(void) +{ + return ((read_cpuid(ID_AA64DFR0_EL1) >> 12) & 0xf) + 1; +} + +/* Determine number of WRP registers available. */ +static inline int get_num_wrps(void) +{ + return ((read_cpuid(ID_AA64DFR0_EL1) >> 20) & 0xf) + 1; +} + extern struct pmu perf_ops_bp; #endif /* __KERNEL__ */ diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h index b60fa7a..a44fb32 100644 --- a/arch/arm64/include/asm/kvm_host.h +++ b/arch/arm64/include/asm/kvm_host.h @@ -108,9 +108,18 @@ struct kvm_vcpu_arch { /* Exception Information */ struct kvm_vcpu_fault_info fault; - /* Debug state */ + /* Guest debug state */ u64 debug_flags; + /* + * For debugging the guest we need to keep a set of debug + * registers which can override the guests own debug state + * while being used. These are set via the KVM_SET_GUEST_DEBUG + * ioctl. + */ + struct kvm_guest_debug_arch *debug_ptr; + struct kvm_guest_debug_arch external_debug_state; + /* Pointer to host CPU context */ kvm_cpu_context_t *host_cpu_context; diff --git a/arch/arm64/include/uapi/asm/kvm.h b/arch/arm64/include/uapi/asm/kvm.h index 04957d7..98e82ef 100644 --- a/arch/arm64/include/uapi/asm/kvm.h +++ b/arch/arm64/include/uapi/asm/kvm.h @@ -121,7 +121,7 @@ struct kvm_guest_debug_arch { struct kvm_debug_exit_arch { __u32 hsr; - __u64 far; + __u64 far; /* used for watchpoints */ }; struct kvm_sync_regs { diff --git a/arch/arm64/kernel/asm-offsets.c b/arch/arm64/kernel/asm-offsets.c index ce7b7dd..671ab13 100644 --- a/arch/arm64/kernel/asm-offsets.c +++ b/arch/arm64/kernel/asm-offsets.c @@ -116,6 +116,7 @@ int main(void) DEFINE(VCPU_FAR_EL2, offsetof(struct kvm_vcpu, arch.fault.far_el2)); DEFINE(VCPU_HPFAR_EL2, offsetof(struct kvm_vcpu, arch.fault.hpfar_el2)); DEFINE(VCPU_DEBUG_FLAGS, offsetof(struct kvm_vcpu, arch.debug_flags)); + DEFINE(VCPU_DEBUG_PTR, offsetof(struct kvm_vcpu, arch.debug_ptr)); DEFINE(DEBUG_BCR, offsetof(struct kvm_guest_debug_arch, dbg_bcr)); DEFINE(DEBUG_BVR, offsetof(struct kvm_guest_debug_arch, dbg_bvr)); DEFINE(DEBUG_WCR, offsetof(struct kvm_guest_debug_arch, dbg_wcr)); diff --git a/arch/arm64/kernel/hw_breakpoint.c b/arch/arm64/kernel/hw_breakpoint.c index e7d934d..3a41bbf 100644 --- a/arch/arm64/kernel/hw_breakpoint.c +++ b/arch/arm64/kernel/hw_breakpoint.c @@ -49,18 +49,6 @@ static DEFINE_PER_CPU(int, stepping_kernel_bp); static int core_num_brps; static int core_num_wrps; -/* Determine number of BRP registers available. */ -static int get_num_brps(void) -{ - return ((read_cpuid(ID_AA64DFR0_EL1) >> 12) & 0xf) + 1; -} - -/* Determine number of WRP registers available. */ -static int get_num_wrps(void) -{ - return ((read_cpuid(ID_AA64DFR0_EL1) >> 20) & 0xf) + 1; -} - int hw_breakpoint_slots(int type) { /* diff --git a/arch/arm64/kvm/debug.c b/arch/arm64/kvm/debug.c index 19346e8..1ab63dd 100644 --- a/arch/arm64/kvm/debug.c +++ b/arch/arm64/kvm/debug.c @@ -99,12 +99,6 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu) MDCR_EL2_TDRA | MDCR_EL2_TDOSA); - /* Trap on access to debug registers? */ - if (trap_debug) - vcpu->arch.mdcr_el2 |= MDCR_EL2_TDA; - else - vcpu->arch.mdcr_el2 &= ~MDCR_EL2_TDA; - /* Is Guest debugging in effect? */ if (vcpu->guest_debug) { vcpu->arch.mdcr_el2 |= MDCR_EL2_TDE; @@ -128,14 +122,54 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu) vcpu_sys_reg(vcpu, MDSCR_EL1) &= ~DBG_MDSCR_SS; } + /* + * HW Break/Watch points + * + * We simply switch the debug_ptr to point to our new + * external_debug_state which has been populated by the + * debug ioctl. The existing KVM_ARM64_DEBUG_DIRTY + * mechanism ensures the registers are updated on the + * world switch. + */ + if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) { + + vcpu_sys_reg(vcpu, MDSCR_EL1) |= + (DBG_MDSCR_KDE | DBG_MDSCR_MDE); + + vcpu->arch.debug_ptr = &vcpu->arch.external_debug_state; + vcpu->arch.debug_flags |= KVM_ARM64_DEBUG_DIRTY; + trap_debug = true; + } + } else { /* Debug operations can go straight to the guest */ vcpu->arch.mdcr_el2 &= ~MDCR_EL2_TDE; } + + /* + * If the guest debug register state is dirty (the guest is + * actively accessing them), then we context-switch the + * registers in EL2. Otherwise, we trap-and-emulate all guest + * accesses to them. + */ + if (trap_debug) + vcpu->arch.mdcr_el2 |= MDCR_EL2_TDA; + else + vcpu->arch.mdcr_el2 &= ~MDCR_EL2_TDA; } void kvm_arm_clear_debug(struct kvm_vcpu *vcpu) { - if (vcpu->guest_debug) + if (vcpu->guest_debug) { restore_guest_debug_regs(vcpu); + + /* + * If we were using HW debug we need to restore the + * debug_ptr to the guest debug state. + */ + if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) { + vcpu->arch.debug_ptr = (struct kvm_guest_debug_arch *) + &vcpu_sys_reg(vcpu, DBGBCR0_EL1); + } + } } diff --git a/arch/arm64/kvm/handle_exit.c b/arch/arm64/kvm/handle_exit.c index e9de13e..68a0759 100644 --- a/arch/arm64/kvm/handle_exit.c +++ b/arch/arm64/kvm/handle_exit.c @@ -103,7 +103,11 @@ 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_WATCHPT_LOW: + run->debug.arch.far = vcpu->arch.fault.far_el2; + /* fall through */ case ESR_ELx_EC_SOFTSTP_LOW: + case ESR_ELx_EC_BREAKPT_LOW: case ESR_ELx_EC_BKPT32: case ESR_ELx_EC_BRK64: break; @@ -132,6 +136,8 @@ static exit_handle_fn arm_exit_handlers[] = { [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_WATCHPT_LOW]= kvm_handle_guest_debug, + [ESR_ELx_EC_BREAKPT_LOW]= kvm_handle_guest_debug, [ESR_ELx_EC_BKPT32] = kvm_handle_guest_debug, [ESR_ELx_EC_BRK64] = kvm_handle_guest_debug, }; diff --git a/arch/arm64/kvm/hyp.S b/arch/arm64/kvm/hyp.S index dd51fb1..921d248 100644 --- a/arch/arm64/kvm/hyp.S +++ b/arch/arm64/kvm/hyp.S @@ -706,7 +706,8 @@ ENTRY(__kvm_vcpu_run) bl __restore_fpsimd skip_debug_state x3, 1f - add x3, x2, #CPU_SYSREG_OFFSET(DBGBCR0_EL1) + ldr x3, [x0, #VCPU_DEBUG_PTR] + kern_hyp_va x3 bl __restore_debug 1: restore_guest_32bit_state @@ -727,7 +728,8 @@ __kvm_vcpu_return: bl __save_sysregs skip_debug_state x3, 1f - add x3, x2, #CPU_SYSREG_OFFSET(DBGBCR0_EL1) + ldr x3, [x0, #VCPU_DEBUG_PTR] + kern_hyp_va x3 bl __save_debug 1: save_guest_32bit_state diff --git a/arch/arm64/kvm/reset.c b/arch/arm64/kvm/reset.c index 0b43265..21d5a62 100644 --- a/arch/arm64/kvm/reset.c +++ b/arch/arm64/kvm/reset.c @@ -56,6 +56,12 @@ static bool cpu_has_32bit_el1(void) return !!(pfr0 & 0x20); } +/** + * kvm_arch_dev_ioctl_check_extension + * + * We currently assume that the number of HW registers is uniform + * across all CPUs (see cpuinfo_sanity_check). + */ int kvm_arch_dev_ioctl_check_extension(long ext) { int r; @@ -64,6 +70,12 @@ int kvm_arch_dev_ioctl_check_extension(long ext) case KVM_CAP_ARM_EL1_32BIT: r = cpu_has_32bit_el1(); break; + case KVM_CAP_GUEST_DEBUG_HW_BPS: + r = get_num_brps(); + break; + case KVM_CAP_GUEST_DEBUG_HW_WPS: + r = get_num_wrps(); + break; default: r = 0; } diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h index 3b6252e..923c2aa 100644 --- a/include/uapi/linux/kvm.h +++ b/include/uapi/linux/kvm.h @@ -825,6 +825,8 @@ struct kvm_ppc_smmu_info { #define KVM_CAP_S390_INJECT_IRQ 113 #define KVM_CAP_S390_IRQ_STATE 114 #define KVM_CAP_PPC_HWRNG 115 +#define KVM_CAP_GUEST_DEBUG_HW_BPS 116 +#define KVM_CAP_GUEST_DEBUG_HW_WPS 117 #ifdef KVM_CAP_IRQ_ROUTING -- 2.3.5 From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Alex=20Benn=C3=A9e?= Subject: [PATCH v3 09/12] KVM: arm64: guest debug, HW assisted debug support Date: Thu, 7 May 2015 10:07:12 +0100 Message-ID: <1430989647-22501-2-git-send-email-alex.bennee@linaro.org> References: <1430929407-3487-1-git-send-email-alex.bennee@linaro.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1430929407-3487-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 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: Peter Zijlstra , Lorenzo Pieralisi , Russell King , Richard Weinberger , Jonathan Corbet , Gleb Natapov , jan.kiszka@siemens.com, AKASHI Takahiro , Ard Biesheuvel , Will Deacon , open list , "open list:ABI/API" , "open list:DOCUMENTATION" , dahi@linux.vnet.ibm.com, Andre Przywara , Catalin Marinas , r65777@freescale.com, bp@suse.de, Ingo Molnar List-Id: linux-api@vger.kernel.org VGhpcyBhZGRzIHN1cHBvcnQgZm9yIHVzZXJzcGFjZSB0byBjb250cm9sIHRoZSBIVyBkZWJ1ZyBy ZWdpc3RlcnMgZm9yCmd1ZXN0IGRlYnVnLiBJbiB0aGUgZGVidWcgaW9jdGwgd2UgY29weSB0aGUg SU1QREVGIGRlZmluZWQgbnVtYmVyIG9mCnJlZ2lzdGVycyBpbnRvIGEgbmV3IHJlZ2lzdGVyIHNl dCBjYWxsZWQgaG9zdF9kZWJ1Z19zdGF0ZS4gVGhlcmUgaXMgbm93CmEgbmV3IHZjcHUgcGFyYW1l dGVyIGNhbGxlZCBkZWJ1Z19wdHIgd2hpY2ggc2VsZWN0cyB3aGljaCByZWdpc3RlciBzZXQKaXMg dG8gY29waWVkIGludG8gdGhlIHJlYWwgcmVnaXN0ZXJzIHdoZW4gd29ybGQgc3dpdGNoIG9jY3Vy cy4KCkkndmUgbW92ZWQgc29tZSBoZWxwZXIgZnVuY3Rpb25zIGludG8gdGhlIGh3X2JyZWFrcG9p bnQuaCBoZWFkZXIgZm9yCnJlLXVzZS4KCkFzIHdpdGggc2luZ2xlIHN0ZXAgd2UgbmVlZCB0byB0 d2VhayB0aGUgZ3Vlc3QgcmVnaXN0ZXJzIHRvIGVuYWJsZSB0aGUKZXhjZXB0aW9ucyBzbyB3ZSBu ZWVkIHRvIHNhdmUgYW5kIHJlc3RvcmUgdGhvc2UgYml0cy4KClR3byBuZXcgY2FwYWJpbGl0aWVz IGhhdmUgYmVlbiBhZGRlZCB0byB0aGUgS1ZNX0VYVEVOU0lPTiBpb2N0bCB0byBhbGxvdwp1c2Vy c3BhY2UgdG8gcXVlcnkgdGhlIG51bWJlciBvZiBoYXJkd2FyZSBicmVhayBhbmQgd2F0Y2ggcG9p bnRzCmF2YWlsYWJsZSBvbiB0aGUgaG9zdCBoYXJkd2FyZS4KClNpZ25lZC1vZmYtYnk6IEFsZXgg QmVubsOpZSA8YWxleC5iZW5uZWVAbGluYXJvLm9yZz4KCi0tLQp2MgogICAtIHN3aXRjaGVkIHRv IEMgc2V0dXAKICAgLSByZXBsYWNlIGhvc3QgZGVidWcgcmVnaXN0ZXJzIGRpcmVjdGx5IGludG8g Y29udGV4dAogICAtIG1pbm9yIHR3ZWFrIHRvIGFwaSBkb2NzCiAgIC0gc2V0dXAgcmlnaHQgcmVn aXN0ZXIgZm9yIGRlYnVnCiAgIC0gYWRkIEZBUl9FTDIgdG8gZGVidWcgZXhpdCBzdHJ1Y3R1cmUK ICAgLSBhZGQgc3VwcG9ydCBmb3IgdHJhcHBpbmcgZGVidWcgcmVnaXN0ZXIgYWNjZXNzCnYzCiAg IC0gcmVtb3ZlIHN0cmF5IHRyYWNlIHN0YXRlbWVudAogICAtIGZpeCBzcGFjaW5nIGFyb3VuZCBv cGVyYXRvcnMgKHZhcmlvdXMpCiAgIC0gY2xlYW4tdXAgdXNhZ2Ugb2YgdHJhcF9kZWJ1ZwogICAt IGludHJvZHVjZSBkZWJ1Z19wdHIsIHJlcGxhY2UgZXhjZXNzaXZlIG1lbWNweSBzdHVmZgogICAt IGRvbid0IHVzZSBtZW1jcHkgaW4gaW9jdGwsIGp1c3QgYXNzaWduCiAgIC0gdXBkYXRlIGNhcCBp b2N0bCBkb2N1bWVudGF0aW9uCiAgIC0gcmV3b3JkIGEgbnVtYmVyIGNvbW1lbnRzCiAgIC0gcmVu YW1lIGhvc3RfZGVidWdfc3RhdGUtPmV4dGVybmFsX2RlYnVnX3N0YXRlCgpkaWZmIC0tZ2l0IGEv RG9jdW1lbnRhdGlvbi92aXJ0dWFsL2t2bS9hcGkudHh0IGIvRG9jdW1lbnRhdGlvbi92aXJ0dWFs L2t2bS9hcGkudHh0CmluZGV4IDVlZjkzN2MuLjQxOWY3YTggMTAwNjQ0Ci0tLSBhL0RvY3VtZW50 YXRpb24vdmlydHVhbC9rdm0vYXBpLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3ZpcnR1YWwva3Zt L2FwaS50eHQKQEAgLTI2NjgsNyArMjY2OCw3IEBAIFRoZSB0b3AgMTYgYml0cyBvZiB0aGUgY29u dHJvbCBmaWVsZCBhcmUgYXJjaGl0ZWN0dXJlIHNwZWNpZmljIGNvbnRyb2wKIGZsYWdzIHdoaWNo IGNhbiBpbmNsdWRlIHRoZSBmb2xsb3dpbmc6CiAKICAgLSBLVk1fR1VFU1REQkdfVVNFX1NXX0JQ OiAgICAgdXNpbmcgc29mdHdhcmUgYnJlYWtwb2ludHMgW3g4NiwgYXJtNjRdCi0gIC0gS1ZNX0dV RVNUREJHX1VTRV9IV19CUDogICAgIHVzaW5nIGhhcmR3YXJlIGJyZWFrcG9pbnRzIFt4ODYsIHMz OTBdCisgIC0gS1ZNX0dVRVNUREJHX1VTRV9IV19CUDogICAgIHVzaW5nIGhhcmR3YXJlIGJyZWFr cG9pbnRzIFt4ODYsIHMzOTAsIGFybTY0XQogICAtIEtWTV9HVUVTVERCR19JTkpFQ1RfREI6ICAg ICBpbmplY3QgREIgdHlwZSBleGNlcHRpb24gW3g4Nl0KICAgLSBLVk1fR1VFU1REQkdfSU5KRUNU X0JQOiAgICAgaW5qZWN0IEJQIHR5cGUgZXhjZXB0aW9uIFt4ODZdCiAgIC0gS1ZNX0dVRVNUREJH X0VYSVRfUEVORElORzogIHRyaWdnZXIgYW4gaW1tZWRpYXRlIGd1ZXN0IGV4aXQgW3MzOTBdCkBA IC0yNjgzLDYgKzI2ODMsMTEgQEAgdXBkYXRlZCB0byB0aGUgY29ycmVjdCAoc3VwcGxpZWQpIHZh bHVlcy4KIFRoZSBzZWNvbmQgcGFydCBvZiB0aGUgc3RydWN0dXJlIGlzIGFyY2hpdGVjdHVyZSBz cGVjaWZpYyBhbmQKIHR5cGljYWxseSBjb250YWlucyBhIHNldCBvZiBkZWJ1ZyByZWdpc3RlcnMu CiAKK0ZvciBhcm02NCB0aGUgbnVtYmVyIG9mIGRlYnVnIHJlZ2lzdGVycyBpcyBpbXBsZW1lbnRh dGlvbiBkZWZpbmVkIGFuZAorY2FuIGJlIGRldGVybWluZWQgYnkgcXVlcnlpbmcgdGhlIEtWTV9D QVBfR1VFU1RfREVCVUdfSFdfQlBTIGFuZAorS1ZNX0NBUF9HVUVTVF9ERUJVR19IV19XUFMgY2Fw YWJpbGl0aWVzIHdoaWNoIHJldHVybnMgYSArdmUgbnVtYmVyCitpbmRpY2F0aW5nIHRoZSBudW1i ZXIgb2Ygc3VwcG9ydGVkIHJlZ2lzdGVycy4KKwogV2hlbiBkZWJ1ZyBldmVudHMgZXhpdCB0aGUg bWFpbiBydW4gbG9vcCB3aXRoIHRoZSByZWFzb24KIEtWTV9FWElUX0RFQlVHIHdpdGggdGhlIGt2 bV9kZWJ1Z19leGl0X2FyY2ggcGFydCBvZiB0aGUga3ZtX3J1bgogc3RydWN0dXJlIGNvbnRhaW5p bmcgYXJjaGl0ZWN0dXJlIHNwZWNpZmljIGRlYnVnIGluZm9ybWF0aW9uLgpkaWZmIC0tZ2l0IGEv YXJjaC9hcm0va3ZtL2FybS5jIGIvYXJjaC9hcm0va3ZtL2FybS5jCmluZGV4IDliM2VkNmQuLjI5 MjAxODUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2t2bS9hcm0uYworKysgYi9hcmNoL2FybS9rdm0v YXJtLmMKQEAgLTI3OSw2ICsyNzksMTAgQEAgaW50IGt2bV9hcmNoX3ZjcHVfaW5pdChzdHJ1Y3Qg a3ZtX3ZjcHUgKnZjcHUpCiAJLyogU2V0IHVwIHRoZSB0aW1lciAqLwogCWt2bV90aW1lcl92Y3B1 X2luaXQodmNwdSk7CiAKKwkvKiBTZXQgdGhlIGRlYnVnIHJlZ2lzdGVycyB0byBiZSB0aGUgZ3Vl c3RzICovCisJdmNwdS0+YXJjaC5kZWJ1Z19wdHIgPSAoc3RydWN0IGt2bV9ndWVzdF9kZWJ1Z19h cmNoICopCisJCQkJJnZjcHVfc3lzX3JlZyh2Y3B1LCBEQkdCQ1IwX0VMMSk7CisKIAlyZXR1cm4g MDsKIH0KIApAQCAtMzA0LDYgKzMwOCw3IEBAIHZvaWQga3ZtX2FyY2hfdmNwdV9wdXQoc3RydWN0 IGt2bV92Y3B1ICp2Y3B1KQogCiAjZGVmaW5lIEtWTV9HVUVTVERCR19WQUxJRF9NQVNLIChLVk1f R1VFU1REQkdfRU5BQkxFIHwgICAgXAogCQkJICAgIEtWTV9HVUVTVERCR19VU0VfU1dfQlAgfCBc CisJCQkgICAgS1ZNX0dVRVNUREJHX1VTRV9IV19CUCB8IFwKIAkJCSAgICBLVk1fR1VFU1REQkdf U0lOR0xFU1RFUCkKIAogLyoqCkBAIC0zMjQsNiArMzI5LDEyIEBAIGludCBrdm1fYXJjaF92Y3B1 X2lvY3RsX3NldF9ndWVzdF9kZWJ1ZyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsCiAKIAlpZiAoZGJn LT5jb250cm9sICYgS1ZNX0dVRVNUREJHX0VOQUJMRSkgewogCQl2Y3B1LT5ndWVzdF9kZWJ1ZyA9 IGRiZy0+Y29udHJvbDsKKworCQkvKiBIYXJkd2FyZSBhc3Npc3RlZCBCcmVhayBhbmQgV2F0Y2gg cG9pbnRzICovCisJCWlmICh2Y3B1LT5ndWVzdF9kZWJ1ZyAmIEtWTV9HVUVTVERCR19VU0VfSFdf QlApIHsKKwkJCXZjcHUtPmFyY2guZXh0ZXJuYWxfZGVidWdfc3RhdGUgPSBkYmctPmFyY2g7CisJ CX0KKwogCX0gZWxzZSB7CiAJCS8qIElmIG5vdCBlbmFibGVkIGNsZWFyIGFsbCBmbGFncyAqLwog CQl2Y3B1LT5ndWVzdF9kZWJ1ZyA9IDA7CmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1ZGUv YXNtL2h3X2JyZWFrcG9pbnQuaCBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20vaHdfYnJlYWtwb2lu dC5oCmluZGV4IDUyYjQ4NGIuLmM0NTA1NTIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQvaW5jbHVk ZS9hc20vaHdfYnJlYWtwb2ludC5oCisrKyBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20vaHdfYnJl YWtwb2ludC5oCkBAIC0xMzAsNiArMTMwLDE4IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBwdHJhY2Vf aHdfY29weV90aHJlYWQoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQogfQogI2VuZGlmCiAKKy8q IERldGVybWluZSBudW1iZXIgb2YgQlJQIHJlZ2lzdGVycyBhdmFpbGFibGUuICovCitzdGF0aWMg aW5saW5lIGludCBnZXRfbnVtX2JycHModm9pZCkKK3sKKwlyZXR1cm4gKChyZWFkX2NwdWlkKElE X0FBNjRERlIwX0VMMSkgPj4gMTIpICYgMHhmKSArIDE7Cit9CisKKy8qIERldGVybWluZSBudW1i ZXIgb2YgV1JQIHJlZ2lzdGVycyBhdmFpbGFibGUuICovCitzdGF0aWMgaW5saW5lIGludCBnZXRf bnVtX3dycHModm9pZCkKK3sKKwlyZXR1cm4gKChyZWFkX2NwdWlkKElEX0FBNjRERlIwX0VMMSkg Pj4gMjApICYgMHhmKSArIDE7Cit9CisKIGV4dGVybiBzdHJ1Y3QgcG11IHBlcmZfb3BzX2JwOwog CiAjZW5kaWYJLyogX19LRVJORUxfXyAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRl L2FzbS9rdm1faG9zdC5oIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1faG9zdC5oCmluZGV4 IGI2MGZhN2EuLmE0NGZiMzIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3Zt X2hvc3QuaAorKysgYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKQEAgLTEwOCw5 ICsxMDgsMTggQEAgc3RydWN0IGt2bV92Y3B1X2FyY2ggewogCS8qIEV4Y2VwdGlvbiBJbmZvcm1h dGlvbiAqLwogCXN0cnVjdCBrdm1fdmNwdV9mYXVsdF9pbmZvIGZhdWx0OwogCi0JLyogRGVidWcg c3RhdGUgKi8KKwkvKiBHdWVzdCBkZWJ1ZyBzdGF0ZSAqLwogCXU2NCBkZWJ1Z19mbGFnczsKIAor CS8qCisJICogRm9yIGRlYnVnZ2luZyB0aGUgZ3Vlc3Qgd2UgbmVlZCB0byBrZWVwIGEgc2V0IG9m IGRlYnVnCisJICogcmVnaXN0ZXJzIHdoaWNoIGNhbiBvdmVycmlkZSB0aGUgZ3Vlc3RzIG93biBk ZWJ1ZyBzdGF0ZQorCSAqIHdoaWxlIGJlaW5nIHVzZWQuIFRoZXNlIGFyZSBzZXQgdmlhIHRoZSBL Vk1fU0VUX0dVRVNUX0RFQlVHCisJICogaW9jdGwuCisJICovCisJc3RydWN0IGt2bV9ndWVzdF9k ZWJ1Z19hcmNoICpkZWJ1Z19wdHI7CisJc3RydWN0IGt2bV9ndWVzdF9kZWJ1Z19hcmNoIGV4dGVy bmFsX2RlYnVnX3N0YXRlOworCiAJLyogUG9pbnRlciB0byBob3N0IENQVSBjb250ZXh0ICovCiAJ a3ZtX2NwdV9jb250ZXh0X3QgKmhvc3RfY3B1X2NvbnRleHQ7CiAKZGlmZiAtLWdpdCBhL2FyY2gv YXJtNjQvaW5jbHVkZS91YXBpL2FzbS9rdm0uaCBiL2FyY2gvYXJtNjQvaW5jbHVkZS91YXBpL2Fz bS9rdm0uaAppbmRleCAwNDk1N2Q3Li45OGU4MmVmIDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2lu Y2x1ZGUvdWFwaS9hc20va3ZtLmgKKysrIGIvYXJjaC9hcm02NC9pbmNsdWRlL3VhcGkvYXNtL2t2 bS5oCkBAIC0xMjEsNyArMTIxLDcgQEAgc3RydWN0IGt2bV9ndWVzdF9kZWJ1Z19hcmNoIHsKIAog c3RydWN0IGt2bV9kZWJ1Z19leGl0X2FyY2ggewogCV9fdTMyIGhzcjsKLQlfX3U2NCBmYXI7CisJ X191NjQgZmFyOwkvKiB1c2VkIGZvciB3YXRjaHBvaW50cyAqLwogfTsKIAogc3RydWN0IGt2bV9z eW5jX3JlZ3MgewpkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9rZXJuZWwvYXNtLW9mZnNldHMuYyBi L2FyY2gvYXJtNjQva2VybmVsL2FzbS1vZmZzZXRzLmMKaW5kZXggY2U3YjdkZC4uNjcxYWIxMyAx MDA2NDQKLS0tIGEvYXJjaC9hcm02NC9rZXJuZWwvYXNtLW9mZnNldHMuYworKysgYi9hcmNoL2Fy bTY0L2tlcm5lbC9hc20tb2Zmc2V0cy5jCkBAIC0xMTYsNiArMTE2LDcgQEAgaW50IG1haW4odm9p ZCkKICAgREVGSU5FKFZDUFVfRkFSX0VMMiwJCW9mZnNldG9mKHN0cnVjdCBrdm1fdmNwdSwgYXJj aC5mYXVsdC5mYXJfZWwyKSk7CiAgIERFRklORShWQ1BVX0hQRkFSX0VMMiwJb2Zmc2V0b2Yoc3Ry dWN0IGt2bV92Y3B1LCBhcmNoLmZhdWx0LmhwZmFyX2VsMikpOwogICBERUZJTkUoVkNQVV9ERUJV R19GTEFHUywJb2Zmc2V0b2Yoc3RydWN0IGt2bV92Y3B1LCBhcmNoLmRlYnVnX2ZsYWdzKSk7Cisg IERFRklORShWQ1BVX0RFQlVHX1BUUiwJb2Zmc2V0b2Yoc3RydWN0IGt2bV92Y3B1LCBhcmNoLmRl YnVnX3B0cikpOwogICBERUZJTkUoREVCVUdfQkNSLCAJCW9mZnNldG9mKHN0cnVjdCBrdm1fZ3Vl c3RfZGVidWdfYXJjaCwgZGJnX2JjcikpOwogICBERUZJTkUoREVCVUdfQlZSLCAJCW9mZnNldG9m KHN0cnVjdCBrdm1fZ3Vlc3RfZGVidWdfYXJjaCwgZGJnX2J2cikpOwogICBERUZJTkUoREVCVUdf V0NSLCAJCW9mZnNldG9mKHN0cnVjdCBrdm1fZ3Vlc3RfZGVidWdfYXJjaCwgZGJnX3djcikpOwpk aWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9rZXJuZWwvaHdfYnJlYWtwb2ludC5jIGIvYXJjaC9hcm02 NC9rZXJuZWwvaHdfYnJlYWtwb2ludC5jCmluZGV4IGU3ZDkzNGQuLjNhNDFiYmYgMTAwNjQ0Ci0t LSBhL2FyY2gvYXJtNjQva2VybmVsL2h3X2JyZWFrcG9pbnQuYworKysgYi9hcmNoL2FybTY0L2tl cm5lbC9od19icmVha3BvaW50LmMKQEAgLTQ5LDE4ICs0OSw2IEBAIHN0YXRpYyBERUZJTkVfUEVS X0NQVShpbnQsIHN0ZXBwaW5nX2tlcm5lbF9icCk7CiBzdGF0aWMgaW50IGNvcmVfbnVtX2JycHM7 CiBzdGF0aWMgaW50IGNvcmVfbnVtX3dycHM7CiAKLS8qIERldGVybWluZSBudW1iZXIgb2YgQlJQ IHJlZ2lzdGVycyBhdmFpbGFibGUuICovCi1zdGF0aWMgaW50IGdldF9udW1fYnJwcyh2b2lkKQot ewotCXJldHVybiAoKHJlYWRfY3B1aWQoSURfQUE2NERGUjBfRUwxKSA+PiAxMikgJiAweGYpICsg MTsKLX0KLQotLyogRGV0ZXJtaW5lIG51bWJlciBvZiBXUlAgcmVnaXN0ZXJzIGF2YWlsYWJsZS4g Ki8KLXN0YXRpYyBpbnQgZ2V0X251bV93cnBzKHZvaWQpCi17Ci0JcmV0dXJuICgocmVhZF9jcHVp ZChJRF9BQTY0REZSMF9FTDEpID4+IDIwKSAmIDB4ZikgKyAxOwotfQotCiBpbnQgaHdfYnJlYWtw b2ludF9zbG90cyhpbnQgdHlwZSkKIHsKIAkvKgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9rdm0v ZGVidWcuYyBiL2FyY2gvYXJtNjQva3ZtL2RlYnVnLmMKaW5kZXggMTkzNDZlOC4uMWFiNjNkZCAx MDA2NDQKLS0tIGEvYXJjaC9hcm02NC9rdm0vZGVidWcuYworKysgYi9hcmNoL2FybTY0L2t2bS9k ZWJ1Zy5jCkBAIC05OSwxMiArOTksNiBAQCB2b2lkIGt2bV9hcm1fc2V0dXBfZGVidWcoc3RydWN0 IGt2bV92Y3B1ICp2Y3B1KQogCQkJCU1EQ1JfRUwyX1REUkEgfAogCQkJCU1EQ1JfRUwyX1RET1NB KTsKIAotCS8qIFRyYXAgb24gYWNjZXNzIHRvIGRlYnVnIHJlZ2lzdGVycz8gKi8KLQlpZiAodHJh cF9kZWJ1ZykKLQkJdmNwdS0+YXJjaC5tZGNyX2VsMiB8PSBNRENSX0VMMl9UREE7Ci0JZWxzZQot CQl2Y3B1LT5hcmNoLm1kY3JfZWwyICY9IH5NRENSX0VMMl9UREE7Ci0KIAkvKiBJcyBHdWVzdCBk ZWJ1Z2dpbmcgaW4gZWZmZWN0PyAqLwogCWlmICh2Y3B1LT5ndWVzdF9kZWJ1ZykgewogCQl2Y3B1 LT5hcmNoLm1kY3JfZWwyIHw9IE1EQ1JfRUwyX1RERTsKQEAgLTEyOCwxNCArMTIyLDU0IEBAIHZv aWQga3ZtX2FybV9zZXR1cF9kZWJ1ZyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCiAJCQl2Y3B1X3N5 c19yZWcodmNwdSwgTURTQ1JfRUwxKSAmPSB+REJHX01EU0NSX1NTOwogCQl9CiAKKwkJLyoKKwkJ ICogSFcgQnJlYWsvV2F0Y2ggcG9pbnRzCisJCSAqCisJCSAqIFdlIHNpbXBseSBzd2l0Y2ggdGhl IGRlYnVnX3B0ciB0byBwb2ludCB0byBvdXIgbmV3CisJCSAqIGV4dGVybmFsX2RlYnVnX3N0YXRl IHdoaWNoIGhhcyBiZWVuIHBvcHVsYXRlZCBieSB0aGUKKwkJICogZGVidWcgaW9jdGwuIFRoZSBl eGlzdGluZyBLVk1fQVJNNjRfREVCVUdfRElSVFkKKwkJICogbWVjaGFuaXNtIGVuc3VyZXMgdGhl IHJlZ2lzdGVycyBhcmUgdXBkYXRlZCBvbiB0aGUKKwkJICogd29ybGQgc3dpdGNoLgorCQkgKi8K KwkJaWYgKHZjcHUtPmd1ZXN0X2RlYnVnICYgS1ZNX0dVRVNUREJHX1VTRV9IV19CUCkgeworCisJ CQl2Y3B1X3N5c19yZWcodmNwdSwgTURTQ1JfRUwxKSB8PQorCQkJCShEQkdfTURTQ1JfS0RFIHwg REJHX01EU0NSX01ERSk7CisKKwkJCXZjcHUtPmFyY2guZGVidWdfcHRyID0gJnZjcHUtPmFyY2gu ZXh0ZXJuYWxfZGVidWdfc3RhdGU7CisJCQl2Y3B1LT5hcmNoLmRlYnVnX2ZsYWdzIHw9IEtWTV9B Uk02NF9ERUJVR19ESVJUWTsKKwkJCXRyYXBfZGVidWcgPSB0cnVlOworCQl9CisKIAl9IGVsc2Ug ewogCQkvKiBEZWJ1ZyBvcGVyYXRpb25zIGNhbiBnbyBzdHJhaWdodCB0byB0aGUgZ3Vlc3QgKi8K IAkJdmNwdS0+YXJjaC5tZGNyX2VsMiAmPSB+TURDUl9FTDJfVERFOwogCX0KKworCS8qCisJICog SWYgdGhlIGd1ZXN0IGRlYnVnIHJlZ2lzdGVyIHN0YXRlIGlzIGRpcnR5ICh0aGUgZ3Vlc3QgaXMK KwkgKiBhY3RpdmVseSBhY2Nlc3NpbmcgdGhlbSksIHRoZW4gd2UgY29udGV4dC1zd2l0Y2ggdGhl CisJICogcmVnaXN0ZXJzIGluIEVMMi4gT3RoZXJ3aXNlLCB3ZSB0cmFwLWFuZC1lbXVsYXRlIGFs bCBndWVzdAorCSAqIGFjY2Vzc2VzIHRvIHRoZW0uCisJICovCisJaWYgKHRyYXBfZGVidWcpCisJ CXZjcHUtPmFyY2gubWRjcl9lbDIgfD0gTURDUl9FTDJfVERBOworCWVsc2UKKwkJdmNwdS0+YXJj aC5tZGNyX2VsMiAmPSB+TURDUl9FTDJfVERBOwogfQogCiB2b2lkIGt2bV9hcm1fY2xlYXJfZGVi dWcoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQogewotCWlmICh2Y3B1LT5ndWVzdF9kZWJ1ZykKKwlp ZiAodmNwdS0+Z3Vlc3RfZGVidWcpIHsKIAkJcmVzdG9yZV9ndWVzdF9kZWJ1Z19yZWdzKHZjcHUp OworCisJCS8qCisJCSAqIElmIHdlIHdlcmUgdXNpbmcgSFcgZGVidWcgd2UgbmVlZCB0byByZXN0 b3JlIHRoZQorCQkgKiBkZWJ1Z19wdHIgdG8gdGhlIGd1ZXN0IGRlYnVnIHN0YXRlLgorCQkgKi8K KwkJaWYgKHZjcHUtPmd1ZXN0X2RlYnVnICYgS1ZNX0dVRVNUREJHX1VTRV9IV19CUCkgeworCQkJ dmNwdS0+YXJjaC5kZWJ1Z19wdHIgPSAoc3RydWN0IGt2bV9ndWVzdF9kZWJ1Z19hcmNoICopCisJ CQkJJnZjcHVfc3lzX3JlZyh2Y3B1LCBEQkdCQ1IwX0VMMSk7CisJCX0KKwl9CiB9CmRpZmYgLS1n aXQgYS9hcmNoL2FybTY0L2t2bS9oYW5kbGVfZXhpdC5jIGIvYXJjaC9hcm02NC9rdm0vaGFuZGxl X2V4aXQuYwppbmRleCBlOWRlMTNlLi42OGEwNzU5IDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2t2 bS9oYW5kbGVfZXhpdC5jCisrKyBiL2FyY2gvYXJtNjQva3ZtL2hhbmRsZV9leGl0LmMKQEAgLTEw Myw3ICsxMDMsMTEgQEAgc3RhdGljIGludCBrdm1faGFuZGxlX2d1ZXN0X2RlYnVnKHN0cnVjdCBr dm1fdmNwdSAqdmNwdSwgc3RydWN0IGt2bV9ydW4gKnJ1bikKIAlydW4tPmRlYnVnLmFyY2guaHNy ID0gaHNyOwogCiAJc3dpdGNoIChoc3IgPj4gRVNSX0VMeF9FQ19TSElGVCkgeworCWNhc2UgRVNS X0VMeF9FQ19XQVRDSFBUX0xPVzoKKwkJcnVuLT5kZWJ1Zy5hcmNoLmZhciA9IHZjcHUtPmFyY2gu ZmF1bHQuZmFyX2VsMjsKKwkJLyogZmFsbCB0aHJvdWdoICovCiAJY2FzZSBFU1JfRUx4X0VDX1NP RlRTVFBfTE9XOgorCWNhc2UgRVNSX0VMeF9FQ19CUkVBS1BUX0xPVzoKIAljYXNlIEVTUl9FTHhf RUNfQktQVDMyOgogCWNhc2UgRVNSX0VMeF9FQ19CUks2NDoKIAkJYnJlYWs7CkBAIC0xMzIsNiAr MTM2LDggQEAgc3RhdGljIGV4aXRfaGFuZGxlX2ZuIGFybV9leGl0X2hhbmRsZXJzW10gPSB7CiAJ W0VTUl9FTHhfRUNfSUFCVF9MT1ddCT0ga3ZtX2hhbmRsZV9ndWVzdF9hYm9ydCwKIAlbRVNSX0VM eF9FQ19EQUJUX0xPV10JPSBrdm1faGFuZGxlX2d1ZXN0X2Fib3J0LAogCVtFU1JfRUx4X0VDX1NP RlRTVFBfTE9XXT0ga3ZtX2hhbmRsZV9ndWVzdF9kZWJ1ZywKKwlbRVNSX0VMeF9FQ19XQVRDSFBU X0xPV109IGt2bV9oYW5kbGVfZ3Vlc3RfZGVidWcsCisJW0VTUl9FTHhfRUNfQlJFQUtQVF9MT1dd PSBrdm1faGFuZGxlX2d1ZXN0X2RlYnVnLAogCVtFU1JfRUx4X0VDX0JLUFQzMl0JPSBrdm1faGFu ZGxlX2d1ZXN0X2RlYnVnLAogCVtFU1JfRUx4X0VDX0JSSzY0XQk9IGt2bV9oYW5kbGVfZ3Vlc3Rf ZGVidWcsCiB9OwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9rdm0vaHlwLlMgYi9hcmNoL2FybTY0 L2t2bS9oeXAuUwppbmRleCBkZDUxZmIxLi45MjFkMjQ4IDEwMDY0NAotLS0gYS9hcmNoL2FybTY0 L2t2bS9oeXAuUworKysgYi9hcmNoL2FybTY0L2t2bS9oeXAuUwpAQCAtNzA2LDcgKzcwNiw4IEBA IEVOVFJZKF9fa3ZtX3ZjcHVfcnVuKQogCWJsIF9fcmVzdG9yZV9mcHNpbWQKIAogCXNraXBfZGVi dWdfc3RhdGUgeDMsIDFmCi0JYWRkCXgzLCB4MiwgI0NQVV9TWVNSRUdfT0ZGU0VUKERCR0JDUjBf RUwxKQorCWxkcgl4MywgW3gwLCAjVkNQVV9ERUJVR19QVFJdCisJa2Vybl9oeXBfdmEgeDMKIAli bAlfX3Jlc3RvcmVfZGVidWcKIDE6CiAJcmVzdG9yZV9ndWVzdF8zMmJpdF9zdGF0ZQpAQCAtNzI3 LDcgKzcyOCw4IEBAIF9fa3ZtX3ZjcHVfcmV0dXJuOgogCWJsIF9fc2F2ZV9zeXNyZWdzCiAKIAlz a2lwX2RlYnVnX3N0YXRlIHgzLCAxZgotCWFkZAl4MywgeDIsICNDUFVfU1lTUkVHX09GRlNFVChE QkdCQ1IwX0VMMSkKKwlsZHIJeDMsIFt4MCwgI1ZDUFVfREVCVUdfUFRSXQorCWtlcm5faHlwX3Zh IHgzCiAJYmwJX19zYXZlX2RlYnVnCiAxOgogCXNhdmVfZ3Vlc3RfMzJiaXRfc3RhdGUKZGlmZiAt LWdpdCBhL2FyY2gvYXJtNjQva3ZtL3Jlc2V0LmMgYi9hcmNoL2FybTY0L2t2bS9yZXNldC5jCmlu ZGV4IDBiNDMyNjUuLjIxZDVhNjIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQva3ZtL3Jlc2V0LmMK KysrIGIvYXJjaC9hcm02NC9rdm0vcmVzZXQuYwpAQCAtNTYsNiArNTYsMTIgQEAgc3RhdGljIGJv b2wgY3B1X2hhc18zMmJpdF9lbDEodm9pZCkKIAlyZXR1cm4gISEocGZyMCAmIDB4MjApOwogfQog CisvKioKKyAqIGt2bV9hcmNoX2Rldl9pb2N0bF9jaGVja19leHRlbnNpb24KKyAqCisgKiBXZSBj dXJyZW50bHkgYXNzdW1lIHRoYXQgdGhlIG51bWJlciBvZiBIVyByZWdpc3RlcnMgaXMgdW5pZm9y bQorICogYWNyb3NzIGFsbCBDUFVzIChzZWUgY3B1aW5mb19zYW5pdHlfY2hlY2spLgorICovCiBp bnQga3ZtX2FyY2hfZGV2X2lvY3RsX2NoZWNrX2V4dGVuc2lvbihsb25nIGV4dCkKIHsKIAlpbnQg cjsKQEAgLTY0LDYgKzcwLDEyIEBAIGludCBrdm1fYXJjaF9kZXZfaW9jdGxfY2hlY2tfZXh0ZW5z aW9uKGxvbmcgZXh0KQogCWNhc2UgS1ZNX0NBUF9BUk1fRUwxXzMyQklUOgogCQlyID0gY3B1X2hh c18zMmJpdF9lbDEoKTsKIAkJYnJlYWs7CisJY2FzZSBLVk1fQ0FQX0dVRVNUX0RFQlVHX0hXX0JQ UzoKKwkJciA9IGdldF9udW1fYnJwcygpOworCQlicmVhazsKKwljYXNlIEtWTV9DQVBfR1VFU1Rf REVCVUdfSFdfV1BTOgorCQlyICA9IGdldF9udW1fd3JwcygpOworCQlicmVhazsKIAlkZWZhdWx0 OgogCQlyID0gMDsKIAl9CmRpZmYgLS1naXQgYS9pbmNsdWRlL3VhcGkvbGludXgva3ZtLmggYi9p bmNsdWRlL3VhcGkvbGludXgva3ZtLmgKaW5kZXggM2I2MjUyZS4uOTIzYzJhYSAxMDA2NDQKLS0t IGEvaW5jbHVkZS91YXBpL2xpbnV4L2t2bS5oCisrKyBiL2luY2x1ZGUvdWFwaS9saW51eC9rdm0u aApAQCAtODI1LDYgKzgyNSw4IEBAIHN0cnVjdCBrdm1fcHBjX3NtbXVfaW5mbyB7CiAjZGVmaW5l IEtWTV9DQVBfUzM5MF9JTkpFQ1RfSVJRIDExMwogI2RlZmluZSBLVk1fQ0FQX1MzOTBfSVJRX1NU QVRFIDExNAogI2RlZmluZSBLVk1fQ0FQX1BQQ19IV1JORyAxMTUKKyNkZWZpbmUgS1ZNX0NBUF9H VUVTVF9ERUJVR19IV19CUFMgMTE2CisjZGVmaW5lIEtWTV9DQVBfR1VFU1RfREVCVUdfSFdfV1BT IDExNwogCiAjaWZkZWYgS1ZNX0NBUF9JUlFfUk9VVElORwogCi0tIAoyLjMuNQoKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18Ka3ZtYXJtIG1haWxpbmcgbGlz dAprdm1hcm1AbGlzdHMuY3MuY29sdW1iaWEuZWR1Cmh0dHBzOi8vbGlzdHMuY3MuY29sdW1iaWEu ZWR1L21haWxtYW4vbGlzdGluZm8va3ZtYXJtCg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: alex.bennee@linaro.org (=?UTF-8?q?Alex=20Benn=C3=A9e?=) Date: Thu, 7 May 2015 10:07:12 +0100 Subject: [PATCH v3 09/12] KVM: arm64: guest debug, HW assisted debug support In-Reply-To: <1430929407-3487-1-git-send-email-alex.bennee@linaro.org> References: <1430929407-3487-1-git-send-email-alex.bennee@linaro.org> Message-ID: <1430989647-22501-2-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 userspace to control the HW debug registers for guest debug. In the debug ioctl we copy the IMPDEF defined number of registers into a new register set called host_debug_state. There is now a new vcpu parameter called debug_ptr which selects which register set is to copied into the real registers when world switch occurs. I've moved some helper functions into the hw_breakpoint.h header for re-use. As with single step we need to tweak the guest registers to enable the exceptions so we need to save and restore those bits. Two new capabilities have been added to the KVM_EXTENSION ioctl to allow userspace to query the number of hardware break and watch points available on the host hardware. Signed-off-by: Alex Benn?e --- v2 - switched to C setup - replace host debug registers directly into context - minor tweak to api docs - setup right register for debug - add FAR_EL2 to debug exit structure - add support for trapping debug register access v3 - remove stray trace statement - fix spacing around operators (various) - clean-up usage of trap_debug - introduce debug_ptr, replace excessive memcpy stuff - don't use memcpy in ioctl, just assign - update cap ioctl documentation - reword a number comments - rename host_debug_state->external_debug_state diff --git a/Documentation/virtual/kvm/api.txt b/Documentation/virtual/kvm/api.txt index 5ef937c..419f7a8 100644 --- a/Documentation/virtual/kvm/api.txt +++ b/Documentation/virtual/kvm/api.txt @@ -2668,7 +2668,7 @@ The top 16 bits of the control field are architecture specific control flags which can include the following: - KVM_GUESTDBG_USE_SW_BP: using software breakpoints [x86, arm64] - - KVM_GUESTDBG_USE_HW_BP: using hardware breakpoints [x86, s390] + - KVM_GUESTDBG_USE_HW_BP: using hardware breakpoints [x86, s390, arm64] - KVM_GUESTDBG_INJECT_DB: inject DB type exception [x86] - KVM_GUESTDBG_INJECT_BP: inject BP type exception [x86] - KVM_GUESTDBG_EXIT_PENDING: trigger an immediate guest exit [s390] @@ -2683,6 +2683,11 @@ updated to the correct (supplied) values. The second part of the structure is architecture specific and typically contains a set of debug registers. +For arm64 the number of debug registers is implementation defined and +can be determined by querying the KVM_CAP_GUEST_DEBUG_HW_BPS and +KVM_CAP_GUEST_DEBUG_HW_WPS capabilities which returns a +ve number +indicating the number of supported registers. + When debug events exit the main run loop with the reason KVM_EXIT_DEBUG with the kvm_debug_exit_arch part of the kvm_run structure containing architecture specific debug information. diff --git a/arch/arm/kvm/arm.c b/arch/arm/kvm/arm.c index 9b3ed6d..2920185 100644 --- a/arch/arm/kvm/arm.c +++ b/arch/arm/kvm/arm.c @@ -279,6 +279,10 @@ int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) /* Set up the timer */ kvm_timer_vcpu_init(vcpu); + /* Set the debug registers to be the guests */ + vcpu->arch.debug_ptr = (struct kvm_guest_debug_arch *) + &vcpu_sys_reg(vcpu, DBGBCR0_EL1); + return 0; } @@ -304,6 +308,7 @@ void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) #define KVM_GUESTDBG_VALID_MASK (KVM_GUESTDBG_ENABLE | \ KVM_GUESTDBG_USE_SW_BP | \ + KVM_GUESTDBG_USE_HW_BP | \ KVM_GUESTDBG_SINGLESTEP) /** @@ -324,6 +329,12 @@ int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, if (dbg->control & KVM_GUESTDBG_ENABLE) { vcpu->guest_debug = dbg->control; + + /* Hardware assisted Break and Watch points */ + if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) { + vcpu->arch.external_debug_state = dbg->arch; + } + } else { /* If not enabled clear all flags */ vcpu->guest_debug = 0; diff --git a/arch/arm64/include/asm/hw_breakpoint.h b/arch/arm64/include/asm/hw_breakpoint.h index 52b484b..c450552 100644 --- a/arch/arm64/include/asm/hw_breakpoint.h +++ b/arch/arm64/include/asm/hw_breakpoint.h @@ -130,6 +130,18 @@ static inline void ptrace_hw_copy_thread(struct task_struct *task) } #endif +/* Determine number of BRP registers available. */ +static inline int get_num_brps(void) +{ + return ((read_cpuid(ID_AA64DFR0_EL1) >> 12) & 0xf) + 1; +} + +/* Determine number of WRP registers available. */ +static inline int get_num_wrps(void) +{ + return ((read_cpuid(ID_AA64DFR0_EL1) >> 20) & 0xf) + 1; +} + extern struct pmu perf_ops_bp; #endif /* __KERNEL__ */ diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h index b60fa7a..a44fb32 100644 --- a/arch/arm64/include/asm/kvm_host.h +++ b/arch/arm64/include/asm/kvm_host.h @@ -108,9 +108,18 @@ struct kvm_vcpu_arch { /* Exception Information */ struct kvm_vcpu_fault_info fault; - /* Debug state */ + /* Guest debug state */ u64 debug_flags; + /* + * For debugging the guest we need to keep a set of debug + * registers which can override the guests own debug state + * while being used. These are set via the KVM_SET_GUEST_DEBUG + * ioctl. + */ + struct kvm_guest_debug_arch *debug_ptr; + struct kvm_guest_debug_arch external_debug_state; + /* Pointer to host CPU context */ kvm_cpu_context_t *host_cpu_context; diff --git a/arch/arm64/include/uapi/asm/kvm.h b/arch/arm64/include/uapi/asm/kvm.h index 04957d7..98e82ef 100644 --- a/arch/arm64/include/uapi/asm/kvm.h +++ b/arch/arm64/include/uapi/asm/kvm.h @@ -121,7 +121,7 @@ struct kvm_guest_debug_arch { struct kvm_debug_exit_arch { __u32 hsr; - __u64 far; + __u64 far; /* used for watchpoints */ }; struct kvm_sync_regs { diff --git a/arch/arm64/kernel/asm-offsets.c b/arch/arm64/kernel/asm-offsets.c index ce7b7dd..671ab13 100644 --- a/arch/arm64/kernel/asm-offsets.c +++ b/arch/arm64/kernel/asm-offsets.c @@ -116,6 +116,7 @@ int main(void) DEFINE(VCPU_FAR_EL2, offsetof(struct kvm_vcpu, arch.fault.far_el2)); DEFINE(VCPU_HPFAR_EL2, offsetof(struct kvm_vcpu, arch.fault.hpfar_el2)); DEFINE(VCPU_DEBUG_FLAGS, offsetof(struct kvm_vcpu, arch.debug_flags)); + DEFINE(VCPU_DEBUG_PTR, offsetof(struct kvm_vcpu, arch.debug_ptr)); DEFINE(DEBUG_BCR, offsetof(struct kvm_guest_debug_arch, dbg_bcr)); DEFINE(DEBUG_BVR, offsetof(struct kvm_guest_debug_arch, dbg_bvr)); DEFINE(DEBUG_WCR, offsetof(struct kvm_guest_debug_arch, dbg_wcr)); diff --git a/arch/arm64/kernel/hw_breakpoint.c b/arch/arm64/kernel/hw_breakpoint.c index e7d934d..3a41bbf 100644 --- a/arch/arm64/kernel/hw_breakpoint.c +++ b/arch/arm64/kernel/hw_breakpoint.c @@ -49,18 +49,6 @@ static DEFINE_PER_CPU(int, stepping_kernel_bp); static int core_num_brps; static int core_num_wrps; -/* Determine number of BRP registers available. */ -static int get_num_brps(void) -{ - return ((read_cpuid(ID_AA64DFR0_EL1) >> 12) & 0xf) + 1; -} - -/* Determine number of WRP registers available. */ -static int get_num_wrps(void) -{ - return ((read_cpuid(ID_AA64DFR0_EL1) >> 20) & 0xf) + 1; -} - int hw_breakpoint_slots(int type) { /* diff --git a/arch/arm64/kvm/debug.c b/arch/arm64/kvm/debug.c index 19346e8..1ab63dd 100644 --- a/arch/arm64/kvm/debug.c +++ b/arch/arm64/kvm/debug.c @@ -99,12 +99,6 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu) MDCR_EL2_TDRA | MDCR_EL2_TDOSA); - /* Trap on access to debug registers? */ - if (trap_debug) - vcpu->arch.mdcr_el2 |= MDCR_EL2_TDA; - else - vcpu->arch.mdcr_el2 &= ~MDCR_EL2_TDA; - /* Is Guest debugging in effect? */ if (vcpu->guest_debug) { vcpu->arch.mdcr_el2 |= MDCR_EL2_TDE; @@ -128,14 +122,54 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu) vcpu_sys_reg(vcpu, MDSCR_EL1) &= ~DBG_MDSCR_SS; } + /* + * HW Break/Watch points + * + * We simply switch the debug_ptr to point to our new + * external_debug_state which has been populated by the + * debug ioctl. The existing KVM_ARM64_DEBUG_DIRTY + * mechanism ensures the registers are updated on the + * world switch. + */ + if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) { + + vcpu_sys_reg(vcpu, MDSCR_EL1) |= + (DBG_MDSCR_KDE | DBG_MDSCR_MDE); + + vcpu->arch.debug_ptr = &vcpu->arch.external_debug_state; + vcpu->arch.debug_flags |= KVM_ARM64_DEBUG_DIRTY; + trap_debug = true; + } + } else { /* Debug operations can go straight to the guest */ vcpu->arch.mdcr_el2 &= ~MDCR_EL2_TDE; } + + /* + * If the guest debug register state is dirty (the guest is + * actively accessing them), then we context-switch the + * registers in EL2. Otherwise, we trap-and-emulate all guest + * accesses to them. + */ + if (trap_debug) + vcpu->arch.mdcr_el2 |= MDCR_EL2_TDA; + else + vcpu->arch.mdcr_el2 &= ~MDCR_EL2_TDA; } void kvm_arm_clear_debug(struct kvm_vcpu *vcpu) { - if (vcpu->guest_debug) + if (vcpu->guest_debug) { restore_guest_debug_regs(vcpu); + + /* + * If we were using HW debug we need to restore the + * debug_ptr to the guest debug state. + */ + if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) { + vcpu->arch.debug_ptr = (struct kvm_guest_debug_arch *) + &vcpu_sys_reg(vcpu, DBGBCR0_EL1); + } + } } diff --git a/arch/arm64/kvm/handle_exit.c b/arch/arm64/kvm/handle_exit.c index e9de13e..68a0759 100644 --- a/arch/arm64/kvm/handle_exit.c +++ b/arch/arm64/kvm/handle_exit.c @@ -103,7 +103,11 @@ 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_WATCHPT_LOW: + run->debug.arch.far = vcpu->arch.fault.far_el2; + /* fall through */ case ESR_ELx_EC_SOFTSTP_LOW: + case ESR_ELx_EC_BREAKPT_LOW: case ESR_ELx_EC_BKPT32: case ESR_ELx_EC_BRK64: break; @@ -132,6 +136,8 @@ static exit_handle_fn arm_exit_handlers[] = { [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_WATCHPT_LOW]= kvm_handle_guest_debug, + [ESR_ELx_EC_BREAKPT_LOW]= kvm_handle_guest_debug, [ESR_ELx_EC_BKPT32] = kvm_handle_guest_debug, [ESR_ELx_EC_BRK64] = kvm_handle_guest_debug, }; diff --git a/arch/arm64/kvm/hyp.S b/arch/arm64/kvm/hyp.S index dd51fb1..921d248 100644 --- a/arch/arm64/kvm/hyp.S +++ b/arch/arm64/kvm/hyp.S @@ -706,7 +706,8 @@ ENTRY(__kvm_vcpu_run) bl __restore_fpsimd skip_debug_state x3, 1f - add x3, x2, #CPU_SYSREG_OFFSET(DBGBCR0_EL1) + ldr x3, [x0, #VCPU_DEBUG_PTR] + kern_hyp_va x3 bl __restore_debug 1: restore_guest_32bit_state @@ -727,7 +728,8 @@ __kvm_vcpu_return: bl __save_sysregs skip_debug_state x3, 1f - add x3, x2, #CPU_SYSREG_OFFSET(DBGBCR0_EL1) + ldr x3, [x0, #VCPU_DEBUG_PTR] + kern_hyp_va x3 bl __save_debug 1: save_guest_32bit_state diff --git a/arch/arm64/kvm/reset.c b/arch/arm64/kvm/reset.c index 0b43265..21d5a62 100644 --- a/arch/arm64/kvm/reset.c +++ b/arch/arm64/kvm/reset.c @@ -56,6 +56,12 @@ static bool cpu_has_32bit_el1(void) return !!(pfr0 & 0x20); } +/** + * kvm_arch_dev_ioctl_check_extension + * + * We currently assume that the number of HW registers is uniform + * across all CPUs (see cpuinfo_sanity_check). + */ int kvm_arch_dev_ioctl_check_extension(long ext) { int r; @@ -64,6 +70,12 @@ int kvm_arch_dev_ioctl_check_extension(long ext) case KVM_CAP_ARM_EL1_32BIT: r = cpu_has_32bit_el1(); break; + case KVM_CAP_GUEST_DEBUG_HW_BPS: + r = get_num_brps(); + break; + case KVM_CAP_GUEST_DEBUG_HW_WPS: + r = get_num_wrps(); + break; default: r = 0; } diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h index 3b6252e..923c2aa 100644 --- a/include/uapi/linux/kvm.h +++ b/include/uapi/linux/kvm.h @@ -825,6 +825,8 @@ struct kvm_ppc_smmu_info { #define KVM_CAP_S390_INJECT_IRQ 113 #define KVM_CAP_S390_IRQ_STATE 114 #define KVM_CAP_PPC_HWRNG 115 +#define KVM_CAP_GUEST_DEBUG_HW_BPS 116 +#define KVM_CAP_GUEST_DEBUG_HW_WPS 117 #ifdef KVM_CAP_IRQ_ROUTING -- 2.3.5