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=-8.5 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,USER_AGENT_MUTT 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 9C8FFC43381 for ; Mon, 18 Mar 2019 17:34:22 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 61BDD20854 for ; Mon, 18 Mar 2019 17:34:22 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727603AbfCRReU (ORCPT ); Mon, 18 Mar 2019 13:34:20 -0400 Received: from foss.arm.com ([217.140.101.70]:38702 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726720AbfCRReU (ORCPT ); Mon, 18 Mar 2019 13:34:20 -0400 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id BF737EBD; Mon, 18 Mar 2019 10:34:19 -0700 (PDT) Received: from en101 (en101.cambridge.arm.com [10.1.196.93]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 645533F614; Mon, 18 Mar 2019 10:34:17 -0700 (PDT) Date: Mon, 18 Mar 2019 17:34:07 +0000 From: Suzuki K Poulose To: Zenghui Yu Cc: zhengxiang9@huawei.com, marc.zyngier@arm.com, christoffer.dall@arm.com, catalin.marinas@arm.com, will.deacon@arm.com, james.morse@arm.com, linux-arm-kernel@lists.infradead.org, kvmarm@lists.cs.columbia.edu, linux-kernel@vger.kernel.org, wanghaibin.wang@huawei.com, lious.lilei@hisilicon.com, lishuo1@hisilicon.com, suzuki.poulose@arm.com Subject: Re: [RFC] Question about TLB flush while set Stage-2 huge pages Message-ID: <20190318173405.GA31412@en101> References: <5f712cc6-0874-adbe-add6-46f5de24f36f@huawei.com> <1c0e07b9-73f0-efa4-c1b7-ad81789b42c5@huawei.com> <5188e3b9-5b5a-a6a7-7ef0-09b7b4f06af6@arm.com> <348d0b3b-c74b-7b39-ec30-85905c077c38@huawei.com> <20190314105537.GA15323@en101> <368bd218-ac1d-19b2-6e92-960b91afee8b@huawei.com> <6aea4049-7860-7144-a7be-14f856cdc789@arm.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: User-Agent: Mutt/1.5.24 (2015-08-30) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi ! On Sun, Mar 17, 2019 at 09:34:11PM +0800, Zenghui Yu wrote: > Hi Suzuki, > > On 2019/3/15 22:56, Suzuki K Poulose wrote: > >Hi Zhengui, > > s/Zhengui/Zheng/ > > (I think you must wanted to say "Hi" to Zheng :-) ) > Sorry about that. > > I have looked into your patch and the kernel log, and I believe that > your patch had already addressed this issue. But I think we can do it > a little better - two more points need to be handled with caution. > > Take PMD hugepage (PMD_SIZE == 2M) for example: > ... > >Thats bad, we seem to be making upto 4 unbalanced put_page(). > > > >>>>--- > >>>>   virt/kvm/arm/mmu.c | 51 > >>>>+++++++++++++++++++++++++++++++++++---------------- > >>>>   1 file changed, 35 insertions(+), 16 deletions(-) > >>>> > >>>>diff --git a/virt/kvm/arm/mmu.c b/virt/kvm/arm/mmu.c > >>>>index 66e0fbb5..04b0f9b 100644 > >>>>--- a/virt/kvm/arm/mmu.c > >>>>+++ b/virt/kvm/arm/mmu.c > >>>>@@ -1076,24 +1076,38 @@ static int stage2_set_pmd_huge(struct kvm > >>>>*kvm, struct kvm_mmu_memory_cache > >>>>            * Skip updating the page table if the entry is > >>>>            * unchanged. > >>>>            */ > >>>>-        if (pmd_val(old_pmd) == pmd_val(*new_pmd)) > >>>>+        if (pmd_val(old_pmd) == pmd_val(*new_pmd)) { > >>>>               return 0; > >>>>- > >>>>+        } else if (WARN_ON_ONCE(!pmd_thp_or_huge(old_pmd))) { > >>>>           /* > >>>>-         * Mapping in huge pages should only happen through a > >>>>-         * fault.  If a page is merged into a transparent huge > >>>>-         * page, the individual subpages of that huge page > >>>>-         * should be unmapped through MMU notifiers before we > >>>>-         * get here. > >>>>-         * > >>>>-         * Merging of CompoundPages is not supported; they > >>>>-         * should become splitting first, unmapped, merged, > >>>>-         * and mapped back in on-demand. > >>>>+         * If we have PTE level mapping for this block, > >>>>+         * we must unmap it to avoid inconsistent TLB > >>>>+         * state. We could end up in this situation if > >>>>+         * the memory slot was marked for dirty logging > >>>>+         * and was reverted, leaving PTE level mappings > >>>>+         * for the pages accessed during the period. > >>>>+         * Normal THP split/merge follows mmu_notifier > >>>>+         * callbacks and do get handled accordingly. > >>>>            */ > >>>>-        VM_BUG_ON(pmd_pfn(old_pmd) != pmd_pfn(*new_pmd)); > >>>>+            unmap_stage2_range(kvm, (addr & S2_PMD_MASK), > >>>>S2_PMD_SIZE); > > First, using unmap_stage2_range() here is not quite appropriate. Suppose > we've only accessed one 2M page in HPA [x, x+1]Gib range, with other > pages unaccessed. What will happen if unmap_stage2_range(this_2M_page)? > We'll unexpectedly reach clear_stage2_pud_entry(), and things are going > to get really bad. So we'd better use unmap_stage2_ptes() here since we > only want to unmap a 2M range. Yes, you're right. If this PMD entry is the only entry in the parent PUD table, then the PUD table may get free'd and we may install the table in a place which is not plugged into the table. > > > Second, consider below function stack: > > unmap_stage2_ptes() > clear_stage2_pmd_entry() > put_page(virt_to_page(pmd)) > > It seems that we have one "redundant" put_page() here, (thus comes the > bad kernel log ... ,) but actually we do not. By stage2_set_pmd_huge(), > the PMD table entry will then point to a 2M block (originally pointed > to a PTE table), the _refcount of this PMD-level table page should _not_ > change after unmap_stage2_ptes(). So what we really should do is adding > a get_page() after unmapping to keep the _refcount a balance! Yes we need an additional refcount on the new huge pmd table, if we are tearing down the PTE level table. > > > thoughts ? A simple patch below (based on yours) for details. > > > thanks, > > zenghui > > > >> > >>It seems that kvm decreases the _refcount of the page twice in > >>transparent_hugepage_adjust() > >>and unmap_stage2_range(). > > > >But I thought we should be doing that on the head_page already, as this is > >THP. > >I will take a look and get back to you on this. Btw, is it possible for you > >to turn on CONFIG_DEBUG_VM and re-run with the above patch ? > > > >Kind regards > >Suzuki > > > > ---8<--- > > test: kvm: arm: Maybe two more fixes > > Applied based on Suzuki's patch. > > Signed-off-by: Zenghui Yu > --- > virt/kvm/arm/mmu.c | 8 ++++++-- > 1 file changed, 6 insertions(+), 2 deletions(-) > > diff --git a/virt/kvm/arm/mmu.c b/virt/kvm/arm/mmu.c > index 05765df..ccd5d5d 100644 > --- a/virt/kvm/arm/mmu.c > +++ b/virt/kvm/arm/mmu.c > @@ -1089,7 +1089,9 @@ static int stage2_set_pmd_huge(struct kvm *kvm, struct > kvm_mmu_memory_cache > * Normal THP split/merge follows mmu_notifier > * callbacks and do get handled accordingly. > */ > - unmap_stage2_range(kvm, (addr & S2_PMD_MASK), S2_PMD_SIZE); > + addr &= S2_PMD_MASK; > + unmap_stage2_ptes(kvm, pmd, addr, addr + S2_PMD_SIZE); > + get_page(virt_to_page(pmd)); > } else { > > /* > @@ -1138,7 +1140,9 @@ static int stage2_set_pud_huge(struct kvm *kvm, struct > kvm_mmu_memory_cache *cac > if (stage2_pud_present(kvm, old_pud)) { > /* If we have PTE level mapping, unmap the entire range */ > if (WARN_ON_ONCE(!stage2_pud_huge(kvm, old_pud))) { > - unmap_stage2_range(kvm, addr & S2_PUD_MASK, S2_PUD_SIZE); > + addr &= S2_PUD_MASK; > + unmap_stage2_pmds(kvm, pudp, addr, addr + S2_PUD_SIZE); > + get_page(virt_to_page(pudp)); > } else { > stage2_pud_clear(kvm, pudp); > kvm_tlb_flush_vmid_ipa(kvm, addr); This makes it a bit tricky to follow the code. The other option is to do something like : ---8>--- kvm: arm: Fix handling of stage2 huge mappings We rely on the mmu_notifier call backs to handle the split/merging of huge pages and thus we are guaranteed that while creating a block mapping, the entire block is unmapped at stage2. However, we miss a case where the block mapping is split for dirty logging case and then could later be made block mapping, if we cancel the dirty logging. This not only creates inconsistent TLB entries for the pages in the the block, but also leakes the table pages for PMD level. Handle these corner cases for the huge mappings at stage2 by unmapping the PTE level mapping. This could potentially release the upper level table. So we need to restart the table walk once we unmap the range. Signed-off-by: Suzuki K Poulose --- virt/kvm/arm/mmu.c | 57 +++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 41 insertions(+), 16 deletions(-) diff --git a/virt/kvm/arm/mmu.c b/virt/kvm/arm/mmu.c index fce0983..a38a3f1 100644 --- a/virt/kvm/arm/mmu.c +++ b/virt/kvm/arm/mmu.c @@ -1060,25 +1060,41 @@ static int stage2_set_pmd_huge(struct kvm *kvm, struct kvm_mmu_memory_cache { pmd_t *pmd, old_pmd; +retry: pmd = stage2_get_pmd(kvm, cache, addr); VM_BUG_ON(!pmd); old_pmd = *pmd; + /* + * Multiple vcpus faulting on the same PMD entry, can + * lead to them sequentially updating the PMD with the + * same value. Following the break-before-make + * (pmd_clear() followed by tlb_flush()) process can + * hinder forward progress due to refaults generated + * on missing translations. + * + * Skip updating the page table if the entry is + * unchanged. + */ + if (pmd_val(old_pmd) == pmd_val(*new_pmd)) + return 0; + if (pmd_present(old_pmd)) { /* - * Multiple vcpus faulting on the same PMD entry, can - * lead to them sequentially updating the PMD with the - * same value. Following the break-before-make - * (pmd_clear() followed by tlb_flush()) process can - * hinder forward progress due to refaults generated - * on missing translations. - * - * Skip updating the page table if the entry is - * unchanged. + * If we already have PTE level mapping for this block, + * we must unmap it to avoid inconsistent TLB + * state. We could end up in this situation if + * the memory slot was marked for dirty logging + * and was reverted, leaving PTE level mappings + * for the pages accessed during the period. + * Normal THP split/merge follows mmu_notifier + * callbacks and do get handled accordingly. + * Unmap the PTE level mapping and retry. */ - if (pmd_val(old_pmd) == pmd_val(*new_pmd)) - return 0; - + if (!pmd_thp_or_huge(old_pmd)) { + unmap_stage2_range(kvm, (addr & S2_PMD_MASK), S2_PMD_SIZE); + goto retry; + } /* * Mapping in huge pages should only happen through a * fault. If a page is merged into a transparent huge @@ -1090,8 +1106,7 @@ static int stage2_set_pmd_huge(struct kvm *kvm, struct kvm_mmu_memory_cache * should become splitting first, unmapped, merged, * and mapped back in on-demand. */ - VM_BUG_ON(pmd_pfn(old_pmd) != pmd_pfn(*new_pmd)); - + WARN_ON_ONCE(pmd_pfn(old_pmd) != pmd_pfn(*new_pmd)); pmd_clear(pmd); kvm_tlb_flush_vmid_ipa(kvm, addr); } else { @@ -1107,6 +1122,7 @@ static int stage2_set_pud_huge(struct kvm *kvm, struct kvm_mmu_memory_cache *cac { pud_t *pudp, old_pud; +retry: pudp = stage2_get_pud(kvm, cache, addr); VM_BUG_ON(!pudp); @@ -1122,8 +1138,17 @@ static int stage2_set_pud_huge(struct kvm *kvm, struct kvm_mmu_memory_cache *cac return 0; if (stage2_pud_present(kvm, old_pud)) { - stage2_pud_clear(kvm, pudp); - kvm_tlb_flush_vmid_ipa(kvm, addr); + /* + * If we already have PTE level mapping, unmap the entire + * range and retry. + */ + if (!stage2_pud_huge(kvm, old_pud)) { + unmap_stage2_range(kvm, addr & S2_PUD_MASK, S2_PUD_SIZE); + goto retry; + } else { + stage2_pud_clear(kvm, pudp); + kvm_tlb_flush_vmid_ipa(kvm, addr); + } } else { get_page(virt_to_page(pudp)); } -- 2.7.4 > -- > 1.8.3.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 X-Spam-Level: X-Spam-Status: No, score=-8.5 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_PASS,USER_AGENT_MUTT 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 319B8C43381 for ; Mon, 18 Mar 2019 17:34:34 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 029D220989 for ; Mon, 18 Mar 2019 17:34:33 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="LAWVd5bc" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 029D220989 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=TidmzsockJwMnpYewZR6Vq7vVZI0JVakaojxKu1NLh4=; b=LAWVd5bcZOPGYT 9R7MCKWfjFrSf8BSCVHOBd2eO5SoVwhZ1C4ZaEN7SrcV91DDEjaOYZuTPwB8kfH6bX0zSyyJTw3h2 lys5mewVpnprOkSJ1Vx0fl6114tKmiGrA2IB/T1ZWCChjKpPRtT2iyPPPndHApt1JbHKB1NWtDRh0 kBrSULKfUMOZQN/N0allU/kbmezED9dv/utM209VCPlZUuBlWGJMojH5VMKRCFXe2w1cMPdsahN+4 B8KkfV5XiqnELP3KVqNds3wd8A4XLNuX0Tv7RGGryvVhrUY9cSBRNJkfu8sFmS286gSnE2ZmF8yzF BXdeZgZwiRjsWhL7vtYw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1h5w9b-00055q-13; Mon, 18 Mar 2019 17:34:27 +0000 Received: from foss.arm.com ([217.140.101.70]) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1h5w9V-00052j-Ui for linux-arm-kernel@lists.infradead.org; Mon, 18 Mar 2019 17:34:25 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id BF737EBD; Mon, 18 Mar 2019 10:34:19 -0700 (PDT) Received: from en101 (en101.cambridge.arm.com [10.1.196.93]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 645533F614; Mon, 18 Mar 2019 10:34:17 -0700 (PDT) Date: Mon, 18 Mar 2019 17:34:07 +0000 From: Suzuki K Poulose To: Zenghui Yu Subject: Re: [RFC] Question about TLB flush while set Stage-2 huge pages Message-ID: <20190318173405.GA31412@en101> References: <5f712cc6-0874-adbe-add6-46f5de24f36f@huawei.com> <1c0e07b9-73f0-efa4-c1b7-ad81789b42c5@huawei.com> <5188e3b9-5b5a-a6a7-7ef0-09b7b4f06af6@arm.com> <348d0b3b-c74b-7b39-ec30-85905c077c38@huawei.com> <20190314105537.GA15323@en101> <368bd218-ac1d-19b2-6e92-960b91afee8b@huawei.com> <6aea4049-7860-7144-a7be-14f856cdc789@arm.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: User-Agent: Mutt/1.5.24 (2015-08-30) X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190318_103421_998683_D9C685AF X-CRM114-Status: GOOD ( 39.59 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: suzuki.poulose@arm.com, marc.zyngier@arm.com, catalin.marinas@arm.com, will.deacon@arm.com, christoffer.dall@arm.com, linux-kernel@vger.kernel.org, zhengxiang9@huawei.com, james.morse@arm.com, lishuo1@hisilicon.com, wanghaibin.wang@huawei.com, kvmarm@lists.cs.columbia.edu, linux-arm-kernel@lists.infradead.org, lious.lilei@hisilicon.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org SGkgIQpPbiBTdW4sIE1hciAxNywgMjAxOSBhdCAwOTozNDoxMVBNICswODAwLCBaZW5naHVpIFl1 IHdyb3RlOgo+IEhpIFN1enVraSwKPiAKPiBPbiAyMDE5LzMvMTUgMjI6NTYsIFN1enVraSBLIFBv dWxvc2Ugd3JvdGU6Cj4gPkhpIFpoZW5ndWksCj4gCj4gcy9aaGVuZ3VpL1poZW5nLwo+IAo+IChJ IHRoaW5rIHlvdSBtdXN0IHdhbnRlZCB0byBzYXkgIkhpIiB0byBaaGVuZyA6LSkgKQo+IAoKU29y cnkgYWJvdXQgdGhhdC4KCj4gCj4gSSBoYXZlIGxvb2tlZCBpbnRvIHlvdXIgcGF0Y2ggYW5kIHRo ZSBrZXJuZWwgbG9nLCBhbmQgSSBiZWxpZXZlIHRoYXQKPiB5b3VyIHBhdGNoIGhhZCBhbHJlYWR5 IGFkZHJlc3NlZCB0aGlzIGlzc3VlLiBCdXQgSSB0aGluayB3ZSBjYW4gZG8gaXQKPiBhIGxpdHRs ZSBiZXR0ZXIgLSB0d28gbW9yZSBwb2ludHMgbmVlZCB0byBiZSBoYW5kbGVkIHdpdGggY2F1dGlv bi4KPiAKPiBUYWtlIFBNRCBodWdlcGFnZSAoUE1EX1NJWkUgPT0gMk0pIGZvciBleGFtcGxlOgo+ CgouLi4KCj4gPlRoYXRzIGJhZCwgd2Ugc2VlbSB0byBiZSBtYWtpbmcgdXB0byA0IHVuYmFsYW5j ZWQgcHV0X3BhZ2UoKS4KPiA+Cj4gPj4+Pi0tLQo+ID4+Pj7CoMKgIHZpcnQva3ZtL2FybS9tbXUu YyB8IDUxCj4gPj4+PisrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0t LS0tLS0tLQo+ID4+Pj7CoMKgIDEgZmlsZSBjaGFuZ2VkLCAzNSBpbnNlcnRpb25zKCspLCAxNiBk ZWxldGlvbnMoLSkKPiA+Pj4+Cj4gPj4+PmRpZmYgLS1naXQgYS92aXJ0L2t2bS9hcm0vbW11LmMg Yi92aXJ0L2t2bS9hcm0vbW11LmMKPiA+Pj4+aW5kZXggNjZlMGZiYjUuLjA0YjBmOWIgMTAwNjQ0 Cj4gPj4+Pi0tLSBhL3ZpcnQva3ZtL2FybS9tbXUuYwo+ID4+Pj4rKysgYi92aXJ0L2t2bS9hcm0v bW11LmMKPiA+Pj4+QEAgLTEwNzYsMjQgKzEwNzYsMzggQEAgc3RhdGljIGludCBzdGFnZTJfc2V0 X3BtZF9odWdlKHN0cnVjdCBrdm0KPiA+Pj4+Kmt2bSwgc3RydWN0IGt2bV9tbXVfbWVtb3J5X2Nh Y2hlCj4gPj4+PsKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgKiBTa2lwIHVwZGF0aW5nIHRoZSBwYWdl IHRhYmxlIGlmIHRoZSBlbnRyeSBpcwo+ID4+Pj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgICogdW5j aGFuZ2VkLgo+ID4+Pj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgICovCj4gPj4+Pi3CoMKgwqDCoMKg wqDCoCBpZiAocG1kX3ZhbChvbGRfcG1kKSA9PSBwbWRfdmFsKCpuZXdfcG1kKSkKPiA+Pj4+K8Kg wqDCoMKgwqDCoMKgIGlmIChwbWRfdmFsKG9sZF9wbWQpID09IHBtZF92YWwoKm5ld19wbWQpKSB7 Cj4gPj4+PsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJuIDA7Cj4gPj4+Pi0KPiA+ Pj4+K8KgwqDCoMKgwqDCoMKgIH0gZWxzZSBpZiAoV0FSTl9PTl9PTkNFKCFwbWRfdGhwX29yX2h1 Z2Uob2xkX3BtZCkpKSB7Cj4gPj4+PsKgwqDCoMKgwqDCoMKgwqDCoMKgIC8qCj4gPj4+Pi3CoMKg wqDCoMKgwqDCoMKgICogTWFwcGluZyBpbiBodWdlIHBhZ2VzIHNob3VsZCBvbmx5IGhhcHBlbiB0 aHJvdWdoIGEKPiA+Pj4+LcKgwqDCoMKgwqDCoMKgwqAgKiBmYXVsdC7CoCBJZiBhIHBhZ2UgaXMg bWVyZ2VkIGludG8gYSB0cmFuc3BhcmVudCBodWdlCj4gPj4+Pi3CoMKgwqDCoMKgwqDCoMKgICog cGFnZSwgdGhlIGluZGl2aWR1YWwgc3VicGFnZXMgb2YgdGhhdCBodWdlIHBhZ2UKPiA+Pj4+LcKg wqDCoMKgwqDCoMKgwqAgKiBzaG91bGQgYmUgdW5tYXBwZWQgdGhyb3VnaCBNTVUgbm90aWZpZXJz IGJlZm9yZSB3ZQo+ID4+Pj4twqDCoMKgwqDCoMKgwqDCoCAqIGdldCBoZXJlLgo+ID4+Pj4twqDC oMKgwqDCoMKgwqDCoCAqCj4gPj4+Pi3CoMKgwqDCoMKgwqDCoMKgICogTWVyZ2luZyBvZiBDb21w b3VuZFBhZ2VzIGlzIG5vdCBzdXBwb3J0ZWQ7IHRoZXkKPiA+Pj4+LcKgwqDCoMKgwqDCoMKgwqAg KiBzaG91bGQgYmVjb21lIHNwbGl0dGluZyBmaXJzdCwgdW5tYXBwZWQsIG1lcmdlZCwKPiA+Pj4+ LcKgwqDCoMKgwqDCoMKgwqAgKiBhbmQgbWFwcGVkIGJhY2sgaW4gb24tZGVtYW5kLgo+ID4+Pj4r wqDCoMKgwqDCoMKgwqDCoCAqIElmIHdlIGhhdmUgUFRFIGxldmVsIG1hcHBpbmcgZm9yIHRoaXMg YmxvY2ssCj4gPj4+PivCoMKgwqDCoMKgwqDCoMKgICogd2UgbXVzdCB1bm1hcCBpdCB0byBhdm9p ZCBpbmNvbnNpc3RlbnQgVExCCj4gPj4+PivCoMKgwqDCoMKgwqDCoMKgICogc3RhdGUuIFdlIGNv dWxkIGVuZCB1cCBpbiB0aGlzIHNpdHVhdGlvbiBpZgo+ID4+Pj4rwqDCoMKgwqDCoMKgwqDCoCAq IHRoZSBtZW1vcnkgc2xvdCB3YXMgbWFya2VkIGZvciBkaXJ0eSBsb2dnaW5nCj4gPj4+PivCoMKg wqDCoMKgwqDCoMKgICogYW5kIHdhcyByZXZlcnRlZCwgbGVhdmluZyBQVEUgbGV2ZWwgbWFwcGlu Z3MKPiA+Pj4+K8KgwqDCoMKgwqDCoMKgwqAgKiBmb3IgdGhlIHBhZ2VzIGFjY2Vzc2VkIGR1cmlu ZyB0aGUgcGVyaW9kLgo+ID4+Pj4rwqDCoMKgwqDCoMKgwqDCoCAqIE5vcm1hbCBUSFAgc3BsaXQv bWVyZ2UgZm9sbG93cyBtbXVfbm90aWZpZXIKPiA+Pj4+K8KgwqDCoMKgwqDCoMKgwqAgKiBjYWxs YmFja3MgYW5kIGRvIGdldCBoYW5kbGVkIGFjY29yZGluZ2x5Lgo+ID4+Pj7CoMKgwqDCoMKgwqDC oMKgwqDCoMKgICovCj4gPj4+Pi3CoMKgwqDCoMKgwqDCoCBWTV9CVUdfT04ocG1kX3BmbihvbGRf cG1kKSAhPSBwbWRfcGZuKCpuZXdfcG1kKSk7Cj4gPj4+PivCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IHVubWFwX3N0YWdlMl9yYW5nZShrdm0sIChhZGRyICYgUzJfUE1EX01BU0spLAo+ID4+Pj5TMl9Q TURfU0laRSk7Cj4gCj4gRmlyc3QsIHVzaW5nIHVubWFwX3N0YWdlMl9yYW5nZSgpIGhlcmUgaXMg bm90IHF1aXRlIGFwcHJvcHJpYXRlLiBTdXBwb3NlCj4gd2UndmUgb25seSBhY2Nlc3NlZCBvbmUg Mk0gcGFnZSBpbiBIUEEgW3gsIHgrMV1HaWIgcmFuZ2UsIHdpdGggb3RoZXIKPiBwYWdlcyB1bmFj Y2Vzc2VkLiAgV2hhdCB3aWxsIGhhcHBlbiBpZiB1bm1hcF9zdGFnZTJfcmFuZ2UodGhpc18yTV9w YWdlKT8KPiBXZSdsbCB1bmV4cGVjdGVkbHkgcmVhY2ggY2xlYXJfc3RhZ2UyX3B1ZF9lbnRyeSgp LCBhbmQgdGhpbmdzIGFyZSBnb2luZwo+IHRvIGdldCByZWFsbHkgYmFkLiAgU28gd2UnZCBiZXR0 ZXIgdXNlIHVubWFwX3N0YWdlMl9wdGVzKCkgaGVyZSBzaW5jZSB3ZQo+IG9ubHkgd2FudCB0byB1 bm1hcCBhIDJNIHJhbmdlLgoKWWVzLCB5b3UncmUgcmlnaHQuIElmIHRoaXMgUE1EIGVudHJ5IGlz IHRoZSBvbmx5IGVudHJ5IGluIHRoZSBwYXJlbnQgUFVEIHRhYmxlLAp0aGVuIHRoZSBQVUQgdGFi bGUgbWF5IGdldCBmcmVlJ2QgYW5kIHdlIG1heSBpbnN0YWxsIHRoZSB0YWJsZSBpbiBhIHBsYWNl IHdoaWNoCmlzIG5vdCBwbHVnZ2VkIGludG8gdGhlIHRhYmxlLgoKPiAKPiAKPiBTZWNvbmQsIGNv bnNpZGVyIGJlbG93IGZ1bmN0aW9uIHN0YWNrOgo+IAo+ICAgdW5tYXBfc3RhZ2UyX3B0ZXMoKQo+ ICAgICBjbGVhcl9zdGFnZTJfcG1kX2VudHJ5KCkKPiAgICAgICBwdXRfcGFnZSh2aXJ0X3RvX3Bh Z2UocG1kKSkKPiAKPiBJdCBzZWVtcyB0aGF0IHdlIGhhdmUgb25lICJyZWR1bmRhbnQiIHB1dF9w YWdlKCkgaGVyZSwgKHRodXMgY29tZXMgdGhlCj4gYmFkIGtlcm5lbCBsb2cgLi4uICwpIGJ1dCBh Y3R1YWxseSB3ZSBkbyBub3QuICBCeSBzdGFnZTJfc2V0X3BtZF9odWdlKCksCj4gdGhlIFBNRCB0 YWJsZSBlbnRyeSB3aWxsIHRoZW4gcG9pbnQgdG8gYSAyTSBibG9jayAob3JpZ2luYWxseSBwb2lu dGVkCj4gdG8gYSBQVEUgdGFibGUpLCB0aGUgX3JlZmNvdW50IG9mIHRoaXMgUE1ELWxldmVsIHRh YmxlIHBhZ2Ugc2hvdWxkIF9ub3RfCj4gY2hhbmdlIGFmdGVyIHVubWFwX3N0YWdlMl9wdGVzKCku ICBTbyB3aGF0IHdlIHJlYWxseSBzaG91bGQgZG8gaXMgYWRkaW5nCj4gYSBnZXRfcGFnZSgpIGFm dGVyIHVubWFwcGluZyB0byBrZWVwIHRoZSBfcmVmY291bnQgYSBiYWxhbmNlIQoKWWVzIHdlIG5l ZWQgYW4gYWRkaXRpb25hbCByZWZjb3VudCBvbiB0aGUgbmV3IGh1Z2UgcG1kIHRhYmxlLCBpZiB3 ZSBhcmUKdGVhcmluZyBkb3duIHRoZSBQVEUgbGV2ZWwgdGFibGUuCgo+IAo+IAo+IHRob3VnaHRz ID8gQSBzaW1wbGUgcGF0Y2ggYmVsb3cgKGJhc2VkIG9uIHlvdXJzKSBmb3IgZGV0YWlscy4KPiAK PiAKPiB0aGFua3MsCj4gCj4gemVuZ2h1aQo+IAo+IAo+ID4+Cj4gPj5JdCBzZWVtcyB0aGF0IGt2 bSBkZWNyZWFzZXMgdGhlIF9yZWZjb3VudCBvZiB0aGUgcGFnZSB0d2ljZSBpbgo+ID4+dHJhbnNw YXJlbnRfaHVnZXBhZ2VfYWRqdXN0KCkKPiA+PmFuZCB1bm1hcF9zdGFnZTJfcmFuZ2UoKS4KPiA+ Cj4gPkJ1dCBJIHRob3VnaHQgd2Ugc2hvdWxkIGJlIGRvaW5nIHRoYXQgb24gdGhlIGhlYWRfcGFn ZSBhbHJlYWR5LCBhcyB0aGlzIGlzCj4gPlRIUC4KPiA+SSB3aWxsIHRha2UgYSBsb29rIGFuZCBn ZXQgYmFjayB0byB5b3Ugb24gdGhpcy4gQnR3LCBpcyBpdCBwb3NzaWJsZSBmb3IgeW91Cj4gPnRv IHR1cm4gb24gQ09ORklHX0RFQlVHX1ZNIGFuZCByZS1ydW4gd2l0aCB0aGUgYWJvdmUgcGF0Y2gg Pwo+ID4KPiA+S2luZCByZWdhcmRzCj4gPlN1enVraQo+ID4KPiAKPiAtLS04PC0tLQo+IAo+IHRl c3Q6IGt2bTogYXJtOiBNYXliZSB0d28gbW9yZSBmaXhlcwo+IAo+IEFwcGxpZWQgYmFzZWQgb24g U3V6dWtpJ3MgcGF0Y2guCj4gCj4gU2lnbmVkLW9mZi1ieTogWmVuZ2h1aSBZdSA8eXV6ZW5naHVp QGh1YXdlaS5jb20+Cj4gLS0tCj4gIHZpcnQva3ZtL2FybS9tbXUuYyB8IDggKysrKysrLS0KPiAg MSBmaWxlIGNoYW5nZWQsIDYgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKPiAKPiBkaWZm IC0tZ2l0IGEvdmlydC9rdm0vYXJtL21tdS5jIGIvdmlydC9rdm0vYXJtL21tdS5jCj4gaW5kZXgg MDU3NjVkZi4uY2NkNWQ1ZCAxMDA2NDQKPiAtLS0gYS92aXJ0L2t2bS9hcm0vbW11LmMKPiArKysg Yi92aXJ0L2t2bS9hcm0vbW11LmMKPiBAQCAtMTA4OSw3ICsxMDg5LDkgQEAgc3RhdGljIGludCBz dGFnZTJfc2V0X3BtZF9odWdlKHN0cnVjdCBrdm0gKmt2bSwgc3RydWN0Cj4ga3ZtX21tdV9tZW1v cnlfY2FjaGUKPiAgCQkgKiBOb3JtYWwgVEhQIHNwbGl0L21lcmdlIGZvbGxvd3MgbW11X25vdGlm aWVyCj4gIAkJICogY2FsbGJhY2tzIGFuZCBkbyBnZXQgaGFuZGxlZCBhY2NvcmRpbmdseS4KPiAg CQkgKi8KPiAtCQkJdW5tYXBfc3RhZ2UyX3JhbmdlKGt2bSwgKGFkZHIgJiBTMl9QTURfTUFTSyks IFMyX1BNRF9TSVpFKTsKPiArCQkJYWRkciAmPSBTMl9QTURfTUFTSzsKPiArCQkJdW5tYXBfc3Rh Z2UyX3B0ZXMoa3ZtLCBwbWQsIGFkZHIsIGFkZHIgKyBTMl9QTURfU0laRSk7Cj4gKwkJCWdldF9w YWdlKHZpcnRfdG9fcGFnZShwbWQpKTsKPiAgCQl9IGVsc2Ugewo+IAo+ICAJCQkvKgo+IEBAIC0x MTM4LDcgKzExNDAsOSBAQCBzdGF0aWMgaW50IHN0YWdlMl9zZXRfcHVkX2h1Z2Uoc3RydWN0IGt2 bSAqa3ZtLCBzdHJ1Y3QKPiBrdm1fbW11X21lbW9yeV9jYWNoZSAqY2FjCj4gIAlpZiAoc3RhZ2Uy X3B1ZF9wcmVzZW50KGt2bSwgb2xkX3B1ZCkpIHsKPiAgCQkvKiBJZiB3ZSBoYXZlIFBURSBsZXZl bCBtYXBwaW5nLCB1bm1hcCB0aGUgZW50aXJlIHJhbmdlICovCj4gIAkJaWYgKFdBUk5fT05fT05D RSghc3RhZ2UyX3B1ZF9odWdlKGt2bSwgb2xkX3B1ZCkpKSB7Cj4gLQkJCXVubWFwX3N0YWdlMl9y YW5nZShrdm0sIGFkZHIgJiBTMl9QVURfTUFTSywgUzJfUFVEX1NJWkUpOwo+ICsJCQlhZGRyICY9 IFMyX1BVRF9NQVNLOwo+ICsJCQl1bm1hcF9zdGFnZTJfcG1kcyhrdm0sIHB1ZHAsIGFkZHIsIGFk ZHIgKyBTMl9QVURfU0laRSk7Cj4gKwkJCWdldF9wYWdlKHZpcnRfdG9fcGFnZShwdWRwKSk7Cj4g IAkJfSBlbHNlIHsKPiAgCQkJc3RhZ2UyX3B1ZF9jbGVhcihrdm0sIHB1ZHApOwo+ICAJCQlrdm1f dGxiX2ZsdXNoX3ZtaWRfaXBhKGt2bSwgYWRkcik7CgpUaGlzIG1ha2VzIGl0IGEgYml0IHRyaWNr eSB0byBmb2xsb3cgdGhlIGNvZGUuIFRoZSBvdGhlciBvcHRpb24gaXMgdG8KZG8gc29tZXRoaW5n IGxpa2UgOgoKCi0tLTg+LS0tCgprdm06IGFybTogRml4IGhhbmRsaW5nIG9mIHN0YWdlMiBodWdl IG1hcHBpbmdzCgpXZSByZWx5IG9uIHRoZSBtbXVfbm90aWZpZXIgY2FsbCBiYWNrcyB0byBoYW5k bGUgdGhlIHNwbGl0L21lcmdpbmcKb2YgaHVnZSBwYWdlcyBhbmQgdGh1cyB3ZSBhcmUgZ3VhcmFu dGVlZCB0aGF0IHdoaWxlIGNyZWF0aW5nIGEKYmxvY2sgbWFwcGluZywgdGhlIGVudGlyZSBibG9j ayBpcyB1bm1hcHBlZCBhdCBzdGFnZTIuIEhvd2V2ZXIsCndlIG1pc3MgYSBjYXNlIHdoZXJlIHRo ZSBibG9jayBtYXBwaW5nIGlzIHNwbGl0IGZvciBkaXJ0eSBsb2dnaW5nCmNhc2UgYW5kIHRoZW4g Y291bGQgbGF0ZXIgYmUgbWFkZSBibG9jayBtYXBwaW5nLCBpZiB3ZSBjYW5jZWwgdGhlCmRpcnR5 IGxvZ2dpbmcuIFRoaXMgbm90IG9ubHkgY3JlYXRlcyBpbmNvbnNpc3RlbnQgVExCIGVudHJpZXMg Zm9yCnRoZSBwYWdlcyBpbiB0aGUgdGhlIGJsb2NrLCBidXQgYWxzbyBsZWFrZXMgdGhlIHRhYmxl IHBhZ2VzIGZvcgpQTUQgbGV2ZWwuCgpIYW5kbGUgdGhlc2UgY29ybmVyIGNhc2VzIGZvciB0aGUg aHVnZSBtYXBwaW5ncyBhdCBzdGFnZTIgYnkKdW5tYXBwaW5nIHRoZSBQVEUgbGV2ZWwgbWFwcGlu Zy4gVGhpcyBjb3VsZCBwb3RlbnRpYWxseSByZWxlYXNlCnRoZSB1cHBlciBsZXZlbCB0YWJsZS4g U28gd2UgbmVlZCB0byByZXN0YXJ0IHRoZSB0YWJsZSB3YWxrCm9uY2Ugd2UgdW5tYXAgdGhlIHJh bmdlLgoKU2lnbmVkLW9mZi1ieTogU3V6dWtpIEsgUG91bG9zZSA8c3V6dWtpLnBvdWxvc2VAYXJt LmNvbT4KLS0tCiB2aXJ0L2t2bS9hcm0vbW11LmMgfCA1NyArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCA0MSBpbnNl cnRpb25zKCspLCAxNiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS92aXJ0L2t2bS9hcm0vbW11 LmMgYi92aXJ0L2t2bS9hcm0vbW11LmMKaW5kZXggZmNlMDk4My4uYTM4YTNmMSAxMDA2NDQKLS0t IGEvdmlydC9rdm0vYXJtL21tdS5jCisrKyBiL3ZpcnQva3ZtL2FybS9tbXUuYwpAQCAtMTA2MCwy NSArMTA2MCw0MSBAQCBzdGF0aWMgaW50IHN0YWdlMl9zZXRfcG1kX2h1Z2Uoc3RydWN0IGt2bSAq a3ZtLCBzdHJ1Y3Qga3ZtX21tdV9tZW1vcnlfY2FjaGUKIHsKIAlwbWRfdCAqcG1kLCBvbGRfcG1k OwogCityZXRyeToKIAlwbWQgPSBzdGFnZTJfZ2V0X3BtZChrdm0sIGNhY2hlLCBhZGRyKTsKIAlW TV9CVUdfT04oIXBtZCk7CiAKIAlvbGRfcG1kID0gKnBtZDsKKwkvKgorCSAqIE11bHRpcGxlIHZj cHVzIGZhdWx0aW5nIG9uIHRoZSBzYW1lIFBNRCBlbnRyeSwgY2FuCisJICogbGVhZCB0byB0aGVt IHNlcXVlbnRpYWxseSB1cGRhdGluZyB0aGUgUE1EIHdpdGggdGhlCisJICogc2FtZSB2YWx1ZS4g Rm9sbG93aW5nIHRoZSBicmVhay1iZWZvcmUtbWFrZQorCSAqIChwbWRfY2xlYXIoKSBmb2xsb3dl ZCBieSB0bGJfZmx1c2goKSkgcHJvY2VzcyBjYW4KKwkgKiBoaW5kZXIgZm9yd2FyZCBwcm9ncmVz cyBkdWUgdG8gcmVmYXVsdHMgZ2VuZXJhdGVkCisJICogb24gbWlzc2luZyB0cmFuc2xhdGlvbnMu CisJICoKKwkgKiBTa2lwIHVwZGF0aW5nIHRoZSBwYWdlIHRhYmxlIGlmIHRoZSBlbnRyeSBpcwor CSAqIHVuY2hhbmdlZC4KKwkgKi8KKwlpZiAocG1kX3ZhbChvbGRfcG1kKSA9PSBwbWRfdmFsKCpu ZXdfcG1kKSkKKwkJcmV0dXJuIDA7CisKIAlpZiAocG1kX3ByZXNlbnQob2xkX3BtZCkpIHsKIAkJ LyoKLQkJICogTXVsdGlwbGUgdmNwdXMgZmF1bHRpbmcgb24gdGhlIHNhbWUgUE1EIGVudHJ5LCBj YW4KLQkJICogbGVhZCB0byB0aGVtIHNlcXVlbnRpYWxseSB1cGRhdGluZyB0aGUgUE1EIHdpdGgg dGhlCi0JCSAqIHNhbWUgdmFsdWUuIEZvbGxvd2luZyB0aGUgYnJlYWstYmVmb3JlLW1ha2UKLQkJ ICogKHBtZF9jbGVhcigpIGZvbGxvd2VkIGJ5IHRsYl9mbHVzaCgpKSBwcm9jZXNzIGNhbgotCQkg KiBoaW5kZXIgZm9yd2FyZCBwcm9ncmVzcyBkdWUgdG8gcmVmYXVsdHMgZ2VuZXJhdGVkCi0JCSAq IG9uIG1pc3NpbmcgdHJhbnNsYXRpb25zLgotCQkgKgotCQkgKiBTa2lwIHVwZGF0aW5nIHRoZSBw YWdlIHRhYmxlIGlmIHRoZSBlbnRyeSBpcwotCQkgKiB1bmNoYW5nZWQuCisJCSAqIElmIHdlIGFs cmVhZHkgaGF2ZSBQVEUgbGV2ZWwgbWFwcGluZyBmb3IgdGhpcyBibG9jaywKKwkJICogd2UgbXVz dCB1bm1hcCBpdCB0byBhdm9pZCBpbmNvbnNpc3RlbnQgVExCCisJCSAqIHN0YXRlLiBXZSBjb3Vs ZCBlbmQgdXAgaW4gdGhpcyBzaXR1YXRpb24gaWYKKwkJICogdGhlIG1lbW9yeSBzbG90IHdhcyBt YXJrZWQgZm9yIGRpcnR5IGxvZ2dpbmcKKwkJICogYW5kIHdhcyByZXZlcnRlZCwgbGVhdmluZyBQ VEUgbGV2ZWwgbWFwcGluZ3MKKwkJICogZm9yIHRoZSBwYWdlcyBhY2Nlc3NlZCBkdXJpbmcgdGhl IHBlcmlvZC4KKwkJICogTm9ybWFsIFRIUCBzcGxpdC9tZXJnZSBmb2xsb3dzIG1tdV9ub3RpZmll cgorCQkgKiBjYWxsYmFja3MgYW5kIGRvIGdldCBoYW5kbGVkIGFjY29yZGluZ2x5LgorCQkgKiBV bm1hcCB0aGUgUFRFIGxldmVsIG1hcHBpbmcgYW5kIHJldHJ5LgogCQkgKi8KLQkJaWYgKHBtZF92 YWwob2xkX3BtZCkgPT0gcG1kX3ZhbCgqbmV3X3BtZCkpCi0JCQlyZXR1cm4gMDsKLQorCQlpZiAo IXBtZF90aHBfb3JfaHVnZShvbGRfcG1kKSkgeworCQkJdW5tYXBfc3RhZ2UyX3JhbmdlKGt2bSwg KGFkZHIgJiBTMl9QTURfTUFTSyksIFMyX1BNRF9TSVpFKTsKKwkJCWdvdG8gcmV0cnk7CisJCX0K IAkJLyoKIAkJICogTWFwcGluZyBpbiBodWdlIHBhZ2VzIHNob3VsZCBvbmx5IGhhcHBlbiB0aHJv dWdoIGEKIAkJICogZmF1bHQuICBJZiBhIHBhZ2UgaXMgbWVyZ2VkIGludG8gYSB0cmFuc3BhcmVu dCBodWdlCkBAIC0xMDkwLDggKzExMDYsNyBAQCBzdGF0aWMgaW50IHN0YWdlMl9zZXRfcG1kX2h1 Z2Uoc3RydWN0IGt2bSAqa3ZtLCBzdHJ1Y3Qga3ZtX21tdV9tZW1vcnlfY2FjaGUKIAkJICogc2hv dWxkIGJlY29tZSBzcGxpdHRpbmcgZmlyc3QsIHVubWFwcGVkLCBtZXJnZWQsCiAJCSAqIGFuZCBt YXBwZWQgYmFjayBpbiBvbi1kZW1hbmQuCiAJCSAqLwotCQlWTV9CVUdfT04ocG1kX3BmbihvbGRf cG1kKSAhPSBwbWRfcGZuKCpuZXdfcG1kKSk7Ci0KKwkJV0FSTl9PTl9PTkNFKHBtZF9wZm4ob2xk X3BtZCkgIT0gcG1kX3BmbigqbmV3X3BtZCkpOwogCQlwbWRfY2xlYXIocG1kKTsKIAkJa3ZtX3Rs Yl9mbHVzaF92bWlkX2lwYShrdm0sIGFkZHIpOwogCX0gZWxzZSB7CkBAIC0xMTA3LDYgKzExMjIs NyBAQCBzdGF0aWMgaW50IHN0YWdlMl9zZXRfcHVkX2h1Z2Uoc3RydWN0IGt2bSAqa3ZtLCBzdHJ1 Y3Qga3ZtX21tdV9tZW1vcnlfY2FjaGUgKmNhYwogewogCXB1ZF90ICpwdWRwLCBvbGRfcHVkOwog CityZXRyeToKIAlwdWRwID0gc3RhZ2UyX2dldF9wdWQoa3ZtLCBjYWNoZSwgYWRkcik7CiAJVk1f QlVHX09OKCFwdWRwKTsKIApAQCAtMTEyMiw4ICsxMTM4LDE3IEBAIHN0YXRpYyBpbnQgc3RhZ2Uy X3NldF9wdWRfaHVnZShzdHJ1Y3Qga3ZtICprdm0sIHN0cnVjdCBrdm1fbW11X21lbW9yeV9jYWNo ZSAqY2FjCiAJCXJldHVybiAwOwogCiAJaWYgKHN0YWdlMl9wdWRfcHJlc2VudChrdm0sIG9sZF9w dWQpKSB7Ci0JCXN0YWdlMl9wdWRfY2xlYXIoa3ZtLCBwdWRwKTsKLQkJa3ZtX3RsYl9mbHVzaF92 bWlkX2lwYShrdm0sIGFkZHIpOworCQkvKgorCQkgKiBJZiB3ZSBhbHJlYWR5IGhhdmUgUFRFIGxl dmVsIG1hcHBpbmcsIHVubWFwIHRoZSBlbnRpcmUKKwkJICogcmFuZ2UgYW5kIHJldHJ5LgorCQkg Ki8KKwkJaWYgKCFzdGFnZTJfcHVkX2h1Z2Uoa3ZtLCBvbGRfcHVkKSkgeworCQkJdW5tYXBfc3Rh Z2UyX3JhbmdlKGt2bSwgYWRkciAmIFMyX1BVRF9NQVNLLCBTMl9QVURfU0laRSk7CisJCQlnb3Rv IHJldHJ5OworCQl9IGVsc2UgeworCQkJc3RhZ2UyX3B1ZF9jbGVhcihrdm0sIHB1ZHApOworCQkJ a3ZtX3RsYl9mbHVzaF92bWlkX2lwYShrdm0sIGFkZHIpOworCQl9CiAJfSBlbHNlIHsKIAkJZ2V0 X3BhZ2UodmlydF90b19wYWdlKHB1ZHApKTsKIAl9Ci0tIAoyLjcuNAoKCj4gLS0gCj4gMS44LjMu MQo+IAo+IAo+IAo+IAo+IAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBs aXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlz dGluZm8vbGludXgtYXJtLWtlcm5lbAo=