From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.linuxfoundation.org ([140.211.169.12]:44668 "EHLO mail.linuxfoundation.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S934619AbdEKOT2 (ORCPT ); Thu, 11 May 2017 10:19:28 -0400 From: Greg Kroah-Hartman To: linux-kernel@vger.kernel.org Cc: Greg Kroah-Hartman , stable@vger.kernel.org, Boris Ostrovsky , Juergen Gross , Thomas Gleixner , Ingo Molnar , "H. Peter Anvin" , x86@kernel.org, Konrad Rzeszutek Wilk , Bjorn Helgaas , Stefano Stabellini , Julien Grall , Vitaly Kuznetsov , Paul Gortmaker , Ross Lagerwall , xen-devel@lists.xenproject.org, linux-pci@vger.kernel.org, Anthony Liguori , KarimAllah Ahmed Subject: [PATCH 4.10 125/129] xen: Revert commits da72ff5bfcb0 and 72a9b186292d Date: Thu, 11 May 2017 16:12:53 +0200 Message-Id: <20170511141227.882547825@linuxfoundation.org> In-Reply-To: <20170511141220.039886885@linuxfoundation.org> References: <20170511141220.039886885@linuxfoundation.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Sender: linux-pci-owner@vger.kernel.org List-ID: 4.10-stable review patch. If anyone has any objections, please let me know. ------------------ From: Boris Ostrovsky commit 84d582d236dc1f9085e741affc72e9ba061a67c2 upstream. Recent discussion (http://marc.info/?l=xen-devel&m=149192184523741) established that commit 72a9b186292d ("xen: Remove event channel notification through Xen PCI platform device") (and thus commit da72ff5bfcb0 ("partially revert "xen: Remove event channel notification through Xen PCI platform device"")) are unnecessary and, in fact, prevent HVM guests from booting on Xen releases prior to 4.0 Therefore we revert both of those commits. The summary of that discussion is below: Here is the brief summary of the current situation: Before the offending commit (72a9b186292): 1) INTx does not work because of the reset_watches path. 2) The reset_watches path is only taken if you have Xen > 4.0 3) The Linux Kernel by default will use vector inject if the hypervisor support. So even INTx does not work no body running the kernel with Xen > 4.0 would notice. Unless he explicitly disabled this feature either in the kernel or in Xen (and this can only be disabled by modifying the code, not user-supported way to do it). After the offending commit (+ partial revert): 1) INTx is no longer support for HVM (only for PV guests). 2) Any HVM guest The kernel will not boot on Xen < 4.0 which does not have vector injection support. Since the only other mode supported is INTx which. So based on this summary, I think before commit (72a9b186292) we were in much better position from a user point of view. Signed-off-by: Boris Ostrovsky Reviewed-by: Juergen Gross Cc: Boris Ostrovsky Cc: Thomas Gleixner Cc: Ingo Molnar Cc: "H. Peter Anvin" Cc: x86@kernel.org Cc: Konrad Rzeszutek Wilk Cc: Bjorn Helgaas Cc: Stefano Stabellini Cc: Julien Grall Cc: Vitaly Kuznetsov Cc: Paul Gortmaker Cc: Ross Lagerwall Cc: xen-devel@lists.xenproject.org Cc: linux-kernel@vger.kernel.org Cc: linux-pci@vger.kernel.org Cc: Anthony Liguori Cc: KarimAllah Ahmed Signed-off-by: Juergen Gross Signed-off-by: Greg Kroah-Hartman --- arch/x86/include/asm/xen/events.h | 11 +++++++++++ arch/x86/pci/xen.c | 2 +- arch/x86/xen/enlighten.c | 21 +++++++++++++++------ arch/x86/xen/smp.c | 2 ++ arch/x86/xen/time.c | 5 +++++ drivers/xen/events/events_base.c | 26 +++++++++++++++++--------- drivers/xen/platform-pci.c | 13 +++---------- include/xen/xen.h | 3 ++- 8 files changed, 56 insertions(+), 27 deletions(-) --- a/arch/x86/include/asm/xen/events.h +++ b/arch/x86/include/asm/xen/events.h @@ -20,4 +20,15 @@ static inline int xen_irqs_disabled(stru /* No need for a barrier -- XCHG is a barrier on x86. */ #define xchg_xen_ulong(ptr, val) xchg((ptr), (val)) +extern int xen_have_vector_callback; + +/* + * Events delivered via platform PCI interrupts are always + * routed to vcpu 0 and hence cannot be rebound. + */ +static inline bool xen_support_evtchn_rebind(void) +{ + return (!xen_hvm_domain() || xen_have_vector_callback); +} + #endif /* _ASM_X86_XEN_EVENTS_H */ --- a/arch/x86/pci/xen.c +++ b/arch/x86/pci/xen.c @@ -447,7 +447,7 @@ void __init xen_msi_init(void) int __init pci_xen_hvm_init(void) { - if (!xen_feature(XENFEAT_hvm_pirqs)) + if (!xen_have_vector_callback || !xen_feature(XENFEAT_hvm_pirqs)) return 0; #ifdef CONFIG_ACPI --- a/arch/x86/xen/enlighten.c +++ b/arch/x86/xen/enlighten.c @@ -137,6 +137,8 @@ struct shared_info xen_dummy_shared_info void *xen_initial_gdt; RESERVE_BRK(shared_info_page_brk, PAGE_SIZE); +__read_mostly int xen_have_vector_callback; +EXPORT_SYMBOL_GPL(xen_have_vector_callback); static int xen_cpu_up_prepare(unsigned int cpu); static int xen_cpu_up_online(unsigned int cpu); @@ -1508,7 +1510,10 @@ static void __init xen_pvh_early_guest_i if (!xen_feature(XENFEAT_auto_translated_physmap)) return; - BUG_ON(!xen_feature(XENFEAT_hvm_callback_vector)); + if (!xen_feature(XENFEAT_hvm_callback_vector)) + return; + + xen_have_vector_callback = 1; xen_pvh_early_cpu_init(0, false); xen_pvh_set_cr_flags(0); @@ -1847,7 +1852,9 @@ static int xen_cpu_up_prepare(unsigned i xen_vcpu_setup(cpu); } - if (xen_pv_domain() || xen_feature(XENFEAT_hvm_safe_pvclock)) + if (xen_pv_domain() || + (xen_have_vector_callback && + xen_feature(XENFEAT_hvm_safe_pvclock))) xen_setup_timer(cpu); rc = xen_smp_intr_init(cpu); @@ -1863,7 +1870,9 @@ static int xen_cpu_dead(unsigned int cpu { xen_smp_intr_free(cpu); - if (xen_pv_domain() || xen_feature(XENFEAT_hvm_safe_pvclock)) + if (xen_pv_domain() || + (xen_have_vector_callback && + xen_feature(XENFEAT_hvm_safe_pvclock))) xen_teardown_timer(cpu); return 0; @@ -1902,8 +1911,8 @@ static void __init xen_hvm_guest_init(vo xen_panic_handler_init(); - BUG_ON(!xen_feature(XENFEAT_hvm_callback_vector)); - + if (xen_feature(XENFEAT_hvm_callback_vector)) + xen_have_vector_callback = 1; xen_hvm_smp_init(); WARN_ON(xen_cpuhp_setup()); xen_unplug_emulated_devices(); @@ -1941,7 +1950,7 @@ bool xen_hvm_need_lapic(void) return false; if (!xen_hvm_domain()) return false; - if (xen_feature(XENFEAT_hvm_pirqs)) + if (xen_feature(XENFEAT_hvm_pirqs) && xen_have_vector_callback) return false; return true; } --- a/arch/x86/xen/smp.c +++ b/arch/x86/xen/smp.c @@ -765,6 +765,8 @@ static void __init xen_hvm_smp_prepare_c void __init xen_hvm_smp_init(void) { + if (!xen_have_vector_callback) + return; smp_ops.smp_prepare_cpus = xen_hvm_smp_prepare_cpus; smp_ops.smp_send_reschedule = xen_smp_send_reschedule; smp_ops.cpu_die = xen_cpu_die; --- a/arch/x86/xen/time.c +++ b/arch/x86/xen/time.c @@ -432,6 +432,11 @@ static void xen_hvm_setup_cpu_clockevent void __init xen_hvm_init_time_ops(void) { + /* vector callback is needed otherwise we cannot receive interrupts + * on cpu > 0 and at this point we don't know how many cpus are + * available */ + if (!xen_have_vector_callback) + return; if (!xen_feature(XENFEAT_hvm_safe_pvclock)) { printk(KERN_INFO "Xen doesn't support pvclock on HVM," "disable pv timer\n"); --- a/drivers/xen/events/events_base.c +++ b/drivers/xen/events/events_base.c @@ -1312,6 +1312,9 @@ static int rebind_irq_to_cpu(unsigned ir if (!VALID_EVTCHN(evtchn)) return -1; + if (!xen_support_evtchn_rebind()) + return -1; + /* Send future instances of this interrupt to other vcpu. */ bind_vcpu.port = evtchn; bind_vcpu.vcpu = xen_vcpu_nr(tcpu); @@ -1645,15 +1648,20 @@ void xen_callback_vector(void) { int rc; uint64_t callback_via; - - callback_via = HVM_CALLBACK_VECTOR(HYPERVISOR_CALLBACK_VECTOR); - rc = xen_set_callback_via(callback_via); - BUG_ON(rc); - pr_info("Xen HVM callback vector for event delivery is enabled\n"); - /* in the restore case the vector has already been allocated */ - if (!test_bit(HYPERVISOR_CALLBACK_VECTOR, used_vectors)) - alloc_intr_gate(HYPERVISOR_CALLBACK_VECTOR, - xen_hvm_callback_vector); + if (xen_have_vector_callback) { + callback_via = HVM_CALLBACK_VECTOR(HYPERVISOR_CALLBACK_VECTOR); + rc = xen_set_callback_via(callback_via); + if (rc) { + pr_err("Request for Xen HVM callback vector failed\n"); + xen_have_vector_callback = 0; + return; + } + pr_info("Xen HVM callback vector for event delivery is enabled\n"); + /* in the restore case the vector has already been allocated */ + if (!test_bit(HYPERVISOR_CALLBACK_VECTOR, used_vectors)) + alloc_intr_gate(HYPERVISOR_CALLBACK_VECTOR, + xen_hvm_callback_vector); + } } #else void xen_callback_vector(void) {} --- a/drivers/xen/platform-pci.c +++ b/drivers/xen/platform-pci.c @@ -67,7 +67,7 @@ static uint64_t get_callback_via(struct pin = pdev->pin; /* We don't know the GSI. Specify the PCI INTx line instead. */ - return ((uint64_t)0x01 << HVM_CALLBACK_VIA_TYPE_SHIFT) | /* PCI INTx identifier */ + return ((uint64_t)0x01 << 56) | /* PCI INTx identifier */ ((uint64_t)pci_domain_nr(pdev->bus) << 32) | ((uint64_t)pdev->bus->number << 16) | ((uint64_t)(pdev->devfn & 0xff) << 8) | @@ -90,7 +90,7 @@ static int xen_allocate_irq(struct pci_d static int platform_pci_resume(struct pci_dev *pdev) { int err; - if (!xen_pv_domain()) + if (xen_have_vector_callback) return 0; err = xen_set_callback_via(callback_via); if (err) { @@ -138,14 +138,7 @@ static int platform_pci_probe(struct pci platform_mmio = mmio_addr; platform_mmiolen = mmio_len; - /* - * Xen HVM guests always use the vector callback mechanism. - * L1 Dom0 in a nested Xen environment is a PV guest inside in an - * HVM environment. It needs the platform-pci driver to get - * notifications from L0 Xen, but it cannot use the vector callback - * as it is not exported by L1 Xen. - */ - if (xen_pv_domain()) { + if (!xen_have_vector_callback) { ret = xen_allocate_irq(pdev); if (ret) { dev_warn(&pdev->dev, "request_irq failed err=%d\n", ret); --- a/include/xen/xen.h +++ b/include/xen/xen.h @@ -38,7 +38,8 @@ extern enum xen_domain_type xen_domain_t */ #include #define xen_pvh_domain() (xen_pv_domain() && \ - xen_feature(XENFEAT_auto_translated_physmap)) + xen_feature(XENFEAT_auto_translated_physmap) && \ + xen_have_vector_callback) #else #define xen_pvh_domain() (0) #endif From mboxrd@z Thu Jan 1 00:00:00 1970 From: Greg Kroah-Hartman Subject: [PATCH 4.10 125/129] xen: Revert commits da72ff5bfcb0 and 72a9b186292d Date: Thu, 11 May 2017 16:12:53 +0200 Message-ID: <20170511141227.882547825@linuxfoundation.org> References: <20170511141220.039886885@linuxfoundation.org> 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 1d8owE-0007iC-LJ for xen-devel@lists.xenproject.org; Thu, 11 May 2017 14:19:30 +0000 In-Reply-To: <20170511141220.039886885@linuxfoundation.org> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: linux-kernel@vger.kernel.org Cc: Juergen Gross , Stefano Stabellini , Ross Lagerwall , linux-pci@vger.kernel.org, Greg Kroah-Hartman , KarimAllah Ahmed , x86@kernel.org, Paul Gortmaker , stable@vger.kernel.org, Vitaly Kuznetsov , Julien Grall , Ingo Molnar , Anthony Liguori , "H. Peter Anvin" , Bjorn Helgaas , xen-devel@lists.xenproject.org, Boris Ostrovsky , Thomas Gleixner List-Id: xen-devel@lists.xenproject.org NC4xMC1zdGFibGUgcmV2aWV3IHBhdGNoLiAgSWYgYW55b25lIGhhcyBhbnkgb2JqZWN0aW9ucywg cGxlYXNlIGxldCBtZSBrbm93LgoKLS0tLS0tLS0tLS0tLS0tLS0tCgpGcm9tOiBCb3JpcyBPc3Ry b3Zza3kgPGJvcmlzLm9zdHJvdnNreUBvcmFjbGUuY29tPgoKY29tbWl0IDg0ZDU4MmQyMzZkYzFm OTA4NWU3NDFhZmZjNzJlOWJhMDYxYTY3YzIgdXBzdHJlYW0uCgpSZWNlbnQgZGlzY3Vzc2lvbiAo aHR0cDovL21hcmMuaW5mby8/bD14ZW4tZGV2ZWwmbT0xNDkxOTIxODQ1MjM3NDEpCmVzdGFibGlz aGVkIHRoYXQgY29tbWl0IDcyYTliMTg2MjkyZCAoInhlbjogUmVtb3ZlIGV2ZW50IGNoYW5uZWwK bm90aWZpY2F0aW9uIHRocm91Z2ggWGVuIFBDSSBwbGF0Zm9ybSBkZXZpY2UiKSAoYW5kIHRodXMg Y29tbWl0CmRhNzJmZjViZmNiMCAoInBhcnRpYWxseSByZXZlcnQgInhlbjogUmVtb3ZlIGV2ZW50 IGNoYW5uZWwKbm90aWZpY2F0aW9uIHRocm91Z2ggWGVuIFBDSSBwbGF0Zm9ybSBkZXZpY2UiIikp IGFyZSB1bm5lY2Vzc2FyeSBhbmQsCmluIGZhY3QsIHByZXZlbnQgSFZNIGd1ZXN0cyBmcm9tIGJv b3Rpbmcgb24gWGVuIHJlbGVhc2VzIHByaW9yIHRvIDQuMAoKVGhlcmVmb3JlIHdlIHJldmVydCBi b3RoIG9mIHRob3NlIGNvbW1pdHMuCgpUaGUgc3VtbWFyeSBvZiB0aGF0IGRpc2N1c3Npb24gaXMg YmVsb3c6CgogIEhlcmUgaXMgdGhlIGJyaWVmIHN1bW1hcnkgb2YgdGhlIGN1cnJlbnQgc2l0dWF0 aW9uOgoKICBCZWZvcmUgdGhlIG9mZmVuZGluZyBjb21taXQgKDcyYTliMTg2MjkyKToKCiAgMSkg SU5UeCBkb2VzIG5vdCB3b3JrIGJlY2F1c2Ugb2YgdGhlIHJlc2V0X3dhdGNoZXMgcGF0aC4KICAy KSBUaGUgcmVzZXRfd2F0Y2hlcyBwYXRoIGlzIG9ubHkgdGFrZW4gaWYgeW91IGhhdmUgWGVuID4g NC4wCiAgMykgVGhlIExpbnV4IEtlcm5lbCBieSBkZWZhdWx0IHdpbGwgdXNlIHZlY3RvciBpbmpl Y3QgaWYgdGhlIGh5cGVydmlzb3IKICAgICBzdXBwb3J0LiBTbyBldmVuIElOVHggZG9lcyBub3Qg d29yayBubyBib2R5IHJ1bm5pbmcgdGhlIGtlcm5lbCB3aXRoCiAgICAgWGVuID4gNC4wIHdvdWxk IG5vdGljZS4gVW5sZXNzIGhlIGV4cGxpY2l0bHkgZGlzYWJsZWQgdGhpcyBmZWF0dXJlCiAgICAg ZWl0aGVyIGluIHRoZSBrZXJuZWwgb3IgaW4gWGVuIChhbmQgdGhpcyBjYW4gb25seSBiZSBkaXNh YmxlZCBieQogICAgIG1vZGlmeWluZyB0aGUgY29kZSwgbm90IHVzZXItc3VwcG9ydGVkIHdheSB0 byBkbyBpdCkuCgogIEFmdGVyIHRoZSBvZmZlbmRpbmcgY29tbWl0ICgrIHBhcnRpYWwgcmV2ZXJ0 KToKCiAgMSkgSU5UeCBpcyBubyBsb25nZXIgc3VwcG9ydCBmb3IgSFZNIChvbmx5IGZvciBQViBn dWVzdHMpLgogIDIpIEFueSBIVk0gZ3Vlc3QgVGhlIGtlcm5lbCB3aWxsIG5vdCBib290IG9uIFhl biA8IDQuMCB3aGljaCBkb2VzCiAgICAgbm90IGhhdmUgdmVjdG9yIGluamVjdGlvbiBzdXBwb3J0 LiBTaW5jZSB0aGUgb25seSBvdGhlciBtb2RlCiAgICAgc3VwcG9ydGVkIGlzIElOVHggd2hpY2gu CgogIFNvIGJhc2VkIG9uIHRoaXMgc3VtbWFyeSwgSSB0aGluayBiZWZvcmUgY29tbWl0ICg3MmE5 YjE4NjI5Mikgd2Ugd2VyZQogIGluIG11Y2ggYmV0dGVyIHBvc2l0aW9uIGZyb20gYSB1c2VyIHBv aW50IG9mIHZpZXcuCgpTaWduZWQtb2ZmLWJ5OiBCb3JpcyBPc3Ryb3Zza3kgPGJvcmlzLm9zdHJv dnNreUBvcmFjbGUuY29tPgpSZXZpZXdlZC1ieTogSnVlcmdlbiBHcm9zcyA8amdyb3NzQHN1c2Uu Y29tPgpDYzogQm9yaXMgT3N0cm92c2t5IDxib3Jpcy5vc3Ryb3Zza3lAb3JhY2xlLmNvbT4KQ2M6 IFRob21hcyBHbGVpeG5lciA8dGdseEBsaW51dHJvbml4LmRlPgpDYzogSW5nbyBNb2xuYXIgPG1p bmdvQHJlZGhhdC5jb20+CkNjOiAiSC4gUGV0ZXIgQW52aW4iIDxocGFAenl0b3IuY29tPgpDYzog eDg2QGtlcm5lbC5vcmcKQ2M6IEtvbnJhZCBSemVzenV0ZWsgV2lsayA8a29ucmFkLndpbGtAb3Jh Y2xlLmNvbT4KQ2M6IEJqb3JuIEhlbGdhYXMgPGJoZWxnYWFzQGdvb2dsZS5jb20+CkNjOiBTdGVm YW5vIFN0YWJlbGxpbmkgPHNzdGFiZWxsaW5pQGtlcm5lbC5vcmc+CkNjOiBKdWxpZW4gR3JhbGwg PGp1bGllbi5ncmFsbEBhcm0uY29tPgpDYzogVml0YWx5IEt1em5ldHNvdiA8dmt1em5ldHNAcmVk aGF0LmNvbT4KQ2M6IFBhdWwgR29ydG1ha2VyIDxwYXVsLmdvcnRtYWtlckB3aW5kcml2ZXIuY29t PgpDYzogUm9zcyBMYWdlcndhbGwgPHJvc3MubGFnZXJ3YWxsQGNpdHJpeC5jb20+CkNjOiB4ZW4t ZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKQ2M6IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5v cmcKQ2M6IGxpbnV4LXBjaUB2Z2VyLmtlcm5lbC5vcmcKQ2M6IEFudGhvbnkgTGlndW9yaSA8YWxp Z3VvcmlAYW1hem9uLmNvbT4KQ2M6IEthcmltQWxsYWggQWhtZWQgPGthcmFobWVkQGFtYXpvbi5k ZT4KU2lnbmVkLW9mZi1ieTogSnVlcmdlbiBHcm9zcyA8amdyb3NzQHN1c2UuY29tPgpTaWduZWQt b2ZmLWJ5OiBHcmVnIEtyb2FoLUhhcnRtYW4gPGdyZWdraEBsaW51eGZvdW5kYXRpb24ub3JnPgoK LS0tCiBhcmNoL3g4Ni9pbmNsdWRlL2FzbS94ZW4vZXZlbnRzLmggfCAgIDExICsrKysrKysrKysr CiBhcmNoL3g4Ni9wY2kveGVuLmMgICAgICAgICAgICAgICAgfCAgICAyICstCiBhcmNoL3g4Ni94 ZW4vZW5saWdodGVuLmMgICAgICAgICAgfCAgIDIxICsrKysrKysrKysrKysrKy0tLS0tLQogYXJj aC94ODYveGVuL3NtcC5jICAgICAgICAgICAgICAgIHwgICAgMiArKwogYXJjaC94ODYveGVuL3Rp bWUuYyAgICAgICAgICAgICAgIHwgICAgNSArKysrKwogZHJpdmVycy94ZW4vZXZlbnRzL2V2ZW50 c19iYXNlLmMgIHwgICAyNiArKysrKysrKysrKysrKysrKy0tLS0tLS0tLQogZHJpdmVycy94ZW4v cGxhdGZvcm0tcGNpLmMgICAgICAgIHwgICAxMyArKystLS0tLS0tLS0tCiBpbmNsdWRlL3hlbi94 ZW4uaCAgICAgICAgICAgICAgICAgfCAgICAzICsrLQogOCBmaWxlcyBjaGFuZ2VkLCA1NiBpbnNl cnRpb25zKCspLCAyNyBkZWxldGlvbnMoLSkKCi0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3hl bi9ldmVudHMuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS94ZW4vZXZlbnRzLmgKQEAgLTIw LDQgKzIwLDE1IEBAIHN0YXRpYyBpbmxpbmUgaW50IHhlbl9pcnFzX2Rpc2FibGVkKHN0cnUKIC8q IE5vIG5lZWQgZm9yIGEgYmFycmllciAtLSBYQ0hHIGlzIGEgYmFycmllciBvbiB4ODYuICovCiAj ZGVmaW5lIHhjaGdfeGVuX3Vsb25nKHB0ciwgdmFsKSB4Y2hnKChwdHIpLCAodmFsKSkKIAorZXh0 ZXJuIGludCB4ZW5faGF2ZV92ZWN0b3JfY2FsbGJhY2s7CisKKy8qCisgKiBFdmVudHMgZGVsaXZl cmVkIHZpYSBwbGF0Zm9ybSBQQ0kgaW50ZXJydXB0cyBhcmUgYWx3YXlzCisgKiByb3V0ZWQgdG8g dmNwdSAwIGFuZCBoZW5jZSBjYW5ub3QgYmUgcmVib3VuZC4KKyAqLworc3RhdGljIGlubGluZSBi b29sIHhlbl9zdXBwb3J0X2V2dGNobl9yZWJpbmQodm9pZCkKK3sKKwlyZXR1cm4gKCF4ZW5faHZt X2RvbWFpbigpIHx8IHhlbl9oYXZlX3ZlY3Rvcl9jYWxsYmFjayk7Cit9CisKICNlbmRpZiAvKiBf QVNNX1g4Nl9YRU5fRVZFTlRTX0ggKi8KLS0tIGEvYXJjaC94ODYvcGNpL3hlbi5jCisrKyBiL2Fy Y2gveDg2L3BjaS94ZW4uYwpAQCAtNDQ3LDcgKzQ0Nyw3IEBAIHZvaWQgX19pbml0IHhlbl9tc2lf aW5pdCh2b2lkKQogCiBpbnQgX19pbml0IHBjaV94ZW5faHZtX2luaXQodm9pZCkKIHsKLQlpZiAo IXhlbl9mZWF0dXJlKFhFTkZFQVRfaHZtX3BpcnFzKSkKKwlpZiAoIXhlbl9oYXZlX3ZlY3Rvcl9j YWxsYmFjayB8fCAheGVuX2ZlYXR1cmUoWEVORkVBVF9odm1fcGlycXMpKQogCQlyZXR1cm4gMDsK IAogI2lmZGVmIENPTkZJR19BQ1BJCi0tLSBhL2FyY2gveDg2L3hlbi9lbmxpZ2h0ZW4uYworKysg Yi9hcmNoL3g4Ni94ZW4vZW5saWdodGVuLmMKQEAgLTEzNyw2ICsxMzcsOCBAQCBzdHJ1Y3Qgc2hh cmVkX2luZm8geGVuX2R1bW15X3NoYXJlZF9pbmZvCiB2b2lkICp4ZW5faW5pdGlhbF9nZHQ7CiAK IFJFU0VSVkVfQlJLKHNoYXJlZF9pbmZvX3BhZ2VfYnJrLCBQQUdFX1NJWkUpOworX19yZWFkX21v c3RseSBpbnQgeGVuX2hhdmVfdmVjdG9yX2NhbGxiYWNrOworRVhQT1JUX1NZTUJPTF9HUEwoeGVu X2hhdmVfdmVjdG9yX2NhbGxiYWNrKTsKIAogc3RhdGljIGludCB4ZW5fY3B1X3VwX3ByZXBhcmUo dW5zaWduZWQgaW50IGNwdSk7CiBzdGF0aWMgaW50IHhlbl9jcHVfdXBfb25saW5lKHVuc2lnbmVk IGludCBjcHUpOwpAQCAtMTUwOCw3ICsxNTEwLDEwIEBAIHN0YXRpYyB2b2lkIF9faW5pdCB4ZW5f cHZoX2Vhcmx5X2d1ZXN0X2kKIAlpZiAoIXhlbl9mZWF0dXJlKFhFTkZFQVRfYXV0b190cmFuc2xh dGVkX3BoeXNtYXApKQogCQlyZXR1cm47CiAKLQlCVUdfT04oIXhlbl9mZWF0dXJlKFhFTkZFQVRf aHZtX2NhbGxiYWNrX3ZlY3RvcikpOworCWlmICgheGVuX2ZlYXR1cmUoWEVORkVBVF9odm1fY2Fs bGJhY2tfdmVjdG9yKSkKKwkJcmV0dXJuOworCisJeGVuX2hhdmVfdmVjdG9yX2NhbGxiYWNrID0g MTsKIAogCXhlbl9wdmhfZWFybHlfY3B1X2luaXQoMCwgZmFsc2UpOwogCXhlbl9wdmhfc2V0X2Ny X2ZsYWdzKDApOwpAQCAtMTg0Nyw3ICsxODUyLDkgQEAgc3RhdGljIGludCB4ZW5fY3B1X3VwX3By ZXBhcmUodW5zaWduZWQgaQogCQl4ZW5fdmNwdV9zZXR1cChjcHUpOwogCX0KIAotCWlmICh4ZW5f cHZfZG9tYWluKCkgfHwgeGVuX2ZlYXR1cmUoWEVORkVBVF9odm1fc2FmZV9wdmNsb2NrKSkKKwlp ZiAoeGVuX3B2X2RvbWFpbigpIHx8CisJICAgICh4ZW5faGF2ZV92ZWN0b3JfY2FsbGJhY2sgJiYK KwkgICAgIHhlbl9mZWF0dXJlKFhFTkZFQVRfaHZtX3NhZmVfcHZjbG9jaykpKQogCQl4ZW5fc2V0 dXBfdGltZXIoY3B1KTsKIAogCXJjID0geGVuX3NtcF9pbnRyX2luaXQoY3B1KTsKQEAgLTE4NjMs NyArMTg3MCw5IEBAIHN0YXRpYyBpbnQgeGVuX2NwdV9kZWFkKHVuc2lnbmVkIGludCBjcHUKIHsK IAl4ZW5fc21wX2ludHJfZnJlZShjcHUpOwogCi0JaWYgKHhlbl9wdl9kb21haW4oKSB8fCB4ZW5f ZmVhdHVyZShYRU5GRUFUX2h2bV9zYWZlX3B2Y2xvY2spKQorCWlmICh4ZW5fcHZfZG9tYWluKCkg fHwKKwkgICAgKHhlbl9oYXZlX3ZlY3Rvcl9jYWxsYmFjayAmJgorCSAgICAgeGVuX2ZlYXR1cmUo WEVORkVBVF9odm1fc2FmZV9wdmNsb2NrKSkpCiAJCXhlbl90ZWFyZG93bl90aW1lcihjcHUpOwog CiAJcmV0dXJuIDA7CkBAIC0xOTAyLDggKzE5MTEsOCBAQCBzdGF0aWMgdm9pZCBfX2luaXQgeGVu X2h2bV9ndWVzdF9pbml0KHZvCiAKIAl4ZW5fcGFuaWNfaGFuZGxlcl9pbml0KCk7CiAKLQlCVUdf T04oIXhlbl9mZWF0dXJlKFhFTkZFQVRfaHZtX2NhbGxiYWNrX3ZlY3RvcikpOwotCisJaWYgKHhl bl9mZWF0dXJlKFhFTkZFQVRfaHZtX2NhbGxiYWNrX3ZlY3RvcikpCisJCXhlbl9oYXZlX3ZlY3Rv cl9jYWxsYmFjayA9IDE7CiAJeGVuX2h2bV9zbXBfaW5pdCgpOwogCVdBUk5fT04oeGVuX2NwdWhw X3NldHVwKCkpOwogCXhlbl91bnBsdWdfZW11bGF0ZWRfZGV2aWNlcygpOwpAQCAtMTk0MSw3ICsx OTUwLDcgQEAgYm9vbCB4ZW5faHZtX25lZWRfbGFwaWModm9pZCkKIAkJcmV0dXJuIGZhbHNlOwog CWlmICgheGVuX2h2bV9kb21haW4oKSkKIAkJcmV0dXJuIGZhbHNlOwotCWlmICh4ZW5fZmVhdHVy ZShYRU5GRUFUX2h2bV9waXJxcykpCisJaWYgKHhlbl9mZWF0dXJlKFhFTkZFQVRfaHZtX3BpcnFz KSAmJiB4ZW5faGF2ZV92ZWN0b3JfY2FsbGJhY2spCiAJCXJldHVybiBmYWxzZTsKIAlyZXR1cm4g dHJ1ZTsKIH0KLS0tIGEvYXJjaC94ODYveGVuL3NtcC5jCisrKyBiL2FyY2gveDg2L3hlbi9zbXAu YwpAQCAtNzY1LDYgKzc2NSw4IEBAIHN0YXRpYyB2b2lkIF9faW5pdCB4ZW5faHZtX3NtcF9wcmVw YXJlX2MKIAogdm9pZCBfX2luaXQgeGVuX2h2bV9zbXBfaW5pdCh2b2lkKQogeworCWlmICgheGVu X2hhdmVfdmVjdG9yX2NhbGxiYWNrKQorCQlyZXR1cm47CiAJc21wX29wcy5zbXBfcHJlcGFyZV9j cHVzID0geGVuX2h2bV9zbXBfcHJlcGFyZV9jcHVzOwogCXNtcF9vcHMuc21wX3NlbmRfcmVzY2hl ZHVsZSA9IHhlbl9zbXBfc2VuZF9yZXNjaGVkdWxlOwogCXNtcF9vcHMuY3B1X2RpZSA9IHhlbl9j cHVfZGllOwotLS0gYS9hcmNoL3g4Ni94ZW4vdGltZS5jCisrKyBiL2FyY2gveDg2L3hlbi90aW1l LmMKQEAgLTQzMiw2ICs0MzIsMTEgQEAgc3RhdGljIHZvaWQgeGVuX2h2bV9zZXR1cF9jcHVfY2xv Y2tldmVudAogCiB2b2lkIF9faW5pdCB4ZW5faHZtX2luaXRfdGltZV9vcHModm9pZCkKIHsKKwkv KiB2ZWN0b3IgY2FsbGJhY2sgaXMgbmVlZGVkIG90aGVyd2lzZSB3ZSBjYW5ub3QgcmVjZWl2ZSBp bnRlcnJ1cHRzCisJICogb24gY3B1ID4gMCBhbmQgYXQgdGhpcyBwb2ludCB3ZSBkb24ndCBrbm93 IGhvdyBtYW55IGNwdXMgYXJlCisJICogYXZhaWxhYmxlICovCisJaWYgKCF4ZW5faGF2ZV92ZWN0 b3JfY2FsbGJhY2spCisJCXJldHVybjsKIAlpZiAoIXhlbl9mZWF0dXJlKFhFTkZFQVRfaHZtX3Nh ZmVfcHZjbG9jaykpIHsKIAkJcHJpbnRrKEtFUk5fSU5GTyAiWGVuIGRvZXNuJ3Qgc3VwcG9ydCBw dmNsb2NrIG9uIEhWTSwiCiAJCQkJImRpc2FibGUgcHYgdGltZXJcbiIpOwotLS0gYS9kcml2ZXJz L3hlbi9ldmVudHMvZXZlbnRzX2Jhc2UuYworKysgYi9kcml2ZXJzL3hlbi9ldmVudHMvZXZlbnRz X2Jhc2UuYwpAQCAtMTMxMiw2ICsxMzEyLDkgQEAgc3RhdGljIGludCByZWJpbmRfaXJxX3RvX2Nw dSh1bnNpZ25lZCBpcgogCWlmICghVkFMSURfRVZUQ0hOKGV2dGNobikpCiAJCXJldHVybiAtMTsK IAorCWlmICgheGVuX3N1cHBvcnRfZXZ0Y2huX3JlYmluZCgpKQorCQlyZXR1cm4gLTE7CisKIAkv KiBTZW5kIGZ1dHVyZSBpbnN0YW5jZXMgb2YgdGhpcyBpbnRlcnJ1cHQgdG8gb3RoZXIgdmNwdS4g Ki8KIAliaW5kX3ZjcHUucG9ydCA9IGV2dGNobjsKIAliaW5kX3ZjcHUudmNwdSA9IHhlbl92Y3B1 X25yKHRjcHUpOwpAQCAtMTY0NSwxNSArMTY0OCwyMCBAQCB2b2lkIHhlbl9jYWxsYmFja192ZWN0 b3Iodm9pZCkKIHsKIAlpbnQgcmM7CiAJdWludDY0X3QgY2FsbGJhY2tfdmlhOwotCi0JY2FsbGJh Y2tfdmlhID0gSFZNX0NBTExCQUNLX1ZFQ1RPUihIWVBFUlZJU09SX0NBTExCQUNLX1ZFQ1RPUik7 Ci0JcmMgPSB4ZW5fc2V0X2NhbGxiYWNrX3ZpYShjYWxsYmFja192aWEpOwotCUJVR19PTihyYyk7 Ci0JcHJfaW5mbygiWGVuIEhWTSBjYWxsYmFjayB2ZWN0b3IgZm9yIGV2ZW50IGRlbGl2ZXJ5IGlz IGVuYWJsZWRcbiIpOwotCS8qIGluIHRoZSByZXN0b3JlIGNhc2UgdGhlIHZlY3RvciBoYXMgYWxy ZWFkeSBiZWVuIGFsbG9jYXRlZCAqLwotCWlmICghdGVzdF9iaXQoSFlQRVJWSVNPUl9DQUxMQkFD S19WRUNUT1IsIHVzZWRfdmVjdG9ycykpCi0JCWFsbG9jX2ludHJfZ2F0ZShIWVBFUlZJU09SX0NB TExCQUNLX1ZFQ1RPUiwKLQkJCQl4ZW5faHZtX2NhbGxiYWNrX3ZlY3Rvcik7CisJaWYgKHhlbl9o YXZlX3ZlY3Rvcl9jYWxsYmFjaykgeworCQljYWxsYmFja192aWEgPSBIVk1fQ0FMTEJBQ0tfVkVD VE9SKEhZUEVSVklTT1JfQ0FMTEJBQ0tfVkVDVE9SKTsKKwkJcmMgPSB4ZW5fc2V0X2NhbGxiYWNr X3ZpYShjYWxsYmFja192aWEpOworCQlpZiAocmMpIHsKKwkJCXByX2VycigiUmVxdWVzdCBmb3Ig WGVuIEhWTSBjYWxsYmFjayB2ZWN0b3IgZmFpbGVkXG4iKTsKKwkJCXhlbl9oYXZlX3ZlY3Rvcl9j YWxsYmFjayA9IDA7CisJCQlyZXR1cm47CisJCX0KKwkJcHJfaW5mbygiWGVuIEhWTSBjYWxsYmFj ayB2ZWN0b3IgZm9yIGV2ZW50IGRlbGl2ZXJ5IGlzIGVuYWJsZWRcbiIpOworCQkvKiBpbiB0aGUg cmVzdG9yZSBjYXNlIHRoZSB2ZWN0b3IgaGFzIGFscmVhZHkgYmVlbiBhbGxvY2F0ZWQgKi8KKwkJ aWYgKCF0ZXN0X2JpdChIWVBFUlZJU09SX0NBTExCQUNLX1ZFQ1RPUiwgdXNlZF92ZWN0b3JzKSkK KwkJCWFsbG9jX2ludHJfZ2F0ZShIWVBFUlZJU09SX0NBTExCQUNLX1ZFQ1RPUiwKKwkJCQkJeGVu X2h2bV9jYWxsYmFja192ZWN0b3IpOworCX0KIH0KICNlbHNlCiB2b2lkIHhlbl9jYWxsYmFja192 ZWN0b3Iodm9pZCkge30KLS0tIGEvZHJpdmVycy94ZW4vcGxhdGZvcm0tcGNpLmMKKysrIGIvZHJp dmVycy94ZW4vcGxhdGZvcm0tcGNpLmMKQEAgLTY3LDcgKzY3LDcgQEAgc3RhdGljIHVpbnQ2NF90 IGdldF9jYWxsYmFja192aWEoc3RydWN0CiAJcGluID0gcGRldi0+cGluOwogCiAJLyogV2UgZG9u J3Qga25vdyB0aGUgR1NJLiBTcGVjaWZ5IHRoZSBQQ0kgSU5UeCBsaW5lIGluc3RlYWQuICovCi0J cmV0dXJuICgodWludDY0X3QpMHgwMSA8PCBIVk1fQ0FMTEJBQ0tfVklBX1RZUEVfU0hJRlQpIHwg LyogUENJIElOVHggaWRlbnRpZmllciAqLworCXJldHVybiAoKHVpbnQ2NF90KTB4MDEgPDwgNTYp IHwgLyogUENJIElOVHggaWRlbnRpZmllciAqLwogCQkoKHVpbnQ2NF90KXBjaV9kb21haW5fbnIo cGRldi0+YnVzKSA8PCAzMikgfAogCQkoKHVpbnQ2NF90KXBkZXYtPmJ1cy0+bnVtYmVyIDw8IDE2 KSB8CiAJCSgodWludDY0X3QpKHBkZXYtPmRldmZuICYgMHhmZikgPDwgOCkgfApAQCAtOTAsNyAr OTAsNyBAQCBzdGF0aWMgaW50IHhlbl9hbGxvY2F0ZV9pcnEoc3RydWN0IHBjaV9kCiBzdGF0aWMg aW50IHBsYXRmb3JtX3BjaV9yZXN1bWUoc3RydWN0IHBjaV9kZXYgKnBkZXYpCiB7CiAJaW50IGVy cjsKLQlpZiAoIXhlbl9wdl9kb21haW4oKSkKKwlpZiAoeGVuX2hhdmVfdmVjdG9yX2NhbGxiYWNr KQogCQlyZXR1cm4gMDsKIAllcnIgPSB4ZW5fc2V0X2NhbGxiYWNrX3ZpYShjYWxsYmFja192aWEp OwogCWlmIChlcnIpIHsKQEAgLTEzOCwxNCArMTM4LDcgQEAgc3RhdGljIGludCBwbGF0Zm9ybV9w Y2lfcHJvYmUoc3RydWN0IHBjaQogCXBsYXRmb3JtX21taW8gPSBtbWlvX2FkZHI7CiAJcGxhdGZv cm1fbW1pb2xlbiA9IG1taW9fbGVuOwogCi0JLyogCi0JICogWGVuIEhWTSBndWVzdHMgYWx3YXlz IHVzZSB0aGUgdmVjdG9yIGNhbGxiYWNrIG1lY2hhbmlzbS4KLQkgKiBMMSBEb20wIGluIGEgbmVz dGVkIFhlbiBlbnZpcm9ubWVudCBpcyBhIFBWIGd1ZXN0IGluc2lkZSBpbiBhbgotCSAqIEhWTSBl bnZpcm9ubWVudC4gSXQgbmVlZHMgdGhlIHBsYXRmb3JtLXBjaSBkcml2ZXIgdG8gZ2V0Ci0JICog bm90aWZpY2F0aW9ucyBmcm9tIEwwIFhlbiwgYnV0IGl0IGNhbm5vdCB1c2UgdGhlIHZlY3RvciBj YWxsYmFjawotCSAqIGFzIGl0IGlzIG5vdCBleHBvcnRlZCBieSBMMSBYZW4uCi0JICovCi0JaWYg KHhlbl9wdl9kb21haW4oKSkgeworCWlmICgheGVuX2hhdmVfdmVjdG9yX2NhbGxiYWNrKSB7CiAJ CXJldCA9IHhlbl9hbGxvY2F0ZV9pcnEocGRldik7CiAJCWlmIChyZXQpIHsKIAkJCWRldl93YXJu KCZwZGV2LT5kZXYsICJyZXF1ZXN0X2lycSBmYWlsZWQgZXJyPSVkXG4iLCByZXQpOwotLS0gYS9p bmNsdWRlL3hlbi94ZW4uaAorKysgYi9pbmNsdWRlL3hlbi94ZW4uaApAQCAtMzgsNyArMzgsOCBA QCBleHRlcm4gZW51bSB4ZW5fZG9tYWluX3R5cGUgeGVuX2RvbWFpbl90CiAgKi8KICNpbmNsdWRl IDx4ZW4vZmVhdHVyZXMuaD4KICNkZWZpbmUgeGVuX3B2aF9kb21haW4oKSAoeGVuX3B2X2RvbWFp bigpICYmIFwKLQkJCSAgeGVuX2ZlYXR1cmUoWEVORkVBVF9hdXRvX3RyYW5zbGF0ZWRfcGh5c21h cCkpCisJCQkgIHhlbl9mZWF0dXJlKFhFTkZFQVRfYXV0b190cmFuc2xhdGVkX3BoeXNtYXApICYm IFwKKwkJCSAgeGVuX2hhdmVfdmVjdG9yX2NhbGxiYWNrKQogI2Vsc2UKICNkZWZpbmUgeGVuX3B2 aF9kb21haW4oKQkoMCkKICNlbmRpZgoKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54 ZW4ub3JnCmh0dHBzOi8vbGlzdHMueGVuLm9yZy94ZW4tZGV2ZWwK