From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id DBE88238172; Thu, 2 Oct 2025 15:58:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759420711; cv=none; b=jxn5WIyIoNQuDvR3tKf0JId36YdjHHfZTRXrgf5zuqe1YTM1EiGknKX8UCbxaItA14x6DNWkuRbkwlUp9aNSxV0c3Fq71ltI7YcZqnemgSX3HNvOIMQHIrDL2TT86bSQ0SnqZM87YOX+WnjrI/NteYdCFGQTPnqoU4sb6sscUAA= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759420711; c=relaxed/simple; bh=cilV1O0vUAtuGZGe3YxvO4p8XIFUBSm2PiXuqmpPfBw=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=t4cD4mW3SUoFySylwp8gjFbwphDxrlmF57dso+/YUUCXIsBBxlSdtZtIO67nkWw+Fx/oao5soXEXzPUZ0s14z+4lj4WGSFf7jZTlYDRqJS68RuMurwufaj/SZ3T1ps7cuvTm0AiLfphNPa1G8wrZmWlDnzFPyn5dTUgAdtRmu+4= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=hit0hmB/; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="hit0hmB/" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 67594C4CEF4; Thu, 2 Oct 2025 15:58:30 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1759420710; bh=cilV1O0vUAtuGZGe3YxvO4p8XIFUBSm2PiXuqmpPfBw=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=hit0hmB/DVeLXD6O/DpSQ8xEhEiP2a3qgSR3d0ryg1junES7D4Ug16orX9gcWc1FL 7KJXcq6+R8iaSXx75VrN6/Fj0NrBsmnICuipBoAzUrZOyFaQlWo/mSf0ocxa4Vtkcs 78Ve8D/fqKlMM17MRWq/WsjPy83yiUuqOIND8GJayscI6IW4TCQOnHgvT8f9vRpNvu 8GQTYZeYvAD3pjerLq4odG28Z6yW36sPZ3tK8D2vnEn0mZpLRsDaK+tomeoWnp5bWN Krn2OP+FMIlynZyqtc+vJbUFDGuPaM1aX4gux0hSnfTYFYAPXXpLqbbGsHYao6Deh2 K9MUduWlNdYDQ== Date: Thu, 2 Oct 2025 08:58:30 -0700 From: Kees Cook To: Sasha Levin Cc: patches@lists.linux.dev, stable@vger.kernel.org, Svetlana Parfenova , paul.walmsley@sifive.com, palmer@dabbelt.com, aou@eecs.berkeley.edu, viro@zeniv.linux.org.uk, akpm@linux-foundation.org, gregkh@linuxfoundation.org, harshvardhan.j.jha@oracle.com, chenqiwu@xiaomi.com, linux-riscv@lists.infradead.org, linux-fsdevel@vger.kernel.org Subject: Re: [PATCH AUTOSEL 6.17-6.12] binfmt_elf: preserve original ELF e_flags for core dumps Message-ID: <202510020856.736F028D@keescook> References: <20251002153025.2209281-1-sashal@kernel.org> <20251002153025.2209281-31-sashal@kernel.org> Precedence: bulk X-Mailing-List: patches@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20251002153025.2209281-31-sashal@kernel.org> I'm not excited about this getting backported without an explicit user/champion for it -- it adds Kconfig dependencies and potentially changes existing runtime behaviors. -Kees On Thu, Oct 02, 2025 at 11:30:18AM -0400, Sasha Levin wrote: > From: Svetlana Parfenova > > [ Upstream commit 8c94db0ae97c72c253a615f990bd466b456e94f6 ] > > Some architectures, such as RISC-V, use the ELF e_flags field to encode > ABI-specific information (e.g., ISA extensions, fpu support). Debuggers > like GDB rely on these flags in core dumps to correctly interpret > optional register sets. If the flags are missing or incorrect, GDB may > warn and ignore valid data, for example: > > warning: Unexpected size of section '.reg2/213' in core file. > > This can prevent access to fpu or other architecture-specific registers > even when they were dumped. > > Save the e_flags field during ELF binary loading (in load_elf_binary()) > into the mm_struct, and later retrieve it during core dump generation > (in fill_note_info()). Kconfig option CONFIG_ARCH_HAS_ELF_CORE_EFLAGS > is introduced for architectures that require this behaviour. > > Signed-off-by: Svetlana Parfenova > Link: https://lore.kernel.org/r/20250901135350.619485-1-svetlana.parfenova@syntacore.com > Signed-off-by: Kees Cook > Signed-off-by: Sasha Levin > --- > > LLM Generated explanations, may be completely bogus: > > Based on my comprehensive analysis, here is my determination: > > --- > > ## **Backport Status: YES** > > ### **Extensive Analysis:** > > #### **Problem Being Fixed:** > This commit addresses a debugging issue on RISC-V architecture where GDB > cannot properly interpret core dumps. The root cause is that RISC-V uses > the ELF e_flags field to encode critical ABI information (ISA > extensions, FPU support), and without preserving these flags in core > dumps, GDB displays warnings like: > > ``` > warning: Unexpected size of section '.reg2/213' in core file. > ``` > > This prevents developers from accessing FPU or other architecture- > specific registers during post-mortem debugging, even when the data was > correctly dumped. > > #### **Code Changes Analysis:** > > **1. fs/binfmt_elf.c (core changes):** > - Lines 106-119: Adds two inline helper functions > `elf_coredump_set_mm_eflags()` and `elf_coredump_get_mm_eflags()` > that are no-ops when CONFIG_ARCH_HAS_ELF_CORE_EFLAGS is disabled > - Line 1308: Saves e_flags during ELF binary loading: > `elf_coredump_set_mm_eflags(mm, elf_ex->e_flags)` > - Lines 1824-1866: Refactors fill_note_info() to extract machine type > and flags into local variables, then overrides flags with saved > value if architecture opted in > > **2. include/linux/mm_types.h:** > - Adds `unsigned long saved_e_flags` field to mm_struct, > conditionally compiled > - Field placement is logical (after saved_auxv, another ELF-related > field) > - Memory overhead: one unsigned long (8 bytes on 64-bit) per > mm_struct, only on RISC-V > > **3. fs/Kconfig.binfmt:** > - Adds CONFIG_ARCH_HAS_ELF_CORE_EFLAGS option > - Depends on BINFMT_ELF && ELF_CORE > - Allows architectures to opt-in to e_flags preservation > > **4. arch/riscv/Kconfig:** > - Enables CONFIG_ARCH_HAS_ELF_CORE_EFLAGS for RISC-V > > #### **Why This Qualifies for Backporting:** > > **✓ Important Bug Fix:** > - Fixes real user-facing problem: debugging RISC-V applications with FPU > is broken > - Affects developers working on RISC-V platforms > - No workaround available (the information is lost in core dumps) > > **✓ Small and Contained:** > - Net change: 55 insertions, 6 deletions across 4 files > - All logic is simple save/restore pattern > - No complex state management or synchronization > > **✓ Minimal Regression Risk:** > - Opt-in via Kconfig - other architectures completely unaffected > - When disabled: zero runtime overhead (functions compile to empty > inline stubs) > - When enabled: trivial assignment operations with no failure paths > - Changes are in well-established code paths (load_elf_binary, > fill_note_info) > > **✓ No Dependencies:** > - Applies cleanly to 6.17 tree > - No prerequisite commits required > - The backport also includes a728ce8ffbd27 (struct_size() refactoring) > which is a compatible cleanup > > **✓ Stable After Mainline:** > - Committed Sep 3, 2025 (27 days in mainline as of Sep 30) > - No fixes, reverts, or reported issues > - git log shows no follow-up corrections needed > > **✓ Maintainer Approved:** > - Signed-off-by: Kees Cook (execve/binfmt maintainer) > - Proper review process through lore.kernel.org > > **✓ Follows Stable Kernel Rules:** > - Rule 1: Must be obviously correct and tested ✓ > - Rule 2: Significant bugfix ✓ > - Rule 3: Not larger than 100 lines ✓ > - Rule 4: Patches cannot add features ✓ (fixes existing feature) > - Rule 5: No theoretical race condition fixes ✓ (fixes actual GDB issue) > > #### **Technical Correctness:** > > **ELF_CORE_EFLAGS Historical Context:** > - The macro has existed since 2005 (Linus's original git import) > - Only Hexagon and PowerPC defined non-zero values > - RISC-V's e_flags usage is architecturally critical for ABI > compatibility > - The old approach (using static ELF_CORE_EFLAGS=0) lost runtime > information > > **Design Quality:** > - Clean separation: CONFIG option → mm_struct field → helper functions > - Backward compatible: architectures that don't need it pay zero cost > - Forward compatible: other architectures (ARM, MIPS) could adopt this > if needed > - Proper abstraction through inline helpers prevents #ifdef > proliferation > > #### **Potential Concerns Addressed:** > > **Q: Is mm_struct size increase acceptable?** > A: Yes. One unsigned long (8 bytes) per process on RISC-V only, > negligible compared to typical mm_struct size (~1KB+) > > **Q: Why not use regset_view->e_flags?** > A: The regset_view structure doesn't have an e_flags field. The old code > fell back to the compile-time ELF_CORE_EFLAGS constant, losing the per- > process runtime ABI information from the actual ELF binary. > > **Q: Thread safety concerns?** > A: None. The e_flags are written once during load_elf_binary() before > any threads can be created, and read during core dump when all threads > are stopped. > > **Q: Is this too recent for backporting?** > A: While 27 days is relatively fresh, the change is so minimal and > isolated that the risk is negligible. The opt-in nature means > regressions can only affect RISC-V users who explicitly enable > coredumps. > > ### **Conclusion:** > > This commit should be backported because it fixes an important debugging > issue on RISC-V with minimal risk. The change is small, self-contained, > opt-in, and has been stable in mainline. It meets all stable kernel > backporting criteria and will significantly improve the debugging > experience for RISC-V developers without impacting other architectures. > > arch/riscv/Kconfig | 1 + > fs/Kconfig.binfmt | 9 +++++++++ > fs/binfmt_elf.c | 40 ++++++++++++++++++++++++++++++++++------ > include/linux/mm_types.h | 5 +++++ > 4 files changed, 49 insertions(+), 6 deletions(-) > > diff --git a/arch/riscv/Kconfig b/arch/riscv/Kconfig > index 51dcd8eaa2435..74db054aa1b8b 100644 > --- a/arch/riscv/Kconfig > +++ b/arch/riscv/Kconfig > @@ -28,6 +28,7 @@ config RISCV > select ARCH_HAS_DEBUG_VIRTUAL if MMU > select ARCH_HAS_DEBUG_VM_PGTABLE > select ARCH_HAS_DEBUG_WX > + select ARCH_HAS_ELF_CORE_EFLAGS > select ARCH_HAS_FAST_MULTIPLIER > select ARCH_HAS_FORTIFY_SOURCE > select ARCH_HAS_GCOV_PROFILE_ALL > diff --git a/fs/Kconfig.binfmt b/fs/Kconfig.binfmt > index bd2f530e57408..1949e25c7741b 100644 > --- a/fs/Kconfig.binfmt > +++ b/fs/Kconfig.binfmt > @@ -184,4 +184,13 @@ config EXEC_KUNIT_TEST > This builds the exec KUnit tests, which tests boundary conditions > of various aspects of the exec internals. > > +config ARCH_HAS_ELF_CORE_EFLAGS > + bool > + depends on BINFMT_ELF && ELF_CORE > + default n > + help > + Select this option if the architecture makes use of the e_flags > + field in the ELF header to store ABI or other architecture-specific > + information that should be preserved in core dumps. > + > endmenu > diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c > index 264fba0d44bdf..c126e3d0e7018 100644 > --- a/fs/binfmt_elf.c > +++ b/fs/binfmt_elf.c > @@ -103,6 +103,21 @@ static struct linux_binfmt elf_format = { > > #define BAD_ADDR(x) (unlikely((unsigned long)(x) >= TASK_SIZE)) > > +static inline void elf_coredump_set_mm_eflags(struct mm_struct *mm, u32 flags) > +{ > +#ifdef CONFIG_ARCH_HAS_ELF_CORE_EFLAGS > + mm->saved_e_flags = flags; > +#endif > +} > + > +static inline u32 elf_coredump_get_mm_eflags(struct mm_struct *mm, u32 flags) > +{ > +#ifdef CONFIG_ARCH_HAS_ELF_CORE_EFLAGS > + flags = mm->saved_e_flags; > +#endif > + return flags; > +} > + > /* > * We need to explicitly zero any trailing portion of the page that follows > * p_filesz when it ends before the page ends (e.g. bss), otherwise this > @@ -1290,6 +1305,8 @@ static int load_elf_binary(struct linux_binprm *bprm) > mm->end_data = end_data; > mm->start_stack = bprm->p; > > + elf_coredump_set_mm_eflags(mm, elf_ex->e_flags); > + > /** > * DOC: "brk" handling > * > @@ -1804,6 +1821,8 @@ static int fill_note_info(struct elfhdr *elf, int phdrs, > struct elf_thread_core_info *t; > struct elf_prpsinfo *psinfo; > struct core_thread *ct; > + u16 machine; > + u32 flags; > > psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL); > if (!psinfo) > @@ -1831,17 +1850,26 @@ static int fill_note_info(struct elfhdr *elf, int phdrs, > return 0; > } > > - /* > - * Initialize the ELF file header. > - */ > - fill_elf_header(elf, phdrs, > - view->e_machine, view->e_flags); > + machine = view->e_machine; > + flags = view->e_flags; > #else > view = NULL; > info->thread_notes = 2; > - fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS); > + machine = ELF_ARCH; > + flags = ELF_CORE_EFLAGS; > #endif > > + /* > + * Override ELF e_flags with value taken from process, > + * if arch needs that. > + */ > + flags = elf_coredump_get_mm_eflags(dump_task->mm, flags); > + > + /* > + * Initialize the ELF file header. > + */ > + fill_elf_header(elf, phdrs, machine, flags); > + > /* > * Allocate a structure for each thread. > */ > diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h > index a643fae8a3494..7f625c35128be 100644 > --- a/include/linux/mm_types.h > +++ b/include/linux/mm_types.h > @@ -1107,6 +1107,11 @@ struct mm_struct { > > unsigned long saved_auxv[AT_VECTOR_SIZE]; /* for /proc/PID/auxv */ > > +#ifdef CONFIG_ARCH_HAS_ELF_CORE_EFLAGS > + /* the ABI-related flags from the ELF header. Used for core dump */ > + unsigned long saved_e_flags; > +#endif > + > struct percpu_counter rss_stat[NR_MM_COUNTERS]; > > struct linux_binfmt *binfmt; > -- > 2.51.0 > -- Kees Cook From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 5E504CAC5B0 for ; Thu, 2 Oct 2025 15:58:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=P+iv+tNWl8ZiU/tVFjQTaVQJxXLuucgg02IJN3wgbXQ=; b=buIH7ADyHSJSqn GtQy0uoxf9dYI0MqWhnq826VVGv1hD3PHvnliTEGPesSBwc7C0mAfTompYzWVWKzHV7dV3NgGxEIh J4vkMKAzuWFhm9d0kqXHbZoFrBTUcQ6QLKVP5gea4BXJEuvkvnlpyxs2FM8lo1v8CkdNIVy8TIu3Z VhTEWwYYLlWCOSX45ZH1sldrG221qGxuMLmy2AlWzEWZCQTMq9iFc3FeJQkuIlH27iExnD8krOVD6 aQFKi/0S8FX3eOigULrBCxBdjRyGUGcC3wJjprKciupmgf4LdAYSmuThM8ogwqWYo50Hq4fWtAVAO entqATVYQswRGgm2jcuA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1v4LhR-0000000AlbF-3OCY; Thu, 02 Oct 2025 15:58:33 +0000 Received: from tor.source.kernel.org ([172.105.4.254]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1v4LhP-0000000AlaJ-38jV for linux-riscv@lists.infradead.org; Thu, 02 Oct 2025 15:58:31 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id BFCF56208C; Thu, 2 Oct 2025 15:58:30 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 67594C4CEF4; Thu, 2 Oct 2025 15:58:30 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1759420710; bh=cilV1O0vUAtuGZGe3YxvO4p8XIFUBSm2PiXuqmpPfBw=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=hit0hmB/DVeLXD6O/DpSQ8xEhEiP2a3qgSR3d0ryg1junES7D4Ug16orX9gcWc1FL 7KJXcq6+R8iaSXx75VrN6/Fj0NrBsmnICuipBoAzUrZOyFaQlWo/mSf0ocxa4Vtkcs 78Ve8D/fqKlMM17MRWq/WsjPy83yiUuqOIND8GJayscI6IW4TCQOnHgvT8f9vRpNvu 8GQTYZeYvAD3pjerLq4odG28Z6yW36sPZ3tK8D2vnEn0mZpLRsDaK+tomeoWnp5bWN Krn2OP+FMIlynZyqtc+vJbUFDGuPaM1aX4gux0hSnfTYFYAPXXpLqbbGsHYao6Deh2 K9MUduWlNdYDQ== Date: Thu, 2 Oct 2025 08:58:30 -0700 From: Kees Cook To: Sasha Levin Cc: patches@lists.linux.dev, stable@vger.kernel.org, Svetlana Parfenova , paul.walmsley@sifive.com, palmer@dabbelt.com, aou@eecs.berkeley.edu, viro@zeniv.linux.org.uk, akpm@linux-foundation.org, gregkh@linuxfoundation.org, harshvardhan.j.jha@oracle.com, chenqiwu@xiaomi.com, linux-riscv@lists.infradead.org, linux-fsdevel@vger.kernel.org Subject: Re: [PATCH AUTOSEL 6.17-6.12] binfmt_elf: preserve original ELF e_flags for core dumps Message-ID: <202510020856.736F028D@keescook> References: <20251002153025.2209281-1-sashal@kernel.org> <20251002153025.2209281-31-sashal@kernel.org> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20251002153025.2209281-31-sashal@kernel.org> X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org SSdtIG5vdCBleGNpdGVkIGFib3V0IHRoaXMgZ2V0dGluZyBiYWNrcG9ydGVkIHdpdGhvdXQgYW4g ZXhwbGljaXQKdXNlci9jaGFtcGlvbiBmb3IgaXQgLS0gaXQgYWRkcyBLY29uZmlnIGRlcGVuZGVu Y2llcyBhbmQgcG90ZW50aWFsbHkKY2hhbmdlcyBleGlzdGluZyBydW50aW1lIGJlaGF2aW9ycy4K Ci1LZWVzCgpPbiBUaHUsIE9jdCAwMiwgMjAyNSBhdCAxMTozMDoxOEFNIC0wNDAwLCBTYXNoYSBM ZXZpbiB3cm90ZToKPiBGcm9tOiBTdmV0bGFuYSBQYXJmZW5vdmEgPHN2ZXRsYW5hLnBhcmZlbm92 YUBzeW50YWNvcmUuY29tPgo+IAo+IFsgVXBzdHJlYW0gY29tbWl0IDhjOTRkYjBhZTk3YzcyYzI1 M2E2MTVmOTkwYmQ0NjZiNDU2ZTk0ZjYgXQo+IAo+IFNvbWUgYXJjaGl0ZWN0dXJlcywgc3VjaCBh cyBSSVNDLVYsIHVzZSB0aGUgRUxGIGVfZmxhZ3MgZmllbGQgdG8gZW5jb2RlCj4gQUJJLXNwZWNp ZmljIGluZm9ybWF0aW9uIChlLmcuLCBJU0EgZXh0ZW5zaW9ucywgZnB1IHN1cHBvcnQpLiBEZWJ1 Z2dlcnMKPiBsaWtlIEdEQiByZWx5IG9uIHRoZXNlIGZsYWdzIGluIGNvcmUgZHVtcHMgdG8gY29y cmVjdGx5IGludGVycHJldAo+IG9wdGlvbmFsIHJlZ2lzdGVyIHNldHMuIElmIHRoZSBmbGFncyBh cmUgbWlzc2luZyBvciBpbmNvcnJlY3QsIEdEQiBtYXkKPiB3YXJuIGFuZCBpZ25vcmUgdmFsaWQg ZGF0YSwgZm9yIGV4YW1wbGU6Cj4gCj4gICAgIHdhcm5pbmc6IFVuZXhwZWN0ZWQgc2l6ZSBvZiBz ZWN0aW9uICcucmVnMi8yMTMnIGluIGNvcmUgZmlsZS4KPiAKPiBUaGlzIGNhbiBwcmV2ZW50IGFj Y2VzcyB0byBmcHUgb3Igb3RoZXIgYXJjaGl0ZWN0dXJlLXNwZWNpZmljIHJlZ2lzdGVycwo+IGV2 ZW4gd2hlbiB0aGV5IHdlcmUgZHVtcGVkLgo+IAo+IFNhdmUgdGhlIGVfZmxhZ3MgZmllbGQgZHVy aW5nIEVMRiBiaW5hcnkgbG9hZGluZyAoaW4gbG9hZF9lbGZfYmluYXJ5KCkpCj4gaW50byB0aGUg bW1fc3RydWN0LCBhbmQgbGF0ZXIgcmV0cmlldmUgaXQgZHVyaW5nIGNvcmUgZHVtcCBnZW5lcmF0 aW9uCj4gKGluIGZpbGxfbm90ZV9pbmZvKCkpLiBLY29uZmlnIG9wdGlvbiBDT05GSUdfQVJDSF9I QVNfRUxGX0NPUkVfRUZMQUdTCj4gaXMgaW50cm9kdWNlZCBmb3IgYXJjaGl0ZWN0dXJlcyB0aGF0 IHJlcXVpcmUgdGhpcyBiZWhhdmlvdXIuCj4gCj4gU2lnbmVkLW9mZi1ieTogU3ZldGxhbmEgUGFy ZmVub3ZhIDxzdmV0bGFuYS5wYXJmZW5vdmFAc3ludGFjb3JlLmNvbT4KPiBMaW5rOiBodHRwczov L2xvcmUua2VybmVsLm9yZy9yLzIwMjUwOTAxMTM1MzUwLjYxOTQ4NS0xLXN2ZXRsYW5hLnBhcmZl bm92YUBzeW50YWNvcmUuY29tCj4gU2lnbmVkLW9mZi1ieTogS2VlcyBDb29rIDxrZWVzQGtlcm5l bC5vcmc+Cj4gU2lnbmVkLW9mZi1ieTogU2FzaGEgTGV2aW4gPHNhc2hhbEBrZXJuZWwub3JnPgo+ IC0tLQo+IAo+IExMTSBHZW5lcmF0ZWQgZXhwbGFuYXRpb25zLCBtYXkgYmUgY29tcGxldGVseSBi b2d1czoKPiAKPiBCYXNlZCBvbiBteSBjb21wcmVoZW5zaXZlIGFuYWx5c2lzLCBoZXJlIGlzIG15 IGRldGVybWluYXRpb246Cj4gCj4gLS0tCj4gCj4gIyMgKipCYWNrcG9ydCBTdGF0dXM6IFlFUyoq Cj4gCj4gIyMjICoqRXh0ZW5zaXZlIEFuYWx5c2lzOioqCj4gCj4gIyMjIyAqKlByb2JsZW0gQmVp bmcgRml4ZWQ6KioKPiBUaGlzIGNvbW1pdCBhZGRyZXNzZXMgYSBkZWJ1Z2dpbmcgaXNzdWUgb24g UklTQy1WIGFyY2hpdGVjdHVyZSB3aGVyZSBHREIKPiBjYW5ub3QgcHJvcGVybHkgaW50ZXJwcmV0 IGNvcmUgZHVtcHMuIFRoZSByb290IGNhdXNlIGlzIHRoYXQgUklTQy1WIHVzZXMKPiB0aGUgRUxG IGVfZmxhZ3MgZmllbGQgdG8gZW5jb2RlIGNyaXRpY2FsIEFCSSBpbmZvcm1hdGlvbiAoSVNBCj4g ZXh0ZW5zaW9ucywgRlBVIHN1cHBvcnQpLCBhbmQgd2l0aG91dCBwcmVzZXJ2aW5nIHRoZXNlIGZs YWdzIGluIGNvcmUKPiBkdW1wcywgR0RCIGRpc3BsYXlzIHdhcm5pbmdzIGxpa2U6Cj4gCj4gYGBg Cj4gd2FybmluZzogVW5leHBlY3RlZCBzaXplIG9mIHNlY3Rpb24gJy5yZWcyLzIxMycgaW4gY29y ZSBmaWxlLgo+IGBgYAo+IAo+IFRoaXMgcHJldmVudHMgZGV2ZWxvcGVycyBmcm9tIGFjY2Vzc2lu ZyBGUFUgb3Igb3RoZXIgYXJjaGl0ZWN0dXJlLQo+IHNwZWNpZmljIHJlZ2lzdGVycyBkdXJpbmcg cG9zdC1tb3J0ZW0gZGVidWdnaW5nLCBldmVuIHdoZW4gdGhlIGRhdGEgd2FzCj4gY29ycmVjdGx5 IGR1bXBlZC4KPiAKPiAjIyMjICoqQ29kZSBDaGFuZ2VzIEFuYWx5c2lzOioqCj4gCj4gKioxLiBm cy9iaW5mbXRfZWxmLmMgKGNvcmUgY2hhbmdlcyk6KioKPiAgICAtIExpbmVzIDEwNi0xMTk6IEFk ZHMgdHdvIGlubGluZSBoZWxwZXIgZnVuY3Rpb25zCj4gICAgICBgZWxmX2NvcmVkdW1wX3NldF9t bV9lZmxhZ3MoKWAgYW5kIGBlbGZfY29yZWR1bXBfZ2V0X21tX2VmbGFncygpYAo+ICAgICAgdGhh dCBhcmUgbm8tb3BzIHdoZW4gQ09ORklHX0FSQ0hfSEFTX0VMRl9DT1JFX0VGTEFHUyBpcyBkaXNh YmxlZAo+ICAgIC0gTGluZSAxMzA4OiBTYXZlcyBlX2ZsYWdzIGR1cmluZyBFTEYgYmluYXJ5IGxv YWRpbmc6Cj4gICAgICBgZWxmX2NvcmVkdW1wX3NldF9tbV9lZmxhZ3MobW0sIGVsZl9leC0+ZV9m bGFncylgCj4gICAgLSBMaW5lcyAxODI0LTE4NjY6IFJlZmFjdG9ycyBmaWxsX25vdGVfaW5mbygp IHRvIGV4dHJhY3QgbWFjaGluZSB0eXBlCj4gICAgICBhbmQgZmxhZ3MgaW50byBsb2NhbCB2YXJp YWJsZXMsIHRoZW4gb3ZlcnJpZGVzIGZsYWdzIHdpdGggc2F2ZWQKPiAgICAgIHZhbHVlIGlmIGFy Y2hpdGVjdHVyZSBvcHRlZCBpbgo+IAo+ICoqMi4gaW5jbHVkZS9saW51eC9tbV90eXBlcy5oOioq Cj4gICAgLSBBZGRzIGB1bnNpZ25lZCBsb25nIHNhdmVkX2VfZmxhZ3NgIGZpZWxkIHRvIG1tX3N0 cnVjdCwKPiAgICAgIGNvbmRpdGlvbmFsbHkgY29tcGlsZWQKPiAgICAtIEZpZWxkIHBsYWNlbWVu dCBpcyBsb2dpY2FsIChhZnRlciBzYXZlZF9hdXh2LCBhbm90aGVyIEVMRi1yZWxhdGVkCj4gICAg ICBmaWVsZCkKPiAgICAtIE1lbW9yeSBvdmVyaGVhZDogb25lIHVuc2lnbmVkIGxvbmcgKDggYnl0 ZXMgb24gNjQtYml0KSBwZXIKPiAgICAgIG1tX3N0cnVjdCwgb25seSBvbiBSSVNDLVYKPiAKPiAq KjMuIGZzL0tjb25maWcuYmluZm10OioqCj4gICAgLSBBZGRzIENPTkZJR19BUkNIX0hBU19FTEZf Q09SRV9FRkxBR1Mgb3B0aW9uCj4gICAgLSBEZXBlbmRzIG9uIEJJTkZNVF9FTEYgJiYgRUxGX0NP UkUKPiAgICAtIEFsbG93cyBhcmNoaXRlY3R1cmVzIHRvIG9wdC1pbiB0byBlX2ZsYWdzIHByZXNl cnZhdGlvbgo+IAo+ICoqNC4gYXJjaC9yaXNjdi9LY29uZmlnOioqCj4gICAgLSBFbmFibGVzIENP TkZJR19BUkNIX0hBU19FTEZfQ09SRV9FRkxBR1MgZm9yIFJJU0MtVgo+IAo+ICMjIyMgKipXaHkg VGhpcyBRdWFsaWZpZXMgZm9yIEJhY2twb3J0aW5nOioqCj4gCj4gKirinJMgSW1wb3J0YW50IEJ1 ZyBGaXg6KioKPiAtIEZpeGVzIHJlYWwgdXNlci1mYWNpbmcgcHJvYmxlbTogZGVidWdnaW5nIFJJ U0MtViBhcHBsaWNhdGlvbnMgd2l0aCBGUFUKPiAgIGlzIGJyb2tlbgo+IC0gQWZmZWN0cyBkZXZl bG9wZXJzIHdvcmtpbmcgb24gUklTQy1WIHBsYXRmb3Jtcwo+IC0gTm8gd29ya2Fyb3VuZCBhdmFp bGFibGUgKHRoZSBpbmZvcm1hdGlvbiBpcyBsb3N0IGluIGNvcmUgZHVtcHMpCj4gCj4gKirinJMg U21hbGwgYW5kIENvbnRhaW5lZDoqKgo+IC0gTmV0IGNoYW5nZTogNTUgaW5zZXJ0aW9ucywgNiBk ZWxldGlvbnMgYWNyb3NzIDQgZmlsZXMKPiAtIEFsbCBsb2dpYyBpcyBzaW1wbGUgc2F2ZS9yZXN0 b3JlIHBhdHRlcm4KPiAtIE5vIGNvbXBsZXggc3RhdGUgbWFuYWdlbWVudCBvciBzeW5jaHJvbml6 YXRpb24KPiAKPiAqKuKckyBNaW5pbWFsIFJlZ3Jlc3Npb24gUmlzazoqKgo+IC0gT3B0LWluIHZp YSBLY29uZmlnIC0gb3RoZXIgYXJjaGl0ZWN0dXJlcyBjb21wbGV0ZWx5IHVuYWZmZWN0ZWQKPiAt IFdoZW4gZGlzYWJsZWQ6IHplcm8gcnVudGltZSBvdmVyaGVhZCAoZnVuY3Rpb25zIGNvbXBpbGUg dG8gZW1wdHkKPiAgIGlubGluZSBzdHVicykKPiAtIFdoZW4gZW5hYmxlZDogdHJpdmlhbCBhc3Np Z25tZW50IG9wZXJhdGlvbnMgd2l0aCBubyBmYWlsdXJlIHBhdGhzCj4gLSBDaGFuZ2VzIGFyZSBp biB3ZWxsLWVzdGFibGlzaGVkIGNvZGUgcGF0aHMgKGxvYWRfZWxmX2JpbmFyeSwKPiAgIGZpbGxf bm90ZV9pbmZvKQo+IAo+ICoq4pyTIE5vIERlcGVuZGVuY2llczoqKgo+IC0gQXBwbGllcyBjbGVh bmx5IHRvIDYuMTcgdHJlZQo+IC0gTm8gcHJlcmVxdWlzaXRlIGNvbW1pdHMgcmVxdWlyZWQKPiAt IFRoZSBiYWNrcG9ydCBhbHNvIGluY2x1ZGVzIGE3MjhjZThmZmJkMjcgKHN0cnVjdF9zaXplKCkg cmVmYWN0b3JpbmcpCj4gICB3aGljaCBpcyBhIGNvbXBhdGlibGUgY2xlYW51cAo+IAo+ICoq4pyT IFN0YWJsZSBBZnRlciBNYWlubGluZToqKgo+IC0gQ29tbWl0dGVkIFNlcCAzLCAyMDI1ICgyNyBk YXlzIGluIG1haW5saW5lIGFzIG9mIFNlcCAzMCkKPiAtIE5vIGZpeGVzLCByZXZlcnRzLCBvciBy ZXBvcnRlZCBpc3N1ZXMKPiAtIGdpdCBsb2cgc2hvd3Mgbm8gZm9sbG93LXVwIGNvcnJlY3Rpb25z IG5lZWRlZAo+IAo+ICoq4pyTIE1haW50YWluZXIgQXBwcm92ZWQ6KioKPiAtIFNpZ25lZC1vZmYt Ynk6IEtlZXMgQ29vayAoZXhlY3ZlL2JpbmZtdCBtYWludGFpbmVyKQo+IC0gUHJvcGVyIHJldmll dyBwcm9jZXNzIHRocm91Z2ggbG9yZS5rZXJuZWwub3JnCj4gCj4gKirinJMgRm9sbG93cyBTdGFi bGUgS2VybmVsIFJ1bGVzOioqCj4gLSBSdWxlIDE6IE11c3QgYmUgb2J2aW91c2x5IGNvcnJlY3Qg YW5kIHRlc3RlZCDinJMKPiAtIFJ1bGUgMjogU2lnbmlmaWNhbnQgYnVnZml4IOKckwo+IC0gUnVs ZSAzOiBOb3QgbGFyZ2VyIHRoYW4gMTAwIGxpbmVzIOKckwo+IC0gUnVsZSA0OiBQYXRjaGVzIGNh bm5vdCBhZGQgZmVhdHVyZXMg4pyTIChmaXhlcyBleGlzdGluZyBmZWF0dXJlKQo+IC0gUnVsZSA1 OiBObyB0aGVvcmV0aWNhbCByYWNlIGNvbmRpdGlvbiBmaXhlcyDinJMgKGZpeGVzIGFjdHVhbCBH REIgaXNzdWUpCj4gCj4gIyMjIyAqKlRlY2huaWNhbCBDb3JyZWN0bmVzczoqKgo+IAo+ICoqRUxG X0NPUkVfRUZMQUdTIEhpc3RvcmljYWwgQ29udGV4dDoqKgo+IC0gVGhlIG1hY3JvIGhhcyBleGlz dGVkIHNpbmNlIDIwMDUgKExpbnVzJ3Mgb3JpZ2luYWwgZ2l0IGltcG9ydCkKPiAtIE9ubHkgSGV4 YWdvbiBhbmQgUG93ZXJQQyBkZWZpbmVkIG5vbi16ZXJvIHZhbHVlcwo+IC0gUklTQy1WJ3MgZV9m bGFncyB1c2FnZSBpcyBhcmNoaXRlY3R1cmFsbHkgY3JpdGljYWwgZm9yIEFCSQo+ICAgY29tcGF0 aWJpbGl0eQo+IC0gVGhlIG9sZCBhcHByb2FjaCAodXNpbmcgc3RhdGljIEVMRl9DT1JFX0VGTEFH Uz0wKSBsb3N0IHJ1bnRpbWUKPiAgIGluZm9ybWF0aW9uCj4gCj4gKipEZXNpZ24gUXVhbGl0eToq Kgo+IC0gQ2xlYW4gc2VwYXJhdGlvbjogQ09ORklHIG9wdGlvbiDihpIgbW1fc3RydWN0IGZpZWxk IOKGkiBoZWxwZXIgZnVuY3Rpb25zCj4gLSBCYWNrd2FyZCBjb21wYXRpYmxlOiBhcmNoaXRlY3R1 cmVzIHRoYXQgZG9uJ3QgbmVlZCBpdCBwYXkgemVybyBjb3N0Cj4gLSBGb3J3YXJkIGNvbXBhdGli bGU6IG90aGVyIGFyY2hpdGVjdHVyZXMgKEFSTSwgTUlQUykgY291bGQgYWRvcHQgdGhpcwo+ICAg aWYgbmVlZGVkCj4gLSBQcm9wZXIgYWJzdHJhY3Rpb24gdGhyb3VnaCBpbmxpbmUgaGVscGVycyBw cmV2ZW50cyAjaWZkZWYKPiAgIHByb2xpZmVyYXRpb24KPiAKPiAjIyMjICoqUG90ZW50aWFsIENv bmNlcm5zIEFkZHJlc3NlZDoqKgo+IAo+ICoqUTogSXMgbW1fc3RydWN0IHNpemUgaW5jcmVhc2Ug YWNjZXB0YWJsZT8qKgo+IEE6IFllcy4gT25lIHVuc2lnbmVkIGxvbmcgKDggYnl0ZXMpIHBlciBw cm9jZXNzIG9uIFJJU0MtViBvbmx5LAo+IG5lZ2xpZ2libGUgY29tcGFyZWQgdG8gdHlwaWNhbCBt bV9zdHJ1Y3Qgc2l6ZSAofjFLQispCj4gCj4gKipROiBXaHkgbm90IHVzZSByZWdzZXRfdmlldy0+ ZV9mbGFncz8qKgo+IEE6IFRoZSByZWdzZXRfdmlldyBzdHJ1Y3R1cmUgZG9lc24ndCBoYXZlIGFu IGVfZmxhZ3MgZmllbGQuIFRoZSBvbGQgY29kZQo+IGZlbGwgYmFjayB0byB0aGUgY29tcGlsZS10 aW1lIEVMRl9DT1JFX0VGTEFHUyBjb25zdGFudCwgbG9zaW5nIHRoZSBwZXItCj4gcHJvY2VzcyBy dW50aW1lIEFCSSBpbmZvcm1hdGlvbiBmcm9tIHRoZSBhY3R1YWwgRUxGIGJpbmFyeS4KPiAKPiAq KlE6IFRocmVhZCBzYWZldHkgY29uY2VybnM/KioKPiBBOiBOb25lLiBUaGUgZV9mbGFncyBhcmUg d3JpdHRlbiBvbmNlIGR1cmluZyBsb2FkX2VsZl9iaW5hcnkoKSBiZWZvcmUKPiBhbnkgdGhyZWFk cyBjYW4gYmUgY3JlYXRlZCwgYW5kIHJlYWQgZHVyaW5nIGNvcmUgZHVtcCB3aGVuIGFsbCB0aHJl YWRzCj4gYXJlIHN0b3BwZWQuCj4gCj4gKipROiBJcyB0aGlzIHRvbyByZWNlbnQgZm9yIGJhY2tw b3J0aW5nPyoqCj4gQTogV2hpbGUgMjcgZGF5cyBpcyByZWxhdGl2ZWx5IGZyZXNoLCB0aGUgY2hh bmdlIGlzIHNvIG1pbmltYWwgYW5kCj4gaXNvbGF0ZWQgdGhhdCB0aGUgcmlzayBpcyBuZWdsaWdp YmxlLiBUaGUgb3B0LWluIG5hdHVyZSBtZWFucwo+IHJlZ3Jlc3Npb25zIGNhbiBvbmx5IGFmZmVj dCBSSVNDLVYgdXNlcnMgd2hvIGV4cGxpY2l0bHkgZW5hYmxlCj4gY29yZWR1bXBzLgo+IAo+ICMj IyAqKkNvbmNsdXNpb246KioKPiAKPiBUaGlzIGNvbW1pdCBzaG91bGQgYmUgYmFja3BvcnRlZCBi ZWNhdXNlIGl0IGZpeGVzIGFuIGltcG9ydGFudCBkZWJ1Z2dpbmcKPiBpc3N1ZSBvbiBSSVNDLVYg d2l0aCBtaW5pbWFsIHJpc2suIFRoZSBjaGFuZ2UgaXMgc21hbGwsIHNlbGYtY29udGFpbmVkLAo+ IG9wdC1pbiwgYW5kIGhhcyBiZWVuIHN0YWJsZSBpbiBtYWlubGluZS4gSXQgbWVldHMgYWxsIHN0 YWJsZSBrZXJuZWwKPiBiYWNrcG9ydGluZyBjcml0ZXJpYSBhbmQgd2lsbCBzaWduaWZpY2FudGx5 IGltcHJvdmUgdGhlIGRlYnVnZ2luZwo+IGV4cGVyaWVuY2UgZm9yIFJJU0MtViBkZXZlbG9wZXJz IHdpdGhvdXQgaW1wYWN0aW5nIG90aGVyIGFyY2hpdGVjdHVyZXMuCj4gCj4gIGFyY2gvcmlzY3Yv S2NvbmZpZyAgICAgICB8ICAxICsKPiAgZnMvS2NvbmZpZy5iaW5mbXQgICAgICAgIHwgIDkgKysr KysrKysrCj4gIGZzL2JpbmZtdF9lbGYuYyAgICAgICAgICB8IDQwICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKystLS0tLS0KPiAgaW5jbHVkZS9saW51eC9tbV90eXBlcy5oIHwgIDUg KysrKysKPiAgNCBmaWxlcyBjaGFuZ2VkLCA0OSBpbnNlcnRpb25zKCspLCA2IGRlbGV0aW9ucygt KQo+IAo+IGRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L0tjb25maWcgYi9hcmNoL3Jpc2N2L0tjb25m aWcKPiBpbmRleCA1MWRjZDhlYWEyNDM1Li43NGRiMDU0YWExYjhiIDEwMDY0NAo+IC0tLSBhL2Fy Y2gvcmlzY3YvS2NvbmZpZwo+ICsrKyBiL2FyY2gvcmlzY3YvS2NvbmZpZwo+IEBAIC0yOCw2ICsy OCw3IEBAIGNvbmZpZyBSSVNDVgo+ICAJc2VsZWN0IEFSQ0hfSEFTX0RFQlVHX1ZJUlRVQUwgaWYg TU1VCj4gIAlzZWxlY3QgQVJDSF9IQVNfREVCVUdfVk1fUEdUQUJMRQo+ICAJc2VsZWN0IEFSQ0hf SEFTX0RFQlVHX1dYCj4gKwlzZWxlY3QgQVJDSF9IQVNfRUxGX0NPUkVfRUZMQUdTCj4gIAlzZWxl Y3QgQVJDSF9IQVNfRkFTVF9NVUxUSVBMSUVSCj4gIAlzZWxlY3QgQVJDSF9IQVNfRk9SVElGWV9T T1VSQ0UKPiAgCXNlbGVjdCBBUkNIX0hBU19HQ09WX1BST0ZJTEVfQUxMCj4gZGlmZiAtLWdpdCBh L2ZzL0tjb25maWcuYmluZm10IGIvZnMvS2NvbmZpZy5iaW5mbXQKPiBpbmRleCBiZDJmNTMwZTU3 NDA4Li4xOTQ5ZTI1Yzc3NDFiIDEwMDY0NAo+IC0tLSBhL2ZzL0tjb25maWcuYmluZm10Cj4gKysr IGIvZnMvS2NvbmZpZy5iaW5mbXQKPiBAQCAtMTg0LDQgKzE4NCwxMyBAQCBjb25maWcgRVhFQ19L VU5JVF9URVNUCj4gIAkgIFRoaXMgYnVpbGRzIHRoZSBleGVjIEtVbml0IHRlc3RzLCB3aGljaCB0 ZXN0cyBib3VuZGFyeSBjb25kaXRpb25zCj4gIAkgIG9mIHZhcmlvdXMgYXNwZWN0cyBvZiB0aGUg ZXhlYyBpbnRlcm5hbHMuCj4gIAo+ICtjb25maWcgQVJDSF9IQVNfRUxGX0NPUkVfRUZMQUdTCj4g Kwlib29sCj4gKwlkZXBlbmRzIG9uIEJJTkZNVF9FTEYgJiYgRUxGX0NPUkUKPiArCWRlZmF1bHQg bgo+ICsJaGVscAo+ICsJICBTZWxlY3QgdGhpcyBvcHRpb24gaWYgdGhlIGFyY2hpdGVjdHVyZSBt YWtlcyB1c2Ugb2YgdGhlIGVfZmxhZ3MKPiArCSAgZmllbGQgaW4gdGhlIEVMRiBoZWFkZXIgdG8g c3RvcmUgQUJJIG9yIG90aGVyIGFyY2hpdGVjdHVyZS1zcGVjaWZpYwo+ICsJICBpbmZvcm1hdGlv biB0aGF0IHNob3VsZCBiZSBwcmVzZXJ2ZWQgaW4gY29yZSBkdW1wcy4KPiArCj4gIGVuZG1lbnUK PiBkaWZmIC0tZ2l0IGEvZnMvYmluZm10X2VsZi5jIGIvZnMvYmluZm10X2VsZi5jCj4gaW5kZXgg MjY0ZmJhMGQ0NGJkZi4uYzEyNmUzZDBlNzAxOCAxMDA2NDQKPiAtLS0gYS9mcy9iaW5mbXRfZWxm LmMKPiArKysgYi9mcy9iaW5mbXRfZWxmLmMKPiBAQCAtMTAzLDYgKzEwMywyMSBAQCBzdGF0aWMg c3RydWN0IGxpbnV4X2JpbmZtdCBlbGZfZm9ybWF0ID0gewo+ICAKPiAgI2RlZmluZSBCQURfQURE Uih4KSAodW5saWtlbHkoKHVuc2lnbmVkIGxvbmcpKHgpID49IFRBU0tfU0laRSkpCj4gIAo+ICtz dGF0aWMgaW5saW5lIHZvaWQgZWxmX2NvcmVkdW1wX3NldF9tbV9lZmxhZ3Moc3RydWN0IG1tX3N0 cnVjdCAqbW0sIHUzMiBmbGFncykKPiArewo+ICsjaWZkZWYgQ09ORklHX0FSQ0hfSEFTX0VMRl9D T1JFX0VGTEFHUwo+ICsJbW0tPnNhdmVkX2VfZmxhZ3MgPSBmbGFnczsKPiArI2VuZGlmCj4gK30K PiArCj4gK3N0YXRpYyBpbmxpbmUgdTMyIGVsZl9jb3JlZHVtcF9nZXRfbW1fZWZsYWdzKHN0cnVj dCBtbV9zdHJ1Y3QgKm1tLCB1MzIgZmxhZ3MpCj4gK3sKPiArI2lmZGVmIENPTkZJR19BUkNIX0hB U19FTEZfQ09SRV9FRkxBR1MKPiArCWZsYWdzID0gbW0tPnNhdmVkX2VfZmxhZ3M7Cj4gKyNlbmRp Zgo+ICsJcmV0dXJuIGZsYWdzOwo+ICt9Cj4gKwo+ICAvKgo+ICAgKiBXZSBuZWVkIHRvIGV4cGxp Y2l0bHkgemVybyBhbnkgdHJhaWxpbmcgcG9ydGlvbiBvZiB0aGUgcGFnZSB0aGF0IGZvbGxvd3MK PiAgICogcF9maWxlc3ogd2hlbiBpdCBlbmRzIGJlZm9yZSB0aGUgcGFnZSBlbmRzIChlLmcuIGJz cyksIG90aGVyd2lzZSB0aGlzCj4gQEAgLTEyOTAsNiArMTMwNSw4IEBAIHN0YXRpYyBpbnQgbG9h ZF9lbGZfYmluYXJ5KHN0cnVjdCBsaW51eF9iaW5wcm0gKmJwcm0pCj4gIAltbS0+ZW5kX2RhdGEg PSBlbmRfZGF0YTsKPiAgCW1tLT5zdGFydF9zdGFjayA9IGJwcm0tPnA7Cj4gIAo+ICsJZWxmX2Nv cmVkdW1wX3NldF9tbV9lZmxhZ3MobW0sIGVsZl9leC0+ZV9mbGFncyk7Cj4gKwo+ICAJLyoqCj4g IAkgKiBET0M6ICJicmsiIGhhbmRsaW5nCj4gIAkgKgo+IEBAIC0xODA0LDYgKzE4MjEsOCBAQCBz dGF0aWMgaW50IGZpbGxfbm90ZV9pbmZvKHN0cnVjdCBlbGZoZHIgKmVsZiwgaW50IHBoZHJzLAo+ ICAJc3RydWN0IGVsZl90aHJlYWRfY29yZV9pbmZvICp0Owo+ICAJc3RydWN0IGVsZl9wcnBzaW5m byAqcHNpbmZvOwo+ICAJc3RydWN0IGNvcmVfdGhyZWFkICpjdDsKPiArCXUxNiBtYWNoaW5lOwo+ ICsJdTMyIGZsYWdzOwo+ICAKPiAgCXBzaW5mbyA9IGttYWxsb2Moc2l6ZW9mKCpwc2luZm8pLCBH RlBfS0VSTkVMKTsKPiAgCWlmICghcHNpbmZvKQo+IEBAIC0xODMxLDE3ICsxODUwLDI2IEBAIHN0 YXRpYyBpbnQgZmlsbF9ub3RlX2luZm8oc3RydWN0IGVsZmhkciAqZWxmLCBpbnQgcGhkcnMsCj4g IAkJcmV0dXJuIDA7Cj4gIAl9Cj4gIAo+IC0JLyoKPiAtCSAqIEluaXRpYWxpemUgdGhlIEVMRiBm aWxlIGhlYWRlci4KPiAtCSAqLwo+IC0JZmlsbF9lbGZfaGVhZGVyKGVsZiwgcGhkcnMsCj4gLQkJ CXZpZXctPmVfbWFjaGluZSwgdmlldy0+ZV9mbGFncyk7Cj4gKwltYWNoaW5lID0gdmlldy0+ZV9t YWNoaW5lOwo+ICsJZmxhZ3MgPSB2aWV3LT5lX2ZsYWdzOwo+ICAjZWxzZQo+ICAJdmlldyA9IE5V TEw7Cj4gIAlpbmZvLT50aHJlYWRfbm90ZXMgPSAyOwo+IC0JZmlsbF9lbGZfaGVhZGVyKGVsZiwg cGhkcnMsIEVMRl9BUkNILCBFTEZfQ09SRV9FRkxBR1MpOwo+ICsJbWFjaGluZSA9IEVMRl9BUkNI Owo+ICsJZmxhZ3MgPSBFTEZfQ09SRV9FRkxBR1M7Cj4gICNlbmRpZgo+ICAKPiArCS8qCj4gKwkg KiBPdmVycmlkZSBFTEYgZV9mbGFncyB3aXRoIHZhbHVlIHRha2VuIGZyb20gcHJvY2VzcywKPiAr CSAqIGlmIGFyY2ggbmVlZHMgdGhhdC4KPiArCSAqLwo+ICsJZmxhZ3MgPSBlbGZfY29yZWR1bXBf Z2V0X21tX2VmbGFncyhkdW1wX3Rhc2stPm1tLCBmbGFncyk7Cj4gKwo+ICsJLyoKPiArCSAqIElu aXRpYWxpemUgdGhlIEVMRiBmaWxlIGhlYWRlci4KPiArCSAqLwo+ICsJZmlsbF9lbGZfaGVhZGVy KGVsZiwgcGhkcnMsIG1hY2hpbmUsIGZsYWdzKTsKPiArCj4gIAkvKgo+ICAJICogQWxsb2NhdGUg YSBzdHJ1Y3R1cmUgZm9yIGVhY2ggdGhyZWFkLgo+ICAJICovCj4gZGlmZiAtLWdpdCBhL2luY2x1 ZGUvbGludXgvbW1fdHlwZXMuaCBiL2luY2x1ZGUvbGludXgvbW1fdHlwZXMuaAo+IGluZGV4IGE2 NDNmYWU4YTM0OTQuLjdmNjI1YzM1MTI4YmUgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9saW51eC9t bV90eXBlcy5oCj4gKysrIGIvaW5jbHVkZS9saW51eC9tbV90eXBlcy5oCj4gQEAgLTExMDcsNiAr MTEwNywxMSBAQCBzdHJ1Y3QgbW1fc3RydWN0IHsKPiAgCj4gIAkJdW5zaWduZWQgbG9uZyBzYXZl ZF9hdXh2W0FUX1ZFQ1RPUl9TSVpFXTsgLyogZm9yIC9wcm9jL1BJRC9hdXh2ICovCj4gIAo+ICsj aWZkZWYgQ09ORklHX0FSQ0hfSEFTX0VMRl9DT1JFX0VGTEFHUwo+ICsJCS8qIHRoZSBBQkktcmVs YXRlZCBmbGFncyBmcm9tIHRoZSBFTEYgaGVhZGVyLiBVc2VkIGZvciBjb3JlIGR1bXAgKi8KPiAr CQl1bnNpZ25lZCBsb25nIHNhdmVkX2VfZmxhZ3M7Cj4gKyNlbmRpZgo+ICsKPiAgCQlzdHJ1Y3Qg cGVyY3B1X2NvdW50ZXIgcnNzX3N0YXRbTlJfTU1fQ09VTlRFUlNdOwo+ICAKPiAgCQlzdHJ1Y3Qg bGludXhfYmluZm10ICpiaW5mbXQ7Cj4gLS0gCj4gMi41MS4wCj4gCgotLSAKS2VlcyBDb29rCgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1yaXNj diBtYWlsaW5nIGxpc3QKbGludXgtcmlzY3ZAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlz dHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJpc2N2Cg==