From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753707AbcGVKkl (ORCPT ); Fri, 22 Jul 2016 06:40:41 -0400 Received: from mx1.redhat.com ([209.132.183.28]:33478 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752741AbcGVKkj (ORCPT ); Fri, 22 Jul 2016 06:40:39 -0400 Date: Fri, 22 Jul 2016 18:40:34 +0800 From: Baoquan He To: Wei Jiangang Cc: linux-kernel@vger.kernel.org, x86@kernel.org, kexec@lists.infradead.org, tglx@linutronix.de, mingo@redhat.com, hpa@zytor.com, ebiederm@xmission.com, kernel@kyup.com, xpang@redhat.com, Cao jin , joro@8bytes.org Subject: Re: [PATCH 3/3] x86/apic: Improved the setting of interrupt mode for bsp Message-ID: <20160722104034.GB3543@x1.redhat.com> References: <1469175026-29447-1-git-send-email-weijg.fnst@cn.fujitsu.com> <1469175026-29447-3-git-send-email-weijg.fnst@cn.fujitsu.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <1469175026-29447-3-git-send-email-weijg.fnst@cn.fujitsu.com> User-Agent: Mutt/1.5.21 (2010-09-15) X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.32]); Fri, 22 Jul 2016 10:40:38 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi Jiangang, This is very nice, should be the stuff Eric and Ingo would like to see. But I have several questions: 1) Are you not going to clean up the old legacy irq mode setting code in 1st kernel? 2)I call them legacy irq mode because not only apic virtual wire mode exists, but the PIC mode in x86 32bit system. You need consider it too. Then init_bsp_APIC need be renamaed to an appropriate one. And assume this has been tested on x86 32bit system. 3) *)About IO-APIC setting as virtual wire mode, I am always confused. In MP Spec 3.6.2.2, it says "the interrupt signal passes through both the I/O APIC and the BSP’s local APIC". That means IO-APIC virtual wire mode need both IO-APIC and LAPIC to be set, and with my understanding only pin of IO-APIC is set as ExtInt, LAPIC should be pass-through. *)But in Intel Arch manual 3A 10.1, there's only below sentences to mention it: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The I/O APIC also has a “virtual wire mode” that allows it to communicate with a standard 8259A-style external interrupt controller. Note that the local APIC can be disabled. This allows an associated processor core to receive interrupts directly from an 8259A interrupt controller. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Eric's code in native_disable_io_apic() has the same point as above words. *)However please read code comments in irq_remapping_disable_io_apic(), Joerg's description give me a different impression that we can choose to only use LAPIC virtual wire mode. Joerg is IOMMU maintainers, he is very familiar with io-apic since IOMMU need take over io-apic entry filling, there must be reason he wrote that. Add Joerg to CC list. Seems it's difficult to find a system with IO-APIC virtual wire mode, maybe we can just keep it as is. Not sure if Intel engineers can help explain and confirm this. That's all I can think of. Thanks Baoquan On 07/22/16 at 04:10pm, Wei Jiangang wrote: > If we specify the 'notsc' parameter for the dump-capture kernel, > and then trigger a crash(panic) by using "ALT-SysRq-c" or > "echo c > /proc/sysrq-trigger", the dump-capture kernel will > hang in calibrate_delay_converge() and wait for jiffies changes. > serial log as follows: > > tsc: Fast TSC calibration using PIT > tsc: Detected 2099.947 MHz processor > Calibrating delay loop... > > The reason for jiffies not changes is there's no timer interrupt > passed to dump-capture kernel. > > In fact, once kernel panic occurs, the local APIC is disabled > by lapic_shutdown() in reboot path. > generly speaking, local APIC state can be initialized by BIOS > after Power-Up or Reset, which doesn't apply to kdump case. > so the kernel has to be responsible for initialize the interrupt > mode properly according the latest status of APIC in bootup path. > > An MP operating system is booted under either PIC mode or > virtual wire mode. Later, the operating system switches to > symmetric I/O mode as it enters multiprocessor mode. > Two kinds of virtual wire mode are defined in Intel MP spec: > virtual wire mode via local APIC or via I/O APIC. > > Now we determine the mode of APIC only through a SMP BIOS(MP table). > That's not enough. > It's better to do further check if APIC works with effective mode, > and do some porper setting. > > Signed-off-by: Cao jin > Signed-off-by: Wei Jiangang > --- > arch/x86/include/asm/io_apic.h | 5 ++++ > arch/x86/kernel/apic/apic.c | 55 +++++++++++++++++++++++++++++++++++++++++- > arch/x86/kernel/apic/io_apic.c | 28 +++++++++++++++++++++ > 3 files changed, 87 insertions(+), 1 deletion(-) > > diff --git a/arch/x86/include/asm/io_apic.h b/arch/x86/include/asm/io_apic.h > index 6cbf2cfb3f8a..6550bd43fa39 100644 > --- a/arch/x86/include/asm/io_apic.h > +++ b/arch/x86/include/asm/io_apic.h > @@ -190,6 +190,7 @@ static inline unsigned int io_apic_read(unsigned int apic, unsigned int reg) > } > > extern void setup_IO_APIC(void); > +extern bool virtual_wire_via_ioapic(void); > extern void enable_IO_APIC(void); > extern void disable_IO_APIC(void); > extern void setup_ioapic_dest(void); > @@ -231,6 +232,10 @@ static inline void io_apic_init_mappings(void) { } > #define native_disable_io_apic NULL > > static inline void setup_IO_APIC(void) { } > +static inline bool virtual_wire_via_ioapic(void) > +{ > + return true; > +} > static inline void enable_IO_APIC(void) { } > static inline void setup_ioapic_dest(void) { } > > diff --git a/arch/x86/kernel/apic/apic.c b/arch/x86/kernel/apic/apic.c > index 8e25b9b2d351..04358e0cf1e2 100644 > --- a/arch/x86/kernel/apic/apic.c > +++ b/arch/x86/kernel/apic/apic.c > @@ -1124,6 +1124,53 @@ void __init sync_Arb_IDs(void) > } > > /* > + * Return false means the virtual wire mode through-local-apic is inactive > + */ > +static bool virtual_wire_via_lapic(void) > +{ > + unsigned int value; > + > + /* Check the APIC global enable/disable flag firstly */ > + if (boot_cpu_data.x86 >= 6) { > + u32 h, l; > + > + rdmsr(MSR_IA32_APICBASE, l, h); > + /* > + * If local APIC is disabled by BIOS > + * do nothing, but return true > + */ > + if (!(l & MSR_IA32_APICBASE_ENABLE)) > + return true; > + } > + > + /* Check the software enable/disable flag */ > + value = apic_read(APIC_SPIV); > + if (!(value & APIC_SPIV_APIC_ENABLED)) > + return false; > + > + /* > + * Virtual wire mode via local APIC requests > + * APIC to enable the LINT0 for edge-trggered ExtINT delivery mode > + * and LINT1 for level-triggered NMI delivery mode > + */ > + value = apic_read(APIC_LVT0); > + if (GET_APIC_DELIVERY_MODE(value) != APIC_MODE_EXTINT) > + return false; > + > + value = apic_read(APIC_LVT1); > + if (GET_APIC_DELIVERY_MODE(value) != APIC_MODE_NMI) > + return false; > + > + return true; > +} > + > +static bool check_virtual_wire_mode(void) > +{ > + /* Neither of virtual wire mode is active, return false */ > + return virtual_wire_via_lapic() || virtual_wire_via_ioapic(); > +} > + > +/* > * An initial setup of the virtual wire mode. > */ > void __init init_bsp_APIC(void) > @@ -1133,8 +1180,14 @@ void __init init_bsp_APIC(void) > /* > * Don't do the setup now if we have a SMP BIOS as the > * through-I/O-APIC virtual wire mode might be active. > + * > + * It's better to do further check if either through-I/O-APIC > + * or through-local-APIC is active. > + * the worst case is that both of them are inactive, > + * If so, We need to enable the virtual wire mode via through-local-APIC > */ > - if (smp_found_config || !boot_cpu_has(X86_FEATURE_APIC)) > + if ((smp_found_config && check_virtual_wire_mode()) || > + !boot_cpu_has(X86_FEATURE_APIC)) > return; > > /* > diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c > index 446702ed99dc..5a32c26938ac 100644 > --- a/arch/x86/kernel/apic/io_apic.c > +++ b/arch/x86/kernel/apic/io_apic.c > @@ -1379,6 +1379,34 @@ void __init print_IO_APICs(void) > /* Where if anywhere is the i8259 connect in external int mode */ > static struct { int pin, apic; } ioapic_i8259 = { -1, -1 }; > > +/* > + * Return false means the virtual wire mode via I/O APIC is inactive > + */ > +bool virtual_wire_via_ioapic(void) > +{ > + int apic, pin; > + > + for_each_ioapic_pin(apic, pin) { > + /* See if any of the pins is in ExtINT mode */ > + struct IO_APIC_route_entry entry = ioapic_read_entry(apic, pin); > + > + /* > + * If the interrupt line is enabled and in ExtInt mode > + * I have found the pin where the i8259 is connected. > + */ > + if ((entry.mask == 0) && (entry.delivery_mode == dest_ExtINT)) > + return true; > + } > + > + /* > + * Virtual wire mode via I/O APIC requests > + * I/O APIC be connected to i8259 in chapter 3.6.2.2 of the MP v1.4 spec > + * If no pin in ExtInt mode, > + * the through-I/O-APIC virtual wire mode can be regarded inactive. > + */ > + return false; > +} > + > void __init enable_IO_APIC(void) > { > int i8259_apic, i8259_pin; > -- > 1.9.3 > > > From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mx1.redhat.com ([209.132.183.28]) by bombadil.infradead.org with esmtps (Exim 4.85_2 #1 (Red Hat Linux)) id 1bQXt5-00005q-8K for kexec@lists.infradead.org; Fri, 22 Jul 2016 10:41:01 +0000 Date: Fri, 22 Jul 2016 18:40:34 +0800 From: Baoquan He Subject: Re: [PATCH 3/3] x86/apic: Improved the setting of interrupt mode for bsp Message-ID: <20160722104034.GB3543@x1.redhat.com> References: <1469175026-29447-1-git-send-email-weijg.fnst@cn.fujitsu.com> <1469175026-29447-3-git-send-email-weijg.fnst@cn.fujitsu.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <1469175026-29447-3-git-send-email-weijg.fnst@cn.fujitsu.com> List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "kexec" Errors-To: kexec-bounces+dwmw2=infradead.org@lists.infradead.org To: Wei Jiangang Cc: xpang@redhat.com, joro@8bytes.org, x86@kernel.org, kexec@lists.infradead.org, linux-kernel@vger.kernel.org, Cao jin , mingo@redhat.com, kernel@kyup.com, ebiederm@xmission.com, hpa@zytor.com, tglx@linutronix.de SGkgSmlhbmdhbmcsCgpUaGlzIGlzIHZlcnkgbmljZSwgc2hvdWxkIGJlIHRoZSBzdHVmZiBFcmlj IGFuZCBJbmdvIHdvdWxkIGxpa2UgdG8gc2VlLgpCdXQgSSBoYXZlIHNldmVyYWwgcXVlc3Rpb25z OgoKMSkgQXJlIHlvdSBub3QgZ29pbmcgdG8gY2xlYW4gdXAgdGhlIG9sZCBsZWdhY3kgaXJxIG1v ZGUgc2V0dGluZyBjb2RlIGluCjFzdCBrZXJuZWw/CgoyKUkgY2FsbCB0aGVtIGxlZ2FjeSBpcnEg bW9kZSBiZWNhdXNlIG5vdCBvbmx5IGFwaWMgdmlydHVhbCB3aXJlIG1vZGUKZXhpc3RzLCBidXQg dGhlIFBJQyBtb2RlIGluIHg4NiAzMmJpdCBzeXN0ZW0uIFlvdSBuZWVkIGNvbnNpZGVyIGl0IHRv by4KVGhlbiBpbml0X2JzcF9BUElDIG5lZWQgYmUgcmVuYW1hZWQgdG8gYW4gYXBwcm9wcmlhdGUg b25lLiBBbmQgYXNzdW1lCnRoaXMgaGFzIGJlZW4gdGVzdGVkIG9uIHg4NiAzMmJpdCBzeXN0ZW0u IAoKMykgCgoqKUFib3V0IElPLUFQSUMgc2V0dGluZyBhcyB2aXJ0dWFsIHdpcmUgbW9kZSwgSSBh bSBhbHdheXMgY29uZnVzZWQuIEluCk1QIFNwZWMgMy42LjIuMiwgaXQgc2F5cyAidGhlIGludGVy cnVwdCBzaWduYWwgcGFzc2VzIHRocm91Z2ggYm90aCB0aGUKSS9PIEFQSUMgYW5kIHRoZSBCU1Di gJlzIGxvY2FsIEFQSUMiLiBUaGF0IG1lYW5zIElPLUFQSUMgdmlydHVhbCB3aXJlIG1vZGUKbmVl ZCBib3RoIElPLUFQSUMgYW5kIExBUElDIHRvIGJlIHNldCwgYW5kIHdpdGggbXkgdW5kZXJzdGFu ZGluZyBvbmx5CnBpbiBvZiBJTy1BUElDIGlzIHNldCBhcyBFeHRJbnQsIExBUElDIHNob3VsZCBi ZSBwYXNzLXRocm91Z2guCgoqKUJ1dCBpbiBJbnRlbCBBcmNoIG1hbnVhbCAzQSAxMC4xLCB0aGVy ZSdzIG9ubHkgYmVsb3cgc2VudGVuY2VzIHRvIG1lbnRpb24KaXQ6Cgp+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KVGhlIEkvTyBB UElDIGFsc28gaGFzIGEg4oCcdmlydHVhbCB3aXJlIG1vZGXigJ0gdGhhdCBhbGxvd3MgaXQgdG8g Y29tbXVuaWNhdGUKd2l0aCBhIHN0YW5kYXJkIDgyNTlBLXN0eWxlIGV4dGVybmFsIGludGVycnVw dCBjb250cm9sbGVyLiBOb3RlIHRoYXQgdGhlCmxvY2FsIEFQSUMgY2FuIGJlIGRpc2FibGVkLiBU aGlzIGFsbG93cyBhbiBhc3NvY2lhdGVkIHByb2Nlc3NvciBjb3JlIHRvCnJlY2VpdmUgaW50ZXJy dXB0cyBkaXJlY3RseSBmcm9tIGFuIDgyNTlBIGludGVycnVwdCBjb250cm9sbGVyLgp+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ CgpFcmljJ3MgY29kZSBpbiBuYXRpdmVfZGlzYWJsZV9pb19hcGljKCkgaGFzIHRoZSBzYW1lIHBv aW50IGFzIGFib3ZlCndvcmRzLgoKKilIb3dldmVyIHBsZWFzZSByZWFkIGNvZGUgY29tbWVudHMg aW4gaXJxX3JlbWFwcGluZ19kaXNhYmxlX2lvX2FwaWMoKSwKSm9lcmcncyBkZXNjcmlwdGlvbiBn aXZlIG1lIGEgZGlmZmVyZW50IGltcHJlc3Npb24gdGhhdCB3ZSBjYW4gY2hvb3NlCnRvIG9ubHkg dXNlIExBUElDIHZpcnR1YWwgd2lyZSBtb2RlLiBKb2VyZyBpcyBJT01NVSBtYWludGFpbmVycywg aGUgaXMKdmVyeSBmYW1pbGlhciB3aXRoIGlvLWFwaWMgc2luY2UgSU9NTVUgbmVlZCB0YWtlIG92 ZXIgaW8tYXBpYyBlbnRyeQpmaWxsaW5nLCB0aGVyZSBtdXN0IGJlIHJlYXNvbiBoZSB3cm90ZSB0 aGF0LiBBZGQgSm9lcmcgdG8gQ0MgbGlzdC4KClNlZW1zIGl0J3MgZGlmZmljdWx0IHRvIGZpbmQg YSBzeXN0ZW0gd2l0aCBJTy1BUElDIHZpcnR1YWwgd2lyZSBtb2RlLAptYXliZSB3ZSBjYW4ganVz dCBrZWVwIGl0IGFzIGlzLiBOb3Qgc3VyZSBpZiBJbnRlbCBlbmdpbmVlcnMgY2FuIGhlbHAKZXhw bGFpbiBhbmQgY29uZmlybSB0aGlzLgoKVGhhdCdzIGFsbCBJIGNhbiB0aGluayBvZi4KClRoYW5r cwpCYW9xdWFuCgpPbiAwNy8yMi8xNiBhdCAwNDoxMHBtLCBXZWkgSmlhbmdhbmcgd3JvdGU6Cj4g SWYgd2Ugc3BlY2lmeSB0aGUgJ25vdHNjJyBwYXJhbWV0ZXIgZm9yIHRoZSBkdW1wLWNhcHR1cmUg a2VybmVsLAo+IGFuZCB0aGVuIHRyaWdnZXIgYSBjcmFzaChwYW5pYykgYnkgdXNpbmcgIkFMVC1T eXNScS1jIiBvcgo+ICJlY2hvIGMgPiAvcHJvYy9zeXNycS10cmlnZ2VyIiwgdGhlIGR1bXAtY2Fw dHVyZSBrZXJuZWwgd2lsbAo+IGhhbmcgaW4gY2FsaWJyYXRlX2RlbGF5X2NvbnZlcmdlKCkgYW5k IHdhaXQgZm9yIGppZmZpZXMgY2hhbmdlcy4KPiBzZXJpYWwgbG9nIGFzIGZvbGxvd3M6Cj4gCj4g ICAgIHRzYzogRmFzdCBUU0MgY2FsaWJyYXRpb24gdXNpbmcgUElUCj4gICAgIHRzYzogRGV0ZWN0 ZWQgMjA5OS45NDcgTUh6IHByb2Nlc3Nvcgo+ICAgICBDYWxpYnJhdGluZyBkZWxheSBsb29wLi4u Cj4gCj4gVGhlIHJlYXNvbiBmb3IgamlmZmllcyBub3QgY2hhbmdlcyBpcyB0aGVyZSdzIG5vIHRp bWVyIGludGVycnVwdAo+IHBhc3NlZCB0byBkdW1wLWNhcHR1cmUga2VybmVsLgo+IAo+IEluIGZh Y3QsIG9uY2Uga2VybmVsIHBhbmljIG9jY3VycywgdGhlIGxvY2FsIEFQSUMgaXMgZGlzYWJsZWQK PiBieSBsYXBpY19zaHV0ZG93bigpIGluIHJlYm9vdCBwYXRoLgo+IGdlbmVybHkgc3BlYWtpbmcs IGxvY2FsIEFQSUMgc3RhdGUgY2FuIGJlIGluaXRpYWxpemVkIGJ5IEJJT1MKPiBhZnRlciBQb3dl ci1VcCBvciBSZXNldCwgd2hpY2ggZG9lc24ndCBhcHBseSB0byBrZHVtcCBjYXNlLgo+IHNvIHRo ZSBrZXJuZWwgaGFzIHRvIGJlIHJlc3BvbnNpYmxlIGZvciBpbml0aWFsaXplIHRoZSBpbnRlcnJ1 cHQKPiBtb2RlIHByb3Blcmx5IGFjY29yZGluZyB0aGUgbGF0ZXN0IHN0YXR1cyBvZiBBUElDIGlu IGJvb3R1cCBwYXRoLgo+IAo+IEFuIE1QIG9wZXJhdGluZyBzeXN0ZW0gaXMgYm9vdGVkIHVuZGVy IGVpdGhlciBQSUMgbW9kZSBvcgo+IHZpcnR1YWwgd2lyZSBtb2RlLiBMYXRlciwgdGhlIG9wZXJh dGluZyBzeXN0ZW0gc3dpdGNoZXMgdG8KPiBzeW1tZXRyaWMgSS9PIG1vZGUgYXMgaXQgZW50ZXJz IG11bHRpcHJvY2Vzc29yIG1vZGUuCj4gVHdvIGtpbmRzIG9mIHZpcnR1YWwgd2lyZSBtb2RlIGFy ZSBkZWZpbmVkIGluIEludGVsIE1QIHNwZWM6Cj4gdmlydHVhbCB3aXJlIG1vZGUgdmlhIGxvY2Fs IEFQSUMgb3IgdmlhIEkvTyBBUElDLgo+IAo+IE5vdyB3ZSBkZXRlcm1pbmUgdGhlIG1vZGUgb2Yg QVBJQyBvbmx5IHRocm91Z2ggYSBTTVAgQklPUyhNUCB0YWJsZSkuCj4gVGhhdCdzIG5vdCBlbm91 Z2guCj4gSXQncyBiZXR0ZXIgdG8gZG8gZnVydGhlciBjaGVjayBpZiBBUElDIHdvcmtzIHdpdGgg ZWZmZWN0aXZlIG1vZGUsCj4gYW5kIGRvIHNvbWUgcG9ycGVyIHNldHRpbmcuCj4gCj4gU2lnbmVk LW9mZi1ieTogQ2FvIGppbiA8Y2Fvai5mbnN0QGNuLmZ1aml0c3UuY29tPgo+IFNpZ25lZC1vZmYt Ynk6IFdlaSBKaWFuZ2FuZyA8d2VpamcuZm5zdEBjbi5mdWppdHN1LmNvbT4KPiAtLS0KPiAgYXJj aC94ODYvaW5jbHVkZS9hc20vaW9fYXBpYy5oIHwgIDUgKysrKwo+ICBhcmNoL3g4Ni9rZXJuZWwv YXBpYy9hcGljLmMgICAgfCA1NSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKy0KPiAgYXJjaC94ODYva2VybmVsL2FwaWMvaW9fYXBpYy5jIHwgMjggKysrKysrKysrKysr KysrKysrKysrCj4gIDMgZmlsZXMgY2hhbmdlZCwgODcgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlv bigtKQo+IAo+IGRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9pb19hcGljLmggYi9h cmNoL3g4Ni9pbmNsdWRlL2FzbS9pb19hcGljLmgKPiBpbmRleCA2Y2JmMmNmYjNmOGEuLjY1NTBi ZDQzZmEzOSAxMDA2NDQKPiAtLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9pb19hcGljLmgKPiAr KysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9pb19hcGljLmgKPiBAQCAtMTkwLDYgKzE5MCw3IEBA IHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgaW50IGlvX2FwaWNfcmVhZCh1bnNpZ25lZCBpbnQgYXBp YywgdW5zaWduZWQgaW50IHJlZykKPiAgfQo+ICAKPiAgZXh0ZXJuIHZvaWQgc2V0dXBfSU9fQVBJ Qyh2b2lkKTsKPiArZXh0ZXJuIGJvb2wgdmlydHVhbF93aXJlX3ZpYV9pb2FwaWModm9pZCk7Cj4g IGV4dGVybiB2b2lkIGVuYWJsZV9JT19BUElDKHZvaWQpOwo+ICBleHRlcm4gdm9pZCBkaXNhYmxl X0lPX0FQSUModm9pZCk7Cj4gIGV4dGVybiB2b2lkIHNldHVwX2lvYXBpY19kZXN0KHZvaWQpOwo+ IEBAIC0yMzEsNiArMjMyLDEwIEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBpb19hcGljX2luaXRfbWFw cGluZ3Modm9pZCkgeyB9Cj4gICNkZWZpbmUgbmF0aXZlX2Rpc2FibGVfaW9fYXBpYwkJTlVMTAo+ ICAKPiAgc3RhdGljIGlubGluZSB2b2lkIHNldHVwX0lPX0FQSUModm9pZCkgeyB9Cj4gK3N0YXRp YyBpbmxpbmUgYm9vbCB2aXJ0dWFsX3dpcmVfdmlhX2lvYXBpYyh2b2lkKQo+ICt7Cj4gKwlyZXR1 cm4gdHJ1ZTsKPiArfQo+ICBzdGF0aWMgaW5saW5lIHZvaWQgZW5hYmxlX0lPX0FQSUModm9pZCkg eyB9Cj4gIHN0YXRpYyBpbmxpbmUgdm9pZCBzZXR1cF9pb2FwaWNfZGVzdCh2b2lkKSB7IH0KPiAg Cj4gZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9hcGljL2FwaWMuYyBiL2FyY2gveDg2L2tl cm5lbC9hcGljL2FwaWMuYwo+IGluZGV4IDhlMjViOWIyZDM1MS4uMDQzNThlMGNmMWUyIDEwMDY0 NAo+IC0tLSBhL2FyY2gveDg2L2tlcm5lbC9hcGljL2FwaWMuYwo+ICsrKyBiL2FyY2gveDg2L2tl cm5lbC9hcGljL2FwaWMuYwo+IEBAIC0xMTI0LDYgKzExMjQsNTMgQEAgdm9pZCBfX2luaXQgc3lu Y19BcmJfSURzKHZvaWQpCj4gIH0KPiAgCj4gIC8qCj4gKyAqIFJldHVybiBmYWxzZSBtZWFucyB0 aGUgdmlydHVhbCB3aXJlIG1vZGUgdGhyb3VnaC1sb2NhbC1hcGljIGlzIGluYWN0aXZlCj4gKyAq Lwo+ICtzdGF0aWMgYm9vbCB2aXJ0dWFsX3dpcmVfdmlhX2xhcGljKHZvaWQpCj4gK3sKPiArCXVu c2lnbmVkIGludCB2YWx1ZTsKPiArCj4gKwkvKiBDaGVjayB0aGUgQVBJQyBnbG9iYWwgZW5hYmxl L2Rpc2FibGUgZmxhZyBmaXJzdGx5ICovCj4gKwlpZiAoYm9vdF9jcHVfZGF0YS54ODYgPj0gNikg ewo+ICsJCXUzMiBoLCBsOwo+ICsKPiArCQlyZG1zcihNU1JfSUEzMl9BUElDQkFTRSwgbCwgaCk7 Cj4gKwkJLyoKPiArCQkgKiBJZiBsb2NhbCBBUElDIGlzIGRpc2FibGVkIGJ5IEJJT1MKPiArCQkg KiBkbyBub3RoaW5nLCBidXQgcmV0dXJuIHRydWUKPiArCQkgKi8KPiArCQlpZiAoIShsICYgTVNS X0lBMzJfQVBJQ0JBU0VfRU5BQkxFKSkKPiArCQkJcmV0dXJuIHRydWU7Cj4gKwl9Cj4gKwo+ICsJ LyogQ2hlY2sgdGhlIHNvZnR3YXJlIGVuYWJsZS9kaXNhYmxlIGZsYWcgKi8KPiArCXZhbHVlID0g YXBpY19yZWFkKEFQSUNfU1BJVik7Cj4gKwlpZiAoISh2YWx1ZSAmIEFQSUNfU1BJVl9BUElDX0VO QUJMRUQpKQo+ICsJCXJldHVybiBmYWxzZTsKPiArCj4gKwkvKgo+ICsJICogVmlydHVhbCB3aXJl IG1vZGUgdmlhIGxvY2FsIEFQSUMgcmVxdWVzdHMKPiArCSAqIEFQSUMgdG8gZW5hYmxlIHRoZSBM SU5UMCBmb3IgZWRnZS10cmdnZXJlZCBFeHRJTlQgZGVsaXZlcnkgbW9kZQo+ICsJICogYW5kIExJ TlQxIGZvciBsZXZlbC10cmlnZ2VyZWQgTk1JIGRlbGl2ZXJ5IG1vZGUKPiArCSAqLwo+ICsJdmFs dWUgPSBhcGljX3JlYWQoQVBJQ19MVlQwKTsKPiArCWlmIChHRVRfQVBJQ19ERUxJVkVSWV9NT0RF KHZhbHVlKSAhPSBBUElDX01PREVfRVhUSU5UKQo+ICsJCXJldHVybiBmYWxzZTsKPiArCj4gKwl2 YWx1ZSA9IGFwaWNfcmVhZChBUElDX0xWVDEpOwo+ICsJaWYgKEdFVF9BUElDX0RFTElWRVJZX01P REUodmFsdWUpICE9IEFQSUNfTU9ERV9OTUkpCj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsKPiArCXJl dHVybiB0cnVlOwo+ICt9Cj4gKwo+ICtzdGF0aWMgYm9vbCBjaGVja192aXJ0dWFsX3dpcmVfbW9k ZSh2b2lkKQo+ICt7Cj4gKwkvKiBOZWl0aGVyIG9mIHZpcnR1YWwgd2lyZSBtb2RlIGlzIGFjdGl2 ZSwgcmV0dXJuIGZhbHNlICovCj4gKwlyZXR1cm4gIHZpcnR1YWxfd2lyZV92aWFfbGFwaWMoKSB8 fCB2aXJ0dWFsX3dpcmVfdmlhX2lvYXBpYygpOwo+ICt9Cj4gKwo+ICsvKgo+ICAgKiBBbiBpbml0 aWFsIHNldHVwIG9mIHRoZSB2aXJ0dWFsIHdpcmUgbW9kZS4KPiAgICovCj4gIHZvaWQgX19pbml0 IGluaXRfYnNwX0FQSUModm9pZCkKPiBAQCAtMTEzMyw4ICsxMTgwLDE0IEBAIHZvaWQgX19pbml0 IGluaXRfYnNwX0FQSUModm9pZCkKPiAgCS8qCj4gIAkgKiBEb24ndCBkbyB0aGUgc2V0dXAgbm93 IGlmIHdlIGhhdmUgYSBTTVAgQklPUyBhcyB0aGUKPiAgCSAqIHRocm91Z2gtSS9PLUFQSUMgdmly dHVhbCB3aXJlIG1vZGUgbWlnaHQgYmUgYWN0aXZlLgo+ICsJICoKPiArCSAqIEl0J3MgYmV0dGVy IHRvIGRvIGZ1cnRoZXIgY2hlY2sgaWYgZWl0aGVyIHRocm91Z2gtSS9PLUFQSUMKPiArCSAqIG9y IHRocm91Z2gtbG9jYWwtQVBJQyBpcyBhY3RpdmUuCj4gKwkgKiB0aGUgd29yc3QgY2FzZSBpcyB0 aGF0IGJvdGggb2YgdGhlbSBhcmUgaW5hY3RpdmUsCj4gKwkgKiBJZiBzbywgV2UgbmVlZCB0byBl bmFibGUgdGhlIHZpcnR1YWwgd2lyZSBtb2RlIHZpYSB0aHJvdWdoLWxvY2FsLUFQSUMKPiAgCSAq Lwo+IC0JaWYgKHNtcF9mb3VuZF9jb25maWcgfHwgIWJvb3RfY3B1X2hhcyhYODZfRkVBVFVSRV9B UElDKSkKPiArCWlmICgoc21wX2ZvdW5kX2NvbmZpZyAmJiBjaGVja192aXJ0dWFsX3dpcmVfbW9k ZSgpKSB8fAo+ICsJCSFib290X2NwdV9oYXMoWDg2X0ZFQVRVUkVfQVBJQykpCj4gIAkJcmV0dXJu Owo+ICAKPiAgCS8qCj4gZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9hcGljL2lvX2FwaWMu YyBiL2FyY2gveDg2L2tlcm5lbC9hcGljL2lvX2FwaWMuYwo+IGluZGV4IDQ0NjcwMmVkOTlkYy4u NWEzMmMyNjkzOGFjIDEwMDY0NAo+IC0tLSBhL2FyY2gveDg2L2tlcm5lbC9hcGljL2lvX2FwaWMu Ywo+ICsrKyBiL2FyY2gveDg2L2tlcm5lbC9hcGljL2lvX2FwaWMuYwo+IEBAIC0xMzc5LDYgKzEz NzksMzQgQEAgdm9pZCBfX2luaXQgcHJpbnRfSU9fQVBJQ3Modm9pZCkKPiAgLyogV2hlcmUgaWYg YW55d2hlcmUgaXMgdGhlIGk4MjU5IGNvbm5lY3QgaW4gZXh0ZXJuYWwgaW50IG1vZGUgKi8KPiAg c3RhdGljIHN0cnVjdCB7IGludCBwaW4sIGFwaWM7IH0gaW9hcGljX2k4MjU5ID0geyAtMSwgLTEg fTsKPiAgCj4gKy8qCj4gKyAqIFJldHVybiBmYWxzZSBtZWFucyB0aGUgdmlydHVhbCB3aXJlIG1v ZGUgdmlhIEkvTyBBUElDIGlzIGluYWN0aXZlCj4gKyAqLwo+ICtib29sIHZpcnR1YWxfd2lyZV92 aWFfaW9hcGljKHZvaWQpCj4gK3sKPiArCWludCBhcGljLCBwaW47Cj4gKwo+ICsJZm9yX2VhY2hf aW9hcGljX3BpbihhcGljLCBwaW4pIHsKPiArCQkvKiBTZWUgaWYgYW55IG9mIHRoZSBwaW5zIGlz IGluIEV4dElOVCBtb2RlICovCj4gKwkJc3RydWN0IElPX0FQSUNfcm91dGVfZW50cnkgZW50cnkg PSBpb2FwaWNfcmVhZF9lbnRyeShhcGljLCBwaW4pOwo+ICsKPiArCQkvKgo+ICsJCSAqIElmIHRo ZSBpbnRlcnJ1cHQgbGluZSBpcyBlbmFibGVkIGFuZCBpbiBFeHRJbnQgbW9kZQo+ICsJCSAqIEkg aGF2ZSBmb3VuZCB0aGUgcGluIHdoZXJlIHRoZSBpODI1OSBpcyBjb25uZWN0ZWQuCj4gKwkJICov Cj4gKwkJaWYgKChlbnRyeS5tYXNrID09IDApICYmIChlbnRyeS5kZWxpdmVyeV9tb2RlID09IGRl c3RfRXh0SU5UKSkKPiArCQkJcmV0dXJuIHRydWU7Cj4gKwl9Cj4gKwo+ICsJLyoKPiArCSAqIFZp cnR1YWwgd2lyZSBtb2RlIHZpYSBJL08gQVBJQyByZXF1ZXN0cwo+ICsJICogSS9PIEFQSUMgYmUg Y29ubmVjdGVkIHRvIGk4MjU5IGluIGNoYXB0ZXIgMy42LjIuMiBvZiB0aGUgTVAgdjEuNCBzcGVj Cj4gKwkgKiBJZiBubyBwaW4gaW4gRXh0SW50IG1vZGUsCj4gKwkgKiB0aGUgdGhyb3VnaC1JL08t QVBJQyB2aXJ0dWFsIHdpcmUgbW9kZSBjYW4gYmUgcmVnYXJkZWQgaW5hY3RpdmUuCj4gKwkgKi8K PiArCXJldHVybiBmYWxzZTsKPiArfQo+ICsKPiAgdm9pZCBfX2luaXQgZW5hYmxlX0lPX0FQSUMo dm9pZCkKPiAgewo+ICAJaW50IGk4MjU5X2FwaWMsIGk4MjU5X3BpbjsKPiAtLSAKPiAxLjkuMwo+ IAo+IAo+IAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K a2V4ZWMgbWFpbGluZyBsaXN0CmtleGVjQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3Rz LmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9rZXhlYwo=