From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752687AbcGYDEs (ORCPT ); Sun, 24 Jul 2016 23:04:48 -0400 Received: from cn.fujitsu.com ([59.151.112.132]:60400 "EHLO heian.cn.fujitsu.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1752582AbcGYDEk (ORCPT ); Sun, 24 Jul 2016 23:04:40 -0400 X-IronPort-AV: E=Sophos;i="5.22,518,1449504000"; d="scan'208";a="9030663" From: "Wei, Jiangang" To: "bhe@redhat.com" CC: "kexec@lists.infradead.org" , "linux-kernel@vger.kernel.org" , "Cao, Jin" , "tglx@linutronix.de" , "xpang@redhat.com" , "kernel@kyup.com" , "x86@kernel.org" , "hpa@zytor.com" , "mingo@redhat.com" , "ebiederm@xmission.com" , "joro@8bytes.org" Subject: Re: [PATCH 3/3] x86/apic: Improved the setting of interrupt mode for bsp Thread-Topic: [PATCH 3/3] x86/apic: Improved the setting of interrupt mode for bsp Thread-Index: AQHR4/Dxcmk++ofYqEmLvQ4Js/z9UqAjvPUAgAQ2wYA= Date: Mon, 25 Jul 2016 03:04:14 +0000 Message-ID: <1469415695.2020.60.camel@localhost> References: <1469175026-29447-1-git-send-email-weijg.fnst@cn.fujitsu.com> <1469175026-29447-3-git-send-email-weijg.fnst@cn.fujitsu.com> <20160722104034.GB3543@x1.redhat.com> In-Reply-To: <20160722104034.GB3543@x1.redhat.com> Accept-Language: zh-CN, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.167.226.50] Content-Type: text/plain; charset="utf-8" Content-ID: <1914B100B118D0449D890373F50E46BD@fujitsu.local> MIME-Version: 1.0 X-yoursite-MailScanner-ID: 72BE94295F98.AE3F9 X-yoursite-MailScanner: Found to be clean X-yoursite-MailScanner-From: weijg.fnst@cn.fujitsu.com Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by mail.home.local id u6P34utg011117 Hi He, Thanks for your response firstly. On Fri, 2016-07-22 at 18:40 +0800, Baoquan He wrote: > 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? Yes, I would like to pay more attention on fixing kdump's failure with notsc. No plan to clean up the irq mode setting codes in the crash kernel reboot path. If you are interested in it, please go on. > > 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. Thanks for your reminders. As the comment of init_bsp_APIC(), it's just used to setup the virtual wire mode. so I won't change its name. But i agree with that PIC mode should be considered. Next version will be like below, diff --git a/arch/x86/kernel/apic/apic.c b/arch/x86/kernel/apic/apic.c index 04358e0cf1e2..d40bab947a2a 100644 --- a/arch/x86/kernel/apic/apic.c +++ b/arch/x86/kernel/apic/apic.c @@ -1186,7 +1186,7 @@ void __init init_bsp_APIC(void) * 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 ( pic_mode || (smp_found_config && check_virtual_wire_mode()) || !boot_cpu_has(X86_FEATURE_APIC)) return; > > 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. IMO， the through-IO-APIC mode has no relationship with the setting of local APIC. that's why i only check the pin of IO-APIC in virtual_wire_via_ioapic(). Thanks wei > > *)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 [59.151.112.132] (helo=heian.cn.fujitsu.com) by bombadil.infradead.org with esmtp (Exim 4.85_2 #1 (Red Hat Linux)) id 1bRWCJ-0000lh-FD for kexec@lists.infradead.org; Mon, 25 Jul 2016 03:04:54 +0000 From: "Wei, Jiangang" Subject: Re: [PATCH 3/3] x86/apic: Improved the setting of interrupt mode for bsp Date: Mon, 25 Jul 2016 03:04:14 +0000 Message-ID: <1469415695.2020.60.camel@localhost> References: <1469175026-29447-1-git-send-email-weijg.fnst@cn.fujitsu.com> <1469175026-29447-3-git-send-email-weijg.fnst@cn.fujitsu.com> <20160722104034.GB3543@x1.redhat.com> In-Reply-To: <20160722104034.GB3543@x1.redhat.com> Content-Language: en-US Content-ID: <1914B100B118D0449D890373F50E46BD@fujitsu.local> MIME-Version: 1.0 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: "bhe@redhat.com" 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" SGkgSGUsDQoNClRoYW5rcyBmb3IgeW91ciByZXNwb25zZSBmaXJzdGx5Lg0KDQpPbiBGcmksIDIw MTYtMDctMjIgYXQgMTg6NDAgKzA4MDAsIEJhb3F1YW4gSGUgd3JvdGU6DQo+IEhpIEppYW5nYW5n LA0KPiANCj4gVGhpcyBpcyB2ZXJ5IG5pY2UsIHNob3VsZCBiZSB0aGUgc3R1ZmYgRXJpYyBhbmQg SW5nbyB3b3VsZCBsaWtlIHRvIHNlZS4NCj4gQnV0IEkgaGF2ZSBzZXZlcmFsIHF1ZXN0aW9uczoN Cj4gDQo+IDEpIEFyZSB5b3Ugbm90IGdvaW5nIHRvIGNsZWFuIHVwIHRoZSBvbGQgbGVnYWN5IGly cSBtb2RlIHNldHRpbmcgY29kZSBpbg0KPiAxc3Qga2VybmVsPw0KWWVzLCBJIHdvdWxkIGxpa2Ug dG8gcGF5IG1vcmUgYXR0ZW50aW9uIG9uIGZpeGluZyBrZHVtcCdzIGZhaWx1cmUgd2l0aA0Kbm90 c2MuDQpObyBwbGFuIHRvIGNsZWFuIHVwIHRoZSBpcnEgbW9kZSBzZXR0aW5nIGNvZGVzIGluIHRo ZSBjcmFzaCBrZXJuZWwNCnJlYm9vdCBwYXRoLg0KSWYgeW91IGFyZSBpbnRlcmVzdGVkIGluIGl0 LCBwbGVhc2UgZ28gb24uDQoNCj4gDQo+IDIpSSBjYWxsIHRoZW0gbGVnYWN5IGlycSBtb2RlIGJl Y2F1c2Ugbm90IG9ubHkgYXBpYyB2aXJ0dWFsIHdpcmUgbW9kZQ0KPiBleGlzdHMsIGJ1dCB0aGUg UElDIG1vZGUgaW4geDg2IDMyYml0IHN5c3RlbS4gWW91IG5lZWQgY29uc2lkZXIgaXQgdG9vLg0K PiBUaGVuIGluaXRfYnNwX0FQSUMgbmVlZCBiZSByZW5hbWFlZCB0byBhbiBhcHByb3ByaWF0ZSBv bmUuIEFuZCBhc3N1bWUNCj4gdGhpcyBoYXMgYmVlbiB0ZXN0ZWQgb24geDg2IDMyYml0IHN5c3Rl bS4gDQoNClRoYW5rcyBmb3IgeW91ciByZW1pbmRlcnMuDQpBcyB0aGUgY29tbWVudCBvZiBpbml0 X2JzcF9BUElDKCksIGl0J3MganVzdCB1c2VkIHRvIHNldHVwIHRoZSB2aXJ0dWFsDQp3aXJlIG1v ZGUuDQpzbyBJIHdvbid0IGNoYW5nZSBpdHMgbmFtZS4NCg0KQnV0IGkgYWdyZWUgd2l0aCB0aGF0 IFBJQyBtb2RlIHNob3VsZCBiZSBjb25zaWRlcmVkLg0KTmV4dCB2ZXJzaW9uIHdpbGwgYmUgbGlr ZSBiZWxvdywNCg0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9hcGljL2FwaWMuYyBiL2Fy Y2gveDg2L2tlcm5lbC9hcGljL2FwaWMuYw0KaW5kZXggMDQzNThlMGNmMWUyLi5kNDBiYWI5NDdh MmEgMTAwNjQ0DQotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvYXBpYy9hcGljLmMNCisrKyBiL2FyY2gv eDg2L2tlcm5lbC9hcGljL2FwaWMuYw0KQEAgLTExODYsNyArMTE4Niw3IEBAIHZvaWQgX19pbml0 IGluaXRfYnNwX0FQSUModm9pZCkNCiAgICAgICAgICogdGhlIHdvcnN0IGNhc2UgaXMgdGhhdCBi b3RoIG9mIHRoZW0gYXJlIGluYWN0aXZlLA0KICAgICAgICAgKiBJZiBzbywgV2UgbmVlZCB0byBl bmFibGUgdGhlIHZpcnR1YWwgd2lyZSBtb2RlIHZpYQ0KdGhyb3VnaC1sb2NhbC1BUElDDQogICAg ICAgICAqLw0KLSAgICAgICBpZiAoc21wX2ZvdW5kX2NvbmZpZyB8fCAhYm9vdF9jcHVfaGFzKFg4 Nl9GRUFUVVJFX0FQSUMpDQorICAgICAgIGlmICggcGljX21vZGUgfHwgKHNtcF9mb3VuZF9jb25m aWcgJiYgY2hlY2tfdmlydHVhbF93aXJlX21vZGUoKSkNCnx8DQogICAgICAgICAgICAgICAgIWJv b3RfY3B1X2hhcyhYODZfRkVBVFVSRV9BUElDKSkNCiAgICAgICAgICAgICAgICByZXR1cm47DQo+ IA0KPiAzKSANCj4gDQo+ICopQWJvdXQgSU8tQVBJQyBzZXR0aW5nIGFzIHZpcnR1YWwgd2lyZSBt b2RlLCBJIGFtIGFsd2F5cyBjb25mdXNlZC4gSW4NCj4gTVAgU3BlYyAzLjYuMi4yLCBpdCBzYXlz ICJ0aGUgaW50ZXJydXB0IHNpZ25hbCBwYXNzZXMgdGhyb3VnaCBib3RoIHRoZQ0KPiBJL08gQVBJ QyBhbmQgdGhlIEJTUOKAmXMgbG9jYWwgQVBJQyIuIFRoYXQgbWVhbnMgSU8tQVBJQyB2aXJ0dWFs IHdpcmUgbW9kZQ0KPiBuZWVkIGJvdGggSU8tQVBJQyBhbmQgTEFQSUMgdG8gYmUgc2V0LCBhbmQg d2l0aCBteSB1bmRlcnN0YW5kaW5nIG9ubHkNCj4gcGluIG9mIElPLUFQSUMgaXMgc2V0IGFzIEV4 dEludCwgTEFQSUMgc2hvdWxkIGJlIHBhc3MtdGhyb3VnaC4NCj4gDQo+ICopQnV0IGluIEludGVs IEFyY2ggbWFudWFsIDNBIDEwLjEsIHRoZXJlJ3Mgb25seSBiZWxvdyBzZW50ZW5jZXMgdG8gbWVu dGlvbg0KPiBpdDoNCj4gDQo+IH5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fg0KPiBUaGUgSS9PIEFQSUMgYWxzbyBoYXMgYSDigJx2 aXJ0dWFsIHdpcmUgbW9kZeKAnSB0aGF0IGFsbG93cyBpdCB0byBjb21tdW5pY2F0ZQ0KPiB3aXRo IGEgc3RhbmRhcmQgODI1OUEtc3R5bGUgZXh0ZXJuYWwgaW50ZXJydXB0IGNvbnRyb2xsZXIuIE5v dGUgdGhhdCB0aGUNCj4gbG9jYWwgQVBJQyBjYW4gYmUgZGlzYWJsZWQuIFRoaXMgYWxsb3dzIGFu IGFzc29jaWF0ZWQgcHJvY2Vzc29yIGNvcmUgdG8NCj4gcmVjZWl2ZSBpbnRlcnJ1cHRzIGRpcmVj dGx5IGZyb20gYW4gODI1OUEgaW50ZXJydXB0IGNvbnRyb2xsZXIuDQo+IH5+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4NCj4gDQo+ IEVyaWMncyBjb2RlIGluIG5hdGl2ZV9kaXNhYmxlX2lvX2FwaWMoKSBoYXMgdGhlIHNhbWUgcG9p bnQgYXMgYWJvdmUNCj4gd29yZHMuDQoNCklNT++8jA0KdGhlIHRocm91Z2gtSU8tQVBJQyBtb2Rl IGhhcyBubyByZWxhdGlvbnNoaXAgd2l0aCB0aGUgc2V0dGluZyBvZiBsb2NhbA0KQVBJQy4NCnRo YXQncyB3aHkgaSBvbmx5IGNoZWNrIHRoZSBwaW4gb2YgSU8tQVBJQyBpbiB2aXJ0dWFsX3dpcmVf dmlhX2lvYXBpYygpLg0KDQpUaGFua3MNCndlaQ0KPiANCj4gKilIb3dldmVyIHBsZWFzZSByZWFk IGNvZGUgY29tbWVudHMgaW4gaXJxX3JlbWFwcGluZ19kaXNhYmxlX2lvX2FwaWMoKSwNCj4gSm9l cmcncyBkZXNjcmlwdGlvbiBnaXZlIG1lIGEgZGlmZmVyZW50IGltcHJlc3Npb24gdGhhdCB3ZSBj YW4gY2hvb3NlDQo+IHRvIG9ubHkgdXNlIExBUElDIHZpcnR1YWwgd2lyZSBtb2RlLiBKb2VyZyBp cyBJT01NVSBtYWludGFpbmVycywgaGUgaXMNCj4gdmVyeSBmYW1pbGlhciB3aXRoIGlvLWFwaWMg c2luY2UgSU9NTVUgbmVlZCB0YWtlIG92ZXIgaW8tYXBpYyBlbnRyeQ0KPiBmaWxsaW5nLCB0aGVy ZSBtdXN0IGJlIHJlYXNvbiBoZSB3cm90ZSB0aGF0LiBBZGQgSm9lcmcgdG8gQ0MgbGlzdC4NCj4g DQo+IFNlZW1zIGl0J3MgZGlmZmljdWx0IHRvIGZpbmQgYSBzeXN0ZW0gd2l0aCBJTy1BUElDIHZp cnR1YWwgd2lyZSBtb2RlLA0KPiBtYXliZSB3ZSBjYW4ganVzdCBrZWVwIGl0IGFzIGlzLiBOb3Qg c3VyZSBpZiBJbnRlbCBlbmdpbmVlcnMgY2FuIGhlbHANCj4gZXhwbGFpbiBhbmQgY29uZmlybSB0 aGlzLg0KPiANCj4gVGhhdCdzIGFsbCBJIGNhbiB0aGluayBvZi4NCj4gDQo+IFRoYW5rcw0KPiBC YW9xdWFuDQo+IA0KPiBPbiAwNy8yMi8xNiBhdCAwNDoxMHBtLCBXZWkgSmlhbmdhbmcgd3JvdGU6 DQo+ID4gSWYgd2Ugc3BlY2lmeSB0aGUgJ25vdHNjJyBwYXJhbWV0ZXIgZm9yIHRoZSBkdW1wLWNh cHR1cmUga2VybmVsLA0KPiA+IGFuZCB0aGVuIHRyaWdnZXIgYSBjcmFzaChwYW5pYykgYnkgdXNp bmcgIkFMVC1TeXNScS1jIiBvcg0KPiA+ICJlY2hvIGMgPiAvcHJvYy9zeXNycS10cmlnZ2VyIiwg dGhlIGR1bXAtY2FwdHVyZSBrZXJuZWwgd2lsbA0KPiA+IGhhbmcgaW4gY2FsaWJyYXRlX2RlbGF5 X2NvbnZlcmdlKCkgYW5kIHdhaXQgZm9yIGppZmZpZXMgY2hhbmdlcy4NCj4gPiBzZXJpYWwgbG9n IGFzIGZvbGxvd3M6DQo+ID4gDQo+ID4gICAgIHRzYzogRmFzdCBUU0MgY2FsaWJyYXRpb24gdXNp bmcgUElUDQo+ID4gICAgIHRzYzogRGV0ZWN0ZWQgMjA5OS45NDcgTUh6IHByb2Nlc3Nvcg0KPiA+ ICAgICBDYWxpYnJhdGluZyBkZWxheSBsb29wLi4uDQo+ID4gDQo+ID4gVGhlIHJlYXNvbiBmb3Ig amlmZmllcyBub3QgY2hhbmdlcyBpcyB0aGVyZSdzIG5vIHRpbWVyIGludGVycnVwdA0KPiA+IHBh c3NlZCB0byBkdW1wLWNhcHR1cmUga2VybmVsLg0KPiA+IA0KPiA+IEluIGZhY3QsIG9uY2Uga2Vy bmVsIHBhbmljIG9jY3VycywgdGhlIGxvY2FsIEFQSUMgaXMgZGlzYWJsZWQNCj4gPiBieSBsYXBp Y19zaHV0ZG93bigpIGluIHJlYm9vdCBwYXRoLg0KPiA+IGdlbmVybHkgc3BlYWtpbmcsIGxvY2Fs IEFQSUMgc3RhdGUgY2FuIGJlIGluaXRpYWxpemVkIGJ5IEJJT1MNCj4gPiBhZnRlciBQb3dlci1V cCBvciBSZXNldCwgd2hpY2ggZG9lc24ndCBhcHBseSB0byBrZHVtcCBjYXNlLg0KPiA+IHNvIHRo ZSBrZXJuZWwgaGFzIHRvIGJlIHJlc3BvbnNpYmxlIGZvciBpbml0aWFsaXplIHRoZSBpbnRlcnJ1 cHQNCj4gPiBtb2RlIHByb3Blcmx5IGFjY29yZGluZyB0aGUgbGF0ZXN0IHN0YXR1cyBvZiBBUElD IGluIGJvb3R1cCBwYXRoLg0KPiA+IA0KPiA+IEFuIE1QIG9wZXJhdGluZyBzeXN0ZW0gaXMgYm9v dGVkIHVuZGVyIGVpdGhlciBQSUMgbW9kZSBvcg0KPiA+IHZpcnR1YWwgd2lyZSBtb2RlLiBMYXRl ciwgdGhlIG9wZXJhdGluZyBzeXN0ZW0gc3dpdGNoZXMgdG8NCj4gPiBzeW1tZXRyaWMgSS9PIG1v ZGUgYXMgaXQgZW50ZXJzIG11bHRpcHJvY2Vzc29yIG1vZGUuDQo+ID4gVHdvIGtpbmRzIG9mIHZp cnR1YWwgd2lyZSBtb2RlIGFyZSBkZWZpbmVkIGluIEludGVsIE1QIHNwZWM6DQo+ID4gdmlydHVh bCB3aXJlIG1vZGUgdmlhIGxvY2FsIEFQSUMgb3IgdmlhIEkvTyBBUElDLg0KPiA+IA0KPiA+IE5v dyB3ZSBkZXRlcm1pbmUgdGhlIG1vZGUgb2YgQVBJQyBvbmx5IHRocm91Z2ggYSBTTVAgQklPUyhN UCB0YWJsZSkuDQo+ID4gVGhhdCdzIG5vdCBlbm91Z2guDQo+ID4gSXQncyBiZXR0ZXIgdG8gZG8g ZnVydGhlciBjaGVjayBpZiBBUElDIHdvcmtzIHdpdGggZWZmZWN0aXZlIG1vZGUsDQo+ID4gYW5k IGRvIHNvbWUgcG9ycGVyIHNldHRpbmcuDQo+ID4gDQo+ID4gU2lnbmVkLW9mZi1ieTogQ2FvIGpp biA8Y2Fvai5mbnN0QGNuLmZ1aml0c3UuY29tPg0KPiA+IFNpZ25lZC1vZmYtYnk6IFdlaSBKaWFu Z2FuZyA8d2VpamcuZm5zdEBjbi5mdWppdHN1LmNvbT4NCj4gPiAtLS0NCj4gPiAgYXJjaC94ODYv aW5jbHVkZS9hc20vaW9fYXBpYy5oIHwgIDUgKysrKw0KPiA+ICBhcmNoL3g4Ni9rZXJuZWwvYXBp Yy9hcGljLmMgICAgfCA1NSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr Ky0NCj4gPiAgYXJjaC94ODYva2VybmVsL2FwaWMvaW9fYXBpYy5jIHwgMjggKysrKysrKysrKysr KysrKysrKysrDQo+ID4gIDMgZmlsZXMgY2hhbmdlZCwgODcgaW5zZXJ0aW9ucygrKSwgMSBkZWxl dGlvbigtKQ0KPiA+IA0KPiA+IGRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9pb19h cGljLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9pb19hcGljLmgNCj4gPiBpbmRleCA2Y2JmMmNm YjNmOGEuLjY1NTBiZDQzZmEzOSAxMDA2NDQNCj4gPiAtLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2Fz bS9pb19hcGljLmgNCj4gPiArKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9pb19hcGljLmgNCj4g PiBAQCAtMTkwLDYgKzE5MCw3IEBAIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgaW50IGlvX2FwaWNf cmVhZCh1bnNpZ25lZCBpbnQgYXBpYywgdW5zaWduZWQgaW50IHJlZykNCj4gPiAgfQ0KPiA+ICAN Cj4gPiAgZXh0ZXJuIHZvaWQgc2V0dXBfSU9fQVBJQyh2b2lkKTsNCj4gPiArZXh0ZXJuIGJvb2wg dmlydHVhbF93aXJlX3ZpYV9pb2FwaWModm9pZCk7DQo+ID4gIGV4dGVybiB2b2lkIGVuYWJsZV9J T19BUElDKHZvaWQpOw0KPiA+ICBleHRlcm4gdm9pZCBkaXNhYmxlX0lPX0FQSUModm9pZCk7DQo+ ID4gIGV4dGVybiB2b2lkIHNldHVwX2lvYXBpY19kZXN0KHZvaWQpOw0KPiA+IEBAIC0yMzEsNiAr MjMyLDEwIEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBpb19hcGljX2luaXRfbWFwcGluZ3Modm9pZCkg eyB9DQo+ID4gICNkZWZpbmUgbmF0aXZlX2Rpc2FibGVfaW9fYXBpYwkJTlVMTA0KPiA+ICANCj4g PiAgc3RhdGljIGlubGluZSB2b2lkIHNldHVwX0lPX0FQSUModm9pZCkgeyB9DQo+ID4gK3N0YXRp YyBpbmxpbmUgYm9vbCB2aXJ0dWFsX3dpcmVfdmlhX2lvYXBpYyh2b2lkKQ0KPiA+ICt7DQo+ID4g KwlyZXR1cm4gdHJ1ZTsNCj4gPiArfQ0KPiA+ICBzdGF0aWMgaW5saW5lIHZvaWQgZW5hYmxlX0lP X0FQSUModm9pZCkgeyB9DQo+ID4gIHN0YXRpYyBpbmxpbmUgdm9pZCBzZXR1cF9pb2FwaWNfZGVz dCh2b2lkKSB7IH0NCj4gPiAgDQo+ID4gZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9hcGlj L2FwaWMuYyBiL2FyY2gveDg2L2tlcm5lbC9hcGljL2FwaWMuYw0KPiA+IGluZGV4IDhlMjViOWIy ZDM1MS4uMDQzNThlMGNmMWUyIDEwMDY0NA0KPiA+IC0tLSBhL2FyY2gveDg2L2tlcm5lbC9hcGlj L2FwaWMuYw0KPiA+ICsrKyBiL2FyY2gveDg2L2tlcm5lbC9hcGljL2FwaWMuYw0KPiA+IEBAIC0x MTI0LDYgKzExMjQsNTMgQEAgdm9pZCBfX2luaXQgc3luY19BcmJfSURzKHZvaWQpDQo+ID4gIH0N Cj4gPiAgDQo+ID4gIC8qDQo+ID4gKyAqIFJldHVybiBmYWxzZSBtZWFucyB0aGUgdmlydHVhbCB3 aXJlIG1vZGUgdGhyb3VnaC1sb2NhbC1hcGljIGlzIGluYWN0aXZlDQo+ID4gKyAqLw0KPiA+ICtz dGF0aWMgYm9vbCB2aXJ0dWFsX3dpcmVfdmlhX2xhcGljKHZvaWQpDQo+ID4gK3sNCj4gPiArCXVu c2lnbmVkIGludCB2YWx1ZTsNCj4gPiArDQo+ID4gKwkvKiBDaGVjayB0aGUgQVBJQyBnbG9iYWwg ZW5hYmxlL2Rpc2FibGUgZmxhZyBmaXJzdGx5ICovDQo+ID4gKwlpZiAoYm9vdF9jcHVfZGF0YS54 ODYgPj0gNikgew0KPiA+ICsJCXUzMiBoLCBsOw0KPiA+ICsNCj4gPiArCQlyZG1zcihNU1JfSUEz Ml9BUElDQkFTRSwgbCwgaCk7DQo+ID4gKwkJLyoNCj4gPiArCQkgKiBJZiBsb2NhbCBBUElDIGlz IGRpc2FibGVkIGJ5IEJJT1MNCj4gPiArCQkgKiBkbyBub3RoaW5nLCBidXQgcmV0dXJuIHRydWUN Cj4gPiArCQkgKi8NCj4gPiArCQlpZiAoIShsICYgTVNSX0lBMzJfQVBJQ0JBU0VfRU5BQkxFKSkN Cj4gPiArCQkJcmV0dXJuIHRydWU7DQo+ID4gKwl9DQo+ID4gKw0KPiA+ICsJLyogQ2hlY2sgdGhl IHNvZnR3YXJlIGVuYWJsZS9kaXNhYmxlIGZsYWcgKi8NCj4gPiArCXZhbHVlID0gYXBpY19yZWFk KEFQSUNfU1BJVik7DQo+ID4gKwlpZiAoISh2YWx1ZSAmIEFQSUNfU1BJVl9BUElDX0VOQUJMRUQp KQ0KPiA+ICsJCXJldHVybiBmYWxzZTsNCj4gPiArDQo+ID4gKwkvKg0KPiA+ICsJICogVmlydHVh bCB3aXJlIG1vZGUgdmlhIGxvY2FsIEFQSUMgcmVxdWVzdHMNCj4gPiArCSAqIEFQSUMgdG8gZW5h YmxlIHRoZSBMSU5UMCBmb3IgZWRnZS10cmdnZXJlZCBFeHRJTlQgZGVsaXZlcnkgbW9kZQ0KPiA+ ICsJICogYW5kIExJTlQxIGZvciBsZXZlbC10cmlnZ2VyZWQgTk1JIGRlbGl2ZXJ5IG1vZGUNCj4g PiArCSAqLw0KPiA+ICsJdmFsdWUgPSBhcGljX3JlYWQoQVBJQ19MVlQwKTsNCj4gPiArCWlmIChH RVRfQVBJQ19ERUxJVkVSWV9NT0RFKHZhbHVlKSAhPSBBUElDX01PREVfRVhUSU5UKQ0KPiA+ICsJ CXJldHVybiBmYWxzZTsNCj4gPiArDQo+ID4gKwl2YWx1ZSA9IGFwaWNfcmVhZChBUElDX0xWVDEp Ow0KPiA+ICsJaWYgKEdFVF9BUElDX0RFTElWRVJZX01PREUodmFsdWUpICE9IEFQSUNfTU9ERV9O TUkpDQo+ID4gKwkJcmV0dXJuIGZhbHNlOw0KPiA+ICsNCj4gPiArCXJldHVybiB0cnVlOw0KPiA+ ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgYm9vbCBjaGVja192aXJ0dWFsX3dpcmVfbW9kZSh2b2lk KQ0KPiA+ICt7DQo+ID4gKwkvKiBOZWl0aGVyIG9mIHZpcnR1YWwgd2lyZSBtb2RlIGlzIGFjdGl2 ZSwgcmV0dXJuIGZhbHNlICovDQo+ID4gKwlyZXR1cm4gIHZpcnR1YWxfd2lyZV92aWFfbGFwaWMo KSB8fCB2aXJ0dWFsX3dpcmVfdmlhX2lvYXBpYygpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICsvKg0K PiA+ICAgKiBBbiBpbml0aWFsIHNldHVwIG9mIHRoZSB2aXJ0dWFsIHdpcmUgbW9kZS4NCj4gPiAg ICovDQo+ID4gIHZvaWQgX19pbml0IGluaXRfYnNwX0FQSUModm9pZCkNCj4gPiBAQCAtMTEzMyw4 ICsxMTgwLDE0IEBAIHZvaWQgX19pbml0IGluaXRfYnNwX0FQSUModm9pZCkNCj4gPiAgCS8qDQo+ ID4gIAkgKiBEb24ndCBkbyB0aGUgc2V0dXAgbm93IGlmIHdlIGhhdmUgYSBTTVAgQklPUyBhcyB0 aGUNCj4gPiAgCSAqIHRocm91Z2gtSS9PLUFQSUMgdmlydHVhbCB3aXJlIG1vZGUgbWlnaHQgYmUg YWN0aXZlLg0KPiA+ICsJICoNCj4gPiArCSAqIEl0J3MgYmV0dGVyIHRvIGRvIGZ1cnRoZXIgY2hl Y2sgaWYgZWl0aGVyIHRocm91Z2gtSS9PLUFQSUMNCj4gPiArCSAqIG9yIHRocm91Z2gtbG9jYWwt QVBJQyBpcyBhY3RpdmUuDQo+ID4gKwkgKiB0aGUgd29yc3QgY2FzZSBpcyB0aGF0IGJvdGggb2Yg dGhlbSBhcmUgaW5hY3RpdmUsDQo+ID4gKwkgKiBJZiBzbywgV2UgbmVlZCB0byBlbmFibGUgdGhl IHZpcnR1YWwgd2lyZSBtb2RlIHZpYSB0aHJvdWdoLWxvY2FsLUFQSUMNCj4gPiAgCSAqLw0KPiA+ IC0JaWYgKHNtcF9mb3VuZF9jb25maWcgfHwgIWJvb3RfY3B1X2hhcyhYODZfRkVBVFVSRV9BUElD KSkNCj4gPiArCWlmICgoc21wX2ZvdW5kX2NvbmZpZyAmJiBjaGVja192aXJ0dWFsX3dpcmVfbW9k ZSgpKSB8fA0KPiA+ICsJCSFib290X2NwdV9oYXMoWDg2X0ZFQVRVUkVfQVBJQykpDQo+ID4gIAkJ cmV0dXJuOw0KPiA+ICANCj4gPiAgCS8qDQo+ID4gZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5l bC9hcGljL2lvX2FwaWMuYyBiL2FyY2gveDg2L2tlcm5lbC9hcGljL2lvX2FwaWMuYw0KPiA+IGlu ZGV4IDQ0NjcwMmVkOTlkYy4uNWEzMmMyNjkzOGFjIDEwMDY0NA0KPiA+IC0tLSBhL2FyY2gveDg2 L2tlcm5lbC9hcGljL2lvX2FwaWMuYw0KPiA+ICsrKyBiL2FyY2gveDg2L2tlcm5lbC9hcGljL2lv X2FwaWMuYw0KPiA+IEBAIC0xMzc5LDYgKzEzNzksMzQgQEAgdm9pZCBfX2luaXQgcHJpbnRfSU9f QVBJQ3Modm9pZCkNCj4gPiAgLyogV2hlcmUgaWYgYW55d2hlcmUgaXMgdGhlIGk4MjU5IGNvbm5l Y3QgaW4gZXh0ZXJuYWwgaW50IG1vZGUgKi8NCj4gPiAgc3RhdGljIHN0cnVjdCB7IGludCBwaW4s IGFwaWM7IH0gaW9hcGljX2k4MjU5ID0geyAtMSwgLTEgfTsNCj4gPiAgDQo+ID4gKy8qDQo+ID4g KyAqIFJldHVybiBmYWxzZSBtZWFucyB0aGUgdmlydHVhbCB3aXJlIG1vZGUgdmlhIEkvTyBBUElD IGlzIGluYWN0aXZlDQo+ID4gKyAqLw0KPiA+ICtib29sIHZpcnR1YWxfd2lyZV92aWFfaW9hcGlj KHZvaWQpDQo+ID4gK3sNCj4gPiArCWludCBhcGljLCBwaW47DQo+ID4gKw0KPiA+ICsJZm9yX2Vh Y2hfaW9hcGljX3BpbihhcGljLCBwaW4pIHsNCj4gPiArCQkvKiBTZWUgaWYgYW55IG9mIHRoZSBw aW5zIGlzIGluIEV4dElOVCBtb2RlICovDQo+ID4gKwkJc3RydWN0IElPX0FQSUNfcm91dGVfZW50 cnkgZW50cnkgPSBpb2FwaWNfcmVhZF9lbnRyeShhcGljLCBwaW4pOw0KPiA+ICsNCj4gPiArCQkv Kg0KPiA+ICsJCSAqIElmIHRoZSBpbnRlcnJ1cHQgbGluZSBpcyBlbmFibGVkIGFuZCBpbiBFeHRJ bnQgbW9kZQ0KPiA+ICsJCSAqIEkgaGF2ZSBmb3VuZCB0aGUgcGluIHdoZXJlIHRoZSBpODI1OSBp cyBjb25uZWN0ZWQuDQo+ID4gKwkJICovDQo+ID4gKwkJaWYgKChlbnRyeS5tYXNrID09IDApICYm IChlbnRyeS5kZWxpdmVyeV9tb2RlID09IGRlc3RfRXh0SU5UKSkNCj4gPiArCQkJcmV0dXJuIHRy dWU7DQo+ID4gKwl9DQo+ID4gKw0KPiA+ICsJLyoNCj4gPiArCSAqIFZpcnR1YWwgd2lyZSBtb2Rl IHZpYSBJL08gQVBJQyByZXF1ZXN0cw0KPiA+ICsJICogSS9PIEFQSUMgYmUgY29ubmVjdGVkIHRv IGk4MjU5IGluIGNoYXB0ZXIgMy42LjIuMiBvZiB0aGUgTVAgdjEuNCBzcGVjDQo+ID4gKwkgKiBJ ZiBubyBwaW4gaW4gRXh0SW50IG1vZGUsDQo+ID4gKwkgKiB0aGUgdGhyb3VnaC1JL08tQVBJQyB2 aXJ0dWFsIHdpcmUgbW9kZSBjYW4gYmUgcmVnYXJkZWQgaW5hY3RpdmUuDQo+ID4gKwkgKi8NCj4g PiArCXJldHVybiBmYWxzZTsNCj4gPiArfQ0KPiA+ICsNCj4gPiAgdm9pZCBfX2luaXQgZW5hYmxl X0lPX0FQSUModm9pZCkNCj4gPiAgew0KPiA+ICAJaW50IGk4MjU5X2FwaWMsIGk4MjU5X3BpbjsN Cj4gPiAtLSANCj4gPiAxLjkuMw0KPiA+IA0KPiA+IA0KPiA+IA0KPiANCj4gDQoNCgoKX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18Ka2V4ZWMgbWFpbGluZyBs aXN0CmtleGVjQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcv bWFpbG1hbi9saXN0aW5mby9rZXhlYwo=