From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S940189AbdAFWY6 (ORCPT ); Fri, 6 Jan 2017 17:24:58 -0500 Received: from mail.linuxfoundation.org ([140.211.169.12]:55634 "EHLO mail.linuxfoundation.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S968788AbdAFWAQ (ORCPT ); Fri, 6 Jan 2017 17:00:16 -0500 From: Greg Kroah-Hartman To: linux-kernel@vger.kernel.org Cc: Greg Kroah-Hartman , stable@vger.kernel.org, Boris Ostrovsky , Thomas Gleixner , Juergen Gross , Peter Zijlstra , "M. Vefa Bicakci" , xen-devel , "Charles (Chas) Williams" , Borislav Petkov , Alok Kataria Subject: [PATCH 4.9 079/116] x86/smpboot: Make logical package management more robust Date: Fri, 6 Jan 2017 22:44:01 +0100 Message-Id: <20170106213912.347392169@linuxfoundation.org> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20170106213908.681421800@linuxfoundation.org> References: <20170106213908.681421800@linuxfoundation.org> User-Agent: quilt/0.65 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 4.9-stable review patch. If anyone has any objections, please let me know. ------------------ From: Thomas Gleixner commit 9d85eb9119f4eeeb48e87adfcd71f752655700e9 upstream. The logical package management has several issues: - The APIC ids provided by ACPI are not required to be the same as the initial APIC id which can be retrieved by CPUID. The APIC ids provided by ACPI are those which are written by the BIOS into the APIC. The initial id is set by hardware and can not be changed. The hardware provided ids contain the real hardware package information. Especially AMD sets the effective APIC id different from the hardware id as they need to reserve space for the IOAPIC ids starting at id 0. As a consequence those machines trigger the currently active firmware bug printouts in dmesg, These are obviously wrong. - Virtual machines have their own interesting of enumerating APICs and packages which are not reliably covered by the current implementation. The sizing of the mapping array has been tweaked to be generously large to handle systems which provide a wrong core count when HT is disabled so the whole magic which checks for space in the physical hotplug case is not needed anymore. Simplify the whole machinery and do the mapping when the CPU starts and the CPUID derived physical package information is available. This solves the observed problems on AMD machines and works for the virtualization issues as well. Remove the extra call from XEN cpu bringup code as it is not longer required. Fixes: d49597fd3bc7 ("x86/cpu: Deal with broken firmware (VMWare/XEN)") Reported-and-tested-by: Borislav Petkov Tested-by: Boris Ostrovsky Signed-off-by: Thomas Gleixner Cc: Juergen Gross Cc: Peter Zijlstra Cc: M. Vefa Bicakci Cc: xen-devel Cc: Charles (Chas) Williams Cc: Borislav Petkov Cc: Alok Kataria Link: http://lkml.kernel.org/r/alpine.DEB.2.20.1612121102260.3429@nanos Signed-off-by: Thomas Gleixner Signed-off-by: Greg Kroah-Hartman --- arch/x86/kernel/apic/apic.c | 15 ------------ arch/x86/kernel/cpu/common.c | 24 ++++++-------------- arch/x86/kernel/smpboot.c | 51 ++++++++++++++++--------------------------- arch/x86/xen/smp.c | 6 ----- 4 files changed, 27 insertions(+), 69 deletions(-) --- a/arch/x86/kernel/apic/apic.c +++ b/arch/x86/kernel/apic/apic.c @@ -2159,21 +2159,6 @@ int __generic_processor_info(int apicid, } /* - * This can happen on physical hotplug. The sanity check at boot time - * is done from native_smp_prepare_cpus() after num_possible_cpus() is - * established. - */ - if (topology_update_package_map(apicid, cpu) < 0) { - int thiscpu = max + disabled_cpus; - - pr_warning("APIC: Package limit reached. Processor %d/0x%x ignored.\n", - thiscpu, apicid); - - disabled_cpus++; - return -ENOSPC; - } - - /* * Validate version */ if (version == 0x0) { --- a/arch/x86/kernel/cpu/common.c +++ b/arch/x86/kernel/cpu/common.c @@ -979,29 +979,21 @@ static void x86_init_cache_qos(struct cp } /* - * The physical to logical package id mapping is initialized from the - * acpi/mptables information. Make sure that CPUID actually agrees with - * that. + * Validate that ACPI/mptables have the same information about the + * effective APIC id and update the package map. */ -static void sanitize_package_id(struct cpuinfo_x86 *c) +static void validate_apic_and_package_id(struct cpuinfo_x86 *c) { #ifdef CONFIG_SMP - unsigned int pkg, apicid, cpu = smp_processor_id(); + unsigned int apicid, cpu = smp_processor_id(); apicid = apic->cpu_present_to_apicid(cpu); - pkg = apicid >> boot_cpu_data.x86_coreid_bits; - if (apicid != c->initial_apicid) { - pr_err(FW_BUG "CPU%u: APIC id mismatch. Firmware: %x CPUID: %x\n", + if (apicid != c->apicid) { + pr_err(FW_BUG "CPU%u: APIC id mismatch. Firmware: %x APIC: %x\n", cpu, apicid, c->initial_apicid); - c->initial_apicid = apicid; } - if (pkg != c->phys_proc_id) { - pr_err(FW_BUG "CPU%u: Using firmware package id %u instead of %u\n", - cpu, pkg, c->phys_proc_id); - c->phys_proc_id = pkg; - } - c->logical_proc_id = topology_phys_to_logical_pkg(pkg); + BUG_ON(topology_update_package_map(c->phys_proc_id, cpu)); #else c->logical_proc_id = 0; #endif @@ -1132,7 +1124,6 @@ static void identify_cpu(struct cpuinfo_ #ifdef CONFIG_NUMA numa_add_cpu(smp_processor_id()); #endif - sanitize_package_id(c); } /* @@ -1188,6 +1179,7 @@ void identify_secondary_cpu(struct cpuin enable_sep_cpu(); #endif mtrr_ap_init(); + validate_apic_and_package_id(c); } struct msr_range { --- a/arch/x86/kernel/smpboot.c +++ b/arch/x86/kernel/smpboot.c @@ -104,7 +104,6 @@ static unsigned int max_physical_pkg_id unsigned int __max_logical_packages __read_mostly; EXPORT_SYMBOL(__max_logical_packages); static unsigned int logical_packages __read_mostly; -static bool logical_packages_frozen __read_mostly; /* Maximum number of SMT threads on any online core */ int __max_smt_threads __read_mostly; @@ -263,9 +262,14 @@ static void notrace start_secondary(void cpu_startup_entry(CPUHP_AP_ONLINE_IDLE); } -int topology_update_package_map(unsigned int apicid, unsigned int cpu) +/** + * topology_update_package_map - Update the physical to logical package map + * @pkg: The physical package id as retrieved via CPUID + * @cpu: The cpu for which this is updated + */ +int topology_update_package_map(unsigned int pkg, unsigned int cpu) { - unsigned int new, pkg = apicid >> boot_cpu_data.x86_coreid_bits; + unsigned int new; /* Called from early boot ? */ if (!physical_package_map) @@ -278,16 +282,17 @@ int topology_update_package_map(unsigned if (test_and_set_bit(pkg, physical_package_map)) goto found; - if (logical_packages_frozen) { - physical_to_logical_pkg[pkg] = -1; - pr_warn("APIC(%x) Package %u exceeds logical package max\n", - apicid, pkg); + if (logical_packages >= __max_logical_packages) { + pr_warn("Package %u of CPU %u exceeds BIOS package data %u.\n", + logical_packages, cpu, __max_logical_packages); return -ENOSPC; } new = logical_packages++; - pr_info("APIC(%x) Converting physical %u to logical package %u\n", - apicid, pkg, new); + if (new != pkg) { + pr_info("CPU %u Converting physical %u to logical package %u\n", + cpu, pkg, new); + } physical_to_logical_pkg[pkg] = new; found: @@ -308,9 +313,9 @@ int topology_phys_to_logical_pkg(unsigne } EXPORT_SYMBOL(topology_phys_to_logical_pkg); -static void __init smp_init_package_map(void) +static void __init smp_init_package_map(struct cpuinfo_x86 *c, unsigned int cpu) { - unsigned int ncpus, cpu; + unsigned int ncpus; size_t size; /* @@ -355,27 +360,9 @@ static void __init smp_init_package_map( size = BITS_TO_LONGS(max_physical_pkg_id) * sizeof(unsigned long); physical_package_map = kzalloc(size, GFP_KERNEL); - for_each_present_cpu(cpu) { - unsigned int apicid = apic->cpu_present_to_apicid(cpu); - - if (apicid == BAD_APICID || !apic->apic_id_valid(apicid)) - continue; - if (!topology_update_package_map(apicid, cpu)) - continue; - pr_warn("CPU %u APICId %x disabled\n", cpu, apicid); - per_cpu(x86_bios_cpu_apicid, cpu) = BAD_APICID; - set_cpu_possible(cpu, false); - set_cpu_present(cpu, false); - } - - if (logical_packages > __max_logical_packages) { - pr_warn("Detected more packages (%u), then computed by BIOS data (%u).\n", - logical_packages, __max_logical_packages); - logical_packages_frozen = true; - __max_logical_packages = logical_packages; - } - pr_info("Max logical packages: %u\n", __max_logical_packages); + + topology_update_package_map(c->phys_proc_id, cpu); } void __init smp_store_boot_cpu_info(void) @@ -385,7 +372,7 @@ void __init smp_store_boot_cpu_info(void *c = boot_cpu_data; c->cpu_index = id; - smp_init_package_map(); + smp_init_package_map(c, id); } /* --- a/arch/x86/xen/smp.c +++ b/arch/x86/xen/smp.c @@ -87,12 +87,6 @@ static void cpu_bringup(void) cpu_data(cpu).x86_max_cores = 1; set_cpu_sibling_map(cpu); - /* - * identify_cpu() may have set logical_pkg_id to -1 due - * to incorrect phys_proc_id. Let's re-comupte it. - */ - topology_update_package_map(apic->cpu_present_to_apicid(cpu), cpu); - xen_setup_cpu_clockevents(); notify_cpu_starting(cpu); From mboxrd@z Thu Jan 1 00:00:00 1970 From: Greg Kroah-Hartman Subject: [PATCH 4.9 079/116] x86/smpboot: Make logical package management more robust Date: Fri, 6 Jan 2017 22:44:01 +0100 Message-ID: <20170106213912.347392169@linuxfoundation.org> References: <20170106213908.681421800@linuxfoundation.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20170106213908.681421800@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 , Alok Kataria , Peter Zijlstra , Greg Kroah-Hartman , "M. Vefa Bicakci" , stable@vger.kernel.org, xen-devel , "Charles (Chas) Williams" , Borislav Petkov , Boris Ostrovsky , Thomas Gleixner List-Id: xen-devel@lists.xenproject.org NC45LXN0YWJsZSByZXZpZXcgcGF0Y2guICBJZiBhbnlvbmUgaGFzIGFueSBvYmplY3Rpb25zLCBw bGVhc2UgbGV0IG1lIGtub3cuCgotLS0tLS0tLS0tLS0tLS0tLS0KCkZyb206IFRob21hcyBHbGVp eG5lciA8dGdseEBsaW51dHJvbml4LmRlPgoKY29tbWl0IDlkODVlYjkxMTlmNGVlZWI0OGU4N2Fk ZmNkNzFmNzUyNjU1NzAwZTkgdXBzdHJlYW0uCgpUaGUgbG9naWNhbCBwYWNrYWdlIG1hbmFnZW1l bnQgaGFzIHNldmVyYWwgaXNzdWVzOgoKIC0gVGhlIEFQSUMgaWRzIHByb3ZpZGVkIGJ5IEFDUEkg YXJlIG5vdCByZXF1aXJlZCB0byBiZSB0aGUgc2FtZSBhcyB0aGUKICAgaW5pdGlhbCBBUElDIGlk IHdoaWNoIGNhbiBiZSByZXRyaWV2ZWQgYnkgQ1BVSUQuIFRoZSBBUElDIGlkcyBwcm92aWRlZAog ICBieSBBQ1BJIGFyZSB0aG9zZSB3aGljaCBhcmUgd3JpdHRlbiBieSB0aGUgQklPUyBpbnRvIHRo ZSBBUElDLiBUaGUKICAgaW5pdGlhbCBpZCBpcyBzZXQgYnkgaGFyZHdhcmUgYW5kIGNhbiBub3Qg YmUgY2hhbmdlZC4gVGhlIGhhcmR3YXJlCiAgIHByb3ZpZGVkIGlkcyBjb250YWluIHRoZSByZWFs IGhhcmR3YXJlIHBhY2thZ2UgaW5mb3JtYXRpb24uCgogICBFc3BlY2lhbGx5IEFNRCBzZXRzIHRo ZSBlZmZlY3RpdmUgQVBJQyBpZCBkaWZmZXJlbnQgZnJvbSB0aGUgaGFyZHdhcmUgaWQKICAgYXMg dGhleSBuZWVkIHRvIHJlc2VydmUgc3BhY2UgZm9yIHRoZSBJT0FQSUMgaWRzIHN0YXJ0aW5nIGF0 IGlkIDAuCgogICBBcyBhIGNvbnNlcXVlbmNlIHRob3NlIG1hY2hpbmVzIHRyaWdnZXIgdGhlIGN1 cnJlbnRseSBhY3RpdmUgZmlybXdhcmUKICAgYnVnIHByaW50b3V0cyBpbiBkbWVzZywgVGhlc2Ug YXJlIG9idmlvdXNseSB3cm9uZy4KCiAtIFZpcnR1YWwgbWFjaGluZXMgaGF2ZSB0aGVpciBvd24g aW50ZXJlc3Rpbmcgb2YgZW51bWVyYXRpbmcgQVBJQ3MgYW5kCiAgIHBhY2thZ2VzIHdoaWNoIGFy ZSBub3QgcmVsaWFibHkgY292ZXJlZCBieSB0aGUgY3VycmVudCBpbXBsZW1lbnRhdGlvbi4KClRo ZSBzaXppbmcgb2YgdGhlIG1hcHBpbmcgYXJyYXkgaGFzIGJlZW4gdHdlYWtlZCB0byBiZSBnZW5l cm91c2x5IGxhcmdlIHRvCmhhbmRsZSBzeXN0ZW1zIHdoaWNoIHByb3ZpZGUgYSB3cm9uZyBjb3Jl IGNvdW50IHdoZW4gSFQgaXMgZGlzYWJsZWQgc28gdGhlCndob2xlIG1hZ2ljIHdoaWNoIGNoZWNr cyBmb3Igc3BhY2UgaW4gdGhlIHBoeXNpY2FsIGhvdHBsdWcgY2FzZSBpcyBub3QKbmVlZGVkIGFu eW1vcmUuCgpTaW1wbGlmeSB0aGUgd2hvbGUgbWFjaGluZXJ5IGFuZCBkbyB0aGUgbWFwcGluZyB3 aGVuIHRoZSBDUFUgc3RhcnRzIGFuZCB0aGUKQ1BVSUQgZGVyaXZlZCBwaHlzaWNhbCBwYWNrYWdl IGluZm9ybWF0aW9uIGlzIGF2YWlsYWJsZS4gVGhpcyBzb2x2ZXMgdGhlCm9ic2VydmVkIHByb2Js ZW1zIG9uIEFNRCBtYWNoaW5lcyBhbmQgd29ya3MgZm9yIHRoZSB2aXJ0dWFsaXphdGlvbiBpc3N1 ZXMKYXMgd2VsbC4KClJlbW92ZSB0aGUgZXh0cmEgY2FsbCBmcm9tIFhFTiBjcHUgYnJpbmd1cCBj b2RlIGFzIGl0IGlzIG5vdCBsb25nZXIKcmVxdWlyZWQuCgpGaXhlczogZDQ5NTk3ZmQzYmM3ICgi eDg2L2NwdTogRGVhbCB3aXRoIGJyb2tlbiBmaXJtd2FyZSAoVk1XYXJlL1hFTikiKQpSZXBvcnRl ZC1hbmQtdGVzdGVkLWJ5OiBCb3Jpc2xhdiBQZXRrb3YgPGJwQHN1c2UuZGU+ClRlc3RlZC1ieTog Qm9yaXMgT3N0cm92c2t5IDxib3Jpcy5vc3Ryb3Zza3lAb3JhY2xlLmNvbT4KU2lnbmVkLW9mZi1i eTogVGhvbWFzIEdsZWl4bmVyIDx0Z2x4QGxpbnV0cm9uaXguZGU+CkNjOiBKdWVyZ2VuIEdyb3Nz IDxqZ3Jvc3NAc3VzZS5jb20+CkNjOiBQZXRlciBaaWpsc3RyYSA8cGV0ZXJ6QGluZnJhZGVhZC5v cmc+CkNjOiBNLiBWZWZhIEJpY2FrY2kgPG0udi5iQHJ1bmJveC5jb20+CkNjOiB4ZW4tZGV2ZWwg PHhlbi1kZXZlbEBsaXN0cy54ZW4ub3JnPgpDYzogQ2hhcmxlcyAoQ2hhcykgV2lsbGlhbXMgPGNp d2lsbGlhQGJyb2NhZGUuY29tPgpDYzogQm9yaXNsYXYgUGV0a292IDxicEBhbGllbjguZGU+CkNj OiBBbG9rIEthdGFyaWEgPGFrYXRhcmlhQHZtd2FyZS5jb20+Ckxpbms6IGh0dHA6Ly9sa21sLmtl cm5lbC5vcmcvci9hbHBpbmUuREVCLjIuMjAuMTYxMjEyMTEwMjI2MC4zNDI5QG5hbm9zClNpZ25l ZC1vZmYtYnk6IFRob21hcyBHbGVpeG5lciA8dGdseEBsaW51dHJvbml4LmRlPgpTaWduZWQtb2Zm LWJ5OiBHcmVnIEtyb2FoLUhhcnRtYW4gPGdyZWdraEBsaW51eGZvdW5kYXRpb24ub3JnPgoKLS0t CiBhcmNoL3g4Ni9rZXJuZWwvYXBpYy9hcGljLmMgIHwgICAxNSAtLS0tLS0tLS0tLS0KIGFyY2gv eDg2L2tlcm5lbC9jcHUvY29tbW9uLmMgfCAgIDI0ICsrKysrKy0tLS0tLS0tLS0tLS0tCiBhcmNo L3g4Ni9rZXJuZWwvc21wYm9vdC5jICAgIHwgICA1MSArKysrKysrKysrKysrKysrLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tCiBhcmNoL3g4Ni94ZW4vc21wLmMgICAgICAgICAgIHwgICAgNiAt LS0tLQogNCBmaWxlcyBjaGFuZ2VkLCAyNyBpbnNlcnRpb25zKCspLCA2OSBkZWxldGlvbnMoLSkK Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC9hcGljL2FwaWMuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwv YXBpYy9hcGljLmMKQEAgLTIxNTksMjEgKzIxNTksNiBAQCBpbnQgX19nZW5lcmljX3Byb2Nlc3Nv cl9pbmZvKGludCBhcGljaWQsCiAJfQogCiAJLyoKLQkgKiBUaGlzIGNhbiBoYXBwZW4gb24gcGh5 c2ljYWwgaG90cGx1Zy4gVGhlIHNhbml0eSBjaGVjayBhdCBib290IHRpbWUKLQkgKiBpcyBkb25l IGZyb20gbmF0aXZlX3NtcF9wcmVwYXJlX2NwdXMoKSBhZnRlciBudW1fcG9zc2libGVfY3B1cygp IGlzCi0JICogZXN0YWJsaXNoZWQuCi0JICovCi0JaWYgKHRvcG9sb2d5X3VwZGF0ZV9wYWNrYWdl X21hcChhcGljaWQsIGNwdSkgPCAwKSB7Ci0JCWludCB0aGlzY3B1ID0gbWF4ICsgZGlzYWJsZWRf Y3B1czsKLQotCQlwcl93YXJuaW5nKCJBUElDOiBQYWNrYWdlIGxpbWl0IHJlYWNoZWQuIFByb2Nl c3NvciAlZC8weCV4IGlnbm9yZWQuXG4iLAotCQkJICAgdGhpc2NwdSwgYXBpY2lkKTsKLQotCQlk aXNhYmxlZF9jcHVzKys7Ci0JCXJldHVybiAtRU5PU1BDOwotCX0KLQotCS8qCiAJICogVmFsaWRh dGUgdmVyc2lvbgogCSAqLwogCWlmICh2ZXJzaW9uID09IDB4MCkgewotLS0gYS9hcmNoL3g4Ni9r ZXJuZWwvY3B1L2NvbW1vbi5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9jcHUvY29tbW9uLmMKQEAg LTk3OSwyOSArOTc5LDIxIEBAIHN0YXRpYyB2b2lkIHg4Nl9pbml0X2NhY2hlX3FvcyhzdHJ1Y3Qg Y3AKIH0KIAogLyoKLSAqIFRoZSBwaHlzaWNhbCB0byBsb2dpY2FsIHBhY2thZ2UgaWQgbWFwcGlu ZyBpcyBpbml0aWFsaXplZCBmcm9tIHRoZQotICogYWNwaS9tcHRhYmxlcyBpbmZvcm1hdGlvbi4g TWFrZSBzdXJlIHRoYXQgQ1BVSUQgYWN0dWFsbHkgYWdyZWVzIHdpdGgKLSAqIHRoYXQuCisgKiBW YWxpZGF0ZSB0aGF0IEFDUEkvbXB0YWJsZXMgaGF2ZSB0aGUgc2FtZSBpbmZvcm1hdGlvbiBhYm91 dCB0aGUKKyAqIGVmZmVjdGl2ZSBBUElDIGlkIGFuZCB1cGRhdGUgdGhlIHBhY2thZ2UgbWFwLgog ICovCi1zdGF0aWMgdm9pZCBzYW5pdGl6ZV9wYWNrYWdlX2lkKHN0cnVjdCBjcHVpbmZvX3g4NiAq YykKK3N0YXRpYyB2b2lkIHZhbGlkYXRlX2FwaWNfYW5kX3BhY2thZ2VfaWQoc3RydWN0IGNwdWlu Zm9feDg2ICpjKQogewogI2lmZGVmIENPTkZJR19TTVAKLQl1bnNpZ25lZCBpbnQgcGtnLCBhcGlj aWQsIGNwdSA9IHNtcF9wcm9jZXNzb3JfaWQoKTsKKwl1bnNpZ25lZCBpbnQgYXBpY2lkLCBjcHUg PSBzbXBfcHJvY2Vzc29yX2lkKCk7CiAKIAlhcGljaWQgPSBhcGljLT5jcHVfcHJlc2VudF90b19h cGljaWQoY3B1KTsKLQlwa2cgPSBhcGljaWQgPj4gYm9vdF9jcHVfZGF0YS54ODZfY29yZWlkX2Jp dHM7CiAKLQlpZiAoYXBpY2lkICE9IGMtPmluaXRpYWxfYXBpY2lkKSB7Ci0JCXByX2VycihGV19C VUcgIkNQVSV1OiBBUElDIGlkIG1pc21hdGNoLiBGaXJtd2FyZTogJXggQ1BVSUQ6ICV4XG4iLAor CWlmIChhcGljaWQgIT0gYy0+YXBpY2lkKSB7CisJCXByX2VycihGV19CVUcgIkNQVSV1OiBBUElD IGlkIG1pc21hdGNoLiBGaXJtd2FyZTogJXggQVBJQzogJXhcbiIsCiAJCSAgICAgICBjcHUsIGFw aWNpZCwgYy0+aW5pdGlhbF9hcGljaWQpOwotCQljLT5pbml0aWFsX2FwaWNpZCA9IGFwaWNpZDsK IAl9Ci0JaWYgKHBrZyAhPSBjLT5waHlzX3Byb2NfaWQpIHsKLQkJcHJfZXJyKEZXX0JVRyAiQ1BV JXU6IFVzaW5nIGZpcm13YXJlIHBhY2thZ2UgaWQgJXUgaW5zdGVhZCBvZiAldVxuIiwKLQkJICAg ICAgIGNwdSwgcGtnLCBjLT5waHlzX3Byb2NfaWQpOwotCQljLT5waHlzX3Byb2NfaWQgPSBwa2c7 Ci0JfQotCWMtPmxvZ2ljYWxfcHJvY19pZCA9IHRvcG9sb2d5X3BoeXNfdG9fbG9naWNhbF9wa2co cGtnKTsKKwlCVUdfT04odG9wb2xvZ3lfdXBkYXRlX3BhY2thZ2VfbWFwKGMtPnBoeXNfcHJvY19p ZCwgY3B1KSk7CiAjZWxzZQogCWMtPmxvZ2ljYWxfcHJvY19pZCA9IDA7CiAjZW5kaWYKQEAgLTEx MzIsNyArMTEyNCw2IEBAIHN0YXRpYyB2b2lkIGlkZW50aWZ5X2NwdShzdHJ1Y3QgY3B1aW5mb18K ICNpZmRlZiBDT05GSUdfTlVNQQogCW51bWFfYWRkX2NwdShzbXBfcHJvY2Vzc29yX2lkKCkpOwog I2VuZGlmCi0Jc2FuaXRpemVfcGFja2FnZV9pZChjKTsKIH0KIAogLyoKQEAgLTExODgsNiArMTE3 OSw3IEBAIHZvaWQgaWRlbnRpZnlfc2Vjb25kYXJ5X2NwdShzdHJ1Y3QgY3B1aW4KIAllbmFibGVf c2VwX2NwdSgpOwogI2VuZGlmCiAJbXRycl9hcF9pbml0KCk7CisJdmFsaWRhdGVfYXBpY19hbmRf cGFja2FnZV9pZChjKTsKIH0KIAogc3RydWN0IG1zcl9yYW5nZSB7Ci0tLSBhL2FyY2gveDg2L2tl cm5lbC9zbXBib290LmMKKysrIGIvYXJjaC94ODYva2VybmVsL3NtcGJvb3QuYwpAQCAtMTA0LDcg KzEwNCw2IEBAIHN0YXRpYyB1bnNpZ25lZCBpbnQgbWF4X3BoeXNpY2FsX3BrZ19pZAogdW5zaWdu ZWQgaW50IF9fbWF4X2xvZ2ljYWxfcGFja2FnZXMgX19yZWFkX21vc3RseTsKIEVYUE9SVF9TWU1C T0woX19tYXhfbG9naWNhbF9wYWNrYWdlcyk7CiBzdGF0aWMgdW5zaWduZWQgaW50IGxvZ2ljYWxf cGFja2FnZXMgX19yZWFkX21vc3RseTsKLXN0YXRpYyBib29sIGxvZ2ljYWxfcGFja2FnZXNfZnJv emVuIF9fcmVhZF9tb3N0bHk7CiAKIC8qIE1heGltdW0gbnVtYmVyIG9mIFNNVCB0aHJlYWRzIG9u IGFueSBvbmxpbmUgY29yZSAqLwogaW50IF9fbWF4X3NtdF90aHJlYWRzIF9fcmVhZF9tb3N0bHk7 CkBAIC0yNjMsOSArMjYyLDE0IEBAIHN0YXRpYyB2b2lkIG5vdHJhY2Ugc3RhcnRfc2Vjb25kYXJ5 KHZvaWQKIAljcHVfc3RhcnR1cF9lbnRyeShDUFVIUF9BUF9PTkxJTkVfSURMRSk7CiB9CiAKLWlu dCB0b3BvbG9neV91cGRhdGVfcGFja2FnZV9tYXAodW5zaWduZWQgaW50IGFwaWNpZCwgdW5zaWdu ZWQgaW50IGNwdSkKKy8qKgorICogdG9wb2xvZ3lfdXBkYXRlX3BhY2thZ2VfbWFwIC0gVXBkYXRl IHRoZSBwaHlzaWNhbCB0byBsb2dpY2FsIHBhY2thZ2UgbWFwCisgKiBAcGtnOglUaGUgcGh5c2lj YWwgcGFja2FnZSBpZCBhcyByZXRyaWV2ZWQgdmlhIENQVUlECisgKiBAY3B1OglUaGUgY3B1IGZv ciB3aGljaCB0aGlzIGlzIHVwZGF0ZWQKKyAqLworaW50IHRvcG9sb2d5X3VwZGF0ZV9wYWNrYWdl X21hcCh1bnNpZ25lZCBpbnQgcGtnLCB1bnNpZ25lZCBpbnQgY3B1KQogewotCXVuc2lnbmVkIGlu dCBuZXcsIHBrZyA9IGFwaWNpZCA+PiBib290X2NwdV9kYXRhLng4Nl9jb3JlaWRfYml0czsKKwl1 bnNpZ25lZCBpbnQgbmV3OwogCiAJLyogQ2FsbGVkIGZyb20gZWFybHkgYm9vdCA/ICovCiAJaWYg KCFwaHlzaWNhbF9wYWNrYWdlX21hcCkKQEAgLTI3OCwxNiArMjgyLDE3IEBAIGludCB0b3BvbG9n eV91cGRhdGVfcGFja2FnZV9tYXAodW5zaWduZWQKIAlpZiAodGVzdF9hbmRfc2V0X2JpdChwa2cs IHBoeXNpY2FsX3BhY2thZ2VfbWFwKSkKIAkJZ290byBmb3VuZDsKIAotCWlmIChsb2dpY2FsX3Bh Y2thZ2VzX2Zyb3plbikgewotCQlwaHlzaWNhbF90b19sb2dpY2FsX3BrZ1twa2ddID0gLTE7Ci0J CXByX3dhcm4oIkFQSUMoJXgpIFBhY2thZ2UgJXUgZXhjZWVkcyBsb2dpY2FsIHBhY2thZ2UgbWF4 XG4iLAotCQkJYXBpY2lkLCBwa2cpOworCWlmIChsb2dpY2FsX3BhY2thZ2VzID49IF9fbWF4X2xv Z2ljYWxfcGFja2FnZXMpIHsKKwkJcHJfd2FybigiUGFja2FnZSAldSBvZiBDUFUgJXUgZXhjZWVk cyBCSU9TIHBhY2thZ2UgZGF0YSAldS5cbiIsCisJCQlsb2dpY2FsX3BhY2thZ2VzLCBjcHUsIF9f bWF4X2xvZ2ljYWxfcGFja2FnZXMpOwogCQlyZXR1cm4gLUVOT1NQQzsKIAl9CiAKIAluZXcgPSBs b2dpY2FsX3BhY2thZ2VzKys7Ci0JcHJfaW5mbygiQVBJQygleCkgQ29udmVydGluZyBwaHlzaWNh bCAldSB0byBsb2dpY2FsIHBhY2thZ2UgJXVcbiIsCi0JCWFwaWNpZCwgcGtnLCBuZXcpOworCWlm IChuZXcgIT0gcGtnKSB7CisJCXByX2luZm8oIkNQVSAldSBDb252ZXJ0aW5nIHBoeXNpY2FsICV1 IHRvIGxvZ2ljYWwgcGFja2FnZSAldVxuIiwKKwkJCWNwdSwgcGtnLCBuZXcpOworCX0KIAlwaHlz aWNhbF90b19sb2dpY2FsX3BrZ1twa2ddID0gbmV3OwogCiBmb3VuZDoKQEAgLTMwOCw5ICszMTMs OSBAQCBpbnQgdG9wb2xvZ3lfcGh5c190b19sb2dpY2FsX3BrZyh1bnNpZ25lCiB9CiBFWFBPUlRf U1lNQk9MKHRvcG9sb2d5X3BoeXNfdG9fbG9naWNhbF9wa2cpOwogCi1zdGF0aWMgdm9pZCBfX2lu aXQgc21wX2luaXRfcGFja2FnZV9tYXAodm9pZCkKK3N0YXRpYyB2b2lkIF9faW5pdCBzbXBfaW5p dF9wYWNrYWdlX21hcChzdHJ1Y3QgY3B1aW5mb194ODYgKmMsIHVuc2lnbmVkIGludCBjcHUpCiB7 Ci0JdW5zaWduZWQgaW50IG5jcHVzLCBjcHU7CisJdW5zaWduZWQgaW50IG5jcHVzOwogCXNpemVf dCBzaXplOwogCiAJLyoKQEAgLTM1NSwyNyArMzYwLDkgQEAgc3RhdGljIHZvaWQgX19pbml0IHNt cF9pbml0X3BhY2thZ2VfbWFwKAogCXNpemUgPSBCSVRTX1RPX0xPTkdTKG1heF9waHlzaWNhbF9w a2dfaWQpICogc2l6ZW9mKHVuc2lnbmVkIGxvbmcpOwogCXBoeXNpY2FsX3BhY2thZ2VfbWFwID0g a3phbGxvYyhzaXplLCBHRlBfS0VSTkVMKTsKIAotCWZvcl9lYWNoX3ByZXNlbnRfY3B1KGNwdSkg ewotCQl1bnNpZ25lZCBpbnQgYXBpY2lkID0gYXBpYy0+Y3B1X3ByZXNlbnRfdG9fYXBpY2lkKGNw dSk7Ci0KLQkJaWYgKGFwaWNpZCA9PSBCQURfQVBJQ0lEIHx8ICFhcGljLT5hcGljX2lkX3ZhbGlk KGFwaWNpZCkpCi0JCQljb250aW51ZTsKLQkJaWYgKCF0b3BvbG9neV91cGRhdGVfcGFja2FnZV9t YXAoYXBpY2lkLCBjcHUpKQotCQkJY29udGludWU7Ci0JCXByX3dhcm4oIkNQVSAldSBBUElDSWQg JXggZGlzYWJsZWRcbiIsIGNwdSwgYXBpY2lkKTsKLQkJcGVyX2NwdSh4ODZfYmlvc19jcHVfYXBp Y2lkLCBjcHUpID0gQkFEX0FQSUNJRDsKLQkJc2V0X2NwdV9wb3NzaWJsZShjcHUsIGZhbHNlKTsK LQkJc2V0X2NwdV9wcmVzZW50KGNwdSwgZmFsc2UpOwotCX0KLQotCWlmIChsb2dpY2FsX3BhY2th Z2VzID4gX19tYXhfbG9naWNhbF9wYWNrYWdlcykgewotCQlwcl93YXJuKCJEZXRlY3RlZCBtb3Jl IHBhY2thZ2VzICgldSksIHRoZW4gY29tcHV0ZWQgYnkgQklPUyBkYXRhICgldSkuXG4iLAotCQkJ bG9naWNhbF9wYWNrYWdlcywgX19tYXhfbG9naWNhbF9wYWNrYWdlcyk7Ci0JCWxvZ2ljYWxfcGFj a2FnZXNfZnJvemVuID0gdHJ1ZTsKLQkJX19tYXhfbG9naWNhbF9wYWNrYWdlcyAgPSBsb2dpY2Fs X3BhY2thZ2VzOwotCX0KLQogCXByX2luZm8oIk1heCBsb2dpY2FsIHBhY2thZ2VzOiAldVxuIiwg X19tYXhfbG9naWNhbF9wYWNrYWdlcyk7CisKKwl0b3BvbG9neV91cGRhdGVfcGFja2FnZV9tYXAo Yy0+cGh5c19wcm9jX2lkLCBjcHUpOwogfQogCiB2b2lkIF9faW5pdCBzbXBfc3RvcmVfYm9vdF9j cHVfaW5mbyh2b2lkKQpAQCAtMzg1LDcgKzM3Miw3IEBAIHZvaWQgX19pbml0IHNtcF9zdG9yZV9i b290X2NwdV9pbmZvKHZvaWQKIAogCSpjID0gYm9vdF9jcHVfZGF0YTsKIAljLT5jcHVfaW5kZXgg PSBpZDsKLQlzbXBfaW5pdF9wYWNrYWdlX21hcCgpOworCXNtcF9pbml0X3BhY2thZ2VfbWFwKGMs IGlkKTsKIH0KIAogLyoKLS0tIGEvYXJjaC94ODYveGVuL3NtcC5jCisrKyBiL2FyY2gveDg2L3hl bi9zbXAuYwpAQCAtODcsMTIgKzg3LDYgQEAgc3RhdGljIHZvaWQgY3B1X2JyaW5ndXAodm9pZCkK IAljcHVfZGF0YShjcHUpLng4Nl9tYXhfY29yZXMgPSAxOwogCXNldF9jcHVfc2libGluZ19tYXAo Y3B1KTsKIAotCS8qCi0JICogaWRlbnRpZnlfY3B1KCkgbWF5IGhhdmUgc2V0IGxvZ2ljYWxfcGtn X2lkIHRvIC0xIGR1ZQotCSAqIHRvIGluY29ycmVjdCBwaHlzX3Byb2NfaWQuIExldCdzIHJlLWNv bXVwdGUgaXQuCi0JICovCi0JdG9wb2xvZ3lfdXBkYXRlX3BhY2thZ2VfbWFwKGFwaWMtPmNwdV9w cmVzZW50X3RvX2FwaWNpZChjcHUpLCBjcHUpOwotCiAJeGVuX3NldHVwX2NwdV9jbG9ja2V2ZW50 cygpOwogCiAJbm90aWZ5X2NwdV9zdGFydGluZyhjcHUpOwoKCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1k ZXZlbEBsaXN0cy54ZW4ub3JnCmh0dHBzOi8vbGlzdHMueGVuLm9yZy94ZW4tZGV2ZWwK