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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 48BB4C46467 for ; Tue, 3 Jan 2023 08:53:31 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232960AbjACIxa (ORCPT ); Tue, 3 Jan 2023 03:53:30 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59672 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229520AbjACIx3 (ORCPT ); Tue, 3 Jan 2023 03:53:29 -0500 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 73B4F6392; Tue, 3 Jan 2023 00:53:27 -0800 (PST) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 960714B3; Tue, 3 Jan 2023 00:54:08 -0800 (PST) Received: from FVFF77S0Q05N (unknown [10.57.37.13]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id E88793F663; Tue, 3 Jan 2023 00:53:21 -0800 (PST) Date: Tue, 3 Jan 2023 08:53:13 +0000 From: Mark Rutland To: Dan Li Cc: Masahiro Yamada , Michal Marek , Nick Desaulniers , Catalin Marinas , Will Deacon , Sami Tolvanen , Kees Cook , Nathan Chancellor , Tom Rix , Peter Zijlstra , "Paul E. McKenney" , Josh Poimboeuf , Frederic Weisbecker , "Eric W. Biederman" , Marco Elver , Christophe Leroy , Song Liu , Andrew Morton , Uros Bizjak , Kumar Kartikeya Dwivedi , Juergen Gross , Luis Chamberlain , Borislav Petkov , Masami Hiramatsu , Dmitry Torokhov , Aaron Tomlin , Kalesh Singh , Yuntao Wang , Changbin Du , linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, llvm@lists.linux.dev Subject: Re: [RFC/RFT] CFI: Add support for gcc CFI in aarch64 Message-ID: References: <20221219061758.23321-1-ashimida.1990@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20221219061758.23321-1-ashimida.1990@gmail.com> Precedence: bulk List-ID: X-Mailing-List: linux-kbuild@vger.kernel.org On Sun, Dec 18, 2022 at 10:17:58PM -0800, Dan Li wrote: > Based on Sami's patch[1], this patch makes the corresponding kernel > configuration of CFI available when compiling the kernel with the gcc[2]. > > The code after enabling cfi is as follows: > > int (*p)(void); > int func (int) > { > p(); > } > > __cfi_func: > .4byte 0x439d3502 > func: > ...... > adrp x0, p > add x0, x0, :lo12:p > mov w1, 23592 > movk w1, 0x4601, lsl 16 > cmp w0, w1 > beq .L2 > ...... > bl cfi_check_failed > .L2: > blr x19 > ret > > In the compiler part[4], there are some differences from Sami's > implementation[3], mainly including: > > 1. When a typeid mismatch is detected, the cfi_check_failed function > will be called instead of the brk instruction. This function needs > to be implemented by the compiler user. For arm64, we specifically wanted the BRK approach (with the information endoed into an immediate) because it gave us all the information we needed to diagnose the failed check, while giving the compiler freedom to perform the check however it wanted, and without needing to shuffle a bunch of registers (or having a weird calling convention for the cfi_check_failed handler). > If there are user mode programs or other systems that want to use > this feature, it may be more convenient to use a callback (so this > compilation option is set to -fsanitize=cfi instead of kcfi). I appreciate that may be nicer for userspace, but it would be far nicer for the kernel if we could have a kcfi mode that behaves the same as LLVM, using a BRK. That's going to be simpler for the kernel to deal with, and should result in nicer code / smaller binary size (for the reasons given above). Can we please have an LLVM-compatible KCFI mode, and have the -fsanitize=cfi be a separate option from -fsanitize=kcfi? > 2. A reserved typeid (such as 0x0U on the aarch64 platform) is always > inserted in front of functions that should not be called indirectly. > Functions that can be called indirectly will not use this hash value, > which prevents instructions/data before the function from being used > as a typeid by an attacker. That sounds sensible, though it meanse we'll need to go audit all the assembly without type annotations. I presume that "functions that should not be called indirectly" only includes those which are not directly visible outside the compilation unit AND whose address is never taken / escaped from the compilation unit. Is that the case? > 3. Some bits are ignored in the typeid to avoid conflicts between the > typeid and the instruction set of a specific platform, thereby > preventing an attacker from bypassing the CFI check by using the > instruction as a typeid, such as on the aarch64 platform: > * If the following instruction sequence exists: > 400620: a9be7bfd stp x29, x30, [sp, #-32]! > 400624: 910003fd mov x29, sp > 400628: f9000bf3 str x19, [sp, #16] > * If the expected typeid of the indirect call is exactly 0x910003fd, > the attacker can jump to the next instruction position of any > "mov x29,sp" instruction (such as 0x400628 here). Which bits exactly are ignored on arm64? e.g. are these encoded into UDF immediates? > 4. Insert a symbol __cfi_ before each function's typeid, > which may be helpful for fine-grained KASLR implementations (or not?). I can imagine this is useful, but I am not immediately sure. > 5. The current implementation of gcc only supports the aarch64 platform. > > This produces the following oops on CFI failure (generated using lkdtm): > > /kselftest_install/lkdtm # ./CFI_FORWARD_PROTO.sh > [ 74.856516] lkdtm: Performing direct entry CFI_FORWARD_PROTO > [ 74.856878] lkdtm: Calling matched prototype ... > [ 74.857011] lkdtm: Calling mismatched prototype ... > [ 74.857133] CFI failure at lkdtm_indirect_call+0x30/0x50 (target: lkdtm_increment_int+0x0/0x1c; expected type: 0xc59c68f1) > [ 74.858185] Kernel panic - not syncing: Oops - CFI > [ 74.859240] CPU: 0 PID: 129 Comm: cat Not tainted 6.0.0-rc4-00024-g32bf7f14f497-dirty #150 > [ 74.859481] Hardware name: linux,dummy-virt (DT) > [ 74.859795] Call trace: > [ 74.859959] dump_backtrace.part.0+0xcc/0xe0 > [ 74.860212] show_stack+0x18/0x5c > [ 74.860327] dump_stack_lvl+0x64/0x84 > [ 74.860398] dump_stack+0x18/0x38 > [ 74.860443] panic+0x170/0x36c > [ 74.860496] cfi_check_failed+0x38/0x44 > [ 74.860564] lkdtm_indirect_call+0x30/0x50 > [ 74.860614] lkdtm_CFI_FORWARD_PROTO+0x3c/0x6c > [ 74.860701] lkdtm_do_action+0x44/0x58 > [ 74.860764] direct_entry+0x148/0x160 > [ 74.860814] full_proxy_write+0x74/0xe0 > [ 74.860874] vfs_write+0xd8/0x2d0 > [ 74.860942] ksys_write+0x70/0x110 > [ 74.861000] __arm64_sys_write+0x1c/0x30 > [ 74.861067] invoke_syscall+0x5c/0x140 > [ 74.861117] el0_svc_common.constprop.0+0x44/0xf0 > [ 74.861190] do_el0_svc+0x2c/0xc0 > [ 74.861233] el0_svc+0x20/0x60 > [ 74.861287] el0t_64_sync_handler+0xf4/0x124 > [ 74.861340] el0t_64_sync+0x160/0x164 > [ 74.861782] SMP: stopping secondary CPUs > [ 74.862336] Kernel Offset: disabled > [ 74.862439] CPU features: 0x0000,00075024,699418af > [ 74.862799] Memory Limit: none > [ 74.863373] ---[ end Kernel panic - not syncing: Oops - CFI ]--- > > The gcc-related patches[4] are based on tag: releases/gcc-12.2.0. > > Any suggestion please let me know :). As a general thing, how does this work with -fpatchable-function-entry=M,N, where N is non-zero? We still need to fix that for LLVM, and it would be good to align on the same behaviour. Thanks, Mark. > > Thanks, Dan. > > [1] https://lore.kernel.org/all/20220908215504.3686827-1-samitolvanen@google.com/ > [2] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107048 > [3] https://reviews.llvm.org/D119296 > [4] https://lore.kernel.org/linux-hardening/20221219055431.22596-1-ashimida.1990@gmail.com/ > > Signed-off-by: Dan Li > --- > Makefile | 6 ++++++ > arch/Kconfig | 24 +++++++++++++++++++++++- > arch/arm64/Kconfig | 1 + > include/linux/cfi_types.h | 15 +++++++++++---- > include/linux/compiler-gcc.h | 4 ++++ > kernel/Makefile | 1 + > kernel/cfi.c | 23 +++++++++++++++++++++++ > scripts/kallsyms.c | 4 +++- > 8 files changed, 72 insertions(+), 6 deletions(-) > > diff --git a/Makefile b/Makefile > index 43e08c9f95e9..7c74dac57aa4 100644 > --- a/Makefile > +++ b/Makefile > @@ -926,6 +926,12 @@ KBUILD_CFLAGS += $(CC_FLAGS_CFI) > export CC_FLAGS_CFI > endif > > +ifdef CONFIG_CFI_GCC > +CC_FLAGS_CFI := -fsanitize=cfi > +KBUILD_CFLAGS += $(CC_FLAGS_CFI) > +export CC_FLAGS_CFI > +endif > + > ifdef CONFIG_DEBUG_FORCE_FUNCTION_ALIGN_64B > KBUILD_CFLAGS += -falign-functions=64 > endif > diff --git a/arch/Kconfig b/arch/Kconfig > index 1c1eca0c0019..8b43a9fd3b54 100644 > --- a/arch/Kconfig > +++ b/arch/Kconfig > @@ -756,9 +756,31 @@ config CFI_CLANG > > https://clang.llvm.org/docs/ControlFlowIntegrity.html > > +config ARCH_SUPPORTS_CFI_GCC > + bool > + help > + An architecture should select this option if it can support GCC's > + Control-Flow Integrity (CFI) checking. > + > +config CFI_GCC > + bool "Use GCC's Control Flow Integrity (CFI)" > + depends on ARCH_SUPPORTS_CFI_GCC > + depends on $(cc-option,-fsanitize=cfi) > + help > + This option enables GCC’s forward-edge Control Flow Integrity > + (CFI) checking, where the compiler injects a runtime check to each > + indirect function call to ensure the target is a valid function with > + the correct static type. This restricts possible call targets and > + makes it more difficult for an attacker to exploit bugs that allow > + the modification of stored function pointers. More information can be > + found from the compiler's documentation: > + > + - Clang: https://clang.llvm.org/docs/ControlFlowIntegrity.html > + - GCC: https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html#Instrumentation-Options > + > config CFI_PERMISSIVE > bool "Use CFI in permissive mode" > - depends on CFI_CLANG > + depends on CFI_CLANG || CFI_GCC > help > When selected, Control Flow Integrity (CFI) violations result in a > warning instead of a kernel panic. This option should only be used > diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig > index 9fb9fff08c94..60fdfb01cecb 100644 > --- a/arch/arm64/Kconfig > +++ b/arch/arm64/Kconfig > @@ -89,6 +89,7 @@ config ARM64 > select ARCH_SUPPORTS_LTO_CLANG if CPU_LITTLE_ENDIAN > select ARCH_SUPPORTS_LTO_CLANG_THIN > select ARCH_SUPPORTS_CFI_CLANG > + select ARCH_SUPPORTS_CFI_GCC > select ARCH_SUPPORTS_ATOMIC_RMW > select ARCH_SUPPORTS_INT128 if CC_HAS_INT128 > select ARCH_SUPPORTS_NUMA_BALANCING > diff --git a/include/linux/cfi_types.h b/include/linux/cfi_types.h > index 6b8713675765..1c3b7ea6a79f 100644 > --- a/include/linux/cfi_types.h > +++ b/include/linux/cfi_types.h > @@ -8,18 +8,25 @@ > #ifdef __ASSEMBLY__ > #include > > -#ifdef CONFIG_CFI_CLANG > +#if defined(CONFIG_CFI_CLANG) || defined(CONFIG_CFI_GCC) > /* > - * Use the __kcfi_typeid_ type identifier symbol to > + * Use the __[k]cfi_typeid_ type identifier symbol to > * annotate indirectly called assembly functions. The compiler emits > * these symbols for all address-taken function declarations in C > * code. > */ > #ifndef __CFI_TYPE > + > +#ifdef CONFIG_CFI_GCC > +#define __CFI_TYPE(name) \ > + .4byte __cfi_typeid_##name > +#else > #define __CFI_TYPE(name) \ > .4byte __kcfi_typeid_##name > #endif > > +#endif > + > #define SYM_TYPED_ENTRY(name, linkage, align...) \ > linkage(name) ASM_NL \ > align ASM_NL \ > @@ -29,12 +36,12 @@ > #define SYM_TYPED_START(name, linkage, align...) \ > SYM_TYPED_ENTRY(name, linkage, align) > > -#else /* CONFIG_CFI_CLANG */ > +#else /* defined(CONFIG_CFI_CLANG) || defined(CONFIG_CFI_GCC) */ > > #define SYM_TYPED_START(name, linkage, align...) \ > SYM_START(name, linkage, align) > > -#endif /* CONFIG_CFI_CLANG */ > +#endif /* defined(CONFIG_CFI_CLANG) || defined(CONFIG_CFI_GCC) */ > > #ifndef SYM_TYPED_FUNC_START > #define SYM_TYPED_FUNC_START(name) \ > diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h > index 9b157b71036f..aec1ce327b1a 100644 > --- a/include/linux/compiler-gcc.h > +++ b/include/linux/compiler-gcc.h > @@ -82,6 +82,10 @@ > #define __noscs __attribute__((__no_sanitize__("shadow-call-stack"))) > #endif > > +#ifdef CONFIG_CFI_GCC > +#define __nocfi __attribute__((no_sanitize("cfi"))) > +#endif > + > #if __has_attribute(__no_sanitize_address__) > #define __no_sanitize_address __attribute__((no_sanitize_address)) > #else > diff --git a/kernel/Makefile b/kernel/Makefile > index 318789c728d3..923d3e060852 100644 > --- a/kernel/Makefile > +++ b/kernel/Makefile > @@ -114,6 +114,7 @@ obj-$(CONFIG_SHADOW_CALL_STACK) += scs.o > obj-$(CONFIG_HAVE_STATIC_CALL) += static_call.o > obj-$(CONFIG_HAVE_STATIC_CALL_INLINE) += static_call_inline.o > obj-$(CONFIG_CFI_CLANG) += cfi.o > +obj-$(CONFIG_CFI_GCC) += cfi.o > > obj-$(CONFIG_PERF_EVENTS) += events/ > > diff --git a/kernel/cfi.c b/kernel/cfi.c > index 08caad776717..9bff35736756 100644 > --- a/kernel/cfi.c > +++ b/kernel/cfi.c > @@ -25,6 +25,7 @@ enum bug_trap_type report_cfi_failure(struct pt_regs *regs, unsigned long addr, > return BUG_TRAP_TYPE_BUG; > } > > +#ifdef CONFIG_CFI_CLANG > #ifdef CONFIG_ARCH_USES_CFI_TRAPS > static inline unsigned long trap_address(s32 *p) > { > @@ -99,3 +100,25 @@ bool is_cfi_trap(unsigned long addr) > return is_module_cfi_trap(addr); > } > #endif /* CONFIG_ARCH_USES_CFI_TRAPS */ > +#endif /* CONFIG_CFI_CLANG */ > + > + > +#ifdef CONFIG_CFI_GCC > +void cfi_check_failed(u32 caller_hash, u32 callee_hash, void *callee_addr) > +{ > + unsigned long pc, target; > + > + pc = (unsigned long)__builtin_return_address(0); > + target = (unsigned long)callee_addr; > + > + switch (report_cfi_failure(NULL, pc, &target, caller_hash)) { > + case BUG_TRAP_TYPE_WARN: > + break; > + > + default: > + panic("Oops - CFI"); > + } > +} > +EXPORT_SYMBOL(cfi_check_failed); > + > +#endif /* CONFIG_CFI_GCC */ > diff --git a/scripts/kallsyms.c b/scripts/kallsyms.c > index ccdf0c897f31..ed8db513b918 100644 > --- a/scripts/kallsyms.c > +++ b/scripts/kallsyms.c > @@ -119,7 +119,9 @@ static bool is_ignored_symbol(const char *name, char type) > "__ThumbV7PILongThunk_", > "__LA25Thunk_", /* mips lld */ > "__microLA25Thunk_", > - "__kcfi_typeid_", /* CFI type identifiers */ > + "__kcfi_typeid_", /* CFI type identifiers in Clang */ > + "__cfi_", /* CFI type identifiers in GCC */ > + "__pi___cfi", /* CFI type identifiers in GCC */ > NULL > }; > > -- > 2.17.1 > 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 E86FEC4708E for ; Tue, 3 Jan 2023 13:29:14 +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=NesYKd8cC2RORiB2wdBerUgVUWGuq5iR6PFo7ItnxZQ=; b=a+grNoYOwibpMs ymphL1ZAxvJdA0K4tTAD71pbJMHxEzHRWhUBuT/lP6Fs5kSubetsIpKmR5Bapf7o8kBCEExKLqPCz +oKnna4vuSGzNdU6Rb/G10Ph9z4qAYUzNh7sPgpj/KcpBrqhKQ5k8uqDdg5UqjZv5YBNblEXgD10G AQMLZMLC8C/t8kY9DFTiD1YF8WjKZka6keVxMLGSprn1rZSi+MpNCXkGj8yXvtUZF2WQkIX28F1Ve 8Pa4/CLd+5/6i+1RNp4UuCJeQwyEPyRccvgMU8+8+qIE+/+sNx48Zi+rAqI1AWmkyaS7pwtKBgSbH mRDrKXmjGvCyvzB98/eQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1pChKI-001XDQ-1q; Tue, 03 Jan 2023 13:27:34 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1pCd3B-000N1I-4A for linux-arm-kernel@lists.infradead.org; Tue, 03 Jan 2023 08:53:45 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 960714B3; Tue, 3 Jan 2023 00:54:08 -0800 (PST) Received: from FVFF77S0Q05N (unknown [10.57.37.13]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id E88793F663; Tue, 3 Jan 2023 00:53:21 -0800 (PST) Date: Tue, 3 Jan 2023 08:53:13 +0000 From: Mark Rutland To: Dan Li Cc: Masahiro Yamada , Michal Marek , Nick Desaulniers , Catalin Marinas , Will Deacon , Sami Tolvanen , Kees Cook , Nathan Chancellor , Tom Rix , Peter Zijlstra , "Paul E. McKenney" , Josh Poimboeuf , Frederic Weisbecker , "Eric W. Biederman" , Marco Elver , Christophe Leroy , Song Liu , Andrew Morton , Uros Bizjak , Kumar Kartikeya Dwivedi , Juergen Gross , Luis Chamberlain , Borislav Petkov , Masami Hiramatsu , Dmitry Torokhov , Aaron Tomlin , Kalesh Singh , Yuntao Wang , Changbin Du , linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, llvm@lists.linux.dev Subject: Re: [RFC/RFT] CFI: Add support for gcc CFI in aarch64 Message-ID: References: <20221219061758.23321-1-ashimida.1990@gmail.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20221219061758.23321-1-ashimida.1990@gmail.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20230103_005339_749409_E46F7A8F X-CRM114-Status: GOOD ( 54.73 ) X-BeenThere: linux-arm-kernel@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-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org T24gU3VuLCBEZWMgMTgsIDIwMjIgYXQgMTA6MTc6NThQTSAtMDgwMCwgRGFuIExpIHdyb3RlOgo+ IEJhc2VkIG9uIFNhbWkncyBwYXRjaFsxXSwgdGhpcyBwYXRjaCBtYWtlcyB0aGUgY29ycmVzcG9u ZGluZyBrZXJuZWwKPiBjb25maWd1cmF0aW9uIG9mIENGSSBhdmFpbGFibGUgd2hlbiBjb21waWxp bmcgdGhlIGtlcm5lbCB3aXRoIHRoZSBnY2NbMl0uCj4gCj4gVGhlIGNvZGUgYWZ0ZXIgZW5hYmxp bmcgY2ZpIGlzIGFzIGZvbGxvd3M6Cj4gCj4gaW50ICgqcCkodm9pZCk7Cj4gaW50IGZ1bmMgKGlu dCkKPiB7Cj4gCXAoKTsKPiB9Cj4gCj4gX19jZmlfZnVuYzoKPiAgICAgICAgIC40Ynl0ZSAweDQz OWQzNTAyCj4gZnVuYzoKPiAgICAgICAgIC4uLi4uLgo+ICAgICAgICAgYWRycCAgICB4MCwgcAo+ ICAgICAgICAgYWRkICAgICB4MCwgeDAsIDpsbzEyOnAKPiAgICAgICAgIG1vdiAgICAgdzEsIDIz NTkyCj4gICAgICAgICBtb3ZrICAgIHcxLCAweDQ2MDEsIGxzbCAxNgo+ICAgICAgICAgY21wICAg ICB3MCwgdzEKPiAgICAgICAgIGJlcSAgICAgLkwyCj4gICAgICAgICAuLi4uLi4KPiAgICAgICAg IGJsICAgICAgY2ZpX2NoZWNrX2ZhaWxlZAo+IC5MMjoKPiAgICAgICAgIGJsciAgICAgeDE5Cj4g ICAgICAgICByZXQKPiAKPiBJbiB0aGUgY29tcGlsZXIgcGFydFs0XSwgdGhlcmUgYXJlIHNvbWUg ZGlmZmVyZW5jZXMgZnJvbSBTYW1pJ3MKPiBpbXBsZW1lbnRhdGlvblszXSwgbWFpbmx5IGluY2x1 ZGluZzoKPiAKPiAxLiBXaGVuIGEgdHlwZWlkIG1pc21hdGNoIGlzIGRldGVjdGVkLCB0aGUgY2Zp X2NoZWNrX2ZhaWxlZCBmdW5jdGlvbgo+ICAgIHdpbGwgYmUgY2FsbGVkIGluc3RlYWQgb2YgdGhl IGJyayBpbnN0cnVjdGlvbi4gVGhpcyBmdW5jdGlvbiBuZWVkcwo+ICAgIHRvIGJlIGltcGxlbWVu dGVkIGJ5IHRoZSBjb21waWxlciB1c2VyLgoKRm9yIGFybTY0LCB3ZSBzcGVjaWZpY2FsbHkgd2Fu dGVkIHRoZSBCUksgYXBwcm9hY2ggKHdpdGggdGhlIGluZm9ybWF0aW9uIGVuZG9lZAppbnRvIGFu IGltbWVkaWF0ZSkgYmVjYXVzZSBpdCBnYXZlIHVzIGFsbCB0aGUgaW5mb3JtYXRpb24gd2UgbmVl ZGVkIHRvIGRpYWdub3NlCnRoZSBmYWlsZWQgY2hlY2ssIHdoaWxlIGdpdmluZyB0aGUgY29tcGls ZXIgZnJlZWRvbSB0byBwZXJmb3JtIHRoZSBjaGVjawpob3dldmVyIGl0IHdhbnRlZCwgYW5kIHdp dGhvdXQgbmVlZGluZyB0byBzaHVmZmxlIGEgYnVuY2ggb2YgcmVnaXN0ZXJzIChvcgpoYXZpbmcg YSB3ZWlyZCBjYWxsaW5nIGNvbnZlbnRpb24gZm9yIHRoZSBjZmlfY2hlY2tfZmFpbGVkIGhhbmRs ZXIpLgoKPiAgICBJZiB0aGVyZSBhcmUgdXNlciBtb2RlIHByb2dyYW1zIG9yIG90aGVyIHN5c3Rl bXMgdGhhdCB3YW50IHRvIHVzZQo+ICAgIHRoaXMgZmVhdHVyZSwgaXQgbWF5IGJlIG1vcmUgY29u dmVuaWVudCB0byB1c2UgYSBjYWxsYmFjayAoc28gdGhpcwo+ICAgIGNvbXBpbGF0aW9uIG9wdGlv biBpcyBzZXQgdG8gLWZzYW5pdGl6ZT1jZmkgaW5zdGVhZCBvZiBrY2ZpKS4KCkkgYXBwcmVjaWF0 ZSB0aGF0IG1heSBiZSBuaWNlciBmb3IgdXNlcnNwYWNlLCBidXQgaXQgd291bGQgYmUgZmFyIG5p Y2VyIGZvciB0aGUKa2VybmVsIGlmIHdlIGNvdWxkIGhhdmUgYSBrY2ZpIG1vZGUgdGhhdCBiZWhh dmVzIHRoZSBzYW1lIGFzIExMVk0sIHVzaW5nIGEgQlJLLgpUaGF0J3MgZ29pbmcgdG8gYmUgc2lt cGxlciBmb3IgdGhlIGtlcm5lbCB0byBkZWFsIHdpdGgsIGFuZCBzaG91bGQgcmVzdWx0IGluCm5p Y2VyIGNvZGUgLyBzbWFsbGVyIGJpbmFyeSBzaXplIChmb3IgdGhlIHJlYXNvbnMgZ2l2ZW4gYWJv dmUpLgoKQ2FuIHdlIHBsZWFzZSBoYXZlIGFuIExMVk0tY29tcGF0aWJsZSBLQ0ZJIG1vZGUsIGFu ZCBoYXZlIHRoZSAtZnNhbml0aXplPWNmaSBiZQphIHNlcGFyYXRlIG9wdGlvbiBmcm9tIC1mc2Fu aXRpemU9a2NmaT8KCj4gMi4gQSByZXNlcnZlZCB0eXBlaWQgKHN1Y2ggYXMgMHgwVSBvbiB0aGUg YWFyY2g2NCBwbGF0Zm9ybSkgaXMgYWx3YXlzCj4gICAgaW5zZXJ0ZWQgaW4gZnJvbnQgb2YgZnVu Y3Rpb25zIHRoYXQgc2hvdWxkIG5vdCBiZSBjYWxsZWQgaW5kaXJlY3RseS4KPiAgICBGdW5jdGlv bnMgdGhhdCBjYW4gYmUgY2FsbGVkIGluZGlyZWN0bHkgd2lsbCBub3QgdXNlIHRoaXMgaGFzaCB2 YWx1ZSwKPiAgICB3aGljaCBwcmV2ZW50cyBpbnN0cnVjdGlvbnMvZGF0YSBiZWZvcmUgdGhlIGZ1 bmN0aW9uIGZyb20gYmVpbmcgdXNlZAo+ICAgIGFzIGEgdHlwZWlkIGJ5IGFuIGF0dGFja2VyLgoK VGhhdCBzb3VuZHMgc2Vuc2libGUsIHRob3VnaCBpdCBtZWFuc2Ugd2UnbGwgbmVlZCB0byBnbyBh dWRpdCBhbGwgdGhlIGFzc2VtYmx5CndpdGhvdXQgdHlwZSBhbm5vdGF0aW9ucy4KCkkgcHJlc3Vt ZSB0aGF0ICJmdW5jdGlvbnMgdGhhdCBzaG91bGQgbm90IGJlIGNhbGxlZCBpbmRpcmVjdGx5IiBv bmx5IGluY2x1ZGVzCnRob3NlIHdoaWNoIGFyZSBub3QgZGlyZWN0bHkgdmlzaWJsZSBvdXRzaWRl IHRoZSBjb21waWxhdGlvbiB1bml0IEFORCB3aG9zZQphZGRyZXNzIGlzIG5ldmVyIHRha2VuIC8g ZXNjYXBlZCBmcm9tIHRoZSBjb21waWxhdGlvbiB1bml0LiBJcyB0aGF0IHRoZSBjYXNlPwoKPiAz LiBTb21lIGJpdHMgYXJlIGlnbm9yZWQgaW4gdGhlIHR5cGVpZCB0byBhdm9pZCBjb25mbGljdHMg YmV0d2VlbiB0aGUKPiAgICB0eXBlaWQgYW5kIHRoZSBpbnN0cnVjdGlvbiBzZXQgb2YgYSBzcGVj aWZpYyBwbGF0Zm9ybSwgdGhlcmVieQo+ICAgIHByZXZlbnRpbmcgYW4gYXR0YWNrZXIgZnJvbSBi eXBhc3NpbmcgdGhlIENGSSBjaGVjayBieSB1c2luZyB0aGUKPiAgICBpbnN0cnVjdGlvbiBhcyBh IHR5cGVpZCwgc3VjaCBhcyBvbiB0aGUgYWFyY2g2NCBwbGF0Zm9ybToKPiAgICAqIElmIHRoZSBm b2xsb3dpbmcgaW5zdHJ1Y3Rpb24gc2VxdWVuY2UgZXhpc3RzOgo+IAkgIDQwMDYyMDogICAgICAg YTliZTdiZmQgICAgICAgIHN0cCAgICAgeDI5LCB4MzAsIFtzcCwgIy0zMl0hCj4gCSAgNDAwNjI0 OiAgICAgICA5MTAwMDNmZCAgICAgICAgbW92ICAgICB4MjksIHNwCj4gCSAgNDAwNjI4OiAgICAg ICBmOTAwMGJmMyAgICAgICAgc3RyICAgICB4MTksIFtzcCwgIzE2XQo+ICAgICogSWYgdGhlIGV4 cGVjdGVkIHR5cGVpZCBvZiB0aGUgaW5kaXJlY3QgY2FsbCBpcyBleGFjdGx5IDB4OTEwMDAzZmQs Cj4gICAgICB0aGUgYXR0YWNrZXIgY2FuIGp1bXAgdG8gdGhlIG5leHQgaW5zdHJ1Y3Rpb24gcG9z aXRpb24gb2YgYW55Cj4gICAgICAibW92IHgyOSxzcCIgaW5zdHJ1Y3Rpb24gKHN1Y2ggYXMgMHg0 MDA2MjggaGVyZSkuCgpXaGljaCBiaXRzIGV4YWN0bHkgYXJlIGlnbm9yZWQgb24gYXJtNjQ/Cgpl LmcuIGFyZSB0aGVzZSBlbmNvZGVkIGludG8gVURGIGltbWVkaWF0ZXM/Cgo+IDQuIEluc2VydCBh IHN5bWJvbCBfX2NmaV88ZnVuY3Rpb24+IGJlZm9yZSBlYWNoIGZ1bmN0aW9uJ3MgdHlwZWlkLAo+ ICAgIHdoaWNoIG1heSBiZSBoZWxwZnVsIGZvciBmaW5lLWdyYWluZWQgS0FTTFIgaW1wbGVtZW50 YXRpb25zIChvciBub3Q/KS4KCkkgY2FuIGltYWdpbmUgdGhpcyBpcyB1c2VmdWwsIGJ1dCBJIGFt IG5vdCBpbW1lZGlhdGVseSBzdXJlLgoKPiA1LiBUaGUgY3VycmVudCBpbXBsZW1lbnRhdGlvbiBv ZiBnY2Mgb25seSBzdXBwb3J0cyB0aGUgYWFyY2g2NCBwbGF0Zm9ybS4KPiAKPiBUaGlzIHByb2R1 Y2VzIHRoZSBmb2xsb3dpbmcgb29wcyBvbiBDRkkgZmFpbHVyZSAoZ2VuZXJhdGVkIHVzaW5nIGxr ZHRtKToKPiAKPiAva3NlbGZ0ZXN0X2luc3RhbGwvbGtkdG0gIyAuL0NGSV9GT1JXQVJEX1BST1RP LnNoCj4gWyAgIDc0Ljg1NjUxNl0gbGtkdG06IFBlcmZvcm1pbmcgZGlyZWN0IGVudHJ5IENGSV9G T1JXQVJEX1BST1RPCj4gWyAgIDc0Ljg1Njg3OF0gbGtkdG06IENhbGxpbmcgbWF0Y2hlZCBwcm90 b3R5cGUgLi4uCj4gWyAgIDc0Ljg1NzAxMV0gbGtkdG06IENhbGxpbmcgbWlzbWF0Y2hlZCBwcm90 b3R5cGUgLi4uCj4gWyAgIDc0Ljg1NzEzM10gQ0ZJIGZhaWx1cmUgYXQgbGtkdG1faW5kaXJlY3Rf Y2FsbCsweDMwLzB4NTAgKHRhcmdldDogbGtkdG1faW5jcmVtZW50X2ludCsweDAvMHgxYzsgZXhw ZWN0ZWQgdHlwZTogMHhjNTljNjhmMSkKPiBbICAgNzQuODU4MTg1XSBLZXJuZWwgcGFuaWMgLSBu b3Qgc3luY2luZzogT29wcyAtIENGSQo+IFsgICA3NC44NTkyNDBdIENQVTogMCBQSUQ6IDEyOSBD b21tOiBjYXQgTm90IHRhaW50ZWQgNi4wLjAtcmM0LTAwMDI0LWczMmJmN2YxNGY0OTctZGlydHkg IzE1MAo+IFsgICA3NC44NTk0ODFdIEhhcmR3YXJlIG5hbWU6IGxpbnV4LGR1bW15LXZpcnQgKERU KQo+IFsgICA3NC44NTk3OTVdIENhbGwgdHJhY2U6Cj4gWyAgIDc0Ljg1OTk1OV0gIGR1bXBfYmFj a3RyYWNlLnBhcnQuMCsweGNjLzB4ZTAKPiBbICAgNzQuODYwMjEyXSAgc2hvd19zdGFjaysweDE4 LzB4NWMKPiBbICAgNzQuODYwMzI3XSAgZHVtcF9zdGFja19sdmwrMHg2NC8weDg0Cj4gWyAgIDc0 Ljg2MDM5OF0gIGR1bXBfc3RhY2srMHgxOC8weDM4Cj4gWyAgIDc0Ljg2MDQ0M10gIHBhbmljKzB4 MTcwLzB4MzZjCj4gWyAgIDc0Ljg2MDQ5Nl0gIGNmaV9jaGVja19mYWlsZWQrMHgzOC8weDQ0Cj4g WyAgIDc0Ljg2MDU2NF0gIGxrZHRtX2luZGlyZWN0X2NhbGwrMHgzMC8weDUwCj4gWyAgIDc0Ljg2 MDYxNF0gIGxrZHRtX0NGSV9GT1JXQVJEX1BST1RPKzB4M2MvMHg2Ywo+IFsgICA3NC44NjA3MDFd ICBsa2R0bV9kb19hY3Rpb24rMHg0NC8weDU4Cj4gWyAgIDc0Ljg2MDc2NF0gIGRpcmVjdF9lbnRy eSsweDE0OC8weDE2MAo+IFsgICA3NC44NjA4MTRdICBmdWxsX3Byb3h5X3dyaXRlKzB4NzQvMHhl MAo+IFsgICA3NC44NjA4NzRdICB2ZnNfd3JpdGUrMHhkOC8weDJkMAo+IFsgICA3NC44NjA5NDJd ICBrc3lzX3dyaXRlKzB4NzAvMHgxMTAKPiBbICAgNzQuODYxMDAwXSAgX19hcm02NF9zeXNfd3Jp dGUrMHgxYy8weDMwCj4gWyAgIDc0Ljg2MTA2N10gIGludm9rZV9zeXNjYWxsKzB4NWMvMHgxNDAK PiBbICAgNzQuODYxMTE3XSAgZWwwX3N2Y19jb21tb24uY29uc3Rwcm9wLjArMHg0NC8weGYwCj4g WyAgIDc0Ljg2MTE5MF0gIGRvX2VsMF9zdmMrMHgyYy8weGMwCj4gWyAgIDc0Ljg2MTIzM10gIGVs MF9zdmMrMHgyMC8weDYwCj4gWyAgIDc0Ljg2MTI4N10gIGVsMHRfNjRfc3luY19oYW5kbGVyKzB4 ZjQvMHgxMjQKPiBbICAgNzQuODYxMzQwXSAgZWwwdF82NF9zeW5jKzB4MTYwLzB4MTY0Cj4gWyAg IDc0Ljg2MTc4Ml0gU01QOiBzdG9wcGluZyBzZWNvbmRhcnkgQ1BVcwo+IFsgICA3NC44NjIzMzZd IEtlcm5lbCBPZmZzZXQ6IGRpc2FibGVkCj4gWyAgIDc0Ljg2MjQzOV0gQ1BVIGZlYXR1cmVzOiAw eDAwMDAsMDAwNzUwMjQsNjk5NDE4YWYKPiBbICAgNzQuODYyNzk5XSBNZW1vcnkgTGltaXQ6IG5v bmUKPiBbICAgNzQuODYzMzczXSAtLS1bIGVuZCBLZXJuZWwgcGFuaWMgLSBub3Qgc3luY2luZzog T29wcyAtIENGSSBdLS0tCj4gCj4gVGhlIGdjYy1yZWxhdGVkIHBhdGNoZXNbNF0gYXJlIGJhc2Vk IG9uIHRhZzogcmVsZWFzZXMvZ2NjLTEyLjIuMC4KPiAKPiBBbnkgc3VnZ2VzdGlvbiBwbGVhc2Ug bGV0IG1lIGtub3cgOikuCgpBcyBhIGdlbmVyYWwgdGhpbmcsIGhvdyBkb2VzIHRoaXMgd29yayB3 aXRoIC1mcGF0Y2hhYmxlLWZ1bmN0aW9uLWVudHJ5PU0sTiwKd2hlcmUgTiBpcyBub24temVybz8K CldlIHN0aWxsIG5lZWQgdG8gZml4IHRoYXQgZm9yIExMVk0sIGFuZCBpdCB3b3VsZCBiZSBnb29k IHRvIGFsaWduIG9uIHRoZSBzYW1lIGJlaGF2aW91ci4KClRoYW5rcywKTWFyay4KCj4gCj4gVGhh bmtzLCBEYW4uCj4gCj4gWzFdIGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL2FsbC8yMDIyMDkwODIx NTUwNC4zNjg2ODI3LTEtc2FtaXRvbHZhbmVuQGdvb2dsZS5jb20vCj4gWzJdIGh0dHBzOi8vZ2Nj LmdudS5vcmcvYnVnemlsbGEvc2hvd19idWcuY2dpP2lkPTEwNzA0OAo+IFszXSBodHRwczovL3Jl dmlld3MubGx2bS5vcmcvRDExOTI5Ngo+IFs0XSBodHRwczovL2xvcmUua2VybmVsLm9yZy9saW51 eC1oYXJkZW5pbmcvMjAyMjEyMTkwNTU0MzEuMjI1OTYtMS1hc2hpbWlkYS4xOTkwQGdtYWlsLmNv bS8KPiAKPiBTaWduZWQtb2ZmLWJ5OiBEYW4gTGkgPGFzaGltaWRhLjE5OTBAZ21haWwuY29tPgo+ IC0tLQo+ICBNYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgIHwgIDYgKysrKysrCj4gIGFyY2gv S2NvbmZpZyAgICAgICAgICAgICAgICAgfCAyNCArKysrKysrKysrKysrKysrKysrKysrKy0KPiAg YXJjaC9hcm02NC9LY29uZmlnICAgICAgICAgICB8ICAxICsKPiAgaW5jbHVkZS9saW51eC9jZmlf dHlwZXMuaCAgICB8IDE1ICsrKysrKysrKysrLS0tLQo+ICBpbmNsdWRlL2xpbnV4L2NvbXBpbGVy LWdjYy5oIHwgIDQgKysrKwo+ICBrZXJuZWwvTWFrZWZpbGUgICAgICAgICAgICAgIHwgIDEgKwo+ ICBrZXJuZWwvY2ZpLmMgICAgICAgICAgICAgICAgIHwgMjMgKysrKysrKysrKysrKysrKysrKysr KysKPiAgc2NyaXB0cy9rYWxsc3ltcy5jICAgICAgICAgICB8ICA0ICsrKy0KPiAgOCBmaWxlcyBj aGFuZ2VkLCA3MiBpbnNlcnRpb25zKCspLCA2IGRlbGV0aW9ucygtKQo+IAo+IGRpZmYgLS1naXQg YS9NYWtlZmlsZSBiL01ha2VmaWxlCj4gaW5kZXggNDNlMDhjOWY5NWU5Li43Yzc0ZGFjNTdhYTQg MTAwNjQ0Cj4gLS0tIGEvTWFrZWZpbGUKPiArKysgYi9NYWtlZmlsZQo+IEBAIC05MjYsNiArOTI2 LDEyIEBAIEtCVUlMRF9DRkxBR1MJKz0gJChDQ19GTEFHU19DRkkpCj4gIGV4cG9ydCBDQ19GTEFH U19DRkkKPiAgZW5kaWYKPiAgCj4gK2lmZGVmIENPTkZJR19DRklfR0NDCj4gK0NDX0ZMQUdTX0NG SQk6PSAtZnNhbml0aXplPWNmaQo+ICtLQlVJTERfQ0ZMQUdTCSs9ICQoQ0NfRkxBR1NfQ0ZJKQo+ ICtleHBvcnQgQ0NfRkxBR1NfQ0ZJCj4gK2VuZGlmCj4gKwo+ICBpZmRlZiBDT05GSUdfREVCVUdf Rk9SQ0VfRlVOQ1RJT05fQUxJR05fNjRCCj4gIEtCVUlMRF9DRkxBR1MgKz0gLWZhbGlnbi1mdW5j dGlvbnM9NjQKPiAgZW5kaWYKPiBkaWZmIC0tZ2l0IGEvYXJjaC9LY29uZmlnIGIvYXJjaC9LY29u ZmlnCj4gaW5kZXggMWMxZWNhMGMwMDE5Li44YjQzYTlmZDNiNTQgMTAwNjQ0Cj4gLS0tIGEvYXJj aC9LY29uZmlnCj4gKysrIGIvYXJjaC9LY29uZmlnCj4gQEAgLTc1Niw5ICs3NTYsMzEgQEAgY29u ZmlnIENGSV9DTEFORwo+ICAKPiAgCSAgICBodHRwczovL2NsYW5nLmxsdm0ub3JnL2RvY3MvQ29u dHJvbEZsb3dJbnRlZ3JpdHkuaHRtbAo+ICAKPiArY29uZmlnIEFSQ0hfU1VQUE9SVFNfQ0ZJX0dD Qwo+ICsJYm9vbAo+ICsJaGVscAo+ICsJICBBbiBhcmNoaXRlY3R1cmUgc2hvdWxkIHNlbGVjdCB0 aGlzIG9wdGlvbiBpZiBpdCBjYW4gc3VwcG9ydCBHQ0Mncwo+ICsJICBDb250cm9sLUZsb3cgSW50 ZWdyaXR5IChDRkkpIGNoZWNraW5nLgo+ICsKPiArY29uZmlnIENGSV9HQ0MKPiArCWJvb2wgIlVz ZSBHQ0MncyBDb250cm9sIEZsb3cgSW50ZWdyaXR5IChDRkkpIgo+ICsJZGVwZW5kcyBvbiBBUkNI X1NVUFBPUlRTX0NGSV9HQ0MKPiArCWRlcGVuZHMgb24gJChjYy1vcHRpb24sLWZzYW5pdGl6ZT1j ZmkpCj4gKwloZWxwCj4gKwkgIFRoaXMgb3B0aW9uIGVuYWJsZXMgR0ND4oCZcyBmb3J3YXJkLWVk Z2UgQ29udHJvbCBGbG93IEludGVncml0eQo+ICsJICAoQ0ZJKSBjaGVja2luZywgd2hlcmUgdGhl IGNvbXBpbGVyIGluamVjdHMgYSBydW50aW1lIGNoZWNrIHRvIGVhY2gKPiArCSAgaW5kaXJlY3Qg ZnVuY3Rpb24gY2FsbCB0byBlbnN1cmUgdGhlIHRhcmdldCBpcyBhIHZhbGlkIGZ1bmN0aW9uIHdp dGgKPiArCSAgdGhlIGNvcnJlY3Qgc3RhdGljIHR5cGUuIFRoaXMgcmVzdHJpY3RzIHBvc3NpYmxl IGNhbGwgdGFyZ2V0cyBhbmQKPiArCSAgbWFrZXMgaXQgbW9yZSBkaWZmaWN1bHQgZm9yIGFuIGF0 dGFja2VyIHRvIGV4cGxvaXQgYnVncyB0aGF0IGFsbG93Cj4gKwkgIHRoZSBtb2RpZmljYXRpb24g b2Ygc3RvcmVkIGZ1bmN0aW9uIHBvaW50ZXJzLiBNb3JlIGluZm9ybWF0aW9uIGNhbiBiZQo+ICsJ ICBmb3VuZCBmcm9tIHRoZSBjb21waWxlcidzIGRvY3VtZW50YXRpb246Cj4gKwo+ICsJICAtIENs YW5nOiBodHRwczovL2NsYW5nLmxsdm0ub3JnL2RvY3MvQ29udHJvbEZsb3dJbnRlZ3JpdHkuaHRt bAo+ICsJICAtIEdDQzogaHR0cHM6Ly9nY2MuZ251Lm9yZy9vbmxpbmVkb2NzL2djYy9JbnN0cnVt ZW50YXRpb24tT3B0aW9ucy5odG1sI0luc3RydW1lbnRhdGlvbi1PcHRpb25zCj4gKwo+ICBjb25m aWcgQ0ZJX1BFUk1JU1NJVkUKPiAgCWJvb2wgIlVzZSBDRkkgaW4gcGVybWlzc2l2ZSBtb2RlIgo+ IC0JZGVwZW5kcyBvbiBDRklfQ0xBTkcKPiArCWRlcGVuZHMgb24gQ0ZJX0NMQU5HIHx8IENGSV9H Q0MKPiAgCWhlbHAKPiAgCSAgV2hlbiBzZWxlY3RlZCwgQ29udHJvbCBGbG93IEludGVncml0eSAo Q0ZJKSB2aW9sYXRpb25zIHJlc3VsdCBpbiBhCj4gIAkgIHdhcm5pbmcgaW5zdGVhZCBvZiBhIGtl cm5lbCBwYW5pYy4gVGhpcyBvcHRpb24gc2hvdWxkIG9ubHkgYmUgdXNlZAo+IGRpZmYgLS1naXQg YS9hcmNoL2FybTY0L0tjb25maWcgYi9hcmNoL2FybTY0L0tjb25maWcKPiBpbmRleCA5ZmI5ZmZm MDhjOTQuLjYwZmRmYjAxY2VjYiAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0L0tjb25maWcKPiAr KysgYi9hcmNoL2FybTY0L0tjb25maWcKPiBAQCAtODksNiArODksNyBAQCBjb25maWcgQVJNNjQK PiAgCXNlbGVjdCBBUkNIX1NVUFBPUlRTX0xUT19DTEFORyBpZiBDUFVfTElUVExFX0VORElBTgo+ ICAJc2VsZWN0IEFSQ0hfU1VQUE9SVFNfTFRPX0NMQU5HX1RISU4KPiAgCXNlbGVjdCBBUkNIX1NV UFBPUlRTX0NGSV9DTEFORwo+ICsJc2VsZWN0IEFSQ0hfU1VQUE9SVFNfQ0ZJX0dDQwo+ICAJc2Vs ZWN0IEFSQ0hfU1VQUE9SVFNfQVRPTUlDX1JNVwo+ICAJc2VsZWN0IEFSQ0hfU1VQUE9SVFNfSU5U MTI4IGlmIENDX0hBU19JTlQxMjgKPiAgCXNlbGVjdCBBUkNIX1NVUFBPUlRTX05VTUFfQkFMQU5D SU5HCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvY2ZpX3R5cGVzLmggYi9pbmNsdWRlL2xp bnV4L2NmaV90eXBlcy5oCj4gaW5kZXggNmI4NzEzNjc1NzY1Li4xYzNiN2VhNmE3OWYgMTAwNjQ0 Cj4gLS0tIGEvaW5jbHVkZS9saW51eC9jZmlfdHlwZXMuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgv Y2ZpX3R5cGVzLmgKPiBAQCAtOCwxOCArOCwyNSBAQAo+ICAjaWZkZWYgX19BU1NFTUJMWV9fCj4g ICNpbmNsdWRlIDxsaW51eC9saW5rYWdlLmg+Cj4gIAo+IC0jaWZkZWYgQ09ORklHX0NGSV9DTEFO Rwo+ICsjaWYgZGVmaW5lZChDT05GSUdfQ0ZJX0NMQU5HKSB8fCBkZWZpbmVkKENPTkZJR19DRklf R0NDKQo+ICAvKgo+IC0gKiBVc2UgdGhlIF9fa2NmaV90eXBlaWRfPGZ1bmN0aW9uPiB0eXBlIGlk ZW50aWZpZXIgc3ltYm9sIHRvCj4gKyAqIFVzZSB0aGUgX19ba11jZmlfdHlwZWlkXzxmdW5jdGlv bj4gdHlwZSBpZGVudGlmaWVyIHN5bWJvbCB0bwo+ICAgKiBhbm5vdGF0ZSBpbmRpcmVjdGx5IGNh bGxlZCBhc3NlbWJseSBmdW5jdGlvbnMuIFRoZSBjb21waWxlciBlbWl0cwo+ICAgKiB0aGVzZSBz eW1ib2xzIGZvciBhbGwgYWRkcmVzcy10YWtlbiBmdW5jdGlvbiBkZWNsYXJhdGlvbnMgaW4gQwo+ ICAgKiBjb2RlLgo+ICAgKi8KPiAgI2lmbmRlZiBfX0NGSV9UWVBFCj4gKwo+ICsjaWZkZWYgQ09O RklHX0NGSV9HQ0MKPiArI2RlZmluZSBfX0NGSV9UWVBFKG5hbWUpCQkJCVwKPiArCS40Ynl0ZSBf X2NmaV90eXBlaWRfIyNuYW1lCj4gKyNlbHNlCj4gICNkZWZpbmUgX19DRklfVFlQRShuYW1lKQkJ CQlcCj4gIAkuNGJ5dGUgX19rY2ZpX3R5cGVpZF8jI25hbWUKPiAgI2VuZGlmCj4gIAo+ICsjZW5k aWYKPiArCj4gICNkZWZpbmUgU1lNX1RZUEVEX0VOVFJZKG5hbWUsIGxpbmthZ2UsIGFsaWduLi4u KQlcCj4gIAlsaW5rYWdlKG5hbWUpIEFTTV9OTAkJCQlcCj4gIAlhbGlnbiBBU01fTkwJCQkJCVwK PiBAQCAtMjksMTIgKzM2LDEyIEBACj4gICNkZWZpbmUgU1lNX1RZUEVEX1NUQVJUKG5hbWUsIGxp bmthZ2UsIGFsaWduLi4uKQlcCj4gIAlTWU1fVFlQRURfRU5UUlkobmFtZSwgbGlua2FnZSwgYWxp Z24pCj4gIAo+IC0jZWxzZSAvKiBDT05GSUdfQ0ZJX0NMQU5HICovCj4gKyNlbHNlIC8qIGRlZmlu ZWQoQ09ORklHX0NGSV9DTEFORykgfHwgZGVmaW5lZChDT05GSUdfQ0ZJX0dDQykgKi8KPiAgCj4g ICNkZWZpbmUgU1lNX1RZUEVEX1NUQVJUKG5hbWUsIGxpbmthZ2UsIGFsaWduLi4uKQlcCj4gIAlT WU1fU1RBUlQobmFtZSwgbGlua2FnZSwgYWxpZ24pCj4gIAo+IC0jZW5kaWYgLyogQ09ORklHX0NG SV9DTEFORyAqLwo+ICsjZW5kaWYgLyogZGVmaW5lZChDT05GSUdfQ0ZJX0NMQU5HKSB8fCBkZWZp bmVkKENPTkZJR19DRklfR0NDKSAqLwo+ICAKPiAgI2lmbmRlZiBTWU1fVFlQRURfRlVOQ19TVEFS VAo+ICAjZGVmaW5lIFNZTV9UWVBFRF9GVU5DX1NUQVJUKG5hbWUpIAkJCVwKPiBkaWZmIC0tZ2l0 IGEvaW5jbHVkZS9saW51eC9jb21waWxlci1nY2MuaCBiL2luY2x1ZGUvbGludXgvY29tcGlsZXIt Z2NjLmgKPiBpbmRleCA5YjE1N2I3MTAzNmYuLmFlYzFjZTMyN2IxYSAxMDA2NDQKPiAtLS0gYS9p bmNsdWRlL2xpbnV4L2NvbXBpbGVyLWdjYy5oCj4gKysrIGIvaW5jbHVkZS9saW51eC9jb21waWxl ci1nY2MuaAo+IEBAIC04Miw2ICs4MiwxMCBAQAo+ICAjZGVmaW5lIF9fbm9zY3MgX19hdHRyaWJ1 dGVfXygoX19ub19zYW5pdGl6ZV9fKCJzaGFkb3ctY2FsbC1zdGFjayIpKSkKPiAgI2VuZGlmCj4g IAo+ICsjaWZkZWYgQ09ORklHX0NGSV9HQ0MKPiArI2RlZmluZSBfX25vY2ZpIF9fYXR0cmlidXRl X18oKG5vX3Nhbml0aXplKCJjZmkiKSkpCj4gKyNlbmRpZgo+ICsKPiAgI2lmIF9faGFzX2F0dHJp YnV0ZShfX25vX3Nhbml0aXplX2FkZHJlc3NfXykKPiAgI2RlZmluZSBfX25vX3Nhbml0aXplX2Fk ZHJlc3MgX19hdHRyaWJ1dGVfXygobm9fc2FuaXRpemVfYWRkcmVzcykpCj4gICNlbHNlCj4gZGlm ZiAtLWdpdCBhL2tlcm5lbC9NYWtlZmlsZSBiL2tlcm5lbC9NYWtlZmlsZQo+IGluZGV4IDMxODc4 OWM3MjhkMy4uOTIzZDNlMDYwODUyIDEwMDY0NAo+IC0tLSBhL2tlcm5lbC9NYWtlZmlsZQo+ICsr KyBiL2tlcm5lbC9NYWtlZmlsZQo+IEBAIC0xMTQsNiArMTE0LDcgQEAgb2JqLSQoQ09ORklHX1NI QURPV19DQUxMX1NUQUNLKSArPSBzY3Mubwo+ICBvYmotJChDT05GSUdfSEFWRV9TVEFUSUNfQ0FM TCkgKz0gc3RhdGljX2NhbGwubwo+ICBvYmotJChDT05GSUdfSEFWRV9TVEFUSUNfQ0FMTF9JTkxJ TkUpICs9IHN0YXRpY19jYWxsX2lubGluZS5vCj4gIG9iai0kKENPTkZJR19DRklfQ0xBTkcpICs9 IGNmaS5vCj4gK29iai0kKENPTkZJR19DRklfR0NDKSArPSBjZmkubwo+ICAKPiAgb2JqLSQoQ09O RklHX1BFUkZfRVZFTlRTKSArPSBldmVudHMvCj4gIAo+IGRpZmYgLS1naXQgYS9rZXJuZWwvY2Zp LmMgYi9rZXJuZWwvY2ZpLmMKPiBpbmRleCAwOGNhYWQ3NzY3MTcuLjliZmYzNTczNjc1NiAxMDA2 NDQKPiAtLS0gYS9rZXJuZWwvY2ZpLmMKPiArKysgYi9rZXJuZWwvY2ZpLmMKPiBAQCAtMjUsNiAr MjUsNyBAQCBlbnVtIGJ1Z190cmFwX3R5cGUgcmVwb3J0X2NmaV9mYWlsdXJlKHN0cnVjdCBwdF9y ZWdzICpyZWdzLCB1bnNpZ25lZCBsb25nIGFkZHIsCj4gIAlyZXR1cm4gQlVHX1RSQVBfVFlQRV9C VUc7Cj4gIH0KPiAgCj4gKyNpZmRlZiBDT05GSUdfQ0ZJX0NMQU5HCj4gICNpZmRlZiBDT05GSUdf QVJDSF9VU0VTX0NGSV9UUkFQUwo+ICBzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgdHJhcF9h ZGRyZXNzKHMzMiAqcCkKPiAgewo+IEBAIC05OSwzICsxMDAsMjUgQEAgYm9vbCBpc19jZmlfdHJh cCh1bnNpZ25lZCBsb25nIGFkZHIpCj4gIAlyZXR1cm4gaXNfbW9kdWxlX2NmaV90cmFwKGFkZHIp Owo+ICB9Cj4gICNlbmRpZiAvKiBDT05GSUdfQVJDSF9VU0VTX0NGSV9UUkFQUyAqLwo+ICsjZW5k aWYgLyogQ09ORklHX0NGSV9DTEFORyAqLwo+ICsKPiArCj4gKyNpZmRlZiBDT05GSUdfQ0ZJX0dD Qwo+ICt2b2lkIGNmaV9jaGVja19mYWlsZWQodTMyIGNhbGxlcl9oYXNoLCB1MzIgY2FsbGVlX2hh c2gsIHZvaWQgKmNhbGxlZV9hZGRyKQo+ICt7Cj4gKwl1bnNpZ25lZCBsb25nIHBjLCB0YXJnZXQ7 Cj4gKwo+ICsJcGMgPSAodW5zaWduZWQgbG9uZylfX2J1aWx0aW5fcmV0dXJuX2FkZHJlc3MoMCk7 Cj4gKwl0YXJnZXQgPSAodW5zaWduZWQgbG9uZyljYWxsZWVfYWRkcjsKPiArCj4gKwlzd2l0Y2gg KHJlcG9ydF9jZmlfZmFpbHVyZShOVUxMLCBwYywgJnRhcmdldCwgY2FsbGVyX2hhc2gpKSB7Cj4g KwljYXNlIEJVR19UUkFQX1RZUEVfV0FSTjoKPiArCQlicmVhazsKPiArCj4gKwlkZWZhdWx0Ogo+ ICsJCXBhbmljKCJPb3BzIC0gQ0ZJIik7Cj4gKwl9Cj4gK30KPiArRVhQT1JUX1NZTUJPTChjZmlf Y2hlY2tfZmFpbGVkKTsKPiArCj4gKyNlbmRpZiAvKiBDT05GSUdfQ0ZJX0dDQyAqLwo+IGRpZmYg LS1naXQgYS9zY3JpcHRzL2thbGxzeW1zLmMgYi9zY3JpcHRzL2thbGxzeW1zLmMKPiBpbmRleCBj Y2RmMGM4OTdmMzEuLmVkOGRiNTEzYjkxOCAxMDA2NDQKPiAtLS0gYS9zY3JpcHRzL2thbGxzeW1z LmMKPiArKysgYi9zY3JpcHRzL2thbGxzeW1zLmMKPiBAQCAtMTE5LDcgKzExOSw5IEBAIHN0YXRp YyBib29sIGlzX2lnbm9yZWRfc3ltYm9sKGNvbnN0IGNoYXIgKm5hbWUsIGNoYXIgdHlwZSkKPiAg CQkiX19UaHVtYlY3UElMb25nVGh1bmtfIiwKPiAgCQkiX19MQTI1VGh1bmtfIiwJCS8qIG1pcHMg bGxkICovCj4gIAkJIl9fbWljcm9MQTI1VGh1bmtfIiwKPiAtCQkiX19rY2ZpX3R5cGVpZF8iLAkv KiBDRkkgdHlwZSBpZGVudGlmaWVycyAqLwo+ICsJCSJfX2tjZmlfdHlwZWlkXyIsCS8qIENGSSB0 eXBlIGlkZW50aWZpZXJzIGluIENsYW5nICovCj4gKwkJIl9fY2ZpXyIsCQkvKiBDRkkgdHlwZSBp ZGVudGlmaWVycyBpbiBHQ0MgKi8KPiArCQkiX19waV9fX2NmaSIsCQkvKiBDRkkgdHlwZSBpZGVu dGlmaWVycyBpbiBHQ0MgKi8KPiAgCQlOVUxMCj4gIAl9Owo+ICAKPiAtLSAKPiAyLjE3LjEKPiAK Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFy bS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9y ZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1r ZXJuZWwK