From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751467AbdCBWJO (ORCPT ); Thu, 2 Mar 2017 17:09:14 -0500 Received: from mx1.redhat.com ([209.132.183.28]:54560 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751185AbdCBWJM (ORCPT ); Thu, 2 Mar 2017 17:09:12 -0500 From: Vitaly Kuznetsov To: xen-devel@lists.xenproject.org Cc: x86@kernel.org, linux-kernel@vger.kernel.org, Boris Ostrovsky , Juergen Gross , Andrew Jones Subject: [PATCH v2 05/21] x86/xen: split off enlighten_hvm.c Date: Thu, 2 Mar 2017 18:53:41 +0100 Message-Id: <20170302175357.8222-6-vkuznets@redhat.com> In-Reply-To: <20170302175357.8222-1-vkuznets@redhat.com> References: <20170302175357.8222-1-vkuznets@redhat.com> X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.38]); Thu, 02 Mar 2017 17:54:09 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Move PVHVM related code to enlighten_hvm.c. Three functions: xen_cpuhp_setup(), xen_reboot(), xen_emergency_restart() are shared, drop static qualifier from them. These functions will go to common code once it is split from enlighten.c. Signed-off-by: Vitaly Kuznetsov --- arch/x86/xen/Makefile | 1 + arch/x86/xen/enlighten.c | 209 +----------------------------------------- arch/x86/xen/enlighten_hvm.c | 210 +++++++++++++++++++++++++++++++++++++++++++ arch/x86/xen/xen-ops.h | 6 ++ 4 files changed, 221 insertions(+), 205 deletions(-) create mode 100644 arch/x86/xen/enlighten_hvm.c diff --git a/arch/x86/xen/Makefile b/arch/x86/xen/Makefile index 348128b..1bca75b 100644 --- a/arch/x86/xen/Makefile +++ b/arch/x86/xen/Makefile @@ -15,6 +15,7 @@ obj-y := enlighten.o setup.o multicalls.o mmu.o irq.o \ grant-table.o suspend.o platform-pci-unplug.o \ p2m.o apic.o pmu.o +obj-$(CONFIG_XEN_PVHVM) += enlighten_hvm.o obj-$(CONFIG_XEN_PVH) += enlighten_pvh.o obj-$(CONFIG_EVENT_TRACING) += trace.o diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c index d66debd..0cd99ad 100644 --- a/arch/x86/xen/enlighten.c +++ b/arch/x86/xen/enlighten.c @@ -45,10 +45,8 @@ #include #include #include -#include #include #include -#include #include #include @@ -140,10 +138,8 @@ void *xen_initial_gdt; RESERVE_BRK(shared_info_page_brk, PAGE_SIZE); static int xen_cpu_up_prepare_pv(unsigned int cpu); -static int xen_cpu_up_prepare_hvm(unsigned int cpu); static int xen_cpu_up_online(unsigned int cpu); static int xen_cpu_dead_pv(unsigned int cpu); -static int xen_cpu_dead_hvm(unsigned int cpu); /* * Point at some empty memory to start with. We map the real shared_info @@ -1282,7 +1278,7 @@ static const struct pv_cpu_ops xen_cpu_ops __initconst = { .end_context_switch = xen_end_context_switch, }; -static void xen_reboot(int reason) +void xen_reboot(int reason) { struct sched_shutdown r = { .reason = reason }; int cpu; @@ -1299,7 +1295,7 @@ static void xen_restart(char *msg) xen_reboot(SHUTDOWN_reboot); } -static void xen_emergency_restart(void) +void xen_emergency_restart(void) { xen_reboot(SHUTDOWN_reboot); } @@ -1435,8 +1431,8 @@ static void __init xen_dom0_set_legacy_features(void) x86_platform.legacy.rtc = 1; } -static int xen_cpuhp_setup(int (*cpu_up_prepare_cb)(unsigned int), - int (*cpu_dead_cb)(unsigned int)) +int xen_cpuhp_setup(int (*cpu_up_prepare_cb)(unsigned int), + int (*cpu_dead_cb)(unsigned int)) { int rc; @@ -1660,79 +1656,6 @@ asmlinkage __visible void __init xen_start_kernel(void) #endif } -void __ref xen_hvm_init_shared_info(void) -{ - int cpu; - struct xen_add_to_physmap xatp; - static struct shared_info *shared_info_page = 0; - - if (!shared_info_page) - shared_info_page = (struct shared_info *) - extend_brk(PAGE_SIZE, PAGE_SIZE); - xatp.domid = DOMID_SELF; - xatp.idx = 0; - xatp.space = XENMAPSPACE_shared_info; - xatp.gpfn = __pa(shared_info_page) >> PAGE_SHIFT; - if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp)) - BUG(); - - HYPERVISOR_shared_info = (struct shared_info *)shared_info_page; - - /* xen_vcpu is a pointer to the vcpu_info struct in the shared_info - * page, we use it in the event channel upcall and in some pvclock - * related functions. We don't need the vcpu_info placement - * optimizations because we don't use any pv_mmu or pv_irq op on - * HVM. - * When xen_hvm_init_shared_info is run at boot time only vcpu 0 is - * online but xen_hvm_init_shared_info is run at resume time too and - * in that case multiple vcpus might be online. */ - for_each_online_cpu(cpu) { - /* Leave it to be NULL. */ - if (xen_vcpu_nr(cpu) >= MAX_VIRT_CPUS) - continue; - per_cpu(xen_vcpu, cpu) = - &HYPERVISOR_shared_info->vcpu_info[xen_vcpu_nr(cpu)]; - } -} - -#ifdef CONFIG_XEN_PVHVM -static void __init init_hvm_pv_info(void) -{ - int major, minor; - uint32_t eax, ebx, ecx, edx, base; - - base = xen_cpuid_base(); - eax = cpuid_eax(base + 1); - - major = eax >> 16; - minor = eax & 0xffff; - printk(KERN_INFO "Xen version %d.%d.\n", major, minor); - - xen_domain_type = XEN_HVM_DOMAIN; - - /* PVH set up hypercall page in xen_prepare_pvh(). */ - if (xen_pvh_domain()) - pv_info.name = "Xen PVH"; - else { - u64 pfn; - uint32_t msr; - - pv_info.name = "Xen HVM"; - msr = cpuid_ebx(base + 2); - pfn = __pa(hypercall_page); - wrmsr_safe(msr, (u32)pfn, (u32)(pfn >> 32)); - } - - xen_setup_features(); - - cpuid(base + 4, &eax, &ebx, &ecx, &edx); - if (eax & XEN_HVM_CPUID_VCPU_ID_PRESENT) - this_cpu_write(xen_vcpu_id, ebx); - else - this_cpu_write(xen_vcpu_id, smp_processor_id()); -} -#endif - static int xen_cpu_up_prepare_pv(unsigned int cpu) { int rc; @@ -1748,37 +1671,6 @@ static int xen_cpu_up_prepare_pv(unsigned int cpu) return 0; } -static int xen_cpu_up_prepare_hvm(unsigned int cpu) -{ - int rc; - - /* - * This can happen if CPU was offlined earlier and - * offlining timed out in common_cpu_die(). - */ - if (cpu_report_state(cpu) == CPU_DEAD_FROZEN) { - xen_smp_intr_free(cpu); - xen_uninit_lock_cpu(cpu); - } - - if (cpu_acpi_id(cpu) != U32_MAX) - per_cpu(xen_vcpu_id, cpu) = cpu_acpi_id(cpu); - else - per_cpu(xen_vcpu_id, cpu) = cpu; - xen_vcpu_setup(cpu); - - if (xen_feature(XENFEAT_hvm_safe_pvclock)) - xen_setup_timer(cpu); - - rc = xen_smp_intr_init(cpu); - if (rc) { - WARN(1, "xen_smp_intr_init() for CPU %d failed: %d\n", - cpu, rc); - return rc; - } - return 0; -} - static int xen_cpu_dead_pv(unsigned int cpu) { xen_smp_intr_free(cpu); @@ -1788,75 +1680,12 @@ static int xen_cpu_dead_pv(unsigned int cpu) return 0; } -static int xen_cpu_dead_hvm(unsigned int cpu) -{ - xen_smp_intr_free(cpu); - - if (xen_feature(XENFEAT_hvm_safe_pvclock)) - xen_teardown_timer(cpu); - - return 0; -} - static int xen_cpu_up_online(unsigned int cpu) { xen_init_lock_cpu(cpu); return 0; } -#ifdef CONFIG_XEN_PVHVM -#ifdef CONFIG_KEXEC_CORE -static void xen_hvm_shutdown(void) -{ - native_machine_shutdown(); - if (kexec_in_progress) - xen_reboot(SHUTDOWN_soft_reset); -} - -static void xen_hvm_crash_shutdown(struct pt_regs *regs) -{ - native_machine_crash_shutdown(regs); - xen_reboot(SHUTDOWN_soft_reset); -} -#endif - -static void __init xen_hvm_guest_init(void) -{ - if (xen_pv_domain()) - return; - - init_hvm_pv_info(); - - xen_hvm_init_shared_info(); - - xen_panic_handler_init(); - - BUG_ON(!xen_feature(XENFEAT_hvm_callback_vector)); - - xen_hvm_smp_init(); - WARN_ON(xen_cpuhp_setup(xen_cpu_up_prepare_hvm, xen_cpu_dead_hvm)); - xen_unplug_emulated_devices(); - x86_init.irqs.intr_init = xen_init_IRQ; - xen_hvm_init_time_ops(); - xen_hvm_init_mmu_ops(); - - if (xen_pvh_domain()) - machine_ops.emergency_restart = xen_emergency_restart; -#ifdef CONFIG_KEXEC_CORE - machine_ops.shutdown = xen_hvm_shutdown; - machine_ops.crash_shutdown = xen_hvm_crash_shutdown; -#endif -} -#endif - -static bool xen_nopv = false; -static __init int xen_parse_nopv(char *arg) -{ - xen_nopv = true; - return 0; -} -early_param("xen_nopv", xen_parse_nopv); - static uint32_t __init xen_platform_pv(void) { if (xen_pv_domain()) @@ -1865,28 +1694,6 @@ static uint32_t __init xen_platform_pv(void) return 0; } -static uint32_t __init xen_platform_hvm(void) -{ - if (xen_pv_domain() || xen_nopv) - return 0; - - return xen_cpuid_base(); -} - -bool xen_hvm_need_lapic(void) -{ - if (xen_nopv) - return false; - if (xen_pv_domain()) - return false; - if (!xen_hvm_domain()) - return false; - if (xen_feature(XENFEAT_hvm_pirqs)) - return false; - return true; -} -EXPORT_SYMBOL_GPL(xen_hvm_need_lapic); - static void xen_set_cpu_features(struct cpuinfo_x86 *c) { clear_cpu_bug(c, X86_BUG_SYSRET_SS_ATTRS); @@ -1940,14 +1747,6 @@ const struct hypervisor_x86 x86_hyper_xen_pv = { }; EXPORT_SYMBOL(x86_hyper_xen_pv); -const struct hypervisor_x86 x86_hyper_xen_hvm = { - .name = "Xen HVM", - .detect = xen_platform_hvm, - .init_platform = xen_hvm_guest_init, - .x2apic_available = xen_x2apic_para_available, -}; -EXPORT_SYMBOL(x86_hyper_xen_hvm); - #ifdef CONFIG_HOTPLUG_CPU void xen_arch_register_cpu(int num) { diff --git a/arch/x86/xen/enlighten_hvm.c b/arch/x86/xen/enlighten_hvm.c new file mode 100644 index 0000000..a8f4d7e --- /dev/null +++ b/arch/x86/xen/enlighten_hvm.c @@ -0,0 +1,210 @@ +#include +#include + +#include +#include +#include + +#include +#include +#include + +#include +#include + +#include "xen-ops.h" +#include "mmu.h" +#include "smp.h" + +void __ref xen_hvm_init_shared_info(void) +{ + int cpu; + struct xen_add_to_physmap xatp; + static struct shared_info *shared_info_page; + + if (!shared_info_page) + shared_info_page = (struct shared_info *) + extend_brk(PAGE_SIZE, PAGE_SIZE); + xatp.domid = DOMID_SELF; + xatp.idx = 0; + xatp.space = XENMAPSPACE_shared_info; + xatp.gpfn = __pa(shared_info_page) >> PAGE_SHIFT; + if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp)) + BUG(); + + HYPERVISOR_shared_info = (struct shared_info *)shared_info_page; + + /* xen_vcpu is a pointer to the vcpu_info struct in the shared_info + * page, we use it in the event channel upcall and in some pvclock + * related functions. We don't need the vcpu_info placement + * optimizations because we don't use any pv_mmu or pv_irq op on + * HVM. + * When xen_hvm_init_shared_info is run at boot time only vcpu 0 is + * online but xen_hvm_init_shared_info is run at resume time too and + * in that case multiple vcpus might be online. */ + for_each_online_cpu(cpu) { + /* Leave it to be NULL. */ + if (xen_vcpu_nr(cpu) >= MAX_VIRT_CPUS) + continue; + per_cpu(xen_vcpu, cpu) = + &HYPERVISOR_shared_info->vcpu_info[xen_vcpu_nr(cpu)]; + } +} + +static void __init init_hvm_pv_info(void) +{ + int major, minor; + uint32_t eax, ebx, ecx, edx, base; + + base = xen_cpuid_base(); + eax = cpuid_eax(base + 1); + + major = eax >> 16; + minor = eax & 0xffff; + printk(KERN_INFO "Xen version %d.%d.\n", major, minor); + + xen_domain_type = XEN_HVM_DOMAIN; + + /* PVH set up hypercall page in xen_prepare_pvh(). */ + if (xen_pvh_domain()) + pv_info.name = "Xen PVH"; + else { + u64 pfn; + uint32_t msr; + + pv_info.name = "Xen HVM"; + msr = cpuid_ebx(base + 2); + pfn = __pa(hypercall_page); + wrmsr_safe(msr, (u32)pfn, (u32)(pfn >> 32)); + } + + xen_setup_features(); + + cpuid(base + 4, &eax, &ebx, &ecx, &edx); + if (eax & XEN_HVM_CPUID_VCPU_ID_PRESENT) + this_cpu_write(xen_vcpu_id, ebx); + else + this_cpu_write(xen_vcpu_id, smp_processor_id()); +} + +#ifdef CONFIG_KEXEC_CORE +static void xen_hvm_shutdown(void) +{ + native_machine_shutdown(); + if (kexec_in_progress) + xen_reboot(SHUTDOWN_soft_reset); +} + +static void xen_hvm_crash_shutdown(struct pt_regs *regs) +{ + native_machine_crash_shutdown(regs); + xen_reboot(SHUTDOWN_soft_reset); +} +#endif + +static int xen_cpu_up_prepare_hvm(unsigned int cpu) +{ + int rc; + + /* + * This can happen if CPU was offlined earlier and + * offlining timed out in common_cpu_die(). + */ + if (cpu_report_state(cpu) == CPU_DEAD_FROZEN) { + xen_smp_intr_free(cpu); + xen_uninit_lock_cpu(cpu); + } + + if (cpu_acpi_id(cpu) != U32_MAX) + per_cpu(xen_vcpu_id, cpu) = cpu_acpi_id(cpu); + else + per_cpu(xen_vcpu_id, cpu) = cpu; + xen_vcpu_setup(cpu); + + if (xen_feature(XENFEAT_hvm_safe_pvclock)) + xen_setup_timer(cpu); + + rc = xen_smp_intr_init(cpu); + if (rc) { + WARN(1, "xen_smp_intr_init() for CPU %d failed: %d\n", + cpu, rc); + return rc; + } + return 0; +} + +static int xen_cpu_dead_hvm(unsigned int cpu) +{ + xen_smp_intr_free(cpu); + + if (xen_feature(XENFEAT_hvm_safe_pvclock)) + xen_teardown_timer(cpu); + + return 0; +} + +static void __init xen_hvm_guest_init(void) +{ + if (xen_pv_domain()) + return; + + init_hvm_pv_info(); + + xen_hvm_init_shared_info(); + + xen_panic_handler_init(); + + BUG_ON(!xen_feature(XENFEAT_hvm_callback_vector)); + + xen_hvm_smp_init(); + WARN_ON(xen_cpuhp_setup(xen_cpu_up_prepare_hvm, xen_cpu_dead_hvm)); + xen_unplug_emulated_devices(); + x86_init.irqs.intr_init = xen_init_IRQ; + xen_hvm_init_time_ops(); + xen_hvm_init_mmu_ops(); + + if (xen_pvh_domain()) + machine_ops.emergency_restart = xen_emergency_restart; +#ifdef CONFIG_KEXEC_CORE + machine_ops.shutdown = xen_hvm_shutdown; + machine_ops.crash_shutdown = xen_hvm_crash_shutdown; +#endif +} + +static bool xen_nopv; +static __init int xen_parse_nopv(char *arg) +{ + xen_nopv = true; + return 0; +} +early_param("xen_nopv", xen_parse_nopv); + +bool xen_hvm_need_lapic(void) +{ + if (xen_nopv) + return false; + if (xen_pv_domain()) + return false; + if (!xen_hvm_domain()) + return false; + if (xen_feature(XENFEAT_hvm_pirqs)) + return false; + return true; +} +EXPORT_SYMBOL_GPL(xen_hvm_need_lapic); + +static uint32_t __init xen_platform_hvm(void) +{ + if (xen_pv_domain() || xen_nopv) + return 0; + + return xen_cpuid_base(); +} + +const struct hypervisor_x86 x86_hyper_xen_hvm = { + .name = "Xen HVM", + .detect = xen_platform_hvm, + .init_platform = xen_hvm_guest_init, + .x2apic_available = xen_x2apic_para_available, +}; +EXPORT_SYMBOL(x86_hyper_xen_hvm); diff --git a/arch/x86/xen/xen-ops.h b/arch/x86/xen/xen-ops.h index 2b162f6..7baeb04 100644 --- a/arch/x86/xen/xen-ops.h +++ b/arch/x86/xen/xen-ops.h @@ -148,4 +148,10 @@ __visible void xen_adjust_exception_frame(void); extern int xen_panic_handler_init(void); +extern int xen_cpuhp_setup(int (*cpu_up_prepare_cb)(unsigned int), + int (*cpu_dead_cb)(unsigned int)); + +extern void xen_reboot(int reason); +extern void xen_emergency_restart(void); + #endif /* XEN_OPS_H */ -- 2.9.3 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Vitaly Kuznetsov Subject: [PATCH v2 05/21] x86/xen: split off enlighten_hvm.c Date: Thu, 2 Mar 2017 18:53:41 +0100 Message-ID: <20170302175357.8222-6-vkuznets@redhat.com> References: <20170302175357.8222-1-vkuznets@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail6.bemta6.messagelabs.com ([193.109.254.103]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1cjUvc-0003Qg-36 for xen-devel@lists.xenproject.org; Thu, 02 Mar 2017 17:54:12 +0000 In-Reply-To: <20170302175357.8222-1-vkuznets@redhat.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Boris Ostrovsky , x86@kernel.org, Andrew Jones , linux-kernel@vger.kernel.org List-Id: xen-devel@lists.xenproject.org TW92ZSBQVkhWTSByZWxhdGVkIGNvZGUgdG8gZW5saWdodGVuX2h2bS5jLiBUaHJlZSBmdW5jdGlv bnM6Cnhlbl9jcHVocF9zZXR1cCgpLCB4ZW5fcmVib290KCksIHhlbl9lbWVyZ2VuY3lfcmVzdGFy dCgpIGFyZSBzaGFyZWQsIGRyb3AKc3RhdGljIHF1YWxpZmllciBmcm9tIHRoZW0uIFRoZXNlIGZ1 bmN0aW9ucyB3aWxsIGdvIHRvIGNvbW1vbiBjb2RlIG9uY2UKaXQgaXMgc3BsaXQgZnJvbSBlbmxp Z2h0ZW4uYy4KClNpZ25lZC1vZmYtYnk6IFZpdGFseSBLdXpuZXRzb3YgPHZrdXpuZXRzQHJlZGhh dC5jb20+Ci0tLQogYXJjaC94ODYveGVuL01ha2VmaWxlICAgICAgICB8ICAgMSArCiBhcmNoL3g4 Ni94ZW4vZW5saWdodGVuLmMgICAgIHwgMjA5ICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLQogYXJjaC94ODYveGVuL2VubGlnaHRlbl9odm0uYyB8IDIxMCArKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBhcmNoL3g4Ni94ZW4veGVuLW9w cy5oICAgICAgIHwgICA2ICsrCiA0IGZpbGVzIGNoYW5nZWQsIDIyMSBpbnNlcnRpb25zKCspLCAy MDUgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgYXJjaC94ODYveGVuL2VubGlnaHRl bl9odm0uYwoKZGlmZiAtLWdpdCBhL2FyY2gveDg2L3hlbi9NYWtlZmlsZSBiL2FyY2gveDg2L3hl bi9NYWtlZmlsZQppbmRleCAzNDgxMjhiLi4xYmNhNzViIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni94 ZW4vTWFrZWZpbGUKKysrIGIvYXJjaC94ODYveGVuL01ha2VmaWxlCkBAIC0xNSw2ICsxNSw3IEBA IG9iai15CQk6PSBlbmxpZ2h0ZW4ubyBzZXR1cC5vIG11bHRpY2FsbHMubyBtbXUubyBpcnEubyBc CiAJCQlncmFudC10YWJsZS5vIHN1c3BlbmQubyBwbGF0Zm9ybS1wY2ktdW5wbHVnLm8gXAogCQkJ cDJtLm8gYXBpYy5vIHBtdS5vCiAKK29iai0kKENPTkZJR19YRU5fUFZIVk0pCQkrPSBlbmxpZ2h0 ZW5faHZtLm8KIG9iai0kKENPTkZJR19YRU5fUFZIKQkJCSs9IGVubGlnaHRlbl9wdmgubwogCiBv YmotJChDT05GSUdfRVZFTlRfVFJBQ0lORykgKz0gdHJhY2UubwpkaWZmIC0tZ2l0IGEvYXJjaC94 ODYveGVuL2VubGlnaHRlbi5jIGIvYXJjaC94ODYveGVuL2VubGlnaHRlbi5jCmluZGV4IGQ2NmRl YmQuLjBjZDk5YWQgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L3hlbi9lbmxpZ2h0ZW4uYworKysgYi9h cmNoL3g4Ni94ZW4vZW5saWdodGVuLmMKQEAgLTQ1LDEwICs0NSw4IEBACiAjaW5jbHVkZSA8eGVu L2ludGVyZmFjZS9tZW1vcnkuaD4KICNpbmNsdWRlIDx4ZW4vaW50ZXJmYWNlL25taS5oPgogI2lu Y2x1ZGUgPHhlbi9pbnRlcmZhY2UveGVuLW1jYS5oPgotI2luY2x1ZGUgPHhlbi9pbnRlcmZhY2Uv aHZtL3N0YXJ0X2luZm8uaD4KICNpbmNsdWRlIDx4ZW4vZmVhdHVyZXMuaD4KICNpbmNsdWRlIDx4 ZW4vcGFnZS5oPgotI2luY2x1ZGUgPHhlbi9odm0uaD4KICNpbmNsdWRlIDx4ZW4vaHZjLWNvbnNv bGUuaD4KICNpbmNsdWRlIDx4ZW4vYWNwaS5oPgogCkBAIC0xNDAsMTAgKzEzOCw4IEBAIHZvaWQg Knhlbl9pbml0aWFsX2dkdDsKIFJFU0VSVkVfQlJLKHNoYXJlZF9pbmZvX3BhZ2VfYnJrLCBQQUdF X1NJWkUpOwogCiBzdGF0aWMgaW50IHhlbl9jcHVfdXBfcHJlcGFyZV9wdih1bnNpZ25lZCBpbnQg Y3B1KTsKLXN0YXRpYyBpbnQgeGVuX2NwdV91cF9wcmVwYXJlX2h2bSh1bnNpZ25lZCBpbnQgY3B1 KTsKIHN0YXRpYyBpbnQgeGVuX2NwdV91cF9vbmxpbmUodW5zaWduZWQgaW50IGNwdSk7CiBzdGF0 aWMgaW50IHhlbl9jcHVfZGVhZF9wdih1bnNpZ25lZCBpbnQgY3B1KTsKLXN0YXRpYyBpbnQgeGVu X2NwdV9kZWFkX2h2bSh1bnNpZ25lZCBpbnQgY3B1KTsKIAogLyoKICAqIFBvaW50IGF0IHNvbWUg ZW1wdHkgbWVtb3J5IHRvIHN0YXJ0IHdpdGguIFdlIG1hcCB0aGUgcmVhbCBzaGFyZWRfaW5mbwpA QCAtMTI4Miw3ICsxMjc4LDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBwdl9jcHVfb3BzIHhlbl9j cHVfb3BzIF9faW5pdGNvbnN0ID0gewogCS5lbmRfY29udGV4dF9zd2l0Y2ggPSB4ZW5fZW5kX2Nv bnRleHRfc3dpdGNoLAogfTsKIAotc3RhdGljIHZvaWQgeGVuX3JlYm9vdChpbnQgcmVhc29uKQor dm9pZCB4ZW5fcmVib290KGludCByZWFzb24pCiB7CiAJc3RydWN0IHNjaGVkX3NodXRkb3duIHIg PSB7IC5yZWFzb24gPSByZWFzb24gfTsKIAlpbnQgY3B1OwpAQCAtMTI5OSw3ICsxMjk1LDcgQEAg c3RhdGljIHZvaWQgeGVuX3Jlc3RhcnQoY2hhciAqbXNnKQogCXhlbl9yZWJvb3QoU0hVVERPV05f cmVib290KTsKIH0KIAotc3RhdGljIHZvaWQgeGVuX2VtZXJnZW5jeV9yZXN0YXJ0KHZvaWQpCit2 b2lkIHhlbl9lbWVyZ2VuY3lfcmVzdGFydCh2b2lkKQogewogCXhlbl9yZWJvb3QoU0hVVERPV05f cmVib290KTsKIH0KQEAgLTE0MzUsOCArMTQzMSw4IEBAIHN0YXRpYyB2b2lkIF9faW5pdCB4ZW5f ZG9tMF9zZXRfbGVnYWN5X2ZlYXR1cmVzKHZvaWQpCiAJeDg2X3BsYXRmb3JtLmxlZ2FjeS5ydGMg PSAxOwogfQogCi1zdGF0aWMgaW50IHhlbl9jcHVocF9zZXR1cChpbnQgKCpjcHVfdXBfcHJlcGFy ZV9jYikodW5zaWduZWQgaW50KSwKLQkJCSAgIGludCAoKmNwdV9kZWFkX2NiKSh1bnNpZ25lZCBp bnQpKQoraW50IHhlbl9jcHVocF9zZXR1cChpbnQgKCpjcHVfdXBfcHJlcGFyZV9jYikodW5zaWdu ZWQgaW50KSwKKwkJICAgIGludCAoKmNwdV9kZWFkX2NiKSh1bnNpZ25lZCBpbnQpKQogewogCWlu dCByYzsKIApAQCAtMTY2MCw3OSArMTY1Niw2IEBAIGFzbWxpbmthZ2UgX192aXNpYmxlIHZvaWQg X19pbml0IHhlbl9zdGFydF9rZXJuZWwodm9pZCkKICNlbmRpZgogfQogCi12b2lkIF9fcmVmIHhl bl9odm1faW5pdF9zaGFyZWRfaW5mbyh2b2lkKQotewotCWludCBjcHU7Ci0Jc3RydWN0IHhlbl9h ZGRfdG9fcGh5c21hcCB4YXRwOwotCXN0YXRpYyBzdHJ1Y3Qgc2hhcmVkX2luZm8gKnNoYXJlZF9p bmZvX3BhZ2UgPSAwOwotCi0JaWYgKCFzaGFyZWRfaW5mb19wYWdlKQotCQlzaGFyZWRfaW5mb19w YWdlID0gKHN0cnVjdCBzaGFyZWRfaW5mbyAqKQotCQkJZXh0ZW5kX2JyayhQQUdFX1NJWkUsIFBB R0VfU0laRSk7Ci0JeGF0cC5kb21pZCA9IERPTUlEX1NFTEY7Ci0JeGF0cC5pZHggPSAwOwotCXhh dHAuc3BhY2UgPSBYRU5NQVBTUEFDRV9zaGFyZWRfaW5mbzsKLQl4YXRwLmdwZm4gPSBfX3BhKHNo YXJlZF9pbmZvX3BhZ2UpID4+IFBBR0VfU0hJRlQ7Ci0JaWYgKEhZUEVSVklTT1JfbWVtb3J5X29w KFhFTk1FTV9hZGRfdG9fcGh5c21hcCwgJnhhdHApKQotCQlCVUcoKTsKLQotCUhZUEVSVklTT1Jf c2hhcmVkX2luZm8gPSAoc3RydWN0IHNoYXJlZF9pbmZvICopc2hhcmVkX2luZm9fcGFnZTsKLQot CS8qIHhlbl92Y3B1IGlzIGEgcG9pbnRlciB0byB0aGUgdmNwdV9pbmZvIHN0cnVjdCBpbiB0aGUg c2hhcmVkX2luZm8KLQkgKiBwYWdlLCB3ZSB1c2UgaXQgaW4gdGhlIGV2ZW50IGNoYW5uZWwgdXBj YWxsIGFuZCBpbiBzb21lIHB2Y2xvY2sKLQkgKiByZWxhdGVkIGZ1bmN0aW9ucy4gV2UgZG9uJ3Qg bmVlZCB0aGUgdmNwdV9pbmZvIHBsYWNlbWVudAotCSAqIG9wdGltaXphdGlvbnMgYmVjYXVzZSB3 ZSBkb24ndCB1c2UgYW55IHB2X21tdSBvciBwdl9pcnEgb3Agb24KLQkgKiBIVk0uCi0JICogV2hl biB4ZW5faHZtX2luaXRfc2hhcmVkX2luZm8gaXMgcnVuIGF0IGJvb3QgdGltZSBvbmx5IHZjcHUg MCBpcwotCSAqIG9ubGluZSBidXQgeGVuX2h2bV9pbml0X3NoYXJlZF9pbmZvIGlzIHJ1biBhdCBy ZXN1bWUgdGltZSB0b28gYW5kCi0JICogaW4gdGhhdCBjYXNlIG11bHRpcGxlIHZjcHVzIG1pZ2h0 IGJlIG9ubGluZS4gKi8KLQlmb3JfZWFjaF9vbmxpbmVfY3B1KGNwdSkgewotCQkvKiBMZWF2ZSBp dCB0byBiZSBOVUxMLiAqLwotCQlpZiAoeGVuX3ZjcHVfbnIoY3B1KSA+PSBNQVhfVklSVF9DUFVT KQotCQkJY29udGludWU7Ci0JCXBlcl9jcHUoeGVuX3ZjcHUsIGNwdSkgPQotCQkJJkhZUEVSVklT T1Jfc2hhcmVkX2luZm8tPnZjcHVfaW5mb1t4ZW5fdmNwdV9ucihjcHUpXTsKLQl9Ci19Ci0KLSNp ZmRlZiBDT05GSUdfWEVOX1BWSFZNCi1zdGF0aWMgdm9pZCBfX2luaXQgaW5pdF9odm1fcHZfaW5m byh2b2lkKQotewotCWludCBtYWpvciwgbWlub3I7Ci0JdWludDMyX3QgZWF4LCBlYngsIGVjeCwg ZWR4LCBiYXNlOwotCi0JYmFzZSA9IHhlbl9jcHVpZF9iYXNlKCk7Ci0JZWF4ID0gY3B1aWRfZWF4 KGJhc2UgKyAxKTsKLQotCW1ham9yID0gZWF4ID4+IDE2OwotCW1pbm9yID0gZWF4ICYgMHhmZmZm OwotCXByaW50ayhLRVJOX0lORk8gIlhlbiB2ZXJzaW9uICVkLiVkLlxuIiwgbWFqb3IsIG1pbm9y KTsKLQotCXhlbl9kb21haW5fdHlwZSA9IFhFTl9IVk1fRE9NQUlOOwotCi0JLyogUFZIIHNldCB1 cCBoeXBlcmNhbGwgcGFnZSBpbiB4ZW5fcHJlcGFyZV9wdmgoKS4gKi8KLQlpZiAoeGVuX3B2aF9k b21haW4oKSkKLQkJcHZfaW5mby5uYW1lID0gIlhlbiBQVkgiOwotCWVsc2UgewotCQl1NjQgcGZu OwotCQl1aW50MzJfdCBtc3I7Ci0KLQkJcHZfaW5mby5uYW1lID0gIlhlbiBIVk0iOwotCQltc3Ig PSBjcHVpZF9lYngoYmFzZSArIDIpOwotCQlwZm4gPSBfX3BhKGh5cGVyY2FsbF9wYWdlKTsKLQkJ d3Jtc3Jfc2FmZShtc3IsICh1MzIpcGZuLCAodTMyKShwZm4gPj4gMzIpKTsKLQl9Ci0KLQl4ZW5f c2V0dXBfZmVhdHVyZXMoKTsKLQotCWNwdWlkKGJhc2UgKyA0LCAmZWF4LCAmZWJ4LCAmZWN4LCAm ZWR4KTsKLQlpZiAoZWF4ICYgWEVOX0hWTV9DUFVJRF9WQ1BVX0lEX1BSRVNFTlQpCi0JCXRoaXNf Y3B1X3dyaXRlKHhlbl92Y3B1X2lkLCBlYngpOwotCWVsc2UKLQkJdGhpc19jcHVfd3JpdGUoeGVu X3ZjcHVfaWQsIHNtcF9wcm9jZXNzb3JfaWQoKSk7Ci19Ci0jZW5kaWYKLQogc3RhdGljIGludCB4 ZW5fY3B1X3VwX3ByZXBhcmVfcHYodW5zaWduZWQgaW50IGNwdSkKIHsKIAlpbnQgcmM7CkBAIC0x NzQ4LDM3ICsxNjcxLDYgQEAgc3RhdGljIGludCB4ZW5fY3B1X3VwX3ByZXBhcmVfcHYodW5zaWdu ZWQgaW50IGNwdSkKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCB4ZW5fY3B1X3VwX3ByZXBh cmVfaHZtKHVuc2lnbmVkIGludCBjcHUpCi17Ci0JaW50IHJjOwotCi0JLyoKLQkgKiBUaGlzIGNh biBoYXBwZW4gaWYgQ1BVIHdhcyBvZmZsaW5lZCBlYXJsaWVyIGFuZAotCSAqIG9mZmxpbmluZyB0 aW1lZCBvdXQgaW4gY29tbW9uX2NwdV9kaWUoKS4KLQkgKi8KLQlpZiAoY3B1X3JlcG9ydF9zdGF0 ZShjcHUpID09IENQVV9ERUFEX0ZST1pFTikgewotCQl4ZW5fc21wX2ludHJfZnJlZShjcHUpOwot CQl4ZW5fdW5pbml0X2xvY2tfY3B1KGNwdSk7Ci0JfQotCi0JaWYgKGNwdV9hY3BpX2lkKGNwdSkg IT0gVTMyX01BWCkKLQkJcGVyX2NwdSh4ZW5fdmNwdV9pZCwgY3B1KSA9IGNwdV9hY3BpX2lkKGNw dSk7Ci0JZWxzZQotCQlwZXJfY3B1KHhlbl92Y3B1X2lkLCBjcHUpID0gY3B1OwotCXhlbl92Y3B1 X3NldHVwKGNwdSk7Ci0KLQlpZiAoeGVuX2ZlYXR1cmUoWEVORkVBVF9odm1fc2FmZV9wdmNsb2Nr KSkKLQkJeGVuX3NldHVwX3RpbWVyKGNwdSk7Ci0KLQlyYyA9IHhlbl9zbXBfaW50cl9pbml0KGNw dSk7Ci0JaWYgKHJjKSB7Ci0JCVdBUk4oMSwgInhlbl9zbXBfaW50cl9pbml0KCkgZm9yIENQVSAl ZCBmYWlsZWQ6ICVkXG4iLAotCQkgICAgIGNwdSwgcmMpOwotCQlyZXR1cm4gcmM7Ci0JfQotCXJl dHVybiAwOwotfQotCiBzdGF0aWMgaW50IHhlbl9jcHVfZGVhZF9wdih1bnNpZ25lZCBpbnQgY3B1 KQogewogCXhlbl9zbXBfaW50cl9mcmVlKGNwdSk7CkBAIC0xNzg4LDc1ICsxNjgwLDEyIEBAIHN0 YXRpYyBpbnQgeGVuX2NwdV9kZWFkX3B2KHVuc2lnbmVkIGludCBjcHUpCiAJcmV0dXJuIDA7CiB9 CiAKLXN0YXRpYyBpbnQgeGVuX2NwdV9kZWFkX2h2bSh1bnNpZ25lZCBpbnQgY3B1KQotewotCXhl bl9zbXBfaW50cl9mcmVlKGNwdSk7Ci0KLQlpZiAoeGVuX2ZlYXR1cmUoWEVORkVBVF9odm1fc2Fm ZV9wdmNsb2NrKSkKLQkJeGVuX3RlYXJkb3duX3RpbWVyKGNwdSk7Ci0KLSAgICAgICByZXR1cm4g MDsKLX0KLQogc3RhdGljIGludCB4ZW5fY3B1X3VwX29ubGluZSh1bnNpZ25lZCBpbnQgY3B1KQog ewogCXhlbl9pbml0X2xvY2tfY3B1KGNwdSk7CiAJcmV0dXJuIDA7CiB9CiAKLSNpZmRlZiBDT05G SUdfWEVOX1BWSFZNCi0jaWZkZWYgQ09ORklHX0tFWEVDX0NPUkUKLXN0YXRpYyB2b2lkIHhlbl9o dm1fc2h1dGRvd24odm9pZCkKLXsKLQluYXRpdmVfbWFjaGluZV9zaHV0ZG93bigpOwotCWlmIChr ZXhlY19pbl9wcm9ncmVzcykKLQkJeGVuX3JlYm9vdChTSFVURE9XTl9zb2Z0X3Jlc2V0KTsKLX0K LQotc3RhdGljIHZvaWQgeGVuX2h2bV9jcmFzaF9zaHV0ZG93bihzdHJ1Y3QgcHRfcmVncyAqcmVn cykKLXsKLQluYXRpdmVfbWFjaGluZV9jcmFzaF9zaHV0ZG93bihyZWdzKTsKLQl4ZW5fcmVib290 KFNIVVRET1dOX3NvZnRfcmVzZXQpOwotfQotI2VuZGlmCi0KLXN0YXRpYyB2b2lkIF9faW5pdCB4 ZW5faHZtX2d1ZXN0X2luaXQodm9pZCkKLXsKLQlpZiAoeGVuX3B2X2RvbWFpbigpKQotCQlyZXR1 cm47Ci0KLQlpbml0X2h2bV9wdl9pbmZvKCk7Ci0KLQl4ZW5faHZtX2luaXRfc2hhcmVkX2luZm8o KTsKLQotCXhlbl9wYW5pY19oYW5kbGVyX2luaXQoKTsKLQotCUJVR19PTigheGVuX2ZlYXR1cmUo WEVORkVBVF9odm1fY2FsbGJhY2tfdmVjdG9yKSk7Ci0KLQl4ZW5faHZtX3NtcF9pbml0KCk7Ci0J V0FSTl9PTih4ZW5fY3B1aHBfc2V0dXAoeGVuX2NwdV91cF9wcmVwYXJlX2h2bSwgeGVuX2NwdV9k ZWFkX2h2bSkpOwotCXhlbl91bnBsdWdfZW11bGF0ZWRfZGV2aWNlcygpOwotCXg4Nl9pbml0Lmly cXMuaW50cl9pbml0ID0geGVuX2luaXRfSVJROwotCXhlbl9odm1faW5pdF90aW1lX29wcygpOwot CXhlbl9odm1faW5pdF9tbXVfb3BzKCk7Ci0KLQlpZiAoeGVuX3B2aF9kb21haW4oKSkKLQkJbWFj aGluZV9vcHMuZW1lcmdlbmN5X3Jlc3RhcnQgPSB4ZW5fZW1lcmdlbmN5X3Jlc3RhcnQ7Ci0jaWZk ZWYgQ09ORklHX0tFWEVDX0NPUkUKLQltYWNoaW5lX29wcy5zaHV0ZG93biA9IHhlbl9odm1fc2h1 dGRvd247Ci0JbWFjaGluZV9vcHMuY3Jhc2hfc2h1dGRvd24gPSB4ZW5faHZtX2NyYXNoX3NodXRk b3duOwotI2VuZGlmCi19Ci0jZW5kaWYKLQotc3RhdGljIGJvb2wgeGVuX25vcHYgPSBmYWxzZTsK LXN0YXRpYyBfX2luaXQgaW50IHhlbl9wYXJzZV9ub3B2KGNoYXIgKmFyZykKLXsKLSAgICAgICB4 ZW5fbm9wdiA9IHRydWU7Ci0gICAgICAgcmV0dXJuIDA7Ci19Ci1lYXJseV9wYXJhbSgieGVuX25v cHYiLCB4ZW5fcGFyc2Vfbm9wdik7Ci0KIHN0YXRpYyB1aW50MzJfdCBfX2luaXQgeGVuX3BsYXRm b3JtX3B2KHZvaWQpCiB7CiAJaWYgKHhlbl9wdl9kb21haW4oKSkKQEAgLTE4NjUsMjggKzE2OTQs NiBAQCBzdGF0aWMgdWludDMyX3QgX19pbml0IHhlbl9wbGF0Zm9ybV9wdih2b2lkKQogCXJldHVy biAwOwogfQogCi1zdGF0aWMgdWludDMyX3QgX19pbml0IHhlbl9wbGF0Zm9ybV9odm0odm9pZCkK LXsKLQlpZiAoeGVuX3B2X2RvbWFpbigpIHx8IHhlbl9ub3B2KQotCQlyZXR1cm4gMDsKLQotCXJl dHVybiB4ZW5fY3B1aWRfYmFzZSgpOwotfQotCi1ib29sIHhlbl9odm1fbmVlZF9sYXBpYyh2b2lk KQotewotCWlmICh4ZW5fbm9wdikKLQkJcmV0dXJuIGZhbHNlOwotCWlmICh4ZW5fcHZfZG9tYWlu KCkpCi0JCXJldHVybiBmYWxzZTsKLQlpZiAoIXhlbl9odm1fZG9tYWluKCkpCi0JCXJldHVybiBm YWxzZTsKLQlpZiAoeGVuX2ZlYXR1cmUoWEVORkVBVF9odm1fcGlycXMpKQotCQlyZXR1cm4gZmFs c2U7Ci0JcmV0dXJuIHRydWU7Ci19Ci1FWFBPUlRfU1lNQk9MX0dQTCh4ZW5faHZtX25lZWRfbGFw aWMpOwotCiBzdGF0aWMgdm9pZCB4ZW5fc2V0X2NwdV9mZWF0dXJlcyhzdHJ1Y3QgY3B1aW5mb194 ODYgKmMpCiB7CiAJY2xlYXJfY3B1X2J1ZyhjLCBYODZfQlVHX1NZU1JFVF9TU19BVFRSUyk7CkBA IC0xOTQwLDE0ICsxNzQ3LDYgQEAgY29uc3Qgc3RydWN0IGh5cGVydmlzb3JfeDg2IHg4Nl9oeXBl cl94ZW5fcHYgPSB7CiB9OwogRVhQT1JUX1NZTUJPTCh4ODZfaHlwZXJfeGVuX3B2KTsKIAotY29u c3Qgc3RydWN0IGh5cGVydmlzb3JfeDg2IHg4Nl9oeXBlcl94ZW5faHZtID0gewotCS5uYW1lICAg ICAgICAgICAgICAgICAgID0gIlhlbiBIVk0iLAotCS5kZXRlY3QgICAgICAgICAgICAgICAgID0g eGVuX3BsYXRmb3JtX2h2bSwKLQkuaW5pdF9wbGF0Zm9ybSAgICAgICAgICA9IHhlbl9odm1fZ3Vl c3RfaW5pdCwKLQkueDJhcGljX2F2YWlsYWJsZSAgICAgICA9IHhlbl94MmFwaWNfcGFyYV9hdmFp bGFibGUsCi19OwotRVhQT1JUX1NZTUJPTCh4ODZfaHlwZXJfeGVuX2h2bSk7Ci0KICNpZmRlZiBD T05GSUdfSE9UUExVR19DUFUKIHZvaWQgeGVuX2FyY2hfcmVnaXN0ZXJfY3B1KGludCBudW0pCiB7 CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni94ZW4vZW5saWdodGVuX2h2bS5jIGIvYXJjaC94ODYveGVu L2VubGlnaHRlbl9odm0uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hOGY0 ZDdlCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC94ODYveGVuL2VubGlnaHRlbl9odm0uYwpAQCAt MCwwICsxLDIxMCBAQAorI2luY2x1ZGUgPGxpbnV4L2NwdS5oPgorI2luY2x1ZGUgPGxpbnV4L2tl eGVjLmg+CisKKyNpbmNsdWRlIDx4ZW4vZmVhdHVyZXMuaD4KKyNpbmNsdWRlIDx4ZW4vZXZlbnRz Lmg+CisjaW5jbHVkZSA8eGVuL2ludGVyZmFjZS9tZW1vcnkuaD4KKworI2luY2x1ZGUgPGFzbS9y ZWJvb3QuaD4KKyNpbmNsdWRlIDxhc20vc2V0dXAuaD4KKyNpbmNsdWRlIDxhc20vaHlwZXJ2aXNv ci5oPgorCisjaW5jbHVkZSA8YXNtL3hlbi9jcHVpZC5oPgorI2luY2x1ZGUgPGFzbS94ZW4vaHlw ZXJ2aXNvci5oPgorCisjaW5jbHVkZSAieGVuLW9wcy5oIgorI2luY2x1ZGUgIm1tdS5oIgorI2lu Y2x1ZGUgInNtcC5oIgorCit2b2lkIF9fcmVmIHhlbl9odm1faW5pdF9zaGFyZWRfaW5mbyh2b2lk KQoreworCWludCBjcHU7CisJc3RydWN0IHhlbl9hZGRfdG9fcGh5c21hcCB4YXRwOworCXN0YXRp YyBzdHJ1Y3Qgc2hhcmVkX2luZm8gKnNoYXJlZF9pbmZvX3BhZ2U7CisKKwlpZiAoIXNoYXJlZF9p bmZvX3BhZ2UpCisJCXNoYXJlZF9pbmZvX3BhZ2UgPSAoc3RydWN0IHNoYXJlZF9pbmZvICopCisJ CQlleHRlbmRfYnJrKFBBR0VfU0laRSwgUEFHRV9TSVpFKTsKKwl4YXRwLmRvbWlkID0gRE9NSURf U0VMRjsKKwl4YXRwLmlkeCA9IDA7CisJeGF0cC5zcGFjZSA9IFhFTk1BUFNQQUNFX3NoYXJlZF9p bmZvOworCXhhdHAuZ3BmbiA9IF9fcGEoc2hhcmVkX2luZm9fcGFnZSkgPj4gUEFHRV9TSElGVDsK KwlpZiAoSFlQRVJWSVNPUl9tZW1vcnlfb3AoWEVOTUVNX2FkZF90b19waHlzbWFwLCAmeGF0cCkp CisJCUJVRygpOworCisJSFlQRVJWSVNPUl9zaGFyZWRfaW5mbyA9IChzdHJ1Y3Qgc2hhcmVkX2lu Zm8gKilzaGFyZWRfaW5mb19wYWdlOworCisJLyogeGVuX3ZjcHUgaXMgYSBwb2ludGVyIHRvIHRo ZSB2Y3B1X2luZm8gc3RydWN0IGluIHRoZSBzaGFyZWRfaW5mbworCSAqIHBhZ2UsIHdlIHVzZSBp dCBpbiB0aGUgZXZlbnQgY2hhbm5lbCB1cGNhbGwgYW5kIGluIHNvbWUgcHZjbG9jaworCSAqIHJl bGF0ZWQgZnVuY3Rpb25zLiBXZSBkb24ndCBuZWVkIHRoZSB2Y3B1X2luZm8gcGxhY2VtZW50CisJ ICogb3B0aW1pemF0aW9ucyBiZWNhdXNlIHdlIGRvbid0IHVzZSBhbnkgcHZfbW11IG9yIHB2X2ly cSBvcCBvbgorCSAqIEhWTS4KKwkgKiBXaGVuIHhlbl9odm1faW5pdF9zaGFyZWRfaW5mbyBpcyBy dW4gYXQgYm9vdCB0aW1lIG9ubHkgdmNwdSAwIGlzCisJICogb25saW5lIGJ1dCB4ZW5faHZtX2lu aXRfc2hhcmVkX2luZm8gaXMgcnVuIGF0IHJlc3VtZSB0aW1lIHRvbyBhbmQKKwkgKiBpbiB0aGF0 IGNhc2UgbXVsdGlwbGUgdmNwdXMgbWlnaHQgYmUgb25saW5lLiAqLworCWZvcl9lYWNoX29ubGlu ZV9jcHUoY3B1KSB7CisJCS8qIExlYXZlIGl0IHRvIGJlIE5VTEwuICovCisJCWlmICh4ZW5fdmNw dV9ucihjcHUpID49IE1BWF9WSVJUX0NQVVMpCisJCQljb250aW51ZTsKKwkJcGVyX2NwdSh4ZW5f dmNwdSwgY3B1KSA9CisJCQkmSFlQRVJWSVNPUl9zaGFyZWRfaW5mby0+dmNwdV9pbmZvW3hlbl92 Y3B1X25yKGNwdSldOworCX0KK30KKworc3RhdGljIHZvaWQgX19pbml0IGluaXRfaHZtX3B2X2lu Zm8odm9pZCkKK3sKKwlpbnQgbWFqb3IsIG1pbm9yOworCXVpbnQzMl90IGVheCwgZWJ4LCBlY3gs IGVkeCwgYmFzZTsKKworCWJhc2UgPSB4ZW5fY3B1aWRfYmFzZSgpOworCWVheCA9IGNwdWlkX2Vh eChiYXNlICsgMSk7CisKKwltYWpvciA9IGVheCA+PiAxNjsKKwltaW5vciA9IGVheCAmIDB4ZmZm ZjsKKwlwcmludGsoS0VSTl9JTkZPICJYZW4gdmVyc2lvbiAlZC4lZC5cbiIsIG1ham9yLCBtaW5v cik7CisKKwl4ZW5fZG9tYWluX3R5cGUgPSBYRU5fSFZNX0RPTUFJTjsKKworCS8qIFBWSCBzZXQg dXAgaHlwZXJjYWxsIHBhZ2UgaW4geGVuX3ByZXBhcmVfcHZoKCkuICovCisJaWYgKHhlbl9wdmhf ZG9tYWluKCkpCisJCXB2X2luZm8ubmFtZSA9ICJYZW4gUFZIIjsKKwllbHNlIHsKKwkJdTY0IHBm bjsKKwkJdWludDMyX3QgbXNyOworCisJCXB2X2luZm8ubmFtZSA9ICJYZW4gSFZNIjsKKwkJbXNy ID0gY3B1aWRfZWJ4KGJhc2UgKyAyKTsKKwkJcGZuID0gX19wYShoeXBlcmNhbGxfcGFnZSk7CisJ CXdybXNyX3NhZmUobXNyLCAodTMyKXBmbiwgKHUzMikocGZuID4+IDMyKSk7CisJfQorCisJeGVu X3NldHVwX2ZlYXR1cmVzKCk7CisKKwljcHVpZChiYXNlICsgNCwgJmVheCwgJmVieCwgJmVjeCwg JmVkeCk7CisJaWYgKGVheCAmIFhFTl9IVk1fQ1BVSURfVkNQVV9JRF9QUkVTRU5UKQorCQl0aGlz X2NwdV93cml0ZSh4ZW5fdmNwdV9pZCwgZWJ4KTsKKwllbHNlCisJCXRoaXNfY3B1X3dyaXRlKHhl bl92Y3B1X2lkLCBzbXBfcHJvY2Vzc29yX2lkKCkpOworfQorCisjaWZkZWYgQ09ORklHX0tFWEVD X0NPUkUKK3N0YXRpYyB2b2lkIHhlbl9odm1fc2h1dGRvd24odm9pZCkKK3sKKwluYXRpdmVfbWFj aGluZV9zaHV0ZG93bigpOworCWlmIChrZXhlY19pbl9wcm9ncmVzcykKKwkJeGVuX3JlYm9vdChT SFVURE9XTl9zb2Z0X3Jlc2V0KTsKK30KKworc3RhdGljIHZvaWQgeGVuX2h2bV9jcmFzaF9zaHV0 ZG93bihzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3sKKwluYXRpdmVfbWFjaGluZV9jcmFzaF9zaHV0 ZG93bihyZWdzKTsKKwl4ZW5fcmVib290KFNIVVRET1dOX3NvZnRfcmVzZXQpOworfQorI2VuZGlm CisKK3N0YXRpYyBpbnQgeGVuX2NwdV91cF9wcmVwYXJlX2h2bSh1bnNpZ25lZCBpbnQgY3B1KQor eworCWludCByYzsKKworCS8qCisJICogVGhpcyBjYW4gaGFwcGVuIGlmIENQVSB3YXMgb2ZmbGlu ZWQgZWFybGllciBhbmQKKwkgKiBvZmZsaW5pbmcgdGltZWQgb3V0IGluIGNvbW1vbl9jcHVfZGll KCkuCisJICovCisJaWYgKGNwdV9yZXBvcnRfc3RhdGUoY3B1KSA9PSBDUFVfREVBRF9GUk9aRU4p IHsKKwkJeGVuX3NtcF9pbnRyX2ZyZWUoY3B1KTsKKwkJeGVuX3VuaW5pdF9sb2NrX2NwdShjcHUp OworCX0KKworCWlmIChjcHVfYWNwaV9pZChjcHUpICE9IFUzMl9NQVgpCisJCXBlcl9jcHUoeGVu X3ZjcHVfaWQsIGNwdSkgPSBjcHVfYWNwaV9pZChjcHUpOworCWVsc2UKKwkJcGVyX2NwdSh4ZW5f dmNwdV9pZCwgY3B1KSA9IGNwdTsKKwl4ZW5fdmNwdV9zZXR1cChjcHUpOworCisJaWYgKHhlbl9m ZWF0dXJlKFhFTkZFQVRfaHZtX3NhZmVfcHZjbG9jaykpCisJCXhlbl9zZXR1cF90aW1lcihjcHUp OworCisJcmMgPSB4ZW5fc21wX2ludHJfaW5pdChjcHUpOworCWlmIChyYykgeworCQlXQVJOKDEs ICJ4ZW5fc21wX2ludHJfaW5pdCgpIGZvciBDUFUgJWQgZmFpbGVkOiAlZFxuIiwKKwkJICAgICBj cHUsIHJjKTsKKwkJcmV0dXJuIHJjOworCX0KKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCB4 ZW5fY3B1X2RlYWRfaHZtKHVuc2lnbmVkIGludCBjcHUpCit7CisJeGVuX3NtcF9pbnRyX2ZyZWUo Y3B1KTsKKworCWlmICh4ZW5fZmVhdHVyZShYRU5GRUFUX2h2bV9zYWZlX3B2Y2xvY2spKQorCQl4 ZW5fdGVhcmRvd25fdGltZXIoY3B1KTsKKworICAgICAgIHJldHVybiAwOworfQorCitzdGF0aWMg dm9pZCBfX2luaXQgeGVuX2h2bV9ndWVzdF9pbml0KHZvaWQpCit7CisJaWYgKHhlbl9wdl9kb21h aW4oKSkKKwkJcmV0dXJuOworCisJaW5pdF9odm1fcHZfaW5mbygpOworCisJeGVuX2h2bV9pbml0 X3NoYXJlZF9pbmZvKCk7CisKKwl4ZW5fcGFuaWNfaGFuZGxlcl9pbml0KCk7CisKKwlCVUdfT04o IXhlbl9mZWF0dXJlKFhFTkZFQVRfaHZtX2NhbGxiYWNrX3ZlY3RvcikpOworCisJeGVuX2h2bV9z bXBfaW5pdCgpOworCVdBUk5fT04oeGVuX2NwdWhwX3NldHVwKHhlbl9jcHVfdXBfcHJlcGFyZV9o dm0sIHhlbl9jcHVfZGVhZF9odm0pKTsKKwl4ZW5fdW5wbHVnX2VtdWxhdGVkX2RldmljZXMoKTsK Kwl4ODZfaW5pdC5pcnFzLmludHJfaW5pdCA9IHhlbl9pbml0X0lSUTsKKwl4ZW5faHZtX2luaXRf dGltZV9vcHMoKTsKKwl4ZW5faHZtX2luaXRfbW11X29wcygpOworCisJaWYgKHhlbl9wdmhfZG9t YWluKCkpCisJCW1hY2hpbmVfb3BzLmVtZXJnZW5jeV9yZXN0YXJ0ID0geGVuX2VtZXJnZW5jeV9y ZXN0YXJ0OworI2lmZGVmIENPTkZJR19LRVhFQ19DT1JFCisJbWFjaGluZV9vcHMuc2h1dGRvd24g PSB4ZW5faHZtX3NodXRkb3duOworCW1hY2hpbmVfb3BzLmNyYXNoX3NodXRkb3duID0geGVuX2h2 bV9jcmFzaF9zaHV0ZG93bjsKKyNlbmRpZgorfQorCitzdGF0aWMgYm9vbCB4ZW5fbm9wdjsKK3N0 YXRpYyBfX2luaXQgaW50IHhlbl9wYXJzZV9ub3B2KGNoYXIgKmFyZykKK3sKKyAgICAgICB4ZW5f bm9wdiA9IHRydWU7CisgICAgICAgcmV0dXJuIDA7Cit9CitlYXJseV9wYXJhbSgieGVuX25vcHYi LCB4ZW5fcGFyc2Vfbm9wdik7CisKK2Jvb2wgeGVuX2h2bV9uZWVkX2xhcGljKHZvaWQpCit7CisJ aWYgKHhlbl9ub3B2KQorCQlyZXR1cm4gZmFsc2U7CisJaWYgKHhlbl9wdl9kb21haW4oKSkKKwkJ cmV0dXJuIGZhbHNlOworCWlmICgheGVuX2h2bV9kb21haW4oKSkKKwkJcmV0dXJuIGZhbHNlOwor CWlmICh4ZW5fZmVhdHVyZShYRU5GRUFUX2h2bV9waXJxcykpCisJCXJldHVybiBmYWxzZTsKKwly ZXR1cm4gdHJ1ZTsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKHhlbl9odm1fbmVlZF9sYXBpYyk7CisK K3N0YXRpYyB1aW50MzJfdCBfX2luaXQgeGVuX3BsYXRmb3JtX2h2bSh2b2lkKQoreworCWlmICh4 ZW5fcHZfZG9tYWluKCkgfHwgeGVuX25vcHYpCisJCXJldHVybiAwOworCisJcmV0dXJuIHhlbl9j cHVpZF9iYXNlKCk7Cit9CisKK2NvbnN0IHN0cnVjdCBoeXBlcnZpc29yX3g4NiB4ODZfaHlwZXJf eGVuX2h2bSA9IHsKKwkubmFtZSAgICAgICAgICAgICAgICAgICA9ICJYZW4gSFZNIiwKKwkuZGV0 ZWN0ICAgICAgICAgICAgICAgICA9IHhlbl9wbGF0Zm9ybV9odm0sCisJLmluaXRfcGxhdGZvcm0g ICAgICAgICAgPSB4ZW5faHZtX2d1ZXN0X2luaXQsCisJLngyYXBpY19hdmFpbGFibGUgICAgICAg PSB4ZW5feDJhcGljX3BhcmFfYXZhaWxhYmxlLAorfTsKK0VYUE9SVF9TWU1CT0woeDg2X2h5cGVy X3hlbl9odm0pOwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYveGVuL3hlbi1vcHMuaCBiL2FyY2gveDg2 L3hlbi94ZW4tb3BzLmgKaW5kZXggMmIxNjJmNi4uN2JhZWIwNCAxMDA2NDQKLS0tIGEvYXJjaC94 ODYveGVuL3hlbi1vcHMuaAorKysgYi9hcmNoL3g4Ni94ZW4veGVuLW9wcy5oCkBAIC0xNDgsNCAr MTQ4LDEwIEBAIF9fdmlzaWJsZSB2b2lkIHhlbl9hZGp1c3RfZXhjZXB0aW9uX2ZyYW1lKHZvaWQp OwogCiBleHRlcm4gaW50IHhlbl9wYW5pY19oYW5kbGVyX2luaXQodm9pZCk7CiAKK2V4dGVybiBp bnQgeGVuX2NwdWhwX3NldHVwKGludCAoKmNwdV91cF9wcmVwYXJlX2NiKSh1bnNpZ25lZCBpbnQp LAorCQkJICAgaW50ICgqY3B1X2RlYWRfY2IpKHVuc2lnbmVkIGludCkpOworCitleHRlcm4gdm9p ZCB4ZW5fcmVib290KGludCByZWFzb24pOworZXh0ZXJuIHZvaWQgeGVuX2VtZXJnZW5jeV9yZXN0 YXJ0KHZvaWQpOworCiAjZW5kaWYgLyogWEVOX09QU19IICovCi0tIAoyLjkuMwoKCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5n IGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0cHM6Ly9saXN0cy54ZW4ub3JnL3hlbi1k ZXZlbAo=