From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: 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.11 27/28] xen: Revert commits da72ff5bfcb0 and 72a9b186292d Date: Thu, 11 May 2017 16:12:44 +0200 Message-Id: <20170511141222.882133049@linuxfoundation.org> In-Reply-To: <20170511141221.109842231@linuxfoundation.org> References: <20170511141221.109842231@linuxfoundation.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Sender: linux-kernel-owner@vger.kernel.org List-ID: 4.11-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 | 16 +++++++++++----- 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 +++---------- 7 files changed, 50 insertions(+), 25 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 @@ -138,6 +138,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); @@ -1861,7 +1863,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); @@ -1877,7 +1881,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; @@ -1916,8 +1922,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(); @@ -1958,7 +1964,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 @@ -742,6 +742,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); From mboxrd@z Thu Jan 1 00:00:00 1970 From: Greg Kroah-Hartman Subject: [PATCH 4.11 27/28] xen: Revert commits da72ff5bfcb0 and 72a9b186292d Date: Thu, 11 May 2017 16:12:44 +0200 Message-ID: <20170511141222.882133049@linuxfoundation.org> References: <20170511141221.109842231@linuxfoundation.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1d8orW-0007Fe-C4 for xen-devel@lists.xenproject.org; Thu, 11 May 2017 14:14:38 +0000 In-Reply-To: <20170511141221.109842231@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 NC4xMS1zdGFibGUgcmV2aWV3IHBhdGNoLiAgSWYgYW55b25lIGhhcyBhbnkgb2JqZWN0aW9ucywg 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 ZW4vZW5saWdodGVuLmMgICAgICAgICAgfCAgIDE2ICsrKysrKysrKysrLS0tLS0KIGFyY2gveDg2 L3hlbi9zbXAuYyAgICAgICAgICAgICAgICB8ICAgIDIgKysKIGFyY2gveDg2L3hlbi90aW1lLmMg ICAgICAgICAgICAgICB8ICAgIDUgKysrKysKIGRyaXZlcnMveGVuL2V2ZW50cy9ldmVudHNfYmFz ZS5jICB8ICAgMjYgKysrKysrKysrKysrKysrKystLS0tLS0tLS0KIGRyaXZlcnMveGVuL3BsYXRm b3JtLXBjaS5jICAgICAgICB8ICAgMTMgKysrLS0tLS0tLS0tLQogNyBmaWxlcyBjaGFuZ2VkLCA1 MCBpbnNlcnRpb25zKCspLCAyNSBkZWxldGlvbnMoLSkKCi0tLSBhL2FyY2gveDg2L2luY2x1ZGUv YXNtL3hlbi9ldmVudHMuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS94ZW4vZXZlbnRzLmgK QEAgLTIwLDQgKzIwLDE1IEBAIHN0YXRpYyBpbmxpbmUgaW50IHhlbl9pcnFzX2Rpc2FibGVkKHN0 cnUKIC8qIE5vIG5lZWQgZm9yIGEgYmFycmllciAtLSBYQ0hHIGlzIGEgYmFycmllciBvbiB4ODYu ICovCiAjZGVmaW5lIHhjaGdfeGVuX3Vsb25nKHB0ciwgdmFsKSB4Y2hnKChwdHIpLCAodmFsKSkK IAorZXh0ZXJuIGludCB4ZW5faGF2ZV92ZWN0b3JfY2FsbGJhY2s7CisKKy8qCisgKiBFdmVudHMg ZGVsaXZlcmVkIHZpYSBwbGF0Zm9ybSBQQ0kgaW50ZXJydXB0cyBhcmUgYWx3YXlzCisgKiByb3V0 ZWQgdG8gdmNwdSAwIGFuZCBoZW5jZSBjYW5ub3QgYmUgcmVib3VuZC4KKyAqLworc3RhdGljIGlu bGluZSBib29sIHhlbl9zdXBwb3J0X2V2dGNobl9yZWJpbmQodm9pZCkKK3sKKwlyZXR1cm4gKCF4 ZW5faHZtX2RvbWFpbigpIHx8IHhlbl9oYXZlX3ZlY3Rvcl9jYWxsYmFjayk7Cit9CisKICNlbmRp ZiAvKiBfQVNNX1g4Nl9YRU5fRVZFTlRTX0ggKi8KLS0tIGEvYXJjaC94ODYvcGNpL3hlbi5jCisr KyBiL2FyY2gveDg2L3BjaS94ZW4uYwpAQCAtNDQ3LDcgKzQ0Nyw3IEBAIHZvaWQgX19pbml0IHhl bl9tc2lfaW5pdCh2b2lkKQogCiBpbnQgX19pbml0IHBjaV94ZW5faHZtX2luaXQodm9pZCkKIHsK LQlpZiAoIXhlbl9mZWF0dXJlKFhFTkZFQVRfaHZtX3BpcnFzKSkKKwlpZiAoIXhlbl9oYXZlX3Zl Y3Rvcl9jYWxsYmFjayB8fCAheGVuX2ZlYXR1cmUoWEVORkVBVF9odm1fcGlycXMpKQogCQlyZXR1 cm4gMDsKIAogI2lmZGVmIENPTkZJR19BQ1BJCi0tLSBhL2FyY2gveDg2L3hlbi9lbmxpZ2h0ZW4u YworKysgYi9hcmNoL3g4Ni94ZW4vZW5saWdodGVuLmMKQEAgLTEzOCw2ICsxMzgsOCBAQCBzdHJ1 Y3Qgc2hhcmVkX2luZm8geGVuX2R1bW15X3NoYXJlZF9pbmZvCiB2b2lkICp4ZW5faW5pdGlhbF9n ZHQ7CiAKIFJFU0VSVkVfQlJLKHNoYXJlZF9pbmZvX3BhZ2VfYnJrLCBQQUdFX1NJWkUpOworX19y ZWFkX21vc3RseSBpbnQgeGVuX2hhdmVfdmVjdG9yX2NhbGxiYWNrOworRVhQT1JUX1NZTUJPTF9H UEwoeGVuX2hhdmVfdmVjdG9yX2NhbGxiYWNrKTsKIAogc3RhdGljIGludCB4ZW5fY3B1X3VwX3By ZXBhcmUodW5zaWduZWQgaW50IGNwdSk7CiBzdGF0aWMgaW50IHhlbl9jcHVfdXBfb25saW5lKHVu c2lnbmVkIGludCBjcHUpOwpAQCAtMTg2MSw3ICsxODYzLDkgQEAgc3RhdGljIGludCB4ZW5fY3B1 X3VwX3ByZXBhcmUodW5zaWduZWQgaQogCQl4ZW5fdmNwdV9zZXR1cChjcHUpOwogCX0KIAotCWlm ICh4ZW5fcHZfZG9tYWluKCkgfHwgeGVuX2ZlYXR1cmUoWEVORkVBVF9odm1fc2FmZV9wdmNsb2Nr KSkKKwlpZiAoeGVuX3B2X2RvbWFpbigpIHx8CisJICAgICh4ZW5faGF2ZV92ZWN0b3JfY2FsbGJh Y2sgJiYKKwkgICAgIHhlbl9mZWF0dXJlKFhFTkZFQVRfaHZtX3NhZmVfcHZjbG9jaykpKQogCQl4 ZW5fc2V0dXBfdGltZXIoY3B1KTsKIAogCXJjID0geGVuX3NtcF9pbnRyX2luaXQoY3B1KTsKQEAg LTE4NzcsNyArMTg4MSw5IEBAIHN0YXRpYyBpbnQgeGVuX2NwdV9kZWFkKHVuc2lnbmVkIGludCBj cHUKIHsKIAl4ZW5fc21wX2ludHJfZnJlZShjcHUpOwogCi0JaWYgKHhlbl9wdl9kb21haW4oKSB8 fCB4ZW5fZmVhdHVyZShYRU5GRUFUX2h2bV9zYWZlX3B2Y2xvY2spKQorCWlmICh4ZW5fcHZfZG9t YWluKCkgfHwKKwkgICAgKHhlbl9oYXZlX3ZlY3Rvcl9jYWxsYmFjayAmJgorCSAgICAgeGVuX2Zl YXR1cmUoWEVORkVBVF9odm1fc2FmZV9wdmNsb2NrKSkpCiAJCXhlbl90ZWFyZG93bl90aW1lcihj cHUpOwogCiAJcmV0dXJuIDA7CkBAIC0xOTE2LDggKzE5MjIsOCBAQCBzdGF0aWMgdm9pZCBfX2lu aXQgeGVuX2h2bV9ndWVzdF9pbml0KHZvCiAKIAl4ZW5fcGFuaWNfaGFuZGxlcl9pbml0KCk7CiAK LQlCVUdfT04oIXhlbl9mZWF0dXJlKFhFTkZFQVRfaHZtX2NhbGxiYWNrX3ZlY3RvcikpOwotCisJ aWYgKHhlbl9mZWF0dXJlKFhFTkZFQVRfaHZtX2NhbGxiYWNrX3ZlY3RvcikpCisJCXhlbl9oYXZl X3ZlY3Rvcl9jYWxsYmFjayA9IDE7CiAJeGVuX2h2bV9zbXBfaW5pdCgpOwogCVdBUk5fT04oeGVu X2NwdWhwX3NldHVwKCkpOwogCXhlbl91bnBsdWdfZW11bGF0ZWRfZGV2aWNlcygpOwpAQCAtMTk1 OCw3ICsxOTY0LDcgQEAgYm9vbCB4ZW5faHZtX25lZWRfbGFwaWModm9pZCkKIAkJcmV0dXJuIGZh bHNlOwogCWlmICgheGVuX2h2bV9kb21haW4oKSkKIAkJcmV0dXJuIGZhbHNlOwotCWlmICh4ZW5f ZmVhdHVyZShYRU5GRUFUX2h2bV9waXJxcykpCisJaWYgKHhlbl9mZWF0dXJlKFhFTkZFQVRfaHZt X3BpcnFzKSAmJiB4ZW5faGF2ZV92ZWN0b3JfY2FsbGJhY2spCiAJCXJldHVybiBmYWxzZTsKIAly ZXR1cm4gdHJ1ZTsKIH0KLS0tIGEvYXJjaC94ODYveGVuL3NtcC5jCisrKyBiL2FyY2gveDg2L3hl bi9zbXAuYwpAQCAtNzQyLDYgKzc0Miw4IEBAIHN0YXRpYyB2b2lkIF9faW5pdCB4ZW5faHZtX3Nt cF9wcmVwYXJlX2MKIAogdm9pZCBfX2luaXQgeGVuX2h2bV9zbXBfaW5pdCh2b2lkKQogeworCWlm ICgheGVuX2hhdmVfdmVjdG9yX2NhbGxiYWNrKQorCQlyZXR1cm47CiAJc21wX29wcy5zbXBfcHJl cGFyZV9jcHVzID0geGVuX2h2bV9zbXBfcHJlcGFyZV9jcHVzOwogCXNtcF9vcHMuc21wX3NlbmRf cmVzY2hlZHVsZSA9IHhlbl9zbXBfc2VuZF9yZXNjaGVkdWxlOwogCXNtcF9vcHMuY3B1X2RpZSA9 IHhlbl9jcHVfZGllOwotLS0gYS9hcmNoL3g4Ni94ZW4vdGltZS5jCisrKyBiL2FyY2gveDg2L3hl bi90aW1lLmMKQEAgLTQzMiw2ICs0MzIsMTEgQEAgc3RhdGljIHZvaWQgeGVuX2h2bV9zZXR1cF9j cHVfY2xvY2tldmVudAogCiB2b2lkIF9faW5pdCB4ZW5faHZtX2luaXRfdGltZV9vcHModm9pZCkK IHsKKwkvKiB2ZWN0b3IgY2FsbGJhY2sgaXMgbmVlZGVkIG90aGVyd2lzZSB3ZSBjYW5ub3QgcmVj ZWl2ZSBpbnRlcnJ1cHRzCisJICogb24gY3B1ID4gMCBhbmQgYXQgdGhpcyBwb2ludCB3ZSBkb24n dCBrbm93IGhvdyBtYW55IGNwdXMgYXJlCisJICogYXZhaWxhYmxlICovCisJaWYgKCF4ZW5faGF2 ZV92ZWN0b3JfY2FsbGJhY2spCisJCXJldHVybjsKIAlpZiAoIXhlbl9mZWF0dXJlKFhFTkZFQVRf aHZtX3NhZmVfcHZjbG9jaykpIHsKIAkJcHJpbnRrKEtFUk5fSU5GTyAiWGVuIGRvZXNuJ3Qgc3Vw cG9ydCBwdmNsb2NrIG9uIEhWTSwiCiAJCQkJImRpc2FibGUgcHYgdGltZXJcbiIpOwotLS0gYS9k cml2ZXJzL3hlbi9ldmVudHMvZXZlbnRzX2Jhc2UuYworKysgYi9kcml2ZXJzL3hlbi9ldmVudHMv ZXZlbnRzX2Jhc2UuYwpAQCAtMTMxMiw2ICsxMzEyLDkgQEAgc3RhdGljIGludCByZWJpbmRfaXJx X3RvX2NwdSh1bnNpZ25lZCBpcgogCWlmICghVkFMSURfRVZUQ0hOKGV2dGNobikpCiAJCXJldHVy biAtMTsKIAorCWlmICgheGVuX3N1cHBvcnRfZXZ0Y2huX3JlYmluZCgpKQorCQlyZXR1cm4gLTE7 CisKIAkvKiBTZW5kIGZ1dHVyZSBpbnN0YW5jZXMgb2YgdGhpcyBpbnRlcnJ1cHQgdG8gb3RoZXIg dmNwdS4gKi8KIAliaW5kX3ZjcHUucG9ydCA9IGV2dGNobjsKIAliaW5kX3ZjcHUudmNwdSA9IHhl bl92Y3B1X25yKHRjcHUpOwpAQCAtMTY0NSwxNSArMTY0OCwyMCBAQCB2b2lkIHhlbl9jYWxsYmFj a192ZWN0b3Iodm9pZCkKIHsKIAlpbnQgcmM7CiAJdWludDY0X3QgY2FsbGJhY2tfdmlhOwotCi0J Y2FsbGJhY2tfdmlhID0gSFZNX0NBTExCQUNLX1ZFQ1RPUihIWVBFUlZJU09SX0NBTExCQUNLX1ZF Q1RPUik7Ci0JcmMgPSB4ZW5fc2V0X2NhbGxiYWNrX3ZpYShjYWxsYmFja192aWEpOwotCUJVR19P TihyYyk7Ci0JcHJfaW5mbygiWGVuIEhWTSBjYWxsYmFjayB2ZWN0b3IgZm9yIGV2ZW50IGRlbGl2 ZXJ5IGlzIGVuYWJsZWRcbiIpOwotCS8qIGluIHRoZSByZXN0b3JlIGNhc2UgdGhlIHZlY3RvciBo YXMgYWxyZWFkeSBiZWVuIGFsbG9jYXRlZCAqLwotCWlmICghdGVzdF9iaXQoSFlQRVJWSVNPUl9D QUxMQkFDS19WRUNUT1IsIHVzZWRfdmVjdG9ycykpCi0JCWFsbG9jX2ludHJfZ2F0ZShIWVBFUlZJ U09SX0NBTExCQUNLX1ZFQ1RPUiwKLQkJCQl4ZW5faHZtX2NhbGxiYWNrX3ZlY3Rvcik7CisJaWYg KHhlbl9oYXZlX3ZlY3Rvcl9jYWxsYmFjaykgeworCQljYWxsYmFja192aWEgPSBIVk1fQ0FMTEJB Q0tfVkVDVE9SKEhZUEVSVklTT1JfQ0FMTEJBQ0tfVkVDVE9SKTsKKwkJcmMgPSB4ZW5fc2V0X2Nh bGxiYWNrX3ZpYShjYWxsYmFja192aWEpOworCQlpZiAocmMpIHsKKwkJCXByX2VycigiUmVxdWVz dCBmb3IgWGVuIEhWTSBjYWxsYmFjayB2ZWN0b3IgZmFpbGVkXG4iKTsKKwkJCXhlbl9oYXZlX3Zl Y3Rvcl9jYWxsYmFjayA9IDA7CisJCQlyZXR1cm47CisJCX0KKwkJcHJfaW5mbygiWGVuIEhWTSBj YWxsYmFjayB2ZWN0b3IgZm9yIGV2ZW50IGRlbGl2ZXJ5IGlzIGVuYWJsZWRcbiIpOworCQkvKiBp biB0aGUgcmVzdG9yZSBjYXNlIHRoZSB2ZWN0b3IgaGFzIGFscmVhZHkgYmVlbiBhbGxvY2F0ZWQg Ki8KKwkJaWYgKCF0ZXN0X2JpdChIWVBFUlZJU09SX0NBTExCQUNLX1ZFQ1RPUiwgdXNlZF92ZWN0 b3JzKSkKKwkJCWFsbG9jX2ludHJfZ2F0ZShIWVBFUlZJU09SX0NBTExCQUNLX1ZFQ1RPUiwKKwkJ CQkJeGVuX2h2bV9jYWxsYmFja192ZWN0b3IpOworCX0KIH0KICNlbHNlCiB2b2lkIHhlbl9jYWxs YmFja192ZWN0b3Iodm9pZCkge30KLS0tIGEvZHJpdmVycy94ZW4vcGxhdGZvcm0tcGNpLmMKKysr IGIvZHJpdmVycy94ZW4vcGxhdGZvcm0tcGNpLmMKQEAgLTY3LDcgKzY3LDcgQEAgc3RhdGljIHVp bnQ2NF90IGdldF9jYWxsYmFja192aWEoc3RydWN0CiAJcGluID0gcGRldi0+cGluOwogCiAJLyog V2UgZG9uJ3Qga25vdyB0aGUgR1NJLiBTcGVjaWZ5IHRoZSBQQ0kgSU5UeCBsaW5lIGluc3RlYWQu ICovCi0JcmV0dXJuICgodWludDY0X3QpMHgwMSA8PCBIVk1fQ0FMTEJBQ0tfVklBX1RZUEVfU0hJ RlQpIHwgLyogUENJIElOVHggaWRlbnRpZmllciAqLworCXJldHVybiAoKHVpbnQ2NF90KTB4MDEg PDwgNTYpIHwgLyogUENJIElOVHggaWRlbnRpZmllciAqLwogCQkoKHVpbnQ2NF90KXBjaV9kb21h aW5fbnIocGRldi0+YnVzKSA8PCAzMikgfAogCQkoKHVpbnQ2NF90KXBkZXYtPmJ1cy0+bnVtYmVy IDw8IDE2KSB8CiAJCSgodWludDY0X3QpKHBkZXYtPmRldmZuICYgMHhmZikgPDwgOCkgfApAQCAt OTAsNyArOTAsNyBAQCBzdGF0aWMgaW50IHhlbl9hbGxvY2F0ZV9pcnEoc3RydWN0IHBjaV9kCiBz dGF0aWMgaW50IHBsYXRmb3JtX3BjaV9yZXN1bWUoc3RydWN0IHBjaV9kZXYgKnBkZXYpCiB7CiAJ aW50IGVycjsKLQlpZiAoIXhlbl9wdl9kb21haW4oKSkKKwlpZiAoeGVuX2hhdmVfdmVjdG9yX2Nh bGxiYWNrKQogCQlyZXR1cm4gMDsKIAllcnIgPSB4ZW5fc2V0X2NhbGxiYWNrX3ZpYShjYWxsYmFj a192aWEpOwogCWlmIChlcnIpIHsKQEAgLTEzOCwxNCArMTM4LDcgQEAgc3RhdGljIGludCBwbGF0 Zm9ybV9wY2lfcHJvYmUoc3RydWN0IHBjaQogCXBsYXRmb3JtX21taW8gPSBtbWlvX2FkZHI7CiAJ cGxhdGZvcm1fbW1pb2xlbiA9IG1taW9fbGVuOwogCi0JLyogCi0JICogWGVuIEhWTSBndWVzdHMg YWx3YXlzIHVzZSB0aGUgdmVjdG9yIGNhbGxiYWNrIG1lY2hhbmlzbS4KLQkgKiBMMSBEb20wIGlu IGEgbmVzdGVkIFhlbiBlbnZpcm9ubWVudCBpcyBhIFBWIGd1ZXN0IGluc2lkZSBpbiBhbgotCSAq IEhWTSBlbnZpcm9ubWVudC4gSXQgbmVlZHMgdGhlIHBsYXRmb3JtLXBjaSBkcml2ZXIgdG8gZ2V0 Ci0JICogbm90aWZpY2F0aW9ucyBmcm9tIEwwIFhlbiwgYnV0IGl0IGNhbm5vdCB1c2UgdGhlIHZl Y3RvciBjYWxsYmFjawotCSAqIGFzIGl0IGlzIG5vdCBleHBvcnRlZCBieSBMMSBYZW4uCi0JICov Ci0JaWYgKHhlbl9wdl9kb21haW4oKSkgeworCWlmICgheGVuX2hhdmVfdmVjdG9yX2NhbGxiYWNr KSB7CiAJCXJldCA9IHhlbl9hbGxvY2F0ZV9pcnEocGRldik7CiAJCWlmIChyZXQpIHsKIAkJCWRl dl93YXJuKCZwZGV2LT5kZXYsICJyZXF1ZXN0X2lycSBmYWlsZWQgZXJyPSVkXG4iLCByZXQpOwoK CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2 ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW4ub3JnCmh0dHBzOi8vbGlzdHMueGVu Lm9yZy94ZW4tZGV2ZWwK