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=-9.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT 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 C6069C04AB6 for ; Fri, 31 May 2019 06:37:40 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 9144424961 for ; Fri, 31 May 2019 06:37:40 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726837AbfEaGhJ (ORCPT ); Fri, 31 May 2019 02:37:09 -0400 Received: from mail-pg1-f193.google.com ([209.85.215.193]:33055 "EHLO mail-pg1-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726784AbfEaGhF (ORCPT ); Fri, 31 May 2019 02:37:05 -0400 Received: by mail-pg1-f193.google.com with SMTP id h17so3486873pgv.0; Thu, 30 May 2019 23:37:04 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=a2Mx1/vUAD+hUjRBQ0rljEO+u5VAVjEGIXV2xv53BGI=; b=U8s9UWBEs7VVSL/KW/pX34PH2cNNPktkD5v2dEvWNS0Q8622ED/pvv326dIlHjVlko ZobdEHL2YILFq/BH7RTNypXHGrM2sbraXIXLR3OJ18UuquOvmJAL+hUOiVfOaLJQAPGX nPzvUA2ZhBpAkdvgRHOV+K94McQzf093ih7pB8/XfQkbTvG0ggmqjCIIFseBIPvr5O2Y k97HnDH/ry4WvdtBo4ZLGRNjF6ociV6WL5rMisOH9aYW96q+ZPYwFjLRZyt40YpchetC V9LYDRtibvmMmpqdQ+hRUhvayDuYh8rNcIFHa/749dlr/7ZNfbZ5NiBdGWzZVU2l80Gq nAwg== X-Gm-Message-State: APjAAAWzyw3W6HiY3HiWfPgwQHZwDLhHv+EKT4KbXxSAnU6banyc2zvr BbipJeETyJDFXazAuYxsXq8= X-Google-Smtp-Source: APXvYqz9GhmxhqTntyg3gGdbuyeRsmz9SE9oNH3Wo5RyTBt3cFNm7lf7sT2aHuNRkNsPjjq/Xi4Niw== X-Received: by 2002:a17:90a:ac04:: with SMTP id o4mr7290720pjq.134.1559284623987; Thu, 30 May 2019 23:37:03 -0700 (PDT) Received: from htb-2n-eng-dhcp405.eng.vmware.com ([66.170.99.1]) by smtp.gmail.com with ESMTPSA id g17sm9256429pfk.55.2019.05.30.23.37.02 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 30 May 2019 23:37:03 -0700 (PDT) From: Nadav Amit To: Peter Zijlstra , Andy Lutomirski Cc: Borislav Petkov , Dave Hansen , Ingo Molnar , Thomas Gleixner , x86@kernel.org, linux-kernel@vger.kernel.org, Nadav Amit , "K. Y. Srinivasan" , Haiyang Zhang , Stephen Hemminger , Sasha Levin , Juergen Gross , Paolo Bonzini , Dave Hansen , Boris Ostrovsky , linux-hyperv@vger.kernel.org, virtualization@lists.linux-foundation.org, kvm@vger.kernel.org, xen-devel@lists.xenproject.org Subject: [RFC PATCH v2 04/12] x86/mm/tlb: Flush remote and local TLBs concurrently Date: Thu, 30 May 2019 23:36:37 -0700 Message-Id: <20190531063645.4697-5-namit@vmware.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190531063645.4697-1-namit@vmware.com> References: <20190531063645.4697-1-namit@vmware.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org To improve TLB shootdown performance, flush the remote and local TLBs concurrently. Introduce flush_tlb_multi() that does so. The current flush_tlb_others() interface is kept, since paravirtual interfaces need to be adapted first before it can be removed. This is left for future work. In such PV environments, TLB flushes are not performed, at this time, concurrently. Add a static key to tell whether this new interface is supported. Cc: "K. Y. Srinivasan" Cc: Haiyang Zhang Cc: Stephen Hemminger Cc: Sasha Levin Cc: Thomas Gleixner Cc: Ingo Molnar Cc: Borislav Petkov Cc: x86@kernel.org Cc: Juergen Gross Cc: Paolo Bonzini Cc: Dave Hansen Cc: Andy Lutomirski Cc: Peter Zijlstra Cc: Boris Ostrovsky Cc: linux-hyperv@vger.kernel.org Cc: linux-kernel@vger.kernel.org Cc: virtualization@lists.linux-foundation.org Cc: kvm@vger.kernel.org Cc: xen-devel@lists.xenproject.org Signed-off-by: Nadav Amit --- arch/x86/hyperv/mmu.c | 2 + arch/x86/include/asm/paravirt.h | 8 +++ arch/x86/include/asm/paravirt_types.h | 6 ++ arch/x86/include/asm/tlbflush.h | 6 ++ arch/x86/kernel/kvm.c | 1 + arch/x86/kernel/paravirt.c | 3 + arch/x86/mm/tlb.c | 80 +++++++++++++++++++++++---- arch/x86/xen/mmu_pv.c | 2 + 8 files changed, 96 insertions(+), 12 deletions(-) diff --git a/arch/x86/hyperv/mmu.c b/arch/x86/hyperv/mmu.c index e65d7fe6489f..ca28b400c87c 100644 --- a/arch/x86/hyperv/mmu.c +++ b/arch/x86/hyperv/mmu.c @@ -233,4 +233,6 @@ void hyperv_setup_mmu_ops(void) pr_info("Using hypercall for remote TLB flush\n"); pv_ops.mmu.flush_tlb_others = hyperv_flush_tlb_others; pv_ops.mmu.tlb_remove_table = tlb_remove_table; + + static_key_disable(&flush_tlb_multi_enabled.key); } diff --git a/arch/x86/include/asm/paravirt.h b/arch/x86/include/asm/paravirt.h index c25c38a05c1c..192be7254457 100644 --- a/arch/x86/include/asm/paravirt.h +++ b/arch/x86/include/asm/paravirt.h @@ -47,6 +47,8 @@ static inline void slow_down_io(void) #endif } +DECLARE_STATIC_KEY_TRUE(flush_tlb_multi_enabled); + static inline void __flush_tlb(void) { PVOP_VCALL0(mmu.flush_tlb_user); @@ -62,6 +64,12 @@ static inline void __flush_tlb_one_user(unsigned long addr) PVOP_VCALL1(mmu.flush_tlb_one_user, addr); } +static inline void flush_tlb_multi(const struct cpumask *cpumask, + const struct flush_tlb_info *info) +{ + PVOP_VCALL2(mmu.flush_tlb_multi, cpumask, info); +} + static inline void flush_tlb_others(const struct cpumask *cpumask, const struct flush_tlb_info *info) { diff --git a/arch/x86/include/asm/paravirt_types.h b/arch/x86/include/asm/paravirt_types.h index 946f8f1f1efc..3a156e63c57d 100644 --- a/arch/x86/include/asm/paravirt_types.h +++ b/arch/x86/include/asm/paravirt_types.h @@ -211,6 +211,12 @@ struct pv_mmu_ops { void (*flush_tlb_user)(void); void (*flush_tlb_kernel)(void); void (*flush_tlb_one_user)(unsigned long addr); + /* + * flush_tlb_multi() is the preferred interface. When it is used, + * flush_tlb_others() should return false. + */ + void (*flush_tlb_multi)(const struct cpumask *cpus, + const struct flush_tlb_info *info); void (*flush_tlb_others)(const struct cpumask *cpus, const struct flush_tlb_info *info); diff --git a/arch/x86/include/asm/tlbflush.h b/arch/x86/include/asm/tlbflush.h index dee375831962..79272938cf79 100644 --- a/arch/x86/include/asm/tlbflush.h +++ b/arch/x86/include/asm/tlbflush.h @@ -569,6 +569,9 @@ static inline void flush_tlb_page(struct vm_area_struct *vma, unsigned long a) flush_tlb_mm_range(vma->vm_mm, a, a + PAGE_SIZE, PAGE_SHIFT, false); } +void native_flush_tlb_multi(const struct cpumask *cpumask, + const struct flush_tlb_info *info); + void native_flush_tlb_others(const struct cpumask *cpumask, const struct flush_tlb_info *info); @@ -593,6 +596,9 @@ static inline void arch_tlbbatch_add_mm(struct arch_tlbflush_unmap_batch *batch, extern void arch_tlbbatch_flush(struct arch_tlbflush_unmap_batch *batch); #ifndef CONFIG_PARAVIRT +#define flush_tlb_multi(mask, info) \ + native_flush_tlb_multi(mask, info) + #define flush_tlb_others(mask, info) \ native_flush_tlb_others(mask, info) diff --git a/arch/x86/kernel/kvm.c b/arch/x86/kernel/kvm.c index 3f0cc828cc36..c1c2b88ea3f1 100644 --- a/arch/x86/kernel/kvm.c +++ b/arch/x86/kernel/kvm.c @@ -643,6 +643,7 @@ static void __init kvm_guest_init(void) kvm_para_has_feature(KVM_FEATURE_STEAL_TIME)) { pv_ops.mmu.flush_tlb_others = kvm_flush_tlb_others; pv_ops.mmu.tlb_remove_table = tlb_remove_table; + static_key_disable(&flush_tlb_multi_enabled.key); } if (kvm_para_has_feature(KVM_FEATURE_PV_EOI)) diff --git a/arch/x86/kernel/paravirt.c b/arch/x86/kernel/paravirt.c index 5492a669f658..1314f89304a8 100644 --- a/arch/x86/kernel/paravirt.c +++ b/arch/x86/kernel/paravirt.c @@ -171,6 +171,8 @@ unsigned paravirt_patch_insns(void *insn_buff, unsigned len, return insn_len; } +DEFINE_STATIC_KEY_TRUE(flush_tlb_multi_enabled); + static void native_flush_tlb(void) { __native_flush_tlb(); @@ -375,6 +377,7 @@ struct paravirt_patch_template pv_ops = { .mmu.flush_tlb_user = native_flush_tlb, .mmu.flush_tlb_kernel = native_flush_tlb_global, .mmu.flush_tlb_one_user = native_flush_tlb_one_user, + .mmu.flush_tlb_multi = native_flush_tlb_multi, .mmu.flush_tlb_others = native_flush_tlb_others, .mmu.tlb_remove_table = (void (*)(struct mmu_gather *, void *))tlb_remove_page, diff --git a/arch/x86/mm/tlb.c b/arch/x86/mm/tlb.c index ac98ad76f695..73d0d51b0f61 100644 --- a/arch/x86/mm/tlb.c +++ b/arch/x86/mm/tlb.c @@ -550,7 +550,7 @@ static void flush_tlb_func_common(const struct flush_tlb_info *f, * garbage into our TLB. Since switching to init_mm is barely * slower than a minimal flush, just switch to init_mm. * - * This should be rare, with native_flush_tlb_others skipping + * This should be rare, with native_flush_tlb_multi skipping * IPIs to lazy TLB mode CPUs. */ switch_mm_irqs_off(NULL, &init_mm, NULL); @@ -634,9 +634,12 @@ static void flush_tlb_func_common(const struct flush_tlb_info *f, this_cpu_write(cpu_tlbstate.ctxs[loaded_mm_asid].tlb_gen, mm_tlb_gen); } -static void flush_tlb_func_local(const void *info, enum tlb_flush_reason reason) +static void flush_tlb_func_local(void *info) { const struct flush_tlb_info *f = info; + enum tlb_flush_reason reason; + + reason = (f->mm == NULL) ? TLB_LOCAL_SHOOTDOWN : TLB_LOCAL_MM_SHOOTDOWN; flush_tlb_func_common(f, true, reason); } @@ -654,14 +657,30 @@ static void flush_tlb_func_remote(void *info) flush_tlb_func_common(f, false, TLB_REMOTE_SHOOTDOWN); } -static bool tlb_is_not_lazy(int cpu, void *data) +static inline bool tlb_is_not_lazy(int cpu) { return !per_cpu(cpu_tlbstate.is_lazy, cpu); } -void native_flush_tlb_others(const struct cpumask *cpumask, - const struct flush_tlb_info *info) +static DEFINE_PER_CPU(cpumask_t, flush_tlb_mask); + +void native_flush_tlb_multi(const struct cpumask *cpumask, + const struct flush_tlb_info *info) { + /* + * native_flush_tlb_multi() can handle a single CPU, but it is + * suboptimal if the local TLB should be flushed, and therefore should + * not be used in such case. Check that it is not used in such case, + * and use this assumption for tracing and accounting of remote TLB + * flushes. + */ + VM_WARN_ON(!cpumask_any_but(cpumask, smp_processor_id())); + + /* + * Do accounting and tracing. Note that there are (and have always been) + * cases in which a remote TLB flush will be traced, but eventually + * would not happen. + */ count_vm_tlb_event(NR_TLB_REMOTE_FLUSH); if (info->end == TLB_FLUSH_ALL) trace_tlb_flush(TLB_REMOTE_SEND_IPI, TLB_FLUSH_ALL); @@ -681,10 +700,14 @@ void native_flush_tlb_others(const struct cpumask *cpumask, * means that the percpu tlb_gen variables won't be updated * and we'll do pointless flushes on future context switches. * - * Rather than hooking native_flush_tlb_others() here, I think + * Rather than hooking native_flush_tlb_multi() here, I think * that UV should be updated so that smp_call_function_many(), * etc, are optimal on UV. */ + local_irq_disable(); + flush_tlb_func_local((__force void *)info); + local_irq_enable(); + cpumask = uv_flush_tlb_others(cpumask, info); if (cpumask) smp_call_function_many(cpumask, flush_tlb_func_remote, @@ -703,11 +726,39 @@ void native_flush_tlb_others(const struct cpumask *cpumask, * doing a speculative memory access. */ if (info->freed_tables) - smp_call_function_many(cpumask, flush_tlb_func_remote, - (void *)info, 1); - else - on_each_cpu_cond_mask(tlb_is_not_lazy, flush_tlb_func_remote, - (void *)info, 1, GFP_ATOMIC, cpumask); + __smp_call_function_many(cpumask, flush_tlb_func_remote, + flush_tlb_func_local, (void *)info, 1); + else { + /* + * Although we could have used on_each_cpu_cond_mask(), + * open-coding it has several performance advantages: (1) we can + * use specialized functions for remote and local flushes; (2) + * no need for indirect branch to test if TLB is lazy; (3) we + * can use a designated cpumask for evaluating the condition + * instead of allocating a new one. + * + * This works under the assumption that there are no nested TLB + * flushes, an assumption that is already made in + * flush_tlb_mm_range(). + */ + struct cpumask *cond_cpumask = this_cpu_ptr(&flush_tlb_mask); + int cpu; + + cpumask_clear(cond_cpumask); + + for_each_cpu(cpu, cpumask) { + if (tlb_is_not_lazy(cpu)) + __cpumask_set_cpu(cpu, cond_cpumask); + } + __smp_call_function_many(cond_cpumask, flush_tlb_func_remote, + flush_tlb_func_local, (void *)info, 1); + } +} + +void native_flush_tlb_others(const struct cpumask *cpumask, + const struct flush_tlb_info *info) +{ + native_flush_tlb_multi(cpumask, info); } /* @@ -773,10 +824,15 @@ static void flush_tlb_on_cpus(const cpumask_t *cpumask, { int this_cpu = smp_processor_id(); + if (static_branch_likely(&flush_tlb_multi_enabled)) { + flush_tlb_multi(cpumask, info); + return; + } + if (cpumask_test_cpu(this_cpu, cpumask)) { lockdep_assert_irqs_enabled(); local_irq_disable(); - flush_tlb_func_local(info, TLB_LOCAL_MM_SHOOTDOWN); + flush_tlb_func_local((__force void *)info); local_irq_enable(); } diff --git a/arch/x86/xen/mmu_pv.c b/arch/x86/xen/mmu_pv.c index beb44e22afdf..0cb277848cb4 100644 --- a/arch/x86/xen/mmu_pv.c +++ b/arch/x86/xen/mmu_pv.c @@ -2474,6 +2474,8 @@ void __init xen_init_mmu_ops(void) pv_ops.mmu = xen_mmu_ops; + static_key_disable(&flush_tlb_multi_enabled.key); + memset(dummy_mapping, 0xff, PAGE_SIZE); } -- 2.20.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=-9.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT 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 C4103C04AB6 for ; Fri, 31 May 2019 06:37:32 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (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 9548925783 for ; Fri, 31 May 2019 06:37:32 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 9548925783 Authentication-Results: mail.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=vmware.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1hWbA4-0004So-DV; Fri, 31 May 2019 06:37:08 +0000 Received: from us1-rack-dfw2.inumbo.com ([104.130.134.6]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1hWbA3-0004Sj-0W for xen-devel@lists.xenproject.org; Fri, 31 May 2019 06:37:07 +0000 X-Inumbo-ID: 811407b9-836e-11e9-8980-bc764e045a96 Received: from mail-pg1-f195.google.com (unknown [209.85.215.195]) by us1-rack-dfw2.inumbo.com (Halon) with ESMTPS id 811407b9-836e-11e9-8980-bc764e045a96; Fri, 31 May 2019 06:37:04 +0000 (UTC) Received: by mail-pg1-f195.google.com with SMTP id n2so3455195pgp.11 for ; Thu, 30 May 2019 23:37:04 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=a2Mx1/vUAD+hUjRBQ0rljEO+u5VAVjEGIXV2xv53BGI=; b=ddm/0IWlT9HsF+o2/VoPjo+UjCnG2b4tUx75++wsPHbyfCF5RBt87soKySKYl/tCLJ bCqZPLn4/GGGbyQyNd1JjssQr3Vcyc2VG+49X8BiRRE64hLVISskzuNkIIy3khfz7fX9 RZHx4bUfnb/JlRenq2u54vW8D89YSQybna3Qa6nz7Gg5qdPNpaRwymbR7M0E9PMXgeB2 iimawLUY6Hc/YCKh6kCvDMTfWv/bjLQVva/mSqbbp0n1/MHla8fA0yLfStuy/aDgXOoF n1FQd+XtJ/1YXH+MMDDgGKgr5+duQjBBbNZWLtZjWqzPI5grgpAb9LBj11zOde6NEv7B 315w== X-Gm-Message-State: APjAAAWeQCJgqkOLsah9l4ngFpn1EqSluHg9XbTZapQlDtaKJNFB9dLq hvNV7kWJxpFmowMvV2d0h2tgyPMe/P9E0g== X-Google-Smtp-Source: APXvYqz9GhmxhqTntyg3gGdbuyeRsmz9SE9oNH3Wo5RyTBt3cFNm7lf7sT2aHuNRkNsPjjq/Xi4Niw== X-Received: by 2002:a17:90a:ac04:: with SMTP id o4mr7290720pjq.134.1559284623987; Thu, 30 May 2019 23:37:03 -0700 (PDT) Received: from htb-2n-eng-dhcp405.eng.vmware.com ([66.170.99.1]) by smtp.gmail.com with ESMTPSA id g17sm9256429pfk.55.2019.05.30.23.37.02 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 30 May 2019 23:37:03 -0700 (PDT) From: Nadav Amit To: Peter Zijlstra , Andy Lutomirski Date: Thu, 30 May 2019 23:36:37 -0700 Message-Id: <20190531063645.4697-5-namit@vmware.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190531063645.4697-1-namit@vmware.com> References: <20190531063645.4697-1-namit@vmware.com> MIME-Version: 1.0 Subject: [Xen-devel] [RFC PATCH v2 04/12] x86/mm/tlb: Flush remote and local TLBs concurrently X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Sasha Levin , Juergen Gross , linux-hyperv@vger.kernel.org, Dave Hansen , Stephen Hemminger , xen-devel@lists.xenproject.org, kvm@vger.kernel.org, Haiyang Zhang , x86@kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, Dave Hansen , Ingo Molnar , Borislav Petkov , Paolo Bonzini , Nadav Amit , Thomas Gleixner , "K. Y. Srinivasan" , Boris Ostrovsky Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" VG8gaW1wcm92ZSBUTEIgc2hvb3Rkb3duIHBlcmZvcm1hbmNlLCBmbHVzaCB0aGUgcmVtb3RlIGFu ZCBsb2NhbCBUTEJzCmNvbmN1cnJlbnRseS4gSW50cm9kdWNlIGZsdXNoX3RsYl9tdWx0aSgpIHRo YXQgZG9lcyBzby4gVGhlIGN1cnJlbnQKZmx1c2hfdGxiX290aGVycygpIGludGVyZmFjZSBpcyBr ZXB0LCBzaW5jZSBwYXJhdmlydHVhbCBpbnRlcmZhY2VzIG5lZWQKdG8gYmUgYWRhcHRlZCBmaXJz dCBiZWZvcmUgaXQgY2FuIGJlIHJlbW92ZWQuIFRoaXMgaXMgbGVmdCBmb3IgZnV0dXJlCndvcmsu IEluIHN1Y2ggUFYgZW52aXJvbm1lbnRzLCBUTEIgZmx1c2hlcyBhcmUgbm90IHBlcmZvcm1lZCwg YXQgdGhpcwp0aW1lLCBjb25jdXJyZW50bHkuCgpBZGQgYSBzdGF0aWMga2V5IHRvIHRlbGwgd2hl dGhlciB0aGlzIG5ldyBpbnRlcmZhY2UgaXMgc3VwcG9ydGVkLgoKQ2M6ICJLLiBZLiBTcmluaXZh c2FuIiA8a3lzQG1pY3Jvc29mdC5jb20+CkNjOiBIYWl5YW5nIFpoYW5nIDxoYWl5YW5nekBtaWNy b3NvZnQuY29tPgpDYzogU3RlcGhlbiBIZW1taW5nZXIgPHN0aGVtbWluQG1pY3Jvc29mdC5jb20+ CkNjOiBTYXNoYSBMZXZpbiA8c2FzaGFsQGtlcm5lbC5vcmc+CkNjOiBUaG9tYXMgR2xlaXhuZXIg PHRnbHhAbGludXRyb25peC5kZT4KQ2M6IEluZ28gTW9sbmFyIDxtaW5nb0ByZWRoYXQuY29tPgpD YzogQm9yaXNsYXYgUGV0a292IDxicEBhbGllbjguZGU+CkNjOiB4ODZAa2VybmVsLm9yZwpDYzog SnVlcmdlbiBHcm9zcyA8amdyb3NzQHN1c2UuY29tPgpDYzogUGFvbG8gQm9uemluaSA8cGJvbnpp bmlAcmVkaGF0LmNvbT4KQ2M6IERhdmUgSGFuc2VuIDxkYXZlLmhhbnNlbkBsaW51eC5pbnRlbC5j b20+CkNjOiBBbmR5IEx1dG9taXJza2kgPGx1dG9Aa2VybmVsLm9yZz4KQ2M6IFBldGVyIFppamxz dHJhIDxwZXRlcnpAaW5mcmFkZWFkLm9yZz4KQ2M6IEJvcmlzIE9zdHJvdnNreSA8Ym9yaXMub3N0 cm92c2t5QG9yYWNsZS5jb20+CkNjOiBsaW51eC1oeXBlcnZAdmdlci5rZXJuZWwub3JnCkNjOiBs aW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3JnCkNjOiB2aXJ0dWFsaXphdGlvbkBsaXN0cy5saW51 eC1mb3VuZGF0aW9uLm9yZwpDYzoga3ZtQHZnZXIua2VybmVsLm9yZwpDYzogeGVuLWRldmVsQGxp c3RzLnhlbnByb2plY3Qub3JnClNpZ25lZC1vZmYtYnk6IE5hZGF2IEFtaXQgPG5hbWl0QHZtd2Fy ZS5jb20+Ci0tLQogYXJjaC94ODYvaHlwZXJ2L21tdS5jICAgICAgICAgICAgICAgICB8ICAyICsK IGFyY2gveDg2L2luY2x1ZGUvYXNtL3BhcmF2aXJ0LmggICAgICAgfCAgOCArKysKIGFyY2gveDg2 L2luY2x1ZGUvYXNtL3BhcmF2aXJ0X3R5cGVzLmggfCAgNiArKwogYXJjaC94ODYvaW5jbHVkZS9h c20vdGxiZmx1c2guaCAgICAgICB8ICA2ICsrCiBhcmNoL3g4Ni9rZXJuZWwva3ZtLmMgICAgICAg ICAgICAgICAgIHwgIDEgKwogYXJjaC94ODYva2VybmVsL3BhcmF2aXJ0LmMgICAgICAgICAgICB8 ICAzICsKIGFyY2gveDg2L21tL3RsYi5jICAgICAgICAgICAgICAgICAgICAgfCA4MCArKysrKysr KysrKysrKysrKysrKysrKy0tLS0KIGFyY2gveDg2L3hlbi9tbXVfcHYuYyAgICAgICAgICAgICAg ICAgfCAgMiArCiA4IGZpbGVzIGNoYW5nZWQsIDk2IGluc2VydGlvbnMoKyksIDEyIGRlbGV0aW9u cygtKQoKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2h5cGVydi9tbXUuYyBiL2FyY2gveDg2L2h5cGVy di9tbXUuYwppbmRleCBlNjVkN2ZlNjQ4OWYuLmNhMjhiNDAwYzg3YyAxMDA2NDQKLS0tIGEvYXJj aC94ODYvaHlwZXJ2L21tdS5jCisrKyBiL2FyY2gveDg2L2h5cGVydi9tbXUuYwpAQCAtMjMzLDQg KzIzMyw2IEBAIHZvaWQgaHlwZXJ2X3NldHVwX21tdV9vcHModm9pZCkKIAlwcl9pbmZvKCJVc2lu ZyBoeXBlcmNhbGwgZm9yIHJlbW90ZSBUTEIgZmx1c2hcbiIpOwogCXB2X29wcy5tbXUuZmx1c2hf dGxiX290aGVycyA9IGh5cGVydl9mbHVzaF90bGJfb3RoZXJzOwogCXB2X29wcy5tbXUudGxiX3Jl bW92ZV90YWJsZSA9IHRsYl9yZW1vdmVfdGFibGU7CisKKwlzdGF0aWNfa2V5X2Rpc2FibGUoJmZs dXNoX3RsYl9tdWx0aV9lbmFibGVkLmtleSk7CiB9CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNs dWRlL2FzbS9wYXJhdmlydC5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vcGFyYXZpcnQuaAppbmRl eCBjMjVjMzhhMDVjMWMuLjE5MmJlNzI1NDQ1NyAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVk ZS9hc20vcGFyYXZpcnQuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJhdmlydC5oCkBA IC00Nyw2ICs0Nyw4IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBzbG93X2Rvd25faW8odm9pZCkKICNl bmRpZgogfQogCitERUNMQVJFX1NUQVRJQ19LRVlfVFJVRShmbHVzaF90bGJfbXVsdGlfZW5hYmxl ZCk7CisKIHN0YXRpYyBpbmxpbmUgdm9pZCBfX2ZsdXNoX3RsYih2b2lkKQogewogCVBWT1BfVkNB TEwwKG1tdS5mbHVzaF90bGJfdXNlcik7CkBAIC02Miw2ICs2NCwxMiBAQCBzdGF0aWMgaW5saW5l IHZvaWQgX19mbHVzaF90bGJfb25lX3VzZXIodW5zaWduZWQgbG9uZyBhZGRyKQogCVBWT1BfVkNB TEwxKG1tdS5mbHVzaF90bGJfb25lX3VzZXIsIGFkZHIpOwogfQogCitzdGF0aWMgaW5saW5lIHZv aWQgZmx1c2hfdGxiX211bHRpKGNvbnN0IHN0cnVjdCBjcHVtYXNrICpjcHVtYXNrLAorCQkJCSAg IGNvbnN0IHN0cnVjdCBmbHVzaF90bGJfaW5mbyAqaW5mbykKK3sKKwlQVk9QX1ZDQUxMMihtbXUu Zmx1c2hfdGxiX211bHRpLCBjcHVtYXNrLCBpbmZvKTsKK30KKwogc3RhdGljIGlubGluZSB2b2lk IGZsdXNoX3RsYl9vdGhlcnMoY29uc3Qgc3RydWN0IGNwdW1hc2sgKmNwdW1hc2ssCiAJCQkJICAg IGNvbnN0IHN0cnVjdCBmbHVzaF90bGJfaW5mbyAqaW5mbykKIHsKZGlmZiAtLWdpdCBhL2FyY2gv eDg2L2luY2x1ZGUvYXNtL3BhcmF2aXJ0X3R5cGVzLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9w YXJhdmlydF90eXBlcy5oCmluZGV4IDk0NmY4ZjFmMWVmYy4uM2ExNTZlNjNjNTdkIDEwMDY0NAot LS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJhdmlydF90eXBlcy5oCisrKyBiL2FyY2gveDg2 L2luY2x1ZGUvYXNtL3BhcmF2aXJ0X3R5cGVzLmgKQEAgLTIxMSw2ICsyMTEsMTIgQEAgc3RydWN0 IHB2X21tdV9vcHMgewogCXZvaWQgKCpmbHVzaF90bGJfdXNlcikodm9pZCk7CiAJdm9pZCAoKmZs dXNoX3RsYl9rZXJuZWwpKHZvaWQpOwogCXZvaWQgKCpmbHVzaF90bGJfb25lX3VzZXIpKHVuc2ln bmVkIGxvbmcgYWRkcik7CisJLyoKKwkgKiBmbHVzaF90bGJfbXVsdGkoKSBpcyB0aGUgcHJlZmVy cmVkIGludGVyZmFjZS4gV2hlbiBpdCBpcyB1c2VkLAorCSAqIGZsdXNoX3RsYl9vdGhlcnMoKSBz aG91bGQgcmV0dXJuIGZhbHNlLgorCSAqLworCXZvaWQgKCpmbHVzaF90bGJfbXVsdGkpKGNvbnN0 IHN0cnVjdCBjcHVtYXNrICpjcHVzLAorCQkJCWNvbnN0IHN0cnVjdCBmbHVzaF90bGJfaW5mbyAq aW5mbyk7CiAJdm9pZCAoKmZsdXNoX3RsYl9vdGhlcnMpKGNvbnN0IHN0cnVjdCBjcHVtYXNrICpj cHVzLAogCQkJCSBjb25zdCBzdHJ1Y3QgZmx1c2hfdGxiX2luZm8gKmluZm8pOwogCmRpZmYgLS1n aXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS90bGJmbHVzaC5oIGIvYXJjaC94ODYvaW5jbHVkZS9h c20vdGxiZmx1c2guaAppbmRleCBkZWUzNzU4MzE5NjIuLjc5MjcyOTM4Y2Y3OSAxMDA2NDQKLS0t IGEvYXJjaC94ODYvaW5jbHVkZS9hc20vdGxiZmx1c2guaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRl L2FzbS90bGJmbHVzaC5oCkBAIC01NjksNiArNTY5LDkgQEAgc3RhdGljIGlubGluZSB2b2lkIGZs dXNoX3RsYl9wYWdlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLCB1bnNpZ25lZCBsb25nIGEp CiAJZmx1c2hfdGxiX21tX3JhbmdlKHZtYS0+dm1fbW0sIGEsIGEgKyBQQUdFX1NJWkUsIFBBR0Vf U0hJRlQsIGZhbHNlKTsKIH0KIAordm9pZCBuYXRpdmVfZmx1c2hfdGxiX211bHRpKGNvbnN0IHN0 cnVjdCBjcHVtYXNrICpjcHVtYXNrLAorCQkJICAgICBjb25zdCBzdHJ1Y3QgZmx1c2hfdGxiX2lu Zm8gKmluZm8pOworCiB2b2lkIG5hdGl2ZV9mbHVzaF90bGJfb3RoZXJzKGNvbnN0IHN0cnVjdCBj cHVtYXNrICpjcHVtYXNrLAogCQkJICAgICBjb25zdCBzdHJ1Y3QgZmx1c2hfdGxiX2luZm8gKmlu Zm8pOwogCkBAIC01OTMsNiArNTk2LDkgQEAgc3RhdGljIGlubGluZSB2b2lkIGFyY2hfdGxiYmF0 Y2hfYWRkX21tKHN0cnVjdCBhcmNoX3RsYmZsdXNoX3VubWFwX2JhdGNoICpiYXRjaCwKIGV4dGVy biB2b2lkIGFyY2hfdGxiYmF0Y2hfZmx1c2goc3RydWN0IGFyY2hfdGxiZmx1c2hfdW5tYXBfYmF0 Y2ggKmJhdGNoKTsKIAogI2lmbmRlZiBDT05GSUdfUEFSQVZJUlQKKyNkZWZpbmUgZmx1c2hfdGxi X211bHRpKG1hc2ssIGluZm8pCVwKKwluYXRpdmVfZmx1c2hfdGxiX211bHRpKG1hc2ssIGluZm8p CisKICNkZWZpbmUgZmx1c2hfdGxiX290aGVycyhtYXNrLCBpbmZvKQlcCiAJbmF0aXZlX2ZsdXNo X3RsYl9vdGhlcnMobWFzaywgaW5mbykKIApkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL2t2 bS5jIGIvYXJjaC94ODYva2VybmVsL2t2bS5jCmluZGV4IDNmMGNjODI4Y2MzNi4uYzFjMmI4OGVh M2YxIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwva3ZtLmMKKysrIGIvYXJjaC94ODYva2Vy bmVsL2t2bS5jCkBAIC02NDMsNiArNjQzLDcgQEAgc3RhdGljIHZvaWQgX19pbml0IGt2bV9ndWVz dF9pbml0KHZvaWQpCiAJICAgIGt2bV9wYXJhX2hhc19mZWF0dXJlKEtWTV9GRUFUVVJFX1NURUFM X1RJTUUpKSB7CiAJCXB2X29wcy5tbXUuZmx1c2hfdGxiX290aGVycyA9IGt2bV9mbHVzaF90bGJf b3RoZXJzOwogCQlwdl9vcHMubW11LnRsYl9yZW1vdmVfdGFibGUgPSB0bGJfcmVtb3ZlX3RhYmxl OworCQlzdGF0aWNfa2V5X2Rpc2FibGUoJmZsdXNoX3RsYl9tdWx0aV9lbmFibGVkLmtleSk7CiAJ fQogCiAJaWYgKGt2bV9wYXJhX2hhc19mZWF0dXJlKEtWTV9GRUFUVVJFX1BWX0VPSSkpCmRpZmYg LS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvcGFyYXZpcnQuYyBiL2FyY2gveDg2L2tlcm5lbC9wYXJh dmlydC5jCmluZGV4IDU0OTJhNjY5ZjY1OC4uMTMxNGY4OTMwNGE4IDEwMDY0NAotLS0gYS9hcmNo L3g4Ni9rZXJuZWwvcGFyYXZpcnQuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvcGFyYXZpcnQuYwpA QCAtMTcxLDYgKzE3MSw4IEBAIHVuc2lnbmVkIHBhcmF2aXJ0X3BhdGNoX2luc25zKHZvaWQgKmlu c25fYnVmZiwgdW5zaWduZWQgbGVuLAogCXJldHVybiBpbnNuX2xlbjsKIH0KIAorREVGSU5FX1NU QVRJQ19LRVlfVFJVRShmbHVzaF90bGJfbXVsdGlfZW5hYmxlZCk7CisKIHN0YXRpYyB2b2lkIG5h dGl2ZV9mbHVzaF90bGIodm9pZCkKIHsKIAlfX25hdGl2ZV9mbHVzaF90bGIoKTsKQEAgLTM3NSw2 ICszNzcsNyBAQCBzdHJ1Y3QgcGFyYXZpcnRfcGF0Y2hfdGVtcGxhdGUgcHZfb3BzID0gewogCS5t bXUuZmx1c2hfdGxiX3VzZXIJPSBuYXRpdmVfZmx1c2hfdGxiLAogCS5tbXUuZmx1c2hfdGxiX2tl cm5lbAk9IG5hdGl2ZV9mbHVzaF90bGJfZ2xvYmFsLAogCS5tbXUuZmx1c2hfdGxiX29uZV91c2Vy CT0gbmF0aXZlX2ZsdXNoX3RsYl9vbmVfdXNlciwKKwkubW11LmZsdXNoX3RsYl9tdWx0aQk9IG5h dGl2ZV9mbHVzaF90bGJfbXVsdGksCiAJLm1tdS5mbHVzaF90bGJfb3RoZXJzCT0gbmF0aXZlX2Zs dXNoX3RsYl9vdGhlcnMsCiAJLm1tdS50bGJfcmVtb3ZlX3RhYmxlCT0KIAkJCSh2b2lkICgqKShz dHJ1Y3QgbW11X2dhdGhlciAqLCB2b2lkICopKXRsYl9yZW1vdmVfcGFnZSwKZGlmZiAtLWdpdCBh L2FyY2gveDg2L21tL3RsYi5jIGIvYXJjaC94ODYvbW0vdGxiLmMKaW5kZXggYWM5OGFkNzZmNjk1 Li43M2QwZDUxYjBmNjEgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L21tL3RsYi5jCisrKyBiL2FyY2gv eDg2L21tL3RsYi5jCkBAIC01NTAsNyArNTUwLDcgQEAgc3RhdGljIHZvaWQgZmx1c2hfdGxiX2Z1 bmNfY29tbW9uKGNvbnN0IHN0cnVjdCBmbHVzaF90bGJfaW5mbyAqZiwKIAkJICogZ2FyYmFnZSBp bnRvIG91ciBUTEIuICBTaW5jZSBzd2l0Y2hpbmcgdG8gaW5pdF9tbSBpcyBiYXJlbHkKIAkJICog c2xvd2VyIHRoYW4gYSBtaW5pbWFsIGZsdXNoLCBqdXN0IHN3aXRjaCB0byBpbml0X21tLgogCQkg KgotCQkgKiBUaGlzIHNob3VsZCBiZSByYXJlLCB3aXRoIG5hdGl2ZV9mbHVzaF90bGJfb3RoZXJz IHNraXBwaW5nCisJCSAqIFRoaXMgc2hvdWxkIGJlIHJhcmUsIHdpdGggbmF0aXZlX2ZsdXNoX3Rs Yl9tdWx0aSBza2lwcGluZwogCQkgKiBJUElzIHRvIGxhenkgVExCIG1vZGUgQ1BVcy4KIAkJICov CiAJCXN3aXRjaF9tbV9pcnFzX29mZihOVUxMLCAmaW5pdF9tbSwgTlVMTCk7CkBAIC02MzQsOSAr NjM0LDEyIEBAIHN0YXRpYyB2b2lkIGZsdXNoX3RsYl9mdW5jX2NvbW1vbihjb25zdCBzdHJ1Y3Qg Zmx1c2hfdGxiX2luZm8gKmYsCiAJdGhpc19jcHVfd3JpdGUoY3B1X3RsYnN0YXRlLmN0eHNbbG9h ZGVkX21tX2FzaWRdLnRsYl9nZW4sIG1tX3RsYl9nZW4pOwogfQogCi1zdGF0aWMgdm9pZCBmbHVz aF90bGJfZnVuY19sb2NhbChjb25zdCB2b2lkICppbmZvLCBlbnVtIHRsYl9mbHVzaF9yZWFzb24g cmVhc29uKQorc3RhdGljIHZvaWQgZmx1c2hfdGxiX2Z1bmNfbG9jYWwodm9pZCAqaW5mbykKIHsK IAljb25zdCBzdHJ1Y3QgZmx1c2hfdGxiX2luZm8gKmYgPSBpbmZvOworCWVudW0gdGxiX2ZsdXNo X3JlYXNvbiByZWFzb247CisKKwlyZWFzb24gPSAoZi0+bW0gPT0gTlVMTCkgPyBUTEJfTE9DQUxf U0hPT1RET1dOIDogVExCX0xPQ0FMX01NX1NIT09URE9XTjsKIAogCWZsdXNoX3RsYl9mdW5jX2Nv bW1vbihmLCB0cnVlLCByZWFzb24pOwogfQpAQCAtNjU0LDE0ICs2NTcsMzAgQEAgc3RhdGljIHZv aWQgZmx1c2hfdGxiX2Z1bmNfcmVtb3RlKHZvaWQgKmluZm8pCiAJZmx1c2hfdGxiX2Z1bmNfY29t bW9uKGYsIGZhbHNlLCBUTEJfUkVNT1RFX1NIT09URE9XTik7CiB9CiAKLXN0YXRpYyBib29sIHRs Yl9pc19ub3RfbGF6eShpbnQgY3B1LCB2b2lkICpkYXRhKQorc3RhdGljIGlubGluZSBib29sIHRs Yl9pc19ub3RfbGF6eShpbnQgY3B1KQogewogCXJldHVybiAhcGVyX2NwdShjcHVfdGxic3RhdGUu aXNfbGF6eSwgY3B1KTsKIH0KIAotdm9pZCBuYXRpdmVfZmx1c2hfdGxiX290aGVycyhjb25zdCBz dHJ1Y3QgY3B1bWFzayAqY3B1bWFzaywKLQkJCSAgICAgY29uc3Qgc3RydWN0IGZsdXNoX3RsYl9p bmZvICppbmZvKQorc3RhdGljIERFRklORV9QRVJfQ1BVKGNwdW1hc2tfdCwgZmx1c2hfdGxiX21h c2spOworCit2b2lkIG5hdGl2ZV9mbHVzaF90bGJfbXVsdGkoY29uc3Qgc3RydWN0IGNwdW1hc2sg KmNwdW1hc2ssCisJCQkgICAgY29uc3Qgc3RydWN0IGZsdXNoX3RsYl9pbmZvICppbmZvKQogewor CS8qCisJICogbmF0aXZlX2ZsdXNoX3RsYl9tdWx0aSgpIGNhbiBoYW5kbGUgYSBzaW5nbGUgQ1BV LCBidXQgaXQgaXMKKwkgKiBzdWJvcHRpbWFsIGlmIHRoZSBsb2NhbCBUTEIgc2hvdWxkIGJlIGZs dXNoZWQsIGFuZCB0aGVyZWZvcmUgc2hvdWxkCisJICogbm90IGJlIHVzZWQgaW4gc3VjaCBjYXNl LiBDaGVjayB0aGF0IGl0IGlzIG5vdCB1c2VkIGluIHN1Y2ggY2FzZSwKKwkgKiBhbmQgdXNlIHRo aXMgYXNzdW1wdGlvbiBmb3IgdHJhY2luZyBhbmQgYWNjb3VudGluZyBvZiByZW1vdGUgVExCCisJ ICogZmx1c2hlcy4KKwkgKi8KKwlWTV9XQVJOX09OKCFjcHVtYXNrX2FueV9idXQoY3B1bWFzaywg c21wX3Byb2Nlc3Nvcl9pZCgpKSk7CisKKwkvKgorCSAqIERvIGFjY291bnRpbmcgYW5kIHRyYWNp bmcuIE5vdGUgdGhhdCB0aGVyZSBhcmUgKGFuZCBoYXZlIGFsd2F5cyBiZWVuKQorCSAqIGNhc2Vz IGluIHdoaWNoIGEgcmVtb3RlIFRMQiBmbHVzaCB3aWxsIGJlIHRyYWNlZCwgYnV0IGV2ZW50dWFs bHkKKwkgKiB3b3VsZCBub3QgaGFwcGVuLgorCSAqLwogCWNvdW50X3ZtX3RsYl9ldmVudChOUl9U TEJfUkVNT1RFX0ZMVVNIKTsKIAlpZiAoaW5mby0+ZW5kID09IFRMQl9GTFVTSF9BTEwpCiAJCXRy YWNlX3RsYl9mbHVzaChUTEJfUkVNT1RFX1NFTkRfSVBJLCBUTEJfRkxVU0hfQUxMKTsKQEAgLTY4 MSwxMCArNzAwLDE0IEBAIHZvaWQgbmF0aXZlX2ZsdXNoX3RsYl9vdGhlcnMoY29uc3Qgc3RydWN0 IGNwdW1hc2sgKmNwdW1hc2ssCiAJCSAqIG1lYW5zIHRoYXQgdGhlIHBlcmNwdSB0bGJfZ2VuIHZh cmlhYmxlcyB3b24ndCBiZSB1cGRhdGVkCiAJCSAqIGFuZCB3ZSdsbCBkbyBwb2ludGxlc3MgZmx1 c2hlcyBvbiBmdXR1cmUgY29udGV4dCBzd2l0Y2hlcy4KIAkJICoKLQkJICogUmF0aGVyIHRoYW4g aG9va2luZyBuYXRpdmVfZmx1c2hfdGxiX290aGVycygpIGhlcmUsIEkgdGhpbmsKKwkJICogUmF0 aGVyIHRoYW4gaG9va2luZyBuYXRpdmVfZmx1c2hfdGxiX211bHRpKCkgaGVyZSwgSSB0aGluawog CQkgKiB0aGF0IFVWIHNob3VsZCBiZSB1cGRhdGVkIHNvIHRoYXQgc21wX2NhbGxfZnVuY3Rpb25f bWFueSgpLAogCQkgKiBldGMsIGFyZSBvcHRpbWFsIG9uIFVWLgogCQkgKi8KKwkJbG9jYWxfaXJx X2Rpc2FibGUoKTsKKwkJZmx1c2hfdGxiX2Z1bmNfbG9jYWwoKF9fZm9yY2Ugdm9pZCAqKWluZm8p OworCQlsb2NhbF9pcnFfZW5hYmxlKCk7CisKIAkJY3B1bWFzayA9IHV2X2ZsdXNoX3RsYl9vdGhl cnMoY3B1bWFzaywgaW5mbyk7CiAJCWlmIChjcHVtYXNrKQogCQkJc21wX2NhbGxfZnVuY3Rpb25f bWFueShjcHVtYXNrLCBmbHVzaF90bGJfZnVuY19yZW1vdGUsCkBAIC03MDMsMTEgKzcyNiwzOSBA QCB2b2lkIG5hdGl2ZV9mbHVzaF90bGJfb3RoZXJzKGNvbnN0IHN0cnVjdCBjcHVtYXNrICpjcHVt YXNrLAogCSAqIGRvaW5nIGEgc3BlY3VsYXRpdmUgbWVtb3J5IGFjY2Vzcy4KIAkgKi8KIAlpZiAo aW5mby0+ZnJlZWRfdGFibGVzKQotCQlzbXBfY2FsbF9mdW5jdGlvbl9tYW55KGNwdW1hc2ssIGZs dXNoX3RsYl9mdW5jX3JlbW90ZSwKLQkJCSAgICAgICAodm9pZCAqKWluZm8sIDEpOwotCWVsc2UK LQkJb25fZWFjaF9jcHVfY29uZF9tYXNrKHRsYl9pc19ub3RfbGF6eSwgZmx1c2hfdGxiX2Z1bmNf cmVtb3RlLAotCQkJCSh2b2lkICopaW5mbywgMSwgR0ZQX0FUT01JQywgY3B1bWFzayk7CisJCV9f c21wX2NhbGxfZnVuY3Rpb25fbWFueShjcHVtYXNrLCBmbHVzaF90bGJfZnVuY19yZW1vdGUsCisJ CQkJCSBmbHVzaF90bGJfZnVuY19sb2NhbCwgKHZvaWQgKilpbmZvLCAxKTsKKwllbHNlIHsKKwkJ LyoKKwkJICogQWx0aG91Z2ggd2UgY291bGQgaGF2ZSB1c2VkIG9uX2VhY2hfY3B1X2NvbmRfbWFz aygpLAorCQkgKiBvcGVuLWNvZGluZyBpdCBoYXMgc2V2ZXJhbCBwZXJmb3JtYW5jZSBhZHZhbnRh Z2VzOiAoMSkgd2UgY2FuCisJCSAqIHVzZSBzcGVjaWFsaXplZCBmdW5jdGlvbnMgZm9yIHJlbW90 ZSBhbmQgbG9jYWwgZmx1c2hlczsgKDIpCisJCSAqIG5vIG5lZWQgZm9yIGluZGlyZWN0IGJyYW5j aCB0byB0ZXN0IGlmIFRMQiBpcyBsYXp5OyAoMykgd2UKKwkJICogY2FuIHVzZSBhIGRlc2lnbmF0 ZWQgY3B1bWFzayBmb3IgZXZhbHVhdGluZyB0aGUgY29uZGl0aW9uCisJCSAqIGluc3RlYWQgb2Yg YWxsb2NhdGluZyBhIG5ldyBvbmUuCisJCSAqCisJCSAqIFRoaXMgd29ya3MgdW5kZXIgdGhlIGFz c3VtcHRpb24gdGhhdCB0aGVyZSBhcmUgbm8gbmVzdGVkIFRMQgorCQkgKiBmbHVzaGVzLCBhbiBh c3N1bXB0aW9uIHRoYXQgaXMgYWxyZWFkeSBtYWRlIGluCisJCSAqIGZsdXNoX3RsYl9tbV9yYW5n ZSgpLgorCQkgKi8KKwkJc3RydWN0IGNwdW1hc2sgKmNvbmRfY3B1bWFzayA9IHRoaXNfY3B1X3B0 cigmZmx1c2hfdGxiX21hc2spOworCQlpbnQgY3B1OworCisJCWNwdW1hc2tfY2xlYXIoY29uZF9j cHVtYXNrKTsKKworCQlmb3JfZWFjaF9jcHUoY3B1LCBjcHVtYXNrKSB7CisJCQlpZiAodGxiX2lz X25vdF9sYXp5KGNwdSkpCisJCQkJX19jcHVtYXNrX3NldF9jcHUoY3B1LCBjb25kX2NwdW1hc2sp OworCQl9CisJCV9fc21wX2NhbGxfZnVuY3Rpb25fbWFueShjb25kX2NwdW1hc2ssIGZsdXNoX3Rs Yl9mdW5jX3JlbW90ZSwKKwkJCQkJIGZsdXNoX3RsYl9mdW5jX2xvY2FsLCAodm9pZCAqKWluZm8s IDEpOworCX0KK30KKwordm9pZCBuYXRpdmVfZmx1c2hfdGxiX290aGVycyhjb25zdCBzdHJ1Y3Qg Y3B1bWFzayAqY3B1bWFzaywKKwkJCSAgICAgY29uc3Qgc3RydWN0IGZsdXNoX3RsYl9pbmZvICpp bmZvKQoreworCW5hdGl2ZV9mbHVzaF90bGJfbXVsdGkoY3B1bWFzaywgaW5mbyk7CiB9CiAKIC8q CkBAIC03NzMsMTAgKzgyNCwxNSBAQCBzdGF0aWMgdm9pZCBmbHVzaF90bGJfb25fY3B1cyhjb25z dCBjcHVtYXNrX3QgKmNwdW1hc2ssCiB7CiAJaW50IHRoaXNfY3B1ID0gc21wX3Byb2Nlc3Nvcl9p ZCgpOwogCisJaWYgKHN0YXRpY19icmFuY2hfbGlrZWx5KCZmbHVzaF90bGJfbXVsdGlfZW5hYmxl ZCkpIHsKKwkJZmx1c2hfdGxiX211bHRpKGNwdW1hc2ssIGluZm8pOworCQlyZXR1cm47CisJfQor CiAJaWYgKGNwdW1hc2tfdGVzdF9jcHUodGhpc19jcHUsIGNwdW1hc2spKSB7CiAJCWxvY2tkZXBf YXNzZXJ0X2lycXNfZW5hYmxlZCgpOwogCQlsb2NhbF9pcnFfZGlzYWJsZSgpOwotCQlmbHVzaF90 bGJfZnVuY19sb2NhbChpbmZvLCBUTEJfTE9DQUxfTU1fU0hPT1RET1dOKTsKKwkJZmx1c2hfdGxi X2Z1bmNfbG9jYWwoKF9fZm9yY2Ugdm9pZCAqKWluZm8pOwogCQlsb2NhbF9pcnFfZW5hYmxlKCk7 CiAJfQogCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni94ZW4vbW11X3B2LmMgYi9hcmNoL3g4Ni94ZW4v bW11X3B2LmMKaW5kZXggYmViNDRlMjJhZmRmLi4wY2IyNzc4NDhjYjQgMTAwNjQ0Ci0tLSBhL2Fy Y2gveDg2L3hlbi9tbXVfcHYuYworKysgYi9hcmNoL3g4Ni94ZW4vbW11X3B2LmMKQEAgLTI0NzQs NiArMjQ3NCw4IEBAIHZvaWQgX19pbml0IHhlbl9pbml0X21tdV9vcHModm9pZCkKIAogCXB2X29w cy5tbXUgPSB4ZW5fbW11X29wczsKIAorCXN0YXRpY19rZXlfZGlzYWJsZSgmZmx1c2hfdGxiX211 bHRpX2VuYWJsZWQua2V5KTsKKwogCW1lbXNldChkdW1teV9tYXBwaW5nLCAweGZmLCBQQUdFX1NJ WkUpOwogfQogCi0tIAoyLjIwLjEKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW5w cm9qZWN0Lm9yZwpodHRwczovL2xpc3RzLnhlbnByb2plY3Qub3JnL21haWxtYW4vbGlzdGluZm8v eGVuLWRldmVs