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 F0621221572; Fri, 23 May 2025 04:39:38 +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=1747975179; cv=none; b=ry6tpHG3NABxqyzvPLQ/NJ6RI+y8mINZlDhH24LWTAlw1wy6qSy2gSOk8pCavrAVAaPkC+0sXv6MzmLz6N0yrAcGeKExQI9gxUEWUjV9+iuAXGjL/aEVbNgNUXn7TGBYNUXphZWzMjxjhQ7m62D0+dvOUdUFDoNPogPyxOcu1uI= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1747975179; c=relaxed/simple; bh=9AkAkSKl9S4JaL8v+O2hS6MFbAfqao2mTLxrmw6SRmE=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=bCM9Q0O8bJhCmW7ySAcZ2AHbBbE6HkoQQd768tTbGmOHzGdMjEhvbV/BjJid+2UEgnA2WQ1QuQgW5yMXrfgM/tawZYmw2ooynA66G6V+j/4FFpU0B+oSIp8eynDJs+lvBhJ8CnZ/xoOQEIyyM0TSbROYTItnBwNeQk6FN9yJtzY= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=BwShGNjl; 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="BwShGNjl" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 628DBC4CEE9; Fri, 23 May 2025 04:39:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1747975178; bh=9AkAkSKl9S4JaL8v+O2hS6MFbAfqao2mTLxrmw6SRmE=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=BwShGNjlDVKDb99dus3C4Aw4MVpsaV7mbXYwh1hIrC7DuKXYqlAVmVavm1HNkRlVn 4L159ccVT45fGrMrmEAaS88OmwMFBAJT8P2982HyEO03BkNFQtXtfwKe+orPtkU+Ga 37Hqm+/OQcBQNnpKkRHit/KURAflGfh4+pSUclAFlcSq/3KPARUDTEA0xlOp7CLlzg g3411DfatJJnzdtaUgvh6oXocfd8GAcp+Vk3PZHxDqx/9M6pju9btX39GIj+dM1/LG 1+/hUplsEg18ecK2d+QVLsB2r3LvQmNVULZjeYg7GjN9lKRJ0PY0kt7FyfHLrcTbgQ ST0I1fmxAThHQ== From: Kees Cook To: Arnd Bergmann Cc: Kees Cook , Ingo Molnar , x86@kernel.org, "Gustavo A. R. Silva" , linux-doc@vger.kernel.org, linux-arm-kernel@lists.infradead.org, kvmarm@lists.linux.dev, linux-riscv@lists.infradead.org, linux-s390@vger.kernel.org, linux-efi@vger.kernel.org, linux-hardening@vger.kernel.org, linux-kbuild@vger.kernel.org, linux-security-module@vger.kernel.org, linux-kselftest@vger.kernel.org, Christoph Hellwig , Marco Elver , Andrey Konovalov , Andrey Ryabinin , Ard Biesheuvel , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Nick Desaulniers , Bill Wendling , Justin Stitt , linux-kernel@vger.kernel.org, kasan-dev@googlegroups.com, sparclinux@vger.kernel.org, llvm@lists.linux.dev Subject: [PATCH v2 01/14] stackleak: Rename STACKLEAK to KSTACK_ERASE Date: Thu, 22 May 2025 21:39:11 -0700 Message-Id: <20250523043935.2009972-1-kees@kernel.org> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20250523043251.it.550-kees@kernel.org> References: <20250523043251.it.550-kees@kernel.org> Precedence: bulk X-Mailing-List: kvmarm@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=36006; i=kees@kernel.org; h=from:subject; bh=9AkAkSKl9S4JaL8v+O2hS6MFbAfqao2mTLxrmw6SRmE=; b=owGbwMvMwCVmps19z/KJym7G02pJDBn6v78bHbjqUCS/yZI1lJddPPsgl+Gs+Yd+zn2bvOBo+ 9zgHfccOkpZGMS4GGTFFFmC7NzjXDzetoe7z1WEmcPKBDKEgYtTACZi08Twz775WYHCrfbrKh63 bJpXGamk7NBMUTx1UO4483tJHp/1Bxh+s96ak5Lkmvj6g0dF6Yvt3k8/tc/kiGf13+I3P9Lf3Wc 6NwA= X-Developer-Key: i=kees@kernel.org; a=openpgp; fpr=A5C3F68F229DD60F723E6E138972F4DFDC6DC026 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit In preparation for adding Clang sanitizer coverage stack depth tracking that can support stack depth callbacks: - Add the new top-level CONFIG_KSTACK_ERASE option which will be implemented either with the stackleak GCC plugin, or with the Clang stack depth callback support. - Rename CONFIG_GCC_PLUGIN_STACKLEAK as needed to CONFIG_KSTACK_ERASE, but keep it for anything specific to the GCC plugin itself. - Rename all exposed "STACKLEAK" names and files to "KSTACK_ERASE" (named for what it does rather than what it protects against), but leave as many of the internals alone as possible to avoid even more churn. While here, also split "prev_lowest_stack" into CONFIG_KSTACK_ERASE_METRICS, since that's the only place it is referenced from. Suggested-by: Ingo Molnar Signed-off-by: Kees Cook --- Cc: Arnd Bergmann Cc: Cc: "Gustavo A. R. Silva" Cc: Cc: Cc: Cc: Cc: Cc: Cc: Cc: Cc: Cc: --- arch/Kconfig | 4 +-- arch/arm/Kconfig | 2 +- arch/arm64/Kconfig | 2 +- arch/riscv/Kconfig | 2 +- arch/s390/Kconfig | 2 +- arch/x86/Kconfig | 2 +- security/Kconfig.hardening | 36 ++++++++++--------- arch/arm/boot/compressed/Makefile | 2 +- arch/arm64/kernel/pi/Makefile | 2 +- arch/arm64/kvm/hyp/nvhe/Makefile | 2 +- arch/riscv/kernel/pi/Makefile | 2 +- arch/riscv/purgatory/Makefile | 2 +- arch/x86/purgatory/Makefile | 2 +- drivers/firmware/efi/libstub/Makefile | 8 ++--- drivers/misc/lkdtm/Makefile | 2 +- kernel/Makefile | 10 +++--- lib/Makefile | 2 +- scripts/Makefile.gcc-plugins | 6 ++-- Documentation/admin-guide/sysctl/kernel.rst | 4 +-- Documentation/arch/x86/x86_64/mm.rst | 2 +- Documentation/security/self-protection.rst | 2 +- .../zh_CN/security/self-protection.rst | 2 +- arch/x86/entry/calling.h | 4 +-- include/linux/{stackleak.h => kstack_erase.h} | 18 +++++----- include/linux/sched.h | 4 ++- arch/arm/kernel/entry-common.S | 2 +- arch/arm64/kernel/entry.S | 2 +- arch/riscv/kernel/entry.S | 2 +- arch/s390/kernel/entry.S | 2 +- .../lkdtm/{stackleak.c => kstack_erase.c} | 26 +++++++------- fs/proc/base.c | 6 ++-- kernel/fork.c | 2 +- kernel/{stackleak.c => kstack_erase.c} | 18 +++++----- tools/objtool/check.c | 2 +- tools/testing/selftests/lkdtm/config | 2 +- MAINTAINERS | 4 +-- 36 files changed, 100 insertions(+), 94 deletions(-) rename include/linux/{stackleak.h => kstack_erase.h} (85%) rename drivers/misc/lkdtm/{stackleak.c => kstack_erase.c} (89%) rename kernel/{stackleak.c => kstack_erase.c} (90%) diff --git a/arch/Kconfig b/arch/Kconfig index a3308a220f86..4d1908f6f084 100644 --- a/arch/Kconfig +++ b/arch/Kconfig @@ -630,11 +630,11 @@ config SECCOMP_CACHE_DEBUG If unsure, say N. -config HAVE_ARCH_STACKLEAK +config HAVE_ARCH_KSTACK_ERASE bool help An architecture should select this if it has the code which - fills the used part of the kernel stack with the STACKLEAK_POISON + fills the used part of the kernel stack with the KSTACK_ERASE_POISON value before returning from system calls. config HAVE_STACKPROTECTOR diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig index 3072731fe09c..cb0b2e2211ca 100644 --- a/arch/arm/Kconfig +++ b/arch/arm/Kconfig @@ -87,11 +87,11 @@ config ARM select HAVE_ARCH_KGDB if !CPU_ENDIAN_BE32 && MMU select HAVE_ARCH_KASAN if MMU && !XIP_KERNEL select HAVE_ARCH_KASAN_VMALLOC if HAVE_ARCH_KASAN + select HAVE_ARCH_KSTACK_ERASE select HAVE_ARCH_MMAP_RND_BITS if MMU select HAVE_ARCH_PFN_VALID select HAVE_ARCH_SECCOMP select HAVE_ARCH_SECCOMP_FILTER if AEABI && !OABI_COMPAT - select HAVE_ARCH_STACKLEAK select HAVE_ARCH_THREAD_STRUCT_WHITELIST select HAVE_ARCH_TRACEHOOK select HAVE_ARCH_TRANSPARENT_HUGEPAGE if ARM_LPAE diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig index 55fc331af337..e2a9e013b6a9 100644 --- a/arch/arm64/Kconfig +++ b/arch/arm64/Kconfig @@ -187,12 +187,12 @@ config ARM64 select HAVE_ARCH_KCSAN if EXPERT select HAVE_ARCH_KFENCE select HAVE_ARCH_KGDB + select HAVE_ARCH_KSTACK_ERASE select HAVE_ARCH_MMAP_RND_BITS select HAVE_ARCH_MMAP_RND_COMPAT_BITS if COMPAT select HAVE_ARCH_PREL32_RELOCATIONS select HAVE_ARCH_RANDOMIZE_KSTACK_OFFSET select HAVE_ARCH_SECCOMP_FILTER - select HAVE_ARCH_STACKLEAK select HAVE_ARCH_THREAD_STRUCT_WHITELIST select HAVE_ARCH_TRACEHOOK select HAVE_ARCH_TRANSPARENT_HUGEPAGE diff --git a/arch/riscv/Kconfig b/arch/riscv/Kconfig index fbca724302ab..31792e0e0bf6 100644 --- a/arch/riscv/Kconfig +++ b/arch/riscv/Kconfig @@ -133,13 +133,13 @@ config RISCV select HAVE_ARCH_KASAN if MMU && 64BIT select HAVE_ARCH_KASAN_VMALLOC if MMU && 64BIT select HAVE_ARCH_KFENCE if MMU && 64BIT + select HAVE_ARCH_KSTACK_ERASE select HAVE_ARCH_KGDB if !XIP_KERNEL select HAVE_ARCH_KGDB_QXFER_PKT select HAVE_ARCH_MMAP_RND_BITS if MMU select HAVE_ARCH_MMAP_RND_COMPAT_BITS if COMPAT select HAVE_ARCH_RANDOMIZE_KSTACK_OFFSET select HAVE_ARCH_SECCOMP_FILTER - select HAVE_ARCH_STACKLEAK select HAVE_ARCH_THREAD_STRUCT_WHITELIST select HAVE_ARCH_TRACEHOOK select HAVE_ARCH_TRANSPARENT_HUGEPAGE if 64BIT && MMU diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig index 0c16dc443e2f..a8e74ed8e3cc 100644 --- a/arch/s390/Kconfig +++ b/arch/s390/Kconfig @@ -176,10 +176,10 @@ config S390 select HAVE_ARCH_KCSAN select HAVE_ARCH_KMSAN select HAVE_ARCH_KFENCE + select HAVE_ARCH_KSTACK_ERASE select HAVE_ARCH_RANDOMIZE_KSTACK_OFFSET select HAVE_ARCH_SECCOMP_FILTER select HAVE_ARCH_SOFT_DIRTY - select HAVE_ARCH_STACKLEAK select HAVE_ARCH_TRACEHOOK select HAVE_ARCH_TRANSPARENT_HUGEPAGE select HAVE_ARCH_VMAP_STACK diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 340e5468980e..bc3708cad46b 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -204,13 +204,13 @@ config X86 select HAVE_ARCH_KFENCE select HAVE_ARCH_KMSAN if X86_64 select HAVE_ARCH_KGDB + select HAVE_ARCH_KSTACK_ERASE select HAVE_ARCH_MMAP_RND_BITS if MMU select HAVE_ARCH_MMAP_RND_COMPAT_BITS if MMU && COMPAT select HAVE_ARCH_COMPAT_MMAP_BASES if MMU && COMPAT select HAVE_ARCH_PREL32_RELOCATIONS select HAVE_ARCH_SECCOMP_FILTER select HAVE_ARCH_THREAD_STRUCT_WHITELIST - select HAVE_ARCH_STACKLEAK select HAVE_ARCH_TRACEHOOK select HAVE_ARCH_TRANSPARENT_HUGEPAGE select HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD if X86_64 diff --git a/security/Kconfig.hardening b/security/Kconfig.hardening index fd1238753cad..125b35e2ef0f 100644 --- a/security/Kconfig.hardening +++ b/security/Kconfig.hardening @@ -82,10 +82,10 @@ choice endchoice -config GCC_PLUGIN_STACKLEAK +config KSTACK_ERASE bool "Poison kernel stack before returning from syscalls" + depends on HAVE_ARCH_KSTACK_ERASE depends on GCC_PLUGINS - depends on HAVE_ARCH_STACKLEAK help This option makes the kernel erase the kernel stack before returning from system calls. This has the effect of leaving @@ -103,6 +103,10 @@ config GCC_PLUGIN_STACKLEAK are advised to test this feature on your expected workload before deploying it. +config GCC_PLUGIN_STACKLEAK + def_bool KSTACK_ERASE + depends on GCC_PLUGINS + help This plugin was ported from grsecurity/PaX. More information at: * https://grsecurity.net/ * https://pax.grsecurity.net/ @@ -117,37 +121,37 @@ config GCC_PLUGIN_STACKLEAK_VERBOSE instrumented. This is useful for comparing coverage between builds. -config STACKLEAK_TRACK_MIN_SIZE - int "Minimum stack frame size of functions tracked by STACKLEAK" +config KSTACK_ERASE_TRACK_MIN_SIZE + int "Minimum stack frame size of functions tracked by KSTACK_ERASE" default 100 range 0 4096 - depends on GCC_PLUGIN_STACKLEAK + depends on KSTACK_ERASE help - The STACKLEAK gcc plugin instruments the kernel code for tracking + The KSTACK_ERASE option instruments the kernel code for tracking the lowest border of the kernel stack (and for some other purposes). It inserts the stackleak_track_stack() call for the functions with a stack frame size greater than or equal to this parameter. If unsure, leave the default value 100. -config STACKLEAK_METRICS - bool "Show STACKLEAK metrics in the /proc file system" - depends on GCC_PLUGIN_STACKLEAK +config KSTACK_ERASE_METRICS + bool "Show KSTACK_ERASE metrics in the /proc file system" + depends on KSTACK_ERASE depends on PROC_FS help - If this is set, STACKLEAK metrics for every task are available in - the /proc file system. In particular, /proc//stack_depth + If this is set, KSTACK_ERASE metrics for every task are available + in the /proc file system. In particular, /proc//stack_depth shows the maximum kernel stack consumption for the current and previous syscalls. Although this information is not precise, it - can be useful for estimating the STACKLEAK performance impact for - your workloads. + can be useful for estimating the KSTACK_ERASE performance impact + for your workloads. -config STACKLEAK_RUNTIME_DISABLE +config KSTACK_ERASE_RUNTIME_DISABLE bool "Allow runtime disabling of kernel stack erasing" - depends on GCC_PLUGIN_STACKLEAK + depends on KSTACK_ERASE help This option provides 'stack_erasing' sysctl, which can be used in runtime to control kernel stack erasing for kernels built with - CONFIG_GCC_PLUGIN_STACKLEAK. + CONFIG_KSTACK_ERASE. config INIT_ON_ALLOC_DEFAULT_ON bool "Enable heap memory zeroing on allocation by default" diff --git a/arch/arm/boot/compressed/Makefile b/arch/arm/boot/compressed/Makefile index d61369b1eabe..f9075edfd773 100644 --- a/arch/arm/boot/compressed/Makefile +++ b/arch/arm/boot/compressed/Makefile @@ -9,7 +9,7 @@ OBJS = HEAD = head.o OBJS += misc.o decompress.o -CFLAGS_decompress.o += $(DISABLE_STACKLEAK_PLUGIN) +CFLAGS_decompress.o += $(DISABLE_KSTACK_ERASE) ifeq ($(CONFIG_DEBUG_UNCOMPRESS),y) OBJS += debug.o AFLAGS_head.o += -DDEBUG diff --git a/arch/arm64/kernel/pi/Makefile b/arch/arm64/kernel/pi/Makefile index 4d11a8c29181..f440bf57b1a5 100644 --- a/arch/arm64/kernel/pi/Makefile +++ b/arch/arm64/kernel/pi/Makefile @@ -2,7 +2,7 @@ # Copyright 2022 Google LLC KBUILD_CFLAGS := $(subst $(CC_FLAGS_FTRACE),,$(KBUILD_CFLAGS)) -fpie \ - -Os -DDISABLE_BRANCH_PROFILING $(DISABLE_STACKLEAK_PLUGIN) \ + -Os -DDISABLE_BRANCH_PROFILING $(DISABLE_KSTACK_ERASE) \ $(DISABLE_LATENT_ENTROPY_PLUGIN) \ $(call cc-option,-mbranch-protection=none) \ -I$(srctree)/scripts/dtc/libfdt -fno-stack-protector \ diff --git a/arch/arm64/kvm/hyp/nvhe/Makefile b/arch/arm64/kvm/hyp/nvhe/Makefile index a76522d63c3e..0b0a68b663d4 100644 --- a/arch/arm64/kvm/hyp/nvhe/Makefile +++ b/arch/arm64/kvm/hyp/nvhe/Makefile @@ -12,7 +12,7 @@ asflags-y := -D__KVM_NVHE_HYPERVISOR__ -D__DISABLE_EXPORTS ccflags-y := -D__KVM_NVHE_HYPERVISOR__ -D__DISABLE_EXPORTS -D__DISABLE_TRACE_MMIO__ ccflags-y += -fno-stack-protector \ -DDISABLE_BRANCH_PROFILING \ - $(DISABLE_STACKLEAK_PLUGIN) + $(DISABLE_KSTACK_ERASE) hostprogs := gen-hyprel HOST_EXTRACFLAGS += -I$(objtree)/include diff --git a/arch/riscv/kernel/pi/Makefile b/arch/riscv/kernel/pi/Makefile index 81d69d45c06c..7dd15be69c90 100644 --- a/arch/riscv/kernel/pi/Makefile +++ b/arch/riscv/kernel/pi/Makefile @@ -2,7 +2,7 @@ # This file was copied from arm64/kernel/pi/Makefile. KBUILD_CFLAGS := $(subst $(CC_FLAGS_FTRACE),,$(KBUILD_CFLAGS)) -fpie \ - -Os -DDISABLE_BRANCH_PROFILING $(DISABLE_STACKLEAK_PLUGIN) \ + -Os -DDISABLE_BRANCH_PROFILING $(DISABLE_KSTACK_ERASE) \ $(call cc-option,-mbranch-protection=none) \ -I$(srctree)/scripts/dtc/libfdt -fno-stack-protector \ -include $(srctree)/include/linux/hidden.h \ diff --git a/arch/riscv/purgatory/Makefile b/arch/riscv/purgatory/Makefile index fb9c917c9b45..240592e3f5c2 100644 --- a/arch/riscv/purgatory/Makefile +++ b/arch/riscv/purgatory/Makefile @@ -53,7 +53,7 @@ targets += purgatory.ro purgatory.chk PURGATORY_CFLAGS_REMOVE := -mcmodel=kernel PURGATORY_CFLAGS := -mcmodel=medany -ffreestanding -fno-zero-initialized-in-bss -PURGATORY_CFLAGS += $(DISABLE_STACKLEAK_PLUGIN) -DDISABLE_BRANCH_PROFILING +PURGATORY_CFLAGS += $(DISABLE_KSTACK_ERASE) -DDISABLE_BRANCH_PROFILING PURGATORY_CFLAGS += -fno-stack-protector -g0 # Default KBUILD_CFLAGS can have -pg option set when FTRACE is enabled. That diff --git a/arch/x86/purgatory/Makefile b/arch/x86/purgatory/Makefile index ebdfd7b84feb..e0a607a14e7e 100644 --- a/arch/x86/purgatory/Makefile +++ b/arch/x86/purgatory/Makefile @@ -35,7 +35,7 @@ targets += purgatory.ro purgatory.chk PURGATORY_CFLAGS_REMOVE := -mcmodel=kernel PURGATORY_CFLAGS := -mcmodel=small -ffreestanding -fno-zero-initialized-in-bss -g0 PURGATORY_CFLAGS += -fpic -fvisibility=hidden -PURGATORY_CFLAGS += $(DISABLE_STACKLEAK_PLUGIN) -DDISABLE_BRANCH_PROFILING +PURGATORY_CFLAGS += $(DISABLE_KSTACK_ERASE) -DDISABLE_BRANCH_PROFILING PURGATORY_CFLAGS += -fno-stack-protector # Default KBUILD_CFLAGS can have -pg option set when FTRACE is enabled. That diff --git a/drivers/firmware/efi/libstub/Makefile b/drivers/firmware/efi/libstub/Makefile index 6a0152858a2a..cdba14dde7d5 100644 --- a/drivers/firmware/efi/libstub/Makefile +++ b/drivers/firmware/efi/libstub/Makefile @@ -22,16 +22,16 @@ cflags-$(CONFIG_X86) += -m$(BITS) -D__KERNEL__ -std=gnu11 \ # arm64 uses the full KBUILD_CFLAGS so it's necessary to explicitly # disable the stackleak plugin -cflags-$(CONFIG_ARM64) += -fpie $(DISABLE_STACKLEAK_PLUGIN) \ +cflags-$(CONFIG_ARM64) += -fpie $(DISABLE_KSTACK_ERASE) \ -fno-unwind-tables -fno-asynchronous-unwind-tables cflags-$(CONFIG_ARM) += -DEFI_HAVE_STRLEN -DEFI_HAVE_STRNLEN \ -DEFI_HAVE_MEMCHR -DEFI_HAVE_STRRCHR \ -DEFI_HAVE_STRCMP -fno-builtin -fpic \ $(call cc-option,-mno-single-pic-base) \ - $(DISABLE_STACKLEAK_PLUGIN) + $(DISABLE_KSTACK_ERASE) cflags-$(CONFIG_RISCV) += -fpic -DNO_ALTERNATIVE -mno-relax \ - $(DISABLE_STACKLEAK_PLUGIN) -cflags-$(CONFIG_LOONGARCH) += -fpie $(DISABLE_STACKLEAK_PLUGIN) + $(DISABLE_KSTACK_ERASE) +cflags-$(CONFIG_LOONGARCH) += -fpie $(DISABLE_KSTACK_ERASE) cflags-$(CONFIG_EFI_PARAMS_FROM_FDT) += -I$(srctree)/scripts/dtc/libfdt diff --git a/drivers/misc/lkdtm/Makefile b/drivers/misc/lkdtm/Makefile index 39468bd27b85..03ebe33185f9 100644 --- a/drivers/misc/lkdtm/Makefile +++ b/drivers/misc/lkdtm/Makefile @@ -8,7 +8,7 @@ lkdtm-$(CONFIG_LKDTM) += perms.o lkdtm-$(CONFIG_LKDTM) += refcount.o lkdtm-$(CONFIG_LKDTM) += rodata_objcopy.o lkdtm-$(CONFIG_LKDTM) += usercopy.o -lkdtm-$(CONFIG_LKDTM) += stackleak.o +lkdtm-$(CONFIG_LKDTM) += kstack_erase.o lkdtm-$(CONFIG_LKDTM) += cfi.o lkdtm-$(CONFIG_LKDTM) += fortify.o lkdtm-$(CONFIG_PPC_64S_HASH_MMU) += powerpc.o diff --git a/kernel/Makefile b/kernel/Makefile index 32e80dd626af..e4f01f1d4d0c 100644 --- a/kernel/Makefile +++ b/kernel/Makefile @@ -139,11 +139,11 @@ obj-$(CONFIG_WATCH_QUEUE) += watch_queue.o obj-$(CONFIG_RESOURCE_KUNIT_TEST) += resource_kunit.o obj-$(CONFIG_SYSCTL_KUNIT_TEST) += sysctl-test.o -CFLAGS_stackleak.o += $(DISABLE_STACKLEAK_PLUGIN) -obj-$(CONFIG_GCC_PLUGIN_STACKLEAK) += stackleak.o -KASAN_SANITIZE_stackleak.o := n -KCSAN_SANITIZE_stackleak.o := n -KCOV_INSTRUMENT_stackleak.o := n +CFLAGS_kstack_erase.o += $(DISABLE_KSTACK_ERASE) +obj-$(CONFIG_KSTACK_ERASE) += kstack_erase.o +KASAN_SANITIZE_kstack_erase.o := n +KCSAN_SANITIZE_kstack_erase.o := n +KCOV_INSTRUMENT_kstack_erase.o := n obj-$(CONFIG_SCF_TORTURE_TEST) += scftorture.o diff --git a/lib/Makefile b/lib/Makefile index c38582f187dd..632e69d25feb 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -337,7 +337,7 @@ obj-$(CONFIG_UBSAN) += ubsan.o UBSAN_SANITIZE_ubsan.o := n KASAN_SANITIZE_ubsan.o := n KCSAN_SANITIZE_ubsan.o := n -CFLAGS_ubsan.o := -fno-stack-protector $(DISABLE_STACKLEAK_PLUGIN) +CFLAGS_ubsan.o := -fno-stack-protector $(DISABLE_KSTACK_ERASE) obj-$(CONFIG_SBITMAP) += sbitmap.o diff --git a/scripts/Makefile.gcc-plugins b/scripts/Makefile.gcc-plugins index 435ab3f0ec44..28b8867c4e84 100644 --- a/scripts/Makefile.gcc-plugins +++ b/scripts/Makefile.gcc-plugins @@ -12,15 +12,15 @@ gcc-plugin-$(CONFIG_GCC_PLUGIN_STACKLEAK) += stackleak_plugin.so gcc-plugin-cflags-$(CONFIG_GCC_PLUGIN_STACKLEAK) \ += -DSTACKLEAK_PLUGIN gcc-plugin-cflags-$(CONFIG_GCC_PLUGIN_STACKLEAK) \ - += -fplugin-arg-stackleak_plugin-track-min-size=$(CONFIG_STACKLEAK_TRACK_MIN_SIZE) + += -fplugin-arg-stackleak_plugin-track-min-size=$(CONFIG_KSTACK_ERASE_TRACK_MIN_SIZE) gcc-plugin-cflags-$(CONFIG_GCC_PLUGIN_STACKLEAK) \ += -fplugin-arg-stackleak_plugin-arch=$(SRCARCH) gcc-plugin-cflags-$(CONFIG_GCC_PLUGIN_STACKLEAK_VERBOSE) \ += -fplugin-arg-stackleak_plugin-verbose ifdef CONFIG_GCC_PLUGIN_STACKLEAK - DISABLE_STACKLEAK_PLUGIN += -fplugin-arg-stackleak_plugin-disable + DISABLE_KSTACK_ERASE += -fplugin-arg-stackleak_plugin-disable endif -export DISABLE_STACKLEAK_PLUGIN +export DISABLE_KSTACK_ERASE # All the plugin CFLAGS are collected here in case a build target needs to # filter them out of the KBUILD_CFLAGS. diff --git a/Documentation/admin-guide/sysctl/kernel.rst b/Documentation/admin-guide/sysctl/kernel.rst index dd49a89a62d3..19224eeac1c2 100644 --- a/Documentation/admin-guide/sysctl/kernel.rst +++ b/Documentation/admin-guide/sysctl/kernel.rst @@ -1465,7 +1465,7 @@ stack_erasing ============= This parameter can be used to control kernel stack erasing at the end -of syscalls for kernels built with ``CONFIG_GCC_PLUGIN_STACKLEAK``. +of syscalls for kernels built with ``CONFIG_KSTACK_ERASE``. That erasing reduces the information which kernel stack leak bugs can reveal and blocks some uninitialized stack variable attacks. @@ -1473,7 +1473,7 @@ The tradeoff is the performance impact: on a single CPU system kernel compilation sees a 1% slowdown, other systems and workloads may vary. = ==================================================================== -0 Kernel stack erasing is disabled, STACKLEAK_METRICS are not updated. +0 Kernel stack erasing is disabled, KSTACK_ERASE_METRICS are not updated. 1 Kernel stack erasing is enabled (default), it is performed before returning to the userspace at the end of syscalls. = ==================================================================== diff --git a/Documentation/arch/x86/x86_64/mm.rst b/Documentation/arch/x86/x86_64/mm.rst index f2db178b353f..a6cf05d51bd8 100644 --- a/Documentation/arch/x86/x86_64/mm.rst +++ b/Documentation/arch/x86/x86_64/mm.rst @@ -176,5 +176,5 @@ Be very careful vs. KASLR when changing anything here. The KASLR address range must not overlap with anything except the KASAN shadow area, which is correct as KASAN disables KASLR. -For both 4- and 5-level layouts, the STACKLEAK_POISON value in the last 2MB +For both 4- and 5-level layouts, the KSTACK_ERASE_POISON value in the last 2MB hole: ffffffffffff4111 diff --git a/Documentation/security/self-protection.rst b/Documentation/security/self-protection.rst index 910668e665cb..a32ca23c21b0 100644 --- a/Documentation/security/self-protection.rst +++ b/Documentation/security/self-protection.rst @@ -303,7 +303,7 @@ Memory poisoning When releasing memory, it is best to poison the contents, to avoid reuse attacks that rely on the old contents of memory. E.g., clear stack on a -syscall return (``CONFIG_GCC_PLUGIN_STACKLEAK``), wipe heap memory on a +syscall return (``CONFIG_KSTACK_ERASE``), wipe heap memory on a free. This frustrates many uninitialized variable attacks, stack content exposures, heap content exposures, and use-after-free attacks. diff --git a/Documentation/translations/zh_CN/security/self-protection.rst b/Documentation/translations/zh_CN/security/self-protection.rst index 3c8a68b1e1be..93de9cee5c1a 100644 --- a/Documentation/translations/zh_CN/security/self-protection.rst +++ b/Documentation/translations/zh_CN/security/self-protection.rst @@ -259,7 +259,7 @@ KALLSYSM，则会直接打印原始地址。 -------- 在释放内存时，最好对内存内容进行清除处理，以防止攻击者重用内存中以前 -的内容。例如，在系统调用返回时清除堆栈（CONFIG_GCC_PLUGIN_STACKLEAK）, +的内容。例如，在系统调用返回时清除堆栈（CONFIG_KSTACK_ERASE）, 在释放堆内容是清除其内容。这有助于防止许多未初始化变量攻击、堆栈内容 泄露、堆内容泄露以及使用后释放攻击（user-after-free）。 diff --git a/arch/x86/entry/calling.h b/arch/x86/entry/calling.h index d83236b96f22..94519688b007 100644 --- a/arch/x86/entry/calling.h +++ b/arch/x86/entry/calling.h @@ -369,7 +369,7 @@ For 32-bit we have the following conventions - kernel is built with .endm .macro STACKLEAK_ERASE_NOCLOBBER -#ifdef CONFIG_GCC_PLUGIN_STACKLEAK +#ifdef CONFIG_KSTACK_ERASE PUSH_AND_CLEAR_REGS call stackleak_erase POP_REGS @@ -388,7 +388,7 @@ For 32-bit we have the following conventions - kernel is built with #endif /* !CONFIG_X86_64 */ .macro STACKLEAK_ERASE -#ifdef CONFIG_GCC_PLUGIN_STACKLEAK +#ifdef CONFIG_KSTACK_ERASE call stackleak_erase #endif .endm diff --git a/include/linux/stackleak.h b/include/linux/kstack_erase.h similarity index 85% rename from include/linux/stackleak.h rename to include/linux/kstack_erase.h index 3be2cb564710..4e432eefa4d0 100644 --- a/include/linux/stackleak.h +++ b/include/linux/kstack_erase.h @@ -1,6 +1,6 @@ /* SPDX-License-Identifier: GPL-2.0 */ -#ifndef _LINUX_STACKLEAK_H -#define _LINUX_STACKLEAK_H +#ifndef _LINUX_KSTACK_ERASE_H +#define _LINUX_KSTACK_ERASE_H #include #include @@ -9,10 +9,10 @@ * Check that the poison value points to the unused hole in the * virtual memory map for your platform. */ -#define STACKLEAK_POISON -0xBEEF -#define STACKLEAK_SEARCH_DEPTH 128 +#define KSTACK_ERASE_POISON -0xBEEF +#define KSTACK_ERASE_SEARCH_DEPTH 128 -#ifdef CONFIG_GCC_PLUGIN_STACKLEAK +#ifdef CONFIG_KSTACK_ERASE #include #include @@ -50,7 +50,7 @@ stackleak_task_high_bound(const struct task_struct *tsk) static __always_inline unsigned long stackleak_find_top_of_poison(const unsigned long low, const unsigned long high) { - const unsigned int depth = STACKLEAK_SEARCH_DEPTH / sizeof(unsigned long); + const unsigned int depth = KSTACK_ERASE_SEARCH_DEPTH / sizeof(unsigned long); unsigned int poison_count = 0; unsigned long poison_high = high; unsigned long sp = high; @@ -58,7 +58,7 @@ stackleak_find_top_of_poison(const unsigned long low, const unsigned long high) while (sp > low && poison_count < depth) { sp -= sizeof(unsigned long); - if (*(unsigned long *)sp == STACKLEAK_POISON) { + if (*(unsigned long *)sp == KSTACK_ERASE_POISON) { poison_count++; } else { poison_count = 0; @@ -72,7 +72,7 @@ stackleak_find_top_of_poison(const unsigned long low, const unsigned long high) static inline void stackleak_task_init(struct task_struct *t) { t->lowest_stack = stackleak_task_low_bound(t); -# ifdef CONFIG_STACKLEAK_METRICS +# ifdef CONFIG_KSTACK_ERASE_METRICS t->prev_lowest_stack = t->lowest_stack; # endif } @@ -82,7 +82,7 @@ asmlinkage void noinstr stackleak_erase_on_task_stack(void); asmlinkage void noinstr stackleak_erase_off_task_stack(void); void __no_caller_saved_registers noinstr stackleak_track_stack(void); -#else /* !CONFIG_GCC_PLUGIN_STACKLEAK */ +#else /* !CONFIG_KSTACK_ERASE */ static inline void stackleak_task_init(struct task_struct *t) { } #endif diff --git a/include/linux/sched.h b/include/linux/sched.h index 8c60a42f9d00..9051d9484393 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -1606,8 +1606,10 @@ struct task_struct { /* Used by BPF for per-TASK xdp storage */ struct bpf_net_context *bpf_net_context; -#ifdef CONFIG_GCC_PLUGIN_STACKLEAK +#ifdef CONFIG_KSTACK_ERASE unsigned long lowest_stack; +#endif +#ifdef CONFIG_KSTACK_ERASE_METRICS unsigned long prev_lowest_stack; #endif diff --git a/arch/arm/kernel/entry-common.S b/arch/arm/kernel/entry-common.S index f379c852dcb7..88336a1292bb 100644 --- a/arch/arm/kernel/entry-common.S +++ b/arch/arm/kernel/entry-common.S @@ -119,7 +119,7 @@ no_work_pending: ct_user_enter save = 0 -#ifdef CONFIG_GCC_PLUGIN_STACKLEAK +#ifdef CONFIG_KSTACK_ERASE bl stackleak_erase_on_task_stack #endif restore_user_regs fast = 0, offset = 0 diff --git a/arch/arm64/kernel/entry.S b/arch/arm64/kernel/entry.S index 5ae2a34b50bd..67331437b2aa 100644 --- a/arch/arm64/kernel/entry.S +++ b/arch/arm64/kernel/entry.S @@ -614,7 +614,7 @@ SYM_CODE_END(ret_to_kernel) SYM_CODE_START_LOCAL(ret_to_user) ldr x19, [tsk, #TSK_TI_FLAGS] // re-check for single-step enable_step_tsk x19, x2 -#ifdef CONFIG_GCC_PLUGIN_STACKLEAK +#ifdef CONFIG_KSTACK_ERASE bl stackleak_erase_on_task_stack #endif kernel_exit 0 diff --git a/arch/riscv/kernel/entry.S b/arch/riscv/kernel/entry.S index af514614404a..49e2344007c8 100644 --- a/arch/riscv/kernel/entry.S +++ b/arch/riscv/kernel/entry.S @@ -220,7 +220,7 @@ SYM_CODE_START_NOALIGN(ret_from_exception) #endif bnez s0, 1f -#ifdef CONFIG_GCC_PLUGIN_STACKLEAK +#ifdef CONFIG_KSTACK_ERASE call stackleak_erase_on_task_stack #endif diff --git a/arch/s390/kernel/entry.S b/arch/s390/kernel/entry.S index 0f00f4b06d51..75b0fbb236d0 100644 --- a/arch/s390/kernel/entry.S +++ b/arch/s390/kernel/entry.S @@ -124,7 +124,7 @@ _LPP_OFFSET = __LC_LPP #endif .macro STACKLEAK_ERASE -#ifdef CONFIG_GCC_PLUGIN_STACKLEAK +#ifdef CONFIG_KSTACK_ERASE brasl %r14,stackleak_erase_on_task_stack #endif .endm diff --git a/drivers/misc/lkdtm/stackleak.c b/drivers/misc/lkdtm/kstack_erase.c similarity index 89% rename from drivers/misc/lkdtm/stackleak.c rename to drivers/misc/lkdtm/kstack_erase.c index f1d022160913..4fd9b0bfb874 100644 --- a/drivers/misc/lkdtm/stackleak.c +++ b/drivers/misc/lkdtm/kstack_erase.c @@ -1,7 +1,7 @@ // SPDX-License-Identifier: GPL-2.0 /* * This code tests that the current task stack is properly erased (filled - * with STACKLEAK_POISON). + * with KSTACK_ERASE_POISON). * * Authors: * Alexander Popov @@ -9,9 +9,9 @@ */ #include "lkdtm.h" -#include +#include -#if defined(CONFIG_GCC_PLUGIN_STACKLEAK) +#if defined(CONFIG_KSTACK_ERASE) /* * Check that stackleak tracks the lowest stack pointer and erases the stack * below this as expected. @@ -85,7 +85,7 @@ static void noinstr check_stackleak_irqoff(void) while (poison_low > task_stack_low) { poison_low -= sizeof(unsigned long); - if (*(unsigned long *)poison_low == STACKLEAK_POISON) + if (*(unsigned long *)poison_low == KSTACK_ERASE_POISON) continue; instrumentation_begin(); @@ -96,7 +96,7 @@ static void noinstr check_stackleak_irqoff(void) } instrumentation_begin(); - pr_info("stackleak stack usage:\n" + pr_info("kstack erase stack usage:\n" " high offset: %lu bytes\n" " current: %lu bytes\n" " lowest: %lu bytes\n" @@ -121,7 +121,7 @@ static void noinstr check_stackleak_irqoff(void) instrumentation_end(); } -static void lkdtm_STACKLEAK_ERASING(void) +static void lkdtm_KSTACK_ERASE(void) { unsigned long flags; @@ -129,19 +129,19 @@ static void lkdtm_STACKLEAK_ERASING(void) check_stackleak_irqoff(); local_irq_restore(flags); } -#else /* defined(CONFIG_GCC_PLUGIN_STACKLEAK) */ -static void lkdtm_STACKLEAK_ERASING(void) +#else /* defined(CONFIG_KSTACK_ERASE) */ +static void lkdtm_KSTACK_ERASE(void) { - if (IS_ENABLED(CONFIG_HAVE_ARCH_STACKLEAK)) { - pr_err("XFAIL: stackleak is not enabled (CONFIG_GCC_PLUGIN_STACKLEAK=n)\n"); + if (IS_ENABLED(CONFIG_HAVE_ARCH_KSTACK_ERASE)) { + pr_err("XFAIL: stackleak is not enabled (CONFIG_KSTACK_ERASE=n)\n"); } else { - pr_err("XFAIL: stackleak is not supported on this arch (HAVE_ARCH_STACKLEAK=n)\n"); + pr_err("XFAIL: stackleak is not supported on this arch (HAVE_ARCH_KSTACK_ERASE=n)\n"); } } -#endif /* defined(CONFIG_GCC_PLUGIN_STACKLEAK) */ +#endif /* defined(CONFIG_KSTACK_ERASE) */ static struct crashtype crashtypes[] = { - CRASHTYPE(STACKLEAK_ERASING), + CRASHTYPE(KSTACK_ERASE), }; struct crashtype_category stackleak_crashtypes = { diff --git a/fs/proc/base.c b/fs/proc/base.c index c667702dc69b..be34612af8b6 100644 --- a/fs/proc/base.c +++ b/fs/proc/base.c @@ -3291,7 +3291,7 @@ static int proc_pid_ksm_stat(struct seq_file *m, struct pid_namespace *ns, } #endif /* CONFIG_KSM */ -#ifdef CONFIG_STACKLEAK_METRICS +#ifdef CONFIG_KSTACK_ERASE_METRICS static int proc_stack_depth(struct seq_file *m, struct pid_namespace *ns, struct pid *pid, struct task_struct *task) { @@ -3304,7 +3304,7 @@ static int proc_stack_depth(struct seq_file *m, struct pid_namespace *ns, prev_depth, depth); return 0; } -#endif /* CONFIG_STACKLEAK_METRICS */ +#endif /* CONFIG_KSTACK_ERASE_METRICS */ /* * Thread groups @@ -3411,7 +3411,7 @@ static const struct pid_entry tgid_base_stuff[] = { #ifdef CONFIG_LIVEPATCH ONE("patch_state", S_IRUSR, proc_pid_patch_state), #endif -#ifdef CONFIG_STACKLEAK_METRICS +#ifdef CONFIG_KSTACK_ERASE_METRICS ONE("stack_depth", S_IRUGO, proc_stack_depth), #endif #ifdef CONFIG_PROC_PID_ARCH_STATUS diff --git a/kernel/fork.c b/kernel/fork.c index 1ee8eb11f38b..1ec66911f6f6 100644 --- a/kernel/fork.c +++ b/kernel/fork.c @@ -93,7 +93,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/kernel/stackleak.c b/kernel/kstack_erase.c similarity index 90% rename from kernel/stackleak.c rename to kernel/kstack_erase.c index bb65321761b4..201b846f8345 100644 --- a/kernel/stackleak.c +++ b/kernel/kstack_erase.c @@ -6,14 +6,14 @@ * * Author: Alexander Popov * - * STACKLEAK reduces the information which kernel stack leak bugs can + * KSTACK_ERASE reduces the information which kernel stack leak bugs can * reveal and blocks some uninitialized stack variable attacks. */ -#include +#include #include -#ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE +#ifdef CONFIG_KSTACK_ERASE_RUNTIME_DISABLE #include #include #include @@ -68,7 +68,7 @@ late_initcall(stackleak_sysctls_init); #define skip_erasing() static_branch_unlikely(&stack_erasing_bypass) #else #define skip_erasing() false -#endif /* CONFIG_STACKLEAK_RUNTIME_DISABLE */ +#endif /* CONFIG_KSTACK_ERASE_RUNTIME_DISABLE */ #ifndef __stackleak_poison static __always_inline void __stackleak_poison(unsigned long erase_low, @@ -91,7 +91,7 @@ static __always_inline void __stackleak_erase(bool on_task_stack) erase_low = stackleak_find_top_of_poison(task_stack_low, current->lowest_stack); -#ifdef CONFIG_STACKLEAK_METRICS +#ifdef CONFIG_KSTACK_ERASE_METRICS current->prev_lowest_stack = erase_low; #endif @@ -113,7 +113,7 @@ static __always_inline void __stackleak_erase(bool on_task_stack) else erase_high = task_stack_high; - __stackleak_poison(erase_low, erase_high, STACKLEAK_POISON); + __stackleak_poison(erase_low, erase_high, KSTACK_ERASE_POISON); /* Reset the 'lowest_stack' value for the next syscall */ current->lowest_stack = task_stack_high; @@ -161,11 +161,11 @@ void __used __no_caller_saved_registers noinstr stackleak_track_stack(void) unsigned long sp = current_stack_pointer; /* - * Having CONFIG_STACKLEAK_TRACK_MIN_SIZE larger than - * STACKLEAK_SEARCH_DEPTH makes the poison search in + * Having CONFIG_KSTACK_ERASE_TRACK_MIN_SIZE larger than + * KSTACK_ERASE_SEARCH_DEPTH makes the poison search in * stackleak_erase() unreliable. Let's prevent that. */ - BUILD_BUG_ON(CONFIG_STACKLEAK_TRACK_MIN_SIZE > STACKLEAK_SEARCH_DEPTH); + BUILD_BUG_ON(CONFIG_KSTACK_ERASE_TRACK_MIN_SIZE > KSTACK_ERASE_SEARCH_DEPTH); /* 'lowest_stack' should be aligned on the register width boundary */ sp = ALIGN(sp, sizeof(unsigned long)); diff --git a/tools/objtool/check.c b/tools/objtool/check.c index b21b12ec88d9..31088a138bc9 100644 --- a/tools/objtool/check.c +++ b/tools/objtool/check.c @@ -1191,7 +1191,7 @@ static const char *uaccess_safe_builtin[] = { "__ubsan_handle_type_mismatch_v1", "__ubsan_handle_shift_out_of_bounds", "__ubsan_handle_load_invalid_value", - /* STACKLEAK */ + /* KSTACK_ERASE */ "stackleak_track_stack", /* TRACE_BRANCH_PROFILING */ "ftrace_likely_update", diff --git a/tools/testing/selftests/lkdtm/config b/tools/testing/selftests/lkdtm/config index 7afe05e8c4d7..bd09fdaf53e0 100644 --- a/tools/testing/selftests/lkdtm/config +++ b/tools/testing/selftests/lkdtm/config @@ -2,7 +2,7 @@ CONFIG_LKDTM=y CONFIG_DEBUG_LIST=y CONFIG_SLAB_FREELIST_HARDENED=y CONFIG_FORTIFY_SOURCE=y -CONFIG_GCC_PLUGIN_STACKLEAK=y +CONFIG_KSTACK_ERASE=y CONFIG_HARDENED_USERCOPY=y CONFIG_RANDOMIZE_KSTACK_OFFSET_DEFAULT=y CONFIG_INIT_ON_FREE_DEFAULT_ON=y diff --git a/MAINTAINERS b/MAINTAINERS index 79a8e2c73908..9f76b329fdb3 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -9971,8 +9971,6 @@ L: linux-hardening@vger.kernel.org S: Maintained T: git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/hardening F: Documentation/kbuild/gcc-plugins.rst -F: include/linux/stackleak.h -F: kernel/stackleak.c F: scripts/Makefile.gcc-plugins F: scripts/gcc-plugins/ @@ -13060,10 +13058,12 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/har F: Documentation/ABI/testing/sysfs-kernel-oops_count F: Documentation/ABI/testing/sysfs-kernel-warn_count F: arch/*/configs/hardening.config +F: include/linux/kstack_erase.h F: include/linux/overflow.h F: include/linux/randomize_kstack.h F: include/linux/ucopysize.h F: kernel/configs/hardening.config +F: kernel/kstack_erase.c F: lib/tests/randstruct_kunit.c F: lib/tests/usercopy_kunit.c F: mm/usercopy.c -- 2.34.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 5FCB8C3DA6D for ; Fri, 23 May 2025 04:53:32 +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:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=Sb6uQ1w37OGXpW46AUp2br9QICwQ+GziW+gYoxXB5GU=; b=inc66266jiZDc6 zweFMZs8cwIaRCW7+21VF84pufkZ4qX3TZJCtqySHpEgtFDUiSlXXULLFMvozyo3XVOy8ahZ5CoJo hAJpbFu0rJVSl4vmG+9XFarOt5NIyzV0KRs//96Q+rvE3eZ9eLFjJwnmztjcFxjok6YfkhmG3KdrQ RjtLqUA2hCQBk5E29RckxkSteRs4y7jxdAyDFTQNlTaKfzQWW/mh+jbIR02k/pj0EhKuXTd61+E2D Ra/0xZEYyXjwNuazvqGZbIqcTt1MBrL/MkNfXtvfyLtDSXgPCyagsRPmjsOvtPHl8EbVuSdJqtMLv RfxjDAn7IiPdOGr77QJg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1uIKPP-00000002wjD-1KVV; Fri, 23 May 2025 04:53:27 +0000 Received: from dfw.source.kernel.org ([2604:1380:4641:c500::1]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1uIKC3-00000002twZ-2l23; Fri, 23 May 2025 04:39:44 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id A87805C6CC1; Fri, 23 May 2025 04:37:21 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 628DBC4CEE9; Fri, 23 May 2025 04:39:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1747975178; bh=9AkAkSKl9S4JaL8v+O2hS6MFbAfqao2mTLxrmw6SRmE=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=BwShGNjlDVKDb99dus3C4Aw4MVpsaV7mbXYwh1hIrC7DuKXYqlAVmVavm1HNkRlVn 4L159ccVT45fGrMrmEAaS88OmwMFBAJT8P2982HyEO03BkNFQtXtfwKe+orPtkU+Ga 37Hqm+/OQcBQNnpKkRHit/KURAflGfh4+pSUclAFlcSq/3KPARUDTEA0xlOp7CLlzg g3411DfatJJnzdtaUgvh6oXocfd8GAcp+Vk3PZHxDqx/9M6pju9btX39GIj+dM1/LG 1+/hUplsEg18ecK2d+QVLsB2r3LvQmNVULZjeYg7GjN9lKRJ0PY0kt7FyfHLrcTbgQ ST0I1fmxAThHQ== From: Kees Cook To: Arnd Bergmann Cc: Kees Cook , Ingo Molnar , x86@kernel.org, "Gustavo A. R. Silva" , linux-doc@vger.kernel.org, linux-arm-kernel@lists.infradead.org, kvmarm@lists.linux.dev, linux-riscv@lists.infradead.org, linux-s390@vger.kernel.org, linux-efi@vger.kernel.org, linux-hardening@vger.kernel.org, linux-kbuild@vger.kernel.org, linux-security-module@vger.kernel.org, linux-kselftest@vger.kernel.org, Christoph Hellwig , Marco Elver , Andrey Konovalov , Andrey Ryabinin , Ard Biesheuvel , Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Nick Desaulniers , Bill Wendling , Justin Stitt , linux-kernel@vger.kernel.org, kasan-dev@googlegroups.com, sparclinux@vger.kernel.org, llvm@lists.linux.dev Subject: [PATCH v2 01/14] stackleak: Rename STACKLEAK to KSTACK_ERASE Date: Thu, 22 May 2025 21:39:11 -0700 Message-Id: <20250523043935.2009972-1-kees@kernel.org> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20250523043251.it.550-kees@kernel.org> References: <20250523043251.it.550-kees@kernel.org> MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=36006; i=kees@kernel.org; h=from:subject; bh=9AkAkSKl9S4JaL8v+O2hS6MFbAfqao2mTLxrmw6SRmE=; b=owGbwMvMwCVmps19z/KJym7G02pJDBn6v78bHbjqUCS/yZI1lJddPPsgl+Gs+Yd+zn2bvOBo+ 9zgHfccOkpZGMS4GGTFFFmC7NzjXDzetoe7z1WEmcPKBDKEgYtTACZi08Twz775WYHCrfbrKh63 bJpXGamk7NBMUTx1UO4483tJHp/1Bxh+s96ak5Lkmvj6g0dF6Yvt3k8/tc/kiGf13+I3P9Lf3Wc 6NwA= X-Developer-Key: i=kees@kernel.org; a=openpgp; fpr=A5C3F68F229DD60F723E6E138972F4DFDC6DC026 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250522_213939_814767_D0F2AF2F X-CRM114-Status: GOOD ( 22.91 ) 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 SW4gcHJlcGFyYXRpb24gZm9yIGFkZGluZyBDbGFuZyBzYW5pdGl6ZXIgY292ZXJhZ2Ugc3RhY2sg ZGVwdGggdHJhY2tpbmcKdGhhdCBjYW4gc3VwcG9ydCBzdGFjayBkZXB0aCBjYWxsYmFja3M6Cgot IEFkZCB0aGUgbmV3IHRvcC1sZXZlbCBDT05GSUdfS1NUQUNLX0VSQVNFIG9wdGlvbiB3aGljaCB3 aWxsIGJlCiAgaW1wbGVtZW50ZWQgZWl0aGVyIHdpdGggdGhlIHN0YWNrbGVhayBHQ0MgcGx1Z2lu LCBvciB3aXRoIHRoZSBDbGFuZwogIHN0YWNrIGRlcHRoIGNhbGxiYWNrIHN1cHBvcnQuCi0gUmVu YW1lIENPTkZJR19HQ0NfUExVR0lOX1NUQUNLTEVBSyBhcyBuZWVkZWQgdG8gQ09ORklHX0tTVEFD S19FUkFTRSwKICBidXQga2VlcCBpdCBmb3IgYW55dGhpbmcgc3BlY2lmaWMgdG8gdGhlIEdDQyBw bHVnaW4gaXRzZWxmLgotIFJlbmFtZSBhbGwgZXhwb3NlZCAiU1RBQ0tMRUFLIiBuYW1lcyBhbmQg ZmlsZXMgdG8gIktTVEFDS19FUkFTRSIgKG5hbWVkCiAgZm9yIHdoYXQgaXQgZG9lcyByYXRoZXIg dGhhbiB3aGF0IGl0IHByb3RlY3RzIGFnYWluc3QpLCBidXQgbGVhdmUgYXMKICBtYW55IG9mIHRo ZSBpbnRlcm5hbHMgYWxvbmUgYXMgcG9zc2libGUgdG8gYXZvaWQgZXZlbiBtb3JlIGNodXJuLgoK V2hpbGUgaGVyZSwgYWxzbyBzcGxpdCAicHJldl9sb3dlc3Rfc3RhY2siIGludG8gQ09ORklHX0tT VEFDS19FUkFTRV9NRVRSSUNTLApzaW5jZSB0aGF0J3MgdGhlIG9ubHkgcGxhY2UgaXQgaXMgcmVm ZXJlbmNlZCBmcm9tLgoKU3VnZ2VzdGVkLWJ5OiBJbmdvIE1vbG5hciA8bWluZ29Aa2VybmVsLm9y Zz4KU2lnbmVkLW9mZi1ieTogS2VlcyBDb29rIDxrZWVzQGtlcm5lbC5vcmc+Ci0tLQpDYzogQXJu ZCBCZXJnbWFubiA8YXJuZEBhcm5kYi5kZT4KQ2M6IDx4ODZAa2VybmVsLm9yZz4KQ2M6ICJHdXN0 YXZvIEEuIFIuIFNpbHZhIiA8Z3VzdGF2b2Fyc0BrZXJuZWwub3JnPgpDYzogPGxpbnV4LWRvY0B2 Z2VyLmtlcm5lbC5vcmc+CkNjOiA8bGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3Jn PgpDYzogPGt2bWFybUBsaXN0cy5saW51eC5kZXY+CkNjOiA8bGludXgtcmlzY3ZAbGlzdHMuaW5m cmFkZWFkLm9yZz4KQ2M6IDxsaW51eC1zMzkwQHZnZXIua2VybmVsLm9yZz4KQ2M6IDxsaW51eC1l ZmlAdmdlci5rZXJuZWwub3JnPgpDYzogPGxpbnV4LWhhcmRlbmluZ0B2Z2VyLmtlcm5lbC5vcmc+ CkNjOiA8bGludXgta2J1aWxkQHZnZXIua2VybmVsLm9yZz4KQ2M6IDxsaW51eC1zZWN1cml0eS1t b2R1bGVAdmdlci5rZXJuZWwub3JnPgpDYzogPGxpbnV4LWtzZWxmdGVzdEB2Z2VyLmtlcm5lbC5v cmc+Ci0tLQogYXJjaC9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwg IDQgKy0tCiBhcmNoL2FybS9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg MiArLQogYXJjaC9hcm02NC9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDIg Ky0KIGFyY2gvcmlzY3YvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAyICst CiBhcmNoL3MzOTAvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQog YXJjaC94ODYvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIHNl Y3VyaXR5L0tjb25maWcuaGFyZGVuaW5nICAgICAgICAgICAgICAgICAgICB8IDM2ICsrKysrKysr KystLS0tLS0tLS0KIGFyY2gvYXJtL2Jvb3QvY29tcHJlc3NlZC9NYWtlZmlsZSAgICAgICAgICAg ICB8ICAyICstCiBhcmNoL2FybTY0L2tlcm5lbC9waS9NYWtlZmlsZSAgICAgICAgICAgICAgICAg fCAgMiArLQogYXJjaC9hcm02NC9rdm0vaHlwL252aGUvTWFrZWZpbGUgICAgICAgICAgICAgIHwg IDIgKy0KIGFyY2gvcmlzY3Yva2VybmVsL3BpL01ha2VmaWxlICAgICAgICAgICAgICAgICB8ICAy ICstCiBhcmNoL3Jpc2N2L3B1cmdhdG9yeS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgfCAgMiAr LQogYXJjaC94ODYvcHVyZ2F0b3J5L01ha2VmaWxlICAgICAgICAgICAgICAgICAgIHwgIDIgKy0K IGRyaXZlcnMvZmlybXdhcmUvZWZpL2xpYnN0dWIvTWFrZWZpbGUgICAgICAgICB8ICA4ICsrLS0t CiBkcml2ZXJzL21pc2MvbGtkdG0vTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgfCAgMiArLQog a2VybmVsL01ha2VmaWxlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMTAgKysrLS0t CiBsaWIvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQog c2NyaXB0cy9NYWtlZmlsZS5nY2MtcGx1Z2lucyAgICAgICAgICAgICAgICAgIHwgIDYgKystLQog RG9jdW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9zeXNjdGwva2VybmVsLnJzdCAgIHwgIDQgKy0tCiBE b2N1bWVudGF0aW9uL2FyY2gveDg2L3g4Nl82NC9tbS5yc3QgICAgICAgICAgfCAgMiArLQogRG9j dW1lbnRhdGlvbi9zZWN1cml0eS9zZWxmLXByb3RlY3Rpb24ucnN0ICAgIHwgIDIgKy0KIC4uLi96 aF9DTi9zZWN1cml0eS9zZWxmLXByb3RlY3Rpb24ucnN0ICAgICAgICB8ICAyICstCiBhcmNoL3g4 Ni9lbnRyeS9jYWxsaW5nLmggICAgICAgICAgICAgICAgICAgICAgfCAgNCArLS0KIGluY2x1ZGUv bGludXgve3N0YWNrbGVhay5oID0+IGtzdGFja19lcmFzZS5ofSB8IDE4ICsrKysrLS0tLS0KIGlu Y2x1ZGUvbGludXgvc2NoZWQuaCAgICAgICAgICAgICAgICAgICAgICAgICB8ICA0ICsrLQogYXJj aC9hcm0va2VybmVsL2VudHJ5LWNvbW1vbi5TICAgICAgICAgICAgICAgIHwgIDIgKy0KIGFyY2gv YXJtNjQva2VybmVsL2VudHJ5LlMgICAgICAgICAgICAgICAgICAgICB8ICAyICstCiBhcmNoL3Jp c2N2L2tlcm5lbC9lbnRyeS5TICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogYXJjaC9zMzkw L2tlcm5lbC9lbnRyeS5TICAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIC4uLi9sa2R0bS97 c3RhY2tsZWFrLmMgPT4ga3N0YWNrX2VyYXNlLmN9ICAgICB8IDI2ICsrKysrKystLS0tLS0tCiBm cy9wcm9jL2Jhc2UuYyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgNiArKy0tCiBr ZXJuZWwvZm9yay5jICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQoga2Vy bmVsL3tzdGFja2xlYWsuYyA9PiBrc3RhY2tfZXJhc2UuY30gICAgICAgIHwgMTggKysrKystLS0t LQogdG9vbHMvb2JqdG9vbC9jaGVjay5jICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0K IHRvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2xrZHRtL2NvbmZpZyAgICAgICAgICB8ICAyICstCiBN QUlOVEFJTkVSUyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgNCArLS0KIDM2 IGZpbGVzIGNoYW5nZWQsIDEwMCBpbnNlcnRpb25zKCspLCA5NCBkZWxldGlvbnMoLSkKIHJlbmFt ZSBpbmNsdWRlL2xpbnV4L3tzdGFja2xlYWsuaCA9PiBrc3RhY2tfZXJhc2UuaH0gKDg1JSkKIHJl bmFtZSBkcml2ZXJzL21pc2MvbGtkdG0ve3N0YWNrbGVhay5jID0+IGtzdGFja19lcmFzZS5jfSAo ODklKQogcmVuYW1lIGtlcm5lbC97c3RhY2tsZWFrLmMgPT4ga3N0YWNrX2VyYXNlLmN9ICg5MCUp CgpkaWZmIC0tZ2l0IGEvYXJjaC9LY29uZmlnIGIvYXJjaC9LY29uZmlnCmluZGV4IGEzMzA4YTIy MGY4Ni4uNGQxOTA4ZjZmMDg0IDEwMDY0NAotLS0gYS9hcmNoL0tjb25maWcKKysrIGIvYXJjaC9L Y29uZmlnCkBAIC02MzAsMTEgKzYzMCwxMSBAQCBjb25maWcgU0VDQ09NUF9DQUNIRV9ERUJVRwog CiAJICBJZiB1bnN1cmUsIHNheSBOLgogCi1jb25maWcgSEFWRV9BUkNIX1NUQUNLTEVBSworY29u ZmlnIEhBVkVfQVJDSF9LU1RBQ0tfRVJBU0UKIAlib29sCiAJaGVscAogCSAgQW4gYXJjaGl0ZWN0 dXJlIHNob3VsZCBzZWxlY3QgdGhpcyBpZiBpdCBoYXMgdGhlIGNvZGUgd2hpY2gKLQkgIGZpbGxz IHRoZSB1c2VkIHBhcnQgb2YgdGhlIGtlcm5lbCBzdGFjayB3aXRoIHRoZSBTVEFDS0xFQUtfUE9J U09OCisJICBmaWxscyB0aGUgdXNlZCBwYXJ0IG9mIHRoZSBrZXJuZWwgc3RhY2sgd2l0aCB0aGUg S1NUQUNLX0VSQVNFX1BPSVNPTgogCSAgdmFsdWUgYmVmb3JlIHJldHVybmluZyBmcm9tIHN5c3Rl bSBjYWxscy4KIAogY29uZmlnIEhBVkVfU1RBQ0tQUk9URUNUT1IKZGlmZiAtLWdpdCBhL2FyY2gv YXJtL0tjb25maWcgYi9hcmNoL2FybS9LY29uZmlnCmluZGV4IDMwNzI3MzFmZTA5Yy4uY2IwYjJl MjIxMWNhIDEwMDY0NAotLS0gYS9hcmNoL2FybS9LY29uZmlnCisrKyBiL2FyY2gvYXJtL0tjb25m aWcKQEAgLTg3LDExICs4NywxMSBAQCBjb25maWcgQVJNCiAJc2VsZWN0IEhBVkVfQVJDSF9LR0RC IGlmICFDUFVfRU5ESUFOX0JFMzIgJiYgTU1VCiAJc2VsZWN0IEhBVkVfQVJDSF9LQVNBTiBpZiBN TVUgJiYgIVhJUF9LRVJORUwKIAlzZWxlY3QgSEFWRV9BUkNIX0tBU0FOX1ZNQUxMT0MgaWYgSEFW RV9BUkNIX0tBU0FOCisJc2VsZWN0IEhBVkVfQVJDSF9LU1RBQ0tfRVJBU0UKIAlzZWxlY3QgSEFW RV9BUkNIX01NQVBfUk5EX0JJVFMgaWYgTU1VCiAJc2VsZWN0IEhBVkVfQVJDSF9QRk5fVkFMSUQK IAlzZWxlY3QgSEFWRV9BUkNIX1NFQ0NPTVAKIAlzZWxlY3QgSEFWRV9BUkNIX1NFQ0NPTVBfRklM VEVSIGlmIEFFQUJJICYmICFPQUJJX0NPTVBBVAotCXNlbGVjdCBIQVZFX0FSQ0hfU1RBQ0tMRUFL CiAJc2VsZWN0IEhBVkVfQVJDSF9USFJFQURfU1RSVUNUX1dISVRFTElTVAogCXNlbGVjdCBIQVZF X0FSQ0hfVFJBQ0VIT09LCiAJc2VsZWN0IEhBVkVfQVJDSF9UUkFOU1BBUkVOVF9IVUdFUEFHRSBp ZiBBUk1fTFBBRQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9LY29uZmlnIGIvYXJjaC9hcm02NC9L Y29uZmlnCmluZGV4IDU1ZmMzMzFhZjMzNy4uZTJhOWUwMTNiNmE5IDEwMDY0NAotLS0gYS9hcmNo L2FybTY0L0tjb25maWcKKysrIGIvYXJjaC9hcm02NC9LY29uZmlnCkBAIC0xODcsMTIgKzE4Nywx MiBAQCBjb25maWcgQVJNNjQKIAlzZWxlY3QgSEFWRV9BUkNIX0tDU0FOIGlmIEVYUEVSVAogCXNl bGVjdCBIQVZFX0FSQ0hfS0ZFTkNFCiAJc2VsZWN0IEhBVkVfQVJDSF9LR0RCCisJc2VsZWN0IEhB VkVfQVJDSF9LU1RBQ0tfRVJBU0UKIAlzZWxlY3QgSEFWRV9BUkNIX01NQVBfUk5EX0JJVFMKIAlz ZWxlY3QgSEFWRV9BUkNIX01NQVBfUk5EX0NPTVBBVF9CSVRTIGlmIENPTVBBVAogCXNlbGVjdCBI QVZFX0FSQ0hfUFJFTDMyX1JFTE9DQVRJT05TCiAJc2VsZWN0IEhBVkVfQVJDSF9SQU5ET01JWkVf S1NUQUNLX09GRlNFVAogCXNlbGVjdCBIQVZFX0FSQ0hfU0VDQ09NUF9GSUxURVIKLQlzZWxlY3Qg SEFWRV9BUkNIX1NUQUNLTEVBSwogCXNlbGVjdCBIQVZFX0FSQ0hfVEhSRUFEX1NUUlVDVF9XSElU RUxJU1QKIAlzZWxlY3QgSEFWRV9BUkNIX1RSQUNFSE9PSwogCXNlbGVjdCBIQVZFX0FSQ0hfVFJB TlNQQVJFTlRfSFVHRVBBR0UKZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvS2NvbmZpZyBiL2FyY2gv cmlzY3YvS2NvbmZpZwppbmRleCBmYmNhNzI0MzAyYWIuLjMxNzkyZTBlMGJmNiAxMDA2NDQKLS0t IGEvYXJjaC9yaXNjdi9LY29uZmlnCisrKyBiL2FyY2gvcmlzY3YvS2NvbmZpZwpAQCAtMTMzLDEz ICsxMzMsMTMgQEAgY29uZmlnIFJJU0NWCiAJc2VsZWN0IEhBVkVfQVJDSF9LQVNBTiBpZiBNTVUg JiYgNjRCSVQKIAlzZWxlY3QgSEFWRV9BUkNIX0tBU0FOX1ZNQUxMT0MgaWYgTU1VICYmIDY0QklU CiAJc2VsZWN0IEhBVkVfQVJDSF9LRkVOQ0UgaWYgTU1VICYmIDY0QklUCisJc2VsZWN0IEhBVkVf QVJDSF9LU1RBQ0tfRVJBU0UKIAlzZWxlY3QgSEFWRV9BUkNIX0tHREIgaWYgIVhJUF9LRVJORUwK IAlzZWxlY3QgSEFWRV9BUkNIX0tHREJfUVhGRVJfUEtUCiAJc2VsZWN0IEhBVkVfQVJDSF9NTUFQ X1JORF9CSVRTIGlmIE1NVQogCXNlbGVjdCBIQVZFX0FSQ0hfTU1BUF9STkRfQ09NUEFUX0JJVFMg aWYgQ09NUEFUCiAJc2VsZWN0IEhBVkVfQVJDSF9SQU5ET01JWkVfS1NUQUNLX09GRlNFVAogCXNl bGVjdCBIQVZFX0FSQ0hfU0VDQ09NUF9GSUxURVIKLQlzZWxlY3QgSEFWRV9BUkNIX1NUQUNLTEVB SwogCXNlbGVjdCBIQVZFX0FSQ0hfVEhSRUFEX1NUUlVDVF9XSElURUxJU1QKIAlzZWxlY3QgSEFW RV9BUkNIX1RSQUNFSE9PSwogCXNlbGVjdCBIQVZFX0FSQ0hfVFJBTlNQQVJFTlRfSFVHRVBBR0Ug aWYgNjRCSVQgJiYgTU1VCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvS2NvbmZpZyBiL2FyY2gvczM5 MC9LY29uZmlnCmluZGV4IDBjMTZkYzQ0M2UyZi4uYThlNzRlZDhlM2NjIDEwMDY0NAotLS0gYS9h cmNoL3MzOTAvS2NvbmZpZworKysgYi9hcmNoL3MzOTAvS2NvbmZpZwpAQCAtMTc2LDEwICsxNzYs MTAgQEAgY29uZmlnIFMzOTAKIAlzZWxlY3QgSEFWRV9BUkNIX0tDU0FOCiAJc2VsZWN0IEhBVkVf QVJDSF9LTVNBTgogCXNlbGVjdCBIQVZFX0FSQ0hfS0ZFTkNFCisJc2VsZWN0IEhBVkVfQVJDSF9L U1RBQ0tfRVJBU0UKIAlzZWxlY3QgSEFWRV9BUkNIX1JBTkRPTUlaRV9LU1RBQ0tfT0ZGU0VUCiAJ c2VsZWN0IEhBVkVfQVJDSF9TRUNDT01QX0ZJTFRFUgogCXNlbGVjdCBIQVZFX0FSQ0hfU09GVF9E SVJUWQotCXNlbGVjdCBIQVZFX0FSQ0hfU1RBQ0tMRUFLCiAJc2VsZWN0IEhBVkVfQVJDSF9UUkFD RUhPT0sKIAlzZWxlY3QgSEFWRV9BUkNIX1RSQU5TUEFSRU5UX0hVR0VQQUdFCiAJc2VsZWN0IEhB VkVfQVJDSF9WTUFQX1NUQUNLCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9LY29uZmlnIGIvYXJjaC94 ODYvS2NvbmZpZwppbmRleCAzNDBlNTQ2ODk4MGUuLmJjMzcwOGNhZDQ2YiAxMDA2NDQKLS0tIGEv YXJjaC94ODYvS2NvbmZpZworKysgYi9hcmNoL3g4Ni9LY29uZmlnCkBAIC0yMDQsMTMgKzIwNCwx MyBAQCBjb25maWcgWDg2CiAJc2VsZWN0IEhBVkVfQVJDSF9LRkVOQ0UKIAlzZWxlY3QgSEFWRV9B UkNIX0tNU0FOCQkJaWYgWDg2XzY0CiAJc2VsZWN0IEhBVkVfQVJDSF9LR0RCCisJc2VsZWN0IEhB VkVfQVJDSF9LU1RBQ0tfRVJBU0UKIAlzZWxlY3QgSEFWRV9BUkNIX01NQVBfUk5EX0JJVFMJCWlm IE1NVQogCXNlbGVjdCBIQVZFX0FSQ0hfTU1BUF9STkRfQ09NUEFUX0JJVFMJaWYgTU1VICYmIENP TVBBVAogCXNlbGVjdCBIQVZFX0FSQ0hfQ09NUEFUX01NQVBfQkFTRVMJaWYgTU1VICYmIENPTVBB VAogCXNlbGVjdCBIQVZFX0FSQ0hfUFJFTDMyX1JFTE9DQVRJT05TCiAJc2VsZWN0IEhBVkVfQVJD SF9TRUNDT01QX0ZJTFRFUgogCXNlbGVjdCBIQVZFX0FSQ0hfVEhSRUFEX1NUUlVDVF9XSElURUxJ U1QKLQlzZWxlY3QgSEFWRV9BUkNIX1NUQUNLTEVBSwogCXNlbGVjdCBIQVZFX0FSQ0hfVFJBQ0VI T09LCiAJc2VsZWN0IEhBVkVfQVJDSF9UUkFOU1BBUkVOVF9IVUdFUEFHRQogCXNlbGVjdCBIQVZF X0FSQ0hfVFJBTlNQQVJFTlRfSFVHRVBBR0VfUFVEIGlmIFg4Nl82NApkaWZmIC0tZ2l0IGEvc2Vj dXJpdHkvS2NvbmZpZy5oYXJkZW5pbmcgYi9zZWN1cml0eS9LY29uZmlnLmhhcmRlbmluZwppbmRl eCBmZDEyMzg3NTNjYWQuLjEyNWIzNWUyZWYwZiAxMDA2NDQKLS0tIGEvc2VjdXJpdHkvS2NvbmZp Zy5oYXJkZW5pbmcKKysrIGIvc2VjdXJpdHkvS2NvbmZpZy5oYXJkZW5pbmcKQEAgLTgyLDEwICs4 MiwxMCBAQCBjaG9pY2UKIAogZW5kY2hvaWNlCiAKLWNvbmZpZyBHQ0NfUExVR0lOX1NUQUNLTEVB SworY29uZmlnIEtTVEFDS19FUkFTRQogCWJvb2wgIlBvaXNvbiBrZXJuZWwgc3RhY2sgYmVmb3Jl IHJldHVybmluZyBmcm9tIHN5c2NhbGxzIgorCWRlcGVuZHMgb24gSEFWRV9BUkNIX0tTVEFDS19F UkFTRQogCWRlcGVuZHMgb24gR0NDX1BMVUdJTlMKLQlkZXBlbmRzIG9uIEhBVkVfQVJDSF9TVEFD S0xFQUsKIAloZWxwCiAJICBUaGlzIG9wdGlvbiBtYWtlcyB0aGUga2VybmVsIGVyYXNlIHRoZSBr ZXJuZWwgc3RhY2sgYmVmb3JlCiAJICByZXR1cm5pbmcgZnJvbSBzeXN0ZW0gY2FsbHMuIFRoaXMg aGFzIHRoZSBlZmZlY3Qgb2YgbGVhdmluZwpAQCAtMTAzLDYgKzEwMywxMCBAQCBjb25maWcgR0ND X1BMVUdJTl9TVEFDS0xFQUsKIAkgIGFyZSBhZHZpc2VkIHRvIHRlc3QgdGhpcyBmZWF0dXJlIG9u IHlvdXIgZXhwZWN0ZWQgd29ya2xvYWQgYmVmb3JlCiAJICBkZXBsb3lpbmcgaXQuCiAKK2NvbmZp ZyBHQ0NfUExVR0lOX1NUQUNLTEVBSworCWRlZl9ib29sIEtTVEFDS19FUkFTRQorCWRlcGVuZHMg b24gR0NDX1BMVUdJTlMKKwloZWxwCiAJICBUaGlzIHBsdWdpbiB3YXMgcG9ydGVkIGZyb20gZ3Jz ZWN1cml0eS9QYVguIE1vcmUgaW5mb3JtYXRpb24gYXQ6CiAJICAgKiBodHRwczovL2dyc2VjdXJp dHkubmV0LwogCSAgICogaHR0cHM6Ly9wYXguZ3JzZWN1cml0eS5uZXQvCkBAIC0xMTcsMzcgKzEy MSwzNyBAQCBjb25maWcgR0NDX1BMVUdJTl9TVEFDS0xFQUtfVkVSQk9TRQogCSAgaW5zdHJ1bWVu dGVkLiBUaGlzIGlzIHVzZWZ1bCBmb3IgY29tcGFyaW5nIGNvdmVyYWdlIGJldHdlZW4KIAkgIGJ1 aWxkcy4KIAotY29uZmlnIFNUQUNLTEVBS19UUkFDS19NSU5fU0laRQotCWludCAiTWluaW11bSBz dGFjayBmcmFtZSBzaXplIG9mIGZ1bmN0aW9ucyB0cmFja2VkIGJ5IFNUQUNLTEVBSyIKK2NvbmZp ZyBLU1RBQ0tfRVJBU0VfVFJBQ0tfTUlOX1NJWkUKKwlpbnQgIk1pbmltdW0gc3RhY2sgZnJhbWUg c2l6ZSBvZiBmdW5jdGlvbnMgdHJhY2tlZCBieSBLU1RBQ0tfRVJBU0UiCiAJZGVmYXVsdCAxMDAK IAlyYW5nZSAwIDQwOTYKLQlkZXBlbmRzIG9uIEdDQ19QTFVHSU5fU1RBQ0tMRUFLCisJZGVwZW5k cyBvbiBLU1RBQ0tfRVJBU0UKIAloZWxwCi0JICBUaGUgU1RBQ0tMRUFLIGdjYyBwbHVnaW4gaW5z dHJ1bWVudHMgdGhlIGtlcm5lbCBjb2RlIGZvciB0cmFja2luZworCSAgVGhlIEtTVEFDS19FUkFT RSBvcHRpb24gaW5zdHJ1bWVudHMgdGhlIGtlcm5lbCBjb2RlIGZvciB0cmFja2luZwogCSAgdGhl IGxvd2VzdCBib3JkZXIgb2YgdGhlIGtlcm5lbCBzdGFjayAoYW5kIGZvciBzb21lIG90aGVyIHB1 cnBvc2VzKS4KIAkgIEl0IGluc2VydHMgdGhlIHN0YWNrbGVha190cmFja19zdGFjaygpIGNhbGwg Zm9yIHRoZSBmdW5jdGlvbnMgd2l0aAogCSAgYSBzdGFjayBmcmFtZSBzaXplIGdyZWF0ZXIgdGhh biBvciBlcXVhbCB0byB0aGlzIHBhcmFtZXRlci4KIAkgIElmIHVuc3VyZSwgbGVhdmUgdGhlIGRl ZmF1bHQgdmFsdWUgMTAwLgogCi1jb25maWcgU1RBQ0tMRUFLX01FVFJJQ1MKLQlib29sICJTaG93 IFNUQUNLTEVBSyBtZXRyaWNzIGluIHRoZSAvcHJvYyBmaWxlIHN5c3RlbSIKLQlkZXBlbmRzIG9u IEdDQ19QTFVHSU5fU1RBQ0tMRUFLCitjb25maWcgS1NUQUNLX0VSQVNFX01FVFJJQ1MKKwlib29s ICJTaG93IEtTVEFDS19FUkFTRSBtZXRyaWNzIGluIHRoZSAvcHJvYyBmaWxlIHN5c3RlbSIKKwlk ZXBlbmRzIG9uIEtTVEFDS19FUkFTRQogCWRlcGVuZHMgb24gUFJPQ19GUwogCWhlbHAKLQkgIElm IHRoaXMgaXMgc2V0LCBTVEFDS0xFQUsgbWV0cmljcyBmb3IgZXZlcnkgdGFzayBhcmUgYXZhaWxh YmxlIGluCi0JICB0aGUgL3Byb2MgZmlsZSBzeXN0ZW0uIEluIHBhcnRpY3VsYXIsIC9wcm9jLzxw aWQ+L3N0YWNrX2RlcHRoCisJICBJZiB0aGlzIGlzIHNldCwgS1NUQUNLX0VSQVNFIG1ldHJpY3Mg Zm9yIGV2ZXJ5IHRhc2sgYXJlIGF2YWlsYWJsZQorCSAgaW4gdGhlIC9wcm9jIGZpbGUgc3lzdGVt LiBJbiBwYXJ0aWN1bGFyLCAvcHJvYy88cGlkPi9zdGFja19kZXB0aAogCSAgc2hvd3MgdGhlIG1h eGltdW0ga2VybmVsIHN0YWNrIGNvbnN1bXB0aW9uIGZvciB0aGUgY3VycmVudCBhbmQKIAkgIHBy ZXZpb3VzIHN5c2NhbGxzLiBBbHRob3VnaCB0aGlzIGluZm9ybWF0aW9uIGlzIG5vdCBwcmVjaXNl LCBpdAotCSAgY2FuIGJlIHVzZWZ1bCBmb3IgZXN0aW1hdGluZyB0aGUgU1RBQ0tMRUFLIHBlcmZv cm1hbmNlIGltcGFjdCBmb3IKLQkgIHlvdXIgd29ya2xvYWRzLgorCSAgY2FuIGJlIHVzZWZ1bCBm b3IgZXN0aW1hdGluZyB0aGUgS1NUQUNLX0VSQVNFIHBlcmZvcm1hbmNlIGltcGFjdAorCSAgZm9y IHlvdXIgd29ya2xvYWRzLgogCi1jb25maWcgU1RBQ0tMRUFLX1JVTlRJTUVfRElTQUJMRQorY29u ZmlnIEtTVEFDS19FUkFTRV9SVU5USU1FX0RJU0FCTEUKIAlib29sICJBbGxvdyBydW50aW1lIGRp c2FibGluZyBvZiBrZXJuZWwgc3RhY2sgZXJhc2luZyIKLQlkZXBlbmRzIG9uIEdDQ19QTFVHSU5f U1RBQ0tMRUFLCisJZGVwZW5kcyBvbiBLU1RBQ0tfRVJBU0UKIAloZWxwCiAJICBUaGlzIG9wdGlv biBwcm92aWRlcyAnc3RhY2tfZXJhc2luZycgc3lzY3RsLCB3aGljaCBjYW4gYmUgdXNlZCBpbgog CSAgcnVudGltZSB0byBjb250cm9sIGtlcm5lbCBzdGFjayBlcmFzaW5nIGZvciBrZXJuZWxzIGJ1 aWx0IHdpdGgKLQkgIENPTkZJR19HQ0NfUExVR0lOX1NUQUNLTEVBSy4KKwkgIENPTkZJR19LU1RB Q0tfRVJBU0UuCiAKIGNvbmZpZyBJTklUX09OX0FMTE9DX0RFRkFVTFRfT04KIAlib29sICJFbmFi bGUgaGVhcCBtZW1vcnkgemVyb2luZyBvbiBhbGxvY2F0aW9uIGJ5IGRlZmF1bHQiCmRpZmYgLS1n aXQgYS9hcmNoL2FybS9ib290L2NvbXByZXNzZWQvTWFrZWZpbGUgYi9hcmNoL2FybS9ib290L2Nv bXByZXNzZWQvTWFrZWZpbGUKaW5kZXggZDYxMzY5YjFlYWJlLi5mOTA3NWVkZmQ3NzMgMTAwNjQ0 Ci0tLSBhL2FyY2gvYXJtL2Jvb3QvY29tcHJlc3NlZC9NYWtlZmlsZQorKysgYi9hcmNoL2FybS9i b290L2NvbXByZXNzZWQvTWFrZWZpbGUKQEAgLTksNyArOSw3IEBAIE9CSlMJCT0KIAogSEVBRAk9 IGhlYWQubwogT0JKUwkrPSBtaXNjLm8gZGVjb21wcmVzcy5vCi1DRkxBR1NfZGVjb21wcmVzcy5v ICs9ICQoRElTQUJMRV9TVEFDS0xFQUtfUExVR0lOKQorQ0ZMQUdTX2RlY29tcHJlc3MubyArPSAk KERJU0FCTEVfS1NUQUNLX0VSQVNFKQogaWZlcSAoJChDT05GSUdfREVCVUdfVU5DT01QUkVTUyks eSkKIE9CSlMJKz0gZGVidWcubwogQUZMQUdTX2hlYWQubyArPSAtRERFQlVHCmRpZmYgLS1naXQg YS9hcmNoL2FybTY0L2tlcm5lbC9waS9NYWtlZmlsZSBiL2FyY2gvYXJtNjQva2VybmVsL3BpL01h a2VmaWxlCmluZGV4IDRkMTFhOGMyOTE4MS4uZjQ0MGJmNTdiMWE1IDEwMDY0NAotLS0gYS9hcmNo L2FybTY0L2tlcm5lbC9waS9NYWtlZmlsZQorKysgYi9hcmNoL2FybTY0L2tlcm5lbC9waS9NYWtl ZmlsZQpAQCAtMiw3ICsyLDcgQEAKICMgQ29weXJpZ2h0IDIwMjIgR29vZ2xlIExMQwogCiBLQlVJ TERfQ0ZMQUdTCTo9ICQoc3Vic3QgJChDQ19GTEFHU19GVFJBQ0UpLCwkKEtCVUlMRF9DRkxBR1Mp KSAtZnBpZSBcCi0JCSAgIC1PcyAtRERJU0FCTEVfQlJBTkNIX1BST0ZJTElORyAkKERJU0FCTEVf U1RBQ0tMRUFLX1BMVUdJTikgXAorCQkgICAtT3MgLURESVNBQkxFX0JSQU5DSF9QUk9GSUxJTkcg JChESVNBQkxFX0tTVEFDS19FUkFTRSkgXAogCQkgICAkKERJU0FCTEVfTEFURU5UX0VOVFJPUFlf UExVR0lOKSBcCiAJCSAgICQoY2FsbCBjYy1vcHRpb24sLW1icmFuY2gtcHJvdGVjdGlvbj1ub25l KSBcCiAJCSAgIC1JJChzcmN0cmVlKS9zY3JpcHRzL2R0Yy9saWJmZHQgLWZuby1zdGFjay1wcm90 ZWN0b3IgXApkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9rdm0vaHlwL252aGUvTWFrZWZpbGUgYi9h cmNoL2FybTY0L2t2bS9oeXAvbnZoZS9NYWtlZmlsZQppbmRleCBhNzY1MjJkNjNjM2UuLjBiMGE2 OGI2NjNkNCAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9rdm0vaHlwL252aGUvTWFrZWZpbGUKKysr IGIvYXJjaC9hcm02NC9rdm0vaHlwL252aGUvTWFrZWZpbGUKQEAgLTEyLDcgKzEyLDcgQEAgYXNm bGFncy15IDo9IC1EX19LVk1fTlZIRV9IWVBFUlZJU09SX18gLURfX0RJU0FCTEVfRVhQT1JUUwog Y2NmbGFncy15IDo9IC1EX19LVk1fTlZIRV9IWVBFUlZJU09SX18gLURfX0RJU0FCTEVfRVhQT1JU UyAtRF9fRElTQUJMRV9UUkFDRV9NTUlPX18KIGNjZmxhZ3MteSArPSAtZm5vLXN0YWNrLXByb3Rl Y3RvcglcCiAJICAgICAtRERJU0FCTEVfQlJBTkNIX1BST0ZJTElORwlcCi0JICAgICAkKERJU0FC TEVfU1RBQ0tMRUFLX1BMVUdJTikKKwkgICAgICQoRElTQUJMRV9LU1RBQ0tfRVJBU0UpCiAKIGhv c3Rwcm9ncyA6PSBnZW4taHlwcmVsCiBIT1NUX0VYVFJBQ0ZMQUdTICs9IC1JJChvYmp0cmVlKS9p bmNsdWRlCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC9waS9NYWtlZmlsZSBiL2FyY2gv cmlzY3Yva2VybmVsL3BpL01ha2VmaWxlCmluZGV4IDgxZDY5ZDQ1YzA2Yy4uN2RkMTViZTY5Yzkw IDEwMDY0NAotLS0gYS9hcmNoL3Jpc2N2L2tlcm5lbC9waS9NYWtlZmlsZQorKysgYi9hcmNoL3Jp c2N2L2tlcm5lbC9waS9NYWtlZmlsZQpAQCAtMiw3ICsyLDcgQEAKICMgVGhpcyBmaWxlIHdhcyBj b3BpZWQgZnJvbSBhcm02NC9rZXJuZWwvcGkvTWFrZWZpbGUuCiAKIEtCVUlMRF9DRkxBR1MJOj0g JChzdWJzdCAkKENDX0ZMQUdTX0ZUUkFDRSksLCQoS0JVSUxEX0NGTEFHUykpIC1mcGllIFwKLQkJ ICAgLU9zIC1ERElTQUJMRV9CUkFOQ0hfUFJPRklMSU5HICQoRElTQUJMRV9TVEFDS0xFQUtfUExV R0lOKSBcCisJCSAgIC1PcyAtRERJU0FCTEVfQlJBTkNIX1BST0ZJTElORyAkKERJU0FCTEVfS1NU QUNLX0VSQVNFKSBcCiAJCSAgICQoY2FsbCBjYy1vcHRpb24sLW1icmFuY2gtcHJvdGVjdGlvbj1u b25lKSBcCiAJCSAgIC1JJChzcmN0cmVlKS9zY3JpcHRzL2R0Yy9saWJmZHQgLWZuby1zdGFjay1w cm90ZWN0b3IgXAogCQkgICAtaW5jbHVkZSAkKHNyY3RyZWUpL2luY2x1ZGUvbGludXgvaGlkZGVu LmggXApkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9wdXJnYXRvcnkvTWFrZWZpbGUgYi9hcmNoL3Jp c2N2L3B1cmdhdG9yeS9NYWtlZmlsZQppbmRleCBmYjljOTE3YzliNDUuLjI0MDU5MmUzZjVjMiAx MDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9wdXJnYXRvcnkvTWFrZWZpbGUKKysrIGIvYXJjaC9yaXNj di9wdXJnYXRvcnkvTWFrZWZpbGUKQEAgLTUzLDcgKzUzLDcgQEAgdGFyZ2V0cyArPSBwdXJnYXRv cnkucm8gcHVyZ2F0b3J5LmNoawogCiBQVVJHQVRPUllfQ0ZMQUdTX1JFTU9WRSA6PSAtbWNtb2Rl bD1rZXJuZWwKIFBVUkdBVE9SWV9DRkxBR1MgOj0gLW1jbW9kZWw9bWVkYW55IC1mZnJlZXN0YW5k aW5nIC1mbm8temVyby1pbml0aWFsaXplZC1pbi1ic3MKLVBVUkdBVE9SWV9DRkxBR1MgKz0gJChE SVNBQkxFX1NUQUNLTEVBS19QTFVHSU4pIC1ERElTQUJMRV9CUkFOQ0hfUFJPRklMSU5HCitQVVJH QVRPUllfQ0ZMQUdTICs9ICQoRElTQUJMRV9LU1RBQ0tfRVJBU0UpIC1ERElTQUJMRV9CUkFOQ0hf UFJPRklMSU5HCiBQVVJHQVRPUllfQ0ZMQUdTICs9IC1mbm8tc3RhY2stcHJvdGVjdG9yIC1nMAog CiAjIERlZmF1bHQgS0JVSUxEX0NGTEFHUyBjYW4gaGF2ZSAtcGcgb3B0aW9uIHNldCB3aGVuIEZU UkFDRSBpcyBlbmFibGVkLiBUaGF0CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9wdXJnYXRvcnkvTWFr ZWZpbGUgYi9hcmNoL3g4Ni9wdXJnYXRvcnkvTWFrZWZpbGUKaW5kZXggZWJkZmQ3Yjg0ZmViLi5l MGE2MDdhMTRlN2UgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L3B1cmdhdG9yeS9NYWtlZmlsZQorKysg Yi9hcmNoL3g4Ni9wdXJnYXRvcnkvTWFrZWZpbGUKQEAgLTM1LDcgKzM1LDcgQEAgdGFyZ2V0cyAr PSBwdXJnYXRvcnkucm8gcHVyZ2F0b3J5LmNoawogUFVSR0FUT1JZX0NGTEFHU19SRU1PVkUgOj0g LW1jbW9kZWw9a2VybmVsCiBQVVJHQVRPUllfQ0ZMQUdTIDo9IC1tY21vZGVsPXNtYWxsIC1mZnJl ZXN0YW5kaW5nIC1mbm8temVyby1pbml0aWFsaXplZC1pbi1ic3MgLWcwCiBQVVJHQVRPUllfQ0ZM QUdTICs9IC1mcGljIC1mdmlzaWJpbGl0eT1oaWRkZW4KLVBVUkdBVE9SWV9DRkxBR1MgKz0gJChE SVNBQkxFX1NUQUNLTEVBS19QTFVHSU4pIC1ERElTQUJMRV9CUkFOQ0hfUFJPRklMSU5HCitQVVJH QVRPUllfQ0ZMQUdTICs9ICQoRElTQUJMRV9LU1RBQ0tfRVJBU0UpIC1ERElTQUJMRV9CUkFOQ0hf UFJPRklMSU5HCiBQVVJHQVRPUllfQ0ZMQUdTICs9IC1mbm8tc3RhY2stcHJvdGVjdG9yCiAKICMg RGVmYXVsdCBLQlVJTERfQ0ZMQUdTIGNhbiBoYXZlIC1wZyBvcHRpb24gc2V0IHdoZW4gRlRSQUNF IGlzIGVuYWJsZWQuIFRoYXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZmlybXdhcmUvZWZpL2xpYnN0 dWIvTWFrZWZpbGUgYi9kcml2ZXJzL2Zpcm13YXJlL2VmaS9saWJzdHViL01ha2VmaWxlCmluZGV4 IDZhMDE1Mjg1OGEyYS4uY2RiYTE0ZGRlN2Q1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Zpcm13YXJl L2VmaS9saWJzdHViL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvZmlybXdhcmUvZWZpL2xpYnN0dWIv TWFrZWZpbGUKQEAgLTIyLDE2ICsyMiwxNiBAQCBjZmxhZ3MtJChDT05GSUdfWDg2KQkJKz0gLW0k KEJJVFMpIC1EX19LRVJORUxfXyAtc3RkPWdudTExIFwKIAogIyBhcm02NCB1c2VzIHRoZSBmdWxs IEtCVUlMRF9DRkxBR1Mgc28gaXQncyBuZWNlc3NhcnkgdG8gZXhwbGljaXRseQogIyBkaXNhYmxl IHRoZSBzdGFja2xlYWsgcGx1Z2luCi1jZmxhZ3MtJChDT05GSUdfQVJNNjQpCQkrPSAtZnBpZSAk KERJU0FCTEVfU1RBQ0tMRUFLX1BMVUdJTikgXAorY2ZsYWdzLSQoQ09ORklHX0FSTTY0KQkJKz0g LWZwaWUgJChESVNBQkxFX0tTVEFDS19FUkFTRSkgXAogCQkJCSAgIC1mbm8tdW53aW5kLXRhYmxl cyAtZm5vLWFzeW5jaHJvbm91cy11bndpbmQtdGFibGVzCiBjZmxhZ3MtJChDT05GSUdfQVJNKQkJ Kz0gLURFRklfSEFWRV9TVFJMRU4gLURFRklfSEFWRV9TVFJOTEVOIFwKIAkJCQkgICAtREVGSV9I QVZFX01FTUNIUiAtREVGSV9IQVZFX1NUUlJDSFIgXAogCQkJCSAgIC1ERUZJX0hBVkVfU1RSQ01Q IC1mbm8tYnVpbHRpbiAtZnBpYyBcCiAJCQkJICAgJChjYWxsIGNjLW9wdGlvbiwtbW5vLXNpbmds ZS1waWMtYmFzZSkgXAotCQkJCSAgICQoRElTQUJMRV9TVEFDS0xFQUtfUExVR0lOKQorCQkJCSAg ICQoRElTQUJMRV9LU1RBQ0tfRVJBU0UpCiBjZmxhZ3MtJChDT05GSUdfUklTQ1YpCQkrPSAtZnBp YyAtRE5PX0FMVEVSTkFUSVZFIC1tbm8tcmVsYXggXAotCQkJCSAgICQoRElTQUJMRV9TVEFDS0xF QUtfUExVR0lOKQotY2ZsYWdzLSQoQ09ORklHX0xPT05HQVJDSCkJKz0gLWZwaWUgJChESVNBQkxF X1NUQUNLTEVBS19QTFVHSU4pCisJCQkJICAgJChESVNBQkxFX0tTVEFDS19FUkFTRSkKK2NmbGFn cy0kKENPTkZJR19MT09OR0FSQ0gpCSs9IC1mcGllICQoRElTQUJMRV9LU1RBQ0tfRVJBU0UpCiAK IGNmbGFncy0kKENPTkZJR19FRklfUEFSQU1TX0ZST01fRkRUKQkrPSAtSSQoc3JjdHJlZSkvc2Ny aXB0cy9kdGMvbGliZmR0CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWlzYy9sa2R0bS9NYWtlZmls ZSBiL2RyaXZlcnMvbWlzYy9sa2R0bS9NYWtlZmlsZQppbmRleCAzOTQ2OGJkMjdiODUuLjAzZWJl MzMxODVmOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9taXNjL2xrZHRtL01ha2VmaWxlCisrKyBiL2Ry aXZlcnMvbWlzYy9sa2R0bS9NYWtlZmlsZQpAQCAtOCw3ICs4LDcgQEAgbGtkdG0tJChDT05GSUdf TEtEVE0pCQkrPSBwZXJtcy5vCiBsa2R0bS0kKENPTkZJR19MS0RUTSkJCSs9IHJlZmNvdW50Lm8K IGxrZHRtLSQoQ09ORklHX0xLRFRNKQkJKz0gcm9kYXRhX29iamNvcHkubwogbGtkdG0tJChDT05G SUdfTEtEVE0pCQkrPSB1c2VyY29weS5vCi1sa2R0bS0kKENPTkZJR19MS0RUTSkJCSs9IHN0YWNr bGVhay5vCitsa2R0bS0kKENPTkZJR19MS0RUTSkJCSs9IGtzdGFja19lcmFzZS5vCiBsa2R0bS0k KENPTkZJR19MS0RUTSkJCSs9IGNmaS5vCiBsa2R0bS0kKENPTkZJR19MS0RUTSkJCSs9IGZvcnRp ZnkubwogbGtkdG0tJChDT05GSUdfUFBDXzY0U19IQVNIX01NVSkJKz0gcG93ZXJwYy5vCmRpZmYg LS1naXQgYS9rZXJuZWwvTWFrZWZpbGUgYi9rZXJuZWwvTWFrZWZpbGUKaW5kZXggMzJlODBkZDYy NmFmLi5lNGYwMWYxZDRkMGMgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9NYWtlZmlsZQorKysgYi9rZXJu ZWwvTWFrZWZpbGUKQEAgLTEzOSwxMSArMTM5LDExIEBAIG9iai0kKENPTkZJR19XQVRDSF9RVUVV RSkgKz0gd2F0Y2hfcXVldWUubwogb2JqLSQoQ09ORklHX1JFU09VUkNFX0tVTklUX1RFU1QpICs9 IHJlc291cmNlX2t1bml0Lm8KIG9iai0kKENPTkZJR19TWVNDVExfS1VOSVRfVEVTVCkgKz0gc3lz Y3RsLXRlc3QubwogCi1DRkxBR1Nfc3RhY2tsZWFrLm8gKz0gJChESVNBQkxFX1NUQUNLTEVBS19Q TFVHSU4pCi1vYmotJChDT05GSUdfR0NDX1BMVUdJTl9TVEFDS0xFQUspICs9IHN0YWNrbGVhay5v Ci1LQVNBTl9TQU5JVElaRV9zdGFja2xlYWsubyA6PSBuCi1LQ1NBTl9TQU5JVElaRV9zdGFja2xl YWsubyA6PSBuCi1LQ09WX0lOU1RSVU1FTlRfc3RhY2tsZWFrLm8gOj0gbgorQ0ZMQUdTX2tzdGFj a19lcmFzZS5vICs9ICQoRElTQUJMRV9LU1RBQ0tfRVJBU0UpCitvYmotJChDT05GSUdfS1NUQUNL X0VSQVNFKSArPSBrc3RhY2tfZXJhc2UubworS0FTQU5fU0FOSVRJWkVfa3N0YWNrX2VyYXNlLm8g Oj0gbgorS0NTQU5fU0FOSVRJWkVfa3N0YWNrX2VyYXNlLm8gOj0gbgorS0NPVl9JTlNUUlVNRU5U X2tzdGFja19lcmFzZS5vIDo9IG4KIAogb2JqLSQoQ09ORklHX1NDRl9UT1JUVVJFX1RFU1QpICs9 IHNjZnRvcnR1cmUubwogCmRpZmYgLS1naXQgYS9saWIvTWFrZWZpbGUgYi9saWIvTWFrZWZpbGUK aW5kZXggYzM4NTgyZjE4N2RkLi42MzJlNjlkMjVmZWIgMTAwNjQ0Ci0tLSBhL2xpYi9NYWtlZmls ZQorKysgYi9saWIvTWFrZWZpbGUKQEAgLTMzNyw3ICszMzcsNyBAQCBvYmotJChDT05GSUdfVUJT QU4pICs9IHVic2FuLm8KIFVCU0FOX1NBTklUSVpFX3Vic2FuLm8gOj0gbgogS0FTQU5fU0FOSVRJ WkVfdWJzYW4ubyA6PSBuCiBLQ1NBTl9TQU5JVElaRV91YnNhbi5vIDo9IG4KLUNGTEFHU191YnNh bi5vIDo9IC1mbm8tc3RhY2stcHJvdGVjdG9yICQoRElTQUJMRV9TVEFDS0xFQUtfUExVR0lOKQor Q0ZMQUdTX3Vic2FuLm8gOj0gLWZuby1zdGFjay1wcm90ZWN0b3IgJChESVNBQkxFX0tTVEFDS19F UkFTRSkKIAogb2JqLSQoQ09ORklHX1NCSVRNQVApICs9IHNiaXRtYXAubwogCmRpZmYgLS1naXQg YS9zY3JpcHRzL01ha2VmaWxlLmdjYy1wbHVnaW5zIGIvc2NyaXB0cy9NYWtlZmlsZS5nY2MtcGx1 Z2lucwppbmRleCA0MzVhYjNmMGVjNDQuLjI4Yjg4NjdjNGU4NCAxMDA2NDQKLS0tIGEvc2NyaXB0 cy9NYWtlZmlsZS5nY2MtcGx1Z2lucworKysgYi9zY3JpcHRzL01ha2VmaWxlLmdjYy1wbHVnaW5z CkBAIC0xMiwxNSArMTIsMTUgQEAgZ2NjLXBsdWdpbi0kKENPTkZJR19HQ0NfUExVR0lOX1NUQUNL TEVBSykJKz0gc3RhY2tsZWFrX3BsdWdpbi5zbwogZ2NjLXBsdWdpbi1jZmxhZ3MtJChDT05GSUdf R0NDX1BMVUdJTl9TVEFDS0xFQUspCQlcCiAJCSs9IC1EU1RBQ0tMRUFLX1BMVUdJTgogZ2NjLXBs dWdpbi1jZmxhZ3MtJChDT05GSUdfR0NDX1BMVUdJTl9TVEFDS0xFQUspCQlcCi0JCSs9IC1mcGx1 Z2luLWFyZy1zdGFja2xlYWtfcGx1Z2luLXRyYWNrLW1pbi1zaXplPSQoQ09ORklHX1NUQUNLTEVB S19UUkFDS19NSU5fU0laRSkKKwkJKz0gLWZwbHVnaW4tYXJnLXN0YWNrbGVha19wbHVnaW4tdHJh Y2stbWluLXNpemU9JChDT05GSUdfS1NUQUNLX0VSQVNFX1RSQUNLX01JTl9TSVpFKQogZ2NjLXBs dWdpbi1jZmxhZ3MtJChDT05GSUdfR0NDX1BMVUdJTl9TVEFDS0xFQUspCQlcCiAJCSs9IC1mcGx1 Z2luLWFyZy1zdGFja2xlYWtfcGx1Z2luLWFyY2g9JChTUkNBUkNIKQogZ2NjLXBsdWdpbi1jZmxh Z3MtJChDT05GSUdfR0NDX1BMVUdJTl9TVEFDS0xFQUtfVkVSQk9TRSkJXAogCQkrPSAtZnBsdWdp bi1hcmctc3RhY2tsZWFrX3BsdWdpbi12ZXJib3NlCiBpZmRlZiBDT05GSUdfR0NDX1BMVUdJTl9T VEFDS0xFQUsKLSAgICBESVNBQkxFX1NUQUNLTEVBS19QTFVHSU4gKz0gLWZwbHVnaW4tYXJnLXN0 YWNrbGVha19wbHVnaW4tZGlzYWJsZQorICAgIERJU0FCTEVfS1NUQUNLX0VSQVNFICs9IC1mcGx1 Z2luLWFyZy1zdGFja2xlYWtfcGx1Z2luLWRpc2FibGUKIGVuZGlmCi1leHBvcnQgRElTQUJMRV9T VEFDS0xFQUtfUExVR0lOCitleHBvcnQgRElTQUJMRV9LU1RBQ0tfRVJBU0UKIAogIyBBbGwgdGhl IHBsdWdpbiBDRkxBR1MgYXJlIGNvbGxlY3RlZCBoZXJlIGluIGNhc2UgYSBidWlsZCB0YXJnZXQg bmVlZHMgdG8KICMgZmlsdGVyIHRoZW0gb3V0IG9mIHRoZSBLQlVJTERfQ0ZMQUdTLgpkaWZmIC0t Z2l0IGEvRG9jdW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9zeXNjdGwva2VybmVsLnJzdCBiL0RvY3Vt ZW50YXRpb24vYWRtaW4tZ3VpZGUvc3lzY3RsL2tlcm5lbC5yc3QKaW5kZXggZGQ0OWE4OWE2MmQz Li4xOTIyNGVlYWMxYzIgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vYWRtaW4tZ3VpZGUvc3lz Y3RsL2tlcm5lbC5yc3QKKysrIGIvRG9jdW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9zeXNjdGwva2Vy bmVsLnJzdApAQCAtMTQ2NSw3ICsxNDY1LDcgQEAgc3RhY2tfZXJhc2luZwogPT09PT09PT09PT09 PQogCiBUaGlzIHBhcmFtZXRlciBjYW4gYmUgdXNlZCB0byBjb250cm9sIGtlcm5lbCBzdGFjayBl cmFzaW5nIGF0IHRoZSBlbmQKLW9mIHN5c2NhbGxzIGZvciBrZXJuZWxzIGJ1aWx0IHdpdGggYGBD T05GSUdfR0NDX1BMVUdJTl9TVEFDS0xFQUtgYC4KK29mIHN5c2NhbGxzIGZvciBrZXJuZWxzIGJ1 aWx0IHdpdGggYGBDT05GSUdfS1NUQUNLX0VSQVNFYGAuCiAKIFRoYXQgZXJhc2luZyByZWR1Y2Vz IHRoZSBpbmZvcm1hdGlvbiB3aGljaCBrZXJuZWwgc3RhY2sgbGVhayBidWdzCiBjYW4gcmV2ZWFs IGFuZCBibG9ja3Mgc29tZSB1bmluaXRpYWxpemVkIHN0YWNrIHZhcmlhYmxlIGF0dGFja3MuCkBA IC0xNDczLDcgKzE0NzMsNyBAQCBUaGUgdHJhZGVvZmYgaXMgdGhlIHBlcmZvcm1hbmNlIGltcGFj dDogb24gYSBzaW5nbGUgQ1BVIHN5c3RlbSBrZXJuZWwKIGNvbXBpbGF0aW9uIHNlZXMgYSAxJSBz bG93ZG93biwgb3RoZXIgc3lzdGVtcyBhbmQgd29ya2xvYWRzIG1heSB2YXJ5LgogCiA9ID09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0wIEtlcm5lbCBzdGFjayBlcmFzaW5nIGlzIGRpc2FibGVkLCBTVEFDS0xFQUtfTUVU UklDUyBhcmUgbm90IHVwZGF0ZWQuCiswIEtlcm5lbCBzdGFjayBlcmFzaW5nIGlzIGRpc2FibGVk LCBLU1RBQ0tfRVJBU0VfTUVUUklDUyBhcmUgbm90IHVwZGF0ZWQuCiAxIEtlcm5lbCBzdGFjayBl cmFzaW5nIGlzIGVuYWJsZWQgKGRlZmF1bHQpLCBpdCBpcyBwZXJmb3JtZWQgYmVmb3JlCiAgIHJl dHVybmluZyB0byB0aGUgdXNlcnNwYWNlIGF0IHRoZSBlbmQgb2Ygc3lzY2FsbHMuCiA9ID09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2FyY2gveDg2L3g4Nl82NC9tbS5yc3Qg Yi9Eb2N1bWVudGF0aW9uL2FyY2gveDg2L3g4Nl82NC9tbS5yc3QKaW5kZXggZjJkYjE3OGIzNTNm Li5hNmNmMDVkNTFiZDggMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vYXJjaC94ODYveDg2XzY0 L21tLnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL2FyY2gveDg2L3g4Nl82NC9tbS5yc3QKQEAgLTE3 Niw1ICsxNzYsNSBAQCBCZSB2ZXJ5IGNhcmVmdWwgdnMuIEtBU0xSIHdoZW4gY2hhbmdpbmcgYW55 dGhpbmcgaGVyZS4gVGhlIEtBU0xSIGFkZHJlc3MKIHJhbmdlIG11c3Qgbm90IG92ZXJsYXAgd2l0 aCBhbnl0aGluZyBleGNlcHQgdGhlIEtBU0FOIHNoYWRvdyBhcmVhLCB3aGljaCBpcwogY29ycmVj dCBhcyBLQVNBTiBkaXNhYmxlcyBLQVNMUi4KIAotRm9yIGJvdGggNC0gYW5kIDUtbGV2ZWwgbGF5 b3V0cywgdGhlIFNUQUNLTEVBS19QT0lTT04gdmFsdWUgaW4gdGhlIGxhc3QgMk1CCitGb3IgYm90 aCA0LSBhbmQgNS1sZXZlbCBsYXlvdXRzLCB0aGUgS1NUQUNLX0VSQVNFX1BPSVNPTiB2YWx1ZSBp biB0aGUgbGFzdCAyTUIKIGhvbGU6IGZmZmZmZmZmZmZmZjQxMTEKZGlmZiAtLWdpdCBhL0RvY3Vt ZW50YXRpb24vc2VjdXJpdHkvc2VsZi1wcm90ZWN0aW9uLnJzdCBiL0RvY3VtZW50YXRpb24vc2Vj dXJpdHkvc2VsZi1wcm90ZWN0aW9uLnJzdAppbmRleCA5MTA2NjhlNjY1Y2IuLmEzMmNhMjNjMjFi MCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9zZWN1cml0eS9zZWxmLXByb3RlY3Rpb24ucnN0 CisrKyBiL0RvY3VtZW50YXRpb24vc2VjdXJpdHkvc2VsZi1wcm90ZWN0aW9uLnJzdApAQCAtMzAz LDcgKzMwMyw3IEBAIE1lbW9yeSBwb2lzb25pbmcKIAogV2hlbiByZWxlYXNpbmcgbWVtb3J5LCBp dCBpcyBiZXN0IHRvIHBvaXNvbiB0aGUgY29udGVudHMsIHRvIGF2b2lkIHJldXNlCiBhdHRhY2tz IHRoYXQgcmVseSBvbiB0aGUgb2xkIGNvbnRlbnRzIG9mIG1lbW9yeS4gRS5nLiwgY2xlYXIgc3Rh Y2sgb24gYQotc3lzY2FsbCByZXR1cm4gKGBgQ09ORklHX0dDQ19QTFVHSU5fU1RBQ0tMRUFLYGAp LCB3aXBlIGhlYXAgbWVtb3J5IG9uIGEKK3N5c2NhbGwgcmV0dXJuIChgYENPTkZJR19LU1RBQ0tf RVJBU0VgYCksIHdpcGUgaGVhcCBtZW1vcnkgb24gYQogZnJlZS4gVGhpcyBmcnVzdHJhdGVzIG1h bnkgdW5pbml0aWFsaXplZCB2YXJpYWJsZSBhdHRhY2tzLCBzdGFjayBjb250ZW50CiBleHBvc3Vy ZXMsIGhlYXAgY29udGVudCBleHBvc3VyZXMsIGFuZCB1c2UtYWZ0ZXItZnJlZSBhdHRhY2tzLgog CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3RyYW5zbGF0aW9ucy96aF9DTi9zZWN1cml0eS9z ZWxmLXByb3RlY3Rpb24ucnN0IGIvRG9jdW1lbnRhdGlvbi90cmFuc2xhdGlvbnMvemhfQ04vc2Vj dXJpdHkvc2VsZi1wcm90ZWN0aW9uLnJzdAppbmRleCAzYzhhNjhiMWUxYmUuLjkzZGU5Y2VlNWMx YSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi90cmFuc2xhdGlvbnMvemhfQ04vc2VjdXJpdHkv c2VsZi1wcm90ZWN0aW9uLnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL3RyYW5zbGF0aW9ucy96aF9D Ti9zZWN1cml0eS9zZWxmLXByb3RlY3Rpb24ucnN0CkBAIC0yNTksNyArMjU5LDcgQEAgS0FMTFNZ U03vvIzliJnkvJrnm7TmjqXmiZPljbDljp/lp4vlnLDlnYDjgIIKIC0tLS0tLS0tCiAKIOWcqOmH iuaUvuWGheWtmOaXtu+8jOacgOWlveWvueWGheWtmOWGheWuuei/m+ihjOa4hemZpOWkhOeQhu+8 jOS7pemYsuatouaUu+WHu+iAhemHjeeUqOWGheWtmOS4reS7peWJjQot55qE5YaF5a6544CC5L6L 5aaC77yM5Zyo57O757uf6LCD55So6L+U5Zue5pe25riF6Zmk5aCG5qCI77yIQ09ORklHX0dDQ19Q TFVHSU5fU1RBQ0tMRUFL77yJLAor55qE5YaF5a6544CC5L6L5aaC77yM5Zyo57O757uf6LCD55So 6L+U5Zue5pe25riF6Zmk5aCG5qCI77yIQ09ORklHX0tTVEFDS19FUkFTRe+8iSwKIOWcqOmHiuaU vuWghuWGheWuueaYr+a4hemZpOWFtuWGheWuueOAgui/meacieWKqeS6jumYsuatouiuuOWkmuac quWIneWni+WMluWPmOmHj+aUu+WHu+OAgeWghuagiOWGheWuuQog5rOE6Zyy44CB5aCG5YaF5a65 5rOE6Zyy5Lul5Y+K5L2/55So5ZCO6YeK5pS+5pS75Ye777yIdXNlci1hZnRlci1mcmVl77yJ44CC CiAKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2VudHJ5L2NhbGxpbmcuaCBiL2FyY2gveDg2L2VudHJ5 L2NhbGxpbmcuaAppbmRleCBkODMyMzZiOTZmMjIuLjk0NTE5Njg4YjAwNyAxMDA2NDQKLS0tIGEv YXJjaC94ODYvZW50cnkvY2FsbGluZy5oCisrKyBiL2FyY2gveDg2L2VudHJ5L2NhbGxpbmcuaApA QCAtMzY5LDcgKzM2OSw3IEBAIEZvciAzMi1iaXQgd2UgaGF2ZSB0aGUgZm9sbG93aW5nIGNvbnZl bnRpb25zIC0ga2VybmVsIGlzIGJ1aWx0IHdpdGgKIC5lbmRtCiAKIC5tYWNybyBTVEFDS0xFQUtf RVJBU0VfTk9DTE9CQkVSCi0jaWZkZWYgQ09ORklHX0dDQ19QTFVHSU5fU1RBQ0tMRUFLCisjaWZk ZWYgQ09ORklHX0tTVEFDS19FUkFTRQogCVBVU0hfQU5EX0NMRUFSX1JFR1MKIAljYWxsIHN0YWNr bGVha19lcmFzZQogCVBPUF9SRUdTCkBAIC0zODgsNyArMzg4LDcgQEAgRm9yIDMyLWJpdCB3ZSBo YXZlIHRoZSBmb2xsb3dpbmcgY29udmVudGlvbnMgLSBrZXJuZWwgaXMgYnVpbHQgd2l0aAogI2Vu ZGlmIC8qICFDT05GSUdfWDg2XzY0ICovCiAKIC5tYWNybyBTVEFDS0xFQUtfRVJBU0UKLSNpZmRl ZiBDT05GSUdfR0NDX1BMVUdJTl9TVEFDS0xFQUsKKyNpZmRlZiBDT05GSUdfS1NUQUNLX0VSQVNF CiAJY2FsbCBzdGFja2xlYWtfZXJhc2UKICNlbmRpZgogLmVuZG0KZGlmZiAtLWdpdCBhL2luY2x1 ZGUvbGludXgvc3RhY2tsZWFrLmggYi9pbmNsdWRlL2xpbnV4L2tzdGFja19lcmFzZS5oCnNpbWls YXJpdHkgaW5kZXggODUlCnJlbmFtZSBmcm9tIGluY2x1ZGUvbGludXgvc3RhY2tsZWFrLmgKcmVu YW1lIHRvIGluY2x1ZGUvbGludXgva3N0YWNrX2VyYXNlLmgKaW5kZXggM2JlMmNiNTY0NzEwLi40 ZTQzMmVlZmE0ZDAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvc3RhY2tsZWFrLmgKKysrIGIv aW5jbHVkZS9saW51eC9rc3RhY2tfZXJhc2UuaApAQCAtMSw2ICsxLDYgQEAKIC8qIFNQRFgtTGlj ZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wICovCi0jaWZuZGVmIF9MSU5VWF9TVEFDS0xFQUtfSAot I2RlZmluZSBfTElOVVhfU1RBQ0tMRUFLX0gKKyNpZm5kZWYgX0xJTlVYX0tTVEFDS19FUkFTRV9I CisjZGVmaW5lIF9MSU5VWF9LU1RBQ0tfRVJBU0VfSAogCiAjaW5jbHVkZSA8bGludXgvc2NoZWQu aD4KICNpbmNsdWRlIDxsaW51eC9zY2hlZC90YXNrX3N0YWNrLmg+CkBAIC05LDEwICs5LDEwIEBA CiAgKiBDaGVjayB0aGF0IHRoZSBwb2lzb24gdmFsdWUgcG9pbnRzIHRvIHRoZSB1bnVzZWQgaG9s ZSBpbiB0aGUKICAqIHZpcnR1YWwgbWVtb3J5IG1hcCBmb3IgeW91ciBwbGF0Zm9ybS4KICAqLwot I2RlZmluZSBTVEFDS0xFQUtfUE9JU09OIC0weEJFRUYKLSNkZWZpbmUgU1RBQ0tMRUFLX1NFQVJD SF9ERVBUSCAxMjgKKyNkZWZpbmUgS1NUQUNLX0VSQVNFX1BPSVNPTiAtMHhCRUVGCisjZGVmaW5l IEtTVEFDS19FUkFTRV9TRUFSQ0hfREVQVEggMTI4CiAKLSNpZmRlZiBDT05GSUdfR0NDX1BMVUdJ Tl9TVEFDS0xFQUsKKyNpZmRlZiBDT05GSUdfS1NUQUNLX0VSQVNFCiAjaW5jbHVkZSA8YXNtL3N0 YWNrdHJhY2UuaD4KICNpbmNsdWRlIDxsaW51eC9saW5rYWdlLmg+CiAKQEAgLTUwLDcgKzUwLDcg QEAgc3RhY2tsZWFrX3Rhc2tfaGlnaF9ib3VuZChjb25zdCBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRz aykKIHN0YXRpYyBfX2Fsd2F5c19pbmxpbmUgdW5zaWduZWQgbG9uZwogc3RhY2tsZWFrX2ZpbmRf dG9wX29mX3BvaXNvbihjb25zdCB1bnNpZ25lZCBsb25nIGxvdywgY29uc3QgdW5zaWduZWQgbG9u ZyBoaWdoKQogewotCWNvbnN0IHVuc2lnbmVkIGludCBkZXB0aCA9IFNUQUNLTEVBS19TRUFSQ0hf REVQVEggLyBzaXplb2YodW5zaWduZWQgbG9uZyk7CisJY29uc3QgdW5zaWduZWQgaW50IGRlcHRo ID0gS1NUQUNLX0VSQVNFX1NFQVJDSF9ERVBUSCAvIHNpemVvZih1bnNpZ25lZCBsb25nKTsKIAl1 bnNpZ25lZCBpbnQgcG9pc29uX2NvdW50ID0gMDsKIAl1bnNpZ25lZCBsb25nIHBvaXNvbl9oaWdo ID0gaGlnaDsKIAl1bnNpZ25lZCBsb25nIHNwID0gaGlnaDsKQEAgLTU4LDcgKzU4LDcgQEAgc3Rh Y2tsZWFrX2ZpbmRfdG9wX29mX3BvaXNvbihjb25zdCB1bnNpZ25lZCBsb25nIGxvdywgY29uc3Qg dW5zaWduZWQgbG9uZyBoaWdoKQogCXdoaWxlIChzcCA+IGxvdyAmJiBwb2lzb25fY291bnQgPCBk ZXB0aCkgewogCQlzcCAtPSBzaXplb2YodW5zaWduZWQgbG9uZyk7CiAKLQkJaWYgKCoodW5zaWdu ZWQgbG9uZyAqKXNwID09IFNUQUNLTEVBS19QT0lTT04pIHsKKwkJaWYgKCoodW5zaWduZWQgbG9u ZyAqKXNwID09IEtTVEFDS19FUkFTRV9QT0lTT04pIHsKIAkJCXBvaXNvbl9jb3VudCsrOwogCQl9 IGVsc2UgewogCQkJcG9pc29uX2NvdW50ID0gMDsKQEAgLTcyLDcgKzcyLDcgQEAgc3RhY2tsZWFr X2ZpbmRfdG9wX29mX3BvaXNvbihjb25zdCB1bnNpZ25lZCBsb25nIGxvdywgY29uc3QgdW5zaWdu ZWQgbG9uZyBoaWdoKQogc3RhdGljIGlubGluZSB2b2lkIHN0YWNrbGVha190YXNrX2luaXQoc3Ry dWN0IHRhc2tfc3RydWN0ICp0KQogewogCXQtPmxvd2VzdF9zdGFjayA9IHN0YWNrbGVha190YXNr X2xvd19ib3VuZCh0KTsKLSMgaWZkZWYgQ09ORklHX1NUQUNLTEVBS19NRVRSSUNTCisjIGlmZGVm IENPTkZJR19LU1RBQ0tfRVJBU0VfTUVUUklDUwogCXQtPnByZXZfbG93ZXN0X3N0YWNrID0gdC0+ bG93ZXN0X3N0YWNrOwogIyBlbmRpZgogfQpAQCAtODIsNyArODIsNyBAQCBhc21saW5rYWdlIHZv aWQgbm9pbnN0ciBzdGFja2xlYWtfZXJhc2Vfb25fdGFza19zdGFjayh2b2lkKTsKIGFzbWxpbmth Z2Ugdm9pZCBub2luc3RyIHN0YWNrbGVha19lcmFzZV9vZmZfdGFza19zdGFjayh2b2lkKTsKIHZv aWQgX19ub19jYWxsZXJfc2F2ZWRfcmVnaXN0ZXJzIG5vaW5zdHIgc3RhY2tsZWFrX3RyYWNrX3N0 YWNrKHZvaWQpOwogCi0jZWxzZSAvKiAhQ09ORklHX0dDQ19QTFVHSU5fU1RBQ0tMRUFLICovCisj ZWxzZSAvKiAhQ09ORklHX0tTVEFDS19FUkFTRSAqLwogc3RhdGljIGlubGluZSB2b2lkIHN0YWNr bGVha190YXNrX2luaXQoc3RydWN0IHRhc2tfc3RydWN0ICp0KSB7IH0KICNlbmRpZgogCmRpZmYg LS1naXQgYS9pbmNsdWRlL2xpbnV4L3NjaGVkLmggYi9pbmNsdWRlL2xpbnV4L3NjaGVkLmgKaW5k ZXggOGM2MGE0MmY5ZDAwLi45MDUxZDk0ODQzOTMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgv c2NoZWQuaAorKysgYi9pbmNsdWRlL2xpbnV4L3NjaGVkLmgKQEAgLTE2MDYsOCArMTYwNiwxMCBA QCBzdHJ1Y3QgdGFza19zdHJ1Y3QgewogCS8qIFVzZWQgYnkgQlBGIGZvciBwZXItVEFTSyB4ZHAg c3RvcmFnZSAqLwogCXN0cnVjdCBicGZfbmV0X2NvbnRleHQJCSpicGZfbmV0X2NvbnRleHQ7CiAK LSNpZmRlZiBDT05GSUdfR0NDX1BMVUdJTl9TVEFDS0xFQUsKKyNpZmRlZiBDT05GSUdfS1NUQUNL X0VSQVNFCiAJdW5zaWduZWQgbG9uZwkJCWxvd2VzdF9zdGFjazsKKyNlbmRpZgorI2lmZGVmIENP TkZJR19LU1RBQ0tfRVJBU0VfTUVUUklDUwogCXVuc2lnbmVkIGxvbmcJCQlwcmV2X2xvd2VzdF9z dGFjazsKICNlbmRpZgogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwvZW50cnktY29tbW9u LlMgYi9hcmNoL2FybS9rZXJuZWwvZW50cnktY29tbW9uLlMKaW5kZXggZjM3OWM4NTJkY2I3Li44 ODMzNmExMjkyYmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2tlcm5lbC9lbnRyeS1jb21tb24uUwor KysgYi9hcmNoL2FybS9rZXJuZWwvZW50cnktY29tbW9uLlMKQEAgLTExOSw3ICsxMTksNyBAQCBu b193b3JrX3BlbmRpbmc6CiAKIAljdF91c2VyX2VudGVyIHNhdmUgPSAwCiAKLSNpZmRlZiBDT05G SUdfR0NDX1BMVUdJTl9TVEFDS0xFQUsKKyNpZmRlZiBDT05GSUdfS1NUQUNLX0VSQVNFCiAJYmwJ c3RhY2tsZWFrX2VyYXNlX29uX3Rhc2tfc3RhY2sKICNlbmRpZgogCXJlc3RvcmVfdXNlcl9yZWdz IGZhc3QgPSAwLCBvZmZzZXQgPSAwCmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2tlcm5lbC9lbnRy eS5TIGIvYXJjaC9hcm02NC9rZXJuZWwvZW50cnkuUwppbmRleCA1YWUyYTM0YjUwYmQuLjY3MzMx NDM3YjJhYSAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9rZXJuZWwvZW50cnkuUworKysgYi9hcmNo L2FybTY0L2tlcm5lbC9lbnRyeS5TCkBAIC02MTQsNyArNjE0LDcgQEAgU1lNX0NPREVfRU5EKHJl dF90b19rZXJuZWwpCiBTWU1fQ09ERV9TVEFSVF9MT0NBTChyZXRfdG9fdXNlcikKIAlsZHIJeDE5 LCBbdHNrLCAjVFNLX1RJX0ZMQUdTXQkvLyByZS1jaGVjayBmb3Igc2luZ2xlLXN0ZXAKIAllbmFi bGVfc3RlcF90c2sgeDE5LCB4MgotI2lmZGVmIENPTkZJR19HQ0NfUExVR0lOX1NUQUNLTEVBSwor I2lmZGVmIENPTkZJR19LU1RBQ0tfRVJBU0UKIAlibAlzdGFja2xlYWtfZXJhc2Vfb25fdGFza19z dGFjawogI2VuZGlmCiAJa2VybmVsX2V4aXQgMApkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJu ZWwvZW50cnkuUyBiL2FyY2gvcmlzY3Yva2VybmVsL2VudHJ5LlMKaW5kZXggYWY1MTQ2MTQ0MDRh Li40OWUyMzQ0MDA3YzggMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3Yva2VybmVsL2VudHJ5LlMKKysr IGIvYXJjaC9yaXNjdi9rZXJuZWwvZW50cnkuUwpAQCAtMjIwLDcgKzIyMCw3IEBAIFNZTV9DT0RF X1NUQVJUX05PQUxJR04ocmV0X2Zyb21fZXhjZXB0aW9uKQogI2VuZGlmCiAJYm5leiBzMCwgMWYK IAotI2lmZGVmIENPTkZJR19HQ0NfUExVR0lOX1NUQUNLTEVBSworI2lmZGVmIENPTkZJR19LU1RB Q0tfRVJBU0UKIAljYWxsCXN0YWNrbGVha19lcmFzZV9vbl90YXNrX3N0YWNrCiAjZW5kaWYKIApk aWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2tlcm5lbC9lbnRyeS5TIGIvYXJjaC9zMzkwL2tlcm5lbC9l bnRyeS5TCmluZGV4IDBmMDBmNGIwNmQ1MS4uNzViMGZiYjIzNmQwIDEwMDY0NAotLS0gYS9hcmNo L3MzOTAva2VybmVsL2VudHJ5LlMKKysrIGIvYXJjaC9zMzkwL2tlcm5lbC9lbnRyeS5TCkBAIC0x MjQsNyArMTI0LDcgQEAgX0xQUF9PRkZTRVQJPSBfX0xDX0xQUAogI2VuZGlmCiAKIAkubWFjcm8g U1RBQ0tMRUFLX0VSQVNFCi0jaWZkZWYgQ09ORklHX0dDQ19QTFVHSU5fU1RBQ0tMRUFLCisjaWZk ZWYgQ09ORklHX0tTVEFDS19FUkFTRQogCWJyYXNsCSVyMTQsc3RhY2tsZWFrX2VyYXNlX29uX3Rh c2tfc3RhY2sKICNlbmRpZgogCS5lbmRtCmRpZmYgLS1naXQgYS9kcml2ZXJzL21pc2MvbGtkdG0v c3RhY2tsZWFrLmMgYi9kcml2ZXJzL21pc2MvbGtkdG0va3N0YWNrX2VyYXNlLmMKc2ltaWxhcml0 eSBpbmRleCA4OSUKcmVuYW1lIGZyb20gZHJpdmVycy9taXNjL2xrZHRtL3N0YWNrbGVhay5jCnJl bmFtZSB0byBkcml2ZXJzL21pc2MvbGtkdG0va3N0YWNrX2VyYXNlLmMKaW5kZXggZjFkMDIyMTYw OTEzLi40ZmQ5YjBiZmI4NzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWlzYy9sa2R0bS9zdGFja2xl YWsuYworKysgYi9kcml2ZXJzL21pc2MvbGtkdG0va3N0YWNrX2VyYXNlLmMKQEAgLTEsNyArMSw3 IEBACiAvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAogLyoKICAqIFRoaXMgY29k ZSB0ZXN0cyB0aGF0IHRoZSBjdXJyZW50IHRhc2sgc3RhY2sgaXMgcHJvcGVybHkgZXJhc2VkIChm aWxsZWQKLSAqIHdpdGggU1RBQ0tMRUFLX1BPSVNPTikuCisgKiB3aXRoIEtTVEFDS19FUkFTRV9Q T0lTT04pLgogICoKICAqIEF1dGhvcnM6CiAgKiAgIEFsZXhhbmRlciBQb3BvdiA8YWxleC5wb3Bv dkBsaW51eC5jb20+CkBAIC05LDkgKzksOSBAQAogICovCiAKICNpbmNsdWRlICJsa2R0bS5oIgot I2luY2x1ZGUgPGxpbnV4L3N0YWNrbGVhay5oPgorI2luY2x1ZGUgPGxpbnV4L2tzdGFja19lcmFz ZS5oPgogCi0jaWYgZGVmaW5lZChDT05GSUdfR0NDX1BMVUdJTl9TVEFDS0xFQUspCisjaWYgZGVm aW5lZChDT05GSUdfS1NUQUNLX0VSQVNFKQogLyoKICAqIENoZWNrIHRoYXQgc3RhY2tsZWFrIHRy YWNrcyB0aGUgbG93ZXN0IHN0YWNrIHBvaW50ZXIgYW5kIGVyYXNlcyB0aGUgc3RhY2sKICAqIGJl bG93IHRoaXMgYXMgZXhwZWN0ZWQuCkBAIC04NSw3ICs4NSw3IEBAIHN0YXRpYyB2b2lkIG5vaW5z dHIgY2hlY2tfc3RhY2tsZWFrX2lycW9mZih2b2lkKQogCXdoaWxlIChwb2lzb25fbG93ID4gdGFz a19zdGFja19sb3cpIHsKIAkJcG9pc29uX2xvdyAtPSBzaXplb2YodW5zaWduZWQgbG9uZyk7CiAK LQkJaWYgKCoodW5zaWduZWQgbG9uZyAqKXBvaXNvbl9sb3cgPT0gU1RBQ0tMRUFLX1BPSVNPTikK KwkJaWYgKCoodW5zaWduZWQgbG9uZyAqKXBvaXNvbl9sb3cgPT0gS1NUQUNLX0VSQVNFX1BPSVNP TikKIAkJCWNvbnRpbnVlOwogCiAJCWluc3RydW1lbnRhdGlvbl9iZWdpbigpOwpAQCAtOTYsNyAr OTYsNyBAQCBzdGF0aWMgdm9pZCBub2luc3RyIGNoZWNrX3N0YWNrbGVha19pcnFvZmYodm9pZCkK IAl9CiAKIAlpbnN0cnVtZW50YXRpb25fYmVnaW4oKTsKLQlwcl9pbmZvKCJzdGFja2xlYWsgc3Rh Y2sgdXNhZ2U6XG4iCisJcHJfaW5mbygia3N0YWNrIGVyYXNlIHN0YWNrIHVzYWdlOlxuIgogCQki ICBoaWdoIG9mZnNldDogJWx1IGJ5dGVzXG4iCiAJCSIgIGN1cnJlbnQ6ICAgICAlbHUgYnl0ZXNc biIKIAkJIiAgbG93ZXN0OiAgICAgICVsdSBieXRlc1xuIgpAQCAtMTIxLDcgKzEyMSw3IEBAIHN0 YXRpYyB2b2lkIG5vaW5zdHIgY2hlY2tfc3RhY2tsZWFrX2lycW9mZih2b2lkKQogCWluc3RydW1l bnRhdGlvbl9lbmQoKTsKIH0KIAotc3RhdGljIHZvaWQgbGtkdG1fU1RBQ0tMRUFLX0VSQVNJTkco dm9pZCkKK3N0YXRpYyB2b2lkIGxrZHRtX0tTVEFDS19FUkFTRSh2b2lkKQogewogCXVuc2lnbmVk IGxvbmcgZmxhZ3M7CiAKQEAgLTEyOSwxOSArMTI5LDE5IEBAIHN0YXRpYyB2b2lkIGxrZHRtX1NU QUNLTEVBS19FUkFTSU5HKHZvaWQpCiAJY2hlY2tfc3RhY2tsZWFrX2lycW9mZigpOwogCWxvY2Fs X2lycV9yZXN0b3JlKGZsYWdzKTsKIH0KLSNlbHNlIC8qIGRlZmluZWQoQ09ORklHX0dDQ19QTFVH SU5fU1RBQ0tMRUFLKSAqLwotc3RhdGljIHZvaWQgbGtkdG1fU1RBQ0tMRUFLX0VSQVNJTkcodm9p ZCkKKyNlbHNlIC8qIGRlZmluZWQoQ09ORklHX0tTVEFDS19FUkFTRSkgKi8KK3N0YXRpYyB2b2lk IGxrZHRtX0tTVEFDS19FUkFTRSh2b2lkKQogewotCWlmIChJU19FTkFCTEVEKENPTkZJR19IQVZF X0FSQ0hfU1RBQ0tMRUFLKSkgewotCQlwcl9lcnIoIlhGQUlMOiBzdGFja2xlYWsgaXMgbm90IGVu YWJsZWQgKENPTkZJR19HQ0NfUExVR0lOX1NUQUNLTEVBSz1uKVxuIik7CisJaWYgKElTX0VOQUJM RUQoQ09ORklHX0hBVkVfQVJDSF9LU1RBQ0tfRVJBU0UpKSB7CisJCXByX2VycigiWEZBSUw6IHN0 YWNrbGVhayBpcyBub3QgZW5hYmxlZCAoQ09ORklHX0tTVEFDS19FUkFTRT1uKVxuIik7CiAJfSBl bHNlIHsKLQkJcHJfZXJyKCJYRkFJTDogc3RhY2tsZWFrIGlzIG5vdCBzdXBwb3J0ZWQgb24gdGhp cyBhcmNoIChIQVZFX0FSQ0hfU1RBQ0tMRUFLPW4pXG4iKTsKKwkJcHJfZXJyKCJYRkFJTDogc3Rh Y2tsZWFrIGlzIG5vdCBzdXBwb3J0ZWQgb24gdGhpcyBhcmNoIChIQVZFX0FSQ0hfS1NUQUNLX0VS QVNFPW4pXG4iKTsKIAl9CiB9Ci0jZW5kaWYgLyogZGVmaW5lZChDT05GSUdfR0NDX1BMVUdJTl9T VEFDS0xFQUspICovCisjZW5kaWYgLyogZGVmaW5lZChDT05GSUdfS1NUQUNLX0VSQVNFKSAqLwog CiBzdGF0aWMgc3RydWN0IGNyYXNodHlwZSBjcmFzaHR5cGVzW10gPSB7Ci0JQ1JBU0hUWVBFKFNU QUNLTEVBS19FUkFTSU5HKSwKKwlDUkFTSFRZUEUoS1NUQUNLX0VSQVNFKSwKIH07CiAKIHN0cnVj dCBjcmFzaHR5cGVfY2F0ZWdvcnkgc3RhY2tsZWFrX2NyYXNodHlwZXMgPSB7CmRpZmYgLS1naXQg YS9mcy9wcm9jL2Jhc2UuYyBiL2ZzL3Byb2MvYmFzZS5jCmluZGV4IGM2Njc3MDJkYzY5Yi4uYmUz NDYxMmFmOGI2IDEwMDY0NAotLS0gYS9mcy9wcm9jL2Jhc2UuYworKysgYi9mcy9wcm9jL2Jhc2Uu YwpAQCAtMzI5MSw3ICszMjkxLDcgQEAgc3RhdGljIGludCBwcm9jX3BpZF9rc21fc3RhdChzdHJ1 Y3Qgc2VxX2ZpbGUgKm0sIHN0cnVjdCBwaWRfbmFtZXNwYWNlICpucywKIH0KICNlbmRpZiAvKiBD T05GSUdfS1NNICovCiAKLSNpZmRlZiBDT05GSUdfU1RBQ0tMRUFLX01FVFJJQ1MKKyNpZmRlZiBD T05GSUdfS1NUQUNLX0VSQVNFX01FVFJJQ1MKIHN0YXRpYyBpbnQgcHJvY19zdGFja19kZXB0aChz dHJ1Y3Qgc2VxX2ZpbGUgKm0sIHN0cnVjdCBwaWRfbmFtZXNwYWNlICpucywKIAkJCQlzdHJ1Y3Qg cGlkICpwaWQsIHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKIHsKQEAgLTMzMDQsNyArMzMwNCw3 IEBAIHN0YXRpYyBpbnQgcHJvY19zdGFja19kZXB0aChzdHJ1Y3Qgc2VxX2ZpbGUgKm0sIHN0cnVj dCBwaWRfbmFtZXNwYWNlICpucywKIAkJCQkJCQlwcmV2X2RlcHRoLCBkZXB0aCk7CiAJcmV0dXJu IDA7CiB9Ci0jZW5kaWYgLyogQ09ORklHX1NUQUNLTEVBS19NRVRSSUNTICovCisjZW5kaWYgLyog Q09ORklHX0tTVEFDS19FUkFTRV9NRVRSSUNTICovCiAKIC8qCiAgKiBUaHJlYWQgZ3JvdXBzCkBA IC0zNDExLDcgKzM0MTEsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IHBpZF9lbnRyeSB0Z2lkX2Jh c2Vfc3R1ZmZbXSA9IHsKICNpZmRlZiBDT05GSUdfTElWRVBBVENICiAJT05FKCJwYXRjaF9zdGF0 ZSIsICBTX0lSVVNSLCBwcm9jX3BpZF9wYXRjaF9zdGF0ZSksCiAjZW5kaWYKLSNpZmRlZiBDT05G SUdfU1RBQ0tMRUFLX01FVFJJQ1MKKyNpZmRlZiBDT05GSUdfS1NUQUNLX0VSQVNFX01FVFJJQ1MK IAlPTkUoInN0YWNrX2RlcHRoIiwgU19JUlVHTywgcHJvY19zdGFja19kZXB0aCksCiAjZW5kaWYK ICNpZmRlZiBDT05GSUdfUFJPQ19QSURfQVJDSF9TVEFUVVMKZGlmZiAtLWdpdCBhL2tlcm5lbC9m b3JrLmMgYi9rZXJuZWwvZm9yay5jCmluZGV4IDFlZThlYjExZjM4Yi4uMWVjNjY5MTFmNmY2IDEw MDY0NAotLS0gYS9rZXJuZWwvZm9yay5jCisrKyBiL2tlcm5lbC9mb3JrLmMKQEAgLTkzLDcgKzkz LDcgQEAKICNpbmNsdWRlIDxsaW51eC9rY292Lmg+CiAjaW5jbHVkZSA8bGludXgvbGl2ZXBhdGNo Lmg+CiAjaW5jbHVkZSA8bGludXgvdGhyZWFkX2luZm8uaD4KLSNpbmNsdWRlIDxsaW51eC9zdGFj a2xlYWsuaD4KKyNpbmNsdWRlIDxsaW51eC9rc3RhY2tfZXJhc2UuaD4KICNpbmNsdWRlIDxsaW51 eC9rYXNhbi5oPgogI2luY2x1ZGUgPGxpbnV4L3Njcy5oPgogI2luY2x1ZGUgPGxpbnV4L2lvX3Vy aW5nLmg+CmRpZmYgLS1naXQgYS9rZXJuZWwvc3RhY2tsZWFrLmMgYi9rZXJuZWwva3N0YWNrX2Vy YXNlLmMKc2ltaWxhcml0eSBpbmRleCA5MCUKcmVuYW1lIGZyb20ga2VybmVsL3N0YWNrbGVhay5j CnJlbmFtZSB0byBrZXJuZWwva3N0YWNrX2VyYXNlLmMKaW5kZXggYmI2NTMyMTc2MWI0Li4yMDFi ODQ2ZjgzNDUgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9zdGFja2xlYWsuYworKysgYi9rZXJuZWwva3N0 YWNrX2VyYXNlLmMKQEAgLTYsMTQgKzYsMTQgQEAKICAqCiAgKiBBdXRob3I6IEFsZXhhbmRlciBQ b3BvdiA8YWxleC5wb3BvdkBsaW51eC5jb20+CiAgKgotICogU1RBQ0tMRUFLIHJlZHVjZXMgdGhl IGluZm9ybWF0aW9uIHdoaWNoIGtlcm5lbCBzdGFjayBsZWFrIGJ1Z3MgY2FuCisgKiBLU1RBQ0tf RVJBU0UgcmVkdWNlcyB0aGUgaW5mb3JtYXRpb24gd2hpY2gga2VybmVsIHN0YWNrIGxlYWsgYnVn cyBjYW4KICAqIHJldmVhbCBhbmQgYmxvY2tzIHNvbWUgdW5pbml0aWFsaXplZCBzdGFjayB2YXJp YWJsZSBhdHRhY2tzLgogICovCiAKLSNpbmNsdWRlIDxsaW51eC9zdGFja2xlYWsuaD4KKyNpbmNs dWRlIDxsaW51eC9rc3RhY2tfZXJhc2UuaD4KICNpbmNsdWRlIDxsaW51eC9rcHJvYmVzLmg+CiAK LSNpZmRlZiBDT05GSUdfU1RBQ0tMRUFLX1JVTlRJTUVfRElTQUJMRQorI2lmZGVmIENPTkZJR19L U1RBQ0tfRVJBU0VfUlVOVElNRV9ESVNBQkxFCiAjaW5jbHVkZSA8bGludXgvanVtcF9sYWJlbC5o PgogI2luY2x1ZGUgPGxpbnV4L3N0cmluZ19jaG9pY2VzLmg+CiAjaW5jbHVkZSA8bGludXgvc3lz Y3RsLmg+CkBAIC02OCw3ICs2OCw3IEBAIGxhdGVfaW5pdGNhbGwoc3RhY2tsZWFrX3N5c2N0bHNf aW5pdCk7CiAjZGVmaW5lIHNraXBfZXJhc2luZygpCXN0YXRpY19icmFuY2hfdW5saWtlbHkoJnN0 YWNrX2VyYXNpbmdfYnlwYXNzKQogI2Vsc2UKICNkZWZpbmUgc2tpcF9lcmFzaW5nKCkJZmFsc2UK LSNlbmRpZiAvKiBDT05GSUdfU1RBQ0tMRUFLX1JVTlRJTUVfRElTQUJMRSAqLworI2VuZGlmIC8q IENPTkZJR19LU1RBQ0tfRVJBU0VfUlVOVElNRV9ESVNBQkxFICovCiAKICNpZm5kZWYgX19zdGFj a2xlYWtfcG9pc29uCiBzdGF0aWMgX19hbHdheXNfaW5saW5lIHZvaWQgX19zdGFja2xlYWtfcG9p c29uKHVuc2lnbmVkIGxvbmcgZXJhc2VfbG93LApAQCAtOTEsNyArOTEsNyBAQCBzdGF0aWMgX19h bHdheXNfaW5saW5lIHZvaWQgX19zdGFja2xlYWtfZXJhc2UoYm9vbCBvbl90YXNrX3N0YWNrKQog CWVyYXNlX2xvdyA9IHN0YWNrbGVha19maW5kX3RvcF9vZl9wb2lzb24odGFza19zdGFja19sb3cs CiAJCQkJCQkgY3VycmVudC0+bG93ZXN0X3N0YWNrKTsKIAotI2lmZGVmIENPTkZJR19TVEFDS0xF QUtfTUVUUklDUworI2lmZGVmIENPTkZJR19LU1RBQ0tfRVJBU0VfTUVUUklDUwogCWN1cnJlbnQt PnByZXZfbG93ZXN0X3N0YWNrID0gZXJhc2VfbG93OwogI2VuZGlmCiAKQEAgLTExMyw3ICsxMTMs NyBAQCBzdGF0aWMgX19hbHdheXNfaW5saW5lIHZvaWQgX19zdGFja2xlYWtfZXJhc2UoYm9vbCBv bl90YXNrX3N0YWNrKQogCWVsc2UKIAkJZXJhc2VfaGlnaCA9IHRhc2tfc3RhY2tfaGlnaDsKIAot CV9fc3RhY2tsZWFrX3BvaXNvbihlcmFzZV9sb3csIGVyYXNlX2hpZ2gsIFNUQUNLTEVBS19QT0lT T04pOworCV9fc3RhY2tsZWFrX3BvaXNvbihlcmFzZV9sb3csIGVyYXNlX2hpZ2gsIEtTVEFDS19F UkFTRV9QT0lTT04pOwogCiAJLyogUmVzZXQgdGhlICdsb3dlc3Rfc3RhY2snIHZhbHVlIGZvciB0 aGUgbmV4dCBzeXNjYWxsICovCiAJY3VycmVudC0+bG93ZXN0X3N0YWNrID0gdGFza19zdGFja19o aWdoOwpAQCAtMTYxLDExICsxNjEsMTEgQEAgdm9pZCBfX3VzZWQgX19ub19jYWxsZXJfc2F2ZWRf cmVnaXN0ZXJzIG5vaW5zdHIgc3RhY2tsZWFrX3RyYWNrX3N0YWNrKHZvaWQpCiAJdW5zaWduZWQg bG9uZyBzcCA9IGN1cnJlbnRfc3RhY2tfcG9pbnRlcjsKIAogCS8qCi0JICogSGF2aW5nIENPTkZJ R19TVEFDS0xFQUtfVFJBQ0tfTUlOX1NJWkUgbGFyZ2VyIHRoYW4KLQkgKiBTVEFDS0xFQUtfU0VB UkNIX0RFUFRIIG1ha2VzIHRoZSBwb2lzb24gc2VhcmNoIGluCisJICogSGF2aW5nIENPTkZJR19L U1RBQ0tfRVJBU0VfVFJBQ0tfTUlOX1NJWkUgbGFyZ2VyIHRoYW4KKwkgKiBLU1RBQ0tfRVJBU0Vf U0VBUkNIX0RFUFRIIG1ha2VzIHRoZSBwb2lzb24gc2VhcmNoIGluCiAJICogc3RhY2tsZWFrX2Vy YXNlKCkgdW5yZWxpYWJsZS4gTGV0J3MgcHJldmVudCB0aGF0LgogCSAqLwotCUJVSUxEX0JVR19P TihDT05GSUdfU1RBQ0tMRUFLX1RSQUNLX01JTl9TSVpFID4gU1RBQ0tMRUFLX1NFQVJDSF9ERVBU SCk7CisJQlVJTERfQlVHX09OKENPTkZJR19LU1RBQ0tfRVJBU0VfVFJBQ0tfTUlOX1NJWkUgPiBL U1RBQ0tfRVJBU0VfU0VBUkNIX0RFUFRIKTsKIAogCS8qICdsb3dlc3Rfc3RhY2snIHNob3VsZCBi ZSBhbGlnbmVkIG9uIHRoZSByZWdpc3RlciB3aWR0aCBib3VuZGFyeSAqLwogCXNwID0gQUxJR04o c3AsIHNpemVvZih1bnNpZ25lZCBsb25nKSk7CmRpZmYgLS1naXQgYS90b29scy9vYmp0b29sL2No ZWNrLmMgYi90b29scy9vYmp0b29sL2NoZWNrLmMKaW5kZXggYjIxYjEyZWM4OGQ5Li4zMTA4OGEx MzhiYzkgMTAwNjQ0Ci0tLSBhL3Rvb2xzL29ianRvb2wvY2hlY2suYworKysgYi90b29scy9vYmp0 b29sL2NoZWNrLmMKQEAgLTExOTEsNyArMTE5MSw3IEBAIHN0YXRpYyBjb25zdCBjaGFyICp1YWNj ZXNzX3NhZmVfYnVpbHRpbltdID0gewogCSJfX3Vic2FuX2hhbmRsZV90eXBlX21pc21hdGNoX3Yx IiwKIAkiX191YnNhbl9oYW5kbGVfc2hpZnRfb3V0X29mX2JvdW5kcyIsCiAJIl9fdWJzYW5faGFu ZGxlX2xvYWRfaW52YWxpZF92YWx1ZSIsCi0JLyogU1RBQ0tMRUFLICovCisJLyogS1NUQUNLX0VS QVNFICovCiAJInN0YWNrbGVha190cmFja19zdGFjayIsCiAJLyogVFJBQ0VfQlJBTkNIX1BST0ZJ TElORyAqLwogCSJmdHJhY2VfbGlrZWx5X3VwZGF0ZSIsCmRpZmYgLS1naXQgYS90b29scy90ZXN0 aW5nL3NlbGZ0ZXN0cy9sa2R0bS9jb25maWcgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9sa2R0 bS9jb25maWcKaW5kZXggN2FmZTA1ZThjNGQ3Li5iZDA5ZmRhZjUzZTAgMTAwNjQ0Ci0tLSBhL3Rv b2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2xrZHRtL2NvbmZpZworKysgYi90b29scy90ZXN0aW5nL3Nl bGZ0ZXN0cy9sa2R0bS9jb25maWcKQEAgLTIsNyArMiw3IEBAIENPTkZJR19MS0RUTT15CiBDT05G SUdfREVCVUdfTElTVD15CiBDT05GSUdfU0xBQl9GUkVFTElTVF9IQVJERU5FRD15CiBDT05GSUdf Rk9SVElGWV9TT1VSQ0U9eQotQ09ORklHX0dDQ19QTFVHSU5fU1RBQ0tMRUFLPXkKK0NPTkZJR19L U1RBQ0tfRVJBU0U9eQogQ09ORklHX0hBUkRFTkVEX1VTRVJDT1BZPXkKIENPTkZJR19SQU5ET01J WkVfS1NUQUNLX09GRlNFVF9ERUZBVUxUPXkKIENPTkZJR19JTklUX09OX0ZSRUVfREVGQVVMVF9P Tj15CmRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCmluZGV4IDc5YThlMmM3 MzkwOC4uOWY3NmIzMjlmZGIzIDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysgYi9NQUlOVEFJ TkVSUwpAQCAtOTk3MSw4ICs5OTcxLDYgQEAgTDoJbGludXgtaGFyZGVuaW5nQHZnZXIua2VybmVs Lm9yZwogUzoJTWFpbnRhaW5lZAogVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20v bGludXgva2VybmVsL2dpdC9rZWVzL2xpbnV4LmdpdCBmb3ItbmV4dC9oYXJkZW5pbmcKIEY6CURv Y3VtZW50YXRpb24va2J1aWxkL2djYy1wbHVnaW5zLnJzdAotRjoJaW5jbHVkZS9saW51eC9zdGFj a2xlYWsuaAotRjoJa2VybmVsL3N0YWNrbGVhay5jCiBGOglzY3JpcHRzL01ha2VmaWxlLmdjYy1w bHVnaW5zCiBGOglzY3JpcHRzL2djYy1wbHVnaW5zLwogCkBAIC0xMzA2MCwxMCArMTMwNTgsMTIg QEAgVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC9r ZWVzL2xpbnV4LmdpdCBmb3ItbmV4dC9oYXIKIEY6CURvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcv c3lzZnMta2VybmVsLW9vcHNfY291bnQKIEY6CURvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lz ZnMta2VybmVsLXdhcm5fY291bnQKIEY6CWFyY2gvKi9jb25maWdzL2hhcmRlbmluZy5jb25maWcK K0Y6CWluY2x1ZGUvbGludXgva3N0YWNrX2VyYXNlLmgKIEY6CWluY2x1ZGUvbGludXgvb3ZlcmZs b3cuaAogRjoJaW5jbHVkZS9saW51eC9yYW5kb21pemVfa3N0YWNrLmgKIEY6CWluY2x1ZGUvbGlu dXgvdWNvcHlzaXplLmgKIEY6CWtlcm5lbC9jb25maWdzL2hhcmRlbmluZy5jb25maWcKK0Y6CWtl cm5lbC9rc3RhY2tfZXJhc2UuYwogRjoJbGliL3Rlc3RzL3JhbmRzdHJ1Y3Rfa3VuaXQuYwogRjoJ bGliL3Rlc3RzL3VzZXJjb3B5X2t1bml0LmMKIEY6CW1tL3VzZXJjb3B5LmMKLS0gCjIuMzQuMQoK Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LXJp c2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9s aXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcmlzY3YK