From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755289Ab2GQKZF (ORCPT ); Tue, 17 Jul 2012 06:25:05 -0400 Received: from mo-p00-ob.rzone.de ([81.169.146.160]:19638 "EHLO mo-p00-ob.rzone.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753999Ab2GQKY7 (ORCPT ); Tue, 17 Jul 2012 06:24:59 -0400 X-RZG-AUTH: :P2EQZWCpfu+qG7CngxMFH1J+zrwiavkK6tmQaLfmztM8TOFJji0PEBZF X-RZG-CLASS-ID: mo00 Date: Tue, 17 Jul 2012 12:24:56 +0200 From: Olaf Hering To: Konrad Rzeszutek Wilk Cc: Keir Fraser , xen-devel@lists.xensource.com, kexec@lists.infradead.org, linux-kernel@vger.kernel.org, Jan Beulich , Daniel Kiper Subject: Re: [Xen-devel] incorrect layout of globals from head_64.S during kexec boot Message-ID: <20120717102456.GA8197@aepfle.de> References: <20120710180953.GB20075@aepfle.de> <20120715160653.GA22779@aepfle.de> <20120716154647.GC13540@phenom.dumpdata.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20120716154647.GC13540@phenom.dumpdata.com> User-Agent: Mutt/1.5.21.rev5543 (2011-12-20) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Mon, Jul 16, Konrad Rzeszutek Wilk wrote: > On Sun, Jul 15, 2012 at 06:06:53PM +0200, Olaf Hering wrote: > > -void __ref xen_hvm_init_shared_info(void) > > +static struct shared_info *hvm_shared_info; > > +static unsigned long hvm_shared_info_pfn; > > + > > Please include a big comment explainig what this machination is OK > to do multiple times. If you can include the juicy snippets of the > email converstation in this comment so that in 6 months if somebody > looks at this they have a good understanding of it. I have added a comment to the new patch, and I will extend it further in the commit message. > > + /* Move pfn, disconnects previous pfn from mfn */ > > + set_shared_info(sip, pfn); > > + > > + /* Allocate new mfn for previous pfn */ > > + rc = HYPERVISOR_memory_op(XENMEM_populate_physmap, &reservation); > > + WARN_ON(rc != 1); > > Shouldn't you do some recovery if it fails? Like reassign the old RAM pfn > back to the shared page? I moved the whole reassignment into the shutdown path because there is appearently no sane way to make the move atomic. Shortly before reboot all vcpus are still online, but hopefully the other vcpus have no work left. See below, the change is on top of the two other patches I sent out today. Olaf xen PVonHVM: move shared_info to MMIO before kexec Signed-off-by: Olaf Hering --- arch/x86/xen/enlighten.c | 114 +++++++++++++++++++++++++++++++++++++++----- arch/x86/xen/suspend.c | 2 +- arch/x86/xen/xen-ops.h | 2 +- drivers/xen/platform-pci.c | 15 ++++++ include/xen/events.h | 2 + 5 Dateien geändert, 122 Zeilen hinzugefügt(+), 13 Zeilen entfernt(-) diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c index 184fa9c..3cf233b 100644 --- a/arch/x86/xen/enlighten.c +++ b/arch/x86/xen/enlighten.c @@ -31,6 +31,7 @@ #include #include #include +#include #include #include @@ -1439,38 +1440,126 @@ asmlinkage void __init xen_start_kernel(void) #endif } -void __ref xen_hvm_init_shared_info(void) +#ifdef CONFIG_XEN_PVHVM +/* + * The pfn containing the shared_info is located somewhere in RAM. This + * will cause trouble if the current kernel is doing a kexec boot into a + * new kernel. The new kernel (and its startup code) can not know where + * the pfn is, so it can not reserve the page. The hypervisor will + * continue to update the pfn, and as a result memory corruption occours + * in the new kernel. + * + * One way to work around this issue is to allocate a page in the + * xen-platform pci device's BAR memory range. But pci init is done very + * late and the shared_info page is already in use very early to read + * the pvclock. So moving the pfn from RAM to MMIO is racy because some + * code paths on other vcpus could access the pfn during the small + * window when the old pfn is moved to the new pfn. There is even a + * small window were the old pfn is not backed by a mfn, and during that + * time all reads return -1. + * + * Because it is not known upfront where the MMIO region is located it + * can not be used right from the start in xen_hvm_init_shared_info. + * + * To minimise trouble the move of the pfn is done shortly before kexec. + * This does not eliminate the race because all vcpus are still online + * when the syscore_ops will be called. But hopefully there is no work + * pending at this point in time. Also the syscore_op is run last which + * reduces the risk further. + */ + +static struct shared_info *xen_hvm_shared_info; + +static void xen_hvm_connect_shared_info(unsigned long pfn) { - int cpu; struct xen_add_to_physmap xatp; - static struct shared_info *shared_info_page = 0; - if (!shared_info_page) - shared_info_page = (struct shared_info *) - extend_brk(PAGE_SIZE, PAGE_SIZE); xatp.domid = DOMID_SELF; xatp.idx = 0; xatp.space = XENMAPSPACE_shared_info; - xatp.gpfn = __pa(shared_info_page) >> PAGE_SHIFT; + xatp.gpfn = pfn; if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp)) BUG(); - HYPERVISOR_shared_info = (struct shared_info *)shared_info_page; +} +static void xen_hvm_set_shared_info(struct shared_info *sip) +{ + int cpu; + + HYPERVISOR_shared_info = sip; /* xen_vcpu is a pointer to the vcpu_info struct in the shared_info * page, we use it in the event channel upcall and in some pvclock * related functions. We don't need the vcpu_info placement * optimizations because we don't use any pv_mmu or pv_irq op on * HVM. - * When xen_hvm_init_shared_info is run at boot time only vcpu 0 is - * online but xen_hvm_init_shared_info is run at resume time too and + * When xen_hvm_set_shared_info is run at boot time only vcpu 0 is + * online but xen_hvm_set_shared_info is run at resume time too and * in that case multiple vcpus might be online. */ for_each_online_cpu(cpu) { per_cpu(xen_vcpu, cpu) = &HYPERVISOR_shared_info->vcpu_info[cpu]; } } -#ifdef CONFIG_XEN_PVHVM +/* Reconnect the shared_info pfn to a mfn */ +void xen_hvm_resume_shared_info(void) +{ + xen_hvm_connect_shared_info(__pa(xen_hvm_shared_info) >> PAGE_SHIFT); +} + +#ifdef CONFIG_KEXEC +static struct shared_info *xen_hvm_shared_info_kexec; +static unsigned long xen_hvm_shared_info_pfn_kexec; + +/* Remember a pfn in MMIO space for kexec reboot */ +void __devinit xen_hvm_prepare_kexec(struct shared_info *sip, unsigned long pfn) +{ + xen_hvm_shared_info_kexec = sip; + xen_hvm_shared_info_pfn_kexec = pfn; +} + +static void xen_hvm_syscore_shutdown(void) +{ + struct xen_memory_reservation reservation = { + .domid = DOMID_SELF, + .nr_extents = 1, + }; + unsigned long prev_pfn; + int rc; + + if (!xen_hvm_shared_info_kexec) + return; + + prev_pfn = __pa(xen_hvm_shared_info) >> PAGE_SHIFT; + set_xen_guest_handle(reservation.extent_start, &prev_pfn); + + /* Move pfn to MMIO, disconnects previous pfn from mfn */ + xen_hvm_connect_shared_info(xen_hvm_shared_info_pfn_kexec); + + /* Update pointers, following hypercall is also a memory barrier */ + xen_hvm_set_shared_info(xen_hvm_shared_info_kexec); + + /* Allocate new mfn for previous pfn */ + rc = HYPERVISOR_memory_op(XENMEM_populate_physmap, &reservation); + + /* Make sure the previous pfn is really connected to a (new) mfn */ + BUG_ON(rc != 1); +} + +static struct syscore_ops xen_hvm_syscore_ops = { + .shutdown = xen_hvm_syscore_shutdown, +}; +#endif + +/* Use a pfn in RAM, may move to MMIO before kexec. */ +static void __init xen_hvm_init_shared_info(void) +{ + /* Remember pointer for resume */ + xen_hvm_shared_info = extend_brk(PAGE_SIZE, PAGE_SIZE); + xen_hvm_connect_shared_info(__pa(xen_hvm_shared_info) >> PAGE_SHIFT); + xen_hvm_set_shared_info(xen_hvm_shared_info); +} + static void __init init_hvm_pv_info(void) { int major, minor; @@ -1521,6 +1610,9 @@ static void __init xen_hvm_guest_init(void) init_hvm_pv_info(); xen_hvm_init_shared_info(); +#ifdef CONFIG_KEXEC + register_syscore_ops(&xen_hvm_syscore_ops); +#endif if (xen_feature(XENFEAT_hvm_callback_vector)) xen_have_vector_callback = 1; diff --git a/arch/x86/xen/suspend.c b/arch/x86/xen/suspend.c index 45329c8..ae8a00c 100644 --- a/arch/x86/xen/suspend.c +++ b/arch/x86/xen/suspend.c @@ -30,7 +30,7 @@ void xen_arch_hvm_post_suspend(int suspend_cancelled) { #ifdef CONFIG_XEN_PVHVM int cpu; - xen_hvm_init_shared_info(); + xen_hvm_resume_shared_info(); xen_callback_vector(); xen_unplug_emulated_devices(); if (xen_feature(XENFEAT_hvm_safe_pvclock)) { diff --git a/arch/x86/xen/xen-ops.h b/arch/x86/xen/xen-ops.h index 202d4c1..1e4329e 100644 --- a/arch/x86/xen/xen-ops.h +++ b/arch/x86/xen/xen-ops.h @@ -41,7 +41,7 @@ void xen_enable_syscall(void); void xen_vcpu_restore(void); void xen_callback_vector(void); -void xen_hvm_init_shared_info(void); +void xen_hvm_resume_shared_info(void); void xen_unplug_emulated_devices(void); void __init xen_build_dynamic_phys_to_machine(void); diff --git a/drivers/xen/platform-pci.c b/drivers/xen/platform-pci.c index 97ca359..d4c50d6 100644 --- a/drivers/xen/platform-pci.c +++ b/drivers/xen/platform-pci.c @@ -101,6 +101,19 @@ static int platform_pci_resume(struct pci_dev *pdev) return 0; } +static void __devinit prepare_shared_info(void) +{ +#ifdef CONFIG_KEXEC + unsigned long addr; + struct shared_info *hvm_shared_info; + + addr = alloc_xen_mmio(PAGE_SIZE); + hvm_shared_info = ioremap(addr, PAGE_SIZE); + memset(hvm_shared_info, 0, PAGE_SIZE); + xen_hvm_prepare_kexec(hvm_shared_info, addr >> PAGE_SHIFT); +#endif +} + static int __devinit platform_pci_init(struct pci_dev *pdev, const struct pci_device_id *ent) { @@ -138,6 +151,8 @@ static int __devinit platform_pci_init(struct pci_dev *pdev, platform_mmio = mmio_addr; platform_mmiolen = mmio_len; + prepare_shared_info(); + if (!xen_have_vector_callback) { ret = xen_allocate_irq(pdev); if (ret) { diff --git a/include/xen/events.h b/include/xen/events.h index 04399b2..9c641de 100644 --- a/include/xen/events.h +++ b/include/xen/events.h @@ -58,6 +58,8 @@ void notify_remote_via_irq(int irq); void xen_irq_resume(void); +void xen_hvm_prepare_kexec(struct shared_info *sip, unsigned long pfn); + /* Clear an irq's pending state, in preparation for polling on it */ void xen_clear_irq_pending(int irq); void xen_set_irq_pending(int irq); -- 1.7.10.4 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mo6-p00-ob.rzone.de ([2a01:238:20a:202:5300::1]) by merlin.infradead.org with esmtps (Exim 4.76 #1 (Red Hat Linux)) id 1Sr4yB-0003OQ-DI for kexec@lists.infradead.org; Tue, 17 Jul 2012 10:25:37 +0000 Date: Tue, 17 Jul 2012 12:24:56 +0200 From: Olaf Hering Subject: Re: [Xen-devel] incorrect layout of globals from head_64.S during kexec boot Message-ID: <20120717102456.GA8197@aepfle.de> References: <20120710180953.GB20075@aepfle.de> <20120715160653.GA22779@aepfle.de> <20120716154647.GC13540@phenom.dumpdata.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20120716154647.GC13540@phenom.dumpdata.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-bounces@lists.infradead.org Errors-To: kexec-bounces+dwmw2=infradead.org@lists.infradead.org To: Konrad Rzeszutek Wilk Cc: xen-devel@lists.xensource.com, kexec@lists.infradead.org, linux-kernel@vger.kernel.org, Keir Fraser , Jan Beulich , Daniel Kiper T24gTW9uLCBKdWwgMTYsIEtvbnJhZCBSemVzenV0ZWsgV2lsayB3cm90ZToKCj4gT24gU3VuLCBK dWwgMTUsIDIwMTIgYXQgMDY6MDY6NTNQTSArMDIwMCwgT2xhZiBIZXJpbmcgd3JvdGU6Cj4gPiAt dm9pZCBfX3JlZiB4ZW5faHZtX2luaXRfc2hhcmVkX2luZm8odm9pZCkKPiA+ICtzdGF0aWMgc3Ry dWN0IHNoYXJlZF9pbmZvICpodm1fc2hhcmVkX2luZm87Cj4gPiArc3RhdGljIHVuc2lnbmVkIGxv bmcgaHZtX3NoYXJlZF9pbmZvX3BmbjsKPiA+ICsKPiAKPiBQbGVhc2UgaW5jbHVkZSBhIGJpZyBj b21tZW50IGV4cGxhaW5pZyB3aGF0IHRoaXMgbWFjaGluYXRpb24gaXMgT0sKPiB0byBkbyBtdWx0 aXBsZSB0aW1lcy4gSWYgeW91IGNhbiBpbmNsdWRlIHRoZSBqdWljeSBzbmlwcGV0cyBvZiB0aGUK PiBlbWFpbCBjb252ZXJzdGF0aW9uIGluIHRoaXMgY29tbWVudCBzbyB0aGF0IGluIDYgbW9udGhz IGlmIHNvbWVib2R5Cj4gbG9va3MgYXQgdGhpcyB0aGV5IGhhdmUgYSBnb29kIHVuZGVyc3RhbmRp bmcgb2YgaXQuCgpJIGhhdmUgYWRkZWQgYSBjb21tZW50IHRvIHRoZSBuZXcgcGF0Y2gsIGFuZCBJ IHdpbGwgZXh0ZW5kIGl0IGZ1cnRoZXIgaW4KdGhlIGNvbW1pdCBtZXNzYWdlLgoKPiA+ICsJLyog TW92ZSBwZm4sIGRpc2Nvbm5lY3RzIHByZXZpb3VzIHBmbiBmcm9tIG1mbiAqLwo+ID4gKwlzZXRf c2hhcmVkX2luZm8oc2lwLCBwZm4pOwo+ID4gKwo+ID4gKwkvKiBBbGxvY2F0ZSBuZXcgbWZuIGZv ciBwcmV2aW91cyBwZm4gKi8KPiA+ICsJcmMgPSBIWVBFUlZJU09SX21lbW9yeV9vcChYRU5NRU1f cG9wdWxhdGVfcGh5c21hcCwgJnJlc2VydmF0aW9uKTsKPiA+ICsJV0FSTl9PTihyYyAhPSAxKTsK PiAKPiBTaG91bGRuJ3QgeW91IGRvIHNvbWUgcmVjb3ZlcnkgaWYgaXQgZmFpbHM/IExpa2UgcmVh c3NpZ24gdGhlIG9sZCBSQU0gcGZuCj4gYmFjayB0byB0aGUgc2hhcmVkIHBhZ2U/CgpJIG1vdmVk IHRoZSB3aG9sZSByZWFzc2lnbm1lbnQgaW50byB0aGUgc2h1dGRvd24gcGF0aCBiZWNhdXNlIHRo ZXJlIGlzCmFwcGVhcmVudGx5IG5vIHNhbmUgd2F5IHRvIG1ha2UgdGhlIG1vdmUgYXRvbWljLiBT aG9ydGx5IGJlZm9yZSByZWJvb3QKYWxsIHZjcHVzIGFyZSBzdGlsbCBvbmxpbmUsIGJ1dCBob3Bl ZnVsbHkgdGhlIG90aGVyIHZjcHVzIGhhdmUgbm8gd29yawpsZWZ0LgoKU2VlIGJlbG93LCB0aGUg Y2hhbmdlIGlzIG9uIHRvcCBvZiB0aGUgdHdvIG90aGVyIHBhdGNoZXMgSSBzZW50IG91dAp0b2Rh eS4KCk9sYWYKCnhlbiBQVm9uSFZNOiBtb3ZlIHNoYXJlZF9pbmZvIHRvIE1NSU8gYmVmb3JlIGtl eGVjCgpTaWduZWQtb2ZmLWJ5OiBPbGFmIEhlcmluZyA8b2xhZkBhZXBmbGUuZGU+Ci0tLQogYXJj aC94ODYveGVuL2VubGlnaHRlbi5jICAgfCAgMTE0ICsrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKy0tLS0tCiBhcmNoL3g4Ni94ZW4vc3VzcGVuZC5jICAgICB8ICAgIDIgKy0K IGFyY2gveDg2L3hlbi94ZW4tb3BzLmggICAgIHwgICAgMiArLQogZHJpdmVycy94ZW4vcGxhdGZv cm0tcGNpLmMgfCAgIDE1ICsrKysrKwogaW5jbHVkZS94ZW4vZXZlbnRzLmggICAgICAgfCAgICAy ICsKIDUgRGF0ZWllbiBnZcOkbmRlcnQsIDEyMiBaZWlsZW4gaGluenVnZWbDvGd0KCspLCAxMyBa ZWlsZW4gZW50ZmVybnQoLSkKCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni94ZW4vZW5saWdodGVuLmMg Yi9hcmNoL3g4Ni94ZW4vZW5saWdodGVuLmMKaW5kZXggMTg0ZmE5Yy4uM2NmMjMzYiAxMDA2NDQK LS0tIGEvYXJjaC94ODYveGVuL2VubGlnaHRlbi5jCisrKyBiL2FyY2gveDg2L3hlbi9lbmxpZ2h0 ZW4uYwpAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgogI2luY2x1ZGUg PGxpbnV4L2dmcC5oPgogI2luY2x1ZGUgPGxpbnV4L21lbWJsb2NrLmg+CisjaW5jbHVkZSA8bGlu dXgvc3lzY29yZV9vcHMuaD4KIAogI2luY2x1ZGUgPHhlbi94ZW4uaD4KICNpbmNsdWRlIDx4ZW4v aW50ZXJmYWNlL3hlbi5oPgpAQCAtMTQzOSwzOCArMTQ0MCwxMjYgQEAgYXNtbGlua2FnZSB2b2lk IF9faW5pdCB4ZW5fc3RhcnRfa2VybmVsKHZvaWQpCiAjZW5kaWYKIH0KIAotdm9pZCBfX3JlZiB4 ZW5faHZtX2luaXRfc2hhcmVkX2luZm8odm9pZCkKKyNpZmRlZiBDT05GSUdfWEVOX1BWSFZNCisv KgorICogVGhlIHBmbiBjb250YWluaW5nIHRoZSBzaGFyZWRfaW5mbyBpcyBsb2NhdGVkIHNvbWV3 aGVyZSBpbiBSQU0uIFRoaXMKKyAqIHdpbGwgY2F1c2UgdHJvdWJsZSBpZiB0aGUgY3VycmVudCBr ZXJuZWwgaXMgZG9pbmcgYSBrZXhlYyBib290IGludG8gYQorICogbmV3IGtlcm5lbC4gVGhlIG5l dyBrZXJuZWwgKGFuZCBpdHMgc3RhcnR1cCBjb2RlKSBjYW4gbm90IGtub3cgd2hlcmUKKyAqIHRo ZSBwZm4gaXMsIHNvIGl0IGNhbiBub3QgcmVzZXJ2ZSB0aGUgcGFnZS4gVGhlIGh5cGVydmlzb3Ig d2lsbAorICogY29udGludWUgdG8gdXBkYXRlIHRoZSBwZm4sIGFuZCBhcyBhIHJlc3VsdCBtZW1v cnkgY29ycnVwdGlvbiBvY2NvdXJzCisgKiBpbiB0aGUgbmV3IGtlcm5lbC4KKyAqCisgKiBPbmUg d2F5IHRvIHdvcmsgYXJvdW5kIHRoaXMgaXNzdWUgaXMgdG8gYWxsb2NhdGUgYSBwYWdlIGluIHRo ZQorICogeGVuLXBsYXRmb3JtIHBjaSBkZXZpY2UncyBCQVIgbWVtb3J5IHJhbmdlLiBCdXQgcGNp IGluaXQgaXMgZG9uZSB2ZXJ5CisgKiBsYXRlIGFuZCB0aGUgc2hhcmVkX2luZm8gcGFnZSBpcyBh bHJlYWR5IGluIHVzZSB2ZXJ5IGVhcmx5IHRvIHJlYWQKKyAqIHRoZSBwdmNsb2NrLiBTbyBtb3Zp bmcgdGhlIHBmbiBmcm9tIFJBTSB0byBNTUlPIGlzIHJhY3kgYmVjYXVzZSBzb21lCisgKiBjb2Rl IHBhdGhzIG9uIG90aGVyIHZjcHVzIGNvdWxkIGFjY2VzcyB0aGUgcGZuIGR1cmluZyB0aGUgc21h bGwKKyAqIHdpbmRvdyB3aGVuIHRoZSBvbGQgcGZuIGlzIG1vdmVkIHRvIHRoZSBuZXcgcGZuLiBU aGVyZSBpcyBldmVuIGEKKyAqIHNtYWxsIHdpbmRvdyB3ZXJlIHRoZSBvbGQgcGZuIGlzIG5vdCBi YWNrZWQgYnkgYSBtZm4sIGFuZCBkdXJpbmcgdGhhdAorICogdGltZSBhbGwgcmVhZHMgcmV0dXJu IC0xLgorICoKKyAqIEJlY2F1c2UgaXQgaXMgbm90IGtub3duIHVwZnJvbnQgd2hlcmUgdGhlIE1N SU8gcmVnaW9uIGlzIGxvY2F0ZWQgaXQKKyAqIGNhbiBub3QgYmUgdXNlZCByaWdodCBmcm9tIHRo ZSBzdGFydCBpbiB4ZW5faHZtX2luaXRfc2hhcmVkX2luZm8uCisgKgorICogVG8gbWluaW1pc2Ug dHJvdWJsZSB0aGUgbW92ZSBvZiB0aGUgcGZuIGlzIGRvbmUgc2hvcnRseSBiZWZvcmUga2V4ZWMu CisgKiBUaGlzIGRvZXMgbm90IGVsaW1pbmF0ZSB0aGUgcmFjZSBiZWNhdXNlIGFsbCB2Y3B1cyBh cmUgc3RpbGwgb25saW5lCisgKiB3aGVuIHRoZSBzeXNjb3JlX29wcyB3aWxsIGJlIGNhbGxlZC4g QnV0IGhvcGVmdWxseSB0aGVyZSBpcyBubyB3b3JrCisgKiBwZW5kaW5nIGF0IHRoaXMgcG9pbnQg aW4gdGltZS4gQWxzbyB0aGUgc3lzY29yZV9vcCBpcyBydW4gbGFzdCB3aGljaAorICogcmVkdWNl cyB0aGUgcmlzayBmdXJ0aGVyLgorICovCisKK3N0YXRpYyBzdHJ1Y3Qgc2hhcmVkX2luZm8gKnhl bl9odm1fc2hhcmVkX2luZm87CisKK3N0YXRpYyB2b2lkIHhlbl9odm1fY29ubmVjdF9zaGFyZWRf aW5mbyh1bnNpZ25lZCBsb25nIHBmbikKIHsKLQlpbnQgY3B1OwogCXN0cnVjdCB4ZW5fYWRkX3Rv X3BoeXNtYXAgeGF0cDsKLQlzdGF0aWMgc3RydWN0IHNoYXJlZF9pbmZvICpzaGFyZWRfaW5mb19w YWdlID0gMDsKIAotCWlmICghc2hhcmVkX2luZm9fcGFnZSkKLQkJc2hhcmVkX2luZm9fcGFnZSA9 IChzdHJ1Y3Qgc2hhcmVkX2luZm8gKikKLQkJCWV4dGVuZF9icmsoUEFHRV9TSVpFLCBQQUdFX1NJ WkUpOwogCXhhdHAuZG9taWQgPSBET01JRF9TRUxGOwogCXhhdHAuaWR4ID0gMDsKIAl4YXRwLnNw YWNlID0gWEVOTUFQU1BBQ0Vfc2hhcmVkX2luZm87Ci0JeGF0cC5ncGZuID0gX19wYShzaGFyZWRf aW5mb19wYWdlKSA+PiBQQUdFX1NISUZUOworCXhhdHAuZ3BmbiA9IHBmbjsKIAlpZiAoSFlQRVJW SVNPUl9tZW1vcnlfb3AoWEVOTUVNX2FkZF90b19waHlzbWFwLCAmeGF0cCkpCiAJCUJVRygpOwog Ci0JSFlQRVJWSVNPUl9zaGFyZWRfaW5mbyA9IChzdHJ1Y3Qgc2hhcmVkX2luZm8gKilzaGFyZWRf aW5mb19wYWdlOworfQorc3RhdGljIHZvaWQgeGVuX2h2bV9zZXRfc2hhcmVkX2luZm8oc3RydWN0 IHNoYXJlZF9pbmZvICpzaXApCit7CisJaW50IGNwdTsKKworCUhZUEVSVklTT1Jfc2hhcmVkX2lu Zm8gPSBzaXA7CiAKIAkvKiB4ZW5fdmNwdSBpcyBhIHBvaW50ZXIgdG8gdGhlIHZjcHVfaW5mbyBz dHJ1Y3QgaW4gdGhlIHNoYXJlZF9pbmZvCiAJICogcGFnZSwgd2UgdXNlIGl0IGluIHRoZSBldmVu dCBjaGFubmVsIHVwY2FsbCBhbmQgaW4gc29tZSBwdmNsb2NrCiAJICogcmVsYXRlZCBmdW5jdGlv bnMuIFdlIGRvbid0IG5lZWQgdGhlIHZjcHVfaW5mbyBwbGFjZW1lbnQKIAkgKiBvcHRpbWl6YXRp b25zIGJlY2F1c2Ugd2UgZG9uJ3QgdXNlIGFueSBwdl9tbXUgb3IgcHZfaXJxIG9wIG9uCiAJICog SFZNLgotCSAqIFdoZW4geGVuX2h2bV9pbml0X3NoYXJlZF9pbmZvIGlzIHJ1biBhdCBib290IHRp bWUgb25seSB2Y3B1IDAgaXMKLQkgKiBvbmxpbmUgYnV0IHhlbl9odm1faW5pdF9zaGFyZWRfaW5m byBpcyBydW4gYXQgcmVzdW1lIHRpbWUgdG9vIGFuZAorCSAqIFdoZW4geGVuX2h2bV9zZXRfc2hh cmVkX2luZm8gaXMgcnVuIGF0IGJvb3QgdGltZSBvbmx5IHZjcHUgMCBpcworCSAqIG9ubGluZSBi dXQgeGVuX2h2bV9zZXRfc2hhcmVkX2luZm8gaXMgcnVuIGF0IHJlc3VtZSB0aW1lIHRvbyBhbmQK IAkgKiBpbiB0aGF0IGNhc2UgbXVsdGlwbGUgdmNwdXMgbWlnaHQgYmUgb25saW5lLiAqLwogCWZv cl9lYWNoX29ubGluZV9jcHUoY3B1KSB7CiAJCXBlcl9jcHUoeGVuX3ZjcHUsIGNwdSkgPSAmSFlQ RVJWSVNPUl9zaGFyZWRfaW5mby0+dmNwdV9pbmZvW2NwdV07CiAJfQogfQogCi0jaWZkZWYgQ09O RklHX1hFTl9QVkhWTQorLyogUmVjb25uZWN0IHRoZSBzaGFyZWRfaW5mbyBwZm4gdG8gYSBtZm4g Ki8KK3ZvaWQgeGVuX2h2bV9yZXN1bWVfc2hhcmVkX2luZm8odm9pZCkKK3sKKwl4ZW5faHZtX2Nv bm5lY3Rfc2hhcmVkX2luZm8oX19wYSh4ZW5faHZtX3NoYXJlZF9pbmZvKSA+PiBQQUdFX1NISUZU KTsKK30KKworI2lmZGVmIENPTkZJR19LRVhFQworc3RhdGljIHN0cnVjdCBzaGFyZWRfaW5mbyAq eGVuX2h2bV9zaGFyZWRfaW5mb19rZXhlYzsKK3N0YXRpYyB1bnNpZ25lZCBsb25nIHhlbl9odm1f c2hhcmVkX2luZm9fcGZuX2tleGVjOworCisvKiBSZW1lbWJlciBhIHBmbiBpbiBNTUlPIHNwYWNl IGZvciBrZXhlYyByZWJvb3QgKi8KK3ZvaWQgX19kZXZpbml0IHhlbl9odm1fcHJlcGFyZV9rZXhl YyhzdHJ1Y3Qgc2hhcmVkX2luZm8gKnNpcCwgdW5zaWduZWQgbG9uZyBwZm4pCit7CisJeGVuX2h2 bV9zaGFyZWRfaW5mb19rZXhlYyA9IHNpcDsKKwl4ZW5faHZtX3NoYXJlZF9pbmZvX3Bmbl9rZXhl YyA9IHBmbjsKK30KKworc3RhdGljIHZvaWQgeGVuX2h2bV9zeXNjb3JlX3NodXRkb3duKHZvaWQp Cit7CisJc3RydWN0IHhlbl9tZW1vcnlfcmVzZXJ2YXRpb24gcmVzZXJ2YXRpb24gPSB7CisJCS5k b21pZCA9IERPTUlEX1NFTEYsCisJCS5ucl9leHRlbnRzID0gMSwKKwl9OworCXVuc2lnbmVkIGxv bmcgcHJldl9wZm47CisJaW50IHJjOworCisJaWYgKCF4ZW5faHZtX3NoYXJlZF9pbmZvX2tleGVj KQorCQlyZXR1cm47CisKKwlwcmV2X3BmbiA9IF9fcGEoeGVuX2h2bV9zaGFyZWRfaW5mbykgPj4g UEFHRV9TSElGVDsKKwlzZXRfeGVuX2d1ZXN0X2hhbmRsZShyZXNlcnZhdGlvbi5leHRlbnRfc3Rh cnQsICZwcmV2X3Bmbik7CisKKwkvKiBNb3ZlIHBmbiB0byBNTUlPLCBkaXNjb25uZWN0cyBwcmV2 aW91cyBwZm4gZnJvbSBtZm4gKi8KKwl4ZW5faHZtX2Nvbm5lY3Rfc2hhcmVkX2luZm8oeGVuX2h2 bV9zaGFyZWRfaW5mb19wZm5fa2V4ZWMpOworCisJLyogVXBkYXRlIHBvaW50ZXJzLCBmb2xsb3dp bmcgaHlwZXJjYWxsIGlzIGFsc28gYSBtZW1vcnkgYmFycmllciAqLworCXhlbl9odm1fc2V0X3No YXJlZF9pbmZvKHhlbl9odm1fc2hhcmVkX2luZm9fa2V4ZWMpOworCisJLyogQWxsb2NhdGUgbmV3 IG1mbiBmb3IgcHJldmlvdXMgcGZuICovCisJcmMgPSBIWVBFUlZJU09SX21lbW9yeV9vcChYRU5N RU1fcG9wdWxhdGVfcGh5c21hcCwgJnJlc2VydmF0aW9uKTsKKworCS8qIE1ha2Ugc3VyZSB0aGUg cHJldmlvdXMgcGZuIGlzIHJlYWxseSBjb25uZWN0ZWQgdG8gYSAobmV3KSBtZm4gKi8KKwlCVUdf T04ocmMgIT0gMSk7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc3lzY29yZV9vcHMgeGVuX2h2bV9zeXNj b3JlX29wcyA9IHsKKwkuc2h1dGRvd24gPSB4ZW5faHZtX3N5c2NvcmVfc2h1dGRvd24sCit9Owor I2VuZGlmCisKKy8qIFVzZSBhIHBmbiBpbiBSQU0sIG1heSBtb3ZlIHRvIE1NSU8gYmVmb3JlIGtl eGVjLiAqLworc3RhdGljIHZvaWQgX19pbml0IHhlbl9odm1faW5pdF9zaGFyZWRfaW5mbyh2b2lk KQoreworCS8qIFJlbWVtYmVyIHBvaW50ZXIgZm9yIHJlc3VtZSAqLworCXhlbl9odm1fc2hhcmVk X2luZm8gPSBleHRlbmRfYnJrKFBBR0VfU0laRSwgUEFHRV9TSVpFKTsKKwl4ZW5faHZtX2Nvbm5l Y3Rfc2hhcmVkX2luZm8oX19wYSh4ZW5faHZtX3NoYXJlZF9pbmZvKSA+PiBQQUdFX1NISUZUKTsK Kwl4ZW5faHZtX3NldF9zaGFyZWRfaW5mbyh4ZW5faHZtX3NoYXJlZF9pbmZvKTsKK30KKwogc3Rh dGljIHZvaWQgX19pbml0IGluaXRfaHZtX3B2X2luZm8odm9pZCkKIHsKIAlpbnQgbWFqb3IsIG1p bm9yOwpAQCAtMTUyMSw2ICsxNjEwLDkgQEAgc3RhdGljIHZvaWQgX19pbml0IHhlbl9odm1fZ3Vl c3RfaW5pdCh2b2lkKQogCWluaXRfaHZtX3B2X2luZm8oKTsKIAogCXhlbl9odm1faW5pdF9zaGFy ZWRfaW5mbygpOworI2lmZGVmIENPTkZJR19LRVhFQworCXJlZ2lzdGVyX3N5c2NvcmVfb3BzKCZ4 ZW5faHZtX3N5c2NvcmVfb3BzKTsKKyNlbmRpZgogCiAJaWYgKHhlbl9mZWF0dXJlKFhFTkZFQVRf aHZtX2NhbGxiYWNrX3ZlY3RvcikpCiAJCXhlbl9oYXZlX3ZlY3Rvcl9jYWxsYmFjayA9IDE7CmRp ZmYgLS1naXQgYS9hcmNoL3g4Ni94ZW4vc3VzcGVuZC5jIGIvYXJjaC94ODYveGVuL3N1c3BlbmQu YwppbmRleCA0NTMyOWM4Li5hZThhMDBjIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni94ZW4vc3VzcGVu ZC5jCisrKyBiL2FyY2gveDg2L3hlbi9zdXNwZW5kLmMKQEAgLTMwLDcgKzMwLDcgQEAgdm9pZCB4 ZW5fYXJjaF9odm1fcG9zdF9zdXNwZW5kKGludCBzdXNwZW5kX2NhbmNlbGxlZCkKIHsKICNpZmRl ZiBDT05GSUdfWEVOX1BWSFZNCiAJaW50IGNwdTsKLQl4ZW5faHZtX2luaXRfc2hhcmVkX2luZm8o KTsKKwl4ZW5faHZtX3Jlc3VtZV9zaGFyZWRfaW5mbygpOwogCXhlbl9jYWxsYmFja192ZWN0b3Io KTsKIAl4ZW5fdW5wbHVnX2VtdWxhdGVkX2RldmljZXMoKTsKIAlpZiAoeGVuX2ZlYXR1cmUoWEVO RkVBVF9odm1fc2FmZV9wdmNsb2NrKSkgewpkaWZmIC0tZ2l0IGEvYXJjaC94ODYveGVuL3hlbi1v cHMuaCBiL2FyY2gveDg2L3hlbi94ZW4tb3BzLmgKaW5kZXggMjAyZDRjMS4uMWU0MzI5ZSAxMDA2 NDQKLS0tIGEvYXJjaC94ODYveGVuL3hlbi1vcHMuaAorKysgYi9hcmNoL3g4Ni94ZW4veGVuLW9w cy5oCkBAIC00MSw3ICs0MSw3IEBAIHZvaWQgeGVuX2VuYWJsZV9zeXNjYWxsKHZvaWQpOwogdm9p ZCB4ZW5fdmNwdV9yZXN0b3JlKHZvaWQpOwogCiB2b2lkIHhlbl9jYWxsYmFja192ZWN0b3Iodm9p ZCk7Ci12b2lkIHhlbl9odm1faW5pdF9zaGFyZWRfaW5mbyh2b2lkKTsKK3ZvaWQgeGVuX2h2bV9y ZXN1bWVfc2hhcmVkX2luZm8odm9pZCk7CiB2b2lkIHhlbl91bnBsdWdfZW11bGF0ZWRfZGV2aWNl cyh2b2lkKTsKIAogdm9pZCBfX2luaXQgeGVuX2J1aWxkX2R5bmFtaWNfcGh5c190b19tYWNoaW5l KHZvaWQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vcGxhdGZvcm0tcGNpLmMgYi9kcml2ZXJz L3hlbi9wbGF0Zm9ybS1wY2kuYwppbmRleCA5N2NhMzU5Li5kNGM1MGQ2IDEwMDY0NAotLS0gYS9k cml2ZXJzL3hlbi9wbGF0Zm9ybS1wY2kuYworKysgYi9kcml2ZXJzL3hlbi9wbGF0Zm9ybS1wY2ku YwpAQCAtMTAxLDYgKzEwMSwxOSBAQCBzdGF0aWMgaW50IHBsYXRmb3JtX3BjaV9yZXN1bWUoc3Ry dWN0IHBjaV9kZXYgKnBkZXYpCiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyB2b2lkIF9fZGV2aW5p dCBwcmVwYXJlX3NoYXJlZF9pbmZvKHZvaWQpCit7CisjaWZkZWYgQ09ORklHX0tFWEVDCisJdW5z aWduZWQgbG9uZyBhZGRyOworCXN0cnVjdCBzaGFyZWRfaW5mbyAqaHZtX3NoYXJlZF9pbmZvOwor CisJYWRkciA9IGFsbG9jX3hlbl9tbWlvKFBBR0VfU0laRSk7CisJaHZtX3NoYXJlZF9pbmZvID0g aW9yZW1hcChhZGRyLCBQQUdFX1NJWkUpOworCW1lbXNldChodm1fc2hhcmVkX2luZm8sIDAsIFBB R0VfU0laRSk7CisJeGVuX2h2bV9wcmVwYXJlX2tleGVjKGh2bV9zaGFyZWRfaW5mbywgYWRkciA+ PiBQQUdFX1NISUZUKTsKKyNlbmRpZgorfQorCiBzdGF0aWMgaW50IF9fZGV2aW5pdCBwbGF0Zm9y bV9wY2lfaW5pdChzdHJ1Y3QgcGNpX2RldiAqcGRldiwKIAkJCQkgICAgICAgY29uc3Qgc3RydWN0 IHBjaV9kZXZpY2VfaWQgKmVudCkKIHsKQEAgLTEzOCw2ICsxNTEsOCBAQCBzdGF0aWMgaW50IF9f ZGV2aW5pdCBwbGF0Zm9ybV9wY2lfaW5pdChzdHJ1Y3QgcGNpX2RldiAqcGRldiwKIAlwbGF0Zm9y bV9tbWlvID0gbW1pb19hZGRyOwogCXBsYXRmb3JtX21taW9sZW4gPSBtbWlvX2xlbjsKIAorCXBy ZXBhcmVfc2hhcmVkX2luZm8oKTsKKwogCWlmICgheGVuX2hhdmVfdmVjdG9yX2NhbGxiYWNrKSB7 CiAJCXJldCA9IHhlbl9hbGxvY2F0ZV9pcnEocGRldik7CiAJCWlmIChyZXQpIHsKZGlmZiAtLWdp dCBhL2luY2x1ZGUveGVuL2V2ZW50cy5oIGIvaW5jbHVkZS94ZW4vZXZlbnRzLmgKaW5kZXggMDQz OTliMi4uOWM2NDFkZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS94ZW4vZXZlbnRzLmgKKysrIGIvaW5j bHVkZS94ZW4vZXZlbnRzLmgKQEAgLTU4LDYgKzU4LDggQEAgdm9pZCBub3RpZnlfcmVtb3RlX3Zp YV9pcnEoaW50IGlycSk7CiAKIHZvaWQgeGVuX2lycV9yZXN1bWUodm9pZCk7CiAKK3ZvaWQgeGVu X2h2bV9wcmVwYXJlX2tleGVjKHN0cnVjdCBzaGFyZWRfaW5mbyAqc2lwLCB1bnNpZ25lZCBsb25n IHBmbik7CisKIC8qIENsZWFyIGFuIGlycSdzIHBlbmRpbmcgc3RhdGUsIGluIHByZXBhcmF0aW9u IGZvciBwb2xsaW5nIG9uIGl0ICovCiB2b2lkIHhlbl9jbGVhcl9pcnFfcGVuZGluZyhpbnQgaXJx KTsKIHZvaWQgeGVuX3NldF9pcnFfcGVuZGluZyhpbnQgaXJxKTsKLS0gCjEuNy4xMC40CgoKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18Ka2V4ZWMgbWFpbGlu ZyBsaXN0CmtleGVjQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5v cmcvbWFpbG1hbi9saXN0aW5mby9rZXhlYwo=