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 8422310958; Tue, 2 Jan 2024 06:50:44 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Ud9Xwg93" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D0F1AC43391; Tue, 2 Jan 2024 06:50:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1704178244; bh=AitJ29G3E6vFWJv2gmKjCVHjLojwFUnKnw9FBdbCvTY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Ud9Xwg93n0bFPbyv1l0V6nrphmxiLBMXyyjgV8TBcULtp1ay6cjRJEwxB+kf1sp/N j0FU8I85uyYT1b29S88MwJfITHUQTBAUS6DkNi+blWWHHDeKeW9wqUMCY6gdah10Lj cmcKNlMt5OuXsY6IevQQNXArvwtpqXD1ImN7KjQfHYR1cueyftewMdNL7l+TEmAg37 27Jc/dw7diWMG3vc60qzKLIvNTaHW39ZSo4kuDcL6jmvbrZjjubW0M51M2TvRgRmDs 9k8frjwPXWgntyKlelLcsLzj5ulT9upaefrkGWspmCx3on4X9wXu6M/TkAVzEHHGW7 qx/65lE8g+b+A== From: Eric Biggers To: linux-crypto@vger.kernel.org, linux-riscv@lists.infradead.org, Jerry Shih Cc: linux-kernel@vger.kernel.org, Ard Biesheuvel , Heiko Stuebner , Phoebe Chen , hongrong.hsu@sifive.com, Paul Walmsley , Palmer Dabbelt , Albert Ou , Andy Chiu , Charalampos Mitrodimas , Heiko Stuebner Subject: [RFC PATCH 11/13] crypto: riscv - add vector crypto accelerated SHA-{512,384} Date: Tue, 2 Jan 2024 00:47:37 -0600 Message-ID: <20240102064743.220490-12-ebiggers@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240102064743.220490-1-ebiggers@kernel.org> References: <20240102064743.220490-1-ebiggers@kernel.org> Precedence: bulk X-Mailing-List: linux-crypto@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: Jerry Shih Add an implementation of SHA-384 and SHA-512 using the Zvknhb extension. The assembly code is derived from OpenSSL code (openssl/openssl#21923) that was dual-licensed so that it could be reused in the kernel. Nevertheless, the assembly has been significantly reworked for integration with the kernel, for example by using a regular .S file instead of the so-called perlasm, using the assembler instead of bare '.inst', and greatly reducing code duplication. Co-developed-by: Charalampos Mitrodimas Signed-off-by: Charalampos Mitrodimas Co-developed-by: Heiko Stuebner Signed-off-by: Heiko Stuebner Co-developed-by: Phoebe Chen Signed-off-by: Phoebe Chen Signed-off-by: Jerry Shih Co-developed-by: Eric Biggers Signed-off-by: Eric Biggers --- arch/riscv/crypto/Kconfig | 11 + arch/riscv/crypto/Makefile | 3 + arch/riscv/crypto/sha512-riscv64-glue.c | 133 ++++++++++++ .../riscv/crypto/sha512-riscv64-zvknhb-zvkb.S | 203 ++++++++++++++++++ 4 files changed, 350 insertions(+) create mode 100644 arch/riscv/crypto/sha512-riscv64-glue.c create mode 100644 arch/riscv/crypto/sha512-riscv64-zvknhb-zvkb.S diff --git a/arch/riscv/crypto/Kconfig b/arch/riscv/crypto/Kconfig index 533bc6def123a..ca13895c3e0f6 100644 --- a/arch/riscv/crypto/Kconfig +++ b/arch/riscv/crypto/Kconfig @@ -58,11 +58,22 @@ config CRYPTO_SHA256_RISCV64 tristate "Hash functions: SHA-224 and SHA-256" depends on 64BIT && RISCV_ISA_V && TOOLCHAIN_HAS_VECTOR_CRYPTO select CRYPTO_SHA256 help SHA-224 and SHA-256 secure hash algorithm (FIPS 180) Architecture: riscv64 using: - Zvknha or Zvknhb vector crypto extensions - Zvkb vector crypto extension +config CRYPTO_SHA512_RISCV64 + tristate "Hash functions: SHA-384 and SHA-512" + depends on 64BIT && RISCV_ISA_V && TOOLCHAIN_HAS_VECTOR_CRYPTO + select CRYPTO_SHA512 + help + SHA-384 and SHA-512 secure hash algorithm (FIPS 180) + + Architecture: riscv64 using: + - Zvknhb vector crypto extension + - Zvkb vector crypto extension + endmenu diff --git a/arch/riscv/crypto/Makefile b/arch/riscv/crypto/Makefile index 28a58e89927ae..e30a1bcc788bf 100644 --- a/arch/riscv/crypto/Makefile +++ b/arch/riscv/crypto/Makefile @@ -10,10 +10,13 @@ obj-$(CONFIG_CRYPTO_AES_BLOCK_RISCV64) += aes-block-riscv64.o aes-block-riscv64-y := aes-riscv64-block-mode-glue.o aes-riscv64-zvkned-zvbb-zvkg.o aes-riscv64-zvkned-zvkb.o obj-$(CONFIG_CRYPTO_CHACHA_RISCV64) += chacha-riscv64.o chacha-riscv64-y := chacha-riscv64-glue.o chacha-riscv64-zvkb.o obj-$(CONFIG_CRYPTO_GHASH_RISCV64) += ghash-riscv64.o ghash-riscv64-y := ghash-riscv64-glue.o ghash-riscv64-zvkg.o obj-$(CONFIG_CRYPTO_SHA256_RISCV64) += sha256-riscv64.o sha256-riscv64-y := sha256-riscv64-glue.o sha256-riscv64-zvknha_or_zvknhb-zvkb.o + +obj-$(CONFIG_CRYPTO_SHA512_RISCV64) += sha512-riscv64.o +sha512-riscv64-y := sha512-riscv64-glue.o sha512-riscv64-zvknhb-zvkb.o diff --git a/arch/riscv/crypto/sha512-riscv64-glue.c b/arch/riscv/crypto/sha512-riscv64-glue.c new file mode 100644 index 0000000000000..f30f723742cbe --- /dev/null +++ b/arch/riscv/crypto/sha512-riscv64-glue.c @@ -0,0 +1,133 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * SHA-512 and SHA-384 using the RISC-V vector crypto extensions + * + * Copyright (C) 2023 VRULL GmbH + * Author: Heiko Stuebner + * + * Copyright (C) 2023 SiFive, Inc. + * Author: Jerry Shih + */ + +#include +#include +#include +#include +#include +#include +#include + +/* + * Note: the asm function only uses the 'state' field of struct sha512_state. + * It is assumed to be the first field. + */ +asmlinkage void sha512_transform_zvknhb_zvkb( + struct sha512_state *state, const u8 *data, int num_blocks); + +static int riscv64_sha512_update(struct shash_desc *desc, const u8 *data, + unsigned int len) +{ + /* + * Ensure struct sha512_state begins directly with the SHA-512 + * 512-bit internal state, as this is what the asm function expects. + */ + BUILD_BUG_ON(offsetof(struct sha512_state, state) != 0); + + if (crypto_simd_usable()) { + kernel_vector_begin(); + sha512_base_do_update(desc, data, len, + sha512_transform_zvknhb_zvkb); + kernel_vector_end(); + } else { + crypto_sha512_update(desc, data, len); + } + return 0; +} + +static int riscv64_sha512_finup(struct shash_desc *desc, const u8 *data, + unsigned int len, u8 *out) +{ + if (crypto_simd_usable()) { + kernel_vector_begin(); + if (len) + sha512_base_do_update(desc, data, len, + sha512_transform_zvknhb_zvkb); + sha512_base_do_finalize(desc, sha512_transform_zvknhb_zvkb); + kernel_vector_end(); + + return sha512_base_finish(desc, out); + } + + return crypto_sha512_finup(desc, data, len, out); +} + +static int riscv64_sha512_final(struct shash_desc *desc, u8 *out) +{ + return riscv64_sha512_finup(desc, NULL, 0, out); +} + +static int riscv64_sha512_digest(struct shash_desc *desc, const u8 *data, + unsigned int len, u8 *out) +{ + return sha512_base_init(desc) ?: + riscv64_sha512_finup(desc, data, len, out); +} + +static struct shash_alg riscv64_sha512_algs[] = { + { + .init = sha512_base_init, + .update = riscv64_sha512_update, + .final = riscv64_sha512_final, + .finup = riscv64_sha512_finup, + .digest = riscv64_sha512_digest, + .descsize = sizeof(struct sha512_state), + .digestsize = SHA512_DIGEST_SIZE, + .base = { + .cra_blocksize = SHA512_BLOCK_SIZE, + .cra_priority = 300, + .cra_name = "sha512", + .cra_driver_name = "sha512-riscv64-zvknhb-zvkb", + .cra_module = THIS_MODULE, + }, + }, { + .init = sha384_base_init, + .update = riscv64_sha512_update, + .final = riscv64_sha512_final, + .finup = riscv64_sha512_finup, + .descsize = sizeof(struct sha512_state), + .digestsize = SHA384_DIGEST_SIZE, + .base = { + .cra_blocksize = SHA384_BLOCK_SIZE, + .cra_priority = 300, + .cra_name = "sha384", + .cra_driver_name = "sha384-riscv64-zvknhb-zvkb", + .cra_module = THIS_MODULE, + }, + }, +}; + +static int __init riscv64_sha512_mod_init(void) +{ + if (riscv_isa_extension_available(NULL, ZVKNHB) && + riscv_isa_extension_available(NULL, ZVKB) && + riscv_vector_vlen() >= 128) + return crypto_register_shashes(riscv64_sha512_algs, + ARRAY_SIZE(riscv64_sha512_algs)); + + return -ENODEV; +} + +static void __exit riscv64_sha512_mod_fini(void) +{ + crypto_unregister_shashes(riscv64_sha512_algs, + ARRAY_SIZE(riscv64_sha512_algs)); +} + +module_init(riscv64_sha512_mod_init); +module_exit(riscv64_sha512_mod_fini); + +MODULE_DESCRIPTION("SHA-512 (RISC-V accelerated)"); +MODULE_AUTHOR("Heiko Stuebner "); +MODULE_LICENSE("GPL"); +MODULE_ALIAS_CRYPTO("sha512"); +MODULE_ALIAS_CRYPTO("sha384"); diff --git a/arch/riscv/crypto/sha512-riscv64-zvknhb-zvkb.S b/arch/riscv/crypto/sha512-riscv64-zvknhb-zvkb.S new file mode 100644 index 0000000000000..3a9ae210f9158 --- /dev/null +++ b/arch/riscv/crypto/sha512-riscv64-zvknhb-zvkb.S @@ -0,0 +1,203 @@ +/* SPDX-License-Identifier: Apache-2.0 OR BSD-2-Clause */ +// +// This file is dual-licensed, meaning that you can use it under your +// choice of either of the following two licenses: +// +// Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. +// +// Licensed under the Apache License 2.0 (the "License"). You can obtain +// a copy in the file LICENSE in the source distribution or at +// https://www.openssl.org/source/license.html +// +// or +// +// Copyright (c) 2023, Christoph Müllner +// Copyright (c) 2023, Phoebe Chen +// Copyright 2024 Google LLC +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// The generated code of this file depends on the following RISC-V extensions: +// - RV64I +// - RISC-V Vector ('V') with VLEN >= 128 +// - RISC-V Vector SHA-2 Secure Hash extension ('Zvknhb') +// - RISC-V Vector Cryptography Bit-manipulation extension ('Zvkb') + +#include + +.text +.option arch, +zvknhb, +zvkb + +#define STATEP a0 +#define DATA a1 +#define NUM_BLOCKS a2 + +#define STATEP_C a3 +#define K a4 + +#define MASK v0 +#define INDICES v1 +#define W0 v10 // LMUL=2 +#define W1 v12 // LMUL=2 +#define W2 v14 // LMUL=2 +#define W3 v16 // LMUL=2 +#define VTMP v20 // LMUL=2 +#define FEBA v22 // LMUL=2 +#define HGDC v24 // LMUL=2 +#define PREV_FEBA v26 // LMUL=2 +#define PREV_HGDC v28 // LMUL=2 + +// Do 4 rounds of SHA-512. w0 contains the current 4 message schedule words. +// +// If not all the message schedule words have been computed yet, then this also +// computes 4 more message schedule words. w1-w3 contain the next 3 groups of 4 +// message schedule words; this macro computes the group after w3 and writes it +// to w0. This means that the next (w0, w1, w2, w3) is the current (w1, w2, w3, +// w0), so the caller must cycle through the registers accordingly. +.macro sha512_4rounds last, w0, w1, w2, w3 + vle64.v VTMP, (K) + addi K, K, 32 + vadd.vv VTMP, VTMP, \w0 + vsha2cl.vv HGDC, FEBA, VTMP + vsha2ch.vv FEBA, HGDC, VTMP +.if !\last + vmerge.vvm VTMP, \w2, \w1, MASK + vsha2ms.vv \w0, VTMP, \w3 +.endif +.endm + +.macro sha512_16rounds last + sha512_4rounds \last, W0, W1, W2, W3 + sha512_4rounds \last, W1, W2, W3, W0 + sha512_4rounds \last, W2, W3, W0, W1 + sha512_4rounds \last, W3, W0, W1, W2 +.endm + +// void sha512_transform_zvknhb_zvkb(u64 state[8], const u8 *data, +// int num_blocks); +SYM_TYPED_FUNC_START(sha512_transform_zvknhb_zvkb) + + // Setup mask for the vmerge to replace the first word (idx==0) in + // message scheduling. There are 4 words, so an 8-bit mask suffices. + vsetivli zero, 1, e8, m1, ta, ma + vmv.v.i MASK, 0x01 + + // Load the state. The state is stored as {a,b,c,d,e,f,g,h}, but we + // need {f,e,b,a},{h,g,d,c}. The dst vtype is e64m2 and the index vtype + // is e8mf4. We use index-load with the i8 indices {40, 32, 8, 0}, + // loaded using the 32-bit little endian value 0x00082028. + li t0, 0x00082028 + vsetivli zero, 1, e32, m1, ta, ma + vmv.v.x INDICES, t0 + addi STATEP_C, STATEP, 16 + vsetivli zero, 4, e64, m2, ta, ma + vluxei8.v FEBA, (STATEP), INDICES + vluxei8.v HGDC, (STATEP_C), INDICES + +.Lnext_block: + la K, K512 + addi NUM_BLOCKS, NUM_BLOCKS, -1 + + // Save the previous state, as it's needed later. + vmv.v.v PREV_FEBA, FEBA + vmv.v.v PREV_HGDC, HGDC + + // Load the next 1024-bit message block and endian-swap each 64-bit word + vle64.v W0, (DATA) + vrev8.v W0, W0 + addi DATA, DATA, 32 + vle64.v W1, (DATA) + vrev8.v W1, W1 + addi DATA, DATA, 32 + vle64.v W2, (DATA) + vrev8.v W2, W2 + addi DATA, DATA, 32 + vle64.v W3, (DATA) + vrev8.v W3, W3 + addi DATA, DATA, 32 + + // Do the 80 rounds of SHA-512. + sha512_16rounds 0 + sha512_16rounds 0 + sha512_16rounds 0 + sha512_16rounds 0 + sha512_16rounds 1 + + // Add the previous state. + vadd.vv FEBA, FEBA, PREV_FEBA + vadd.vv HGDC, HGDC, PREV_HGDC + + // Repeat if more blocks remain. + bnez NUM_BLOCKS, .Lnext_block + + // Store the new state and return. + vsuxei8.v FEBA, (STATEP), INDICES + vsuxei8.v HGDC, (STATEP_C), INDICES + ret +SYM_FUNC_END(sha512_transform_zvknhb_zvkb) + +.section ".rodata" +.p2align 3 +.type K512, @object +K512: + .dword 0x428a2f98d728ae22, 0x7137449123ef65cd + .dword 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc + .dword 0x3956c25bf348b538, 0x59f111f1b605d019 + .dword 0x923f82a4af194f9b, 0xab1c5ed5da6d8118 + .dword 0xd807aa98a3030242, 0x12835b0145706fbe + .dword 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2 + .dword 0x72be5d74f27b896f, 0x80deb1fe3b1696b1 + .dword 0x9bdc06a725c71235, 0xc19bf174cf692694 + .dword 0xe49b69c19ef14ad2, 0xefbe4786384f25e3 + .dword 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65 + .dword 0x2de92c6f592b0275, 0x4a7484aa6ea6e483 + .dword 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5 + .dword 0x983e5152ee66dfab, 0xa831c66d2db43210 + .dword 0xb00327c898fb213f, 0xbf597fc7beef0ee4 + .dword 0xc6e00bf33da88fc2, 0xd5a79147930aa725 + .dword 0x06ca6351e003826f, 0x142929670a0e6e70 + .dword 0x27b70a8546d22ffc, 0x2e1b21385c26c926 + .dword 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df + .dword 0x650a73548baf63de, 0x766a0abb3c77b2a8 + .dword 0x81c2c92e47edaee6, 0x92722c851482353b + .dword 0xa2bfe8a14cf10364, 0xa81a664bbc423001 + .dword 0xc24b8b70d0f89791, 0xc76c51a30654be30 + .dword 0xd192e819d6ef5218, 0xd69906245565a910 + .dword 0xf40e35855771202a, 0x106aa07032bbd1b8 + .dword 0x19a4c116b8d2d0c8, 0x1e376c085141ab53 + .dword 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8 + .dword 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb + .dword 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3 + .dword 0x748f82ee5defb2fc, 0x78a5636f43172f60 + .dword 0x84c87814a1f0ab72, 0x8cc702081a6439ec + .dword 0x90befffa23631e28, 0xa4506cebde82bde9 + .dword 0xbef9a3f7b2c67915, 0xc67178f2e372532b + .dword 0xca273eceea26619c, 0xd186b8c721c0c207 + .dword 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178 + .dword 0x06f067aa72176fba, 0x0a637dc5a2c898a6 + .dword 0x113f9804bef90dae, 0x1b710b35131c471b + .dword 0x28db77f523047d84, 0x32caab7b40c72493 + .dword 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c + .dword 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a + .dword 0x5fcb6fab3ad6faec, 0x6c44198c4a475817 +.size K512, . - K512 -- 2.43.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 07D20C47073 for ; Tue, 2 Jan 2024 06:50:59 +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=TKP+JB2Mond0Zmpt6yXm0NCrkIIvNr/ucmPx9GmgusM=; b=f2TRoePHpjWKyM fYF0eG6MZQFfKemWnmkxikbhtyIfssKVfSxQK1HJZidaIKk6+DKIaRv8pqzhekMfCzWcFHp81Mjc/ cSeCw2x4uMggULUPEyUgvUAoGcUjk3/jK0PcNEEkFmpaN8K0DhqgxKM++SmKxAfOXpezWmU9K/+X2 BhQFpuwRrXu6SwI2rHZKHgFDGT7l0xUbHk4pncPIgy6/QDBVyne+gTtYqvU0PmbenF3JuI8++oArG rasjMHNjtMybThbtXzoVq9SOQuxFIzJJcXB0Oq2DBNDK8xaeYoRYyXT6cJQ/r9E5X3798A8jnwY/B q7ZLroEH4yhVKQ2cyOXg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1rKYby-007CZG-2v; Tue, 02 Jan 2024 06:50:50 +0000 Received: from dfw.source.kernel.org ([139.178.84.217]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1rKYbt-007CSg-02 for linux-riscv@lists.infradead.org; Tue, 02 Jan 2024 06:50:48 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id 685F160FB3; Tue, 2 Jan 2024 06:50:44 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id D0F1AC43391; Tue, 2 Jan 2024 06:50:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1704178244; bh=AitJ29G3E6vFWJv2gmKjCVHjLojwFUnKnw9FBdbCvTY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Ud9Xwg93n0bFPbyv1l0V6nrphmxiLBMXyyjgV8TBcULtp1ay6cjRJEwxB+kf1sp/N j0FU8I85uyYT1b29S88MwJfITHUQTBAUS6DkNi+blWWHHDeKeW9wqUMCY6gdah10Lj cmcKNlMt5OuXsY6IevQQNXArvwtpqXD1ImN7KjQfHYR1cueyftewMdNL7l+TEmAg37 27Jc/dw7diWMG3vc60qzKLIvNTaHW39ZSo4kuDcL6jmvbrZjjubW0M51M2TvRgRmDs 9k8frjwPXWgntyKlelLcsLzj5ulT9upaefrkGWspmCx3on4X9wXu6M/TkAVzEHHGW7 qx/65lE8g+b+A== From: Eric Biggers To: linux-crypto@vger.kernel.org, linux-riscv@lists.infradead.org, Jerry Shih Cc: linux-kernel@vger.kernel.org, Ard Biesheuvel , Heiko Stuebner , Phoebe Chen , hongrong.hsu@sifive.com, Paul Walmsley , Palmer Dabbelt , Albert Ou , Andy Chiu , Charalampos Mitrodimas , Heiko Stuebner Subject: [RFC PATCH 11/13] crypto: riscv - add vector crypto accelerated SHA-{512,384} Date: Tue, 2 Jan 2024 00:47:37 -0600 Message-ID: <20240102064743.220490-12-ebiggers@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240102064743.220490-1-ebiggers@kernel.org> References: <20240102064743.220490-1-ebiggers@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240101_225045_160722_AD4E9C4B X-CRM114-Status: GOOD ( 31.53 ) 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 RnJvbTogSmVycnkgU2hpaCA8amVycnkuc2hpaEBzaWZpdmUuY29tPgoKQWRkIGFuIGltcGxlbWVu dGF0aW9uIG9mIFNIQS0zODQgYW5kIFNIQS01MTIgdXNpbmcgdGhlIFp2a25oYiBleHRlbnNpb24u ClRoZSBhc3NlbWJseSBjb2RlIGlzIGRlcml2ZWQgZnJvbSBPcGVuU1NMIGNvZGUgKG9wZW5zc2wv b3BlbnNzbCMyMTkyMykKdGhhdCB3YXMgZHVhbC1saWNlbnNlZCBzbyB0aGF0IGl0IGNvdWxkIGJl IHJldXNlZCBpbiB0aGUga2VybmVsLgpOZXZlcnRoZWxlc3MsIHRoZSBhc3NlbWJseSBoYXMgYmVl biBzaWduaWZpY2FudGx5IHJld29ya2VkIGZvcgppbnRlZ3JhdGlvbiB3aXRoIHRoZSBrZXJuZWws IGZvciBleGFtcGxlIGJ5IHVzaW5nIGEgcmVndWxhciAuUyBmaWxlCmluc3RlYWQgb2YgdGhlIHNv LWNhbGxlZCBwZXJsYXNtLCB1c2luZyB0aGUgYXNzZW1ibGVyIGluc3RlYWQgb2YgYmFyZQonLmlu c3QnLCBhbmQgZ3JlYXRseSByZWR1Y2luZyBjb2RlIGR1cGxpY2F0aW9uLgoKQ28tZGV2ZWxvcGVk LWJ5OiBDaGFyYWxhbXBvcyBNaXRyb2RpbWFzIDxjaGFyYWxhbXBvcy5taXRyb2RpbWFzQHZydWxs LmV1PgpTaWduZWQtb2ZmLWJ5OiBDaGFyYWxhbXBvcyBNaXRyb2RpbWFzIDxjaGFyYWxhbXBvcy5t aXRyb2RpbWFzQHZydWxsLmV1PgpDby1kZXZlbG9wZWQtYnk6IEhlaWtvIFN0dWVibmVyIDxoZWlr by5zdHVlYm5lckB2cnVsbC5ldT4KU2lnbmVkLW9mZi1ieTogSGVpa28gU3R1ZWJuZXIgPGhlaWtv LnN0dWVibmVyQHZydWxsLmV1PgpDby1kZXZlbG9wZWQtYnk6IFBob2ViZSBDaGVuIDxwaG9lYmUu Y2hlbkBzaWZpdmUuY29tPgpTaWduZWQtb2ZmLWJ5OiBQaG9lYmUgQ2hlbiA8cGhvZWJlLmNoZW5A c2lmaXZlLmNvbT4KU2lnbmVkLW9mZi1ieTogSmVycnkgU2hpaCA8amVycnkuc2hpaEBzaWZpdmUu Y29tPgpDby1kZXZlbG9wZWQtYnk6IEVyaWMgQmlnZ2VycyA8ZWJpZ2dlcnNAZ29vZ2xlLmNvbT4K U2lnbmVkLW9mZi1ieTogRXJpYyBCaWdnZXJzIDxlYmlnZ2Vyc0Bnb29nbGUuY29tPgotLS0KIGFy Y2gvcmlzY3YvY3J5cHRvL0tjb25maWcgICAgICAgICAgICAgICAgICAgICB8ICAxMSArCiBhcmNo L3Jpc2N2L2NyeXB0by9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgfCAgIDMgKwogYXJjaC9y aXNjdi9jcnlwdG8vc2hhNTEyLXJpc2N2NjQtZ2x1ZS5jICAgICAgIHwgMTMzICsrKysrKysrKysr KwogLi4uL3Jpc2N2L2NyeXB0by9zaGE1MTItcmlzY3Y2NC16dmtuaGItenZrYi5TIHwgMjAzICsr KysrKysrKysrKysrKysrKwogNCBmaWxlcyBjaGFuZ2VkLCAzNTAgaW5zZXJ0aW9ucygrKQogY3Jl YXRlIG1vZGUgMTAwNjQ0IGFyY2gvcmlzY3YvY3J5cHRvL3NoYTUxMi1yaXNjdjY0LWdsdWUuYwog Y3JlYXRlIG1vZGUgMTAwNjQ0IGFyY2gvcmlzY3YvY3J5cHRvL3NoYTUxMi1yaXNjdjY0LXp2a25o Yi16dmtiLlMKCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2NyeXB0by9LY29uZmlnIGIvYXJjaC9y aXNjdi9jcnlwdG8vS2NvbmZpZwppbmRleCA1MzNiYzZkZWYxMjNhLi5jYTEzODk1YzNlMGY2IDEw MDY0NAotLS0gYS9hcmNoL3Jpc2N2L2NyeXB0by9LY29uZmlnCisrKyBiL2FyY2gvcmlzY3YvY3J5 cHRvL0tjb25maWcKQEAgLTU4LDExICs1OCwyMiBAQCBjb25maWcgQ1JZUFRPX1NIQTI1Nl9SSVND VjY0CiAJdHJpc3RhdGUgIkhhc2ggZnVuY3Rpb25zOiBTSEEtMjI0IGFuZCBTSEEtMjU2IgogCWRl cGVuZHMgb24gNjRCSVQgJiYgUklTQ1ZfSVNBX1YgJiYgVE9PTENIQUlOX0hBU19WRUNUT1JfQ1JZ UFRPCiAJc2VsZWN0IENSWVBUT19TSEEyNTYKIAloZWxwCiAJICBTSEEtMjI0IGFuZCBTSEEtMjU2 IHNlY3VyZSBoYXNoIGFsZ29yaXRobSAoRklQUyAxODApCiAKIAkgIEFyY2hpdGVjdHVyZTogcmlz Y3Y2NCB1c2luZzoKIAkgIC0gWnZrbmhhIG9yIFp2a25oYiB2ZWN0b3IgY3J5cHRvIGV4dGVuc2lv bnMKIAkgIC0gWnZrYiB2ZWN0b3IgY3J5cHRvIGV4dGVuc2lvbgogCitjb25maWcgQ1JZUFRPX1NI QTUxMl9SSVNDVjY0CisJdHJpc3RhdGUgIkhhc2ggZnVuY3Rpb25zOiBTSEEtMzg0IGFuZCBTSEEt NTEyIgorCWRlcGVuZHMgb24gNjRCSVQgJiYgUklTQ1ZfSVNBX1YgJiYgVE9PTENIQUlOX0hBU19W RUNUT1JfQ1JZUFRPCisJc2VsZWN0IENSWVBUT19TSEE1MTIKKwloZWxwCisJICBTSEEtMzg0IGFu ZCBTSEEtNTEyIHNlY3VyZSBoYXNoIGFsZ29yaXRobSAoRklQUyAxODApCisKKwkgIEFyY2hpdGVj dHVyZTogcmlzY3Y2NCB1c2luZzoKKwkgIC0gWnZrbmhiIHZlY3RvciBjcnlwdG8gZXh0ZW5zaW9u CisJICAtIFp2a2IgdmVjdG9yIGNyeXB0byBleHRlbnNpb24KKwogZW5kbWVudQpkaWZmIC0tZ2l0 IGEvYXJjaC9yaXNjdi9jcnlwdG8vTWFrZWZpbGUgYi9hcmNoL3Jpc2N2L2NyeXB0by9NYWtlZmls ZQppbmRleCAyOGE1OGU4OTkyN2FlLi5lMzBhMWJjYzc4OGJmIDEwMDY0NAotLS0gYS9hcmNoL3Jp c2N2L2NyeXB0by9NYWtlZmlsZQorKysgYi9hcmNoL3Jpc2N2L2NyeXB0by9NYWtlZmlsZQpAQCAt MTAsMTAgKzEwLDEzIEBAIG9iai0kKENPTkZJR19DUllQVE9fQUVTX0JMT0NLX1JJU0NWNjQpICs9 IGFlcy1ibG9jay1yaXNjdjY0Lm8KIGFlcy1ibG9jay1yaXNjdjY0LXkgOj0gYWVzLXJpc2N2NjQt YmxvY2stbW9kZS1nbHVlLm8gYWVzLXJpc2N2NjQtenZrbmVkLXp2YmItenZrZy5vIGFlcy1yaXNj djY0LXp2a25lZC16dmtiLm8KIAogb2JqLSQoQ09ORklHX0NSWVBUT19DSEFDSEFfUklTQ1Y2NCkg Kz0gY2hhY2hhLXJpc2N2NjQubwogY2hhY2hhLXJpc2N2NjQteSA6PSBjaGFjaGEtcmlzY3Y2NC1n bHVlLm8gY2hhY2hhLXJpc2N2NjQtenZrYi5vCiAKIG9iai0kKENPTkZJR19DUllQVE9fR0hBU0hf UklTQ1Y2NCkgKz0gZ2hhc2gtcmlzY3Y2NC5vCiBnaGFzaC1yaXNjdjY0LXkgOj0gZ2hhc2gtcmlz Y3Y2NC1nbHVlLm8gZ2hhc2gtcmlzY3Y2NC16dmtnLm8KIAogb2JqLSQoQ09ORklHX0NSWVBUT19T SEEyNTZfUklTQ1Y2NCkgKz0gc2hhMjU2LXJpc2N2NjQubwogc2hhMjU2LXJpc2N2NjQteSA6PSBz aGEyNTYtcmlzY3Y2NC1nbHVlLm8gc2hhMjU2LXJpc2N2NjQtenZrbmhhX29yX3p2a25oYi16dmti Lm8KKworb2JqLSQoQ09ORklHX0NSWVBUT19TSEE1MTJfUklTQ1Y2NCkgKz0gc2hhNTEyLXJpc2N2 NjQubworc2hhNTEyLXJpc2N2NjQteSA6PSBzaGE1MTItcmlzY3Y2NC1nbHVlLm8gc2hhNTEyLXJp c2N2NjQtenZrbmhiLXp2a2IubwpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9jcnlwdG8vc2hhNTEy LXJpc2N2NjQtZ2x1ZS5jIGIvYXJjaC9yaXNjdi9jcnlwdG8vc2hhNTEyLXJpc2N2NjQtZ2x1ZS5j Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAuLmYzMGY3MjM3NDJjYmUK LS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3Jpc2N2L2NyeXB0by9zaGE1MTItcmlzY3Y2NC1nbHVl LmMKQEAgLTAsMCArMSwxMzMgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4w LW9yLWxhdGVyCisvKgorICogU0hBLTUxMiBhbmQgU0hBLTM4NCB1c2luZyB0aGUgUklTQy1WIHZl Y3RvciBjcnlwdG8gZXh0ZW5zaW9ucworICoKKyAqIENvcHlyaWdodCAoQykgMjAyMyBWUlVMTCBH bWJICisgKiBBdXRob3I6IEhlaWtvIFN0dWVibmVyIDxoZWlrby5zdHVlYm5lckB2cnVsbC5ldT4K KyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgU2lGaXZlLCBJbmMuCisgKiBBdXRob3I6IEplcnJ5 IFNoaWggPGplcnJ5LnNoaWhAc2lmaXZlLmNvbT4KKyAqLworCisjaW5jbHVkZSA8YXNtL3NpbWQu aD4KKyNpbmNsdWRlIDxhc20vdmVjdG9yLmg+CisjaW5jbHVkZSA8Y3J5cHRvL2ludGVybmFsL2hh c2guaD4KKyNpbmNsdWRlIDxjcnlwdG8vaW50ZXJuYWwvc2ltZC5oPgorI2luY2x1ZGUgPGNyeXB0 by9zaGE1MTJfYmFzZS5oPgorI2luY2x1ZGUgPGxpbnV4L2xpbmthZ2UuaD4KKyNpbmNsdWRlIDxs aW51eC9tb2R1bGUuaD4KKworLyoKKyAqIE5vdGU6IHRoZSBhc20gZnVuY3Rpb24gb25seSB1c2Vz IHRoZSAnc3RhdGUnIGZpZWxkIG9mIHN0cnVjdCBzaGE1MTJfc3RhdGUuCisgKiBJdCBpcyBhc3N1 bWVkIHRvIGJlIHRoZSBmaXJzdCBmaWVsZC4KKyAqLworYXNtbGlua2FnZSB2b2lkIHNoYTUxMl90 cmFuc2Zvcm1fenZrbmhiX3p2a2IoCisJc3RydWN0IHNoYTUxMl9zdGF0ZSAqc3RhdGUsIGNvbnN0 IHU4ICpkYXRhLCBpbnQgbnVtX2Jsb2Nrcyk7CisKK3N0YXRpYyBpbnQgcmlzY3Y2NF9zaGE1MTJf dXBkYXRlKHN0cnVjdCBzaGFzaF9kZXNjICpkZXNjLCBjb25zdCB1OCAqZGF0YSwKKwkJCQkgdW5z aWduZWQgaW50IGxlbikKK3sKKwkvKgorCSAqIEVuc3VyZSBzdHJ1Y3Qgc2hhNTEyX3N0YXRlIGJl Z2lucyBkaXJlY3RseSB3aXRoIHRoZSBTSEEtNTEyCisJICogNTEyLWJpdCBpbnRlcm5hbCBzdGF0 ZSwgYXMgdGhpcyBpcyB3aGF0IHRoZSBhc20gZnVuY3Rpb24gZXhwZWN0cy4KKwkgKi8KKwlCVUlM RF9CVUdfT04ob2Zmc2V0b2Yoc3RydWN0IHNoYTUxMl9zdGF0ZSwgc3RhdGUpICE9IDApOworCisJ aWYgKGNyeXB0b19zaW1kX3VzYWJsZSgpKSB7CisJCWtlcm5lbF92ZWN0b3JfYmVnaW4oKTsKKwkJ c2hhNTEyX2Jhc2VfZG9fdXBkYXRlKGRlc2MsIGRhdGEsIGxlbiwKKwkJCQkgICAgICBzaGE1MTJf dHJhbnNmb3JtX3p2a25oYl96dmtiKTsKKwkJa2VybmVsX3ZlY3Rvcl9lbmQoKTsKKwl9IGVsc2Ug eworCQljcnlwdG9fc2hhNTEyX3VwZGF0ZShkZXNjLCBkYXRhLCBsZW4pOworCX0KKwlyZXR1cm4g MDsKK30KKworc3RhdGljIGludCByaXNjdjY0X3NoYTUxMl9maW51cChzdHJ1Y3Qgc2hhc2hfZGVz YyAqZGVzYywgY29uc3QgdTggKmRhdGEsCisJCQkJdW5zaWduZWQgaW50IGxlbiwgdTggKm91dCkK K3sKKwlpZiAoY3J5cHRvX3NpbWRfdXNhYmxlKCkpIHsKKwkJa2VybmVsX3ZlY3Rvcl9iZWdpbigp OworCQlpZiAobGVuKQorCQkJc2hhNTEyX2Jhc2VfZG9fdXBkYXRlKGRlc2MsIGRhdGEsIGxlbiwK KwkJCQkJICAgICAgc2hhNTEyX3RyYW5zZm9ybV96dmtuaGJfenZrYik7CisJCXNoYTUxMl9iYXNl X2RvX2ZpbmFsaXplKGRlc2MsIHNoYTUxMl90cmFuc2Zvcm1fenZrbmhiX3p2a2IpOworCQlrZXJu ZWxfdmVjdG9yX2VuZCgpOworCisJCXJldHVybiBzaGE1MTJfYmFzZV9maW5pc2goZGVzYywgb3V0 KTsKKwl9CisKKwlyZXR1cm4gY3J5cHRvX3NoYTUxMl9maW51cChkZXNjLCBkYXRhLCBsZW4sIG91 dCk7Cit9CisKK3N0YXRpYyBpbnQgcmlzY3Y2NF9zaGE1MTJfZmluYWwoc3RydWN0IHNoYXNoX2Rl c2MgKmRlc2MsIHU4ICpvdXQpCit7CisJcmV0dXJuIHJpc2N2NjRfc2hhNTEyX2ZpbnVwKGRlc2Ms IE5VTEwsIDAsIG91dCk7Cit9CisKK3N0YXRpYyBpbnQgcmlzY3Y2NF9zaGE1MTJfZGlnZXN0KHN0 cnVjdCBzaGFzaF9kZXNjICpkZXNjLCBjb25zdCB1OCAqZGF0YSwKKwkJCQkgdW5zaWduZWQgaW50 IGxlbiwgdTggKm91dCkKK3sKKwlyZXR1cm4gc2hhNTEyX2Jhc2VfaW5pdChkZXNjKSA/OgorCSAg ICAgICByaXNjdjY0X3NoYTUxMl9maW51cChkZXNjLCBkYXRhLCBsZW4sIG91dCk7Cit9CisKK3N0 YXRpYyBzdHJ1Y3Qgc2hhc2hfYWxnIHJpc2N2NjRfc2hhNTEyX2FsZ3NbXSA9IHsKKwl7CisJCS5p bml0ID0gc2hhNTEyX2Jhc2VfaW5pdCwKKwkJLnVwZGF0ZSA9IHJpc2N2NjRfc2hhNTEyX3VwZGF0 ZSwKKwkJLmZpbmFsID0gcmlzY3Y2NF9zaGE1MTJfZmluYWwsCisJCS5maW51cCA9IHJpc2N2NjRf c2hhNTEyX2ZpbnVwLAorCQkuZGlnZXN0ID0gcmlzY3Y2NF9zaGE1MTJfZGlnZXN0LAorCQkuZGVz Y3NpemUgPSBzaXplb2Yoc3RydWN0IHNoYTUxMl9zdGF0ZSksCisJCS5kaWdlc3RzaXplID0gU0hB NTEyX0RJR0VTVF9TSVpFLAorCQkuYmFzZSA9IHsKKwkJCS5jcmFfYmxvY2tzaXplID0gU0hBNTEy X0JMT0NLX1NJWkUsCisJCQkuY3JhX3ByaW9yaXR5ID0gMzAwLAorCQkJLmNyYV9uYW1lID0gInNo YTUxMiIsCisJCQkuY3JhX2RyaXZlcl9uYW1lID0gInNoYTUxMi1yaXNjdjY0LXp2a25oYi16dmti IiwKKwkJCS5jcmFfbW9kdWxlID0gVEhJU19NT0RVTEUsCisJCX0sCisJfSwgeworCQkuaW5pdCA9 IHNoYTM4NF9iYXNlX2luaXQsCisJCS51cGRhdGUgPSByaXNjdjY0X3NoYTUxMl91cGRhdGUsCisJ CS5maW5hbCA9IHJpc2N2NjRfc2hhNTEyX2ZpbmFsLAorCQkuZmludXAgPSByaXNjdjY0X3NoYTUx Ml9maW51cCwKKwkJLmRlc2NzaXplID0gc2l6ZW9mKHN0cnVjdCBzaGE1MTJfc3RhdGUpLAorCQku ZGlnZXN0c2l6ZSA9IFNIQTM4NF9ESUdFU1RfU0laRSwKKwkJLmJhc2UgPSB7CisJCQkuY3JhX2Js b2Nrc2l6ZSA9IFNIQTM4NF9CTE9DS19TSVpFLAorCQkJLmNyYV9wcmlvcml0eSA9IDMwMCwKKwkJ CS5jcmFfbmFtZSA9ICJzaGEzODQiLAorCQkJLmNyYV9kcml2ZXJfbmFtZSA9ICJzaGEzODQtcmlz Y3Y2NC16dmtuaGItenZrYiIsCisJCQkuY3JhX21vZHVsZSA9IFRISVNfTU9EVUxFLAorCQl9LAor CX0sCit9OworCitzdGF0aWMgaW50IF9faW5pdCByaXNjdjY0X3NoYTUxMl9tb2RfaW5pdCh2b2lk KQoreworCWlmIChyaXNjdl9pc2FfZXh0ZW5zaW9uX2F2YWlsYWJsZShOVUxMLCBaVktOSEIpICYm CisJICAgIHJpc2N2X2lzYV9leHRlbnNpb25fYXZhaWxhYmxlKE5VTEwsIFpWS0IpICYmCisJICAg IHJpc2N2X3ZlY3Rvcl92bGVuKCkgPj0gMTI4KQorCQlyZXR1cm4gY3J5cHRvX3JlZ2lzdGVyX3No YXNoZXMocmlzY3Y2NF9zaGE1MTJfYWxncywKKwkJCQkJICAgICAgIEFSUkFZX1NJWkUocmlzY3Y2 NF9zaGE1MTJfYWxncykpOworCisJcmV0dXJuIC1FTk9ERVY7Cit9CisKK3N0YXRpYyB2b2lkIF9f ZXhpdCByaXNjdjY0X3NoYTUxMl9tb2RfZmluaSh2b2lkKQoreworCWNyeXB0b191bnJlZ2lzdGVy X3NoYXNoZXMocmlzY3Y2NF9zaGE1MTJfYWxncywKKwkJCQkgIEFSUkFZX1NJWkUocmlzY3Y2NF9z aGE1MTJfYWxncykpOworfQorCittb2R1bGVfaW5pdChyaXNjdjY0X3NoYTUxMl9tb2RfaW5pdCk7 Cittb2R1bGVfZXhpdChyaXNjdjY0X3NoYTUxMl9tb2RfZmluaSk7CisKK01PRFVMRV9ERVNDUklQ VElPTigiU0hBLTUxMiAoUklTQy1WIGFjY2VsZXJhdGVkKSIpOworTU9EVUxFX0FVVEhPUigiSGVp a28gU3R1ZWJuZXIgPGhlaWtvLnN0dWVibmVyQHZydWxsLmV1PiIpOworTU9EVUxFX0xJQ0VOU0Uo IkdQTCIpOworTU9EVUxFX0FMSUFTX0NSWVBUTygic2hhNTEyIik7CitNT0RVTEVfQUxJQVNfQ1JZ UFRPKCJzaGEzODQiKTsKZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvY3J5cHRvL3NoYTUxMi1yaXNj djY0LXp2a25oYi16dmtiLlMgYi9hcmNoL3Jpc2N2L2NyeXB0by9zaGE1MTItcmlzY3Y2NC16dmtu aGItenZrYi5TCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAuLjNhOWFl MjEwZjkxNTgKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3Jpc2N2L2NyeXB0by9zaGE1MTItcmlz Y3Y2NC16dmtuaGItenZrYi5TCkBAIC0wLDAgKzEsMjAzIEBACisvKiBTUERYLUxpY2Vuc2UtSWRl bnRpZmllcjogQXBhY2hlLTIuMCBPUiBCU0QtMi1DbGF1c2UgKi8KKy8vCisvLyBUaGlzIGZpbGUg aXMgZHVhbC1saWNlbnNlZCwgbWVhbmluZyB0aGF0IHlvdSBjYW4gdXNlIGl0IHVuZGVyIHlvdXIK Ky8vIGNob2ljZSBvZiBlaXRoZXIgb2YgdGhlIGZvbGxvd2luZyB0d28gbGljZW5zZXM6CisvLwor Ly8gQ29weXJpZ2h0IDIwMjMgVGhlIE9wZW5TU0wgUHJvamVjdCBBdXRob3JzLiBBbGwgUmlnaHRz IFJlc2VydmVkLgorLy8KKy8vIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSAyLjAg KHRoZSAiTGljZW5zZSIpLiBZb3UgY2FuIG9idGFpbgorLy8gYSBjb3B5IGluIHRoZSBmaWxlIExJ Q0VOU0UgaW4gdGhlIHNvdXJjZSBkaXN0cmlidXRpb24gb3IgYXQKKy8vIGh0dHBzOi8vd3d3Lm9w ZW5zc2wub3JnL3NvdXJjZS9saWNlbnNlLmh0bWwKKy8vCisvLyBvcgorLy8KKy8vIENvcHlyaWdo dCAoYykgMjAyMywgQ2hyaXN0b3BoIE3DvGxsbmVyIDxjaHJpc3RvcGgubXVlbGxuZXJAdnJ1bGwu ZXU+CisvLyBDb3B5cmlnaHQgKGMpIDIwMjMsIFBob2ViZSBDaGVuIDxwaG9lYmUuY2hlbkBzaWZp dmUuY29tPgorLy8gQ29weXJpZ2h0IDIwMjQgR29vZ2xlIExMQworLy8gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKy8vCisvLyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKy8vIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworLy8gYXJlIG1ldDoKKy8vIDEu IFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29w eXJpZ2h0CisvLyAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIuCisvLyAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0g bXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorLy8gICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorLy8g ICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhl IGRpc3RyaWJ1dGlvbi4KKy8vCisvLyBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBD T1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisvLyAiQVMgSVMiIEFORCBBTlkgRVhQ UkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorLy8gTElNSVRF RCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5F U1MgRk9SCisvLyBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZF TlQgU0hBTEwgVEhFIENPUFlSSUdIVAorLy8gT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJM RSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisvLyBTUEVDSUFMLCBFWEVN UExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisvLyBM SU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBM T1NTIE9GIFVTRSwKKy8vIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElP TikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorLy8gVEhFT1JZIE9GIExJQUJJTElUWSwgV0hF VEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorLy8gKElOQ0xVRElO RyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUg VVNFCisvLyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLgorCisvLyBUaGUgZ2VuZXJhdGVkIGNvZGUgb2YgdGhpcyBmaWxl IGRlcGVuZHMgb24gdGhlIGZvbGxvd2luZyBSSVNDLVYgZXh0ZW5zaW9uczoKKy8vIC0gUlY2NEkK Ky8vIC0gUklTQy1WIFZlY3RvciAoJ1YnKSB3aXRoIFZMRU4gPj0gMTI4CisvLyAtIFJJU0MtViBW ZWN0b3IgU0hBLTIgU2VjdXJlIEhhc2ggZXh0ZW5zaW9uICgnWnZrbmhiJykKKy8vIC0gUklTQy1W IFZlY3RvciBDcnlwdG9ncmFwaHkgQml0LW1hbmlwdWxhdGlvbiBleHRlbnNpb24gKCdadmtiJykK KworI2luY2x1ZGUgPGxpbnV4L2NmaV90eXBlcy5oPgorCisudGV4dAorLm9wdGlvbiBhcmNoLCAr enZrbmhiLCArenZrYgorCisjZGVmaW5lIFNUQVRFUAkJYTAKKyNkZWZpbmUgREFUQQkJYTEKKyNk ZWZpbmUgTlVNX0JMT0NLUwlhMgorCisjZGVmaW5lIFNUQVRFUF9DCWEzCisjZGVmaW5lIEsJCWE0 CisKKyNkZWZpbmUgTUFTSwkJdjAKKyNkZWZpbmUgSU5ESUNFUwkJdjEKKyNkZWZpbmUgVzAJCXYx MAkvLyBMTVVMPTIKKyNkZWZpbmUgVzEJCXYxMgkvLyBMTVVMPTIKKyNkZWZpbmUgVzIJCXYxNAkv LyBMTVVMPTIKKyNkZWZpbmUgVzMJCXYxNgkvLyBMTVVMPTIKKyNkZWZpbmUgVlRNUAkJdjIwCS8v IExNVUw9MgorI2RlZmluZSBGRUJBCQl2MjIJLy8gTE1VTD0yCisjZGVmaW5lIEhHREMJCXYyNAkv LyBMTVVMPTIKKyNkZWZpbmUgUFJFVl9GRUJBCXYyNgkvLyBMTVVMPTIKKyNkZWZpbmUgUFJFVl9I R0RDCXYyOAkvLyBMTVVMPTIKKworLy8gRG8gNCByb3VuZHMgb2YgU0hBLTUxMi4gIHcwIGNvbnRh aW5zIHRoZSBjdXJyZW50IDQgbWVzc2FnZSBzY2hlZHVsZSB3b3Jkcy4KKy8vCisvLyBJZiBub3Qg YWxsIHRoZSBtZXNzYWdlIHNjaGVkdWxlIHdvcmRzIGhhdmUgYmVlbiBjb21wdXRlZCB5ZXQsIHRo ZW4gdGhpcyBhbHNvCisvLyBjb21wdXRlcyA0IG1vcmUgbWVzc2FnZSBzY2hlZHVsZSB3b3Jkcy4g IHcxLXczIGNvbnRhaW4gdGhlIG5leHQgMyBncm91cHMgb2YgNAorLy8gbWVzc2FnZSBzY2hlZHVs ZSB3b3JkczsgdGhpcyBtYWNybyBjb21wdXRlcyB0aGUgZ3JvdXAgYWZ0ZXIgdzMgYW5kIHdyaXRl cyBpdAorLy8gdG8gdzAuICBUaGlzIG1lYW5zIHRoYXQgdGhlIG5leHQgKHcwLCB3MSwgdzIsIHcz KSBpcyB0aGUgY3VycmVudCAodzEsIHcyLCB3MywKKy8vIHcwKSwgc28gdGhlIGNhbGxlciBtdXN0 IGN5Y2xlIHRocm91Z2ggdGhlIHJlZ2lzdGVycyBhY2NvcmRpbmdseS4KKy5tYWNybwlzaGE1MTJf NHJvdW5kcwlsYXN0LCB3MCwgdzEsIHcyLCB3MworCXZsZTY0LnYJCVZUTVAsIChLKQorCWFkZGkJ CUssIEssIDMyCisJdmFkZC52dgkJVlRNUCwgVlRNUCwgXHcwCisJdnNoYTJjbC52dglIR0RDLCBG RUJBLCBWVE1QCisJdnNoYTJjaC52dglGRUJBLCBIR0RDLCBWVE1QCisuaWYgIVxsYXN0CisJdm1l cmdlLnZ2bQlWVE1QLCBcdzIsIFx3MSwgTUFTSworCXZzaGEybXMudnYJXHcwLCBWVE1QLCBcdzMK Ky5lbmRpZgorLmVuZG0KKworLm1hY3JvCXNoYTUxMl8xNnJvdW5kcwlsYXN0CisJc2hhNTEyXzRy b3VuZHMJXGxhc3QsIFcwLCBXMSwgVzIsIFczCisJc2hhNTEyXzRyb3VuZHMJXGxhc3QsIFcxLCBX MiwgVzMsIFcwCisJc2hhNTEyXzRyb3VuZHMJXGxhc3QsIFcyLCBXMywgVzAsIFcxCisJc2hhNTEy XzRyb3VuZHMJXGxhc3QsIFczLCBXMCwgVzEsIFcyCisuZW5kbQorCisvLyB2b2lkIHNoYTUxMl90 cmFuc2Zvcm1fenZrbmhiX3p2a2IodTY0IHN0YXRlWzhdLCBjb25zdCB1OCAqZGF0YSwKKy8vCQkJ CSAgICAgaW50IG51bV9ibG9ja3MpOworU1lNX1RZUEVEX0ZVTkNfU1RBUlQoc2hhNTEyX3RyYW5z Zm9ybV96dmtuaGJfenZrYikKKworCS8vIFNldHVwIG1hc2sgZm9yIHRoZSB2bWVyZ2UgdG8gcmVw bGFjZSB0aGUgZmlyc3Qgd29yZCAoaWR4PT0wKSBpbgorCS8vIG1lc3NhZ2Ugc2NoZWR1bGluZy4g IFRoZXJlIGFyZSA0IHdvcmRzLCBzbyBhbiA4LWJpdCBtYXNrIHN1ZmZpY2VzLgorCXZzZXRpdmxp CXplcm8sIDEsIGU4LCBtMSwgdGEsIG1hCisJdm12LnYuaQkJTUFTSywgMHgwMQorCisJLy8gTG9h ZCB0aGUgc3RhdGUuICBUaGUgc3RhdGUgaXMgc3RvcmVkIGFzIHthLGIsYyxkLGUsZixnLGh9LCBi dXQgd2UKKwkvLyBuZWVkIHtmLGUsYixhfSx7aCxnLGQsY30uICBUaGUgZHN0IHZ0eXBlIGlzIGU2 NG0yIGFuZCB0aGUgaW5kZXggdnR5cGUKKwkvLyBpcyBlOG1mNC4gIFdlIHVzZSBpbmRleC1sb2Fk IHdpdGggdGhlIGk4IGluZGljZXMgezQwLCAzMiwgOCwgMH0sCisJLy8gbG9hZGVkIHVzaW5nIHRo ZSAzMi1iaXQgbGl0dGxlIGVuZGlhbiB2YWx1ZSAweDAwMDgyMDI4LgorCWxpCQl0MCwgMHgwMDA4 MjAyOAorCXZzZXRpdmxpCXplcm8sIDEsIGUzMiwgbTEsIHRhLCBtYQorCXZtdi52LngJCUlORElD RVMsIHQwCisJYWRkaQkJU1RBVEVQX0MsIFNUQVRFUCwgMTYKKwl2c2V0aXZsaQl6ZXJvLCA0LCBl NjQsIG0yLCB0YSwgbWEKKwl2bHV4ZWk4LnYJRkVCQSwgKFNUQVRFUCksIElORElDRVMKKwl2bHV4 ZWk4LnYJSEdEQywgKFNUQVRFUF9DKSwgSU5ESUNFUworCisuTG5leHRfYmxvY2s6CisJbGEJCUss IEs1MTIKKwlhZGRpCQlOVU1fQkxPQ0tTLCBOVU1fQkxPQ0tTLCAtMQorCisJLy8gU2F2ZSB0aGUg cHJldmlvdXMgc3RhdGUsIGFzIGl0J3MgbmVlZGVkIGxhdGVyLgorCXZtdi52LnYJCVBSRVZfRkVC QSwgRkVCQQorCXZtdi52LnYJCVBSRVZfSEdEQywgSEdEQworCisJLy8gTG9hZCB0aGUgbmV4dCAx MDI0LWJpdCBtZXNzYWdlIGJsb2NrIGFuZCBlbmRpYW4tc3dhcCBlYWNoIDY0LWJpdCB3b3JkCisJ dmxlNjQudgkJVzAsIChEQVRBKQorCXZyZXY4LnYJCVcwLCBXMAorCWFkZGkJCURBVEEsIERBVEEs IDMyCisJdmxlNjQudgkJVzEsIChEQVRBKQorCXZyZXY4LnYJCVcxLCBXMQorCWFkZGkJCURBVEEs IERBVEEsIDMyCisJdmxlNjQudgkJVzIsIChEQVRBKQorCXZyZXY4LnYJCVcyLCBXMgorCWFkZGkJ CURBVEEsIERBVEEsIDMyCisJdmxlNjQudgkJVzMsIChEQVRBKQorCXZyZXY4LnYJCVczLCBXMwor CWFkZGkJCURBVEEsIERBVEEsIDMyCisKKwkvLyBEbyB0aGUgODAgcm91bmRzIG9mIFNIQS01MTIu CisJc2hhNTEyXzE2cm91bmRzIDAKKwlzaGE1MTJfMTZyb3VuZHMgMAorCXNoYTUxMl8xNnJvdW5k cyAwCisJc2hhNTEyXzE2cm91bmRzIDAKKwlzaGE1MTJfMTZyb3VuZHMgMQorCisJLy8gQWRkIHRo ZSBwcmV2aW91cyBzdGF0ZS4KKwl2YWRkLnZ2CQlGRUJBLCBGRUJBLCBQUkVWX0ZFQkEKKwl2YWRk LnZ2CQlIR0RDLCBIR0RDLCBQUkVWX0hHREMKKworCS8vIFJlcGVhdCBpZiBtb3JlIGJsb2NrcyBy ZW1haW4uCisJYm5legkJTlVNX0JMT0NLUywgLkxuZXh0X2Jsb2NrCisKKwkvLyBTdG9yZSB0aGUg bmV3IHN0YXRlIGFuZCByZXR1cm4uCisJdnN1eGVpOC52CUZFQkEsIChTVEFURVApLCBJTkRJQ0VT CisJdnN1eGVpOC52CUhHREMsIChTVEFURVBfQyksIElORElDRVMKKwlyZXQKK1NZTV9GVU5DX0VO RChzaGE1MTJfdHJhbnNmb3JtX3p2a25oYl96dmtiKQorCisuc2VjdGlvbiAiLnJvZGF0YSIKKy5w MmFsaWduIDMKKy50eXBlIEs1MTIsIEBvYmplY3QKK0s1MTI6CisJLmR3b3JkCQkweDQyOGEyZjk4 ZDcyOGFlMjIsIDB4NzEzNzQ0OTEyM2VmNjVjZAorCS5kd29yZAkJMHhiNWMwZmJjZmVjNGQzYjJm LCAweGU5YjVkYmE1ODE4OWRiYmMKKwkuZHdvcmQJCTB4Mzk1NmMyNWJmMzQ4YjUzOCwgMHg1OWYx MTFmMWI2MDVkMDE5CisJLmR3b3JkCQkweDkyM2Y4MmE0YWYxOTRmOWIsIDB4YWIxYzVlZDVkYTZk ODExOAorCS5kd29yZAkJMHhkODA3YWE5OGEzMDMwMjQyLCAweDEyODM1YjAxNDU3MDZmYmUKKwku ZHdvcmQJCTB4MjQzMTg1YmU0ZWU0YjI4YywgMHg1NTBjN2RjM2Q1ZmZiNGUyCisJLmR3b3JkCQkw eDcyYmU1ZDc0ZjI3Yjg5NmYsIDB4ODBkZWIxZmUzYjE2OTZiMQorCS5kd29yZAkJMHg5YmRjMDZh NzI1YzcxMjM1LCAweGMxOWJmMTc0Y2Y2OTI2OTQKKwkuZHdvcmQJCTB4ZTQ5YjY5YzE5ZWYxNGFk MiwgMHhlZmJlNDc4NjM4NGYyNWUzCisJLmR3b3JkCQkweDBmYzE5ZGM2OGI4Y2Q1YjUsIDB4MjQw Y2ExY2M3N2FjOWM2NQorCS5kd29yZAkJMHgyZGU5MmM2ZjU5MmIwMjc1LCAweDRhNzQ4NGFhNmVh NmU0ODMKKwkuZHdvcmQJCTB4NWNiMGE5ZGNiZDQxZmJkNCwgMHg3NmY5ODhkYTgzMTE1M2I1CisJ LmR3b3JkCQkweDk4M2U1MTUyZWU2NmRmYWIsIDB4YTgzMWM2NmQyZGI0MzIxMAorCS5kd29yZAkJ MHhiMDAzMjdjODk4ZmIyMTNmLCAweGJmNTk3ZmM3YmVlZjBlZTQKKwkuZHdvcmQJCTB4YzZlMDBi ZjMzZGE4OGZjMiwgMHhkNWE3OTE0NzkzMGFhNzI1CisJLmR3b3JkCQkweDA2Y2E2MzUxZTAwMzgy NmYsIDB4MTQyOTI5NjcwYTBlNmU3MAorCS5kd29yZAkJMHgyN2I3MGE4NTQ2ZDIyZmZjLCAweDJl MWIyMTM4NWMyNmM5MjYKKwkuZHdvcmQJCTB4NGQyYzZkZmM1YWM0MmFlZCwgMHg1MzM4MGQxMzlk OTViM2RmCisJLmR3b3JkCQkweDY1MGE3MzU0OGJhZjYzZGUsIDB4NzY2YTBhYmIzYzc3YjJhOAor CS5kd29yZAkJMHg4MWMyYzkyZTQ3ZWRhZWU2LCAweDkyNzIyYzg1MTQ4MjM1M2IKKwkuZHdvcmQJ CTB4YTJiZmU4YTE0Y2YxMDM2NCwgMHhhODFhNjY0YmJjNDIzMDAxCisJLmR3b3JkCQkweGMyNGI4 YjcwZDBmODk3OTEsIDB4Yzc2YzUxYTMwNjU0YmUzMAorCS5kd29yZAkJMHhkMTkyZTgxOWQ2ZWY1 MjE4LCAweGQ2OTkwNjI0NTU2NWE5MTAKKwkuZHdvcmQJCTB4ZjQwZTM1ODU1NzcxMjAyYSwgMHgx MDZhYTA3MDMyYmJkMWI4CisJLmR3b3JkCQkweDE5YTRjMTE2YjhkMmQwYzgsIDB4MWUzNzZjMDg1 MTQxYWI1MworCS5kd29yZAkJMHgyNzQ4Nzc0Y2RmOGVlYjk5LCAweDM0YjBiY2I1ZTE5YjQ4YTgK KwkuZHdvcmQJCTB4MzkxYzBjYjNjNWM5NWE2MywgMHg0ZWQ4YWE0YWUzNDE4YWNiCisJLmR3b3Jk CQkweDViOWNjYTRmNzc2M2UzNzMsIDB4NjgyZTZmZjNkNmIyYjhhMworCS5kd29yZAkJMHg3NDhm ODJlZTVkZWZiMmZjLCAweDc4YTU2MzZmNDMxNzJmNjAKKwkuZHdvcmQJCTB4ODRjODc4MTRhMWYw YWI3MiwgMHg4Y2M3MDIwODFhNjQzOWVjCisJLmR3b3JkCQkweDkwYmVmZmZhMjM2MzFlMjgsIDB4 YTQ1MDZjZWJkZTgyYmRlOQorCS5kd29yZAkJMHhiZWY5YTNmN2IyYzY3OTE1LCAweGM2NzE3OGYy ZTM3MjUzMmIKKwkuZHdvcmQJCTB4Y2EyNzNlY2VlYTI2NjE5YywgMHhkMTg2YjhjNzIxYzBjMjA3 CisJLmR3b3JkCQkweGVhZGE3ZGQ2Y2RlMGViMWUsIDB4ZjU3ZDRmN2ZlZTZlZDE3OAorCS5kd29y ZAkJMHgwNmYwNjdhYTcyMTc2ZmJhLCAweDBhNjM3ZGM1YTJjODk4YTYKKwkuZHdvcmQJCTB4MTEz Zjk4MDRiZWY5MGRhZSwgMHgxYjcxMGIzNTEzMWM0NzFiCisJLmR3b3JkCQkweDI4ZGI3N2Y1MjMw NDdkODQsIDB4MzJjYWFiN2I0MGM3MjQ5MworCS5kd29yZAkJMHgzYzllYmUwYTE1YzliZWJjLCAw eDQzMWQ2N2M0OWMxMDBkNGMKKwkuZHdvcmQJCTB4NGNjNWQ0YmVjYjNlNDJiNiwgMHg1OTdmMjk5 Y2ZjNjU3ZTJhCisJLmR3b3JkCQkweDVmY2I2ZmFiM2FkNmZhZWMsIDB4NmM0NDE5OGM0YTQ3NTgx NworLnNpemUgSzUxMiwgLiAtIEs1MTIKLS0gCjIuNDMuMAoKCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51 eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21h aWxtYW4vbGlzdGluZm8vbGludXgtcmlzY3YK