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 312891DF742; Sat, 26 Apr 2025 06:51:40 +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=1745650301; cv=none; b=s4pu1WJz6bL7H/xJVFSm9z88CvN7PayNY9zdSTSxIddfc6IKr7ReNSUY1YxbGDM8eSr/iEPcB0OOmWen0JS2UwbiZJPe8XDHmxc1zqamgGnBV+0+xuKsSLpPiZjM+jOLHtfoUT+rHqJoyRflhtsplxeBqpwzkawOhoPXvy5Gj78= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745650301; c=relaxed/simple; bh=Z8g2QC8t5xCKSohXvmUSVfT8rth+Vg9Lxt049FddoYE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=VaV32B1MUY+LpKGXYih7ZGZTcN2etBI8M9hr1/OpSBAF+05aePiFqMfZH35CTbpJbHIb9/rJ0S3jCgZBNz44xhhbNgXWDq0PVvRerRCSh4bJreMvnEaJRh8SVy10yl+oGp7SWb3JtZTr96xQ1u0fBvHNlZlFDge0m+Ispl8ovDI= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=iPg3d5nn; 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="iPg3d5nn" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3A9A5C4CEED; Sat, 26 Apr 2025 06:51:40 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1745650300; bh=Z8g2QC8t5xCKSohXvmUSVfT8rth+Vg9Lxt049FddoYE=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=iPg3d5nn3ULW7JRpe6IVXE1Bk7r2X7yA9WibbhTzMjeRf9ALqm6H7ARsM4mfuGXo4 fNqydbIM3GqFYiGV6ZMlr4I/vtUuBFqQJk/v1J5IXcIIUjDHFow0ibNJZFDBqHzjqm M1/gdZG9l/fA5MJZ3B0QSxk5lxA1fqxFBl+XOawMwp58l9mSU5YeDoPTnAg6fApxn9 fRUEzLCt+7zscEpkq6U8F7V3ANws7z16ZLS6BvmViMe8SSfwAFv0dzA4bSl2EuDRpZ 7cXp/pEhJTAX9RAx8tYs60jO7NhS2N5yk85ksULRDBzMgTblSErI7gjXqB5l0ykmp1 Cm4xOy8vte8ZQ== From: Eric Biggers To: linux-crypto@vger.kernel.org Cc: linux-kernel@vger.kernel.org, linux-arch@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-mips@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, linux-riscv@lists.infradead.org, sparclinux@vger.kernel.org, linux-s390@vger.kernel.org, x86@kernel.org, Ard Biesheuvel , "Jason A . Donenfeld " , Linus Torvalds Subject: [PATCH 02/13] crypto: arm/sha256 - implement library instead of shash Date: Fri, 25 Apr 2025 23:50:28 -0700 Message-ID: <20250426065041.1551914-3-ebiggers@kernel.org> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250426065041.1551914-1-ebiggers@kernel.org> References: <20250426065041.1551914-1-ebiggers@kernel.org> Precedence: bulk X-Mailing-List: linux-arch@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit From: Eric Biggers Instead of providing crypto_shash algorithms for the arch-optimized SHA-256 code, instead implement the SHA-256 library. This is much simpler, it makes the SHA-256 library functions be arch-optimized, and it fixes the longstanding issue where the arch-optimized SHA-256 was disabled by default. SHA-256 still remains available through crypto_shash, but individual architectures no longer need to handle it. To merge the scalar, NEON, and CE code all into one module cleanly, add !CPU_V7M as a direct dependency of the CE code. Previously, !CPU_V7M was only a direct dependency of the scalar and NEON code. The result is still the same because CPU_V7M implies !KERNEL_MODE_NEON, so !CPU_V7M was already an indirect dependency of the CE code. To match sha256_blocks_arch(), change the type of the nblocks parameter of the assembly functions from int to size_t. The assembly functions actually already treated it as size_t. While renaming the assembly files, also fix the naming quirk where "sha2" meant sha256. (SHA-512 is also part of SHA-2.) Signed-off-by: Eric Biggers --- arch/arm/configs/exynos_defconfig | 1 - arch/arm/configs/milbeaut_m10v_defconfig | 1 - arch/arm/configs/multi_v7_defconfig | 1 - arch/arm/configs/omap2plus_defconfig | 1 - arch/arm/configs/pxa_defconfig | 1 - arch/arm/crypto/Kconfig | 21 ---- arch/arm/crypto/Makefile | 8 +- arch/arm/crypto/sha2-ce-glue.c | 87 -------------- arch/arm/crypto/sha256_glue.c | 107 ------------------ arch/arm/crypto/sha256_glue.h | 9 -- arch/arm/crypto/sha256_neon_glue.c | 75 ------------ arch/arm/lib/crypto/.gitignore | 1 + arch/arm/lib/crypto/Kconfig | 6 + arch/arm/lib/crypto/Makefile | 8 +- arch/arm/{ => lib}/crypto/sha256-armv4.pl | 0 .../sha2-ce-core.S => lib/crypto/sha256-ce.S} | 10 +- arch/arm/lib/crypto/sha256.c | 64 +++++++++++ 17 files changed, 84 insertions(+), 317 deletions(-) delete mode 100644 arch/arm/crypto/sha2-ce-glue.c delete mode 100644 arch/arm/crypto/sha256_glue.c delete mode 100644 arch/arm/crypto/sha256_glue.h delete mode 100644 arch/arm/crypto/sha256_neon_glue.c rename arch/arm/{ => lib}/crypto/sha256-armv4.pl (100%) rename arch/arm/{crypto/sha2-ce-core.S => lib/crypto/sha256-ce.S} (91%) create mode 100644 arch/arm/lib/crypto/sha256.c diff --git a/arch/arm/configs/exynos_defconfig b/arch/arm/configs/exynos_defconfig index 7ad48fdda1dac..244dd5dec98bd 100644 --- a/arch/arm/configs/exynos_defconfig +++ b/arch/arm/configs/exynos_defconfig @@ -362,11 +362,10 @@ CONFIG_CRYPTO_LZ4=m CONFIG_CRYPTO_USER_API_HASH=m CONFIG_CRYPTO_USER_API_SKCIPHER=m CONFIG_CRYPTO_USER_API_RNG=m CONFIG_CRYPTO_USER_API_AEAD=m CONFIG_CRYPTO_SHA1_ARM_NEON=m -CONFIG_CRYPTO_SHA256_ARM=m CONFIG_CRYPTO_SHA512_ARM=m CONFIG_CRYPTO_AES_ARM_BS=m CONFIG_CRYPTO_CHACHA20_NEON=m CONFIG_CRYPTO_DEV_EXYNOS_RNG=y CONFIG_CRYPTO_DEV_S5P=y diff --git a/arch/arm/configs/milbeaut_m10v_defconfig b/arch/arm/configs/milbeaut_m10v_defconfig index acd16204f8d7f..fce33c1eb65bf 100644 --- a/arch/arm/configs/milbeaut_m10v_defconfig +++ b/arch/arm/configs/milbeaut_m10v_defconfig @@ -99,11 +99,10 @@ CONFIG_CRYPTO_MANAGER=y CONFIG_CRYPTO_AES=y CONFIG_CRYPTO_SEQIV=m CONFIG_CRYPTO_GHASH_ARM_CE=m CONFIG_CRYPTO_SHA1_ARM_NEON=m CONFIG_CRYPTO_SHA1_ARM_CE=m -CONFIG_CRYPTO_SHA2_ARM_CE=m CONFIG_CRYPTO_SHA512_ARM=m CONFIG_CRYPTO_AES_ARM=m CONFIG_CRYPTO_AES_ARM_BS=m CONFIG_CRYPTO_AES_ARM_CE=m CONFIG_CRYPTO_CHACHA20_NEON=m diff --git a/arch/arm/configs/multi_v7_defconfig b/arch/arm/configs/multi_v7_defconfig index ad037c175fdb0..96178acedad0b 100644 --- a/arch/arm/configs/multi_v7_defconfig +++ b/arch/arm/configs/multi_v7_defconfig @@ -1299,11 +1299,10 @@ CONFIG_CRYPTO_USER_API_SKCIPHER=m CONFIG_CRYPTO_USER_API_RNG=m CONFIG_CRYPTO_USER_API_AEAD=m CONFIG_CRYPTO_GHASH_ARM_CE=m CONFIG_CRYPTO_SHA1_ARM_NEON=m CONFIG_CRYPTO_SHA1_ARM_CE=m -CONFIG_CRYPTO_SHA2_ARM_CE=m CONFIG_CRYPTO_SHA512_ARM=m CONFIG_CRYPTO_AES_ARM=m CONFIG_CRYPTO_AES_ARM_BS=m CONFIG_CRYPTO_AES_ARM_CE=m CONFIG_CRYPTO_CHACHA20_NEON=m diff --git a/arch/arm/configs/omap2plus_defconfig b/arch/arm/configs/omap2plus_defconfig index 113d6dfe52435..57d9e4dba29e3 100644 --- a/arch/arm/configs/omap2plus_defconfig +++ b/arch/arm/configs/omap2plus_defconfig @@ -695,11 +695,10 @@ CONFIG_NLS_CODEPAGE_437=y CONFIG_NLS_ISO8859_1=y CONFIG_SECURITY=y CONFIG_CRYPTO_MICHAEL_MIC=y CONFIG_CRYPTO_GHASH_ARM_CE=m CONFIG_CRYPTO_SHA1_ARM_NEON=m -CONFIG_CRYPTO_SHA256_ARM=m CONFIG_CRYPTO_SHA512_ARM=m CONFIG_CRYPTO_AES_ARM=m CONFIG_CRYPTO_AES_ARM_BS=m CONFIG_CRYPTO_CHACHA20_NEON=m CONFIG_CRYPTO_DEV_OMAP=m diff --git a/arch/arm/configs/pxa_defconfig b/arch/arm/configs/pxa_defconfig index de0ac8f521d76..fa631523616f8 100644 --- a/arch/arm/configs/pxa_defconfig +++ b/arch/arm/configs/pxa_defconfig @@ -658,11 +658,10 @@ CONFIG_CRYPTO_WP512=m CONFIG_CRYPTO_ANUBIS=m CONFIG_CRYPTO_XCBC=m CONFIG_CRYPTO_DEFLATE=y CONFIG_CRYPTO_LZO=y CONFIG_CRYPTO_SHA1_ARM=m -CONFIG_CRYPTO_SHA256_ARM=m CONFIG_CRYPTO_SHA512_ARM=m CONFIG_CRYPTO_AES_ARM=m CONFIG_CRC_CCITT=y CONFIG_CRC_T10DIF=m CONFIG_FONTS=y diff --git a/arch/arm/crypto/Kconfig b/arch/arm/crypto/Kconfig index 1f889d6bab77d..7efb9a8596e4e 100644 --- a/arch/arm/crypto/Kconfig +++ b/arch/arm/crypto/Kconfig @@ -91,31 +91,10 @@ config CRYPTO_SHA1_ARM_CE help SHA-1 secure hash algorithm (FIPS 180) Architecture: arm using ARMv8 Crypto Extensions -config CRYPTO_SHA2_ARM_CE - tristate "Hash functions: SHA-224 and SHA-256 (ARMv8 Crypto Extensions)" - depends on KERNEL_MODE_NEON - select CRYPTO_SHA256_ARM - select CRYPTO_HASH - help - SHA-224 and SHA-256 secure hash algorithms (FIPS 180) - - Architecture: arm using - - ARMv8 Crypto Extensions - -config CRYPTO_SHA256_ARM - tristate "Hash functions: SHA-224 and SHA-256 (NEON)" - select CRYPTO_HASH - depends on !CPU_V7M - help - SHA-224 and SHA-256 secure hash algorithms (FIPS 180) - - Architecture: arm using - - NEON (Advanced SIMD) extensions - config CRYPTO_SHA512_ARM tristate "Hash functions: SHA-384 and SHA-512 (NEON)" select CRYPTO_HASH depends on !CPU_V7M help diff --git a/arch/arm/crypto/Makefile b/arch/arm/crypto/Makefile index ecabe6603e080..8479137c6e800 100644 --- a/arch/arm/crypto/Makefile +++ b/arch/arm/crypto/Makefile @@ -5,32 +5,27 @@ obj-$(CONFIG_CRYPTO_AES_ARM) += aes-arm.o obj-$(CONFIG_CRYPTO_AES_ARM_BS) += aes-arm-bs.o obj-$(CONFIG_CRYPTO_SHA1_ARM) += sha1-arm.o obj-$(CONFIG_CRYPTO_SHA1_ARM_NEON) += sha1-arm-neon.o -obj-$(CONFIG_CRYPTO_SHA256_ARM) += sha256-arm.o obj-$(CONFIG_CRYPTO_SHA512_ARM) += sha512-arm.o obj-$(CONFIG_CRYPTO_BLAKE2B_NEON) += blake2b-neon.o obj-$(CONFIG_CRYPTO_NHPOLY1305_NEON) += nhpoly1305-neon.o obj-$(CONFIG_CRYPTO_CURVE25519_NEON) += curve25519-neon.o obj-$(CONFIG_CRYPTO_AES_ARM_CE) += aes-arm-ce.o obj-$(CONFIG_CRYPTO_SHA1_ARM_CE) += sha1-arm-ce.o -obj-$(CONFIG_CRYPTO_SHA2_ARM_CE) += sha2-arm-ce.o obj-$(CONFIG_CRYPTO_GHASH_ARM_CE) += ghash-arm-ce.o aes-arm-y := aes-cipher-core.o aes-cipher-glue.o aes-arm-bs-y := aes-neonbs-core.o aes-neonbs-glue.o sha1-arm-y := sha1-armv4-large.o sha1_glue.o sha1-arm-neon-y := sha1-armv7-neon.o sha1_neon_glue.o -sha256-arm-neon-$(CONFIG_KERNEL_MODE_NEON) := sha256_neon_glue.o -sha256-arm-y := sha256-core.o sha256_glue.o $(sha256-arm-neon-y) sha512-arm-neon-$(CONFIG_KERNEL_MODE_NEON) := sha512-neon-glue.o sha512-arm-y := sha512-core.o sha512-glue.o $(sha512-arm-neon-y) blake2b-neon-y := blake2b-neon-core.o blake2b-neon-glue.o sha1-arm-ce-y := sha1-ce-core.o sha1-ce-glue.o -sha2-arm-ce-y := sha2-ce-core.o sha2-ce-glue.o aes-arm-ce-y := aes-ce-core.o aes-ce-glue.o ghash-arm-ce-y := ghash-ce-core.o ghash-ce-glue.o nhpoly1305-neon-y := nh-neon-core.o nhpoly1305-neon-glue.o curve25519-neon-y := curve25519-core.o curve25519-glue.o @@ -38,11 +33,10 @@ quiet_cmd_perl = PERL $@ cmd_perl = $(PERL) $(<) > $(@) $(obj)/%-core.S: $(src)/%-armv4.pl $(call cmd,perl) -clean-files += sha256-core.S sha512-core.S +clean-files += sha512-core.S aflags-thumb2-$(CONFIG_THUMB2_KERNEL) := -U__thumb2__ -D__thumb2__=1 -AFLAGS_sha256-core.o += $(aflags-thumb2-y) AFLAGS_sha512-core.o += $(aflags-thumb2-y) diff --git a/arch/arm/crypto/sha2-ce-glue.c b/arch/arm/crypto/sha2-ce-glue.c deleted file mode 100644 index 1e9d16f796787..0000000000000 --- a/arch/arm/crypto/sha2-ce-glue.c +++ /dev/null @@ -1,87 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-only -/* - * sha2-ce-glue.c - SHA-224/SHA-256 using ARMv8 Crypto Extensions - * - * Copyright (C) 2015 Linaro Ltd - */ - -#include -#include -#include -#include -#include -#include -#include - -MODULE_DESCRIPTION("SHA-224/SHA-256 secure hash using ARMv8 Crypto Extensions"); -MODULE_AUTHOR("Ard Biesheuvel "); -MODULE_LICENSE("GPL v2"); - -asmlinkage void sha2_ce_transform(struct crypto_sha256_state *sst, - u8 const *src, int blocks); - -static int sha2_ce_update(struct shash_desc *desc, const u8 *data, - unsigned int len) -{ - int remain; - - kernel_neon_begin(); - remain = sha256_base_do_update_blocks(desc, data, len, - sha2_ce_transform); - kernel_neon_end(); - return remain; -} - -static int sha2_ce_finup(struct shash_desc *desc, const u8 *data, - unsigned int len, u8 *out) -{ - kernel_neon_begin(); - sha256_base_do_finup(desc, data, len, sha2_ce_transform); - kernel_neon_end(); - return sha256_base_finish(desc, out); -} - -static struct shash_alg algs[] = { { - .init = sha224_base_init, - .update = sha2_ce_update, - .finup = sha2_ce_finup, - .descsize = sizeof(struct crypto_sha256_state), - .digestsize = SHA224_DIGEST_SIZE, - .base = { - .cra_name = "sha224", - .cra_driver_name = "sha224-ce", - .cra_priority = 300, - .cra_flags = CRYPTO_AHASH_ALG_BLOCK_ONLY | - CRYPTO_AHASH_ALG_FINUP_MAX, - .cra_blocksize = SHA256_BLOCK_SIZE, - .cra_module = THIS_MODULE, - } -}, { - .init = sha256_base_init, - .update = sha2_ce_update, - .finup = sha2_ce_finup, - .descsize = sizeof(struct crypto_sha256_state), - .digestsize = SHA256_DIGEST_SIZE, - .base = { - .cra_name = "sha256", - .cra_driver_name = "sha256-ce", - .cra_priority = 300, - .cra_flags = CRYPTO_AHASH_ALG_BLOCK_ONLY | - CRYPTO_AHASH_ALG_FINUP_MAX, - .cra_blocksize = SHA256_BLOCK_SIZE, - .cra_module = THIS_MODULE, - } -} }; - -static int __init sha2_ce_mod_init(void) -{ - return crypto_register_shashes(algs, ARRAY_SIZE(algs)); -} - -static void __exit sha2_ce_mod_fini(void) -{ - crypto_unregister_shashes(algs, ARRAY_SIZE(algs)); -} - -module_cpu_feature_match(SHA2, sha2_ce_mod_init); -module_exit(sha2_ce_mod_fini); diff --git a/arch/arm/crypto/sha256_glue.c b/arch/arm/crypto/sha256_glue.c deleted file mode 100644 index d04c4e6bae6d3..0000000000000 --- a/arch/arm/crypto/sha256_glue.c +++ /dev/null @@ -1,107 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-or-later -/* - * Glue code for the SHA256 Secure Hash Algorithm assembly implementation - * using optimized ARM assembler and NEON instructions. - * - * Copyright © 2015 Google Inc. - * - * This file is based on sha256_ssse3_glue.c: - * Copyright (C) 2013 Intel Corporation - * Author: Tim Chen - */ - -#include -#include -#include -#include -#include -#include - -#include "sha256_glue.h" - -asmlinkage void sha256_block_data_order(struct crypto_sha256_state *state, - const u8 *data, int num_blks); - -static int crypto_sha256_arm_update(struct shash_desc *desc, const u8 *data, - unsigned int len) -{ - /* make sure casting to sha256_block_fn() is safe */ - BUILD_BUG_ON(offsetof(struct crypto_sha256_state, state) != 0); - - return sha256_base_do_update_blocks(desc, data, len, - sha256_block_data_order); -} - -static int crypto_sha256_arm_finup(struct shash_desc *desc, const u8 *data, - unsigned int len, u8 *out) -{ - sha256_base_do_finup(desc, data, len, sha256_block_data_order); - return sha256_base_finish(desc, out); -} - -static struct shash_alg algs[] = { { - .digestsize = SHA256_DIGEST_SIZE, - .init = sha256_base_init, - .update = crypto_sha256_arm_update, - .finup = crypto_sha256_arm_finup, - .descsize = sizeof(struct crypto_sha256_state), - .base = { - .cra_name = "sha256", - .cra_driver_name = "sha256-asm", - .cra_priority = 150, - .cra_flags = CRYPTO_AHASH_ALG_BLOCK_ONLY | - CRYPTO_AHASH_ALG_FINUP_MAX, - .cra_blocksize = SHA256_BLOCK_SIZE, - .cra_module = THIS_MODULE, - } -}, { - .digestsize = SHA224_DIGEST_SIZE, - .init = sha224_base_init, - .update = crypto_sha256_arm_update, - .finup = crypto_sha256_arm_finup, - .descsize = sizeof(struct crypto_sha256_state), - .base = { - .cra_name = "sha224", - .cra_driver_name = "sha224-asm", - .cra_priority = 150, - .cra_flags = CRYPTO_AHASH_ALG_BLOCK_ONLY | - CRYPTO_AHASH_ALG_FINUP_MAX, - .cra_blocksize = SHA224_BLOCK_SIZE, - .cra_module = THIS_MODULE, - } -} }; - -static int __init sha256_mod_init(void) -{ - int res = crypto_register_shashes(algs, ARRAY_SIZE(algs)); - - if (res < 0) - return res; - - if (IS_ENABLED(CONFIG_KERNEL_MODE_NEON) && cpu_has_neon()) { - res = crypto_register_shashes(sha256_neon_algs, - ARRAY_SIZE(sha256_neon_algs)); - - if (res < 0) - crypto_unregister_shashes(algs, ARRAY_SIZE(algs)); - } - - return res; -} - -static void __exit sha256_mod_fini(void) -{ - crypto_unregister_shashes(algs, ARRAY_SIZE(algs)); - - if (IS_ENABLED(CONFIG_KERNEL_MODE_NEON) && cpu_has_neon()) - crypto_unregister_shashes(sha256_neon_algs, - ARRAY_SIZE(sha256_neon_algs)); -} - -module_init(sha256_mod_init); -module_exit(sha256_mod_fini); - -MODULE_LICENSE("GPL"); -MODULE_DESCRIPTION("SHA256 Secure Hash Algorithm (ARM), including NEON"); - -MODULE_ALIAS_CRYPTO("sha256"); diff --git a/arch/arm/crypto/sha256_glue.h b/arch/arm/crypto/sha256_glue.h deleted file mode 100644 index 9881c9a115d1f..0000000000000 --- a/arch/arm/crypto/sha256_glue.h +++ /dev/null @@ -1,9 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0 */ -#ifndef _CRYPTO_SHA256_GLUE_H -#define _CRYPTO_SHA256_GLUE_H - -#include - -extern struct shash_alg sha256_neon_algs[2]; - -#endif /* _CRYPTO_SHA256_GLUE_H */ diff --git a/arch/arm/crypto/sha256_neon_glue.c b/arch/arm/crypto/sha256_neon_glue.c deleted file mode 100644 index 76eb3cdc21c96..0000000000000 --- a/arch/arm/crypto/sha256_neon_glue.c +++ /dev/null @@ -1,75 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-or-later -/* - * Glue code for the SHA256 Secure Hash Algorithm assembly implementation - * using NEON instructions. - * - * Copyright © 2015 Google Inc. - * - * This file is based on sha512_neon_glue.c: - * Copyright © 2014 Jussi Kivilinna - */ - -#include -#include -#include -#include -#include -#include - -#include "sha256_glue.h" - -asmlinkage void sha256_block_data_order_neon( - struct crypto_sha256_state *digest, const u8 *data, int num_blks); - -static int crypto_sha256_neon_update(struct shash_desc *desc, const u8 *data, - unsigned int len) -{ - int remain; - - kernel_neon_begin(); - remain = sha256_base_do_update_blocks(desc, data, len, - sha256_block_data_order_neon); - kernel_neon_end(); - return remain; -} - -static int crypto_sha256_neon_finup(struct shash_desc *desc, const u8 *data, - unsigned int len, u8 *out) -{ - kernel_neon_begin(); - sha256_base_do_finup(desc, data, len, sha256_block_data_order_neon); - kernel_neon_end(); - return sha256_base_finish(desc, out); -} - -struct shash_alg sha256_neon_algs[] = { { - .digestsize = SHA256_DIGEST_SIZE, - .init = sha256_base_init, - .update = crypto_sha256_neon_update, - .finup = crypto_sha256_neon_finup, - .descsize = sizeof(struct crypto_sha256_state), - .base = { - .cra_name = "sha256", - .cra_driver_name = "sha256-neon", - .cra_priority = 250, - .cra_flags = CRYPTO_AHASH_ALG_BLOCK_ONLY | - CRYPTO_AHASH_ALG_FINUP_MAX, - .cra_blocksize = SHA256_BLOCK_SIZE, - .cra_module = THIS_MODULE, - } -}, { - .digestsize = SHA224_DIGEST_SIZE, - .init = sha224_base_init, - .update = crypto_sha256_neon_update, - .finup = crypto_sha256_neon_finup, - .descsize = sizeof(struct crypto_sha256_state), - .base = { - .cra_name = "sha224", - .cra_driver_name = "sha224-neon", - .cra_priority = 250, - .cra_flags = CRYPTO_AHASH_ALG_BLOCK_ONLY | - CRYPTO_AHASH_ALG_FINUP_MAX, - .cra_blocksize = SHA224_BLOCK_SIZE, - .cra_module = THIS_MODULE, - } -} }; diff --git a/arch/arm/lib/crypto/.gitignore b/arch/arm/lib/crypto/.gitignore index 0d47d4f21c6de..12d74d8b03d0a 100644 --- a/arch/arm/lib/crypto/.gitignore +++ b/arch/arm/lib/crypto/.gitignore @@ -1,2 +1,3 @@ # SPDX-License-Identifier: GPL-2.0-only poly1305-core.S +sha256-core.S diff --git a/arch/arm/lib/crypto/Kconfig b/arch/arm/lib/crypto/Kconfig index e8444fd0aae30..9f3ff30f40328 100644 --- a/arch/arm/lib/crypto/Kconfig +++ b/arch/arm/lib/crypto/Kconfig @@ -20,5 +20,11 @@ config CRYPTO_CHACHA20_NEON config CRYPTO_POLY1305_ARM tristate default CRYPTO_LIB_POLY1305 select CRYPTO_ARCH_HAVE_LIB_POLY1305 + +config CRYPTO_SHA256_ARM + tristate + depends on !CPU_V7M + default CRYPTO_LIB_SHA256 + select CRYPTO_ARCH_HAVE_LIB_SHA256 diff --git a/arch/arm/lib/crypto/Makefile b/arch/arm/lib/crypto/Makefile index 4c042a4c77ed6..431f77c3ff6fd 100644 --- a/arch/arm/lib/crypto/Makefile +++ b/arch/arm/lib/crypto/Makefile @@ -8,19 +8,25 @@ chacha-neon-y := chacha-scalar-core.o chacha-glue.o chacha-neon-$(CONFIG_KERNEL_MODE_NEON) += chacha-neon-core.o obj-$(CONFIG_CRYPTO_POLY1305_ARM) += poly1305-arm.o poly1305-arm-y := poly1305-core.o poly1305-glue.o +obj-$(CONFIG_CRYPTO_SHA256_ARM) += sha256-arm.o +sha256-arm-y := sha256.o sha256-core.o +sha256-arm-$(CONFIG_KERNEL_MODE_NEON) += sha256-ce.o + quiet_cmd_perl = PERL $@ cmd_perl = $(PERL) $(<) > $(@) $(obj)/%-core.S: $(src)/%-armv4.pl $(call cmd,perl) -clean-files += poly1305-core.S +clean-files += poly1305-core.S sha256-core.S aflags-thumb2-$(CONFIG_THUMB2_KERNEL) := -U__thumb2__ -D__thumb2__=1 # massage the perlasm code a bit so we only get the NEON routine if we need it poly1305-aflags-$(CONFIG_CPU_V7) := -U__LINUX_ARM_ARCH__ -D__LINUX_ARM_ARCH__=5 poly1305-aflags-$(CONFIG_KERNEL_MODE_NEON) := -U__LINUX_ARM_ARCH__ -D__LINUX_ARM_ARCH__=7 AFLAGS_poly1305-core.o += $(poly1305-aflags-y) $(aflags-thumb2-y) + +AFLAGS_sha256-core.o += $(aflags-thumb2-y) diff --git a/arch/arm/crypto/sha256-armv4.pl b/arch/arm/lib/crypto/sha256-armv4.pl similarity index 100% rename from arch/arm/crypto/sha256-armv4.pl rename to arch/arm/lib/crypto/sha256-armv4.pl diff --git a/arch/arm/crypto/sha2-ce-core.S b/arch/arm/lib/crypto/sha256-ce.S similarity index 91% rename from arch/arm/crypto/sha2-ce-core.S rename to arch/arm/lib/crypto/sha256-ce.S index b6369d2440a19..ac2c9b01b22d2 100644 --- a/arch/arm/crypto/sha2-ce-core.S +++ b/arch/arm/lib/crypto/sha256-ce.S @@ -1,8 +1,8 @@ /* SPDX-License-Identifier: GPL-2.0-only */ /* - * sha2-ce-core.S - SHA-224/256 secure hash using ARMv8 Crypto Extensions + * sha256-ce.S - SHA-224/256 secure hash using ARMv8 Crypto Extensions * * Copyright (C) 2015 Linaro Ltd. * Author: Ard Biesheuvel */ @@ -65,14 +65,14 @@ .word 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3 .word 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208 .word 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 /* - * void sha2_ce_transform(struct sha256_state *sst, u8 const *src, - int blocks); + * void sha256_ce_transform(u32 state[SHA256_STATE_WORDS], + * const u8 *data, size_t nblocks); */ -ENTRY(sha2_ce_transform) +ENTRY(sha256_ce_transform) /* load state */ vld1.32 {dga-dgb}, [r0] /* load input */ 0: vld1.32 {q0-q1}, [r1]! @@ -118,6 +118,6 @@ ENTRY(sha2_ce_transform) bne 0b /* store new state */ vst1.32 {dga-dgb}, [r0] bx lr -ENDPROC(sha2_ce_transform) +ENDPROC(sha256_ce_transform) diff --git a/arch/arm/lib/crypto/sha256.c b/arch/arm/lib/crypto/sha256.c new file mode 100644 index 0000000000000..3a8dfc304807a --- /dev/null +++ b/arch/arm/lib/crypto/sha256.c @@ -0,0 +1,64 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * SHA-256 optimized for ARM + * + * Copyright 2025 Google LLC + */ +#include +#include +#include +#include +#include + +asmlinkage void sha256_block_data_order(u32 state[SHA256_STATE_WORDS], + const u8 *data, size_t nblocks); +asmlinkage void sha256_block_data_order_neon(u32 state[SHA256_STATE_WORDS], + const u8 *data, size_t nblocks); +asmlinkage void sha256_ce_transform(u32 state[SHA256_STATE_WORDS], + const u8 *data, size_t nblocks); + +static __ro_after_init DEFINE_STATIC_KEY_FALSE(have_neon); +static __ro_after_init DEFINE_STATIC_KEY_FALSE(have_ce); + +void sha256_blocks_arch(u32 state[SHA256_STATE_WORDS], + const u8 *data, size_t nblocks) +{ + if (IS_ENABLED(CONFIG_KERNEL_MODE_NEON) && + static_branch_likely(&have_neon) && crypto_simd_usable()) { + kernel_neon_begin(); + if (static_branch_likely(&have_ce)) + sha256_ce_transform(state, data, nblocks); + else + sha256_block_data_order_neon(state, data, nblocks); + kernel_neon_end(); + } else { + sha256_block_data_order(state, data, nblocks); + } +} +EXPORT_SYMBOL(sha256_blocks_arch); + +bool sha256_is_arch_optimized(void) +{ + /* We always can use at least the ARM scalar implementation. */ + return true; +} +EXPORT_SYMBOL(sha256_is_arch_optimized); + +static int __init sha256_arm_mod_init(void) +{ + if (IS_ENABLED(CONFIG_KERNEL_MODE_NEON) && (elf_hwcap & HWCAP_NEON)) { + static_branch_enable(&have_neon); + if (elf_hwcap2 & HWCAP2_SHA2) + static_branch_enable(&have_ce); + } + return 0; +} +arch_initcall(sha256_arm_mod_init); + +static void __exit sha256_arm_mod_exit(void) +{ +} +module_exit(sha256_arm_mod_exit); + +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("SHA-256 optimized for ARM"); -- 2.49.0 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 6018BC369CB for ; Sat, 26 Apr 2025 07:07:05 +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=FxK6RQ8P0WvMAtWyYuOgLOUCzgsjPt3eUvja0oHlm6c=; b=rDPXfRmmjgTEkI SEEQ4/HHWIrJBWeoe6SGW0E07vHpcZj9xcvIYAPWrS5fl0cbSz6MZyKtPWVRx0/4TLAYXVrBPHedU SPKfIJWX/+bun1YCaWT4ZC9siTMjRTR7smCGbbnr9ahdnI11VGeyYaXPk3Q2dRnuXsgLy7CqEriPT DH/NgTMTfR7l+5VnxftW0VrmnOe9p10rPp31cBa2jnteRZ1XImUkoUG6Q2RyWNYndRxCY6jH4pEfv eGJjEuHlZar+85A/Lr/HSXARvEmAIDZ++7tbdtxu1F0zznBFAn+AqQFSi4hjCXz6NSqWM24Fxs9yt sIWUMVWCTniPp+T1h/rA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1u8Zcq-00000001dYV-0Pus; Sat, 26 Apr 2025 07:07:00 +0000 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1u8ZO2-00000001aZt-1A3m; Sat, 26 Apr 2025 06:51:46 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by sea.source.kernel.org (Postfix) with ESMTP id EFEC34A497; Sat, 26 Apr 2025 06:51:38 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3A9A5C4CEED; Sat, 26 Apr 2025 06:51:40 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1745650300; bh=Z8g2QC8t5xCKSohXvmUSVfT8rth+Vg9Lxt049FddoYE=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=iPg3d5nn3ULW7JRpe6IVXE1Bk7r2X7yA9WibbhTzMjeRf9ALqm6H7ARsM4mfuGXo4 fNqydbIM3GqFYiGV6ZMlr4I/vtUuBFqQJk/v1J5IXcIIUjDHFow0ibNJZFDBqHzjqm M1/gdZG9l/fA5MJZ3B0QSxk5lxA1fqxFBl+XOawMwp58l9mSU5YeDoPTnAg6fApxn9 fRUEzLCt+7zscEpkq6U8F7V3ANws7z16ZLS6BvmViMe8SSfwAFv0dzA4bSl2EuDRpZ 7cXp/pEhJTAX9RAx8tYs60jO7NhS2N5yk85ksULRDBzMgTblSErI7gjXqB5l0ykmp1 Cm4xOy8vte8ZQ== From: Eric Biggers To: linux-crypto@vger.kernel.org Cc: linux-kernel@vger.kernel.org, linux-arch@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-mips@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, linux-riscv@lists.infradead.org, sparclinux@vger.kernel.org, linux-s390@vger.kernel.org, x86@kernel.org, Ard Biesheuvel , "Jason A . Donenfeld " , Linus Torvalds Subject: [PATCH 02/13] crypto: arm/sha256 - implement library instead of shash Date: Fri, 25 Apr 2025 23:50:28 -0700 Message-ID: <20250426065041.1551914-3-ebiggers@kernel.org> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250426065041.1551914-1-ebiggers@kernel.org> References: <20250426065041.1551914-1-ebiggers@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250425_235142_373024_23810F93 X-CRM114-Status: GOOD ( 19.23 ) 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 RnJvbTogRXJpYyBCaWdnZXJzIDxlYmlnZ2Vyc0Bnb29nbGUuY29tPgoKSW5zdGVhZCBvZiBwcm92 aWRpbmcgY3J5cHRvX3NoYXNoIGFsZ29yaXRobXMgZm9yIHRoZSBhcmNoLW9wdGltaXplZApTSEEt MjU2IGNvZGUsIGluc3RlYWQgaW1wbGVtZW50IHRoZSBTSEEtMjU2IGxpYnJhcnkuICBUaGlzIGlz IG11Y2gKc2ltcGxlciwgaXQgbWFrZXMgdGhlIFNIQS0yNTYgbGlicmFyeSBmdW5jdGlvbnMgYmUg YXJjaC1vcHRpbWl6ZWQsIGFuZAppdCBmaXhlcyB0aGUgbG9uZ3N0YW5kaW5nIGlzc3VlIHdoZXJl IHRoZSBhcmNoLW9wdGltaXplZCBTSEEtMjU2IHdhcwpkaXNhYmxlZCBieSBkZWZhdWx0LiAgU0hB LTI1NiBzdGlsbCByZW1haW5zIGF2YWlsYWJsZSB0aHJvdWdoCmNyeXB0b19zaGFzaCwgYnV0IGlu ZGl2aWR1YWwgYXJjaGl0ZWN0dXJlcyBubyBsb25nZXIgbmVlZCB0byBoYW5kbGUgaXQuCgpUbyBt ZXJnZSB0aGUgc2NhbGFyLCBORU9OLCBhbmQgQ0UgY29kZSBhbGwgaW50byBvbmUgbW9kdWxlIGNs ZWFubHksIGFkZAohQ1BVX1Y3TSBhcyBhIGRpcmVjdCBkZXBlbmRlbmN5IG9mIHRoZSBDRSBjb2Rl LiAgUHJldmlvdXNseSwgIUNQVV9WN00Kd2FzIG9ubHkgYSBkaXJlY3QgZGVwZW5kZW5jeSBvZiB0 aGUgc2NhbGFyIGFuZCBORU9OIGNvZGUuICBUaGUgcmVzdWx0IGlzCnN0aWxsIHRoZSBzYW1lIGJl Y2F1c2UgQ1BVX1Y3TSBpbXBsaWVzICFLRVJORUxfTU9ERV9ORU9OLCBzbyAhQ1BVX1Y3TQp3YXMg YWxyZWFkeSBhbiBpbmRpcmVjdCBkZXBlbmRlbmN5IG9mIHRoZSBDRSBjb2RlLgoKVG8gbWF0Y2gg c2hhMjU2X2Jsb2Nrc19hcmNoKCksIGNoYW5nZSB0aGUgdHlwZSBvZiB0aGUgbmJsb2NrcyBwYXJh bWV0ZXIKb2YgdGhlIGFzc2VtYmx5IGZ1bmN0aW9ucyBmcm9tIGludCB0byBzaXplX3QuICBUaGUg YXNzZW1ibHkgZnVuY3Rpb25zCmFjdHVhbGx5IGFscmVhZHkgdHJlYXRlZCBpdCBhcyBzaXplX3Qu CgpXaGlsZSByZW5hbWluZyB0aGUgYXNzZW1ibHkgZmlsZXMsIGFsc28gZml4IHRoZSBuYW1pbmcg cXVpcmsgd2hlcmUKInNoYTIiIG1lYW50IHNoYTI1Ni4gIChTSEEtNTEyIGlzIGFsc28gcGFydCBv ZiBTSEEtMi4pCgpTaWduZWQtb2ZmLWJ5OiBFcmljIEJpZ2dlcnMgPGViaWdnZXJzQGdvb2dsZS5j b20+Ci0tLQogYXJjaC9hcm0vY29uZmlncy9leHlub3NfZGVmY29uZmlnICAgICAgICAgICAgIHwg ICAxIC0KIGFyY2gvYXJtL2NvbmZpZ3MvbWlsYmVhdXRfbTEwdl9kZWZjb25maWcgICAgICB8ICAg MSAtCiBhcmNoL2FybS9jb25maWdzL211bHRpX3Y3X2RlZmNvbmZpZyAgICAgICAgICAgfCAgIDEg LQogYXJjaC9hcm0vY29uZmlncy9vbWFwMnBsdXNfZGVmY29uZmlnICAgICAgICAgIHwgICAxIC0K IGFyY2gvYXJtL2NvbmZpZ3MvcHhhX2RlZmNvbmZpZyAgICAgICAgICAgICAgICB8ICAgMSAtCiBh cmNoL2FybS9jcnlwdG8vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgfCAgMjEgLS0tLQog YXJjaC9hcm0vY3J5cHRvL01ha2VmaWxlICAgICAgICAgICAgICAgICAgICAgIHwgICA4ICstCiBh cmNoL2FybS9jcnlwdG8vc2hhMi1jZS1nbHVlLmMgICAgICAgICAgICAgICAgfCAgODcgLS0tLS0t LS0tLS0tLS0KIGFyY2gvYXJtL2NyeXB0by9zaGEyNTZfZ2x1ZS5jICAgICAgICAgICAgICAgICB8 IDEwNyAtLS0tLS0tLS0tLS0tLS0tLS0KIGFyY2gvYXJtL2NyeXB0by9zaGEyNTZfZ2x1ZS5oICAg ICAgICAgICAgICAgICB8ICAgOSAtLQogYXJjaC9hcm0vY3J5cHRvL3NoYTI1Nl9uZW9uX2dsdWUu YyAgICAgICAgICAgIHwgIDc1IC0tLS0tLS0tLS0tLQogYXJjaC9hcm0vbGliL2NyeXB0by8uZ2l0 aWdub3JlICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvYXJtL2xpYi9jcnlwdG8vS2NvbmZp ZyAgICAgICAgICAgICAgICAgICB8ICAgNiArCiBhcmNoL2FybS9saWIvY3J5cHRvL01ha2VmaWxl ICAgICAgICAgICAgICAgICAgfCAgIDggKy0KIGFyY2gvYXJtL3sgPT4gbGlifS9jcnlwdG8vc2hh MjU2LWFybXY0LnBsICAgICB8ICAgMAogLi4uL3NoYTItY2UtY29yZS5TID0+IGxpYi9jcnlwdG8v c2hhMjU2LWNlLlN9IHwgIDEwICstCiBhcmNoL2FybS9saWIvY3J5cHRvL3NoYTI1Ni5jICAgICAg ICAgICAgICAgICAgfCAgNjQgKysrKysrKysrKysKIDE3IGZpbGVzIGNoYW5nZWQsIDg0IGluc2Vy dGlvbnMoKyksIDMxNyBkZWxldGlvbnMoLSkKIGRlbGV0ZSBtb2RlIDEwMDY0NCBhcmNoL2FybS9j cnlwdG8vc2hhMi1jZS1nbHVlLmMKIGRlbGV0ZSBtb2RlIDEwMDY0NCBhcmNoL2FybS9jcnlwdG8v c2hhMjU2X2dsdWUuYwogZGVsZXRlIG1vZGUgMTAwNjQ0IGFyY2gvYXJtL2NyeXB0by9zaGEyNTZf Z2x1ZS5oCiBkZWxldGUgbW9kZSAxMDA2NDQgYXJjaC9hcm0vY3J5cHRvL3NoYTI1Nl9uZW9uX2ds dWUuYwogcmVuYW1lIGFyY2gvYXJtL3sgPT4gbGlifS9jcnlwdG8vc2hhMjU2LWFybXY0LnBsICgx MDAlKQogcmVuYW1lIGFyY2gvYXJtL3tjcnlwdG8vc2hhMi1jZS1jb3JlLlMgPT4gbGliL2NyeXB0 by9zaGEyNTYtY2UuU30gKDkxJSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL2FybS9saWIvY3J5 cHRvL3NoYTI1Ni5jCgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9leHlub3NfZGVmY29u ZmlnIGIvYXJjaC9hcm0vY29uZmlncy9leHlub3NfZGVmY29uZmlnCmluZGV4IDdhZDQ4ZmRkYTFk YWMuLjI0NGRkNWRlYzk4YmQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3MvZXh5bm9zX2Rl ZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL2V4eW5vc19kZWZjb25maWcKQEAgLTM2Miwx MSArMzYyLDEwIEBAIENPTkZJR19DUllQVE9fTFo0PW0KIENPTkZJR19DUllQVE9fVVNFUl9BUElf SEFTSD1tCiBDT05GSUdfQ1JZUFRPX1VTRVJfQVBJX1NLQ0lQSEVSPW0KIENPTkZJR19DUllQVE9f VVNFUl9BUElfUk5HPW0KIENPTkZJR19DUllQVE9fVVNFUl9BUElfQUVBRD1tCiBDT05GSUdfQ1JZ UFRPX1NIQTFfQVJNX05FT049bQotQ09ORklHX0NSWVBUT19TSEEyNTZfQVJNPW0KIENPTkZJR19D UllQVE9fU0hBNTEyX0FSTT1tCiBDT05GSUdfQ1JZUFRPX0FFU19BUk1fQlM9bQogQ09ORklHX0NS WVBUT19DSEFDSEEyMF9ORU9OPW0KIENPTkZJR19DUllQVE9fREVWX0VYWU5PU19STkc9eQogQ09O RklHX0NSWVBUT19ERVZfUzVQPXkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvbWlsYmVh dXRfbTEwdl9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL21pbGJlYXV0X20xMHZfZGVmY29u ZmlnCmluZGV4IGFjZDE2MjA0ZjhkN2YuLmZjZTMzYzFlYjY1YmYgMTAwNjQ0Ci0tLSBhL2FyY2gv YXJtL2NvbmZpZ3MvbWlsYmVhdXRfbTEwdl9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmln cy9taWxiZWF1dF9tMTB2X2RlZmNvbmZpZwpAQCAtOTksMTEgKzk5LDEwIEBAIENPTkZJR19DUllQ VE9fTUFOQUdFUj15CiBDT05GSUdfQ1JZUFRPX0FFUz15CiBDT05GSUdfQ1JZUFRPX1NFUUlWPW0K IENPTkZJR19DUllQVE9fR0hBU0hfQVJNX0NFPW0KIENPTkZJR19DUllQVE9fU0hBMV9BUk1fTkVP Tj1tCiBDT05GSUdfQ1JZUFRPX1NIQTFfQVJNX0NFPW0KLUNPTkZJR19DUllQVE9fU0hBMl9BUk1f Q0U9bQogQ09ORklHX0NSWVBUT19TSEE1MTJfQVJNPW0KIENPTkZJR19DUllQVE9fQUVTX0FSTT1t CiBDT05GSUdfQ1JZUFRPX0FFU19BUk1fQlM9bQogQ09ORklHX0NSWVBUT19BRVNfQVJNX0NFPW0K IENPTkZJR19DUllQVE9fQ0hBQ0hBMjBfTkVPTj1tCmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25m aWdzL211bHRpX3Y3X2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvbXVsdGlfdjdfZGVmY29u ZmlnCmluZGV4IGFkMDM3YzE3NWZkYjAuLjk2MTc4YWNlZGFkMGIgMTAwNjQ0Ci0tLSBhL2FyY2gv YXJtL2NvbmZpZ3MvbXVsdGlfdjdfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvbXVs dGlfdjdfZGVmY29uZmlnCkBAIC0xMjk5LDExICsxMjk5LDEwIEBAIENPTkZJR19DUllQVE9fVVNF Ul9BUElfU0tDSVBIRVI9bQogQ09ORklHX0NSWVBUT19VU0VSX0FQSV9STkc9bQogQ09ORklHX0NS WVBUT19VU0VSX0FQSV9BRUFEPW0KIENPTkZJR19DUllQVE9fR0hBU0hfQVJNX0NFPW0KIENPTkZJ R19DUllQVE9fU0hBMV9BUk1fTkVPTj1tCiBDT05GSUdfQ1JZUFRPX1NIQTFfQVJNX0NFPW0KLUNP TkZJR19DUllQVE9fU0hBMl9BUk1fQ0U9bQogQ09ORklHX0NSWVBUT19TSEE1MTJfQVJNPW0KIENP TkZJR19DUllQVE9fQUVTX0FSTT1tCiBDT05GSUdfQ1JZUFRPX0FFU19BUk1fQlM9bQogQ09ORklH X0NSWVBUT19BRVNfQVJNX0NFPW0KIENPTkZJR19DUllQVE9fQ0hBQ0hBMjBfTkVPTj1tCmRpZmYg LS1naXQgYS9hcmNoL2FybS9jb25maWdzL29tYXAycGx1c19kZWZjb25maWcgYi9hcmNoL2FybS9j b25maWdzL29tYXAycGx1c19kZWZjb25maWcKaW5kZXggMTEzZDZkZmU1MjQzNS4uNTdkOWU0ZGJh MjllMyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9vbWFwMnBsdXNfZGVmY29uZmlnCisr KyBiL2FyY2gvYXJtL2NvbmZpZ3Mvb21hcDJwbHVzX2RlZmNvbmZpZwpAQCAtNjk1LDExICs2OTUs MTAgQEAgQ09ORklHX05MU19DT0RFUEFHRV80Mzc9eQogQ09ORklHX05MU19JU084ODU5XzE9eQog Q09ORklHX1NFQ1VSSVRZPXkKIENPTkZJR19DUllQVE9fTUlDSEFFTF9NSUM9eQogQ09ORklHX0NS WVBUT19HSEFTSF9BUk1fQ0U9bQogQ09ORklHX0NSWVBUT19TSEExX0FSTV9ORU9OPW0KLUNPTkZJ R19DUllQVE9fU0hBMjU2X0FSTT1tCiBDT05GSUdfQ1JZUFRPX1NIQTUxMl9BUk09bQogQ09ORklH X0NSWVBUT19BRVNfQVJNPW0KIENPTkZJR19DUllQVE9fQUVTX0FSTV9CUz1tCiBDT05GSUdfQ1JZ UFRPX0NIQUNIQTIwX05FT049bQogQ09ORklHX0NSWVBUT19ERVZfT01BUD1tCmRpZmYgLS1naXQg YS9hcmNoL2FybS9jb25maWdzL3B4YV9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL3B4YV9k ZWZjb25maWcKaW5kZXggZGUwYWM4ZjUyMWQ3Ni4uZmE2MzE1MjM2MTZmOCAxMDA2NDQKLS0tIGEv YXJjaC9hcm0vY29uZmlncy9weGFfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvcHhh X2RlZmNvbmZpZwpAQCAtNjU4LDExICs2NTgsMTAgQEAgQ09ORklHX0NSWVBUT19XUDUxMj1tCiBD T05GSUdfQ1JZUFRPX0FOVUJJUz1tCiBDT05GSUdfQ1JZUFRPX1hDQkM9bQogQ09ORklHX0NSWVBU T19ERUZMQVRFPXkKIENPTkZJR19DUllQVE9fTFpPPXkKIENPTkZJR19DUllQVE9fU0hBMV9BUk09 bQotQ09ORklHX0NSWVBUT19TSEEyNTZfQVJNPW0KIENPTkZJR19DUllQVE9fU0hBNTEyX0FSTT1t CiBDT05GSUdfQ1JZUFRPX0FFU19BUk09bQogQ09ORklHX0NSQ19DQ0lUVD15CiBDT05GSUdfQ1JD X1QxMERJRj1tCiBDT05GSUdfRk9OVFM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY3J5cHRvL0tj b25maWcgYi9hcmNoL2FybS9jcnlwdG8vS2NvbmZpZwppbmRleCAxZjg4OWQ2YmFiNzdkLi43ZWZi OWE4NTk2ZTRlIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jcnlwdG8vS2NvbmZpZworKysgYi9hcmNo L2FybS9jcnlwdG8vS2NvbmZpZwpAQCAtOTEsMzEgKzkxLDEwIEBAIGNvbmZpZyBDUllQVE9fU0hB MV9BUk1fQ0UKIAloZWxwCiAJICBTSEEtMSBzZWN1cmUgaGFzaCBhbGdvcml0aG0gKEZJUFMgMTgw KQogCiAJICBBcmNoaXRlY3R1cmU6IGFybSB1c2luZyBBUk12OCBDcnlwdG8gRXh0ZW5zaW9ucwog Ci1jb25maWcgQ1JZUFRPX1NIQTJfQVJNX0NFCi0JdHJpc3RhdGUgIkhhc2ggZnVuY3Rpb25zOiBT SEEtMjI0IGFuZCBTSEEtMjU2IChBUk12OCBDcnlwdG8gRXh0ZW5zaW9ucykiCi0JZGVwZW5kcyBv biBLRVJORUxfTU9ERV9ORU9OCi0Jc2VsZWN0IENSWVBUT19TSEEyNTZfQVJNCi0Jc2VsZWN0IENS WVBUT19IQVNICi0JaGVscAotCSAgU0hBLTIyNCBhbmQgU0hBLTI1NiBzZWN1cmUgaGFzaCBhbGdv cml0aG1zIChGSVBTIDE4MCkKLQotCSAgQXJjaGl0ZWN0dXJlOiBhcm0gdXNpbmcKLQkgIC0gQVJN djggQ3J5cHRvIEV4dGVuc2lvbnMKLQotY29uZmlnIENSWVBUT19TSEEyNTZfQVJNCi0JdHJpc3Rh dGUgIkhhc2ggZnVuY3Rpb25zOiBTSEEtMjI0IGFuZCBTSEEtMjU2IChORU9OKSIKLQlzZWxlY3Qg Q1JZUFRPX0hBU0gKLQlkZXBlbmRzIG9uICFDUFVfVjdNCi0JaGVscAotCSAgU0hBLTIyNCBhbmQg U0hBLTI1NiBzZWN1cmUgaGFzaCBhbGdvcml0aG1zIChGSVBTIDE4MCkKLQotCSAgQXJjaGl0ZWN0 dXJlOiBhcm0gdXNpbmcKLQkgIC0gTkVPTiAoQWR2YW5jZWQgU0lNRCkgZXh0ZW5zaW9ucwotCiBj b25maWcgQ1JZUFRPX1NIQTUxMl9BUk0KIAl0cmlzdGF0ZSAiSGFzaCBmdW5jdGlvbnM6IFNIQS0z ODQgYW5kIFNIQS01MTIgKE5FT04pIgogCXNlbGVjdCBDUllQVE9fSEFTSAogCWRlcGVuZHMgb24g IUNQVV9WN00KIAloZWxwCmRpZmYgLS1naXQgYS9hcmNoL2FybS9jcnlwdG8vTWFrZWZpbGUgYi9h cmNoL2FybS9jcnlwdG8vTWFrZWZpbGUKaW5kZXggZWNhYmU2NjAzZTA4MC4uODQ3OTEzN2M2ZTgw MCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY3J5cHRvL01ha2VmaWxlCisrKyBiL2FyY2gvYXJtL2Ny eXB0by9NYWtlZmlsZQpAQCAtNSwzMiArNSwyNyBAQAogCiBvYmotJChDT05GSUdfQ1JZUFRPX0FF U19BUk0pICs9IGFlcy1hcm0ubwogb2JqLSQoQ09ORklHX0NSWVBUT19BRVNfQVJNX0JTKSArPSBh ZXMtYXJtLWJzLm8KIG9iai0kKENPTkZJR19DUllQVE9fU0hBMV9BUk0pICs9IHNoYTEtYXJtLm8K IG9iai0kKENPTkZJR19DUllQVE9fU0hBMV9BUk1fTkVPTikgKz0gc2hhMS1hcm0tbmVvbi5vCi1v YmotJChDT05GSUdfQ1JZUFRPX1NIQTI1Nl9BUk0pICs9IHNoYTI1Ni1hcm0ubwogb2JqLSQoQ09O RklHX0NSWVBUT19TSEE1MTJfQVJNKSArPSBzaGE1MTItYXJtLm8KIG9iai0kKENPTkZJR19DUllQ VE9fQkxBS0UyQl9ORU9OKSArPSBibGFrZTJiLW5lb24ubwogb2JqLSQoQ09ORklHX0NSWVBUT19O SFBPTFkxMzA1X05FT04pICs9IG5ocG9seTEzMDUtbmVvbi5vCiBvYmotJChDT05GSUdfQ1JZUFRP X0NVUlZFMjU1MTlfTkVPTikgKz0gY3VydmUyNTUxOS1uZW9uLm8KIAogb2JqLSQoQ09ORklHX0NS WVBUT19BRVNfQVJNX0NFKSArPSBhZXMtYXJtLWNlLm8KIG9iai0kKENPTkZJR19DUllQVE9fU0hB MV9BUk1fQ0UpICs9IHNoYTEtYXJtLWNlLm8KLW9iai0kKENPTkZJR19DUllQVE9fU0hBMl9BUk1f Q0UpICs9IHNoYTItYXJtLWNlLm8KIG9iai0kKENPTkZJR19DUllQVE9fR0hBU0hfQVJNX0NFKSAr PSBnaGFzaC1hcm0tY2UubwogCiBhZXMtYXJtLXkJOj0gYWVzLWNpcGhlci1jb3JlLm8gYWVzLWNp cGhlci1nbHVlLm8KIGFlcy1hcm0tYnMteQk6PSBhZXMtbmVvbmJzLWNvcmUubyBhZXMtbmVvbmJz LWdsdWUubwogc2hhMS1hcm0teQk6PSBzaGExLWFybXY0LWxhcmdlLm8gc2hhMV9nbHVlLm8KIHNo YTEtYXJtLW5lb24teQk6PSBzaGExLWFybXY3LW5lb24ubyBzaGExX25lb25fZ2x1ZS5vCi1zaGEy NTYtYXJtLW5lb24tJChDT05GSUdfS0VSTkVMX01PREVfTkVPTikgOj0gc2hhMjU2X25lb25fZ2x1 ZS5vCi1zaGEyNTYtYXJtLXkJOj0gc2hhMjU2LWNvcmUubyBzaGEyNTZfZ2x1ZS5vICQoc2hhMjU2 LWFybS1uZW9uLXkpCiBzaGE1MTItYXJtLW5lb24tJChDT05GSUdfS0VSTkVMX01PREVfTkVPTikg Oj0gc2hhNTEyLW5lb24tZ2x1ZS5vCiBzaGE1MTItYXJtLXkJOj0gc2hhNTEyLWNvcmUubyBzaGE1 MTItZ2x1ZS5vICQoc2hhNTEyLWFybS1uZW9uLXkpCiBibGFrZTJiLW5lb24teSAgOj0gYmxha2Uy Yi1uZW9uLWNvcmUubyBibGFrZTJiLW5lb24tZ2x1ZS5vCiBzaGExLWFybS1jZS15CTo9IHNoYTEt Y2UtY29yZS5vIHNoYTEtY2UtZ2x1ZS5vCi1zaGEyLWFybS1jZS15CTo9IHNoYTItY2UtY29yZS5v IHNoYTItY2UtZ2x1ZS5vCiBhZXMtYXJtLWNlLXkJOj0gYWVzLWNlLWNvcmUubyBhZXMtY2UtZ2x1 ZS5vCiBnaGFzaC1hcm0tY2UteQk6PSBnaGFzaC1jZS1jb3JlLm8gZ2hhc2gtY2UtZ2x1ZS5vCiBu aHBvbHkxMzA1LW5lb24teSA6PSBuaC1uZW9uLWNvcmUubyBuaHBvbHkxMzA1LW5lb24tZ2x1ZS5v CiBjdXJ2ZTI1NTE5LW5lb24teSA6PSBjdXJ2ZTI1NTE5LWNvcmUubyBjdXJ2ZTI1NTE5LWdsdWUu bwogCkBAIC0zOCwxMSArMzMsMTAgQEAgcXVpZXRfY21kX3BlcmwgPSBQRVJMICAgICRACiAgICAg ICBjbWRfcGVybCA9ICQoUEVSTCkgJCg8KSA+ICQoQCkKIAogJChvYmopLyUtY29yZS5TOiAkKHNy YykvJS1hcm12NC5wbAogCSQoY2FsbCBjbWQscGVybCkKIAotY2xlYW4tZmlsZXMgKz0gc2hhMjU2 LWNvcmUuUyBzaGE1MTItY29yZS5TCitjbGVhbi1maWxlcyArPSBzaGE1MTItY29yZS5TCiAKIGFm bGFncy10aHVtYjItJChDT05GSUdfVEhVTUIyX0tFUk5FTCkgIDo9IC1VX190aHVtYjJfXyAtRF9f dGh1bWIyX189MQogCi1BRkxBR1Nfc2hhMjU2LWNvcmUubyArPSAkKGFmbGFncy10aHVtYjIteSkK IEFGTEFHU19zaGE1MTItY29yZS5vICs9ICQoYWZsYWdzLXRodW1iMi15KQpkaWZmIC0tZ2l0IGEv YXJjaC9hcm0vY3J5cHRvL3NoYTItY2UtZ2x1ZS5jIGIvYXJjaC9hcm0vY3J5cHRvL3NoYTItY2Ut Z2x1ZS5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxZTlkMTZmNzk2Nzg3Li4wMDAw MDAwMDAwMDAwCi0tLSBhL2FyY2gvYXJtL2NyeXB0by9zaGEyLWNlLWdsdWUuYworKysgL2Rldi9u dWxsCkBAIC0xLDg3ICswLDAgQEAKLS8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4w LW9ubHkKLS8qCi0gKiBzaGEyLWNlLWdsdWUuYyAtIFNIQS0yMjQvU0hBLTI1NiB1c2luZyBBUk12 OCBDcnlwdG8gRXh0ZW5zaW9ucwotICoKLSAqIENvcHlyaWdodCAoQykgMjAxNSBMaW5hcm8gTHRk IDxhcmQuYmllc2hldXZlbEBsaW5hcm8ub3JnPgotICovCi0KLSNpbmNsdWRlIDxhc20vbmVvbi5o PgotI2luY2x1ZGUgPGNyeXB0by9pbnRlcm5hbC9oYXNoLmg+Ci0jaW5jbHVkZSA8Y3J5cHRvL3No YTIuaD4KLSNpbmNsdWRlIDxjcnlwdG8vc2hhMjU2X2Jhc2UuaD4KLSNpbmNsdWRlIDxsaW51eC9j cHVmZWF0dXJlLmg+Ci0jaW5jbHVkZSA8bGludXgva2VybmVsLmg+Ci0jaW5jbHVkZSA8bGludXgv bW9kdWxlLmg+Ci0KLU1PRFVMRV9ERVNDUklQVElPTigiU0hBLTIyNC9TSEEtMjU2IHNlY3VyZSBo YXNoIHVzaW5nIEFSTXY4IENyeXB0byBFeHRlbnNpb25zIik7Ci1NT0RVTEVfQVVUSE9SKCJBcmQg Qmllc2hldXZlbCA8YXJkLmJpZXNoZXV2ZWxAbGluYXJvLm9yZz4iKTsKLU1PRFVMRV9MSUNFTlNF KCJHUEwgdjIiKTsKLQotYXNtbGlua2FnZSB2b2lkIHNoYTJfY2VfdHJhbnNmb3JtKHN0cnVjdCBj cnlwdG9fc2hhMjU2X3N0YXRlICpzc3QsCi0JCQkJICB1OCBjb25zdCAqc3JjLCBpbnQgYmxvY2tz KTsKLQotc3RhdGljIGludCBzaGEyX2NlX3VwZGF0ZShzdHJ1Y3Qgc2hhc2hfZGVzYyAqZGVzYywg Y29uc3QgdTggKmRhdGEsCi0JCQkgIHVuc2lnbmVkIGludCBsZW4pCi17Ci0JaW50IHJlbWFpbjsK LQotCWtlcm5lbF9uZW9uX2JlZ2luKCk7Ci0JcmVtYWluID0gc2hhMjU2X2Jhc2VfZG9fdXBkYXRl X2Jsb2NrcyhkZXNjLCBkYXRhLCBsZW4sCi0JCQkJCSAgICAgIHNoYTJfY2VfdHJhbnNmb3JtKTsK LQlrZXJuZWxfbmVvbl9lbmQoKTsKLQlyZXR1cm4gcmVtYWluOwotfQotCi1zdGF0aWMgaW50IHNo YTJfY2VfZmludXAoc3RydWN0IHNoYXNoX2Rlc2MgKmRlc2MsIGNvbnN0IHU4ICpkYXRhLAotCQkJ IHVuc2lnbmVkIGludCBsZW4sIHU4ICpvdXQpCi17Ci0Ja2VybmVsX25lb25fYmVnaW4oKTsKLQlz aGEyNTZfYmFzZV9kb19maW51cChkZXNjLCBkYXRhLCBsZW4sIHNoYTJfY2VfdHJhbnNmb3JtKTsK LQlrZXJuZWxfbmVvbl9lbmQoKTsKLQlyZXR1cm4gc2hhMjU2X2Jhc2VfZmluaXNoKGRlc2MsIG91 dCk7Ci19Ci0KLXN0YXRpYyBzdHJ1Y3Qgc2hhc2hfYWxnIGFsZ3NbXSA9IHsgewotCS5pbml0CQkJ PSBzaGEyMjRfYmFzZV9pbml0LAotCS51cGRhdGUJCQk9IHNoYTJfY2VfdXBkYXRlLAotCS5maW51 cAkJCT0gc2hhMl9jZV9maW51cCwKLQkuZGVzY3NpemUJCT0gc2l6ZW9mKHN0cnVjdCBjcnlwdG9f c2hhMjU2X3N0YXRlKSwKLQkuZGlnZXN0c2l6ZQkJPSBTSEEyMjRfRElHRVNUX1NJWkUsCi0JLmJh c2UJCQk9IHsKLQkJLmNyYV9uYW1lCQk9ICJzaGEyMjQiLAotCQkuY3JhX2RyaXZlcl9uYW1lCT0g InNoYTIyNC1jZSIsCi0JCS5jcmFfcHJpb3JpdHkJCT0gMzAwLAotCQkuY3JhX2ZsYWdzCQk9IENS WVBUT19BSEFTSF9BTEdfQkxPQ0tfT05MWSB8Ci0JCQkJCSAgQ1JZUFRPX0FIQVNIX0FMR19GSU5V UF9NQVgsCi0JCS5jcmFfYmxvY2tzaXplCQk9IFNIQTI1Nl9CTE9DS19TSVpFLAotCQkuY3JhX21v ZHVsZQkJPSBUSElTX01PRFVMRSwKLQl9Ci19LCB7Ci0JLmluaXQJCQk9IHNoYTI1Nl9iYXNlX2lu aXQsCi0JLnVwZGF0ZQkJCT0gc2hhMl9jZV91cGRhdGUsCi0JLmZpbnVwCQkJPSBzaGEyX2NlX2Zp bnVwLAotCS5kZXNjc2l6ZQkJPSBzaXplb2Yoc3RydWN0IGNyeXB0b19zaGEyNTZfc3RhdGUpLAot CS5kaWdlc3RzaXplCQk9IFNIQTI1Nl9ESUdFU1RfU0laRSwKLQkuYmFzZQkJCT0gewotCQkuY3Jh X25hbWUJCT0gInNoYTI1NiIsCi0JCS5jcmFfZHJpdmVyX25hbWUJPSAic2hhMjU2LWNlIiwKLQkJ LmNyYV9wcmlvcml0eQkJPSAzMDAsCi0JCS5jcmFfZmxhZ3MJCT0gQ1JZUFRPX0FIQVNIX0FMR19C TE9DS19PTkxZIHwKLQkJCQkJICBDUllQVE9fQUhBU0hfQUxHX0ZJTlVQX01BWCwKLQkJLmNyYV9i bG9ja3NpemUJCT0gU0hBMjU2X0JMT0NLX1NJWkUsCi0JCS5jcmFfbW9kdWxlCQk9IFRISVNfTU9E VUxFLAotCX0KLX0gfTsKLQotc3RhdGljIGludCBfX2luaXQgc2hhMl9jZV9tb2RfaW5pdCh2b2lk KQotewotCXJldHVybiBjcnlwdG9fcmVnaXN0ZXJfc2hhc2hlcyhhbGdzLCBBUlJBWV9TSVpFKGFs Z3MpKTsKLX0KLQotc3RhdGljIHZvaWQgX19leGl0IHNoYTJfY2VfbW9kX2Zpbmkodm9pZCkKLXsK LQljcnlwdG9fdW5yZWdpc3Rlcl9zaGFzaGVzKGFsZ3MsIEFSUkFZX1NJWkUoYWxncykpOwotfQot Ci1tb2R1bGVfY3B1X2ZlYXR1cmVfbWF0Y2goU0hBMiwgc2hhMl9jZV9tb2RfaW5pdCk7Ci1tb2R1 bGVfZXhpdChzaGEyX2NlX21vZF9maW5pKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NyeXB0by9z aGEyNTZfZ2x1ZS5jIGIvYXJjaC9hcm0vY3J5cHRvL3NoYTI1Nl9nbHVlLmMKZGVsZXRlZCBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IGQwNGM0ZTZiYWU2ZDMuLjAwMDAwMDAwMDAwMDAKLS0tIGEvYXJj aC9hcm0vY3J5cHRvL3NoYTI1Nl9nbHVlLmMKKysrIC9kZXYvbnVsbApAQCAtMSwxMDcgKzAsMCBA QAotLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb3ItbGF0ZXIKLS8qCi0gKiBH bHVlIGNvZGUgZm9yIHRoZSBTSEEyNTYgU2VjdXJlIEhhc2ggQWxnb3JpdGhtIGFzc2VtYmx5IGlt cGxlbWVudGF0aW9uCi0gKiB1c2luZyBvcHRpbWl6ZWQgQVJNIGFzc2VtYmxlciBhbmQgTkVPTiBp bnN0cnVjdGlvbnMuCi0gKgotICogQ29weXJpZ2h0IMKpIDIwMTUgR29vZ2xlIEluYy4KLSAqCi0g KiBUaGlzIGZpbGUgaXMgYmFzZWQgb24gc2hhMjU2X3Nzc2UzX2dsdWUuYzoKLSAqICAgQ29weXJp Z2h0IChDKSAyMDEzIEludGVsIENvcnBvcmF0aW9uCi0gKiAgIEF1dGhvcjogVGltIENoZW4gPHRp bS5jLmNoZW5AbGludXguaW50ZWwuY29tPgotICovCi0KLSNpbmNsdWRlIDxhc20vbmVvbi5oPgot I2luY2x1ZGUgPGNyeXB0by9pbnRlcm5hbC9oYXNoLmg+Ci0jaW5jbHVkZSA8Y3J5cHRvL3NoYTIu aD4KLSNpbmNsdWRlIDxjcnlwdG8vc2hhMjU2X2Jhc2UuaD4KLSNpbmNsdWRlIDxsaW51eC9rZXJu ZWwuaD4KLSNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KLQotI2luY2x1ZGUgInNoYTI1Nl9nbHVl LmgiCi0KLWFzbWxpbmthZ2Ugdm9pZCBzaGEyNTZfYmxvY2tfZGF0YV9vcmRlcihzdHJ1Y3QgY3J5 cHRvX3NoYTI1Nl9zdGF0ZSAqc3RhdGUsCi0JCQkJCWNvbnN0IHU4ICpkYXRhLCBpbnQgbnVtX2Js a3MpOwotCi1zdGF0aWMgaW50IGNyeXB0b19zaGEyNTZfYXJtX3VwZGF0ZShzdHJ1Y3Qgc2hhc2hf ZGVzYyAqZGVzYywgY29uc3QgdTggKmRhdGEsCi0JCQkJICAgIHVuc2lnbmVkIGludCBsZW4pCi17 Ci0JLyogbWFrZSBzdXJlIGNhc3RpbmcgdG8gc2hhMjU2X2Jsb2NrX2ZuKCkgaXMgc2FmZSAqLwot CUJVSUxEX0JVR19PTihvZmZzZXRvZihzdHJ1Y3QgY3J5cHRvX3NoYTI1Nl9zdGF0ZSwgc3RhdGUp ICE9IDApOwotCi0JcmV0dXJuIHNoYTI1Nl9iYXNlX2RvX3VwZGF0ZV9ibG9ja3MoZGVzYywgZGF0 YSwgbGVuLAotCQkJCQkgICAgc2hhMjU2X2Jsb2NrX2RhdGFfb3JkZXIpOwotfQotCi1zdGF0aWMg aW50IGNyeXB0b19zaGEyNTZfYXJtX2ZpbnVwKHN0cnVjdCBzaGFzaF9kZXNjICpkZXNjLCBjb25z dCB1OCAqZGF0YSwKLQkJCQkgICB1bnNpZ25lZCBpbnQgbGVuLCB1OCAqb3V0KQotewotCXNoYTI1 Nl9iYXNlX2RvX2ZpbnVwKGRlc2MsIGRhdGEsIGxlbiwgc2hhMjU2X2Jsb2NrX2RhdGFfb3JkZXIp OwotCXJldHVybiBzaGEyNTZfYmFzZV9maW5pc2goZGVzYywgb3V0KTsKLX0KLQotc3RhdGljIHN0 cnVjdCBzaGFzaF9hbGcgYWxnc1tdID0geyB7Ci0JLmRpZ2VzdHNpemUJPQlTSEEyNTZfRElHRVNU X1NJWkUsCi0JLmluaXQJCT0Jc2hhMjU2X2Jhc2VfaW5pdCwKLQkudXBkYXRlCQk9CWNyeXB0b19z aGEyNTZfYXJtX3VwZGF0ZSwKLQkuZmludXAJCT0JY3J5cHRvX3NoYTI1Nl9hcm1fZmludXAsCi0J LmRlc2NzaXplCT0Jc2l6ZW9mKHN0cnVjdCBjcnlwdG9fc2hhMjU2X3N0YXRlKSwKLQkuYmFzZQkJ PQl7Ci0JCS5jcmFfbmFtZQk9CSJzaGEyNTYiLAotCQkuY3JhX2RyaXZlcl9uYW1lID0JInNoYTI1 Ni1hc20iLAotCQkuY3JhX3ByaW9yaXR5CT0JMTUwLAotCQkuY3JhX2ZsYWdzCT0JQ1JZUFRPX0FI QVNIX0FMR19CTE9DS19PTkxZIHwKLQkJCQkJQ1JZUFRPX0FIQVNIX0FMR19GSU5VUF9NQVgsCi0J CS5jcmFfYmxvY2tzaXplCT0JU0hBMjU2X0JMT0NLX1NJWkUsCi0JCS5jcmFfbW9kdWxlCT0JVEhJ U19NT0RVTEUsCi0JfQotfSwgewotCS5kaWdlc3RzaXplCT0JU0hBMjI0X0RJR0VTVF9TSVpFLAot CS5pbml0CQk9CXNoYTIyNF9iYXNlX2luaXQsCi0JLnVwZGF0ZQkJPQljcnlwdG9fc2hhMjU2X2Fy bV91cGRhdGUsCi0JLmZpbnVwCQk9CWNyeXB0b19zaGEyNTZfYXJtX2ZpbnVwLAotCS5kZXNjc2l6 ZQk9CXNpemVvZihzdHJ1Y3QgY3J5cHRvX3NoYTI1Nl9zdGF0ZSksCi0JLmJhc2UJCT0JewotCQku Y3JhX25hbWUJPQkic2hhMjI0IiwKLQkJLmNyYV9kcml2ZXJfbmFtZSA9CSJzaGEyMjQtYXNtIiwK LQkJLmNyYV9wcmlvcml0eQk9CTE1MCwKLQkJLmNyYV9mbGFncwk9CUNSWVBUT19BSEFTSF9BTEdf QkxPQ0tfT05MWSB8Ci0JCQkJCUNSWVBUT19BSEFTSF9BTEdfRklOVVBfTUFYLAotCQkuY3JhX2Js b2Nrc2l6ZQk9CVNIQTIyNF9CTE9DS19TSVpFLAotCQkuY3JhX21vZHVsZQk9CVRISVNfTU9EVUxF LAotCX0KLX0gfTsKLQotc3RhdGljIGludCBfX2luaXQgc2hhMjU2X21vZF9pbml0KHZvaWQpCi17 Ci0JaW50IHJlcyA9IGNyeXB0b19yZWdpc3Rlcl9zaGFzaGVzKGFsZ3MsIEFSUkFZX1NJWkUoYWxn cykpOwotCi0JaWYgKHJlcyA8IDApCi0JCXJldHVybiByZXM7Ci0KLQlpZiAoSVNfRU5BQkxFRChD T05GSUdfS0VSTkVMX01PREVfTkVPTikgJiYgY3B1X2hhc19uZW9uKCkpIHsKLQkJcmVzID0gY3J5 cHRvX3JlZ2lzdGVyX3NoYXNoZXMoc2hhMjU2X25lb25fYWxncywKLQkJCQkJICAgICAgQVJSQVlf U0laRShzaGEyNTZfbmVvbl9hbGdzKSk7Ci0KLQkJaWYgKHJlcyA8IDApCi0JCQljcnlwdG9fdW5y ZWdpc3Rlcl9zaGFzaGVzKGFsZ3MsIEFSUkFZX1NJWkUoYWxncykpOwotCX0KLQotCXJldHVybiBy ZXM7Ci19Ci0KLXN0YXRpYyB2b2lkIF9fZXhpdCBzaGEyNTZfbW9kX2Zpbmkodm9pZCkKLXsKLQlj cnlwdG9fdW5yZWdpc3Rlcl9zaGFzaGVzKGFsZ3MsIEFSUkFZX1NJWkUoYWxncykpOwotCi0JaWYg KElTX0VOQUJMRUQoQ09ORklHX0tFUk5FTF9NT0RFX05FT04pICYmIGNwdV9oYXNfbmVvbigpKQot CQljcnlwdG9fdW5yZWdpc3Rlcl9zaGFzaGVzKHNoYTI1Nl9uZW9uX2FsZ3MsCi0JCQkJCSAgQVJS QVlfU0laRShzaGEyNTZfbmVvbl9hbGdzKSk7Ci19Ci0KLW1vZHVsZV9pbml0KHNoYTI1Nl9tb2Rf aW5pdCk7Ci1tb2R1bGVfZXhpdChzaGEyNTZfbW9kX2ZpbmkpOwotCi1NT0RVTEVfTElDRU5TRSgi R1BMIik7Ci1NT0RVTEVfREVTQ1JJUFRJT04oIlNIQTI1NiBTZWN1cmUgSGFzaCBBbGdvcml0aG0g KEFSTSksIGluY2x1ZGluZyBORU9OIik7Ci0KLU1PRFVMRV9BTElBU19DUllQVE8oInNoYTI1NiIp OwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY3J5cHRvL3NoYTI1Nl9nbHVlLmggYi9hcmNoL2FybS9j cnlwdG8vc2hhMjU2X2dsdWUuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTg4MWM5 YTExNWQxZi4uMDAwMDAwMDAwMDAwMAotLS0gYS9hcmNoL2FybS9jcnlwdG8vc2hhMjU2X2dsdWUu aAorKysgL2Rldi9udWxsCkBAIC0xLDkgKzAsMCBAQAotLyogU1BEWC1MaWNlbnNlLUlkZW50aWZp ZXI6IEdQTC0yLjAgKi8KLSNpZm5kZWYgX0NSWVBUT19TSEEyNTZfR0xVRV9ICi0jZGVmaW5lIF9D UllQVE9fU0hBMjU2X0dMVUVfSAotCi0jaW5jbHVkZSA8Y3J5cHRvL2hhc2guaD4KLQotZXh0ZXJu IHN0cnVjdCBzaGFzaF9hbGcgc2hhMjU2X25lb25fYWxnc1syXTsKLQotI2VuZGlmIC8qIF9DUllQ VE9fU0hBMjU2X0dMVUVfSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY3J5cHRvL3NoYTI1Nl9u ZW9uX2dsdWUuYyBiL2FyY2gvYXJtL2NyeXB0by9zaGEyNTZfbmVvbl9nbHVlLmMKZGVsZXRlZCBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDc2ZWIzY2RjMjFjOTYuLjAwMDAwMDAwMDAwMDAKLS0tIGEv YXJjaC9hcm0vY3J5cHRvL3NoYTI1Nl9uZW9uX2dsdWUuYworKysgL2Rldi9udWxsCkBAIC0xLDc1 ICswLDAgQEAKLS8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9yLWxhdGVyCi0v KgotICogR2x1ZSBjb2RlIGZvciB0aGUgU0hBMjU2IFNlY3VyZSBIYXNoIEFsZ29yaXRobSBhc3Nl bWJseSBpbXBsZW1lbnRhdGlvbgotICogdXNpbmcgTkVPTiBpbnN0cnVjdGlvbnMuCi0gKgotICog Q29weXJpZ2h0IMKpIDIwMTUgR29vZ2xlIEluYy4KLSAqCi0gKiBUaGlzIGZpbGUgaXMgYmFzZWQg b24gc2hhNTEyX25lb25fZ2x1ZS5jOgotICogICBDb3B5cmlnaHQgwqkgMjAxNCBKdXNzaSBLaXZp bGlubmEgPGp1c3NpLmtpdmlsaW5uYUBpa2kuZmk+Ci0gKi8KLQotI2luY2x1ZGUgPGFzbS9uZW9u Lmg+Ci0jaW5jbHVkZSA8Y3J5cHRvL2ludGVybmFsL2hhc2guaD4KLSNpbmNsdWRlIDxjcnlwdG8v c2hhMi5oPgotI2luY2x1ZGUgPGNyeXB0by9zaGEyNTZfYmFzZS5oPgotI2luY2x1ZGUgPGxpbnV4 L2tlcm5lbC5oPgotI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgotCi0jaW5jbHVkZSAic2hhMjU2 X2dsdWUuaCIKLQotYXNtbGlua2FnZSB2b2lkIHNoYTI1Nl9ibG9ja19kYXRhX29yZGVyX25lb24o Ci0Jc3RydWN0IGNyeXB0b19zaGEyNTZfc3RhdGUgKmRpZ2VzdCwgY29uc3QgdTggKmRhdGEsIGlu dCBudW1fYmxrcyk7Ci0KLXN0YXRpYyBpbnQgY3J5cHRvX3NoYTI1Nl9uZW9uX3VwZGF0ZShzdHJ1 Y3Qgc2hhc2hfZGVzYyAqZGVzYywgY29uc3QgdTggKmRhdGEsCi0JCQkJICAgICB1bnNpZ25lZCBp bnQgbGVuKQotewotCWludCByZW1haW47Ci0KLQlrZXJuZWxfbmVvbl9iZWdpbigpOwotCXJlbWFp biA9IHNoYTI1Nl9iYXNlX2RvX3VwZGF0ZV9ibG9ja3MoZGVzYywgZGF0YSwgbGVuLAotCQkJCQkg ICAgICBzaGEyNTZfYmxvY2tfZGF0YV9vcmRlcl9uZW9uKTsKLQlrZXJuZWxfbmVvbl9lbmQoKTsK LQlyZXR1cm4gcmVtYWluOwotfQotCi1zdGF0aWMgaW50IGNyeXB0b19zaGEyNTZfbmVvbl9maW51 cChzdHJ1Y3Qgc2hhc2hfZGVzYyAqZGVzYywgY29uc3QgdTggKmRhdGEsCi0JCQkJICAgIHVuc2ln bmVkIGludCBsZW4sIHU4ICpvdXQpCi17Ci0Ja2VybmVsX25lb25fYmVnaW4oKTsKLQlzaGEyNTZf YmFzZV9kb19maW51cChkZXNjLCBkYXRhLCBsZW4sIHNoYTI1Nl9ibG9ja19kYXRhX29yZGVyX25l b24pOwotCWtlcm5lbF9uZW9uX2VuZCgpOwotCXJldHVybiBzaGEyNTZfYmFzZV9maW5pc2goZGVz Yywgb3V0KTsKLX0KLQotc3RydWN0IHNoYXNoX2FsZyBzaGEyNTZfbmVvbl9hbGdzW10gPSB7IHsK LQkuZGlnZXN0c2l6ZQk9CVNIQTI1Nl9ESUdFU1RfU0laRSwKLQkuaW5pdAkJPQlzaGEyNTZfYmFz ZV9pbml0LAotCS51cGRhdGUJCT0JY3J5cHRvX3NoYTI1Nl9uZW9uX3VwZGF0ZSwKLQkuZmludXAJ CT0JY3J5cHRvX3NoYTI1Nl9uZW9uX2ZpbnVwLAotCS5kZXNjc2l6ZQk9CXNpemVvZihzdHJ1Y3Qg Y3J5cHRvX3NoYTI1Nl9zdGF0ZSksCi0JLmJhc2UJCT0JewotCQkuY3JhX25hbWUJPQkic2hhMjU2 IiwKLQkJLmNyYV9kcml2ZXJfbmFtZSA9CSJzaGEyNTYtbmVvbiIsCi0JCS5jcmFfcHJpb3JpdHkJ PQkyNTAsCi0JCS5jcmFfZmxhZ3MJPQlDUllQVE9fQUhBU0hfQUxHX0JMT0NLX09OTFkgfAotCQkJ CQlDUllQVE9fQUhBU0hfQUxHX0ZJTlVQX01BWCwKLQkJLmNyYV9ibG9ja3NpemUJPQlTSEEyNTZf QkxPQ0tfU0laRSwKLQkJLmNyYV9tb2R1bGUJPQlUSElTX01PRFVMRSwKLQl9Ci19LCB7Ci0JLmRp Z2VzdHNpemUJPQlTSEEyMjRfRElHRVNUX1NJWkUsCi0JLmluaXQJCT0Jc2hhMjI0X2Jhc2VfaW5p dCwKLQkudXBkYXRlCQk9CWNyeXB0b19zaGEyNTZfbmVvbl91cGRhdGUsCi0JLmZpbnVwCQk9CWNy eXB0b19zaGEyNTZfbmVvbl9maW51cCwKLQkuZGVzY3NpemUJPQlzaXplb2Yoc3RydWN0IGNyeXB0 b19zaGEyNTZfc3RhdGUpLAotCS5iYXNlCQk9CXsKLQkJLmNyYV9uYW1lCT0JInNoYTIyNCIsCi0J CS5jcmFfZHJpdmVyX25hbWUgPQkic2hhMjI0LW5lb24iLAotCQkuY3JhX3ByaW9yaXR5CT0JMjUw LAotCQkuY3JhX2ZsYWdzCT0JQ1JZUFRPX0FIQVNIX0FMR19CTE9DS19PTkxZIHwKLQkJCQkJQ1JZ UFRPX0FIQVNIX0FMR19GSU5VUF9NQVgsCi0JCS5jcmFfYmxvY2tzaXplCT0JU0hBMjI0X0JMT0NL X1NJWkUsCi0JCS5jcmFfbW9kdWxlCT0JVEhJU19NT0RVTEUsCi0JfQotfSB9OwpkaWZmIC0tZ2l0 IGEvYXJjaC9hcm0vbGliL2NyeXB0by8uZ2l0aWdub3JlIGIvYXJjaC9hcm0vbGliL2NyeXB0by8u Z2l0aWdub3JlCmluZGV4IDBkNDdkNGYyMWM2ZGUuLjEyZDc0ZDhiMDNkMGEgMTAwNjQ0Ci0tLSBh L2FyY2gvYXJtL2xpYi9jcnlwdG8vLmdpdGlnbm9yZQorKysgYi9hcmNoL2FybS9saWIvY3J5cHRv Ly5naXRpZ25vcmUKQEAgLTEsMiArMSwzIEBACiAjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBH UEwtMi4wLW9ubHkKIHBvbHkxMzA1LWNvcmUuUworc2hhMjU2LWNvcmUuUwpkaWZmIC0tZ2l0IGEv YXJjaC9hcm0vbGliL2NyeXB0by9LY29uZmlnIGIvYXJjaC9hcm0vbGliL2NyeXB0by9LY29uZmln CmluZGV4IGU4NDQ0ZmQwYWFlMzAuLjlmM2ZmMzBmNDAzMjggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJt L2xpYi9jcnlwdG8vS2NvbmZpZworKysgYi9hcmNoL2FybS9saWIvY3J5cHRvL0tjb25maWcKQEAg LTIwLDUgKzIwLDExIEBAIGNvbmZpZyBDUllQVE9fQ0hBQ0hBMjBfTkVPTgogCiBjb25maWcgQ1JZ UFRPX1BPTFkxMzA1X0FSTQogCXRyaXN0YXRlCiAJZGVmYXVsdCBDUllQVE9fTElCX1BPTFkxMzA1 CiAJc2VsZWN0IENSWVBUT19BUkNIX0hBVkVfTElCX1BPTFkxMzA1CisKK2NvbmZpZyBDUllQVE9f U0hBMjU2X0FSTQorCXRyaXN0YXRlCisJZGVwZW5kcyBvbiAhQ1BVX1Y3TQorCWRlZmF1bHQgQ1JZ UFRPX0xJQl9TSEEyNTYKKwlzZWxlY3QgQ1JZUFRPX0FSQ0hfSEFWRV9MSUJfU0hBMjU2CmRpZmYg LS1naXQgYS9hcmNoL2FybS9saWIvY3J5cHRvL01ha2VmaWxlIGIvYXJjaC9hcm0vbGliL2NyeXB0 by9NYWtlZmlsZQppbmRleCA0YzA0MmE0Yzc3ZWQ2Li40MzFmNzdjM2ZmNmZkIDEwMDY0NAotLS0g YS9hcmNoL2FybS9saWIvY3J5cHRvL01ha2VmaWxlCisrKyBiL2FyY2gvYXJtL2xpYi9jcnlwdG8v TWFrZWZpbGUKQEAgLTgsMTkgKzgsMjUgQEAgY2hhY2hhLW5lb24teSA6PSBjaGFjaGEtc2NhbGFy LWNvcmUubyBjaGFjaGEtZ2x1ZS5vCiBjaGFjaGEtbmVvbi0kKENPTkZJR19LRVJORUxfTU9ERV9O RU9OKSArPSBjaGFjaGEtbmVvbi1jb3JlLm8KIAogb2JqLSQoQ09ORklHX0NSWVBUT19QT0xZMTMw NV9BUk0pICs9IHBvbHkxMzA1LWFybS5vCiBwb2x5MTMwNS1hcm0teSA6PSBwb2x5MTMwNS1jb3Jl Lm8gcG9seTEzMDUtZ2x1ZS5vCiAKK29iai0kKENPTkZJR19DUllQVE9fU0hBMjU2X0FSTSkgKz0g c2hhMjU2LWFybS5vCitzaGEyNTYtYXJtLXkgOj0gc2hhMjU2Lm8gc2hhMjU2LWNvcmUubworc2hh MjU2LWFybS0kKENPTkZJR19LRVJORUxfTU9ERV9ORU9OKSArPSBzaGEyNTYtY2UubworCiBxdWll dF9jbWRfcGVybCA9IFBFUkwgICAgJEAKICAgICAgIGNtZF9wZXJsID0gJChQRVJMKSAkKDwpID4g JChAKQogCiAkKG9iaikvJS1jb3JlLlM6ICQoc3JjKS8lLWFybXY0LnBsCiAJJChjYWxsIGNtZCxw ZXJsKQogCi1jbGVhbi1maWxlcyArPSBwb2x5MTMwNS1jb3JlLlMKK2NsZWFuLWZpbGVzICs9IHBv bHkxMzA1LWNvcmUuUyBzaGEyNTYtY29yZS5TCiAKIGFmbGFncy10aHVtYjItJChDT05GSUdfVEhV TUIyX0tFUk5FTCkgIDo9IC1VX190aHVtYjJfXyAtRF9fdGh1bWIyX189MQogCiAjIG1hc3NhZ2Ug dGhlIHBlcmxhc20gY29kZSBhIGJpdCBzbyB3ZSBvbmx5IGdldCB0aGUgTkVPTiByb3V0aW5lIGlm IHdlIG5lZWQgaXQKIHBvbHkxMzA1LWFmbGFncy0kKENPTkZJR19DUFVfVjcpIDo9IC1VX19MSU5V WF9BUk1fQVJDSF9fIC1EX19MSU5VWF9BUk1fQVJDSF9fPTUKIHBvbHkxMzA1LWFmbGFncy0kKENP TkZJR19LRVJORUxfTU9ERV9ORU9OKSA6PSAtVV9fTElOVVhfQVJNX0FSQ0hfXyAtRF9fTElOVVhf QVJNX0FSQ0hfXz03CiBBRkxBR1NfcG9seTEzMDUtY29yZS5vICs9ICQocG9seTEzMDUtYWZsYWdz LXkpICQoYWZsYWdzLXRodW1iMi15KQorCitBRkxBR1Nfc2hhMjU2LWNvcmUubyArPSAkKGFmbGFn cy10aHVtYjIteSkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NyeXB0by9zaGEyNTYtYXJtdjQucGwg Yi9hcmNoL2FybS9saWIvY3J5cHRvL3NoYTI1Ni1hcm12NC5wbApzaW1pbGFyaXR5IGluZGV4IDEw MCUKcmVuYW1lIGZyb20gYXJjaC9hcm0vY3J5cHRvL3NoYTI1Ni1hcm12NC5wbApyZW5hbWUgdG8g YXJjaC9hcm0vbGliL2NyeXB0by9zaGEyNTYtYXJtdjQucGwKZGlmZiAtLWdpdCBhL2FyY2gvYXJt L2NyeXB0by9zaGEyLWNlLWNvcmUuUyBiL2FyY2gvYXJtL2xpYi9jcnlwdG8vc2hhMjU2LWNlLlMK c2ltaWxhcml0eSBpbmRleCA5MSUKcmVuYW1lIGZyb20gYXJjaC9hcm0vY3J5cHRvL3NoYTItY2Ut Y29yZS5TCnJlbmFtZSB0byBhcmNoL2FybS9saWIvY3J5cHRvL3NoYTI1Ni1jZS5TCmluZGV4IGI2 MzY5ZDI0NDBhMTkuLmFjMmM5YjAxYjIyZDIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NyeXB0by9z aGEyLWNlLWNvcmUuUworKysgYi9hcmNoL2FybS9saWIvY3J5cHRvL3NoYTI1Ni1jZS5TCkBAIC0x LDggKzEsOCBAQAogLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb25seSAqLwog LyoKLSAqIHNoYTItY2UtY29yZS5TIC0gU0hBLTIyNC8yNTYgc2VjdXJlIGhhc2ggdXNpbmcgQVJN djggQ3J5cHRvIEV4dGVuc2lvbnMKKyAqIHNoYTI1Ni1jZS5TIC0gU0hBLTIyNC8yNTYgc2VjdXJl IGhhc2ggdXNpbmcgQVJNdjggQ3J5cHRvIEV4dGVuc2lvbnMKICAqCiAgKiBDb3B5cmlnaHQgKEMp IDIwMTUgTGluYXJvIEx0ZC4KICAqIEF1dGhvcjogQXJkIEJpZXNoZXV2ZWwgPGFyZC5iaWVzaGV1 dmVsQGxpbmFyby5vcmc+CiAgKi8KIApAQCAtNjUsMTQgKzY1LDE0IEBACiAJLndvcmQJCTB4Mzkx YzBjYjMsIDB4NGVkOGFhNGEsIDB4NWI5Y2NhNGYsIDB4NjgyZTZmZjMKIAkud29yZAkJMHg3NDhm ODJlZSwgMHg3OGE1NjM2ZiwgMHg4NGM4NzgxNCwgMHg4Y2M3MDIwOAogCS53b3JkCQkweDkwYmVm ZmZhLCAweGE0NTA2Y2ViLCAweGJlZjlhM2Y3LCAweGM2NzE3OGYyCiAKIAkvKgotCSAqIHZvaWQg c2hhMl9jZV90cmFuc2Zvcm0oc3RydWN0IHNoYTI1Nl9zdGF0ZSAqc3N0LCB1OCBjb25zdCAqc3Jj LAotCQkJCSAgaW50IGJsb2Nrcyk7CisJICogdm9pZCBzaGEyNTZfY2VfdHJhbnNmb3JtKHUzMiBz dGF0ZVtTSEEyNTZfU1RBVEVfV09SRFNdLAorCSAqCQkJICAgIGNvbnN0IHU4ICpkYXRhLCBzaXpl X3QgbmJsb2Nrcyk7CiAJICovCi1FTlRSWShzaGEyX2NlX3RyYW5zZm9ybSkKK0VOVFJZKHNoYTI1 Nl9jZV90cmFuc2Zvcm0pCiAJLyogbG9hZCBzdGF0ZSAqLwogCXZsZDEuMzIJCXtkZ2EtZGdifSwg W3IwXQogCiAJLyogbG9hZCBpbnB1dCAqLwogMDoJdmxkMS4zMgkJe3EwLXExfSwgW3IxXSEKQEAg LTExOCw2ICsxMTgsNiBAQCBFTlRSWShzaGEyX2NlX3RyYW5zZm9ybSkKIAlibmUJCTBiCiAKIAkv KiBzdG9yZSBuZXcgc3RhdGUgKi8KIAl2c3QxLjMyCQl7ZGdhLWRnYn0sIFtyMF0KIAlieAkJbHIK LUVORFBST0Moc2hhMl9jZV90cmFuc2Zvcm0pCitFTkRQUk9DKHNoYTI1Nl9jZV90cmFuc2Zvcm0p CmRpZmYgLS1naXQgYS9hcmNoL2FybS9saWIvY3J5cHRvL3NoYTI1Ni5jIGIvYXJjaC9hcm0vbGli L2NyeXB0by9zaGEyNTYuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw Li4zYThkZmMzMDQ4MDdhCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9hcm0vbGliL2NyeXB0by9z aGEyNTYuYwpAQCAtMCwwICsxLDY0IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BM LTIuMC1vci1sYXRlcgorLyoKKyAqIFNIQS0yNTYgb3B0aW1pemVkIGZvciBBUk0KKyAqCisgKiBD b3B5cmlnaHQgMjAyNSBHb29nbGUgTExDCisgKi8KKyNpbmNsdWRlIDxhc20vbmVvbi5oPgorI2lu Y2x1ZGUgPGNyeXB0by9pbnRlcm5hbC9zaGEyLmg+CisjaW5jbHVkZSA8Y3J5cHRvL2ludGVybmFs L3NpbWQuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1 bGUuaD4KKworYXNtbGlua2FnZSB2b2lkIHNoYTI1Nl9ibG9ja19kYXRhX29yZGVyKHUzMiBzdGF0 ZVtTSEEyNTZfU1RBVEVfV09SRFNdLAorCQkJCQljb25zdCB1OCAqZGF0YSwgc2l6ZV90IG5ibG9j a3MpOworYXNtbGlua2FnZSB2b2lkIHNoYTI1Nl9ibG9ja19kYXRhX29yZGVyX25lb24odTMyIHN0 YXRlW1NIQTI1Nl9TVEFURV9XT1JEU10sCisJCQkJCSAgICAgY29uc3QgdTggKmRhdGEsIHNpemVf dCBuYmxvY2tzKTsKK2FzbWxpbmthZ2Ugdm9pZCBzaGEyNTZfY2VfdHJhbnNmb3JtKHUzMiBzdGF0 ZVtTSEEyNTZfU1RBVEVfV09SRFNdLAorCQkJCSAgICBjb25zdCB1OCAqZGF0YSwgc2l6ZV90IG5i bG9ja3MpOworCitzdGF0aWMgX19yb19hZnRlcl9pbml0IERFRklORV9TVEFUSUNfS0VZX0ZBTFNF KGhhdmVfbmVvbik7CitzdGF0aWMgX19yb19hZnRlcl9pbml0IERFRklORV9TVEFUSUNfS0VZX0ZB TFNFKGhhdmVfY2UpOworCit2b2lkIHNoYTI1Nl9ibG9ja3NfYXJjaCh1MzIgc3RhdGVbU0hBMjU2 X1NUQVRFX1dPUkRTXSwKKwkJCWNvbnN0IHU4ICpkYXRhLCBzaXplX3QgbmJsb2NrcykKK3sKKwlp ZiAoSVNfRU5BQkxFRChDT05GSUdfS0VSTkVMX01PREVfTkVPTikgJiYKKwkgICAgc3RhdGljX2Jy YW5jaF9saWtlbHkoJmhhdmVfbmVvbikgJiYgY3J5cHRvX3NpbWRfdXNhYmxlKCkpIHsKKwkJa2Vy bmVsX25lb25fYmVnaW4oKTsKKwkJaWYgKHN0YXRpY19icmFuY2hfbGlrZWx5KCZoYXZlX2NlKSkK KwkJCXNoYTI1Nl9jZV90cmFuc2Zvcm0oc3RhdGUsIGRhdGEsIG5ibG9ja3MpOworCQllbHNlCisJ CQlzaGEyNTZfYmxvY2tfZGF0YV9vcmRlcl9uZW9uKHN0YXRlLCBkYXRhLCBuYmxvY2tzKTsKKwkJ a2VybmVsX25lb25fZW5kKCk7CisJfSBlbHNlIHsKKwkJc2hhMjU2X2Jsb2NrX2RhdGFfb3JkZXIo c3RhdGUsIGRhdGEsIG5ibG9ja3MpOworCX0KK30KK0VYUE9SVF9TWU1CT0woc2hhMjU2X2Jsb2Nr c19hcmNoKTsKKworYm9vbCBzaGEyNTZfaXNfYXJjaF9vcHRpbWl6ZWQodm9pZCkKK3sKKwkvKiBX ZSBhbHdheXMgY2FuIHVzZSBhdCBsZWFzdCB0aGUgQVJNIHNjYWxhciBpbXBsZW1lbnRhdGlvbi4g Ki8KKwlyZXR1cm4gdHJ1ZTsKK30KK0VYUE9SVF9TWU1CT0woc2hhMjU2X2lzX2FyY2hfb3B0aW1p emVkKTsKKworc3RhdGljIGludCBfX2luaXQgc2hhMjU2X2FybV9tb2RfaW5pdCh2b2lkKQorewor CWlmIChJU19FTkFCTEVEKENPTkZJR19LRVJORUxfTU9ERV9ORU9OKSAmJiAoZWxmX2h3Y2FwICYg SFdDQVBfTkVPTikpIHsKKwkJc3RhdGljX2JyYW5jaF9lbmFibGUoJmhhdmVfbmVvbik7CisJCWlm IChlbGZfaHdjYXAyICYgSFdDQVAyX1NIQTIpCisJCQlzdGF0aWNfYnJhbmNoX2VuYWJsZSgmaGF2 ZV9jZSk7CisJfQorCXJldHVybiAwOworfQorYXJjaF9pbml0Y2FsbChzaGEyNTZfYXJtX21vZF9p bml0KTsKKworc3RhdGljIHZvaWQgX19leGl0IHNoYTI1Nl9hcm1fbW9kX2V4aXQodm9pZCkKK3sK K30KK21vZHVsZV9leGl0KHNoYTI1Nl9hcm1fbW9kX2V4aXQpOworCitNT0RVTEVfTElDRU5TRSgi R1BMIik7CitNT0RVTEVfREVTQ1JJUFRJT04oIlNIQS0yNTYgb3B0aW1pemVkIGZvciBBUk0iKTsK LS0gCjIuNDkuMAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCmxpbnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQu b3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcmlz Y3YK