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=-14.0 required=3.0 tests=BAYES_00,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS 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 C8C87C433E6 for ; Mon, 4 Jan 2021 19:04:09 +0000 (UTC) Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [63.128.21.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 5A4432068D for ; Mon, 4 Jan 2021 19:04:09 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5A4432068D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=tempfail smtp.mailfrom=dm-devel-bounces@redhat.com Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-480-N1ViPDkdMG6rBddN1vHL0Q-1; Mon, 04 Jan 2021 14:04:05 -0500 X-MC-Unique: N1ViPDkdMG6rBddN1vHL0Q-1 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 12BB8801AFB; Mon, 4 Jan 2021 19:03:55 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id EA3A26F950; Mon, 4 Jan 2021 19:03:54 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id BE4AF1809CB6; Mon, 4 Jan 2021 19:03:54 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.rdu2.redhat.com [10.11.54.4]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 0BNMlx1M014959 for ; Wed, 23 Dec 2020 17:47:59 -0500 Received: by smtp.corp.redhat.com (Postfix) id 29FBD2026D3B; Wed, 23 Dec 2020 22:47:59 +0000 (UTC) Received: from mimecast-mx02.redhat.com (mimecast03.extmail.prod.ext.rdu2.redhat.com [10.11.55.19]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 2520B2026D5D for ; Wed, 23 Dec 2020 22:47:57 +0000 (UTC) Received: from us-smtp-1.mimecast.com (us-smtp-2.mimecast.com [205.139.110.61]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id C11D8811E78 for ; Wed, 23 Dec 2020 22:47:57 +0000 (UTC) Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-448-R48h6s5MNrCUJgnMECOqRQ-1; Wed, 23 Dec 2020 17:47:55 -0500 X-MC-Unique: R48h6s5MNrCUJgnMECOqRQ-1 Received: by mail.kernel.org (Postfix) with ESMTPSA id 4D0D9223E0; Wed, 23 Dec 2020 22:39:01 +0000 (UTC) From: Ard Biesheuvel To: linux-crypto@vger.kernel.org Date: Wed, 23 Dec 2020 23:38:32 +0100 Message-Id: <20201223223841.11311-2-ardb@kernel.org> In-Reply-To: <20201223223841.11311-1-ardb@kernel.org> References: <20201223223841.11311-1-ardb@kernel.org> MIME-Version: 1.0 X-Mimecast-Impersonation-Protect: Policy=CLT - Impersonation Protection Definition; Similar Internal Domain=false; Similar Monitored External Domain=false; Custom External Domain=false; Mimecast External Domain=false; Newly Observed Domain=false; Internal User Name=false; Custom Display Name List=false; Reply-to Address Mismatch=false; Targeted Threat Dictionary=false; Mimecast Threat Dictionary=false; Custom Threat Dictionary=false X-Scanned-By: MIMEDefang 2.78 on 10.11.54.4 X-MIME-Autoconverted: from quoted-printable to 8bit by lists01.pubmisc.prod.ext.phx2.redhat.com id 0BNMlx1M014959 X-loop: dm-devel@redhat.com X-Mailman-Approved-At: Mon, 04 Jan 2021 14:03:11 -0500 Cc: Herbert Xu , Mike Snitzer , Ard Biesheuvel , Eric Biggers , dm-devel@redhat.com, Milan Broz , Megha Dey Subject: [dm-devel] [RFC PATCH 01/10] crypto: x86/camellia - switch to XTS template X-BeenThere: dm-devel@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: device-mapper development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: dm-devel-bounces@redhat.com Errors-To: dm-devel-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=dm-devel-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Tm93IHRoYXQgdGhlIFhUUyB0ZW1wbGF0ZSBjYW4gd3JhcCBhY2NlbGVyYXRlZCBFQ0IgbW9kZXMs IGl0IGNhbiBiZQp1c2VkIHRvIGltcGxlbWVudCBDYW1lbGxpYSBpbiBYVFMgbW9kZSBhcyB3ZWxs LCB3aGljaCB0dXJucyBvdXQgdG8KYmUgYXQgbGVhc3QgYXMgZmFzdCwgYW5kIHNvbWV0aW1lcyBl dmVuIGZhc3Rlci4KClNpZ25lZC1vZmYtYnk6IEFyZCBCaWVzaGV1dmVsIDxhcmRiQGtlcm5lbC5v cmc+Ci0tLQogYXJjaC94ODYvY3J5cHRvL2NhbWVsbGlhLWFlc25pLWF2eC1hc21fNjQuUyAgfCAx ODAgLS0tLS0tLS0tLS0tLS0tLS0KIGFyY2gveDg2L2NyeXB0by9jYW1lbGxpYS1hZXNuaS1hdngy LWFzbV82NC5TIHwgMjA2IC0tLS0tLS0tLS0tLS0tLS0tLS0tCiBhcmNoL3g4Ni9jcnlwdG8vY2Ft ZWxsaWFfYWVzbmlfYXZ4Ml9nbHVlLmMgICB8ICA3MCAtLS0tLS0tCiBhcmNoL3g4Ni9jcnlwdG8v Y2FtZWxsaWFfYWVzbmlfYXZ4X2dsdWUuYyAgICB8IDEwMSArLS0tLS0tLS0tCiBhcmNoL3g4Ni9p bmNsdWRlL2FzbS9jcnlwdG8vY2FtZWxsaWEuaCAgICAgICB8ICAxOCAtLQogNSBmaWxlcyBjaGFu Z2VkLCAxIGluc2VydGlvbigrKSwgNTc0IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2FyY2gv eDg2L2NyeXB0by9jYW1lbGxpYS1hZXNuaS1hdngtYXNtXzY0LlMgYi9hcmNoL3g4Ni9jcnlwdG8v Y2FtZWxsaWEtYWVzbmktYXZ4LWFzbV82NC5TCmluZGV4IGVjYzBhOWE5MDVjNC4uMWUwMzgzYTg0 MjQ3IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9jcnlwdG8vY2FtZWxsaWEtYWVzbmktYXZ4LWFzbV82 NC5TCisrKyBiL2FyY2gveDg2L2NyeXB0by9jYW1lbGxpYS1hZXNuaS1hdngtYXNtXzY0LlMKQEAg LTU5MywxMCArNTkzLDYgQEAgU1lNX0ZVTkNfRU5EKHJvdW5kc20xNl94NF94NV94Nl94N194MF94 MV94Ml94M195NF95NV95Nl95N195MF95MV95Ml95M19hYikKIC5MYnN3YXAxMjhfbWFzazoKIAku Ynl0ZSAxNSwgMTQsIDEzLCAxMiwgMTEsIDEwLCA5LCA4LCA3LCA2LCA1LCA0LCAzLCAyLCAxLCAw CiAKLS8qIEZvciBYVFMgbW9kZSBJViBnZW5lcmF0aW9uICovCi0uTHh0c19nZjEyOG11bF9hbmRf c2hsMV9tYXNrOgotCS5ieXRlIDB4ODcsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDEsIDAsIDAsIDAs IDAsIDAsIDAsIDAKLQogLyoKICAqIHByZS1TdWJCeXRlIHRyYW5zZm9ybQogICoKQEAgLTExMTEs MTc5ICsxMTA3LDMgQEAgU1lNX0ZVTkNfU1RBUlQoY2FtZWxsaWFfY3RyXzE2d2F5KQogCUZSQU1F X0VORAogCXJldDsKIFNZTV9GVU5DX0VORChjYW1lbGxpYV9jdHJfMTZ3YXkpCi0KLSNkZWZpbmUg Z2YxMjhtdWxfeF9ibGUoaXYsIG1hc2ssIHRtcCkgXAotCXZwc3JhZCAkMzEsIGl2LCB0bXA7IFwK LQl2cGFkZHEgaXYsIGl2LCBpdjsgXAotCXZwc2h1ZmQgJDB4MTMsIHRtcCwgdG1wOyBcCi0JdnBh bmQgbWFzaywgdG1wLCB0bXA7IFwKLQl2cHhvciB0bXAsIGl2LCBpdjsKLQotLmFsaWduIDgKLVNZ TV9GVU5DX1NUQVJUX0xPQ0FMKGNhbWVsbGlhX3h0c19jcnlwdF8xNndheSkKLQkvKiBpbnB1dDoK LQkgKgklcmRpOiBjdHgsIENUWAotCSAqCSVyc2k6IGRzdCAoMTYgYmxvY2tzKQotCSAqCSVyZHg6 IHNyYyAoMTYgYmxvY2tzKQotCSAqCSVyY3g6IGl2ICh0IOKKlSDOseKBvyDiiIggR0YoMsK5wrLi gbgpKQotCSAqCSVyODogaW5kZXggZm9yIGlucHV0IHdoaXRlbmluZyBrZXkKLQkgKgklcjk6IHBv aW50ZXIgdG8gIF9fY2FtZWxsaWFfZW5jX2JsazE2IG9yIF9fY2FtZWxsaWFfZGVjX2JsazE2Ci0J ICovCi0JRlJBTUVfQkVHSU4KLQotCXN1YnEgJCgxNiAqIDE2KSwgJXJzcDsKLQltb3ZxICVyc3As ICVyYXg7Ci0KLQl2bW92ZHFhIC5MeHRzX2dmMTI4bXVsX2FuZF9zaGwxX21hc2ssICV4bW0xNDsK LQotCS8qIGxvYWQgSVYgKi8KLQl2bW92ZHF1ICglcmN4KSwgJXhtbTA7Ci0JdnB4b3IgMCAqIDE2 KCVyZHgpLCAleG1tMCwgJXhtbTE1OwotCXZtb3ZkcXUgJXhtbTE1LCAxNSAqIDE2KCVyYXgpOwot CXZtb3ZkcXUgJXhtbTAsIDAgKiAxNiglcnNpKTsKLQotCS8qIGNvbnN0cnVjdCBJVnMgKi8KLQln ZjEyOG11bF94X2JsZSgleG1tMCwgJXhtbTE0LCAleG1tMTUpOwotCXZweG9yIDEgKiAxNiglcmR4 KSwgJXhtbTAsICV4bW0xNTsKLQl2bW92ZHF1ICV4bW0xNSwgMTQgKiAxNiglcmF4KTsKLQl2bW92 ZHF1ICV4bW0wLCAxICogMTYoJXJzaSk7Ci0KLQlnZjEyOG11bF94X2JsZSgleG1tMCwgJXhtbTE0 LCAleG1tMTUpOwotCXZweG9yIDIgKiAxNiglcmR4KSwgJXhtbTAsICV4bW0xMzsKLQl2bW92ZHF1 ICV4bW0wLCAyICogMTYoJXJzaSk7Ci0KLQlnZjEyOG11bF94X2JsZSgleG1tMCwgJXhtbTE0LCAl eG1tMTUpOwotCXZweG9yIDMgKiAxNiglcmR4KSwgJXhtbTAsICV4bW0xMjsKLQl2bW92ZHF1ICV4 bW0wLCAzICogMTYoJXJzaSk7Ci0KLQlnZjEyOG11bF94X2JsZSgleG1tMCwgJXhtbTE0LCAleG1t MTUpOwotCXZweG9yIDQgKiAxNiglcmR4KSwgJXhtbTAsICV4bW0xMTsKLQl2bW92ZHF1ICV4bW0w LCA0ICogMTYoJXJzaSk7Ci0KLQlnZjEyOG11bF94X2JsZSgleG1tMCwgJXhtbTE0LCAleG1tMTUp OwotCXZweG9yIDUgKiAxNiglcmR4KSwgJXhtbTAsICV4bW0xMDsKLQl2bW92ZHF1ICV4bW0wLCA1 ICogMTYoJXJzaSk7Ci0KLQlnZjEyOG11bF94X2JsZSgleG1tMCwgJXhtbTE0LCAleG1tMTUpOwot CXZweG9yIDYgKiAxNiglcmR4KSwgJXhtbTAsICV4bW05OwotCXZtb3ZkcXUgJXhtbTAsIDYgKiAx NiglcnNpKTsKLQotCWdmMTI4bXVsX3hfYmxlKCV4bW0wLCAleG1tMTQsICV4bW0xNSk7Ci0JdnB4 b3IgNyAqIDE2KCVyZHgpLCAleG1tMCwgJXhtbTg7Ci0Jdm1vdmRxdSAleG1tMCwgNyAqIDE2KCVy c2kpOwotCi0JZ2YxMjhtdWxfeF9ibGUoJXhtbTAsICV4bW0xNCwgJXhtbTE1KTsKLQl2cHhvciA4 ICogMTYoJXJkeCksICV4bW0wLCAleG1tNzsKLQl2bW92ZHF1ICV4bW0wLCA4ICogMTYoJXJzaSk7 Ci0KLQlnZjEyOG11bF94X2JsZSgleG1tMCwgJXhtbTE0LCAleG1tMTUpOwotCXZweG9yIDkgKiAx NiglcmR4KSwgJXhtbTAsICV4bW02OwotCXZtb3ZkcXUgJXhtbTAsIDkgKiAxNiglcnNpKTsKLQot CWdmMTI4bXVsX3hfYmxlKCV4bW0wLCAleG1tMTQsICV4bW0xNSk7Ci0JdnB4b3IgMTAgKiAxNigl cmR4KSwgJXhtbTAsICV4bW01OwotCXZtb3ZkcXUgJXhtbTAsIDEwICogMTYoJXJzaSk7Ci0KLQln ZjEyOG11bF94X2JsZSgleG1tMCwgJXhtbTE0LCAleG1tMTUpOwotCXZweG9yIDExICogMTYoJXJk eCksICV4bW0wLCAleG1tNDsKLQl2bW92ZHF1ICV4bW0wLCAxMSAqIDE2KCVyc2kpOwotCi0JZ2Yx MjhtdWxfeF9ibGUoJXhtbTAsICV4bW0xNCwgJXhtbTE1KTsKLQl2cHhvciAxMiAqIDE2KCVyZHgp LCAleG1tMCwgJXhtbTM7Ci0Jdm1vdmRxdSAleG1tMCwgMTIgKiAxNiglcnNpKTsKLQotCWdmMTI4 bXVsX3hfYmxlKCV4bW0wLCAleG1tMTQsICV4bW0xNSk7Ci0JdnB4b3IgMTMgKiAxNiglcmR4KSwg JXhtbTAsICV4bW0yOwotCXZtb3ZkcXUgJXhtbTAsIDEzICogMTYoJXJzaSk7Ci0KLQlnZjEyOG11 bF94X2JsZSgleG1tMCwgJXhtbTE0LCAleG1tMTUpOwotCXZweG9yIDE0ICogMTYoJXJkeCksICV4 bW0wLCAleG1tMTsKLQl2bW92ZHF1ICV4bW0wLCAxNCAqIDE2KCVyc2kpOwotCi0JZ2YxMjhtdWxf eF9ibGUoJXhtbTAsICV4bW0xNCwgJXhtbTE1KTsKLQl2cHhvciAxNSAqIDE2KCVyZHgpLCAleG1t MCwgJXhtbTE1OwotCXZtb3ZkcXUgJXhtbTE1LCAwICogMTYoJXJheCk7Ci0Jdm1vdmRxdSAleG1t MCwgMTUgKiAxNiglcnNpKTsKLQotCWdmMTI4bXVsX3hfYmxlKCV4bW0wLCAleG1tMTQsICV4bW0x NSk7Ci0Jdm1vdmRxdSAleG1tMCwgKCVyY3gpOwotCi0JLyogaW5wYWNrMTZfcHJlOiAqLwotCXZt b3ZxIChrZXlfdGFibGUpKENUWCwgJXI4LCA4KSwgJXhtbTE1OwotCXZwc2h1ZmIgLkxwYWNrX2Jz d2FwLCAleG1tMTUsICV4bW0xNTsKLQl2cHhvciAwICogMTYoJXJheCksICV4bW0xNSwgJXhtbTA7 Ci0JdnB4b3IgJXhtbTEsICV4bW0xNSwgJXhtbTE7Ci0JdnB4b3IgJXhtbTIsICV4bW0xNSwgJXht bTI7Ci0JdnB4b3IgJXhtbTMsICV4bW0xNSwgJXhtbTM7Ci0JdnB4b3IgJXhtbTQsICV4bW0xNSwg JXhtbTQ7Ci0JdnB4b3IgJXhtbTUsICV4bW0xNSwgJXhtbTU7Ci0JdnB4b3IgJXhtbTYsICV4bW0x NSwgJXhtbTY7Ci0JdnB4b3IgJXhtbTcsICV4bW0xNSwgJXhtbTc7Ci0JdnB4b3IgJXhtbTgsICV4 bW0xNSwgJXhtbTg7Ci0JdnB4b3IgJXhtbTksICV4bW0xNSwgJXhtbTk7Ci0JdnB4b3IgJXhtbTEw LCAleG1tMTUsICV4bW0xMDsKLQl2cHhvciAleG1tMTEsICV4bW0xNSwgJXhtbTExOwotCXZweG9y ICV4bW0xMiwgJXhtbTE1LCAleG1tMTI7Ci0JdnB4b3IgJXhtbTEzLCAleG1tMTUsICV4bW0xMzsK LQl2cHhvciAxNCAqIDE2KCVyYXgpLCAleG1tMTUsICV4bW0xNDsKLQl2cHhvciAxNSAqIDE2KCVy YXgpLCAleG1tMTUsICV4bW0xNTsKLQotCUNBTExfTk9TUEVDIHI5OwotCi0JYWRkcSAkKDE2ICog MTYpLCAlcnNwOwotCi0JdnB4b3IgMCAqIDE2KCVyc2kpLCAleG1tNywgJXhtbTc7Ci0JdnB4b3Ig MSAqIDE2KCVyc2kpLCAleG1tNiwgJXhtbTY7Ci0JdnB4b3IgMiAqIDE2KCVyc2kpLCAleG1tNSwg JXhtbTU7Ci0JdnB4b3IgMyAqIDE2KCVyc2kpLCAleG1tNCwgJXhtbTQ7Ci0JdnB4b3IgNCAqIDE2 KCVyc2kpLCAleG1tMywgJXhtbTM7Ci0JdnB4b3IgNSAqIDE2KCVyc2kpLCAleG1tMiwgJXhtbTI7 Ci0JdnB4b3IgNiAqIDE2KCVyc2kpLCAleG1tMSwgJXhtbTE7Ci0JdnB4b3IgNyAqIDE2KCVyc2kp LCAleG1tMCwgJXhtbTA7Ci0JdnB4b3IgOCAqIDE2KCVyc2kpLCAleG1tMTUsICV4bW0xNTsKLQl2 cHhvciA5ICogMTYoJXJzaSksICV4bW0xNCwgJXhtbTE0OwotCXZweG9yIDEwICogMTYoJXJzaSks ICV4bW0xMywgJXhtbTEzOwotCXZweG9yIDExICogMTYoJXJzaSksICV4bW0xMiwgJXhtbTEyOwot CXZweG9yIDEyICogMTYoJXJzaSksICV4bW0xMSwgJXhtbTExOwotCXZweG9yIDEzICogMTYoJXJz aSksICV4bW0xMCwgJXhtbTEwOwotCXZweG9yIDE0ICogMTYoJXJzaSksICV4bW05LCAleG1tOTsK LQl2cHhvciAxNSAqIDE2KCVyc2kpLCAleG1tOCwgJXhtbTg7Ci0Jd3JpdGVfb3V0cHV0KCV4bW03 LCAleG1tNiwgJXhtbTUsICV4bW00LCAleG1tMywgJXhtbTIsICV4bW0xLCAleG1tMCwKLQkJICAg ICAleG1tMTUsICV4bW0xNCwgJXhtbTEzLCAleG1tMTIsICV4bW0xMSwgJXhtbTEwLCAleG1tOSwK LQkJICAgICAleG1tOCwgJXJzaSk7Ci0KLQlGUkFNRV9FTkQKLQlyZXQ7Ci1TWU1fRlVOQ19FTkQo Y2FtZWxsaWFfeHRzX2NyeXB0XzE2d2F5KQotCi1TWU1fRlVOQ19TVEFSVChjYW1lbGxpYV94dHNf ZW5jXzE2d2F5KQotCS8qIGlucHV0OgotCSAqCSVyZGk6IGN0eCwgQ1RYCi0JICoJJXJzaTogZHN0 ICgxNiBibG9ja3MpCi0JICoJJXJkeDogc3JjICgxNiBibG9ja3MpCi0JICoJJXJjeDogaXYgKHQg 4oqVIM6x4oG/IOKIiCBHRigywrnCsuKBuCkpCi0JICovCi0JeG9ybCAlcjhkLCAlcjhkOyAvKiBp bnB1dCB3aGl0ZW5pbmcga2V5LCAwIGZvciBlbmMgKi8KLQotCWxlYXEgX19jYW1lbGxpYV9lbmNf YmxrMTYsICVyOTsKLQotCWptcCBjYW1lbGxpYV94dHNfY3J5cHRfMTZ3YXk7Ci1TWU1fRlVOQ19F TkQoY2FtZWxsaWFfeHRzX2VuY18xNndheSkKLQotU1lNX0ZVTkNfU1RBUlQoY2FtZWxsaWFfeHRz X2RlY18xNndheSkKLQkvKiBpbnB1dDoKLQkgKgklcmRpOiBjdHgsIENUWAotCSAqCSVyc2k6IGRz dCAoMTYgYmxvY2tzKQotCSAqCSVyZHg6IHNyYyAoMTYgYmxvY2tzKQotCSAqCSVyY3g6IGl2ICh0 IOKKlSDOseKBvyDiiIggR0YoMsK5wrLigbgpKQotCSAqLwotCi0JY21wbCAkMTYsIGtleV9sZW5n dGgoQ1RYKTsKLQltb3ZsICQzMiwgJXI4ZDsKLQltb3ZsICQyNCwgJWVheDsKLQljbW92ZWwgJWVh eCwgJXI4ZDsgIC8qIGlucHV0IHdoaXRlbmluZyBrZXksIGxhc3QgZm9yIGRlYyAqLwotCi0JbGVh cSBfX2NhbWVsbGlhX2RlY19ibGsxNiwgJXI5OwotCi0Jam1wIGNhbWVsbGlhX3h0c19jcnlwdF8x NndheTsKLVNZTV9GVU5DX0VORChjYW1lbGxpYV94dHNfZGVjXzE2d2F5KQpkaWZmIC0tZ2l0IGEv YXJjaC94ODYvY3J5cHRvL2NhbWVsbGlhLWFlc25pLWF2eDItYXNtXzY0LlMgYi9hcmNoL3g4Ni9j cnlwdG8vY2FtZWxsaWEtYWVzbmktYXZ4Mi1hc21fNjQuUwppbmRleCAwOTA3MjQzYzUwMWMuLjQz MmJmYWY1NGZmOSAxMDA2NDQKLS0tIGEvYXJjaC94ODYvY3J5cHRvL2NhbWVsbGlhLWFlc25pLWF2 eDItYXNtXzY0LlMKKysrIGIvYXJjaC94ODYvY3J5cHRvL2NhbWVsbGlhLWFlc25pLWF2eDItYXNt XzY0LlMKQEAgLTYyOSwxMiArNjI5LDYgQEAgU1lNX0ZVTkNfRU5EKHJvdW5kc20zMl94NF94NV94 Nl94N194MF94MV94Ml94M195NF95NV95Nl95N195MF95MV95Ml95M19hYikKIC5MYnN3YXAxMjhf bWFzazoKIAkuYnl0ZSAxNSwgMTQsIDEzLCAxMiwgMTEsIDEwLCA5LCA4LCA3LCA2LCA1LCA0LCAz LCAyLCAxLCAwCiAKLS8qIEZvciBYVFMgbW9kZSAqLwotLkx4dHNfZ2YxMjhtdWxfYW5kX3NobDFf bWFza18wOgotCS5ieXRlIDB4ODcsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDEsIDAsIDAsIDAsIDAs IDAsIDAsIDAKLS5MeHRzX2dmMTI4bXVsX2FuZF9zaGwxX21hc2tfMToKLQkuYnl0ZSAweDBlLCAx LCAwLCAwLCAwLCAwLCAwLCAwLCAyLCAwLCAwLCAwLCAwLCAwLCAwLCAwCi0KIC8qCiAgKiBwcmUt U3ViQnl0ZSB0cmFuc2Zvcm0KICAqCkBAIC0xMjAxLDIwMyArMTE5NSwzIEBAIFNZTV9GVU5DX1NU QVJUKGNhbWVsbGlhX2N0cl8zMndheSkKIAlGUkFNRV9FTkQKIAlyZXQ7CiBTWU1fRlVOQ19FTkQo Y2FtZWxsaWFfY3RyXzMyd2F5KQotCi0jZGVmaW5lIGdmMTI4bXVsX3hfYmxlKGl2LCBtYXNrLCB0 bXApIFwKLQl2cHNyYWQgJDMxLCBpdiwgdG1wOyBcCi0JdnBhZGRxIGl2LCBpdiwgaXY7IFwKLQl2 cHNodWZkICQweDEzLCB0bXAsIHRtcDsgXAotCXZwYW5kIG1hc2ssIHRtcCwgdG1wOyBcCi0JdnB4 b3IgdG1wLCBpdiwgaXY7Ci0KLSNkZWZpbmUgZ2YxMjhtdWxfeDJfYmxlKGl2LCBtYXNrMSwgbWFz azIsIHRtcDAsIHRtcDEpIFwKLQl2cHNyYWQgJDMxLCBpdiwgdG1wMDsgXAotCXZwYWRkcSBpdiwg aXYsIHRtcDE7IFwKLQl2cHNsbHEgJDIsIGl2LCBpdjsgXAotCXZwc2h1ZmQgJDB4MTMsIHRtcDAs IHRtcDA7IFwKLQl2cHNyYWQgJDMxLCB0bXAxLCB0bXAxOyBcCi0JdnBhbmQgbWFzazIsIHRtcDAs IHRtcDA7IFwKLQl2cHNodWZkICQweDEzLCB0bXAxLCB0bXAxOyBcCi0JdnB4b3IgdG1wMCwgaXYs IGl2OyBcCi0JdnBhbmQgbWFzazEsIHRtcDEsIHRtcDE7IFwKLQl2cHhvciB0bXAxLCBpdiwgaXY7 Ci0KLS5hbGlnbiA4Ci1TWU1fRlVOQ19TVEFSVF9MT0NBTChjYW1lbGxpYV94dHNfY3J5cHRfMzJ3 YXkpCi0JLyogaW5wdXQ6Ci0JICoJJXJkaTogY3R4LCBDVFgKLQkgKgklcnNpOiBkc3QgKDMyIGJs b2NrcykKLQkgKgklcmR4OiBzcmMgKDMyIGJsb2NrcykKLQkgKgklcmN4OiBpdiAodCDiipUgzrHi gb8g4oiIIEdGKDLCucKy4oG4KSkKLQkgKgklcjg6IGluZGV4IGZvciBpbnB1dCB3aGl0ZW5pbmcg a2V5Ci0JICoJJXI5OiBwb2ludGVyIHRvICBfX2NhbWVsbGlhX2VuY19ibGszMiBvciBfX2NhbWVs bGlhX2RlY19ibGszMgotCSAqLwotCUZSQU1FX0JFR0lOCi0KLQl2emVyb3VwcGVyOwotCi0Jc3Vi cSAkKDE2ICogMzIpLCAlcnNwOwotCW1vdnEgJXJzcCwgJXJheDsKLQotCXZicm9hZGNhc3RpMTI4 IC5MeHRzX2dmMTI4bXVsX2FuZF9zaGwxX21hc2tfMCwgJXltbTEyOwotCi0JLyogbG9hZCBJViBh bmQgY29uc3RydWN0IHNlY29uZCBJViAqLwotCXZtb3ZkcXUgKCVyY3gpLCAleG1tMDsKLQl2bW92 ZHFhICV4bW0wLCAleG1tMTU7Ci0JZ2YxMjhtdWxfeF9ibGUoJXhtbTAsICV4bW0xMiwgJXhtbTEz KTsKLQl2YnJvYWRjYXN0aTEyOCAuTHh0c19nZjEyOG11bF9hbmRfc2hsMV9tYXNrXzEsICV5bW0x MzsKLQl2aW5zZXJ0aTEyOCAkMSwgJXhtbTAsICV5bW0xNSwgJXltbTA7Ci0JdnB4b3IgMCAqIDMy KCVyZHgpLCAleW1tMCwgJXltbTE1OwotCXZtb3ZkcXUgJXltbTE1LCAxNSAqIDMyKCVyYXgpOwot CXZtb3ZkcXUgJXltbTAsIDAgKiAzMiglcnNpKTsKLQotCS8qIGNvbnN0cnVjdCBJVnMgKi8KLQln ZjEyOG11bF94Ml9ibGUoJXltbTAsICV5bW0xMiwgJXltbTEzLCAleW1tMTQsICV5bW0xNSk7Ci0J dnB4b3IgMSAqIDMyKCVyZHgpLCAleW1tMCwgJXltbTE1OwotCXZtb3ZkcXUgJXltbTE1LCAxNCAq IDMyKCVyYXgpOwotCXZtb3ZkcXUgJXltbTAsIDEgKiAzMiglcnNpKTsKLQotCWdmMTI4bXVsX3gy X2JsZSgleW1tMCwgJXltbTEyLCAleW1tMTMsICV5bW0xNCwgJXltbTE1KTsKLQl2cHhvciAyICog MzIoJXJkeCksICV5bW0wLCAleW1tMTU7Ci0Jdm1vdmRxdSAleW1tMTUsIDEzICogMzIoJXJheCk7 Ci0Jdm1vdmRxdSAleW1tMCwgMiAqIDMyKCVyc2kpOwotCi0JZ2YxMjhtdWxfeDJfYmxlKCV5bW0w LCAleW1tMTIsICV5bW0xMywgJXltbTE0LCAleW1tMTUpOwotCXZweG9yIDMgKiAzMiglcmR4KSwg JXltbTAsICV5bW0xNTsKLQl2bW92ZHF1ICV5bW0xNSwgMTIgKiAzMiglcmF4KTsKLQl2bW92ZHF1 ICV5bW0wLCAzICogMzIoJXJzaSk7Ci0KLQlnZjEyOG11bF94Ml9ibGUoJXltbTAsICV5bW0xMiwg JXltbTEzLCAleW1tMTQsICV5bW0xNSk7Ci0JdnB4b3IgNCAqIDMyKCVyZHgpLCAleW1tMCwgJXlt bTExOwotCXZtb3ZkcXUgJXltbTAsIDQgKiAzMiglcnNpKTsKLQotCWdmMTI4bXVsX3gyX2JsZSgl eW1tMCwgJXltbTEyLCAleW1tMTMsICV5bW0xNCwgJXltbTE1KTsKLQl2cHhvciA1ICogMzIoJXJk eCksICV5bW0wLCAleW1tMTA7Ci0Jdm1vdmRxdSAleW1tMCwgNSAqIDMyKCVyc2kpOwotCi0JZ2Yx MjhtdWxfeDJfYmxlKCV5bW0wLCAleW1tMTIsICV5bW0xMywgJXltbTE0LCAleW1tMTUpOwotCXZw eG9yIDYgKiAzMiglcmR4KSwgJXltbTAsICV5bW05OwotCXZtb3ZkcXUgJXltbTAsIDYgKiAzMigl cnNpKTsKLQotCWdmMTI4bXVsX3gyX2JsZSgleW1tMCwgJXltbTEyLCAleW1tMTMsICV5bW0xNCwg JXltbTE1KTsKLQl2cHhvciA3ICogMzIoJXJkeCksICV5bW0wLCAleW1tODsKLQl2bW92ZHF1ICV5 bW0wLCA3ICogMzIoJXJzaSk7Ci0KLQlnZjEyOG11bF94Ml9ibGUoJXltbTAsICV5bW0xMiwgJXlt bTEzLCAleW1tMTQsICV5bW0xNSk7Ci0JdnB4b3IgOCAqIDMyKCVyZHgpLCAleW1tMCwgJXltbTc7 Ci0Jdm1vdmRxdSAleW1tMCwgOCAqIDMyKCVyc2kpOwotCi0JZ2YxMjhtdWxfeDJfYmxlKCV5bW0w LCAleW1tMTIsICV5bW0xMywgJXltbTE0LCAleW1tMTUpOwotCXZweG9yIDkgKiAzMiglcmR4KSwg JXltbTAsICV5bW02OwotCXZtb3ZkcXUgJXltbTAsIDkgKiAzMiglcnNpKTsKLQotCWdmMTI4bXVs X3gyX2JsZSgleW1tMCwgJXltbTEyLCAleW1tMTMsICV5bW0xNCwgJXltbTE1KTsKLQl2cHhvciAx MCAqIDMyKCVyZHgpLCAleW1tMCwgJXltbTU7Ci0Jdm1vdmRxdSAleW1tMCwgMTAgKiAzMiglcnNp KTsKLQotCWdmMTI4bXVsX3gyX2JsZSgleW1tMCwgJXltbTEyLCAleW1tMTMsICV5bW0xNCwgJXlt bTE1KTsKLQl2cHhvciAxMSAqIDMyKCVyZHgpLCAleW1tMCwgJXltbTQ7Ci0Jdm1vdmRxdSAleW1t MCwgMTEgKiAzMiglcnNpKTsKLQotCWdmMTI4bXVsX3gyX2JsZSgleW1tMCwgJXltbTEyLCAleW1t MTMsICV5bW0xNCwgJXltbTE1KTsKLQl2cHhvciAxMiAqIDMyKCVyZHgpLCAleW1tMCwgJXltbTM7 Ci0Jdm1vdmRxdSAleW1tMCwgMTIgKiAzMiglcnNpKTsKLQotCWdmMTI4bXVsX3gyX2JsZSgleW1t MCwgJXltbTEyLCAleW1tMTMsICV5bW0xNCwgJXltbTE1KTsKLQl2cHhvciAxMyAqIDMyKCVyZHgp LCAleW1tMCwgJXltbTI7Ci0Jdm1vdmRxdSAleW1tMCwgMTMgKiAzMiglcnNpKTsKLQotCWdmMTI4 bXVsX3gyX2JsZSgleW1tMCwgJXltbTEyLCAleW1tMTMsICV5bW0xNCwgJXltbTE1KTsKLQl2cHhv ciAxNCAqIDMyKCVyZHgpLCAleW1tMCwgJXltbTE7Ci0Jdm1vdmRxdSAleW1tMCwgMTQgKiAzMigl cnNpKTsKLQotCWdmMTI4bXVsX3gyX2JsZSgleW1tMCwgJXltbTEyLCAleW1tMTMsICV5bW0xNCwg JXltbTE1KTsKLQl2cHhvciAxNSAqIDMyKCVyZHgpLCAleW1tMCwgJXltbTE1OwotCXZtb3ZkcXUg JXltbTE1LCAwICogMzIoJXJheCk7Ci0Jdm1vdmRxdSAleW1tMCwgMTUgKiAzMiglcnNpKTsKLQot CXZleHRyYWN0aTEyOCAkMSwgJXltbTAsICV4bW0wOwotCWdmMTI4bXVsX3hfYmxlKCV4bW0wLCAl eG1tMTIsICV4bW0xNSk7Ci0Jdm1vdmRxdSAleG1tMCwgKCVyY3gpOwotCi0JLyogaW5wYWNrMzJf cHJlOiAqLwotCXZwYnJvYWRjYXN0cSAoa2V5X3RhYmxlKShDVFgsICVyOCwgOCksICV5bW0xNTsK LQl2cHNodWZiIC5McGFja19ic3dhcCwgJXltbTE1LCAleW1tMTU7Ci0JdnB4b3IgMCAqIDMyKCVy YXgpLCAleW1tMTUsICV5bW0wOwotCXZweG9yICV5bW0xLCAleW1tMTUsICV5bW0xOwotCXZweG9y ICV5bW0yLCAleW1tMTUsICV5bW0yOwotCXZweG9yICV5bW0zLCAleW1tMTUsICV5bW0zOwotCXZw eG9yICV5bW00LCAleW1tMTUsICV5bW00OwotCXZweG9yICV5bW01LCAleW1tMTUsICV5bW01Owot CXZweG9yICV5bW02LCAleW1tMTUsICV5bW02OwotCXZweG9yICV5bW03LCAleW1tMTUsICV5bW03 OwotCXZweG9yICV5bW04LCAleW1tMTUsICV5bW04OwotCXZweG9yICV5bW05LCAleW1tMTUsICV5 bW05OwotCXZweG9yICV5bW0xMCwgJXltbTE1LCAleW1tMTA7Ci0JdnB4b3IgJXltbTExLCAleW1t MTUsICV5bW0xMTsKLQl2cHhvciAxMiAqIDMyKCVyYXgpLCAleW1tMTUsICV5bW0xMjsKLQl2cHhv ciAxMyAqIDMyKCVyYXgpLCAleW1tMTUsICV5bW0xMzsKLQl2cHhvciAxNCAqIDMyKCVyYXgpLCAl eW1tMTUsICV5bW0xNDsKLQl2cHhvciAxNSAqIDMyKCVyYXgpLCAleW1tMTUsICV5bW0xNTsKLQot CUNBTExfTk9TUEVDIHI5OwotCi0JYWRkcSAkKDE2ICogMzIpLCAlcnNwOwotCi0JdnB4b3IgMCAq IDMyKCVyc2kpLCAleW1tNywgJXltbTc7Ci0JdnB4b3IgMSAqIDMyKCVyc2kpLCAleW1tNiwgJXlt bTY7Ci0JdnB4b3IgMiAqIDMyKCVyc2kpLCAleW1tNSwgJXltbTU7Ci0JdnB4b3IgMyAqIDMyKCVy c2kpLCAleW1tNCwgJXltbTQ7Ci0JdnB4b3IgNCAqIDMyKCVyc2kpLCAleW1tMywgJXltbTM7Ci0J dnB4b3IgNSAqIDMyKCVyc2kpLCAleW1tMiwgJXltbTI7Ci0JdnB4b3IgNiAqIDMyKCVyc2kpLCAl eW1tMSwgJXltbTE7Ci0JdnB4b3IgNyAqIDMyKCVyc2kpLCAleW1tMCwgJXltbTA7Ci0JdnB4b3Ig OCAqIDMyKCVyc2kpLCAleW1tMTUsICV5bW0xNTsKLQl2cHhvciA5ICogMzIoJXJzaSksICV5bW0x NCwgJXltbTE0OwotCXZweG9yIDEwICogMzIoJXJzaSksICV5bW0xMywgJXltbTEzOwotCXZweG9y IDExICogMzIoJXJzaSksICV5bW0xMiwgJXltbTEyOwotCXZweG9yIDEyICogMzIoJXJzaSksICV5 bW0xMSwgJXltbTExOwotCXZweG9yIDEzICogMzIoJXJzaSksICV5bW0xMCwgJXltbTEwOwotCXZw eG9yIDE0ICogMzIoJXJzaSksICV5bW05LCAleW1tOTsKLQl2cHhvciAxNSAqIDMyKCVyc2kpLCAl eW1tOCwgJXltbTg7Ci0Jd3JpdGVfb3V0cHV0KCV5bW03LCAleW1tNiwgJXltbTUsICV5bW00LCAl eW1tMywgJXltbTIsICV5bW0xLCAleW1tMCwKLQkJICAgICAleW1tMTUsICV5bW0xNCwgJXltbTEz LCAleW1tMTIsICV5bW0xMSwgJXltbTEwLCAleW1tOSwKLQkJICAgICAleW1tOCwgJXJzaSk7Ci0K LQl2emVyb3VwcGVyOwotCi0JRlJBTUVfRU5ECi0JcmV0OwotU1lNX0ZVTkNfRU5EKGNhbWVsbGlh X3h0c19jcnlwdF8zMndheSkKLQotU1lNX0ZVTkNfU1RBUlQoY2FtZWxsaWFfeHRzX2VuY18zMndh eSkKLQkvKiBpbnB1dDoKLQkgKgklcmRpOiBjdHgsIENUWAotCSAqCSVyc2k6IGRzdCAoMzIgYmxv Y2tzKQotCSAqCSVyZHg6IHNyYyAoMzIgYmxvY2tzKQotCSAqCSVyY3g6IGl2ICh0IOKKlSDOseKB vyDiiIggR0YoMsK5wrLigbgpKQotCSAqLwotCi0JeG9ybCAlcjhkLCAlcjhkOyAvKiBpbnB1dCB3 aGl0ZW5pbmcga2V5LCAwIGZvciBlbmMgKi8KLQotCWxlYXEgX19jYW1lbGxpYV9lbmNfYmxrMzIs ICVyOTsKLQotCWptcCBjYW1lbGxpYV94dHNfY3J5cHRfMzJ3YXk7Ci1TWU1fRlVOQ19FTkQoY2Ft ZWxsaWFfeHRzX2VuY18zMndheSkKLQotU1lNX0ZVTkNfU1RBUlQoY2FtZWxsaWFfeHRzX2RlY18z MndheSkKLQkvKiBpbnB1dDoKLQkgKgklcmRpOiBjdHgsIENUWAotCSAqCSVyc2k6IGRzdCAoMzIg YmxvY2tzKQotCSAqCSVyZHg6IHNyYyAoMzIgYmxvY2tzKQotCSAqCSVyY3g6IGl2ICh0IOKKlSDO seKBvyDiiIggR0YoMsK5wrLigbgpKQotCSAqLwotCi0JY21wbCAkMTYsIGtleV9sZW5ndGgoQ1RY KTsKLQltb3ZsICQzMiwgJXI4ZDsKLQltb3ZsICQyNCwgJWVheDsKLQljbW92ZWwgJWVheCwgJXI4 ZDsgIC8qIGlucHV0IHdoaXRlbmluZyBrZXksIGxhc3QgZm9yIGRlYyAqLwotCi0JbGVhcSBfX2Nh bWVsbGlhX2RlY19ibGszMiwgJXI5OwotCi0Jam1wIGNhbWVsbGlhX3h0c19jcnlwdF8zMndheTsK LVNZTV9GVU5DX0VORChjYW1lbGxpYV94dHNfZGVjXzMyd2F5KQpkaWZmIC0tZ2l0IGEvYXJjaC94 ODYvY3J5cHRvL2NhbWVsbGlhX2Flc25pX2F2eDJfZ2x1ZS5jIGIvYXJjaC94ODYvY3J5cHRvL2Nh bWVsbGlhX2Flc25pX2F2eDJfZ2x1ZS5jCmluZGV4IGNjZGE2NDc0MjJkNi4uZDk1NmQwNDczNjY4 IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9jcnlwdG8vY2FtZWxsaWFfYWVzbmlfYXZ4Ml9nbHVlLmMK KysrIGIvYXJjaC94ODYvY3J5cHRvL2NhbWVsbGlhX2Flc25pX2F2eDJfZ2x1ZS5jCkBAIC05LDcg KzksNiBAQAogI2luY2x1ZGUgPGFzbS9jcnlwdG8vZ2x1ZV9oZWxwZXIuaD4KICNpbmNsdWRlIDxj cnlwdG8vYWxnYXBpLmg+CiAjaW5jbHVkZSA8Y3J5cHRvL2ludGVybmFsL3NpbWQuaD4KLSNpbmNs dWRlIDxjcnlwdG8veHRzLmg+CiAjaW5jbHVkZSA8bGludXgvY3J5cHRvLmg+CiAjaW5jbHVkZSA8 bGludXgvZXJyLmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CkBAIC0yNiwxMSArMjUsNiBA QCBhc21saW5rYWdlIHZvaWQgY2FtZWxsaWFfY2JjX2RlY18zMndheShjb25zdCB2b2lkICpjdHgs IHU4ICpkc3QsIGNvbnN0IHU4ICpzcmMpOwogYXNtbGlua2FnZSB2b2lkIGNhbWVsbGlhX2N0cl8z MndheShjb25zdCB2b2lkICpjdHgsIHU4ICpkc3QsIGNvbnN0IHU4ICpzcmMsCiAJCQkJICAgbGUx MjggKml2KTsKIAotYXNtbGlua2FnZSB2b2lkIGNhbWVsbGlhX3h0c19lbmNfMzJ3YXkoY29uc3Qg dm9pZCAqY3R4LCB1OCAqZHN0LCBjb25zdCB1OCAqc3JjLAotCQkJCSAgICAgICBsZTEyOCAqaXYp OwotYXNtbGlua2FnZSB2b2lkIGNhbWVsbGlhX3h0c19kZWNfMzJ3YXkoY29uc3Qgdm9pZCAqY3R4 LCB1OCAqZHN0LCBjb25zdCB1OCAqc3JjLAotCQkJCSAgICAgICBsZTEyOCAqaXYpOwotCiBzdGF0 aWMgY29uc3Qgc3RydWN0IGNvbW1vbl9nbHVlX2N0eCBjYW1lbGxpYV9lbmMgPSB7CiAJLm51bV9m dW5jcyA9IDQsCiAJLmZwdV9ibG9ja3NfbGltaXQgPSBDQU1FTExJQV9BRVNOSV9QQVJBTExFTF9C TE9DS1MsCkBAIC02OSwyMiArNjMsNiBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGNvbW1vbl9nbHVl X2N0eCBjYW1lbGxpYV9jdHIgPSB7CiAJfSB9CiB9OwogCi1zdGF0aWMgY29uc3Qgc3RydWN0IGNv bW1vbl9nbHVlX2N0eCBjYW1lbGxpYV9lbmNfeHRzID0gewotCS5udW1fZnVuY3MgPSAzLAotCS5m cHVfYmxvY2tzX2xpbWl0ID0gQ0FNRUxMSUFfQUVTTklfUEFSQUxMRUxfQkxPQ0tTLAotCi0JLmZ1 bmNzID0geyB7Ci0JCS5udW1fYmxvY2tzID0gQ0FNRUxMSUFfQUVTTklfQVZYMl9QQVJBTExFTF9C TE9DS1MsCi0JCS5mbl91ID0geyAueHRzID0gY2FtZWxsaWFfeHRzX2VuY18zMndheSB9Ci0JfSwg ewotCQkubnVtX2Jsb2NrcyA9IENBTUVMTElBX0FFU05JX1BBUkFMTEVMX0JMT0NLUywKLQkJLmZu X3UgPSB7IC54dHMgPSBjYW1lbGxpYV94dHNfZW5jXzE2d2F5IH0KLQl9LCB7Ci0JCS5udW1fYmxv Y2tzID0gMSwKLQkJLmZuX3UgPSB7IC54dHMgPSBjYW1lbGxpYV94dHNfZW5jIH0KLQl9IH0KLX07 Ci0KIHN0YXRpYyBjb25zdCBzdHJ1Y3QgY29tbW9uX2dsdWVfY3R4IGNhbWVsbGlhX2RlYyA9IHsK IAkubnVtX2Z1bmNzID0gNCwKIAkuZnB1X2Jsb2Nrc19saW1pdCA9IENBTUVMTElBX0FFU05JX1BB UkFMTEVMX0JMT0NLUywKQEAgLTEyMywyMiArMTAxLDYgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBj b21tb25fZ2x1ZV9jdHggY2FtZWxsaWFfZGVjX2NiYyA9IHsKIAl9IH0KIH07CiAKLXN0YXRpYyBj b25zdCBzdHJ1Y3QgY29tbW9uX2dsdWVfY3R4IGNhbWVsbGlhX2RlY194dHMgPSB7Ci0JLm51bV9m dW5jcyA9IDMsCi0JLmZwdV9ibG9ja3NfbGltaXQgPSBDQU1FTExJQV9BRVNOSV9QQVJBTExFTF9C TE9DS1MsCi0KLQkuZnVuY3MgPSB7IHsKLQkJLm51bV9ibG9ja3MgPSBDQU1FTExJQV9BRVNOSV9B VlgyX1BBUkFMTEVMX0JMT0NLUywKLQkJLmZuX3UgPSB7IC54dHMgPSBjYW1lbGxpYV94dHNfZGVj XzMyd2F5IH0KLQl9LCB7Ci0JCS5udW1fYmxvY2tzID0gQ0FNRUxMSUFfQUVTTklfUEFSQUxMRUxf QkxPQ0tTLAotCQkuZm5fdSA9IHsgLnh0cyA9IGNhbWVsbGlhX3h0c19kZWNfMTZ3YXkgfQotCX0s IHsKLQkJLm51bV9ibG9ja3MgPSAxLAotCQkuZm5fdSA9IHsgLnh0cyA9IGNhbWVsbGlhX3h0c19k ZWMgfQotCX0gfQotfTsKLQogc3RhdGljIGludCBjYW1lbGxpYV9zZXRrZXkoc3RydWN0IGNyeXB0 b19za2NpcGhlciAqdGZtLCBjb25zdCB1OCAqa2V5LAogCQkJICAgdW5zaWduZWQgaW50IGtleWxl bikKIHsKQEAgLTE3MCwyNCArMTMyLDYgQEAgc3RhdGljIGludCBjdHJfY3J5cHQoc3RydWN0IHNr Y2lwaGVyX3JlcXVlc3QgKnJlcSkKIAlyZXR1cm4gZ2x1ZV9jdHJfcmVxXzEyOGJpdCgmY2FtZWxs aWFfY3RyLCByZXEpOwogfQogCi1zdGF0aWMgaW50IHh0c19lbmNyeXB0KHN0cnVjdCBza2NpcGhl cl9yZXF1ZXN0ICpyZXEpCi17Ci0Jc3RydWN0IGNyeXB0b19za2NpcGhlciAqdGZtID0gY3J5cHRv X3NrY2lwaGVyX3JlcXRmbShyZXEpOwotCXN0cnVjdCBjYW1lbGxpYV94dHNfY3R4ICpjdHggPSBj cnlwdG9fc2tjaXBoZXJfY3R4KHRmbSk7Ci0KLQlyZXR1cm4gZ2x1ZV94dHNfcmVxXzEyOGJpdCgm Y2FtZWxsaWFfZW5jX3h0cywgcmVxLCBjYW1lbGxpYV9lbmNfYmxrLAotCQkJCSAgICZjdHgtPnR3 ZWFrX2N0eCwgJmN0eC0+Y3J5cHRfY3R4LCBmYWxzZSk7Ci19Ci0KLXN0YXRpYyBpbnQgeHRzX2Rl Y3J5cHQoc3RydWN0IHNrY2lwaGVyX3JlcXVlc3QgKnJlcSkKLXsKLQlzdHJ1Y3QgY3J5cHRvX3Nr Y2lwaGVyICp0Zm0gPSBjcnlwdG9fc2tjaXBoZXJfcmVxdGZtKHJlcSk7Ci0Jc3RydWN0IGNhbWVs bGlhX3h0c19jdHggKmN0eCA9IGNyeXB0b19za2NpcGhlcl9jdHgodGZtKTsKLQotCXJldHVybiBn bHVlX3h0c19yZXFfMTI4Yml0KCZjYW1lbGxpYV9kZWNfeHRzLCByZXEsIGNhbWVsbGlhX2VuY19i bGssCi0JCQkJICAgJmN0eC0+dHdlYWtfY3R4LCAmY3R4LT5jcnlwdF9jdHgsIHRydWUpOwotfQot CiBzdGF0aWMgc3RydWN0IHNrY2lwaGVyX2FsZyBjYW1lbGxpYV9hbGdzW10gPSB7CiAJewogCQku YmFzZS5jcmFfbmFtZQkJPSAiX19lY2IoY2FtZWxsaWEpIiwKQEAgLTIzMSwyMCArMTc1LDYgQEAg c3RhdGljIHN0cnVjdCBza2NpcGhlcl9hbGcgY2FtZWxsaWFfYWxnc1tdID0gewogCQkuc2V0a2V5 CQkJPSBjYW1lbGxpYV9zZXRrZXksCiAJCS5lbmNyeXB0CQk9IGN0cl9jcnlwdCwKIAkJLmRlY3J5 cHQJCT0gY3RyX2NyeXB0LAotCX0sIHsKLQkJLmJhc2UuY3JhX25hbWUJCT0gIl9feHRzKGNhbWVs bGlhKSIsCi0JCS5iYXNlLmNyYV9kcml2ZXJfbmFtZQk9ICJfX3h0cy1jYW1lbGxpYS1hZXNuaS1h dngyIiwKLQkJLmJhc2UuY3JhX3ByaW9yaXR5CT0gNTAwLAotCQkuYmFzZS5jcmFfZmxhZ3MJCT0g Q1JZUFRPX0FMR19JTlRFUk5BTCwKLQkJLmJhc2UuY3JhX2Jsb2Nrc2l6ZQk9IENBTUVMTElBX0JM T0NLX1NJWkUsCi0JCS5iYXNlLmNyYV9jdHhzaXplCT0gc2l6ZW9mKHN0cnVjdCBjYW1lbGxpYV94 dHNfY3R4KSwKLQkJLmJhc2UuY3JhX21vZHVsZQk9IFRISVNfTU9EVUxFLAotCQkubWluX2tleXNp emUJCT0gMiAqIENBTUVMTElBX01JTl9LRVlfU0laRSwKLQkJLm1heF9rZXlzaXplCQk9IDIgKiBD QU1FTExJQV9NQVhfS0VZX1NJWkUsCi0JCS5pdnNpemUJCQk9IENBTUVMTElBX0JMT0NLX1NJWkUs Ci0JCS5zZXRrZXkJCQk9IHh0c19jYW1lbGxpYV9zZXRrZXksCi0JCS5lbmNyeXB0CQk9IHh0c19l bmNyeXB0LAotCQkuZGVjcnlwdAkJPSB4dHNfZGVjcnlwdCwKIAl9LAogfTsKIApkaWZmIC0tZ2l0 IGEvYXJjaC94ODYvY3J5cHRvL2NhbWVsbGlhX2Flc25pX2F2eF9nbHVlLmMgYi9hcmNoL3g4Ni9j cnlwdG8vY2FtZWxsaWFfYWVzbmlfYXZ4X2dsdWUuYwppbmRleCA0ZTVkZTZlZjIwNmUuLjQ0NjE0 ZjhhNDUyYyAxMDA2NDQKLS0tIGEvYXJjaC94ODYvY3J5cHRvL2NhbWVsbGlhX2Flc25pX2F2eF9n bHVlLmMKKysrIGIvYXJjaC94ODYvY3J5cHRvL2NhbWVsbGlhX2Flc25pX2F2eF9nbHVlLmMKQEAg LTksNyArOSw2IEBACiAjaW5jbHVkZSA8YXNtL2NyeXB0by9nbHVlX2hlbHBlci5oPgogI2luY2x1 ZGUgPGNyeXB0by9hbGdhcGkuaD4KICNpbmNsdWRlIDxjcnlwdG8vaW50ZXJuYWwvc2ltZC5oPgot I2luY2x1ZGUgPGNyeXB0by94dHMuaD4KICNpbmNsdWRlIDxsaW51eC9jcnlwdG8uaD4KICNpbmNs dWRlIDxsaW51eC9lcnIuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KQEAgLTMxLDI2ICsz MCw2IEBAIGFzbWxpbmthZ2Ugdm9pZCBjYW1lbGxpYV9jdHJfMTZ3YXkoY29uc3Qgdm9pZCAqY3R4 LCB1OCAqZHN0LCBjb25zdCB1OCAqc3JjLAogCQkJCSAgIGxlMTI4ICppdik7CiBFWFBPUlRfU1lN Qk9MX0dQTChjYW1lbGxpYV9jdHJfMTZ3YXkpOwogCi1hc21saW5rYWdlIHZvaWQgY2FtZWxsaWFf eHRzX2VuY18xNndheShjb25zdCB2b2lkICpjdHgsIHU4ICpkc3QsIGNvbnN0IHU4ICpzcmMsCi0J CQkJICAgICAgIGxlMTI4ICppdik7Ci1FWFBPUlRfU1lNQk9MX0dQTChjYW1lbGxpYV94dHNfZW5j XzE2d2F5KTsKLQotYXNtbGlua2FnZSB2b2lkIGNhbWVsbGlhX3h0c19kZWNfMTZ3YXkoY29uc3Qg dm9pZCAqY3R4LCB1OCAqZHN0LCBjb25zdCB1OCAqc3JjLAotCQkJCSAgICAgICBsZTEyOCAqaXYp OwotRVhQT1JUX1NZTUJPTF9HUEwoY2FtZWxsaWFfeHRzX2RlY18xNndheSk7Ci0KLXZvaWQgY2Ft ZWxsaWFfeHRzX2VuYyhjb25zdCB2b2lkICpjdHgsIHU4ICpkc3QsIGNvbnN0IHU4ICpzcmMsIGxl MTI4ICppdikKLXsKLQlnbHVlX3h0c19jcnlwdF8xMjhiaXRfb25lKGN0eCwgZHN0LCBzcmMsIGl2 LCBjYW1lbGxpYV9lbmNfYmxrKTsKLX0KLUVYUE9SVF9TWU1CT0xfR1BMKGNhbWVsbGlhX3h0c19l bmMpOwotCi12b2lkIGNhbWVsbGlhX3h0c19kZWMoY29uc3Qgdm9pZCAqY3R4LCB1OCAqZHN0LCBj b25zdCB1OCAqc3JjLCBsZTEyOCAqaXYpCi17Ci0JZ2x1ZV94dHNfY3J5cHRfMTI4Yml0X29uZShj dHgsIGRzdCwgc3JjLCBpdiwgY2FtZWxsaWFfZGVjX2Jsayk7Ci19Ci1FWFBPUlRfU1lNQk9MX0dQ TChjYW1lbGxpYV94dHNfZGVjKTsKLQogc3RhdGljIGNvbnN0IHN0cnVjdCBjb21tb25fZ2x1ZV9j dHggY2FtZWxsaWFfZW5jID0gewogCS5udW1fZnVuY3MgPSAzLAogCS5mcHVfYmxvY2tzX2xpbWl0 ID0gQ0FNRUxMSUFfQUVTTklfUEFSQUxMRUxfQkxPQ0tTLApAQCAtODMsMTkgKzYyLDYgQEAgc3Rh dGljIGNvbnN0IHN0cnVjdCBjb21tb25fZ2x1ZV9jdHggY2FtZWxsaWFfY3RyID0gewogCX0gfQog fTsKIAotc3RhdGljIGNvbnN0IHN0cnVjdCBjb21tb25fZ2x1ZV9jdHggY2FtZWxsaWFfZW5jX3h0 cyA9IHsKLQkubnVtX2Z1bmNzID0gMiwKLQkuZnB1X2Jsb2Nrc19saW1pdCA9IENBTUVMTElBX0FF U05JX1BBUkFMTEVMX0JMT0NLUywKLQotCS5mdW5jcyA9IHsgewotCQkubnVtX2Jsb2NrcyA9IENB TUVMTElBX0FFU05JX1BBUkFMTEVMX0JMT0NLUywKLQkJLmZuX3UgPSB7IC54dHMgPSBjYW1lbGxp YV94dHNfZW5jXzE2d2F5IH0KLQl9LCB7Ci0JCS5udW1fYmxvY2tzID0gMSwKLQkJLmZuX3UgPSB7 IC54dHMgPSBjYW1lbGxpYV94dHNfZW5jIH0KLQl9IH0KLX07Ci0KIHN0YXRpYyBjb25zdCBzdHJ1 Y3QgY29tbW9uX2dsdWVfY3R4IGNhbWVsbGlhX2RlYyA9IHsKIAkubnVtX2Z1bmNzID0gMywKIAku ZnB1X2Jsb2Nrc19saW1pdCA9IENBTUVMTElBX0FFU05JX1BBUkFMTEVMX0JMT0NLUywKQEAgLTEy OCwxOSArOTQsNiBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGNvbW1vbl9nbHVlX2N0eCBjYW1lbGxp YV9kZWNfY2JjID0gewogCX0gfQogfTsKIAotc3RhdGljIGNvbnN0IHN0cnVjdCBjb21tb25fZ2x1 ZV9jdHggY2FtZWxsaWFfZGVjX3h0cyA9IHsKLQkubnVtX2Z1bmNzID0gMiwKLQkuZnB1X2Jsb2Nr c19saW1pdCA9IENBTUVMTElBX0FFU05JX1BBUkFMTEVMX0JMT0NLUywKLQotCS5mdW5jcyA9IHsg ewotCQkubnVtX2Jsb2NrcyA9IENBTUVMTElBX0FFU05JX1BBUkFMTEVMX0JMT0NLUywKLQkJLmZu X3UgPSB7IC54dHMgPSBjYW1lbGxpYV94dHNfZGVjXzE2d2F5IH0KLQl9LCB7Ci0JCS5udW1fYmxv Y2tzID0gMSwKLQkJLmZuX3UgPSB7IC54dHMgPSBjYW1lbGxpYV94dHNfZGVjIH0KLQl9IH0KLX07 Ci0KIHN0YXRpYyBpbnQgY2FtZWxsaWFfc2V0a2V5KHN0cnVjdCBjcnlwdG9fc2tjaXBoZXIgKnRm bSwgY29uc3QgdTggKmtleSwKIAkJCSAgIHVuc2lnbmVkIGludCBrZXlsZW4pCiB7CkBAIC0xNzIs NDQgKzEyNSw2IEBAIHN0YXRpYyBpbnQgY3RyX2NyeXB0KHN0cnVjdCBza2NpcGhlcl9yZXF1ZXN0 ICpyZXEpCiAJcmV0dXJuIGdsdWVfY3RyX3JlcV8xMjhiaXQoJmNhbWVsbGlhX2N0ciwgcmVxKTsK IH0KIAotaW50IHh0c19jYW1lbGxpYV9zZXRrZXkoc3RydWN0IGNyeXB0b19za2NpcGhlciAqdGZt LCBjb25zdCB1OCAqa2V5LAotCQkJdW5zaWduZWQgaW50IGtleWxlbikKLXsKLQlzdHJ1Y3QgY2Ft ZWxsaWFfeHRzX2N0eCAqY3R4ID0gY3J5cHRvX3NrY2lwaGVyX2N0eCh0Zm0pOwotCWludCBlcnI7 Ci0KLQllcnIgPSB4dHNfdmVyaWZ5X2tleSh0Zm0sIGtleSwga2V5bGVuKTsKLQlpZiAoZXJyKQot CQlyZXR1cm4gZXJyOwotCi0JLyogZmlyc3QgaGFsZiBvZiB4dHMta2V5IGlzIGZvciBjcnlwdCAq LwotCWVyciA9IF9fY2FtZWxsaWFfc2V0a2V5KCZjdHgtPmNyeXB0X2N0eCwga2V5LCBrZXlsZW4g LyAyKTsKLQlpZiAoZXJyKQotCQlyZXR1cm4gZXJyOwotCi0JLyogc2Vjb25kIGhhbGYgb2YgeHRz LWtleSBpcyBmb3IgdHdlYWsgKi8KLQlyZXR1cm4gX19jYW1lbGxpYV9zZXRrZXkoJmN0eC0+dHdl YWtfY3R4LCBrZXkgKyBrZXlsZW4gLyAyLCBrZXlsZW4gLyAyKTsKLX0KLUVYUE9SVF9TWU1CT0xf R1BMKHh0c19jYW1lbGxpYV9zZXRrZXkpOwotCi1zdGF0aWMgaW50IHh0c19lbmNyeXB0KHN0cnVj dCBza2NpcGhlcl9yZXF1ZXN0ICpyZXEpCi17Ci0Jc3RydWN0IGNyeXB0b19za2NpcGhlciAqdGZt ID0gY3J5cHRvX3NrY2lwaGVyX3JlcXRmbShyZXEpOwotCXN0cnVjdCBjYW1lbGxpYV94dHNfY3R4 ICpjdHggPSBjcnlwdG9fc2tjaXBoZXJfY3R4KHRmbSk7Ci0KLQlyZXR1cm4gZ2x1ZV94dHNfcmVx XzEyOGJpdCgmY2FtZWxsaWFfZW5jX3h0cywgcmVxLCBjYW1lbGxpYV9lbmNfYmxrLAotCQkJCSAg ICZjdHgtPnR3ZWFrX2N0eCwgJmN0eC0+Y3J5cHRfY3R4LCBmYWxzZSk7Ci19Ci0KLXN0YXRpYyBp bnQgeHRzX2RlY3J5cHQoc3RydWN0IHNrY2lwaGVyX3JlcXVlc3QgKnJlcSkKLXsKLQlzdHJ1Y3Qg Y3J5cHRvX3NrY2lwaGVyICp0Zm0gPSBjcnlwdG9fc2tjaXBoZXJfcmVxdGZtKHJlcSk7Ci0Jc3Ry dWN0IGNhbWVsbGlhX3h0c19jdHggKmN0eCA9IGNyeXB0b19za2NpcGhlcl9jdHgodGZtKTsKLQot CXJldHVybiBnbHVlX3h0c19yZXFfMTI4Yml0KCZjYW1lbGxpYV9kZWNfeHRzLCByZXEsIGNhbWVs bGlhX2VuY19ibGssCi0JCQkJICAgJmN0eC0+dHdlYWtfY3R4LCAmY3R4LT5jcnlwdF9jdHgsIHRy dWUpOwotfQotCiBzdGF0aWMgc3RydWN0IHNrY2lwaGVyX2FsZyBjYW1lbGxpYV9hbGdzW10gPSB7 CiAJewogCQkuYmFzZS5jcmFfbmFtZQkJPSAiX19lY2IoY2FtZWxsaWEpIiwKQEAgLTI1MywyMSAr MTY4LDcgQEAgc3RhdGljIHN0cnVjdCBza2NpcGhlcl9hbGcgY2FtZWxsaWFfYWxnc1tdID0gewog CQkuc2V0a2V5CQkJPSBjYW1lbGxpYV9zZXRrZXksCiAJCS5lbmNyeXB0CQk9IGN0cl9jcnlwdCwK IAkJLmRlY3J5cHQJCT0gY3RyX2NyeXB0LAotCX0sIHsKLQkJLmJhc2UuY3JhX25hbWUJCT0gIl9f eHRzKGNhbWVsbGlhKSIsCi0JCS5iYXNlLmNyYV9kcml2ZXJfbmFtZQk9ICJfX3h0cy1jYW1lbGxp YS1hZXNuaSIsCi0JCS5iYXNlLmNyYV9wcmlvcml0eQk9IDQwMCwKLQkJLmJhc2UuY3JhX2ZsYWdz CQk9IENSWVBUT19BTEdfSU5URVJOQUwsCi0JCS5iYXNlLmNyYV9ibG9ja3NpemUJPSBDQU1FTExJ QV9CTE9DS19TSVpFLAotCQkuYmFzZS5jcmFfY3R4c2l6ZQk9IHNpemVvZihzdHJ1Y3QgY2FtZWxs aWFfeHRzX2N0eCksCi0JCS5iYXNlLmNyYV9tb2R1bGUJPSBUSElTX01PRFVMRSwKLQkJLm1pbl9r ZXlzaXplCQk9IDIgKiBDQU1FTExJQV9NSU5fS0VZX1NJWkUsCi0JCS5tYXhfa2V5c2l6ZQkJPSAy ICogQ0FNRUxMSUFfTUFYX0tFWV9TSVpFLAotCQkuaXZzaXplCQkJPSBDQU1FTExJQV9CTE9DS19T SVpFLAotCQkuc2V0a2V5CQkJPSB4dHNfY2FtZWxsaWFfc2V0a2V5LAotCQkuZW5jcnlwdAkJPSB4 dHNfZW5jcnlwdCwKLQkJLmRlY3J5cHQJCT0geHRzX2RlY3J5cHQsCi0JfSwKKwl9CiB9OwogCiBz dGF0aWMgc3RydWN0IHNpbWRfc2tjaXBoZXJfYWxnICpjYW1lbGxpYV9zaW1kX2FsZ3NbQVJSQVlf U0laRShjYW1lbGxpYV9hbGdzKV07CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9j cnlwdG8vY2FtZWxsaWEuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2NyeXB0by9jYW1lbGxpYS5o CmluZGV4IGY2ZDkxODYxY2IxNC4uMGU1ZjgyYWRiYWY5IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9p bmNsdWRlL2FzbS9jcnlwdG8vY2FtZWxsaWEuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9j cnlwdG8vY2FtZWxsaWEuaApAQCAtMTksMTggKzE5LDEwIEBAIHN0cnVjdCBjYW1lbGxpYV9jdHgg ewogCXUzMiBrZXlfbGVuZ3RoOwogfTsKIAotc3RydWN0IGNhbWVsbGlhX3h0c19jdHggewotCXN0 cnVjdCBjYW1lbGxpYV9jdHggdHdlYWtfY3R4OwotCXN0cnVjdCBjYW1lbGxpYV9jdHggY3J5cHRf Y3R4OwotfTsKLQogZXh0ZXJuIGludCBfX2NhbWVsbGlhX3NldGtleShzdHJ1Y3QgY2FtZWxsaWFf Y3R4ICpjY3R4LAogCQkJICAgICBjb25zdCB1bnNpZ25lZCBjaGFyICprZXksCiAJCQkgICAgIHVu c2lnbmVkIGludCBrZXlfbGVuKTsKIAotZXh0ZXJuIGludCB4dHNfY2FtZWxsaWFfc2V0a2V5KHN0 cnVjdCBjcnlwdG9fc2tjaXBoZXIgKnRmbSwgY29uc3QgdTggKmtleSwKLQkJCSAgICAgICB1bnNp Z25lZCBpbnQga2V5bGVuKTsKLQogLyogcmVndWxhciBibG9jayBjaXBoZXIgZnVuY3Rpb25zICov CiBhc21saW5rYWdlIHZvaWQgX19jYW1lbGxpYV9lbmNfYmxrKGNvbnN0IHZvaWQgKmN0eCwgdTgg KmRzdCwgY29uc3QgdTggKnNyYywKIAkJCQkgICBib29sIHhvcik7CkBAIC00OSwxMSArNDEsNiBA QCBhc21saW5rYWdlIHZvaWQgY2FtZWxsaWFfY2JjX2RlY18xNndheShjb25zdCB2b2lkICpjdHgs IHU4ICpkc3QsIGNvbnN0IHU4ICpzcmMpOwogYXNtbGlua2FnZSB2b2lkIGNhbWVsbGlhX2N0cl8x NndheShjb25zdCB2b2lkICpjdHgsIHU4ICpkc3QsIGNvbnN0IHU4ICpzcmMsCiAJCQkJICAgbGUx MjggKml2KTsKIAotYXNtbGlua2FnZSB2b2lkIGNhbWVsbGlhX3h0c19lbmNfMTZ3YXkoY29uc3Qg dm9pZCAqY3R4LCB1OCAqZHN0LCBjb25zdCB1OCAqc3JjLAotCQkJCSAgICAgICBsZTEyOCAqaXYp OwotYXNtbGlua2FnZSB2b2lkIGNhbWVsbGlhX3h0c19kZWNfMTZ3YXkoY29uc3Qgdm9pZCAqY3R4 LCB1OCAqZHN0LCBjb25zdCB1OCAqc3JjLAotCQkJCSAgICAgICBsZTEyOCAqaXYpOwotCiBzdGF0 aWMgaW5saW5lIHZvaWQgY2FtZWxsaWFfZW5jX2Jsayhjb25zdCB2b2lkICpjdHgsIHU4ICpkc3Qs IGNvbnN0IHU4ICpzcmMpCiB7CiAJX19jYW1lbGxpYV9lbmNfYmxrKGN0eCwgZHN0LCBzcmMsIGZh bHNlKTsKQEAgLTgzLDkgKzcwLDQgQEAgZXh0ZXJuIHZvaWQgY2FtZWxsaWFfY3J5cHRfY3RyKGNv bnN0IHZvaWQgKmN0eCwgdTggKmRzdCwgY29uc3QgdTggKnNyYywKIGV4dGVybiB2b2lkIGNhbWVs bGlhX2NyeXB0X2N0cl8yd2F5KGNvbnN0IHZvaWQgKmN0eCwgdTggKmRzdCwgY29uc3QgdTggKnNy YywKIAkJCQkgICAgbGUxMjggKml2KTsKIAotZXh0ZXJuIHZvaWQgY2FtZWxsaWFfeHRzX2VuYyhj b25zdCB2b2lkICpjdHgsIHU4ICpkc3QsIGNvbnN0IHU4ICpzcmMsCi0JCQkgICAgIGxlMTI4ICpp dik7Ci1leHRlcm4gdm9pZCBjYW1lbGxpYV94dHNfZGVjKGNvbnN0IHZvaWQgKmN0eCwgdTggKmRz dCwgY29uc3QgdTggKnNyYywKLQkJCSAgICAgbGUxMjggKml2KTsKLQogI2VuZGlmIC8qIEFTTV9Y ODZfQ0FNRUxMSUFfSCAqLwotLSAKMi4xNy4xCgoKLS0KZG0tZGV2ZWwgbWFpbGluZyBsaXN0CmRt LWRldmVsQHJlZGhhdC5jb20KaHR0cHM6Ly93d3cucmVkaGF0LmNvbS9tYWlsbWFuL2xpc3RpbmZv L2RtLWRldmVs 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=-19.0 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,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 314FFC433DB for ; Wed, 23 Dec 2020 22:39:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id E9F0B22955 for ; Wed, 23 Dec 2020 22:39:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726279AbgLWWjp (ORCPT ); Wed, 23 Dec 2020 17:39:45 -0500 Received: from mail.kernel.org ([198.145.29.99]:59228 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725811AbgLWWjo (ORCPT ); Wed, 23 Dec 2020 17:39:44 -0500 Received: by mail.kernel.org (Postfix) with ESMTPSA id 4D0D9223E0; Wed, 23 Dec 2020 22:39:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1608763143; bh=FfOLsukuUAlU/P2uYv1a0PGd6ELkIxt7Ahgo3EMIxZA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=oJA66AmAcyFFjuNEvW4s1LB2sC9RMu6OcBQori5lBZMSpbpJo13uvx9sfe2q+pl1Q 3KYQX7IUUBNznq8qdrM1oksUP5aG8fUSP5bavURIEvRRVqlxpUn4qgI+HyfXRvxqPF Y9LvAmYobMCQSYUAWAJ7iq0KZoalMELzKsHrBuUc+QHYY0lYnKBwupyj/L6omqSn+z Af9DAZpiEH2ITaV8Ns6v1pMabAMtC6UGtZ3d+tYHRrJxWCWh+oV2FWUk0oTqPLuEC6 TGP2elNoc5neo7C9r9kwZmjAccNUAwcECTIcA189jEkq09Z5Zrhma6zt1iXae/Vwa0 Yh247fPj0j5ag== From: Ard Biesheuvel To: linux-crypto@vger.kernel.org Cc: dm-devel@redhat.com, Ard Biesheuvel , Megha Dey , Eric Biggers , Herbert Xu , Milan Broz , Mike Snitzer Subject: [RFC PATCH 01/10] crypto: x86/camellia - switch to XTS template Date: Wed, 23 Dec 2020 23:38:32 +0100 Message-Id: <20201223223841.11311-2-ardb@kernel.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20201223223841.11311-1-ardb@kernel.org> References: <20201223223841.11311-1-ardb@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-crypto@vger.kernel.org Now that the XTS template can wrap accelerated ECB modes, it can be used to implement Camellia in XTS mode as well, which turns out to be at least as fast, and sometimes even faster. Signed-off-by: Ard Biesheuvel --- arch/x86/crypto/camellia-aesni-avx-asm_64.S | 180 ----------------- arch/x86/crypto/camellia-aesni-avx2-asm_64.S | 206 -------------------- arch/x86/crypto/camellia_aesni_avx2_glue.c | 70 ------- arch/x86/crypto/camellia_aesni_avx_glue.c | 101 +--------- arch/x86/include/asm/crypto/camellia.h | 18 -- 5 files changed, 1 insertion(+), 574 deletions(-) diff --git a/arch/x86/crypto/camellia-aesni-avx-asm_64.S b/arch/x86/crypto/camellia-aesni-avx-asm_64.S index ecc0a9a905c4..1e0383a84247 100644 --- a/arch/x86/crypto/camellia-aesni-avx-asm_64.S +++ b/arch/x86/crypto/camellia-aesni-avx-asm_64.S @@ -593,10 +593,6 @@ SYM_FUNC_END(roundsm16_x4_x5_x6_x7_x0_x1_x2_x3_y4_y5_y6_y7_y0_y1_y2_y3_ab) .Lbswap128_mask: .byte 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 -/* For XTS mode IV generation */ -.Lxts_gf128mul_and_shl1_mask: - .byte 0x87, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 - /* * pre-SubByte transform * @@ -1111,179 +1107,3 @@ SYM_FUNC_START(camellia_ctr_16way) FRAME_END ret; SYM_FUNC_END(camellia_ctr_16way) - -#define gf128mul_x_ble(iv, mask, tmp) \ - vpsrad $31, iv, tmp; \ - vpaddq iv, iv, iv; \ - vpshufd $0x13, tmp, tmp; \ - vpand mask, tmp, tmp; \ - vpxor tmp, iv, iv; - -.align 8 -SYM_FUNC_START_LOCAL(camellia_xts_crypt_16way) - /* input: - * %rdi: ctx, CTX - * %rsi: dst (16 blocks) - * %rdx: src (16 blocks) - * %rcx: iv (t ⊕ αⁿ ∈ GF(2¹²⁸)) - * %r8: index for input whitening key - * %r9: pointer to __camellia_enc_blk16 or __camellia_dec_blk16 - */ - FRAME_BEGIN - - subq $(16 * 16), %rsp; - movq %rsp, %rax; - - vmovdqa .Lxts_gf128mul_and_shl1_mask, %xmm14; - - /* load IV */ - vmovdqu (%rcx), %xmm0; - vpxor 0 * 16(%rdx), %xmm0, %xmm15; - vmovdqu %xmm15, 15 * 16(%rax); - vmovdqu %xmm0, 0 * 16(%rsi); - - /* construct IVs */ - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 1 * 16(%rdx), %xmm0, %xmm15; - vmovdqu %xmm15, 14 * 16(%rax); - vmovdqu %xmm0, 1 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 2 * 16(%rdx), %xmm0, %xmm13; - vmovdqu %xmm0, 2 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 3 * 16(%rdx), %xmm0, %xmm12; - vmovdqu %xmm0, 3 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 4 * 16(%rdx), %xmm0, %xmm11; - vmovdqu %xmm0, 4 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 5 * 16(%rdx), %xmm0, %xmm10; - vmovdqu %xmm0, 5 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 6 * 16(%rdx), %xmm0, %xmm9; - vmovdqu %xmm0, 6 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 7 * 16(%rdx), %xmm0, %xmm8; - vmovdqu %xmm0, 7 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 8 * 16(%rdx), %xmm0, %xmm7; - vmovdqu %xmm0, 8 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 9 * 16(%rdx), %xmm0, %xmm6; - vmovdqu %xmm0, 9 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 10 * 16(%rdx), %xmm0, %xmm5; - vmovdqu %xmm0, 10 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 11 * 16(%rdx), %xmm0, %xmm4; - vmovdqu %xmm0, 11 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 12 * 16(%rdx), %xmm0, %xmm3; - vmovdqu %xmm0, 12 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 13 * 16(%rdx), %xmm0, %xmm2; - vmovdqu %xmm0, 13 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 14 * 16(%rdx), %xmm0, %xmm1; - vmovdqu %xmm0, 14 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vpxor 15 * 16(%rdx), %xmm0, %xmm15; - vmovdqu %xmm15, 0 * 16(%rax); - vmovdqu %xmm0, 15 * 16(%rsi); - - gf128mul_x_ble(%xmm0, %xmm14, %xmm15); - vmovdqu %xmm0, (%rcx); - - /* inpack16_pre: */ - vmovq (key_table)(CTX, %r8, 8), %xmm15; - vpshufb .Lpack_bswap, %xmm15, %xmm15; - vpxor 0 * 16(%rax), %xmm15, %xmm0; - vpxor %xmm1, %xmm15, %xmm1; - vpxor %xmm2, %xmm15, %xmm2; - vpxor %xmm3, %xmm15, %xmm3; - vpxor %xmm4, %xmm15, %xmm4; - vpxor %xmm5, %xmm15, %xmm5; - vpxor %xmm6, %xmm15, %xmm6; - vpxor %xmm7, %xmm15, %xmm7; - vpxor %xmm8, %xmm15, %xmm8; - vpxor %xmm9, %xmm15, %xmm9; - vpxor %xmm10, %xmm15, %xmm10; - vpxor %xmm11, %xmm15, %xmm11; - vpxor %xmm12, %xmm15, %xmm12; - vpxor %xmm13, %xmm15, %xmm13; - vpxor 14 * 16(%rax), %xmm15, %xmm14; - vpxor 15 * 16(%rax), %xmm15, %xmm15; - - CALL_NOSPEC r9; - - addq $(16 * 16), %rsp; - - vpxor 0 * 16(%rsi), %xmm7, %xmm7; - vpxor 1 * 16(%rsi), %xmm6, %xmm6; - vpxor 2 * 16(%rsi), %xmm5, %xmm5; - vpxor 3 * 16(%rsi), %xmm4, %xmm4; - vpxor 4 * 16(%rsi), %xmm3, %xmm3; - vpxor 5 * 16(%rsi), %xmm2, %xmm2; - vpxor 6 * 16(%rsi), %xmm1, %xmm1; - vpxor 7 * 16(%rsi), %xmm0, %xmm0; - vpxor 8 * 16(%rsi), %xmm15, %xmm15; - vpxor 9 * 16(%rsi), %xmm14, %xmm14; - vpxor 10 * 16(%rsi), %xmm13, %xmm13; - vpxor 11 * 16(%rsi), %xmm12, %xmm12; - vpxor 12 * 16(%rsi), %xmm11, %xmm11; - vpxor 13 * 16(%rsi), %xmm10, %xmm10; - vpxor 14 * 16(%rsi), %xmm9, %xmm9; - vpxor 15 * 16(%rsi), %xmm8, %xmm8; - write_output(%xmm7, %xmm6, %xmm5, %xmm4, %xmm3, %xmm2, %xmm1, %xmm0, - %xmm15, %xmm14, %xmm13, %xmm12, %xmm11, %xmm10, %xmm9, - %xmm8, %rsi); - - FRAME_END - ret; -SYM_FUNC_END(camellia_xts_crypt_16way) - -SYM_FUNC_START(camellia_xts_enc_16way) - /* input: - * %rdi: ctx, CTX - * %rsi: dst (16 blocks) - * %rdx: src (16 blocks) - * %rcx: iv (t ⊕ αⁿ ∈ GF(2¹²⁸)) - */ - xorl %r8d, %r8d; /* input whitening key, 0 for enc */ - - leaq __camellia_enc_blk16, %r9; - - jmp camellia_xts_crypt_16way; -SYM_FUNC_END(camellia_xts_enc_16way) - -SYM_FUNC_START(camellia_xts_dec_16way) - /* input: - * %rdi: ctx, CTX - * %rsi: dst (16 blocks) - * %rdx: src (16 blocks) - * %rcx: iv (t ⊕ αⁿ ∈ GF(2¹²⁸)) - */ - - cmpl $16, key_length(CTX); - movl $32, %r8d; - movl $24, %eax; - cmovel %eax, %r8d; /* input whitening key, last for dec */ - - leaq __camellia_dec_blk16, %r9; - - jmp camellia_xts_crypt_16way; -SYM_FUNC_END(camellia_xts_dec_16way) diff --git a/arch/x86/crypto/camellia-aesni-avx2-asm_64.S b/arch/x86/crypto/camellia-aesni-avx2-asm_64.S index 0907243c501c..432bfaf54ff9 100644 --- a/arch/x86/crypto/camellia-aesni-avx2-asm_64.S +++ b/arch/x86/crypto/camellia-aesni-avx2-asm_64.S @@ -629,12 +629,6 @@ SYM_FUNC_END(roundsm32_x4_x5_x6_x7_x0_x1_x2_x3_y4_y5_y6_y7_y0_y1_y2_y3_ab) .Lbswap128_mask: .byte 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 -/* For XTS mode */ -.Lxts_gf128mul_and_shl1_mask_0: - .byte 0x87, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 -.Lxts_gf128mul_and_shl1_mask_1: - .byte 0x0e, 1, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 - /* * pre-SubByte transform * @@ -1201,203 +1195,3 @@ SYM_FUNC_START(camellia_ctr_32way) FRAME_END ret; SYM_FUNC_END(camellia_ctr_32way) - -#define gf128mul_x_ble(iv, mask, tmp) \ - vpsrad $31, iv, tmp; \ - vpaddq iv, iv, iv; \ - vpshufd $0x13, tmp, tmp; \ - vpand mask, tmp, tmp; \ - vpxor tmp, iv, iv; - -#define gf128mul_x2_ble(iv, mask1, mask2, tmp0, tmp1) \ - vpsrad $31, iv, tmp0; \ - vpaddq iv, iv, tmp1; \ - vpsllq $2, iv, iv; \ - vpshufd $0x13, tmp0, tmp0; \ - vpsrad $31, tmp1, tmp1; \ - vpand mask2, tmp0, tmp0; \ - vpshufd $0x13, tmp1, tmp1; \ - vpxor tmp0, iv, iv; \ - vpand mask1, tmp1, tmp1; \ - vpxor tmp1, iv, iv; - -.align 8 -SYM_FUNC_START_LOCAL(camellia_xts_crypt_32way) - /* input: - * %rdi: ctx, CTX - * %rsi: dst (32 blocks) - * %rdx: src (32 blocks) - * %rcx: iv (t ⊕ αⁿ ∈ GF(2¹²⁸)) - * %r8: index for input whitening key - * %r9: pointer to __camellia_enc_blk32 or __camellia_dec_blk32 - */ - FRAME_BEGIN - - vzeroupper; - - subq $(16 * 32), %rsp; - movq %rsp, %rax; - - vbroadcasti128 .Lxts_gf128mul_and_shl1_mask_0, %ymm12; - - /* load IV and construct second IV */ - vmovdqu (%rcx), %xmm0; - vmovdqa %xmm0, %xmm15; - gf128mul_x_ble(%xmm0, %xmm12, %xmm13); - vbroadcasti128 .Lxts_gf128mul_and_shl1_mask_1, %ymm13; - vinserti128 $1, %xmm0, %ymm15, %ymm0; - vpxor 0 * 32(%rdx), %ymm0, %ymm15; - vmovdqu %ymm15, 15 * 32(%rax); - vmovdqu %ymm0, 0 * 32(%rsi); - - /* construct IVs */ - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 1 * 32(%rdx), %ymm0, %ymm15; - vmovdqu %ymm15, 14 * 32(%rax); - vmovdqu %ymm0, 1 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 2 * 32(%rdx), %ymm0, %ymm15; - vmovdqu %ymm15, 13 * 32(%rax); - vmovdqu %ymm0, 2 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 3 * 32(%rdx), %ymm0, %ymm15; - vmovdqu %ymm15, 12 * 32(%rax); - vmovdqu %ymm0, 3 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 4 * 32(%rdx), %ymm0, %ymm11; - vmovdqu %ymm0, 4 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 5 * 32(%rdx), %ymm0, %ymm10; - vmovdqu %ymm0, 5 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 6 * 32(%rdx), %ymm0, %ymm9; - vmovdqu %ymm0, 6 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 7 * 32(%rdx), %ymm0, %ymm8; - vmovdqu %ymm0, 7 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 8 * 32(%rdx), %ymm0, %ymm7; - vmovdqu %ymm0, 8 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 9 * 32(%rdx), %ymm0, %ymm6; - vmovdqu %ymm0, 9 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 10 * 32(%rdx), %ymm0, %ymm5; - vmovdqu %ymm0, 10 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 11 * 32(%rdx), %ymm0, %ymm4; - vmovdqu %ymm0, 11 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 12 * 32(%rdx), %ymm0, %ymm3; - vmovdqu %ymm0, 12 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 13 * 32(%rdx), %ymm0, %ymm2; - vmovdqu %ymm0, 13 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 14 * 32(%rdx), %ymm0, %ymm1; - vmovdqu %ymm0, 14 * 32(%rsi); - - gf128mul_x2_ble(%ymm0, %ymm12, %ymm13, %ymm14, %ymm15); - vpxor 15 * 32(%rdx), %ymm0, %ymm15; - vmovdqu %ymm15, 0 * 32(%rax); - vmovdqu %ymm0, 15 * 32(%rsi); - - vextracti128 $1, %ymm0, %xmm0; - gf128mul_x_ble(%xmm0, %xmm12, %xmm15); - vmovdqu %xmm0, (%rcx); - - /* inpack32_pre: */ - vpbroadcastq (key_table)(CTX, %r8, 8), %ymm15; - vpshufb .Lpack_bswap, %ymm15, %ymm15; - vpxor 0 * 32(%rax), %ymm15, %ymm0; - vpxor %ymm1, %ymm15, %ymm1; - vpxor %ymm2, %ymm15, %ymm2; - vpxor %ymm3, %ymm15, %ymm3; - vpxor %ymm4, %ymm15, %ymm4; - vpxor %ymm5, %ymm15, %ymm5; - vpxor %ymm6, %ymm15, %ymm6; - vpxor %ymm7, %ymm15, %ymm7; - vpxor %ymm8, %ymm15, %ymm8; - vpxor %ymm9, %ymm15, %ymm9; - vpxor %ymm10, %ymm15, %ymm10; - vpxor %ymm11, %ymm15, %ymm11; - vpxor 12 * 32(%rax), %ymm15, %ymm12; - vpxor 13 * 32(%rax), %ymm15, %ymm13; - vpxor 14 * 32(%rax), %ymm15, %ymm14; - vpxor 15 * 32(%rax), %ymm15, %ymm15; - - CALL_NOSPEC r9; - - addq $(16 * 32), %rsp; - - vpxor 0 * 32(%rsi), %ymm7, %ymm7; - vpxor 1 * 32(%rsi), %ymm6, %ymm6; - vpxor 2 * 32(%rsi), %ymm5, %ymm5; - vpxor 3 * 32(%rsi), %ymm4, %ymm4; - vpxor 4 * 32(%rsi), %ymm3, %ymm3; - vpxor 5 * 32(%rsi), %ymm2, %ymm2; - vpxor 6 * 32(%rsi), %ymm1, %ymm1; - vpxor 7 * 32(%rsi), %ymm0, %ymm0; - vpxor 8 * 32(%rsi), %ymm15, %ymm15; - vpxor 9 * 32(%rsi), %ymm14, %ymm14; - vpxor 10 * 32(%rsi), %ymm13, %ymm13; - vpxor 11 * 32(%rsi), %ymm12, %ymm12; - vpxor 12 * 32(%rsi), %ymm11, %ymm11; - vpxor 13 * 32(%rsi), %ymm10, %ymm10; - vpxor 14 * 32(%rsi), %ymm9, %ymm9; - vpxor 15 * 32(%rsi), %ymm8, %ymm8; - write_output(%ymm7, %ymm6, %ymm5, %ymm4, %ymm3, %ymm2, %ymm1, %ymm0, - %ymm15, %ymm14, %ymm13, %ymm12, %ymm11, %ymm10, %ymm9, - %ymm8, %rsi); - - vzeroupper; - - FRAME_END - ret; -SYM_FUNC_END(camellia_xts_crypt_32way) - -SYM_FUNC_START(camellia_xts_enc_32way) - /* input: - * %rdi: ctx, CTX - * %rsi: dst (32 blocks) - * %rdx: src (32 blocks) - * %rcx: iv (t ⊕ αⁿ ∈ GF(2¹²⁸)) - */ - - xorl %r8d, %r8d; /* input whitening key, 0 for enc */ - - leaq __camellia_enc_blk32, %r9; - - jmp camellia_xts_crypt_32way; -SYM_FUNC_END(camellia_xts_enc_32way) - -SYM_FUNC_START(camellia_xts_dec_32way) - /* input: - * %rdi: ctx, CTX - * %rsi: dst (32 blocks) - * %rdx: src (32 blocks) - * %rcx: iv (t ⊕ αⁿ ∈ GF(2¹²⁸)) - */ - - cmpl $16, key_length(CTX); - movl $32, %r8d; - movl $24, %eax; - cmovel %eax, %r8d; /* input whitening key, last for dec */ - - leaq __camellia_dec_blk32, %r9; - - jmp camellia_xts_crypt_32way; -SYM_FUNC_END(camellia_xts_dec_32way) diff --git a/arch/x86/crypto/camellia_aesni_avx2_glue.c b/arch/x86/crypto/camellia_aesni_avx2_glue.c index ccda647422d6..d956d0473668 100644 --- a/arch/x86/crypto/camellia_aesni_avx2_glue.c +++ b/arch/x86/crypto/camellia_aesni_avx2_glue.c @@ -9,7 +9,6 @@ #include #include #include -#include #include #include #include @@ -26,11 +25,6 @@ asmlinkage void camellia_cbc_dec_32way(const void *ctx, u8 *dst, const u8 *src); asmlinkage void camellia_ctr_32way(const void *ctx, u8 *dst, const u8 *src, le128 *iv); -asmlinkage void camellia_xts_enc_32way(const void *ctx, u8 *dst, const u8 *src, - le128 *iv); -asmlinkage void camellia_xts_dec_32way(const void *ctx, u8 *dst, const u8 *src, - le128 *iv); - static const struct common_glue_ctx camellia_enc = { .num_funcs = 4, .fpu_blocks_limit = CAMELLIA_AESNI_PARALLEL_BLOCKS, @@ -69,22 +63,6 @@ static const struct common_glue_ctx camellia_ctr = { } } }; -static const struct common_glue_ctx camellia_enc_xts = { - .num_funcs = 3, - .fpu_blocks_limit = CAMELLIA_AESNI_PARALLEL_BLOCKS, - - .funcs = { { - .num_blocks = CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS, - .fn_u = { .xts = camellia_xts_enc_32way } - }, { - .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS, - .fn_u = { .xts = camellia_xts_enc_16way } - }, { - .num_blocks = 1, - .fn_u = { .xts = camellia_xts_enc } - } } -}; - static const struct common_glue_ctx camellia_dec = { .num_funcs = 4, .fpu_blocks_limit = CAMELLIA_AESNI_PARALLEL_BLOCKS, @@ -123,22 +101,6 @@ static const struct common_glue_ctx camellia_dec_cbc = { } } }; -static const struct common_glue_ctx camellia_dec_xts = { - .num_funcs = 3, - .fpu_blocks_limit = CAMELLIA_AESNI_PARALLEL_BLOCKS, - - .funcs = { { - .num_blocks = CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS, - .fn_u = { .xts = camellia_xts_dec_32way } - }, { - .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS, - .fn_u = { .xts = camellia_xts_dec_16way } - }, { - .num_blocks = 1, - .fn_u = { .xts = camellia_xts_dec } - } } -}; - static int camellia_setkey(struct crypto_skcipher *tfm, const u8 *key, unsigned int keylen) { @@ -170,24 +132,6 @@ static int ctr_crypt(struct skcipher_request *req) return glue_ctr_req_128bit(&camellia_ctr, req); } -static int xts_encrypt(struct skcipher_request *req) -{ - struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); - struct camellia_xts_ctx *ctx = crypto_skcipher_ctx(tfm); - - return glue_xts_req_128bit(&camellia_enc_xts, req, camellia_enc_blk, - &ctx->tweak_ctx, &ctx->crypt_ctx, false); -} - -static int xts_decrypt(struct skcipher_request *req) -{ - struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); - struct camellia_xts_ctx *ctx = crypto_skcipher_ctx(tfm); - - return glue_xts_req_128bit(&camellia_dec_xts, req, camellia_enc_blk, - &ctx->tweak_ctx, &ctx->crypt_ctx, true); -} - static struct skcipher_alg camellia_algs[] = { { .base.cra_name = "__ecb(camellia)", @@ -231,20 +175,6 @@ static struct skcipher_alg camellia_algs[] = { .setkey = camellia_setkey, .encrypt = ctr_crypt, .decrypt = ctr_crypt, - }, { - .base.cra_name = "__xts(camellia)", - .base.cra_driver_name = "__xts-camellia-aesni-avx2", - .base.cra_priority = 500, - .base.cra_flags = CRYPTO_ALG_INTERNAL, - .base.cra_blocksize = CAMELLIA_BLOCK_SIZE, - .base.cra_ctxsize = sizeof(struct camellia_xts_ctx), - .base.cra_module = THIS_MODULE, - .min_keysize = 2 * CAMELLIA_MIN_KEY_SIZE, - .max_keysize = 2 * CAMELLIA_MAX_KEY_SIZE, - .ivsize = CAMELLIA_BLOCK_SIZE, - .setkey = xts_camellia_setkey, - .encrypt = xts_encrypt, - .decrypt = xts_decrypt, }, }; diff --git a/arch/x86/crypto/camellia_aesni_avx_glue.c b/arch/x86/crypto/camellia_aesni_avx_glue.c index 4e5de6ef206e..44614f8a452c 100644 --- a/arch/x86/crypto/camellia_aesni_avx_glue.c +++ b/arch/x86/crypto/camellia_aesni_avx_glue.c @@ -9,7 +9,6 @@ #include #include #include -#include #include #include #include @@ -31,26 +30,6 @@ asmlinkage void camellia_ctr_16way(const void *ctx, u8 *dst, const u8 *src, le128 *iv); EXPORT_SYMBOL_GPL(camellia_ctr_16way); -asmlinkage void camellia_xts_enc_16way(const void *ctx, u8 *dst, const u8 *src, - le128 *iv); -EXPORT_SYMBOL_GPL(camellia_xts_enc_16way); - -asmlinkage void camellia_xts_dec_16way(const void *ctx, u8 *dst, const u8 *src, - le128 *iv); -EXPORT_SYMBOL_GPL(camellia_xts_dec_16way); - -void camellia_xts_enc(const void *ctx, u8 *dst, const u8 *src, le128 *iv) -{ - glue_xts_crypt_128bit_one(ctx, dst, src, iv, camellia_enc_blk); -} -EXPORT_SYMBOL_GPL(camellia_xts_enc); - -void camellia_xts_dec(const void *ctx, u8 *dst, const u8 *src, le128 *iv) -{ - glue_xts_crypt_128bit_one(ctx, dst, src, iv, camellia_dec_blk); -} -EXPORT_SYMBOL_GPL(camellia_xts_dec); - static const struct common_glue_ctx camellia_enc = { .num_funcs = 3, .fpu_blocks_limit = CAMELLIA_AESNI_PARALLEL_BLOCKS, @@ -83,19 +62,6 @@ static const struct common_glue_ctx camellia_ctr = { } } }; -static const struct common_glue_ctx camellia_enc_xts = { - .num_funcs = 2, - .fpu_blocks_limit = CAMELLIA_AESNI_PARALLEL_BLOCKS, - - .funcs = { { - .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS, - .fn_u = { .xts = camellia_xts_enc_16way } - }, { - .num_blocks = 1, - .fn_u = { .xts = camellia_xts_enc } - } } -}; - static const struct common_glue_ctx camellia_dec = { .num_funcs = 3, .fpu_blocks_limit = CAMELLIA_AESNI_PARALLEL_BLOCKS, @@ -128,19 +94,6 @@ static const struct common_glue_ctx camellia_dec_cbc = { } } }; -static const struct common_glue_ctx camellia_dec_xts = { - .num_funcs = 2, - .fpu_blocks_limit = CAMELLIA_AESNI_PARALLEL_BLOCKS, - - .funcs = { { - .num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS, - .fn_u = { .xts = camellia_xts_dec_16way } - }, { - .num_blocks = 1, - .fn_u = { .xts = camellia_xts_dec } - } } -}; - static int camellia_setkey(struct crypto_skcipher *tfm, const u8 *key, unsigned int keylen) { @@ -172,44 +125,6 @@ static int ctr_crypt(struct skcipher_request *req) return glue_ctr_req_128bit(&camellia_ctr, req); } -int xts_camellia_setkey(struct crypto_skcipher *tfm, const u8 *key, - unsigned int keylen) -{ - struct camellia_xts_ctx *ctx = crypto_skcipher_ctx(tfm); - int err; - - err = xts_verify_key(tfm, key, keylen); - if (err) - return err; - - /* first half of xts-key is for crypt */ - err = __camellia_setkey(&ctx->crypt_ctx, key, keylen / 2); - if (err) - return err; - - /* second half of xts-key is for tweak */ - return __camellia_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2); -} -EXPORT_SYMBOL_GPL(xts_camellia_setkey); - -static int xts_encrypt(struct skcipher_request *req) -{ - struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); - struct camellia_xts_ctx *ctx = crypto_skcipher_ctx(tfm); - - return glue_xts_req_128bit(&camellia_enc_xts, req, camellia_enc_blk, - &ctx->tweak_ctx, &ctx->crypt_ctx, false); -} - -static int xts_decrypt(struct skcipher_request *req) -{ - struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); - struct camellia_xts_ctx *ctx = crypto_skcipher_ctx(tfm); - - return glue_xts_req_128bit(&camellia_dec_xts, req, camellia_enc_blk, - &ctx->tweak_ctx, &ctx->crypt_ctx, true); -} - static struct skcipher_alg camellia_algs[] = { { .base.cra_name = "__ecb(camellia)", @@ -253,21 +168,7 @@ static struct skcipher_alg camellia_algs[] = { .setkey = camellia_setkey, .encrypt = ctr_crypt, .decrypt = ctr_crypt, - }, { - .base.cra_name = "__xts(camellia)", - .base.cra_driver_name = "__xts-camellia-aesni", - .base.cra_priority = 400, - .base.cra_flags = CRYPTO_ALG_INTERNAL, - .base.cra_blocksize = CAMELLIA_BLOCK_SIZE, - .base.cra_ctxsize = sizeof(struct camellia_xts_ctx), - .base.cra_module = THIS_MODULE, - .min_keysize = 2 * CAMELLIA_MIN_KEY_SIZE, - .max_keysize = 2 * CAMELLIA_MAX_KEY_SIZE, - .ivsize = CAMELLIA_BLOCK_SIZE, - .setkey = xts_camellia_setkey, - .encrypt = xts_encrypt, - .decrypt = xts_decrypt, - }, + } }; static struct simd_skcipher_alg *camellia_simd_algs[ARRAY_SIZE(camellia_algs)]; diff --git a/arch/x86/include/asm/crypto/camellia.h b/arch/x86/include/asm/crypto/camellia.h index f6d91861cb14..0e5f82adbaf9 100644 --- a/arch/x86/include/asm/crypto/camellia.h +++ b/arch/x86/include/asm/crypto/camellia.h @@ -19,18 +19,10 @@ struct camellia_ctx { u32 key_length; }; -struct camellia_xts_ctx { - struct camellia_ctx tweak_ctx; - struct camellia_ctx crypt_ctx; -}; - extern int __camellia_setkey(struct camellia_ctx *cctx, const unsigned char *key, unsigned int key_len); -extern int xts_camellia_setkey(struct crypto_skcipher *tfm, const u8 *key, - unsigned int keylen); - /* regular block cipher functions */ asmlinkage void __camellia_enc_blk(const void *ctx, u8 *dst, const u8 *src, bool xor); @@ -49,11 +41,6 @@ asmlinkage void camellia_cbc_dec_16way(const void *ctx, u8 *dst, const u8 *src); asmlinkage void camellia_ctr_16way(const void *ctx, u8 *dst, const u8 *src, le128 *iv); -asmlinkage void camellia_xts_enc_16way(const void *ctx, u8 *dst, const u8 *src, - le128 *iv); -asmlinkage void camellia_xts_dec_16way(const void *ctx, u8 *dst, const u8 *src, - le128 *iv); - static inline void camellia_enc_blk(const void *ctx, u8 *dst, const u8 *src) { __camellia_enc_blk(ctx, dst, src, false); @@ -83,9 +70,4 @@ extern void camellia_crypt_ctr(const void *ctx, u8 *dst, const u8 *src, extern void camellia_crypt_ctr_2way(const void *ctx, u8 *dst, const u8 *src, le128 *iv); -extern void camellia_xts_enc(const void *ctx, u8 *dst, const u8 *src, - le128 *iv); -extern void camellia_xts_dec(const void *ctx, u8 *dst, const u8 *src, - le128 *iv); - #endif /* ASM_X86_CAMELLIA_H */ -- 2.17.1