From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.7 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1C8C1C2BBD4 for ; Mon, 7 Dec 2020 20:49:06 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id F207C238A0 for ; Mon, 7 Dec 2020 20:49:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727689AbgLGUs6 (ORCPT ); Mon, 7 Dec 2020 15:48:58 -0500 Received: from mx01.bbu.dsd.mx.bitdefender.com ([91.199.104.161]:42600 "EHLO mx01.bbu.dsd.mx.bitdefender.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727629AbgLGUsz (ORCPT ); Mon, 7 Dec 2020 15:48:55 -0500 Received: from smtp.bitdefender.com (smtp01.buh.bitdefender.com [10.17.80.75]) by mx01.bbu.dsd.mx.bitdefender.com (Postfix) with ESMTPS id D821C305D487; Mon, 7 Dec 2020 22:46:25 +0200 (EET) Received: from localhost.localdomain (unknown [91.199.104.27]) by smtp.bitdefender.com (Postfix) with ESMTPSA id B19083072785; Mon, 7 Dec 2020 22:46:25 +0200 (EET) From: =?UTF-8?q?Adalbert=20Laz=C4=83r?= To: kvm@vger.kernel.org Cc: virtualization@lists.linux-foundation.org, Paolo Bonzini , =?UTF-8?q?Nicu=C8=99or=20C=C3=AE=C8=9Bu?= , =?UTF-8?q?Adalbert=20Laz=C4=83r?= Subject: [PATCH v11 77/81] KVM: introspection: add KVMI_VCPU_CONTROL_SINGLESTEP Date: Mon, 7 Dec 2020 22:46:18 +0200 Message-Id: <20201207204622.15258-78-alazar@bitdefender.com> In-Reply-To: <20201207204622.15258-1-alazar@bitdefender.com> References: <20201207204622.15258-1-alazar@bitdefender.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org From: Nicușor Cîțu The next commit that adds the KVMI_VCPU_EVENT_SINGLESTEP event will make this command more useful. Signed-off-by: Nicușor Cîțu Co-developed-by: Adalbert Lazăr Signed-off-by: Adalbert Lazăr --- Documentation/virt/kvm/kvmi.rst | 33 +++++++++++ arch/x86/kvm/kvmi.c | 14 ++++- arch/x86/kvm/kvmi_msg.c | 56 +++++++++++++++---- arch/x86/kvm/x86.c | 12 +++- include/linux/kvmi_host.h | 7 +++ include/uapi/linux/kvmi.h | 30 ++++++---- .../testing/selftests/kvm/x86_64/kvmi_test.c | 39 +++++++++++++ virt/kvm/introspection/kvmi.c | 22 ++++++++ virt/kvm/introspection/kvmi_int.h | 2 + 9 files changed, 187 insertions(+), 28 deletions(-) diff --git a/Documentation/virt/kvm/kvmi.rst b/Documentation/virt/kvm/kvmi.rst index a3c48cbd8c72..7b5c2c92e47a 100644 --- a/Documentation/virt/kvm/kvmi.rst +++ b/Documentation/virt/kvm/kvmi.rst @@ -791,6 +791,7 @@ exception. * -KVM_EINVAL - the selected vCPU is invalid * -KVM_EINVAL - the padding is not zero * -KVM_EAGAIN - the selected vCPU can't be introspected yet +* -KVM_EBUSY - the vCPU is switched in singlestep mode (*KVMI_VCPU_CONTROL_SINGLESTEP*) * -KVM_EBUSY - another *KVMI_VCPU_INJECT_EXCEPTION*-*KVMI_VCPU_EVENT_TRAP* pair is in progress @@ -1036,6 +1037,38 @@ In order to 'forget' an address, all three bits ('rwx') must be set. * -KVM_EAGAIN - the selected vCPU can't be introspected yet * -KVM_ENOMEM - there is not enough memory to add the page tracking structures +24. KVMI_VCPU_CONTROL_SINGLESTEP +-------------------------------- + +:Architectures: x86 (vmx) +:Versions: >= 1 +:Parameters: + +:: + + struct kvmi_vcpu_hdr; + struct kvmi_vcpu_control_singlestep { + __u8 enable; + __u8 padding[7]; + }; + +:Returns: + +:: + + struct kvmi_error_code; + +Enables/disables singlestep for the selected vCPU. + +The introspection tool should use *KVMI_GET_VERSION*, to check +if the hardware supports singlestep (see **KVMI_GET_VERSION**). + +:Errors: + +* -KVM_EOPNOTSUPP - the hardware doesn't support singlestep +* -KVM_EINVAL - the padding is not zero +* -KVM_EAGAIN - the selected vCPU can't be introspected yet + Events ====== diff --git a/arch/x86/kvm/kvmi.c b/arch/x86/kvm/kvmi.c index e0302883aec5..31a2de24de29 100644 --- a/arch/x86/kvm/kvmi.c +++ b/arch/x86/kvm/kvmi.c @@ -776,7 +776,9 @@ void kvmi_enter_guest(struct kvm_vcpu *vcpu) if (kvmi) { vcpui = VCPUI(vcpu); - if (vcpui->arch.exception.pending) + if (vcpui->singlestep.loop) + kvmi_arch_start_singlestep(vcpu); + else if (vcpui->arch.exception.pending) kvmi_inject_pending_exception(vcpu); kvmi_put(vcpu->kvm); @@ -1086,3 +1088,13 @@ void kvmi_arch_features(struct kvmi_features *feat) { feat->singlestep = !!kvm_x86_ops.control_singlestep; } + +void kvmi_arch_start_singlestep(struct kvm_vcpu *vcpu) +{ + kvm_x86_ops.control_singlestep(vcpu, true); +} + +void kvmi_arch_stop_singlestep(struct kvm_vcpu *vcpu) +{ + kvm_x86_ops.control_singlestep(vcpu, false); +} diff --git a/arch/x86/kvm/kvmi_msg.c b/arch/x86/kvm/kvmi_msg.c index 6d45b1c49184..9332c558c2ab 100644 --- a/arch/x86/kvm/kvmi_msg.c +++ b/arch/x86/kvm/kvmi_msg.c @@ -166,7 +166,8 @@ static int handle_vcpu_inject_exception(const struct kvmi_vcpu_msg_job *job, else if (req->padding1 || req->padding2) ec = -KVM_EINVAL; else if (VCPUI(vcpu)->arch.exception.pending || - VCPUI(vcpu)->arch.exception.send_event) + VCPUI(vcpu)->arch.exception.send_event || + VCPUI(vcpu)->singlestep.loop) ec = -KVM_EBUSY; else ec = kvmi_arch_cmd_vcpu_inject_exception(vcpu, req); @@ -275,18 +276,49 @@ static int handle_vcpu_control_msr(const struct kvmi_vcpu_msg_job *job, return kvmi_msg_vcpu_reply(job, msg, ec, NULL, 0); } +static int handle_vcpu_control_singlestep(const struct kvmi_vcpu_msg_job *job, + const struct kvmi_msg_hdr *msg, + const void *_req) +{ + const struct kvmi_vcpu_control_singlestep *req = _req; + struct kvm_vcpu *vcpu = job->vcpu; + int ec = 0; + + if (non_zero_padding(req->padding, ARRAY_SIZE(req->padding)) || + req->enable > 1) { + ec = -KVM_EINVAL; + goto reply; + } + + if (!kvm_x86_ops.control_singlestep) { + ec = -KVM_EOPNOTSUPP; + goto reply; + } + + if (req->enable) + kvmi_arch_start_singlestep(vcpu); + else + kvmi_arch_stop_singlestep(vcpu); + + VCPUI(vcpu)->singlestep.loop = !!req->enable; + +reply: + return kvmi_msg_vcpu_reply(job, msg, ec, NULL, 0); +} + static kvmi_vcpu_msg_job_fct const msg_vcpu[] = { - [KVMI_VCPU_CONTROL_CR] = handle_vcpu_control_cr, - [KVMI_VCPU_CONTROL_MSR] = handle_vcpu_control_msr, - [KVMI_VCPU_GET_CPUID] = handle_vcpu_get_cpuid, - [KVMI_VCPU_GET_INFO] = handle_vcpu_get_info, - [KVMI_VCPU_GET_MTRR_TYPE] = handle_vcpu_get_mtrr_type, - [KVMI_VCPU_GET_REGISTERS] = handle_vcpu_get_registers, - [KVMI_VCPU_GET_XCR] = handle_vcpu_get_xcr, - [KVMI_VCPU_GET_XSAVE] = handle_vcpu_get_xsave, - [KVMI_VCPU_INJECT_EXCEPTION] = handle_vcpu_inject_exception, - [KVMI_VCPU_SET_REGISTERS] = handle_vcpu_set_registers, - [KVMI_VCPU_SET_XSAVE] = handle_vcpu_set_xsave, + [KVMI_VCPU_CONTROL_CR] = handle_vcpu_control_cr, + [KVMI_VCPU_CONTROL_MSR] = handle_vcpu_control_msr, + [KVMI_VCPU_CONTROL_SINGLESTEP] = handle_vcpu_control_singlestep, + [KVMI_VCPU_GET_CPUID] = handle_vcpu_get_cpuid, + [KVMI_VCPU_GET_INFO] = handle_vcpu_get_info, + [KVMI_VCPU_GET_MTRR_TYPE] = handle_vcpu_get_mtrr_type, + [KVMI_VCPU_GET_REGISTERS] = handle_vcpu_get_registers, + [KVMI_VCPU_GET_XCR] = handle_vcpu_get_xcr, + [KVMI_VCPU_GET_XSAVE] = handle_vcpu_get_xsave, + [KVMI_VCPU_INJECT_EXCEPTION] = handle_vcpu_inject_exception, + [KVMI_VCPU_SET_REGISTERS] = handle_vcpu_set_registers, + [KVMI_VCPU_SET_XSAVE] = handle_vcpu_set_xsave, }; kvmi_vcpu_msg_job_fct kvmi_arch_vcpu_msg_handler(u16 id) diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index 381e3dfba535..d3f145f9e196 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -8954,9 +8954,15 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) goto out; } - inject_pending_event(vcpu, &req_immediate_exit); - if (req_int_win) - kvm_x86_ops.enable_irq_window(vcpu); + if (!kvmi_vcpu_running_singlestep(vcpu)) { + /* + * We cannot inject events during single-stepping. + * Try again later. + */ + inject_pending_event(vcpu, &req_immediate_exit); + if (req_int_win) + kvm_x86_ops.enable_irq_window(vcpu); + } if (kvm_lapic_enabled(vcpu)) { update_cr8_intercept(vcpu); diff --git a/include/linux/kvmi_host.h b/include/linux/kvmi_host.h index 14ac075a3ea9..e2103ab9d0d5 100644 --- a/include/linux/kvmi_host.h +++ b/include/linux/kvmi_host.h @@ -33,6 +33,10 @@ struct kvm_vcpu_introspection { bool waiting_for_reply; unsigned long *ev_enable_mask; + + struct { + bool loop; + } singlestep; }; struct kvm_introspection { @@ -76,6 +80,7 @@ int kvmi_ioctl_preunhook(struct kvm *kvm); void kvmi_handle_requests(struct kvm_vcpu *vcpu); bool kvmi_hypercall_event(struct kvm_vcpu *vcpu); bool kvmi_breakpoint_event(struct kvm_vcpu *vcpu, u64 gva, u8 insn_len); +bool kvmi_vcpu_running_singlestep(struct kvm_vcpu *vcpu); #else @@ -90,6 +95,8 @@ static inline void kvmi_handle_requests(struct kvm_vcpu *vcpu) { } static inline bool kvmi_hypercall_event(struct kvm_vcpu *vcpu) { return false; } static inline bool kvmi_breakpoint_event(struct kvm_vcpu *vcpu, u64 gva, u8 insn_len) { return true; } +static inline bool kvmi_vcpu_running_singlestep(struct kvm_vcpu *vcpu) + { return false; } #endif /* CONFIG_KVM_INTROSPECTION */ diff --git a/include/uapi/linux/kvmi.h b/include/uapi/linux/kvmi.h index 43631ed2b06c..91126607b7eb 100644 --- a/include/uapi/linux/kvmi.h +++ b/include/uapi/linux/kvmi.h @@ -38,18 +38,19 @@ enum { enum { KVMI_VCPU_EVENT = KVMI_VCPU_MESSAGE_ID(0), - KVMI_VCPU_GET_INFO = KVMI_VCPU_MESSAGE_ID(1), - KVMI_VCPU_CONTROL_EVENTS = KVMI_VCPU_MESSAGE_ID(2), - KVMI_VCPU_GET_REGISTERS = KVMI_VCPU_MESSAGE_ID(3), - KVMI_VCPU_SET_REGISTERS = KVMI_VCPU_MESSAGE_ID(4), - KVMI_VCPU_GET_CPUID = KVMI_VCPU_MESSAGE_ID(5), - KVMI_VCPU_CONTROL_CR = KVMI_VCPU_MESSAGE_ID(6), - KVMI_VCPU_INJECT_EXCEPTION = KVMI_VCPU_MESSAGE_ID(7), - KVMI_VCPU_GET_XCR = KVMI_VCPU_MESSAGE_ID(8), - KVMI_VCPU_GET_XSAVE = KVMI_VCPU_MESSAGE_ID(9), - KVMI_VCPU_SET_XSAVE = KVMI_VCPU_MESSAGE_ID(10), - KVMI_VCPU_GET_MTRR_TYPE = KVMI_VCPU_MESSAGE_ID(11), - KVMI_VCPU_CONTROL_MSR = KVMI_VCPU_MESSAGE_ID(12), + KVMI_VCPU_GET_INFO = KVMI_VCPU_MESSAGE_ID(1), + KVMI_VCPU_CONTROL_EVENTS = KVMI_VCPU_MESSAGE_ID(2), + KVMI_VCPU_GET_REGISTERS = KVMI_VCPU_MESSAGE_ID(3), + KVMI_VCPU_SET_REGISTERS = KVMI_VCPU_MESSAGE_ID(4), + KVMI_VCPU_GET_CPUID = KVMI_VCPU_MESSAGE_ID(5), + KVMI_VCPU_CONTROL_CR = KVMI_VCPU_MESSAGE_ID(6), + KVMI_VCPU_INJECT_EXCEPTION = KVMI_VCPU_MESSAGE_ID(7), + KVMI_VCPU_GET_XCR = KVMI_VCPU_MESSAGE_ID(8), + KVMI_VCPU_GET_XSAVE = KVMI_VCPU_MESSAGE_ID(9), + KVMI_VCPU_SET_XSAVE = KVMI_VCPU_MESSAGE_ID(10), + KVMI_VCPU_GET_MTRR_TYPE = KVMI_VCPU_MESSAGE_ID(11), + KVMI_VCPU_CONTROL_MSR = KVMI_VCPU_MESSAGE_ID(12), + KVMI_VCPU_CONTROL_SINGLESTEP = KVMI_VCPU_MESSAGE_ID(13), KVMI_NEXT_VCPU_MESSAGE }; @@ -221,4 +222,9 @@ struct kvmi_vcpu_event_pf { __u32 padding3; }; +struct kvmi_vcpu_control_singlestep { + __u8 enable; + __u8 padding[7]; +}; + #endif /* _UAPI__LINUX_KVMI_H */ diff --git a/tools/testing/selftests/kvm/x86_64/kvmi_test.c b/tools/testing/selftests/kvm/x86_64/kvmi_test.c index 9984b0247ae9..d959216aac9d 100644 --- a/tools/testing/selftests/kvm/x86_64/kvmi_test.c +++ b/tools/testing/selftests/kvm/x86_64/kvmi_test.c @@ -1819,6 +1819,44 @@ static void test_event_pf(struct kvm_vm *vm) test_pf(vm, cbk_test_event_pf); } +static void cmd_vcpu_singlestep(struct kvm_vm *vm, __u8 enable, + int expected_err) +{ + struct { + struct kvmi_msg_hdr hdr; + struct kvmi_vcpu_hdr vcpu_hdr; + struct kvmi_vcpu_control_singlestep cmd; + } req = {}; + + req.cmd.enable = enable; + + test_vcpu0_command(vm, KVMI_VCPU_CONTROL_SINGLESTEP, + &req.hdr, sizeof(req), NULL, 0, expected_err); +} + +static void test_supported_singlestep(struct kvm_vm *vm) +{ + __u8 disable = 0, enable = 1, enable_inval = 2; + + cmd_vcpu_singlestep(vm, enable, 0); + cmd_vcpu_singlestep(vm, disable, 0); + + cmd_vcpu_singlestep(vm, enable_inval, -KVM_EINVAL); +} + +static void test_unsupported_singlestep(struct kvm_vm *vm) +{ + cmd_vcpu_singlestep(vm, 1, -KVM_EOPNOTSUPP); +} + +static void test_cmd_vcpu_control_singlestep(struct kvm_vm *vm) +{ + if (features.singlestep) + test_supported_singlestep(vm); + else + test_unsupported_singlestep(vm); +} + static void test_introspection(struct kvm_vm *vm) { srandom(time(0)); @@ -1853,6 +1891,7 @@ static void test_introspection(struct kvm_vm *vm) test_cmd_vcpu_control_msr(vm); test_cmd_vm_set_page_access(vm); test_event_pf(vm); + test_cmd_vcpu_control_singlestep(vm); unhook_introspection(vm); } diff --git a/virt/kvm/introspection/kvmi.c b/virt/kvm/introspection/kvmi.c index 841779143609..38d3cde47740 100644 --- a/virt/kvm/introspection/kvmi.c +++ b/virt/kvm/introspection/kvmi.c @@ -436,6 +436,11 @@ static void kvmi_job_release_vcpu(struct kvm_vcpu *vcpu, void *ctx) atomic_set(&vcpui->pause_requests, 0); vcpui->waiting_for_reply = false; + + if (vcpui->singlestep.loop) { + kvmi_arch_stop_singlestep(vcpu); + vcpui->singlestep.loop = false; + } } static void kvmi_release_vcpus(struct kvm *kvm) @@ -1171,3 +1176,20 @@ void kvmi_remove_memslot(struct kvm *kvm, struct kvm_memory_slot *slot) spin_unlock(&kvm->mmu_lock); srcu_read_unlock(&kvm->srcu, idx); } + +bool kvmi_vcpu_running_singlestep(struct kvm_vcpu *vcpu) +{ + struct kvm_introspection *kvmi; + bool ret; + + kvmi = kvmi_get(vcpu->kvm); + if (!kvmi) + return false; + + ret = VCPUI(vcpu)->singlestep.loop; + + kvmi_put(vcpu->kvm); + + return ret; +} +EXPORT_SYMBOL(kvmi_vcpu_running_singlestep); diff --git a/virt/kvm/introspection/kvmi_int.h b/virt/kvm/introspection/kvmi_int.h index a51e7e4ed511..4815fa61b136 100644 --- a/virt/kvm/introspection/kvmi_int.h +++ b/virt/kvm/introspection/kvmi_int.h @@ -122,5 +122,7 @@ void kvmi_arch_update_page_tracking(struct kvm *kvm, void kvmi_arch_hook(struct kvm *kvm); void kvmi_arch_unhook(struct kvm *kvm); void kvmi_arch_features(struct kvmi_features *feat); +void kvmi_arch_start_singlestep(struct kvm_vcpu *vcpu); +void kvmi_arch_stop_singlestep(struct kvm_vcpu *vcpu); #endif From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.7 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8C826C4361B for ; Mon, 7 Dec 2020 20:57:26 +0000 (UTC) Received: from fraxinus.osuosl.org (smtp4.osuosl.org [140.211.166.137]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 47431238E3 for ; Mon, 7 Dec 2020 20:57:26 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 47431238E3 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=bitdefender.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=virtualization-bounces@lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by fraxinus.osuosl.org (Postfix) with ESMTP id 300588737C; Mon, 7 Dec 2020 20:57:26 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from fraxinus.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id TPWH5Xj9nChJ; Mon, 7 Dec 2020 20:57:17 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by fraxinus.osuosl.org (Postfix) with ESMTP id 8CCFA87563; Mon, 7 Dec 2020 20:57:02 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 6E707C1DA0; Mon, 7 Dec 2020 20:57:02 +0000 (UTC) Received: from whitealder.osuosl.org (smtp1.osuosl.org [140.211.166.138]) by lists.linuxfoundation.org (Postfix) with ESMTP id 8A183C163C for ; Mon, 7 Dec 2020 20:56:58 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by whitealder.osuosl.org (Postfix) with ESMTP id 7418787A8A for ; Mon, 7 Dec 2020 20:56:58 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from whitealder.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id AGBLxBUZc+v9 for ; Mon, 7 Dec 2020 20:56:58 +0000 (UTC) X-Greylist: from auto-whitelisted by SQLgrey-1.7.6 Received: from mx01.bbu.dsd.mx.bitdefender.com (mx01.bbu.dsd.mx.bitdefender.com [91.199.104.161]) by whitealder.osuosl.org (Postfix) with ESMTPS id EF77A87A69 for ; Mon, 7 Dec 2020 20:56:57 +0000 (UTC) Received: from smtp.bitdefender.com (smtp01.buh.bitdefender.com [10.17.80.75]) by mx01.bbu.dsd.mx.bitdefender.com (Postfix) with ESMTPS id D821C305D487; Mon, 7 Dec 2020 22:46:25 +0200 (EET) Received: from localhost.localdomain (unknown [91.199.104.27]) by smtp.bitdefender.com (Postfix) with ESMTPSA id B19083072785; Mon, 7 Dec 2020 22:46:25 +0200 (EET) From: =?UTF-8?q?Adalbert=20Laz=C4=83r?= To: kvm@vger.kernel.org Subject: [PATCH v11 77/81] KVM: introspection: add KVMI_VCPU_CONTROL_SINGLESTEP Date: Mon, 7 Dec 2020 22:46:18 +0200 Message-Id: <20201207204622.15258-78-alazar@bitdefender.com> In-Reply-To: <20201207204622.15258-1-alazar@bitdefender.com> References: <20201207204622.15258-1-alazar@bitdefender.com> MIME-Version: 1.0 Cc: =?UTF-8?q?Adalbert=20Laz=C4=83r?= , Paolo Bonzini , =?UTF-8?q?Nicu=C8=99or=20C=C3=AE=C8=9Bu?= , virtualization@lists.linux-foundation.org X-BeenThere: virtualization@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Linux virtualization List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" RnJvbTogTmljdciZb3IgQ8OuyJt1IDxuaWN1LmNpdHVAaWNsb3VkLmNvbT4KClRoZSBuZXh0IGNv bW1pdCB0aGF0IGFkZHMgdGhlIEtWTUlfVkNQVV9FVkVOVF9TSU5HTEVTVEVQIGV2ZW50IHdpbGwg bWFrZQp0aGlzIGNvbW1hbmQgbW9yZSB1c2VmdWwuCgpTaWduZWQtb2ZmLWJ5OiBOaWN1yJlvciBD w67Im3UgPG5pY3UuY2l0dUBpY2xvdWQuY29tPgpDby1kZXZlbG9wZWQtYnk6IEFkYWxiZXJ0IExh esSDciA8YWxhemFyQGJpdGRlZmVuZGVyLmNvbT4KU2lnbmVkLW9mZi1ieTogQWRhbGJlcnQgTGF6 xINyIDxhbGF6YXJAYml0ZGVmZW5kZXIuY29tPgotLS0KIERvY3VtZW50YXRpb24vdmlydC9rdm0v a3ZtaS5yc3QgICAgICAgICAgICAgICB8IDMzICsrKysrKysrKysrCiBhcmNoL3g4Ni9rdm0va3Zt aS5jICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAxNCArKysrLQogYXJjaC94ODYva3ZtL2t2 bWlfbXNnLmMgICAgICAgICAgICAgICAgICAgICAgIHwgNTYgKysrKysrKysrKysrKysrLS0tLQog YXJjaC94ODYva3ZtL3g4Ni5jICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMTIgKysrLQog aW5jbHVkZS9saW51eC9rdm1pX2hvc3QuaCAgICAgICAgICAgICAgICAgICAgIHwgIDcgKysrCiBp bmNsdWRlL3VhcGkvbGludXgva3ZtaS5oICAgICAgICAgICAgICAgICAgICAgfCAzMCArKysrKyst LS0tCiAuLi4vdGVzdGluZy9zZWxmdGVzdHMva3ZtL3g4Nl82NC9rdm1pX3Rlc3QuYyAgfCAzOSAr KysrKysrKysrKysrCiB2aXJ0L2t2bS9pbnRyb3NwZWN0aW9uL2t2bWkuYyAgICAgICAgICAgICAg ICAgfCAyMiArKysrKysrKwogdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pX2ludC5oICAgICAg ICAgICAgIHwgIDIgKwogOSBmaWxlcyBjaGFuZ2VkLCAxODcgaW5zZXJ0aW9ucygrKSwgMjggZGVs ZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi92aXJ0L2t2bS9rdm1pLnJzdCBi L0RvY3VtZW50YXRpb24vdmlydC9rdm0va3ZtaS5yc3QKaW5kZXggYTNjNDhjYmQ4YzcyLi43YjVj MmM5MmU0N2EgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vdmlydC9rdm0va3ZtaS5yc3QKKysr IGIvRG9jdW1lbnRhdGlvbi92aXJ0L2t2bS9rdm1pLnJzdApAQCAtNzkxLDYgKzc5MSw3IEBAIGV4 Y2VwdGlvbi4KICogLUtWTV9FSU5WQUwgLSB0aGUgc2VsZWN0ZWQgdkNQVSBpcyBpbnZhbGlkCiAq IC1LVk1fRUlOVkFMIC0gdGhlIHBhZGRpbmcgaXMgbm90IHplcm8KICogLUtWTV9FQUdBSU4gLSB0 aGUgc2VsZWN0ZWQgdkNQVSBjYW4ndCBiZSBpbnRyb3NwZWN0ZWQgeWV0CisqIC1LVk1fRUJVU1kg LSB0aGUgdkNQVSBpcyBzd2l0Y2hlZCBpbiBzaW5nbGVzdGVwIG1vZGUgKCpLVk1JX1ZDUFVfQ09O VFJPTF9TSU5HTEVTVEVQKikKICogLUtWTV9FQlVTWSAtIGFub3RoZXIgKktWTUlfVkNQVV9JTkpF Q1RfRVhDRVBUSU9OKi0qS1ZNSV9WQ1BVX0VWRU5UX1RSQVAqCiAgICAgICAgICAgICAgICBwYWly IGlzIGluIHByb2dyZXNzCiAKQEAgLTEwMzYsNiArMTAzNywzOCBAQCBJbiBvcmRlciB0byAnZm9y Z2V0JyBhbiBhZGRyZXNzLCBhbGwgdGhyZWUgYml0cyAoJ3J3eCcpIG11c3QgYmUgc2V0LgogKiAt S1ZNX0VBR0FJTiAtIHRoZSBzZWxlY3RlZCB2Q1BVIGNhbid0IGJlIGludHJvc3BlY3RlZCB5ZXQK ICogLUtWTV9FTk9NRU0gLSB0aGVyZSBpcyBub3QgZW5vdWdoIG1lbW9yeSB0byBhZGQgdGhlIHBh Z2UgdHJhY2tpbmcgc3RydWN0dXJlcwogCisyNC4gS1ZNSV9WQ1BVX0NPTlRST0xfU0lOR0xFU1RF UAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworOkFyY2hpdGVjdHVyZXM6IHg4 NiAodm14KQorOlZlcnNpb25zOiA+PSAxCis6UGFyYW1ldGVyczoKKworOjoKKworCXN0cnVjdCBr dm1pX3ZjcHVfaGRyOworCXN0cnVjdCBrdm1pX3ZjcHVfY29udHJvbF9zaW5nbGVzdGVwIHsKKwkJ X191OCBlbmFibGU7CisJCV9fdTggcGFkZGluZ1s3XTsKKwl9OworCis6UmV0dXJuczoKKworOjoK KworCXN0cnVjdCBrdm1pX2Vycm9yX2NvZGU7CisKK0VuYWJsZXMvZGlzYWJsZXMgc2luZ2xlc3Rl cCBmb3IgdGhlIHNlbGVjdGVkIHZDUFUuCisKK1RoZSBpbnRyb3NwZWN0aW9uIHRvb2wgc2hvdWxk IHVzZSAqS1ZNSV9HRVRfVkVSU0lPTiosIHRvIGNoZWNrCitpZiB0aGUgaGFyZHdhcmUgc3VwcG9y dHMgc2luZ2xlc3RlcCAoc2VlICoqS1ZNSV9HRVRfVkVSU0lPTioqKS4KKworOkVycm9yczoKKwor KiAtS1ZNX0VPUE5PVFNVUFAgLSB0aGUgaGFyZHdhcmUgZG9lc24ndCBzdXBwb3J0IHNpbmdsZXN0 ZXAKKyogLUtWTV9FSU5WQUwgLSB0aGUgcGFkZGluZyBpcyBub3QgemVybworKiAtS1ZNX0VBR0FJ TiAtIHRoZSBzZWxlY3RlZCB2Q1BVIGNhbid0IGJlIGludHJvc3BlY3RlZCB5ZXQKKwogRXZlbnRz CiA9PT09PT0KIApkaWZmIC0tZ2l0IGEvYXJjaC94ODYva3ZtL2t2bWkuYyBiL2FyY2gveDg2L2t2 bS9rdm1pLmMKaW5kZXggZTAzMDI4ODNhZWM1Li4zMWEyZGUyNGRlMjkgMTAwNjQ0Ci0tLSBhL2Fy Y2gveDg2L2t2bS9rdm1pLmMKKysrIGIvYXJjaC94ODYva3ZtL2t2bWkuYwpAQCAtNzc2LDcgKzc3 Niw5IEBAIHZvaWQga3ZtaV9lbnRlcl9ndWVzdChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCiAJaWYg KGt2bWkpIHsKIAkJdmNwdWkgPSBWQ1BVSSh2Y3B1KTsKIAotCQlpZiAodmNwdWktPmFyY2guZXhj ZXB0aW9uLnBlbmRpbmcpCisJCWlmICh2Y3B1aS0+c2luZ2xlc3RlcC5sb29wKQorCQkJa3ZtaV9h cmNoX3N0YXJ0X3NpbmdsZXN0ZXAodmNwdSk7CisJCWVsc2UgaWYgKHZjcHVpLT5hcmNoLmV4Y2Vw dGlvbi5wZW5kaW5nKQogCQkJa3ZtaV9pbmplY3RfcGVuZGluZ19leGNlcHRpb24odmNwdSk7CiAK IAkJa3ZtaV9wdXQodmNwdS0+a3ZtKTsKQEAgLTEwODYsMyArMTA4OCwxMyBAQCB2b2lkIGt2bWlf YXJjaF9mZWF0dXJlcyhzdHJ1Y3Qga3ZtaV9mZWF0dXJlcyAqZmVhdCkKIHsKIAlmZWF0LT5zaW5n bGVzdGVwID0gISFrdm1feDg2X29wcy5jb250cm9sX3NpbmdsZXN0ZXA7CiB9CisKK3ZvaWQga3Zt aV9hcmNoX3N0YXJ0X3NpbmdsZXN0ZXAoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQoreworCWt2bV94 ODZfb3BzLmNvbnRyb2xfc2luZ2xlc3RlcCh2Y3B1LCB0cnVlKTsKK30KKwordm9pZCBrdm1pX2Fy Y2hfc3RvcF9zaW5nbGVzdGVwKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSkKK3sKKwlrdm1feDg2X29w cy5jb250cm9sX3NpbmdsZXN0ZXAodmNwdSwgZmFsc2UpOworfQpkaWZmIC0tZ2l0IGEvYXJjaC94 ODYva3ZtL2t2bWlfbXNnLmMgYi9hcmNoL3g4Ni9rdm0va3ZtaV9tc2cuYwppbmRleCA2ZDQ1YjFj NDkxODQuLjkzMzJjNTU4YzJhYiAxMDA2NDQKLS0tIGEvYXJjaC94ODYva3ZtL2t2bWlfbXNnLmMK KysrIGIvYXJjaC94ODYva3ZtL2t2bWlfbXNnLmMKQEAgLTE2Niw3ICsxNjYsOCBAQCBzdGF0aWMg aW50IGhhbmRsZV92Y3B1X2luamVjdF9leGNlcHRpb24oY29uc3Qgc3RydWN0IGt2bWlfdmNwdV9t c2dfam9iICpqb2IsCiAJZWxzZSBpZiAocmVxLT5wYWRkaW5nMSB8fCByZXEtPnBhZGRpbmcyKQog CQllYyA9IC1LVk1fRUlOVkFMOwogCWVsc2UgaWYgKFZDUFVJKHZjcHUpLT5hcmNoLmV4Y2VwdGlv bi5wZW5kaW5nIHx8Ci0JCQlWQ1BVSSh2Y3B1KS0+YXJjaC5leGNlcHRpb24uc2VuZF9ldmVudCkK KwkJCVZDUFVJKHZjcHUpLT5hcmNoLmV4Y2VwdGlvbi5zZW5kX2V2ZW50IHx8CisJCQlWQ1BVSSh2 Y3B1KS0+c2luZ2xlc3RlcC5sb29wKQogCQllYyA9IC1LVk1fRUJVU1k7CiAJZWxzZQogCQllYyA9 IGt2bWlfYXJjaF9jbWRfdmNwdV9pbmplY3RfZXhjZXB0aW9uKHZjcHUsIHJlcSk7CkBAIC0yNzUs MTggKzI3Niw0OSBAQCBzdGF0aWMgaW50IGhhbmRsZV92Y3B1X2NvbnRyb2xfbXNyKGNvbnN0IHN0 cnVjdCBrdm1pX3ZjcHVfbXNnX2pvYiAqam9iLAogCXJldHVybiBrdm1pX21zZ192Y3B1X3JlcGx5 KGpvYiwgbXNnLCBlYywgTlVMTCwgMCk7CiB9CiAKK3N0YXRpYyBpbnQgaGFuZGxlX3ZjcHVfY29u dHJvbF9zaW5nbGVzdGVwKGNvbnN0IHN0cnVjdCBrdm1pX3ZjcHVfbXNnX2pvYiAqam9iLAorCQkJ CQkgIGNvbnN0IHN0cnVjdCBrdm1pX21zZ19oZHIgKm1zZywKKwkJCQkJICBjb25zdCB2b2lkICpf cmVxKQoreworCWNvbnN0IHN0cnVjdCBrdm1pX3ZjcHVfY29udHJvbF9zaW5nbGVzdGVwICpyZXEg PSBfcmVxOworCXN0cnVjdCBrdm1fdmNwdSAqdmNwdSA9IGpvYi0+dmNwdTsKKwlpbnQgZWMgPSAw OworCisJaWYgKG5vbl96ZXJvX3BhZGRpbmcocmVxLT5wYWRkaW5nLCBBUlJBWV9TSVpFKHJlcS0+ cGFkZGluZykpIHx8CisJICAgIHJlcS0+ZW5hYmxlID4gMSkgeworCQllYyA9IC1LVk1fRUlOVkFM OworCQlnb3RvIHJlcGx5OworCX0KKworCWlmICgha3ZtX3g4Nl9vcHMuY29udHJvbF9zaW5nbGVz dGVwKSB7CisJCWVjID0gLUtWTV9FT1BOT1RTVVBQOworCQlnb3RvIHJlcGx5OworCX0KKworCWlm IChyZXEtPmVuYWJsZSkKKwkJa3ZtaV9hcmNoX3N0YXJ0X3NpbmdsZXN0ZXAodmNwdSk7CisJZWxz ZQorCQlrdm1pX2FyY2hfc3RvcF9zaW5nbGVzdGVwKHZjcHUpOworCisJVkNQVUkodmNwdSktPnNp bmdsZXN0ZXAubG9vcCA9ICEhcmVxLT5lbmFibGU7CisKK3JlcGx5OgorCXJldHVybiBrdm1pX21z Z192Y3B1X3JlcGx5KGpvYiwgbXNnLCBlYywgTlVMTCwgMCk7Cit9CisKIHN0YXRpYyBrdm1pX3Zj cHVfbXNnX2pvYl9mY3QgY29uc3QgbXNnX3ZjcHVbXSA9IHsKLQlbS1ZNSV9WQ1BVX0NPTlRST0xf Q1JdICAgICAgID0gaGFuZGxlX3ZjcHVfY29udHJvbF9jciwKLQlbS1ZNSV9WQ1BVX0NPTlRST0xf TVNSXSAgICAgID0gaGFuZGxlX3ZjcHVfY29udHJvbF9tc3IsCi0JW0tWTUlfVkNQVV9HRVRfQ1BV SURdICAgICAgICA9IGhhbmRsZV92Y3B1X2dldF9jcHVpZCwKLQlbS1ZNSV9WQ1BVX0dFVF9JTkZP XSAgICAgICAgID0gaGFuZGxlX3ZjcHVfZ2V0X2luZm8sCi0JW0tWTUlfVkNQVV9HRVRfTVRSUl9U WVBFXSAgICA9IGhhbmRsZV92Y3B1X2dldF9tdHJyX3R5cGUsCi0JW0tWTUlfVkNQVV9HRVRfUkVH SVNURVJTXSAgICA9IGhhbmRsZV92Y3B1X2dldF9yZWdpc3RlcnMsCi0JW0tWTUlfVkNQVV9HRVRf WENSXSAgICAgICAgICA9IGhhbmRsZV92Y3B1X2dldF94Y3IsCi0JW0tWTUlfVkNQVV9HRVRfWFNB VkVdICAgICAgICA9IGhhbmRsZV92Y3B1X2dldF94c2F2ZSwKLQlbS1ZNSV9WQ1BVX0lOSkVDVF9F WENFUFRJT05dID0gaGFuZGxlX3ZjcHVfaW5qZWN0X2V4Y2VwdGlvbiwKLQlbS1ZNSV9WQ1BVX1NF VF9SRUdJU1RFUlNdICAgID0gaGFuZGxlX3ZjcHVfc2V0X3JlZ2lzdGVycywKLQlbS1ZNSV9WQ1BV X1NFVF9YU0FWRV0gICAgICAgID0gaGFuZGxlX3ZjcHVfc2V0X3hzYXZlLAorCVtLVk1JX1ZDUFVf Q09OVFJPTF9DUl0gICAgICAgICA9IGhhbmRsZV92Y3B1X2NvbnRyb2xfY3IsCisJW0tWTUlfVkNQ VV9DT05UUk9MX01TUl0gICAgICAgID0gaGFuZGxlX3ZjcHVfY29udHJvbF9tc3IsCisJW0tWTUlf VkNQVV9DT05UUk9MX1NJTkdMRVNURVBdID0gaGFuZGxlX3ZjcHVfY29udHJvbF9zaW5nbGVzdGVw LAorCVtLVk1JX1ZDUFVfR0VUX0NQVUlEXSAgICAgICAgICA9IGhhbmRsZV92Y3B1X2dldF9jcHVp ZCwKKwlbS1ZNSV9WQ1BVX0dFVF9JTkZPXSAgICAgICAgICAgPSBoYW5kbGVfdmNwdV9nZXRfaW5m bywKKwlbS1ZNSV9WQ1BVX0dFVF9NVFJSX1RZUEVdICAgICAgPSBoYW5kbGVfdmNwdV9nZXRfbXRy cl90eXBlLAorCVtLVk1JX1ZDUFVfR0VUX1JFR0lTVEVSU10gICAgICA9IGhhbmRsZV92Y3B1X2dl dF9yZWdpc3RlcnMsCisJW0tWTUlfVkNQVV9HRVRfWENSXSAgICAgICAgICAgID0gaGFuZGxlX3Zj cHVfZ2V0X3hjciwKKwlbS1ZNSV9WQ1BVX0dFVF9YU0FWRV0gICAgICAgICAgPSBoYW5kbGVfdmNw dV9nZXRfeHNhdmUsCisJW0tWTUlfVkNQVV9JTkpFQ1RfRVhDRVBUSU9OXSAgID0gaGFuZGxlX3Zj cHVfaW5qZWN0X2V4Y2VwdGlvbiwKKwlbS1ZNSV9WQ1BVX1NFVF9SRUdJU1RFUlNdICAgICAgPSBo YW5kbGVfdmNwdV9zZXRfcmVnaXN0ZXJzLAorCVtLVk1JX1ZDUFVfU0VUX1hTQVZFXSAgICAgICAg ICA9IGhhbmRsZV92Y3B1X3NldF94c2F2ZSwKIH07CiAKIGt2bWlfdmNwdV9tc2dfam9iX2ZjdCBr dm1pX2FyY2hfdmNwdV9tc2dfaGFuZGxlcih1MTYgaWQpCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9r dm0veDg2LmMgYi9hcmNoL3g4Ni9rdm0veDg2LmMKaW5kZXggMzgxZTNkZmJhNTM1Li5kM2YxNDVm OWUxOTYgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2t2bS94ODYuYworKysgYi9hcmNoL3g4Ni9rdm0v eDg2LmMKQEAgLTg5NTQsOSArODk1NCwxNSBAQCBzdGF0aWMgaW50IHZjcHVfZW50ZXJfZ3Vlc3Qo c3RydWN0IGt2bV92Y3B1ICp2Y3B1KQogCQkJZ290byBvdXQ7CiAJCX0KIAotCQlpbmplY3RfcGVu ZGluZ19ldmVudCh2Y3B1LCAmcmVxX2ltbWVkaWF0ZV9leGl0KTsKLQkJaWYgKHJlcV9pbnRfd2lu KQotCQkJa3ZtX3g4Nl9vcHMuZW5hYmxlX2lycV93aW5kb3codmNwdSk7CisJCWlmICgha3ZtaV92 Y3B1X3J1bm5pbmdfc2luZ2xlc3RlcCh2Y3B1KSkgeworCQkJLyoKKwkJCSAqIFdlIGNhbm5vdCBp bmplY3QgZXZlbnRzIGR1cmluZyBzaW5nbGUtc3RlcHBpbmcuCisJCQkgKiBUcnkgYWdhaW4gbGF0 ZXIuCisJCQkgKi8KKwkJCWluamVjdF9wZW5kaW5nX2V2ZW50KHZjcHUsICZyZXFfaW1tZWRpYXRl X2V4aXQpOworCQkJaWYgKHJlcV9pbnRfd2luKQorCQkJCWt2bV94ODZfb3BzLmVuYWJsZV9pcnFf d2luZG93KHZjcHUpOworCQl9CiAKIAkJaWYgKGt2bV9sYXBpY19lbmFibGVkKHZjcHUpKSB7CiAJ CQl1cGRhdGVfY3I4X2ludGVyY2VwdCh2Y3B1KTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgv a3ZtaV9ob3N0LmggYi9pbmNsdWRlL2xpbnV4L2t2bWlfaG9zdC5oCmluZGV4IDE0YWMwNzVhM2Vh OS4uZTIxMDNhYjlkMGQ1IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2t2bWlfaG9zdC5oCisr KyBiL2luY2x1ZGUvbGludXgva3ZtaV9ob3N0LmgKQEAgLTMzLDYgKzMzLDEwIEBAIHN0cnVjdCBr dm1fdmNwdV9pbnRyb3NwZWN0aW9uIHsKIAlib29sIHdhaXRpbmdfZm9yX3JlcGx5OwogCiAJdW5z aWduZWQgbG9uZyAqZXZfZW5hYmxlX21hc2s7CisKKwlzdHJ1Y3QgeworCQlib29sIGxvb3A7CisJ fSBzaW5nbGVzdGVwOwogfTsKIAogc3RydWN0IGt2bV9pbnRyb3NwZWN0aW9uIHsKQEAgLTc2LDYg KzgwLDcgQEAgaW50IGt2bWlfaW9jdGxfcHJldW5ob29rKHN0cnVjdCBrdm0gKmt2bSk7CiB2b2lk IGt2bWlfaGFuZGxlX3JlcXVlc3RzKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSk7CiBib29sIGt2bWlf aHlwZXJjYWxsX2V2ZW50KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSk7CiBib29sIGt2bWlfYnJlYWtw b2ludF9ldmVudChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIHU2NCBndmEsIHU4IGluc25fbGVuKTsK K2Jvb2wga3ZtaV92Y3B1X3J1bm5pbmdfc2luZ2xlc3RlcChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUp OwogCiAjZWxzZQogCkBAIC05MCw2ICs5NSw4IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBrdm1pX2hh bmRsZV9yZXF1ZXN0cyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpIHsgfQogc3RhdGljIGlubGluZSBi b29sIGt2bWlfaHlwZXJjYWxsX2V2ZW50KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSkgeyByZXR1cm4g ZmFsc2U7IH0KIHN0YXRpYyBpbmxpbmUgYm9vbCBrdm1pX2JyZWFrcG9pbnRfZXZlbnQoc3RydWN0 IGt2bV92Y3B1ICp2Y3B1LCB1NjQgZ3ZhLAogCQkJCQkgdTggaW5zbl9sZW4pIHsgcmV0dXJuIHRy dWU7IH0KK3N0YXRpYyBpbmxpbmUgYm9vbCBrdm1pX3ZjcHVfcnVubmluZ19zaW5nbGVzdGVwKHN0 cnVjdCBrdm1fdmNwdSAqdmNwdSkKKwkJCXsgcmV0dXJuIGZhbHNlOyB9CiAKICNlbmRpZiAvKiBD T05GSUdfS1ZNX0lOVFJPU1BFQ1RJT04gKi8KIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2xp bnV4L2t2bWkuaCBiL2luY2x1ZGUvdWFwaS9saW51eC9rdm1pLmgKaW5kZXggNDM2MzFlZDJiMDZj Li45MTEyNjYwN2I3ZWIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdWFwaS9saW51eC9rdm1pLmgKKysr IGIvaW5jbHVkZS91YXBpL2xpbnV4L2t2bWkuaApAQCAtMzgsMTggKzM4LDE5IEBAIGVudW0gewog ZW51bSB7CiAJS1ZNSV9WQ1BVX0VWRU5UID0gS1ZNSV9WQ1BVX01FU1NBR0VfSUQoMCksCiAKLQlL Vk1JX1ZDUFVfR0VUX0lORk8gICAgICAgICA9IEtWTUlfVkNQVV9NRVNTQUdFX0lEKDEpLAotCUtW TUlfVkNQVV9DT05UUk9MX0VWRU5UUyAgID0gS1ZNSV9WQ1BVX01FU1NBR0VfSUQoMiksCi0JS1ZN SV9WQ1BVX0dFVF9SRUdJU1RFUlMgICAgPSBLVk1JX1ZDUFVfTUVTU0FHRV9JRCgzKSwKLQlLVk1J X1ZDUFVfU0VUX1JFR0lTVEVSUyAgICA9IEtWTUlfVkNQVV9NRVNTQUdFX0lEKDQpLAotCUtWTUlf VkNQVV9HRVRfQ1BVSUQgICAgICAgID0gS1ZNSV9WQ1BVX01FU1NBR0VfSUQoNSksCi0JS1ZNSV9W Q1BVX0NPTlRST0xfQ1IgICAgICAgPSBLVk1JX1ZDUFVfTUVTU0FHRV9JRCg2KSwKLQlLVk1JX1ZD UFVfSU5KRUNUX0VYQ0VQVElPTiA9IEtWTUlfVkNQVV9NRVNTQUdFX0lEKDcpLAotCUtWTUlfVkNQ VV9HRVRfWENSICAgICAgICAgID0gS1ZNSV9WQ1BVX01FU1NBR0VfSUQoOCksCi0JS1ZNSV9WQ1BV X0dFVF9YU0FWRSAgICAgICAgPSBLVk1JX1ZDUFVfTUVTU0FHRV9JRCg5KSwKLQlLVk1JX1ZDUFVf U0VUX1hTQVZFICAgICAgICA9IEtWTUlfVkNQVV9NRVNTQUdFX0lEKDEwKSwKLQlLVk1JX1ZDUFVf R0VUX01UUlJfVFlQRSAgICA9IEtWTUlfVkNQVV9NRVNTQUdFX0lEKDExKSwKLQlLVk1JX1ZDUFVf Q09OVFJPTF9NU1IgICAgICA9IEtWTUlfVkNQVV9NRVNTQUdFX0lEKDEyKSwKKwlLVk1JX1ZDUFVf R0VUX0lORk8gICAgICAgICAgID0gS1ZNSV9WQ1BVX01FU1NBR0VfSUQoMSksCisJS1ZNSV9WQ1BV X0NPTlRST0xfRVZFTlRTICAgICA9IEtWTUlfVkNQVV9NRVNTQUdFX0lEKDIpLAorCUtWTUlfVkNQ VV9HRVRfUkVHSVNURVJTICAgICAgPSBLVk1JX1ZDUFVfTUVTU0FHRV9JRCgzKSwKKwlLVk1JX1ZD UFVfU0VUX1JFR0lTVEVSUyAgICAgID0gS1ZNSV9WQ1BVX01FU1NBR0VfSUQoNCksCisJS1ZNSV9W Q1BVX0dFVF9DUFVJRCAgICAgICAgICA9IEtWTUlfVkNQVV9NRVNTQUdFX0lEKDUpLAorCUtWTUlf VkNQVV9DT05UUk9MX0NSICAgICAgICAgPSBLVk1JX1ZDUFVfTUVTU0FHRV9JRCg2KSwKKwlLVk1J X1ZDUFVfSU5KRUNUX0VYQ0VQVElPTiAgID0gS1ZNSV9WQ1BVX01FU1NBR0VfSUQoNyksCisJS1ZN SV9WQ1BVX0dFVF9YQ1IgICAgICAgICAgICA9IEtWTUlfVkNQVV9NRVNTQUdFX0lEKDgpLAorCUtW TUlfVkNQVV9HRVRfWFNBVkUgICAgICAgICAgPSBLVk1JX1ZDUFVfTUVTU0FHRV9JRCg5KSwKKwlL Vk1JX1ZDUFVfU0VUX1hTQVZFICAgICAgICAgID0gS1ZNSV9WQ1BVX01FU1NBR0VfSUQoMTApLAor CUtWTUlfVkNQVV9HRVRfTVRSUl9UWVBFICAgICAgPSBLVk1JX1ZDUFVfTUVTU0FHRV9JRCgxMSks CisJS1ZNSV9WQ1BVX0NPTlRST0xfTVNSICAgICAgICA9IEtWTUlfVkNQVV9NRVNTQUdFX0lEKDEy KSwKKwlLVk1JX1ZDUFVfQ09OVFJPTF9TSU5HTEVTVEVQID0gS1ZNSV9WQ1BVX01FU1NBR0VfSUQo MTMpLAogCiAJS1ZNSV9ORVhUX1ZDUFVfTUVTU0FHRQogfTsKQEAgLTIyMSw0ICsyMjIsOSBAQCBz dHJ1Y3Qga3ZtaV92Y3B1X2V2ZW50X3BmIHsKIAlfX3UzMiBwYWRkaW5nMzsKIH07CiAKK3N0cnVj dCBrdm1pX3ZjcHVfY29udHJvbF9zaW5nbGVzdGVwIHsKKwlfX3U4IGVuYWJsZTsKKwlfX3U4IHBh ZGRpbmdbN107Cit9OworCiAjZW5kaWYgLyogX1VBUElfX0xJTlVYX0tWTUlfSCAqLwpkaWZmIC0t Z2l0IGEvdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMva3ZtL3g4Nl82NC9rdm1pX3Rlc3QuYyBiL3Rv b2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2t2bS94ODZfNjQva3ZtaV90ZXN0LmMKaW5kZXggOTk4NGIw MjQ3YWU5Li5kOTU5MjE2YWFjOWQgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3Rz L2t2bS94ODZfNjQva3ZtaV90ZXN0LmMKKysrIGIvdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMva3Zt L3g4Nl82NC9rdm1pX3Rlc3QuYwpAQCAtMTgxOSw2ICsxODE5LDQ0IEBAIHN0YXRpYyB2b2lkIHRl c3RfZXZlbnRfcGYoc3RydWN0IGt2bV92bSAqdm0pCiAJdGVzdF9wZih2bSwgY2JrX3Rlc3RfZXZl bnRfcGYpOwogfQogCitzdGF0aWMgdm9pZCBjbWRfdmNwdV9zaW5nbGVzdGVwKHN0cnVjdCBrdm1f dm0gKnZtLCBfX3U4IGVuYWJsZSwKKwkJCQlpbnQgZXhwZWN0ZWRfZXJyKQoreworCXN0cnVjdCB7 CisJCXN0cnVjdCBrdm1pX21zZ19oZHIgaGRyOworCQlzdHJ1Y3Qga3ZtaV92Y3B1X2hkciB2Y3B1 X2hkcjsKKwkJc3RydWN0IGt2bWlfdmNwdV9jb250cm9sX3NpbmdsZXN0ZXAgY21kOworCX0gcmVx ID0ge307CisKKwlyZXEuY21kLmVuYWJsZSA9IGVuYWJsZTsKKworCXRlc3RfdmNwdTBfY29tbWFu ZCh2bSwgS1ZNSV9WQ1BVX0NPTlRST0xfU0lOR0xFU1RFUCwKKwkJCSAgICZyZXEuaGRyLCBzaXpl b2YocmVxKSwgTlVMTCwgMCwgZXhwZWN0ZWRfZXJyKTsKK30KKworc3RhdGljIHZvaWQgdGVzdF9z dXBwb3J0ZWRfc2luZ2xlc3RlcChzdHJ1Y3Qga3ZtX3ZtICp2bSkKK3sKKwlfX3U4IGRpc2FibGUg PSAwLCBlbmFibGUgPSAxLCBlbmFibGVfaW52YWwgPSAyOworCisJY21kX3ZjcHVfc2luZ2xlc3Rl cCh2bSwgZW5hYmxlLCAwKTsKKwljbWRfdmNwdV9zaW5nbGVzdGVwKHZtLCBkaXNhYmxlLCAwKTsK KworCWNtZF92Y3B1X3NpbmdsZXN0ZXAodm0sIGVuYWJsZV9pbnZhbCwgLUtWTV9FSU5WQUwpOwor fQorCitzdGF0aWMgdm9pZCB0ZXN0X3Vuc3VwcG9ydGVkX3NpbmdsZXN0ZXAoc3RydWN0IGt2bV92 bSAqdm0pCit7CisJY21kX3ZjcHVfc2luZ2xlc3RlcCh2bSwgMSwgLUtWTV9FT1BOT1RTVVBQKTsK K30KKworc3RhdGljIHZvaWQgdGVzdF9jbWRfdmNwdV9jb250cm9sX3NpbmdsZXN0ZXAoc3RydWN0 IGt2bV92bSAqdm0pCit7CisJaWYgKGZlYXR1cmVzLnNpbmdsZXN0ZXApCisJCXRlc3Rfc3VwcG9y dGVkX3NpbmdsZXN0ZXAodm0pOworCWVsc2UKKwkJdGVzdF91bnN1cHBvcnRlZF9zaW5nbGVzdGVw KHZtKTsKK30KKwogc3RhdGljIHZvaWQgdGVzdF9pbnRyb3NwZWN0aW9uKHN0cnVjdCBrdm1fdm0g KnZtKQogewogCXNyYW5kb20odGltZSgwKSk7CkBAIC0xODUzLDYgKzE4OTEsNyBAQCBzdGF0aWMg dm9pZCB0ZXN0X2ludHJvc3BlY3Rpb24oc3RydWN0IGt2bV92bSAqdm0pCiAJdGVzdF9jbWRfdmNw dV9jb250cm9sX21zcih2bSk7CiAJdGVzdF9jbWRfdm1fc2V0X3BhZ2VfYWNjZXNzKHZtKTsKIAl0 ZXN0X2V2ZW50X3BmKHZtKTsKKwl0ZXN0X2NtZF92Y3B1X2NvbnRyb2xfc2luZ2xlc3RlcCh2bSk7 CiAKIAl1bmhvb2tfaW50cm9zcGVjdGlvbih2bSk7CiB9CmRpZmYgLS1naXQgYS92aXJ0L2t2bS9p bnRyb3NwZWN0aW9uL2t2bWkuYyBiL3ZpcnQva3ZtL2ludHJvc3BlY3Rpb24va3ZtaS5jCmluZGV4 IDg0MTc3OTE0MzYwOS4uMzhkM2NkZTQ3NzQwIDEwMDY0NAotLS0gYS92aXJ0L2t2bS9pbnRyb3Nw ZWN0aW9uL2t2bWkuYworKysgYi92aXJ0L2t2bS9pbnRyb3NwZWN0aW9uL2t2bWkuYwpAQCAtNDM2 LDYgKzQzNiwxMSBAQCBzdGF0aWMgdm9pZCBrdm1pX2pvYl9yZWxlYXNlX3ZjcHUoc3RydWN0IGt2 bV92Y3B1ICp2Y3B1LCB2b2lkICpjdHgpCiAKIAlhdG9taWNfc2V0KCZ2Y3B1aS0+cGF1c2VfcmVx dWVzdHMsIDApOwogCXZjcHVpLT53YWl0aW5nX2Zvcl9yZXBseSA9IGZhbHNlOworCisJaWYgKHZj cHVpLT5zaW5nbGVzdGVwLmxvb3ApIHsKKwkJa3ZtaV9hcmNoX3N0b3Bfc2luZ2xlc3RlcCh2Y3B1 KTsKKwkJdmNwdWktPnNpbmdsZXN0ZXAubG9vcCA9IGZhbHNlOworCX0KIH0KIAogc3RhdGljIHZv aWQga3ZtaV9yZWxlYXNlX3ZjcHVzKHN0cnVjdCBrdm0gKmt2bSkKQEAgLTExNzEsMyArMTE3Niwy MCBAQCB2b2lkIGt2bWlfcmVtb3ZlX21lbXNsb3Qoc3RydWN0IGt2bSAqa3ZtLCBzdHJ1Y3Qga3Zt X21lbW9yeV9zbG90ICpzbG90KQogCXNwaW5fdW5sb2NrKCZrdm0tPm1tdV9sb2NrKTsKIAlzcmN1 X3JlYWRfdW5sb2NrKCZrdm0tPnNyY3UsIGlkeCk7CiB9CisKK2Jvb2wga3ZtaV92Y3B1X3J1bm5p bmdfc2luZ2xlc3RlcChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCit7CisJc3RydWN0IGt2bV9pbnRy b3NwZWN0aW9uICprdm1pOworCWJvb2wgcmV0OworCisJa3ZtaSA9IGt2bWlfZ2V0KHZjcHUtPmt2 bSk7CisJaWYgKCFrdm1pKQorCQlyZXR1cm4gZmFsc2U7CisKKwlyZXQgPSBWQ1BVSSh2Y3B1KS0+ c2luZ2xlc3RlcC5sb29wOworCisJa3ZtaV9wdXQodmNwdS0+a3ZtKTsKKworCXJldHVybiByZXQ7 Cit9CitFWFBPUlRfU1lNQk9MKGt2bWlfdmNwdV9ydW5uaW5nX3NpbmdsZXN0ZXApOwpkaWZmIC0t Z2l0IGEvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pX2ludC5oIGIvdmlydC9rdm0vaW50cm9z cGVjdGlvbi9rdm1pX2ludC5oCmluZGV4IGE1MWU3ZTRlZDUxMS4uNDgxNWZhNjFiMTM2IDEwMDY0 NAotLS0gYS92aXJ0L2t2bS9pbnRyb3NwZWN0aW9uL2t2bWlfaW50LmgKKysrIGIvdmlydC9rdm0v aW50cm9zcGVjdGlvbi9rdm1pX2ludC5oCkBAIC0xMjIsNSArMTIyLDcgQEAgdm9pZCBrdm1pX2Fy Y2hfdXBkYXRlX3BhZ2VfdHJhY2tpbmcoc3RydWN0IGt2bSAqa3ZtLAogdm9pZCBrdm1pX2FyY2hf aG9vayhzdHJ1Y3Qga3ZtICprdm0pOwogdm9pZCBrdm1pX2FyY2hfdW5ob29rKHN0cnVjdCBrdm0g Kmt2bSk7CiB2b2lkIGt2bWlfYXJjaF9mZWF0dXJlcyhzdHJ1Y3Qga3ZtaV9mZWF0dXJlcyAqZmVh dCk7Cit2b2lkIGt2bWlfYXJjaF9zdGFydF9zaW5nbGVzdGVwKHN0cnVjdCBrdm1fdmNwdSAqdmNw dSk7Cit2b2lkIGt2bWlfYXJjaF9zdG9wX3NpbmdsZXN0ZXAoc3RydWN0IGt2bV92Y3B1ICp2Y3B1 KTsKIAogI2VuZGlmCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fClZpcnR1YWxpemF0aW9uIG1haWxpbmcgbGlzdApWaXJ0dWFsaXphdGlvbkBsaXN0cy5saW51 eC1mb3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1h bi9saXN0aW5mby92aXJ0dWFsaXphdGlvbg==