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 67AB7ECAAA1 for ; Tue, 30 Aug 2022 23:32:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231604AbiH3XcA (ORCPT ); Tue, 30 Aug 2022 19:32:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42280 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231842AbiH3Xbz (ORCPT ); Tue, 30 Aug 2022 19:31:55 -0400 Received: from mail-yb1-xb49.google.com (mail-yb1-xb49.google.com [IPv6:2607:f8b0:4864:20::b49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E554873908 for ; Tue, 30 Aug 2022 16:31:47 -0700 (PDT) Received: by mail-yb1-xb49.google.com with SMTP id y81-20020a253254000000b0069339437485so864667yby.5 for ; Tue, 30 Aug 2022 16:31:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=content-transfer-encoding:cc:to:from:subject:references :mime-version:message-id:in-reply-to:date:from:to:cc:subject:date; bh=W+Rg4QRmmdA0/Hc4QXoXxn9OQCFXsXPrsC4ccUXv4Tc=; b=rDhka3uRx1PU8f2EDWnEpOrnvrdx5qN9dYpFwRrqfzvRKXUIANFLrLRCziHCAUNIcr CDtIm8N/+ogxY9VUQGAhXL4yzuoL15fnpZhVbIULb4mqm1gzo3J5h0IgBdZJB1FScttP dfn/+F6ctlxMLIlzO/fbsOGHAe3OskYsCiUpm0ZOEPIh1mbC2+Nf+cftVRGfEimFQ9v3 lq9WAVd+Yi6VG3jdMVQFOevSl8vktq6shSnecjO0a+yZtTwUnoBkKtLj9k73QDySItSu V/Zj1fBtLnPbgXm4xEdqL+jO0WetgEoojDcSvgLB67zDo6rClf1tbpMtES9fUxtGbwVU xKSQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:cc:to:from:subject:references :mime-version:message-id:in-reply-to:date:x-gm-message-state:from:to :cc:subject:date; bh=W+Rg4QRmmdA0/Hc4QXoXxn9OQCFXsXPrsC4ccUXv4Tc=; b=uKRGgUbaloydLh7p/z24heIhWOdS2VH55NmEhWAIOpIXzntiRsCMzvbLTUvnzQDEqd cxtetMb5T6Ecs+eu3OfhPZ68lhXi4FrV/56MV6wM5tHuwAITWydf51OwKe8e6JthL0hD Z15oltZ2rsHxkh1rMyOpxW6XHnFIXiEN3LVAe2Ctr6b3A8k0OoBG36juWK5pzVoYuED6 nrm47aAvWSenCTKDSs0TaRECkdcM/ap3fney1Gy1N9tfxuJJ5SkVOo178M+3aObKuTSW k1zOEkbGu3wL56zHPZ9x3nV8QF6ISHf+mdFPtghrGt+yX63dnMso3ffJczkN0uA/8m8E +ljA== X-Gm-Message-State: ACgBeo3E03uf7yZNqWRb0Ppv4Gwcpt9BO6lswTJ1TqqbV3jAzv8B1sF7 BrT+z0EhpSrRZOuSLyYeZm6K1V+nDSz892n75Ns= X-Google-Smtp-Source: AA6agR5MF3H8wULga6oaTI4IDTrFITlveKsApTUGMpZ8bebnrHcV+zPFGJHOnWGe87MvszIlybHltVZfU/snDGUEcQA= X-Received: from samitolvanen1.mtv.corp.google.com ([2620:15c:201:2:54d9:7143:6a7d:91d]) (user=samitolvanen job=sendgmr) by 2002:a25:6f8a:0:b0:695:8d02:89ed with SMTP id k132-20020a256f8a000000b006958d0289edmr13982166ybc.434.1661902306650; Tue, 30 Aug 2022 16:31:46 -0700 (PDT) Date: Tue, 30 Aug 2022 16:31:13 -0700 In-Reply-To: <20220830233129.30610-1-samitolvanen@google.com> Message-Id: <20220830233129.30610-6-samitolvanen@google.com> Mime-Version: 1.0 References: <20220830233129.30610-1-samitolvanen@google.com> X-Developer-Key: i=samitolvanen@google.com; a=openpgp; fpr=35CCFB63B283D6D3AEB783944CB5F6848BBC56EE X-Developer-Signature: v=1; a=openpgp-sha256; l=15753; i=samitolvanen@google.com; h=from:subject; bh=kCPCwrWfKfR+47zuMRd+7NjMRv71MY29I1bZCtxLbxI=; b=owEB7QES/pANAwAKAUy19oSLvFbuAcsmYgBjDp3MrdViWUem/XBnu30YaMAfZydcXlgcbTrgLa+e jBt4PdWJAbMEAAEKAB0WIQQ1zPtjsoPW0663g5RMtfaEi7xW7gUCYw6dzAAKCRBMtfaEi7xW7umoC/ 49UVQV86/AuVPkPWkdVrVkEyDS/X6YCJh7gGxvdJkHW9pGZOxawDYIWlV42qbIKWbW/FO1ZEOXmtEv +6024VtQSVK+D75MltkNDV7Q68PJaWGvjSBCOZPdXupe76AUtLrNF2fDvUrcKhNbHIqQVI3gNYNmnb 61VrmRipFhfZZP36JbCxFSIQ8fSZz/o6wdm1WJNmCG7Am+vZEpPwhsbyI5YzO8stpkpyN5KCp02rxa oW7SmnGkROBEOVPKYFGgvuA9jqu7XmBISbEZeoaVehPFeAMa+9bR8XoNz85TD+4BGoTEuYjG4PL9Qm S5QfrWEKKhvdfW3A3/qZ9sDRMaFeGuNQP1a65S2iDzXwyCBXyHbkc1JMbrecqfU1UmyoCBECD1SLDe F2TJotemis8EYU4f/N1t70u/OJQi7ah3MSuSzdS865T8L8jIYWNHnMR8q3fQimrL6A4WN4/UvcMxqr MuCBFpmLi6jwn7Ht/KNck9FqME0wqqRetzAPUnaLFKfVA= X-Mailer: git-send-email 2.37.2.672.g94769d06f0-goog Subject: [PATCH v4 05/21] cfi: Switch to -fsanitize=kcfi From: Sami Tolvanen To: linux-kernel@vger.kernel.org Cc: Kees Cook , Josh Poimboeuf , Peter Zijlstra , x86@kernel.org, Catalin Marinas , Will Deacon , Mark Rutland , Nathan Chancellor , Nick Desaulniers , Joao Moreira , Sedat Dilek , Steven Rostedt , linux-hardening@vger.kernel.org, linux-arm-kernel@lists.infradead.org, llvm@lists.linux.dev, Sami Tolvanen Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-hardening@vger.kernel.org Switch from Clang's original forward-edge control-flow integrity implementation to -fsanitize=3Dkcfi, which is better suited for the kernel, as it doesn't require LTO, doesn't use a jump table that requires altering function references, and won't break cross-module function address equality. Signed-off-by: Sami Tolvanen Reviewed-by: Kees Cook --- Makefile | 13 +-- arch/Kconfig | 8 +- include/asm-generic/vmlinux.lds.h | 37 ++++---- include/linux/cfi.h | 29 +++++- include/linux/compiler-clang.h | 14 +-- include/linux/module.h | 6 +- kernel/cfi.c | 144 +++++++++++++++--------------- kernel/module/main.c | 35 +------- scripts/module.lds.S | 23 +---- 9 files changed, 133 insertions(+), 176 deletions(-) diff --git a/Makefile b/Makefile index 952d354069a4..eec147f5572c 100644 --- a/Makefile +++ b/Makefile @@ -921,18 +921,7 @@ export CC_FLAGS_LTO endif =20 ifdef CONFIG_CFI_CLANG -CC_FLAGS_CFI :=3D -fsanitize=3Dcfi \ - -fsanitize-cfi-cross-dso \ - -fno-sanitize-cfi-canonical-jump-tables \ - -fno-sanitize-trap=3Dcfi \ - -fno-sanitize-blacklist - -ifdef CONFIG_CFI_PERMISSIVE -CC_FLAGS_CFI +=3D -fsanitize-recover=3Dcfi -endif - -# If LTO flags are filtered out, we must also filter out CFI. -CC_FLAGS_LTO +=3D $(CC_FLAGS_CFI) +CC_FLAGS_CFI :=3D -fsanitize=3Dkcfi KBUILD_CFLAGS +=3D $(CC_FLAGS_CFI) export CC_FLAGS_CFI endif diff --git a/arch/Kconfig b/arch/Kconfig index 5fd875e18c99..1c1eca0c0019 100644 --- a/arch/Kconfig +++ b/arch/Kconfig @@ -738,11 +738,13 @@ config ARCH_SUPPORTS_CFI_CLANG An architecture should select this option if it can support Clang's Control-Flow Integrity (CFI) checking. =20 +config ARCH_USES_CFI_TRAPS + bool + config CFI_CLANG bool "Use Clang's Control Flow Integrity (CFI)" - depends on LTO_CLANG && ARCH_SUPPORTS_CFI_CLANG - depends on CLANG_VERSION >=3D 140000 - select KALLSYMS + depends on ARCH_SUPPORTS_CFI_CLANG + depends on $(cc-option,-fsanitize=3Dkcfi) help This option enables Clang=E2=80=99s forward-edge Control Flow Integrity (CFI) checking, where the compiler injects a runtime check to each diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinu= x.lds.h index 7515a465ec03..7501edfce11e 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h @@ -421,6 +421,22 @@ __end_ro_after_init =3D .; #endif =20 +/* + * .kcfi_traps contains a list KCFI trap locations. + */ +#ifndef KCFI_TRAPS +#ifdef CONFIG_ARCH_USES_CFI_TRAPS +#define KCFI_TRAPS \ + __kcfi_traps : AT(ADDR(__kcfi_traps) - LOAD_OFFSET) { \ + __start___kcfi_traps =3D .; \ + KEEP(*(.kcfi_traps)) \ + __stop___kcfi_traps =3D .; \ + } +#else +#define KCFI_TRAPS +#endif +#endif + /* * Read only Data */ @@ -529,6 +545,8 @@ __stop___modver =3D .; \ } \ \ + KCFI_TRAPS \ + \ RO_EXCEPTION_TABLE \ NOTES \ BTF \ @@ -537,21 +555,6 @@ __end_rodata =3D .; =20 =20 -/* - * .text..L.cfi.jumptable.* contain Control-Flow Integrity (CFI) - * jump table entries. - */ -#ifdef CONFIG_CFI_CLANG -#define TEXT_CFI_JT \ - . =3D ALIGN(PMD_SIZE); \ - __cfi_jt_start =3D .; \ - *(.text..L.cfi.jumptable .text..L.cfi.jumptable.*) \ - . =3D ALIGN(PMD_SIZE); \ - __cfi_jt_end =3D .; -#else -#define TEXT_CFI_JT -#endif - /* * Non-instrumentable text section */ @@ -579,7 +582,6 @@ *(.text..refcount) \ *(.ref.text) \ *(.text.asan.* .text.tsan.*) \ - TEXT_CFI_JT \ MEM_KEEP(init.text*) \ MEM_KEEP(exit.text*) \ =20 @@ -1008,8 +1010,7 @@ * keep any .init_array.* sections. * https://bugs.llvm.org/show_bug.cgi?id=3D46478 */ -#if defined(CONFIG_GCOV_KERNEL) || defined(CONFIG_KASAN_GENERIC) || define= d(CONFIG_KCSAN) || \ - defined(CONFIG_CFI_CLANG) +#if defined(CONFIG_GCOV_KERNEL) || defined(CONFIG_KASAN_GENERIC) || define= d(CONFIG_KCSAN) # ifdef CONFIG_CONSTRUCTORS # define SANITIZER_DISCARDS \ *(.eh_frame) diff --git a/include/linux/cfi.h b/include/linux/cfi.h index 2cdbc0fbd0ab..5e134f4ce8b7 100644 --- a/include/linux/cfi.h +++ b/include/linux/cfi.h @@ -2,17 +2,38 @@ /* * Clang Control Flow Integrity (CFI) support. * - * Copyright (C) 2021 Google LLC + * Copyright (C) 2022 Google LLC */ #ifndef _LINUX_CFI_H #define _LINUX_CFI_H =20 +#include +#include + #ifdef CONFIG_CFI_CLANG -typedef void (*cfi_check_fn)(uint64_t id, void *ptr, void *diag); +enum bug_trap_type report_cfi_failure(struct pt_regs *regs, unsigned long = addr, + unsigned long *target, u32 type); =20 -/* Compiler-generated function in each module, and the kernel */ -extern void __cfi_check(uint64_t id, void *ptr, void *diag); +static inline enum bug_trap_type report_cfi_failure_noaddr(struct pt_regs = *regs, + unsigned long addr) +{ + return report_cfi_failure(regs, addr, NULL, 0); +} =20 +#ifdef CONFIG_ARCH_USES_CFI_TRAPS +bool is_cfi_trap(unsigned long addr); +#endif #endif /* CONFIG_CFI_CLANG */ =20 +#ifdef CONFIG_MODULES +#ifdef CONFIG_ARCH_USES_CFI_TRAPS +void module_cfi_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, + struct module *mod); +#else +static inline void module_cfi_finalize(const Elf_Ehdr *hdr, + const Elf_Shdr *sechdrs, + struct module *mod) {} +#endif /* CONFIG_ARCH_USES_CFI_TRAPS */ +#endif /* CONFIG_MODULES */ + #endif /* _LINUX_CFI_H */ diff --git a/include/linux/compiler-clang.h b/include/linux/compiler-clang.= h index c84fec767445..42e55579d649 100644 --- a/include/linux/compiler-clang.h +++ b/include/linux/compiler-clang.h @@ -66,17 +66,9 @@ # define __noscs __attribute__((__no_sanitize__("shadow-call-stack"))) #endif =20 -#define __nocfi __attribute__((__no_sanitize__("cfi"))) -#define __cficanonical __attribute__((__cfi_canonical_jump_table__)) - -#if defined(CONFIG_CFI_CLANG) -/* - * With CONFIG_CFI_CLANG, the compiler replaces function address - * references with the address of the function's CFI jump table - * entry. The function_nocfi macro always returns the address of the - * actual function instead. - */ -#define function_nocfi(x) __builtin_function_start(x) +#if __has_feature(kcfi) +/* Disable CFI checking inside a function. */ +#define __nocfi __attribute__((__no_sanitize__("kcfi"))) #endif =20 /* diff --git a/include/linux/module.h b/include/linux/module.h index 8937b020ec04..ec61fb53979a 100644 --- a/include/linux/module.h +++ b/include/linux/module.h @@ -27,7 +27,6 @@ #include #include #include -#include =20 #include #include @@ -387,8 +386,9 @@ struct module { const s32 *crcs; unsigned int num_syms; =20 -#ifdef CONFIG_CFI_CLANG - cfi_check_fn cfi_check; +#ifdef CONFIG_ARCH_USES_CFI_TRAPS + s32 *kcfi_traps; + s32 *kcfi_traps_end; #endif =20 /* Kernel parameters. */ diff --git a/kernel/cfi.c b/kernel/cfi.c index e8bc1b370edc..08caad776717 100644 --- a/kernel/cfi.c +++ b/kernel/cfi.c @@ -1,105 +1,101 @@ // SPDX-License-Identifier: GPL-2.0 /* - * Clang Control Flow Integrity (CFI) error and slowpath handling. + * Clang Control Flow Integrity (CFI) error handling. * - * Copyright (C) 2021 Google LLC + * Copyright (C) 2022 Google LLC */ =20 -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -/* Compiler-defined handler names */ -#ifdef CONFIG_CFI_PERMISSIVE -#define cfi_failure_handler __ubsan_handle_cfi_check_fail -#else -#define cfi_failure_handler __ubsan_handle_cfi_check_fail_abort -#endif - -static inline void handle_cfi_failure(void *ptr) +#include + +enum bug_trap_type report_cfi_failure(struct pt_regs *regs, unsigned long = addr, + unsigned long *target, u32 type) { - if (IS_ENABLED(CONFIG_CFI_PERMISSIVE)) - WARN_RATELIMIT(1, "CFI failure (target: %pS):\n", ptr); + if (target) + pr_err("CFI failure at %pS (target: %pS; expected type: 0x%08x)\n", + (void *)addr, (void *)*target, type); else - panic("CFI failure (target: %pS)\n", ptr); + pr_err("CFI failure at %pS (no target information)\n", + (void *)addr); + + if (IS_ENABLED(CONFIG_CFI_PERMISSIVE)) { + __warn(NULL, 0, (void *)addr, 0, regs, NULL); + return BUG_TRAP_TYPE_WARN; + } + + return BUG_TRAP_TYPE_BUG; } =20 -#ifdef CONFIG_MODULES +#ifdef CONFIG_ARCH_USES_CFI_TRAPS +static inline unsigned long trap_address(s32 *p) +{ + return (unsigned long)((long)p + (long)*p); +} =20 -static inline cfi_check_fn find_module_check_fn(unsigned long ptr) +static bool is_trap(unsigned long addr, s32 *start, s32 *end) { - cfi_check_fn fn =3D NULL; - struct module *mod; + s32 *p; =20 - rcu_read_lock_sched_notrace(); - mod =3D __module_address(ptr); - if (mod) - fn =3D mod->cfi_check; - rcu_read_unlock_sched_notrace(); + for (p =3D start; p < end; ++p) { + if (trap_address(p) =3D=3D addr) + return true; + } =20 - return fn; + return false; } =20 -static inline cfi_check_fn find_check_fn(unsigned long ptr) +#ifdef CONFIG_MODULES +/* Populates `kcfi_trap(_end)?` fields in `struct module`. */ +void module_cfi_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, + struct module *mod) { - cfi_check_fn fn =3D NULL; - unsigned long flags; - bool rcu_idle; - - if (is_kernel_text(ptr)) - return __cfi_check; - - /* - * Indirect call checks can happen when RCU is not watching. Both - * the shadow and __module_address use RCU, so we need to wake it - * up if necessary. - */ - rcu_idle =3D !rcu_is_watching(); - if (rcu_idle) { - local_irq_save(flags); - ct_irq_enter(); - } + char *secstrings; + unsigned int i; =20 - fn =3D find_module_check_fn(ptr); + mod->kcfi_traps =3D NULL; + mod->kcfi_traps_end =3D NULL; =20 - if (rcu_idle) { - ct_irq_exit(); - local_irq_restore(flags); - } + secstrings =3D (char *)hdr + sechdrs[hdr->e_shstrndx].sh_offset; + + for (i =3D 1; i < hdr->e_shnum; i++) { + if (strcmp(secstrings + sechdrs[i].sh_name, "__kcfi_traps")) + continue; =20 - return fn; + mod->kcfi_traps =3D (s32 *)sechdrs[i].sh_addr; + mod->kcfi_traps_end =3D (s32 *)(sechdrs[i].sh_addr + sechdrs[i].sh_size)= ; + break; + } } =20 -void __cfi_slowpath_diag(uint64_t id, void *ptr, void *diag) +static bool is_module_cfi_trap(unsigned long addr) { - cfi_check_fn fn =3D find_check_fn((unsigned long)ptr); + struct module *mod; + bool found =3D false; =20 - if (likely(fn)) - fn(id, ptr, diag); - else /* Don't allow unchecked modules */ - handle_cfi_failure(ptr); -} -EXPORT_SYMBOL(__cfi_slowpath_diag); + rcu_read_lock_sched_notrace(); =20 -#else /* !CONFIG_MODULES */ + mod =3D __module_address(addr); + if (mod) + found =3D is_trap(addr, mod->kcfi_traps, mod->kcfi_traps_end); =20 -void __cfi_slowpath_diag(uint64_t id, void *ptr, void *diag) + rcu_read_unlock_sched_notrace(); + + return found; +} +#else /* CONFIG_MODULES */ +static inline bool is_module_cfi_trap(unsigned long addr) { - handle_cfi_failure(ptr); /* No modules */ + return false; } -EXPORT_SYMBOL(__cfi_slowpath_diag); - #endif /* CONFIG_MODULES */ =20 -void cfi_failure_handler(void *data, void *ptr, void *vtable) +extern s32 __start___kcfi_traps[]; +extern s32 __stop___kcfi_traps[]; + +bool is_cfi_trap(unsigned long addr) { - handle_cfi_failure(ptr); + if (is_trap(addr, __start___kcfi_traps, __stop___kcfi_traps)) + return true; + + return is_module_cfi_trap(addr); } -EXPORT_SYMBOL(cfi_failure_handler); +#endif /* CONFIG_ARCH_USES_CFI_TRAPS */ diff --git a/kernel/module/main.c b/kernel/module/main.c index 0228f44b58e5..70c0b2c6fef8 100644 --- a/kernel/module/main.c +++ b/kernel/module/main.c @@ -53,6 +53,7 @@ #include #include #include +#include #include #include "internal.h" =20 @@ -2597,8 +2598,9 @@ static int complete_formation(struct module *mod, str= uct load_info *info) if (err < 0) goto out; =20 - /* This relies on module_mutex for list integrity. */ + /* These rely on module_mutex for list integrity. */ module_bug_finalize(info->hdr, info->sechdrs, mod); + module_cfi_finalize(info->hdr, info->sechdrs, mod); =20 if (module_check_misalignment(mod)) goto out_misaligned; @@ -2660,8 +2662,6 @@ static int unknown_module_param_cb(char *param, char = *val, const char *modname, return 0; } =20 -static void cfi_init(struct module *mod); - /* * Allocate and load the module: note that size of section 0 is always * zero, and we rely on this for optional sections. @@ -2791,9 +2791,6 @@ static int load_module(struct load_info *info, const = char __user *uargs, =20 flush_module_icache(mod); =20 - /* Setup CFI for the module. */ - cfi_init(mod); - /* Now copy in args */ mod->args =3D strndup_user(uargs, ~0UL >> 1); if (IS_ERR(mod->args)) { @@ -2955,32 +2952,6 @@ static inline int within(unsigned long addr, void *s= tart, unsigned long size) return ((void *)addr >=3D start && (void *)addr < start + size); } =20 -static void cfi_init(struct module *mod) -{ -#ifdef CONFIG_CFI_CLANG - initcall_t *init; -#ifdef CONFIG_MODULE_UNLOAD - exitcall_t *exit; -#endif - - rcu_read_lock_sched(); - mod->cfi_check =3D (cfi_check_fn) - find_kallsyms_symbol_value(mod, "__cfi_check"); - init =3D (initcall_t *) - find_kallsyms_symbol_value(mod, "__cfi_jt_init_module"); - /* Fix init/exit functions to point to the CFI jump table */ - if (init) - mod->init =3D *init; -#ifdef CONFIG_MODULE_UNLOAD - exit =3D (exitcall_t *) - find_kallsyms_symbol_value(mod, "__cfi_jt_cleanup_module"); - if (exit) - mod->exit =3D *exit; -#endif - rcu_read_unlock_sched(); -#endif -} - /* Keep in sync with MODULE_FLAGS_BUF_SIZE !!! */ char *module_flags(struct module *mod, char *buf, bool show_state) { diff --git a/scripts/module.lds.S b/scripts/module.lds.S index 3a3aa2354ed8..da4bddd26171 100644 --- a/scripts/module.lds.S +++ b/scripts/module.lds.S @@ -3,20 +3,10 @@ * Archs are free to supply their own linker scripts. ld will * combine them automatically. */ -#ifdef CONFIG_CFI_CLANG -# include -# define ALIGN_CFI ALIGN(PAGE_SIZE) -# define SANITIZER_DISCARDS *(.eh_frame) -#else -# define ALIGN_CFI -# define SANITIZER_DISCARDS -#endif - SECTIONS { /DISCARD/ : { *(.discard) *(.discard.*) - SANITIZER_DISCARDS } =20 __ksymtab 0 : { *(SORT(___ksymtab+*)) } @@ -33,6 +23,10 @@ SECTIONS { =20 __patchable_function_entries : { *(__patchable_function_entries) } =20 +#ifdef CONFIG_ARCH_USES_CFI_TRAPS + __kcfi_traps : { KEEP(*(.kcfi_traps)) } +#endif + #ifdef CONFIG_LTO_CLANG /* * With CONFIG_LTO_CLANG, LLD always enables -fdata-sections and @@ -53,15 +47,6 @@ SECTIONS { *(.rodata .rodata.[0-9a-zA-Z_]*) *(.rodata..L*) } - - /* - * With CONFIG_CFI_CLANG, we assume __cfi_check is at the beginning - * of the .text section, and is aligned to PAGE_SIZE. - */ - .text : ALIGN_CFI { - *(.text.__cfi_check) - *(.text .text.[0-9a-zA-Z_]* .text..L.cfi*) - } #endif } =20 --=20 2.37.2.672.g94769d06f0-goog 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 2DE74ECAAD4 for ; Wed, 31 Aug 2022 00:09:25 +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:Cc:To:From:Subject:References: Mime-Version:Message-Id:In-Reply-To:Date:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=o67hieBAJuauP/YSwhP6rz3Fv341aRIIuYz0aF2iRQA=; b=nZWPcw45lFaxdFY59tGL2FKlnW O/MnZbQr3D90DweynJK2vRzhuHw91FedpbA6N62dIVF3FSafQ74YNB6BQwwFvc4ySeOH7htbjeHwf 2YdWhS248lzFPhJ9n72HTaY6MibmOroMR5IRjOkBn3tNnnPUExQkfmH61lAxul6eFHlo3WM7KlSqO tMVFTaMnqwDMc049/Vc788q/Vamd20/ZXnpIPpOwgBpfmfgKPPmZX5wOF3XuqxrZWiAnLyc72MAw9 QI/0L/B6+KI4TcGhR6afZfbmbAOri2lSGPzXZnpu0SfMdeh0hFp2Tau87A+RSy0kYM6Zm9/4ibESV hHwBhjzA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1oTBGx-002dkr-2r; Wed, 31 Aug 2022 00:07:59 +0000 Received: from desiato.infradead.org ([2001:8b0:10b:1:d65d:64ff:fe57:4e05]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1oTBCe-002bel-Tg for linux-arm-kernel@bombadil.infradead.org; Wed, 31 Aug 2022 00:03:33 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=desiato.20200630; h=Content-Transfer-Encoding:Content-Type :Cc:To:From:Subject:References:Mime-Version:Message-Id:In-Reply-To:Date: Sender:Reply-To:Content-ID:Content-Description; bh=W+Rg4QRmmdA0/Hc4QXoXxn9OQCFXsXPrsC4ccUXv4Tc=; b=OvsCbmSCQR3/vD41zCFU/bru8B 0qDWVphWtksyDaZEVTYwFhzydLWhgs7jqH5dJYcojiniYRX1Ahd5Kvvut5H2eUDBo5lwU6lxXTFp/ yUANbXHFHnVH5GAFWRI/Pjs2eQo5tmDQ+KyF1qGR8P9pbxRYjBjft2FCZX+s5QxaJkxMAu8kAotS0 ZP8fNMzCLWdGlyQR5wt9lo+BV69x5hjYueWXec1du02biNK0nALvVgCCqJP9oSfZFrLhxqIStWKW4 9GdE7WCOw8Buy7XItXa2PhtxMs89ZLs5H1B4QPSeQ269lZbQ+7EfCE3fbORn4I+HSdoffO9+1GrV1 vfhI0nZg==; Received: from mail-yw1-x114a.google.com ([2607:f8b0:4864:20::114a]) by desiato.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1oTAhx-007zd7-DB for linux-arm-kernel@lists.infradead.org; Tue, 30 Aug 2022 23:31:52 +0000 Received: by mail-yw1-x114a.google.com with SMTP id 00721157ae682-31f5960500bso190096837b3.14 for ; Tue, 30 Aug 2022 16:31:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=content-transfer-encoding:cc:to:from:subject:references :mime-version:message-id:in-reply-to:date:from:to:cc:subject:date; bh=W+Rg4QRmmdA0/Hc4QXoXxn9OQCFXsXPrsC4ccUXv4Tc=; b=rDhka3uRx1PU8f2EDWnEpOrnvrdx5qN9dYpFwRrqfzvRKXUIANFLrLRCziHCAUNIcr CDtIm8N/+ogxY9VUQGAhXL4yzuoL15fnpZhVbIULb4mqm1gzo3J5h0IgBdZJB1FScttP dfn/+F6ctlxMLIlzO/fbsOGHAe3OskYsCiUpm0ZOEPIh1mbC2+Nf+cftVRGfEimFQ9v3 lq9WAVd+Yi6VG3jdMVQFOevSl8vktq6shSnecjO0a+yZtTwUnoBkKtLj9k73QDySItSu V/Zj1fBtLnPbgXm4xEdqL+jO0WetgEoojDcSvgLB67zDo6rClf1tbpMtES9fUxtGbwVU xKSQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:cc:to:from:subject:references :mime-version:message-id:in-reply-to:date:x-gm-message-state:from:to :cc:subject:date; bh=W+Rg4QRmmdA0/Hc4QXoXxn9OQCFXsXPrsC4ccUXv4Tc=; b=OgQpNTHfwTRURU/47lx3NUMDBxOZIyDXTFkhNGdZMiHLe/CvNeSWFjfhkKCqewu83M Spxl1FO2iWb9YKy9KwD+AGzhFIGLMzZBri0K+RDUKChB5nObM52GmrbZfraiWsfXPVHH b8NvQJw+F5nE4Dree9hMF0nd22uEuayGbUA15T/kqoT3E+2FEccwLduNMl+MclPlz4xH lh2MplTNgvc28EEjRBKbVverdBgHfA90nqlPDc06odBVQa5xknTs68rT9UFAMSvo4EhV R6q3ma6HUfsFvzwflLOU8uUzyS68t1HYucLTHCQibGhkZq/+3dTa8RLmaTf/bvEt2NoU IQfg== X-Gm-Message-State: ACgBeo3EdtRmbdx8m7NUJX0TXR4zjaeZB0eJcTyyGh+1QhoUu6c6lhdV ZOzHxx8NTxrswRwdL/esROyYkPp8stT1R2YsriQ= X-Google-Smtp-Source: AA6agR5MF3H8wULga6oaTI4IDTrFITlveKsApTUGMpZ8bebnrHcV+zPFGJHOnWGe87MvszIlybHltVZfU/snDGUEcQA= X-Received: from samitolvanen1.mtv.corp.google.com ([2620:15c:201:2:54d9:7143:6a7d:91d]) (user=samitolvanen job=sendgmr) by 2002:a25:6f8a:0:b0:695:8d02:89ed with SMTP id k132-20020a256f8a000000b006958d0289edmr13982166ybc.434.1661902306650; Tue, 30 Aug 2022 16:31:46 -0700 (PDT) Date: Tue, 30 Aug 2022 16:31:13 -0700 In-Reply-To: <20220830233129.30610-1-samitolvanen@google.com> Message-Id: <20220830233129.30610-6-samitolvanen@google.com> Mime-Version: 1.0 References: <20220830233129.30610-1-samitolvanen@google.com> X-Developer-Key: i=samitolvanen@google.com; a=openpgp; fpr=35CCFB63B283D6D3AEB783944CB5F6848BBC56EE X-Developer-Signature: v=1; a=openpgp-sha256; l=15753; i=samitolvanen@google.com; h=from:subject; bh=kCPCwrWfKfR+47zuMRd+7NjMRv71MY29I1bZCtxLbxI=; b=owEB7QES/pANAwAKAUy19oSLvFbuAcsmYgBjDp3MrdViWUem/XBnu30YaMAfZydcXlgcbTrgLa+e jBt4PdWJAbMEAAEKAB0WIQQ1zPtjsoPW0663g5RMtfaEi7xW7gUCYw6dzAAKCRBMtfaEi7xW7umoC/ 49UVQV86/AuVPkPWkdVrVkEyDS/X6YCJh7gGxvdJkHW9pGZOxawDYIWlV42qbIKWbW/FO1ZEOXmtEv +6024VtQSVK+D75MltkNDV7Q68PJaWGvjSBCOZPdXupe76AUtLrNF2fDvUrcKhNbHIqQVI3gNYNmnb 61VrmRipFhfZZP36JbCxFSIQ8fSZz/o6wdm1WJNmCG7Am+vZEpPwhsbyI5YzO8stpkpyN5KCp02rxa oW7SmnGkROBEOVPKYFGgvuA9jqu7XmBISbEZeoaVehPFeAMa+9bR8XoNz85TD+4BGoTEuYjG4PL9Qm S5QfrWEKKhvdfW3A3/qZ9sDRMaFeGuNQP1a65S2iDzXwyCBXyHbkc1JMbrecqfU1UmyoCBECD1SLDe F2TJotemis8EYU4f/N1t70u/OJQi7ah3MSuSzdS865T8L8jIYWNHnMR8q3fQimrL6A4WN4/UvcMxqr MuCBFpmLi6jwn7Ht/KNck9FqME0wqqRetzAPUnaLFKfVA= X-Mailer: git-send-email 2.37.2.672.g94769d06f0-goog Subject: [PATCH v4 05/21] cfi: Switch to -fsanitize=kcfi From: Sami Tolvanen To: linux-kernel@vger.kernel.org Cc: Kees Cook , Josh Poimboeuf , Peter Zijlstra , x86@kernel.org, Catalin Marinas , Will Deacon , Mark Rutland , Nathan Chancellor , Nick Desaulniers , Joao Moreira , Sedat Dilek , Steven Rostedt , linux-hardening@vger.kernel.org, linux-arm-kernel@lists.infradead.org, llvm@lists.linux.dev, Sami Tolvanen X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220831_003149_667495_46B0E2B6 X-CRM114-Status: GOOD ( 24.71 ) 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 U3dpdGNoIGZyb20gQ2xhbmcncyBvcmlnaW5hbCBmb3J3YXJkLWVkZ2UgY29udHJvbC1mbG93IGlu dGVncml0eQppbXBsZW1lbnRhdGlvbiB0byAtZnNhbml0aXplPWtjZmksIHdoaWNoIGlzIGJldHRl ciBzdWl0ZWQgZm9yIHRoZQprZXJuZWwsIGFzIGl0IGRvZXNuJ3QgcmVxdWlyZSBMVE8sIGRvZXNu J3QgdXNlIGEganVtcCB0YWJsZSB0aGF0CnJlcXVpcmVzIGFsdGVyaW5nIGZ1bmN0aW9uIHJlZmVy ZW5jZXMsIGFuZCB3b24ndCBicmVhayBjcm9zcy1tb2R1bGUKZnVuY3Rpb24gYWRkcmVzcyBlcXVh bGl0eS4KClNpZ25lZC1vZmYtYnk6IFNhbWkgVG9sdmFuZW4gPHNhbWl0b2x2YW5lbkBnb29nbGUu Y29tPgpSZXZpZXdlZC1ieTogS2VlcyBDb29rIDxrZWVzY29va0BjaHJvbWl1bS5vcmc+Ci0tLQog TWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDEzICstLQogYXJjaC9LY29uZmln ICAgICAgICAgICAgICAgICAgICAgIHwgICA4ICstCiBpbmNsdWRlL2FzbS1nZW5lcmljL3ZtbGlu dXgubGRzLmggfCAgMzcgKysrKy0tLS0KIGluY2x1ZGUvbGludXgvY2ZpLmggICAgICAgICAgICAg ICB8ICAyOSArKysrKy0KIGluY2x1ZGUvbGludXgvY29tcGlsZXItY2xhbmcuaCAgICB8ICAxNCAr LS0KIGluY2x1ZGUvbGludXgvbW9kdWxlLmggICAgICAgICAgICB8ICAgNiArLQoga2VybmVsL2Nm aS5jICAgICAgICAgICAgICAgICAgICAgIHwgMTQ0ICsrKysrKysrKysrKysrKy0tLS0tLS0tLS0t LS0tLQoga2VybmVsL21vZHVsZS9tYWluLmMgICAgICAgICAgICAgIHwgIDM1ICstLS0tLS0tCiBz Y3JpcHRzL21vZHVsZS5sZHMuUyAgICAgICAgICAgICAgfCAgMjMgKy0tLS0KIDkgZmlsZXMgY2hh bmdlZCwgMTMzIGluc2VydGlvbnMoKyksIDE3NiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9N YWtlZmlsZSBiL01ha2VmaWxlCmluZGV4IDk1MmQzNTQwNjlhNC4uZWVjMTQ3ZjU1NzJjIDEwMDY0 NAotLS0gYS9NYWtlZmlsZQorKysgYi9NYWtlZmlsZQpAQCAtOTIxLDE4ICs5MjEsNyBAQCBleHBv cnQgQ0NfRkxBR1NfTFRPCiBlbmRpZgogCiBpZmRlZiBDT05GSUdfQ0ZJX0NMQU5HCi1DQ19GTEFH U19DRkkJOj0gLWZzYW5pdGl6ZT1jZmkgXAotCQkgICAtZnNhbml0aXplLWNmaS1jcm9zcy1kc28g XAotCQkgICAtZm5vLXNhbml0aXplLWNmaS1jYW5vbmljYWwtanVtcC10YWJsZXMgXAotCQkgICAt Zm5vLXNhbml0aXplLXRyYXA9Y2ZpIFwKLQkJICAgLWZuby1zYW5pdGl6ZS1ibGFja2xpc3QKLQot aWZkZWYgQ09ORklHX0NGSV9QRVJNSVNTSVZFCi1DQ19GTEFHU19DRkkJKz0gLWZzYW5pdGl6ZS1y ZWNvdmVyPWNmaQotZW5kaWYKLQotIyBJZiBMVE8gZmxhZ3MgYXJlIGZpbHRlcmVkIG91dCwgd2Ug bXVzdCBhbHNvIGZpbHRlciBvdXQgQ0ZJLgotQ0NfRkxBR1NfTFRPCSs9ICQoQ0NfRkxBR1NfQ0ZJ KQorQ0NfRkxBR1NfQ0ZJCTo9IC1mc2FuaXRpemU9a2NmaQogS0JVSUxEX0NGTEFHUwkrPSAkKEND X0ZMQUdTX0NGSSkKIGV4cG9ydCBDQ19GTEFHU19DRkkKIGVuZGlmCmRpZmYgLS1naXQgYS9hcmNo L0tjb25maWcgYi9hcmNoL0tjb25maWcKaW5kZXggNWZkODc1ZTE4Yzk5Li4xYzFlY2EwYzAwMTkg MTAwNjQ0Ci0tLSBhL2FyY2gvS2NvbmZpZworKysgYi9hcmNoL0tjb25maWcKQEAgLTczOCwxMSAr NzM4LDEzIEBAIGNvbmZpZyBBUkNIX1NVUFBPUlRTX0NGSV9DTEFORwogCSAgQW4gYXJjaGl0ZWN0 dXJlIHNob3VsZCBzZWxlY3QgdGhpcyBvcHRpb24gaWYgaXQgY2FuIHN1cHBvcnQgQ2xhbmcncwog CSAgQ29udHJvbC1GbG93IEludGVncml0eSAoQ0ZJKSBjaGVja2luZy4KIAorY29uZmlnIEFSQ0hf VVNFU19DRklfVFJBUFMKKwlib29sCisKIGNvbmZpZyBDRklfQ0xBTkcKIAlib29sICJVc2UgQ2xh bmcncyBDb250cm9sIEZsb3cgSW50ZWdyaXR5IChDRkkpIgotCWRlcGVuZHMgb24gTFRPX0NMQU5H ICYmIEFSQ0hfU1VQUE9SVFNfQ0ZJX0NMQU5HCi0JZGVwZW5kcyBvbiBDTEFOR19WRVJTSU9OID49 IDE0MDAwMAotCXNlbGVjdCBLQUxMU1lNUworCWRlcGVuZHMgb24gQVJDSF9TVVBQT1JUU19DRklf Q0xBTkcKKwlkZXBlbmRzIG9uICQoY2Mtb3B0aW9uLC1mc2FuaXRpemU9a2NmaSkKIAloZWxwCiAJ ICBUaGlzIG9wdGlvbiBlbmFibGVzIENsYW5n4oCZcyBmb3J3YXJkLWVkZ2UgQ29udHJvbCBGbG93 IEludGVncml0eQogCSAgKENGSSkgY2hlY2tpbmcsIHdoZXJlIHRoZSBjb21waWxlciBpbmplY3Rz IGEgcnVudGltZSBjaGVjayB0byBlYWNoCmRpZmYgLS1naXQgYS9pbmNsdWRlL2FzbS1nZW5lcmlj L3ZtbGludXgubGRzLmggYi9pbmNsdWRlL2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmgKaW5kZXgg NzUxNWE0NjVlYzAzLi43NTAxZWRmY2UxMWUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYXNtLWdlbmVy aWMvdm1saW51eC5sZHMuaAorKysgYi9pbmNsdWRlL2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmgK QEAgLTQyMSw2ICs0MjEsMjIgQEAKIAlfX2VuZF9yb19hZnRlcl9pbml0ID0gLjsKICNlbmRpZgog CisvKgorICogLmtjZmlfdHJhcHMgY29udGFpbnMgYSBsaXN0IEtDRkkgdHJhcCBsb2NhdGlvbnMu CisgKi8KKyNpZm5kZWYgS0NGSV9UUkFQUworI2lmZGVmIENPTkZJR19BUkNIX1VTRVNfQ0ZJX1RS QVBTCisjZGVmaW5lIEtDRklfVFJBUFMJCQkJCQkJXAorCV9fa2NmaV90cmFwcyA6IEFUKEFERFIo X19rY2ZpX3RyYXBzKSAtIExPQURfT0ZGU0VUKSB7CQlcCisJCV9fc3RhcnRfX19rY2ZpX3RyYXBz ID0gLjsJCQkJXAorCQlLRUVQKCooLmtjZmlfdHJhcHMpKQkJCQkJXAorCQlfX3N0b3BfX19rY2Zp X3RyYXBzID0gLjsJCQkJXAorCX0KKyNlbHNlCisjZGVmaW5lIEtDRklfVFJBUFMKKyNlbmRpZgor I2VuZGlmCisKIC8qCiAgKiBSZWFkIG9ubHkgRGF0YQogICovCkBAIC01MjksNiArNTQ1LDggQEAK IAkJX19zdG9wX19fbW9kdmVyID0gLjsJCQkJCVwKIAl9CQkJCQkJCQlcCiAJCQkJCQkJCQlcCisJ S0NGSV9UUkFQUwkJCQkJCQlcCisJCQkJCQkJCQlcCiAJUk9fRVhDRVBUSU9OX1RBQkxFCQkJCQkJ XAogCU5PVEVTCQkJCQkJCQlcCiAJQlRGCQkJCQkJCQlcCkBAIC01MzcsMjEgKzU1NSw2IEBACiAJ X19lbmRfcm9kYXRhID0gLjsKIAogCi0vKgotICogLnRleHQuLkwuY2ZpLmp1bXB0YWJsZS4qIGNv bnRhaW4gQ29udHJvbC1GbG93IEludGVncml0eSAoQ0ZJKQotICoganVtcCB0YWJsZSBlbnRyaWVz LgotICovCi0jaWZkZWYgQ09ORklHX0NGSV9DTEFORwotI2RlZmluZSBURVhUX0NGSV9KVAkJCQkJ CQlcCi0JCS4gPSBBTElHTihQTURfU0laRSk7CQkJCQlcCi0JCV9fY2ZpX2p0X3N0YXJ0ID0gLjsJ CQkJCVwKLQkJKigudGV4dC4uTC5jZmkuanVtcHRhYmxlIC50ZXh0Li5MLmNmaS5qdW1wdGFibGUu KikJXAotCQkuID0gQUxJR04oUE1EX1NJWkUpOwkJCQkJXAotCQlfX2NmaV9qdF9lbmQgPSAuOwot I2Vsc2UKLSNkZWZpbmUgVEVYVF9DRklfSlQKLSNlbmRpZgotCiAvKgogICogTm9uLWluc3RydW1l bnRhYmxlIHRleHQgc2VjdGlvbgogICovCkBAIC01NzksNyArNTgyLDYgQEAKIAkJKigudGV4dC4u cmVmY291bnQpCQkJCQlcCiAJCSooLnJlZi50ZXh0KQkJCQkJCVwKIAkJKigudGV4dC5hc2FuLiog LnRleHQudHNhbi4qKQkJCQlcCi0JCVRFWFRfQ0ZJX0pUCQkJCQkJXAogCU1FTV9LRUVQKGluaXQu dGV4dCopCQkJCQkJXAogCU1FTV9LRUVQKGV4aXQudGV4dCopCQkJCQkJXAogCkBAIC0xMDA4LDgg KzEwMTAsNyBAQAogICoga2VlcCBhbnkgLmluaXRfYXJyYXkuKiBzZWN0aW9ucy4KICAqIGh0dHBz Oi8vYnVncy5sbHZtLm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDY0NzgKICAqLwotI2lmIGRlZmluZWQo Q09ORklHX0dDT1ZfS0VSTkVMKSB8fCBkZWZpbmVkKENPTkZJR19LQVNBTl9HRU5FUklDKSB8fCBk ZWZpbmVkKENPTkZJR19LQ1NBTikgfHwgXAotCWRlZmluZWQoQ09ORklHX0NGSV9DTEFORykKKyNp ZiBkZWZpbmVkKENPTkZJR19HQ09WX0tFUk5FTCkgfHwgZGVmaW5lZChDT05GSUdfS0FTQU5fR0VO RVJJQykgfHwgZGVmaW5lZChDT05GSUdfS0NTQU4pCiAjIGlmZGVmIENPTkZJR19DT05TVFJVQ1RP UlMKICMgIGRlZmluZSBTQU5JVElaRVJfRElTQ0FSRFMJCQkJCQlcCiAJKiguZWhfZnJhbWUpCmRp ZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2NmaS5oIGIvaW5jbHVkZS9saW51eC9jZmkuaAppbmRl eCAyY2RiYzBmYmQwYWIuLjVlMTM0ZjRjZThiNyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9j ZmkuaAorKysgYi9pbmNsdWRlL2xpbnV4L2NmaS5oCkBAIC0yLDE3ICsyLDM4IEBACiAvKgogICog Q2xhbmcgQ29udHJvbCBGbG93IEludGVncml0eSAoQ0ZJKSBzdXBwb3J0LgogICoKLSAqIENvcHly aWdodCAoQykgMjAyMSBHb29nbGUgTExDCisgKiBDb3B5cmlnaHQgKEMpIDIwMjIgR29vZ2xlIExM QwogICovCiAjaWZuZGVmIF9MSU5VWF9DRklfSAogI2RlZmluZSBfTElOVVhfQ0ZJX0gKIAorI2lu Y2x1ZGUgPGxpbnV4L2J1Zy5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorCiAjaWZkZWYg Q09ORklHX0NGSV9DTEFORwotdHlwZWRlZiB2b2lkICgqY2ZpX2NoZWNrX2ZuKSh1aW50NjRfdCBp ZCwgdm9pZCAqcHRyLCB2b2lkICpkaWFnKTsKK2VudW0gYnVnX3RyYXBfdHlwZSByZXBvcnRfY2Zp X2ZhaWx1cmUoc3RydWN0IHB0X3JlZ3MgKnJlZ3MsIHVuc2lnbmVkIGxvbmcgYWRkciwKKwkJCQkg ICAgICB1bnNpZ25lZCBsb25nICp0YXJnZXQsIHUzMiB0eXBlKTsKIAotLyogQ29tcGlsZXItZ2Vu ZXJhdGVkIGZ1bmN0aW9uIGluIGVhY2ggbW9kdWxlLCBhbmQgdGhlIGtlcm5lbCAqLwotZXh0ZXJu IHZvaWQgX19jZmlfY2hlY2sodWludDY0X3QgaWQsIHZvaWQgKnB0ciwgdm9pZCAqZGlhZyk7Citz dGF0aWMgaW5saW5lIGVudW0gYnVnX3RyYXBfdHlwZSByZXBvcnRfY2ZpX2ZhaWx1cmVfbm9hZGRy KHN0cnVjdCBwdF9yZWdzICpyZWdzLAorCQkJCQkJCSAgIHVuc2lnbmVkIGxvbmcgYWRkcikKK3sK KwlyZXR1cm4gcmVwb3J0X2NmaV9mYWlsdXJlKHJlZ3MsIGFkZHIsIE5VTEwsIDApOworfQogCisj aWZkZWYgQ09ORklHX0FSQ0hfVVNFU19DRklfVFJBUFMKK2Jvb2wgaXNfY2ZpX3RyYXAodW5zaWdu ZWQgbG9uZyBhZGRyKTsKKyNlbmRpZgogI2VuZGlmIC8qIENPTkZJR19DRklfQ0xBTkcgKi8KIAor I2lmZGVmIENPTkZJR19NT0RVTEVTCisjaWZkZWYgQ09ORklHX0FSQ0hfVVNFU19DRklfVFJBUFMK K3ZvaWQgbW9kdWxlX2NmaV9maW5hbGl6ZShjb25zdCBFbGZfRWhkciAqaGRyLCBjb25zdCBFbGZf U2hkciAqc2VjaGRycywKKwkJCSBzdHJ1Y3QgbW9kdWxlICptb2QpOworI2Vsc2UKK3N0YXRpYyBp bmxpbmUgdm9pZCBtb2R1bGVfY2ZpX2ZpbmFsaXplKGNvbnN0IEVsZl9FaGRyICpoZHIsCisJCQkJ ICAgICAgIGNvbnN0IEVsZl9TaGRyICpzZWNoZHJzLAorCQkJCSAgICAgICBzdHJ1Y3QgbW9kdWxl ICptb2QpIHt9CisjZW5kaWYgLyogQ09ORklHX0FSQ0hfVVNFU19DRklfVFJBUFMgKi8KKyNlbmRp ZiAvKiBDT05GSUdfTU9EVUxFUyAqLworCiAjZW5kaWYgLyogX0xJTlVYX0NGSV9IICovCmRpZmYg LS1naXQgYS9pbmNsdWRlL2xpbnV4L2NvbXBpbGVyLWNsYW5nLmggYi9pbmNsdWRlL2xpbnV4L2Nv bXBpbGVyLWNsYW5nLmgKaW5kZXggYzg0ZmVjNzY3NDQ1Li40MmU1NTU3OWQ2NDkgMTAwNjQ0Ci0t LSBhL2luY2x1ZGUvbGludXgvY29tcGlsZXItY2xhbmcuaAorKysgYi9pbmNsdWRlL2xpbnV4L2Nv bXBpbGVyLWNsYW5nLmgKQEAgLTY2LDE3ICs2Niw5IEBACiAjIGRlZmluZSBfX25vc2NzCV9fYXR0 cmlidXRlX18oKF9fbm9fc2FuaXRpemVfXygic2hhZG93LWNhbGwtc3RhY2siKSkpCiAjZW5kaWYK IAotI2RlZmluZSBfX25vY2ZpCQlfX2F0dHJpYnV0ZV9fKChfX25vX3Nhbml0aXplX18oImNmaSIp KSkKLSNkZWZpbmUgX19jZmljYW5vbmljYWwJX19hdHRyaWJ1dGVfXygoX19jZmlfY2Fub25pY2Fs X2p1bXBfdGFibGVfXykpCi0KLSNpZiBkZWZpbmVkKENPTkZJR19DRklfQ0xBTkcpCi0vKgotICog V2l0aCBDT05GSUdfQ0ZJX0NMQU5HLCB0aGUgY29tcGlsZXIgcmVwbGFjZXMgZnVuY3Rpb24gYWRk cmVzcwotICogcmVmZXJlbmNlcyB3aXRoIHRoZSBhZGRyZXNzIG9mIHRoZSBmdW5jdGlvbidzIENG SSBqdW1wIHRhYmxlCi0gKiBlbnRyeS4gVGhlIGZ1bmN0aW9uX25vY2ZpIG1hY3JvIGFsd2F5cyBy ZXR1cm5zIHRoZSBhZGRyZXNzIG9mIHRoZQotICogYWN0dWFsIGZ1bmN0aW9uIGluc3RlYWQuCi0g Ki8KLSNkZWZpbmUgZnVuY3Rpb25fbm9jZmkoeCkJX19idWlsdGluX2Z1bmN0aW9uX3N0YXJ0KHgp CisjaWYgX19oYXNfZmVhdHVyZShrY2ZpKQorLyogRGlzYWJsZSBDRkkgY2hlY2tpbmcgaW5zaWRl IGEgZnVuY3Rpb24uICovCisjZGVmaW5lIF9fbm9jZmkJCV9fYXR0cmlidXRlX18oKF9fbm9fc2Fu aXRpemVfXygia2NmaSIpKSkKICNlbmRpZgogCiAvKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51 eC9tb2R1bGUuaCBiL2luY2x1ZGUvbGludXgvbW9kdWxlLmgKaW5kZXggODkzN2IwMjBlYzA0Li5l YzYxZmI1Mzk3OWEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbW9kdWxlLmgKKysrIGIvaW5j bHVkZS9saW51eC9tb2R1bGUuaApAQCAtMjcsNyArMjcsNiBAQAogI2luY2x1ZGUgPGxpbnV4L3Ry YWNlcG9pbnQtZGVmcy5oPgogI2luY2x1ZGUgPGxpbnV4L3NyY3UuaD4KICNpbmNsdWRlIDxsaW51 eC9zdGF0aWNfY2FsbF90eXBlcy5oPgotI2luY2x1ZGUgPGxpbnV4L2NmaS5oPgogCiAjaW5jbHVk ZSA8bGludXgvcGVyY3B1Lmg+CiAjaW5jbHVkZSA8YXNtL21vZHVsZS5oPgpAQCAtMzg3LDggKzM4 Niw5IEBAIHN0cnVjdCBtb2R1bGUgewogCWNvbnN0IHMzMiAqY3JjczsKIAl1bnNpZ25lZCBpbnQg bnVtX3N5bXM7CiAKLSNpZmRlZiBDT05GSUdfQ0ZJX0NMQU5HCi0JY2ZpX2NoZWNrX2ZuIGNmaV9j aGVjazsKKyNpZmRlZiBDT05GSUdfQVJDSF9VU0VTX0NGSV9UUkFQUworCXMzMiAqa2NmaV90cmFw czsKKwlzMzIgKmtjZmlfdHJhcHNfZW5kOwogI2VuZGlmCiAKIAkvKiBLZXJuZWwgcGFyYW1ldGVy cy4gKi8KZGlmZiAtLWdpdCBhL2tlcm5lbC9jZmkuYyBiL2tlcm5lbC9jZmkuYwppbmRleCBlOGJj MWIzNzBlZGMuLjA4Y2FhZDc3NjcxNyAxMDA2NDQKLS0tIGEva2VybmVsL2NmaS5jCisrKyBiL2tl cm5lbC9jZmkuYwpAQCAtMSwxMDUgKzEsMTAxIEBACiAvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmll cjogR1BMLTIuMAogLyoKLSAqIENsYW5nIENvbnRyb2wgRmxvdyBJbnRlZ3JpdHkgKENGSSkgZXJy b3IgYW5kIHNsb3dwYXRoIGhhbmRsaW5nLgorICogQ2xhbmcgQ29udHJvbCBGbG93IEludGVncml0 eSAoQ0ZJKSBlcnJvciBoYW5kbGluZy4KICAqCi0gKiBDb3B5cmlnaHQgKEMpIDIwMjEgR29vZ2xl IExMQworICogQ29weXJpZ2h0IChDKSAyMDIyIEdvb2dsZSBMTEMKICAqLwogCi0jaW5jbHVkZSA8 bGludXgvaGFyZGlycS5oPgotI2luY2x1ZGUgPGxpbnV4L2thbGxzeW1zLmg+Ci0jaW5jbHVkZSA8 bGludXgvbW9kdWxlLmg+Ci0jaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KLSNpbmNsdWRlIDxsaW51 eC9wcmludGsuaD4KLSNpbmNsdWRlIDxsaW51eC9yYXRlbGltaXQuaD4KLSNpbmNsdWRlIDxsaW51 eC9yY3VwZGF0ZS5oPgotI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KLSNpbmNsdWRlIDxhc20v Y2FjaGVmbHVzaC5oPgotI2luY2x1ZGUgPGFzbS9zZXRfbWVtb3J5Lmg+Ci0KLS8qIENvbXBpbGVy LWRlZmluZWQgaGFuZGxlciBuYW1lcyAqLwotI2lmZGVmIENPTkZJR19DRklfUEVSTUlTU0lWRQot I2RlZmluZSBjZmlfZmFpbHVyZV9oYW5kbGVyCV9fdWJzYW5faGFuZGxlX2NmaV9jaGVja19mYWls Ci0jZWxzZQotI2RlZmluZSBjZmlfZmFpbHVyZV9oYW5kbGVyCV9fdWJzYW5faGFuZGxlX2NmaV9j aGVja19mYWlsX2Fib3J0Ci0jZW5kaWYKLQotc3RhdGljIGlubGluZSB2b2lkIGhhbmRsZV9jZmlf ZmFpbHVyZSh2b2lkICpwdHIpCisjaW5jbHVkZSA8bGludXgvY2ZpLmg+CisKK2VudW0gYnVnX3Ry YXBfdHlwZSByZXBvcnRfY2ZpX2ZhaWx1cmUoc3RydWN0IHB0X3JlZ3MgKnJlZ3MsIHVuc2lnbmVk IGxvbmcgYWRkciwKKwkJCQkgICAgICB1bnNpZ25lZCBsb25nICp0YXJnZXQsIHUzMiB0eXBlKQog ewotCWlmIChJU19FTkFCTEVEKENPTkZJR19DRklfUEVSTUlTU0lWRSkpCi0JCVdBUk5fUkFURUxJ TUlUKDEsICJDRkkgZmFpbHVyZSAodGFyZ2V0OiAlcFMpOlxuIiwgcHRyKTsKKwlpZiAodGFyZ2V0 KQorCQlwcl9lcnIoIkNGSSBmYWlsdXJlIGF0ICVwUyAodGFyZ2V0OiAlcFM7IGV4cGVjdGVkIHR5 cGU6IDB4JTA4eClcbiIsCisJCSAgICAgICAodm9pZCAqKWFkZHIsICh2b2lkICopKnRhcmdldCwg dHlwZSk7CiAJZWxzZQotCQlwYW5pYygiQ0ZJIGZhaWx1cmUgKHRhcmdldDogJXBTKVxuIiwgcHRy KTsKKwkJcHJfZXJyKCJDRkkgZmFpbHVyZSBhdCAlcFMgKG5vIHRhcmdldCBpbmZvcm1hdGlvbilc biIsCisJCSAgICAgICAodm9pZCAqKWFkZHIpOworCisJaWYgKElTX0VOQUJMRUQoQ09ORklHX0NG SV9QRVJNSVNTSVZFKSkgeworCQlfX3dhcm4oTlVMTCwgMCwgKHZvaWQgKilhZGRyLCAwLCByZWdz LCBOVUxMKTsKKwkJcmV0dXJuIEJVR19UUkFQX1RZUEVfV0FSTjsKKwl9CisKKwlyZXR1cm4gQlVH X1RSQVBfVFlQRV9CVUc7CiB9CiAKLSNpZmRlZiBDT05GSUdfTU9EVUxFUworI2lmZGVmIENPTkZJ R19BUkNIX1VTRVNfQ0ZJX1RSQVBTCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgdHJhcF9h ZGRyZXNzKHMzMiAqcCkKK3sKKwlyZXR1cm4gKHVuc2lnbmVkIGxvbmcpKChsb25nKXAgKyAobG9u ZykqcCk7Cit9CiAKLXN0YXRpYyBpbmxpbmUgY2ZpX2NoZWNrX2ZuIGZpbmRfbW9kdWxlX2NoZWNr X2ZuKHVuc2lnbmVkIGxvbmcgcHRyKQorc3RhdGljIGJvb2wgaXNfdHJhcCh1bnNpZ25lZCBsb25n IGFkZHIsIHMzMiAqc3RhcnQsIHMzMiAqZW5kKQogewotCWNmaV9jaGVja19mbiBmbiA9IE5VTEw7 Ci0Jc3RydWN0IG1vZHVsZSAqbW9kOworCXMzMiAqcDsKIAotCXJjdV9yZWFkX2xvY2tfc2NoZWRf bm90cmFjZSgpOwotCW1vZCA9IF9fbW9kdWxlX2FkZHJlc3MocHRyKTsKLQlpZiAobW9kKQotCQlm biA9IG1vZC0+Y2ZpX2NoZWNrOwotCXJjdV9yZWFkX3VubG9ja19zY2hlZF9ub3RyYWNlKCk7CisJ Zm9yIChwID0gc3RhcnQ7IHAgPCBlbmQ7ICsrcCkgeworCQlpZiAodHJhcF9hZGRyZXNzKHApID09 IGFkZHIpCisJCQlyZXR1cm4gdHJ1ZTsKKwl9CiAKLQlyZXR1cm4gZm47CisJcmV0dXJuIGZhbHNl OwogfQogCi1zdGF0aWMgaW5saW5lIGNmaV9jaGVja19mbiBmaW5kX2NoZWNrX2ZuKHVuc2lnbmVk IGxvbmcgcHRyKQorI2lmZGVmIENPTkZJR19NT0RVTEVTCisvKiBQb3B1bGF0ZXMgYGtjZmlfdHJh cChfZW5kKT9gIGZpZWxkcyBpbiBgc3RydWN0IG1vZHVsZWAuICovCit2b2lkIG1vZHVsZV9jZmlf ZmluYWxpemUoY29uc3QgRWxmX0VoZHIgKmhkciwgY29uc3QgRWxmX1NoZHIgKnNlY2hkcnMsCisJ CQkgc3RydWN0IG1vZHVsZSAqbW9kKQogewotCWNmaV9jaGVja19mbiBmbiA9IE5VTEw7Ci0JdW5z aWduZWQgbG9uZyBmbGFnczsKLQlib29sIHJjdV9pZGxlOwotCi0JaWYgKGlzX2tlcm5lbF90ZXh0 KHB0cikpCi0JCXJldHVybiBfX2NmaV9jaGVjazsKLQotCS8qCi0JICogSW5kaXJlY3QgY2FsbCBj aGVja3MgY2FuIGhhcHBlbiB3aGVuIFJDVSBpcyBub3Qgd2F0Y2hpbmcuIEJvdGgKLQkgKiB0aGUg c2hhZG93IGFuZCBfX21vZHVsZV9hZGRyZXNzIHVzZSBSQ1UsIHNvIHdlIG5lZWQgdG8gd2FrZSBp dAotCSAqIHVwIGlmIG5lY2Vzc2FyeS4KLQkgKi8KLQlyY3VfaWRsZSA9ICFyY3VfaXNfd2F0Y2hp bmcoKTsKLQlpZiAocmN1X2lkbGUpIHsKLQkJbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOwotCQljdF9p cnFfZW50ZXIoKTsKLQl9CisJY2hhciAqc2Vjc3RyaW5nczsKKwl1bnNpZ25lZCBpbnQgaTsKIAot CWZuID0gZmluZF9tb2R1bGVfY2hlY2tfZm4ocHRyKTsKKwltb2QtPmtjZmlfdHJhcHMgPSBOVUxM OworCW1vZC0+a2NmaV90cmFwc19lbmQgPSBOVUxMOwogCi0JaWYgKHJjdV9pZGxlKSB7Ci0JCWN0 X2lycV9leGl0KCk7Ci0JCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKLQl9CisJc2Vjc3RyaW5n cyA9IChjaGFyICopaGRyICsgc2VjaGRyc1toZHItPmVfc2hzdHJuZHhdLnNoX29mZnNldDsKKwor CWZvciAoaSA9IDE7IGkgPCBoZHItPmVfc2hudW07IGkrKykgeworCQlpZiAoc3RyY21wKHNlY3N0 cmluZ3MgKyBzZWNoZHJzW2ldLnNoX25hbWUsICJfX2tjZmlfdHJhcHMiKSkKKwkJCWNvbnRpbnVl OwogCi0JcmV0dXJuIGZuOworCQltb2QtPmtjZmlfdHJhcHMgPSAoczMyICopc2VjaGRyc1tpXS5z aF9hZGRyOworCQltb2QtPmtjZmlfdHJhcHNfZW5kID0gKHMzMiAqKShzZWNoZHJzW2ldLnNoX2Fk ZHIgKyBzZWNoZHJzW2ldLnNoX3NpemUpOworCQlicmVhazsKKwl9CiB9CiAKLXZvaWQgX19jZmlf c2xvd3BhdGhfZGlhZyh1aW50NjRfdCBpZCwgdm9pZCAqcHRyLCB2b2lkICpkaWFnKQorc3RhdGlj IGJvb2wgaXNfbW9kdWxlX2NmaV90cmFwKHVuc2lnbmVkIGxvbmcgYWRkcikKIHsKLQljZmlfY2hl Y2tfZm4gZm4gPSBmaW5kX2NoZWNrX2ZuKCh1bnNpZ25lZCBsb25nKXB0cik7CisJc3RydWN0IG1v ZHVsZSAqbW9kOworCWJvb2wgZm91bmQgPSBmYWxzZTsKIAotCWlmIChsaWtlbHkoZm4pKQotCQlm bihpZCwgcHRyLCBkaWFnKTsKLQllbHNlIC8qIERvbid0IGFsbG93IHVuY2hlY2tlZCBtb2R1bGVz ICovCi0JCWhhbmRsZV9jZmlfZmFpbHVyZShwdHIpOwotfQotRVhQT1JUX1NZTUJPTChfX2NmaV9z bG93cGF0aF9kaWFnKTsKKwlyY3VfcmVhZF9sb2NrX3NjaGVkX25vdHJhY2UoKTsKIAotI2Vsc2Ug LyogIUNPTkZJR19NT0RVTEVTICovCisJbW9kID0gX19tb2R1bGVfYWRkcmVzcyhhZGRyKTsKKwlp ZiAobW9kKQorCQlmb3VuZCA9IGlzX3RyYXAoYWRkciwgbW9kLT5rY2ZpX3RyYXBzLCBtb2QtPmtj ZmlfdHJhcHNfZW5kKTsKIAotdm9pZCBfX2NmaV9zbG93cGF0aF9kaWFnKHVpbnQ2NF90IGlkLCB2 b2lkICpwdHIsIHZvaWQgKmRpYWcpCisJcmN1X3JlYWRfdW5sb2NrX3NjaGVkX25vdHJhY2UoKTsK KworCXJldHVybiBmb3VuZDsKK30KKyNlbHNlIC8qIENPTkZJR19NT0RVTEVTICovCitzdGF0aWMg aW5saW5lIGJvb2wgaXNfbW9kdWxlX2NmaV90cmFwKHVuc2lnbmVkIGxvbmcgYWRkcikKIHsKLQlo YW5kbGVfY2ZpX2ZhaWx1cmUocHRyKTsgLyogTm8gbW9kdWxlcyAqLworCXJldHVybiBmYWxzZTsK IH0KLUVYUE9SVF9TWU1CT0woX19jZmlfc2xvd3BhdGhfZGlhZyk7Ci0KICNlbmRpZiAvKiBDT05G SUdfTU9EVUxFUyAqLwogCi12b2lkIGNmaV9mYWlsdXJlX2hhbmRsZXIodm9pZCAqZGF0YSwgdm9p ZCAqcHRyLCB2b2lkICp2dGFibGUpCitleHRlcm4gczMyIF9fc3RhcnRfX19rY2ZpX3RyYXBzW107 CitleHRlcm4gczMyIF9fc3RvcF9fX2tjZmlfdHJhcHNbXTsKKworYm9vbCBpc19jZmlfdHJhcCh1 bnNpZ25lZCBsb25nIGFkZHIpCiB7Ci0JaGFuZGxlX2NmaV9mYWlsdXJlKHB0cik7CisJaWYgKGlz X3RyYXAoYWRkciwgX19zdGFydF9fX2tjZmlfdHJhcHMsIF9fc3RvcF9fX2tjZmlfdHJhcHMpKQor CQlyZXR1cm4gdHJ1ZTsKKworCXJldHVybiBpc19tb2R1bGVfY2ZpX3RyYXAoYWRkcik7CiB9Ci1F WFBPUlRfU1lNQk9MKGNmaV9mYWlsdXJlX2hhbmRsZXIpOworI2VuZGlmIC8qIENPTkZJR19BUkNI X1VTRVNfQ0ZJX1RSQVBTICovCmRpZmYgLS1naXQgYS9rZXJuZWwvbW9kdWxlL21haW4uYyBiL2tl cm5lbC9tb2R1bGUvbWFpbi5jCmluZGV4IDAyMjhmNDRiNThlNS4uNzBjMGIyYzZmZWY4IDEwMDY0 NAotLS0gYS9rZXJuZWwvbW9kdWxlL21haW4uYworKysgYi9rZXJuZWwvbW9kdWxlL21haW4uYwpA QCAtNTMsNiArNTMsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2JzZWFyY2guaD4KICNpbmNsdWRlIDxs aW51eC9keW5hbWljX2RlYnVnLmg+CiAjaW5jbHVkZSA8bGludXgvYXVkaXQuaD4KKyNpbmNsdWRl IDxsaW51eC9jZmkuaD4KICNpbmNsdWRlIDx1YXBpL2xpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUg ImludGVybmFsLmgiCiAKQEAgLTI1OTcsOCArMjU5OCw5IEBAIHN0YXRpYyBpbnQgY29tcGxldGVf Zm9ybWF0aW9uKHN0cnVjdCBtb2R1bGUgKm1vZCwgc3RydWN0IGxvYWRfaW5mbyAqaW5mbykKIAlp ZiAoZXJyIDwgMCkKIAkJZ290byBvdXQ7CiAKLQkvKiBUaGlzIHJlbGllcyBvbiBtb2R1bGVfbXV0 ZXggZm9yIGxpc3QgaW50ZWdyaXR5LiAqLworCS8qIFRoZXNlIHJlbHkgb24gbW9kdWxlX211dGV4 IGZvciBsaXN0IGludGVncml0eS4gKi8KIAltb2R1bGVfYnVnX2ZpbmFsaXplKGluZm8tPmhkciwg aW5mby0+c2VjaGRycywgbW9kKTsKKwltb2R1bGVfY2ZpX2ZpbmFsaXplKGluZm8tPmhkciwgaW5m by0+c2VjaGRycywgbW9kKTsKIAogCWlmIChtb2R1bGVfY2hlY2tfbWlzYWxpZ25tZW50KG1vZCkp CiAJCWdvdG8gb3V0X21pc2FsaWduZWQ7CkBAIC0yNjYwLDggKzI2NjIsNiBAQCBzdGF0aWMgaW50 IHVua25vd25fbW9kdWxlX3BhcmFtX2NiKGNoYXIgKnBhcmFtLCBjaGFyICp2YWwsIGNvbnN0IGNo YXIgKm1vZG5hbWUsCiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyB2b2lkIGNmaV9pbml0KHN0cnVj dCBtb2R1bGUgKm1vZCk7Ci0KIC8qCiAgKiBBbGxvY2F0ZSBhbmQgbG9hZCB0aGUgbW9kdWxlOiBu b3RlIHRoYXQgc2l6ZSBvZiBzZWN0aW9uIDAgaXMgYWx3YXlzCiAgKiB6ZXJvLCBhbmQgd2UgcmVs eSBvbiB0aGlzIGZvciBvcHRpb25hbCBzZWN0aW9ucy4KQEAgLTI3OTEsOSArMjc5MSw2IEBAIHN0 YXRpYyBpbnQgbG9hZF9tb2R1bGUoc3RydWN0IGxvYWRfaW5mbyAqaW5mbywgY29uc3QgY2hhciBf X3VzZXIgKnVhcmdzLAogCiAJZmx1c2hfbW9kdWxlX2ljYWNoZShtb2QpOwogCi0JLyogU2V0dXAg Q0ZJIGZvciB0aGUgbW9kdWxlLiAqLwotCWNmaV9pbml0KG1vZCk7Ci0KIAkvKiBOb3cgY29weSBp biBhcmdzICovCiAJbW9kLT5hcmdzID0gc3RybmR1cF91c2VyKHVhcmdzLCB+MFVMID4+IDEpOwog CWlmIChJU19FUlIobW9kLT5hcmdzKSkgewpAQCAtMjk1NSwzMiArMjk1Miw2IEBAIHN0YXRpYyBp bmxpbmUgaW50IHdpdGhpbih1bnNpZ25lZCBsb25nIGFkZHIsIHZvaWQgKnN0YXJ0LCB1bnNpZ25l ZCBsb25nIHNpemUpCiAJcmV0dXJuICgodm9pZCAqKWFkZHIgPj0gc3RhcnQgJiYgKHZvaWQgKilh ZGRyIDwgc3RhcnQgKyBzaXplKTsKIH0KIAotc3RhdGljIHZvaWQgY2ZpX2luaXQoc3RydWN0IG1v ZHVsZSAqbW9kKQotewotI2lmZGVmIENPTkZJR19DRklfQ0xBTkcKLQlpbml0Y2FsbF90ICppbml0 OwotI2lmZGVmIENPTkZJR19NT0RVTEVfVU5MT0FECi0JZXhpdGNhbGxfdCAqZXhpdDsKLSNlbmRp ZgotCi0JcmN1X3JlYWRfbG9ja19zY2hlZCgpOwotCW1vZC0+Y2ZpX2NoZWNrID0gKGNmaV9jaGVj a19mbikKLQkJZmluZF9rYWxsc3ltc19zeW1ib2xfdmFsdWUobW9kLCAiX19jZmlfY2hlY2siKTsK LQlpbml0ID0gKGluaXRjYWxsX3QgKikKLQkJZmluZF9rYWxsc3ltc19zeW1ib2xfdmFsdWUobW9k LCAiX19jZmlfanRfaW5pdF9tb2R1bGUiKTsKLQkvKiBGaXggaW5pdC9leGl0IGZ1bmN0aW9ucyB0 byBwb2ludCB0byB0aGUgQ0ZJIGp1bXAgdGFibGUgKi8KLQlpZiAoaW5pdCkKLQkJbW9kLT5pbml0 ID0gKmluaXQ7Ci0jaWZkZWYgQ09ORklHX01PRFVMRV9VTkxPQUQKLQlleGl0ID0gKGV4aXRjYWxs X3QgKikKLQkJZmluZF9rYWxsc3ltc19zeW1ib2xfdmFsdWUobW9kLCAiX19jZmlfanRfY2xlYW51 cF9tb2R1bGUiKTsKLQlpZiAoZXhpdCkKLQkJbW9kLT5leGl0ID0gKmV4aXQ7Ci0jZW5kaWYKLQly Y3VfcmVhZF91bmxvY2tfc2NoZWQoKTsKLSNlbmRpZgotfQotCiAvKiBLZWVwIGluIHN5bmMgd2l0 aCBNT0RVTEVfRkxBR1NfQlVGX1NJWkUgISEhICovCiBjaGFyICptb2R1bGVfZmxhZ3Moc3RydWN0 IG1vZHVsZSAqbW9kLCBjaGFyICpidWYsIGJvb2wgc2hvd19zdGF0ZSkKIHsKZGlmZiAtLWdpdCBh L3NjcmlwdHMvbW9kdWxlLmxkcy5TIGIvc2NyaXB0cy9tb2R1bGUubGRzLlMKaW5kZXggM2EzYWEy MzU0ZWQ4Li5kYTRiZGRkMjYxNzEgMTAwNjQ0Ci0tLSBhL3NjcmlwdHMvbW9kdWxlLmxkcy5TCisr KyBiL3NjcmlwdHMvbW9kdWxlLmxkcy5TCkBAIC0zLDIwICszLDEwIEBACiAgKiBBcmNocyBhcmUg ZnJlZSB0byBzdXBwbHkgdGhlaXIgb3duIGxpbmtlciBzY3JpcHRzLiAgbGQgd2lsbAogICogY29t YmluZSB0aGVtIGF1dG9tYXRpY2FsbHkuCiAgKi8KLSNpZmRlZiBDT05GSUdfQ0ZJX0NMQU5HCi0j IGluY2x1ZGUgPGFzbS9wYWdlLmg+Ci0jIGRlZmluZSBBTElHTl9DRkkgCQlBTElHTihQQUdFX1NJ WkUpCi0jIGRlZmluZSBTQU5JVElaRVJfRElTQ0FSRFMJKiguZWhfZnJhbWUpCi0jZWxzZQotIyBk ZWZpbmUgQUxJR05fQ0ZJCi0jIGRlZmluZSBTQU5JVElaRVJfRElTQ0FSRFMKLSNlbmRpZgotCiBT RUNUSU9OUyB7CiAJL0RJU0NBUkQvIDogewogCQkqKC5kaXNjYXJkKQogCQkqKC5kaXNjYXJkLiop Ci0JCVNBTklUSVpFUl9ESVNDQVJEUwogCX0KIAogCV9fa3N5bXRhYgkJMCA6IHsgKihTT1JUKF9f X2tzeW10YWIrKikpIH0KQEAgLTMzLDYgKzIzLDEwIEBAIFNFQ1RJT05TIHsKIAogCV9fcGF0Y2hh YmxlX2Z1bmN0aW9uX2VudHJpZXMgOiB7ICooX19wYXRjaGFibGVfZnVuY3Rpb25fZW50cmllcykg fQogCisjaWZkZWYgQ09ORklHX0FSQ0hfVVNFU19DRklfVFJBUFMKKwlfX2tjZmlfdHJhcHMgCQk6 IHsgS0VFUCgqKC5rY2ZpX3RyYXBzKSkgfQorI2VuZGlmCisKICNpZmRlZiBDT05GSUdfTFRPX0NM QU5HCiAJLyoKIAkgKiBXaXRoIENPTkZJR19MVE9fQ0xBTkcsIExMRCBhbHdheXMgZW5hYmxlcyAt ZmRhdGEtc2VjdGlvbnMgYW5kCkBAIC01MywxNSArNDcsNiBAQCBTRUNUSU9OUyB7CiAJCSooLnJv ZGF0YSAucm9kYXRhLlswLTlhLXpBLVpfXSopCiAJCSooLnJvZGF0YS4uTCopCiAJfQotCi0JLyoK LQkgKiBXaXRoIENPTkZJR19DRklfQ0xBTkcsIHdlIGFzc3VtZSBfX2NmaV9jaGVjayBpcyBhdCB0 aGUgYmVnaW5uaW5nCi0JICogb2YgdGhlIC50ZXh0IHNlY3Rpb24sIGFuZCBpcyBhbGlnbmVkIHRv IFBBR0VfU0laRS4KLQkgKi8KLQkudGV4dCA6IEFMSUdOX0NGSSB7Ci0JCSooLnRleHQuX19jZmlf Y2hlY2spCi0JCSooLnRleHQgLnRleHQuWzAtOWEtekEtWl9dKiAudGV4dC4uTC5jZmkqKQotCX0K ICNlbmRpZgogfQogCi0tIAoyLjM3LjIuNjcyLmc5NDc2OWQwNmYwLWdvb2cKCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1h aWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xp c3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==