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 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E591BC433F5 for ; Wed, 6 Oct 2021 17:41:29 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id CA5E76052B for ; Wed, 6 Oct 2021 17:41:29 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239687AbhJFRnQ (ORCPT ); Wed, 6 Oct 2021 13:43:16 -0400 Received: from mx01.bbu.dsd.mx.bitdefender.com ([91.199.104.161]:53648 "EHLO mx01.bbu.dsd.mx.bitdefender.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239260AbhJFRml (ORCPT ); Wed, 6 Oct 2021 13:42:41 -0400 Received: from smtp.bitdefender.com (smtp01.buh.bitdefender.com [10.17.80.75]) by mx01.bbu.dsd.mx.bitdefender.com (Postfix) with ESMTPS id 7BA2C307CAEF; Wed, 6 Oct 2021 20:31:04 +0300 (EEST) Received: from localhost (unknown [91.199.104.28]) by smtp.bitdefender.com (Postfix) with ESMTPSA id 5E389305FFA0; Wed, 6 Oct 2021 20:31:04 +0300 (EEST) X-Is-Junk-Enabled: fGZTSsP0qEJE2AIKtlSuFiRRwg9xyHmJ From: =?UTF-8?q?Adalbert=20Laz=C4=83r?= To: kvm@vger.kernel.org Cc: virtualization@lists.linux-foundation.org, Paolo Bonzini , Sean Christopherson , Vitaly Kuznetsov , Wanpeng Li , Jim Mattson , Joerg Roedel , Mathieu Tarral , Tamas K Lengyel , =?UTF-8?q?Mihai=20Don=C8=9Bu?= , Marian Rotariu , =?UTF-8?q?=C8=98tefan=20=C8=98icleru?= , =?UTF-8?q?Adalbert=20Laz=C4=83r?= Subject: [PATCH v12 27/77] KVM: x86: wire in the preread/prewrite/preexec page trackers Date: Wed, 6 Oct 2021 20:30:23 +0300 Message-Id: <20211006173113.26445-28-alazar@bitdefender.com> In-Reply-To: <20211006173113.26445-1-alazar@bitdefender.com> References: <20211006173113.26445-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: Mihai Donțu These are needed in order to notify the introspection tool when read/write/execute access happens on one of the tracked memory pages. Also, this patch adds the case when the introspection tool requests that the vCPU re-enter in guest (and abort the emulation of the current instruction). Signed-off-by: Mihai Donțu Co-developed-by: Marian Rotariu Signed-off-by: Marian Rotariu Co-developed-by: Ștefan Șicleru Signed-off-by: Ștefan Șicleru Signed-off-by: Adalbert Lazăr --- arch/x86/kvm/emulate.c | 4 ++++ arch/x86/kvm/kvm_emulate.h | 1 + arch/x86/kvm/mmu/mmu.c | 42 +++++++++++++++++++++++++---------- arch/x86/kvm/mmu/spte.c | 23 +++++++++++++++++++ arch/x86/kvm/x86.c | 45 ++++++++++++++++++++++++++++++-------- 5 files changed, 94 insertions(+), 21 deletions(-) diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c index c589ac832265..5e3e8cb0375e 100644 --- a/arch/x86/kvm/emulate.c +++ b/arch/x86/kvm/emulate.c @@ -5307,6 +5307,8 @@ int x86_decode_insn(struct x86_emulate_ctxt *ctxt, void *insn, int insn_len, int ctxt->memopp->addr.mem.ea + ctxt->_eip); done: + if (rc == X86EMUL_RETRY_INSTR) + return EMULATION_RETRY_INSTR; if (rc == X86EMUL_PROPAGATE_FAULT) ctxt->have_exception = true; return (rc != X86EMUL_CONTINUE) ? EMULATION_FAILED : EMULATION_OK; @@ -5678,6 +5680,8 @@ int x86_emulate_insn(struct x86_emulate_ctxt *ctxt) if (rc == X86EMUL_INTERCEPTED) return EMULATION_INTERCEPTED; + if (rc == X86EMUL_RETRY_INSTR) + return EMULATION_RETRY_INSTR; if (rc == X86EMUL_CONTINUE) writeback_registers(ctxt); diff --git a/arch/x86/kvm/kvm_emulate.h b/arch/x86/kvm/kvm_emulate.h index 68b420289d7e..1752679f8cd3 100644 --- a/arch/x86/kvm/kvm_emulate.h +++ b/arch/x86/kvm/kvm_emulate.h @@ -494,6 +494,7 @@ bool x86_page_table_writing_insn(struct x86_emulate_ctxt *ctxt); #define EMULATION_OK 0 #define EMULATION_RESTART 1 #define EMULATION_INTERCEPTED 2 +#define EMULATION_RETRY_INSTR 3 void init_decode_cache(struct x86_emulate_ctxt *ctxt); int x86_emulate_insn(struct x86_emulate_ctxt *ctxt); int emulator_task_switch(struct x86_emulate_ctxt *ctxt, diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c index 8124fdd78aad..b5685e342945 100644 --- a/arch/x86/kvm/mmu/mmu.c +++ b/arch/x86/kvm/mmu/mmu.c @@ -837,9 +837,13 @@ static void account_shadowed(struct kvm *kvm, struct kvm_mmu_page *sp) slot = __gfn_to_memslot(slots, gfn); /* the non-leaf shadow pages are keeping readonly. */ - if (sp->role.level > PG_LEVEL_4K) - return kvm_slot_page_track_add_page(kvm, slot, gfn, - KVM_PAGE_TRACK_WRITE); + if (sp->role.level > PG_LEVEL_4K) { + kvm_slot_page_track_add_page(kvm, slot, gfn, + KVM_PAGE_TRACK_PREWRITE); + kvm_slot_page_track_add_page(kvm, slot, gfn, + KVM_PAGE_TRACK_WRITE); + return; + } kvm_mmu_gfn_disallow_lpage(slot, gfn); } @@ -865,9 +869,13 @@ static void unaccount_shadowed(struct kvm *kvm, struct kvm_mmu_page *sp) gfn = sp->gfn; slots = kvm_memslots_for_spte_role(kvm, sp->role); slot = __gfn_to_memslot(slots, gfn); - if (sp->role.level > PG_LEVEL_4K) - return kvm_slot_page_track_remove_page(kvm, slot, gfn, - KVM_PAGE_TRACK_WRITE); + if (sp->role.level > PG_LEVEL_4K) { + kvm_slot_page_track_remove_page(kvm, slot, gfn, + KVM_PAGE_TRACK_PREWRITE); + kvm_slot_page_track_remove_page(kvm, slot, gfn, + KVM_PAGE_TRACK_WRITE); + return; + } kvm_mmu_gfn_allow_lpage(slot, gfn); } @@ -2678,7 +2686,10 @@ int mmu_try_to_unsync_pages(struct kvm_vcpu *vcpu, struct kvm_memory_slot *slot, * track machinery is used to write-protect upper-level shadow pages, * i.e. this guards the role.level == 4K assertion below! */ - if (kvm_slot_page_track_is_active(vcpu, slot, gfn, KVM_PAGE_TRACK_WRITE)) + if (kvm_slot_page_track_is_active(vcpu, slot, gfn, + KVM_PAGE_TRACK_WRITE) || + kvm_slot_page_track_is_active(vcpu, slot, gfn, + KVM_PAGE_TRACK_PREWRITE)) return -EPERM; /* @@ -3882,14 +3893,21 @@ static bool page_fault_handle_page_track(struct kvm_vcpu *vcpu, if (unlikely(fault->rsvd)) return false; - if (!fault->present || !fault->write) - return false; - /* - * guest is writing the page which is write tracked which can + * guest is reading/writing/fetching the page which is + * read/write/execute tracked which can * not be fixed by page fault handler. */ - if (kvm_slot_page_track_is_active(vcpu, fault->slot, fault->gfn, KVM_PAGE_TRACK_WRITE)) + if ((fault->user && kvm_slot_page_track_is_active(vcpu, fault->slot, + fault->gfn, KVM_PAGE_TRACK_PREREAD)) + || (fault->write && (kvm_slot_page_track_is_active(vcpu, + fault->slot, fault->gfn, + KVM_PAGE_TRACK_PREWRITE) + || kvm_slot_page_track_is_active(vcpu, + fault->slot, fault->gfn, + KVM_PAGE_TRACK_WRITE))) + || (fault->exec && kvm_slot_page_track_is_active(vcpu, fault->slot, + fault->gfn, KVM_PAGE_TRACK_PREEXEC))) return true; return false; diff --git a/arch/x86/kvm/mmu/spte.c b/arch/x86/kvm/mmu/spte.c index 871f6114b0fa..f4147533222d 100644 --- a/arch/x86/kvm/mmu/spte.c +++ b/arch/x86/kvm/mmu/spte.c @@ -89,6 +89,26 @@ static bool kvm_is_mmio_pfn(kvm_pfn_t pfn) E820_TYPE_RAM); } +static unsigned int +kvm_mmu_apply_introspection_access(struct kvm_vcpu *vcpu, + struct kvm_memory_slot *slot, + gfn_t gfn, unsigned int acc) +{ + if (kvm_slot_page_track_is_active(vcpu, slot, gfn, + KVM_PAGE_TRACK_PREREAD)) + acc &= ~ACC_USER_MASK; + if (kvm_slot_page_track_is_active(vcpu, slot, gfn, + KVM_PAGE_TRACK_PREWRITE) || + kvm_slot_page_track_is_active(vcpu, slot, gfn, + KVM_PAGE_TRACK_WRITE)) + acc &= ~ACC_WRITE_MASK; + if (kvm_slot_page_track_is_active(vcpu, slot, gfn, + KVM_PAGE_TRACK_PREEXEC)) + acc &= ~ACC_EXEC_MASK; + + return acc; +} + bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp, struct kvm_memory_slot *slot, unsigned int pte_access, gfn_t gfn, kvm_pfn_t pfn, @@ -99,6 +119,9 @@ bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp, u64 spte = SPTE_MMU_PRESENT_MASK; bool wrprot = false; + pte_access = kvm_mmu_apply_introspection_access(vcpu, slot, gfn, + pte_access); + if (sp->role.ad_disabled) spte |= SPTE_TDP_AD_DISABLED_MASK; else if (kvm_vcpu_ad_need_write_protect(vcpu)) diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index 723ef3b7f95f..c52ac5e9a020 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -6388,6 +6388,8 @@ static int kvm_read_guest_virt_helper(gva_t addr, void *val, unsigned int bytes, if (gpa == UNMAPPED_GVA) return X86EMUL_PROPAGATE_FAULT; + if (!kvm_page_track_preread(vcpu, gpa, addr, toread)) + return X86EMUL_RETRY_INSTR; ret = kvm_vcpu_read_guest_page(vcpu, gpa >> PAGE_SHIFT, data, offset, toread); if (ret < 0) { @@ -6419,6 +6421,9 @@ static int kvm_fetch_guest_virt(struct x86_emulate_ctxt *ctxt, if (unlikely(gpa == UNMAPPED_GVA)) return X86EMUL_PROPAGATE_FAULT; + if (!kvm_page_track_preexec(vcpu, gpa, addr)) + return X86EMUL_RETRY_INSTR; + offset = addr & (PAGE_SIZE-1); if (WARN_ON(offset + bytes > PAGE_SIZE)) bytes = (unsigned)PAGE_SIZE - offset; @@ -6487,11 +6492,14 @@ static int kvm_write_guest_virt_helper(gva_t addr, void *val, unsigned int bytes if (gpa == UNMAPPED_GVA) return X86EMUL_PROPAGATE_FAULT; + if (!kvm_page_track_prewrite(vcpu, gpa, addr, data, towrite)) + return X86EMUL_RETRY_INSTR; ret = kvm_vcpu_write_guest(vcpu, gpa, data, towrite); if (ret < 0) { r = X86EMUL_IO_NEEDED; goto out; } + kvm_page_track_write(vcpu, gpa, addr, data, towrite); bytes -= towrite; data += towrite; @@ -6595,13 +6603,22 @@ static int vcpu_mmio_gva_to_gpa(struct kvm_vcpu *vcpu, unsigned long gva, int emulator_write_phys(struct kvm_vcpu *vcpu, gpa_t gpa, gva_t gva, const void *val, int bytes) { - int ret; - - ret = kvm_vcpu_write_guest(vcpu, gpa, val, bytes); - if (ret < 0) - return 0; + if (!kvm_page_track_prewrite(vcpu, gpa, gva, val, bytes)) + return X86EMUL_RETRY_INSTR; + if (kvm_vcpu_write_guest(vcpu, gpa, val, bytes) < 0) + return X86EMUL_UNHANDLEABLE; kvm_page_track_write(vcpu, gpa, gva, val, bytes); - return 1; + return X86EMUL_CONTINUE; +} + +static int emulator_read_phys(struct kvm_vcpu *vcpu, gpa_t gpa, gva_t gva, + void *val, int bytes) +{ + if (!kvm_page_track_preread(vcpu, gpa, gva, bytes)) + return X86EMUL_RETRY_INSTR; + if (kvm_vcpu_read_guest(vcpu, gpa, val, bytes) < 0) + return X86EMUL_UNHANDLEABLE; + return X86EMUL_CONTINUE; } struct read_write_emulator_ops { @@ -6631,7 +6648,7 @@ static int read_prepare(struct kvm_vcpu *vcpu, void *val, int bytes) static int read_emulate(struct kvm_vcpu *vcpu, gpa_t gpa, gva_t gva, void *val, int bytes) { - return !kvm_vcpu_read_guest(vcpu, gpa, val, bytes); + return emulator_read_phys(vcpu, gpa, gva, val, bytes); } static int write_emulate(struct kvm_vcpu *vcpu, gpa_t gpa, gva_t gva, @@ -6705,8 +6722,11 @@ static int emulator_read_write_onepage(unsigned long addr, void *val, return X86EMUL_PROPAGATE_FAULT; } - if (!ret && ops->read_write_emulate(vcpu, gpa, addr, val, bytes)) - return X86EMUL_CONTINUE; + if (!ret) { + ret = ops->read_write_emulate(vcpu, gpa, addr, val, bytes); + if (ret == X86EMUL_CONTINUE || ret == X86EMUL_RETRY_INSTR) + return ret; + } /* * Is this MMIO handled locally? @@ -6850,6 +6870,9 @@ static int emulator_cmpxchg_emulated(struct x86_emulate_ctxt *ctxt, if (kvm_vcpu_map(vcpu, gpa_to_gfn(gpa), &map)) goto emul_write; + if (!kvm_page_track_prewrite(vcpu, gpa, addr, new, bytes)) + return X86EMUL_RETRY_INSTR; + kaddr = map.hva + offset_in_page(gpa); switch (bytes) { @@ -7850,6 +7873,8 @@ int x86_emulate_instruction(struct kvm_vcpu *vcpu, gpa_t cr2_or_gpa, r = x86_decode_emulated_instruction(vcpu, emulation_type, insn, insn_len); + if (r == EMULATION_RETRY_INSTR) + return 1; if (r != EMULATION_OK) { if ((emulation_type & EMULTYPE_TRAP_UD) || (emulation_type & EMULTYPE_TRAP_UD_FORCED)) { @@ -7919,6 +7944,8 @@ int x86_emulate_instruction(struct kvm_vcpu *vcpu, gpa_t cr2_or_gpa, r = x86_emulate_insn(ctxt); + if (r == EMULATION_RETRY_INSTR) + return 1; if (r == EMULATION_INTERCEPTED) return 1; 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 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7C783C433EF for ; Wed, 6 Oct 2021 17:41:06 +0000 (UTC) Received: from smtp1.osuosl.org (smtp1.osuosl.org [140.211.166.138]) (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 4A9266113A for ; Wed, 6 Oct 2021 17:41:06 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 4A9266113A Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=bitdefender.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by smtp1.osuosl.org (Postfix) with ESMTP id 6CE35840B1; Wed, 6 Oct 2021 17:41:04 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp1.osuosl.org ([127.0.0.1]) by localhost (smtp1.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id w3Z_iT1uEtfJ; Wed, 6 Oct 2021 17:41:01 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp1.osuosl.org (Postfix) with ESMTPS id 1257684073; Wed, 6 Oct 2021 17:41:00 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id DCD92C0034; Wed, 6 Oct 2021 17:40:56 +0000 (UTC) Received: from smtp4.osuosl.org (smtp4.osuosl.org [IPv6:2605:bc80:3010::137]) by lists.linuxfoundation.org (Postfix) with ESMTP id 221C2C000D for ; Wed, 6 Oct 2021 17:40:51 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp4.osuosl.org (Postfix) with ESMTP id 31F0E408DF for ; Wed, 6 Oct 2021 17:40:48 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp4.osuosl.org ([127.0.0.1]) by localhost (smtp4.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id S329bt41xTDX for ; Wed, 6 Oct 2021 17:40:47 +0000 (UTC) X-Greylist: from auto-whitelisted by SQLgrey-1.8.0 Received: from mx01.bbu.dsd.mx.bitdefender.com (mx01.bbu.dsd.mx.bitdefender.com [91.199.104.161]) by smtp4.osuosl.org (Postfix) with ESMTPS id 0888B408E1 for ; Wed, 6 Oct 2021 17:40:46 +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 7BA2C307CAEF; Wed, 6 Oct 2021 20:31:04 +0300 (EEST) Received: from localhost (unknown [91.199.104.28]) by smtp.bitdefender.com (Postfix) with ESMTPSA id 5E389305FFA0; Wed, 6 Oct 2021 20:31:04 +0300 (EEST) X-Is-Junk-Enabled: fGZTSsP0qEJE2AIKtlSuFiRRwg9xyHmJ From: =?UTF-8?q?Adalbert=20Laz=C4=83r?= To: kvm@vger.kernel.org Subject: [PATCH v12 27/77] KVM: x86: wire in the preread/prewrite/preexec page trackers Date: Wed, 6 Oct 2021 20:30:23 +0300 Message-Id: <20211006173113.26445-28-alazar@bitdefender.com> In-Reply-To: <20211006173113.26445-1-alazar@bitdefender.com> References: <20211006173113.26445-1-alazar@bitdefender.com> MIME-Version: 1.0 Cc: Tamas K Lengyel , Wanpeng Li , Sean Christopherson , Joerg Roedel , =?UTF-8?q?=C8=98tefan=20=C8=98icleru?= , virtualization@lists.linux-foundation.org, =?UTF-8?q?Adalbert=20Laz=C4=83r?= , Marian Rotariu , Mathieu Tarral , Paolo Bonzini , =?UTF-8?q?Mihai=20Don=C8=9Bu?= , Jim Mattson 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" RnJvbTogTWloYWkgRG9uyJt1IDxtZG9udHVAYml0ZGVmZW5kZXIuY29tPgoKVGhlc2UgYXJlIG5l ZWRlZCBpbiBvcmRlciB0byBub3RpZnkgdGhlIGludHJvc3BlY3Rpb24gdG9vbCB3aGVuCnJlYWQv d3JpdGUvZXhlY3V0ZSBhY2Nlc3MgaGFwcGVucyBvbiBvbmUgb2YgdGhlIHRyYWNrZWQgbWVtb3J5 IHBhZ2VzLgoKQWxzbywgdGhpcyBwYXRjaCBhZGRzIHRoZSBjYXNlIHdoZW4gdGhlIGludHJvc3Bl Y3Rpb24gdG9vbCByZXF1ZXN0cwp0aGF0IHRoZSB2Q1BVIHJlLWVudGVyIGluIGd1ZXN0IChhbmQg YWJvcnQgdGhlIGVtdWxhdGlvbiBvZiB0aGUgY3VycmVudAppbnN0cnVjdGlvbikuCgpTaWduZWQt b2ZmLWJ5OiBNaWhhaSBEb27Im3UgPG1kb250dUBiaXRkZWZlbmRlci5jb20+CkNvLWRldmVsb3Bl ZC1ieTogTWFyaWFuIFJvdGFyaXUgPG1hcmlhbi5jLnJvdGFyaXVAZ21haWwuY29tPgpTaWduZWQt b2ZmLWJ5OiBNYXJpYW4gUm90YXJpdSA8bWFyaWFuLmMucm90YXJpdUBnbWFpbC5jb20+CkNvLWRl dmVsb3BlZC1ieTogyJh0ZWZhbiDImGljbGVydSA8c3NpY2xlcnVAYml0ZGVmZW5kZXIuY29tPgpT aWduZWQtb2ZmLWJ5OiDImHRlZmFuIMiYaWNsZXJ1IDxzc2ljbGVydUBiaXRkZWZlbmRlci5jb20+ ClNpZ25lZC1vZmYtYnk6IEFkYWxiZXJ0IExhesSDciA8YWxhemFyQGJpdGRlZmVuZGVyLmNvbT4K LS0tCiBhcmNoL3g4Ni9rdm0vZW11bGF0ZS5jICAgICB8ICA0ICsrKysKIGFyY2gveDg2L2t2bS9r dm1fZW11bGF0ZS5oIHwgIDEgKwogYXJjaC94ODYva3ZtL21tdS9tbXUuYyAgICAgfCA0MiArKysr KysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLQogYXJjaC94ODYva3ZtL21tdS9zcHRlLmMg ICAgfCAyMyArKysrKysrKysrKysrKysrKysrCiBhcmNoL3g4Ni9rdm0veDg2LmMgICAgICAgICB8 IDQ1ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tCiA1IGZpbGVzIGNoYW5n ZWQsIDk0IGluc2VydGlvbnMoKyksIDIxIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2FyY2gv eDg2L2t2bS9lbXVsYXRlLmMgYi9hcmNoL3g4Ni9rdm0vZW11bGF0ZS5jCmluZGV4IGM1ODlhYzgz MjI2NS4uNWUzZThjYjAzNzVlIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rdm0vZW11bGF0ZS5jCisr KyBiL2FyY2gveDg2L2t2bS9lbXVsYXRlLmMKQEAgLTUzMDcsNiArNTMwNyw4IEBAIGludCB4ODZf ZGVjb2RlX2luc24oc3RydWN0IHg4Nl9lbXVsYXRlX2N0eHQgKmN0eHQsIHZvaWQgKmluc24sIGlu dCBpbnNuX2xlbiwgaW50CiAJCQkJCWN0eHQtPm1lbW9wcC0+YWRkci5tZW0uZWEgKyBjdHh0LT5f ZWlwKTsKIAogZG9uZToKKwlpZiAocmMgPT0gWDg2RU1VTF9SRVRSWV9JTlNUUikKKwkJcmV0dXJu IEVNVUxBVElPTl9SRVRSWV9JTlNUUjsKIAlpZiAocmMgPT0gWDg2RU1VTF9QUk9QQUdBVEVfRkFV TFQpCiAJCWN0eHQtPmhhdmVfZXhjZXB0aW9uID0gdHJ1ZTsKIAlyZXR1cm4gKHJjICE9IFg4NkVN VUxfQ09OVElOVUUpID8gRU1VTEFUSU9OX0ZBSUxFRCA6IEVNVUxBVElPTl9PSzsKQEAgLTU2Nzgs NiArNTY4MCw4IEBAIGludCB4ODZfZW11bGF0ZV9pbnNuKHN0cnVjdCB4ODZfZW11bGF0ZV9jdHh0 ICpjdHh0KQogCWlmIChyYyA9PSBYODZFTVVMX0lOVEVSQ0VQVEVEKQogCQlyZXR1cm4gRU1VTEFU SU9OX0lOVEVSQ0VQVEVEOwogCisJaWYgKHJjID09IFg4NkVNVUxfUkVUUllfSU5TVFIpCisJCXJl dHVybiBFTVVMQVRJT05fUkVUUllfSU5TVFI7CiAJaWYgKHJjID09IFg4NkVNVUxfQ09OVElOVUUp CiAJCXdyaXRlYmFja19yZWdpc3RlcnMoY3R4dCk7CiAKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2t2 bS9rdm1fZW11bGF0ZS5oIGIvYXJjaC94ODYva3ZtL2t2bV9lbXVsYXRlLmgKaW5kZXggNjhiNDIw Mjg5ZDdlLi4xNzUyNjc5ZjhjZDMgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2t2bS9rdm1fZW11bGF0 ZS5oCisrKyBiL2FyY2gveDg2L2t2bS9rdm1fZW11bGF0ZS5oCkBAIC00OTQsNiArNDk0LDcgQEAg Ym9vbCB4ODZfcGFnZV90YWJsZV93cml0aW5nX2luc24oc3RydWN0IHg4Nl9lbXVsYXRlX2N0eHQg KmN0eHQpOwogI2RlZmluZSBFTVVMQVRJT05fT0sgMAogI2RlZmluZSBFTVVMQVRJT05fUkVTVEFS VCAxCiAjZGVmaW5lIEVNVUxBVElPTl9JTlRFUkNFUFRFRCAyCisjZGVmaW5lIEVNVUxBVElPTl9S RVRSWV9JTlNUUiAzCiB2b2lkIGluaXRfZGVjb2RlX2NhY2hlKHN0cnVjdCB4ODZfZW11bGF0ZV9j dHh0ICpjdHh0KTsKIGludCB4ODZfZW11bGF0ZV9pbnNuKHN0cnVjdCB4ODZfZW11bGF0ZV9jdHh0 ICpjdHh0KTsKIGludCBlbXVsYXRvcl90YXNrX3N3aXRjaChzdHJ1Y3QgeDg2X2VtdWxhdGVfY3R4 dCAqY3R4dCwKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2t2bS9tbXUvbW11LmMgYi9hcmNoL3g4Ni9r dm0vbW11L21tdS5jCmluZGV4IDgxMjRmZGQ3OGFhZC4uYjU2ODVlMzQyOTQ1IDEwMDY0NAotLS0g YS9hcmNoL3g4Ni9rdm0vbW11L21tdS5jCisrKyBiL2FyY2gveDg2L2t2bS9tbXUvbW11LmMKQEAg LTgzNyw5ICs4MzcsMTMgQEAgc3RhdGljIHZvaWQgYWNjb3VudF9zaGFkb3dlZChzdHJ1Y3Qga3Zt ICprdm0sIHN0cnVjdCBrdm1fbW11X3BhZ2UgKnNwKQogCXNsb3QgPSBfX2dmbl90b19tZW1zbG90 KHNsb3RzLCBnZm4pOwogCiAJLyogdGhlIG5vbi1sZWFmIHNoYWRvdyBwYWdlcyBhcmUga2VlcGlu ZyByZWFkb25seS4gKi8KLQlpZiAoc3AtPnJvbGUubGV2ZWwgPiBQR19MRVZFTF80SykKLQkJcmV0 dXJuIGt2bV9zbG90X3BhZ2VfdHJhY2tfYWRkX3BhZ2Uoa3ZtLCBzbG90LCBnZm4sCi0JCQkJCQkg ICAgS1ZNX1BBR0VfVFJBQ0tfV1JJVEUpOworCWlmIChzcC0+cm9sZS5sZXZlbCA+IFBHX0xFVkVM XzRLKSB7CisJCWt2bV9zbG90X3BhZ2VfdHJhY2tfYWRkX3BhZ2Uoa3ZtLCBzbG90LCBnZm4sCisJ CQkJCSAgICAgS1ZNX1BBR0VfVFJBQ0tfUFJFV1JJVEUpOworCQlrdm1fc2xvdF9wYWdlX3RyYWNr X2FkZF9wYWdlKGt2bSwgc2xvdCwgZ2ZuLAorCQkJCQkgICAgIEtWTV9QQUdFX1RSQUNLX1dSSVRF KTsKKwkJcmV0dXJuOworCX0KIAogCWt2bV9tbXVfZ2ZuX2Rpc2FsbG93X2xwYWdlKHNsb3QsIGdm bik7CiB9CkBAIC04NjUsOSArODY5LDEzIEBAIHN0YXRpYyB2b2lkIHVuYWNjb3VudF9zaGFkb3dl ZChzdHJ1Y3Qga3ZtICprdm0sIHN0cnVjdCBrdm1fbW11X3BhZ2UgKnNwKQogCWdmbiA9IHNwLT5n Zm47CiAJc2xvdHMgPSBrdm1fbWVtc2xvdHNfZm9yX3NwdGVfcm9sZShrdm0sIHNwLT5yb2xlKTsK IAlzbG90ID0gX19nZm5fdG9fbWVtc2xvdChzbG90cywgZ2ZuKTsKLQlpZiAoc3AtPnJvbGUubGV2 ZWwgPiBQR19MRVZFTF80SykKLQkJcmV0dXJuIGt2bV9zbG90X3BhZ2VfdHJhY2tfcmVtb3ZlX3Bh Z2Uoa3ZtLCBzbG90LCBnZm4sCi0JCQkJCQkgICAgICAgS1ZNX1BBR0VfVFJBQ0tfV1JJVEUpOwor CWlmIChzcC0+cm9sZS5sZXZlbCA+IFBHX0xFVkVMXzRLKSB7CisJCWt2bV9zbG90X3BhZ2VfdHJh Y2tfcmVtb3ZlX3BhZ2Uoa3ZtLCBzbG90LCBnZm4sCisJCQkJCQlLVk1fUEFHRV9UUkFDS19QUkVX UklURSk7CisJCWt2bV9zbG90X3BhZ2VfdHJhY2tfcmVtb3ZlX3BhZ2Uoa3ZtLCBzbG90LCBnZm4s CisJCQkJCQlLVk1fUEFHRV9UUkFDS19XUklURSk7CisJCXJldHVybjsKKwl9CiAKIAlrdm1fbW11 X2dmbl9hbGxvd19scGFnZShzbG90LCBnZm4pOwogfQpAQCAtMjY3OCw3ICsyNjg2LDEwIEBAIGlu dCBtbXVfdHJ5X3RvX3Vuc3luY19wYWdlcyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIHN0cnVjdCBr dm1fbWVtb3J5X3Nsb3QgKnNsb3QsCiAJICogdHJhY2sgbWFjaGluZXJ5IGlzIHVzZWQgdG8gd3Jp dGUtcHJvdGVjdCB1cHBlci1sZXZlbCBzaGFkb3cgcGFnZXMsCiAJICogaS5lLiB0aGlzIGd1YXJk cyB0aGUgcm9sZS5sZXZlbCA9PSA0SyBhc3NlcnRpb24gYmVsb3chCiAJICovCi0JaWYgKGt2bV9z bG90X3BhZ2VfdHJhY2tfaXNfYWN0aXZlKHZjcHUsIHNsb3QsIGdmbiwgS1ZNX1BBR0VfVFJBQ0tf V1JJVEUpKQorCWlmIChrdm1fc2xvdF9wYWdlX3RyYWNrX2lzX2FjdGl2ZSh2Y3B1LCBzbG90LCBn Zm4sCisJCQkJCQlLVk1fUEFHRV9UUkFDS19XUklURSkgfHwKKwkgICAga3ZtX3Nsb3RfcGFnZV90 cmFja19pc19hY3RpdmUodmNwdSwgc2xvdCwgZ2ZuLAorCQkJCQkJS1ZNX1BBR0VfVFJBQ0tfUFJF V1JJVEUpKQogCQlyZXR1cm4gLUVQRVJNOwogCiAJLyoKQEAgLTM4ODIsMTQgKzM4OTMsMjEgQEAg c3RhdGljIGJvb2wgcGFnZV9mYXVsdF9oYW5kbGVfcGFnZV90cmFjayhzdHJ1Y3Qga3ZtX3ZjcHUg KnZjcHUsCiAJaWYgKHVubGlrZWx5KGZhdWx0LT5yc3ZkKSkKIAkJcmV0dXJuIGZhbHNlOwogCi0J aWYgKCFmYXVsdC0+cHJlc2VudCB8fCAhZmF1bHQtPndyaXRlKQotCQlyZXR1cm4gZmFsc2U7Ci0K IAkvKgotCSAqIGd1ZXN0IGlzIHdyaXRpbmcgdGhlIHBhZ2Ugd2hpY2ggaXMgd3JpdGUgdHJhY2tl ZCB3aGljaCBjYW4KKwkgKiBndWVzdCBpcyByZWFkaW5nL3dyaXRpbmcvZmV0Y2hpbmcgdGhlIHBh Z2Ugd2hpY2ggaXMKKwkgKiByZWFkL3dyaXRlL2V4ZWN1dGUgdHJhY2tlZCB3aGljaCBjYW4KIAkg KiBub3QgYmUgZml4ZWQgYnkgcGFnZSBmYXVsdCBoYW5kbGVyLgogCSAqLwotCWlmIChrdm1fc2xv dF9wYWdlX3RyYWNrX2lzX2FjdGl2ZSh2Y3B1LCBmYXVsdC0+c2xvdCwgZmF1bHQtPmdmbiwgS1ZN X1BBR0VfVFJBQ0tfV1JJVEUpKQorCWlmICgoZmF1bHQtPnVzZXIgJiYga3ZtX3Nsb3RfcGFnZV90 cmFja19pc19hY3RpdmUodmNwdSwgZmF1bHQtPnNsb3QsCisJCQkJCWZhdWx0LT5nZm4sIEtWTV9Q QUdFX1RSQUNLX1BSRVJFQUQpKQorCSAgICB8fCAoZmF1bHQtPndyaXRlICYmIChrdm1fc2xvdF9w YWdlX3RyYWNrX2lzX2FjdGl2ZSh2Y3B1LAorCQkJCQlmYXVsdC0+c2xvdCwgZmF1bHQtPmdmbiwK KwkJCQkJS1ZNX1BBR0VfVFJBQ0tfUFJFV1JJVEUpCisJCQkJfHwga3ZtX3Nsb3RfcGFnZV90cmFj a19pc19hY3RpdmUodmNwdSwKKwkJCQkJZmF1bHQtPnNsb3QsIGZhdWx0LT5nZm4sCisJCQkJCUtW TV9QQUdFX1RSQUNLX1dSSVRFKSkpCisJICAgIHx8IChmYXVsdC0+ZXhlYyAmJiBrdm1fc2xvdF9w YWdlX3RyYWNrX2lzX2FjdGl2ZSh2Y3B1LCBmYXVsdC0+c2xvdCwKKwkJCQkJZmF1bHQtPmdmbiwg S1ZNX1BBR0VfVFJBQ0tfUFJFRVhFQykpKQogCQlyZXR1cm4gdHJ1ZTsKIAogCXJldHVybiBmYWxz ZTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2t2bS9tbXUvc3B0ZS5jIGIvYXJjaC94ODYva3ZtL21t dS9zcHRlLmMKaW5kZXggODcxZjYxMTRiMGZhLi5mNDE0NzUzMzIyMmQgMTAwNjQ0Ci0tLSBhL2Fy Y2gveDg2L2t2bS9tbXUvc3B0ZS5jCisrKyBiL2FyY2gveDg2L2t2bS9tbXUvc3B0ZS5jCkBAIC04 OSw2ICs4OSwyNiBAQCBzdGF0aWMgYm9vbCBrdm1faXNfbW1pb19wZm4oa3ZtX3Bmbl90IHBmbikK IAkJCQkgICAgIEU4MjBfVFlQRV9SQU0pOwogfQogCitzdGF0aWMgdW5zaWduZWQgaW50Citrdm1f bW11X2FwcGx5X2ludHJvc3BlY3Rpb25fYWNjZXNzKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwKKwkJ CQkgICBzdHJ1Y3Qga3ZtX21lbW9yeV9zbG90ICpzbG90LAorCQkJCSAgIGdmbl90IGdmbiwgdW5z aWduZWQgaW50IGFjYykKK3sKKwlpZiAoa3ZtX3Nsb3RfcGFnZV90cmFja19pc19hY3RpdmUodmNw dSwgc2xvdCwgZ2ZuLAorCQkJCQkgIEtWTV9QQUdFX1RSQUNLX1BSRVJFQUQpKQorCQlhY2MgJj0g fkFDQ19VU0VSX01BU0s7CisJaWYgKGt2bV9zbG90X3BhZ2VfdHJhY2tfaXNfYWN0aXZlKHZjcHUs IHNsb3QsIGdmbiwKKwkJCQkJICBLVk1fUEFHRV9UUkFDS19QUkVXUklURSkgfHwKKwkgICAga3Zt X3Nsb3RfcGFnZV90cmFja19pc19hY3RpdmUodmNwdSwgc2xvdCwgZ2ZuLAorCQkJCQkgIEtWTV9Q QUdFX1RSQUNLX1dSSVRFKSkKKwkJYWNjICY9IH5BQ0NfV1JJVEVfTUFTSzsKKwlpZiAoa3ZtX3Ns b3RfcGFnZV90cmFja19pc19hY3RpdmUodmNwdSwgc2xvdCwgZ2ZuLAorCQkJCQkgIEtWTV9QQUdF X1RSQUNLX1BSRUVYRUMpKQorCQlhY2MgJj0gfkFDQ19FWEVDX01BU0s7CisKKwlyZXR1cm4gYWNj OworfQorCiBib29sIG1ha2Vfc3B0ZShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIHN0cnVjdCBrdm1f bW11X3BhZ2UgKnNwLAogCSAgICAgICBzdHJ1Y3Qga3ZtX21lbW9yeV9zbG90ICpzbG90LAogCSAg ICAgICB1bnNpZ25lZCBpbnQgcHRlX2FjY2VzcywgZ2ZuX3QgZ2ZuLCBrdm1fcGZuX3QgcGZuLApA QCAtOTksNiArMTE5LDkgQEAgYm9vbCBtYWtlX3NwdGUoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBz dHJ1Y3Qga3ZtX21tdV9wYWdlICpzcCwKIAl1NjQgc3B0ZSA9IFNQVEVfTU1VX1BSRVNFTlRfTUFT SzsKIAlib29sIHdycHJvdCA9IGZhbHNlOwogCisJcHRlX2FjY2VzcyA9IGt2bV9tbXVfYXBwbHlf aW50cm9zcGVjdGlvbl9hY2Nlc3ModmNwdSwgc2xvdCwgZ2ZuLAorCQkJCQkJCXB0ZV9hY2Nlc3Mp OworCiAJaWYgKHNwLT5yb2xlLmFkX2Rpc2FibGVkKQogCQlzcHRlIHw9IFNQVEVfVERQX0FEX0RJ U0FCTEVEX01BU0s7CiAJZWxzZSBpZiAoa3ZtX3ZjcHVfYWRfbmVlZF93cml0ZV9wcm90ZWN0KHZj cHUpKQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva3ZtL3g4Ni5jIGIvYXJjaC94ODYva3ZtL3g4Ni5j CmluZGV4IDcyM2VmM2I3Zjk1Zi4uYzUyYWM1ZTlhMDIwIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9r dm0veDg2LmMKKysrIGIvYXJjaC94ODYva3ZtL3g4Ni5jCkBAIC02Mzg4LDYgKzYzODgsOCBAQCBz dGF0aWMgaW50IGt2bV9yZWFkX2d1ZXN0X3ZpcnRfaGVscGVyKGd2YV90IGFkZHIsIHZvaWQgKnZh bCwgdW5zaWduZWQgaW50IGJ5dGVzLAogCiAJCWlmIChncGEgPT0gVU5NQVBQRURfR1ZBKQogCQkJ cmV0dXJuIFg4NkVNVUxfUFJPUEFHQVRFX0ZBVUxUOworCQlpZiAoIWt2bV9wYWdlX3RyYWNrX3By ZXJlYWQodmNwdSwgZ3BhLCBhZGRyLCB0b3JlYWQpKQorCQkJcmV0dXJuIFg4NkVNVUxfUkVUUllf SU5TVFI7CiAJCXJldCA9IGt2bV92Y3B1X3JlYWRfZ3Vlc3RfcGFnZSh2Y3B1LCBncGEgPj4gUEFH RV9TSElGVCwgZGF0YSwKIAkJCQkJICAgICAgIG9mZnNldCwgdG9yZWFkKTsKIAkJaWYgKHJldCA8 IDApIHsKQEAgLTY0MTksNiArNjQyMSw5IEBAIHN0YXRpYyBpbnQga3ZtX2ZldGNoX2d1ZXN0X3Zp cnQoc3RydWN0IHg4Nl9lbXVsYXRlX2N0eHQgKmN0eHQsCiAJaWYgKHVubGlrZWx5KGdwYSA9PSBV Tk1BUFBFRF9HVkEpKQogCQlyZXR1cm4gWDg2RU1VTF9QUk9QQUdBVEVfRkFVTFQ7CiAKKwlpZiAo IWt2bV9wYWdlX3RyYWNrX3ByZWV4ZWModmNwdSwgZ3BhLCBhZGRyKSkKKwkJcmV0dXJuIFg4NkVN VUxfUkVUUllfSU5TVFI7CisKIAlvZmZzZXQgPSBhZGRyICYgKFBBR0VfU0laRS0xKTsKIAlpZiAo V0FSTl9PTihvZmZzZXQgKyBieXRlcyA+IFBBR0VfU0laRSkpCiAJCWJ5dGVzID0gKHVuc2lnbmVk KVBBR0VfU0laRSAtIG9mZnNldDsKQEAgLTY0ODcsMTEgKzY0OTIsMTQgQEAgc3RhdGljIGludCBr dm1fd3JpdGVfZ3Vlc3RfdmlydF9oZWxwZXIoZ3ZhX3QgYWRkciwgdm9pZCAqdmFsLCB1bnNpZ25l ZCBpbnQgYnl0ZXMKIAogCQlpZiAoZ3BhID09IFVOTUFQUEVEX0dWQSkKIAkJCXJldHVybiBYODZF TVVMX1BST1BBR0FURV9GQVVMVDsKKwkJaWYgKCFrdm1fcGFnZV90cmFja19wcmV3cml0ZSh2Y3B1 LCBncGEsIGFkZHIsIGRhdGEsIHRvd3JpdGUpKQorCQkJcmV0dXJuIFg4NkVNVUxfUkVUUllfSU5T VFI7CiAJCXJldCA9IGt2bV92Y3B1X3dyaXRlX2d1ZXN0KHZjcHUsIGdwYSwgZGF0YSwgdG93cml0 ZSk7CiAJCWlmIChyZXQgPCAwKSB7CiAJCQlyID0gWDg2RU1VTF9JT19ORUVERUQ7CiAJCQlnb3Rv IG91dDsKIAkJfQorCQlrdm1fcGFnZV90cmFja193cml0ZSh2Y3B1LCBncGEsIGFkZHIsIGRhdGEs IHRvd3JpdGUpOwogCiAJCWJ5dGVzIC09IHRvd3JpdGU7CiAJCWRhdGEgKz0gdG93cml0ZTsKQEAg LTY1OTUsMTMgKzY2MDMsMjIgQEAgc3RhdGljIGludCB2Y3B1X21taW9fZ3ZhX3RvX2dwYShzdHJ1 Y3Qga3ZtX3ZjcHUgKnZjcHUsIHVuc2lnbmVkIGxvbmcgZ3ZhLAogaW50IGVtdWxhdG9yX3dyaXRl X3BoeXMoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBncGFfdCBncGEsIGd2YV90IGd2YSwKIAkJCWNv bnN0IHZvaWQgKnZhbCwgaW50IGJ5dGVzKQogewotCWludCByZXQ7Ci0KLQlyZXQgPSBrdm1fdmNw dV93cml0ZV9ndWVzdCh2Y3B1LCBncGEsIHZhbCwgYnl0ZXMpOwotCWlmIChyZXQgPCAwKQotCQly ZXR1cm4gMDsKKwlpZiAoIWt2bV9wYWdlX3RyYWNrX3ByZXdyaXRlKHZjcHUsIGdwYSwgZ3ZhLCB2 YWwsIGJ5dGVzKSkKKwkJcmV0dXJuIFg4NkVNVUxfUkVUUllfSU5TVFI7CisJaWYgKGt2bV92Y3B1 X3dyaXRlX2d1ZXN0KHZjcHUsIGdwYSwgdmFsLCBieXRlcykgPCAwKQorCQlyZXR1cm4gWDg2RU1V TF9VTkhBTkRMRUFCTEU7CiAJa3ZtX3BhZ2VfdHJhY2tfd3JpdGUodmNwdSwgZ3BhLCBndmEsIHZh bCwgYnl0ZXMpOwotCXJldHVybiAxOworCXJldHVybiBYODZFTVVMX0NPTlRJTlVFOworfQorCitz dGF0aWMgaW50IGVtdWxhdG9yX3JlYWRfcGh5cyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIGdwYV90 IGdwYSwgZ3ZhX3QgZ3ZhLAorCQkJICAgICAgdm9pZCAqdmFsLCBpbnQgYnl0ZXMpCit7CisJaWYg KCFrdm1fcGFnZV90cmFja19wcmVyZWFkKHZjcHUsIGdwYSwgZ3ZhLCBieXRlcykpCisJCXJldHVy biBYODZFTVVMX1JFVFJZX0lOU1RSOworCWlmIChrdm1fdmNwdV9yZWFkX2d1ZXN0KHZjcHUsIGdw YSwgdmFsLCBieXRlcykgPCAwKQorCQlyZXR1cm4gWDg2RU1VTF9VTkhBTkRMRUFCTEU7CisJcmV0 dXJuIFg4NkVNVUxfQ09OVElOVUU7CiB9CiAKIHN0cnVjdCByZWFkX3dyaXRlX2VtdWxhdG9yX29w cyB7CkBAIC02NjMxLDcgKzY2NDgsNyBAQCBzdGF0aWMgaW50IHJlYWRfcHJlcGFyZShzdHJ1Y3Qg a3ZtX3ZjcHUgKnZjcHUsIHZvaWQgKnZhbCwgaW50IGJ5dGVzKQogc3RhdGljIGludCByZWFkX2Vt dWxhdGUoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBncGFfdCBncGEsIGd2YV90IGd2YSwKIAkJCXZv aWQgKnZhbCwgaW50IGJ5dGVzKQogewotCXJldHVybiAha3ZtX3ZjcHVfcmVhZF9ndWVzdCh2Y3B1 LCBncGEsIHZhbCwgYnl0ZXMpOworCXJldHVybiBlbXVsYXRvcl9yZWFkX3BoeXModmNwdSwgZ3Bh LCBndmEsIHZhbCwgYnl0ZXMpOwogfQogCiBzdGF0aWMgaW50IHdyaXRlX2VtdWxhdGUoc3RydWN0 IGt2bV92Y3B1ICp2Y3B1LCBncGFfdCBncGEsIGd2YV90IGd2YSwKQEAgLTY3MDUsOCArNjcyMiwx MSBAQCBzdGF0aWMgaW50IGVtdWxhdG9yX3JlYWRfd3JpdGVfb25lcGFnZSh1bnNpZ25lZCBsb25n IGFkZHIsIHZvaWQgKnZhbCwKIAkJCXJldHVybiBYODZFTVVMX1BST1BBR0FURV9GQVVMVDsKIAl9 CiAKLQlpZiAoIXJldCAmJiBvcHMtPnJlYWRfd3JpdGVfZW11bGF0ZSh2Y3B1LCBncGEsIGFkZHIs IHZhbCwgYnl0ZXMpKQotCQlyZXR1cm4gWDg2RU1VTF9DT05USU5VRTsKKwlpZiAoIXJldCkgewor CQlyZXQgPSBvcHMtPnJlYWRfd3JpdGVfZW11bGF0ZSh2Y3B1LCBncGEsIGFkZHIsIHZhbCwgYnl0 ZXMpOworCQlpZiAocmV0ID09IFg4NkVNVUxfQ09OVElOVUUgfHwgcmV0ID09IFg4NkVNVUxfUkVU UllfSU5TVFIpCisJCQlyZXR1cm4gcmV0OworCX0KIAogCS8qCiAJICogSXMgdGhpcyBNTUlPIGhh bmRsZWQgbG9jYWxseT8KQEAgLTY4NTAsNiArNjg3MCw5IEBAIHN0YXRpYyBpbnQgZW11bGF0b3Jf Y21weGNoZ19lbXVsYXRlZChzdHJ1Y3QgeDg2X2VtdWxhdGVfY3R4dCAqY3R4dCwKIAlpZiAoa3Zt X3ZjcHVfbWFwKHZjcHUsIGdwYV90b19nZm4oZ3BhKSwgJm1hcCkpCiAJCWdvdG8gZW11bF93cml0 ZTsKIAorCWlmICgha3ZtX3BhZ2VfdHJhY2tfcHJld3JpdGUodmNwdSwgZ3BhLCBhZGRyLCBuZXcs IGJ5dGVzKSkKKwkJcmV0dXJuIFg4NkVNVUxfUkVUUllfSU5TVFI7CisKIAlrYWRkciA9IG1hcC5o dmEgKyBvZmZzZXRfaW5fcGFnZShncGEpOwogCiAJc3dpdGNoIChieXRlcykgewpAQCAtNzg1MCw2 ICs3ODczLDggQEAgaW50IHg4Nl9lbXVsYXRlX2luc3RydWN0aW9uKHN0cnVjdCBrdm1fdmNwdSAq dmNwdSwgZ3BhX3QgY3IyX29yX2dwYSwKIAogCQlyID0geDg2X2RlY29kZV9lbXVsYXRlZF9pbnN0 cnVjdGlvbih2Y3B1LCBlbXVsYXRpb25fdHlwZSwKIAkJCQkJCSAgICBpbnNuLCBpbnNuX2xlbik7 CisJCWlmIChyID09IEVNVUxBVElPTl9SRVRSWV9JTlNUUikKKwkJCXJldHVybiAxOwogCQlpZiAo ciAhPSBFTVVMQVRJT05fT0spICB7CiAJCQlpZiAoKGVtdWxhdGlvbl90eXBlICYgRU1VTFRZUEVf VFJBUF9VRCkgfHwKIAkJCSAgICAoZW11bGF0aW9uX3R5cGUgJiBFTVVMVFlQRV9UUkFQX1VEX0ZP UkNFRCkpIHsKQEAgLTc5MTksNiArNzk0NCw4IEBAIGludCB4ODZfZW11bGF0ZV9pbnN0cnVjdGlv bihzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIGdwYV90IGNyMl9vcl9ncGEsCiAKIAlyID0geDg2X2Vt dWxhdGVfaW5zbihjdHh0KTsKIAorCWlmIChyID09IEVNVUxBVElPTl9SRVRSWV9JTlNUUikKKwkJ cmV0dXJuIDE7CiAJaWYgKHIgPT0gRU1VTEFUSU9OX0lOVEVSQ0VQVEVEKQogCQlyZXR1cm4gMTsK IApfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpWaXJ0dWFs aXphdGlvbiBtYWlsaW5nIGxpc3QKVmlydHVhbGl6YXRpb25AbGlzdHMubGludXgtZm91bmRhdGlv bi5vcmcKaHR0cHM6Ly9saXN0cy5saW51eGZvdW5kYXRpb24ub3JnL21haWxtYW4vbGlzdGluZm8v dmlydHVhbGl6YXRpb24=