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 1E8F0C3526A 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 D795D23877 for ; Mon, 7 Dec 2020 20:49:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727682AbgLGUs6 (ORCPT ); Mon, 7 Dec 2020 15:48:58 -0500 Received: from mx01.bbu.dsd.mx.bitdefender.com ([91.199.104.161]:42604 "EHLO mx01.bbu.dsd.mx.bitdefender.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727646AbgLGUsz (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 14258305D488; Mon, 7 Dec 2020 22:46:26 +0200 (EET) Received: from localhost.localdomain (unknown [91.199.104.27]) by smtp.bitdefender.com (Postfix) with ESMTPSA id DB7D23072784; 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 78/81] KVM: introspection: add KVMI_VCPU_EVENT_SINGLESTEP Date: Mon, 7 Dec 2020 22:46:19 +0200 Message-Id: <20201207204622.15258-79-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 This event is sent after each instruction when the singlestep has been enabled for a vCPU. Signed-off-by: Nicușor Cîțu Co-developed-by: Adalbert Lazăr Signed-off-by: Adalbert Lazăr --- Documentation/virt/kvm/kvmi.rst | 31 +++++++++++ arch/x86/kvm/kvmi.c | 1 + arch/x86/kvm/kvmi_msg.c | 6 +++ arch/x86/kvm/vmx/vmx.c | 6 +++ include/linux/kvmi_host.h | 4 ++ include/uapi/linux/kvmi.h | 6 +++ .../testing/selftests/kvm/x86_64/kvmi_test.c | 54 +++++++++++++++++-- virt/kvm/introspection/kvmi.c | 43 +++++++++++++++ virt/kvm/introspection/kvmi_int.h | 1 + virt/kvm/introspection/kvmi_msg.c | 17 ++++++ 10 files changed, 166 insertions(+), 3 deletions(-) diff --git a/Documentation/virt/kvm/kvmi.rst b/Documentation/virt/kvm/kvmi.rst index 7b5c2c92e47a..15dccf57e1a1 100644 --- a/Documentation/virt/kvm/kvmi.rst +++ b/Documentation/virt/kvm/kvmi.rst @@ -565,6 +565,7 @@ because these are sent as a result of certain commands (but they can be disallowed by the device manager) :: KVMI_VCPU_EVENT_PAUSE + KVMI_VCPU_EVENT_SINGLESTEP KVMI_VCPU_EVENT_TRAP The VM events (e.g. *KVMI_VM_EVENT_UNHOOK*) are controlled with @@ -1063,8 +1064,12 @@ 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**). +After every instruction, a *KVMI_VCPU_EVENT_SINGLESTEP* event is sent +to the introspection tool. + :Errors: +* -KVM_EPERM - the *KVMI_VCPU_EVENT_SINGLESTEP* event is disallowed * -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 @@ -1508,3 +1513,29 @@ emulation). The *RETRY* action is used by the introspection tool to retry the execution of the current instruction, usually because it changed the instruction pointer or the page restrictions. + +11. KVMI_VCPU_EVENT_SINGLESTEP +------------------------------ + +:Architectures: x86 +:Versions: >= 1 +:Actions: CONTINUE, CRASH +:Parameters: + +:: + + struct kvmi_vcpu_event; + +:Returns: + +:: + + struct kvmi_vcpu_hdr; + struct kvmi_vcpu_event_reply; + struct kvmi_vcpu_event_singlestep { + __u8 failed; + __u8 padding[7]; + }; + +This event is sent after each instruction, as long as the singlestep is +enabled for the current vCPU (see **KVMI_VCPU_CONTROL_SINGLESTEP**). diff --git a/arch/x86/kvm/kvmi.c b/arch/x86/kvm/kvmi.c index 31a2de24de29..b010d2369756 100644 --- a/arch/x86/kvm/kvmi.c +++ b/arch/x86/kvm/kvmi.c @@ -18,6 +18,7 @@ void kvmi_arch_init_vcpu_events_mask(unsigned long *supported) set_bit(KVMI_VCPU_EVENT_DESCRIPTOR, supported); set_bit(KVMI_VCPU_EVENT_MSR, supported); set_bit(KVMI_VCPU_EVENT_PF, supported); + set_bit(KVMI_VCPU_EVENT_SINGLESTEP, supported); set_bit(KVMI_VCPU_EVENT_TRAP, supported); set_bit(KVMI_VCPU_EVENT_XSETBV, supported); } diff --git a/arch/x86/kvm/kvmi_msg.c b/arch/x86/kvm/kvmi_msg.c index 9332c558c2ab..8ff090f8c0fc 100644 --- a/arch/x86/kvm/kvmi_msg.c +++ b/arch/x86/kvm/kvmi_msg.c @@ -284,6 +284,12 @@ static int handle_vcpu_control_singlestep(const struct kvmi_vcpu_msg_job *job, struct kvm_vcpu *vcpu = job->vcpu; int ec = 0; + if (!kvmi_is_event_allowed(KVMI(vcpu->kvm), + KVMI_VCPU_EVENT_SINGLESTEP)) { + ec = -KVM_EPERM; + goto reply; + } + if (non_zero_padding(req->padding, ARRAY_SIZE(req->padding)) || req->enable > 1) { ec = -KVM_EINVAL; diff --git a/arch/x86/kvm/vmx/vmx.c b/arch/x86/kvm/vmx/vmx.c index 01d18c9243bc..4804eaa012de 100644 --- a/arch/x86/kvm/vmx/vmx.c +++ b/arch/x86/kvm/vmx/vmx.c @@ -5614,6 +5614,7 @@ static int handle_invalid_op(struct kvm_vcpu *vcpu) static int handle_monitor_trap(struct kvm_vcpu *vcpu) { + kvmi_singlestep_done(vcpu); return 1; } @@ -6142,6 +6143,11 @@ static int vmx_handle_exit(struct kvm_vcpu *vcpu, fastpath_t exit_fastpath) } } + if (kvmi_vcpu_running_singlestep(vcpu) && + exit_reason != EXIT_REASON_EPT_VIOLATION && + exit_reason != EXIT_REASON_MONITOR_TRAP_FLAG) + kvmi_singlestep_failed(vcpu); + if (exit_fastpath != EXIT_FASTPATH_NONE) return 1; diff --git a/include/linux/kvmi_host.h b/include/linux/kvmi_host.h index e2103ab9d0d5..ec38e434c8e9 100644 --- a/include/linux/kvmi_host.h +++ b/include/linux/kvmi_host.h @@ -81,6 +81,8 @@ 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); +void kvmi_singlestep_done(struct kvm_vcpu *vcpu); +void kvmi_singlestep_failed(struct kvm_vcpu *vcpu); #else @@ -97,6 +99,8 @@ 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; } +static inline void kvmi_singlestep_done(struct kvm_vcpu *vcpu) { } +static inline void kvmi_singlestep_failed(struct kvm_vcpu *vcpu) { } #endif /* CONFIG_KVM_INTROSPECTION */ diff --git a/include/uapi/linux/kvmi.h b/include/uapi/linux/kvmi.h index 91126607b7eb..9c646229a25a 100644 --- a/include/uapi/linux/kvmi.h +++ b/include/uapi/linux/kvmi.h @@ -74,6 +74,7 @@ enum { KVMI_VCPU_EVENT_DESCRIPTOR = KVMI_VCPU_EVENT_ID(6), KVMI_VCPU_EVENT_MSR = KVMI_VCPU_EVENT_ID(7), KVMI_VCPU_EVENT_PF = KVMI_VCPU_EVENT_ID(8), + KVMI_VCPU_EVENT_SINGLESTEP = KVMI_VCPU_EVENT_ID(9), KVMI_NEXT_VCPU_EVENT }; @@ -227,4 +228,9 @@ struct kvmi_vcpu_control_singlestep { __u8 padding[7]; }; +struct kvmi_vcpu_event_singlestep { + __u8 failed; + __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 d959216aac9d..c6f41f54f9b0 100644 --- a/tools/testing/selftests/kvm/x86_64/kvmi_test.c +++ b/tools/testing/selftests/kvm/x86_64/kvmi_test.c @@ -1834,12 +1834,60 @@ static void cmd_vcpu_singlestep(struct kvm_vm *vm, __u8 enable, &req.hdr, sizeof(req), NULL, 0, expected_err); } +static void __control_singlestep(bool enable) +{ + struct { + struct kvmi_msg_hdr hdr; + struct kvmi_vcpu_hdr vcpu_hdr; + struct kvmi_vcpu_control_singlestep cmd; + } req = {}; + int r; + + req.cmd.enable = enable ? 1 : 0; + + r = __do_vcpu0_command(KVMI_VCPU_CONTROL_SINGLESTEP, + &req.hdr, sizeof(req), NULL, 0); + TEST_ASSERT(r == 0, + "KVMI_VCPU_CONTROL_SINGLESTEP failed, error %d(%s)\n", + -r, kvm_strerror(-r)); +} + +static void test_singlestep_event(__u16 event_id) +{ + struct { + struct vcpu_event vcpu_ev; + struct kvmi_vcpu_event_singlestep singlestep; + } ev; + bool enable = true, disable = false; + struct vcpu_reply rpl = { }; + struct kvmi_msg_hdr hdr; + + __control_singlestep(enable); + + receive_vcpu_event(&hdr, &ev.vcpu_ev, sizeof(ev), event_id); + + pr_debug("SINGLESTEP event, rip 0x%llx success %d\n", + ev.vcpu_ev.common.arch.regs.rip, !ev.singlestep.failed); + TEST_ASSERT(!ev.singlestep.failed, "Singlestep failed"); + + __control_singlestep(disable); + + reply_to_event(&hdr, &ev.vcpu_ev, KVMI_EVENT_ACTION_CONTINUE, + &rpl, sizeof(rpl)); +} + static void test_supported_singlestep(struct kvm_vm *vm) { - __u8 disable = 0, enable = 1, enable_inval = 2; + struct vcpu_worker_data data = {.vm = vm, .vcpu_id = VCPU_ID }; + __u16 event_id = KVMI_VCPU_EVENT_SINGLESTEP; + __u8 enable_inval = 2; + pthread_t vcpu_thread; - cmd_vcpu_singlestep(vm, enable, 0); - cmd_vcpu_singlestep(vm, disable, 0); + enable_vcpu_event(vm, event_id); + vcpu_thread = start_vcpu_worker(&data); + test_singlestep_event(event_id); + wait_vcpu_worker(vcpu_thread); + disable_vcpu_event(vm, event_id); cmd_vcpu_singlestep(vm, enable_inval, -KVM_EINVAL); } diff --git a/virt/kvm/introspection/kvmi.c b/virt/kvm/introspection/kvmi.c index 38d3cde47740..4f9da76c6777 100644 --- a/virt/kvm/introspection/kvmi.c +++ b/virt/kvm/introspection/kvmi.c @@ -1193,3 +1193,46 @@ bool kvmi_vcpu_running_singlestep(struct kvm_vcpu *vcpu) return ret; } EXPORT_SYMBOL(kvmi_vcpu_running_singlestep); + +static void kvmi_singlestep_event(struct kvm_vcpu *vcpu, bool success) +{ + u32 action; + + action = kvmi_msg_send_vcpu_singlestep(vcpu, success); + switch (action) { + case KVMI_EVENT_ACTION_CONTINUE: + break; + default: + kvmi_handle_common_event_actions(vcpu, action); + } +} + +static void kvmi_handle_singlestep_exit(struct kvm_vcpu *vcpu, bool success) +{ + struct kvm_vcpu_introspection *vcpui; + struct kvm_introspection *kvmi; + struct kvm *kvm = vcpu->kvm; + + kvmi = kvmi_get(kvm); + if (!kvmi) + return; + + vcpui = VCPUI(vcpu); + + if (vcpui->singlestep.loop) + kvmi_singlestep_event(vcpu, success); + + kvmi_put(kvm); +} + +void kvmi_singlestep_done(struct kvm_vcpu *vcpu) +{ + kvmi_handle_singlestep_exit(vcpu, true); +} +EXPORT_SYMBOL(kvmi_singlestep_done); + +void kvmi_singlestep_failed(struct kvm_vcpu *vcpu) +{ + kvmi_handle_singlestep_exit(vcpu, false); +} +EXPORT_SYMBOL(kvmi_singlestep_failed); diff --git a/virt/kvm/introspection/kvmi_int.h b/virt/kvm/introspection/kvmi_int.h index 4815fa61b136..5f4bcdf27d6a 100644 --- a/virt/kvm/introspection/kvmi_int.h +++ b/virt/kvm/introspection/kvmi_int.h @@ -64,6 +64,7 @@ u32 kvmi_msg_send_vcpu_pause(struct kvm_vcpu *vcpu); u32 kvmi_msg_send_vcpu_hypercall(struct kvm_vcpu *vcpu); u32 kvmi_msg_send_vcpu_bp(struct kvm_vcpu *vcpu, u64 gpa, u8 insn_len); u32 kvmi_msg_send_vcpu_pf(struct kvm_vcpu *vcpu, u64 gpa, u64 gva, u8 access); +u32 kvmi_msg_send_vcpu_singlestep(struct kvm_vcpu *vcpu, bool success); /* kvmi.c */ void *kvmi_msg_alloc(void); diff --git a/virt/kvm/introspection/kvmi_msg.c b/virt/kvm/introspection/kvmi_msg.c index fc03223d115f..ad2f36465864 100644 --- a/virt/kvm/introspection/kvmi_msg.c +++ b/virt/kvm/introspection/kvmi_msg.c @@ -896,3 +896,20 @@ u32 kvmi_msg_send_vcpu_pf(struct kvm_vcpu *vcpu, u64 gpa, u64 gva, u8 access) return action; } + +u32 kvmi_msg_send_vcpu_singlestep(struct kvm_vcpu *vcpu, bool success) +{ + struct kvmi_vcpu_event_singlestep e; + u32 action; + int err; + + memset(&e, 0, sizeof(e)); + e.failed = success ? 0 : 1; + + err = kvmi_send_vcpu_event(vcpu, KVMI_VCPU_EVENT_SINGLESTEP, + &e, sizeof(e), NULL, 0, &action); + if (err) + return KVMI_EVENT_ACTION_CONTINUE; + + return action; +} 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 2CB8DC4361B for ; Mon, 7 Dec 2020 20:57:31 +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 E7E9D238E3 for ; Mon, 7 Dec 2020 20:57:30 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E7E9D238E3 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 CA847878FB; Mon, 7 Dec 2020 20:57:30 +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 rAXzDbErVltU; Mon, 7 Dec 2020 20:57:27 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by fraxinus.osuosl.org (Postfix) with ESMTP id B64D5870F6; Mon, 7 Dec 2020 20:57:06 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 9B1F4C0FA7; Mon, 7 Dec 2020 20:57:06 +0000 (UTC) Received: from hemlock.osuosl.org (smtp2.osuosl.org [140.211.166.133]) by lists.linuxfoundation.org (Postfix) with ESMTP id 701ACC1834 for ; Mon, 7 Dec 2020 20:56:59 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by hemlock.osuosl.org (Postfix) with ESMTP id 5D9B7873AC for ; Mon, 7 Dec 2020 20:56:59 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from hemlock.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id XsIG1Ycu6Wqd for ; Mon, 7 Dec 2020 20:56:57 +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 hemlock.osuosl.org (Postfix) with ESMTPS id B636087324 for ; Mon, 7 Dec 2020 20:56:56 +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 14258305D488; Mon, 7 Dec 2020 22:46:26 +0200 (EET) Received: from localhost.localdomain (unknown [91.199.104.27]) by smtp.bitdefender.com (Postfix) with ESMTPSA id DB7D23072784; 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 78/81] KVM: introspection: add KVMI_VCPU_EVENT_SINGLESTEP Date: Mon, 7 Dec 2020 22:46:19 +0200 Message-Id: <20201207204622.15258-79-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" RnJvbTogTmljdciZb3IgQ8OuyJt1IDxuaWN1LmNpdHVAaWNsb3VkLmNvbT4KClRoaXMgZXZlbnQg aXMgc2VudCBhZnRlciBlYWNoIGluc3RydWN0aW9uIHdoZW4gdGhlIHNpbmdsZXN0ZXAgaGFzIGJl ZW4KZW5hYmxlZCBmb3IgYSB2Q1BVLgoKU2lnbmVkLW9mZi1ieTogTmljdciZb3IgQ8OuyJt1IDxu aWN1LmNpdHVAaWNsb3VkLmNvbT4KQ28tZGV2ZWxvcGVkLWJ5OiBBZGFsYmVydCBMYXrEg3IgPGFs YXphckBiaXRkZWZlbmRlci5jb20+ClNpZ25lZC1vZmYtYnk6IEFkYWxiZXJ0IExhesSDciA8YWxh emFyQGJpdGRlZmVuZGVyLmNvbT4KLS0tCiBEb2N1bWVudGF0aW9uL3ZpcnQva3ZtL2t2bWkucnN0 ICAgICAgICAgICAgICAgfCAzMSArKysrKysrKysrKwogYXJjaC94ODYva3ZtL2t2bWkuYyAgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgIDEgKwogYXJjaC94ODYva3ZtL2t2bWlfbXNnLmMgICAg ICAgICAgICAgICAgICAgICAgIHwgIDYgKysrCiBhcmNoL3g4Ni9rdm0vdm14L3ZteC5jICAgICAg ICAgICAgICAgICAgICAgICAgfCAgNiArKysKIGluY2x1ZGUvbGludXgva3ZtaV9ob3N0LmggICAg ICAgICAgICAgICAgICAgICB8ICA0ICsrCiBpbmNsdWRlL3VhcGkvbGludXgva3ZtaS5oICAgICAg ICAgICAgICAgICAgICAgfCAgNiArKysKIC4uLi90ZXN0aW5nL3NlbGZ0ZXN0cy9rdm0veDg2XzY0 L2t2bWlfdGVzdC5jICB8IDU0ICsrKysrKysrKysrKysrKysrLS0KIHZpcnQva3ZtL2ludHJvc3Bl Y3Rpb24va3ZtaS5jICAgICAgICAgICAgICAgICB8IDQzICsrKysrKysrKysrKysrKwogdmlydC9r dm0vaW50cm9zcGVjdGlvbi9rdm1pX2ludC5oICAgICAgICAgICAgIHwgIDEgKwogdmlydC9rdm0v aW50cm9zcGVjdGlvbi9rdm1pX21zZy5jICAgICAgICAgICAgIHwgMTcgKysrKysrCiAxMCBmaWxl cyBjaGFuZ2VkLCAxNjYgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQg YS9Eb2N1bWVudGF0aW9uL3ZpcnQva3ZtL2t2bWkucnN0IGIvRG9jdW1lbnRhdGlvbi92aXJ0L2t2 bS9rdm1pLnJzdAppbmRleCA3YjVjMmM5MmU0N2EuLjE1ZGNjZjU3ZTFhMSAxMDA2NDQKLS0tIGEv RG9jdW1lbnRhdGlvbi92aXJ0L2t2bS9rdm1pLnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL3ZpcnQv a3ZtL2t2bWkucnN0CkBAIC01NjUsNiArNTY1LDcgQEAgYmVjYXVzZSB0aGVzZSBhcmUgc2VudCBh cyBhIHJlc3VsdCBvZiBjZXJ0YWluIGNvbW1hbmRzIChidXQgdGhleSBjYW4gYmUKIGRpc2FsbG93 ZWQgYnkgdGhlIGRldmljZSBtYW5hZ2VyKSA6OgogCiAJS1ZNSV9WQ1BVX0VWRU5UX1BBVVNFCisJ S1ZNSV9WQ1BVX0VWRU5UX1NJTkdMRVNURVAKIAlLVk1JX1ZDUFVfRVZFTlRfVFJBUAogCiBUaGUg Vk0gZXZlbnRzIChlLmcuICpLVk1JX1ZNX0VWRU5UX1VOSE9PSyopIGFyZSBjb250cm9sbGVkIHdp dGgKQEAgLTEwNjMsOCArMTA2NCwxMiBAQCBFbmFibGVzL2Rpc2FibGVzIHNpbmdsZXN0ZXAgZm9y IHRoZSBzZWxlY3RlZCB2Q1BVLgogVGhlIGludHJvc3BlY3Rpb24gdG9vbCBzaG91bGQgdXNlICpL Vk1JX0dFVF9WRVJTSU9OKiwgdG8gY2hlY2sKIGlmIHRoZSBoYXJkd2FyZSBzdXBwb3J0cyBzaW5n bGVzdGVwIChzZWUgKipLVk1JX0dFVF9WRVJTSU9OKiopLgogCitBZnRlciBldmVyeSBpbnN0cnVj dGlvbiwgYSAqS1ZNSV9WQ1BVX0VWRU5UX1NJTkdMRVNURVAqIGV2ZW50IGlzIHNlbnQKK3RvIHRo ZSBpbnRyb3NwZWN0aW9uIHRvb2wuCisKIDpFcnJvcnM6CiAKKyogLUtWTV9FUEVSTSAgLSB0aGUg KktWTUlfVkNQVV9FVkVOVF9TSU5HTEVTVEVQKiBldmVudCBpcyBkaXNhbGxvd2VkCiAqIC1LVk1f RU9QTk9UU1VQUCAtIHRoZSBoYXJkd2FyZSBkb2Vzbid0IHN1cHBvcnQgc2luZ2xlc3RlcAogKiAt S1ZNX0VJTlZBTCAtIHRoZSBwYWRkaW5nIGlzIG5vdCB6ZXJvCiAqIC1LVk1fRUFHQUlOIC0gdGhl IHNlbGVjdGVkIHZDUFUgY2FuJ3QgYmUgaW50cm9zcGVjdGVkIHlldApAQCAtMTUwOCwzICsxNTEz LDI5IEBAIGVtdWxhdGlvbikuCiBUaGUgKlJFVFJZKiBhY3Rpb24gaXMgdXNlZCBieSB0aGUgaW50 cm9zcGVjdGlvbiB0b29sIHRvIHJldHJ5IHRoZQogZXhlY3V0aW9uIG9mIHRoZSBjdXJyZW50IGlu c3RydWN0aW9uLCB1c3VhbGx5IGJlY2F1c2UgaXQgY2hhbmdlZCB0aGUKIGluc3RydWN0aW9uIHBv aW50ZXIgb3IgdGhlIHBhZ2UgcmVzdHJpY3Rpb25zLgorCisxMS4gS1ZNSV9WQ1BVX0VWRU5UX1NJ TkdMRVNURVAKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCis6QXJjaGl0ZWN0dXJl czogeDg2Cis6VmVyc2lvbnM6ID49IDEKKzpBY3Rpb25zOiBDT05USU5VRSwgQ1JBU0gKKzpQYXJh bWV0ZXJzOgorCis6OgorCisJc3RydWN0IGt2bWlfdmNwdV9ldmVudDsKKworOlJldHVybnM6CisK Kzo6CisKKwlzdHJ1Y3Qga3ZtaV92Y3B1X2hkcjsKKwlzdHJ1Y3Qga3ZtaV92Y3B1X2V2ZW50X3Jl cGx5OworCXN0cnVjdCBrdm1pX3ZjcHVfZXZlbnRfc2luZ2xlc3RlcCB7CisJCV9fdTggZmFpbGVk OworCQlfX3U4IHBhZGRpbmdbN107CisJfTsKKworVGhpcyBldmVudCBpcyBzZW50IGFmdGVyIGVh Y2ggaW5zdHJ1Y3Rpb24sIGFzIGxvbmcgYXMgdGhlIHNpbmdsZXN0ZXAgaXMKK2VuYWJsZWQgZm9y IHRoZSBjdXJyZW50IHZDUFUgKHNlZSAqKktWTUlfVkNQVV9DT05UUk9MX1NJTkdMRVNURVAqKiku CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rdm0va3ZtaS5jIGIvYXJjaC94ODYva3ZtL2t2bWkuYwpp bmRleCAzMWEyZGUyNGRlMjkuLmIwMTBkMjM2OTc1NiAxMDA2NDQKLS0tIGEvYXJjaC94ODYva3Zt L2t2bWkuYworKysgYi9hcmNoL3g4Ni9rdm0va3ZtaS5jCkBAIC0xOCw2ICsxOCw3IEBAIHZvaWQg a3ZtaV9hcmNoX2luaXRfdmNwdV9ldmVudHNfbWFzayh1bnNpZ25lZCBsb25nICpzdXBwb3J0ZWQp CiAJc2V0X2JpdChLVk1JX1ZDUFVfRVZFTlRfREVTQ1JJUFRPUiwgc3VwcG9ydGVkKTsKIAlzZXRf Yml0KEtWTUlfVkNQVV9FVkVOVF9NU1IsIHN1cHBvcnRlZCk7CiAJc2V0X2JpdChLVk1JX1ZDUFVf RVZFTlRfUEYsIHN1cHBvcnRlZCk7CisJc2V0X2JpdChLVk1JX1ZDUFVfRVZFTlRfU0lOR0xFU1RF UCwgc3VwcG9ydGVkKTsKIAlzZXRfYml0KEtWTUlfVkNQVV9FVkVOVF9UUkFQLCBzdXBwb3J0ZWQp OwogCXNldF9iaXQoS1ZNSV9WQ1BVX0VWRU5UX1hTRVRCViwgc3VwcG9ydGVkKTsKIH0KZGlmZiAt LWdpdCBhL2FyY2gveDg2L2t2bS9rdm1pX21zZy5jIGIvYXJjaC94ODYva3ZtL2t2bWlfbXNnLmMK aW5kZXggOTMzMmM1NThjMmFiLi44ZmYwOTBmOGMwZmMgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2t2 bS9rdm1pX21zZy5jCisrKyBiL2FyY2gveDg2L2t2bS9rdm1pX21zZy5jCkBAIC0yODQsNiArMjg0 LDEyIEBAIHN0YXRpYyBpbnQgaGFuZGxlX3ZjcHVfY29udHJvbF9zaW5nbGVzdGVwKGNvbnN0IHN0 cnVjdCBrdm1pX3ZjcHVfbXNnX2pvYiAqam9iLAogCXN0cnVjdCBrdm1fdmNwdSAqdmNwdSA9IGpv Yi0+dmNwdTsKIAlpbnQgZWMgPSAwOwogCisJaWYgKCFrdm1pX2lzX2V2ZW50X2FsbG93ZWQoS1ZN SSh2Y3B1LT5rdm0pLAorCQkJCSAgIEtWTUlfVkNQVV9FVkVOVF9TSU5HTEVTVEVQKSkgeworCQll YyA9IC1LVk1fRVBFUk07CisJCWdvdG8gcmVwbHk7CisJfQorCiAJaWYgKG5vbl96ZXJvX3BhZGRp bmcocmVxLT5wYWRkaW5nLCBBUlJBWV9TSVpFKHJlcS0+cGFkZGluZykpIHx8CiAJICAgIHJlcS0+ ZW5hYmxlID4gMSkgewogCQllYyA9IC1LVk1fRUlOVkFMOwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYv a3ZtL3ZteC92bXguYyBiL2FyY2gveDg2L2t2bS92bXgvdm14LmMKaW5kZXggMDFkMThjOTI0M2Jj Li40ODA0ZWFhMDEyZGUgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2t2bS92bXgvdm14LmMKKysrIGIv YXJjaC94ODYva3ZtL3ZteC92bXguYwpAQCAtNTYxNCw2ICs1NjE0LDcgQEAgc3RhdGljIGludCBo YW5kbGVfaW52YWxpZF9vcChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCiAKIHN0YXRpYyBpbnQgaGFu ZGxlX21vbml0b3JfdHJhcChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCiB7CisJa3ZtaV9zaW5nbGVz dGVwX2RvbmUodmNwdSk7CiAJcmV0dXJuIDE7CiB9CiAKQEAgLTYxNDIsNiArNjE0MywxMSBAQCBz dGF0aWMgaW50IHZteF9oYW5kbGVfZXhpdChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIGZhc3RwYXRo X3QgZXhpdF9mYXN0cGF0aCkKIAkJfQogCX0KIAorCWlmIChrdm1pX3ZjcHVfcnVubmluZ19zaW5n bGVzdGVwKHZjcHUpICYmCisJICAgIGV4aXRfcmVhc29uICE9IEVYSVRfUkVBU09OX0VQVF9WSU9M QVRJT04gJiYKKwkgICAgZXhpdF9yZWFzb24gIT0gRVhJVF9SRUFTT05fTU9OSVRPUl9UUkFQX0ZM QUcpCisJCWt2bWlfc2luZ2xlc3RlcF9mYWlsZWQodmNwdSk7CisKIAlpZiAoZXhpdF9mYXN0cGF0 aCAhPSBFWElUX0ZBU1RQQVRIX05PTkUpCiAJCXJldHVybiAxOwogCmRpZmYgLS1naXQgYS9pbmNs dWRlL2xpbnV4L2t2bWlfaG9zdC5oIGIvaW5jbHVkZS9saW51eC9rdm1pX2hvc3QuaAppbmRleCBl MjEwM2FiOWQwZDUuLmVjMzhlNDM0YzhlOSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9rdm1p X2hvc3QuaAorKysgYi9pbmNsdWRlL2xpbnV4L2t2bWlfaG9zdC5oCkBAIC04MSw2ICs4MSw4IEBA IHZvaWQga3ZtaV9oYW5kbGVfcmVxdWVzdHMoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KTsKIGJvb2wg a3ZtaV9oeXBlcmNhbGxfZXZlbnQoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KTsKIGJvb2wga3ZtaV9i cmVha3BvaW50X2V2ZW50KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgdTY0IGd2YSwgdTggaW5zbl9s ZW4pOwogYm9vbCBrdm1pX3ZjcHVfcnVubmluZ19zaW5nbGVzdGVwKHN0cnVjdCBrdm1fdmNwdSAq dmNwdSk7Cit2b2lkIGt2bWlfc2luZ2xlc3RlcF9kb25lKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSk7 Cit2b2lkIGt2bWlfc2luZ2xlc3RlcF9mYWlsZWQoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KTsKIAog I2Vsc2UKIApAQCAtOTcsNiArOTksOCBAQCBzdGF0aWMgaW5saW5lIGJvb2wga3ZtaV9icmVha3Bv aW50X2V2ZW50KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgdTY0IGd2YSwKIAkJCQkJIHU4IGluc25f bGVuKSB7IHJldHVybiB0cnVlOyB9CiBzdGF0aWMgaW5saW5lIGJvb2wga3ZtaV92Y3B1X3J1bm5p bmdfc2luZ2xlc3RlcChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCiAJCQl7IHJldHVybiBmYWxzZTsg fQorc3RhdGljIGlubGluZSB2b2lkIGt2bWlfc2luZ2xlc3RlcF9kb25lKHN0cnVjdCBrdm1fdmNw dSAqdmNwdSkgeyB9CitzdGF0aWMgaW5saW5lIHZvaWQga3ZtaV9zaW5nbGVzdGVwX2ZhaWxlZChz dHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpIHsgfQogCiAjZW5kaWYgLyogQ09ORklHX0tWTV9JTlRST1NQ RUNUSU9OICovCiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9saW51eC9rdm1pLmggYi9pbmNs dWRlL3VhcGkvbGludXgva3ZtaS5oCmluZGV4IDkxMTI2NjA3YjdlYi4uOWM2NDYyMjlhMjVhIDEw MDY0NAotLS0gYS9pbmNsdWRlL3VhcGkvbGludXgva3ZtaS5oCisrKyBiL2luY2x1ZGUvdWFwaS9s aW51eC9rdm1pLmgKQEAgLTc0LDYgKzc0LDcgQEAgZW51bSB7CiAJS1ZNSV9WQ1BVX0VWRU5UX0RF U0NSSVBUT1IgPSBLVk1JX1ZDUFVfRVZFTlRfSUQoNiksCiAJS1ZNSV9WQ1BVX0VWRU5UX01TUiAg ICAgICAgPSBLVk1JX1ZDUFVfRVZFTlRfSUQoNyksCiAJS1ZNSV9WQ1BVX0VWRU5UX1BGICAgICAg ICAgPSBLVk1JX1ZDUFVfRVZFTlRfSUQoOCksCisJS1ZNSV9WQ1BVX0VWRU5UX1NJTkdMRVNURVAg PSBLVk1JX1ZDUFVfRVZFTlRfSUQoOSksCiAKIAlLVk1JX05FWFRfVkNQVV9FVkVOVAogfTsKQEAg LTIyNyw0ICsyMjgsOSBAQCBzdHJ1Y3Qga3ZtaV92Y3B1X2NvbnRyb2xfc2luZ2xlc3RlcCB7CiAJ X191OCBwYWRkaW5nWzddOwogfTsKIAorc3RydWN0IGt2bWlfdmNwdV9ldmVudF9zaW5nbGVzdGVw IHsKKwlfX3U4IGZhaWxlZDsKKwlfX3U4IHBhZGRpbmdbN107Cit9OworCiAjZW5kaWYgLyogX1VB UElfX0xJTlVYX0tWTUlfSCAqLwpkaWZmIC0tZ2l0IGEvdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMv a3ZtL3g4Nl82NC9rdm1pX3Rlc3QuYyBiL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2t2bS94ODZf NjQva3ZtaV90ZXN0LmMKaW5kZXggZDk1OTIxNmFhYzlkLi5jNmY0MWY1NGY5YjAgMTAwNjQ0Ci0t LSBhL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2t2bS94ODZfNjQva3ZtaV90ZXN0LmMKKysrIGIv dG9vbHMvdGVzdGluZy9zZWxmdGVzdHMva3ZtL3g4Nl82NC9rdm1pX3Rlc3QuYwpAQCAtMTgzNCwx MiArMTgzNCw2MCBAQCBzdGF0aWMgdm9pZCBjbWRfdmNwdV9zaW5nbGVzdGVwKHN0cnVjdCBrdm1f dm0gKnZtLCBfX3U4IGVuYWJsZSwKIAkJCSAgICZyZXEuaGRyLCBzaXplb2YocmVxKSwgTlVMTCwg MCwgZXhwZWN0ZWRfZXJyKTsKIH0KIAorc3RhdGljIHZvaWQgX19jb250cm9sX3NpbmdsZXN0ZXAo Ym9vbCBlbmFibGUpCit7CisJc3RydWN0IHsKKwkJc3RydWN0IGt2bWlfbXNnX2hkciBoZHI7CisJ CXN0cnVjdCBrdm1pX3ZjcHVfaGRyIHZjcHVfaGRyOworCQlzdHJ1Y3Qga3ZtaV92Y3B1X2NvbnRy b2xfc2luZ2xlc3RlcCBjbWQ7CisJfSByZXEgPSB7fTsKKwlpbnQgcjsKKworCXJlcS5jbWQuZW5h YmxlID0gZW5hYmxlID8gMSA6IDA7CisKKwlyID0gX19kb192Y3B1MF9jb21tYW5kKEtWTUlfVkNQ VV9DT05UUk9MX1NJTkdMRVNURVAsCisJCQkgICAgICZyZXEuaGRyLCBzaXplb2YocmVxKSwgTlVM TCwgMCk7CisJVEVTVF9BU1NFUlQociA9PSAwLAorCQkiS1ZNSV9WQ1BVX0NPTlRST0xfU0lOR0xF U1RFUCBmYWlsZWQsIGVycm9yICVkKCVzKVxuIiwKKwkJLXIsIGt2bV9zdHJlcnJvcigtcikpOwor fQorCitzdGF0aWMgdm9pZCB0ZXN0X3NpbmdsZXN0ZXBfZXZlbnQoX191MTYgZXZlbnRfaWQpCit7 CisJc3RydWN0IHsKKwkJc3RydWN0IHZjcHVfZXZlbnQgdmNwdV9ldjsKKwkJc3RydWN0IGt2bWlf dmNwdV9ldmVudF9zaW5nbGVzdGVwIHNpbmdsZXN0ZXA7CisJfSBldjsKKwlib29sIGVuYWJsZSA9 IHRydWUsIGRpc2FibGUgPSBmYWxzZTsKKwlzdHJ1Y3QgdmNwdV9yZXBseSBycGwgPSB7IH07CisJ c3RydWN0IGt2bWlfbXNnX2hkciBoZHI7CisKKwlfX2NvbnRyb2xfc2luZ2xlc3RlcChlbmFibGUp OworCisJcmVjZWl2ZV92Y3B1X2V2ZW50KCZoZHIsICZldi52Y3B1X2V2LCBzaXplb2YoZXYpLCBl dmVudF9pZCk7CisKKwlwcl9kZWJ1ZygiU0lOR0xFU1RFUCBldmVudCwgcmlwIDB4JWxseCBzdWNj ZXNzICVkXG4iLAorCQkgZXYudmNwdV9ldi5jb21tb24uYXJjaC5yZWdzLnJpcCwgIWV2LnNpbmds ZXN0ZXAuZmFpbGVkKTsKKwlURVNUX0FTU0VSVCghZXYuc2luZ2xlc3RlcC5mYWlsZWQsICJTaW5n bGVzdGVwIGZhaWxlZCIpOworCisJX19jb250cm9sX3NpbmdsZXN0ZXAoZGlzYWJsZSk7CisKKwly ZXBseV90b19ldmVudCgmaGRyLCAmZXYudmNwdV9ldiwgS1ZNSV9FVkVOVF9BQ1RJT05fQ09OVElO VUUsCisJCSAgICAgICAmcnBsLCBzaXplb2YocnBsKSk7Cit9CisKIHN0YXRpYyB2b2lkIHRlc3Rf c3VwcG9ydGVkX3NpbmdsZXN0ZXAoc3RydWN0IGt2bV92bSAqdm0pCiB7Ci0JX191OCBkaXNhYmxl ID0gMCwgZW5hYmxlID0gMSwgZW5hYmxlX2ludmFsID0gMjsKKwlzdHJ1Y3QgdmNwdV93b3JrZXJf ZGF0YSBkYXRhID0gey52bSA9IHZtLCAudmNwdV9pZCA9IFZDUFVfSUQgfTsKKwlfX3UxNiBldmVu dF9pZCA9IEtWTUlfVkNQVV9FVkVOVF9TSU5HTEVTVEVQOworCV9fdTggZW5hYmxlX2ludmFsID0g MjsKKwlwdGhyZWFkX3QgdmNwdV90aHJlYWQ7CiAKLQljbWRfdmNwdV9zaW5nbGVzdGVwKHZtLCBl bmFibGUsIDApOwotCWNtZF92Y3B1X3NpbmdsZXN0ZXAodm0sIGRpc2FibGUsIDApOworCWVuYWJs ZV92Y3B1X2V2ZW50KHZtLCBldmVudF9pZCk7CisJdmNwdV90aHJlYWQgPSBzdGFydF92Y3B1X3dv cmtlcigmZGF0YSk7CisJdGVzdF9zaW5nbGVzdGVwX2V2ZW50KGV2ZW50X2lkKTsKKwl3YWl0X3Zj cHVfd29ya2VyKHZjcHVfdGhyZWFkKTsKKwlkaXNhYmxlX3ZjcHVfZXZlbnQodm0sIGV2ZW50X2lk KTsKIAogCWNtZF92Y3B1X3NpbmdsZXN0ZXAodm0sIGVuYWJsZV9pbnZhbCwgLUtWTV9FSU5WQUwp OwogfQpkaWZmIC0tZ2l0IGEvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pLmMgYi92aXJ0L2t2 bS9pbnRyb3NwZWN0aW9uL2t2bWkuYwppbmRleCAzOGQzY2RlNDc3NDAuLjRmOWRhNzZjNjc3NyAx MDA2NDQKLS0tIGEvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pLmMKKysrIGIvdmlydC9rdm0v aW50cm9zcGVjdGlvbi9rdm1pLmMKQEAgLTExOTMsMyArMTE5Myw0NiBAQCBib29sIGt2bWlfdmNw dV9ydW5uaW5nX3NpbmdsZXN0ZXAoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQogCXJldHVybiByZXQ7 CiB9CiBFWFBPUlRfU1lNQk9MKGt2bWlfdmNwdV9ydW5uaW5nX3NpbmdsZXN0ZXApOworCitzdGF0 aWMgdm9pZCBrdm1pX3NpbmdsZXN0ZXBfZXZlbnQoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBib29s IHN1Y2Nlc3MpCit7CisJdTMyIGFjdGlvbjsKKworCWFjdGlvbiA9IGt2bWlfbXNnX3NlbmRfdmNw dV9zaW5nbGVzdGVwKHZjcHUsIHN1Y2Nlc3MpOworCXN3aXRjaCAoYWN0aW9uKSB7CisJY2FzZSBL Vk1JX0VWRU5UX0FDVElPTl9DT05USU5VRToKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJa3ZtaV9o YW5kbGVfY29tbW9uX2V2ZW50X2FjdGlvbnModmNwdSwgYWN0aW9uKTsKKwl9Cit9CisKK3N0YXRp YyB2b2lkIGt2bWlfaGFuZGxlX3NpbmdsZXN0ZXBfZXhpdChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUs IGJvb2wgc3VjY2VzcykKK3sKKwlzdHJ1Y3Qga3ZtX3ZjcHVfaW50cm9zcGVjdGlvbiAqdmNwdWk7 CisJc3RydWN0IGt2bV9pbnRyb3NwZWN0aW9uICprdm1pOworCXN0cnVjdCBrdm0gKmt2bSA9IHZj cHUtPmt2bTsKKworCWt2bWkgPSBrdm1pX2dldChrdm0pOworCWlmICgha3ZtaSkKKwkJcmV0dXJu OworCisJdmNwdWkgPSBWQ1BVSSh2Y3B1KTsKKworCWlmICh2Y3B1aS0+c2luZ2xlc3RlcC5sb29w KQorCQlrdm1pX3NpbmdsZXN0ZXBfZXZlbnQodmNwdSwgc3VjY2Vzcyk7CisKKwlrdm1pX3B1dChr dm0pOworfQorCit2b2lkIGt2bWlfc2luZ2xlc3RlcF9kb25lKHN0cnVjdCBrdm1fdmNwdSAqdmNw dSkKK3sKKwlrdm1pX2hhbmRsZV9zaW5nbGVzdGVwX2V4aXQodmNwdSwgdHJ1ZSk7Cit9CitFWFBP UlRfU1lNQk9MKGt2bWlfc2luZ2xlc3RlcF9kb25lKTsKKwordm9pZCBrdm1pX3NpbmdsZXN0ZXBf ZmFpbGVkKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSkKK3sKKwlrdm1pX2hhbmRsZV9zaW5nbGVzdGVw X2V4aXQodmNwdSwgZmFsc2UpOworfQorRVhQT1JUX1NZTUJPTChrdm1pX3NpbmdsZXN0ZXBfZmFp bGVkKTsKZGlmZiAtLWdpdCBhL3ZpcnQva3ZtL2ludHJvc3BlY3Rpb24va3ZtaV9pbnQuaCBiL3Zp cnQva3ZtL2ludHJvc3BlY3Rpb24va3ZtaV9pbnQuaAppbmRleCA0ODE1ZmE2MWIxMzYuLjVmNGJj ZGYyN2Q2YSAxMDA2NDQKLS0tIGEvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pX2ludC5oCisr KyBiL3ZpcnQva3ZtL2ludHJvc3BlY3Rpb24va3ZtaV9pbnQuaApAQCAtNjQsNiArNjQsNyBAQCB1 MzIga3ZtaV9tc2dfc2VuZF92Y3B1X3BhdXNlKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSk7CiB1MzIg a3ZtaV9tc2dfc2VuZF92Y3B1X2h5cGVyY2FsbChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpOwogdTMy IGt2bWlfbXNnX3NlbmRfdmNwdV9icChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIHU2NCBncGEsIHU4 IGluc25fbGVuKTsKIHUzMiBrdm1pX21zZ19zZW5kX3ZjcHVfcGYoc3RydWN0IGt2bV92Y3B1ICp2 Y3B1LCB1NjQgZ3BhLCB1NjQgZ3ZhLCB1OCBhY2Nlc3MpOwordTMyIGt2bWlfbXNnX3NlbmRfdmNw dV9zaW5nbGVzdGVwKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgYm9vbCBzdWNjZXNzKTsKIAogLyog a3ZtaS5jICovCiB2b2lkICprdm1pX21zZ19hbGxvYyh2b2lkKTsKZGlmZiAtLWdpdCBhL3ZpcnQv a3ZtL2ludHJvc3BlY3Rpb24va3ZtaV9tc2cuYyBiL3ZpcnQva3ZtL2ludHJvc3BlY3Rpb24va3Zt aV9tc2cuYwppbmRleCBmYzAzMjIzZDExNWYuLmFkMmYzNjQ2NTg2NCAxMDA2NDQKLS0tIGEvdmly dC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pX21zZy5jCisrKyBiL3ZpcnQva3ZtL2ludHJvc3BlY3Rp b24va3ZtaV9tc2cuYwpAQCAtODk2LDMgKzg5NiwyMCBAQCB1MzIga3ZtaV9tc2dfc2VuZF92Y3B1 X3BmKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgdTY0IGdwYSwgdTY0IGd2YSwgdTggYWNjZXNzKQog CiAJcmV0dXJuIGFjdGlvbjsKIH0KKwordTMyIGt2bWlfbXNnX3NlbmRfdmNwdV9zaW5nbGVzdGVw KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgYm9vbCBzdWNjZXNzKQoreworCXN0cnVjdCBrdm1pX3Zj cHVfZXZlbnRfc2luZ2xlc3RlcCBlOworCXUzMiBhY3Rpb247CisJaW50IGVycjsKKworCW1lbXNl dCgmZSwgMCwgc2l6ZW9mKGUpKTsKKwllLmZhaWxlZCA9IHN1Y2Nlc3MgPyAwIDogMTsKKworCWVy ciA9IGt2bWlfc2VuZF92Y3B1X2V2ZW50KHZjcHUsIEtWTUlfVkNQVV9FVkVOVF9TSU5HTEVTVEVQ LAorCQkJCSAgICZlLCBzaXplb2YoZSksIE5VTEwsIDAsICZhY3Rpb24pOworCWlmIChlcnIpCisJ CXJldHVybiBLVk1JX0VWRU5UX0FDVElPTl9DT05USU5VRTsKKworCXJldHVybiBhY3Rpb247Cit9 Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClZpcnR1YWxp emF0aW9uIG1haWxpbmcgbGlzdApWaXJ0dWFsaXphdGlvbkBsaXN0cy5saW51eC1mb3VuZGF0aW9u Lm9yZwpodHRwczovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby92 aXJ0dWFsaXphdGlvbg==