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_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_SANE_1 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 DE952C0651F for ; Thu, 4 Jul 2019 15:51:57 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id A316C218A0 for ; Thu, 4 Jul 2019 15:51:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727815AbfGDPv4 (ORCPT ); Thu, 4 Jul 2019 11:51:56 -0400 Received: from foss.arm.com ([217.140.110.172]:44578 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727394AbfGDPv4 (ORCPT ); Thu, 4 Jul 2019 11:51:56 -0400 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 0110D2B; Thu, 4 Jul 2019 08:51:55 -0700 (PDT) Received: from [10.1.31.185] (e121566-lin.cambridge.arm.com [10.1.31.185]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 049AA3F703; Thu, 4 Jul 2019 08:51:53 -0700 (PDT) Subject: Re: [PATCH 35/59] KVM: arm/arm64: nv: Support multiple nested stage 2 mmu structures To: Marc Zyngier , linux-arm-kernel@lists.infradead.org, kvmarm@lists.cs.columbia.edu, kvm@vger.kernel.org Cc: Andre Przywara , Dave Martin References: <20190621093843.220980-1-marc.zyngier@arm.com> <20190621093843.220980-36-marc.zyngier@arm.com> From: Alexandru Elisei Message-ID: Date: Thu, 4 Jul 2019 16:51:52 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.0 MIME-Version: 1.0 In-Reply-To: <20190621093843.220980-36-marc.zyngier@arm.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Content-Language: en-US Sender: kvm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org On 6/21/19 10:38 AM, Marc Zyngier wrote: > From: Christoffer Dall > > Add stage 2 mmu data structures for virtual EL2 and for nested guests. > We don't yet populate shadow stage 2 page tables, but we now have a > framework for getting to a shadow stage 2 pgd. > > We allocate twice the number of vcpus as stage 2 mmu structures because > that's sufficient for each vcpu running two VMs without having to flush > the stage 2 page tables. > > Signed-off-by: Christoffer Dall > Signed-off-by: Marc Zyngier > --- > arch/arm/include/asm/kvm_host.h | 4 + > arch/arm/include/asm/kvm_mmu.h | 3 + > arch/arm64/include/asm/kvm_host.h | 28 +++++ > arch/arm64/include/asm/kvm_mmu.h | 8 ++ > arch/arm64/include/asm/kvm_nested.h | 7 ++ > arch/arm64/kvm/nested.c | 172 ++++++++++++++++++++++++++++ > virt/kvm/arm/arm.c | 16 ++- > virt/kvm/arm/mmu.c | 31 ++--- > 8 files changed, 254 insertions(+), 15 deletions(-) > > diff --git a/arch/arm/include/asm/kvm_host.h b/arch/arm/include/asm/kvm_host.h > index e3217c4ad25b..b821eb2383ad 100644 > --- a/arch/arm/include/asm/kvm_host.h > +++ b/arch/arm/include/asm/kvm_host.h > @@ -424,4 +424,8 @@ static inline bool kvm_arm_vcpu_is_finalized(struct kvm_vcpu *vcpu) > return true; > } > > +static inline void kvm_vcpu_load_hw_mmu(struct kvm_vcpu *vcpu) {} > +static inline void kvm_vcpu_put_hw_mmu(struct kvm_vcpu *vcpu) {} > +static inline int kvm_vcpu_init_nested(struct kvm_vcpu *vcpu) { return 0; } > + > #endif /* __ARM_KVM_HOST_H__ */ > diff --git a/arch/arm/include/asm/kvm_mmu.h b/arch/arm/include/asm/kvm_mmu.h > index be23e3f8e08c..e6984b6da2ce 100644 > --- a/arch/arm/include/asm/kvm_mmu.h > +++ b/arch/arm/include/asm/kvm_mmu.h > @@ -420,6 +420,9 @@ static inline int hyp_map_aux_data(void) > > static inline void kvm_set_ipa_limit(void) {} > > +static inline void kvm_init_s2_mmu(struct kvm_s2_mmu *mmu) {} > +static inline void kvm_init_nested(struct kvm *kvm) {} > + > static __always_inline u64 kvm_get_vttbr(struct kvm_s2_mmu *mmu) > { > struct kvm_vmid *vmid = &mmu->vmid; > diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h > index 3dee5e17a4ee..cc238de170d2 100644 > --- a/arch/arm64/include/asm/kvm_host.h > +++ b/arch/arm64/include/asm/kvm_host.h > @@ -88,11 +88,39 @@ struct kvm_s2_mmu { > phys_addr_t pgd_phys; > > struct kvm *kvm; > + > + /* > + * For a shadow stage-2 MMU, the virtual vttbr programmed by the guest > + * hypervisor. Unused for kvm_arch->mmu. Set to 1 when the structure > + * contains no valid information. > + */ > + u64 vttbr; > + > + /* true when this represents a nested context where virtual HCR_EL2.VM == 1 */ > + bool nested_stage2_enabled; > + > + /* > + * 0: Nobody is currently using this, check vttbr for validity > + * >0: Somebody is actively using this. > + */ > + atomic_t refcnt; > }; > > +static inline bool kvm_s2_mmu_valid(struct kvm_s2_mmu *mmu) > +{ > + return !(mmu->vttbr & 1); > +} > + > struct kvm_arch { > struct kvm_s2_mmu mmu; > > + /* > + * Stage 2 paging stage for VMs with nested virtual using a virtual > + * VMID. > + */ > + struct kvm_s2_mmu *nested_mmus; > + size_t nested_mmus_size; > + > /* VTCR_EL2 value for this VM */ > u64 vtcr; > > diff --git a/arch/arm64/include/asm/kvm_mmu.h b/arch/arm64/include/asm/kvm_mmu.h > index 1eb6e0ca61c2..32bcaa1845dc 100644 > --- a/arch/arm64/include/asm/kvm_mmu.h > +++ b/arch/arm64/include/asm/kvm_mmu.h > @@ -100,6 +100,7 @@ alternative_cb_end > #include > #include > #include > +#include > > void kvm_update_va_mask(struct alt_instr *alt, > __le32 *origptr, __le32 *updptr, int nr_inst); > @@ -164,6 +165,7 @@ int create_hyp_exec_mappings(phys_addr_t phys_addr, size_t size, > void **haddr); > void free_hyp_pgds(void); > > +void kvm_unmap_stage2_range(struct kvm_s2_mmu *mmu, phys_addr_t start, u64 size); > void stage2_unmap_vm(struct kvm *kvm); > int kvm_alloc_stage2_pgd(struct kvm_s2_mmu *mmu); > void kvm_free_stage2_pgd(struct kvm_s2_mmu *mmu); > @@ -635,5 +637,11 @@ static __always_inline void __load_guest_stage2(struct kvm_s2_mmu *mmu) > asm(ALTERNATIVE("nop", "isb", ARM64_WORKAROUND_1165522)); > } > > +static inline u64 get_vmid(u64 vttbr) > +{ > + return (vttbr & VTTBR_VMID_MASK(kvm_get_vmid_bits())) >> > + VTTBR_VMID_SHIFT; > +} > + > #endif /* __ASSEMBLY__ */ > #endif /* __ARM64_KVM_MMU_H__ */ > diff --git a/arch/arm64/include/asm/kvm_nested.h b/arch/arm64/include/asm/kvm_nested.h > index 61e71d0d2151..d4021d0892bd 100644 > --- a/arch/arm64/include/asm/kvm_nested.h > +++ b/arch/arm64/include/asm/kvm_nested.h > @@ -10,6 +10,13 @@ static inline bool nested_virt_in_use(const struct kvm_vcpu *vcpu) > test_bit(KVM_ARM_VCPU_NESTED_VIRT, vcpu->arch.features); > } > > +extern void kvm_init_nested(struct kvm *kvm); > +extern int kvm_vcpu_init_nested(struct kvm_vcpu *vcpu); > +extern void kvm_init_s2_mmu(struct kvm_s2_mmu *mmu); > +extern struct kvm_s2_mmu *lookup_s2_mmu(struct kvm *kvm, u64 vttbr, u64 hcr); > +extern void kvm_vcpu_load_hw_mmu(struct kvm_vcpu *vcpu); > +extern void kvm_vcpu_put_hw_mmu(struct kvm_vcpu *vcpu); > + > int handle_wfx_nested(struct kvm_vcpu *vcpu, bool is_wfe); > extern bool forward_traps(struct kvm_vcpu *vcpu, u64 control_bit); > extern bool forward_nv_traps(struct kvm_vcpu *vcpu); > diff --git a/arch/arm64/kvm/nested.c b/arch/arm64/kvm/nested.c > index 3872e3cf1691..4b38dc5c0be3 100644 > --- a/arch/arm64/kvm/nested.c > +++ b/arch/arm64/kvm/nested.c > @@ -18,7 +18,161 @@ > #include > #include > > +#include > #include > +#include > +#include > + > +void kvm_init_nested(struct kvm *kvm) > +{ > + kvm_init_s2_mmu(&kvm->arch.mmu); > + > + kvm->arch.nested_mmus = NULL; > + kvm->arch.nested_mmus_size = 0; > +} > + > +int kvm_vcpu_init_nested(struct kvm_vcpu *vcpu) > +{ > + struct kvm *kvm = vcpu->kvm; > + struct kvm_s2_mmu *tmp; > + int num_mmus; > + int ret = -ENOMEM; > + > + if (!test_bit(KVM_ARM_VCPU_NESTED_VIRT, vcpu->arch.features)) > + return 0; > + > + if (!cpus_have_const_cap(ARM64_HAS_NESTED_VIRT)) > + return -EINVAL; > + > + mutex_lock(&kvm->lock); > + > + num_mmus = atomic_read(&kvm->online_vcpus) * 2; > + tmp = __krealloc(kvm->arch.nested_mmus, > + num_mmus * sizeof(*kvm->arch.nested_mmus), > + GFP_KERNEL | __GFP_ZERO); > + > + if (tmp) { > + if (tmp != kvm->arch.nested_mmus) > + kfree(kvm->arch.nested_mmus); Here we are freeing a resource that is shared between all virtual CPUs. So if kvm_alloc_stage2_pgd (below) fails, we could end up freeing something that has been initialized by previous vcpu(s). Same thing happens if tmp == kvm->arch.nested_mmus (because of kfree(tmp)). Looking at Documentation/virtual/kvm/api.txt (section 4.82, KVM_ARM_VCPU_IOCTL): Userspace can call this function multiple times for a given vcpu, including after the vcpu has been run. This will reset the vcpu to its initial state. It seems to me that it is allowed for userspace to try to call KVM_ARM_VCPU_IOCTL again after it failed. I was wondering if it's possible to end up in a situation where the second call succeeds, but kvm->arch.nested_mmus is not initialized properly and if we should care about that. > + > + tmp[num_mmus - 1].kvm = kvm; > + atomic_set(&tmp[num_mmus - 1].refcnt, 0); > + ret = kvm_alloc_stage2_pgd(&tmp[num_mmus - 1]); > + if (ret) > + goto out; > + > + tmp[num_mmus - 2].kvm = kvm; > + atomic_set(&tmp[num_mmus - 2].refcnt, 0); > + ret = kvm_alloc_stage2_pgd(&tmp[num_mmus - 2]); > + if (ret) { > + kvm_free_stage2_pgd(&tmp[num_mmus - 1]); > + goto out; > + } > + > + kvm->arch.nested_mmus_size = num_mmus; > + kvm->arch.nested_mmus = tmp; > + tmp = NULL; > + } > + > +out: > + kfree(tmp); > + mutex_unlock(&kvm->lock); > + return ret; > +} > + > +/* Must be called with kvm->lock held */ > +struct kvm_s2_mmu *lookup_s2_mmu(struct kvm *kvm, u64 vttbr, u64 hcr) > +{ > + bool nested_stage2_enabled = hcr & HCR_VM; > + int i; > + > + /* Don't consider the CnP bit for the vttbr match */ > + vttbr = vttbr & ~1UL; There's a define for that bit, VTTBR_CNP_BIT in kvm_arm.h (which this file includes). > + > + /* Search a mmu in the list using the virtual VMID as a key */ I think when the guest has stage 2 enabled we also match on VTTBR_EL2.VMID + VTTBR_EL2.BADDR. > + for (i = 0; i < kvm->arch.nested_mmus_size; i++) { > + struct kvm_s2_mmu *mmu = &kvm->arch.nested_mmus[i]; > + > + if (!kvm_s2_mmu_valid(mmu)) > + continue; > + > + if (nested_stage2_enabled && > + mmu->nested_stage2_enabled && > + vttbr == mmu->vttbr) > + return mmu; > + > + if (!nested_stage2_enabled && > + !mmu->nested_stage2_enabled && > + get_vmid(vttbr) == get_vmid(mmu->vttbr)) > + return mmu; I'm struggling to understand why we do this. As far as I can tell, this applies only to non-vhe guest hypervisors, because that's the only situation where we run something at vEL1 without shadow stage 2 enabled. There's only one MMU that matches that guest, because there's only one host for the non-vhe hypervisor. So why are we matching on vmid only, instead of matching on the entire vttbr? Is it because we don't want to get fooled by a naughty guest that changes the BADDR each time it switches to its EL1 host? Or something else entirely that I'm missing? > + } > + return NULL; > +} > + > +static struct kvm_s2_mmu *get_s2_mmu_nested(struct kvm_vcpu *vcpu) > +{ > + struct kvm *kvm = vcpu->kvm; > + u64 vttbr = vcpu_read_sys_reg(vcpu, VTTBR_EL2); > + u64 hcr= vcpu_read_sys_reg(vcpu, HCR_EL2); > + struct kvm_s2_mmu *s2_mmu; > + int i; > + > + s2_mmu = lookup_s2_mmu(kvm, vttbr, hcr); > + if (s2_mmu) > + goto out; > + > + for (i = 0; i < kvm->arch.nested_mmus_size; i++) { > + s2_mmu = &kvm->arch.nested_mmus[i]; > + > + if (atomic_read(&s2_mmu->refcnt) == 0) > + break; > + } > + BUG_ON(atomic_read(&s2_mmu->refcnt)); /* We have struct MMUs to spare */ > + > + if (kvm_s2_mmu_valid(s2_mmu)) { > + /* Clear the old state */ > + kvm_unmap_stage2_range(s2_mmu, 0, kvm_phys_size(kvm)); > + if (s2_mmu->vmid.vmid_gen) > + kvm_call_hyp(__kvm_tlb_flush_vmid, s2_mmu); > + } > + > + /* > + * The virtual VMID (modulo CnP) will be used as a key when matching > + * an existing kvm_s2_mmu. > + */ > + s2_mmu->vttbr = vttbr & ~1UL; > + s2_mmu->nested_stage2_enabled = hcr & HCR_VM; > + > +out: > + atomic_inc(&s2_mmu->refcnt); > + return s2_mmu; > +} > + > +void kvm_init_s2_mmu(struct kvm_s2_mmu *mmu) > +{ > + mmu->vttbr = 1; > + mmu->nested_stage2_enabled = false; > + atomic_set(&mmu->refcnt, 0); > +} > + > +void kvm_vcpu_load_hw_mmu(struct kvm_vcpu *vcpu) > +{ > + if (is_hyp_ctxt(vcpu)) { If userspace has set the nested feature, but hasn't set the vcpu mode to PSR_MODE_EL2h/PSR_MODE_EL2t, we will never use kvm->arch.mmu, and instead we'll always take the mmu_lock and search for the mmu. Is that something we should care about? > + vcpu->arch.hw_mmu = &vcpu->kvm->arch.mmu; > + } else { > + spin_lock(&vcpu->kvm->mmu_lock); > + vcpu->arch.hw_mmu = get_s2_mmu_nested(vcpu); > + spin_unlock(&vcpu->kvm->mmu_lock); > + } > +} > + > +void kvm_vcpu_put_hw_mmu(struct kvm_vcpu *vcpu) > +{ > + if (vcpu->arch.hw_mmu != &vcpu->kvm->arch.mmu) { > + atomic_dec(&vcpu->arch.hw_mmu->refcnt); > + vcpu->arch.hw_mmu = NULL; > + } > +} > > /* > * Inject wfx to the virtual EL2 if this is not from the virtual EL2 and > @@ -37,3 +191,21 @@ int handle_wfx_nested(struct kvm_vcpu *vcpu, bool is_wfe) > > return -EINVAL; > } > + > +void kvm_arch_flush_shadow_all(struct kvm *kvm) > +{ > + int i; > + > + for (i = 0; i < kvm->arch.nested_mmus_size; i++) { > + struct kvm_s2_mmu *mmu = &kvm->arch.nested_mmus[i]; > + > + WARN_ON(atomic_read(&mmu->refcnt)); > + > + if (!atomic_read(&mmu->refcnt)) > + kvm_free_stage2_pgd(mmu); > + } > + kfree(kvm->arch.nested_mmus); > + kvm->arch.nested_mmus = NULL; > + kvm->arch.nested_mmus_size = 0; > + kvm_free_stage2_pgd(&kvm->arch.mmu); > +} > diff --git a/virt/kvm/arm/arm.c b/virt/kvm/arm/arm.c > index 5d4371633e1c..4e3cbfa1ecbe 100644 > --- a/virt/kvm/arm/arm.c > +++ b/virt/kvm/arm/arm.c > @@ -36,6 +36,7 @@ > #include > #include > #include > +#include > #include > #include > #include > @@ -126,6 +127,8 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) > kvm->arch.mmu.vmid.vmid_gen = 0; > kvm->arch.mmu.kvm = kvm; > > + kvm_init_nested(kvm); More context: @@ -120,18 +121,20 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)        ret = kvm_alloc_stage2_pgd(&kvm->arch.mmu);      if (ret)          goto out_fail_alloc;        /* Mark the initial VMID generation invalid */      kvm->arch.mmu.vmid.vmid_gen = 0;      kvm->arch.mmu.kvm = kvm;   +    kvm_init_nested(kvm); + kvm_alloc_stage2_pgd ends up calling kvm_init_s2_mmu for kvm->arch.mmu. kvm_init_nested does the same thing, and we end up calling kvm_init_s2_mmu for kvm->arch.mmu twice. There's really no harm in doing it twice, but I thought I could mention it because it looks to me that the fix is simple: remove the kvm_init_s2_mmu call from kvm_init_nested. The double initialization is also true for the tip of the series. Thanks, Alex > + > ret = create_hyp_mappings(kvm, kvm + 1, PAGE_HYP); > if (ret) > goto out_free_stage2_pgd; > @@ -353,6 +356,9 @@ void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) > int *last_ran; > kvm_host_data_t *cpu_data; > > + if (nested_virt_in_use(vcpu)) > + kvm_vcpu_load_hw_mmu(vcpu); > + > last_ran = this_cpu_ptr(vcpu->kvm->arch.last_vcpu_ran); > cpu_data = this_cpu_ptr(&kvm_host_data); > > @@ -391,6 +397,9 @@ void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) > kvm_vgic_put(vcpu); > kvm_vcpu_pmu_restore_host(vcpu); > > + if (nested_virt_in_use(vcpu)) > + kvm_vcpu_put_hw_mmu(vcpu); > + > vcpu->cpu = -1; > > kvm_arm_set_running_vcpu(NULL); > @@ -968,8 +977,13 @@ static int kvm_vcpu_set_target(struct kvm_vcpu *vcpu, > > vcpu->arch.target = phys_target; > > + /* Prepare for nested if required */ > + ret = kvm_vcpu_init_nested(vcpu); > + > /* Now we know what it is, we can reset it. */ > - ret = kvm_reset_vcpu(vcpu); > + if (!ret) > + ret = kvm_reset_vcpu(vcpu); > + > if (ret) { > vcpu->arch.target = -1; > bitmap_zero(vcpu->arch.features, KVM_VCPU_MAX_FEATURES); > diff --git a/virt/kvm/arm/mmu.c b/virt/kvm/arm/mmu.c > index bb1be4ea55ec..faa61a81c8cc 100644 > --- a/virt/kvm/arm/mmu.c > +++ b/virt/kvm/arm/mmu.c > @@ -325,7 +325,7 @@ static void unmap_stage2_puds(struct kvm_s2_mmu *mmu, pgd_t *pgd, > } > > /** > - * unmap_stage2_range -- Clear stage2 page table entries to unmap a range > + * kvm_unmap_stage2_range -- Clear stage2 page table entries to unmap a range > * @kvm: The VM pointer > * @start: The intermediate physical base address of the range to unmap > * @size: The size of the area to unmap > @@ -335,7 +335,7 @@ static void unmap_stage2_puds(struct kvm_s2_mmu *mmu, pgd_t *pgd, > * destroying the VM), otherwise another faulting VCPU may come in and mess > * with things behind our backs. > */ > -static void unmap_stage2_range(struct kvm_s2_mmu *mmu, phys_addr_t start, u64 size) > +void kvm_unmap_stage2_range(struct kvm_s2_mmu *mmu, phys_addr_t start, u64 size) > { > struct kvm *kvm = mmu->kvm; > pgd_t *pgd; > @@ -924,6 +924,10 @@ int kvm_alloc_stage2_pgd(struct kvm_s2_mmu *mmu) > > mmu->pgd = pgd; > mmu->pgd_phys = pgd_phys; > + mmu->vmid.vmid_gen = 0; > + > + kvm_init_s2_mmu(mmu); > + > return 0; > } > > @@ -962,7 +966,7 @@ static void stage2_unmap_memslot(struct kvm *kvm, > > if (!(vma->vm_flags & VM_PFNMAP)) { > gpa_t gpa = addr + (vm_start - memslot->userspace_addr); > - unmap_stage2_range(&kvm->arch.mmu, gpa, vm_end - vm_start); > + kvm_unmap_stage2_range(&kvm->arch.mmu, gpa, vm_end - vm_start); > } > hva = vm_end; > } while (hva < reg_end); > @@ -1001,7 +1005,7 @@ void kvm_free_stage2_pgd(struct kvm_s2_mmu *mmu) > > spin_lock(&kvm->mmu_lock); > if (mmu->pgd) { > - unmap_stage2_range(mmu, 0, kvm_phys_size(kvm)); > + kvm_unmap_stage2_range(mmu, 0, kvm_phys_size(kvm)); > pgd = READ_ONCE(mmu->pgd); > mmu->pgd = NULL; > } > @@ -1093,7 +1097,7 @@ static int stage2_set_pmd_huge(struct kvm_s2_mmu *mmu, > * get handled accordingly. > */ > if (!pmd_thp_or_huge(old_pmd)) { > - unmap_stage2_range(mmu, addr & S2_PMD_MASK, S2_PMD_SIZE); > + kvm_unmap_stage2_range(mmu, addr & S2_PMD_MASK, S2_PMD_SIZE); > goto retry; > } > /* > @@ -1145,7 +1149,7 @@ static int stage2_set_pud_huge(struct kvm_s2_mmu *mmu, > * the range for this block and retry. > */ > if (!stage2_pud_huge(kvm, old_pud)) { > - unmap_stage2_range(mmu, addr & S2_PUD_MASK, S2_PUD_SIZE); > + kvm_unmap_stage2_range(mmu, addr & S2_PUD_MASK, S2_PUD_SIZE); > goto retry; > } > > @@ -2047,7 +2051,7 @@ static int handle_hva_to_gpa(struct kvm *kvm, > > static int kvm_unmap_hva_handler(struct kvm *kvm, gpa_t gpa, u64 size, void *data) > { > - unmap_stage2_range(&kvm->arch.mmu, gpa, size); > + kvm_unmap_stage2_range(&kvm->arch.mmu, gpa, size); > return 0; > } > > @@ -2360,7 +2364,7 @@ int kvm_arch_prepare_memory_region(struct kvm *kvm, > > spin_lock(&kvm->mmu_lock); > if (ret) > - unmap_stage2_range(&kvm->arch.mmu, mem->guest_phys_addr, mem->memory_size); > + kvm_unmap_stage2_range(&kvm->arch.mmu, mem->guest_phys_addr, mem->memory_size); > else > stage2_flush_memslot(&kvm->arch.mmu, memslot); > spin_unlock(&kvm->mmu_lock); > @@ -2384,11 +2388,6 @@ void kvm_arch_memslots_updated(struct kvm *kvm, u64 gen) > { > } > > -void kvm_arch_flush_shadow_all(struct kvm *kvm) > -{ > - kvm_free_stage2_pgd(&kvm->arch.mmu); > -} > - > void kvm_arch_flush_shadow_memslot(struct kvm *kvm, > struct kvm_memory_slot *slot) > { > @@ -2396,7 +2395,7 @@ void kvm_arch_flush_shadow_memslot(struct kvm *kvm, > phys_addr_t size = slot->npages << PAGE_SHIFT; > > spin_lock(&kvm->mmu_lock); > - unmap_stage2_range(&kvm->arch.mmu, gpa, size); > + kvm_unmap_stage2_range(&kvm->arch.mmu, gpa, size); > spin_unlock(&kvm->mmu_lock); > } > > @@ -2467,3 +2466,7 @@ void kvm_toggle_cache(struct kvm_vcpu *vcpu, bool was_enabled) > > trace_kvm_toggle_cache(*vcpu_pc(vcpu), was_enabled, now_enabled); > } > + > +__weak void kvm_arch_flush_shadow_all(struct kvm *kvm) > +{ > +} 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_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_SANE_1 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 E8748C0651F for ; Thu, 4 Jul 2019 15:52:01 +0000 (UTC) Received: from mm01.cs.columbia.edu (mm01.cs.columbia.edu [128.59.11.253]) by mail.kernel.org (Postfix) with ESMTP id 8115C218A0 for ; Thu, 4 Jul 2019 15:52:01 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8115C218A0 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=kvmarm-bounces@lists.cs.columbia.edu Received: from localhost (localhost [127.0.0.1]) by mm01.cs.columbia.edu (Postfix) with ESMTP id C238C4A332; Thu, 4 Jul 2019 11:52:00 -0400 (EDT) X-Virus-Scanned: at lists.cs.columbia.edu Received: from mm01.cs.columbia.edu ([127.0.0.1]) by localhost (mm01.cs.columbia.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id e6CkKcdCKa05; Thu, 4 Jul 2019 11:51:58 -0400 (EDT) Received: from mm01.cs.columbia.edu (localhost [127.0.0.1]) by mm01.cs.columbia.edu (Postfix) with ESMTP id 933374A4DF; Thu, 4 Jul 2019 11:51:58 -0400 (EDT) Received: from localhost (localhost [127.0.0.1]) by mm01.cs.columbia.edu (Postfix) with ESMTP id D3D874A369 for ; Thu, 4 Jul 2019 11:51:57 -0400 (EDT) X-Virus-Scanned: at lists.cs.columbia.edu Received: from mm01.cs.columbia.edu ([127.0.0.1]) by localhost (mm01.cs.columbia.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id s5ihKpMQQD9v for ; Thu, 4 Jul 2019 11:51:55 -0400 (EDT) Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by mm01.cs.columbia.edu (Postfix) with ESMTP id 8C56A4A332 for ; Thu, 4 Jul 2019 11:51:55 -0400 (EDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 0110D2B; Thu, 4 Jul 2019 08:51:55 -0700 (PDT) Received: from [10.1.31.185] (e121566-lin.cambridge.arm.com [10.1.31.185]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 049AA3F703; Thu, 4 Jul 2019 08:51:53 -0700 (PDT) Subject: Re: [PATCH 35/59] KVM: arm/arm64: nv: Support multiple nested stage 2 mmu structures To: Marc Zyngier , linux-arm-kernel@lists.infradead.org, kvmarm@lists.cs.columbia.edu, kvm@vger.kernel.org References: <20190621093843.220980-1-marc.zyngier@arm.com> <20190621093843.220980-36-marc.zyngier@arm.com> From: Alexandru Elisei Message-ID: Date: Thu, 4 Jul 2019 16:51:52 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.0 MIME-Version: 1.0 In-Reply-To: <20190621093843.220980-36-marc.zyngier@arm.com> Content-Language: en-US Cc: Andre Przywara , Dave Martin X-BeenThere: kvmarm@lists.cs.columbia.edu X-Mailman-Version: 2.1.14 Precedence: list List-Id: Where KVM/ARM decisions are made List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: kvmarm-bounces@lists.cs.columbia.edu Sender: kvmarm-bounces@lists.cs.columbia.edu T24gNi8yMS8xOSAxMDozOCBBTSwgTWFyYyBaeW5naWVyIHdyb3RlOgoKPiBGcm9tOiBDaHJpc3Rv ZmZlciBEYWxsIDxjaHJpc3RvZmZlci5kYWxsQGFybS5jb20+Cj4KPiBBZGQgc3RhZ2UgMiBtbXUg ZGF0YSBzdHJ1Y3R1cmVzIGZvciB2aXJ0dWFsIEVMMiBhbmQgZm9yIG5lc3RlZCBndWVzdHMuCj4g V2UgZG9uJ3QgeWV0IHBvcHVsYXRlIHNoYWRvdyBzdGFnZSAyIHBhZ2UgdGFibGVzLCBidXQgd2Ug bm93IGhhdmUgYQo+IGZyYW1ld29yayBmb3IgZ2V0dGluZyB0byBhIHNoYWRvdyBzdGFnZSAyIHBn ZC4KPgo+IFdlIGFsbG9jYXRlIHR3aWNlIHRoZSBudW1iZXIgb2YgdmNwdXMgYXMgc3RhZ2UgMiBt bXUgc3RydWN0dXJlcyBiZWNhdXNlCj4gdGhhdCdzIHN1ZmZpY2llbnQgZm9yIGVhY2ggdmNwdSBy dW5uaW5nIHR3byBWTXMgd2l0aG91dCBoYXZpbmcgdG8gZmx1c2gKPiB0aGUgc3RhZ2UgMiBwYWdl IHRhYmxlcy4KPgo+IFNpZ25lZC1vZmYtYnk6IENocmlzdG9mZmVyIERhbGwgPGNocmlzdG9mZmVy LmRhbGxAYXJtLmNvbT4KPiBTaWduZWQtb2ZmLWJ5OiBNYXJjIFp5bmdpZXIgPG1hcmMuenluZ2ll ckBhcm0uY29tPgo+IC0tLQo+ICBhcmNoL2FybS9pbmNsdWRlL2FzbS9rdm1faG9zdC5oICAgICB8 ICAgNCArCj4gIGFyY2gvYXJtL2luY2x1ZGUvYXNtL2t2bV9tbXUuaCAgICAgIHwgICAzICsKPiAg YXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1faG9zdC5oICAgfCAgMjggKysrKysKPiAgYXJjaC9h cm02NC9pbmNsdWRlL2FzbS9rdm1fbW11LmggICAgfCAgIDggKysKPiAgYXJjaC9hcm02NC9pbmNs dWRlL2FzbS9rdm1fbmVzdGVkLmggfCAgIDcgKysKPiAgYXJjaC9hcm02NC9rdm0vbmVzdGVkLmMg ICAgICAgICAgICAgfCAxNzIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICB2aXJ0L2t2 bS9hcm0vYXJtLmMgICAgICAgICAgICAgICAgICB8ICAxNiArKy0KPiAgdmlydC9rdm0vYXJtL21t dS5jICAgICAgICAgICAgICAgICAgfCAgMzEgKystLS0KPiAgOCBmaWxlcyBjaGFuZ2VkLCAyNTQg aW5zZXJ0aW9ucygrKSwgMTUgZGVsZXRpb25zKC0pCj4KPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm0v aW5jbHVkZS9hc20va3ZtX2hvc3QuaCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgK PiBpbmRleCBlMzIxN2M0YWQyNWIuLmI4MjFlYjIzODNhZCAxMDA2NDQKPiAtLS0gYS9hcmNoL2Fy bS9pbmNsdWRlL2FzbS9rdm1faG9zdC5oCj4gKysrIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20va3Zt X2hvc3QuaAo+IEBAIC00MjQsNCArNDI0LDggQEAgc3RhdGljIGlubGluZSBib29sIGt2bV9hcm1f dmNwdV9pc19maW5hbGl6ZWQoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ICAJcmV0dXJuIHRydWU7 Cj4gIH0KPiAgCj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBrdm1fdmNwdV9sb2FkX2h3X21tdShzdHJ1 Y3Qga3ZtX3ZjcHUgKnZjcHUpIHt9Cj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBrdm1fdmNwdV9wdXRf aHdfbW11KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSkge30KPiArc3RhdGljIGlubGluZSBpbnQga3Zt X3ZjcHVfaW5pdF9uZXN0ZWQoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KSB7IHJldHVybiAwOyB9Cj4g Kwo+ICAjZW5kaWYgLyogX19BUk1fS1ZNX0hPU1RfSF9fICovCj4gZGlmZiAtLWdpdCBhL2FyY2gv YXJtL2luY2x1ZGUvYXNtL2t2bV9tbXUuaCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2t2bV9tbXUu aAo+IGluZGV4IGJlMjNlM2Y4ZTA4Yy4uZTY5ODRiNmRhMmNlIDEwMDY0NAo+IC0tLSBhL2FyY2gv YXJtL2luY2x1ZGUvYXNtL2t2bV9tbXUuaAo+ICsrKyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2t2 bV9tbXUuaAo+IEBAIC00MjAsNiArNDIwLDkgQEAgc3RhdGljIGlubGluZSBpbnQgaHlwX21hcF9h dXhfZGF0YSh2b2lkKQo+ICAKPiAgc3RhdGljIGlubGluZSB2b2lkIGt2bV9zZXRfaXBhX2xpbWl0 KHZvaWQpIHt9Cj4gIAo+ICtzdGF0aWMgaW5saW5lIHZvaWQga3ZtX2luaXRfczJfbW11KHN0cnVj dCBrdm1fczJfbW11ICptbXUpIHt9Cj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBrdm1faW5pdF9uZXN0 ZWQoc3RydWN0IGt2bSAqa3ZtKSB7fQo+ICsKPiAgc3RhdGljIF9fYWx3YXlzX2lubGluZSB1NjQg a3ZtX2dldF92dHRicihzdHJ1Y3Qga3ZtX3MyX21tdSAqbW11KQo+ICB7Cj4gIAlzdHJ1Y3Qga3Zt X3ZtaWQgKnZtaWQgPSAmbW11LT52bWlkOwo+IGRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1 ZGUvYXNtL2t2bV9ob3N0LmggYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKPiBp bmRleCAzZGVlNWUxN2E0ZWUuLmNjMjM4ZGUxNzBkMiAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0 L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKPiArKysgYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2 bV9ob3N0LmgKPiBAQCAtODgsMTEgKzg4LDM5IEBAIHN0cnVjdCBrdm1fczJfbW11IHsKPiAgCXBo eXNfYWRkcl90CXBnZF9waHlzOwo+ICAKPiAgCXN0cnVjdCBrdm0gKmt2bTsKPiArCj4gKwkvKgo+ ICsJICogRm9yIGEgc2hhZG93IHN0YWdlLTIgTU1VLCB0aGUgdmlydHVhbCB2dHRiciBwcm9ncmFt bWVkIGJ5IHRoZSBndWVzdAo+ICsJICogaHlwZXJ2aXNvci4gIFVudXNlZCBmb3Iga3ZtX2FyY2gt Pm1tdS4gU2V0IHRvIDEgd2hlbiB0aGUgc3RydWN0dXJlCj4gKwkgKiBjb250YWlucyBubyB2YWxp ZCBpbmZvcm1hdGlvbi4KPiArCSAqLwo+ICsJdTY0CXZ0dGJyOwo+ICsKPiArCS8qIHRydWUgd2hl biB0aGlzIHJlcHJlc2VudHMgYSBuZXN0ZWQgY29udGV4dCB3aGVyZSB2aXJ0dWFsIEhDUl9FTDIu Vk0gPT0gMSAqLwo+ICsJYm9vbAluZXN0ZWRfc3RhZ2UyX2VuYWJsZWQ7Cj4gKwo+ICsJLyoKPiAr CSAqICAwOiBOb2JvZHkgaXMgY3VycmVudGx5IHVzaW5nIHRoaXMsIGNoZWNrIHZ0dGJyIGZvciB2 YWxpZGl0eQo+ICsJICogPjA6IFNvbWVib2R5IGlzIGFjdGl2ZWx5IHVzaW5nIHRoaXMuCj4gKwkg Ki8KPiArCWF0b21pY190IHJlZmNudDsKPiAgfTsKPiAgCj4gK3N0YXRpYyBpbmxpbmUgYm9vbCBr dm1fczJfbW11X3ZhbGlkKHN0cnVjdCBrdm1fczJfbW11ICptbXUpCj4gK3sKPiArCXJldHVybiAh KG1tdS0+dnR0YnIgJiAxKTsKPiArfQo+ICsKPiAgc3RydWN0IGt2bV9hcmNoIHsKPiAgCXN0cnVj dCBrdm1fczJfbW11IG1tdTsKPiAgCj4gKwkvKgo+ICsJICogU3RhZ2UgMiBwYWdpbmcgc3RhZ2Ug Zm9yIFZNcyB3aXRoIG5lc3RlZCB2aXJ0dWFsIHVzaW5nIGEgdmlydHVhbAo+ICsJICogVk1JRC4K PiArCSAqLwo+ICsJc3RydWN0IGt2bV9zMl9tbXUgKm5lc3RlZF9tbXVzOwo+ICsJc2l6ZV90IG5l c3RlZF9tbXVzX3NpemU7Cj4gKwo+ICAJLyogVlRDUl9FTDIgdmFsdWUgZm9yIHRoaXMgVk0gKi8K PiAgCXU2NCAgICB2dGNyOwo+ICAKPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2Fz bS9rdm1fbW11LmggYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9tbXUuaAo+IGluZGV4IDFl YjZlMGNhNjFjMi4uMzJiY2FhMTg0NWRjIDEwMDY0NAo+IC0tLSBhL2FyY2gvYXJtNjQvaW5jbHVk ZS9hc20va3ZtX21tdS5oCj4gKysrIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1fbW11LmgK PiBAQCAtMTAwLDYgKzEwMCw3IEBAIGFsdGVybmF0aXZlX2NiX2VuZAo+ICAjaW5jbHVkZSA8YXNt L21tdV9jb250ZXh0Lmg+Cj4gICNpbmNsdWRlIDxhc20vcGd0YWJsZS5oPgo+ICAjaW5jbHVkZSA8 YXNtL2t2bV9lbXVsYXRlLmg+Cj4gKyNpbmNsdWRlIDxhc20va3ZtX25lc3RlZC5oPgo+ICAKPiAg dm9pZCBrdm1fdXBkYXRlX3ZhX21hc2soc3RydWN0IGFsdF9pbnN0ciAqYWx0LAo+ICAJCQlfX2xl MzIgKm9yaWdwdHIsIF9fbGUzMiAqdXBkcHRyLCBpbnQgbnJfaW5zdCk7Cj4gQEAgLTE2NCw2ICsx NjUsNyBAQCBpbnQgY3JlYXRlX2h5cF9leGVjX21hcHBpbmdzKHBoeXNfYWRkcl90IHBoeXNfYWRk ciwgc2l6ZV90IHNpemUsCj4gIAkJCSAgICAgdm9pZCAqKmhhZGRyKTsKPiAgdm9pZCBmcmVlX2h5 cF9wZ2RzKHZvaWQpOwo+ICAKPiArdm9pZCBrdm1fdW5tYXBfc3RhZ2UyX3JhbmdlKHN0cnVjdCBr dm1fczJfbW11ICptbXUsIHBoeXNfYWRkcl90IHN0YXJ0LCB1NjQgc2l6ZSk7Cj4gIHZvaWQgc3Rh Z2UyX3VubWFwX3ZtKHN0cnVjdCBrdm0gKmt2bSk7Cj4gIGludCBrdm1fYWxsb2Nfc3RhZ2UyX3Bn ZChzdHJ1Y3Qga3ZtX3MyX21tdSAqbW11KTsKPiAgdm9pZCBrdm1fZnJlZV9zdGFnZTJfcGdkKHN0 cnVjdCBrdm1fczJfbW11ICptbXUpOwo+IEBAIC02MzUsNSArNjM3LDExIEBAIHN0YXRpYyBfX2Fs d2F5c19pbmxpbmUgdm9pZCBfX2xvYWRfZ3Vlc3Rfc3RhZ2UyKHN0cnVjdCBrdm1fczJfbW11ICpt bXUpCj4gIAlhc20oQUxURVJOQVRJVkUoIm5vcCIsICJpc2IiLCBBUk02NF9XT1JLQVJPVU5EXzEx NjU1MjIpKTsKPiAgfQo+ICAKPiArc3RhdGljIGlubGluZSB1NjQgZ2V0X3ZtaWQodTY0IHZ0dGJy KQo+ICt7Cj4gKwlyZXR1cm4gKHZ0dGJyICYgVlRUQlJfVk1JRF9NQVNLKGt2bV9nZXRfdm1pZF9i aXRzKCkpKSA+Pgo+ICsJCVZUVEJSX1ZNSURfU0hJRlQ7Cj4gK30KPiArCj4gICNlbmRpZiAvKiBf X0FTU0VNQkxZX18gKi8KPiAgI2VuZGlmIC8qIF9fQVJNNjRfS1ZNX01NVV9IX18gKi8KPiBkaWZm IC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1fbmVzdGVkLmggYi9hcmNoL2FybTY0 L2luY2x1ZGUvYXNtL2t2bV9uZXN0ZWQuaAo+IGluZGV4IDYxZTcxZDBkMjE1MS4uZDQwMjFkMDg5 MmJkIDEwMDY0NAo+IC0tLSBhL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX25lc3RlZC5oCj4g KysrIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1fbmVzdGVkLmgKPiBAQCAtMTAsNiArMTAs MTMgQEAgc3RhdGljIGlubGluZSBib29sIG5lc3RlZF92aXJ0X2luX3VzZShjb25zdCBzdHJ1Y3Qg a3ZtX3ZjcHUgKnZjcHUpCj4gIAkJdGVzdF9iaXQoS1ZNX0FSTV9WQ1BVX05FU1RFRF9WSVJULCB2 Y3B1LT5hcmNoLmZlYXR1cmVzKTsKPiAgfQo+ICAKPiArZXh0ZXJuIHZvaWQga3ZtX2luaXRfbmVz dGVkKHN0cnVjdCBrdm0gKmt2bSk7Cj4gK2V4dGVybiBpbnQga3ZtX3ZjcHVfaW5pdF9uZXN0ZWQo c3RydWN0IGt2bV92Y3B1ICp2Y3B1KTsKPiArZXh0ZXJuIHZvaWQga3ZtX2luaXRfczJfbW11KHN0 cnVjdCBrdm1fczJfbW11ICptbXUpOwo+ICtleHRlcm4gc3RydWN0IGt2bV9zMl9tbXUgKmxvb2t1 cF9zMl9tbXUoc3RydWN0IGt2bSAqa3ZtLCB1NjQgdnR0YnIsIHU2NCBoY3IpOwo+ICtleHRlcm4g dm9pZCBrdm1fdmNwdV9sb2FkX2h3X21tdShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpOwo+ICtleHRl cm4gdm9pZCBrdm1fdmNwdV9wdXRfaHdfbW11KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSk7Cj4gKwo+ ICBpbnQgaGFuZGxlX3dmeF9uZXN0ZWQoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBib29sIGlzX3dm ZSk7Cj4gIGV4dGVybiBib29sIGZvcndhcmRfdHJhcHMoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCB1 NjQgY29udHJvbF9iaXQpOwo+ICBleHRlcm4gYm9vbCBmb3J3YXJkX252X3RyYXBzKHN0cnVjdCBr dm1fdmNwdSAqdmNwdSk7Cj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQva3ZtL25lc3RlZC5jIGIv YXJjaC9hcm02NC9rdm0vbmVzdGVkLmMKPiBpbmRleCAzODcyZTNjZjE2OTEuLjRiMzhkYzVjMGJl MyAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0L2t2bS9uZXN0ZWQuYwo+ICsrKyBiL2FyY2gvYXJt NjQva3ZtL25lc3RlZC5jCj4gQEAgLTE4LDcgKzE4LDE2MSBAQAo+ICAjaW5jbHVkZSA8bGludXgv a3ZtLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9rdm1faG9zdC5oPgo+ICAKPiArI2luY2x1ZGUgPGFz bS9rdm1fYXJtLmg+Cj4gICNpbmNsdWRlIDxhc20va3ZtX2VtdWxhdGUuaD4KPiArI2luY2x1ZGUg PGFzbS9rdm1fbW11Lmg+Cj4gKyNpbmNsdWRlIDxhc20va3ZtX25lc3RlZC5oPgo+ICsKPiArdm9p ZCBrdm1faW5pdF9uZXN0ZWQoc3RydWN0IGt2bSAqa3ZtKQo+ICt7Cj4gKwlrdm1faW5pdF9zMl9t bXUoJmt2bS0+YXJjaC5tbXUpOwo+ICsKPiArCWt2bS0+YXJjaC5uZXN0ZWRfbW11cyA9IE5VTEw7 Cj4gKwlrdm0tPmFyY2gubmVzdGVkX21tdXNfc2l6ZSA9IDA7Cj4gK30KPiArCj4gK2ludCBrdm1f dmNwdV9pbml0X25lc3RlZChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCj4gK3sKPiArCXN0cnVjdCBr dm0gKmt2bSA9IHZjcHUtPmt2bTsKPiArCXN0cnVjdCBrdm1fczJfbW11ICp0bXA7Cj4gKwlpbnQg bnVtX21tdXM7Cj4gKwlpbnQgcmV0ID0gLUVOT01FTTsKPiArCj4gKwlpZiAoIXRlc3RfYml0KEtW TV9BUk1fVkNQVV9ORVNURURfVklSVCwgdmNwdS0+YXJjaC5mZWF0dXJlcykpCj4gKwkJcmV0dXJu IDA7Cj4gKwo+ICsJaWYgKCFjcHVzX2hhdmVfY29uc3RfY2FwKEFSTTY0X0hBU19ORVNURURfVklS VCkpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJbXV0ZXhfbG9jaygma3ZtLT5sb2NrKTsK PiArCj4gKwludW1fbW11cyA9IGF0b21pY19yZWFkKCZrdm0tPm9ubGluZV92Y3B1cykgKiAyOwo+ ICsJdG1wID0gX19rcmVhbGxvYyhrdm0tPmFyY2gubmVzdGVkX21tdXMsCj4gKwkJCSBudW1fbW11 cyAqIHNpemVvZigqa3ZtLT5hcmNoLm5lc3RlZF9tbXVzKSwKPiArCQkJIEdGUF9LRVJORUwgfCBf X0dGUF9aRVJPKTsKPiArCj4gKwlpZiAodG1wKSB7Cj4gKwkJaWYgKHRtcCAhPSBrdm0tPmFyY2gu bmVzdGVkX21tdXMpCj4gKwkJCWtmcmVlKGt2bS0+YXJjaC5uZXN0ZWRfbW11cyk7CgpIZXJlIHdl IGFyZSBmcmVlaW5nIGEgcmVzb3VyY2UgdGhhdCBpcyBzaGFyZWQgYmV0d2VlbiBhbGwgdmlydHVh bCBDUFVzLiBTbyBpZgprdm1fYWxsb2Nfc3RhZ2UyX3BnZCAoYmVsb3cpIGZhaWxzLCB3ZSBjb3Vs ZCBlbmQgdXAgZnJlZWluZyBzb21ldGhpbmcgdGhhdCBoYXMKYmVlbiBpbml0aWFsaXplZCBieSBw cmV2aW91cyB2Y3B1KHMpLiBTYW1lIHRoaW5nIGhhcHBlbnMgaWYgdG1wID09Cmt2bS0+YXJjaC5u ZXN0ZWRfbW11cyAoYmVjYXVzZSBvZiBrZnJlZSh0bXApKS4KCkxvb2tpbmcgYXQgRG9jdW1lbnRh dGlvbi92aXJ0dWFsL2t2bS9hcGkudHh0IChzZWN0aW9uIDQuODIsIEtWTV9BUk1fVkNQVV9JT0NU TCk6CgpVc2Vyc3BhY2UgY2FuIGNhbGwgdGhpcyBmdW5jdGlvbiBtdWx0aXBsZSB0aW1lcyBmb3Ig YSBnaXZlbiB2Y3B1LCBpbmNsdWRpbmcKYWZ0ZXIgdGhlIHZjcHUgaGFzIGJlZW4gcnVuLiBUaGlz IHdpbGwgcmVzZXQgdGhlIHZjcHUgdG8gaXRzIGluaXRpYWwKc3RhdGUuCgpJdCBzZWVtcyB0byBt ZSB0aGF0IGl0IGlzIGFsbG93ZWQgZm9yIHVzZXJzcGFjZSB0byB0cnkgdG8gY2FsbApLVk1fQVJN X1ZDUFVfSU9DVEwgYWdhaW4gYWZ0ZXIgaXQgZmFpbGVkLiBJIHdhcyB3b25kZXJpbmcgaWYgaXQn cyBwb3NzaWJsZSB0bwplbmQgdXAgaW4gYSBzaXR1YXRpb24gd2hlcmUgdGhlIHNlY29uZCBjYWxs IHN1Y2NlZWRzLCBidXQga3ZtLT5hcmNoLm5lc3RlZF9tbXVzCmlzIG5vdCBpbml0aWFsaXplZCBw cm9wZXJseSBhbmQgaWYgd2Ugc2hvdWxkIGNhcmUgYWJvdXQgdGhhdC4KCj4gKwo+ICsJCXRtcFtu dW1fbW11cyAtIDFdLmt2bSA9IGt2bTsKPiArCQlhdG9taWNfc2V0KCZ0bXBbbnVtX21tdXMgLSAx XS5yZWZjbnQsIDApOwo+ICsJCXJldCA9IGt2bV9hbGxvY19zdGFnZTJfcGdkKCZ0bXBbbnVtX21t dXMgLSAxXSk7Cj4gKwkJaWYgKHJldCkKPiArCQkJZ290byBvdXQ7Cj4gKwo+ICsJCXRtcFtudW1f bW11cyAtIDJdLmt2bSA9IGt2bTsKPiArCQlhdG9taWNfc2V0KCZ0bXBbbnVtX21tdXMgLSAyXS5y ZWZjbnQsIDApOwo+ICsJCXJldCA9IGt2bV9hbGxvY19zdGFnZTJfcGdkKCZ0bXBbbnVtX21tdXMg LSAyXSk7Cj4gKwkJaWYgKHJldCkgewo+ICsJCQlrdm1fZnJlZV9zdGFnZTJfcGdkKCZ0bXBbbnVt X21tdXMgLSAxXSk7Cj4gKwkJCWdvdG8gb3V0Owo+ICsJCX0KPiArCj4gKwkJa3ZtLT5hcmNoLm5l c3RlZF9tbXVzX3NpemUgPSBudW1fbW11czsKPiArCQlrdm0tPmFyY2gubmVzdGVkX21tdXMgPSB0 bXA7Cj4gKwkJdG1wID0gTlVMTDsKPiArCX0KPiArCj4gK291dDoKPiArCWtmcmVlKHRtcCk7Cj4g KwltdXRleF91bmxvY2soJmt2bS0+bG9jayk7Cj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICsv KiBNdXN0IGJlIGNhbGxlZCB3aXRoIGt2bS0+bG9jayBoZWxkICovCj4gK3N0cnVjdCBrdm1fczJf bW11ICpsb29rdXBfczJfbW11KHN0cnVjdCBrdm0gKmt2bSwgdTY0IHZ0dGJyLCB1NjQgaGNyKQo+ ICt7Cj4gKwlib29sIG5lc3RlZF9zdGFnZTJfZW5hYmxlZCA9IGhjciAmIEhDUl9WTTsKPiArCWlu dCBpOwo+ICsKPiArCS8qIERvbid0IGNvbnNpZGVyIHRoZSBDblAgYml0IGZvciB0aGUgdnR0YnIg bWF0Y2ggKi8KPiArCXZ0dGJyID0gdnR0YnIgJiB+MVVMOwoKVGhlcmUncyBhIGRlZmluZSBmb3Ig dGhhdCBiaXQsIFZUVEJSX0NOUF9CSVQgaW4ga3ZtX2FybS5oICh3aGljaCB0aGlzIGZpbGUKaW5j bHVkZXMpLgoKPiArCj4gKwkvKiBTZWFyY2ggYSBtbXUgaW4gdGhlIGxpc3QgdXNpbmcgdGhlIHZp cnR1YWwgVk1JRCBhcyBhIGtleSAqLwoKSSB0aGluayB3aGVuIHRoZSBndWVzdCBoYXMgc3RhZ2Ug MiBlbmFibGVkIHdlIGFsc28gbWF0Y2ggb24gVlRUQlJfRUwyLlZNSUQgKwpWVFRCUl9FTDIuQkFE RFIuCgo+ICsJZm9yIChpID0gMDsgaSA8IGt2bS0+YXJjaC5uZXN0ZWRfbW11c19zaXplOyBpKysp IHsKPiArCQlzdHJ1Y3Qga3ZtX3MyX21tdSAqbW11ID0gJmt2bS0+YXJjaC5uZXN0ZWRfbW11c1tp XTsKPiArCj4gKwkJaWYgKCFrdm1fczJfbW11X3ZhbGlkKG1tdSkpCj4gKwkJCWNvbnRpbnVlOwo+ ICsKPiArCQlpZiAobmVzdGVkX3N0YWdlMl9lbmFibGVkICYmCj4gKwkJICAgIG1tdS0+bmVzdGVk X3N0YWdlMl9lbmFibGVkICYmCj4gKwkJICAgIHZ0dGJyID09IG1tdS0+dnR0YnIpCj4gKwkJCXJl dHVybiBtbXU7Cj4gKwo+ICsJCWlmICghbmVzdGVkX3N0YWdlMl9lbmFibGVkICYmCj4gKwkJICAg ICFtbXUtPm5lc3RlZF9zdGFnZTJfZW5hYmxlZCAmJgo+ICsJCSAgICBnZXRfdm1pZCh2dHRicikg PT0gZ2V0X3ZtaWQobW11LT52dHRicikpCj4gKwkJCXJldHVybiBtbXU7CgpJJ20gc3RydWdnbGlu ZyB0byB1bmRlcnN0YW5kIHdoeSB3ZSBkbyB0aGlzLiBBcyBmYXIgYXMgSSBjYW4gdGVsbCwgdGhp cyBhcHBsaWVzCm9ubHkgdG8gbm9uLXZoZSBndWVzdCBoeXBlcnZpc29ycywgYmVjYXVzZSB0aGF0 J3MgdGhlIG9ubHkgc2l0dWF0aW9uIHdoZXJlIHdlCnJ1biBzb21ldGhpbmcgYXQgdkVMMSB3aXRo b3V0IHNoYWRvdyBzdGFnZSAyIGVuYWJsZWQuIFRoZXJlJ3Mgb25seSBvbmUgTU1VIHRoYXQKbWF0 Y2hlcyB0aGF0IGd1ZXN0LCBiZWNhdXNlIHRoZXJlJ3Mgb25seSBvbmUgaG9zdCBmb3IgdGhlIG5v bi12aGUgaHlwZXJ2aXNvci4gU28Kd2h5IGFyZSB3ZSBtYXRjaGluZyBvbiB2bWlkIG9ubHksIGlu c3RlYWQgb2YgbWF0Y2hpbmcgb24gdGhlIGVudGlyZSB2dHRicj8gSXMgaXQKYmVjYXVzZSB3ZSBk b24ndCB3YW50IHRvIGdldCBmb29sZWQgYnkgYSBuYXVnaHR5IGd1ZXN0IHRoYXQgY2hhbmdlcyB0 aGUgQkFERFIKZWFjaCB0aW1lIGl0IHN3aXRjaGVzIHRvIGl0cyBFTDEgaG9zdD8gT3Igc29tZXRo aW5nIGVsc2UgZW50aXJlbHkgdGhhdCBJJ20gbWlzc2luZz8KCj4gKwl9Cj4gKwlyZXR1cm4gTlVM TDsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCBrdm1fczJfbW11ICpnZXRfczJfbW11X25lc3Rl ZChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCj4gK3sKPiArCXN0cnVjdCBrdm0gKmt2bSA9IHZjcHUt Pmt2bTsKPiArCXU2NCB2dHRiciA9IHZjcHVfcmVhZF9zeXNfcmVnKHZjcHUsIFZUVEJSX0VMMik7 Cj4gKwl1NjQgaGNyPSB2Y3B1X3JlYWRfc3lzX3JlZyh2Y3B1LCBIQ1JfRUwyKTsKPiArCXN0cnVj dCBrdm1fczJfbW11ICpzMl9tbXU7Cj4gKwlpbnQgaTsKPiArCj4gKwlzMl9tbXUgPSBsb29rdXBf czJfbW11KGt2bSwgdnR0YnIsIGhjcik7Cj4gKwlpZiAoczJfbW11KQo+ICsJCWdvdG8gb3V0Owo+ ICsKPiArCWZvciAoaSA9IDA7IGkgPCBrdm0tPmFyY2gubmVzdGVkX21tdXNfc2l6ZTsgaSsrKSB7 Cj4gKwkJczJfbW11ID0gJmt2bS0+YXJjaC5uZXN0ZWRfbW11c1tpXTsKPiArCj4gKwkJaWYgKGF0 b21pY19yZWFkKCZzMl9tbXUtPnJlZmNudCkgPT0gMCkKPiArCQkJYnJlYWs7Cj4gKwl9Cj4gKwlC VUdfT04oYXRvbWljX3JlYWQoJnMyX21tdS0+cmVmY250KSk7IC8qIFdlIGhhdmUgc3RydWN0IE1N VXMgdG8gc3BhcmUgKi8KPiArCj4gKwlpZiAoa3ZtX3MyX21tdV92YWxpZChzMl9tbXUpKSB7Cj4g KwkJLyogQ2xlYXIgdGhlIG9sZCBzdGF0ZSAqLwo+ICsJCWt2bV91bm1hcF9zdGFnZTJfcmFuZ2Uo czJfbW11LCAwLCBrdm1fcGh5c19zaXplKGt2bSkpOwo+ICsJCWlmIChzMl9tbXUtPnZtaWQudm1p ZF9nZW4pCj4gKwkJCWt2bV9jYWxsX2h5cChfX2t2bV90bGJfZmx1c2hfdm1pZCwgczJfbW11KTsK PiArCX0KPiArCj4gKwkvKgo+ICsJICogVGhlIHZpcnR1YWwgVk1JRCAobW9kdWxvIENuUCkgd2ls bCBiZSB1c2VkIGFzIGEga2V5IHdoZW4gbWF0Y2hpbmcKPiArCSAqIGFuIGV4aXN0aW5nIGt2bV9z Ml9tbXUuCj4gKwkgKi8KPiArCXMyX21tdS0+dnR0YnIgPSB2dHRiciAmIH4xVUw7Cj4gKwlzMl9t bXUtPm5lc3RlZF9zdGFnZTJfZW5hYmxlZCA9IGhjciAmIEhDUl9WTTsKPiArCj4gK291dDoKPiAr CWF0b21pY19pbmMoJnMyX21tdS0+cmVmY250KTsKPiArCXJldHVybiBzMl9tbXU7Cj4gK30KPiAr Cj4gK3ZvaWQga3ZtX2luaXRfczJfbW11KHN0cnVjdCBrdm1fczJfbW11ICptbXUpCj4gK3sKPiAr CW1tdS0+dnR0YnIgPSAxOwo+ICsJbW11LT5uZXN0ZWRfc3RhZ2UyX2VuYWJsZWQgPSBmYWxzZTsK PiArCWF0b21pY19zZXQoJm1tdS0+cmVmY250LCAwKTsKPiArfQo+ICsKPiArdm9pZCBrdm1fdmNw dV9sb2FkX2h3X21tdShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCj4gK3sKPiArCWlmIChpc19oeXBf Y3R4dCh2Y3B1KSkgewoKSWYgdXNlcnNwYWNlIGhhcyBzZXQgdGhlIG5lc3RlZCBmZWF0dXJlLCBi dXQgaGFzbid0IHNldCB0aGUgdmNwdSBtb2RlIHRvClBTUl9NT0RFX0VMMmgvUFNSX01PREVfRUwy dCwgd2Ugd2lsbCBuZXZlciB1c2Uga3ZtLT5hcmNoLm1tdSwgYW5kIGluc3RlYWQgd2UnbGwKYWx3 YXlzIHRha2UgdGhlIG1tdV9sb2NrIGFuZCBzZWFyY2ggZm9yIHRoZSBtbXUuIElzIHRoYXQgc29t ZXRoaW5nIHdlIHNob3VsZApjYXJlIGFib3V0PwoKPiArCQl2Y3B1LT5hcmNoLmh3X21tdSA9ICZ2 Y3B1LT5rdm0tPmFyY2gubW11Owo+ICsJfSBlbHNlIHsKPiArCQlzcGluX2xvY2soJnZjcHUtPmt2 bS0+bW11X2xvY2spOwo+ICsJCXZjcHUtPmFyY2guaHdfbW11ID0gZ2V0X3MyX21tdV9uZXN0ZWQo dmNwdSk7Cj4gKwkJc3Bpbl91bmxvY2soJnZjcHUtPmt2bS0+bW11X2xvY2spOwo+ICsJfQo+ICt9 Cj4gKwo+ICt2b2lkIGt2bV92Y3B1X3B1dF9od19tbXUoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ ICt7Cj4gKwlpZiAodmNwdS0+YXJjaC5od19tbXUgIT0gJnZjcHUtPmt2bS0+YXJjaC5tbXUpIHsK PiArCQlhdG9taWNfZGVjKCZ2Y3B1LT5hcmNoLmh3X21tdS0+cmVmY250KTsKPiArCQl2Y3B1LT5h cmNoLmh3X21tdSA9IE5VTEw7Cj4gKwl9Cj4gK30KPiAgCj4gIC8qCj4gICAqIEluamVjdCB3Zngg dG8gdGhlIHZpcnR1YWwgRUwyIGlmIHRoaXMgaXMgbm90IGZyb20gdGhlIHZpcnR1YWwgRUwyIGFu ZAo+IEBAIC0zNywzICsxOTEsMjEgQEAgaW50IGhhbmRsZV93ZnhfbmVzdGVkKHN0cnVjdCBrdm1f dmNwdSAqdmNwdSwgYm9vbCBpc193ZmUpCj4gIAo+ICAJcmV0dXJuIC1FSU5WQUw7Cj4gIH0KPiAr Cj4gK3ZvaWQga3ZtX2FyY2hfZmx1c2hfc2hhZG93X2FsbChzdHJ1Y3Qga3ZtICprdm0pCj4gK3sK PiArCWludCBpOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBrdm0tPmFyY2gubmVzdGVkX21tdXNf c2l6ZTsgaSsrKSB7Cj4gKwkJc3RydWN0IGt2bV9zMl9tbXUgKm1tdSA9ICZrdm0tPmFyY2gubmVz dGVkX21tdXNbaV07Cj4gKwo+ICsJCVdBUk5fT04oYXRvbWljX3JlYWQoJm1tdS0+cmVmY250KSk7 Cj4gKwo+ICsJCWlmICghYXRvbWljX3JlYWQoJm1tdS0+cmVmY250KSkKPiArCQkJa3ZtX2ZyZWVf c3RhZ2UyX3BnZChtbXUpOwo+ICsJfQo+ICsJa2ZyZWUoa3ZtLT5hcmNoLm5lc3RlZF9tbXVzKTsK PiArCWt2bS0+YXJjaC5uZXN0ZWRfbW11cyA9IE5VTEw7Cj4gKwlrdm0tPmFyY2gubmVzdGVkX21t dXNfc2l6ZSA9IDA7Cj4gKwlrdm1fZnJlZV9zdGFnZTJfcGdkKCZrdm0tPmFyY2gubW11KTsKPiAr fQo+IGRpZmYgLS1naXQgYS92aXJ0L2t2bS9hcm0vYXJtLmMgYi92aXJ0L2t2bS9hcm0vYXJtLmMK PiBpbmRleCA1ZDQzNzE2MzNlMWMuLjRlM2NiZmExZWNiZSAxMDA2NDQKPiAtLS0gYS92aXJ0L2t2 bS9hcm0vYXJtLmMKPiArKysgYi92aXJ0L2t2bS9hcm0vYXJtLmMKPiBAQCAtMzYsNiArMzYsNyBA QAo+ICAjaW5jbHVkZSA8YXNtL2t2bV9hcm0uaD4KPiAgI2luY2x1ZGUgPGFzbS9rdm1fYXNtLmg+ Cj4gICNpbmNsdWRlIDxhc20va3ZtX21tdS5oPgo+ICsjaW5jbHVkZSA8YXNtL2t2bV9uZXN0ZWQu aD4KPiAgI2luY2x1ZGUgPGFzbS9rdm1fZW11bGF0ZS5oPgo+ICAjaW5jbHVkZSA8YXNtL2t2bV9j b3Byb2MuaD4KPiAgI2luY2x1ZGUgPGFzbS9zZWN0aW9ucy5oPgo+IEBAIC0xMjYsNiArMTI3LDgg QEAgaW50IGt2bV9hcmNoX2luaXRfdm0oc3RydWN0IGt2bSAqa3ZtLCB1bnNpZ25lZCBsb25nIHR5 cGUpCj4gIAlrdm0tPmFyY2gubW11LnZtaWQudm1pZF9nZW4gPSAwOwo+ICAJa3ZtLT5hcmNoLm1t dS5rdm0gPSBrdm07Cj4gIAo+ICsJa3ZtX2luaXRfbmVzdGVkKGt2bSk7CgpNb3JlIGNvbnRleHQ6 CgpAQCAtMTIwLDE4ICsxMjEsMjAgQEAgaW50IGt2bV9hcmNoX2luaXRfdm0oc3RydWN0IGt2bSAq a3ZtLCB1bnNpZ25lZCBsb25nIHR5cGUpCsKgCsKgwqDCoMKgIHJldCA9IGt2bV9hbGxvY19zdGFn ZTJfcGdkKCZrdm0tPmFyY2gubW11KTsKwqDCoMKgwqAgaWYgKHJldCkKwqDCoMKgwqAgwqDCoMKg IGdvdG8gb3V0X2ZhaWxfYWxsb2M7CsKgCsKgwqDCoMKgIC8qIE1hcmsgdGhlIGluaXRpYWwgVk1J RCBnZW5lcmF0aW9uIGludmFsaWQgKi8KwqDCoMKgwqAga3ZtLT5hcmNoLm1tdS52bWlkLnZtaWRf Z2VuID0gMDsKwqDCoMKgwqAga3ZtLT5hcmNoLm1tdS5rdm0gPSBrdm07CsKgCivCoMKgwqAga3Zt X2luaXRfbmVzdGVkKGt2bSk7CisKCmt2bV9hbGxvY19zdGFnZTJfcGdkIGVuZHMgdXAgY2FsbGlu ZyBrdm1faW5pdF9zMl9tbXUgZm9yIGt2bS0+YXJjaC5tbXUuCmt2bV9pbml0X25lc3RlZCBkb2Vz IHRoZSBzYW1lIHRoaW5nLCBhbmQgd2UgZW5kIHVwIGNhbGxpbmcga3ZtX2luaXRfczJfbW11IGZv cgprdm0tPmFyY2gubW11IHR3aWNlLiBUaGVyZSdzIHJlYWxseSBubyBoYXJtIGluIGRvaW5nIGl0 IHR3aWNlLCBidXQgSSB0aG91Z2h0IEkKY291bGQgbWVudGlvbiBpdCBiZWNhdXNlIGl0IGxvb2tz IHRvIG1lIHRoYXQgdGhlIGZpeCBpcyBzaW1wbGU6IHJlbW92ZSB0aGUKa3ZtX2luaXRfczJfbW11 IGNhbGwgZnJvbSBrdm1faW5pdF9uZXN0ZWQuIFRoZSBkb3VibGUgaW5pdGlhbGl6YXRpb24gaXMg YWxzbwp0cnVlIGZvciB0aGUgdGlwIG9mIHRoZSBzZXJpZXMuCgpUaGFua3MsCgpBbGV4Cgo+ICsK PiAgCXJldCA9IGNyZWF0ZV9oeXBfbWFwcGluZ3Moa3ZtLCBrdm0gKyAxLCBQQUdFX0hZUCk7Cj4g IAlpZiAocmV0KQo+ICAJCWdvdG8gb3V0X2ZyZWVfc3RhZ2UyX3BnZDsKPiBAQCAtMzUzLDYgKzM1 Niw5IEBAIHZvaWQga3ZtX2FyY2hfdmNwdV9sb2FkKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgaW50 IGNwdSkKPiAgCWludCAqbGFzdF9yYW47Cj4gIAlrdm1faG9zdF9kYXRhX3QgKmNwdV9kYXRhOwo+ ICAKPiArCWlmIChuZXN0ZWRfdmlydF9pbl91c2UodmNwdSkpCj4gKwkJa3ZtX3ZjcHVfbG9hZF9o d19tbXUodmNwdSk7Cj4gKwo+ICAJbGFzdF9yYW4gPSB0aGlzX2NwdV9wdHIodmNwdS0+a3ZtLT5h cmNoLmxhc3RfdmNwdV9yYW4pOwo+ICAJY3B1X2RhdGEgPSB0aGlzX2NwdV9wdHIoJmt2bV9ob3N0 X2RhdGEpOwo+ICAKPiBAQCAtMzkxLDYgKzM5Nyw5IEBAIHZvaWQga3ZtX2FyY2hfdmNwdV9wdXQo c3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ICAJa3ZtX3ZnaWNfcHV0KHZjcHUpOwo+ICAJa3ZtX3Zj cHVfcG11X3Jlc3RvcmVfaG9zdCh2Y3B1KTsKPiAgCj4gKwlpZiAobmVzdGVkX3ZpcnRfaW5fdXNl KHZjcHUpKQo+ICsJCWt2bV92Y3B1X3B1dF9od19tbXUodmNwdSk7Cj4gKwo+ICAJdmNwdS0+Y3B1 ID0gLTE7Cj4gIAo+ICAJa3ZtX2FybV9zZXRfcnVubmluZ192Y3B1KE5VTEwpOwo+IEBAIC05Njgs OCArOTc3LDEzIEBAIHN0YXRpYyBpbnQga3ZtX3ZjcHVfc2V0X3RhcmdldChzdHJ1Y3Qga3ZtX3Zj cHUgKnZjcHUsCj4gIAo+ICAJdmNwdS0+YXJjaC50YXJnZXQgPSBwaHlzX3RhcmdldDsKPiAgCj4g KwkvKiBQcmVwYXJlIGZvciBuZXN0ZWQgaWYgcmVxdWlyZWQgKi8KPiArCXJldCA9IGt2bV92Y3B1 X2luaXRfbmVzdGVkKHZjcHUpOwo+ICsKPiAgCS8qIE5vdyB3ZSBrbm93IHdoYXQgaXQgaXMsIHdl IGNhbiByZXNldCBpdC4gKi8KPiAtCXJldCA9IGt2bV9yZXNldF92Y3B1KHZjcHUpOwo+ICsJaWYg KCFyZXQpCj4gKwkJcmV0ID0ga3ZtX3Jlc2V0X3ZjcHUodmNwdSk7Cj4gKwo+ICAJaWYgKHJldCkg ewo+ICAJCXZjcHUtPmFyY2gudGFyZ2V0ID0gLTE7Cj4gIAkJYml0bWFwX3plcm8odmNwdS0+YXJj aC5mZWF0dXJlcywgS1ZNX1ZDUFVfTUFYX0ZFQVRVUkVTKTsKPiBkaWZmIC0tZ2l0IGEvdmlydC9r dm0vYXJtL21tdS5jIGIvdmlydC9rdm0vYXJtL21tdS5jCj4gaW5kZXggYmIxYmU0ZWE1NWVjLi5m YWE2MWE4MWM4Y2MgMTAwNjQ0Cj4gLS0tIGEvdmlydC9rdm0vYXJtL21tdS5jCj4gKysrIGIvdmly dC9rdm0vYXJtL21tdS5jCj4gQEAgLTMyNSw3ICszMjUsNyBAQCBzdGF0aWMgdm9pZCB1bm1hcF9z dGFnZTJfcHVkcyhzdHJ1Y3Qga3ZtX3MyX21tdSAqbW11LCBwZ2RfdCAqcGdkLAo+ICB9Cj4gIAo+ ICAvKioKPiAtICogdW5tYXBfc3RhZ2UyX3JhbmdlIC0tIENsZWFyIHN0YWdlMiBwYWdlIHRhYmxl IGVudHJpZXMgdG8gdW5tYXAgYSByYW5nZQo+ICsgKiBrdm1fdW5tYXBfc3RhZ2UyX3JhbmdlIC0t IENsZWFyIHN0YWdlMiBwYWdlIHRhYmxlIGVudHJpZXMgdG8gdW5tYXAgYSByYW5nZQo+ICAgKiBA a3ZtOiAgIFRoZSBWTSBwb2ludGVyCj4gICAqIEBzdGFydDogVGhlIGludGVybWVkaWF0ZSBwaHlz aWNhbCBiYXNlIGFkZHJlc3Mgb2YgdGhlIHJhbmdlIHRvIHVubWFwCj4gICAqIEBzaXplOiAgVGhl IHNpemUgb2YgdGhlIGFyZWEgdG8gdW5tYXAKPiBAQCAtMzM1LDcgKzMzNSw3IEBAIHN0YXRpYyB2 b2lkIHVubWFwX3N0YWdlMl9wdWRzKHN0cnVjdCBrdm1fczJfbW11ICptbXUsIHBnZF90ICpwZ2Qs Cj4gICAqIGRlc3Ryb3lpbmcgdGhlIFZNKSwgb3RoZXJ3aXNlIGFub3RoZXIgZmF1bHRpbmcgVkNQ VSBtYXkgY29tZSBpbiBhbmQgbWVzcwo+ICAgKiB3aXRoIHRoaW5ncyBiZWhpbmQgb3VyIGJhY2tz Lgo+ICAgKi8KPiAtc3RhdGljIHZvaWQgdW5tYXBfc3RhZ2UyX3JhbmdlKHN0cnVjdCBrdm1fczJf bW11ICptbXUsIHBoeXNfYWRkcl90IHN0YXJ0LCB1NjQgc2l6ZSkKPiArdm9pZCBrdm1fdW5tYXBf c3RhZ2UyX3JhbmdlKHN0cnVjdCBrdm1fczJfbW11ICptbXUsIHBoeXNfYWRkcl90IHN0YXJ0LCB1 NjQgc2l6ZSkKPiAgewo+ICAJc3RydWN0IGt2bSAqa3ZtID0gbW11LT5rdm07Cj4gIAlwZ2RfdCAq cGdkOwo+IEBAIC05MjQsNiArOTI0LDEwIEBAIGludCBrdm1fYWxsb2Nfc3RhZ2UyX3BnZChzdHJ1 Y3Qga3ZtX3MyX21tdSAqbW11KQo+ICAKPiAgCW1tdS0+cGdkID0gcGdkOwo+ICAJbW11LT5wZ2Rf cGh5cyA9IHBnZF9waHlzOwo+ICsJbW11LT52bWlkLnZtaWRfZ2VuID0gMDsKPiArCj4gKwlrdm1f aW5pdF9zMl9tbXUobW11KTsKPiArCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAKPiBAQCAtOTYyLDcg Kzk2Niw3IEBAIHN0YXRpYyB2b2lkIHN0YWdlMl91bm1hcF9tZW1zbG90KHN0cnVjdCBrdm0gKmt2 bSwKPiAgCj4gIAkJaWYgKCEodm1hLT52bV9mbGFncyAmIFZNX1BGTk1BUCkpIHsKPiAgCQkJZ3Bh X3QgZ3BhID0gYWRkciArICh2bV9zdGFydCAtIG1lbXNsb3QtPnVzZXJzcGFjZV9hZGRyKTsKPiAt CQkJdW5tYXBfc3RhZ2UyX3JhbmdlKCZrdm0tPmFyY2gubW11LCBncGEsIHZtX2VuZCAtIHZtX3N0 YXJ0KTsKPiArCQkJa3ZtX3VubWFwX3N0YWdlMl9yYW5nZSgma3ZtLT5hcmNoLm1tdSwgZ3BhLCB2 bV9lbmQgLSB2bV9zdGFydCk7Cj4gIAkJfQo+ICAJCWh2YSA9IHZtX2VuZDsKPiAgCX0gd2hpbGUg KGh2YSA8IHJlZ19lbmQpOwo+IEBAIC0xMDAxLDcgKzEwMDUsNyBAQCB2b2lkIGt2bV9mcmVlX3N0 YWdlMl9wZ2Qoc3RydWN0IGt2bV9zMl9tbXUgKm1tdSkKPiAgCj4gIAlzcGluX2xvY2soJmt2bS0+ bW11X2xvY2spOwo+ICAJaWYgKG1tdS0+cGdkKSB7Cj4gLQkJdW5tYXBfc3RhZ2UyX3JhbmdlKG1t dSwgMCwga3ZtX3BoeXNfc2l6ZShrdm0pKTsKPiArCQlrdm1fdW5tYXBfc3RhZ2UyX3JhbmdlKG1t dSwgMCwga3ZtX3BoeXNfc2l6ZShrdm0pKTsKPiAgCQlwZ2QgPSBSRUFEX09OQ0UobW11LT5wZ2Qp Owo+ICAJCW1tdS0+cGdkID0gTlVMTDsKPiAgCX0KPiBAQCAtMTA5Myw3ICsxMDk3LDcgQEAgc3Rh dGljIGludCBzdGFnZTJfc2V0X3BtZF9odWdlKHN0cnVjdCBrdm1fczJfbW11ICptbXUsCj4gIAkJ ICogZ2V0IGhhbmRsZWQgYWNjb3JkaW5nbHkuCj4gIAkJICovCj4gIAkJaWYgKCFwbWRfdGhwX29y X2h1Z2Uob2xkX3BtZCkpIHsKPiAtCQkJdW5tYXBfc3RhZ2UyX3JhbmdlKG1tdSwgYWRkciAmIFMy X1BNRF9NQVNLLCBTMl9QTURfU0laRSk7Cj4gKwkJCWt2bV91bm1hcF9zdGFnZTJfcmFuZ2UobW11 LCBhZGRyICYgUzJfUE1EX01BU0ssIFMyX1BNRF9TSVpFKTsKPiAgCQkJZ290byByZXRyeTsKPiAg CQl9Cj4gIAkJLyoKPiBAQCAtMTE0NSw3ICsxMTQ5LDcgQEAgc3RhdGljIGludCBzdGFnZTJfc2V0 X3B1ZF9odWdlKHN0cnVjdCBrdm1fczJfbW11ICptbXUsCj4gIAkJICogdGhlIHJhbmdlIGZvciB0 aGlzIGJsb2NrIGFuZCByZXRyeS4KPiAgCQkgKi8KPiAgCQlpZiAoIXN0YWdlMl9wdWRfaHVnZShr dm0sIG9sZF9wdWQpKSB7Cj4gLQkJCXVubWFwX3N0YWdlMl9yYW5nZShtbXUsIGFkZHIgJiBTMl9Q VURfTUFTSywgUzJfUFVEX1NJWkUpOwo+ICsJCQlrdm1fdW5tYXBfc3RhZ2UyX3JhbmdlKG1tdSwg YWRkciAmIFMyX1BVRF9NQVNLLCBTMl9QVURfU0laRSk7Cj4gIAkJCWdvdG8gcmV0cnk7Cj4gIAkJ fQo+ICAKPiBAQCAtMjA0Nyw3ICsyMDUxLDcgQEAgc3RhdGljIGludCBoYW5kbGVfaHZhX3RvX2dw YShzdHJ1Y3Qga3ZtICprdm0sCj4gIAo+ICBzdGF0aWMgaW50IGt2bV91bm1hcF9odmFfaGFuZGxl cihzdHJ1Y3Qga3ZtICprdm0sIGdwYV90IGdwYSwgdTY0IHNpemUsIHZvaWQgKmRhdGEpCj4gIHsK PiAtCXVubWFwX3N0YWdlMl9yYW5nZSgma3ZtLT5hcmNoLm1tdSwgZ3BhLCBzaXplKTsKPiArCWt2 bV91bm1hcF9zdGFnZTJfcmFuZ2UoJmt2bS0+YXJjaC5tbXUsIGdwYSwgc2l6ZSk7Cj4gIAlyZXR1 cm4gMDsKPiAgfQo+ICAKPiBAQCAtMjM2MCw3ICsyMzY0LDcgQEAgaW50IGt2bV9hcmNoX3ByZXBh cmVfbWVtb3J5X3JlZ2lvbihzdHJ1Y3Qga3ZtICprdm0sCj4gIAo+ICAJc3Bpbl9sb2NrKCZrdm0t Pm1tdV9sb2NrKTsKPiAgCWlmIChyZXQpCj4gLQkJdW5tYXBfc3RhZ2UyX3JhbmdlKCZrdm0tPmFy Y2gubW11LCBtZW0tPmd1ZXN0X3BoeXNfYWRkciwgbWVtLT5tZW1vcnlfc2l6ZSk7Cj4gKwkJa3Zt X3VubWFwX3N0YWdlMl9yYW5nZSgma3ZtLT5hcmNoLm1tdSwgbWVtLT5ndWVzdF9waHlzX2FkZHIs IG1lbS0+bWVtb3J5X3NpemUpOwo+ICAJZWxzZQo+ICAJCXN0YWdlMl9mbHVzaF9tZW1zbG90KCZr dm0tPmFyY2gubW11LCBtZW1zbG90KTsKPiAgCXNwaW5fdW5sb2NrKCZrdm0tPm1tdV9sb2NrKTsK PiBAQCAtMjM4NCwxMSArMjM4OCw2IEBAIHZvaWQga3ZtX2FyY2hfbWVtc2xvdHNfdXBkYXRlZChz dHJ1Y3Qga3ZtICprdm0sIHU2NCBnZW4pCj4gIHsKPiAgfQo+ICAKPiAtdm9pZCBrdm1fYXJjaF9m bHVzaF9zaGFkb3dfYWxsKHN0cnVjdCBrdm0gKmt2bSkKPiAtewo+IC0Ja3ZtX2ZyZWVfc3RhZ2Uy X3BnZCgma3ZtLT5hcmNoLm1tdSk7Cj4gLX0KPiAtCj4gIHZvaWQga3ZtX2FyY2hfZmx1c2hfc2hh ZG93X21lbXNsb3Qoc3RydWN0IGt2bSAqa3ZtLAo+ICAJCQkJICAgc3RydWN0IGt2bV9tZW1vcnlf c2xvdCAqc2xvdCkKPiAgewo+IEBAIC0yMzk2LDcgKzIzOTUsNyBAQCB2b2lkIGt2bV9hcmNoX2Zs dXNoX3NoYWRvd19tZW1zbG90KHN0cnVjdCBrdm0gKmt2bSwKPiAgCXBoeXNfYWRkcl90IHNpemUg PSBzbG90LT5ucGFnZXMgPDwgUEFHRV9TSElGVDsKPiAgCj4gIAlzcGluX2xvY2soJmt2bS0+bW11 X2xvY2spOwo+IC0JdW5tYXBfc3RhZ2UyX3JhbmdlKCZrdm0tPmFyY2gubW11LCBncGEsIHNpemUp Owo+ICsJa3ZtX3VubWFwX3N0YWdlMl9yYW5nZSgma3ZtLT5hcmNoLm1tdSwgZ3BhLCBzaXplKTsK PiAgCXNwaW5fdW5sb2NrKCZrdm0tPm1tdV9sb2NrKTsKPiAgfQo+ICAKPiBAQCAtMjQ2NywzICsy NDY2LDcgQEAgdm9pZCBrdm1fdG9nZ2xlX2NhY2hlKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgYm9v bCB3YXNfZW5hYmxlZCkKPiAgCj4gIAl0cmFjZV9rdm1fdG9nZ2xlX2NhY2hlKCp2Y3B1X3BjKHZj cHUpLCB3YXNfZW5hYmxlZCwgbm93X2VuYWJsZWQpOwo+ICB9Cj4gKwo+ICtfX3dlYWsgdm9pZCBr dm1fYXJjaF9mbHVzaF9zaGFkb3dfYWxsKHN0cnVjdCBrdm0gKmt2bSkKPiArewo+ICt9Cl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmt2bWFybSBtYWlsaW5n IGxpc3QKa3ZtYXJtQGxpc3RzLmNzLmNvbHVtYmlhLmVkdQpodHRwczovL2xpc3RzLmNzLmNvbHVt YmlhLmVkdS9tYWlsbWFuL2xpc3RpbmZvL2t2bWFybQo= 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_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=unavailable 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 73459C0651F for ; Thu, 4 Jul 2019 15:52:11 +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 46AB0218A0 for ; Thu, 4 Jul 2019 15:52:11 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="H9yhk8AP" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 46AB0218A0 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:Date: Message-ID:From:References:To:Subject:Reply-To:Content-ID:Content-Description :Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=DEtCAKs+vv3LvN7Q/itjDHxeEtwsEUIQoH052Rphwzk=; b=H9yhk8AP4HSamx vobsxznqzaq4Iet+nZ3g5QTSyDYMTx8P01K8EIGCTXSJHvYuNDmSYoacjTP9FDUn/Uxtfqgd31+rP q2ythEKv/FMZZEyYV/JJbkUSkYq9nlI5ALLIbmXfloapotQoY3up/v41ryk1dhMYL5KbdCOcLusQo +Z0JM1PV2KO/VMGGIKAMmwbPwUwtq5Aaws9yEZ1XDZvSAMzyns8XORedkiwWN94UCsrjVnpcG6ZH+ nTET4sV+/ThYczDNOa2oW2u0Ww+7ckwqCyqWx3qP4yuowXlsvOPeCBGtPP0NTxUfNagmIVnLA+0hc n8lVKXCWR4TU/9/7vqfg==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92 #3 (Red Hat Linux)) id 1hj41i-0005qd-GV; Thu, 04 Jul 2019 15:52:02 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92 #3 (Red Hat Linux)) id 1hj41d-0005pg-9U for linux-arm-kernel@lists.infradead.org; Thu, 04 Jul 2019 15:51:59 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 0110D2B; Thu, 4 Jul 2019 08:51:55 -0700 (PDT) Received: from [10.1.31.185] (e121566-lin.cambridge.arm.com [10.1.31.185]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 049AA3F703; Thu, 4 Jul 2019 08:51:53 -0700 (PDT) Subject: Re: [PATCH 35/59] KVM: arm/arm64: nv: Support multiple nested stage 2 mmu structures To: Marc Zyngier , linux-arm-kernel@lists.infradead.org, kvmarm@lists.cs.columbia.edu, kvm@vger.kernel.org References: <20190621093843.220980-1-marc.zyngier@arm.com> <20190621093843.220980-36-marc.zyngier@arm.com> From: Alexandru Elisei Message-ID: Date: Thu, 4 Jul 2019 16:51:52 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.0 MIME-Version: 1.0 In-Reply-To: <20190621093843.220980-36-marc.zyngier@arm.com> Content-Language: en-US X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190704_085157_427027_BA4F48F5 X-CRM114-Status: GOOD ( 38.76 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Andre Przywara , Dave Martin 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 T24gNi8yMS8xOSAxMDozOCBBTSwgTWFyYyBaeW5naWVyIHdyb3RlOgoKPiBGcm9tOiBDaHJpc3Rv ZmZlciBEYWxsIDxjaHJpc3RvZmZlci5kYWxsQGFybS5jb20+Cj4KPiBBZGQgc3RhZ2UgMiBtbXUg ZGF0YSBzdHJ1Y3R1cmVzIGZvciB2aXJ0dWFsIEVMMiBhbmQgZm9yIG5lc3RlZCBndWVzdHMuCj4g V2UgZG9uJ3QgeWV0IHBvcHVsYXRlIHNoYWRvdyBzdGFnZSAyIHBhZ2UgdGFibGVzLCBidXQgd2Ug bm93IGhhdmUgYQo+IGZyYW1ld29yayBmb3IgZ2V0dGluZyB0byBhIHNoYWRvdyBzdGFnZSAyIHBn ZC4KPgo+IFdlIGFsbG9jYXRlIHR3aWNlIHRoZSBudW1iZXIgb2YgdmNwdXMgYXMgc3RhZ2UgMiBt bXUgc3RydWN0dXJlcyBiZWNhdXNlCj4gdGhhdCdzIHN1ZmZpY2llbnQgZm9yIGVhY2ggdmNwdSBy dW5uaW5nIHR3byBWTXMgd2l0aG91dCBoYXZpbmcgdG8gZmx1c2gKPiB0aGUgc3RhZ2UgMiBwYWdl IHRhYmxlcy4KPgo+IFNpZ25lZC1vZmYtYnk6IENocmlzdG9mZmVyIERhbGwgPGNocmlzdG9mZmVy LmRhbGxAYXJtLmNvbT4KPiBTaWduZWQtb2ZmLWJ5OiBNYXJjIFp5bmdpZXIgPG1hcmMuenluZ2ll ckBhcm0uY29tPgo+IC0tLQo+ICBhcmNoL2FybS9pbmNsdWRlL2FzbS9rdm1faG9zdC5oICAgICB8 ICAgNCArCj4gIGFyY2gvYXJtL2luY2x1ZGUvYXNtL2t2bV9tbXUuaCAgICAgIHwgICAzICsKPiAg YXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1faG9zdC5oICAgfCAgMjggKysrKysKPiAgYXJjaC9h cm02NC9pbmNsdWRlL2FzbS9rdm1fbW11LmggICAgfCAgIDggKysKPiAgYXJjaC9hcm02NC9pbmNs dWRlL2FzbS9rdm1fbmVzdGVkLmggfCAgIDcgKysKPiAgYXJjaC9hcm02NC9rdm0vbmVzdGVkLmMg ICAgICAgICAgICAgfCAxNzIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICB2aXJ0L2t2 bS9hcm0vYXJtLmMgICAgICAgICAgICAgICAgICB8ICAxNiArKy0KPiAgdmlydC9rdm0vYXJtL21t dS5jICAgICAgICAgICAgICAgICAgfCAgMzEgKystLS0KPiAgOCBmaWxlcyBjaGFuZ2VkLCAyNTQg aW5zZXJ0aW9ucygrKSwgMTUgZGVsZXRpb25zKC0pCj4KPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm0v aW5jbHVkZS9hc20va3ZtX2hvc3QuaCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgK PiBpbmRleCBlMzIxN2M0YWQyNWIuLmI4MjFlYjIzODNhZCAxMDA2NDQKPiAtLS0gYS9hcmNoL2Fy bS9pbmNsdWRlL2FzbS9rdm1faG9zdC5oCj4gKysrIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20va3Zt X2hvc3QuaAo+IEBAIC00MjQsNCArNDI0LDggQEAgc3RhdGljIGlubGluZSBib29sIGt2bV9hcm1f dmNwdV9pc19maW5hbGl6ZWQoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ICAJcmV0dXJuIHRydWU7 Cj4gIH0KPiAgCj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBrdm1fdmNwdV9sb2FkX2h3X21tdShzdHJ1 Y3Qga3ZtX3ZjcHUgKnZjcHUpIHt9Cj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBrdm1fdmNwdV9wdXRf aHdfbW11KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSkge30KPiArc3RhdGljIGlubGluZSBpbnQga3Zt X3ZjcHVfaW5pdF9uZXN0ZWQoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KSB7IHJldHVybiAwOyB9Cj4g Kwo+ICAjZW5kaWYgLyogX19BUk1fS1ZNX0hPU1RfSF9fICovCj4gZGlmZiAtLWdpdCBhL2FyY2gv YXJtL2luY2x1ZGUvYXNtL2t2bV9tbXUuaCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2t2bV9tbXUu aAo+IGluZGV4IGJlMjNlM2Y4ZTA4Yy4uZTY5ODRiNmRhMmNlIDEwMDY0NAo+IC0tLSBhL2FyY2gv YXJtL2luY2x1ZGUvYXNtL2t2bV9tbXUuaAo+ICsrKyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2t2 bV9tbXUuaAo+IEBAIC00MjAsNiArNDIwLDkgQEAgc3RhdGljIGlubGluZSBpbnQgaHlwX21hcF9h dXhfZGF0YSh2b2lkKQo+ICAKPiAgc3RhdGljIGlubGluZSB2b2lkIGt2bV9zZXRfaXBhX2xpbWl0 KHZvaWQpIHt9Cj4gIAo+ICtzdGF0aWMgaW5saW5lIHZvaWQga3ZtX2luaXRfczJfbW11KHN0cnVj dCBrdm1fczJfbW11ICptbXUpIHt9Cj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBrdm1faW5pdF9uZXN0 ZWQoc3RydWN0IGt2bSAqa3ZtKSB7fQo+ICsKPiAgc3RhdGljIF9fYWx3YXlzX2lubGluZSB1NjQg a3ZtX2dldF92dHRicihzdHJ1Y3Qga3ZtX3MyX21tdSAqbW11KQo+ICB7Cj4gIAlzdHJ1Y3Qga3Zt X3ZtaWQgKnZtaWQgPSAmbW11LT52bWlkOwo+IGRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1 ZGUvYXNtL2t2bV9ob3N0LmggYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKPiBp bmRleCAzZGVlNWUxN2E0ZWUuLmNjMjM4ZGUxNzBkMiAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0 L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKPiArKysgYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2 bV9ob3N0LmgKPiBAQCAtODgsMTEgKzg4LDM5IEBAIHN0cnVjdCBrdm1fczJfbW11IHsKPiAgCXBo eXNfYWRkcl90CXBnZF9waHlzOwo+ICAKPiAgCXN0cnVjdCBrdm0gKmt2bTsKPiArCj4gKwkvKgo+ ICsJICogRm9yIGEgc2hhZG93IHN0YWdlLTIgTU1VLCB0aGUgdmlydHVhbCB2dHRiciBwcm9ncmFt bWVkIGJ5IHRoZSBndWVzdAo+ICsJICogaHlwZXJ2aXNvci4gIFVudXNlZCBmb3Iga3ZtX2FyY2gt Pm1tdS4gU2V0IHRvIDEgd2hlbiB0aGUgc3RydWN0dXJlCj4gKwkgKiBjb250YWlucyBubyB2YWxp ZCBpbmZvcm1hdGlvbi4KPiArCSAqLwo+ICsJdTY0CXZ0dGJyOwo+ICsKPiArCS8qIHRydWUgd2hl biB0aGlzIHJlcHJlc2VudHMgYSBuZXN0ZWQgY29udGV4dCB3aGVyZSB2aXJ0dWFsIEhDUl9FTDIu Vk0gPT0gMSAqLwo+ICsJYm9vbAluZXN0ZWRfc3RhZ2UyX2VuYWJsZWQ7Cj4gKwo+ICsJLyoKPiAr CSAqICAwOiBOb2JvZHkgaXMgY3VycmVudGx5IHVzaW5nIHRoaXMsIGNoZWNrIHZ0dGJyIGZvciB2 YWxpZGl0eQo+ICsJICogPjA6IFNvbWVib2R5IGlzIGFjdGl2ZWx5IHVzaW5nIHRoaXMuCj4gKwkg Ki8KPiArCWF0b21pY190IHJlZmNudDsKPiAgfTsKPiAgCj4gK3N0YXRpYyBpbmxpbmUgYm9vbCBr dm1fczJfbW11X3ZhbGlkKHN0cnVjdCBrdm1fczJfbW11ICptbXUpCj4gK3sKPiArCXJldHVybiAh KG1tdS0+dnR0YnIgJiAxKTsKPiArfQo+ICsKPiAgc3RydWN0IGt2bV9hcmNoIHsKPiAgCXN0cnVj dCBrdm1fczJfbW11IG1tdTsKPiAgCj4gKwkvKgo+ICsJICogU3RhZ2UgMiBwYWdpbmcgc3RhZ2Ug Zm9yIFZNcyB3aXRoIG5lc3RlZCB2aXJ0dWFsIHVzaW5nIGEgdmlydHVhbAo+ICsJICogVk1JRC4K PiArCSAqLwo+ICsJc3RydWN0IGt2bV9zMl9tbXUgKm5lc3RlZF9tbXVzOwo+ICsJc2l6ZV90IG5l c3RlZF9tbXVzX3NpemU7Cj4gKwo+ICAJLyogVlRDUl9FTDIgdmFsdWUgZm9yIHRoaXMgVk0gKi8K PiAgCXU2NCAgICB2dGNyOwo+ICAKPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2Fz bS9rdm1fbW11LmggYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9tbXUuaAo+IGluZGV4IDFl YjZlMGNhNjFjMi4uMzJiY2FhMTg0NWRjIDEwMDY0NAo+IC0tLSBhL2FyY2gvYXJtNjQvaW5jbHVk ZS9hc20va3ZtX21tdS5oCj4gKysrIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1fbW11LmgK PiBAQCAtMTAwLDYgKzEwMCw3IEBAIGFsdGVybmF0aXZlX2NiX2VuZAo+ICAjaW5jbHVkZSA8YXNt L21tdV9jb250ZXh0Lmg+Cj4gICNpbmNsdWRlIDxhc20vcGd0YWJsZS5oPgo+ICAjaW5jbHVkZSA8 YXNtL2t2bV9lbXVsYXRlLmg+Cj4gKyNpbmNsdWRlIDxhc20va3ZtX25lc3RlZC5oPgo+ICAKPiAg dm9pZCBrdm1fdXBkYXRlX3ZhX21hc2soc3RydWN0IGFsdF9pbnN0ciAqYWx0LAo+ICAJCQlfX2xl MzIgKm9yaWdwdHIsIF9fbGUzMiAqdXBkcHRyLCBpbnQgbnJfaW5zdCk7Cj4gQEAgLTE2NCw2ICsx NjUsNyBAQCBpbnQgY3JlYXRlX2h5cF9leGVjX21hcHBpbmdzKHBoeXNfYWRkcl90IHBoeXNfYWRk ciwgc2l6ZV90IHNpemUsCj4gIAkJCSAgICAgdm9pZCAqKmhhZGRyKTsKPiAgdm9pZCBmcmVlX2h5 cF9wZ2RzKHZvaWQpOwo+ICAKPiArdm9pZCBrdm1fdW5tYXBfc3RhZ2UyX3JhbmdlKHN0cnVjdCBr dm1fczJfbW11ICptbXUsIHBoeXNfYWRkcl90IHN0YXJ0LCB1NjQgc2l6ZSk7Cj4gIHZvaWQgc3Rh Z2UyX3VubWFwX3ZtKHN0cnVjdCBrdm0gKmt2bSk7Cj4gIGludCBrdm1fYWxsb2Nfc3RhZ2UyX3Bn ZChzdHJ1Y3Qga3ZtX3MyX21tdSAqbW11KTsKPiAgdm9pZCBrdm1fZnJlZV9zdGFnZTJfcGdkKHN0 cnVjdCBrdm1fczJfbW11ICptbXUpOwo+IEBAIC02MzUsNSArNjM3LDExIEBAIHN0YXRpYyBfX2Fs d2F5c19pbmxpbmUgdm9pZCBfX2xvYWRfZ3Vlc3Rfc3RhZ2UyKHN0cnVjdCBrdm1fczJfbW11ICpt bXUpCj4gIAlhc20oQUxURVJOQVRJVkUoIm5vcCIsICJpc2IiLCBBUk02NF9XT1JLQVJPVU5EXzEx NjU1MjIpKTsKPiAgfQo+ICAKPiArc3RhdGljIGlubGluZSB1NjQgZ2V0X3ZtaWQodTY0IHZ0dGJy KQo+ICt7Cj4gKwlyZXR1cm4gKHZ0dGJyICYgVlRUQlJfVk1JRF9NQVNLKGt2bV9nZXRfdm1pZF9i aXRzKCkpKSA+Pgo+ICsJCVZUVEJSX1ZNSURfU0hJRlQ7Cj4gK30KPiArCj4gICNlbmRpZiAvKiBf X0FTU0VNQkxZX18gKi8KPiAgI2VuZGlmIC8qIF9fQVJNNjRfS1ZNX01NVV9IX18gKi8KPiBkaWZm IC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1fbmVzdGVkLmggYi9hcmNoL2FybTY0 L2luY2x1ZGUvYXNtL2t2bV9uZXN0ZWQuaAo+IGluZGV4IDYxZTcxZDBkMjE1MS4uZDQwMjFkMDg5 MmJkIDEwMDY0NAo+IC0tLSBhL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX25lc3RlZC5oCj4g KysrIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1fbmVzdGVkLmgKPiBAQCAtMTAsNiArMTAs MTMgQEAgc3RhdGljIGlubGluZSBib29sIG5lc3RlZF92aXJ0X2luX3VzZShjb25zdCBzdHJ1Y3Qg a3ZtX3ZjcHUgKnZjcHUpCj4gIAkJdGVzdF9iaXQoS1ZNX0FSTV9WQ1BVX05FU1RFRF9WSVJULCB2 Y3B1LT5hcmNoLmZlYXR1cmVzKTsKPiAgfQo+ICAKPiArZXh0ZXJuIHZvaWQga3ZtX2luaXRfbmVz dGVkKHN0cnVjdCBrdm0gKmt2bSk7Cj4gK2V4dGVybiBpbnQga3ZtX3ZjcHVfaW5pdF9uZXN0ZWQo c3RydWN0IGt2bV92Y3B1ICp2Y3B1KTsKPiArZXh0ZXJuIHZvaWQga3ZtX2luaXRfczJfbW11KHN0 cnVjdCBrdm1fczJfbW11ICptbXUpOwo+ICtleHRlcm4gc3RydWN0IGt2bV9zMl9tbXUgKmxvb2t1 cF9zMl9tbXUoc3RydWN0IGt2bSAqa3ZtLCB1NjQgdnR0YnIsIHU2NCBoY3IpOwo+ICtleHRlcm4g dm9pZCBrdm1fdmNwdV9sb2FkX2h3X21tdShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpOwo+ICtleHRl cm4gdm9pZCBrdm1fdmNwdV9wdXRfaHdfbW11KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSk7Cj4gKwo+ ICBpbnQgaGFuZGxlX3dmeF9uZXN0ZWQoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBib29sIGlzX3dm ZSk7Cj4gIGV4dGVybiBib29sIGZvcndhcmRfdHJhcHMoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCB1 NjQgY29udHJvbF9iaXQpOwo+ICBleHRlcm4gYm9vbCBmb3J3YXJkX252X3RyYXBzKHN0cnVjdCBr dm1fdmNwdSAqdmNwdSk7Cj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQva3ZtL25lc3RlZC5jIGIv YXJjaC9hcm02NC9rdm0vbmVzdGVkLmMKPiBpbmRleCAzODcyZTNjZjE2OTEuLjRiMzhkYzVjMGJl MyAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0L2t2bS9uZXN0ZWQuYwo+ICsrKyBiL2FyY2gvYXJt NjQva3ZtL25lc3RlZC5jCj4gQEAgLTE4LDcgKzE4LDE2MSBAQAo+ICAjaW5jbHVkZSA8bGludXgv a3ZtLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9rdm1faG9zdC5oPgo+ICAKPiArI2luY2x1ZGUgPGFz bS9rdm1fYXJtLmg+Cj4gICNpbmNsdWRlIDxhc20va3ZtX2VtdWxhdGUuaD4KPiArI2luY2x1ZGUg PGFzbS9rdm1fbW11Lmg+Cj4gKyNpbmNsdWRlIDxhc20va3ZtX25lc3RlZC5oPgo+ICsKPiArdm9p ZCBrdm1faW5pdF9uZXN0ZWQoc3RydWN0IGt2bSAqa3ZtKQo+ICt7Cj4gKwlrdm1faW5pdF9zMl9t bXUoJmt2bS0+YXJjaC5tbXUpOwo+ICsKPiArCWt2bS0+YXJjaC5uZXN0ZWRfbW11cyA9IE5VTEw7 Cj4gKwlrdm0tPmFyY2gubmVzdGVkX21tdXNfc2l6ZSA9IDA7Cj4gK30KPiArCj4gK2ludCBrdm1f dmNwdV9pbml0X25lc3RlZChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCj4gK3sKPiArCXN0cnVjdCBr dm0gKmt2bSA9IHZjcHUtPmt2bTsKPiArCXN0cnVjdCBrdm1fczJfbW11ICp0bXA7Cj4gKwlpbnQg bnVtX21tdXM7Cj4gKwlpbnQgcmV0ID0gLUVOT01FTTsKPiArCj4gKwlpZiAoIXRlc3RfYml0KEtW TV9BUk1fVkNQVV9ORVNURURfVklSVCwgdmNwdS0+YXJjaC5mZWF0dXJlcykpCj4gKwkJcmV0dXJu IDA7Cj4gKwo+ICsJaWYgKCFjcHVzX2hhdmVfY29uc3RfY2FwKEFSTTY0X0hBU19ORVNURURfVklS VCkpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJbXV0ZXhfbG9jaygma3ZtLT5sb2NrKTsK PiArCj4gKwludW1fbW11cyA9IGF0b21pY19yZWFkKCZrdm0tPm9ubGluZV92Y3B1cykgKiAyOwo+ ICsJdG1wID0gX19rcmVhbGxvYyhrdm0tPmFyY2gubmVzdGVkX21tdXMsCj4gKwkJCSBudW1fbW11 cyAqIHNpemVvZigqa3ZtLT5hcmNoLm5lc3RlZF9tbXVzKSwKPiArCQkJIEdGUF9LRVJORUwgfCBf X0dGUF9aRVJPKTsKPiArCj4gKwlpZiAodG1wKSB7Cj4gKwkJaWYgKHRtcCAhPSBrdm0tPmFyY2gu bmVzdGVkX21tdXMpCj4gKwkJCWtmcmVlKGt2bS0+YXJjaC5uZXN0ZWRfbW11cyk7CgpIZXJlIHdl IGFyZSBmcmVlaW5nIGEgcmVzb3VyY2UgdGhhdCBpcyBzaGFyZWQgYmV0d2VlbiBhbGwgdmlydHVh bCBDUFVzLiBTbyBpZgprdm1fYWxsb2Nfc3RhZ2UyX3BnZCAoYmVsb3cpIGZhaWxzLCB3ZSBjb3Vs ZCBlbmQgdXAgZnJlZWluZyBzb21ldGhpbmcgdGhhdCBoYXMKYmVlbiBpbml0aWFsaXplZCBieSBw cmV2aW91cyB2Y3B1KHMpLiBTYW1lIHRoaW5nIGhhcHBlbnMgaWYgdG1wID09Cmt2bS0+YXJjaC5u ZXN0ZWRfbW11cyAoYmVjYXVzZSBvZiBrZnJlZSh0bXApKS4KCkxvb2tpbmcgYXQgRG9jdW1lbnRh dGlvbi92aXJ0dWFsL2t2bS9hcGkudHh0IChzZWN0aW9uIDQuODIsIEtWTV9BUk1fVkNQVV9JT0NU TCk6CgpVc2Vyc3BhY2UgY2FuIGNhbGwgdGhpcyBmdW5jdGlvbiBtdWx0aXBsZSB0aW1lcyBmb3Ig YSBnaXZlbiB2Y3B1LCBpbmNsdWRpbmcKYWZ0ZXIgdGhlIHZjcHUgaGFzIGJlZW4gcnVuLiBUaGlz IHdpbGwgcmVzZXQgdGhlIHZjcHUgdG8gaXRzIGluaXRpYWwKc3RhdGUuCgpJdCBzZWVtcyB0byBt ZSB0aGF0IGl0IGlzIGFsbG93ZWQgZm9yIHVzZXJzcGFjZSB0byB0cnkgdG8gY2FsbApLVk1fQVJN X1ZDUFVfSU9DVEwgYWdhaW4gYWZ0ZXIgaXQgZmFpbGVkLiBJIHdhcyB3b25kZXJpbmcgaWYgaXQn cyBwb3NzaWJsZSB0bwplbmQgdXAgaW4gYSBzaXR1YXRpb24gd2hlcmUgdGhlIHNlY29uZCBjYWxs IHN1Y2NlZWRzLCBidXQga3ZtLT5hcmNoLm5lc3RlZF9tbXVzCmlzIG5vdCBpbml0aWFsaXplZCBw cm9wZXJseSBhbmQgaWYgd2Ugc2hvdWxkIGNhcmUgYWJvdXQgdGhhdC4KCj4gKwo+ICsJCXRtcFtu dW1fbW11cyAtIDFdLmt2bSA9IGt2bTsKPiArCQlhdG9taWNfc2V0KCZ0bXBbbnVtX21tdXMgLSAx XS5yZWZjbnQsIDApOwo+ICsJCXJldCA9IGt2bV9hbGxvY19zdGFnZTJfcGdkKCZ0bXBbbnVtX21t dXMgLSAxXSk7Cj4gKwkJaWYgKHJldCkKPiArCQkJZ290byBvdXQ7Cj4gKwo+ICsJCXRtcFtudW1f bW11cyAtIDJdLmt2bSA9IGt2bTsKPiArCQlhdG9taWNfc2V0KCZ0bXBbbnVtX21tdXMgLSAyXS5y ZWZjbnQsIDApOwo+ICsJCXJldCA9IGt2bV9hbGxvY19zdGFnZTJfcGdkKCZ0bXBbbnVtX21tdXMg LSAyXSk7Cj4gKwkJaWYgKHJldCkgewo+ICsJCQlrdm1fZnJlZV9zdGFnZTJfcGdkKCZ0bXBbbnVt X21tdXMgLSAxXSk7Cj4gKwkJCWdvdG8gb3V0Owo+ICsJCX0KPiArCj4gKwkJa3ZtLT5hcmNoLm5l c3RlZF9tbXVzX3NpemUgPSBudW1fbW11czsKPiArCQlrdm0tPmFyY2gubmVzdGVkX21tdXMgPSB0 bXA7Cj4gKwkJdG1wID0gTlVMTDsKPiArCX0KPiArCj4gK291dDoKPiArCWtmcmVlKHRtcCk7Cj4g KwltdXRleF91bmxvY2soJmt2bS0+bG9jayk7Cj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICsv KiBNdXN0IGJlIGNhbGxlZCB3aXRoIGt2bS0+bG9jayBoZWxkICovCj4gK3N0cnVjdCBrdm1fczJf bW11ICpsb29rdXBfczJfbW11KHN0cnVjdCBrdm0gKmt2bSwgdTY0IHZ0dGJyLCB1NjQgaGNyKQo+ ICt7Cj4gKwlib29sIG5lc3RlZF9zdGFnZTJfZW5hYmxlZCA9IGhjciAmIEhDUl9WTTsKPiArCWlu dCBpOwo+ICsKPiArCS8qIERvbid0IGNvbnNpZGVyIHRoZSBDblAgYml0IGZvciB0aGUgdnR0YnIg bWF0Y2ggKi8KPiArCXZ0dGJyID0gdnR0YnIgJiB+MVVMOwoKVGhlcmUncyBhIGRlZmluZSBmb3Ig dGhhdCBiaXQsIFZUVEJSX0NOUF9CSVQgaW4ga3ZtX2FybS5oICh3aGljaCB0aGlzIGZpbGUKaW5j bHVkZXMpLgoKPiArCj4gKwkvKiBTZWFyY2ggYSBtbXUgaW4gdGhlIGxpc3QgdXNpbmcgdGhlIHZp cnR1YWwgVk1JRCBhcyBhIGtleSAqLwoKSSB0aGluayB3aGVuIHRoZSBndWVzdCBoYXMgc3RhZ2Ug MiBlbmFibGVkIHdlIGFsc28gbWF0Y2ggb24gVlRUQlJfRUwyLlZNSUQgKwpWVFRCUl9FTDIuQkFE RFIuCgo+ICsJZm9yIChpID0gMDsgaSA8IGt2bS0+YXJjaC5uZXN0ZWRfbW11c19zaXplOyBpKysp IHsKPiArCQlzdHJ1Y3Qga3ZtX3MyX21tdSAqbW11ID0gJmt2bS0+YXJjaC5uZXN0ZWRfbW11c1tp XTsKPiArCj4gKwkJaWYgKCFrdm1fczJfbW11X3ZhbGlkKG1tdSkpCj4gKwkJCWNvbnRpbnVlOwo+ ICsKPiArCQlpZiAobmVzdGVkX3N0YWdlMl9lbmFibGVkICYmCj4gKwkJICAgIG1tdS0+bmVzdGVk X3N0YWdlMl9lbmFibGVkICYmCj4gKwkJICAgIHZ0dGJyID09IG1tdS0+dnR0YnIpCj4gKwkJCXJl dHVybiBtbXU7Cj4gKwo+ICsJCWlmICghbmVzdGVkX3N0YWdlMl9lbmFibGVkICYmCj4gKwkJICAg ICFtbXUtPm5lc3RlZF9zdGFnZTJfZW5hYmxlZCAmJgo+ICsJCSAgICBnZXRfdm1pZCh2dHRicikg PT0gZ2V0X3ZtaWQobW11LT52dHRicikpCj4gKwkJCXJldHVybiBtbXU7CgpJJ20gc3RydWdnbGlu ZyB0byB1bmRlcnN0YW5kIHdoeSB3ZSBkbyB0aGlzLiBBcyBmYXIgYXMgSSBjYW4gdGVsbCwgdGhp cyBhcHBsaWVzCm9ubHkgdG8gbm9uLXZoZSBndWVzdCBoeXBlcnZpc29ycywgYmVjYXVzZSB0aGF0 J3MgdGhlIG9ubHkgc2l0dWF0aW9uIHdoZXJlIHdlCnJ1biBzb21ldGhpbmcgYXQgdkVMMSB3aXRo b3V0IHNoYWRvdyBzdGFnZSAyIGVuYWJsZWQuIFRoZXJlJ3Mgb25seSBvbmUgTU1VIHRoYXQKbWF0 Y2hlcyB0aGF0IGd1ZXN0LCBiZWNhdXNlIHRoZXJlJ3Mgb25seSBvbmUgaG9zdCBmb3IgdGhlIG5v bi12aGUgaHlwZXJ2aXNvci4gU28Kd2h5IGFyZSB3ZSBtYXRjaGluZyBvbiB2bWlkIG9ubHksIGlu c3RlYWQgb2YgbWF0Y2hpbmcgb24gdGhlIGVudGlyZSB2dHRicj8gSXMgaXQKYmVjYXVzZSB3ZSBk b24ndCB3YW50IHRvIGdldCBmb29sZWQgYnkgYSBuYXVnaHR5IGd1ZXN0IHRoYXQgY2hhbmdlcyB0 aGUgQkFERFIKZWFjaCB0aW1lIGl0IHN3aXRjaGVzIHRvIGl0cyBFTDEgaG9zdD8gT3Igc29tZXRo aW5nIGVsc2UgZW50aXJlbHkgdGhhdCBJJ20gbWlzc2luZz8KCj4gKwl9Cj4gKwlyZXR1cm4gTlVM TDsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCBrdm1fczJfbW11ICpnZXRfczJfbW11X25lc3Rl ZChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCj4gK3sKPiArCXN0cnVjdCBrdm0gKmt2bSA9IHZjcHUt Pmt2bTsKPiArCXU2NCB2dHRiciA9IHZjcHVfcmVhZF9zeXNfcmVnKHZjcHUsIFZUVEJSX0VMMik7 Cj4gKwl1NjQgaGNyPSB2Y3B1X3JlYWRfc3lzX3JlZyh2Y3B1LCBIQ1JfRUwyKTsKPiArCXN0cnVj dCBrdm1fczJfbW11ICpzMl9tbXU7Cj4gKwlpbnQgaTsKPiArCj4gKwlzMl9tbXUgPSBsb29rdXBf czJfbW11KGt2bSwgdnR0YnIsIGhjcik7Cj4gKwlpZiAoczJfbW11KQo+ICsJCWdvdG8gb3V0Owo+ ICsKPiArCWZvciAoaSA9IDA7IGkgPCBrdm0tPmFyY2gubmVzdGVkX21tdXNfc2l6ZTsgaSsrKSB7 Cj4gKwkJczJfbW11ID0gJmt2bS0+YXJjaC5uZXN0ZWRfbW11c1tpXTsKPiArCj4gKwkJaWYgKGF0 b21pY19yZWFkKCZzMl9tbXUtPnJlZmNudCkgPT0gMCkKPiArCQkJYnJlYWs7Cj4gKwl9Cj4gKwlC VUdfT04oYXRvbWljX3JlYWQoJnMyX21tdS0+cmVmY250KSk7IC8qIFdlIGhhdmUgc3RydWN0IE1N VXMgdG8gc3BhcmUgKi8KPiArCj4gKwlpZiAoa3ZtX3MyX21tdV92YWxpZChzMl9tbXUpKSB7Cj4g KwkJLyogQ2xlYXIgdGhlIG9sZCBzdGF0ZSAqLwo+ICsJCWt2bV91bm1hcF9zdGFnZTJfcmFuZ2Uo czJfbW11LCAwLCBrdm1fcGh5c19zaXplKGt2bSkpOwo+ICsJCWlmIChzMl9tbXUtPnZtaWQudm1p ZF9nZW4pCj4gKwkJCWt2bV9jYWxsX2h5cChfX2t2bV90bGJfZmx1c2hfdm1pZCwgczJfbW11KTsK PiArCX0KPiArCj4gKwkvKgo+ICsJICogVGhlIHZpcnR1YWwgVk1JRCAobW9kdWxvIENuUCkgd2ls bCBiZSB1c2VkIGFzIGEga2V5IHdoZW4gbWF0Y2hpbmcKPiArCSAqIGFuIGV4aXN0aW5nIGt2bV9z Ml9tbXUuCj4gKwkgKi8KPiArCXMyX21tdS0+dnR0YnIgPSB2dHRiciAmIH4xVUw7Cj4gKwlzMl9t bXUtPm5lc3RlZF9zdGFnZTJfZW5hYmxlZCA9IGhjciAmIEhDUl9WTTsKPiArCj4gK291dDoKPiAr CWF0b21pY19pbmMoJnMyX21tdS0+cmVmY250KTsKPiArCXJldHVybiBzMl9tbXU7Cj4gK30KPiAr Cj4gK3ZvaWQga3ZtX2luaXRfczJfbW11KHN0cnVjdCBrdm1fczJfbW11ICptbXUpCj4gK3sKPiAr CW1tdS0+dnR0YnIgPSAxOwo+ICsJbW11LT5uZXN0ZWRfc3RhZ2UyX2VuYWJsZWQgPSBmYWxzZTsK PiArCWF0b21pY19zZXQoJm1tdS0+cmVmY250LCAwKTsKPiArfQo+ICsKPiArdm9pZCBrdm1fdmNw dV9sb2FkX2h3X21tdShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCj4gK3sKPiArCWlmIChpc19oeXBf Y3R4dCh2Y3B1KSkgewoKSWYgdXNlcnNwYWNlIGhhcyBzZXQgdGhlIG5lc3RlZCBmZWF0dXJlLCBi dXQgaGFzbid0IHNldCB0aGUgdmNwdSBtb2RlIHRvClBTUl9NT0RFX0VMMmgvUFNSX01PREVfRUwy dCwgd2Ugd2lsbCBuZXZlciB1c2Uga3ZtLT5hcmNoLm1tdSwgYW5kIGluc3RlYWQgd2UnbGwKYWx3 YXlzIHRha2UgdGhlIG1tdV9sb2NrIGFuZCBzZWFyY2ggZm9yIHRoZSBtbXUuIElzIHRoYXQgc29t ZXRoaW5nIHdlIHNob3VsZApjYXJlIGFib3V0PwoKPiArCQl2Y3B1LT5hcmNoLmh3X21tdSA9ICZ2 Y3B1LT5rdm0tPmFyY2gubW11Owo+ICsJfSBlbHNlIHsKPiArCQlzcGluX2xvY2soJnZjcHUtPmt2 bS0+bW11X2xvY2spOwo+ICsJCXZjcHUtPmFyY2guaHdfbW11ID0gZ2V0X3MyX21tdV9uZXN0ZWQo dmNwdSk7Cj4gKwkJc3Bpbl91bmxvY2soJnZjcHUtPmt2bS0+bW11X2xvY2spOwo+ICsJfQo+ICt9 Cj4gKwo+ICt2b2lkIGt2bV92Y3B1X3B1dF9od19tbXUoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ ICt7Cj4gKwlpZiAodmNwdS0+YXJjaC5od19tbXUgIT0gJnZjcHUtPmt2bS0+YXJjaC5tbXUpIHsK PiArCQlhdG9taWNfZGVjKCZ2Y3B1LT5hcmNoLmh3X21tdS0+cmVmY250KTsKPiArCQl2Y3B1LT5h cmNoLmh3X21tdSA9IE5VTEw7Cj4gKwl9Cj4gK30KPiAgCj4gIC8qCj4gICAqIEluamVjdCB3Zngg dG8gdGhlIHZpcnR1YWwgRUwyIGlmIHRoaXMgaXMgbm90IGZyb20gdGhlIHZpcnR1YWwgRUwyIGFu ZAo+IEBAIC0zNywzICsxOTEsMjEgQEAgaW50IGhhbmRsZV93ZnhfbmVzdGVkKHN0cnVjdCBrdm1f dmNwdSAqdmNwdSwgYm9vbCBpc193ZmUpCj4gIAo+ICAJcmV0dXJuIC1FSU5WQUw7Cj4gIH0KPiAr Cj4gK3ZvaWQga3ZtX2FyY2hfZmx1c2hfc2hhZG93X2FsbChzdHJ1Y3Qga3ZtICprdm0pCj4gK3sK PiArCWludCBpOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBrdm0tPmFyY2gubmVzdGVkX21tdXNf c2l6ZTsgaSsrKSB7Cj4gKwkJc3RydWN0IGt2bV9zMl9tbXUgKm1tdSA9ICZrdm0tPmFyY2gubmVz dGVkX21tdXNbaV07Cj4gKwo+ICsJCVdBUk5fT04oYXRvbWljX3JlYWQoJm1tdS0+cmVmY250KSk7 Cj4gKwo+ICsJCWlmICghYXRvbWljX3JlYWQoJm1tdS0+cmVmY250KSkKPiArCQkJa3ZtX2ZyZWVf c3RhZ2UyX3BnZChtbXUpOwo+ICsJfQo+ICsJa2ZyZWUoa3ZtLT5hcmNoLm5lc3RlZF9tbXVzKTsK PiArCWt2bS0+YXJjaC5uZXN0ZWRfbW11cyA9IE5VTEw7Cj4gKwlrdm0tPmFyY2gubmVzdGVkX21t dXNfc2l6ZSA9IDA7Cj4gKwlrdm1fZnJlZV9zdGFnZTJfcGdkKCZrdm0tPmFyY2gubW11KTsKPiAr fQo+IGRpZmYgLS1naXQgYS92aXJ0L2t2bS9hcm0vYXJtLmMgYi92aXJ0L2t2bS9hcm0vYXJtLmMK PiBpbmRleCA1ZDQzNzE2MzNlMWMuLjRlM2NiZmExZWNiZSAxMDA2NDQKPiAtLS0gYS92aXJ0L2t2 bS9hcm0vYXJtLmMKPiArKysgYi92aXJ0L2t2bS9hcm0vYXJtLmMKPiBAQCAtMzYsNiArMzYsNyBA QAo+ICAjaW5jbHVkZSA8YXNtL2t2bV9hcm0uaD4KPiAgI2luY2x1ZGUgPGFzbS9rdm1fYXNtLmg+ Cj4gICNpbmNsdWRlIDxhc20va3ZtX21tdS5oPgo+ICsjaW5jbHVkZSA8YXNtL2t2bV9uZXN0ZWQu aD4KPiAgI2luY2x1ZGUgPGFzbS9rdm1fZW11bGF0ZS5oPgo+ICAjaW5jbHVkZSA8YXNtL2t2bV9j b3Byb2MuaD4KPiAgI2luY2x1ZGUgPGFzbS9zZWN0aW9ucy5oPgo+IEBAIC0xMjYsNiArMTI3LDgg QEAgaW50IGt2bV9hcmNoX2luaXRfdm0oc3RydWN0IGt2bSAqa3ZtLCB1bnNpZ25lZCBsb25nIHR5 cGUpCj4gIAlrdm0tPmFyY2gubW11LnZtaWQudm1pZF9nZW4gPSAwOwo+ICAJa3ZtLT5hcmNoLm1t dS5rdm0gPSBrdm07Cj4gIAo+ICsJa3ZtX2luaXRfbmVzdGVkKGt2bSk7CgpNb3JlIGNvbnRleHQ6 CgpAQCAtMTIwLDE4ICsxMjEsMjAgQEAgaW50IGt2bV9hcmNoX2luaXRfdm0oc3RydWN0IGt2bSAq a3ZtLCB1bnNpZ25lZCBsb25nIHR5cGUpCsKgCsKgwqDCoMKgIHJldCA9IGt2bV9hbGxvY19zdGFn ZTJfcGdkKCZrdm0tPmFyY2gubW11KTsKwqDCoMKgwqAgaWYgKHJldCkKwqDCoMKgwqAgwqDCoMKg IGdvdG8gb3V0X2ZhaWxfYWxsb2M7CsKgCsKgwqDCoMKgIC8qIE1hcmsgdGhlIGluaXRpYWwgVk1J RCBnZW5lcmF0aW9uIGludmFsaWQgKi8KwqDCoMKgwqAga3ZtLT5hcmNoLm1tdS52bWlkLnZtaWRf Z2VuID0gMDsKwqDCoMKgwqAga3ZtLT5hcmNoLm1tdS5rdm0gPSBrdm07CsKgCivCoMKgwqAga3Zt X2luaXRfbmVzdGVkKGt2bSk7CisKCmt2bV9hbGxvY19zdGFnZTJfcGdkIGVuZHMgdXAgY2FsbGlu ZyBrdm1faW5pdF9zMl9tbXUgZm9yIGt2bS0+YXJjaC5tbXUuCmt2bV9pbml0X25lc3RlZCBkb2Vz IHRoZSBzYW1lIHRoaW5nLCBhbmQgd2UgZW5kIHVwIGNhbGxpbmcga3ZtX2luaXRfczJfbW11IGZv cgprdm0tPmFyY2gubW11IHR3aWNlLiBUaGVyZSdzIHJlYWxseSBubyBoYXJtIGluIGRvaW5nIGl0 IHR3aWNlLCBidXQgSSB0aG91Z2h0IEkKY291bGQgbWVudGlvbiBpdCBiZWNhdXNlIGl0IGxvb2tz IHRvIG1lIHRoYXQgdGhlIGZpeCBpcyBzaW1wbGU6IHJlbW92ZSB0aGUKa3ZtX2luaXRfczJfbW11 IGNhbGwgZnJvbSBrdm1faW5pdF9uZXN0ZWQuIFRoZSBkb3VibGUgaW5pdGlhbGl6YXRpb24gaXMg YWxzbwp0cnVlIGZvciB0aGUgdGlwIG9mIHRoZSBzZXJpZXMuCgpUaGFua3MsCgpBbGV4Cgo+ICsK PiAgCXJldCA9IGNyZWF0ZV9oeXBfbWFwcGluZ3Moa3ZtLCBrdm0gKyAxLCBQQUdFX0hZUCk7Cj4g IAlpZiAocmV0KQo+ICAJCWdvdG8gb3V0X2ZyZWVfc3RhZ2UyX3BnZDsKPiBAQCAtMzUzLDYgKzM1 Niw5IEBAIHZvaWQga3ZtX2FyY2hfdmNwdV9sb2FkKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgaW50 IGNwdSkKPiAgCWludCAqbGFzdF9yYW47Cj4gIAlrdm1faG9zdF9kYXRhX3QgKmNwdV9kYXRhOwo+ ICAKPiArCWlmIChuZXN0ZWRfdmlydF9pbl91c2UodmNwdSkpCj4gKwkJa3ZtX3ZjcHVfbG9hZF9o d19tbXUodmNwdSk7Cj4gKwo+ICAJbGFzdF9yYW4gPSB0aGlzX2NwdV9wdHIodmNwdS0+a3ZtLT5h cmNoLmxhc3RfdmNwdV9yYW4pOwo+ICAJY3B1X2RhdGEgPSB0aGlzX2NwdV9wdHIoJmt2bV9ob3N0 X2RhdGEpOwo+ICAKPiBAQCAtMzkxLDYgKzM5Nyw5IEBAIHZvaWQga3ZtX2FyY2hfdmNwdV9wdXQo c3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ICAJa3ZtX3ZnaWNfcHV0KHZjcHUpOwo+ICAJa3ZtX3Zj cHVfcG11X3Jlc3RvcmVfaG9zdCh2Y3B1KTsKPiAgCj4gKwlpZiAobmVzdGVkX3ZpcnRfaW5fdXNl KHZjcHUpKQo+ICsJCWt2bV92Y3B1X3B1dF9od19tbXUodmNwdSk7Cj4gKwo+ICAJdmNwdS0+Y3B1 ID0gLTE7Cj4gIAo+ICAJa3ZtX2FybV9zZXRfcnVubmluZ192Y3B1KE5VTEwpOwo+IEBAIC05Njgs OCArOTc3LDEzIEBAIHN0YXRpYyBpbnQga3ZtX3ZjcHVfc2V0X3RhcmdldChzdHJ1Y3Qga3ZtX3Zj cHUgKnZjcHUsCj4gIAo+ICAJdmNwdS0+YXJjaC50YXJnZXQgPSBwaHlzX3RhcmdldDsKPiAgCj4g KwkvKiBQcmVwYXJlIGZvciBuZXN0ZWQgaWYgcmVxdWlyZWQgKi8KPiArCXJldCA9IGt2bV92Y3B1 X2luaXRfbmVzdGVkKHZjcHUpOwo+ICsKPiAgCS8qIE5vdyB3ZSBrbm93IHdoYXQgaXQgaXMsIHdl IGNhbiByZXNldCBpdC4gKi8KPiAtCXJldCA9IGt2bV9yZXNldF92Y3B1KHZjcHUpOwo+ICsJaWYg KCFyZXQpCj4gKwkJcmV0ID0ga3ZtX3Jlc2V0X3ZjcHUodmNwdSk7Cj4gKwo+ICAJaWYgKHJldCkg ewo+ICAJCXZjcHUtPmFyY2gudGFyZ2V0ID0gLTE7Cj4gIAkJYml0bWFwX3plcm8odmNwdS0+YXJj aC5mZWF0dXJlcywgS1ZNX1ZDUFVfTUFYX0ZFQVRVUkVTKTsKPiBkaWZmIC0tZ2l0IGEvdmlydC9r dm0vYXJtL21tdS5jIGIvdmlydC9rdm0vYXJtL21tdS5jCj4gaW5kZXggYmIxYmU0ZWE1NWVjLi5m YWE2MWE4MWM4Y2MgMTAwNjQ0Cj4gLS0tIGEvdmlydC9rdm0vYXJtL21tdS5jCj4gKysrIGIvdmly dC9rdm0vYXJtL21tdS5jCj4gQEAgLTMyNSw3ICszMjUsNyBAQCBzdGF0aWMgdm9pZCB1bm1hcF9z dGFnZTJfcHVkcyhzdHJ1Y3Qga3ZtX3MyX21tdSAqbW11LCBwZ2RfdCAqcGdkLAo+ICB9Cj4gIAo+ ICAvKioKPiAtICogdW5tYXBfc3RhZ2UyX3JhbmdlIC0tIENsZWFyIHN0YWdlMiBwYWdlIHRhYmxl IGVudHJpZXMgdG8gdW5tYXAgYSByYW5nZQo+ICsgKiBrdm1fdW5tYXBfc3RhZ2UyX3JhbmdlIC0t IENsZWFyIHN0YWdlMiBwYWdlIHRhYmxlIGVudHJpZXMgdG8gdW5tYXAgYSByYW5nZQo+ICAgKiBA a3ZtOiAgIFRoZSBWTSBwb2ludGVyCj4gICAqIEBzdGFydDogVGhlIGludGVybWVkaWF0ZSBwaHlz aWNhbCBiYXNlIGFkZHJlc3Mgb2YgdGhlIHJhbmdlIHRvIHVubWFwCj4gICAqIEBzaXplOiAgVGhl IHNpemUgb2YgdGhlIGFyZWEgdG8gdW5tYXAKPiBAQCAtMzM1LDcgKzMzNSw3IEBAIHN0YXRpYyB2 b2lkIHVubWFwX3N0YWdlMl9wdWRzKHN0cnVjdCBrdm1fczJfbW11ICptbXUsIHBnZF90ICpwZ2Qs Cj4gICAqIGRlc3Ryb3lpbmcgdGhlIFZNKSwgb3RoZXJ3aXNlIGFub3RoZXIgZmF1bHRpbmcgVkNQ VSBtYXkgY29tZSBpbiBhbmQgbWVzcwo+ICAgKiB3aXRoIHRoaW5ncyBiZWhpbmQgb3VyIGJhY2tz Lgo+ICAgKi8KPiAtc3RhdGljIHZvaWQgdW5tYXBfc3RhZ2UyX3JhbmdlKHN0cnVjdCBrdm1fczJf bW11ICptbXUsIHBoeXNfYWRkcl90IHN0YXJ0LCB1NjQgc2l6ZSkKPiArdm9pZCBrdm1fdW5tYXBf c3RhZ2UyX3JhbmdlKHN0cnVjdCBrdm1fczJfbW11ICptbXUsIHBoeXNfYWRkcl90IHN0YXJ0LCB1 NjQgc2l6ZSkKPiAgewo+ICAJc3RydWN0IGt2bSAqa3ZtID0gbW11LT5rdm07Cj4gIAlwZ2RfdCAq cGdkOwo+IEBAIC05MjQsNiArOTI0LDEwIEBAIGludCBrdm1fYWxsb2Nfc3RhZ2UyX3BnZChzdHJ1 Y3Qga3ZtX3MyX21tdSAqbW11KQo+ICAKPiAgCW1tdS0+cGdkID0gcGdkOwo+ICAJbW11LT5wZ2Rf cGh5cyA9IHBnZF9waHlzOwo+ICsJbW11LT52bWlkLnZtaWRfZ2VuID0gMDsKPiArCj4gKwlrdm1f aW5pdF9zMl9tbXUobW11KTsKPiArCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAKPiBAQCAtOTYyLDcg Kzk2Niw3IEBAIHN0YXRpYyB2b2lkIHN0YWdlMl91bm1hcF9tZW1zbG90KHN0cnVjdCBrdm0gKmt2 bSwKPiAgCj4gIAkJaWYgKCEodm1hLT52bV9mbGFncyAmIFZNX1BGTk1BUCkpIHsKPiAgCQkJZ3Bh X3QgZ3BhID0gYWRkciArICh2bV9zdGFydCAtIG1lbXNsb3QtPnVzZXJzcGFjZV9hZGRyKTsKPiAt CQkJdW5tYXBfc3RhZ2UyX3JhbmdlKCZrdm0tPmFyY2gubW11LCBncGEsIHZtX2VuZCAtIHZtX3N0 YXJ0KTsKPiArCQkJa3ZtX3VubWFwX3N0YWdlMl9yYW5nZSgma3ZtLT5hcmNoLm1tdSwgZ3BhLCB2 bV9lbmQgLSB2bV9zdGFydCk7Cj4gIAkJfQo+ICAJCWh2YSA9IHZtX2VuZDsKPiAgCX0gd2hpbGUg KGh2YSA8IHJlZ19lbmQpOwo+IEBAIC0xMDAxLDcgKzEwMDUsNyBAQCB2b2lkIGt2bV9mcmVlX3N0 YWdlMl9wZ2Qoc3RydWN0IGt2bV9zMl9tbXUgKm1tdSkKPiAgCj4gIAlzcGluX2xvY2soJmt2bS0+ bW11X2xvY2spOwo+ICAJaWYgKG1tdS0+cGdkKSB7Cj4gLQkJdW5tYXBfc3RhZ2UyX3JhbmdlKG1t dSwgMCwga3ZtX3BoeXNfc2l6ZShrdm0pKTsKPiArCQlrdm1fdW5tYXBfc3RhZ2UyX3JhbmdlKG1t dSwgMCwga3ZtX3BoeXNfc2l6ZShrdm0pKTsKPiAgCQlwZ2QgPSBSRUFEX09OQ0UobW11LT5wZ2Qp Owo+ICAJCW1tdS0+cGdkID0gTlVMTDsKPiAgCX0KPiBAQCAtMTA5Myw3ICsxMDk3LDcgQEAgc3Rh dGljIGludCBzdGFnZTJfc2V0X3BtZF9odWdlKHN0cnVjdCBrdm1fczJfbW11ICptbXUsCj4gIAkJ ICogZ2V0IGhhbmRsZWQgYWNjb3JkaW5nbHkuCj4gIAkJICovCj4gIAkJaWYgKCFwbWRfdGhwX29y X2h1Z2Uob2xkX3BtZCkpIHsKPiAtCQkJdW5tYXBfc3RhZ2UyX3JhbmdlKG1tdSwgYWRkciAmIFMy X1BNRF9NQVNLLCBTMl9QTURfU0laRSk7Cj4gKwkJCWt2bV91bm1hcF9zdGFnZTJfcmFuZ2UobW11 LCBhZGRyICYgUzJfUE1EX01BU0ssIFMyX1BNRF9TSVpFKTsKPiAgCQkJZ290byByZXRyeTsKPiAg CQl9Cj4gIAkJLyoKPiBAQCAtMTE0NSw3ICsxMTQ5LDcgQEAgc3RhdGljIGludCBzdGFnZTJfc2V0 X3B1ZF9odWdlKHN0cnVjdCBrdm1fczJfbW11ICptbXUsCj4gIAkJICogdGhlIHJhbmdlIGZvciB0 aGlzIGJsb2NrIGFuZCByZXRyeS4KPiAgCQkgKi8KPiAgCQlpZiAoIXN0YWdlMl9wdWRfaHVnZShr dm0sIG9sZF9wdWQpKSB7Cj4gLQkJCXVubWFwX3N0YWdlMl9yYW5nZShtbXUsIGFkZHIgJiBTMl9Q VURfTUFTSywgUzJfUFVEX1NJWkUpOwo+ICsJCQlrdm1fdW5tYXBfc3RhZ2UyX3JhbmdlKG1tdSwg YWRkciAmIFMyX1BVRF9NQVNLLCBTMl9QVURfU0laRSk7Cj4gIAkJCWdvdG8gcmV0cnk7Cj4gIAkJ fQo+ICAKPiBAQCAtMjA0Nyw3ICsyMDUxLDcgQEAgc3RhdGljIGludCBoYW5kbGVfaHZhX3RvX2dw YShzdHJ1Y3Qga3ZtICprdm0sCj4gIAo+ICBzdGF0aWMgaW50IGt2bV91bm1hcF9odmFfaGFuZGxl cihzdHJ1Y3Qga3ZtICprdm0sIGdwYV90IGdwYSwgdTY0IHNpemUsIHZvaWQgKmRhdGEpCj4gIHsK PiAtCXVubWFwX3N0YWdlMl9yYW5nZSgma3ZtLT5hcmNoLm1tdSwgZ3BhLCBzaXplKTsKPiArCWt2 bV91bm1hcF9zdGFnZTJfcmFuZ2UoJmt2bS0+YXJjaC5tbXUsIGdwYSwgc2l6ZSk7Cj4gIAlyZXR1 cm4gMDsKPiAgfQo+ICAKPiBAQCAtMjM2MCw3ICsyMzY0LDcgQEAgaW50IGt2bV9hcmNoX3ByZXBh cmVfbWVtb3J5X3JlZ2lvbihzdHJ1Y3Qga3ZtICprdm0sCj4gIAo+ICAJc3Bpbl9sb2NrKCZrdm0t Pm1tdV9sb2NrKTsKPiAgCWlmIChyZXQpCj4gLQkJdW5tYXBfc3RhZ2UyX3JhbmdlKCZrdm0tPmFy Y2gubW11LCBtZW0tPmd1ZXN0X3BoeXNfYWRkciwgbWVtLT5tZW1vcnlfc2l6ZSk7Cj4gKwkJa3Zt X3VubWFwX3N0YWdlMl9yYW5nZSgma3ZtLT5hcmNoLm1tdSwgbWVtLT5ndWVzdF9waHlzX2FkZHIs IG1lbS0+bWVtb3J5X3NpemUpOwo+ICAJZWxzZQo+ICAJCXN0YWdlMl9mbHVzaF9tZW1zbG90KCZr dm0tPmFyY2gubW11LCBtZW1zbG90KTsKPiAgCXNwaW5fdW5sb2NrKCZrdm0tPm1tdV9sb2NrKTsK PiBAQCAtMjM4NCwxMSArMjM4OCw2IEBAIHZvaWQga3ZtX2FyY2hfbWVtc2xvdHNfdXBkYXRlZChz dHJ1Y3Qga3ZtICprdm0sIHU2NCBnZW4pCj4gIHsKPiAgfQo+ICAKPiAtdm9pZCBrdm1fYXJjaF9m bHVzaF9zaGFkb3dfYWxsKHN0cnVjdCBrdm0gKmt2bSkKPiAtewo+IC0Ja3ZtX2ZyZWVfc3RhZ2Uy X3BnZCgma3ZtLT5hcmNoLm1tdSk7Cj4gLX0KPiAtCj4gIHZvaWQga3ZtX2FyY2hfZmx1c2hfc2hh ZG93X21lbXNsb3Qoc3RydWN0IGt2bSAqa3ZtLAo+ICAJCQkJICAgc3RydWN0IGt2bV9tZW1vcnlf c2xvdCAqc2xvdCkKPiAgewo+IEBAIC0yMzk2LDcgKzIzOTUsNyBAQCB2b2lkIGt2bV9hcmNoX2Zs dXNoX3NoYWRvd19tZW1zbG90KHN0cnVjdCBrdm0gKmt2bSwKPiAgCXBoeXNfYWRkcl90IHNpemUg PSBzbG90LT5ucGFnZXMgPDwgUEFHRV9TSElGVDsKPiAgCj4gIAlzcGluX2xvY2soJmt2bS0+bW11 X2xvY2spOwo+IC0JdW5tYXBfc3RhZ2UyX3JhbmdlKCZrdm0tPmFyY2gubW11LCBncGEsIHNpemUp Owo+ICsJa3ZtX3VubWFwX3N0YWdlMl9yYW5nZSgma3ZtLT5hcmNoLm1tdSwgZ3BhLCBzaXplKTsK PiAgCXNwaW5fdW5sb2NrKCZrdm0tPm1tdV9sb2NrKTsKPiAgfQo+ICAKPiBAQCAtMjQ2NywzICsy NDY2LDcgQEAgdm9pZCBrdm1fdG9nZ2xlX2NhY2hlKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgYm9v bCB3YXNfZW5hYmxlZCkKPiAgCj4gIAl0cmFjZV9rdm1fdG9nZ2xlX2NhY2hlKCp2Y3B1X3BjKHZj cHUpLCB3YXNfZW5hYmxlZCwgbm93X2VuYWJsZWQpOwo+ICB9Cj4gKwo+ICtfX3dlYWsgdm9pZCBr dm1fYXJjaF9mbHVzaF9zaGFkb3dfYWxsKHN0cnVjdCBrdm0gKmt2bSkKPiArewo+ICt9CgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2Vy bmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0 cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVs Cg==