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 X-Spam-Level: X-Spam-Status: No, score=-10.1 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B2D05C43331 for ; Sat, 9 Nov 2019 17:11:17 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 7D2F5214E0 for ; Sat, 9 Nov 2019 17:11:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1573319477; bh=s1mZKGupfLMG7LF1Q2qHHcPw04QtkXsIKT+mf9lWF88=; h=From:To:Cc:Subject:Date:In-Reply-To:References:List-ID:From; b=C/qHbBe3cdmXVl6yndIVPmA49OG+2sXDefYQvoxWVvVbbckI2fk12emVErI6oji8g I8BQzh1lnGB5ziVJ35LZdtwUKgzBsvwTP6OtU1Ps7wCe22mlyNR+zqu7L/0J98MeBf KtDeYs0i9gnJJD019JkvpfxYX+J2m0Sibk3R0EqA= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726582AbfKIRLR (ORCPT ); Sat, 9 Nov 2019 12:11:17 -0500 Received: from mail.kernel.org ([198.145.29.99]:40994 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726349AbfKIRLQ (ORCPT ); Sat, 9 Nov 2019 12:11:16 -0500 Received: from e123331-lin.home (lfbn-mar-1-643-104.w90-118.abo.wanadoo.fr [90.118.215.104]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id D9E4920659; Sat, 9 Nov 2019 17:11:13 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1573319475; bh=s1mZKGupfLMG7LF1Q2qHHcPw04QtkXsIKT+mf9lWF88=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=X6rdcrpJ7Xve2SCgBS+ZRFCZ0xAAad+66Edj8a9V42ok/VKLeGG+f8bzIzbC0E2Sp TUt6315eBkOhvJp+g/i/cO3jKuJAPKlMIMswgHffyNpWQY64AzB4+vis1Ajt3eK0Ri kLk+I+3T3x66GyKtqVSD6kpwUNPhz1FPDNtrldl4= From: Ard Biesheuvel To: linux-crypto@vger.kernel.org Cc: Ard Biesheuvel , Herbert Xu , "David S. Miller" , Eric Biggers , linux-arm-kernel@lists.infradead.org Subject: [PATCH v4 16/29] crypto: mxs - switch to skcipher API Date: Sat, 9 Nov 2019 18:09:41 +0100 Message-Id: <20191109170954.756-17-ardb@kernel.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20191109170954.756-1-ardb@kernel.org> References: <20191109170954.756-1-ardb@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-crypto-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-crypto@vger.kernel.org Commit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface") dated 20 august 2015 introduced the new skcipher API which is supposed to replace both blkcipher and ablkcipher. While all consumers of the API have been converted long ago, some producers of the ablkcipher remain, forcing us to keep the ablkcipher support routines alive, along with the matching code to expose [a]blkciphers via the skcipher API. So switch this driver to the skcipher API, allowing us to finally drop the ablkcipher code in the near future. Tested-by: Horia Geantă Signed-off-by: Ard Biesheuvel --- drivers/crypto/mxs-dcp.c | 140 +++++++++----------- 1 file changed, 65 insertions(+), 75 deletions(-) diff --git a/drivers/crypto/mxs-dcp.c b/drivers/crypto/mxs-dcp.c index bf8d2197bc11..f438b425c655 100644 --- a/drivers/crypto/mxs-dcp.c +++ b/drivers/crypto/mxs-dcp.c @@ -211,11 +211,11 @@ static int mxs_dcp_start_dma(struct dcp_async_ctx *actx) * Encryption (AES128) */ static int mxs_dcp_run_aes(struct dcp_async_ctx *actx, - struct ablkcipher_request *req, int init) + struct skcipher_request *req, int init) { struct dcp *sdcp = global_sdcp; struct dcp_dma_desc *desc = &sdcp->coh->desc[actx->chan]; - struct dcp_aes_req_ctx *rctx = ablkcipher_request_ctx(req); + struct dcp_aes_req_ctx *rctx = skcipher_request_ctx(req); int ret; dma_addr_t key_phys = dma_map_single(sdcp->dev, sdcp->coh->aes_key, @@ -274,9 +274,9 @@ static int mxs_dcp_aes_block_crypt(struct crypto_async_request *arq) { struct dcp *sdcp = global_sdcp; - struct ablkcipher_request *req = ablkcipher_request_cast(arq); + struct skcipher_request *req = skcipher_request_cast(arq); struct dcp_async_ctx *actx = crypto_tfm_ctx(arq->tfm); - struct dcp_aes_req_ctx *rctx = ablkcipher_request_ctx(req); + struct dcp_aes_req_ctx *rctx = skcipher_request_ctx(req); struct scatterlist *dst = req->dst; struct scatterlist *src = req->src; @@ -305,7 +305,7 @@ static int mxs_dcp_aes_block_crypt(struct crypto_async_request *arq) if (!rctx->ecb) { /* Copy the CBC IV just past the key. */ - memcpy(key + AES_KEYSIZE_128, req->info, AES_KEYSIZE_128); + memcpy(key + AES_KEYSIZE_128, req->iv, AES_KEYSIZE_128); /* CBC needs the INIT set. */ init = 1; } else { @@ -316,10 +316,10 @@ static int mxs_dcp_aes_block_crypt(struct crypto_async_request *arq) src_buf = sg_virt(src); len = sg_dma_len(src); tlen += len; - limit_hit = tlen > req->nbytes; + limit_hit = tlen > req->cryptlen; if (limit_hit) - len = req->nbytes - (tlen - len); + len = req->cryptlen - (tlen - len); do { if (actx->fill + len > out_off) @@ -375,10 +375,10 @@ static int mxs_dcp_aes_block_crypt(struct crypto_async_request *arq) /* Copy the IV for CBC for chaining */ if (!rctx->ecb) { if (rctx->enc) - memcpy(req->info, out_buf+(last_out_len-AES_BLOCK_SIZE), + memcpy(req->iv, out_buf+(last_out_len-AES_BLOCK_SIZE), AES_BLOCK_SIZE); else - memcpy(req->info, in_buf+(last_out_len-AES_BLOCK_SIZE), + memcpy(req->iv, in_buf+(last_out_len-AES_BLOCK_SIZE), AES_BLOCK_SIZE); } @@ -422,17 +422,17 @@ static int dcp_chan_thread_aes(void *data) return 0; } -static int mxs_dcp_block_fallback(struct ablkcipher_request *req, int enc) +static int mxs_dcp_block_fallback(struct skcipher_request *req, int enc) { - struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req); - struct dcp_async_ctx *ctx = crypto_ablkcipher_ctx(tfm); + struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); + struct dcp_async_ctx *ctx = crypto_skcipher_ctx(tfm); SYNC_SKCIPHER_REQUEST_ON_STACK(subreq, ctx->fallback); int ret; skcipher_request_set_sync_tfm(subreq, ctx->fallback); skcipher_request_set_callback(subreq, req->base.flags, NULL, NULL); skcipher_request_set_crypt(subreq, req->src, req->dst, - req->nbytes, req->info); + req->cryptlen, req->iv); if (enc) ret = crypto_skcipher_encrypt(subreq); @@ -444,12 +444,12 @@ static int mxs_dcp_block_fallback(struct ablkcipher_request *req, int enc) return ret; } -static int mxs_dcp_aes_enqueue(struct ablkcipher_request *req, int enc, int ecb) +static int mxs_dcp_aes_enqueue(struct skcipher_request *req, int enc, int ecb) { struct dcp *sdcp = global_sdcp; struct crypto_async_request *arq = &req->base; struct dcp_async_ctx *actx = crypto_tfm_ctx(arq->tfm); - struct dcp_aes_req_ctx *rctx = ablkcipher_request_ctx(req); + struct dcp_aes_req_ctx *rctx = skcipher_request_ctx(req); int ret; if (unlikely(actx->key_len != AES_KEYSIZE_128)) @@ -468,30 +468,30 @@ static int mxs_dcp_aes_enqueue(struct ablkcipher_request *req, int enc, int ecb) return ret; } -static int mxs_dcp_aes_ecb_decrypt(struct ablkcipher_request *req) +static int mxs_dcp_aes_ecb_decrypt(struct skcipher_request *req) { return mxs_dcp_aes_enqueue(req, 0, 1); } -static int mxs_dcp_aes_ecb_encrypt(struct ablkcipher_request *req) +static int mxs_dcp_aes_ecb_encrypt(struct skcipher_request *req) { return mxs_dcp_aes_enqueue(req, 1, 1); } -static int mxs_dcp_aes_cbc_decrypt(struct ablkcipher_request *req) +static int mxs_dcp_aes_cbc_decrypt(struct skcipher_request *req) { return mxs_dcp_aes_enqueue(req, 0, 0); } -static int mxs_dcp_aes_cbc_encrypt(struct ablkcipher_request *req) +static int mxs_dcp_aes_cbc_encrypt(struct skcipher_request *req) { return mxs_dcp_aes_enqueue(req, 1, 0); } -static int mxs_dcp_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key, +static int mxs_dcp_aes_setkey(struct crypto_skcipher *tfm, const u8 *key, unsigned int len) { - struct dcp_async_ctx *actx = crypto_ablkcipher_ctx(tfm); + struct dcp_async_ctx *actx = crypto_skcipher_ctx(tfm); unsigned int ret; /* @@ -525,10 +525,10 @@ static int mxs_dcp_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key, return ret; } -static int mxs_dcp_aes_fallback_init(struct crypto_tfm *tfm) +static int mxs_dcp_aes_fallback_init_tfm(struct crypto_skcipher *tfm) { - const char *name = crypto_tfm_alg_name(tfm); - struct dcp_async_ctx *actx = crypto_tfm_ctx(tfm); + const char *name = crypto_tfm_alg_name(crypto_skcipher_tfm(tfm)); + struct dcp_async_ctx *actx = crypto_skcipher_ctx(tfm); struct crypto_sync_skcipher *blk; blk = crypto_alloc_sync_skcipher(name, 0, CRYPTO_ALG_NEED_FALLBACK); @@ -536,13 +536,13 @@ static int mxs_dcp_aes_fallback_init(struct crypto_tfm *tfm) return PTR_ERR(blk); actx->fallback = blk; - tfm->crt_ablkcipher.reqsize = sizeof(struct dcp_aes_req_ctx); + crypto_skcipher_set_reqsize(tfm, sizeof(struct dcp_aes_req_ctx)); return 0; } -static void mxs_dcp_aes_fallback_exit(struct crypto_tfm *tfm) +static void mxs_dcp_aes_fallback_exit_tfm(struct crypto_skcipher *tfm) { - struct dcp_async_ctx *actx = crypto_tfm_ctx(tfm); + struct dcp_async_ctx *actx = crypto_skcipher_ctx(tfm); crypto_free_sync_skcipher(actx->fallback); } @@ -854,54 +854,44 @@ static void dcp_sha_cra_exit(struct crypto_tfm *tfm) } /* AES 128 ECB and AES 128 CBC */ -static struct crypto_alg dcp_aes_algs[] = { +static struct skcipher_alg dcp_aes_algs[] = { { - .cra_name = "ecb(aes)", - .cra_driver_name = "ecb-aes-dcp", - .cra_priority = 400, - .cra_alignmask = 15, - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | - CRYPTO_ALG_ASYNC | + .base.cra_name = "ecb(aes)", + .base.cra_driver_name = "ecb-aes-dcp", + .base.cra_priority = 400, + .base.cra_alignmask = 15, + .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, - .cra_init = mxs_dcp_aes_fallback_init, - .cra_exit = mxs_dcp_aes_fallback_exit, - .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct dcp_async_ctx), - .cra_type = &crypto_ablkcipher_type, - .cra_module = THIS_MODULE, - .cra_u = { - .ablkcipher = { - .min_keysize = AES_MIN_KEY_SIZE, - .max_keysize = AES_MAX_KEY_SIZE, - .setkey = mxs_dcp_aes_setkey, - .encrypt = mxs_dcp_aes_ecb_encrypt, - .decrypt = mxs_dcp_aes_ecb_decrypt - }, - }, + .base.cra_blocksize = AES_BLOCK_SIZE, + .base.cra_ctxsize = sizeof(struct dcp_async_ctx), + .base.cra_module = THIS_MODULE, + + .min_keysize = AES_MIN_KEY_SIZE, + .max_keysize = AES_MAX_KEY_SIZE, + .setkey = mxs_dcp_aes_setkey, + .encrypt = mxs_dcp_aes_ecb_encrypt, + .decrypt = mxs_dcp_aes_ecb_decrypt, + .init = mxs_dcp_aes_fallback_init_tfm, + .exit = mxs_dcp_aes_fallback_exit_tfm, }, { - .cra_name = "cbc(aes)", - .cra_driver_name = "cbc-aes-dcp", - .cra_priority = 400, - .cra_alignmask = 15, - .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | - CRYPTO_ALG_ASYNC | + .base.cra_name = "cbc(aes)", + .base.cra_driver_name = "cbc-aes-dcp", + .base.cra_priority = 400, + .base.cra_alignmask = 15, + .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, - .cra_init = mxs_dcp_aes_fallback_init, - .cra_exit = mxs_dcp_aes_fallback_exit, - .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct dcp_async_ctx), - .cra_type = &crypto_ablkcipher_type, - .cra_module = THIS_MODULE, - .cra_u = { - .ablkcipher = { - .min_keysize = AES_MIN_KEY_SIZE, - .max_keysize = AES_MAX_KEY_SIZE, - .setkey = mxs_dcp_aes_setkey, - .encrypt = mxs_dcp_aes_cbc_encrypt, - .decrypt = mxs_dcp_aes_cbc_decrypt, - .ivsize = AES_BLOCK_SIZE, - }, - }, + .base.cra_blocksize = AES_BLOCK_SIZE, + .base.cra_ctxsize = sizeof(struct dcp_async_ctx), + .base.cra_module = THIS_MODULE, + + .min_keysize = AES_MIN_KEY_SIZE, + .max_keysize = AES_MAX_KEY_SIZE, + .setkey = mxs_dcp_aes_setkey, + .encrypt = mxs_dcp_aes_cbc_encrypt, + .decrypt = mxs_dcp_aes_cbc_decrypt, + .ivsize = AES_BLOCK_SIZE, + .init = mxs_dcp_aes_fallback_init_tfm, + .exit = mxs_dcp_aes_fallback_exit_tfm, }, }; @@ -1104,8 +1094,8 @@ static int mxs_dcp_probe(struct platform_device *pdev) sdcp->caps = readl(sdcp->base + MXS_DCP_CAPABILITY1); if (sdcp->caps & MXS_DCP_CAPABILITY1_AES128) { - ret = crypto_register_algs(dcp_aes_algs, - ARRAY_SIZE(dcp_aes_algs)); + ret = crypto_register_skciphers(dcp_aes_algs, + ARRAY_SIZE(dcp_aes_algs)); if (ret) { /* Failed to register algorithm. */ dev_err(dev, "Failed to register AES crypto!\n"); @@ -1139,7 +1129,7 @@ static int mxs_dcp_probe(struct platform_device *pdev) err_unregister_aes: if (sdcp->caps & MXS_DCP_CAPABILITY1_AES128) - crypto_unregister_algs(dcp_aes_algs, ARRAY_SIZE(dcp_aes_algs)); + crypto_unregister_skciphers(dcp_aes_algs, ARRAY_SIZE(dcp_aes_algs)); err_destroy_aes_thread: kthread_stop(sdcp->thread[DCP_CHAN_CRYPTO]); @@ -1164,7 +1154,7 @@ static int mxs_dcp_remove(struct platform_device *pdev) crypto_unregister_ahash(&dcp_sha1_alg); if (sdcp->caps & MXS_DCP_CAPABILITY1_AES128) - crypto_unregister_algs(dcp_aes_algs, ARRAY_SIZE(dcp_aes_algs)); + crypto_unregister_skciphers(dcp_aes_algs, ARRAY_SIZE(dcp_aes_algs)); kthread_stop(sdcp->thread[DCP_CHAN_HASH_SHA]); kthread_stop(sdcp->thread[DCP_CHAN_CRYPTO]); -- 2.17.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-10.0 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE, SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 74AE7C43331 for ; Sat, 9 Nov 2019 17:16:38 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id 442D5214E0 for ; Sat, 9 Nov 2019 17:16:38 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="n8NMDzj3"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=kernel.org header.i=@kernel.org header.b="X6rdcrpJ" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 442D5214E0 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=RC/nQh1EmBYt/tNHTqGVElxl04OyuGKUVGf20uXsvoY=; b=n8NMDzj31KorBe Mr24DDgrn3IduCiP+QURAFAUmI/nvbWf/yXn9d/pP6wEiBpaJJC6MKdg+k+SrjMQFxSfnbK6sxW/m ajT/Ed7q34yo5e/dnW1ZIi5uCoKN8A7lUAgHAFVhkwAFPFqWezO9D8wMM5ux0zCHNG6cWDpOHQc45 GWxlMqJG565DVp+l4Mv13TA4TnOYQbbT9w36D+uR+YYM3NJM5G7G4eA9wAoi1ICrMsfpH1yYYj5EP L89vInyP+uxmMovtrgLyTOt667cfGjzzd3PW88fqoDHYufT24aN2S68LKrLdSpXmoHufu3R3BEUQi XSI/jzkQFSklS1srLNeQ==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1iTULl-0001kT-Cs; Sat, 09 Nov 2019 17:16:37 +0000 Received: from mail.kernel.org ([198.145.29.99]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1iTUGa-0004qF-LD for linux-arm-kernel@lists.infradead.org; Sat, 09 Nov 2019 17:11:22 +0000 Received: from e123331-lin.home (lfbn-mar-1-643-104.w90-118.abo.wanadoo.fr [90.118.215.104]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id D9E4920659; Sat, 9 Nov 2019 17:11:13 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1573319475; bh=s1mZKGupfLMG7LF1Q2qHHcPw04QtkXsIKT+mf9lWF88=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=X6rdcrpJ7Xve2SCgBS+ZRFCZ0xAAad+66Edj8a9V42ok/VKLeGG+f8bzIzbC0E2Sp TUt6315eBkOhvJp+g/i/cO3jKuJAPKlMIMswgHffyNpWQY64AzB4+vis1Ajt3eK0Ri kLk+I+3T3x66GyKtqVSD6kpwUNPhz1FPDNtrldl4= From: Ard Biesheuvel To: linux-crypto@vger.kernel.org Subject: [PATCH v4 16/29] crypto: mxs - switch to skcipher API Date: Sat, 9 Nov 2019 18:09:41 +0100 Message-Id: <20191109170954.756-17-ardb@kernel.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20191109170954.756-1-ardb@kernel.org> References: <20191109170954.756-1-ardb@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20191109_091116_898517_516D3832 X-CRM114-Status: GOOD ( 17.14 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: "David S. Miller" , Eric Biggers , Ard Biesheuvel , linux-arm-kernel@lists.infradead.org, Herbert Xu Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org Q29tbWl0IDdhN2ZmZTY1YzhjNSAoImNyeXB0bzogc2tjaXBoZXIgLSBBZGQgdG9wLWxldmVsIHNr Y2lwaGVyIGludGVyZmFjZSIpCmRhdGVkIDIwIGF1Z3VzdCAyMDE1IGludHJvZHVjZWQgdGhlIG5l dyBza2NpcGhlciBBUEkgd2hpY2ggaXMgc3VwcG9zZWQgdG8KcmVwbGFjZSBib3RoIGJsa2NpcGhl ciBhbmQgYWJsa2NpcGhlci4gV2hpbGUgYWxsIGNvbnN1bWVycyBvZiB0aGUgQVBJIGhhdmUKYmVl biBjb252ZXJ0ZWQgbG9uZyBhZ28sIHNvbWUgcHJvZHVjZXJzIG9mIHRoZSBhYmxrY2lwaGVyIHJl bWFpbiwgZm9yY2luZwp1cyB0byBrZWVwIHRoZSBhYmxrY2lwaGVyIHN1cHBvcnQgcm91dGluZXMg YWxpdmUsIGFsb25nIHdpdGggdGhlIG1hdGNoaW5nCmNvZGUgdG8gZXhwb3NlIFthXWJsa2NpcGhl cnMgdmlhIHRoZSBza2NpcGhlciBBUEkuCgpTbyBzd2l0Y2ggdGhpcyBkcml2ZXIgdG8gdGhlIHNr Y2lwaGVyIEFQSSwgYWxsb3dpbmcgdXMgdG8gZmluYWxseSBkcm9wIHRoZQphYmxrY2lwaGVyIGNv ZGUgaW4gdGhlIG5lYXIgZnV0dXJlLgoKVGVzdGVkLWJ5OiBIb3JpYSBHZWFudMSDIDxob3JpYS5n ZWFudGFAbnhwLmNvbT4KU2lnbmVkLW9mZi1ieTogQXJkIEJpZXNoZXV2ZWwgPGFyZGJAa2VybmVs Lm9yZz4KLS0tCiBkcml2ZXJzL2NyeXB0by9teHMtZGNwLmMgfCAxNDAgKysrKysrKysrLS0tLS0t LS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCA2NSBpbnNlcnRpb25zKCspLCA3NSBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NyeXB0by9teHMtZGNwLmMgYi9kcml2ZXJzL2NyeXB0by9t eHMtZGNwLmMKaW5kZXggYmY4ZDIxOTdiYzExLi5mNDM4YjQyNWM2NTUgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvY3J5cHRvL214cy1kY3AuYworKysgYi9kcml2ZXJzL2NyeXB0by9teHMtZGNwLmMKQEAg LTIxMSwxMSArMjExLDExIEBAIHN0YXRpYyBpbnQgbXhzX2RjcF9zdGFydF9kbWEoc3RydWN0IGRj cF9hc3luY19jdHggKmFjdHgpCiAgKiBFbmNyeXB0aW9uIChBRVMxMjgpCiAgKi8KIHN0YXRpYyBp bnQgbXhzX2RjcF9ydW5fYWVzKHN0cnVjdCBkY3BfYXN5bmNfY3R4ICphY3R4LAotCQkJICAgc3Ry dWN0IGFibGtjaXBoZXJfcmVxdWVzdCAqcmVxLCBpbnQgaW5pdCkKKwkJCSAgIHN0cnVjdCBza2Np cGhlcl9yZXF1ZXN0ICpyZXEsIGludCBpbml0KQogewogCXN0cnVjdCBkY3AgKnNkY3AgPSBnbG9i YWxfc2RjcDsKIAlzdHJ1Y3QgZGNwX2RtYV9kZXNjICpkZXNjID0gJnNkY3AtPmNvaC0+ZGVzY1th Y3R4LT5jaGFuXTsKLQlzdHJ1Y3QgZGNwX2Flc19yZXFfY3R4ICpyY3R4ID0gYWJsa2NpcGhlcl9y ZXF1ZXN0X2N0eChyZXEpOworCXN0cnVjdCBkY3BfYWVzX3JlcV9jdHggKnJjdHggPSBza2NpcGhl cl9yZXF1ZXN0X2N0eChyZXEpOwogCWludCByZXQ7CiAKIAlkbWFfYWRkcl90IGtleV9waHlzID0g ZG1hX21hcF9zaW5nbGUoc2RjcC0+ZGV2LCBzZGNwLT5jb2gtPmFlc19rZXksCkBAIC0yNzQsOSAr Mjc0LDkgQEAgc3RhdGljIGludCBteHNfZGNwX2Flc19ibG9ja19jcnlwdChzdHJ1Y3QgY3J5cHRv X2FzeW5jX3JlcXVlc3QgKmFycSkKIHsKIAlzdHJ1Y3QgZGNwICpzZGNwID0gZ2xvYmFsX3NkY3A7 CiAKLQlzdHJ1Y3QgYWJsa2NpcGhlcl9yZXF1ZXN0ICpyZXEgPSBhYmxrY2lwaGVyX3JlcXVlc3Rf Y2FzdChhcnEpOworCXN0cnVjdCBza2NpcGhlcl9yZXF1ZXN0ICpyZXEgPSBza2NpcGhlcl9yZXF1 ZXN0X2Nhc3QoYXJxKTsKIAlzdHJ1Y3QgZGNwX2FzeW5jX2N0eCAqYWN0eCA9IGNyeXB0b190Zm1f Y3R4KGFycS0+dGZtKTsKLQlzdHJ1Y3QgZGNwX2Flc19yZXFfY3R4ICpyY3R4ID0gYWJsa2NpcGhl cl9yZXF1ZXN0X2N0eChyZXEpOworCXN0cnVjdCBkY3BfYWVzX3JlcV9jdHggKnJjdHggPSBza2Np cGhlcl9yZXF1ZXN0X2N0eChyZXEpOwogCiAJc3RydWN0IHNjYXR0ZXJsaXN0ICpkc3QgPSByZXEt PmRzdDsKIAlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNyYyA9IHJlcS0+c3JjOwpAQCAtMzA1LDcgKzMw NSw3IEBAIHN0YXRpYyBpbnQgbXhzX2RjcF9hZXNfYmxvY2tfY3J5cHQoc3RydWN0IGNyeXB0b19h c3luY19yZXF1ZXN0ICphcnEpCiAKIAlpZiAoIXJjdHgtPmVjYikgewogCQkvKiBDb3B5IHRoZSBD QkMgSVYganVzdCBwYXN0IHRoZSBrZXkuICovCi0JCW1lbWNweShrZXkgKyBBRVNfS0VZU0laRV8x MjgsIHJlcS0+aW5mbywgQUVTX0tFWVNJWkVfMTI4KTsKKwkJbWVtY3B5KGtleSArIEFFU19LRVlT SVpFXzEyOCwgcmVxLT5pdiwgQUVTX0tFWVNJWkVfMTI4KTsKIAkJLyogQ0JDIG5lZWRzIHRoZSBJ TklUIHNldC4gKi8KIAkJaW5pdCA9IDE7CiAJfSBlbHNlIHsKQEAgLTMxNiwxMCArMzE2LDEwIEBA IHN0YXRpYyBpbnQgbXhzX2RjcF9hZXNfYmxvY2tfY3J5cHQoc3RydWN0IGNyeXB0b19hc3luY19y ZXF1ZXN0ICphcnEpCiAJCXNyY19idWYgPSBzZ192aXJ0KHNyYyk7CiAJCWxlbiA9IHNnX2RtYV9s ZW4oc3JjKTsKIAkJdGxlbiArPSBsZW47Ci0JCWxpbWl0X2hpdCA9IHRsZW4gPiByZXEtPm5ieXRl czsKKwkJbGltaXRfaGl0ID0gdGxlbiA+IHJlcS0+Y3J5cHRsZW47CiAKIAkJaWYgKGxpbWl0X2hp dCkKLQkJCWxlbiA9IHJlcS0+bmJ5dGVzIC0gKHRsZW4gLSBsZW4pOworCQkJbGVuID0gcmVxLT5j cnlwdGxlbiAtICh0bGVuIC0gbGVuKTsKIAogCQlkbyB7CiAJCQlpZiAoYWN0eC0+ZmlsbCArIGxl biA+IG91dF9vZmYpCkBAIC0zNzUsMTAgKzM3NSwxMCBAQCBzdGF0aWMgaW50IG14c19kY3BfYWVz X2Jsb2NrX2NyeXB0KHN0cnVjdCBjcnlwdG9fYXN5bmNfcmVxdWVzdCAqYXJxKQogCS8qIENvcHkg dGhlIElWIGZvciBDQkMgZm9yIGNoYWluaW5nICovCiAJaWYgKCFyY3R4LT5lY2IpIHsKIAkJaWYg KHJjdHgtPmVuYykKLQkJCW1lbWNweShyZXEtPmluZm8sIG91dF9idWYrKGxhc3Rfb3V0X2xlbi1B RVNfQkxPQ0tfU0laRSksCisJCQltZW1jcHkocmVxLT5pdiwgb3V0X2J1ZisobGFzdF9vdXRfbGVu LUFFU19CTE9DS19TSVpFKSwKIAkJCQlBRVNfQkxPQ0tfU0laRSk7CiAJCWVsc2UKLQkJCW1lbWNw eShyZXEtPmluZm8sIGluX2J1ZisobGFzdF9vdXRfbGVuLUFFU19CTE9DS19TSVpFKSwKKwkJCW1l bWNweShyZXEtPml2LCBpbl9idWYrKGxhc3Rfb3V0X2xlbi1BRVNfQkxPQ0tfU0laRSksCiAJCQkJ QUVTX0JMT0NLX1NJWkUpOwogCX0KIApAQCAtNDIyLDE3ICs0MjIsMTcgQEAgc3RhdGljIGludCBk Y3BfY2hhbl90aHJlYWRfYWVzKHZvaWQgKmRhdGEpCiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBp bnQgbXhzX2RjcF9ibG9ja19mYWxsYmFjayhzdHJ1Y3QgYWJsa2NpcGhlcl9yZXF1ZXN0ICpyZXEs IGludCBlbmMpCitzdGF0aWMgaW50IG14c19kY3BfYmxvY2tfZmFsbGJhY2soc3RydWN0IHNrY2lw aGVyX3JlcXVlc3QgKnJlcSwgaW50IGVuYykKIHsKLQlzdHJ1Y3QgY3J5cHRvX2FibGtjaXBoZXIg KnRmbSA9IGNyeXB0b19hYmxrY2lwaGVyX3JlcXRmbShyZXEpOwotCXN0cnVjdCBkY3BfYXN5bmNf Y3R4ICpjdHggPSBjcnlwdG9fYWJsa2NpcGhlcl9jdHgodGZtKTsKKwlzdHJ1Y3QgY3J5cHRvX3Nr Y2lwaGVyICp0Zm0gPSBjcnlwdG9fc2tjaXBoZXJfcmVxdGZtKHJlcSk7CisJc3RydWN0IGRjcF9h c3luY19jdHggKmN0eCA9IGNyeXB0b19za2NpcGhlcl9jdHgodGZtKTsKIAlTWU5DX1NLQ0lQSEVS X1JFUVVFU1RfT05fU1RBQ0soc3VicmVxLCBjdHgtPmZhbGxiYWNrKTsKIAlpbnQgcmV0OwogCiAJ c2tjaXBoZXJfcmVxdWVzdF9zZXRfc3luY190Zm0oc3VicmVxLCBjdHgtPmZhbGxiYWNrKTsKIAlz a2NpcGhlcl9yZXF1ZXN0X3NldF9jYWxsYmFjayhzdWJyZXEsIHJlcS0+YmFzZS5mbGFncywgTlVM TCwgTlVMTCk7CiAJc2tjaXBoZXJfcmVxdWVzdF9zZXRfY3J5cHQoc3VicmVxLCByZXEtPnNyYywg cmVxLT5kc3QsCi0JCQkJICAgcmVxLT5uYnl0ZXMsIHJlcS0+aW5mbyk7CisJCQkJICAgcmVxLT5j cnlwdGxlbiwgcmVxLT5pdik7CiAKIAlpZiAoZW5jKQogCQlyZXQgPSBjcnlwdG9fc2tjaXBoZXJf ZW5jcnlwdChzdWJyZXEpOwpAQCAtNDQ0LDEyICs0NDQsMTIgQEAgc3RhdGljIGludCBteHNfZGNw X2Jsb2NrX2ZhbGxiYWNrKHN0cnVjdCBhYmxrY2lwaGVyX3JlcXVlc3QgKnJlcSwgaW50IGVuYykK IAlyZXR1cm4gcmV0OwogfQogCi1zdGF0aWMgaW50IG14c19kY3BfYWVzX2VucXVldWUoc3RydWN0 IGFibGtjaXBoZXJfcmVxdWVzdCAqcmVxLCBpbnQgZW5jLCBpbnQgZWNiKQorc3RhdGljIGludCBt eHNfZGNwX2Flc19lbnF1ZXVlKHN0cnVjdCBza2NpcGhlcl9yZXF1ZXN0ICpyZXEsIGludCBlbmMs IGludCBlY2IpCiB7CiAJc3RydWN0IGRjcCAqc2RjcCA9IGdsb2JhbF9zZGNwOwogCXN0cnVjdCBj cnlwdG9fYXN5bmNfcmVxdWVzdCAqYXJxID0gJnJlcS0+YmFzZTsKIAlzdHJ1Y3QgZGNwX2FzeW5j X2N0eCAqYWN0eCA9IGNyeXB0b190Zm1fY3R4KGFycS0+dGZtKTsKLQlzdHJ1Y3QgZGNwX2Flc19y ZXFfY3R4ICpyY3R4ID0gYWJsa2NpcGhlcl9yZXF1ZXN0X2N0eChyZXEpOworCXN0cnVjdCBkY3Bf YWVzX3JlcV9jdHggKnJjdHggPSBza2NpcGhlcl9yZXF1ZXN0X2N0eChyZXEpOwogCWludCByZXQ7 CiAKIAlpZiAodW5saWtlbHkoYWN0eC0+a2V5X2xlbiAhPSBBRVNfS0VZU0laRV8xMjgpKQpAQCAt NDY4LDMwICs0NjgsMzAgQEAgc3RhdGljIGludCBteHNfZGNwX2Flc19lbnF1ZXVlKHN0cnVjdCBh YmxrY2lwaGVyX3JlcXVlc3QgKnJlcSwgaW50IGVuYywgaW50IGVjYikKIAlyZXR1cm4gcmV0Owog fQogCi1zdGF0aWMgaW50IG14c19kY3BfYWVzX2VjYl9kZWNyeXB0KHN0cnVjdCBhYmxrY2lwaGVy X3JlcXVlc3QgKnJlcSkKK3N0YXRpYyBpbnQgbXhzX2RjcF9hZXNfZWNiX2RlY3J5cHQoc3RydWN0 IHNrY2lwaGVyX3JlcXVlc3QgKnJlcSkKIHsKIAlyZXR1cm4gbXhzX2RjcF9hZXNfZW5xdWV1ZShy ZXEsIDAsIDEpOwogfQogCi1zdGF0aWMgaW50IG14c19kY3BfYWVzX2VjYl9lbmNyeXB0KHN0cnVj dCBhYmxrY2lwaGVyX3JlcXVlc3QgKnJlcSkKK3N0YXRpYyBpbnQgbXhzX2RjcF9hZXNfZWNiX2Vu Y3J5cHQoc3RydWN0IHNrY2lwaGVyX3JlcXVlc3QgKnJlcSkKIHsKIAlyZXR1cm4gbXhzX2RjcF9h ZXNfZW5xdWV1ZShyZXEsIDEsIDEpOwogfQogCi1zdGF0aWMgaW50IG14c19kY3BfYWVzX2NiY19k ZWNyeXB0KHN0cnVjdCBhYmxrY2lwaGVyX3JlcXVlc3QgKnJlcSkKK3N0YXRpYyBpbnQgbXhzX2Rj cF9hZXNfY2JjX2RlY3J5cHQoc3RydWN0IHNrY2lwaGVyX3JlcXVlc3QgKnJlcSkKIHsKIAlyZXR1 cm4gbXhzX2RjcF9hZXNfZW5xdWV1ZShyZXEsIDAsIDApOwogfQogCi1zdGF0aWMgaW50IG14c19k Y3BfYWVzX2NiY19lbmNyeXB0KHN0cnVjdCBhYmxrY2lwaGVyX3JlcXVlc3QgKnJlcSkKK3N0YXRp YyBpbnQgbXhzX2RjcF9hZXNfY2JjX2VuY3J5cHQoc3RydWN0IHNrY2lwaGVyX3JlcXVlc3QgKnJl cSkKIHsKIAlyZXR1cm4gbXhzX2RjcF9hZXNfZW5xdWV1ZShyZXEsIDEsIDApOwogfQogCi1zdGF0 aWMgaW50IG14c19kY3BfYWVzX3NldGtleShzdHJ1Y3QgY3J5cHRvX2FibGtjaXBoZXIgKnRmbSwg Y29uc3QgdTggKmtleSwKK3N0YXRpYyBpbnQgbXhzX2RjcF9hZXNfc2V0a2V5KHN0cnVjdCBjcnlw dG9fc2tjaXBoZXIgKnRmbSwgY29uc3QgdTggKmtleSwKIAkJCSAgICAgIHVuc2lnbmVkIGludCBs ZW4pCiB7Ci0Jc3RydWN0IGRjcF9hc3luY19jdHggKmFjdHggPSBjcnlwdG9fYWJsa2NpcGhlcl9j dHgodGZtKTsKKwlzdHJ1Y3QgZGNwX2FzeW5jX2N0eCAqYWN0eCA9IGNyeXB0b19za2NpcGhlcl9j dHgodGZtKTsKIAl1bnNpZ25lZCBpbnQgcmV0OwogCiAJLyoKQEAgLTUyNSwxMCArNTI1LDEwIEBA IHN0YXRpYyBpbnQgbXhzX2RjcF9hZXNfc2V0a2V5KHN0cnVjdCBjcnlwdG9fYWJsa2NpcGhlciAq dGZtLCBjb25zdCB1OCAqa2V5LAogCXJldHVybiByZXQ7CiB9CiAKLXN0YXRpYyBpbnQgbXhzX2Rj cF9hZXNfZmFsbGJhY2tfaW5pdChzdHJ1Y3QgY3J5cHRvX3RmbSAqdGZtKQorc3RhdGljIGludCBt eHNfZGNwX2Flc19mYWxsYmFja19pbml0X3RmbShzdHJ1Y3QgY3J5cHRvX3NrY2lwaGVyICp0Zm0p CiB7Ci0JY29uc3QgY2hhciAqbmFtZSA9IGNyeXB0b190Zm1fYWxnX25hbWUodGZtKTsKLQlzdHJ1 Y3QgZGNwX2FzeW5jX2N0eCAqYWN0eCA9IGNyeXB0b190Zm1fY3R4KHRmbSk7CisJY29uc3QgY2hh ciAqbmFtZSA9IGNyeXB0b190Zm1fYWxnX25hbWUoY3J5cHRvX3NrY2lwaGVyX3RmbSh0Zm0pKTsK KwlzdHJ1Y3QgZGNwX2FzeW5jX2N0eCAqYWN0eCA9IGNyeXB0b19za2NpcGhlcl9jdHgodGZtKTsK IAlzdHJ1Y3QgY3J5cHRvX3N5bmNfc2tjaXBoZXIgKmJsazsKIAogCWJsayA9IGNyeXB0b19hbGxv Y19zeW5jX3NrY2lwaGVyKG5hbWUsIDAsIENSWVBUT19BTEdfTkVFRF9GQUxMQkFDSyk7CkBAIC01 MzYsMTMgKzUzNiwxMyBAQCBzdGF0aWMgaW50IG14c19kY3BfYWVzX2ZhbGxiYWNrX2luaXQoc3Ry dWN0IGNyeXB0b190Zm0gKnRmbSkKIAkJcmV0dXJuIFBUUl9FUlIoYmxrKTsKIAogCWFjdHgtPmZh bGxiYWNrID0gYmxrOwotCXRmbS0+Y3J0X2FibGtjaXBoZXIucmVxc2l6ZSA9IHNpemVvZihzdHJ1 Y3QgZGNwX2Flc19yZXFfY3R4KTsKKwljcnlwdG9fc2tjaXBoZXJfc2V0X3JlcXNpemUodGZtLCBz aXplb2Yoc3RydWN0IGRjcF9hZXNfcmVxX2N0eCkpOwogCXJldHVybiAwOwogfQogCi1zdGF0aWMg dm9pZCBteHNfZGNwX2Flc19mYWxsYmFja19leGl0KHN0cnVjdCBjcnlwdG9fdGZtICp0Zm0pCitz dGF0aWMgdm9pZCBteHNfZGNwX2Flc19mYWxsYmFja19leGl0X3RmbShzdHJ1Y3QgY3J5cHRvX3Nr Y2lwaGVyICp0Zm0pCiB7Ci0Jc3RydWN0IGRjcF9hc3luY19jdHggKmFjdHggPSBjcnlwdG9fdGZt X2N0eCh0Zm0pOworCXN0cnVjdCBkY3BfYXN5bmNfY3R4ICphY3R4ID0gY3J5cHRvX3NrY2lwaGVy X2N0eCh0Zm0pOwogCiAJY3J5cHRvX2ZyZWVfc3luY19za2NpcGhlcihhY3R4LT5mYWxsYmFjayk7 CiB9CkBAIC04NTQsNTQgKzg1NCw0NCBAQCBzdGF0aWMgdm9pZCBkY3Bfc2hhX2NyYV9leGl0KHN0 cnVjdCBjcnlwdG9fdGZtICp0Zm0pCiB9CiAKIC8qIEFFUyAxMjggRUNCIGFuZCBBRVMgMTI4IENC QyAqLwotc3RhdGljIHN0cnVjdCBjcnlwdG9fYWxnIGRjcF9hZXNfYWxnc1tdID0geworc3RhdGlj IHN0cnVjdCBza2NpcGhlcl9hbGcgZGNwX2Flc19hbGdzW10gPSB7CiAJewotCQkuY3JhX25hbWUJ CT0gImVjYihhZXMpIiwKLQkJLmNyYV9kcml2ZXJfbmFtZQk9ICJlY2ItYWVzLWRjcCIsCi0JCS5j cmFfcHJpb3JpdHkJCT0gNDAwLAotCQkuY3JhX2FsaWdubWFzawkJPSAxNSwKLQkJLmNyYV9mbGFn cwkJPSBDUllQVE9fQUxHX1RZUEVfQUJMS0NJUEhFUiB8Ci0JCQkJCSAgQ1JZUFRPX0FMR19BU1lO QyB8CisJCS5iYXNlLmNyYV9uYW1lCQk9ICJlY2IoYWVzKSIsCisJCS5iYXNlLmNyYV9kcml2ZXJf bmFtZQk9ICJlY2ItYWVzLWRjcCIsCisJCS5iYXNlLmNyYV9wcmlvcml0eQk9IDQwMCwKKwkJLmJh c2UuY3JhX2FsaWdubWFzawk9IDE1LAorCQkuYmFzZS5jcmFfZmxhZ3MJCT0gQ1JZUFRPX0FMR19B U1lOQyB8CiAJCQkJCSAgQ1JZUFRPX0FMR19ORUVEX0ZBTExCQUNLLAotCQkuY3JhX2luaXQJCT0g bXhzX2RjcF9hZXNfZmFsbGJhY2tfaW5pdCwKLQkJLmNyYV9leGl0CQk9IG14c19kY3BfYWVzX2Zh bGxiYWNrX2V4aXQsCi0JCS5jcmFfYmxvY2tzaXplCQk9IEFFU19CTE9DS19TSVpFLAotCQkuY3Jh X2N0eHNpemUJCT0gc2l6ZW9mKHN0cnVjdCBkY3BfYXN5bmNfY3R4KSwKLQkJLmNyYV90eXBlCQk9 ICZjcnlwdG9fYWJsa2NpcGhlcl90eXBlLAotCQkuY3JhX21vZHVsZQkJPSBUSElTX01PRFVMRSwK LQkJLmNyYV91CT0gewotCQkJLmFibGtjaXBoZXIgPSB7Ci0JCQkJLm1pbl9rZXlzaXplCT0gQUVT X01JTl9LRVlfU0laRSwKLQkJCQkubWF4X2tleXNpemUJPSBBRVNfTUFYX0tFWV9TSVpFLAotCQkJ CS5zZXRrZXkJCT0gbXhzX2RjcF9hZXNfc2V0a2V5LAotCQkJCS5lbmNyeXB0CT0gbXhzX2RjcF9h ZXNfZWNiX2VuY3J5cHQsCi0JCQkJLmRlY3J5cHQJPSBteHNfZGNwX2Flc19lY2JfZGVjcnlwdAot CQkJfSwKLQkJfSwKKwkJLmJhc2UuY3JhX2Jsb2Nrc2l6ZQk9IEFFU19CTE9DS19TSVpFLAorCQku YmFzZS5jcmFfY3R4c2l6ZQk9IHNpemVvZihzdHJ1Y3QgZGNwX2FzeW5jX2N0eCksCisJCS5iYXNl LmNyYV9tb2R1bGUJPSBUSElTX01PRFVMRSwKKworCQkubWluX2tleXNpemUJCT0gQUVTX01JTl9L RVlfU0laRSwKKwkJLm1heF9rZXlzaXplCQk9IEFFU19NQVhfS0VZX1NJWkUsCisJCS5zZXRrZXkJ CQk9IG14c19kY3BfYWVzX3NldGtleSwKKwkJLmVuY3J5cHQJCT0gbXhzX2RjcF9hZXNfZWNiX2Vu Y3J5cHQsCisJCS5kZWNyeXB0CQk9IG14c19kY3BfYWVzX2VjYl9kZWNyeXB0LAorCQkuaW5pdAkJ CT0gbXhzX2RjcF9hZXNfZmFsbGJhY2tfaW5pdF90Zm0sCisJCS5leGl0CQkJPSBteHNfZGNwX2Fl c19mYWxsYmFja19leGl0X3RmbSwKIAl9LCB7Ci0JCS5jcmFfbmFtZQkJPSAiY2JjKGFlcykiLAot CQkuY3JhX2RyaXZlcl9uYW1lCT0gImNiYy1hZXMtZGNwIiwKLQkJLmNyYV9wcmlvcml0eQkJPSA0 MDAsCi0JCS5jcmFfYWxpZ25tYXNrCQk9IDE1LAotCQkuY3JhX2ZsYWdzCQk9IENSWVBUT19BTEdf VFlQRV9BQkxLQ0lQSEVSIHwKLQkJCQkJICBDUllQVE9fQUxHX0FTWU5DIHwKKwkJLmJhc2UuY3Jh X25hbWUJCT0gImNiYyhhZXMpIiwKKwkJLmJhc2UuY3JhX2RyaXZlcl9uYW1lCT0gImNiYy1hZXMt ZGNwIiwKKwkJLmJhc2UuY3JhX3ByaW9yaXR5CT0gNDAwLAorCQkuYmFzZS5jcmFfYWxpZ25tYXNr CT0gMTUsCisJCS5iYXNlLmNyYV9mbGFncwkJPSBDUllQVE9fQUxHX0FTWU5DIHwKIAkJCQkJICBD UllQVE9fQUxHX05FRURfRkFMTEJBQ0ssCi0JCS5jcmFfaW5pdAkJPSBteHNfZGNwX2Flc19mYWxs YmFja19pbml0LAotCQkuY3JhX2V4aXQJCT0gbXhzX2RjcF9hZXNfZmFsbGJhY2tfZXhpdCwKLQkJ LmNyYV9ibG9ja3NpemUJCT0gQUVTX0JMT0NLX1NJWkUsCi0JCS5jcmFfY3R4c2l6ZQkJPSBzaXpl b2Yoc3RydWN0IGRjcF9hc3luY19jdHgpLAotCQkuY3JhX3R5cGUJCT0gJmNyeXB0b19hYmxrY2lw aGVyX3R5cGUsCi0JCS5jcmFfbW9kdWxlCQk9IFRISVNfTU9EVUxFLAotCQkuY3JhX3UgPSB7Ci0J CQkuYWJsa2NpcGhlciA9IHsKLQkJCQkubWluX2tleXNpemUJPSBBRVNfTUlOX0tFWV9TSVpFLAot CQkJCS5tYXhfa2V5c2l6ZQk9IEFFU19NQVhfS0VZX1NJWkUsCi0JCQkJLnNldGtleQkJPSBteHNf ZGNwX2Flc19zZXRrZXksCi0JCQkJLmVuY3J5cHQJPSBteHNfZGNwX2Flc19jYmNfZW5jcnlwdCwK LQkJCQkuZGVjcnlwdAk9IG14c19kY3BfYWVzX2NiY19kZWNyeXB0LAotCQkJCS5pdnNpemUJCT0g QUVTX0JMT0NLX1NJWkUsCi0JCQl9LAotCQl9LAorCQkuYmFzZS5jcmFfYmxvY2tzaXplCT0gQUVT X0JMT0NLX1NJWkUsCisJCS5iYXNlLmNyYV9jdHhzaXplCT0gc2l6ZW9mKHN0cnVjdCBkY3BfYXN5 bmNfY3R4KSwKKwkJLmJhc2UuY3JhX21vZHVsZQk9IFRISVNfTU9EVUxFLAorCisJCS5taW5fa2V5 c2l6ZQkJPSBBRVNfTUlOX0tFWV9TSVpFLAorCQkubWF4X2tleXNpemUJCT0gQUVTX01BWF9LRVlf U0laRSwKKwkJLnNldGtleQkJCT0gbXhzX2RjcF9hZXNfc2V0a2V5LAorCQkuZW5jcnlwdAkJPSBt eHNfZGNwX2Flc19jYmNfZW5jcnlwdCwKKwkJLmRlY3J5cHQJCT0gbXhzX2RjcF9hZXNfY2JjX2Rl Y3J5cHQsCisJCS5pdnNpemUJCQk9IEFFU19CTE9DS19TSVpFLAorCQkuaW5pdAkJCT0gbXhzX2Rj cF9hZXNfZmFsbGJhY2tfaW5pdF90Zm0sCisJCS5leGl0CQkJPSBteHNfZGNwX2Flc19mYWxsYmFj a19leGl0X3RmbSwKIAl9LAogfTsKIApAQCAtMTEwNCw4ICsxMDk0LDggQEAgc3RhdGljIGludCBt eHNfZGNwX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJc2RjcC0+Y2FwcyA9 IHJlYWRsKHNkY3AtPmJhc2UgKyBNWFNfRENQX0NBUEFCSUxJVFkxKTsKIAogCWlmIChzZGNwLT5j YXBzICYgTVhTX0RDUF9DQVBBQklMSVRZMV9BRVMxMjgpIHsKLQkJcmV0ID0gY3J5cHRvX3JlZ2lz dGVyX2FsZ3MoZGNwX2Flc19hbGdzLAotCQkJCQkgICBBUlJBWV9TSVpFKGRjcF9hZXNfYWxncykp OworCQlyZXQgPSBjcnlwdG9fcmVnaXN0ZXJfc2tjaXBoZXJzKGRjcF9hZXNfYWxncywKKwkJCQkJ CUFSUkFZX1NJWkUoZGNwX2Flc19hbGdzKSk7CiAJCWlmIChyZXQpIHsKIAkJCS8qIEZhaWxlZCB0 byByZWdpc3RlciBhbGdvcml0aG0uICovCiAJCQlkZXZfZXJyKGRldiwgIkZhaWxlZCB0byByZWdp c3RlciBBRVMgY3J5cHRvIVxuIik7CkBAIC0xMTM5LDcgKzExMjksNyBAQCBzdGF0aWMgaW50IG14 c19kY3BfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAogZXJyX3VucmVnaXN0 ZXJfYWVzOgogCWlmIChzZGNwLT5jYXBzICYgTVhTX0RDUF9DQVBBQklMSVRZMV9BRVMxMjgpCi0J CWNyeXB0b191bnJlZ2lzdGVyX2FsZ3MoZGNwX2Flc19hbGdzLCBBUlJBWV9TSVpFKGRjcF9hZXNf YWxncykpOworCQljcnlwdG9fdW5yZWdpc3Rlcl9za2NpcGhlcnMoZGNwX2Flc19hbGdzLCBBUlJB WV9TSVpFKGRjcF9hZXNfYWxncykpOwogCiBlcnJfZGVzdHJveV9hZXNfdGhyZWFkOgogCWt0aHJl YWRfc3RvcChzZGNwLT50aHJlYWRbRENQX0NIQU5fQ1JZUFRPXSk7CkBAIC0xMTY0LDcgKzExNTQs NyBAQCBzdGF0aWMgaW50IG14c19kY3BfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBk ZXYpCiAJCWNyeXB0b191bnJlZ2lzdGVyX2FoYXNoKCZkY3Bfc2hhMV9hbGcpOwogCiAJaWYgKHNk Y3AtPmNhcHMgJiBNWFNfRENQX0NBUEFCSUxJVFkxX0FFUzEyOCkKLQkJY3J5cHRvX3VucmVnaXN0 ZXJfYWxncyhkY3BfYWVzX2FsZ3MsIEFSUkFZX1NJWkUoZGNwX2Flc19hbGdzKSk7CisJCWNyeXB0 b191bnJlZ2lzdGVyX3NrY2lwaGVycyhkY3BfYWVzX2FsZ3MsIEFSUkFZX1NJWkUoZGNwX2Flc19h bGdzKSk7CiAKIAlrdGhyZWFkX3N0b3Aoc2RjcC0+dGhyZWFkW0RDUF9DSEFOX0hBU0hfU0hBXSk7 CiAJa3RocmVhZF9zdG9wKHNkY3AtPnRocmVhZFtEQ1BfQ0hBTl9DUllQVE9dKTsKLS0gCjIuMTcu MQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4 LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFk Lm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFy bS1rZXJuZWwK