From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1762048AbdAEIxT (ORCPT ); Thu, 5 Jan 2017 03:53:19 -0500 Received: from mail-wj0-f193.google.com ([209.85.210.193]:33932 "EHLO mail-wj0-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1761270AbdAEIw5 (ORCPT ); Thu, 5 Jan 2017 03:52:57 -0500 Date: Thu, 5 Jan 2017 09:52:53 +0100 From: Ingo Molnar To: Boris Ostrovsky Cc: tglx@linutronix.de, mingo@redhat.com, hpa@zytor.com, x86@kernel.org, linux-kernel@vger.kernel.org, xen-devel@lists.xenproject.org, matt@codeblueprint.co.uk Subject: Re: [PATCH] x86/head: Refactor 32-bit pgtable setup Message-ID: <20170105085252.GA15715@gmail.com> References: <1481215471-9639-1-git-send-email-boris.ostrovsky@oracle.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1481215471-9639-1-git-send-email-boris.ostrovsky@oracle.com> User-Agent: Mutt/1.5.24 (2015-08-30) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org * Boris Ostrovsky wrote: > The new Xen PVH entry point requires page tables to be setup by the > kernel since it is entered with paging disabled. > > Pull the common code out of head_32.S so that mk_early_pgtbl_32 can be > invoked from both the new Xen entry point and the existing startup_32 > code. > > Convert resulting common code to C. > > Signed-off-by: Boris Ostrovsky > --- > This is replacement for https://lkml.org/lkml/2016/10/14/434, with > assembly code re-written in C as requested by Ingo. > > > arch/x86/include/asm/pgtable_32.h | 32 ++++++++++ > arch/x86/kernel/head32.c | 62 +++++++++++++++++++ > arch/x86/kernel/head_32.S | 122 +++----------------------------------- > 3 files changed, 101 insertions(+), 115 deletions(-) Yeah, so (belatedly) I tried to merge this to latest upstream, via the commit below (note the slight edits to the changelog) - but 32-bit defconfig fails to build: arch/x86/kernel/head_32.S:615: Error: can't resolve `init_thread_union' {*UND* section} - `SIZEOF_PTREGS' {*UND* section} Thanks, Ingo =======================> >>From 071878c634fda7d9be3f015f05a89f5468e7e2e4 Mon Sep 17 00:00:00 2001 From: Boris Ostrovsky Date: Thu, 8 Dec 2016 11:44:31 -0500 Subject: [PATCH] x86/boot/32: Convert the 32-bit pgtable setup code from assembly to C The new Xen PVH entry point requires page tables to be set up by the kernel since it is entered with paging disabled. Pull the common code out of head_32.S so that mk_early_pgtbl_32() can be invoked from both the new Xen entry point and the existing startup_32() code. Convert resulting common code to C. Signed-off-by: Boris Ostrovsky Cc: Andy Lutomirski Cc: Borislav Petkov Cc: Brian Gerst Cc: Denys Vlasenko Cc: H. Peter Anvin Cc: Josh Poimboeuf Cc: Linus Torvalds Cc: Peter Zijlstra Cc: Thomas Gleixner Cc: matt@codeblueprint.co.uk Cc: xen-devel@lists.xenproject.org Link: http://lkml.kernel.org/r/1481215471-9639-1-git-send-email-boris.ostrovsky@oracle.com Signed-off-by: Ingo Molnar --- arch/x86/include/asm/pgtable_32.h | 32 ++++++++++ arch/x86/kernel/head32.c | 62 +++++++++++++++++++ arch/x86/kernel/head_32.S | 122 +++----------------------------------- 3 files changed, 101 insertions(+), 115 deletions(-) diff --git a/arch/x86/include/asm/pgtable_32.h b/arch/x86/include/asm/pgtable_32.h index b6c0b404898a..fbc73360aea0 100644 --- a/arch/x86/include/asm/pgtable_32.h +++ b/arch/x86/include/asm/pgtable_32.h @@ -27,6 +27,7 @@ struct vm_area_struct; extern pgd_t swapper_pg_dir[1024]; extern pgd_t initial_page_table[1024]; +extern pmd_t initial_pg_pmd[]; static inline void pgtable_cache_init(void) { } static inline void check_pgt_cache(void) { } @@ -75,4 +76,35 @@ do { \ #define kern_addr_valid(kaddr) (0) #endif +/* + * This is how much memory in addition to the memory covered up to + * and including _end we need mapped initially. + * We need: + * (KERNEL_IMAGE_SIZE/4096) / 1024 pages (worst case, non PAE) + * (KERNEL_IMAGE_SIZE/4096) / 512 + 4 pages (worst case for PAE) + * + * Modulo rounding, each megabyte assigned here requires a kilobyte of + * memory, which is currently unreclaimed. + * + * This should be a multiple of a page. + * + * KERNEL_IMAGE_SIZE should be greater than pa(_end) + * and small than max_low_pfn, otherwise will waste some page table entries + */ +#if PTRS_PER_PMD > 1 +#define PAGE_TABLE_SIZE(pages) (((pages) / PTRS_PER_PMD) + PTRS_PER_PGD) +#else +#define PAGE_TABLE_SIZE(pages) ((pages) / PTRS_PER_PGD) +#endif + +/* + * Number of possible pages in the lowmem region. + * + * We shift 2 by 31 instead of 1 by 32 to the left in order to avoid a + * gas warning about overflowing shift count when gas has been compiled + * with only a host target support using a 32-bit type for internal + * representation. + */ +#define LOWMEM_PAGES ((((2<<31) - __PAGE_OFFSET) >> PAGE_SHIFT)) + #endif /* _ASM_X86_PGTABLE_32_H */ diff --git a/arch/x86/kernel/head32.c b/arch/x86/kernel/head32.c index f16c55bfc090..e5fb436a6548 100644 --- a/arch/x86/kernel/head32.c +++ b/arch/x86/kernel/head32.c @@ -49,3 +49,65 @@ asmlinkage __visible void __init i386_start_kernel(void) start_kernel(); } + +/* + * Initialize page tables. This creates a PDE and a set of page + * tables, which are located immediately beyond __brk_base. The variable + * _brk_end is set up to point to the first "safe" location. + * Mappings are created both at virtual address 0 (identity mapping) + * and PAGE_OFFSET for up to _end. + * + * In PAE mode initial_page_table is statically defined to contain + * enough entries to cover the VMSPLIT option (that is the top 1, 2 or 3 + * entries). The identity mapping is handled by pointing two PGD entries + * to the first kernel PMD. Note the upper half of each PMD or PTE are + * always zero at this stage. + */ +void __init mk_early_pgtbl_32(void) +{ +#ifdef __pa +#undef __pa +#endif +#define __pa(x) ((unsigned long)(x) - PAGE_OFFSET) + pte_t pte, *ptep; + int i; + unsigned long *ptr; + /* Enough space to fit pagetables for the low memory linear map */ + const unsigned long limit = __pa(_end) + + (PAGE_TABLE_SIZE(LOWMEM_PAGES) << PAGE_SHIFT); +#ifdef CONFIG_X86_PAE + pmd_t pl2, *pl2p = (pmd_t *)__pa(initial_pg_pmd); +#define SET_PL2(pl2, val) { (pl2).pmd = (val); } +#else + pgd_t pl2, *pl2p = (pgd_t *)__pa(initial_page_table); +#define SET_PL2(pl2, val) { (pl2).pgd = (val); } +#endif + + ptep = (pte_t *)__pa(__brk_base); + pte.pte = PTE_IDENT_ATTR; + + while ((pte.pte & PTE_PFN_MASK) < limit) { + + SET_PL2(pl2, (unsigned long)ptep | PDE_IDENT_ATTR); + *pl2p = pl2; +#ifndef CONFIG_X86_PAE + /* Kernel PDE entry */ + *(pl2p + ((PAGE_OFFSET >> PGDIR_SHIFT))) = pl2; +#endif + for (i = 0; i < PTRS_PER_PTE; i++) { + *ptep = pte; + pte.pte += PAGE_SIZE; + ptep++; + } + + pl2p++; + } + + ptr = (unsigned long *)__pa(&max_pfn_mapped); + /* Can't use pte_pfn() since it's a call with CONFIG_PARAVIRT */ + *ptr = (pte.pte & PTE_PFN_MASK) >> PAGE_SHIFT; + + ptr = (unsigned long *)__pa(&_brk_end); + *ptr = (unsigned long)ptep + PAGE_OFFSET; +} + diff --git a/arch/x86/kernel/head_32.S b/arch/x86/kernel/head_32.S index 4e8577d03372..eca1c93c38e8 100644 --- a/arch/x86/kernel/head_32.S +++ b/arch/x86/kernel/head_32.S @@ -24,6 +24,7 @@ #include #include #include +#include /* Physical address */ #define pa(X) ((X) - __PAGE_OFFSET) @@ -42,43 +43,8 @@ #define X86_VENDOR_ID new_cpu_data+CPUINFO_x86_vendor_id /* - * This is how much memory in addition to the memory covered up to - * and including _end we need mapped initially. - * We need: - * (KERNEL_IMAGE_SIZE/4096) / 1024 pages (worst case, non PAE) - * (KERNEL_IMAGE_SIZE/4096) / 512 + 4 pages (worst case for PAE) - * - * Modulo rounding, each megabyte assigned here requires a kilobyte of - * memory, which is currently unreclaimed. - * - * This should be a multiple of a page. - * - * KERNEL_IMAGE_SIZE should be greater than pa(_end) - * and small than max_low_pfn, otherwise will waste some page table entries - */ - -#if PTRS_PER_PMD > 1 -#define PAGE_TABLE_SIZE(pages) (((pages) / PTRS_PER_PMD) + PTRS_PER_PGD) -#else -#define PAGE_TABLE_SIZE(pages) ((pages) / PTRS_PER_PGD) -#endif - #define SIZEOF_PTREGS 17*4 -/* - * Number of possible pages in the lowmem region. - * - * We shift 2 by 31 instead of 1 by 32 to the left in order to avoid a - * gas warning about overflowing shift count when gas has been compiled - * with only a host target support using a 32-bit type for internal - * representation. - */ -LOWMEM_PAGES = (((2<<31) - __PAGE_OFFSET) >> PAGE_SHIFT) - -/* Enough space to fit pagetables for the low memory linear map */ -MAPPING_BEYOND_END = PAGE_TABLE_SIZE(LOWMEM_PAGES) << PAGE_SHIFT - -/* * Worst-case size of the kernel mapping we need to make: * a relocatable kernel can live anywhere in lowmem, so we need to be able * to map all of lowmem. @@ -160,90 +126,15 @@ ENTRY(startup_32) call load_ucode_bsp #endif -/* - * Initialize page tables. This creates a PDE and a set of page - * tables, which are located immediately beyond __brk_base. The variable - * _brk_end is set up to point to the first "safe" location. - * Mappings are created both at virtual address 0 (identity mapping) - * and PAGE_OFFSET for up to _end. - */ -#ifdef CONFIG_X86_PAE - - /* - * In PAE mode initial_page_table is statically defined to contain - * enough entries to cover the VMSPLIT option (that is the top 1, 2 or 3 - * entries). The identity mapping is handled by pointing two PGD entries - * to the first kernel PMD. - * - * Note the upper half of each PMD or PTE are always zero at this stage. - */ - -#define KPMDS (((-__PAGE_OFFSET) >> 30) & 3) /* Number of kernel PMDs */ - - xorl %ebx,%ebx /* %ebx is kept at zero */ - - movl $pa(__brk_base), %edi - movl $pa(initial_pg_pmd), %edx - movl $PTE_IDENT_ATTR, %eax -10: - leal PDE_IDENT_ATTR(%edi),%ecx /* Create PMD entry */ - movl %ecx,(%edx) /* Store PMD entry */ - /* Upper half already zero */ - addl $8,%edx - movl $512,%ecx -11: - stosl - xchgl %eax,%ebx - stosl - xchgl %eax,%ebx - addl $0x1000,%eax - loop 11b - - /* - * End condition: we must map up to the end + MAPPING_BEYOND_END. - */ - movl $pa(_end) + MAPPING_BEYOND_END + PTE_IDENT_ATTR, %ebp - cmpl %ebp,%eax - jb 10b -1: - addl $__PAGE_OFFSET, %edi - movl %edi, pa(_brk_end) - shrl $12, %eax - movl %eax, pa(max_pfn_mapped) + /* Create early pagetables. */ + call mk_early_pgtbl_32 /* Do early initialization of the fixmap area */ movl $pa(initial_pg_fixmap)+PDE_IDENT_ATTR,%eax +#ifdef CONFIG_X86_PAE +#define KPMDS (((-__PAGE_OFFSET) >> 30) & 3) /* Number of kernel PMDs */ movl %eax,pa(initial_pg_pmd+0x1000*KPMDS-8) -#else /* Not PAE */ - -page_pde_offset = (__PAGE_OFFSET >> 20); - - movl $pa(__brk_base), %edi - movl $pa(initial_page_table), %edx - movl $PTE_IDENT_ATTR, %eax -10: - leal PDE_IDENT_ATTR(%edi),%ecx /* Create PDE entry */ - movl %ecx,(%edx) /* Store identity PDE entry */ - movl %ecx,page_pde_offset(%edx) /* Store kernel PDE entry */ - addl $4,%edx - movl $1024, %ecx -11: - stosl - addl $0x1000,%eax - loop 11b - /* - * End condition: we must map up to the end + MAPPING_BEYOND_END. - */ - movl $pa(_end) + MAPPING_BEYOND_END + PTE_IDENT_ATTR, %ebp - cmpl %ebp,%eax - jb 10b - addl $__PAGE_OFFSET, %edi - movl %edi, pa(_brk_end) - shrl $12, %eax - movl %eax, pa(max_pfn_mapped) - - /* Do early initialization of the fixmap area */ - movl $pa(initial_pg_fixmap)+PDE_IDENT_ATTR,%eax +#else movl %eax,pa(initial_page_table+0xffc) #endif @@ -666,6 +557,7 @@ ENTRY(setup_once_ref) __PAGE_ALIGNED_BSS .align PAGE_SIZE #ifdef CONFIG_X86_PAE +.globl initial_pg_pmd initial_pg_pmd: .fill 1024*KPMDS,4,0 #else From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ingo Molnar Subject: Re: [PATCH] x86/head: Refactor 32-bit pgtable setup Date: Thu, 5 Jan 2017 09:52:53 +0100 Message-ID: <20170105085252.GA15715@gmail.com> References: <1481215471-9639-1-git-send-email-boris.ostrovsky@oracle.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail6.bemta6.messagelabs.com ([193.109.254.103]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1cP3n8-0005WZ-1M for xen-devel@lists.xenproject.org; Thu, 05 Jan 2017 08:52:58 +0000 Received: by mail-wj0-f193.google.com with SMTP id qs7so40695071wjc.1 for ; Thu, 05 Jan 2017 00:52:56 -0800 (PST) Content-Disposition: inline In-Reply-To: <1481215471-9639-1-git-send-email-boris.ostrovsky@oracle.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: Boris Ostrovsky Cc: matt@codeblueprint.co.uk, x86@kernel.org, linux-kernel@vger.kernel.org, mingo@redhat.com, hpa@zytor.com, xen-devel@lists.xenproject.org, tglx@linutronix.de List-Id: xen-devel@lists.xenproject.org CiogQm9yaXMgT3N0cm92c2t5IDxib3Jpcy5vc3Ryb3Zza3lAb3JhY2xlLmNvbT4gd3JvdGU6Cgo+ IFRoZSBuZXcgWGVuIFBWSCBlbnRyeSBwb2ludCByZXF1aXJlcyBwYWdlIHRhYmxlcyB0byBiZSBz ZXR1cCBieSB0aGUKPiBrZXJuZWwgc2luY2UgaXQgaXMgZW50ZXJlZCB3aXRoIHBhZ2luZyBkaXNh YmxlZC4KPiAKPiBQdWxsIHRoZSBjb21tb24gY29kZSBvdXQgb2YgaGVhZF8zMi5TIHNvIHRoYXQg bWtfZWFybHlfcGd0YmxfMzIgY2FuIGJlCj4gaW52b2tlZCBmcm9tIGJvdGggdGhlIG5ldyBYZW4g ZW50cnkgcG9pbnQgYW5kIHRoZSBleGlzdGluZyBzdGFydHVwXzMyCj4gY29kZS4KPiAKPiBDb252 ZXJ0IHJlc3VsdGluZyBjb21tb24gY29kZSB0byBDLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEJvcmlz IE9zdHJvdnNreSA8Ym9yaXMub3N0cm92c2t5QG9yYWNsZS5jb20+Cj4gLS0tCj4gVGhpcyBpcyBy ZXBsYWNlbWVudCBmb3IgaHR0cHM6Ly9sa21sLm9yZy9sa21sLzIwMTYvMTAvMTQvNDM0LCB3aXRo Cj4gYXNzZW1ibHkgY29kZSByZS13cml0dGVuIGluIEMgYXMgcmVxdWVzdGVkIGJ5IEluZ28uCj4g Cj4gCj4gIGFyY2gveDg2L2luY2x1ZGUvYXNtL3BndGFibGVfMzIuaCB8ICAzMiArKysrKysrKysr Cj4gIGFyY2gveDg2L2tlcm5lbC9oZWFkMzIuYyAgICAgICAgICB8ICA2MiArKysrKysrKysrKysr KysrKysrCj4gIGFyY2gveDg2L2tlcm5lbC9oZWFkXzMyLlMgICAgICAgICB8IDEyMiArKystLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ICAzIGZpbGVzIGNoYW5nZWQsIDEwMSBp bnNlcnRpb25zKCspLCAxMTUgZGVsZXRpb25zKC0pCgpZZWFoLCBzbyAoYmVsYXRlZGx5KSBJIHRy aWVkIHRvIG1lcmdlIHRoaXMgdG8gbGF0ZXN0IHVwc3RyZWFtLCB2aWEgdGhlIGNvbW1pdCAKYmVs b3cgKG5vdGUgdGhlIHNsaWdodCBlZGl0cyB0byB0aGUgY2hhbmdlbG9nKSAtIGJ1dCAzMi1iaXQg ZGVmY29uZmlnIGZhaWxzIHRvIApidWlsZDoKCiAgYXJjaC94ODYva2VybmVsL2hlYWRfMzIuUzo2 MTU6IEVycm9yOiBjYW4ndCByZXNvbHZlIGBpbml0X3RocmVhZF91bmlvbicgeypVTkQqIHNlY3Rp b259IC0gYFNJWkVPRl9QVFJFR1MnIHsqVU5EKiBzZWN0aW9ufQoKVGhhbmtzLAoKCUluZ28KCj09 PT09PT09PT09PT09PT09PT09PT09PgpGcm9tIDA3MTg3OGM2MzRmZGE3ZDliZTNmMDE1ZjA1YTg5 ZjU0NjhlN2UyZTQgTW9uIFNlcCAxNyAwMDowMDowMCAyMDAxCkZyb206IEJvcmlzIE9zdHJvdnNr eSA8Ym9yaXMub3N0cm92c2t5QG9yYWNsZS5jb20+CkRhdGU6IFRodSwgOCBEZWMgMjAxNiAxMTo0 NDozMSAtMDUwMApTdWJqZWN0OiBbUEFUQ0hdIHg4Ni9ib290LzMyOiBDb252ZXJ0IHRoZSAzMi1i aXQgcGd0YWJsZSBzZXR1cCBjb2RlIGZyb20gYXNzZW1ibHkgdG8gQwoKVGhlIG5ldyBYZW4gUFZI IGVudHJ5IHBvaW50IHJlcXVpcmVzIHBhZ2UgdGFibGVzIHRvIGJlIHNldCB1cCBieSB0aGUKa2Vy bmVsIHNpbmNlIGl0IGlzIGVudGVyZWQgd2l0aCBwYWdpbmcgZGlzYWJsZWQuCgpQdWxsIHRoZSBj b21tb24gY29kZSBvdXQgb2YgaGVhZF8zMi5TIHNvIHRoYXQgbWtfZWFybHlfcGd0YmxfMzIoKSBj YW4gYmUKaW52b2tlZCBmcm9tIGJvdGggdGhlIG5ldyBYZW4gZW50cnkgcG9pbnQgYW5kIHRoZSBl eGlzdGluZyBzdGFydHVwXzMyKCkKY29kZS4KCkNvbnZlcnQgcmVzdWx0aW5nIGNvbW1vbiBjb2Rl IHRvIEMuCgpTaWduZWQtb2ZmLWJ5OiBCb3JpcyBPc3Ryb3Zza3kgPGJvcmlzLm9zdHJvdnNreUBv cmFjbGUuY29tPgpDYzogQW5keSBMdXRvbWlyc2tpIDxsdXRvQGtlcm5lbC5vcmc+CkNjOiBCb3Jp c2xhdiBQZXRrb3YgPGJwQGFsaWVuOC5kZT4KQ2M6IEJyaWFuIEdlcnN0IDxicmdlcnN0QGdtYWls LmNvbT4KQ2M6IERlbnlzIFZsYXNlbmtvIDxkdmxhc2Vua0ByZWRoYXQuY29tPgpDYzogSC4gUGV0 ZXIgQW52aW4gPGhwYUB6eXRvci5jb20+CkNjOiBKb3NoIFBvaW1ib2V1ZiA8anBvaW1ib2VAcmVk aGF0LmNvbT4KQ2M6IExpbnVzIFRvcnZhbGRzIDx0b3J2YWxkc0BsaW51eC1mb3VuZGF0aW9uLm9y Zz4KQ2M6IFBldGVyIFppamxzdHJhIDxwZXRlcnpAaW5mcmFkZWFkLm9yZz4KQ2M6IFRob21hcyBH bGVpeG5lciA8dGdseEBsaW51dHJvbml4LmRlPgpDYzogbWF0dEBjb2RlYmx1ZXByaW50LmNvLnVr CkNjOiB4ZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKTGluazogaHR0cDovL2xrbWwua2Vy bmVsLm9yZy9yLzE0ODEyMTU0NzEtOTYzOS0xLWdpdC1zZW5kLWVtYWlsLWJvcmlzLm9zdHJvdnNr eUBvcmFjbGUuY29tClNpZ25lZC1vZmYtYnk6IEluZ28gTW9sbmFyIDxtaW5nb0BrZXJuZWwub3Jn PgotLS0KIGFyY2gveDg2L2luY2x1ZGUvYXNtL3BndGFibGVfMzIuaCB8ICAzMiArKysrKysrKysr CiBhcmNoL3g4Ni9rZXJuZWwvaGVhZDMyLmMgICAgICAgICAgfCAgNjIgKysrKysrKysrKysrKysr KysrKwogYXJjaC94ODYva2VybmVsL2hlYWRfMzIuUyAgICAgICAgIHwgMTIyICsrKy0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAzIGZpbGVzIGNoYW5nZWQsIDEwMSBpbnNlcnRp b25zKCspLCAxMTUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9h c20vcGd0YWJsZV8zMi5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vcGd0YWJsZV8zMi5oCmluZGV4 IGI2YzBiNDA0ODk4YS4uZmJjNzMzNjBhZWEwIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRl L2FzbS9wZ3RhYmxlXzMyLmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vcGd0YWJsZV8zMi5o CkBAIC0yNyw2ICsyNyw3IEBAIHN0cnVjdCB2bV9hcmVhX3N0cnVjdDsKIAogZXh0ZXJuIHBnZF90 IHN3YXBwZXJfcGdfZGlyWzEwMjRdOwogZXh0ZXJuIHBnZF90IGluaXRpYWxfcGFnZV90YWJsZVsx MDI0XTsKK2V4dGVybiBwbWRfdCBpbml0aWFsX3BnX3BtZFtdOwogCiBzdGF0aWMgaW5saW5lIHZv aWQgcGd0YWJsZV9jYWNoZV9pbml0KHZvaWQpIHsgfQogc3RhdGljIGlubGluZSB2b2lkIGNoZWNr X3BndF9jYWNoZSh2b2lkKSB7IH0KQEAgLTc1LDQgKzc2LDM1IEBAIGRvIHsJCQkJCQlcCiAjZGVm aW5lIGtlcm5fYWRkcl92YWxpZChrYWRkcikJKDApCiAjZW5kaWYKIAorLyoKKyAqIFRoaXMgaXMg aG93IG11Y2ggbWVtb3J5IGluIGFkZGl0aW9uIHRvIHRoZSBtZW1vcnkgY292ZXJlZCB1cCB0bwor ICogYW5kIGluY2x1ZGluZyBfZW5kIHdlIG5lZWQgbWFwcGVkIGluaXRpYWxseS4KKyAqIFdlIG5l ZWQ6CisgKiAgICAgKEtFUk5FTF9JTUFHRV9TSVpFLzQwOTYpIC8gMTAyNCBwYWdlcyAod29yc3Qg Y2FzZSwgbm9uIFBBRSkKKyAqICAgICAoS0VSTkVMX0lNQUdFX1NJWkUvNDA5NikgLyA1MTIgKyA0 IHBhZ2VzICh3b3JzdCBjYXNlIGZvciBQQUUpCisgKgorICogTW9kdWxvIHJvdW5kaW5nLCBlYWNo IG1lZ2FieXRlIGFzc2lnbmVkIGhlcmUgcmVxdWlyZXMgYSBraWxvYnl0ZSBvZgorICogbWVtb3J5 LCB3aGljaCBpcyBjdXJyZW50bHkgdW5yZWNsYWltZWQuCisgKgorICogVGhpcyBzaG91bGQgYmUg YSBtdWx0aXBsZSBvZiBhIHBhZ2UuCisgKgorICogS0VSTkVMX0lNQUdFX1NJWkUgc2hvdWxkIGJl IGdyZWF0ZXIgdGhhbiBwYShfZW5kKQorICogYW5kIHNtYWxsIHRoYW4gbWF4X2xvd19wZm4sIG90 aGVyd2lzZSB3aWxsIHdhc3RlIHNvbWUgcGFnZSB0YWJsZSBlbnRyaWVzCisgKi8KKyNpZiBQVFJT X1BFUl9QTUQgPiAxCisjZGVmaW5lIFBBR0VfVEFCTEVfU0laRShwYWdlcykgKCgocGFnZXMpIC8g UFRSU19QRVJfUE1EKSArIFBUUlNfUEVSX1BHRCkKKyNlbHNlCisjZGVmaW5lIFBBR0VfVEFCTEVf U0laRShwYWdlcykgKChwYWdlcykgLyBQVFJTX1BFUl9QR0QpCisjZW5kaWYKKworLyoKKyAqIE51 bWJlciBvZiBwb3NzaWJsZSBwYWdlcyBpbiB0aGUgbG93bWVtIHJlZ2lvbi4KKyAqCisgKiBXZSBz aGlmdCAyIGJ5IDMxIGluc3RlYWQgb2YgMSBieSAzMiB0byB0aGUgbGVmdCBpbiBvcmRlciB0byBh dm9pZCBhCisgKiBnYXMgd2FybmluZyBhYm91dCBvdmVyZmxvd2luZyBzaGlmdCBjb3VudCB3aGVu IGdhcyBoYXMgYmVlbiBjb21waWxlZAorICogd2l0aCBvbmx5IGEgaG9zdCB0YXJnZXQgc3VwcG9y dCB1c2luZyBhIDMyLWJpdCB0eXBlIGZvciBpbnRlcm5hbAorICogcmVwcmVzZW50YXRpb24uCisg Ki8KKyNkZWZpbmUgTE9XTUVNX1BBR0VTICgoKCgyPDwzMSkgLSBfX1BBR0VfT0ZGU0VUKSA+PiBQ QUdFX1NISUZUKSkKKwogI2VuZGlmIC8qIF9BU01fWDg2X1BHVEFCTEVfMzJfSCAqLwpkaWZmIC0t Z2l0IGEvYXJjaC94ODYva2VybmVsL2hlYWQzMi5jIGIvYXJjaC94ODYva2VybmVsL2hlYWQzMi5j CmluZGV4IGYxNmM1NWJmYzA5MC4uZTVmYjQzNmE2NTQ4IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9r ZXJuZWwvaGVhZDMyLmMKKysrIGIvYXJjaC94ODYva2VybmVsL2hlYWQzMi5jCkBAIC00OSwzICs0 OSw2NSBAQCBhc21saW5rYWdlIF9fdmlzaWJsZSB2b2lkIF9faW5pdCBpMzg2X3N0YXJ0X2tlcm5l bCh2b2lkKQogCiAJc3RhcnRfa2VybmVsKCk7CiB9CisKKy8qCisgKiBJbml0aWFsaXplIHBhZ2Ug dGFibGVzLiAgVGhpcyBjcmVhdGVzIGEgUERFIGFuZCBhIHNldCBvZiBwYWdlCisgKiB0YWJsZXMs IHdoaWNoIGFyZSBsb2NhdGVkIGltbWVkaWF0ZWx5IGJleW9uZCBfX2Jya19iYXNlLiAgVGhlIHZh cmlhYmxlCisgKiBfYnJrX2VuZCBpcyBzZXQgdXAgdG8gcG9pbnQgdG8gdGhlIGZpcnN0ICJzYWZl IiBsb2NhdGlvbi4KKyAqIE1hcHBpbmdzIGFyZSBjcmVhdGVkIGJvdGggYXQgdmlydHVhbCBhZGRy ZXNzIDAgKGlkZW50aXR5IG1hcHBpbmcpCisgKiBhbmQgUEFHRV9PRkZTRVQgZm9yIHVwIHRvIF9l bmQuCisgKgorICogSW4gUEFFIG1vZGUgaW5pdGlhbF9wYWdlX3RhYmxlIGlzIHN0YXRpY2FsbHkg ZGVmaW5lZCB0byBjb250YWluCisgKiBlbm91Z2ggZW50cmllcyB0byBjb3ZlciB0aGUgVk1TUExJ VCBvcHRpb24gKHRoYXQgaXMgdGhlIHRvcCAxLCAyIG9yIDMKKyAqIGVudHJpZXMpLiBUaGUgaWRl bnRpdHkgbWFwcGluZyBpcyBoYW5kbGVkIGJ5IHBvaW50aW5nIHR3byBQR0QgZW50cmllcworICog dG8gdGhlIGZpcnN0IGtlcm5lbCBQTUQuIE5vdGUgdGhlIHVwcGVyIGhhbGYgb2YgZWFjaCBQTUQg b3IgUFRFIGFyZQorICogYWx3YXlzIHplcm8gYXQgdGhpcyBzdGFnZS4KKyAqLwordm9pZCBfX2lu aXQgbWtfZWFybHlfcGd0YmxfMzIodm9pZCkKK3sKKyNpZmRlZiBfX3BhCisjdW5kZWYgX19wYQor I2VuZGlmCisjZGVmaW5lIF9fcGEoeCkgICgodW5zaWduZWQgbG9uZykoeCkgLSBQQUdFX09GRlNF VCkKKwlwdGVfdCBwdGUsICpwdGVwOworCWludCBpOworCXVuc2lnbmVkIGxvbmcgKnB0cjsKKwkv KiBFbm91Z2ggc3BhY2UgdG8gZml0IHBhZ2V0YWJsZXMgZm9yIHRoZSBsb3cgbWVtb3J5IGxpbmVh ciBtYXAgKi8KKwljb25zdCB1bnNpZ25lZCBsb25nIGxpbWl0ID0gX19wYShfZW5kKSArCisJCShQ QUdFX1RBQkxFX1NJWkUoTE9XTUVNX1BBR0VTKSA8PCBQQUdFX1NISUZUKTsKKyNpZmRlZiBDT05G SUdfWDg2X1BBRQorCXBtZF90IHBsMiwgKnBsMnAgPSAocG1kX3QgKilfX3BhKGluaXRpYWxfcGdf cG1kKTsKKyNkZWZpbmUgU0VUX1BMMihwbDIsIHZhbCkgICAgeyAocGwyKS5wbWQgPSAodmFsKTsg fQorI2Vsc2UKKwlwZ2RfdCBwbDIsICpwbDJwID0gKHBnZF90ICopX19wYShpbml0aWFsX3BhZ2Vf dGFibGUpOworI2RlZmluZSBTRVRfUEwyKHBsMiwgdmFsKSAgIHsgKHBsMikucGdkID0gKHZhbCk7 IH0KKyNlbmRpZgorCisJcHRlcCA9IChwdGVfdCAqKV9fcGEoX19icmtfYmFzZSk7CisJcHRlLnB0 ZSA9IFBURV9JREVOVF9BVFRSOworCisJd2hpbGUgKChwdGUucHRlICYgUFRFX1BGTl9NQVNLKSA8 IGxpbWl0KSB7CisKKwkJU0VUX1BMMihwbDIsICh1bnNpZ25lZCBsb25nKXB0ZXAgfCBQREVfSURF TlRfQVRUUik7CisJCSpwbDJwID0gcGwyOworI2lmbmRlZiBDT05GSUdfWDg2X1BBRQorCQkvKiBL ZXJuZWwgUERFIGVudHJ5ICovCisJCSoocGwycCArICAoKFBBR0VfT0ZGU0VUID4+IFBHRElSX1NI SUZUKSkpID0gcGwyOworI2VuZGlmCisJCWZvciAoaSA9IDA7IGkgPCBQVFJTX1BFUl9QVEU7IGkr KykgeworCQkJKnB0ZXAgPSBwdGU7CisJCQlwdGUucHRlICs9IFBBR0VfU0laRTsKKwkJCXB0ZXAr KzsKKwkJfQorCisJCXBsMnArKzsKKwl9CisKKwlwdHIgPSAodW5zaWduZWQgbG9uZyAqKV9fcGEo Jm1heF9wZm5fbWFwcGVkKTsKKwkvKiBDYW4ndCB1c2UgcHRlX3BmbigpIHNpbmNlIGl0J3MgYSBj YWxsIHdpdGggQ09ORklHX1BBUkFWSVJUICovCisJKnB0ciA9IChwdGUucHRlICYgUFRFX1BGTl9N QVNLKSA+PiBQQUdFX1NISUZUOworCisJcHRyID0gKHVuc2lnbmVkIGxvbmcgKilfX3BhKCZfYnJr X2VuZCk7CisJKnB0ciA9ICh1bnNpZ25lZCBsb25nKXB0ZXAgKyBQQUdFX09GRlNFVDsKK30KKwpk aWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL2hlYWRfMzIuUyBiL2FyY2gveDg2L2tlcm5lbC9o ZWFkXzMyLlMKaW5kZXggNGU4NTc3ZDAzMzcyLi5lY2ExYzkzYzM4ZTggMTAwNjQ0Ci0tLSBhL2Fy Y2gveDg2L2tlcm5lbC9oZWFkXzMyLlMKKysrIGIvYXJjaC94ODYva2VybmVsL2hlYWRfMzIuUwpA QCAtMjQsNiArMjQsNyBAQAogI2luY2x1ZGUgPGFzbS9ub3BzLmg+CiAjaW5jbHVkZSA8YXNtL2Jv b3RwYXJhbS5oPgogI2luY2x1ZGUgPGFzbS9leHBvcnQuaD4KKyNpbmNsdWRlIDxhc20vcGd0YWJs ZV8zMi5oPgogCiAvKiBQaHlzaWNhbCBhZGRyZXNzICovCiAjZGVmaW5lIHBhKFgpICgoWCkgLSBf X1BBR0VfT0ZGU0VUKQpAQCAtNDIsNDMgKzQzLDggQEAKICNkZWZpbmUgWDg2X1ZFTkRPUl9JRAlu ZXdfY3B1X2RhdGErQ1BVSU5GT194ODZfdmVuZG9yX2lkCiAKIC8qCi0gKiBUaGlzIGlzIGhvdyBt dWNoIG1lbW9yeSBpbiBhZGRpdGlvbiB0byB0aGUgbWVtb3J5IGNvdmVyZWQgdXAgdG8KLSAqIGFu ZCBpbmNsdWRpbmcgX2VuZCB3ZSBuZWVkIG1hcHBlZCBpbml0aWFsbHkuCi0gKiBXZSBuZWVkOgot ICogICAgIChLRVJORUxfSU1BR0VfU0laRS80MDk2KSAvIDEwMjQgcGFnZXMgKHdvcnN0IGNhc2Us IG5vbiBQQUUpCi0gKiAgICAgKEtFUk5FTF9JTUFHRV9TSVpFLzQwOTYpIC8gNTEyICsgNCBwYWdl cyAod29yc3QgY2FzZSBmb3IgUEFFKQotICoKLSAqIE1vZHVsbyByb3VuZGluZywgZWFjaCBtZWdh Ynl0ZSBhc3NpZ25lZCBoZXJlIHJlcXVpcmVzIGEga2lsb2J5dGUgb2YKLSAqIG1lbW9yeSwgd2hp Y2ggaXMgY3VycmVudGx5IHVucmVjbGFpbWVkLgotICoKLSAqIFRoaXMgc2hvdWxkIGJlIGEgbXVs dGlwbGUgb2YgYSBwYWdlLgotICoKLSAqIEtFUk5FTF9JTUFHRV9TSVpFIHNob3VsZCBiZSBncmVh dGVyIHRoYW4gcGEoX2VuZCkKLSAqIGFuZCBzbWFsbCB0aGFuIG1heF9sb3dfcGZuLCBvdGhlcndp c2Ugd2lsbCB3YXN0ZSBzb21lIHBhZ2UgdGFibGUgZW50cmllcwotICovCi0KLSNpZiBQVFJTX1BF Ul9QTUQgPiAxCi0jZGVmaW5lIFBBR0VfVEFCTEVfU0laRShwYWdlcykgKCgocGFnZXMpIC8gUFRS U19QRVJfUE1EKSArIFBUUlNfUEVSX1BHRCkKLSNlbHNlCi0jZGVmaW5lIFBBR0VfVEFCTEVfU0la RShwYWdlcykgKChwYWdlcykgLyBQVFJTX1BFUl9QR0QpCi0jZW5kaWYKLQogI2RlZmluZSBTSVpF T0ZfUFRSRUdTIDE3KjQKIAotLyoKLSAqIE51bWJlciBvZiBwb3NzaWJsZSBwYWdlcyBpbiB0aGUg bG93bWVtIHJlZ2lvbi4KLSAqCi0gKiBXZSBzaGlmdCAyIGJ5IDMxIGluc3RlYWQgb2YgMSBieSAz MiB0byB0aGUgbGVmdCBpbiBvcmRlciB0byBhdm9pZCBhCi0gKiBnYXMgd2FybmluZyBhYm91dCBv dmVyZmxvd2luZyBzaGlmdCBjb3VudCB3aGVuIGdhcyBoYXMgYmVlbiBjb21waWxlZAotICogd2l0 aCBvbmx5IGEgaG9zdCB0YXJnZXQgc3VwcG9ydCB1c2luZyBhIDMyLWJpdCB0eXBlIGZvciBpbnRl cm5hbAotICogcmVwcmVzZW50YXRpb24uCi0gKi8KLUxPV01FTV9QQUdFUyA9ICgoKDI8PDMxKSAt IF9fUEFHRV9PRkZTRVQpID4+IFBBR0VfU0hJRlQpCi0KLS8qIEVub3VnaCBzcGFjZSB0byBmaXQg cGFnZXRhYmxlcyBmb3IgdGhlIGxvdyBtZW1vcnkgbGluZWFyIG1hcCAqLwotTUFQUElOR19CRVlP TkRfRU5EID0gUEFHRV9UQUJMRV9TSVpFKExPV01FTV9QQUdFUykgPDwgUEFHRV9TSElGVAotCi0v KgogICogV29yc3QtY2FzZSBzaXplIG9mIHRoZSBrZXJuZWwgbWFwcGluZyB3ZSBuZWVkIHRvIG1h a2U6CiAgKiBhIHJlbG9jYXRhYmxlIGtlcm5lbCBjYW4gbGl2ZSBhbnl3aGVyZSBpbiBsb3dtZW0s IHNvIHdlIG5lZWQgdG8gYmUgYWJsZQogICogdG8gbWFwIGFsbCBvZiBsb3dtZW0uCkBAIC0xNjAs OTAgKzEyNiwxNSBAQCBFTlRSWShzdGFydHVwXzMyKQogCWNhbGwgbG9hZF91Y29kZV9ic3AKICNl bmRpZgogCi0vKgotICogSW5pdGlhbGl6ZSBwYWdlIHRhYmxlcy4gIFRoaXMgY3JlYXRlcyBhIFBE RSBhbmQgYSBzZXQgb2YgcGFnZQotICogdGFibGVzLCB3aGljaCBhcmUgbG9jYXRlZCBpbW1lZGlh dGVseSBiZXlvbmQgX19icmtfYmFzZS4gIFRoZSB2YXJpYWJsZQotICogX2Jya19lbmQgaXMgc2V0 IHVwIHRvIHBvaW50IHRvIHRoZSBmaXJzdCAic2FmZSIgbG9jYXRpb24uCi0gKiBNYXBwaW5ncyBh cmUgY3JlYXRlZCBib3RoIGF0IHZpcnR1YWwgYWRkcmVzcyAwIChpZGVudGl0eSBtYXBwaW5nKQot ICogYW5kIFBBR0VfT0ZGU0VUIGZvciB1cCB0byBfZW5kLgotICovCi0jaWZkZWYgQ09ORklHX1g4 Nl9QQUUKLQotCS8qCi0JICogSW4gUEFFIG1vZGUgaW5pdGlhbF9wYWdlX3RhYmxlIGlzIHN0YXRp Y2FsbHkgZGVmaW5lZCB0byBjb250YWluCi0JICogZW5vdWdoIGVudHJpZXMgdG8gY292ZXIgdGhl IFZNU1BMSVQgb3B0aW9uICh0aGF0IGlzIHRoZSB0b3AgMSwgMiBvciAzCi0JICogZW50cmllcyku IFRoZSBpZGVudGl0eSBtYXBwaW5nIGlzIGhhbmRsZWQgYnkgcG9pbnRpbmcgdHdvIFBHRCBlbnRy aWVzCi0JICogdG8gdGhlIGZpcnN0IGtlcm5lbCBQTUQuCi0JICoKLQkgKiBOb3RlIHRoZSB1cHBl ciBoYWxmIG9mIGVhY2ggUE1EIG9yIFBURSBhcmUgYWx3YXlzIHplcm8gYXQgdGhpcyBzdGFnZS4K LQkgKi8KLQotI2RlZmluZSBLUE1EUyAoKCgtX19QQUdFX09GRlNFVCkgPj4gMzApICYgMykgLyog TnVtYmVyIG9mIGtlcm5lbCBQTURzICovCi0KLQl4b3JsICVlYngsJWVieAkJCQkvKiAlZWJ4IGlz IGtlcHQgYXQgemVybyAqLwotCi0JbW92bCAkcGEoX19icmtfYmFzZSksICVlZGkKLQltb3ZsICRw YShpbml0aWFsX3BnX3BtZCksICVlZHgKLQltb3ZsICRQVEVfSURFTlRfQVRUUiwgJWVheAotMTA6 Ci0JbGVhbCBQREVfSURFTlRfQVRUUiglZWRpKSwlZWN4CQkvKiBDcmVhdGUgUE1EIGVudHJ5ICov Ci0JbW92bCAlZWN4LCglZWR4KQkJCS8qIFN0b3JlIFBNRCBlbnRyeSAqLwotCQkJCQkJLyogVXBw ZXIgaGFsZiBhbHJlYWR5IHplcm8gKi8KLQlhZGRsICQ4LCVlZHgKLQltb3ZsICQ1MTIsJWVjeAot MTE6Ci0Jc3Rvc2wKLQl4Y2hnbCAlZWF4LCVlYngKLQlzdG9zbAotCXhjaGdsICVlYXgsJWVieAot CWFkZGwgJDB4MTAwMCwlZWF4Ci0JbG9vcCAxMWIKLQotCS8qCi0JICogRW5kIGNvbmRpdGlvbjog d2UgbXVzdCBtYXAgdXAgdG8gdGhlIGVuZCArIE1BUFBJTkdfQkVZT05EX0VORC4KLQkgKi8KLQlt b3ZsICRwYShfZW5kKSArIE1BUFBJTkdfQkVZT05EX0VORCArIFBURV9JREVOVF9BVFRSLCAlZWJw Ci0JY21wbCAlZWJwLCVlYXgKLQlqYiAxMGIKLTE6Ci0JYWRkbCAkX19QQUdFX09GRlNFVCwgJWVk aQotCW1vdmwgJWVkaSwgcGEoX2Jya19lbmQpCi0Jc2hybCAkMTIsICVlYXgKLQltb3ZsICVlYXgs IHBhKG1heF9wZm5fbWFwcGVkKQorCS8qIENyZWF0ZSBlYXJseSBwYWdldGFibGVzLiAqLworCWNh bGwgIG1rX2Vhcmx5X3BndGJsXzMyCiAKIAkvKiBEbyBlYXJseSBpbml0aWFsaXphdGlvbiBvZiB0 aGUgZml4bWFwIGFyZWEgKi8KIAltb3ZsICRwYShpbml0aWFsX3BnX2ZpeG1hcCkrUERFX0lERU5U X0FUVFIsJWVheAorI2lmZGVmICBDT05GSUdfWDg2X1BBRQorI2RlZmluZSBLUE1EUyAoKCgtX19Q QUdFX09GRlNFVCkgPj4gMzApICYgMykgLyogTnVtYmVyIG9mIGtlcm5lbCBQTURzICovCiAJbW92 bCAlZWF4LHBhKGluaXRpYWxfcGdfcG1kKzB4MTAwMCpLUE1EUy04KQotI2Vsc2UJLyogTm90IFBB RSAqLwotCi1wYWdlX3BkZV9vZmZzZXQgPSAoX19QQUdFX09GRlNFVCA+PiAyMCk7Ci0KLQltb3Zs ICRwYShfX2Jya19iYXNlKSwgJWVkaQotCW1vdmwgJHBhKGluaXRpYWxfcGFnZV90YWJsZSksICVl ZHgKLQltb3ZsICRQVEVfSURFTlRfQVRUUiwgJWVheAotMTA6Ci0JbGVhbCBQREVfSURFTlRfQVRU UiglZWRpKSwlZWN4CQkvKiBDcmVhdGUgUERFIGVudHJ5ICovCi0JbW92bCAlZWN4LCglZWR4KQkJ CS8qIFN0b3JlIGlkZW50aXR5IFBERSBlbnRyeSAqLwotCW1vdmwgJWVjeCxwYWdlX3BkZV9vZmZz ZXQoJWVkeCkJCS8qIFN0b3JlIGtlcm5lbCBQREUgZW50cnkgKi8KLQlhZGRsICQ0LCVlZHgKLQlt b3ZsICQxMDI0LCAlZWN4Ci0xMToKLQlzdG9zbAotCWFkZGwgJDB4MTAwMCwlZWF4Ci0JbG9vcCAx MWIKLQkvKgotCSAqIEVuZCBjb25kaXRpb246IHdlIG11c3QgbWFwIHVwIHRvIHRoZSBlbmQgKyBN QVBQSU5HX0JFWU9ORF9FTkQuCi0JICovCi0JbW92bCAkcGEoX2VuZCkgKyBNQVBQSU5HX0JFWU9O RF9FTkQgKyBQVEVfSURFTlRfQVRUUiwgJWVicAotCWNtcGwgJWVicCwlZWF4Ci0JamIgMTBiCi0J YWRkbCAkX19QQUdFX09GRlNFVCwgJWVkaQotCW1vdmwgJWVkaSwgcGEoX2Jya19lbmQpCi0Jc2hy bCAkMTIsICVlYXgKLQltb3ZsICVlYXgsIHBhKG1heF9wZm5fbWFwcGVkKQotCi0JLyogRG8gZWFy bHkgaW5pdGlhbGl6YXRpb24gb2YgdGhlIGZpeG1hcCBhcmVhICovCi0JbW92bCAkcGEoaW5pdGlh bF9wZ19maXhtYXApK1BERV9JREVOVF9BVFRSLCVlYXgKKyNlbHNlCiAJbW92bCAlZWF4LHBhKGlu aXRpYWxfcGFnZV90YWJsZSsweGZmYykKICNlbmRpZgogCkBAIC02NjYsNiArNTU3LDcgQEAgRU5U Ulkoc2V0dXBfb25jZV9yZWYpCiBfX1BBR0VfQUxJR05FRF9CU1MKIAkuYWxpZ24gUEFHRV9TSVpF CiAjaWZkZWYgQ09ORklHX1g4Nl9QQUUKKy5nbG9ibCBpbml0aWFsX3BnX3BtZAogaW5pdGlhbF9w Z19wbWQ6CiAJLmZpbGwgMTAyNCpLUE1EUyw0LDAKICNlbHNlCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1k ZXZlbEBsaXN0cy54ZW4ub3JnCmh0dHBzOi8vbGlzdHMueGVuLm9yZy94ZW4tZGV2ZWwK