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.7 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 3A25DC76195 for ; Fri, 19 Jul 2019 00:59:08 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 0A34320665 for ; Fri, 19 Jul 2019 00:59:08 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726535AbfGSA7G (ORCPT ); Thu, 18 Jul 2019 20:59:06 -0400 Received: from mail-pg1-f195.google.com ([209.85.215.195]:40370 "EHLO mail-pg1-f195.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726492AbfGSA7F (ORCPT ); Thu, 18 Jul 2019 20:59:05 -0400 Received: by mail-pg1-f195.google.com with SMTP id w10so13661284pgj.7; Thu, 18 Jul 2019 17:59: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=z7W4PDkWeXaZPrNUK/c+i+vfjf2MjCOK5AU8zvB9S68=; b=T15T3GlKk2a55vgbNwDM0mUvHA0CnMPtcRE5h0nJYtjZyOJm2BHt4acXnlVZ0nfbz2 A74ssYKd1UrE+hNaQtYGDAd9qjdEXdk9GEBvKua4hYNaIhNI8qg0buMXBal+45UD1k4y shNDLl9+t8cLBFgJ5g7FInO5XeBUDA2tqIkB+yCw2OOeMMa7N+XH/ndtButEjXHEGClK Afebrk3j9kr1df43UO+Rm1JBkhtHImr4Ea9XHeOKtriQbPVpEj0foYMuR4n7ZWcindVu e2m1d2K8rKWHzD5uqihZ/911HWngPux7/MsrgXCNDM3PdsGM2MPjFwH7QRbR40NFx7Ta /87w== X-Gm-Message-State: APjAAAUv6UjUqOk8cnO9ZYUMBaI6oQ95xPWo+caQ38P2ZCMWwmQNHrq3 4F8kYl3WtPkGuAhd49tyeW0= X-Google-Smtp-Source: APXvYqxNQ0/uVeaBzcrQoRXrm7ObjvZMyoE1Ndm/375Wyb17fCmZyR76u8EhnAcUCW/z5bktSF56tQ== X-Received: by 2002:a63:bd0a:: with SMTP id a10mr50136769pgf.55.1563497944208; Thu, 18 Jul 2019 17:59:04 -0700 (PDT) Received: from htb-2n-eng-dhcp405.eng.vmware.com ([66.170.99.1]) by smtp.gmail.com with ESMTPSA id j128sm14025166pfg.28.2019.07.18.17.59.02 (version=TLS1_3 cipher=AEAD-AES256-GCM-SHA384 bits=256/256); Thu, 18 Jul 2019 17:59:03 -0700 (PDT) From: Nadav Amit To: Andy Lutomirski , Dave Hansen Cc: x86@kernel.org, linux-kernel@vger.kernel.org, Peter Zijlstra , Thomas Gleixner , Ingo Molnar , Nadav Amit , "K. Y. Srinivasan" , Haiyang Zhang , Stephen Hemminger , Sasha Levin , Borislav Petkov , Juergen Gross , Paolo Bonzini , Boris Ostrovsky , linux-hyperv@vger.kernel.org, virtualization@lists.linux-foundation.org, kvm@vger.kernel.org, xen-devel@lists.xenproject.org Subject: [PATCH v3 4/9] x86/mm/tlb: Flush remote and local TLBs concurrently Date: Thu, 18 Jul 2019 17:58:32 -0700 Message-Id: <20190719005837.4150-5-namit@vmware.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190719005837.4150-1-namit@vmware.com> References: <20190719005837.4150-1-namit@vmware.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-hyperv-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-hyperv@vger.kernel.org To improve TLB shootdown performance, flush the remote and local TLBs concurrently. Introduce flush_tlb_multi() that does so. Introduce paravirtual versions of flush_tlb_multi() for KVM, Xen and hyper-v (Xen and hyper-v are only compile-tested). While the updated smp infrastructure is capable of running a function on a single local core, it is not optimized for this case. The multiple function calls and the indirect branch introduce some overhead, and might make local TLB flushes slower than they were before the recent changes. Before calling the SMP infrastructure, check if only a local TLB flush is needed to restore the lost performance in this common case. This requires to check mm_cpumask() one more time, but unless this mask is updated very frequently, this should impact performance negatively. 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 | 10 +++--- arch/x86/include/asm/paravirt.h | 6 ++-- arch/x86/include/asm/paravirt_types.h | 4 +-- arch/x86/include/asm/tlbflush.h | 8 ++--- arch/x86/include/asm/trace/hyperv.h | 2 +- arch/x86/kernel/kvm.c | 11 +++++-- arch/x86/kernel/paravirt.c | 2 +- arch/x86/mm/tlb.c | 47 ++++++++++++++++++--------- arch/x86/xen/mmu_pv.c | 11 +++---- include/trace/events/xen.h | 2 +- 10 files changed, 62 insertions(+), 41 deletions(-) diff --git a/arch/x86/hyperv/mmu.c b/arch/x86/hyperv/mmu.c index e65d7fe6489f..8740d8b21db3 100644 --- a/arch/x86/hyperv/mmu.c +++ b/arch/x86/hyperv/mmu.c @@ -50,8 +50,8 @@ static inline int fill_gva_list(u64 gva_list[], int offset, return gva_n - offset; } -static void hyperv_flush_tlb_others(const struct cpumask *cpus, - const struct flush_tlb_info *info) +static void hyperv_flush_tlb_multi(const struct cpumask *cpus, + const struct flush_tlb_info *info) { int cpu, vcpu, gva_n, max_gvas; struct hv_tlb_flush **flush_pcpu; @@ -59,7 +59,7 @@ static void hyperv_flush_tlb_others(const struct cpumask *cpus, u64 status = U64_MAX; unsigned long flags; - trace_hyperv_mmu_flush_tlb_others(cpus, info); + trace_hyperv_mmu_flush_tlb_multi(cpus, info); if (!hv_hypercall_pg) goto do_native; @@ -156,7 +156,7 @@ static void hyperv_flush_tlb_others(const struct cpumask *cpus, if (!(status & HV_HYPERCALL_RESULT_MASK)) return; do_native: - native_flush_tlb_others(cpus, info); + native_flush_tlb_multi(cpus, info); } static u64 hyperv_flush_tlb_others_ex(const struct cpumask *cpus, @@ -231,6 +231,6 @@ void hyperv_setup_mmu_ops(void) return; pr_info("Using hypercall for remote TLB flush\n"); - pv_ops.mmu.flush_tlb_others = hyperv_flush_tlb_others; + pv_ops.mmu.flush_tlb_multi = hyperv_flush_tlb_multi; pv_ops.mmu.tlb_remove_table = tlb_remove_table; } diff --git a/arch/x86/include/asm/paravirt.h b/arch/x86/include/asm/paravirt.h index dce26f1d13e1..8c6c2394393b 100644 --- a/arch/x86/include/asm/paravirt.h +++ b/arch/x86/include/asm/paravirt.h @@ -62,10 +62,10 @@ static inline void __flush_tlb_one_user(unsigned long addr) PVOP_VCALL1(mmu.flush_tlb_one_user, addr); } -static inline void flush_tlb_others(const struct cpumask *cpumask, - const struct flush_tlb_info *info) +static inline void flush_tlb_multi(const struct cpumask *cpumask, + const struct flush_tlb_info *info) { - PVOP_VCALL2(mmu.flush_tlb_others, cpumask, info); + PVOP_VCALL2(mmu.flush_tlb_multi, cpumask, info); } static inline void paravirt_tlb_remove_table(struct mmu_gather *tlb, void *table) diff --git a/arch/x86/include/asm/paravirt_types.h b/arch/x86/include/asm/paravirt_types.h index 639b2df445ee..c82969f38845 100644 --- a/arch/x86/include/asm/paravirt_types.h +++ b/arch/x86/include/asm/paravirt_types.h @@ -211,8 +211,8 @@ struct pv_mmu_ops { void (*flush_tlb_user)(void); void (*flush_tlb_kernel)(void); void (*flush_tlb_one_user)(unsigned long addr); - void (*flush_tlb_others)(const struct cpumask *cpus, - const struct flush_tlb_info *info); + void (*flush_tlb_multi)(const struct cpumask *cpus, + const struct flush_tlb_info *info); void (*tlb_remove_table)(struct mmu_gather *tlb, void *table); diff --git a/arch/x86/include/asm/tlbflush.h b/arch/x86/include/asm/tlbflush.h index dee375831962..610e47dc66ef 100644 --- a/arch/x86/include/asm/tlbflush.h +++ b/arch/x86/include/asm/tlbflush.h @@ -517,7 +517,7 @@ static inline void __flush_tlb_one_kernel(unsigned long addr) * - flush_tlb_page(vma, vmaddr) flushes one page * - flush_tlb_range(vma, start, end) flushes a range of pages * - flush_tlb_kernel_range(start, end) flushes a range of kernel pages - * - flush_tlb_others(cpumask, info) flushes TLBs on other cpus + * - flush_tlb_multi(cpumask, info) flushes TLBs on multiple cpus * * ..but the i386 has somewhat limited tlb flushing capabilities, * and page-granular flushes are available only on i486 and up. @@ -569,7 +569,7 @@ 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_others(const struct cpumask *cpumask, +void native_flush_tlb_multi(const struct cpumask *cpumask, const struct flush_tlb_info *info); static inline u64 inc_mm_tlb_gen(struct mm_struct *mm) @@ -593,8 +593,8 @@ 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_others(mask, info) \ - native_flush_tlb_others(mask, info) +#define flush_tlb_multi(mask, info) \ + native_flush_tlb_multi(mask, info) #define paravirt_tlb_remove_table(tlb, page) \ tlb_remove_page(tlb, (void *)(page)) diff --git a/arch/x86/include/asm/trace/hyperv.h b/arch/x86/include/asm/trace/hyperv.h index ace464f09681..85ca8560c7f9 100644 --- a/arch/x86/include/asm/trace/hyperv.h +++ b/arch/x86/include/asm/trace/hyperv.h @@ -8,7 +8,7 @@ #if IS_ENABLED(CONFIG_HYPERV) -TRACE_EVENT(hyperv_mmu_flush_tlb_others, +TRACE_EVENT(hyperv_mmu_flush_tlb_multi, TP_PROTO(const struct cpumask *cpus, const struct flush_tlb_info *info), TP_ARGS(cpus, info), diff --git a/arch/x86/kernel/kvm.c b/arch/x86/kernel/kvm.c index b7f34fe2171e..de40657d9025 100644 --- a/arch/x86/kernel/kvm.c +++ b/arch/x86/kernel/kvm.c @@ -595,7 +595,7 @@ static void __init kvm_apf_trap_init(void) static DEFINE_PER_CPU(cpumask_var_t, __pv_tlb_mask); -static void kvm_flush_tlb_others(const struct cpumask *cpumask, +static void kvm_flush_tlb_multi(const struct cpumask *cpumask, const struct flush_tlb_info *info) { u8 state; @@ -609,6 +609,11 @@ static void kvm_flush_tlb_others(const struct cpumask *cpumask, * queue flush_on_enter for pre-empted vCPUs */ for_each_cpu(cpu, flushmask) { + /* + * The local vCPU is never preempted, so we do not explicitly + * skip check for local vCPU - it will never be cleared from + * flushmask. + */ src = &per_cpu(steal_time, cpu); state = READ_ONCE(src->preempted); if ((state & KVM_VCPU_PREEMPTED)) { @@ -618,7 +623,7 @@ static void kvm_flush_tlb_others(const struct cpumask *cpumask, } } - native_flush_tlb_others(flushmask, info); + native_flush_tlb_multi(flushmask, info); } static void __init kvm_guest_init(void) @@ -643,7 +648,7 @@ static void __init kvm_guest_init(void) if (kvm_para_has_feature(KVM_FEATURE_PV_TLB_FLUSH) && !kvm_para_has_hint(KVM_HINTS_REALTIME) && kvm_para_has_feature(KVM_FEATURE_STEAL_TIME)) { - pv_ops.mmu.flush_tlb_others = kvm_flush_tlb_others; + pv_ops.mmu.flush_tlb_multi = kvm_flush_tlb_multi; pv_ops.mmu.tlb_remove_table = tlb_remove_table; } diff --git a/arch/x86/kernel/paravirt.c b/arch/x86/kernel/paravirt.c index 0aa6256eedd8..6af40844a730 100644 --- a/arch/x86/kernel/paravirt.c +++ b/arch/x86/kernel/paravirt.c @@ -363,7 +363,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_others = native_flush_tlb_others, + .mmu.flush_tlb_multi = native_flush_tlb_multi, .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 abbf55fa8b81..63c00908bdd9 100644 --- a/arch/x86/mm/tlb.c +++ b/arch/x86/mm/tlb.c @@ -551,7 +551,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); @@ -665,9 +665,14 @@ static bool tlb_is_not_lazy(int cpu) static DEFINE_PER_CPU(cpumask_t, flush_tlb_mask); -void native_flush_tlb_others(const struct cpumask *cpumask, - const struct flush_tlb_info *info) +void native_flush_tlb_multi(const struct cpumask *cpumask, + const struct flush_tlb_info *info) { + /* + * 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); @@ -687,10 +692,12 @@ 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. */ + flush_tlb_func_local((void *)info); + cpumask = uv_flush_tlb_others(cpumask, info); if (cpumask) smp_call_function_many(cpumask, flush_tlb_func_remote, @@ -709,8 +716,9 @@ 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); + __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(), @@ -737,7 +745,8 @@ void native_flush_tlb_others(const struct cpumask *cpumask, if (tlb_is_not_lazy(cpu)) __cpumask_set_cpu(cpu, cond_cpumask); } - smp_call_function_many(cond_cpumask, flush_tlb_func_remote, + __smp_call_function_many(cond_cpumask, flush_tlb_func_remote, + flush_tlb_func_local, (void *)info, 1); } } @@ -818,16 +827,20 @@ void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start, info = get_flush_tlb_info(mm, start, end, stride_shift, freed_tables, new_tlb_gen); - if (mm == this_cpu_read(cpu_tlbstate.loaded_mm)) { + /* + * flush_tlb_multi() is not optimized for the common case in which only + * a local TLB flush is needed. Optimize this use-case by calling + * flush_tlb_func_local() directly in this case. + */ + if (cpumask_any_but(mm_cpumask(mm), cpu) < nr_cpu_ids) { + flush_tlb_multi(mm_cpumask(mm), info); + } else if (mm == this_cpu_read(cpu_tlbstate.loaded_mm)) { lockdep_assert_irqs_enabled(); local_irq_disable(); flush_tlb_func_local(info); local_irq_enable(); } - if (cpumask_any_but(mm_cpumask(mm), cpu) < nr_cpu_ids) - flush_tlb_others(mm_cpumask(mm), info); - put_flush_tlb_info(); put_cpu(); } @@ -890,16 +903,20 @@ void arch_tlbbatch_flush(struct arch_tlbflush_unmap_batch *batch) { int cpu = get_cpu(); - if (cpumask_test_cpu(cpu, &batch->cpumask)) { + /* + * flush_tlb_multi() is not optimized for the common case in which only + * a local TLB flush is needed. Optimize this use-case by calling + * flush_tlb_func_local() directly in this case. + */ + if (cpumask_any_but(&batch->cpumask, cpu) < nr_cpu_ids) { + flush_tlb_multi(&batch->cpumask, &full_flush_tlb_info); + } else if (cpumask_test_cpu(cpu, &batch->cpumask)) { lockdep_assert_irqs_enabled(); local_irq_disable(); flush_tlb_func_local((void *)&full_flush_tlb_info); local_irq_enable(); } - if (cpumask_any_but(&batch->cpumask, cpu) < nr_cpu_ids) - flush_tlb_others(&batch->cpumask, &full_flush_tlb_info); - cpumask_clear(&batch->cpumask); put_cpu(); diff --git a/arch/x86/xen/mmu_pv.c b/arch/x86/xen/mmu_pv.c index 26e8b326966d..48f7c7eb4dbc 100644 --- a/arch/x86/xen/mmu_pv.c +++ b/arch/x86/xen/mmu_pv.c @@ -1345,8 +1345,8 @@ static void xen_flush_tlb_one_user(unsigned long addr) preempt_enable(); } -static void xen_flush_tlb_others(const struct cpumask *cpus, - const struct flush_tlb_info *info) +static void xen_flush_tlb_multi(const struct cpumask *cpus, + const struct flush_tlb_info *info) { struct { struct mmuext_op op; @@ -1356,7 +1356,7 @@ static void xen_flush_tlb_others(const struct cpumask *cpus, const size_t mc_entry_size = sizeof(args->op) + sizeof(args->mask[0]) * BITS_TO_LONGS(num_possible_cpus()); - trace_xen_mmu_flush_tlb_others(cpus, info->mm, info->start, info->end); + trace_xen_mmu_flush_tlb_multi(cpus, info->mm, info->start, info->end); if (cpumask_empty(cpus)) return; /* nothing to do */ @@ -1365,9 +1365,8 @@ static void xen_flush_tlb_others(const struct cpumask *cpus, args = mcs.args; args->op.arg2.vcpumask = to_cpumask(args->mask); - /* Remove us, and any offline CPUS. */ + /* Remove any offline CPUs */ cpumask_and(to_cpumask(args->mask), cpus, cpu_online_mask); - cpumask_clear_cpu(smp_processor_id(), to_cpumask(args->mask)); args->op.cmd = MMUEXT_TLB_FLUSH_MULTI; if (info->end != TLB_FLUSH_ALL && @@ -2396,7 +2395,7 @@ static const struct pv_mmu_ops xen_mmu_ops __initconst = { .flush_tlb_user = xen_flush_tlb, .flush_tlb_kernel = xen_flush_tlb, .flush_tlb_one_user = xen_flush_tlb_one_user, - .flush_tlb_others = xen_flush_tlb_others, + .flush_tlb_multi = xen_flush_tlb_multi, .tlb_remove_table = tlb_remove_table, .pgd_alloc = xen_pgd_alloc, diff --git a/include/trace/events/xen.h b/include/trace/events/xen.h index 9a0e8af21310..546022acf160 100644 --- a/include/trace/events/xen.h +++ b/include/trace/events/xen.h @@ -362,7 +362,7 @@ TRACE_EVENT(xen_mmu_flush_tlb_one_user, TP_printk("addr %lx", __entry->addr) ); -TRACE_EVENT(xen_mmu_flush_tlb_others, +TRACE_EVENT(xen_mmu_flush_tlb_multi, TP_PROTO(const struct cpumask *cpus, struct mm_struct *mm, unsigned long addr, unsigned long end), TP_ARGS(cpus, mm, addr, end), -- 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.7 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 AA049C76195 for ; Fri, 19 Jul 2019 00:59:33 +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 815542184E for ; Fri, 19 Jul 2019 00:59:33 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 815542184E 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 1hoHEr-0004Hq-PK; Fri, 19 Jul 2019 00:59:09 +0000 Received: from all-amaz-eas1.inumbo.com ([34.197.232.57] helo=us1-amaz-eas2.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1hoHEq-0004Hl-OR for xen-devel@lists.xenproject.org; Fri, 19 Jul 2019 00:59:08 +0000 X-Inumbo-ID: 67993dd0-a9c0-11e9-953c-532004bc9e96 Received: from mail-pf1-f195.google.com (unknown [209.85.210.195]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTPS id 67993dd0-a9c0-11e9-953c-532004bc9e96; Fri, 19 Jul 2019 00:59:05 +0000 (UTC) Received: by mail-pf1-f195.google.com with SMTP id i189so13387019pfg.10 for ; Thu, 18 Jul 2019 17:59:05 -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=z7W4PDkWeXaZPrNUK/c+i+vfjf2MjCOK5AU8zvB9S68=; b=YhQkka4cOuW1Dy23uoAgIwJQX59V86DpiWOOyfLCKsPqvAo52Bpu3GRaXBOJAj+0uS syFr0rO9X8itQwCYNHrvV3t4HevZEZLCgANc90zu1o6BSEAzCX9n52EkCxqNGoZZlvtO 0TfnyvQr2vHm+NaxICw1QX3VAMW+jFJ2oXVN5yy67gfPQx8NaHnXxpym/zWZqmdYY9CG b3j1Yi89rjNGztaE7RLzwZxOJhf4m3Qv7FSGtdkOP8ctNZ2Pd/JPdwehRbgnmpmy4Bu3 cVmWdyWis+B01sswbcdILEv+LOQyqfGPJNun0WvLMYQ5udoraQ5i8BqinWRVhuK8XAnx 9iRA== X-Gm-Message-State: APjAAAXNvgIIQW+96hM1rCLi+QymhWave27mHdAagBz3eL1p138cg56a +3wyTLGGjPhovLTa+yqUAzE= X-Google-Smtp-Source: APXvYqxNQ0/uVeaBzcrQoRXrm7ObjvZMyoE1Ndm/375Wyb17fCmZyR76u8EhnAcUCW/z5bktSF56tQ== X-Received: by 2002:a63:bd0a:: with SMTP id a10mr50136769pgf.55.1563497944208; Thu, 18 Jul 2019 17:59:04 -0700 (PDT) Received: from htb-2n-eng-dhcp405.eng.vmware.com ([66.170.99.1]) by smtp.gmail.com with ESMTPSA id j128sm14025166pfg.28.2019.07.18.17.59.02 (version=TLS1_3 cipher=AEAD-AES256-GCM-SHA384 bits=256/256); Thu, 18 Jul 2019 17:59:03 -0700 (PDT) From: Nadav Amit To: Andy Lutomirski , Dave Hansen Date: Thu, 18 Jul 2019 17:58:32 -0700 Message-Id: <20190719005837.4150-5-namit@vmware.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190719005837.4150-1-namit@vmware.com> References: <20190719005837.4150-1-namit@vmware.com> MIME-Version: 1.0 Subject: [Xen-devel] [PATCH v3 4/9] 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, Stephen Hemminger , xen-devel@lists.xenproject.org, kvm@vger.kernel.org, Peter Zijlstra , Haiyang Zhang , x86@kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, Ingo Molnar , Nadav Amit , Paolo Bonzini , Borislav Petkov , 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 YXQgZG9lcyBzby4gSW50cm9kdWNlCnBhcmF2aXJ0dWFsIHZlcnNpb25zIG9mIGZsdXNoX3RsYl9t dWx0aSgpIGZvciBLVk0sIFhlbiBhbmQgaHlwZXItdiAoWGVuCmFuZCBoeXBlci12IGFyZSBvbmx5 IGNvbXBpbGUtdGVzdGVkKS4KCldoaWxlIHRoZSB1cGRhdGVkIHNtcCBpbmZyYXN0cnVjdHVyZSBp cyBjYXBhYmxlIG9mIHJ1bm5pbmcgYSBmdW5jdGlvbiBvbgphIHNpbmdsZSBsb2NhbCBjb3JlLCBp dCBpcyBub3Qgb3B0aW1pemVkIGZvciB0aGlzIGNhc2UuIFRoZSBtdWx0aXBsZQpmdW5jdGlvbiBj YWxscyBhbmQgdGhlIGluZGlyZWN0IGJyYW5jaCBpbnRyb2R1Y2Ugc29tZSBvdmVyaGVhZCwgYW5k Cm1pZ2h0IG1ha2UgbG9jYWwgVExCIGZsdXNoZXMgc2xvd2VyIHRoYW4gdGhleSB3ZXJlIGJlZm9y ZSB0aGUgcmVjZW50CmNoYW5nZXMuCgpCZWZvcmUgY2FsbGluZyB0aGUgU01QIGluZnJhc3RydWN0 dXJlLCBjaGVjayBpZiBvbmx5IGEgbG9jYWwgVExCIGZsdXNoCmlzIG5lZWRlZCB0byByZXN0b3Jl IHRoZSBsb3N0IHBlcmZvcm1hbmNlIGluIHRoaXMgY29tbW9uIGNhc2UuIFRoaXMKcmVxdWlyZXMg dG8gY2hlY2sgbW1fY3B1bWFzaygpIG9uZSBtb3JlIHRpbWUsIGJ1dCB1bmxlc3MgdGhpcyBtYXNr IGlzCnVwZGF0ZWQgdmVyeSBmcmVxdWVudGx5LCB0aGlzIHNob3VsZCBpbXBhY3QgcGVyZm9ybWFu Y2UgbmVnYXRpdmVseS4KCkNjOiAiSy4gWS4gU3Jpbml2YXNhbiIgPGt5c0BtaWNyb3NvZnQuY29t PgpDYzogSGFpeWFuZyBaaGFuZyA8aGFpeWFuZ3pAbWljcm9zb2Z0LmNvbT4KQ2M6IFN0ZXBoZW4g SGVtbWluZ2VyIDxzdGhlbW1pbkBtaWNyb3NvZnQuY29tPgpDYzogU2FzaGEgTGV2aW4gPHNhc2hh bEBrZXJuZWwub3JnPgpDYzogVGhvbWFzIEdsZWl4bmVyIDx0Z2x4QGxpbnV0cm9uaXguZGU+CkNj OiBJbmdvIE1vbG5hciA8bWluZ29AcmVkaGF0LmNvbT4KQ2M6IEJvcmlzbGF2IFBldGtvdiA8YnBA YWxpZW44LmRlPgpDYzogeDg2QGtlcm5lbC5vcmcKQ2M6IEp1ZXJnZW4gR3Jvc3MgPGpncm9zc0Bz dXNlLmNvbT4KQ2M6IFBhb2xvIEJvbnppbmkgPHBib256aW5pQHJlZGhhdC5jb20+CkNjOiBEYXZl IEhhbnNlbiA8ZGF2ZS5oYW5zZW5AbGludXguaW50ZWwuY29tPgpDYzogQW5keSBMdXRvbWlyc2tp IDxsdXRvQGtlcm5lbC5vcmc+CkNjOiBQZXRlciBaaWpsc3RyYSA8cGV0ZXJ6QGluZnJhZGVhZC5v cmc+CkNjOiBCb3JpcyBPc3Ryb3Zza3kgPGJvcmlzLm9zdHJvdnNreUBvcmFjbGUuY29tPgpDYzog bGludXgtaHlwZXJ2QHZnZXIua2VybmVsLm9yZwpDYzogbGludXgta2VybmVsQHZnZXIua2VybmVs Lm9yZwpDYzogdmlydHVhbGl6YXRpb25AbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKQ2M6IGt2 bUB2Z2VyLmtlcm5lbC5vcmcKQ2M6IHhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwpTaWdu ZWQtb2ZmLWJ5OiBOYWRhdiBBbWl0IDxuYW1pdEB2bXdhcmUuY29tPgotLS0KIGFyY2gveDg2L2h5 cGVydi9tbXUuYyAgICAgICAgICAgICAgICAgfCAxMCArKystLS0KIGFyY2gveDg2L2luY2x1ZGUv YXNtL3BhcmF2aXJ0LmggICAgICAgfCAgNiArKy0tCiBhcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJh dmlydF90eXBlcy5oIHwgIDQgKy0tCiBhcmNoL3g4Ni9pbmNsdWRlL2FzbS90bGJmbHVzaC5oICAg ICAgIHwgIDggKystLS0KIGFyY2gveDg2L2luY2x1ZGUvYXNtL3RyYWNlL2h5cGVydi5oICAgfCAg MiArLQogYXJjaC94ODYva2VybmVsL2t2bS5jICAgICAgICAgICAgICAgICB8IDExICsrKysrLS0K IGFyY2gveDg2L2tlcm5lbC9wYXJhdmlydC5jICAgICAgICAgICAgfCAgMiArLQogYXJjaC94ODYv bW0vdGxiLmMgICAgICAgICAgICAgICAgICAgICB8IDQ3ICsrKysrKysrKysrKysrKysrKy0tLS0t LS0tLQogYXJjaC94ODYveGVuL21tdV9wdi5jICAgICAgICAgICAgICAgICB8IDExICsrKy0tLS0K IGluY2x1ZGUvdHJhY2UvZXZlbnRzL3hlbi5oICAgICAgICAgICAgfCAgMiArLQogMTAgZmlsZXMg Y2hhbmdlZCwgNjIgaW5zZXJ0aW9ucygrKSwgNDEgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEv YXJjaC94ODYvaHlwZXJ2L21tdS5jIGIvYXJjaC94ODYvaHlwZXJ2L21tdS5jCmluZGV4IGU2NWQ3 ZmU2NDg5Zi4uODc0MGQ4YjIxZGIzIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9oeXBlcnYvbW11LmMK KysrIGIvYXJjaC94ODYvaHlwZXJ2L21tdS5jCkBAIC01MCw4ICs1MCw4IEBAIHN0YXRpYyBpbmxp bmUgaW50IGZpbGxfZ3ZhX2xpc3QodTY0IGd2YV9saXN0W10sIGludCBvZmZzZXQsCiAJcmV0dXJu IGd2YV9uIC0gb2Zmc2V0OwogfQogCi1zdGF0aWMgdm9pZCBoeXBlcnZfZmx1c2hfdGxiX290aGVy cyhjb25zdCBzdHJ1Y3QgY3B1bWFzayAqY3B1cywKLQkJCQkgICAgY29uc3Qgc3RydWN0IGZsdXNo X3RsYl9pbmZvICppbmZvKQorc3RhdGljIHZvaWQgaHlwZXJ2X2ZsdXNoX3RsYl9tdWx0aShjb25z dCBzdHJ1Y3QgY3B1bWFzayAqY3B1cywKKwkJCQkgICBjb25zdCBzdHJ1Y3QgZmx1c2hfdGxiX2lu Zm8gKmluZm8pCiB7CiAJaW50IGNwdSwgdmNwdSwgZ3ZhX24sIG1heF9ndmFzOwogCXN0cnVjdCBo dl90bGJfZmx1c2ggKipmbHVzaF9wY3B1OwpAQCAtNTksNyArNTksNyBAQCBzdGF0aWMgdm9pZCBo eXBlcnZfZmx1c2hfdGxiX290aGVycyhjb25zdCBzdHJ1Y3QgY3B1bWFzayAqY3B1cywKIAl1NjQg c3RhdHVzID0gVTY0X01BWDsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCi0JdHJhY2VfaHlwZXJ2 X21tdV9mbHVzaF90bGJfb3RoZXJzKGNwdXMsIGluZm8pOworCXRyYWNlX2h5cGVydl9tbXVfZmx1 c2hfdGxiX211bHRpKGNwdXMsIGluZm8pOwogCiAJaWYgKCFodl9oeXBlcmNhbGxfcGcpCiAJCWdv dG8gZG9fbmF0aXZlOwpAQCAtMTU2LDcgKzE1Niw3IEBAIHN0YXRpYyB2b2lkIGh5cGVydl9mbHVz aF90bGJfb3RoZXJzKGNvbnN0IHN0cnVjdCBjcHVtYXNrICpjcHVzLAogCWlmICghKHN0YXR1cyAm IEhWX0hZUEVSQ0FMTF9SRVNVTFRfTUFTSykpCiAJCXJldHVybjsKIGRvX25hdGl2ZToKLQluYXRp dmVfZmx1c2hfdGxiX290aGVycyhjcHVzLCBpbmZvKTsKKwluYXRpdmVfZmx1c2hfdGxiX211bHRp KGNwdXMsIGluZm8pOwogfQogCiBzdGF0aWMgdTY0IGh5cGVydl9mbHVzaF90bGJfb3RoZXJzX2V4 KGNvbnN0IHN0cnVjdCBjcHVtYXNrICpjcHVzLApAQCAtMjMxLDYgKzIzMSw2IEBAIHZvaWQgaHlw ZXJ2X3NldHVwX21tdV9vcHModm9pZCkKIAkJcmV0dXJuOwogCiAJcHJfaW5mbygiVXNpbmcgaHlw ZXJjYWxsIGZvciByZW1vdGUgVExCIGZsdXNoXG4iKTsKLQlwdl9vcHMubW11LmZsdXNoX3RsYl9v dGhlcnMgPSBoeXBlcnZfZmx1c2hfdGxiX290aGVyczsKKwlwdl9vcHMubW11LmZsdXNoX3RsYl9t dWx0aSA9IGh5cGVydl9mbHVzaF90bGJfbXVsdGk7CiAJcHZfb3BzLm1tdS50bGJfcmVtb3ZlX3Rh YmxlID0gdGxiX3JlbW92ZV90YWJsZTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUv YXNtL3BhcmF2aXJ0LmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJhdmlydC5oCmluZGV4IGRj ZTI2ZjFkMTNlMS4uOGM2YzIzOTQzOTNiIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2Fz bS9wYXJhdmlydC5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BhcmF2aXJ0LmgKQEAgLTYy LDEwICs2MiwxMCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgX19mbHVzaF90bGJfb25lX3VzZXIodW5z aWduZWQgbG9uZyBhZGRyKQogCVBWT1BfVkNBTEwxKG1tdS5mbHVzaF90bGJfb25lX3VzZXIsIGFk ZHIpOwogfQogCi1zdGF0aWMgaW5saW5lIHZvaWQgZmx1c2hfdGxiX290aGVycyhjb25zdCBzdHJ1 Y3QgY3B1bWFzayAqY3B1bWFzaywKLQkJCQkgICAgY29uc3Qgc3RydWN0IGZsdXNoX3RsYl9pbmZv ICppbmZvKQorc3RhdGljIGlubGluZSB2b2lkIGZsdXNoX3RsYl9tdWx0aShjb25zdCBzdHJ1Y3Qg Y3B1bWFzayAqY3B1bWFzaywKKwkJCQkgICBjb25zdCBzdHJ1Y3QgZmx1c2hfdGxiX2luZm8gKmlu Zm8pCiB7Ci0JUFZPUF9WQ0FMTDIobW11LmZsdXNoX3RsYl9vdGhlcnMsIGNwdW1hc2ssIGluZm8p OworCVBWT1BfVkNBTEwyKG1tdS5mbHVzaF90bGJfbXVsdGksIGNwdW1hc2ssIGluZm8pOwogfQog CiBzdGF0aWMgaW5saW5lIHZvaWQgcGFyYXZpcnRfdGxiX3JlbW92ZV90YWJsZShzdHJ1Y3QgbW11 X2dhdGhlciAqdGxiLCB2b2lkICp0YWJsZSkKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUv YXNtL3BhcmF2aXJ0X3R5cGVzLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJhdmlydF90eXBl cy5oCmluZGV4IDYzOWIyZGY0NDVlZS4uYzgyOTY5ZjM4ODQ1IDEwMDY0NAotLS0gYS9hcmNoL3g4 Ni9pbmNsdWRlL2FzbS9wYXJhdmlydF90eXBlcy5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNt L3BhcmF2aXJ0X3R5cGVzLmgKQEAgLTIxMSw4ICsyMTEsOCBAQCBzdHJ1Y3QgcHZfbW11X29wcyB7 CiAJdm9pZCAoKmZsdXNoX3RsYl91c2VyKSh2b2lkKTsKIAl2b2lkICgqZmx1c2hfdGxiX2tlcm5l bCkodm9pZCk7CiAJdm9pZCAoKmZsdXNoX3RsYl9vbmVfdXNlcikodW5zaWduZWQgbG9uZyBhZGRy KTsKLQl2b2lkICgqZmx1c2hfdGxiX290aGVycykoY29uc3Qgc3RydWN0IGNwdW1hc2sgKmNwdXMs Ci0JCQkJIGNvbnN0IHN0cnVjdCBmbHVzaF90bGJfaW5mbyAqaW5mbyk7CisJdm9pZCAoKmZsdXNo X3RsYl9tdWx0aSkoY29uc3Qgc3RydWN0IGNwdW1hc2sgKmNwdXMsCisJCQkJY29uc3Qgc3RydWN0 IGZsdXNoX3RsYl9pbmZvICppbmZvKTsKIAogCXZvaWQgKCp0bGJfcmVtb3ZlX3RhYmxlKShzdHJ1 Y3QgbW11X2dhdGhlciAqdGxiLCB2b2lkICp0YWJsZSk7CiAKZGlmZiAtLWdpdCBhL2FyY2gveDg2 L2luY2x1ZGUvYXNtL3RsYmZsdXNoLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS90bGJmbHVzaC5o CmluZGV4IGRlZTM3NTgzMTk2Mi4uNjEwZTQ3ZGM2NmVmIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9p bmNsdWRlL2FzbS90bGJmbHVzaC5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3RsYmZsdXNo LmgKQEAgLTUxNyw3ICs1MTcsNyBAQCBzdGF0aWMgaW5saW5lIHZvaWQgX19mbHVzaF90bGJfb25l X2tlcm5lbCh1bnNpZ25lZCBsb25nIGFkZHIpCiAgKiAgLSBmbHVzaF90bGJfcGFnZSh2bWEsIHZt YWRkcikgZmx1c2hlcyBvbmUgcGFnZQogICogIC0gZmx1c2hfdGxiX3JhbmdlKHZtYSwgc3RhcnQs IGVuZCkgZmx1c2hlcyBhIHJhbmdlIG9mIHBhZ2VzCiAgKiAgLSBmbHVzaF90bGJfa2VybmVsX3Jh bmdlKHN0YXJ0LCBlbmQpIGZsdXNoZXMgYSByYW5nZSBvZiBrZXJuZWwgcGFnZXMKLSAqICAtIGZs dXNoX3RsYl9vdGhlcnMoY3B1bWFzaywgaW5mbykgZmx1c2hlcyBUTEJzIG9uIG90aGVyIGNwdXMK KyAqICAtIGZsdXNoX3RsYl9tdWx0aShjcHVtYXNrLCBpbmZvKSBmbHVzaGVzIFRMQnMgb24gbXVs dGlwbGUgY3B1cwogICoKICAqIC4uYnV0IHRoZSBpMzg2IGhhcyBzb21ld2hhdCBsaW1pdGVkIHRs YiBmbHVzaGluZyBjYXBhYmlsaXRpZXMsCiAgKiBhbmQgcGFnZS1ncmFudWxhciBmbHVzaGVzIGFy ZSBhdmFpbGFibGUgb25seSBvbiBpNDg2IGFuZCB1cC4KQEAgLTU2OSw3ICs1NjksNyBAQCBzdGF0 aWMgaW5saW5lIHZvaWQgZmx1c2hfdGxiX3BhZ2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEs IHVuc2lnbmVkIGxvbmcgYSkKIAlmbHVzaF90bGJfbW1fcmFuZ2Uodm1hLT52bV9tbSwgYSwgYSAr IFBBR0VfU0laRSwgUEFHRV9TSElGVCwgZmFsc2UpOwogfQogCi12b2lkIG5hdGl2ZV9mbHVzaF90 bGJfb3RoZXJzKGNvbnN0IHN0cnVjdCBjcHVtYXNrICpjcHVtYXNrLAordm9pZCBuYXRpdmVfZmx1 c2hfdGxiX211bHRpKGNvbnN0IHN0cnVjdCBjcHVtYXNrICpjcHVtYXNrLAogCQkJICAgICBjb25z dCBzdHJ1Y3QgZmx1c2hfdGxiX2luZm8gKmluZm8pOwogCiBzdGF0aWMgaW5saW5lIHU2NCBpbmNf bW1fdGxiX2dlbihzdHJ1Y3QgbW1fc3RydWN0ICptbSkKQEAgLTU5Myw4ICs1OTMsOCBAQCBzdGF0 aWMgaW5saW5lIHZvaWQgYXJjaF90bGJiYXRjaF9hZGRfbW0oc3RydWN0IGFyY2hfdGxiZmx1c2hf dW5tYXBfYmF0Y2ggKmJhdGNoLAogZXh0ZXJuIHZvaWQgYXJjaF90bGJiYXRjaF9mbHVzaChzdHJ1 Y3QgYXJjaF90bGJmbHVzaF91bm1hcF9iYXRjaCAqYmF0Y2gpOwogCiAjaWZuZGVmIENPTkZJR19Q QVJBVklSVAotI2RlZmluZSBmbHVzaF90bGJfb3RoZXJzKG1hc2ssIGluZm8pCVwKLQluYXRpdmVf Zmx1c2hfdGxiX290aGVycyhtYXNrLCBpbmZvKQorI2RlZmluZSBmbHVzaF90bGJfbXVsdGkobWFz aywgaW5mbykJXAorCW5hdGl2ZV9mbHVzaF90bGJfbXVsdGkobWFzaywgaW5mbykKIAogI2RlZmlu ZSBwYXJhdmlydF90bGJfcmVtb3ZlX3RhYmxlKHRsYiwgcGFnZSkgXAogCXRsYl9yZW1vdmVfcGFn ZSh0bGIsICh2b2lkICopKHBhZ2UpKQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9hc20v dHJhY2UvaHlwZXJ2LmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS90cmFjZS9oeXBlcnYuaAppbmRl eCBhY2U0NjRmMDk2ODEuLjg1Y2E4NTYwYzdmOSAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVk ZS9hc20vdHJhY2UvaHlwZXJ2LmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vdHJhY2UvaHlw ZXJ2LmgKQEAgLTgsNyArOCw3IEBACiAKICNpZiBJU19FTkFCTEVEKENPTkZJR19IWVBFUlYpCiAK LVRSQUNFX0VWRU5UKGh5cGVydl9tbXVfZmx1c2hfdGxiX290aGVycywKK1RSQUNFX0VWRU5UKGh5 cGVydl9tbXVfZmx1c2hfdGxiX211bHRpLAogCSAgICBUUF9QUk9UTyhjb25zdCBzdHJ1Y3QgY3B1 bWFzayAqY3B1cywKIAkJICAgICBjb25zdCBzdHJ1Y3QgZmx1c2hfdGxiX2luZm8gKmluZm8pLAog CSAgICBUUF9BUkdTKGNwdXMsIGluZm8pLApkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL2t2 bS5jIGIvYXJjaC94ODYva2VybmVsL2t2bS5jCmluZGV4IGI3ZjM0ZmUyMTcxZS4uZGU0MDY1N2Q5 MDI1IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwva3ZtLmMKKysrIGIvYXJjaC94ODYva2Vy bmVsL2t2bS5jCkBAIC01OTUsNyArNTk1LDcgQEAgc3RhdGljIHZvaWQgX19pbml0IGt2bV9hcGZf dHJhcF9pbml0KHZvaWQpCiAKIHN0YXRpYyBERUZJTkVfUEVSX0NQVShjcHVtYXNrX3Zhcl90LCBf X3B2X3RsYl9tYXNrKTsKIAotc3RhdGljIHZvaWQga3ZtX2ZsdXNoX3RsYl9vdGhlcnMoY29uc3Qg c3RydWN0IGNwdW1hc2sgKmNwdW1hc2ssCitzdGF0aWMgdm9pZCBrdm1fZmx1c2hfdGxiX211bHRp KGNvbnN0IHN0cnVjdCBjcHVtYXNrICpjcHVtYXNrLAogCQkJY29uc3Qgc3RydWN0IGZsdXNoX3Rs Yl9pbmZvICppbmZvKQogewogCXU4IHN0YXRlOwpAQCAtNjA5LDYgKzYwOSwxMSBAQCBzdGF0aWMg dm9pZCBrdm1fZmx1c2hfdGxiX290aGVycyhjb25zdCBzdHJ1Y3QgY3B1bWFzayAqY3B1bWFzaywK IAkgKiBxdWV1ZSBmbHVzaF9vbl9lbnRlciBmb3IgcHJlLWVtcHRlZCB2Q1BVcwogCSAqLwogCWZv cl9lYWNoX2NwdShjcHUsIGZsdXNobWFzaykgeworCQkvKgorCQkgKiBUaGUgbG9jYWwgdkNQVSBp cyBuZXZlciBwcmVlbXB0ZWQsIHNvIHdlIGRvIG5vdCBleHBsaWNpdGx5CisJCSAqIHNraXAgY2hl Y2sgZm9yIGxvY2FsIHZDUFUgLSBpdCB3aWxsIG5ldmVyIGJlIGNsZWFyZWQgZnJvbQorCQkgKiBm bHVzaG1hc2suCisJCSAqLwogCQlzcmMgPSAmcGVyX2NwdShzdGVhbF90aW1lLCBjcHUpOwogCQlz dGF0ZSA9IFJFQURfT05DRShzcmMtPnByZWVtcHRlZCk7CiAJCWlmICgoc3RhdGUgJiBLVk1fVkNQ VV9QUkVFTVBURUQpKSB7CkBAIC02MTgsNyArNjIzLDcgQEAgc3RhdGljIHZvaWQga3ZtX2ZsdXNo X3RsYl9vdGhlcnMoY29uc3Qgc3RydWN0IGNwdW1hc2sgKmNwdW1hc2ssCiAJCX0KIAl9CiAKLQlu YXRpdmVfZmx1c2hfdGxiX290aGVycyhmbHVzaG1hc2ssIGluZm8pOworCW5hdGl2ZV9mbHVzaF90 bGJfbXVsdGkoZmx1c2htYXNrLCBpbmZvKTsKIH0KIAogc3RhdGljIHZvaWQgX19pbml0IGt2bV9n dWVzdF9pbml0KHZvaWQpCkBAIC02NDMsNyArNjQ4LDcgQEAgc3RhdGljIHZvaWQgX19pbml0IGt2 bV9ndWVzdF9pbml0KHZvaWQpCiAJaWYgKGt2bV9wYXJhX2hhc19mZWF0dXJlKEtWTV9GRUFUVVJF X1BWX1RMQl9GTFVTSCkgJiYKIAkgICAgIWt2bV9wYXJhX2hhc19oaW50KEtWTV9ISU5UU19SRUFM VElNRSkgJiYKIAkgICAga3ZtX3BhcmFfaGFzX2ZlYXR1cmUoS1ZNX0ZFQVRVUkVfU1RFQUxfVElN RSkpIHsKLQkJcHZfb3BzLm1tdS5mbHVzaF90bGJfb3RoZXJzID0ga3ZtX2ZsdXNoX3RsYl9vdGhl cnM7CisJCXB2X29wcy5tbXUuZmx1c2hfdGxiX211bHRpID0ga3ZtX2ZsdXNoX3RsYl9tdWx0aTsK IAkJcHZfb3BzLm1tdS50bGJfcmVtb3ZlX3RhYmxlID0gdGxiX3JlbW92ZV90YWJsZTsKIAl9CiAK ZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9wYXJhdmlydC5jIGIvYXJjaC94ODYva2VybmVs L3BhcmF2aXJ0LmMKaW5kZXggMGFhNjI1NmVlZGQ4Li42YWY0MDg0NGE3MzAgMTAwNjQ0Ci0tLSBh L2FyY2gveDg2L2tlcm5lbC9wYXJhdmlydC5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9wYXJhdmly dC5jCkBAIC0zNjMsNyArMzYzLDcgQEAgc3RydWN0IHBhcmF2aXJ0X3BhdGNoX3RlbXBsYXRlIHB2 X29wcyA9IHsKIAkubW11LmZsdXNoX3RsYl91c2VyCT0gbmF0aXZlX2ZsdXNoX3RsYiwKIAkubW11 LmZsdXNoX3RsYl9rZXJuZWwJPSBuYXRpdmVfZmx1c2hfdGxiX2dsb2JhbCwKIAkubW11LmZsdXNo X3RsYl9vbmVfdXNlcgk9IG5hdGl2ZV9mbHVzaF90bGJfb25lX3VzZXIsCi0JLm1tdS5mbHVzaF90 bGJfb3RoZXJzCT0gbmF0aXZlX2ZsdXNoX3RsYl9vdGhlcnMsCisJLm1tdS5mbHVzaF90bGJfbXVs dGkJPSBuYXRpdmVfZmx1c2hfdGxiX211bHRpLAogCS5tbXUudGxiX3JlbW92ZV90YWJsZQk9CiAJ CQkodm9pZCAoKikoc3RydWN0IG1tdV9nYXRoZXIgKiwgdm9pZCAqKSl0bGJfcmVtb3ZlX3BhZ2Us CiAKZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL3RsYi5jIGIvYXJjaC94ODYvbW0vdGxiLmMKaW5k ZXggYWJiZjU1ZmE4YjgxLi42M2MwMDkwOGJkZDkgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L21tL3Rs Yi5jCisrKyBiL2FyY2gveDg2L21tL3RsYi5jCkBAIC01NTEsNyArNTUxLDcgQEAgc3RhdGljIHZv aWQgZmx1c2hfdGxiX2Z1bmNfY29tbW9uKGNvbnN0IHN0cnVjdCBmbHVzaF90bGJfaW5mbyAqZiwK IAkJICogZ2FyYmFnZSBpbnRvIG91ciBUTEIuICBTaW5jZSBzd2l0Y2hpbmcgdG8gaW5pdF9tbSBp cyBiYXJlbHkKIAkJICogc2xvd2VyIHRoYW4gYSBtaW5pbWFsIGZsdXNoLCBqdXN0IHN3aXRjaCB0 byBpbml0X21tLgogCQkgKgotCQkgKiBUaGlzIHNob3VsZCBiZSByYXJlLCB3aXRoIG5hdGl2ZV9m bHVzaF90bGJfb3RoZXJzIHNraXBwaW5nCisJCSAqIFRoaXMgc2hvdWxkIGJlIHJhcmUsIHdpdGgg bmF0aXZlX2ZsdXNoX3RsYl9tdWx0aSgpIHNraXBwaW5nCiAJCSAqIElQSXMgdG8gbGF6eSBUTEIg bW9kZSBDUFVzLgogCQkgKi8KIAkJc3dpdGNoX21tX2lycXNfb2ZmKE5VTEwsICZpbml0X21tLCBO VUxMKTsKQEAgLTY2NSw5ICs2NjUsMTQgQEAgc3RhdGljIGJvb2wgdGxiX2lzX25vdF9sYXp5KGlu dCBjcHUpCiAKIHN0YXRpYyBERUZJTkVfUEVSX0NQVShjcHVtYXNrX3QsIGZsdXNoX3RsYl9tYXNr KTsKIAotdm9pZCBuYXRpdmVfZmx1c2hfdGxiX290aGVycyhjb25zdCBzdHJ1Y3QgY3B1bWFzayAq Y3B1bWFzaywKLQkJCSAgICAgY29uc3Qgc3RydWN0IGZsdXNoX3RsYl9pbmZvICppbmZvKQordm9p ZCBuYXRpdmVfZmx1c2hfdGxiX211bHRpKGNvbnN0IHN0cnVjdCBjcHVtYXNrICpjcHVtYXNrLAor CQkJICAgIGNvbnN0IHN0cnVjdCBmbHVzaF90bGJfaW5mbyAqaW5mbykKIHsKKwkvKgorCSAqIERv IGFjY291bnRpbmcgYW5kIHRyYWNpbmcuIE5vdGUgdGhhdCB0aGVyZSBhcmUgKGFuZCBoYXZlIGFs d2F5cyBiZWVuKQorCSAqIGNhc2VzIGluIHdoaWNoIGEgcmVtb3RlIFRMQiBmbHVzaCB3aWxsIGJl IHRyYWNlZCwgYnV0IGV2ZW50dWFsbHkKKwkgKiB3b3VsZCBub3QgaGFwcGVuLgorCSAqLwogCWNv dW50X3ZtX3RsYl9ldmVudChOUl9UTEJfUkVNT1RFX0ZMVVNIKTsKIAlpZiAoaW5mby0+ZW5kID09 IFRMQl9GTFVTSF9BTEwpCiAJCXRyYWNlX3RsYl9mbHVzaChUTEJfUkVNT1RFX1NFTkRfSVBJLCBU TEJfRkxVU0hfQUxMKTsKQEAgLTY4NywxMCArNjkyLDEyIEBAIHZvaWQgbmF0aXZlX2ZsdXNoX3Rs Yl9vdGhlcnMoY29uc3Qgc3RydWN0IGNwdW1hc2sgKmNwdW1hc2ssCiAJCSAqIG1lYW5zIHRoYXQg dGhlIHBlcmNwdSB0bGJfZ2VuIHZhcmlhYmxlcyB3b24ndCBiZSB1cGRhdGVkCiAJCSAqIGFuZCB3 ZSdsbCBkbyBwb2ludGxlc3MgZmx1c2hlcyBvbiBmdXR1cmUgY29udGV4dCBzd2l0Y2hlcy4KIAkJ ICoKLQkJICogUmF0aGVyIHRoYW4gaG9va2luZyBuYXRpdmVfZmx1c2hfdGxiX290aGVycygpIGhl cmUsIEkgdGhpbmsKKwkJICogUmF0aGVyIHRoYW4gaG9va2luZyBuYXRpdmVfZmx1c2hfdGxiX211 bHRpKCkgaGVyZSwgSSB0aGluawogCQkgKiB0aGF0IFVWIHNob3VsZCBiZSB1cGRhdGVkIHNvIHRo YXQgc21wX2NhbGxfZnVuY3Rpb25fbWFueSgpLAogCQkgKiBldGMsIGFyZSBvcHRpbWFsIG9uIFVW LgogCQkgKi8KKwkJZmx1c2hfdGxiX2Z1bmNfbG9jYWwoKHZvaWQgKilpbmZvKTsKKwogCQljcHVt YXNrID0gdXZfZmx1c2hfdGxiX290aGVycyhjcHVtYXNrLCBpbmZvKTsKIAkJaWYgKGNwdW1hc2sp CiAJCQlzbXBfY2FsbF9mdW5jdGlvbl9tYW55KGNwdW1hc2ssIGZsdXNoX3RsYl9mdW5jX3JlbW90 ZSwKQEAgLTcwOSw4ICs3MTYsOSBAQCB2b2lkIG5hdGl2ZV9mbHVzaF90bGJfb3RoZXJzKGNvbnN0 IHN0cnVjdCBjcHVtYXNrICpjcHVtYXNrLAogCSAqIGRvaW5nIGEgc3BlY3VsYXRpdmUgbWVtb3J5 IGFjY2Vzcy4KIAkgKi8KIAlpZiAoaW5mby0+ZnJlZWRfdGFibGVzKSB7Ci0JCXNtcF9jYWxsX2Z1 bmN0aW9uX21hbnkoY3B1bWFzaywgZmx1c2hfdGxiX2Z1bmNfcmVtb3RlLAotCQkJICAgICAgICh2 b2lkICopaW5mbywgMSk7CisJCV9fc21wX2NhbGxfZnVuY3Rpb25fbWFueShjcHVtYXNrLCBmbHVz aF90bGJfZnVuY19yZW1vdGUsCisJCQkJCSBmbHVzaF90bGJfZnVuY19sb2NhbCwKKwkJCQkJICh2 b2lkICopaW5mbywgMSk7CiAJfSBlbHNlIHsKIAkJLyoKIAkJICogQWx0aG91Z2ggd2UgY291bGQg aGF2ZSB1c2VkIG9uX2VhY2hfY3B1X2NvbmRfbWFzaygpLApAQCAtNzM3LDcgKzc0NSw4IEBAIHZv aWQgbmF0aXZlX2ZsdXNoX3RsYl9vdGhlcnMoY29uc3Qgc3RydWN0IGNwdW1hc2sgKmNwdW1hc2ss CiAJCQlpZiAodGxiX2lzX25vdF9sYXp5KGNwdSkpCiAJCQkJX19jcHVtYXNrX3NldF9jcHUoY3B1 LCBjb25kX2NwdW1hc2spOwogCQl9Ci0JCXNtcF9jYWxsX2Z1bmN0aW9uX21hbnkoY29uZF9jcHVt YXNrLCBmbHVzaF90bGJfZnVuY19yZW1vdGUsCisJCV9fc21wX2NhbGxfZnVuY3Rpb25fbWFueShj b25kX2NwdW1hc2ssIGZsdXNoX3RsYl9mdW5jX3JlbW90ZSwKKwkJCQkJIGZsdXNoX3RsYl9mdW5j X2xvY2FsLAogCQkJCQkgKHZvaWQgKilpbmZvLCAxKTsKIAl9CiB9CkBAIC04MTgsMTYgKzgyNywy MCBAQCB2b2lkIGZsdXNoX3RsYl9tbV9yYW5nZShzdHJ1Y3QgbW1fc3RydWN0ICptbSwgdW5zaWdu ZWQgbG9uZyBzdGFydCwKIAlpbmZvID0gZ2V0X2ZsdXNoX3RsYl9pbmZvKG1tLCBzdGFydCwgZW5k LCBzdHJpZGVfc2hpZnQsIGZyZWVkX3RhYmxlcywKIAkJCQkgIG5ld190bGJfZ2VuKTsKIAotCWlm IChtbSA9PSB0aGlzX2NwdV9yZWFkKGNwdV90bGJzdGF0ZS5sb2FkZWRfbW0pKSB7CisJLyoKKwkg KiBmbHVzaF90bGJfbXVsdGkoKSBpcyBub3Qgb3B0aW1pemVkIGZvciB0aGUgY29tbW9uIGNhc2Ug aW4gd2hpY2ggb25seQorCSAqIGEgbG9jYWwgVExCIGZsdXNoIGlzIG5lZWRlZC4gT3B0aW1pemUg dGhpcyB1c2UtY2FzZSBieSBjYWxsaW5nCisJICogZmx1c2hfdGxiX2Z1bmNfbG9jYWwoKSBkaXJl Y3RseSBpbiB0aGlzIGNhc2UuCisJICovCisJaWYgKGNwdW1hc2tfYW55X2J1dChtbV9jcHVtYXNr KG1tKSwgY3B1KSA8IG5yX2NwdV9pZHMpIHsKKwkJZmx1c2hfdGxiX211bHRpKG1tX2NwdW1hc2so bW0pLCBpbmZvKTsKKwl9IGVsc2UgaWYgKG1tID09IHRoaXNfY3B1X3JlYWQoY3B1X3RsYnN0YXRl LmxvYWRlZF9tbSkpIHsKIAkJbG9ja2RlcF9hc3NlcnRfaXJxc19lbmFibGVkKCk7CiAJCWxvY2Fs X2lycV9kaXNhYmxlKCk7CiAJCWZsdXNoX3RsYl9mdW5jX2xvY2FsKGluZm8pOwogCQlsb2NhbF9p cnFfZW5hYmxlKCk7CiAJfQogCi0JaWYgKGNwdW1hc2tfYW55X2J1dChtbV9jcHVtYXNrKG1tKSwg Y3B1KSA8IG5yX2NwdV9pZHMpCi0JCWZsdXNoX3RsYl9vdGhlcnMobW1fY3B1bWFzayhtbSksIGlu Zm8pOwotCiAJcHV0X2ZsdXNoX3RsYl9pbmZvKCk7CiAJcHV0X2NwdSgpOwogfQpAQCAtODkwLDE2 ICs5MDMsMjAgQEAgdm9pZCBhcmNoX3RsYmJhdGNoX2ZsdXNoKHN0cnVjdCBhcmNoX3RsYmZsdXNo X3VubWFwX2JhdGNoICpiYXRjaCkKIHsKIAlpbnQgY3B1ID0gZ2V0X2NwdSgpOwogCi0JaWYgKGNw dW1hc2tfdGVzdF9jcHUoY3B1LCAmYmF0Y2gtPmNwdW1hc2spKSB7CisJLyoKKwkgKiBmbHVzaF90 bGJfbXVsdGkoKSBpcyBub3Qgb3B0aW1pemVkIGZvciB0aGUgY29tbW9uIGNhc2UgaW4gd2hpY2gg b25seQorCSAqIGEgbG9jYWwgVExCIGZsdXNoIGlzIG5lZWRlZC4gT3B0aW1pemUgdGhpcyB1c2Ut Y2FzZSBieSBjYWxsaW5nCisJICogZmx1c2hfdGxiX2Z1bmNfbG9jYWwoKSBkaXJlY3RseSBpbiB0 aGlzIGNhc2UuCisJICovCisJaWYgKGNwdW1hc2tfYW55X2J1dCgmYmF0Y2gtPmNwdW1hc2ssIGNw dSkgPCBucl9jcHVfaWRzKSB7CisJCWZsdXNoX3RsYl9tdWx0aSgmYmF0Y2gtPmNwdW1hc2ssICZm dWxsX2ZsdXNoX3RsYl9pbmZvKTsKKwl9IGVsc2UgaWYgKGNwdW1hc2tfdGVzdF9jcHUoY3B1LCAm YmF0Y2gtPmNwdW1hc2spKSB7CiAJCWxvY2tkZXBfYXNzZXJ0X2lycXNfZW5hYmxlZCgpOwogCQls b2NhbF9pcnFfZGlzYWJsZSgpOwogCQlmbHVzaF90bGJfZnVuY19sb2NhbCgodm9pZCAqKSZmdWxs X2ZsdXNoX3RsYl9pbmZvKTsKIAkJbG9jYWxfaXJxX2VuYWJsZSgpOwogCX0KIAotCWlmIChjcHVt YXNrX2FueV9idXQoJmJhdGNoLT5jcHVtYXNrLCBjcHUpIDwgbnJfY3B1X2lkcykKLQkJZmx1c2hf dGxiX290aGVycygmYmF0Y2gtPmNwdW1hc2ssICZmdWxsX2ZsdXNoX3RsYl9pbmZvKTsKLQogCWNw dW1hc2tfY2xlYXIoJmJhdGNoLT5jcHVtYXNrKTsKIAogCXB1dF9jcHUoKTsKZGlmZiAtLWdpdCBh L2FyY2gveDg2L3hlbi9tbXVfcHYuYyBiL2FyY2gveDg2L3hlbi9tbXVfcHYuYwppbmRleCAyNmU4 YjMyNjk2NmQuLjQ4ZjdjN2ViNGRiYyAxMDA2NDQKLS0tIGEvYXJjaC94ODYveGVuL21tdV9wdi5j CisrKyBiL2FyY2gveDg2L3hlbi9tbXVfcHYuYwpAQCAtMTM0NSw4ICsxMzQ1LDggQEAgc3RhdGlj IHZvaWQgeGVuX2ZsdXNoX3RsYl9vbmVfdXNlcih1bnNpZ25lZCBsb25nIGFkZHIpCiAJcHJlZW1w dF9lbmFibGUoKTsKIH0KIAotc3RhdGljIHZvaWQgeGVuX2ZsdXNoX3RsYl9vdGhlcnMoY29uc3Qg c3RydWN0IGNwdW1hc2sgKmNwdXMsCi0JCQkJIGNvbnN0IHN0cnVjdCBmbHVzaF90bGJfaW5mbyAq aW5mbykKK3N0YXRpYyB2b2lkIHhlbl9mbHVzaF90bGJfbXVsdGkoY29uc3Qgc3RydWN0IGNwdW1h c2sgKmNwdXMsCisJCQkJY29uc3Qgc3RydWN0IGZsdXNoX3RsYl9pbmZvICppbmZvKQogewogCXN0 cnVjdCB7CiAJCXN0cnVjdCBtbXVleHRfb3Agb3A7CkBAIC0xMzU2LDcgKzEzNTYsNyBAQCBzdGF0 aWMgdm9pZCB4ZW5fZmx1c2hfdGxiX290aGVycyhjb25zdCBzdHJ1Y3QgY3B1bWFzayAqY3B1cywK IAljb25zdCBzaXplX3QgbWNfZW50cnlfc2l6ZSA9IHNpemVvZihhcmdzLT5vcCkgKwogCQlzaXpl b2YoYXJncy0+bWFza1swXSkgKiBCSVRTX1RPX0xPTkdTKG51bV9wb3NzaWJsZV9jcHVzKCkpOwog Ci0JdHJhY2VfeGVuX21tdV9mbHVzaF90bGJfb3RoZXJzKGNwdXMsIGluZm8tPm1tLCBpbmZvLT5z dGFydCwgaW5mby0+ZW5kKTsKKwl0cmFjZV94ZW5fbW11X2ZsdXNoX3RsYl9tdWx0aShjcHVzLCBp bmZvLT5tbSwgaW5mby0+c3RhcnQsIGluZm8tPmVuZCk7CiAKIAlpZiAoY3B1bWFza19lbXB0eShj cHVzKSkKIAkJcmV0dXJuOwkJLyogbm90aGluZyB0byBkbyAqLwpAQCAtMTM2NSw5ICsxMzY1LDgg QEAgc3RhdGljIHZvaWQgeGVuX2ZsdXNoX3RsYl9vdGhlcnMoY29uc3Qgc3RydWN0IGNwdW1hc2sg KmNwdXMsCiAJYXJncyA9IG1jcy5hcmdzOwogCWFyZ3MtPm9wLmFyZzIudmNwdW1hc2sgPSB0b19j cHVtYXNrKGFyZ3MtPm1hc2spOwogCi0JLyogUmVtb3ZlIHVzLCBhbmQgYW55IG9mZmxpbmUgQ1BV Uy4gKi8KKwkvKiBSZW1vdmUgYW55IG9mZmxpbmUgQ1BVcyAqLwogCWNwdW1hc2tfYW5kKHRvX2Nw dW1hc2soYXJncy0+bWFzayksIGNwdXMsIGNwdV9vbmxpbmVfbWFzayk7Ci0JY3B1bWFza19jbGVh cl9jcHUoc21wX3Byb2Nlc3Nvcl9pZCgpLCB0b19jcHVtYXNrKGFyZ3MtPm1hc2spKTsKIAogCWFy Z3MtPm9wLmNtZCA9IE1NVUVYVF9UTEJfRkxVU0hfTVVMVEk7CiAJaWYgKGluZm8tPmVuZCAhPSBU TEJfRkxVU0hfQUxMICYmCkBAIC0yMzk2LDcgKzIzOTUsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0 IHB2X21tdV9vcHMgeGVuX21tdV9vcHMgX19pbml0Y29uc3QgPSB7CiAJLmZsdXNoX3RsYl91c2Vy ID0geGVuX2ZsdXNoX3RsYiwKIAkuZmx1c2hfdGxiX2tlcm5lbCA9IHhlbl9mbHVzaF90bGIsCiAJ LmZsdXNoX3RsYl9vbmVfdXNlciA9IHhlbl9mbHVzaF90bGJfb25lX3VzZXIsCi0JLmZsdXNoX3Rs Yl9vdGhlcnMgPSB4ZW5fZmx1c2hfdGxiX290aGVycywKKwkuZmx1c2hfdGxiX211bHRpID0geGVu X2ZsdXNoX3RsYl9tdWx0aSwKIAkudGxiX3JlbW92ZV90YWJsZSA9IHRsYl9yZW1vdmVfdGFibGUs CiAKIAkucGdkX2FsbG9jID0geGVuX3BnZF9hbGxvYywKZGlmZiAtLWdpdCBhL2luY2x1ZGUvdHJh Y2UvZXZlbnRzL3hlbi5oIGIvaW5jbHVkZS90cmFjZS9ldmVudHMveGVuLmgKaW5kZXggOWEwZThh ZjIxMzEwLi41NDYwMjJhY2YxNjAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdHJhY2UvZXZlbnRzL3hl bi5oCisrKyBiL2luY2x1ZGUvdHJhY2UvZXZlbnRzL3hlbi5oCkBAIC0zNjIsNyArMzYyLDcgQEAg VFJBQ0VfRVZFTlQoeGVuX21tdV9mbHVzaF90bGJfb25lX3VzZXIsCiAJICAgIFRQX3ByaW50aygi YWRkciAlbHgiLCBfX2VudHJ5LT5hZGRyKQogCSk7CiAKLVRSQUNFX0VWRU5UKHhlbl9tbXVfZmx1 c2hfdGxiX290aGVycywKK1RSQUNFX0VWRU5UKHhlbl9tbXVfZmx1c2hfdGxiX211bHRpLAogCSAg ICBUUF9QUk9UTyhjb25zdCBzdHJ1Y3QgY3B1bWFzayAqY3B1cywgc3RydWN0IG1tX3N0cnVjdCAq bW0sCiAJCSAgICAgdW5zaWduZWQgbG9uZyBhZGRyLCB1bnNpZ25lZCBsb25nIGVuZCksCiAJICAg IFRQX0FSR1MoY3B1cywgbW0sIGFkZHIsIGVuZCksCi0tIAoyLjIwLjEKCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0 Clhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwpodHRwczovL2xpc3RzLnhlbnByb2plY3Qu b3JnL21haWxtYW4vbGlzdGluZm8veGVuLWRldmVs