From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id E9DB0C433FE for ; Wed, 19 Oct 2022 11:46:34 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:CC:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=JqsHMwGHVM2rNuXMiQu6xBqArKTQukrfhO9pi3Tum1I=; b=LpNY+wwxsqC/6V yCVSlebstT42O+NFl3f8Eeo3eOYDJhctloQH5wqxyjZHANIEbkchfcG24wkeuQmOXF+83GXlAimpa +JelKIR98Irb+x7JKyB6E9Cq+HZLax3GumpzBqrjuH4OAcO237AFnYYFgFHdFRoX43K9djQTg0lF9 3+7VdnU7pUBb3rrHPFp79UWzaV0Roa092WWZy5KvdHBqUlMMX2Q203PaQC/9J51/zp5DsLvD1I/Of JRiXHZJp26XnUHtSxkIPw13gRnLtZoGG/1EOtXag6wzdc7QbSdmeuLeLtW/HLZ+l+D1HuGlymUxUC RsUnXAx9MMAFB7BY0k4g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1ol7VN-000yhf-C4; Wed, 19 Oct 2022 11:45:02 +0000 Received: from esa.microchip.iphmx.com ([68.232.154.123]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1ol7TN-000xCM-J8 for linux-arm-kernel@lists.infradead.org; Wed, 19 Oct 2022 11:43:08 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=microchip.com; i=@microchip.com; q=dns/txt; s=mchp; t=1666179777; x=1697715777; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=pz8rN1GbUuAQDq1CUubvtXkLTuGeD8KwTZXl0bYxDvw=; b=v/vcrccgumERuc2iOK7GjacxZA1tV2LNX2gtMB30L0LikfBCzxRGr+GC hVKw/OayAsDwMZUa6OtKWd+J6rxvsdFDbQsp9KwX6C1MtCHsrN0kbxitF MQmJKkoF12mrZ9bPVzI/ybiSBcJZ1iP7lsJvzLXUIHLLKX1iS0v+EdW/b c4A4gtGiuejqDzyzZCKszLZSXlVbzMLMiBU+uRxFRcpNKSX/cSlpGFcK3 SHR2fPcxKqR2QMFsM6nCJQI3DjvxMwOAa4NrKFpA2STW3kj4KbxNAEVr6 Tbsx20gINmVtErjsrl7ne5WtlMG+1P7pFvDl5L0S14vWPpLNX6ZN7zadk w==; X-IronPort-AV: E=Sophos;i="5.95,196,1661842800"; d="scan'208";a="182926285" Received: from unknown (HELO email.microchip.com) ([170.129.1.10]) by esa2.microchip.iphmx.com with ESMTP/TLS/AES256-SHA256; 19 Oct 2022 04:42:56 -0700 Received: from chn-vm-ex04.mchp-main.com (10.10.85.152) by chn-vm-ex02.mchp-main.com (10.10.85.144) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.12; Wed, 19 Oct 2022 04:42:51 -0700 Received: from den-dk-m31857.microchip.com (10.10.115.15) by chn-vm-ex04.mchp-main.com (10.10.85.152) with Microsoft SMTP Server id 15.1.2507.12 via Frontend Transport; Wed, 19 Oct 2022 04:42:48 -0700 From: Steen Hegelund To: "David S . Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni CC: Steen Hegelund , , Randy Dunlap , "Casper Andersson" , Russell King , Wan Jiabing , "Nathan Huckleberry" , , , , "kernel test robot" Subject: [PATCH net-next v2 9/9] net: microchip: sparx5: Adding KUNIT test for the VCAP API Date: Wed, 19 Oct 2022 13:42:15 +0200 Message-ID: <20221019114215.620969-10-steen.hegelund@microchip.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221019114215.620969-1-steen.hegelund@microchip.com> References: <20221019114215.620969-1-steen.hegelund@microchip.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20221019_044257_890564_9B2B7C0F X-CRM114-Status: GOOD ( 23.17 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org VGhpcyBwcm92aWRlcyBhIEtVTklUIHRlc3Qgc3VpdGUgZm9yIHRoZSBWQ0FQIEFQSXMgZW5jb2Rp bmcgZnVuY3Rpb25hbGl0eS4KClNpZ25lZC1vZmYtYnk6IFN0ZWVuIEhlZ2VsdW5kIDxzdGVlbi5o ZWdlbHVuZEBtaWNyb2NoaXAuY29tPgpSZXBvcnRlZC1ieToga2VybmVsIHRlc3Qgcm9ib3QgPGxr cEBpbnRlbC5jb20+Ci0tLQogZHJpdmVycy9uZXQvZXRoZXJuZXQvbWljcm9jaGlwL3ZjYXAvS2Nv bmZpZyAgIHwgIDEzICsKIC4uLi9taWNyb2NoaXAvdmNhcC92Y2FwX2FnX2FwaV9rdW5pdC5oICAg ICAgICB8IDY0MyArKysrKysrKysrKysKIC4uLi9uZXQvZXRoZXJuZXQvbWljcm9jaGlwL3ZjYXAv dmNhcF9hcGkuYyAgICB8ICAgNCArCiAuLi4vbmV0L2V0aGVybmV0L21pY3JvY2hpcC92Y2FwL3Zj YXBfYXBpLmggICAgfCAgIDMgKwogLi4uL2V0aGVybmV0L21pY3JvY2hpcC92Y2FwL3ZjYXBfYXBp X2t1bml0LmMgIHwgOTMzICsrKysrKysrKysrKysrKysrKwogNSBmaWxlcyBjaGFuZ2VkLCAxNTk2 IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL25ldC9ldGhlcm5ldC9t aWNyb2NoaXAvdmNhcC92Y2FwX2FnX2FwaV9rdW5pdC5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJp dmVycy9uZXQvZXRoZXJuZXQvbWljcm9jaGlwL3ZjYXAvdmNhcF9hcGlfa3VuaXQuYwoKZGlmZiAt LWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L21pY3JvY2hpcC92Y2FwL0tjb25maWcgYi9kcml2 ZXJzL25ldC9ldGhlcm5ldC9taWNyb2NoaXAvdmNhcC9LY29uZmlnCmluZGV4IGE3OGNiYzZjZTZi Yi4uMWFmMzBhMzU4YTE1IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9taWNyb2No aXAvdmNhcC9LY29uZmlnCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L21pY3JvY2hpcC92Y2Fw L0tjb25maWcKQEAgLTM2LDQgKzM2LDE3IEBAIGNvbmZpZyBWQ0FQCiAJICBjaGFyYWN0ZXJpc3Rp Y3MuIExvb2sgaW4gdGhlIGRhdGFzaGVldCBmb3IgdGhlIFZDQVAgc3BlY2lmaWNhdGlvbnMgZm9y IHRoZQogCSAgc3BlY2lmaWMgc3dpdGNoY29yZS4KIAorY29uZmlnIFZDQVBfS1VOSVRfVEVTVAor CWJvb2wgIktVbml0IHRlc3QgZm9yIFZDQVAgbGlicmFyeSIgaWYgIUtVTklUX0FMTF9URVNUUwor CWRlcGVuZHMgb24gS1VOSVQKKwlkZXBlbmRzIG9uIEtVTklUPXkgJiYgVkNBUD15ICYmIHkKKwlk ZWZhdWx0IEtVTklUX0FMTF9URVNUUworCWhlbHAKKwkgIFRoaXMgYnVpbGRzIHVuaXQgdGVzdHMg Zm9yIHRoZSBWQ0FQIGxpYnJhcnkuCisKKwkgIEZvciBtb3JlIGluZm9ybWF0aW9uIG9uIEtVbml0 IGFuZCB1bml0IHRlc3RzIGluIGdlbmVyYWwsIHBsZWFzZSByZWZlcgorCSAgdG8gdGhlIEtVbml0 IGRvY3VtZW50YXRpb24gaW4gRG9jdW1lbnRhdGlvbi9kZXYtdG9vbHMva3VuaXQvLgorCisJICBJ ZiB1bnN1cmUsIHNheSBOLgorCiBlbmRpZiAjIE5FVF9WRU5ET1JfTUlDUk9DSElQCmRpZmYgLS1n aXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9taWNyb2NoaXAvdmNhcC92Y2FwX2FnX2FwaV9rdW5p dC5oIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWljcm9jaGlwL3ZjYXAvdmNhcF9hZ19hcGlfa3Vu aXQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmU1MzhjYTcyNTY4 NwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L21pY3JvY2hpcC92Y2Fw L3ZjYXBfYWdfYXBpX2t1bml0LmgKQEAgLTAsMCArMSw2NDMgQEAKKy8qIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBCU0QtMy1DbGF1c2UgKi8KKy8qIENvcHlyaWdodCAoQykgMjAyMiBNaWNyb2No aXAgVGVjaG5vbG9neSBJbmMuIGFuZCBpdHMgc3Vic2lkaWFyaWVzLgorICogTWljcm9jaGlwIFZD QVAgQVBJIGludGVyZmFjZSBmb3Iga3VuaXQgdGVzdGluZworICogVGhpcyBpcyBhIGRpZmZlcmVu dCBpbnRlcmZhY2UsIHRvIGJlIGFibGUgdG8gaW5jbHVkZSBkaWZmZXJlbnQgVkNBUHMKKyAqLwor CisvKiBVc2Ugc2FtZSBpbmNsdWRlIGd1YXJkIGFzIHRoZSBvZmZpY2lhbCBBUEkgdG8gYmUgYWJs ZSB0byBvdmVycmlkZSBpdCAqLworI2lmbmRlZiBfX1ZDQVBfQUdfQVBJX18KKyNkZWZpbmUgX19W Q0FQX0FHX0FQSV9fCisKK2VudW0gdmNhcF90eXBlIHsKKwlWQ0FQX1RZUEVfRVMyLAorCVZDQVBf VFlQRV9JUzAsCisJVkNBUF9UWVBFX0lTMiwKKwlWQ0FQX1RZUEVfTUFYCit9OworCisvKiBLZXlm aWVsZHNldCBuYW1lcyB3aXRoIG9yaWdpbiBpbmZvcm1hdGlvbiAqLworZW51bSB2Y2FwX2tleWZp ZWxkX3NldCB7CisJVkNBUF9LRlNfTk9fVkFMVUUsICAgICAgICAgIC8qIGluaXRpYWwgdmFsdWUg Ki8KKwlWQ0FQX0tGU19BUlAsICAgICAgICAgICAgICAgLyogc3Bhcng1IGlzMiBYNiwgc3Bhcng1 IGVzMiBYNiAqLworCVZDQVBfS0ZTX0VUQUcsICAgICAgICAgICAgICAvKiBzcGFyeDUgaXMwIFgy ICovCisJVkNBUF9LRlNfSVA0X09USEVSLCAgICAgICAgIC8qIHNwYXJ4NSBpczIgWDYsIHNwYXJ4 NSBlczIgWDYgKi8KKwlWQ0FQX0tGU19JUDRfVENQX1VEUCwgICAgICAgLyogc3Bhcng1IGlzMiBY Niwgc3Bhcng1IGVzMiBYNiAqLworCVZDQVBfS0ZTX0lQNF9WSUQsICAgICAgICAgICAvKiBzcGFy eDUgZXMyIFgzICovCisJVkNBUF9LRlNfSVA2X1NURCwgICAgICAgICAgIC8qIHNwYXJ4NSBpczIg WDYgKi8KKwlWQ0FQX0tGU19JUDZfVklELCAgICAgICAgICAgLyogc3Bhcng1IGlzMiBYNiwgc3Bh cng1IGVzMiBYNiAqLworCVZDQVBfS0ZTX0lQXzdUVVBMRSwgICAgICAgICAvKiBzcGFyeDUgaXMy IFgxMiwgc3Bhcng1IGVzMiBYMTIgKi8KKwlWQ0FQX0tGU19MTF9GVUxMLCAgICAgICAgICAgLyog c3Bhcng1IGlzMCBYNiAqLworCVZDQVBfS0ZTX01BQ19FVFlQRSwgICAgICAgICAvKiBzcGFyeDUg aXMyIFg2LCBzcGFyeDUgZXMyIFg2ICovCisJVkNBUF9LRlNfTUxMLCAgICAgICAgICAgICAgIC8q IHNwYXJ4NSBpczAgWDMgKi8KKwlWQ0FQX0tGU19OT1JNQUwsICAgICAgICAgICAgLyogc3Bhcng1 IGlzMCBYNiAqLworCVZDQVBfS0ZTX05PUk1BTF81VFVQTEVfSVA0LCAgLyogc3Bhcng1IGlzMCBY NiAqLworCVZDQVBfS0ZTX05PUk1BTF83VFVQTEUsICAgICAvKiBzcGFyeDUgaXMwIFgxMiAqLwor CVZDQVBfS0ZTX1BVUkVfNVRVUExFX0lQNCwgICAvKiBzcGFyeDUgaXMwIFgzICovCisJVkNBUF9L RlNfVFJJX1ZJRCwgICAgICAgICAgIC8qIHNwYXJ4NSBpczAgWDIgKi8KK307CisKKy8qIExpc3Qg b2Yga2V5ZmllbGRzIHdpdGggZGVzY3JpcHRpb24KKyAqCisgKiBLZXlzIGVuZGluZyBpbiBfSVMg YXJlIGJvb2xlYW5zIGRlcml2ZWQgZnJvbSBmcmFtZSBkYXRhCisgKiBLZXlzIGVuZGluZyBpbiBf Q0xTIGFyZSBjbGFzc2lmaWVkIGZyYW1lIGRhdGEKKyAqCisgKiBWQ0FQX0tGXzgwMjFCUl9FQ0lE X0JBU0U6IFcxMiwgc3Bhcng1OiBpczAKKyAqICAgVXNlZCBieSA4MDIuMUJSIEJyaWRnZSBQb3J0 IEV4dGVuc2lvbiBpbiBhbiBFLVRhZworICogVkNBUF9LRl84MDIxQlJfRUNJRF9FWFQ6IFc4LCBz cGFyeDU6IGlzMAorICogICBVc2VkIGJ5IDgwMi4xQlIgQnJpZGdlIFBvcnQgRXh0ZW5zaW9uIGlu IGFuIEUtVGFnCisgKiBWQ0FQX0tGXzgwMjFCUl9FX1RBR0dFRDogVzEsIHNwYXJ4NTogaXMwCisg KiAgIFNldCBmb3IgZnJhbWVzIGNvbnRhaW5pbmcgYW4gRS1UQUcgKDgwMi4xQlIgRXRoZXJ0eXBl IDg5M2YpCisgKiBWQ0FQX0tGXzgwMjFCUl9HUlA6IFcyLCBzcGFyeDU6IGlzMAorICogICBFLVRh ZyBncm91cCBiaXRzIGluIDgwMi4xQlIgQnJpZGdlIFBvcnQgRXh0ZW5zaW9uCisgKiBWQ0FQX0tG XzgwMjFCUl9JR1JfRUNJRF9CQVNFOiBXMTIsIHNwYXJ4NTogaXMwCisgKiAgIFVzZWQgYnkgODAy LjFCUiBCcmlkZ2UgUG9ydCBFeHRlbnNpb24gaW4gYW4gRS1UYWcKKyAqIFZDQVBfS0ZfODAyMUJS X0lHUl9FQ0lEX0VYVDogVzgsIHNwYXJ4NTogaXMwCisgKiAgIFVzZWQgYnkgODAyLjFCUiBCcmlk Z2UgUG9ydCBFeHRlbnNpb24gaW4gYW4gRS1UYWcKKyAqIFZDQVBfS0ZfODAyMVFfREVJMDogVzEs IHNwYXJ4NTogaXMwCisgKiAgIEZpcnN0IERFSSBpbiBtdWx0aXBsZSB2bGFuIHRhZ3MgKG91dGVy IHRhZyBvciBkZWZhdWx0IHBvcnQgdGFnKQorICogVkNBUF9LRl84MDIxUV9ERUkxOiBXMSwgc3Bh cng1OiBpczAKKyAqICAgU2Vjb25kIERFSSBpbiBtdWx0aXBsZSB2bGFuIHRhZ3MgKGlubmVyIHRh ZykKKyAqIFZDQVBfS0ZfODAyMVFfREVJMjogVzEsIHNwYXJ4NTogaXMwCisgKiAgIFRoaXJkIERF SSBpbiBtdWx0aXBsZSB2bGFuIHRhZ3MgKG5vdCBhbHdheXMgYXZhaWxhYmxlKQorICogVkNBUF9L Rl84MDIxUV9ERUlfQ0xTOiBXMSwgc3Bhcng1OiBpczIvZXMyCisgKiAgIENsYXNzaWZpZWQgREVJ CisgKiBWQ0FQX0tGXzgwMjFRX1BDUDA6IFczLCBzcGFyeDU6IGlzMAorICogICBGaXJzdCBQQ1Ag aW4gbXVsdGlwbGUgdmxhbiB0YWdzIChvdXRlciB0YWcgb3IgZGVmYXVsdCBwb3J0IHRhZykKKyAq IFZDQVBfS0ZfODAyMVFfUENQMTogVzMsIHNwYXJ4NTogaXMwCisgKiAgIFNlY29uZCBQQ1AgaW4g bXVsdGlwbGUgdmxhbiB0YWdzIChpbm5lciB0YWcpCisgKiBWQ0FQX0tGXzgwMjFRX1BDUDI6IFcz LCBzcGFyeDU6IGlzMAorICogICBUaGlyZCBQQ1AgaW4gbXVsdGlwbGUgdmxhbiB0YWdzIChub3Qg YWx3YXlzIGF2YWlsYWJsZSkKKyAqIFZDQVBfS0ZfODAyMVFfUENQX0NMUzogVzMsIHNwYXJ4NTog aXMyL2VzMgorICogICBDbGFzc2lmaWVkIFBDUAorICogVkNBUF9LRl84MDIxUV9UUElEMDogVzMs IHNwYXJ4NTogaXMwCisgKiAgIEZpcnN0IFRQSUMgaW4gbXVsdGlwbGUgdmxhbiB0YWdzIChvdXRl ciB0YWcgb3IgZGVmYXVsdCBwb3J0IHRhZykKKyAqIFZDQVBfS0ZfODAyMVFfVFBJRDE6IFczLCBz cGFyeDU6IGlzMAorICogICBTZWNvbmQgVFBJRCBpbiBtdWx0aXBsZSB2bGFuIHRhZ3MgKGlubmVy IHRhZykKKyAqIFZDQVBfS0ZfODAyMVFfVFBJRDI6IFczLCBzcGFyeDU6IGlzMAorICogICBUaGly ZCBUUElEIGluIG11bHRpcGxlIHZsYW4gdGFncyAobm90IGFsd2F5cyBhdmFpbGFibGUpCisgKiBW Q0FQX0tGXzgwMjFRX1ZJRDA6IFcxMiwgc3Bhcng1OiBpczAKKyAqICAgRmlyc3QgVklEIGluIG11 bHRpcGxlIHZsYW4gdGFncyAob3V0ZXIgdGFnIG9yIGRlZmF1bHQgcG9ydCB0YWcpCisgKiBWQ0FQ X0tGXzgwMjFRX1ZJRDE6IFcxMiwgc3Bhcng1OiBpczAKKyAqICAgU2Vjb25kIFZJRCBpbiBtdWx0 aXBsZSB2bGFuIHRhZ3MgKGlubmVyIHRhZykKKyAqIFZDQVBfS0ZfODAyMVFfVklEMjogVzEyLCBz cGFyeDU6IGlzMAorICogICBUaGlyZCBWSUQgaW4gbXVsdGlwbGUgdmxhbiB0YWdzIChub3QgYWx3 YXlzIGF2YWlsYWJsZSkKKyAqIFZDQVBfS0ZfODAyMVFfVklEX0NMUzogVzEzLCBzcGFyeDU6IGlz Mi9lczIKKyAqICAgQ2xhc3NpZmllZCBWSUQKKyAqIFZDQVBfS0ZfODAyMVFfVkxBTl9UQUdHRURf SVM6IFcxLCBzcGFyeDU6IGlzMi9lczIKKyAqICAgU3Bhcng1OiBTZXQgaWYgZnJhbWUgd2FzIHJl Y2VpdmVkIHdpdGggYSBWTEFOIHRhZywgTEFOOTY2eDogU2V0IGlmIGZyYW1lIGhhcworICogICBv bmUgb3IgbW9yZSBRLXRhZ3MuIEluZGVwZW5kZW50IG9mIHBvcnQgVkxBTiBhd2FyZW5lc3MKKyAq IFZDQVBfS0ZfODAyMVFfVkxBTl9UQUdTOiBXMywgc3Bhcng1OiBpczAKKyAqICAgTnVtYmVyIG9m IFZMQU4gdGFncyBpbiBmcmFtZTogMDogVW50YWdnZWQsIDE6IFNpbmdsZSB0YWdnZWQsIDM6IERv dWJsZQorICogICB0YWdnZWQsIDc6IFRyaXBsZSB0YWdnZWQKKyAqIFZDQVBfS0ZfQUNMX0dSUF9J RDogVzgsIHNwYXJ4NTogZXMyCisgKiAgIFVzZWQgaW4gaW50ZXJmYWNlIG1hcCB0YWJsZQorICog VkNBUF9LRl9BUlBfQUREUl9TUEFDRV9PS19JUzogVzEsIHNwYXJ4NTogaXMyL2VzMgorICogICBT ZXQgaWYgaGFyZHdhcmUgYWRkcmVzcyBpcyBFdGhlcm5ldAorICogVkNBUF9LRl9BUlBfTEVOX09L X0lTOiBXMSwgc3Bhcng1OiBpczIvZXMyCisgKiAgIFNldCBpZiBoYXJkd2FyZSBhZGRyZXNzIGxl bmd0aCA9IDYgKEV0aGVybmV0KSBhbmQgSVAgYWRkcmVzcyBsZW5ndGggPSA0IChJUCkuCisgKiBW Q0FQX0tGX0FSUF9PUENPREU6IFcyLCBzcGFyeDU6IGlzMi9lczIKKyAqICAgQVJQIG9wY29kZQor ICogVkNBUF9LRl9BUlBfT1BDT0RFX1VOS05PV05fSVM6IFcxLCBzcGFyeDU6IGlzMi9lczIKKyAq ICAgU2V0IGlmIG5vdCBvbmUgb2YgdGhlIGNvZGVzIGRlZmluZWQgaW4gVkNBUF9LRl9BUlBfT1BD T0RFCisgKiBWQ0FQX0tGX0FSUF9QUk9UT19TUEFDRV9PS19JUzogVzEsIHNwYXJ4NTogaXMyL2Vz MgorICogICBTZXQgaWYgcHJvdG9jb2wgYWRkcmVzcyBzcGFjZSBpcyAweDA4MDAKKyAqIFZDQVBf S0ZfQVJQX1NFTkRFUl9NQVRDSF9JUzogVzEsIHNwYXJ4NTogaXMyL2VzMgorICogICBTZW5kZXIg SGFyZHdhcmUgQWRkcmVzcyA9IFNNQUMgKEFSUCkKKyAqIFZDQVBfS0ZfQVJQX1RHVF9NQVRDSF9J UzogVzEsIHNwYXJ4NTogaXMyL2VzMgorICogICBUYXJnZXQgSGFyZHdhcmUgQWRkcmVzcyA9IFNN QUMgKFJBUlApCisgKiBWQ0FQX0tGX0NPU0lEX0NMUzogVzMsIHNwYXJ4NTogZXMyCisgKiAgIENs YXNzIG9mIHNlcnZpY2UKKyAqIFZDQVBfS0ZfRFNUX0VOVFJZOiBXMSwgc3Bhcng1OiBpczAKKyAq ICAgU2VsZWN0cyB3aGV0aGVyIHRoZSBmcmFtZeKAmXMgZGVzdGluYXRpb24gb3Igc291cmNlIGlu Zm9ybWF0aW9uIGlzIHVzZWQgZm9yCisgKiAgIGZpZWxkcyBMMl9TTUFDIGFuZCBMM19JUDRfU0lQ CisgKiBWQ0FQX0tGX0VTMF9JU0RYX0tFWV9FTkE6IFcxLCBzcGFyeDU6IGVzMgorICogICBUaGUg dmFsdWUgdGFrZW4gZnJvbSB0aGUgSUZIIC5GV0QuRVMwX0lTRFhfS0VZX0VOQQorICogVkNBUF9L Rl9FVFlQRTogVzE2LCBzcGFyeDU6IGlzMC9pczIvZXMyCisgKiAgIEV0aGVybmV0IHR5cGUKKyAq IFZDQVBfS0ZfRVRZUEVfTEVOX0lTOiBXMSwgc3Bhcng1OiBpczAvaXMyL2VzMgorICogICBTZXQg aWYgZnJhbWUgaGFzIEV0aGVyVHlwZSA+PSAweDYwMAorICogVkNBUF9LRl9FVFlQRV9NUExTOiBX Miwgc3Bhcng1OiBpczAKKyAqICAgVHlwZSBvZiBNUExTIEV0aGVydHlwZSAob3Igbm90KQorICog VkNBUF9LRl9JRl9FR1JfUE9SVF9NQVNLOiBXMzIsIHNwYXJ4NTogZXMyCisgKiAgIEVncmVzcyBw b3J0IG1hc2ssIG9uZSBiaXQgcGVyIHBvcnQKKyAqIFZDQVBfS0ZfSUZfRUdSX1BPUlRfTUFTS19S Tkc6IFczLCBzcGFyeDU6IGVzMgorICogICBTZWxlY3Qgd2hpY2ggMzIgcG9ydCBncm91cCBpcyBh dmFpbGFibGUgaW4gSUZfRUdSX1BPUlQgKG9yIHZpcnR1YWwgcG9ydHMgb3IKKyAqICAgQ1BVIHF1 ZXVlKQorICogVkNBUF9LRl9JRl9JR1JfUE9SVDogc3Bhcng1IGlzMCBXNywgc3Bhcng1IGVzMiBX OQorICogICBTcGFyeDU6IExvZ2ljYWwgaW5ncmVzcyBwb3J0IG51bWJlciByZXRyaWV2ZWQgZnJv bQorICogICBBTkFfQ0w6OlBPUlRfSURfQ0ZHLkxQT1JUX05VTSBvciBFUkxFRywgTEFOOTY2eDog aW5ncmVzcyBwb3J0IG51bm1iZXIKKyAqIFZDQVBfS0ZfSUZfSUdSX1BPUlRfTUFTSzogc3Bhcng1 IGlzMCBXNjUsIHNwYXJ4NSBpczIgVzMyLCBzcGFyeDUgaXMyIFc2NQorICogICBJbmdyZXNzIHBv cnQgbWFzaywgb25lIGJpdCBwZXIgcG9ydC9lcmxlZworICogVkNBUF9LRl9JRl9JR1JfUE9SVF9N QVNLX0wzOiBXMSwgc3Bhcng1OiBpczIKKyAqICAgSWYgc2V0LCBJRl9JR1JfUE9SVF9NQVNLLCBJ Rl9JR1JfUE9SVF9NQVNLX1JORywgYW5kIElGX0lHUl9QT1JUX01BU0tfU0VMIGFyZQorICogICB1 c2VkIHRvIHNwZWNpZnkgTDMgaW50ZXJmYWNlcworICogVkNBUF9LRl9JRl9JR1JfUE9SVF9NQVNL X1JORzogVzQsIHNwYXJ4NTogaXMyCisgKiAgIFJhbmdlIHNlbGVjdG9yIGZvciBJRl9JR1JfUE9S VF9NQVNLLiAgU3BlY2lmaWVzIHdoaWNoIGdyb3VwIG9mIDMyIHBvcnRzIGFyZQorICogICBhdmFp bGFibGUgaW4gSUZfSUdSX1BPUlRfTUFTSworICogVkNBUF9LRl9JRl9JR1JfUE9SVF9NQVNLX1NF TDogVzIsIHNwYXJ4NTogaXMwL2lzMgorICogICBNb2RlIHNlbGVjdG9yIGZvciBJRl9JR1JfUE9S VF9NQVNLLCBhcHBsaWNhYmxlIHdoZW4gSUZfSUdSX1BPUlRfTUFTS19MMyA9PSAwLgorICogICBN YXBwaW5nOiAwOiBERUZBVUxUIDE6IExPT1BCQUNLIDI6IE1BU1FVRVJBREUgMzogQ1BVX1ZECisg KiBWQ0FQX0tGX0lGX0lHUl9QT1JUX1NFTDogVzEsIHNwYXJ4NTogZXMyCisgKiAgIFNlbGVjdG9y IGZvciBJRl9JR1JfUE9SVDogcGh5c2ljYWwgcG9ydCBudW1iZXIgb3IgRVJMRUcKKyAqIFZDQVBf S0ZfSVA0X0lTOiBXMSwgc3Bhcng1OiBpczAvaXMyL2VzMgorICogICBTZXQgaWYgZnJhbWUgaGFz IEV0aGVyVHlwZSA9IDB4ODAwIGFuZCBJUCB2ZXJzaW9uID0gNAorICogVkNBUF9LRl9JUF9NQ19J UzogVzEsIHNwYXJ4NTogaXMwCisgKiAgIFNldCBpZiBmcmFtZSBpcyBJUHY0IGZyYW1lIGFuZCBm cmFtZeKAmXMgZGVzdGluYXRpb24gTUFDIGFkZHJlc3MgaXMgYW4gSVB2NAorICogICBtdWx0aWNh c3QgYWRkcmVzcyAoMHgwMTAwNUUwIC8yNSkuIFNldCBpZiBmcmFtZSBpcyBJUHY2IGZyYW1lIGFu ZCBmcmFtZeKAmXMKKyAqICAgZGVzdGluYXRpb24gTUFDIGFkZHJlc3MgaXMgYW4gSVB2NiBtdWx0 aWNhc3QgYWRkcmVzcyAoMHgzMzMzLzE2KS4KKyAqIFZDQVBfS0ZfSVBfUEFZTE9BRF81VFVQTEU6 IFczMiwgc3Bhcng1OiBpczAKKyAqICAgUGF5bG9hZCBieXRlcyBhZnRlciBJUCBoZWFkZXIKKyAq IFZDQVBfS0ZfSVBfU05BUF9JUzogVzEsIHNwYXJ4NTogaXMwCisgKiAgIFNldCBpZiBmcmFtZSBp cyBJUHY0LCBJUHY2LCBvciBTTkFQIGZyYW1lCisgKiBWQ0FQX0tGX0lTRFhfQ0xTOiBXMTIsIHNw YXJ4NTogaXMyL2VzMgorICogICBDbGFzc2lmaWVkIElTRFgKKyAqIFZDQVBfS0ZfSVNEWF9HVDBf SVM6IFcxLCBzcGFyeDU6IGlzMi9lczIKKyAqICAgU2V0IGlmIGNsYXNzaWZpZWQgSVNEWCA+IDAK KyAqIFZDQVBfS0ZfTDJfQkNfSVM6IFcxLCBzcGFyeDU6IGlzMC9pczIvZXMyCisgKiAgIFNldCBp ZiBmcmFtZeKAmXMgZGVzdGluYXRpb24gTUFDIGFkZHJlc3MgaXMgdGhlIGJyb2FkY2FzdCBhZGRy ZXNzCisgKiAgIChGRi1GRi1GRi1GRi1GRi1GRikuCisgKiBWQ0FQX0tGX0wyX0RNQUM6IFc0OCwg c3Bhcng1OiBpczAvaXMyL2VzMgorICogICBEZXN0aW5hdGlvbiBNQUMgYWRkcmVzcworICogVkNB UF9LRl9MMl9GV0RfSVM6IFcxLCBzcGFyeDU6IGlzMgorICogICBTZXQgaWYgdGhlIGZyYW1lIGlz IGFsbG93ZWQgdG8gYmUgZm9yd2FyZGVkIHRvIGZyb250IHBvcnRzCisgKiBWQ0FQX0tGX0wyX01D X0lTOiBXMSwgc3Bhcng1OiBpczAvaXMyL2VzMgorICogICBTZXQgaWYgZnJhbWXigJlzIGRlc3Rp bmF0aW9uIE1BQyBhZGRyZXNzIGlzIGEgbXVsdGljYXN0IGFkZHJlc3MgKGJpdCA0MCA9IDEpLgor ICogVkNBUF9LRl9MMl9QQVlMT0FEX0VUWVBFOiBXNjQsIHNwYXJ4NTogaXMyL2VzMgorICogICBC eXRlIDAtNyBvZiBMMiBwYXlsb2FkIGFmdGVyIFR5cGUvTGVuIGZpZWxkIGFuZCBvdmVybG9hZGlu ZyBmb3IgT0FNCisgKiBWQ0FQX0tGX0wyX1NNQUM6IFc0OCwgc3Bhcng1OiBpczAvaXMyL2VzMgor ICogICBTb3VyY2UgTUFDIGFkZHJlc3MKKyAqIFZDQVBfS0ZfTDNfRElQX0VRX1NJUF9JUzogVzEs IHNwYXJ4NTogaXMyL2VzMgorICogICBTZXQgaWYgU3JjIElQIG1hdGNoZXMgRHN0IElQIGFkZHJl c3MKKyAqIFZDQVBfS0ZfTDNfRE1BQ19ESVBfTUFUQ0g6IFcxLCBzcGFyeDU6IGlzMgorICogICBN YXRjaCBmb3VuZCBpbiBESVAgc2VjdXJpdHkgbG9va3VwIGluIEFOQV9MMworICogVkNBUF9LRl9M M19EUExfQ0xTOiBXMSwgc3Bhcng1OiBlczIKKyAqICAgVGhlIGZyYW1lcyBkcm9wIHByZWNlZGVu Y2UgbGV2ZWwKKyAqIFZDQVBfS0ZfTDNfRFNDUDogVzYsIHNwYXJ4NTogaXMwCisgKiAgIEZyYW1l 4oCZcyBEU0NQIHZhbHVlCisgKiBWQ0FQX0tGX0wzX0RTVF9JUzogVzEsIHNwYXJ4NTogaXMyCisg KiAgIFNldCBpZiBsb29rdXAgaXMgZG9uZSBmb3IgZWdyZXNzIHJvdXRlciBsZWcKKyAqIFZDQVBf S0ZfTDNfRlJBR01FTlRfVFlQRTogVzIsIHNwYXJ4NTogaXMwL2lzMi9lczIKKyAqICAgTDMgRnJh Z21lbnRhdGlvbiB0eXBlIChub25lLCBpbml0aWFsLCBzdXNwaWNpb3VzLCB2YWxpZCBmb2xsb3cg dXApCisgKiBWQ0FQX0tGX0wzX0ZSQUdfSU5WTERfTDRfTEVOOiBXMSwgc3Bhcng1OiBpczAvaXMy CisgKiAgIFNldCBpZiBmcmFtZSdzIEw0IGxlbmd0aCBpcyBsZXNzIHRoYW4gQU5BX0NMOkNPTU1P TjpDTE1fRlJBR01FTlRfQ0ZHLkw0X01JTl9MCisgKiAgIEVOCisgKiBWQ0FQX0tGX0wzX0lQNF9E SVA6IFczMiwgc3Bhcng1OiBpczAvaXMyL2VzMgorICogICBEZXN0aW5hdGlvbiBJUHY0IEFkZHJl c3MKKyAqIFZDQVBfS0ZfTDNfSVA0X1NJUDogVzMyLCBzcGFyeDU6IGlzMC9pczIvZXMyCisgKiAg IFNvdXJjZSBJUHY0IEFkZHJlc3MKKyAqIFZDQVBfS0ZfTDNfSVA2X0RJUDogVzEyOCwgc3Bhcng1 OiBpczAvaXMyL2VzMgorICogICBTcGFyeDU6IEZ1bGwgSVB2NiBESVAsIExBTjk2Nng6IEVpdGhl ciBGdWxsIElQdjYgRElQIG9yIGEgc3Vic2V0IGRlcGVuZGluZyBvbgorICogICBmcmFtZSB0eXBl CisgKiBWQ0FQX0tGX0wzX0lQNl9TSVA6IFcxMjgsIHNwYXJ4NTogaXMwL2lzMi9lczIKKyAqICAg U3Bhcng1OiBGdWxsIElQdjYgU0lQLCBMQU45NjZ4OiBFaXRoZXIgRnVsbCBJUHY2IFNJUCBvciBh IHN1YnNldCBkZXBlbmRpbmcgb24KKyAqICAgZnJhbWUgdHlwZQorICogVkNBUF9LRl9MM19JUF9Q Uk9UTzogVzgsIHNwYXJ4NTogaXMwL2lzMi9lczIKKyAqICAgSVB2NCBmcmFtZXM6IElQIHByb3Rv Y29sLiBJUHY2IGZyYW1lczogTmV4dCBoZWFkZXIsIHNhbWUgYXMgZm9yIElQVjQKKyAqIFZDQVBf S0ZfTDNfT1BUSU9OU19JUzogVzEsIHNwYXJ4NTogaXMwL2lzMi9lczIKKyAqICAgU2V0IGlmIElQ djQgZnJhbWUgY29udGFpbnMgb3B0aW9ucyAoSVAgbGVuID4gNSkKKyAqIFZDQVBfS0ZfTDNfUEFZ TE9BRDogc3Bhcng1IGlzMiBXOTYsIHNwYXJ4NSBpczIgVzQwLCBzcGFyeDUgZXMyIFc5NgorICog ICBTcGFyeDU6IFBheWxvYWQgYnl0ZXMgYWZ0ZXIgSVAgaGVhZGVyLiBJUHY0OiBJUHY0IG9wdGlv bnMgYXJlIG5vdCBwYXJzZWQgc28KKyAqICAgcGF5bG9hZCBpcyBhbHdheXMgdGFrZW4gMjAgYnl0 ZXMgYWZ0ZXIgdGhlIHN0YXJ0IG9mIHRoZSBJUHY0IGhlYWRlciwgTEFOOTY2eDoKKyAqICAgQnl0 ZXMgMC02IGFmdGVyIElQIGhlYWRlcgorICogVkNBUF9LRl9MM19SVF9JUzogVzEsIHNwYXJ4NTog aXMyL2VzMgorICogICBTZXQgaWYgZnJhbWUgaGFzIGhpdCBhIHJvdXRlciBsZWcKKyAqIFZDQVBf S0ZfTDNfU01BQ19TSVBfTUFUQ0g6IFcxLCBzcGFyeDU6IGlzMgorICogICBNYXRjaCBmb3VuZCBp biBTSVAgc2VjdXJpdHkgbG9va3VwIGluIEFOQV9MMworICogVkNBUF9LRl9MM19UT1M6IFc4LCBz cGFyeDU6IGlzMi9lczIKKyAqICAgU3Bhcng1OiBGcmFtZSdzIElQdjQvSVB2NiBEU0NQIGFuZCBF Q04gZmllbGRzLCBMQU45NjZ4OiBJUCBUT1MgZmllbGQKKyAqIFZDQVBfS0ZfTDNfVFRMX0dUMDog VzEsIHNwYXJ4NTogaXMyL2VzMgorICogICBTZXQgaWYgSVB2NCBUVEwgLyBJUHY2IGhvcCBsaW1p dCBpcyBncmVhdGVyIHRoYW4gMAorICogVkNBUF9LRl9MNF9BQ0s6IFcxLCBzcGFyeDU6IGlzMi9l czIKKyAqICAgU3Bhcng1IGFuZCBMQU45NjZ4OiBUQ1AgZmxhZyBBQ0ssIExBTjk2Nnggb25seTog UFRQIG92ZXIgVURQOiBmbGFnRmllbGQgYml0IDIKKyAqICAgKHVuaWNhc3RGbGFnKQorICogVkNB UF9LRl9MNF9EUE9SVDogVzE2LCBzcGFyeDU6IGlzMi9lczIKKyAqICAgU3Bhcng1OiBUQ1AvVURQ IGRlc3RpbmF0aW9uIHBvcnQuIE92ZXJsb2FkaW5nIGZvciBJUF83VFVQTEU6IE5vbi1UQ1AvVURQ IElQCisgKiAgIGZyYW1lczogTDRfRFBPUlQgPSBMM19JUF9QUk9UTywgTEFOOTY2eDogVENQL1VE UCBkZXN0aW5hdGlvbiBwb3J0CisgKiBWQ0FQX0tGX0w0X0ZJTjogVzEsIHNwYXJ4NTogaXMyL2Vz MgorICogICBUQ1AgZmxhZyBGSU4sIExBTjk2Nng6IFRDUCBmbGFnIEZJTiwgYW5kIGZvciBQVFAg b3ZlciBVRFA6IG1lc3NhZ2VUeXBlIGJpdCAxCisgKiBWQ0FQX0tGX0w0X1BBWUxPQUQ6IFc2NCwg c3Bhcng1OiBpczIvZXMyCisgKiAgIFBheWxvYWQgYnl0ZXMgYWZ0ZXIgVENQL1VEUCBoZWFkZXIg T3ZlcmxvYWRpbmcgZm9yIElQXzdUVVBMRTogTm9uIFRDUC9VRFAKKyAqICAgZnJhbWVzOiBQYXls b2FkIGJ5dGVzIDDigJM3IGFmdGVyIElQIGhlYWRlci4gSVB2NCBvcHRpb25zIGFyZSBub3QgcGFy c2VkIHNvCisgKiAgIHBheWxvYWQgaXMgYWx3YXlzIHRha2VuIDIwIGJ5dGVzIGFmdGVyIHRoZSBz dGFydCBvZiB0aGUgSVB2NCBoZWFkZXIgZm9yIG5vbgorICogICBUQ1AvVURQIElQdjQgZnJhbWVz CisgKiBWQ0FQX0tGX0w0X1BTSDogVzEsIHNwYXJ4NTogaXMyL2VzMgorICogICBTcGFyeDU6IFRD UCBmbGFnIFBTSCwgTEFOOTY2eDogVENQOiBUQ1AgZmxhZyBQU0guIFBUUCBvdmVyIFVEUDogZmxh Z0ZpZWxkIGJpdAorICogICAxICh0d29TdGVwRmxhZykKKyAqIFZDQVBfS0ZfTDRfUk5HOiBzcGFy eDUgaXMwIFc4LCBzcGFyeDUgaXMyIFcxNiwgc3Bhcng1IGVzMiBXMTYKKyAqICAgUmFuZ2UgY2hl Y2tlciBiaXRtYXNrIChvbmUgZm9yIGVhY2ggcmFuZ2UgY2hlY2tlcikuIElucHV0IGludG8gcmFu Z2UgY2hlY2tlcnMKKyAqICAgaXMgdGFrZW4gZnJvbSBjbGFzc2lmaWVkIHJlc3VsdHMgKFZJRCwg RFNDUCkgYW5kIGZyYW1lIChTUE9SVCwgRFBPUlQsIEVUWVBFLAorICogICBvdXRlciBWSUQsIGlu bmVyIFZJRCkKKyAqIFZDQVBfS0ZfTDRfUlNUOiBXMSwgc3Bhcng1OiBpczIvZXMyCisgKiAgIFNw YXJ4NTogVENQIGZsYWcgUlNUICwgTEFOOTY2eDogVENQOiBUQ1AgZmxhZyBSU1QuIFBUUCBvdmVy IFVEUDogbWVzc2FnZVR5cGUKKyAqICAgYml0IDMKKyAqIFZDQVBfS0ZfTDRfU0VRVUVOQ0VfRVEw X0lTOiBXMSwgc3Bhcng1OiBpczIvZXMyCisgKiAgIFNldCBpZiBUQ1Agc2VxdWVuY2UgbnVtYmVy IGlzIDAsIExBTjk2Nng6IE92ZXJsYXllZCB3aXRoIFBUUCBvdmVyIFVEUDoKKyAqICAgbWVzc2Fn ZVR5cGUgYml0IDAKKyAqIFZDQVBfS0ZfTDRfU1BPUlQ6IFcxNiwgc3Bhcng1OiBpczAvaXMyL2Vz MgorICogICBUQ1AvVURQIHNvdXJjZSBwb3J0CisgKiBWQ0FQX0tGX0w0X1NQT1JUX0VRX0RQT1JU X0lTOiBXMSwgc3Bhcng1OiBpczIvZXMyCisgKiAgIFNldCBpZiBVRFAgb3IgVENQIHNvdXJjZSBw b3J0IGVxdWFscyBVRFAgb3IgVENQIGRlc3RpbmF0aW9uIHBvcnQKKyAqIFZDQVBfS0ZfTDRfU1lO OiBXMSwgc3Bhcng1OiBpczIvZXMyCisgKiAgIFNwYXJ4NTogVENQIGZsYWcgU1lOLCBMQU45NjZ4 OiBUQ1A6IFRDUCBmbGFnIFNZTi4gUFRQIG92ZXIgVURQOiBtZXNzYWdlVHlwZQorICogICBiaXQg MgorICogVkNBUF9LRl9MNF9VUkc6IFcxLCBzcGFyeDU6IGlzMi9lczIKKyAqICAgU3Bhcng1OiBU Q1AgZmxhZyBVUkcsIExBTjk2Nng6IFRDUDogVENQIGZsYWcgVVJHLiBQVFAgb3ZlciBVRFA6IGZs YWdGaWVsZCBiaXQKKyAqICAgNyAocmVzZXJ2ZWQpCisgKiBWQ0FQX0tGX0xPT0tVUF9GSVJTVF9J UzogVzEsIHNwYXJ4NTogaXMwL2lzMi9lczIKKyAqICAgU2VsZWN0cyBiZXR3ZWVuIGVudHJpZXMg cmVsZXZhbnQgZm9yIGZpcnN0IGFuZCBzZWNvbmQgbG9va3VwLiBTZXQgZm9yIGZpcnN0CisgKiAg IGxvb2t1cCwgY2xlYXJlZCBmb3Igc2Vjb25kIGxvb2t1cC4KKyAqIFZDQVBfS0ZfTE9PS1VQX0dF Tl9JRFg6IFcxMiwgc3Bhcng1OiBpczAKKyAqICAgR2VuZXJpYyBpbmRleCAtIGZvciBjaGFpbmlu ZyBDTE0gaW5zdGFuY2VzCisgKiBWQ0FQX0tGX0xPT0tVUF9HRU5fSURYX1NFTDogVzIsIHNwYXJ4 NTogaXMwCisgKiAgIFNlbGVjdCB0aGUgbW9kZSBvZiB0aGUgR2VuZXJpYyBJbmRleAorICogVkNB UF9LRl9MT09LVVBfUEFHOiBXOCwgc3Bhcng1OiBpczIKKyAqICAgQ2xhc3NpZmllZCBQb2xpY3kg QXNzb2NpYXRpb24gR3JvdXA6IGNoYWlucyBydWxlcyBmcm9tIElTMS9DTE0gdG8gSVMyCisgKiBW Q0FQX0tGX09BTV9DQ01fQ05UU19FUTA6IFcxLCBzcGFyeDU6IGlzMi9lczIKKyAqICAgRHVhbC1l bmRlZCBsb3NzIG1lYXN1cmVtZW50IGNvdW50ZXJzIGluIENDTSBmcmFtZXMgYXJlIGFsbCB6ZXJv CisgKiBWQ0FQX0tGX09BTV9NRUxfRkxBR1M6IFc3LCBzcGFyeDU6IGlzMAorICogICBFbmNvZGlu ZyBvZiBNRCBsZXZlbC9NRUcgbGV2ZWwgKE1FTCkKKyAqIFZDQVBfS0ZfT0FNX1kxNzMxX0lTOiBX MSwgc3Bhcng1OiBpczAvaXMyL2VzMgorICogICBTZXQgaWYgZnJhbWXigJlzIEV0aGVyVHlwZSA9 IDB4ODkwMgorICogVkNBUF9LRl9QUk9UX0FDVElWRTogVzEsIHNwYXJ4NTogZXMyCisgKiAgIFBy b3RlY3Rpb24gaXMgYWN0aXZlCisgKiBWQ0FQX0tGX1RDUF9JUzogVzEsIHNwYXJ4NTogaXMwL2lz Mi9lczIKKyAqICAgU2V0IGlmIGZyYW1lIGlzIElQdjQgVENQIGZyYW1lIChJUCBwcm90b2NvbCA9 IDYpIG9yIElQdjYgVENQIGZyYW1lcyAoTmV4dAorICogICBoZWFkZXIgPSA2KQorICogVkNBUF9L Rl9UQ1BfVURQX0lTOiBXMSwgc3Bhcng1OiBpczAvaXMyL2VzMgorICogICBTZXQgaWYgZnJhbWUg aXMgSVB2NC9JUHY2IFRDUCBvciBVRFAgZnJhbWUgKElQIHByb3RvY29sL25leHQgaGVhZGVyIGVx dWFscyA2CisgKiAgIG9yIDE3KQorICogVkNBUF9LRl9UWVBFOiBzcGFyeDUgaXMwIFcyLCBzcGFy eDUgaXMwIFcxLCBzcGFyeDUgaXMyIFc0LCBzcGFyeDUgaXMyIFcyLAorICogICBzcGFyeDUgZXMy IFczCisgKiAgIEtleXNldCB0eXBlIGlkIC0gc2V0IGJ5IHRoZSBBUEkKKyAqLworCisvKiBLZXlm aWVsZCBuYW1lcyAqLworZW51bSB2Y2FwX2tleV9maWVsZCB7CisJVkNBUF9LRl9OT19WQUxVRSwg IC8qIGluaXRpYWwgdmFsdWUgKi8KKwlWQ0FQX0tGXzgwMjFCUl9FQ0lEX0JBU0UsCisJVkNBUF9L Rl84MDIxQlJfRUNJRF9FWFQsCisJVkNBUF9LRl84MDIxQlJfRV9UQUdHRUQsCisJVkNBUF9LRl84 MDIxQlJfR1JQLAorCVZDQVBfS0ZfODAyMUJSX0lHUl9FQ0lEX0JBU0UsCisJVkNBUF9LRl84MDIx QlJfSUdSX0VDSURfRVhULAorCVZDQVBfS0ZfODAyMVFfREVJMCwKKwlWQ0FQX0tGXzgwMjFRX0RF STEsCisJVkNBUF9LRl84MDIxUV9ERUkyLAorCVZDQVBfS0ZfODAyMVFfREVJX0NMUywKKwlWQ0FQ X0tGXzgwMjFRX1BDUDAsCisJVkNBUF9LRl84MDIxUV9QQ1AxLAorCVZDQVBfS0ZfODAyMVFfUENQ MiwKKwlWQ0FQX0tGXzgwMjFRX1BDUF9DTFMsCisJVkNBUF9LRl84MDIxUV9UUElEMCwKKwlWQ0FQ X0tGXzgwMjFRX1RQSUQxLAorCVZDQVBfS0ZfODAyMVFfVFBJRDIsCisJVkNBUF9LRl84MDIxUV9W SUQwLAorCVZDQVBfS0ZfODAyMVFfVklEMSwKKwlWQ0FQX0tGXzgwMjFRX1ZJRDIsCisJVkNBUF9L Rl84MDIxUV9WSURfQ0xTLAorCVZDQVBfS0ZfODAyMVFfVkxBTl9UQUdHRURfSVMsCisJVkNBUF9L Rl84MDIxUV9WTEFOX1RBR1MsCisJVkNBUF9LRl9BQ0xfR1JQX0lELAorCVZDQVBfS0ZfQVJQX0FE RFJfU1BBQ0VfT0tfSVMsCisJVkNBUF9LRl9BUlBfTEVOX09LX0lTLAorCVZDQVBfS0ZfQVJQX09Q Q09ERSwKKwlWQ0FQX0tGX0FSUF9PUENPREVfVU5LTk9XTl9JUywKKwlWQ0FQX0tGX0FSUF9QUk9U T19TUEFDRV9PS19JUywKKwlWQ0FQX0tGX0FSUF9TRU5ERVJfTUFUQ0hfSVMsCisJVkNBUF9LRl9B UlBfVEdUX01BVENIX0lTLAorCVZDQVBfS0ZfQ09TSURfQ0xTLAorCVZDQVBfS0ZfRFNUX0VOVFJZ LAorCVZDQVBfS0ZfRVMwX0lTRFhfS0VZX0VOQSwKKwlWQ0FQX0tGX0VUWVBFLAorCVZDQVBfS0Zf RVRZUEVfTEVOX0lTLAorCVZDQVBfS0ZfRVRZUEVfTVBMUywKKwlWQ0FQX0tGX0lGX0VHUl9QT1JU X01BU0ssCisJVkNBUF9LRl9JRl9FR1JfUE9SVF9NQVNLX1JORywKKwlWQ0FQX0tGX0lGX0lHUl9Q T1JULAorCVZDQVBfS0ZfSUZfSUdSX1BPUlRfTUFTSywKKwlWQ0FQX0tGX0lGX0lHUl9QT1JUX01B U0tfTDMsCisJVkNBUF9LRl9JRl9JR1JfUE9SVF9NQVNLX1JORywKKwlWQ0FQX0tGX0lGX0lHUl9Q T1JUX01BU0tfU0VMLAorCVZDQVBfS0ZfSUZfSUdSX1BPUlRfU0VMLAorCVZDQVBfS0ZfSVA0X0lT LAorCVZDQVBfS0ZfSVBfTUNfSVMsCisJVkNBUF9LRl9JUF9QQVlMT0FEXzVUVVBMRSwKKwlWQ0FQ X0tGX0lQX1NOQVBfSVMsCisJVkNBUF9LRl9JU0RYX0NMUywKKwlWQ0FQX0tGX0lTRFhfR1QwX0lT LAorCVZDQVBfS0ZfTDJfQkNfSVMsCisJVkNBUF9LRl9MMl9ETUFDLAorCVZDQVBfS0ZfTDJfRldE X0lTLAorCVZDQVBfS0ZfTDJfTUNfSVMsCisJVkNBUF9LRl9MMl9QQVlMT0FEX0VUWVBFLAorCVZD QVBfS0ZfTDJfU01BQywKKwlWQ0FQX0tGX0wzX0RJUF9FUV9TSVBfSVMsCisJVkNBUF9LRl9MM19E TUFDX0RJUF9NQVRDSCwKKwlWQ0FQX0tGX0wzX0RQTF9DTFMsCisJVkNBUF9LRl9MM19EU0NQLAor CVZDQVBfS0ZfTDNfRFNUX0lTLAorCVZDQVBfS0ZfTDNfRlJBR01FTlRfVFlQRSwKKwlWQ0FQX0tG X0wzX0ZSQUdfSU5WTERfTDRfTEVOLAorCVZDQVBfS0ZfTDNfSVA0X0RJUCwKKwlWQ0FQX0tGX0wz X0lQNF9TSVAsCisJVkNBUF9LRl9MM19JUDZfRElQLAorCVZDQVBfS0ZfTDNfSVA2X1NJUCwKKwlW Q0FQX0tGX0wzX0lQX1BST1RPLAorCVZDQVBfS0ZfTDNfT1BUSU9OU19JUywKKwlWQ0FQX0tGX0wz X1BBWUxPQUQsCisJVkNBUF9LRl9MM19SVF9JUywKKwlWQ0FQX0tGX0wzX1NNQUNfU0lQX01BVENI LAorCVZDQVBfS0ZfTDNfVE9TLAorCVZDQVBfS0ZfTDNfVFRMX0dUMCwKKwlWQ0FQX0tGX0w0X0FD SywKKwlWQ0FQX0tGX0w0X0RQT1JULAorCVZDQVBfS0ZfTDRfRklOLAorCVZDQVBfS0ZfTDRfUEFZ TE9BRCwKKwlWQ0FQX0tGX0w0X1BTSCwKKwlWQ0FQX0tGX0w0X1JORywKKwlWQ0FQX0tGX0w0X1JT VCwKKwlWQ0FQX0tGX0w0X1NFUVVFTkNFX0VRMF9JUywKKwlWQ0FQX0tGX0w0X1NQT1JULAorCVZD QVBfS0ZfTDRfU1BPUlRfRVFfRFBPUlRfSVMsCisJVkNBUF9LRl9MNF9TWU4sCisJVkNBUF9LRl9M NF9VUkcsCisJVkNBUF9LRl9MT09LVVBfRklSU1RfSVMsCisJVkNBUF9LRl9MT09LVVBfR0VOX0lE WCwKKwlWQ0FQX0tGX0xPT0tVUF9HRU5fSURYX1NFTCwKKwlWQ0FQX0tGX0xPT0tVUF9QQUcsCisJ VkNBUF9LRl9NSVJST1JfRU5BLAorCVZDQVBfS0ZfT0FNX0NDTV9DTlRTX0VRMCwKKwlWQ0FQX0tG X09BTV9NRUxfRkxBR1MsCisJVkNBUF9LRl9PQU1fWTE3MzFfSVMsCisJVkNBUF9LRl9QUk9UX0FD VElWRSwKKwlWQ0FQX0tGX1RDUF9JUywKKwlWQ0FQX0tGX1RDUF9VRFBfSVMsCisJVkNBUF9LRl9U WVBFLAorfTsKKworLyogQWN0aW9uc2V0IG5hbWVzIHdpdGggb3JpZ2luIGluZm9ybWF0aW9uICov CitlbnVtIHZjYXBfYWN0aW9uZmllbGRfc2V0IHsKKwlWQ0FQX0FGU19OT19WQUxVRSwgICAgICAg ICAgLyogaW5pdGlhbCB2YWx1ZSAqLworCVZDQVBfQUZTX0JBU0VfVFlQRSwgICAgICAgICAvKiBz cGFyeDUgaXMyIFgzLCBzcGFyeDUgZXMyIFgzICovCisJVkNBUF9BRlNfQ0xBU1NJRklDQVRJT04s ICAgIC8qIHNwYXJ4NSBpczAgWDIgKi8KKwlWQ0FQX0FGU19DTEFTU19SRURVQ0VELCAgICAgLyog c3Bhcng1IGlzMCBYMSAqLworCVZDQVBfQUZTX0ZVTEwsICAgICAgICAgICAgICAvKiBzcGFyeDUg aXMwIFgzICovCisJVkNBUF9BRlNfTUxCUywgICAgICAgICAgICAgIC8qIHNwYXJ4NSBpczAgWDIg Ki8KKwlWQ0FQX0FGU19NTEJTX1JFRFVDRUQsICAgICAgLyogc3Bhcng1IGlzMCBYMSAqLworfTsK KworLyogTGlzdCBvZiBhY3Rpb25maWVsZHMgd2l0aCBkZXNjcmlwdGlvbgorICoKKyAqIFZDQVBf QUZfQ0xTX1ZJRF9TRUw6IFczLCBzcGFyeDU6IGlzMAorICogICBDb250cm9scyB0aGUgY2xhc3Np ZmllZCBWSUQ6IDA6IFZJRF9OT05FOiBObyBhY3Rpb24uIDE6IFZJRF9BREQ6IE5ldyBWSUQgPQor ICogICBvbGQgVklEICsgVklEX1ZBTC4gMjogVklEX1JFUExBQ0U6IE5ldyBWSUQgPSBWSURfVkFM LiAzOiBWSURfRklSU1RfVEFHOiBOZXcKKyAqICAgVklEID0gVklEIGZyb20gZnJhbWUncyBmaXJz dCB0YWcgKG91dGVyIHRhZykgaWYgYXZhaWxhYmxlLCBvdGhlcndpc2UgVklEX1ZBTC4KKyAqICAg NDogVklEX1NFQ09ORF9UQUc6IE5ldyBWSUQgPSBWSUQgZnJvbSBmcmFtZSdzIHNlY29uZCB0YWcg KG1pZGRsZSB0YWcpIGlmCisgKiAgIGF2YWlsYWJsZSwgb3RoZXJ3aXNlIFZJRF9WQUwuIDU6IFZJ RF9USElSRF9UQUc6IE5ldyBWSUQgPSBWSUQgZnJvbSBmcmFtZSdzCisgKiAgIHRoaXJkIHRhZyAo aW5uZXIgdGFnKSBpZiBhdmFpbGFibGUsIG90aGVyd2lzZSBWSURfVkFMLgorICogVkNBUF9BRl9D TlRfSUQ6IHNwYXJ4NSBpczIgVzEyLCBzcGFyeDUgZXMyIFcxMQorICogICBDb3VudGVyIElELCB1 c2VkIHBlciBsb29rdXAgdG8gaW5kZXggdGhlIDRLIGZyYW1lIGNvdW50ZXJzIChBTkFfQUNMOkNO VF9UQkwpLgorICogICBNdWx0aXBsZSBWQ0FQIElTMiBlbnRyaWVzIGNhbiB1c2UgdGhlIHNhbWUg Y291bnRlci4KKyAqIFZDQVBfQUZfQ09QWV9QT1JUX05VTTogVzcsIHNwYXJ4NTogZXMyCisgKiAg IFFTWVMgcG9ydCBudW1iZXIgd2hlbiBGV0RfTU9ERSBpcyByZWRpcmVjdCBvciBjb3B5CisgKiBW Q0FQX0FGX0NPUFlfUVVFVUVfTlVNOiBXMTYsIHNwYXJ4NTogZXMyCisgKiAgIFFTWVMgcXVldWUg bnVtYmVyIHdoZW4gRldEX01PREUgaXMgcmVkaXJlY3Qgb3IgY29weQorICogVkNBUF9BRl9DUFVf Q09QWV9FTkE6IFcxLCBzcGFyeDU6IGlzMi9lczIKKyAqICAgU2V0dGluZyB0aGlzIGJpdCB0byAx IGNhdXNlcyBhbGwgZnJhbWVzIHRoYXQgaGl0IHRoaXMgYWN0aW9uIHRvIGJlIGNvcGllZCB0bwor ICogICB0aGUgQ1BVIGV4dHJhY3Rpb24gcXVldWUgc3BlY2lmaWVkIGluIENQVV9RVUVVRV9OVU0u CisgKiBWQ0FQX0FGX0NQVV9RVUVVRV9OVU06IFczLCBzcGFyeDU6IGlzMi9lczIKKyAqICAgQ1BV IHF1ZXVlIG51bWJlci4gVXNlZCB3aGVuIENQVV9DT1BZX0VOQSBpcyBzZXQuCisgKiBWQ0FQX0FG X0RFSV9FTkE6IFcxLCBzcGFyeDU6IGlzMAorICogICBJZiBzZXQsIHVzZSBERUlfVkFMIGFzIGNs YXNzaWZpZWQgREVJIHZhbHVlLiBPdGhlcndpc2UsIERFSSBmcm9tIGJhc2ljCisgKiAgIGNsYXNz aWZpY2F0aW9uIGlzIHVzZWQKKyAqIFZDQVBfQUZfREVJX1ZBTDogVzEsIHNwYXJ4NTogaXMwCisg KiAgIFNlZSBERUlfRU5BCisgKiBWQ0FQX0FGX0RQX0VOQTogVzEsIHNwYXJ4NTogaXMwCisgKiAg IElmIHNldCwgdXNlIERQX1ZBTCBhcyBjbGFzc2lmaWVkIGRyb3AgcHJlY2VkZW5jZSBsZXZlbC4g T3RoZXJ3aXNlLCBkcm9wCisgKiAgIHByZWNlZGVuY2UgbGV2ZWwgZnJvbSBiYXNpYyBjbGFzc2lm aWNhdGlvbiBpcyB1c2VkLgorICogVkNBUF9BRl9EUF9WQUw6IFcyLCBzcGFyeDU6IGlzMAorICog ICBTZWUgRFBfRU5BLgorICogVkNBUF9BRl9EU0NQX0VOQTogVzEsIHNwYXJ4NTogaXMwCisgKiAg IElmIHNldCwgdXNlIERTQ1BfVkFMIGFzIGNsYXNzaWZpZWQgRFNDUCB2YWx1ZS4gT3RoZXJ3aXNl LCBEU0NQIHZhbHVlIGZyb20KKyAqICAgYmFzaWMgY2xhc3NpZmljYXRpb24gaXMgdXNlZC4KKyAq IFZDQVBfQUZfRFNDUF9WQUw6IFc2LCBzcGFyeDU6IGlzMAorICogICBTZWUgRFNDUF9FTkEuCisg KiBWQ0FQX0FGX0VTMl9SRVdfQ01EOiBXMywgc3Bhcng1OiBlczIKKyAqICAgQ29tbWFuZCBmb3J3 YXJkZWQgdG8gUkVXOiAwOiBObyBhY3Rpb24uIDE6IFNXQVAgTUFDIGFkZHJlc3Nlcy4gMjogRG8g TDJDUAorICogICBETUFDIHRyYW5zbGF0aW9uIHdoZW4gZW50ZXJpbmcgb3IgbGVhdmluZyBhIHR1 bm5lbC4KKyAqIFZDQVBfQUZfRldEX01PREU6IFcyLCBzcGFyeDU6IGVzMgorICogICBGb3J3YXJk IHNlbGVjdG9yOiAwOiBGb3J3YXJkLiAxOiBEaXNjYXJkLiAyOiBSZWRpcmVjdC4gMzogQ29weS4K KyAqIFZDQVBfQUZfSElUX01FX09OQ0U6IFcxLCBzcGFyeDU6IGlzMi9lczIKKyAqICAgU2V0dGlu ZyB0aGlzIGJpdCB0byAxIGNhdXNlcyB0aGUgZmlyc3QgZnJhbWUgdGhhdCBoaXRzIHRoaXMgYWN0 aW9uIHdoZXJlIHRoZQorICogICBISVRfQ05UIGNvdW50ZXIgaXMgemVybyB0byBiZSBjb3BpZWQg dG8gdGhlIENQVSBleHRyYWN0aW9uIHF1ZXVlIHNwZWNpZmllZCBpbgorICogICBDUFVfUVVFVUVf TlVNLiBUaGUgSElUX0NOVCBjb3VudGVyIGlzIHRoZW4gaW5jcmVtZW50ZWQgYW5kIGFueSBmcmFt ZXMgdGhhdAorICogICBoaXQgdGhpcyBhY3Rpb24gbGF0ZXIgYXJlIG5vdCBjb3BpZWQgdG8gdGhl IENQVS4gVG8gcmUtZW5hYmxlIHRoZSBISVRfTUVfT05DRQorICogICBmdW5jdGlvbmFsaXR5LCB0 aGUgSElUX0NOVCBjb3VudGVyIG11c3QgYmUgY2xlYXJlZC4KKyAqIFZDQVBfQUZfSUdOT1JFX1BJ UEVMSU5FX0NUUkw6IFcxLCBzcGFyeDU6IGlzMi9lczIKKyAqICAgSWdub3JlIGluZ3Jlc3MgcGlw ZWxpbmUgY29udHJvbC4gVGhpcyBlbmZvcmNlcyB0aGUgdXNlIG9mIHRoZSBWQ0FQIElTMiBhY3Rp b24KKyAqICAgZXZlbiB3aGVuIHRoZSBwaXBlbGluZSBjb250cm9sIGhhcyB0ZXJtaW5hdGVkIHRo ZSBmcmFtZSBiZWZvcmUgVkNBUCBJUzIuCisgKiBWQ0FQX0FGX0lOVFJfRU5BOiBXMSwgc3Bhcng1 OiBpczIvZXMyCisgKiAgIElmIHNldCwgYW4gaW50ZXJydXB0IGlzIHRyaWdnZXJlZCB3aGVuIHRo aXMgcnVsZSBpcyBoaXQKKyAqIFZDQVBfQUZfSVNEWF9BRERfUkVQTEFDRV9TRUw6IFcxLCBzcGFy eDU6IGlzMAorICogICBDb250cm9scyB0aGUgY2xhc3NpZmllZCBJU0RYLiAwOiBOZXcgSVNEWCA9 IG9sZCBJU0RYICsgSVNEWF9WQUwuIDE6IE5ldyBJU0RYCisgKiAgID0gSVNEWF9WQUwuCisgKiBW Q0FQX0FGX0lTRFhfVkFMOiBXMTIsIHNwYXJ4NTogaXMwCisgKiAgIFNlZSBpc2R4X2FkZF9yZXBs YWNlX3NlbAorICogVkNBUF9BRl9MUk5fRElTOiBXMSwgc3Bhcng1OiBpczIKKyAqICAgU2V0dGlu ZyB0aGlzIGJpdCB0byAxIGRpc2FibGVzIGxlYXJuaW5nIG9mIGZyYW1lcyBoaXR0aW5nIHRoaXMg YWN0aW9uLgorICogVkNBUF9BRl9NQVBfSURYOiBXOSwgc3Bhcng1OiBpczAKKyAqICAgSW5kZXgg Zm9yIFFvUyBtYXBwaW5nIHRhYmxlIGxvb2t1cAorICogVkNBUF9BRl9NQVBfS0VZOiBXMywgc3Bh cng1OiBpczAKKyAqICAgS2V5IHR5cGUgZm9yIFFvUyBtYXBwaW5nIHRhYmxlIGxvb2t1cC4gMDog REVJMCwgUENQMCAob3V0ZXIgdGFnKS4gMTogREVJMSwKKyAqICAgUENQMSAobWlkZGxlIHRhZyku IDI6IERFSTIsIFBDUDIgKGlubmVyIHRhZykuIDM6IE1QTFMgVEMuIDQ6IFBDUDAgKG91dGVyCisg KiAgIHRhZykuIDU6IEUtREVJLCBFLVBDUCAoRS1UQUcpLiA2OiBEU0NQIGlmIGF2YWlsYWJsZSwg b3RoZXJ3aXNlIG5vbmUuIDc6IERTQ1AKKyAqICAgaWYgYXZhaWxhYmxlLCBvdGhlcndpc2UgREVJ MCwgUENQMCAob3V0ZXIgdGFnKSBpZiBhdmFpbGFibGUgdXNpbmcgTUFQX0lEWCs4LAorICogICBv dGhlcndpc2Ugbm9uZQorICogVkNBUF9BRl9NQVBfTE9PS1VQX1NFTDogVzIsIHNwYXJ4NTogaXMw CisgKiAgIFNlbGVjdHMgd2hpY2ggb2YgdGhlIHR3byBRb1MgTWFwcGluZyBUYWJsZSBsb29rdXBz IHRoYXQgTUFQX0tFWSBhbmQgTUFQX0lEWAorICogICBhcmUgYXBwbGllZCB0by4gMDogTm8gY2hh bmdlcyB0byB0aGUgUW9TIE1hcHBpbmcgVGFibGUgbG9va3VwLiAxOiBVcGRhdGUga2V5CisgKiAg IHR5cGUgYW5kIGluZGV4IGZvciBRb1MgTWFwcGluZyBUYWJsZSBsb29rdXAgIzAuIDI6IFVwZGF0 ZSBrZXkgdHlwZSBhbmQgaW5kZXgKKyAqICAgZm9yIFFvUyBNYXBwaW5nIFRhYmxlIGxvb2t1cCAj MS4gMzogUmVzZXJ2ZWQuCisgKiBWQ0FQX0FGX01BU0tfTU9ERTogVzMsIHNwYXJ4NTogaXMwL2lz MgorICogICBDb250cm9scyB0aGUgUE9SVF9NQVNLIHVzZS4gU3Bhcng1OiAwOiBPUl9EU1RNQVNL LCAxOiBBTkRfVkxBTk1BU0ssIDI6CisgKiAgIFJFUExBQ0VfUEdJRCwgMzogUkVQTEFDRV9BTEws IDQ6IFJFRElSX1BHSUQsIDU6IE9SX1BHSURfTUFTSywgNjogVlNUQVgsIDc6CisgKiAgIE5vdCBh cHBsaWNhYmxlLiBMQU45NjZYOiAwOiBObyBhY3Rpb24sIDE6IFBlcm1pdC9kZW55IChBTkQpLCAy OiBQb2xpY3kKKyAqICAgZm9yd2FyZGluZyAoRE1BQyBsb29rdXApLCAzOiBSZWRpcmVjdC4gVGhl IENQVSBwb3J0IGlzIHVudG91Y2hlZCBieQorICogICBNQVNLX01PREUuCisgKiBWQ0FQX0FGX01B VENIX0lEOiBXMTYsIHNwYXJ4NTogaXMwL2lzMgorICogICBMb2dpY2FsIElEIGZvciB0aGUgZW50 cnkuIFRoZSBNQVRDSF9JRCBpcyBleHRyYWN0ZWQgdG9nZXRoZXIgd2l0aCB0aGUgZnJhbWUKKyAq ICAgaWYgdGhlIGZyYW1lIGlzIGZvcndhcmRlZCB0byB0aGUgQ1BVIChDUFVfQ09QWV9FTkEpLiBU aGUgcmVzdWx0IGlzIHBsYWNlZCBpbgorICogICBJRkguQ0xfUlNMVC4KKyAqIFZDQVBfQUZfTUFU Q0hfSURfTUFTSzogVzE2LCBzcGFyeDU6IGlzMC9pczIKKyAqICAgTWFzayB1c2VkIGJ5IE1BVENI X0lELgorICogVkNBUF9BRl9NSVJST1JfUFJPQkU6IFcyLCBzcGFyeDU6IGlzMgorICogICBNaXJy b3JpbmcgcGVyZm9ybWVkIGFjY29yZGluZyB0byBjb25maWd1cmF0aW9uIG9mIGEgbWlycm9yIHBy b2JlLiAwOiBObworICogICBtaXJyb3JpbmcuIDE6IE1pcnJvciBwcm9iZSAwLiAyOiBNaXJyb3Ig cHJvYmUgMS4gMzogTWlycm9yIHByb2JlIDIKKyAqIFZDQVBfQUZfTUlSUk9SX1BST0JFX0lEOiBX Miwgc3Bhcng1OiBlczIKKyAqICAgU2lnbmFscyBhIG1pcnJvciBwcm9iZSB0byBiZSBwbGFjZWQg aW4gdGhlIElGSC4gT25seSBwb3NzaWJsZSB3aGVuIEZXRF9NT0RFCisgKiAgIGlzIGNvcHkuIDA6 IE5vIG1pcnJvcmluZy4gMeKAkzM6IFVzZSBtaXJyb3IgcHJvYmUgMC0yLgorICogVkNBUF9BRl9O WFRfSURYOiBXMTIsIHNwYXJ4NTogaXMwCisgKiAgIEluZGV4IHVzZWQgYXMgcGFydCBvZiBrZXkg KGZpZWxkIEdfSURYKSBpbiB0aGUgbmV4dCBsb29rdXAuCisgKiBWQ0FQX0FGX05YVF9JRFhfQ1RS TDogVzMsIHNwYXJ4NTogaXMwCisgKiAgIENvbnRyb2xzIHRoZSBnZW5lcmF0aW9uIG9mIHRoZSBH X0lEWCB1c2VkIGluIHRoZSBWQ0FQIENMTSBuZXh0IGxvb2t1cAorICogVkNBUF9BRl9QQUdfT1ZF UlJJREVfTUFTSzogVzgsIHNwYXJ4NTogaXMwCisgKiAgIEJpdHMgc2V0IGluIHRoaXMgbWFzayB3 aWxsIG92ZXJyaWRlIFBBR19WQUwgZnJvbSBwb3J0IHByb2ZpbGUuIO+AoCBOZXcgUEFHID0KKyAq ICAgKFBBRyAoaW5wdXQpIEFORCB+UEFHX09WRVJSSURFX01BU0spIE9SIChQQUdfVkFMIEFORCBQ QUdfT1ZFUlJJREVfTUFTSykKKyAqIFZDQVBfQUZfUEFHX1ZBTDogVzgsIHNwYXJ4NTogaXMwCisg KiAgIFNlZSBQQUdfT1ZFUlJJREVfTUFTSy4KKyAqIFZDQVBfQUZfUENQX0VOQTogVzEsIHNwYXJ4 NTogaXMwCisgKiAgIElmIHNldCwgdXNlIFBDUF9WQUwgYXMgY2xhc3NpZmllZCBQQ1AgdmFsdWUu IE90aGVyd2lzZSwgUENQIGZyb20gYmFzaWMKKyAqICAgY2xhc3NpZmljYXRpb24gaXMgdXNlZC4K KyAqIFZDQVBfQUZfUENQX1ZBTDogVzMsIHNwYXJ4NTogaXMwCisgKiAgIFNlZSBQQ1BfRU5BLgor ICogVkNBUF9BRl9QSVBFTElORV9GT1JDRV9FTkE6IHNwYXJ4NSBpczAgVzIsIHNwYXJ4NSBpczIg VzEKKyAqICAgSWYgc2V0LCB1c2UgUElQRUxJTkVfUFQgdW5jb25kaXRpb25hbGx5IGFuZCBzZXQg UElQRUxJTkVfQUNUID0gTk9ORSBpZgorICogICBQSVBFTElORV9QVCA9PSBOT05FLiBPdmVycnVs ZXMgcHJldmlvdXMgc2V0dGluZ3Mgb2YgcGlwZWxpbmUgcG9pbnQuCisgKiBWQ0FQX0FGX1BJUEVM SU5FX1BUOiBXNSwgc3Bhcng1OiBpczAvaXMyCisgKiAgIFBpcGVsaW5lIHBvaW50IHVzZWQgaWYg UElQRUxJTkVfRk9SQ0VfRU5BIGlzIHNldAorICogVkNBUF9BRl9QT0xJQ0VfRU5BOiBXMSwgc3Bh cng1OiBpczIvZXMyCisgKiAgIFNldHRpbmcgdGhpcyBiaXQgdG8gMSBjYXVzZXMgZnJhbWVzIHRo YXQgaGl0IHRoaXMgYWN0aW9uIHRvIGJlIHBvbGljZWQgYnkgdGhlCisgKiAgIEFDTCBwb2xpY2Vy IHNwZWNpZmllZCBpbiBQT0xJQ0VfSURYLiBPbmx5IGFwcGxpZXMgdG8gdGhlIGZpcnN0IGxvb2t1 cC4KKyAqIFZDQVBfQUZfUE9MSUNFX0lEWDogVzYsIHNwYXJ4NTogaXMyL2VzMgorICogICBTZWxl Y3RzIFZDQVAgcG9saWNlciB1c2VkIHdoZW4gcG9saWNpbmcgZnJhbWVzIChQT0xJQ0VfRU5BKQor ICogVkNBUF9BRl9QT0xJQ0VfUkVNQVJLOiBXMSwgc3Bhcng1OiBlczIKKyAqICAgSWYgc2V0LCBm cmFtZXMgZXhjZWVkaW5nIHBvbGljZXIgcmF0ZXMgYXJlIG1hcmtlZCBhcyB5ZWxsb3cgYnV0IG5v dAorICogICBkaXNjYXJkZWQuCisgKiBWQ0FQX0FGX1BPUlRfTUFTSzogc3Bhcng1IGlzMCBXNjUs IHNwYXJ4NSBpczIgVzY4CisgKiAgIFBvcnQgbWFzayBhcHBsaWVkIHRvIHRoZSBmb3J3YXJkaW5n IGRlY2lzaW9uIGJhc2VkIG9uIE1BU0tfTU9ERS4KKyAqIFZDQVBfQUZfUU9TX0VOQTogVzEsIHNw YXJ4NTogaXMwCisgKiAgIElmIHNldCwgdXNlIFFPU19WQUwgYXMgY2xhc3NpZmllZCBRb1MgY2xh c3MuIE90aGVyd2lzZSwgUW9TIGNsYXNzIGZyb20gYmFzaWMKKyAqICAgY2xhc3NpZmljYXRpb24g aXMgdXNlZC4KKyAqIFZDQVBfQUZfUU9TX1ZBTDogVzMsIHNwYXJ4NTogaXMwCisgKiAgIFNlZSBR T1NfRU5BLgorICogVkNBUF9BRl9SVF9ESVM6IFcxLCBzcGFyeDU6IGlzMgorICogICBJZiBzZXQs IHJvdXRpbmcgaXMgZGlzYWxsb3dlZC4gT25seSBhcHBsaWVzIHdoZW4gSVNfSU5ORVJfQUNMIGlz IDAuIFNlZSBhbHNvCisgKiAgIElHUl9BQ0xfRU5BLCBFR1JfQUNMX0VOQSwgYW5kIFJMRUdfU1RB VF9JRFguCisgKiBWQ0FQX0FGX1RZUEU6IFcxLCBzcGFyeDU6IGlzMAorICogICBBY3Rpb25zZXQg dHlwZSBpZCAtIFNldCBieSB0aGUgQVBJCisgKiBWQ0FQX0FGX1ZJRF9WQUw6IFcxMywgc3Bhcng1 OiBpczAKKyAqICAgTmV3IFZJRCBWYWx1ZQorICovCisKKy8qIEFjdGlvbmZpZWxkIG5hbWVzICov CitlbnVtIHZjYXBfYWN0aW9uX2ZpZWxkIHsKKwlWQ0FQX0FGX05PX1ZBTFVFLCAgLyogaW5pdGlh bCB2YWx1ZSAqLworCVZDQVBfQUZfQUNMX01BQywKKwlWQ0FQX0FGX0FDTF9SVF9NT0RFLAorCVZD QVBfQUZfQ0xTX1ZJRF9TRUwsCisJVkNBUF9BRl9DTlRfSUQsCisJVkNBUF9BRl9DT1BZX1BPUlRf TlVNLAorCVZDQVBfQUZfQ09QWV9RVUVVRV9OVU0sCisJVkNBUF9BRl9DT1NJRF9FTkEsCisJVkNB UF9BRl9DT1NJRF9WQUwsCisJVkNBUF9BRl9DUFVfQ09QWV9FTkEsCisJVkNBUF9BRl9DUFVfRElT LAorCVZDQVBfQUZfQ1BVX0VOQSwKKwlWQ0FQX0FGX0NQVV9RLAorCVZDQVBfQUZfQ1BVX1FVRVVF X05VTSwKKwlWQ0FQX0FGX0NVU1RPTV9BQ0VfRU5BLAorCVZDQVBfQUZfQ1VTVE9NX0FDRV9PRkZT RVQsCisJVkNBUF9BRl9ERUlfRU5BLAorCVZDQVBfQUZfREVJX1ZBTCwKKwlWQ0FQX0FGX0RMQl9P RkZTRVQsCisJVkNBUF9BRl9ETUFDX09GRlNFVF9FTkEsCisJVkNBUF9BRl9EUF9FTkEsCisJVkNB UF9BRl9EUF9WQUwsCisJVkNBUF9BRl9EU0NQX0VOQSwKKwlWQ0FQX0FGX0RTQ1BfVkFMLAorCVZD QVBfQUZfRUdSX0FDTF9FTkEsCisJVkNBUF9BRl9FUzJfUkVXX0NNRCwKKwlWQ0FQX0FGX0ZXRF9E SVMsCisJVkNBUF9BRl9GV0RfTU9ERSwKKwlWQ0FQX0FGX0ZXRF9UWVBFLAorCVZDQVBfQUZfR1ZJ RF9BRERfUkVQTEFDRV9TRUwsCisJVkNBUF9BRl9ISVRfTUVfT05DRSwKKwlWQ0FQX0FGX0lHTk9S RV9QSVBFTElORV9DVFJMLAorCVZDQVBfQUZfSUdSX0FDTF9FTkEsCisJVkNBUF9BRl9JTkpfTUFT UV9FTkEsCisJVkNBUF9BRl9JTkpfTUFTUV9MUE9SVCwKKwlWQ0FQX0FGX0lOSl9NQVNRX1BPUlQs CisJVkNBUF9BRl9JTlRSX0VOQSwKKwlWQ0FQX0FGX0lTRFhfQUREX1JFUExBQ0VfU0VMLAorCVZD QVBfQUZfSVNEWF9WQUwsCisJVkNBUF9BRl9JU19JTk5FUl9BQ0wsCisJVkNBUF9BRl9MM19NQUNf VVBEQVRFX0RJUywKKwlWQ0FQX0FGX0xPR19NU0dfSU5URVJWQUwsCisJVkNBUF9BRl9MUE1fQUZG SVhfRU5BLAorCVZDQVBfQUZfTFBNX0FGRklYX1ZBTCwKKwlWQ0FQX0FGX0xQT1JUX0VOQSwKKwlW Q0FQX0FGX0xSTl9ESVMsCisJVkNBUF9BRl9NQVBfSURYLAorCVZDQVBfQUZfTUFQX0tFWSwKKwlW Q0FQX0FGX01BUF9MT09LVVBfU0VMLAorCVZDQVBfQUZfTUFTS19NT0RFLAorCVZDQVBfQUZfTUFU Q0hfSUQsCisJVkNBUF9BRl9NQVRDSF9JRF9NQVNLLAorCVZDQVBfQUZfTUlQX1NFTCwKKwlWQ0FQ X0FGX01JUlJPUl9QUk9CRSwKKwlWQ0FQX0FGX01JUlJPUl9QUk9CRV9JRCwKKwlWQ0FQX0FGX01Q TFNfSVBfQ1RSTF9FTkEsCisJVkNBUF9BRl9NUExTX01FUF9FTkEsCisJVkNBUF9BRl9NUExTX01J UF9FTkEsCisJVkNBUF9BRl9NUExTX09BTV9GTEFWT1IsCisJVkNBUF9BRl9NUExTX09BTV9UWVBF LAorCVZDQVBfQUZfTlVNX1ZMRF9MQUJFTFMsCisJVkNBUF9BRl9OWFRfSURYLAorCVZDQVBfQUZf TlhUX0lEWF9DVFJMLAorCVZDQVBfQUZfTlhUX0tFWV9UWVBFLAorCVZDQVBfQUZfTlhUX05PUk1B TElaRSwKKwlWQ0FQX0FGX05YVF9OT1JNX1cxNl9PRkZTRVQsCisJVkNBUF9BRl9OWFRfTk9STV9X MzJfT0ZGU0VULAorCVZDQVBfQUZfTlhUX09GRlNFVF9GUk9NX1RZUEUsCisJVkNBUF9BRl9OWFRf VFlQRV9BRlRFUl9PRkZTRVQsCisJVkNBUF9BRl9PQU1fSVBfQkZEX0VOQSwKKwlWQ0FQX0FGX09B TV9UV0FNUF9FTkEsCisJVkNBUF9BRl9PQU1fWTE3MzFfU0VMLAorCVZDQVBfQUZfUEFHX09WRVJS SURFX01BU0ssCisJVkNBUF9BRl9QQUdfVkFMLAorCVZDQVBfQUZfUENQX0VOQSwKKwlWQ0FQX0FG X1BDUF9WQUwsCisJVkNBUF9BRl9QSVBFTElORV9BQ1RfU0VMLAorCVZDQVBfQUZfUElQRUxJTkVf Rk9SQ0VfRU5BLAorCVZDQVBfQUZfUElQRUxJTkVfUFQsCisJVkNBUF9BRl9QSVBFTElORV9QVF9S RURVQ0VELAorCVZDQVBfQUZfUE9MSUNFX0VOQSwKKwlWQ0FQX0FGX1BPTElDRV9JRFgsCisJVkNB UF9BRl9QT0xJQ0VfUkVNQVJLLAorCVZDQVBfQUZfUE9SVF9NQVNLLAorCVZDQVBfQUZfUFRQX01B U1RFUl9TRUwsCisJVkNBUF9BRl9RT1NfRU5BLAorCVZDQVBfQUZfUU9TX1ZBTCwKKwlWQ0FQX0FG X1JFV19DTUQsCisJVkNBUF9BRl9STEVHX0RNQUNfQ0hLX0RJUywKKwlWQ0FQX0FGX1JMRUdfU1RB VF9JRFgsCisJVkNBUF9BRl9SU0RYX0VOQSwKKwlWQ0FQX0FGX1JTRFhfVkFMLAorCVZDQVBfQUZf UlNWRF9MQkxfVkFMLAorCVZDQVBfQUZfUlRfRElTLAorCVZDQVBfQUZfUlRfU0VMLAorCVZDQVBf QUZfUzJfS0VZX1NFTF9FTkEsCisJVkNBUF9BRl9TMl9LRVlfU0VMX0lEWCwKKwlWQ0FQX0FGX1NB TV9TRVFfRU5BLAorCVZDQVBfQUZfU0lQX0lEWCwKKwlWQ0FQX0FGX1NXQVBfTUFDX0VOQSwKKwlW Q0FQX0FGX1RDUF9VRFBfRFBPUlQsCisJVkNBUF9BRl9UQ1BfVURQX0VOQSwKKwlWQ0FQX0FGX1RD UF9VRFBfU1BPUlQsCisJVkNBUF9BRl9UQ19FTkEsCisJVkNBUF9BRl9UQ19MQUJFTCwKKwlWQ0FQ X0FGX1RQSURfU0VMLAorCVZDQVBfQUZfVFRMX0RFQ1JfRElTLAorCVZDQVBfQUZfVFRMX0VOQSwK KwlWQ0FQX0FGX1RUTF9MQUJFTCwKKwlWQ0FQX0FGX1RUTF9VUERBVEVfRU5BLAorCVZDQVBfQUZf VFlQRSwKKwlWQ0FQX0FGX1ZJRF9WQUwsCisJVkNBUF9BRl9WTEFOX1BPUF9DTlQsCisJVkNBUF9B Rl9WTEFOX1BPUF9DTlRfRU5BLAorCVZDQVBfQUZfVkxBTl9QVVNIX0NOVCwKKwlWQ0FQX0FGX1ZM QU5fUFVTSF9DTlRfRU5BLAorCVZDQVBfQUZfVkxBTl9XQVNfVEFHR0VELAorfTsKKworI2VuZGlm IC8qIF9fVkNBUF9BR19BUElfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQv bWljcm9jaGlwL3ZjYXAvdmNhcF9hcGkuYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L21pY3JvY2hp cC92Y2FwL3ZjYXBfYXBpLmMKaW5kZXggMDYyOTBmZDI3Y2MxLi41YzNmNjg5ZDdkYTcgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L21pY3JvY2hpcC92Y2FwL3ZjYXBfYXBpLmMKKysr IGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWljcm9jaGlwL3ZjYXAvdmNhcF9hcGkuYwpAQCAtMTEz NiwzICsxMTM2LDcgQEAgaW50IHZjYXBfcnVsZV9hZGRfYWN0aW9uX3UzMihzdHJ1Y3QgdmNhcF9y dWxlICpydWxlLAogCXJldHVybiB2Y2FwX3J1bGVfYWRkX2FjdGlvbihydWxlLCBhY3Rpb24sIFZD QVBfRklFTERfVTMyLCAmZGF0YSk7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTCh2Y2FwX3J1bGVfYWRk X2FjdGlvbl91MzIpOworCisjaWZkZWYgQ09ORklHX1ZDQVBfS1VOSVRfVEVTVAorI2luY2x1ZGUg InZjYXBfYXBpX2t1bml0LmMiCisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVy bmV0L21pY3JvY2hpcC92Y2FwL3ZjYXBfYXBpLmggYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9taWNy b2NoaXAvdmNhcC92Y2FwX2FwaS5oCmluZGV4IDQ0NDRiZjY3ZWJlYy4uZWIyZWFlNzVjN2U4IDEw MDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9taWNyb2NoaXAvdmNhcC92Y2FwX2FwaS5o CisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L21pY3JvY2hpcC92Y2FwL3ZjYXBfYXBpLmgKQEAg LTExLDYgKzExLDkgQEAKICNpbmNsdWRlIDxsaW51eC9uZXRkZXZpY2UuaD4KIAogLyogVXNlIHRo ZSBnZW5lcmF0ZWQgQVBJIG1vZGVsICovCisjaWZkZWYgQ09ORklHX1ZDQVBfS1VOSVRfVEVTVAor I2luY2x1ZGUgInZjYXBfYWdfYXBpX2t1bml0LmgiCisjZW5kaWYKICNpbmNsdWRlICJ2Y2FwX2Fn X2FwaS5oIgogCiAjZGVmaW5lIFZDQVBfQ0lEX0xPT0tVUF9TSVpFICAgICAgICAgIDEwMDAwMCAv KiBDaGFpbnMgaW4gYSBsb29rdXAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0 L21pY3JvY2hpcC92Y2FwL3ZjYXBfYXBpX2t1bml0LmMgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9t aWNyb2NoaXAvdmNhcC92Y2FwX2FwaV9rdW5pdC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMC4uYjAxYTZlNTAzOWIwCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9u ZXQvZXRoZXJuZXQvbWljcm9jaGlwL3ZjYXAvdmNhcF9hcGlfa3VuaXQuYwpAQCAtMCwwICsxLDkz MyBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEJTRC0zLUNsYXVzZQorLyogQ29weXJp Z2h0IChDKSAyMDIyIE1pY3JvY2hpcCBUZWNobm9sb2d5IEluYy4gYW5kIGl0cyBzdWJzaWRpYXJp ZXMuCisgKiBNaWNyb2NoaXAgVkNBUCBBUEkga3VuaXQgdGVzdCBzdWl0ZQorICovCisKKyNpbmNs dWRlIDxrdW5pdC90ZXN0Lmg+CisjaW5jbHVkZSAidmNhcF9hcGkuaCIKKyNpbmNsdWRlICJ2Y2Fw X2FwaV9jbGllbnQuaCIKKyNpbmNsdWRlICJ2Y2FwX21vZGVsX2t1bml0LmgiCisKKy8qIEZpcnN0 IHdlIGhhdmUgdGhlIHRlc3QgaW5mcmFzdHJ1Y3R1cmUgdGhhdCBlbXVsYXRlcyB0aGUgcGxhdGZv cm0KKyAqIGltcGxlbWVudGF0aW9uCisgKi8KKyNkZWZpbmUgVEVTVF9CVUZfQ05UIDEwMAorI2Rl ZmluZSBURVNUX0JVRl9TWiAgMzUwCisjZGVmaW5lIFNUUkVBTVdTSVpFIDY0CisKK3N0YXRpYyB1 MzIgdGVzdF91cGRhdGVhZGRyW1NUUkVBTVdTSVpFXSA9IHt9Oworc3RhdGljIGludCB0ZXN0X3Vw ZGF0ZWFkZHJpZHg7CitzdGF0aWMgaW50IHRlc3RfY2FjaGVfZXJhc2VfY291bnQ7CitzdGF0aWMg dTMyIHRlc3RfaW5pdF9zdGFydDsKK3N0YXRpYyB1MzIgdGVzdF9pbml0X2NvdW50Oworc3RhdGlj IHUzMiB0ZXN0X2h3X2NvdW50ZXJfaWQ7CitzdGF0aWMgc3RydWN0IHZjYXBfY2FjaGVfZGF0YSB0 ZXN0X2h3X2NhY2hlOworCisvKiBDYWxsYmFjayB1c2VkIGJ5IHRoZSBWQ0FQIEFQSSAqLworc3Rh dGljIGVudW0gdmNhcF9rZXlmaWVsZF9zZXQgdGVzdF92YWxfa2V5c2V0KHN0cnVjdCBuZXRfZGV2 aWNlICpuZGV2LAorCQkJCQkgICAgICBzdHJ1Y3QgdmNhcF9hZG1pbiAqYWRtaW4sCisJCQkJCSAg ICAgIHN0cnVjdCB2Y2FwX3J1bGUgKnJ1bGUsCisJCQkJCSAgICAgIHN0cnVjdCB2Y2FwX2tleXNl dF9saXN0ICprc2xpc3QsCisJCQkJCSAgICAgIHUxNiBsM19wcm90bykKK3sKKwlpbnQgaWR4Owor CisJaWYgKGtzbGlzdC0+Y250ID4gMCkgeworCQlzd2l0Y2ggKGFkbWluLT52dHlwZSkgeworCQlj YXNlIFZDQVBfVFlQRV9JUzA6CisJCQlmb3IgKGlkeCA9IDA7IGlkeCA8IGtzbGlzdC0+Y250OyBp ZHgrKykgeworCQkJCWlmIChrc2xpc3QtPmtleXNldHNbaWR4XSA9PSBWQ0FQX0tGU19FVEFHKQor CQkJCQlyZXR1cm4ga3NsaXN0LT5rZXlzZXRzW2lkeF07CisJCQkJaWYgKGtzbGlzdC0+a2V5c2V0 c1tpZHhdID09IFZDQVBfS0ZTX1BVUkVfNVRVUExFX0lQNCkKKwkJCQkJcmV0dXJuIGtzbGlzdC0+ a2V5c2V0c1tpZHhdOworCQkJCWlmIChrc2xpc3QtPmtleXNldHNbaWR4XSA9PSBWQ0FQX0tGU19O T1JNQUxfNVRVUExFX0lQNCkKKwkJCQkJcmV0dXJuIGtzbGlzdC0+a2V5c2V0c1tpZHhdOworCQkJ CWlmIChrc2xpc3QtPmtleXNldHNbaWR4XSA9PSBWQ0FQX0tGU19OT1JNQUxfN1RVUExFKQorCQkJ CQlyZXR1cm4ga3NsaXN0LT5rZXlzZXRzW2lkeF07CisJCQl9CisJCQlicmVhazsKKwkJY2FzZSBW Q0FQX1RZUEVfSVMyOgorCQkJZm9yIChpZHggPSAwOyBpZHggPCBrc2xpc3QtPmNudDsgaWR4Kysp IHsKKwkJCQlpZiAoa3NsaXN0LT5rZXlzZXRzW2lkeF0gPT0gVkNBUF9LRlNfTUFDX0VUWVBFKQor CQkJCQlyZXR1cm4ga3NsaXN0LT5rZXlzZXRzW2lkeF07CisJCQkJaWYgKGtzbGlzdC0+a2V5c2V0 c1tpZHhdID09IFZDQVBfS0ZTX0FSUCkKKwkJCQkJcmV0dXJuIGtzbGlzdC0+a2V5c2V0c1tpZHhd OworCQkJCWlmIChrc2xpc3QtPmtleXNldHNbaWR4XSA9PSBWQ0FQX0tGU19JUF83VFVQTEUpCisJ CQkJCXJldHVybiBrc2xpc3QtPmtleXNldHNbaWR4XTsKKwkJCX0KKwkJCWJyZWFrOworCQlkZWZh dWx0OgorCQkJcHJfaW5mbygiJXM6JWQ6IG5vIHZhbGlkYXRpb24gZm9yIFZDQVAgJWRcbiIsCisJ CQkJX19mdW5jX18sIF9fTElORV9fLCBhZG1pbi0+dnR5cGUpOworCQkJYnJlYWs7CisJCX0KKwl9 CisJcmV0dXJuIC1FSU5WQUw7Cit9CisKKy8qIENhbGxiYWNrIHVzZWQgYnkgdGhlIFZDQVAgQVBJ ICovCitzdGF0aWMgdm9pZCB0ZXN0X2FkZF9kZWZfZmllbGRzKHN0cnVjdCBuZXRfZGV2aWNlICpu ZGV2LAorCQkJCXN0cnVjdCB2Y2FwX2FkbWluICphZG1pbiwKKwkJCQlzdHJ1Y3QgdmNhcF9ydWxl ICpydWxlKQoreworCWlmIChhZG1pbi0+dmluc3QgPT0gMCB8fCBhZG1pbi0+dmluc3QgPT0gMikK KwkJdmNhcF9ydWxlX2FkZF9rZXlfYml0KHJ1bGUsIFZDQVBfS0ZfTE9PS1VQX0ZJUlNUX0lTLCBW Q0FQX0JJVF8xKTsKKwllbHNlCisJCXZjYXBfcnVsZV9hZGRfa2V5X2JpdChydWxlLCBWQ0FQX0tG X0xPT0tVUF9GSVJTVF9JUywgVkNBUF9CSVRfMCk7Cit9CisKKy8qIENhbGxiYWNrIHVzZWQgYnkg dGhlIFZDQVAgQVBJICovCitzdGF0aWMgdm9pZCB0ZXN0X2NhY2hlX2VyYXNlKHN0cnVjdCB2Y2Fw X2FkbWluICphZG1pbikKK3sKKwlpZiAodGVzdF9jYWNoZV9lcmFzZV9jb3VudCkgeworCQltZW1z ZXQoYWRtaW4tPmNhY2hlLmtleXN0cmVhbSwgMCwgdGVzdF9jYWNoZV9lcmFzZV9jb3VudCk7CisJ CW1lbXNldChhZG1pbi0+Y2FjaGUubWFza3N0cmVhbSwgMCwgdGVzdF9jYWNoZV9lcmFzZV9jb3Vu dCk7CisJCW1lbXNldChhZG1pbi0+Y2FjaGUuYWN0aW9uc3RyZWFtLCAwLCB0ZXN0X2NhY2hlX2Vy YXNlX2NvdW50KTsKKwkJdGVzdF9jYWNoZV9lcmFzZV9jb3VudCA9IDA7CisJfQorfQorCisvKiBD YWxsYmFjayB1c2VkIGJ5IHRoZSBWQ0FQIEFQSSAqLworc3RhdGljIHZvaWQgdGVzdF9jYWNoZV9p bml0KHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2LCBzdHJ1Y3QgdmNhcF9hZG1pbiAqYWRtaW4sCisJ CQkgICAgdTMyIHN0YXJ0LCB1MzIgY291bnQpCit7CisJdGVzdF9pbml0X3N0YXJ0ID0gc3RhcnQ7 CisJdGVzdF9pbml0X2NvdW50ID0gY291bnQ7Cit9CisKKy8qIENhbGxiYWNrIHVzZWQgYnkgdGhl IFZDQVAgQVBJICovCitzdGF0aWMgdm9pZCB0ZXN0X2NhY2hlX3JlYWQoc3RydWN0IG5ldF9kZXZp Y2UgKm5kZXYsIHN0cnVjdCB2Y2FwX2FkbWluICphZG1pbiwKKwkJCSAgICBlbnVtIHZjYXBfc2Vs ZWN0aW9uIHNlbCwgdTMyIHN0YXJ0LCB1MzIgY291bnQpCit7CisJdTMyICprZXlzdHIsICptc2tz dHIsICphY3RzdHI7CisJaW50IGlkeDsKKworCXByX2RlYnVnKCIlczolZDogJWQgJWRcbiIsIF9f ZnVuY19fLCBfX0xJTkVfXywgc3RhcnQsIGNvdW50KTsKKwlzd2l0Y2ggKHNlbCkgeworCWNhc2Ug VkNBUF9TRUxfRU5UUlk6CisJCWtleXN0ciA9ICZhZG1pbi0+Y2FjaGUua2V5c3RyZWFtW3N0YXJ0 XTsKKwkJbXNrc3RyID0gJmFkbWluLT5jYWNoZS5tYXNrc3RyZWFtW3N0YXJ0XTsKKwkJZm9yIChp ZHggPSAwOyBpZHggPCBjb3VudDsgKytpZHgpIHsKKwkJCXByX2RlYnVnKCIlczolZDoga2V5ZGF0 YVslMDJkXTogMHglMDh4XG4iLCBfX2Z1bmNfXywKKwkJCQkgX19MSU5FX18sIHN0YXJ0ICsgaWR4 LCBrZXlzdHJbaWR4XSk7CisJCX0KKwkJZm9yIChpZHggPSAwOyBpZHggPCBjb3VudDsgKytpZHgp IHsKKwkJCS8qIEludmVydCB0aGUgbWFzayBiZWZvcmUgZGVjb2Rpbmcgc3RhcnRzICovCisJCQlt c2tzdHJbaWR4XSA9IH5tc2tzdHJbaWR4XTsKKwkJCXByX2RlYnVnKCIlczolZDogbXNrZGF0YVsl MDJkXTogMHglMDh4XG4iLCBfX2Z1bmNfXywKKwkJCQkgX19MSU5FX18sIHN0YXJ0ICsgaWR4LCBt c2tzdHJbaWR4XSk7CisJCX0KKwkJYnJlYWs7CisJY2FzZSBWQ0FQX1NFTF9BQ1RJT046CisJCWFj dHN0ciA9ICZhZG1pbi0+Y2FjaGUuYWN0aW9uc3RyZWFtW3N0YXJ0XTsKKwkJZm9yIChpZHggPSAw OyBpZHggPCBjb3VudDsgKytpZHgpIHsKKwkJCXByX2RlYnVnKCIlczolZDogYWN0ZGF0YVslMDJk XTogMHglMDh4XG4iLCBfX2Z1bmNfXywKKwkJCQkgX19MSU5FX18sIHN0YXJ0ICsgaWR4LCBhY3Rz dHJbaWR4XSk7CisJCX0KKwkJYnJlYWs7CisJY2FzZSBWQ0FQX1NFTF9DT1VOVEVSOgorCQlwcl9k ZWJ1ZygiJXM6JWRcbiIsIF9fZnVuY19fLCBfX0xJTkVfXyk7CisJCXRlc3RfaHdfY291bnRlcl9p ZCA9IHN0YXJ0OworCQlhZG1pbi0+Y2FjaGUuY291bnRlciA9IHRlc3RfaHdfY2FjaGUuY291bnRl cjsKKwkJYWRtaW4tPmNhY2hlLnN0aWNreSA9IHRlc3RfaHdfY2FjaGUuc3RpY2t5OworCQlicmVh azsKKwljYXNlIFZDQVBfU0VMX0FMTDoKKwkJcHJfZGVidWcoIiVzOiVkXG4iLCBfX2Z1bmNfXywg X19MSU5FX18pOworCQlicmVhazsKKwl9Cit9CisKKy8qIENhbGxiYWNrIHVzZWQgYnkgdGhlIFZD QVAgQVBJICovCitzdGF0aWMgdm9pZCB0ZXN0X2NhY2hlX3dyaXRlKHN0cnVjdCBuZXRfZGV2aWNl ICpuZGV2LCBzdHJ1Y3QgdmNhcF9hZG1pbiAqYWRtaW4sCisJCQkgICAgIGVudW0gdmNhcF9zZWxl Y3Rpb24gc2VsLCB1MzIgc3RhcnQsIHUzMiBjb3VudCkKK3sKKwl1MzIgKmtleXN0ciwgKm1za3N0 ciwgKmFjdHN0cjsKKwlpbnQgaWR4OworCisJc3dpdGNoIChzZWwpIHsKKwljYXNlIFZDQVBfU0VM X0VOVFJZOgorCQlrZXlzdHIgPSAmYWRtaW4tPmNhY2hlLmtleXN0cmVhbVtzdGFydF07CisJCW1z a3N0ciA9ICZhZG1pbi0+Y2FjaGUubWFza3N0cmVhbVtzdGFydF07CisJCWZvciAoaWR4ID0gMDsg aWR4IDwgY291bnQ7ICsraWR4KSB7CisJCQlwcl9kZWJ1ZygiJXM6JWQ6IGtleWRhdGFbJTAyZF06 IDB4JTA4eFxuIiwgX19mdW5jX18sCisJCQkJIF9fTElORV9fLCBzdGFydCArIGlkeCwga2V5c3Ry W2lkeF0pOworCQl9CisJCWZvciAoaWR4ID0gMDsgaWR4IDwgY291bnQ7ICsraWR4KSB7CisJCQkv KiBJbnZlcnQgdGhlIG1hc2sgYmVmb3JlIGVuY29kaW5nIHN0YXJ0cyAqLworCQkJbXNrc3RyW2lk eF0gPSB+bXNrc3RyW2lkeF07CisJCQlwcl9kZWJ1ZygiJXM6JWQ6IG1za2RhdGFbJTAyZF06IDB4 JTA4eFxuIiwgX19mdW5jX18sCisJCQkJIF9fTElORV9fLCBzdGFydCArIGlkeCwgbXNrc3RyW2lk eF0pOworCQl9CisJCWJyZWFrOworCWNhc2UgVkNBUF9TRUxfQUNUSU9OOgorCQlhY3RzdHIgPSAm YWRtaW4tPmNhY2hlLmFjdGlvbnN0cmVhbVtzdGFydF07CisJCWZvciAoaWR4ID0gMDsgaWR4IDwg Y291bnQ7ICsraWR4KSB7CisJCQlwcl9kZWJ1ZygiJXM6JWQ6IGFjdGRhdGFbJTAyZF06IDB4JTA4 eFxuIiwgX19mdW5jX18sCisJCQkJIF9fTElORV9fLCBzdGFydCArIGlkeCwgYWN0c3RyW2lkeF0p OworCQl9CisJCWJyZWFrOworCWNhc2UgVkNBUF9TRUxfQ09VTlRFUjoKKwkJcHJfZGVidWcoIiVz OiVkXG4iLCBfX2Z1bmNfXywgX19MSU5FX18pOworCQl0ZXN0X2h3X2NvdW50ZXJfaWQgPSBzdGFy dDsKKwkJdGVzdF9od19jYWNoZS5jb3VudGVyID0gYWRtaW4tPmNhY2hlLmNvdW50ZXI7CisJCXRl c3RfaHdfY2FjaGUuc3RpY2t5ID0gYWRtaW4tPmNhY2hlLnN0aWNreTsKKwkJYnJlYWs7CisJY2Fz ZSBWQ0FQX1NFTF9BTEw6CisJCXByX2VycigiJXM6JWQ6IGNhbm5vdCB3cml0ZSBhbGwgc3RyZWFt cyBhdCBvbmNlXG4iLAorCQkgICAgICAgX19mdW5jX18sIF9fTElORV9fKTsKKwkJYnJlYWs7CisJ fQorfQorCisvKiBDYWxsYmFjayB1c2VkIGJ5IHRoZSBWQ0FQIEFQSSAqLworc3RhdGljIHZvaWQg dGVzdF9jYWNoZV91cGRhdGUoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIHN0cnVjdCB2Y2FwX2Fk bWluICphZG1pbiwKKwkJCSAgICAgIGVudW0gdmNhcF9jb21tYW5kIGNtZCwKKwkJCSAgICAgIGVu dW0gdmNhcF9zZWxlY3Rpb24gc2VsLCB1MzIgYWRkcikKK3sKKwlpZiAodGVzdF91cGRhdGVhZGRy aWR4IDwgQVJSQVlfU0laRSh0ZXN0X3VwZGF0ZWFkZHIpKQorCQl0ZXN0X3VwZGF0ZWFkZHJbdGVz dF91cGRhdGVhZGRyaWR4XSA9IGFkZHI7CisJZWxzZQorCQlwcl9lcnIoIiVzOiVkOiBvdmVyZmxv dzogJWRcbiIsIF9fZnVuY19fLCBfX0xJTkVfXywgdGVzdF91cGRhdGVhZGRyaWR4KTsKKwl0ZXN0 X3VwZGF0ZWFkZHJpZHgrKzsKK30KKworc3RhdGljIHZvaWQgdGVzdF9jYWNoZV9tb3ZlKHN0cnVj dCBuZXRfZGV2aWNlICpuZGV2LCBzdHJ1Y3QgdmNhcF9hZG1pbiAqYWRtaW4sCisJCQkgICAgdTMy IGFkZHIsIGludCBvZmZzZXQsIGludCBjb3VudCkKK3sKK30KKworLyogUHJvdmlkZSBwb3J0IGlu Zm9ybWF0aW9uIHZpYSBhIGNhbGxiYWNrIGludGVyZmFjZSAqLworc3RhdGljIGludCB2Y2FwX3Rl c3RfcG9ydF9pbmZvKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2LCBlbnVtIHZjYXBfdHlwZSB2dHlw ZSwKKwkJCSAgICAgICBpbnQgKCpwZikodm9pZCAqb3V0LCBpbnQgYXJnLCBjb25zdCBjaGFyICpm bXQsIC4uLiksCisJCQkgICAgICAgdm9pZCAqb3V0LCBpbnQgYXJnKQoreworCXJldHVybiAwOwor fQorCitzdHJ1Y3QgdmNhcF9vcGVyYXRpb25zIHRlc3RfY2FsbGJhY2tzID0geworCS52YWxpZGF0 ZV9rZXlzZXQgPSB0ZXN0X3ZhbF9rZXlzZXQsCisJLmFkZF9kZWZhdWx0X2ZpZWxkcyA9IHRlc3Rf YWRkX2RlZl9maWVsZHMsCisJLmNhY2hlX2VyYXNlID0gdGVzdF9jYWNoZV9lcmFzZSwKKwkuY2Fj aGVfd3JpdGUgPSB0ZXN0X2NhY2hlX3dyaXRlLAorCS5jYWNoZV9yZWFkID0gdGVzdF9jYWNoZV9y ZWFkLAorCS5pbml0ID0gdGVzdF9jYWNoZV9pbml0LAorCS51cGRhdGUgPSB0ZXN0X2NhY2hlX3Vw ZGF0ZSwKKwkubW92ZSA9IHRlc3RfY2FjaGVfbW92ZSwKKwkucG9ydF9pbmZvID0gdmNhcF90ZXN0 X3BvcnRfaW5mbywKK307CisKK3N0cnVjdCB2Y2FwX2NvbnRyb2wgdGVzdF92Y3RybCA9IHsKKwku dmNhcHMgPSBrdW5pdF90ZXN0X3ZjYXBzLAorCS5zdGF0cyA9ICZrdW5pdF90ZXN0X3ZjYXBfc3Rh dHMsCisJLm9wcyA9ICZ0ZXN0X2NhbGxiYWNrcywKK307CisKK3N0YXRpYyB2b2lkIHZjYXBfdGVz dF9hcGlfaW5pdChzdHJ1Y3QgdmNhcF9hZG1pbiAqYWRtaW4pCit7CisJLyogSW5pdGlhbGl6ZSB0 aGUgc2hhcmVkIG9iamVjdHMgKi8KKwlJTklUX0xJU1RfSEVBRCgmdGVzdF92Y3RybC5saXN0KTsK KwlJTklUX0xJU1RfSEVBRCgmYWRtaW4tPmxpc3QpOworCUlOSVRfTElTVF9IRUFEKCZhZG1pbi0+ cnVsZXMpOworCWxpc3RfYWRkX3RhaWwoJmFkbWluLT5saXN0LCAmdGVzdF92Y3RybC5saXN0KTsK KwltZW1zZXQodGVzdF91cGRhdGVhZGRyLCAwLCBzaXplb2YodGVzdF91cGRhdGVhZGRyKSk7CisJ dGVzdF91cGRhdGVhZGRyaWR4ID0gMDsKK30KKworLyogRGVmaW5lIHRoZSB0ZXN0IGNhc2VzLiAq LworCitzdGF0aWMgdm9pZCB2Y2FwX2FwaV9zZXRfYml0XzFfdGVzdChzdHJ1Y3Qga3VuaXQgKnRl c3QpCit7CisJc3RydWN0IHZjYXBfc3RyZWFtX2l0ZXIgaXRlciA9IHsKKwkJLm9mZnNldCA9IDM1 LAorCQkuc3dfd2lkdGggPSA1MiwKKwkJLnJlZ19pZHggPSAxLAorCQkucmVnX2JpdHBvcyA9IDIw LAorCQkudGcgPSAwCisJfTsKKwl1MzIgc3RyZWFtWzJdID0gezB9OworCisJdmNhcF9zZXRfYml0 KHN0cmVhbSwgJml0ZXIsIDEpOworCisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgwLCBz dHJlYW1bMF0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKUJJVCgyMCksIHN0cmVhbVsx XSk7Cit9CisKK3N0YXRpYyB2b2lkIHZjYXBfYXBpX3NldF9iaXRfMF90ZXN0KHN0cnVjdCBrdW5p dCAqdGVzdCkKK3sKKwlzdHJ1Y3QgdmNhcF9zdHJlYW1faXRlciBpdGVyID0geworCQkub2Zmc2V0 ID0gMzUsCisJCS5zd193aWR0aCA9IDUyLAorCQkucmVnX2lkeCA9IDIsCisJCS5yZWdfYml0cG9z ID0gMTEsCisJCS50ZyA9IDAKKwl9OworCXUzMiBzdHJlYW1bM10gPSB7fjAsIH4wLCB+MH07CisK Kwl2Y2FwX3NldF9iaXQoc3RyZWFtLCAmaXRlciwgMCk7CisKKwlLVU5JVF9FWFBFQ1RfRVEodGVz dCwgKHUzMil+MCwgc3RyZWFtWzBdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMil+MCwg c3RyZWFtWzFdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMil+QklUKDExKSwgc3RyZWFt WzJdKTsKK30KKworc3RhdGljIHZvaWQgdmNhcF9hcGlfaXRlcmF0b3JfaW5pdF90ZXN0KHN0cnVj dCBrdW5pdCAqdGVzdCkKK3sKKwlzdHJ1Y3QgdmNhcF9zdHJlYW1faXRlciBpdGVyOworCXN0cnVj dCB2Y2FwX3R5cGVncm91cCB0eXBlZ3JvdXBzW10gPSB7CisJCXsgLm9mZnNldCA9IDAsIC53aWR0 aCA9IDIsIC52YWx1ZSA9IDIsIH0sCisJCXsgLm9mZnNldCA9IDE1NiwgLndpZHRoID0gMSwgLnZh bHVlID0gMCwgfSwKKwkJeyAub2Zmc2V0ID0gMCwgLndpZHRoID0gMCwgLnZhbHVlID0gMCwgfSwK Kwl9OworCXN0cnVjdCB2Y2FwX3R5cGVncm91cCB0eXBlZ3JvdXBzMltdID0geworCQl7IC5vZmZz ZXQgPSAwLCAud2lkdGggPSAzLCAudmFsdWUgPSA0LCB9LAorCQl7IC5vZmZzZXQgPSA0OSwgLndp ZHRoID0gMiwgLnZhbHVlID0gMCwgfSwKKwkJeyAub2Zmc2V0ID0gOTgsIC53aWR0aCA9IDIsIC52 YWx1ZSA9IDAsIH0sCisJfTsKKworCXZjYXBfaXRlcl9pbml0KCZpdGVyLCA1MiwgdHlwZWdyb3Vw cywgODYpOworCisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsIDUyLCBpdGVyLnN3X3dpZHRoKTsKKwlL VU5JVF9FWFBFQ1RfRVEodGVzdCwgODYgKyAyLCBpdGVyLm9mZnNldCk7CisJS1VOSVRfRVhQRUNU X0VRKHRlc3QsIDMsIGl0ZXIucmVnX2lkeCk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsIDQsIGl0 ZXIucmVnX2JpdHBvcyk7CisKKwl2Y2FwX2l0ZXJfaW5pdCgmaXRlciwgNDksIHR5cGVncm91cHMy LCAxMzQpOworCisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsIDQ5LCBpdGVyLnN3X3dpZHRoKTsKKwlL VU5JVF9FWFBFQ1RfRVEodGVzdCwgMTM0ICsgNywgaXRlci5vZmZzZXQpOworCUtVTklUX0VYUEVD VF9FUSh0ZXN0LCA1LCBpdGVyLnJlZ19pZHgpOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAxMSwg aXRlci5yZWdfYml0cG9zKTsKK30KKworc3RhdGljIHZvaWQgdmNhcF9hcGlfaXRlcmF0b3JfbmV4 dF90ZXN0KHN0cnVjdCBrdW5pdCAqdGVzdCkKK3sKKwlzdHJ1Y3QgdmNhcF9zdHJlYW1faXRlciBp dGVyOworCXN0cnVjdCB2Y2FwX3R5cGVncm91cCB0eXBlZ3JvdXBzW10gPSB7CisJCXsgLm9mZnNl dCA9IDAsIC53aWR0aCA9IDQsIC52YWx1ZSA9IDgsIH0sCisJCXsgLm9mZnNldCA9IDQ5LCAud2lk dGggPSAxLCAudmFsdWUgPSAwLCB9LAorCQl7IC5vZmZzZXQgPSA5OCwgLndpZHRoID0gMiwgLnZh bHVlID0gMCwgfSwKKwkJeyAub2Zmc2V0ID0gMTQ3LCAud2lkdGggPSAzLCAudmFsdWUgPSAwLCB9 LAorCQl7IC5vZmZzZXQgPSAxOTYsIC53aWR0aCA9IDIsIC52YWx1ZSA9IDAsIH0sCisJCXsgLm9m ZnNldCA9IDI0NSwgLndpZHRoID0gMSwgLnZhbHVlID0gMCwgfSwKKwl9OworCWludCBpZHg7CisK Kwl2Y2FwX2l0ZXJfaW5pdCgmaXRlciwgNDksIHR5cGVncm91cHMsIDg2KTsKKworCUtVTklUX0VY UEVDVF9FUSh0ZXN0LCA0OSwgaXRlci5zd193aWR0aCk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3Qs IDg2ICsgNSwgaXRlci5vZmZzZXQpOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAzLCBpdGVyLnJl Z19pZHgpOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAxMCwgaXRlci5yZWdfYml0cG9zKTsKKwor CXZjYXBfaXRlcl9uZXh0KCZpdGVyKTsKKworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCA5MSArIDEs IGl0ZXIub2Zmc2V0KTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgMywgaXRlci5yZWdfaWR4KTsK KwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgMTEsIGl0ZXIucmVnX2JpdHBvcyk7CisKKwlmb3IgKGlk eCA9IDA7IGlkeCA8IDY7IGlkeCsrKQorCQl2Y2FwX2l0ZXJfbmV4dCgmaXRlcik7CisKKwlLVU5J VF9FWFBFQ1RfRVEodGVzdCwgOTIgKyA2ICsgMiwgaXRlci5vZmZzZXQpOworCUtVTklUX0VYUEVD VF9FUSh0ZXN0LCA0LCBpdGVyLnJlZ19pZHgpOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAyLCBp dGVyLnJlZ19iaXRwb3MpOworfQorCitzdGF0aWMgdm9pZCB2Y2FwX2FwaV9lbmNvZGVfdHlwZWdy b3Vwc190ZXN0KHN0cnVjdCBrdW5pdCAqdGVzdCkKK3sKKwl1MzIgc3RyZWFtWzEyXSA9IHswfTsK KwlzdHJ1Y3QgdmNhcF90eXBlZ3JvdXAgdHlwZWdyb3Vwc1tdID0geworCQl7IC5vZmZzZXQgPSAw LCAud2lkdGggPSA0LCAudmFsdWUgPSA4LCB9LAorCQl7IC5vZmZzZXQgPSA0OSwgLndpZHRoID0g MSwgLnZhbHVlID0gMSwgfSwKKwkJeyAub2Zmc2V0ID0gOTgsIC53aWR0aCA9IDIsIC52YWx1ZSA9 IDMsIH0sCisJCXsgLm9mZnNldCA9IDE0NywgLndpZHRoID0gMywgLnZhbHVlID0gNSwgfSwKKwkJ eyAub2Zmc2V0ID0gMTk2LCAud2lkdGggPSAyLCAudmFsdWUgPSAyLCB9LAorCQl7IC5vZmZzZXQg PSAyNDUsIC53aWR0aCA9IDUsIC52YWx1ZSA9IDI3LCB9LAorCQl7IC5vZmZzZXQgPSAwLCAud2lk dGggPSAwLCAudmFsdWUgPSAwLCB9LAorCX07CisKKwl2Y2FwX2VuY29kZV90eXBlZ3JvdXBzKHN0 cmVhbSwgNDksIHR5cGVncm91cHMsIGZhbHNlKTsKKworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAo dTMyKTB4OCwgc3RyZWFtWzBdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAsIHN0 cmVhbVsxXSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgxLCBzdHJlYW1bMl0pOwor CUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4MCwgc3RyZWFtWzNdKTsKKwlLVU5JVF9FWFBF Q1RfRVEodGVzdCwgKHUzMikweDMsIHN0cmVhbVs0XSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3Qs ICh1MzIpMHgwLCBzdHJlYW1bNV0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4NSwg c3RyZWFtWzZdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAsIHN0cmVhbVs3XSk7 CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgyLCBzdHJlYW1bOF0pOworCUtVTklUX0VY UEVDVF9FUSh0ZXN0LCAodTMyKTB4MCwgc3RyZWFtWzldKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVz dCwgKHUzMikyNywgc3RyZWFtWzEwXSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgw LCBzdHJlYW1bMTFdKTsKK30KKworc3RhdGljIHZvaWQgdmNhcF9hcGlfZW5jb2RlX2JpdF90ZXN0 KHN0cnVjdCBrdW5pdCAqdGVzdCkKK3sKKwlzdHJ1Y3QgdmNhcF9zdHJlYW1faXRlciBpdGVyOwor CXUzMiBzdHJlYW1bNF0gPSB7MH07CisJc3RydWN0IHZjYXBfdHlwZWdyb3VwIHR5cGVncm91cHNb XSA9IHsKKwkJeyAub2Zmc2V0ID0gMCwgLndpZHRoID0gNCwgLnZhbHVlID0gOCwgfSwKKwkJeyAu b2Zmc2V0ID0gNDksIC53aWR0aCA9IDEsIC52YWx1ZSA9IDEsIH0sCisJCXsgLm9mZnNldCA9IDk4 LCAud2lkdGggPSAyLCAudmFsdWUgPSAzLCB9LAorCQl7IC5vZmZzZXQgPSAxNDcsIC53aWR0aCA9 IDMsIC52YWx1ZSA9IDUsIH0sCisJCXsgLm9mZnNldCA9IDE5NiwgLndpZHRoID0gMiwgLnZhbHVl ID0gMiwgfSwKKwkJeyAub2Zmc2V0ID0gMjQ1LCAud2lkdGggPSAxLCAudmFsdWUgPSAwLCB9LAor CX07CisKKwl2Y2FwX2l0ZXJfaW5pdCgmaXRlciwgNDksIHR5cGVncm91cHMsIDQ0KTsKKworCUtV TklUX0VYUEVDVF9FUSh0ZXN0LCA0OCwgaXRlci5vZmZzZXQpOworCUtVTklUX0VYUEVDVF9FUSh0 ZXN0LCAxLCBpdGVyLnJlZ19pZHgpOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAxNiwgaXRlci5y ZWdfYml0cG9zKTsKKworCXZjYXBfZW5jb2RlX2JpdChzdHJlYW0sICZpdGVyLCAxKTsKKworCUtV TklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4MCwgc3RyZWFtWzBdKTsKKwlLVU5JVF9FWFBFQ1Rf RVEodGVzdCwgKHUzMilCSVQoMTYpLCBzdHJlYW1bMV0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0 LCAodTMyKTB4MCwgc3RyZWFtWzJdKTsKK30KKworc3RhdGljIHZvaWQgdmNhcF9hcGlfZW5jb2Rl X2ZpZWxkX3Rlc3Qoc3RydWN0IGt1bml0ICp0ZXN0KQoreworCXN0cnVjdCB2Y2FwX3N0cmVhbV9p dGVyIGl0ZXI7CisJdTMyIHN0cmVhbVsxNl0gPSB7MH07CisJc3RydWN0IHZjYXBfdHlwZWdyb3Vw IHR5cGVncm91cHNbXSA9IHsKKwkJeyAub2Zmc2V0ID0gMCwgLndpZHRoID0gNCwgLnZhbHVlID0g OCwgfSwKKwkJeyAub2Zmc2V0ID0gNDksIC53aWR0aCA9IDEsIC52YWx1ZSA9IDEsIH0sCisJCXsg Lm9mZnNldCA9IDk4LCAud2lkdGggPSAyLCAudmFsdWUgPSAzLCB9LAorCQl7IC5vZmZzZXQgPSAx NDcsIC53aWR0aCA9IDMsIC52YWx1ZSA9IDUsIH0sCisJCXsgLm9mZnNldCA9IDE5NiwgLndpZHRo ID0gMiwgLnZhbHVlID0gMiwgfSwKKwkJeyAub2Zmc2V0ID0gMjQ1LCAud2lkdGggPSA1LCAudmFs dWUgPSAyNywgfSwKKwkJeyAub2Zmc2V0ID0gMCwgLndpZHRoID0gMCwgLnZhbHVlID0gMCwgfSwK Kwl9OworCXN0cnVjdCB2Y2FwX2ZpZWxkIHJmID0geworCQkudHlwZSA9IFZDQVBfRklFTERfVTMy LAorCQkub2Zmc2V0ID0gODYsCisJCS53aWR0aCA9IDQsCisJfTsKKwl1OCB2YWx1ZVtdID0gezB4 NX07CisKKwl2Y2FwX2l0ZXJfaW5pdCgmaXRlciwgNDksIHR5cGVncm91cHMsIHJmLm9mZnNldCk7 CisKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgOTEsIGl0ZXIub2Zmc2V0KTsKKwlLVU5JVF9FWFBF Q1RfRVEodGVzdCwgMywgaXRlci5yZWdfaWR4KTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgMTAs IGl0ZXIucmVnX2JpdHBvcyk7CisKKwl2Y2FwX2VuY29kZV9maWVsZChzdHJlYW0sICZpdGVyLCBy Zi53aWR0aCwgdmFsdWUpOworCisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgwLCBzdHJl YW1bMF0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4MCwgc3RyZWFtWzFdKTsKKwlL VU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAsIHN0cmVhbVsyXSk7CisJS1VOSVRfRVhQRUNU X0VRKHRlc3QsICh1MzIpKDB4NSA8PCAxMCksIHN0cmVhbVszXSk7CisJS1VOSVRfRVhQRUNUX0VR KHRlc3QsICh1MzIpMHgwLCBzdHJlYW1bNF0pOworCisJdmNhcF9lbmNvZGVfdHlwZWdyb3Vwcyhz dHJlYW0sIDQ5LCB0eXBlZ3JvdXBzLCBmYWxzZSk7CisKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwg KHUzMikweDgsIHN0cmVhbVswXSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgwLCBz dHJlYW1bMV0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4MSwgc3RyZWFtWzJdKTsK KwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikoMHg1IDw8IDEwKSwgc3RyZWFtWzNdKTsKKwlL VU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDMsIHN0cmVhbVs0XSk7CisJS1VOSVRfRVhQRUNU X0VRKHRlc3QsICh1MzIpMHgwLCBzdHJlYW1bNV0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAo dTMyKTB4NSwgc3RyZWFtWzZdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAsIHN0 cmVhbVs3XSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgyLCBzdHJlYW1bOF0pOwor CUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4MCwgc3RyZWFtWzldKTsKKwlLVU5JVF9FWFBF Q1RfRVEodGVzdCwgKHUzMikyNywgc3RyZWFtWzEwXSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3Qs ICh1MzIpMHgwLCBzdHJlYW1bMTFdKTsKK30KKworLyogSW4gdGhpcyB0ZXN0Y2FzZSB0aGUgc3Vi d29yZCBpcyBzbWFsbGVyIHRoYW4gYSByZWdpc3RlciAqLworc3RhdGljIHZvaWQgdmNhcF9hcGlf ZW5jb2RlX3Nob3J0X2ZpZWxkX3Rlc3Qoc3RydWN0IGt1bml0ICp0ZXN0KQoreworCXN0cnVjdCB2 Y2FwX3N0cmVhbV9pdGVyIGl0ZXI7CisJaW50IHN3X3dpZHRoID0gMjE7CisJdTMyIHN0cmVhbVs2 XSA9IHswfTsKKwlzdHJ1Y3QgdmNhcF90eXBlZ3JvdXAgdGd0W10gPSB7CisJCXsgLm9mZnNldCA9 IDAsIC53aWR0aCA9IDMsIC52YWx1ZSA9IDcsIH0sCisJCXsgLm9mZnNldCA9IDIxLCAud2lkdGgg PSAyLCAudmFsdWUgPSAzLCB9LAorCQl7IC5vZmZzZXQgPSA0MiwgLndpZHRoID0gMSwgLnZhbHVl ID0gMSwgfSwKKwkJeyAub2Zmc2V0ID0gMCwgLndpZHRoID0gMCwgLnZhbHVlID0gMCwgfSwKKwl9 OworCXN0cnVjdCB2Y2FwX2ZpZWxkIHJmID0geworCQkudHlwZSA9IFZDQVBfRklFTERfVTMyLAor CQkub2Zmc2V0ID0gMjUsCisJCS53aWR0aCA9IDQsCisJfTsKKwl1OCB2YWx1ZVtdID0gezB4NX07 CisKKwl2Y2FwX2l0ZXJfaW5pdCgmaXRlciwgc3dfd2lkdGgsIHRndCwgcmYub2Zmc2V0KTsKKwor CUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAxLCBpdGVyLnJlZ3NfcGVyX3N3KTsKKwlLVU5JVF9FWFBF Q1RfRVEodGVzdCwgMjEsIGl0ZXIuc3dfd2lkdGgpOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAy NSArIDMgKyAyLCBpdGVyLm9mZnNldCk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsIDEsIGl0ZXIu cmVnX2lkeCk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsIDI1ICsgMyArIDIgLSBzd193aWR0aCwg aXRlci5yZWdfYml0cG9zKTsKKworCXZjYXBfZW5jb2RlX2ZpZWxkKHN0cmVhbSwgJml0ZXIsIHJm LndpZHRoLCB2YWx1ZSk7CisKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAsIHN0cmVh bVswXSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpKDB4NSA8PCAoMjUgKyAzICsgMiAt IHN3X3dpZHRoKSksIHN0cmVhbVsxXSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgw LCBzdHJlYW1bMl0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4MCwgc3RyZWFtWzNd KTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAsIHN0cmVhbVs0XSk7CisJS1VOSVRf RVhQRUNUX0VRKHRlc3QsICh1MzIpMHgwLCBzdHJlYW1bNV0pOworCisJdmNhcF9lbmNvZGVfdHlw ZWdyb3VwcyhzdHJlYW0sIHN3X3dpZHRoLCB0Z3QsIGZhbHNlKTsKKworCUtVTklUX0VYUEVDVF9F USh0ZXN0LCAodTMyKTcsIHN0cmVhbVswXSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIp KCgweDUgPDwgKDI1ICsgMyArIDIgLSBzd193aWR0aCkpICsgMyksIHN0cmVhbVsxXSk7CisJS1VO SVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMSwgc3RyZWFtWzJdKTsKKwlLVU5JVF9FWFBFQ1RfRVEo dGVzdCwgKHUzMikwLCBzdHJlYW1bM10pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTAs IHN0cmVhbVs0XSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMCwgc3RyZWFtWzVdKTsK K30KKworc3RhdGljIHZvaWQgdmNhcF9hcGlfZW5jb2RlX2tleWZpZWxkX3Rlc3Qoc3RydWN0IGt1 bml0ICp0ZXN0KQoreworCXUzMiBrZXl3b3Jkc1sxNl0gPSB7MH07CisJdTMyIG1hc2t3b3Jkc1sx Nl0gPSB7MH07CisJc3RydWN0IHZjYXBfYWRtaW4gYWRtaW4gPSB7CisJCS52dHlwZSA9IFZDQVBf VFlQRV9JUzIsCisJCS5jYWNoZSA9IHsKKwkJCS5rZXlzdHJlYW0gPSBrZXl3b3JkcywKKwkJCS5t YXNrc3RyZWFtID0gbWFza3dvcmRzLAorCQkJLmFjdGlvbnN0cmVhbSA9IGtleXdvcmRzLAorCQl9 LAorCX07CisJc3RydWN0IHZjYXBfcnVsZV9pbnRlcm5hbCBydWxlID0geworCQkuYWRtaW4gPSAm YWRtaW4sCisJCS5kYXRhID0geworCQkJLmtleXNldCA9IFZDQVBfS0ZTX01BQ19FVFlQRSwKKwkJ fSwKKwkJLnZjdHJsID0gJnRlc3RfdmN0cmwsCisJfTsKKwlzdHJ1Y3QgdmNhcF9jbGllbnRfa2V5 ZmllbGQgY2tmID0geworCQkuY3RybC5saXN0ID0ge30sCisJCS5jdHJsLmtleSA9IFZDQVBfS0Zf SVNEWF9DTFMsCisJCS5jdHJsLnR5cGUgPSBWQ0FQX0ZJRUxEX1UzMiwKKwkJLmRhdGEudTMyLnZh bHVlID0gMHhlZWYwMTRhMSwKKwkJLmRhdGEudTMyLm1hc2sgPSAweGZmZiwKKwl9OworCXN0cnVj dCB2Y2FwX2ZpZWxkIHJmID0geworCQkudHlwZSA9IFZDQVBfRklFTERfVTMyLAorCQkub2Zmc2V0 ID0gNTYsCisJCS53aWR0aCA9IDEyLAorCX07CisJc3RydWN0IHZjYXBfdHlwZWdyb3VwIHRndFtd ID0geworCQl7IC5vZmZzZXQgPSAwLCAud2lkdGggPSAyLCAudmFsdWUgPSAyLCB9LAorCQl7IC5v ZmZzZXQgPSAxNTYsIC53aWR0aCA9IDEsIC52YWx1ZSA9IDEsIH0sCisJCXsgLm9mZnNldCA9IDAs IC53aWR0aCA9IDAsIC52YWx1ZSA9IDAsIH0sCisJfTsKKworCXZjYXBfdGVzdF9hcGlfaW5pdCgm YWRtaW4pOworCXZjYXBfZW5jb2RlX2tleWZpZWxkKCZydWxlLCAmY2tmLCAmcmYsIHRndCk7CisK KwkvKiBLZXkgKi8KKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAsIGtleXdvcmRzWzBd KTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAsIGtleXdvcmRzWzFdKTsKKwlLVU5J VF9FWFBFQ1RfRVEodGVzdCwgKHUzMikoMHgwNGExIDw8IDYpLCBrZXl3b3Jkc1syXSk7CisJS1VO SVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgwLCBrZXl3b3Jkc1szXSk7CisJS1VOSVRfRVhQRUNU X0VRKHRlc3QsICh1MzIpMHgwLCBrZXl3b3Jkc1s0XSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3Qs ICh1MzIpMHgwLCBrZXl3b3Jkc1s1XSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgw LCBrZXl3b3Jkc1s2XSk7CisKKwkvKiBNYXNrICovCisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1 MzIpMHgwLCBtYXNrd29yZHNbMF0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4MCwg bWFza3dvcmRzWzFdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikoMHgwZmZmIDw8IDYp LCBtYXNrd29yZHNbMl0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4MCwgbWFza3dv cmRzWzNdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAsIG1hc2t3b3Jkc1s0XSk7 CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgwLCBtYXNrd29yZHNbNV0pOworCUtVTklU X0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4MCwgbWFza3dvcmRzWzZdKTsKK30KKworc3RhdGljIHZv aWQgdmNhcF9hcGlfZW5jb2RlX21heF9rZXlmaWVsZF90ZXN0KHN0cnVjdCBrdW5pdCAqdGVzdCkK K3sKKwlpbnQgaWR4OworCXUzMiBrZXl3b3Jkc1s2XSA9IHswfTsKKwl1MzIgbWFza3dvcmRzWzZd ID0gezB9OworCXN0cnVjdCB2Y2FwX2FkbWluIGFkbWluID0geworCQkudnR5cGUgPSBWQ0FQX1RZ UEVfSVMyLAorCQkvKiBJUzIgc3dfd2lkdGggPSA1MiBiaXQgKi8KKwkJLmNhY2hlID0geworCQkJ LmtleXN0cmVhbSA9IGtleXdvcmRzLAorCQkJLm1hc2tzdHJlYW0gPSBtYXNrd29yZHMsCisJCQku YWN0aW9uc3RyZWFtID0ga2V5d29yZHMsCisJCX0sCisJfTsKKwlzdHJ1Y3QgdmNhcF9ydWxlX2lu dGVybmFsIHJ1bGUgPSB7CisJCS5hZG1pbiA9ICZhZG1pbiwKKwkJLmRhdGEgPSB7CisJCQkua2V5 c2V0ID0gVkNBUF9LRlNfSVBfN1RVUExFLAorCQl9LAorCQkudmN0cmwgPSAmdGVzdF92Y3RybCwK Kwl9OworCXN0cnVjdCB2Y2FwX2NsaWVudF9rZXlmaWVsZCBja2YgPSB7CisJCS5jdHJsLmxpc3Qg PSB7fSwKKwkJLmN0cmwua2V5ID0gVkNBUF9LRl9MM19JUDZfRElQLAorCQkuY3RybC50eXBlID0g VkNBUF9GSUVMRF9VMTI4LAorCQkuZGF0YS51MTI4LnZhbHVlID0geyAweGExLCAweGEyLCAweGEz LCAweGE0LCAwLCAwLCAweDQzLCAwLAorCQkJMCwgMCwgMCwgMCwgMCwgMCwgMHg3OCwgMHg4ZSwg fSwKKwkJLmRhdGEudTEyOC5tYXNrID0gIHsgMHhmZiwgMHhmZiwgMHhmZiwgMHhmZiwgMCwgMCwg MHhmZiwgMCwKKwkJCTAsIDAsIDAsIDAsIDAsIDAsIDB4ZmYsIDB4ZmYgfSwKKwl9OworCXN0cnVj dCB2Y2FwX2ZpZWxkIHJmID0geworCQkudHlwZSA9IFZDQVBfRklFTERfVTEyOCwKKwkJLm9mZnNl dCA9IDAsCisJCS53aWR0aCA9IDEyOCwKKwl9OworCXN0cnVjdCB2Y2FwX3R5cGVncm91cCB0Z3Rb XSA9IHsKKwkJeyAub2Zmc2V0ID0gMCwgLndpZHRoID0gMiwgLnZhbHVlID0gMiwgfSwKKwkJeyAu b2Zmc2V0ID0gMTU2LCAud2lkdGggPSAxLCAudmFsdWUgPSAxLCB9LAorCQl7IC5vZmZzZXQgPSAw LCAud2lkdGggPSAwLCAudmFsdWUgPSAwLCB9LAorCX07CisJdTMyIGtleXJlc1tdID0geworCQkw eDkyOGU4YTg0LAorCQkweDAwMGMwMDAyLAorCQkweDAwMDAwMDEwLAorCQkweDAwMDAwMDAwLAor CQkweDAyMzllMDAwLAorCQkweDAwMDAwMDAwLAorCX07CisJdTMyIG1za3Jlc1tdID0geworCQkw eGZmZmZmZmZjLAorCQkweDAwMGMwMDAzLAorCQkweDAwMDAwMDNmLAorCQkweDAwMDAwMDAwLAor CQkweDAzZmZmYzAwLAorCQkweDAwMDAwMDAwLAorCX07CisKKwl2Y2FwX2VuY29kZV9rZXlmaWVs ZCgmcnVsZSwgJmNrZiwgJnJmLCB0Z3QpOworCisJLyogS2V5ICovCisJZm9yIChpZHggPSAwOyBp ZHggPCBBUlJBWV9TSVpFKGtleXJlcyk7ICsraWR4KQorCQlLVU5JVF9FWFBFQ1RfRVEodGVzdCwg a2V5cmVzW2lkeF0sIGtleXdvcmRzW2lkeF0pOworCS8qIE1hc2sgKi8KKwlmb3IgKGlkeCA9IDA7 IGlkeCA8IEFSUkFZX1NJWkUobXNrcmVzKTsgKytpZHgpCisJCUtVTklUX0VYUEVDVF9FUSh0ZXN0 LCBtc2tyZXNbaWR4XSwgbWFza3dvcmRzW2lkeF0pOworfQorCitzdGF0aWMgdm9pZCB2Y2FwX2Fw aV9lbmNvZGVfYWN0aW9uZmllbGRfdGVzdChzdHJ1Y3Qga3VuaXQgKnRlc3QpCit7CisJdTMyIGFj dHdvcmRzWzE2XSA9IHswfTsKKwlpbnQgc3dfd2lkdGggPSAyMTsKKwlzdHJ1Y3QgdmNhcF9hZG1p biBhZG1pbiA9IHsKKwkJLnZ0eXBlID0gVkNBUF9UWVBFX0VTMiwgLyogYWN0X3dpZHRoID0gMjEg Ki8KKwkJLmNhY2hlID0geworCQkJLmFjdGlvbnN0cmVhbSA9IGFjdHdvcmRzLAorCQl9LAorCX07 CisJc3RydWN0IHZjYXBfcnVsZV9pbnRlcm5hbCBydWxlID0geworCQkuYWRtaW4gPSAmYWRtaW4s CisJCS5kYXRhID0geworCQkJLmFjdGlvbnNldCA9IFZDQVBfQUZTX0JBU0VfVFlQRSwKKwkJfSwK KwkJLnZjdHJsID0gJnRlc3RfdmN0cmwsCisJfTsKKwlzdHJ1Y3QgdmNhcF9jbGllbnRfYWN0aW9u ZmllbGQgY2FmID0geworCQkuY3RybC5saXN0ID0ge30sCisJCS5jdHJsLmFjdGlvbiA9IFZDQVBf QUZfUE9MSUNFX0lEWCwKKwkJLmN0cmwudHlwZSA9IFZDQVBfRklFTERfVTMyLAorCQkuZGF0YS51 MzIudmFsdWUgPSAweDY3OTA4MDMyLAorCX07CisJc3RydWN0IHZjYXBfZmllbGQgcmYgPSB7CisJ CS50eXBlID0gVkNBUF9GSUVMRF9VMzIsCisJCS5vZmZzZXQgPSAzNSwKKwkJLndpZHRoID0gNiwK Kwl9OworCXN0cnVjdCB2Y2FwX3R5cGVncm91cCB0Z3RbXSA9IHsKKwkJeyAub2Zmc2V0ID0gMCwg LndpZHRoID0gMiwgLnZhbHVlID0gMiwgfSwKKwkJeyAub2Zmc2V0ID0gMjEsIC53aWR0aCA9IDEs IC52YWx1ZSA9IDEsIH0sCisJCXsgLm9mZnNldCA9IDQyLCAud2lkdGggPSAxLCAudmFsdWUgPSAw LCB9LAorCQl7IC5vZmZzZXQgPSAwLCAud2lkdGggPSAwLCAudmFsdWUgPSAwLCB9LAorCX07CisK Kwl2Y2FwX2VuY29kZV9hY3Rpb25maWVsZCgmcnVsZSwgJmNhZiwgJnJmLCB0Z3QpOworCisJLyog QWN0aW9uICovCisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgwLCBhY3R3b3Jkc1swXSk7 CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpKCgweDMyIDw8ICgzNSArIDIgKyAxIC0gc3df d2lkdGgpKSAmIDB4MWZmZmZmKSwgYWN0d29yZHNbMV0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0 LCAodTMyKSgoMHgzMiA+PiAoKDIgKiBzd193aWR0aCkgLSAzOCAtIDEpKSksIGFjdHdvcmRzWzJd KTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAsIGFjdHdvcmRzWzNdKTsKKwlLVU5J VF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAsIGFjdHdvcmRzWzRdKTsKKwlLVU5JVF9FWFBFQ1Rf RVEodGVzdCwgKHUzMikweDAsIGFjdHdvcmRzWzVdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwg KHUzMikweDAsIGFjdHdvcmRzWzZdKTsKK30KKworc3RhdGljIHZvaWQgdmNhcF9hcGlfa2V5Zmll bGRfdHlwZWdyb3VwX3Rlc3Qoc3RydWN0IGt1bml0ICp0ZXN0KQoreworCWNvbnN0IHN0cnVjdCB2 Y2FwX3R5cGVncm91cCAqdGc7CisKKwl0ZyA9IHZjYXBfa2V5ZmllbGRfdHlwZWdyb3VwKCZ0ZXN0 X3ZjdHJsLCBWQ0FQX1RZUEVfSVMyLCBWQ0FQX0tGU19NQUNfRVRZUEUpOworCUtVTklUX0VYUEVD VF9QVFJfTkUodGVzdCwgTlVMTCwgdGcpOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAwLCB0Z1sw XS5vZmZzZXQpOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAyLCB0Z1swXS53aWR0aCk7CisJS1VO SVRfRVhQRUNUX0VRKHRlc3QsIDIsIHRnWzBdLnZhbHVlKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVz dCwgMTU2LCB0Z1sxXS5vZmZzZXQpOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAxLCB0Z1sxXS53 aWR0aCk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsIDAsIHRnWzFdLnZhbHVlKTsKKwlLVU5JVF9F WFBFQ1RfRVEodGVzdCwgMCwgdGdbMl0ub2Zmc2V0KTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwg MCwgdGdbMl0ud2lkdGgpOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAwLCB0Z1syXS52YWx1ZSk7 CisKKwl0ZyA9IHZjYXBfa2V5ZmllbGRfdHlwZWdyb3VwKCZ0ZXN0X3ZjdHJsLCBWQ0FQX1RZUEVf RVMyLCBWQ0FQX0tGU19MTF9GVUxMKTsKKwlLVU5JVF9FWFBFQ1RfUFRSX0VRKHRlc3QsIE5VTEws IHRnKTsKK30KKworc3RhdGljIHZvaWQgdmNhcF9hcGlfYWN0aW9uZmllbGRfdHlwZWdyb3VwX3Rl c3Qoc3RydWN0IGt1bml0ICp0ZXN0KQoreworCWNvbnN0IHN0cnVjdCB2Y2FwX3R5cGVncm91cCAq dGc7CisKKwl0ZyA9IHZjYXBfYWN0aW9uZmllbGRfdHlwZWdyb3VwKCZ0ZXN0X3ZjdHJsLCBWQ0FQ X1RZUEVfSVMwLCBWQ0FQX0FGU19GVUxMKTsKKwlLVU5JVF9FWFBFQ1RfUFRSX05FKHRlc3QsIE5V TEwsIHRnKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgMCwgdGdbMF0ub2Zmc2V0KTsKKwlLVU5J VF9FWFBFQ1RfRVEodGVzdCwgMywgdGdbMF0ud2lkdGgpOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0 LCA0LCB0Z1swXS52YWx1ZSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsIDExMCwgdGdbMV0ub2Zm c2V0KTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgMiwgdGdbMV0ud2lkdGgpOworCUtVTklUX0VY UEVDVF9FUSh0ZXN0LCAwLCB0Z1sxXS52YWx1ZSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsIDIy MCwgdGdbMl0ub2Zmc2V0KTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgMiwgdGdbMl0ud2lkdGgp OworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAwLCB0Z1syXS52YWx1ZSk7CisJS1VOSVRfRVhQRUNU X0VRKHRlc3QsIDAsIHRnWzNdLm9mZnNldCk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsIDAsIHRn WzNdLndpZHRoKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgMCwgdGdbM10udmFsdWUpOworCisJ dGcgPSB2Y2FwX2FjdGlvbmZpZWxkX3R5cGVncm91cCgmdGVzdF92Y3RybCwgVkNBUF9UWVBFX0lT MiwgVkNBUF9BRlNfQ0xBU1NJRklDQVRJT04pOworCUtVTklUX0VYUEVDVF9QVFJfRVEodGVzdCwg TlVMTCwgdGcpOworfQorCitzdGF0aWMgdm9pZCB2Y2FwX2FwaV92Y2FwX2tleWZpZWxkc190ZXN0 KHN0cnVjdCBrdW5pdCAqdGVzdCkKK3sKKwljb25zdCBzdHJ1Y3QgdmNhcF9maWVsZCAqZnQ7CisK KwlmdCA9IHZjYXBfa2V5ZmllbGRzKCZ0ZXN0X3ZjdHJsLCBWQ0FQX1RZUEVfSVMyLCBWQ0FQX0tG U19NQUNfRVRZUEUpOworCUtVTklUX0VYUEVDVF9QVFJfTkUodGVzdCwgTlVMTCwgZnQpOworCisJ LyogS2V5c2V0IHRoYXQgaXMgbm90IGF2YWlsYWJsZSBhbmQgd2l0aGluIHRoZSBtYXhpbXVtIGtl eXNldCBlbnVtIHZhbHVlICovCisJZnQgPSB2Y2FwX2tleWZpZWxkcygmdGVzdF92Y3RybCwgVkNB UF9UWVBFX0VTMiwgVkNBUF9LRlNfUFVSRV81VFVQTEVfSVA0KTsKKwlLVU5JVF9FWFBFQ1RfUFRS X0VRKHRlc3QsIE5VTEwsIGZ0KTsKKworCS8qIEtleXNldCB0aGF0IGlzIG5vdCBhdmFpbGFibGUg YW5kIGJleW9uZCB0aGUgbWF4aW11bSBrZXlzZXQgZW51bSB2YWx1ZSAqLworCWZ0ID0gdmNhcF9r ZXlmaWVsZHMoJnRlc3RfdmN0cmwsIFZDQVBfVFlQRV9FUzIsIFZDQVBfS0ZTX0xMX0ZVTEwpOwor CUtVTklUX0VYUEVDVF9QVFJfRVEodGVzdCwgTlVMTCwgZnQpOworfQorCitzdGF0aWMgdm9pZCB2 Y2FwX2FwaV92Y2FwX2FjdGlvbmZpZWxkc190ZXN0KHN0cnVjdCBrdW5pdCAqdGVzdCkKK3sKKwlj b25zdCBzdHJ1Y3QgdmNhcF9maWVsZCAqZnQ7CisKKwlmdCA9IHZjYXBfYWN0aW9uZmllbGRzKCZ0 ZXN0X3ZjdHJsLCBWQ0FQX1RZUEVfSVMwLCBWQ0FQX0FGU19GVUxMKTsKKwlLVU5JVF9FWFBFQ1Rf UFRSX05FKHRlc3QsIE5VTEwsIGZ0KTsKKworCWZ0ID0gdmNhcF9hY3Rpb25maWVsZHMoJnRlc3Rf dmN0cmwsIFZDQVBfVFlQRV9JUzIsIFZDQVBfQUZTX0ZVTEwpOworCUtVTklUX0VYUEVDVF9QVFJf RVEodGVzdCwgTlVMTCwgZnQpOworCisJZnQgPSB2Y2FwX2FjdGlvbmZpZWxkcygmdGVzdF92Y3Ry bCwgVkNBUF9UWVBFX0lTMiwgVkNBUF9BRlNfQ0xBU1NJRklDQVRJT04pOworCUtVTklUX0VYUEVD VF9QVFJfRVEodGVzdCwgTlVMTCwgZnQpOworfQorCitzdGF0aWMgdm9pZCB2Y2FwX2FwaV9lbmNv ZGVfcnVsZV9rZXlzZXRfdGVzdChzdHJ1Y3Qga3VuaXQgKnRlc3QpCit7CisJdTMyIGtleXdvcmRz WzE2XSA9IHswfTsKKwl1MzIgbWFza3dvcmRzWzE2XSA9IHswfTsKKwlzdHJ1Y3QgdmNhcF9hZG1p biBhZG1pbiA9IHsKKwkJLnZ0eXBlID0gVkNBUF9UWVBFX0lTMiwKKwkJLmNhY2hlID0geworCQkJ LmtleXN0cmVhbSA9IGtleXdvcmRzLAorCQkJLm1hc2tzdHJlYW0gPSBtYXNrd29yZHMsCisJCX0s CisJfTsKKwlzdHJ1Y3QgdmNhcF9ydWxlX2ludGVybmFsIHJ1bGUgPSB7CisJCS5hZG1pbiA9ICZh ZG1pbiwKKwkJLmRhdGEgPSB7CisJCQkua2V5c2V0ID0gVkNBUF9LRlNfTUFDX0VUWVBFLAorCQl9 LAorCQkudmN0cmwgPSAmdGVzdF92Y3RybCwKKwl9OworCXN0cnVjdCB2Y2FwX2NsaWVudF9rZXlm aWVsZCBja2ZbXSA9IHsKKwkJeworCQkJLmN0cmwua2V5ID0gVkNBUF9LRl9UWVBFLAorCQkJLmN0 cmwudHlwZSA9IFZDQVBfRklFTERfVTMyLAorCQkJLmRhdGEudTMyLnZhbHVlID0gMHgwMCwKKwkJ CS5kYXRhLnUzMi5tYXNrID0gMHgwZiwKKwkJfSwKKwkJeworCQkJLmN0cmwua2V5ID0gVkNBUF9L Rl9MT09LVVBfRklSU1RfSVMsCisJCQkuY3RybC50eXBlID0gVkNBUF9GSUVMRF9CSVQsCisJCQku ZGF0YS51MS52YWx1ZSA9IDB4MDEsCisJCQkuZGF0YS51MS5tYXNrID0gMHgwMSwKKwkJfSwKKwkJ eworCQkJLmN0cmwua2V5ID0gVkNBUF9LRl9JRl9JR1JfUE9SVF9NQVNLX0wzLAorCQkJLmN0cmwu dHlwZSA9IFZDQVBfRklFTERfQklULAorCQkJLmRhdGEudTEudmFsdWUgPSAweDAwLAorCQkJLmRh dGEudTEubWFzayA9IDB4MDEsCisJCX0sCisJCXsKKwkJCS5jdHJsLmtleSA9IFZDQVBfS0ZfSUZf SUdSX1BPUlRfTUFTS19STkcsCisJCQkuY3RybC50eXBlID0gVkNBUF9GSUVMRF9VMzIsCisJCQku ZGF0YS51MzIudmFsdWUgPSAweDAwLAorCQkJLmRhdGEudTMyLm1hc2sgPSAweDBmLAorCQl9LAor CQl7CisJCQkuY3RybC5rZXkgPSBWQ0FQX0tGX0lGX0lHUl9QT1JUX01BU0ssCisJCQkuY3RybC50 eXBlID0gVkNBUF9GSUVMRF9VNzIsCisJCQkuZGF0YS51NzIudmFsdWUgPSB7MHgwLCAweDAwLCAw eDAwLCAweDAwfSwKKwkJCS5kYXRhLnU3Mi5tYXNrID0gezB4ZmQsIDB4ZmYsIDB4ZmYsIDB4ZmZ9 LAorCQl9LAorCQl7CisJCQkuY3RybC5rZXkgPSBWQ0FQX0tGX0wyX0RNQUMsCisJCQkuY3RybC50 eXBlID0gVkNBUF9GSUVMRF9VNDgsCisJCQkvKiBPcHBvc2l0ZSBlbmRpYW5uZXNzICovCisJCQku ZGF0YS51NDgudmFsdWUgPSB7MHgwMSwgMHgwMiwgMHgwMywgMHgwNCwgMHgwNSwgMHgwNn0sCisJ CQkuZGF0YS51NDgubWFzayA9IHsweGZmLCAweGZmLCAweGZmLCAweGZmLCAweGZmLCAweGZmfSwK KwkJfSwKKwkJeworCQkJLmN0cmwua2V5ID0gVkNBUF9LRl9FVFlQRV9MRU5fSVMsCisJCQkuY3Ry bC50eXBlID0gVkNBUF9GSUVMRF9CSVQsCisJCQkuZGF0YS51MS52YWx1ZSA9IDB4MDEsCisJCQku ZGF0YS51MS5tYXNrID0gMHgwMSwKKwkJfSwKKwkJeworCQkJLmN0cmwua2V5ID0gVkNBUF9LRl9F VFlQRSwKKwkJCS5jdHJsLnR5cGUgPSBWQ0FQX0ZJRUxEX1UzMiwKKwkJCS5kYXRhLnUzMi52YWx1 ZSA9IDB4YWFiYiwKKwkJCS5kYXRhLnUzMi5tYXNrID0gMHhmZmZmLAorCQl9LAorCX07CisJaW50 IGlkeDsKKwlpbnQgcmV0OworCisJLyogRW1wdHkgZW50cnkgbGlzdCAqLworCUlOSVRfTElTVF9I RUFEKCZydWxlLmRhdGEua2V5ZmllbGRzKTsKKwlyZXQgPSB2Y2FwX2VuY29kZV9ydWxlX2tleXNl dCgmcnVsZSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsIC1FSU5WQUwsIHJldCk7CisKKwlmb3Ig KGlkeCA9IDA7IGlkeCA8IEFSUkFZX1NJWkUoY2tmKTsgaWR4KyspCisJCWxpc3RfYWRkX3RhaWwo JmNrZltpZHhdLmN0cmwubGlzdCwgJnJ1bGUuZGF0YS5rZXlmaWVsZHMpOworCXJldCA9IHZjYXBf ZW5jb2RlX3J1bGVfa2V5c2V0KCZydWxlKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgMCwgcmV0 KTsKKworCS8qIFRoZSBrZXkgYW5kIG1hc2sgdmFsdWVzIGJlbG93IGFyZSBmcm9tIGFuIGFjdHVh bCBTcGFyeDUgcnVsZSBjb25maWcgKi8KKwkvKiBLZXkgKi8KKwlLVU5JVF9FWFBFQ1RfRVEodGVz dCwgKHUzMikweDAwMDAwMDQyLCBrZXl3b3Jkc1swXSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3Qs ICh1MzIpMHgwMDAwMDAwMCwga2V5d29yZHNbMV0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAo dTMyKTB4MDAwMDAwMDAsIGtleXdvcmRzWzJdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUz MikweDAwMDIwMTAwLCBrZXl3b3Jkc1szXSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIp MHg2MDUwNDAzMCwga2V5d29yZHNbNF0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4 MDAwMDAwMDAsIGtleXdvcmRzWzVdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAw MDAwMDAwLCBrZXl3b3Jkc1s2XSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgwMDAy YWFlZSwga2V5d29yZHNbN10pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4MDAwMDAw MDAsIGtleXdvcmRzWzhdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAwMDAwMDAw LCBrZXl3b3Jkc1s5XSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgwMDAwMDAwMCwg a2V5d29yZHNbMTBdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAwMDAwMDAwLCBr ZXl3b3Jkc1sxMV0pOworCisJLyogTWFzazogdGhleSB3aWxsIGJlIGludmVydGVkIHdoZW4gYXBw bGllZCB0byB0aGUgcmVnaXN0ZXIgKi8KKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMil+MHgw MGIwN2Y4MCwgbWFza3dvcmRzWzBdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMil+MHhm ZmYwMDAwMCwgbWFza3dvcmRzWzFdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMil+MHhm ZmZmZmZmYywgbWFza3dvcmRzWzJdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMil+MHhm ZmYwMDBmZiwgbWFza3dvcmRzWzNdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMil+MHgw MDAwMDAwMCwgbWFza3dvcmRzWzRdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMil+MHhm ZmZmZmZmMCwgbWFza3dvcmRzWzVdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMil+MHhm ZmZmZmZmZSwgbWFza3dvcmRzWzZdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMil+MHhm ZmZjMDAwMSwgbWFza3dvcmRzWzddKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMil+MHhm ZmZmZmZmZiwgbWFza3dvcmRzWzhdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMil+MHhm ZmZmZmZmZiwgbWFza3dvcmRzWzldKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMil+MHhm ZmZmZmZmZiwgbWFza3dvcmRzWzEwXSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpfjB4 ZmZmZmZmZmYsIG1hc2t3b3Jkc1sxMV0pOworfQorCitzdGF0aWMgdm9pZCB2Y2FwX2FwaV9lbmNv ZGVfcnVsZV9hY3Rpb25zZXRfdGVzdChzdHJ1Y3Qga3VuaXQgKnRlc3QpCit7CisJdTMyIGFjdHdv cmRzWzE2XSA9IHswfTsKKwlzdHJ1Y3QgdmNhcF9hZG1pbiBhZG1pbiA9IHsKKwkJLnZ0eXBlID0g VkNBUF9UWVBFX0lTMiwKKwkJLmNhY2hlID0geworCQkJLmFjdGlvbnN0cmVhbSA9IGFjdHdvcmRz LAorCQl9LAorCX07CisJc3RydWN0IHZjYXBfcnVsZV9pbnRlcm5hbCBydWxlID0geworCQkuYWRt aW4gPSAmYWRtaW4sCisJCS5kYXRhID0geworCQkJLmFjdGlvbnNldCA9IFZDQVBfQUZTX0JBU0Vf VFlQRSwKKwkJfSwKKwkJLnZjdHJsID0gJnRlc3RfdmN0cmwsCisJfTsKKwlzdHJ1Y3QgdmNhcF9j bGllbnRfYWN0aW9uZmllbGQgY2FmW10gPSB7CisJCXsKKwkJCS5jdHJsLmFjdGlvbiA9IFZDQVBf QUZfTUFUQ0hfSUQsCisJCQkuY3RybC50eXBlID0gVkNBUF9GSUVMRF9VMzIsCisJCQkuZGF0YS51 MzIudmFsdWUgPSAweDAxLAorCQl9LAorCQl7CisJCQkuY3RybC5hY3Rpb24gPSBWQ0FQX0FGX01B VENIX0lEX01BU0ssCisJCQkuY3RybC50eXBlID0gVkNBUF9GSUVMRF9VMzIsCisJCQkuZGF0YS51 MzIudmFsdWUgPSAweDAxLAorCQl9LAorCQl7CisJCQkuY3RybC5hY3Rpb24gPSBWQ0FQX0FGX0NO VF9JRCwKKwkJCS5jdHJsLnR5cGUgPSBWQ0FQX0ZJRUxEX1UzMiwKKwkJCS5kYXRhLnUzMi52YWx1 ZSA9IDB4NjQsCisJCX0sCisJfTsKKwlpbnQgaWR4OworCWludCByZXQ7CisKKwkvKiBFbXB0eSBl bnRyeSBsaXN0ICovCisJSU5JVF9MSVNUX0hFQUQoJnJ1bGUuZGF0YS5hY3Rpb25maWVsZHMpOwor CXJldCA9IHZjYXBfZW5jb2RlX3J1bGVfYWN0aW9uc2V0KCZydWxlKTsKKwkvKiBXZSBhbGxvdyBy dWxlcyB3aXRoIG5vIGFjdGlvbnMgKi8KKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgMCwgcmV0KTsK KworCWZvciAoaWR4ID0gMDsgaWR4IDwgQVJSQVlfU0laRShjYWYpOyBpZHgrKykKKwkJbGlzdF9h ZGRfdGFpbCgmY2FmW2lkeF0uY3RybC5saXN0LCAmcnVsZS5kYXRhLmFjdGlvbmZpZWxkcyk7CisJ cmV0ID0gdmNhcF9lbmNvZGVfcnVsZV9hY3Rpb25zZXQoJnJ1bGUpOworCUtVTklUX0VYUEVDVF9F USh0ZXN0LCAwLCByZXQpOworCisJLyogVGhlIGFjdGlvbiB2YWx1ZXMgYmVsb3cgYXJlIGZyb20g YW4gYWN0dWFsIFNwYXJ4NSBydWxlIGNvbmZpZyAqLworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAo dTMyKTB4MDAwMDAwMDIsIGFjdHdvcmRzWzBdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUz MikweDAwMDAwMDAwLCBhY3R3b3Jkc1sxXSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIp MHgwMDAwMDAwMCwgYWN0d29yZHNbMl0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4 MDAwMDAwMDAsIGFjdHdvcmRzWzNdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAw MDAwMDAwLCBhY3R3b3Jkc1s0XSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgwMDEw MDAwMCwgYWN0d29yZHNbNV0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4MDY0MDAw MTAsIGFjdHdvcmRzWzZdKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAwMDAwMDAw LCBhY3R3b3Jkc1s3XSk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsICh1MzIpMHgwMDAwMDAwMCwg YWN0d29yZHNbOF0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4MDAwMDAwMDAsIGFj dHdvcmRzWzldKTsKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgKHUzMikweDAwMDAwMDAwLCBhY3R3 b3Jkc1sxMF0pOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAodTMyKTB4MDAwMDAwMDAsIGFjdHdv cmRzWzExXSk7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qga3VuaXRfY2FzZSB2Y2FwX2FwaV9lbmNvZGlu Z190ZXN0X2Nhc2VzW10gPSB7CisJS1VOSVRfQ0FTRSh2Y2FwX2FwaV9zZXRfYml0XzFfdGVzdCks CisJS1VOSVRfQ0FTRSh2Y2FwX2FwaV9zZXRfYml0XzBfdGVzdCksCisJS1VOSVRfQ0FTRSh2Y2Fw X2FwaV9pdGVyYXRvcl9pbml0X3Rlc3QpLAorCUtVTklUX0NBU0UodmNhcF9hcGlfaXRlcmF0b3Jf bmV4dF90ZXN0KSwKKwlLVU5JVF9DQVNFKHZjYXBfYXBpX2VuY29kZV90eXBlZ3JvdXBzX3Rlc3Qp LAorCUtVTklUX0NBU0UodmNhcF9hcGlfZW5jb2RlX2JpdF90ZXN0KSwKKwlLVU5JVF9DQVNFKHZj YXBfYXBpX2VuY29kZV9maWVsZF90ZXN0KSwKKwlLVU5JVF9DQVNFKHZjYXBfYXBpX2VuY29kZV9z aG9ydF9maWVsZF90ZXN0KSwKKwlLVU5JVF9DQVNFKHZjYXBfYXBpX2VuY29kZV9rZXlmaWVsZF90 ZXN0KSwKKwlLVU5JVF9DQVNFKHZjYXBfYXBpX2VuY29kZV9tYXhfa2V5ZmllbGRfdGVzdCksCisJ S1VOSVRfQ0FTRSh2Y2FwX2FwaV9lbmNvZGVfYWN0aW9uZmllbGRfdGVzdCksCisJS1VOSVRfQ0FT RSh2Y2FwX2FwaV9rZXlmaWVsZF90eXBlZ3JvdXBfdGVzdCksCisJS1VOSVRfQ0FTRSh2Y2FwX2Fw aV9hY3Rpb25maWVsZF90eXBlZ3JvdXBfdGVzdCksCisJS1VOSVRfQ0FTRSh2Y2FwX2FwaV92Y2Fw X2tleWZpZWxkc190ZXN0KSwKKwlLVU5JVF9DQVNFKHZjYXBfYXBpX3ZjYXBfYWN0aW9uZmllbGRz X3Rlc3QpLAorCUtVTklUX0NBU0UodmNhcF9hcGlfZW5jb2RlX3J1bGVfa2V5c2V0X3Rlc3QpLAor CUtVTklUX0NBU0UodmNhcF9hcGlfZW5jb2RlX3J1bGVfYWN0aW9uc2V0X3Rlc3QpLAorCXt9Cit9 OworCitzdGF0aWMgc3RydWN0IGt1bml0X3N1aXRlIHZjYXBfYXBpX2VuY29kaW5nX3Rlc3Rfc3Vp dGUgPSB7CisJLm5hbWUgPSAiVkNBUF9BUElfRW5jb2RpbmdfVGVzdHN1aXRlIiwKKwkudGVzdF9j YXNlcyA9IHZjYXBfYXBpX2VuY29kaW5nX3Rlc3RfY2FzZXMsCit9OworCitrdW5pdF90ZXN0X3N1 aXRlKHZjYXBfYXBpX2VuY29kaW5nX3Rlc3Rfc3VpdGUpOwotLSAKMi4zOC4xCgoKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBt YWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9s aXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 07E18C433FE for ; Wed, 19 Oct 2022 12:09:55 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231627AbiJSMJv (ORCPT ); Wed, 19 Oct 2022 08:09:51 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58336 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232333AbiJSMH6 (ORCPT ); Wed, 19 Oct 2022 08:07:58 -0400 Received: from esa.microchip.iphmx.com (esa.microchip.iphmx.com [68.232.154.123]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6BFD8B44; Wed, 19 Oct 2022 04:44:20 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=microchip.com; i=@microchip.com; q=dns/txt; s=mchp; t=1666179861; x=1697715861; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=pz8rN1GbUuAQDq1CUubvtXkLTuGeD8KwTZXl0bYxDvw=; b=ZlGhUyGyulVlxep+Z7zak107JBB+To9Lo69bvnwWDGLW/PQY3j9oxNMv Yr4r+9Tw7tTK4+WRvsEqCXZvBdDvx/ZnyShYyIrCi/dbtQrkn9Udd5g+q S4mdyemfracpn6F9uwt5I0ZTFUgF7uWewoOdplveeAxUi3OqUxdU8Tx+e xTMQZAQ+j7fwQqGC9GrzIyT4boXf49hVm1z4Vd0i77F/Vc1aerevFDIA/ DFJbnRD4+MwA7oZALfvsU62AtnQICk7cZXVEr9OMRwhylfIJ1tWf9dgCI nt2nu2MdonpzPaUaW0bwvzRIe04ORI7M9Sdbqw0WN6oRwTSTu3k3/6Pw4 A==; X-IronPort-AV: E=Sophos;i="5.95,196,1661842800"; d="scan'208";a="182926285" Received: from unknown (HELO email.microchip.com) ([170.129.1.10]) by esa2.microchip.iphmx.com with ESMTP/TLS/AES256-SHA256; 19 Oct 2022 04:42:56 -0700 Received: from chn-vm-ex04.mchp-main.com (10.10.85.152) by chn-vm-ex02.mchp-main.com (10.10.85.144) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.12; Wed, 19 Oct 2022 04:42:51 -0700 Received: from den-dk-m31857.microchip.com (10.10.115.15) by chn-vm-ex04.mchp-main.com (10.10.85.152) with Microsoft SMTP Server id 15.1.2507.12 via Frontend Transport; Wed, 19 Oct 2022 04:42:48 -0700 From: Steen Hegelund To: "David S . Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni CC: Steen Hegelund , , Randy Dunlap , "Casper Andersson" , Russell King , Wan Jiabing , "Nathan Huckleberry" , , , , "kernel test robot" Subject: [PATCH net-next v2 9/9] net: microchip: sparx5: Adding KUNIT test for the VCAP API Date: Wed, 19 Oct 2022 13:42:15 +0200 Message-ID: <20221019114215.620969-10-steen.hegelund@microchip.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221019114215.620969-1-steen.hegelund@microchip.com> References: <20221019114215.620969-1-steen.hegelund@microchip.com> MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This provides a KUNIT test suite for the VCAP APIs encoding functionality. Signed-off-by: Steen Hegelund Reported-by: kernel test robot --- drivers/net/ethernet/microchip/vcap/Kconfig | 13 + .../microchip/vcap/vcap_ag_api_kunit.h | 643 ++++++++++++ .../net/ethernet/microchip/vcap/vcap_api.c | 4 + .../net/ethernet/microchip/vcap/vcap_api.h | 3 + .../ethernet/microchip/vcap/vcap_api_kunit.c | 933 ++++++++++++++++++ 5 files changed, 1596 insertions(+) create mode 100644 drivers/net/ethernet/microchip/vcap/vcap_ag_api_kunit.h create mode 100644 drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c diff --git a/drivers/net/ethernet/microchip/vcap/Kconfig b/drivers/net/ethernet/microchip/vcap/Kconfig index a78cbc6ce6bb..1af30a358a15 100644 --- a/drivers/net/ethernet/microchip/vcap/Kconfig +++ b/drivers/net/ethernet/microchip/vcap/Kconfig @@ -36,4 +36,17 @@ config VCAP characteristics. Look in the datasheet for the VCAP specifications for the specific switchcore. +config VCAP_KUNIT_TEST + bool "KUnit test for VCAP library" if !KUNIT_ALL_TESTS + depends on KUNIT + depends on KUNIT=y && VCAP=y && y + default KUNIT_ALL_TESTS + help + This builds unit tests for the VCAP library. + + For more information on KUnit and unit tests in general, please refer + to the KUnit documentation in Documentation/dev-tools/kunit/. + + If unsure, say N. + endif # NET_VENDOR_MICROCHIP diff --git a/drivers/net/ethernet/microchip/vcap/vcap_ag_api_kunit.h b/drivers/net/ethernet/microchip/vcap/vcap_ag_api_kunit.h new file mode 100644 index 000000000000..e538ca725687 --- /dev/null +++ b/drivers/net/ethernet/microchip/vcap/vcap_ag_api_kunit.h @@ -0,0 +1,643 @@ +/* SPDX-License-Identifier: BSD-3-Clause */ +/* Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries. + * Microchip VCAP API interface for kunit testing + * This is a different interface, to be able to include different VCAPs + */ + +/* Use same include guard as the official API to be able to override it */ +#ifndef __VCAP_AG_API__ +#define __VCAP_AG_API__ + +enum vcap_type { + VCAP_TYPE_ES2, + VCAP_TYPE_IS0, + VCAP_TYPE_IS2, + VCAP_TYPE_MAX +}; + +/* Keyfieldset names with origin information */ +enum vcap_keyfield_set { + VCAP_KFS_NO_VALUE, /* initial value */ + VCAP_KFS_ARP, /* sparx5 is2 X6, sparx5 es2 X6 */ + VCAP_KFS_ETAG, /* sparx5 is0 X2 */ + VCAP_KFS_IP4_OTHER, /* sparx5 is2 X6, sparx5 es2 X6 */ + VCAP_KFS_IP4_TCP_UDP, /* sparx5 is2 X6, sparx5 es2 X6 */ + VCAP_KFS_IP4_VID, /* sparx5 es2 X3 */ + VCAP_KFS_IP6_STD, /* sparx5 is2 X6 */ + VCAP_KFS_IP6_VID, /* sparx5 is2 X6, sparx5 es2 X6 */ + VCAP_KFS_IP_7TUPLE, /* sparx5 is2 X12, sparx5 es2 X12 */ + VCAP_KFS_LL_FULL, /* sparx5 is0 X6 */ + VCAP_KFS_MAC_ETYPE, /* sparx5 is2 X6, sparx5 es2 X6 */ + VCAP_KFS_MLL, /* sparx5 is0 X3 */ + VCAP_KFS_NORMAL, /* sparx5 is0 X6 */ + VCAP_KFS_NORMAL_5TUPLE_IP4, /* sparx5 is0 X6 */ + VCAP_KFS_NORMAL_7TUPLE, /* sparx5 is0 X12 */ + VCAP_KFS_PURE_5TUPLE_IP4, /* sparx5 is0 X3 */ + VCAP_KFS_TRI_VID, /* sparx5 is0 X2 */ +}; + +/* List of keyfields with description + * + * Keys ending in _IS are booleans derived from frame data + * Keys ending in _CLS are classified frame data + * + * VCAP_KF_8021BR_ECID_BASE: W12, sparx5: is0 + * Used by 802.1BR Bridge Port Extension in an E-Tag + * VCAP_KF_8021BR_ECID_EXT: W8, sparx5: is0 + * Used by 802.1BR Bridge Port Extension in an E-Tag + * VCAP_KF_8021BR_E_TAGGED: W1, sparx5: is0 + * Set for frames containing an E-TAG (802.1BR Ethertype 893f) + * VCAP_KF_8021BR_GRP: W2, sparx5: is0 + * E-Tag group bits in 802.1BR Bridge Port Extension + * VCAP_KF_8021BR_IGR_ECID_BASE: W12, sparx5: is0 + * Used by 802.1BR Bridge Port Extension in an E-Tag + * VCAP_KF_8021BR_IGR_ECID_EXT: W8, sparx5: is0 + * Used by 802.1BR Bridge Port Extension in an E-Tag + * VCAP_KF_8021Q_DEI0: W1, sparx5: is0 + * First DEI in multiple vlan tags (outer tag or default port tag) + * VCAP_KF_8021Q_DEI1: W1, sparx5: is0 + * Second DEI in multiple vlan tags (inner tag) + * VCAP_KF_8021Q_DEI2: W1, sparx5: is0 + * Third DEI in multiple vlan tags (not always available) + * VCAP_KF_8021Q_DEI_CLS: W1, sparx5: is2/es2 + * Classified DEI + * VCAP_KF_8021Q_PCP0: W3, sparx5: is0 + * First PCP in multiple vlan tags (outer tag or default port tag) + * VCAP_KF_8021Q_PCP1: W3, sparx5: is0 + * Second PCP in multiple vlan tags (inner tag) + * VCAP_KF_8021Q_PCP2: W3, sparx5: is0 + * Third PCP in multiple vlan tags (not always available) + * VCAP_KF_8021Q_PCP_CLS: W3, sparx5: is2/es2 + * Classified PCP + * VCAP_KF_8021Q_TPID0: W3, sparx5: is0 + * First TPIC in multiple vlan tags (outer tag or default port tag) + * VCAP_KF_8021Q_TPID1: W3, sparx5: is0 + * Second TPID in multiple vlan tags (inner tag) + * VCAP_KF_8021Q_TPID2: W3, sparx5: is0 + * Third TPID in multiple vlan tags (not always available) + * VCAP_KF_8021Q_VID0: W12, sparx5: is0 + * First VID in multiple vlan tags (outer tag or default port tag) + * VCAP_KF_8021Q_VID1: W12, sparx5: is0 + * Second VID in multiple vlan tags (inner tag) + * VCAP_KF_8021Q_VID2: W12, sparx5: is0 + * Third VID in multiple vlan tags (not always available) + * VCAP_KF_8021Q_VID_CLS: W13, sparx5: is2/es2 + * Classified VID + * VCAP_KF_8021Q_VLAN_TAGGED_IS: W1, sparx5: is2/es2 + * Sparx5: Set if frame was received with a VLAN tag, LAN966x: Set if frame has + * one or more Q-tags. Independent of port VLAN awareness + * VCAP_KF_8021Q_VLAN_TAGS: W3, sparx5: is0 + * Number of VLAN tags in frame: 0: Untagged, 1: Single tagged, 3: Double + * tagged, 7: Triple tagged + * VCAP_KF_ACL_GRP_ID: W8, sparx5: es2 + * Used in interface map table + * VCAP_KF_ARP_ADDR_SPACE_OK_IS: W1, sparx5: is2/es2 + * Set if hardware address is Ethernet + * VCAP_KF_ARP_LEN_OK_IS: W1, sparx5: is2/es2 + * Set if hardware address length = 6 (Ethernet) and IP address length = 4 (IP). + * VCAP_KF_ARP_OPCODE: W2, sparx5: is2/es2 + * ARP opcode + * VCAP_KF_ARP_OPCODE_UNKNOWN_IS: W1, sparx5: is2/es2 + * Set if not one of the codes defined in VCAP_KF_ARP_OPCODE + * VCAP_KF_ARP_PROTO_SPACE_OK_IS: W1, sparx5: is2/es2 + * Set if protocol address space is 0x0800 + * VCAP_KF_ARP_SENDER_MATCH_IS: W1, sparx5: is2/es2 + * Sender Hardware Address = SMAC (ARP) + * VCAP_KF_ARP_TGT_MATCH_IS: W1, sparx5: is2/es2 + * Target Hardware Address = SMAC (RARP) + * VCAP_KF_COSID_CLS: W3, sparx5: es2 + * Class of service + * VCAP_KF_DST_ENTRY: W1, sparx5: is0 + * Selects whether the frame’s destination or source information is used for + * fields L2_SMAC and L3_IP4_SIP + * VCAP_KF_ES0_ISDX_KEY_ENA: W1, sparx5: es2 + * The value taken from the IFH .FWD.ES0_ISDX_KEY_ENA + * VCAP_KF_ETYPE: W16, sparx5: is0/is2/es2 + * Ethernet type + * VCAP_KF_ETYPE_LEN_IS: W1, sparx5: is0/is2/es2 + * Set if frame has EtherType >= 0x600 + * VCAP_KF_ETYPE_MPLS: W2, sparx5: is0 + * Type of MPLS Ethertype (or not) + * VCAP_KF_IF_EGR_PORT_MASK: W32, sparx5: es2 + * Egress port mask, one bit per port + * VCAP_KF_IF_EGR_PORT_MASK_RNG: W3, sparx5: es2 + * Select which 32 port group is available in IF_EGR_PORT (or virtual ports or + * CPU queue) + * VCAP_KF_IF_IGR_PORT: sparx5 is0 W7, sparx5 es2 W9 + * Sparx5: Logical ingress port number retrieved from + * ANA_CL::PORT_ID_CFG.LPORT_NUM or ERLEG, LAN966x: ingress port nunmber + * VCAP_KF_IF_IGR_PORT_MASK: sparx5 is0 W65, sparx5 is2 W32, sparx5 is2 W65 + * Ingress port mask, one bit per port/erleg + * VCAP_KF_IF_IGR_PORT_MASK_L3: W1, sparx5: is2 + * If set, IF_IGR_PORT_MASK, IF_IGR_PORT_MASK_RNG, and IF_IGR_PORT_MASK_SEL are + * used to specify L3 interfaces + * VCAP_KF_IF_IGR_PORT_MASK_RNG: W4, sparx5: is2 + * Range selector for IF_IGR_PORT_MASK. Specifies which group of 32 ports are + * available in IF_IGR_PORT_MASK + * VCAP_KF_IF_IGR_PORT_MASK_SEL: W2, sparx5: is0/is2 + * Mode selector for IF_IGR_PORT_MASK, applicable when IF_IGR_PORT_MASK_L3 == 0. + * Mapping: 0: DEFAULT 1: LOOPBACK 2: MASQUERADE 3: CPU_VD + * VCAP_KF_IF_IGR_PORT_SEL: W1, sparx5: es2 + * Selector for IF_IGR_PORT: physical port number or ERLEG + * VCAP_KF_IP4_IS: W1, sparx5: is0/is2/es2 + * Set if frame has EtherType = 0x800 and IP version = 4 + * VCAP_KF_IP_MC_IS: W1, sparx5: is0 + * Set if frame is IPv4 frame and frame’s destination MAC address is an IPv4 + * multicast address (0x01005E0 /25). Set if frame is IPv6 frame and frame’s + * destination MAC address is an IPv6 multicast address (0x3333/16). + * VCAP_KF_IP_PAYLOAD_5TUPLE: W32, sparx5: is0 + * Payload bytes after IP header + * VCAP_KF_IP_SNAP_IS: W1, sparx5: is0 + * Set if frame is IPv4, IPv6, or SNAP frame + * VCAP_KF_ISDX_CLS: W12, sparx5: is2/es2 + * Classified ISDX + * VCAP_KF_ISDX_GT0_IS: W1, sparx5: is2/es2 + * Set if classified ISDX > 0 + * VCAP_KF_L2_BC_IS: W1, sparx5: is0/is2/es2 + * Set if frame’s destination MAC address is the broadcast address + * (FF-FF-FF-FF-FF-FF). + * VCAP_KF_L2_DMAC: W48, sparx5: is0/is2/es2 + * Destination MAC address + * VCAP_KF_L2_FWD_IS: W1, sparx5: is2 + * Set if the frame is allowed to be forwarded to front ports + * VCAP_KF_L2_MC_IS: W1, sparx5: is0/is2/es2 + * Set if frame’s destination MAC address is a multicast address (bit 40 = 1). + * VCAP_KF_L2_PAYLOAD_ETYPE: W64, sparx5: is2/es2 + * Byte 0-7 of L2 payload after Type/Len field and overloading for OAM + * VCAP_KF_L2_SMAC: W48, sparx5: is0/is2/es2 + * Source MAC address + * VCAP_KF_L3_DIP_EQ_SIP_IS: W1, sparx5: is2/es2 + * Set if Src IP matches Dst IP address + * VCAP_KF_L3_DMAC_DIP_MATCH: W1, sparx5: is2 + * Match found in DIP security lookup in ANA_L3 + * VCAP_KF_L3_DPL_CLS: W1, sparx5: es2 + * The frames drop precedence level + * VCAP_KF_L3_DSCP: W6, sparx5: is0 + * Frame’s DSCP value + * VCAP_KF_L3_DST_IS: W1, sparx5: is2 + * Set if lookup is done for egress router leg + * VCAP_KF_L3_FRAGMENT_TYPE: W2, sparx5: is0/is2/es2 + * L3 Fragmentation type (none, initial, suspicious, valid follow up) + * VCAP_KF_L3_FRAG_INVLD_L4_LEN: W1, sparx5: is0/is2 + * Set if frame's L4 length is less than ANA_CL:COMMON:CLM_FRAGMENT_CFG.L4_MIN_L + * EN + * VCAP_KF_L3_IP4_DIP: W32, sparx5: is0/is2/es2 + * Destination IPv4 Address + * VCAP_KF_L3_IP4_SIP: W32, sparx5: is0/is2/es2 + * Source IPv4 Address + * VCAP_KF_L3_IP6_DIP: W128, sparx5: is0/is2/es2 + * Sparx5: Full IPv6 DIP, LAN966x: Either Full IPv6 DIP or a subset depending on + * frame type + * VCAP_KF_L3_IP6_SIP: W128, sparx5: is0/is2/es2 + * Sparx5: Full IPv6 SIP, LAN966x: Either Full IPv6 SIP or a subset depending on + * frame type + * VCAP_KF_L3_IP_PROTO: W8, sparx5: is0/is2/es2 + * IPv4 frames: IP protocol. IPv6 frames: Next header, same as for IPV4 + * VCAP_KF_L3_OPTIONS_IS: W1, sparx5: is0/is2/es2 + * Set if IPv4 frame contains options (IP len > 5) + * VCAP_KF_L3_PAYLOAD: sparx5 is2 W96, sparx5 is2 W40, sparx5 es2 W96 + * Sparx5: Payload bytes after IP header. IPv4: IPv4 options are not parsed so + * payload is always taken 20 bytes after the start of the IPv4 header, LAN966x: + * Bytes 0-6 after IP header + * VCAP_KF_L3_RT_IS: W1, sparx5: is2/es2 + * Set if frame has hit a router leg + * VCAP_KF_L3_SMAC_SIP_MATCH: W1, sparx5: is2 + * Match found in SIP security lookup in ANA_L3 + * VCAP_KF_L3_TOS: W8, sparx5: is2/es2 + * Sparx5: Frame's IPv4/IPv6 DSCP and ECN fields, LAN966x: IP TOS field + * VCAP_KF_L3_TTL_GT0: W1, sparx5: is2/es2 + * Set if IPv4 TTL / IPv6 hop limit is greater than 0 + * VCAP_KF_L4_ACK: W1, sparx5: is2/es2 + * Sparx5 and LAN966x: TCP flag ACK, LAN966x only: PTP over UDP: flagField bit 2 + * (unicastFlag) + * VCAP_KF_L4_DPORT: W16, sparx5: is2/es2 + * Sparx5: TCP/UDP destination port. Overloading for IP_7TUPLE: Non-TCP/UDP IP + * frames: L4_DPORT = L3_IP_PROTO, LAN966x: TCP/UDP destination port + * VCAP_KF_L4_FIN: W1, sparx5: is2/es2 + * TCP flag FIN, LAN966x: TCP flag FIN, and for PTP over UDP: messageType bit 1 + * VCAP_KF_L4_PAYLOAD: W64, sparx5: is2/es2 + * Payload bytes after TCP/UDP header Overloading for IP_7TUPLE: Non TCP/UDP + * frames: Payload bytes 0–7 after IP header. IPv4 options are not parsed so + * payload is always taken 20 bytes after the start of the IPv4 header for non + * TCP/UDP IPv4 frames + * VCAP_KF_L4_PSH: W1, sparx5: is2/es2 + * Sparx5: TCP flag PSH, LAN966x: TCP: TCP flag PSH. PTP over UDP: flagField bit + * 1 (twoStepFlag) + * VCAP_KF_L4_RNG: sparx5 is0 W8, sparx5 is2 W16, sparx5 es2 W16 + * Range checker bitmask (one for each range checker). Input into range checkers + * is taken from classified results (VID, DSCP) and frame (SPORT, DPORT, ETYPE, + * outer VID, inner VID) + * VCAP_KF_L4_RST: W1, sparx5: is2/es2 + * Sparx5: TCP flag RST , LAN966x: TCP: TCP flag RST. PTP over UDP: messageType + * bit 3 + * VCAP_KF_L4_SEQUENCE_EQ0_IS: W1, sparx5: is2/es2 + * Set if TCP sequence number is 0, LAN966x: Overlayed with PTP over UDP: + * messageType bit 0 + * VCAP_KF_L4_SPORT: W16, sparx5: is0/is2/es2 + * TCP/UDP source port + * VCAP_KF_L4_SPORT_EQ_DPORT_IS: W1, sparx5: is2/es2 + * Set if UDP or TCP source port equals UDP or TCP destination port + * VCAP_KF_L4_SYN: W1, sparx5: is2/es2 + * Sparx5: TCP flag SYN, LAN966x: TCP: TCP flag SYN. PTP over UDP: messageType + * bit 2 + * VCAP_KF_L4_URG: W1, sparx5: is2/es2 + * Sparx5: TCP flag URG, LAN966x: TCP: TCP flag URG. PTP over UDP: flagField bit + * 7 (reserved) + * VCAP_KF_LOOKUP_FIRST_IS: W1, sparx5: is0/is2/es2 + * Selects between entries relevant for first and second lookup. Set for first + * lookup, cleared for second lookup. + * VCAP_KF_LOOKUP_GEN_IDX: W12, sparx5: is0 + * Generic index - for chaining CLM instances + * VCAP_KF_LOOKUP_GEN_IDX_SEL: W2, sparx5: is0 + * Select the mode of the Generic Index + * VCAP_KF_LOOKUP_PAG: W8, sparx5: is2 + * Classified Policy Association Group: chains rules from IS1/CLM to IS2 + * VCAP_KF_OAM_CCM_CNTS_EQ0: W1, sparx5: is2/es2 + * Dual-ended loss measurement counters in CCM frames are all zero + * VCAP_KF_OAM_MEL_FLAGS: W7, sparx5: is0 + * Encoding of MD level/MEG level (MEL) + * VCAP_KF_OAM_Y1731_IS: W1, sparx5: is0/is2/es2 + * Set if frame’s EtherType = 0x8902 + * VCAP_KF_PROT_ACTIVE: W1, sparx5: es2 + * Protection is active + * VCAP_KF_TCP_IS: W1, sparx5: is0/is2/es2 + * Set if frame is IPv4 TCP frame (IP protocol = 6) or IPv6 TCP frames (Next + * header = 6) + * VCAP_KF_TCP_UDP_IS: W1, sparx5: is0/is2/es2 + * Set if frame is IPv4/IPv6 TCP or UDP frame (IP protocol/next header equals 6 + * or 17) + * VCAP_KF_TYPE: sparx5 is0 W2, sparx5 is0 W1, sparx5 is2 W4, sparx5 is2 W2, + * sparx5 es2 W3 + * Keyset type id - set by the API + */ + +/* Keyfield names */ +enum vcap_key_field { + VCAP_KF_NO_VALUE, /* initial value */ + VCAP_KF_8021BR_ECID_BASE, + VCAP_KF_8021BR_ECID_EXT, + VCAP_KF_8021BR_E_TAGGED, + VCAP_KF_8021BR_GRP, + VCAP_KF_8021BR_IGR_ECID_BASE, + VCAP_KF_8021BR_IGR_ECID_EXT, + VCAP_KF_8021Q_DEI0, + VCAP_KF_8021Q_DEI1, + VCAP_KF_8021Q_DEI2, + VCAP_KF_8021Q_DEI_CLS, + VCAP_KF_8021Q_PCP0, + VCAP_KF_8021Q_PCP1, + VCAP_KF_8021Q_PCP2, + VCAP_KF_8021Q_PCP_CLS, + VCAP_KF_8021Q_TPID0, + VCAP_KF_8021Q_TPID1, + VCAP_KF_8021Q_TPID2, + VCAP_KF_8021Q_VID0, + VCAP_KF_8021Q_VID1, + VCAP_KF_8021Q_VID2, + VCAP_KF_8021Q_VID_CLS, + VCAP_KF_8021Q_VLAN_TAGGED_IS, + VCAP_KF_8021Q_VLAN_TAGS, + VCAP_KF_ACL_GRP_ID, + VCAP_KF_ARP_ADDR_SPACE_OK_IS, + VCAP_KF_ARP_LEN_OK_IS, + VCAP_KF_ARP_OPCODE, + VCAP_KF_ARP_OPCODE_UNKNOWN_IS, + VCAP_KF_ARP_PROTO_SPACE_OK_IS, + VCAP_KF_ARP_SENDER_MATCH_IS, + VCAP_KF_ARP_TGT_MATCH_IS, + VCAP_KF_COSID_CLS, + VCAP_KF_DST_ENTRY, + VCAP_KF_ES0_ISDX_KEY_ENA, + VCAP_KF_ETYPE, + VCAP_KF_ETYPE_LEN_IS, + VCAP_KF_ETYPE_MPLS, + VCAP_KF_IF_EGR_PORT_MASK, + VCAP_KF_IF_EGR_PORT_MASK_RNG, + VCAP_KF_IF_IGR_PORT, + VCAP_KF_IF_IGR_PORT_MASK, + VCAP_KF_IF_IGR_PORT_MASK_L3, + VCAP_KF_IF_IGR_PORT_MASK_RNG, + VCAP_KF_IF_IGR_PORT_MASK_SEL, + VCAP_KF_IF_IGR_PORT_SEL, + VCAP_KF_IP4_IS, + VCAP_KF_IP_MC_IS, + VCAP_KF_IP_PAYLOAD_5TUPLE, + VCAP_KF_IP_SNAP_IS, + VCAP_KF_ISDX_CLS, + VCAP_KF_ISDX_GT0_IS, + VCAP_KF_L2_BC_IS, + VCAP_KF_L2_DMAC, + VCAP_KF_L2_FWD_IS, + VCAP_KF_L2_MC_IS, + VCAP_KF_L2_PAYLOAD_ETYPE, + VCAP_KF_L2_SMAC, + VCAP_KF_L3_DIP_EQ_SIP_IS, + VCAP_KF_L3_DMAC_DIP_MATCH, + VCAP_KF_L3_DPL_CLS, + VCAP_KF_L3_DSCP, + VCAP_KF_L3_DST_IS, + VCAP_KF_L3_FRAGMENT_TYPE, + VCAP_KF_L3_FRAG_INVLD_L4_LEN, + VCAP_KF_L3_IP4_DIP, + VCAP_KF_L3_IP4_SIP, + VCAP_KF_L3_IP6_DIP, + VCAP_KF_L3_IP6_SIP, + VCAP_KF_L3_IP_PROTO, + VCAP_KF_L3_OPTIONS_IS, + VCAP_KF_L3_PAYLOAD, + VCAP_KF_L3_RT_IS, + VCAP_KF_L3_SMAC_SIP_MATCH, + VCAP_KF_L3_TOS, + VCAP_KF_L3_TTL_GT0, + VCAP_KF_L4_ACK, + VCAP_KF_L4_DPORT, + VCAP_KF_L4_FIN, + VCAP_KF_L4_PAYLOAD, + VCAP_KF_L4_PSH, + VCAP_KF_L4_RNG, + VCAP_KF_L4_RST, + VCAP_KF_L4_SEQUENCE_EQ0_IS, + VCAP_KF_L4_SPORT, + VCAP_KF_L4_SPORT_EQ_DPORT_IS, + VCAP_KF_L4_SYN, + VCAP_KF_L4_URG, + VCAP_KF_LOOKUP_FIRST_IS, + VCAP_KF_LOOKUP_GEN_IDX, + VCAP_KF_LOOKUP_GEN_IDX_SEL, + VCAP_KF_LOOKUP_PAG, + VCAP_KF_MIRROR_ENA, + VCAP_KF_OAM_CCM_CNTS_EQ0, + VCAP_KF_OAM_MEL_FLAGS, + VCAP_KF_OAM_Y1731_IS, + VCAP_KF_PROT_ACTIVE, + VCAP_KF_TCP_IS, + VCAP_KF_TCP_UDP_IS, + VCAP_KF_TYPE, +}; + +/* Actionset names with origin information */ +enum vcap_actionfield_set { + VCAP_AFS_NO_VALUE, /* initial value */ + VCAP_AFS_BASE_TYPE, /* sparx5 is2 X3, sparx5 es2 X3 */ + VCAP_AFS_CLASSIFICATION, /* sparx5 is0 X2 */ + VCAP_AFS_CLASS_REDUCED, /* sparx5 is0 X1 */ + VCAP_AFS_FULL, /* sparx5 is0 X3 */ + VCAP_AFS_MLBS, /* sparx5 is0 X2 */ + VCAP_AFS_MLBS_REDUCED, /* sparx5 is0 X1 */ +}; + +/* List of actionfields with description + * + * VCAP_AF_CLS_VID_SEL: W3, sparx5: is0 + * Controls the classified VID: 0: VID_NONE: No action. 1: VID_ADD: New VID = + * old VID + VID_VAL. 2: VID_REPLACE: New VID = VID_VAL. 3: VID_FIRST_TAG: New + * VID = VID from frame's first tag (outer tag) if available, otherwise VID_VAL. + * 4: VID_SECOND_TAG: New VID = VID from frame's second tag (middle tag) if + * available, otherwise VID_VAL. 5: VID_THIRD_TAG: New VID = VID from frame's + * third tag (inner tag) if available, otherwise VID_VAL. + * VCAP_AF_CNT_ID: sparx5 is2 W12, sparx5 es2 W11 + * Counter ID, used per lookup to index the 4K frame counters (ANA_ACL:CNT_TBL). + * Multiple VCAP IS2 entries can use the same counter. + * VCAP_AF_COPY_PORT_NUM: W7, sparx5: es2 + * QSYS port number when FWD_MODE is redirect or copy + * VCAP_AF_COPY_QUEUE_NUM: W16, sparx5: es2 + * QSYS queue number when FWD_MODE is redirect or copy + * VCAP_AF_CPU_COPY_ENA: W1, sparx5: is2/es2 + * Setting this bit to 1 causes all frames that hit this action to be copied to + * the CPU extraction queue specified in CPU_QUEUE_NUM. + * VCAP_AF_CPU_QUEUE_NUM: W3, sparx5: is2/es2 + * CPU queue number. Used when CPU_COPY_ENA is set. + * VCAP_AF_DEI_ENA: W1, sparx5: is0 + * If set, use DEI_VAL as classified DEI value. Otherwise, DEI from basic + * classification is used + * VCAP_AF_DEI_VAL: W1, sparx5: is0 + * See DEI_ENA + * VCAP_AF_DP_ENA: W1, sparx5: is0 + * If set, use DP_VAL as classified drop precedence level. Otherwise, drop + * precedence level from basic classification is used. + * VCAP_AF_DP_VAL: W2, sparx5: is0 + * See DP_ENA. + * VCAP_AF_DSCP_ENA: W1, sparx5: is0 + * If set, use DSCP_VAL as classified DSCP value. Otherwise, DSCP value from + * basic classification is used. + * VCAP_AF_DSCP_VAL: W6, sparx5: is0 + * See DSCP_ENA. + * VCAP_AF_ES2_REW_CMD: W3, sparx5: es2 + * Command forwarded to REW: 0: No action. 1: SWAP MAC addresses. 2: Do L2CP + * DMAC translation when entering or leaving a tunnel. + * VCAP_AF_FWD_MODE: W2, sparx5: es2 + * Forward selector: 0: Forward. 1: Discard. 2: Redirect. 3: Copy. + * VCAP_AF_HIT_ME_ONCE: W1, sparx5: is2/es2 + * Setting this bit to 1 causes the first frame that hits this action where the + * HIT_CNT counter is zero to be copied to the CPU extraction queue specified in + * CPU_QUEUE_NUM. The HIT_CNT counter is then incremented and any frames that + * hit this action later are not copied to the CPU. To re-enable the HIT_ME_ONCE + * functionality, the HIT_CNT counter must be cleared. + * VCAP_AF_IGNORE_PIPELINE_CTRL: W1, sparx5: is2/es2 + * Ignore ingress pipeline control. This enforces the use of the VCAP IS2 action + * even when the pipeline control has terminated the frame before VCAP IS2. + * VCAP_AF_INTR_ENA: W1, sparx5: is2/es2 + * If set, an interrupt is triggered when this rule is hit + * VCAP_AF_ISDX_ADD_REPLACE_SEL: W1, sparx5: is0 + * Controls the classified ISDX. 0: New ISDX = old ISDX + ISDX_VAL. 1: New ISDX + * = ISDX_VAL. + * VCAP_AF_ISDX_VAL: W12, sparx5: is0 + * See isdx_add_replace_sel + * VCAP_AF_LRN_DIS: W1, sparx5: is2 + * Setting this bit to 1 disables learning of frames hitting this action. + * VCAP_AF_MAP_IDX: W9, sparx5: is0 + * Index for QoS mapping table lookup + * VCAP_AF_MAP_KEY: W3, sparx5: is0 + * Key type for QoS mapping table lookup. 0: DEI0, PCP0 (outer tag). 1: DEI1, + * PCP1 (middle tag). 2: DEI2, PCP2 (inner tag). 3: MPLS TC. 4: PCP0 (outer + * tag). 5: E-DEI, E-PCP (E-TAG). 6: DSCP if available, otherwise none. 7: DSCP + * if available, otherwise DEI0, PCP0 (outer tag) if available using MAP_IDX+8, + * otherwise none + * VCAP_AF_MAP_LOOKUP_SEL: W2, sparx5: is0 + * Selects which of the two QoS Mapping Table lookups that MAP_KEY and MAP_IDX + * are applied to. 0: No changes to the QoS Mapping Table lookup. 1: Update key + * type and index for QoS Mapping Table lookup #0. 2: Update key type and index + * for QoS Mapping Table lookup #1. 3: Reserved. + * VCAP_AF_MASK_MODE: W3, sparx5: is0/is2 + * Controls the PORT_MASK use. Sparx5: 0: OR_DSTMASK, 1: AND_VLANMASK, 2: + * REPLACE_PGID, 3: REPLACE_ALL, 4: REDIR_PGID, 5: OR_PGID_MASK, 6: VSTAX, 7: + * Not applicable. LAN966X: 0: No action, 1: Permit/deny (AND), 2: Policy + * forwarding (DMAC lookup), 3: Redirect. The CPU port is untouched by + * MASK_MODE. + * VCAP_AF_MATCH_ID: W16, sparx5: is0/is2 + * Logical ID for the entry. The MATCH_ID is extracted together with the frame + * if the frame is forwarded to the CPU (CPU_COPY_ENA). The result is placed in + * IFH.CL_RSLT. + * VCAP_AF_MATCH_ID_MASK: W16, sparx5: is0/is2 + * Mask used by MATCH_ID. + * VCAP_AF_MIRROR_PROBE: W2, sparx5: is2 + * Mirroring performed according to configuration of a mirror probe. 0: No + * mirroring. 1: Mirror probe 0. 2: Mirror probe 1. 3: Mirror probe 2 + * VCAP_AF_MIRROR_PROBE_ID: W2, sparx5: es2 + * Signals a mirror probe to be placed in the IFH. Only possible when FWD_MODE + * is copy. 0: No mirroring. 1–3: Use mirror probe 0-2. + * VCAP_AF_NXT_IDX: W12, sparx5: is0 + * Index used as part of key (field G_IDX) in the next lookup. + * VCAP_AF_NXT_IDX_CTRL: W3, sparx5: is0 + * Controls the generation of the G_IDX used in the VCAP CLM next lookup + * VCAP_AF_PAG_OVERRIDE_MASK: W8, sparx5: is0 + * Bits set in this mask will override PAG_VAL from port profile.  New PAG = + * (PAG (input) AND ~PAG_OVERRIDE_MASK) OR (PAG_VAL AND PAG_OVERRIDE_MASK) + * VCAP_AF_PAG_VAL: W8, sparx5: is0 + * See PAG_OVERRIDE_MASK. + * VCAP_AF_PCP_ENA: W1, sparx5: is0 + * If set, use PCP_VAL as classified PCP value. Otherwise, PCP from basic + * classification is used. + * VCAP_AF_PCP_VAL: W3, sparx5: is0 + * See PCP_ENA. + * VCAP_AF_PIPELINE_FORCE_ENA: sparx5 is0 W2, sparx5 is2 W1 + * If set, use PIPELINE_PT unconditionally and set PIPELINE_ACT = NONE if + * PIPELINE_PT == NONE. Overrules previous settings of pipeline point. + * VCAP_AF_PIPELINE_PT: W5, sparx5: is0/is2 + * Pipeline point used if PIPELINE_FORCE_ENA is set + * VCAP_AF_POLICE_ENA: W1, sparx5: is2/es2 + * Setting this bit to 1 causes frames that hit this action to be policed by the + * ACL policer specified in POLICE_IDX. Only applies to the first lookup. + * VCAP_AF_POLICE_IDX: W6, sparx5: is2/es2 + * Selects VCAP policer used when policing frames (POLICE_ENA) + * VCAP_AF_POLICE_REMARK: W1, sparx5: es2 + * If set, frames exceeding policer rates are marked as yellow but not + * discarded. + * VCAP_AF_PORT_MASK: sparx5 is0 W65, sparx5 is2 W68 + * Port mask applied to the forwarding decision based on MASK_MODE. + * VCAP_AF_QOS_ENA: W1, sparx5: is0 + * If set, use QOS_VAL as classified QoS class. Otherwise, QoS class from basic + * classification is used. + * VCAP_AF_QOS_VAL: W3, sparx5: is0 + * See QOS_ENA. + * VCAP_AF_RT_DIS: W1, sparx5: is2 + * If set, routing is disallowed. Only applies when IS_INNER_ACL is 0. See also + * IGR_ACL_ENA, EGR_ACL_ENA, and RLEG_STAT_IDX. + * VCAP_AF_TYPE: W1, sparx5: is0 + * Actionset type id - Set by the API + * VCAP_AF_VID_VAL: W13, sparx5: is0 + * New VID Value + */ + +/* Actionfield names */ +enum vcap_action_field { + VCAP_AF_NO_VALUE, /* initial value */ + VCAP_AF_ACL_MAC, + VCAP_AF_ACL_RT_MODE, + VCAP_AF_CLS_VID_SEL, + VCAP_AF_CNT_ID, + VCAP_AF_COPY_PORT_NUM, + VCAP_AF_COPY_QUEUE_NUM, + VCAP_AF_COSID_ENA, + VCAP_AF_COSID_VAL, + VCAP_AF_CPU_COPY_ENA, + VCAP_AF_CPU_DIS, + VCAP_AF_CPU_ENA, + VCAP_AF_CPU_Q, + VCAP_AF_CPU_QUEUE_NUM, + VCAP_AF_CUSTOM_ACE_ENA, + VCAP_AF_CUSTOM_ACE_OFFSET, + VCAP_AF_DEI_ENA, + VCAP_AF_DEI_VAL, + VCAP_AF_DLB_OFFSET, + VCAP_AF_DMAC_OFFSET_ENA, + VCAP_AF_DP_ENA, + VCAP_AF_DP_VAL, + VCAP_AF_DSCP_ENA, + VCAP_AF_DSCP_VAL, + VCAP_AF_EGR_ACL_ENA, + VCAP_AF_ES2_REW_CMD, + VCAP_AF_FWD_DIS, + VCAP_AF_FWD_MODE, + VCAP_AF_FWD_TYPE, + VCAP_AF_GVID_ADD_REPLACE_SEL, + VCAP_AF_HIT_ME_ONCE, + VCAP_AF_IGNORE_PIPELINE_CTRL, + VCAP_AF_IGR_ACL_ENA, + VCAP_AF_INJ_MASQ_ENA, + VCAP_AF_INJ_MASQ_LPORT, + VCAP_AF_INJ_MASQ_PORT, + VCAP_AF_INTR_ENA, + VCAP_AF_ISDX_ADD_REPLACE_SEL, + VCAP_AF_ISDX_VAL, + VCAP_AF_IS_INNER_ACL, + VCAP_AF_L3_MAC_UPDATE_DIS, + VCAP_AF_LOG_MSG_INTERVAL, + VCAP_AF_LPM_AFFIX_ENA, + VCAP_AF_LPM_AFFIX_VAL, + VCAP_AF_LPORT_ENA, + VCAP_AF_LRN_DIS, + VCAP_AF_MAP_IDX, + VCAP_AF_MAP_KEY, + VCAP_AF_MAP_LOOKUP_SEL, + VCAP_AF_MASK_MODE, + VCAP_AF_MATCH_ID, + VCAP_AF_MATCH_ID_MASK, + VCAP_AF_MIP_SEL, + VCAP_AF_MIRROR_PROBE, + VCAP_AF_MIRROR_PROBE_ID, + VCAP_AF_MPLS_IP_CTRL_ENA, + VCAP_AF_MPLS_MEP_ENA, + VCAP_AF_MPLS_MIP_ENA, + VCAP_AF_MPLS_OAM_FLAVOR, + VCAP_AF_MPLS_OAM_TYPE, + VCAP_AF_NUM_VLD_LABELS, + VCAP_AF_NXT_IDX, + VCAP_AF_NXT_IDX_CTRL, + VCAP_AF_NXT_KEY_TYPE, + VCAP_AF_NXT_NORMALIZE, + VCAP_AF_NXT_NORM_W16_OFFSET, + VCAP_AF_NXT_NORM_W32_OFFSET, + VCAP_AF_NXT_OFFSET_FROM_TYPE, + VCAP_AF_NXT_TYPE_AFTER_OFFSET, + VCAP_AF_OAM_IP_BFD_ENA, + VCAP_AF_OAM_TWAMP_ENA, + VCAP_AF_OAM_Y1731_SEL, + VCAP_AF_PAG_OVERRIDE_MASK, + VCAP_AF_PAG_VAL, + VCAP_AF_PCP_ENA, + VCAP_AF_PCP_VAL, + VCAP_AF_PIPELINE_ACT_SEL, + VCAP_AF_PIPELINE_FORCE_ENA, + VCAP_AF_PIPELINE_PT, + VCAP_AF_PIPELINE_PT_REDUCED, + VCAP_AF_POLICE_ENA, + VCAP_AF_POLICE_IDX, + VCAP_AF_POLICE_REMARK, + VCAP_AF_PORT_MASK, + VCAP_AF_PTP_MASTER_SEL, + VCAP_AF_QOS_ENA, + VCAP_AF_QOS_VAL, + VCAP_AF_REW_CMD, + VCAP_AF_RLEG_DMAC_CHK_DIS, + VCAP_AF_RLEG_STAT_IDX, + VCAP_AF_RSDX_ENA, + VCAP_AF_RSDX_VAL, + VCAP_AF_RSVD_LBL_VAL, + VCAP_AF_RT_DIS, + VCAP_AF_RT_SEL, + VCAP_AF_S2_KEY_SEL_ENA, + VCAP_AF_S2_KEY_SEL_IDX, + VCAP_AF_SAM_SEQ_ENA, + VCAP_AF_SIP_IDX, + VCAP_AF_SWAP_MAC_ENA, + VCAP_AF_TCP_UDP_DPORT, + VCAP_AF_TCP_UDP_ENA, + VCAP_AF_TCP_UDP_SPORT, + VCAP_AF_TC_ENA, + VCAP_AF_TC_LABEL, + VCAP_AF_TPID_SEL, + VCAP_AF_TTL_DECR_DIS, + VCAP_AF_TTL_ENA, + VCAP_AF_TTL_LABEL, + VCAP_AF_TTL_UPDATE_ENA, + VCAP_AF_TYPE, + VCAP_AF_VID_VAL, + VCAP_AF_VLAN_POP_CNT, + VCAP_AF_VLAN_POP_CNT_ENA, + VCAP_AF_VLAN_PUSH_CNT, + VCAP_AF_VLAN_PUSH_CNT_ENA, + VCAP_AF_VLAN_WAS_TAGGED, +}; + +#endif /* __VCAP_AG_API__ */ diff --git a/drivers/net/ethernet/microchip/vcap/vcap_api.c b/drivers/net/ethernet/microchip/vcap/vcap_api.c index 06290fd27cc1..5c3f689d7da7 100644 --- a/drivers/net/ethernet/microchip/vcap/vcap_api.c +++ b/drivers/net/ethernet/microchip/vcap/vcap_api.c @@ -1136,3 +1136,7 @@ int vcap_rule_add_action_u32(struct vcap_rule *rule, return vcap_rule_add_action(rule, action, VCAP_FIELD_U32, &data); } EXPORT_SYMBOL_GPL(vcap_rule_add_action_u32); + +#ifdef CONFIG_VCAP_KUNIT_TEST +#include "vcap_api_kunit.c" +#endif diff --git a/drivers/net/ethernet/microchip/vcap/vcap_api.h b/drivers/net/ethernet/microchip/vcap/vcap_api.h index 4444bf67ebec..eb2eae75c7e8 100644 --- a/drivers/net/ethernet/microchip/vcap/vcap_api.h +++ b/drivers/net/ethernet/microchip/vcap/vcap_api.h @@ -11,6 +11,9 @@ #include /* Use the generated API model */ +#ifdef CONFIG_VCAP_KUNIT_TEST +#include "vcap_ag_api_kunit.h" +#endif #include "vcap_ag_api.h" #define VCAP_CID_LOOKUP_SIZE 100000 /* Chains in a lookup */ diff --git a/drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c b/drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c new file mode 100644 index 000000000000..b01a6e5039b0 --- /dev/null +++ b/drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c @@ -0,0 +1,933 @@ +// SPDX-License-Identifier: BSD-3-Clause +/* Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries. + * Microchip VCAP API kunit test suite + */ + +#include +#include "vcap_api.h" +#include "vcap_api_client.h" +#include "vcap_model_kunit.h" + +/* First we have the test infrastructure that emulates the platform + * implementation + */ +#define TEST_BUF_CNT 100 +#define TEST_BUF_SZ 350 +#define STREAMWSIZE 64 + +static u32 test_updateaddr[STREAMWSIZE] = {}; +static int test_updateaddridx; +static int test_cache_erase_count; +static u32 test_init_start; +static u32 test_init_count; +static u32 test_hw_counter_id; +static struct vcap_cache_data test_hw_cache; + +/* Callback used by the VCAP API */ +static enum vcap_keyfield_set test_val_keyset(struct net_device *ndev, + struct vcap_admin *admin, + struct vcap_rule *rule, + struct vcap_keyset_list *kslist, + u16 l3_proto) +{ + int idx; + + if (kslist->cnt > 0) { + switch (admin->vtype) { + case VCAP_TYPE_IS0: + for (idx = 0; idx < kslist->cnt; idx++) { + if (kslist->keysets[idx] == VCAP_KFS_ETAG) + return kslist->keysets[idx]; + if (kslist->keysets[idx] == VCAP_KFS_PURE_5TUPLE_IP4) + return kslist->keysets[idx]; + if (kslist->keysets[idx] == VCAP_KFS_NORMAL_5TUPLE_IP4) + return kslist->keysets[idx]; + if (kslist->keysets[idx] == VCAP_KFS_NORMAL_7TUPLE) + return kslist->keysets[idx]; + } + break; + case VCAP_TYPE_IS2: + for (idx = 0; idx < kslist->cnt; idx++) { + if (kslist->keysets[idx] == VCAP_KFS_MAC_ETYPE) + return kslist->keysets[idx]; + if (kslist->keysets[idx] == VCAP_KFS_ARP) + return kslist->keysets[idx]; + if (kslist->keysets[idx] == VCAP_KFS_IP_7TUPLE) + return kslist->keysets[idx]; + } + break; + default: + pr_info("%s:%d: no validation for VCAP %d\n", + __func__, __LINE__, admin->vtype); + break; + } + } + return -EINVAL; +} + +/* Callback used by the VCAP API */ +static void test_add_def_fields(struct net_device *ndev, + struct vcap_admin *admin, + struct vcap_rule *rule) +{ + if (admin->vinst == 0 || admin->vinst == 2) + vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_1); + else + vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_0); +} + +/* Callback used by the VCAP API */ +static void test_cache_erase(struct vcap_admin *admin) +{ + if (test_cache_erase_count) { + memset(admin->cache.keystream, 0, test_cache_erase_count); + memset(admin->cache.maskstream, 0, test_cache_erase_count); + memset(admin->cache.actionstream, 0, test_cache_erase_count); + test_cache_erase_count = 0; + } +} + +/* Callback used by the VCAP API */ +static void test_cache_init(struct net_device *ndev, struct vcap_admin *admin, + u32 start, u32 count) +{ + test_init_start = start; + test_init_count = count; +} + +/* Callback used by the VCAP API */ +static void test_cache_read(struct net_device *ndev, struct vcap_admin *admin, + enum vcap_selection sel, u32 start, u32 count) +{ + u32 *keystr, *mskstr, *actstr; + int idx; + + pr_debug("%s:%d: %d %d\n", __func__, __LINE__, start, count); + switch (sel) { + case VCAP_SEL_ENTRY: + keystr = &admin->cache.keystream[start]; + mskstr = &admin->cache.maskstream[start]; + for (idx = 0; idx < count; ++idx) { + pr_debug("%s:%d: keydata[%02d]: 0x%08x\n", __func__, + __LINE__, start + idx, keystr[idx]); + } + for (idx = 0; idx < count; ++idx) { + /* Invert the mask before decoding starts */ + mskstr[idx] = ~mskstr[idx]; + pr_debug("%s:%d: mskdata[%02d]: 0x%08x\n", __func__, + __LINE__, start + idx, mskstr[idx]); + } + break; + case VCAP_SEL_ACTION: + actstr = &admin->cache.actionstream[start]; + for (idx = 0; idx < count; ++idx) { + pr_debug("%s:%d: actdata[%02d]: 0x%08x\n", __func__, + __LINE__, start + idx, actstr[idx]); + } + break; + case VCAP_SEL_COUNTER: + pr_debug("%s:%d\n", __func__, __LINE__); + test_hw_counter_id = start; + admin->cache.counter = test_hw_cache.counter; + admin->cache.sticky = test_hw_cache.sticky; + break; + case VCAP_SEL_ALL: + pr_debug("%s:%d\n", __func__, __LINE__); + break; + } +} + +/* Callback used by the VCAP API */ +static void test_cache_write(struct net_device *ndev, struct vcap_admin *admin, + enum vcap_selection sel, u32 start, u32 count) +{ + u32 *keystr, *mskstr, *actstr; + int idx; + + switch (sel) { + case VCAP_SEL_ENTRY: + keystr = &admin->cache.keystream[start]; + mskstr = &admin->cache.maskstream[start]; + for (idx = 0; idx < count; ++idx) { + pr_debug("%s:%d: keydata[%02d]: 0x%08x\n", __func__, + __LINE__, start + idx, keystr[idx]); + } + for (idx = 0; idx < count; ++idx) { + /* Invert the mask before encoding starts */ + mskstr[idx] = ~mskstr[idx]; + pr_debug("%s:%d: mskdata[%02d]: 0x%08x\n", __func__, + __LINE__, start + idx, mskstr[idx]); + } + break; + case VCAP_SEL_ACTION: + actstr = &admin->cache.actionstream[start]; + for (idx = 0; idx < count; ++idx) { + pr_debug("%s:%d: actdata[%02d]: 0x%08x\n", __func__, + __LINE__, start + idx, actstr[idx]); + } + break; + case VCAP_SEL_COUNTER: + pr_debug("%s:%d\n", __func__, __LINE__); + test_hw_counter_id = start; + test_hw_cache.counter = admin->cache.counter; + test_hw_cache.sticky = admin->cache.sticky; + break; + case VCAP_SEL_ALL: + pr_err("%s:%d: cannot write all streams at once\n", + __func__, __LINE__); + break; + } +} + +/* Callback used by the VCAP API */ +static void test_cache_update(struct net_device *ndev, struct vcap_admin *admin, + enum vcap_command cmd, + enum vcap_selection sel, u32 addr) +{ + if (test_updateaddridx < ARRAY_SIZE(test_updateaddr)) + test_updateaddr[test_updateaddridx] = addr; + else + pr_err("%s:%d: overflow: %d\n", __func__, __LINE__, test_updateaddridx); + test_updateaddridx++; +} + +static void test_cache_move(struct net_device *ndev, struct vcap_admin *admin, + u32 addr, int offset, int count) +{ +} + +/* Provide port information via a callback interface */ +static int vcap_test_port_info(struct net_device *ndev, enum vcap_type vtype, + int (*pf)(void *out, int arg, const char *fmt, ...), + void *out, int arg) +{ + return 0; +} + +struct vcap_operations test_callbacks = { + .validate_keyset = test_val_keyset, + .add_default_fields = test_add_def_fields, + .cache_erase = test_cache_erase, + .cache_write = test_cache_write, + .cache_read = test_cache_read, + .init = test_cache_init, + .update = test_cache_update, + .move = test_cache_move, + .port_info = vcap_test_port_info, +}; + +struct vcap_control test_vctrl = { + .vcaps = kunit_test_vcaps, + .stats = &kunit_test_vcap_stats, + .ops = &test_callbacks, +}; + +static void vcap_test_api_init(struct vcap_admin *admin) +{ + /* Initialize the shared objects */ + INIT_LIST_HEAD(&test_vctrl.list); + INIT_LIST_HEAD(&admin->list); + INIT_LIST_HEAD(&admin->rules); + list_add_tail(&admin->list, &test_vctrl.list); + memset(test_updateaddr, 0, sizeof(test_updateaddr)); + test_updateaddridx = 0; +} + +/* Define the test cases. */ + +static void vcap_api_set_bit_1_test(struct kunit *test) +{ + struct vcap_stream_iter iter = { + .offset = 35, + .sw_width = 52, + .reg_idx = 1, + .reg_bitpos = 20, + .tg = 0 + }; + u32 stream[2] = {0}; + + vcap_set_bit(stream, &iter, 1); + + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]); + KUNIT_EXPECT_EQ(test, (u32)BIT(20), stream[1]); +} + +static void vcap_api_set_bit_0_test(struct kunit *test) +{ + struct vcap_stream_iter iter = { + .offset = 35, + .sw_width = 52, + .reg_idx = 2, + .reg_bitpos = 11, + .tg = 0 + }; + u32 stream[3] = {~0, ~0, ~0}; + + vcap_set_bit(stream, &iter, 0); + + KUNIT_EXPECT_EQ(test, (u32)~0, stream[0]); + KUNIT_EXPECT_EQ(test, (u32)~0, stream[1]); + KUNIT_EXPECT_EQ(test, (u32)~BIT(11), stream[2]); +} + +static void vcap_api_iterator_init_test(struct kunit *test) +{ + struct vcap_stream_iter iter; + struct vcap_typegroup typegroups[] = { + { .offset = 0, .width = 2, .value = 2, }, + { .offset = 156, .width = 1, .value = 0, }, + { .offset = 0, .width = 0, .value = 0, }, + }; + struct vcap_typegroup typegroups2[] = { + { .offset = 0, .width = 3, .value = 4, }, + { .offset = 49, .width = 2, .value = 0, }, + { .offset = 98, .width = 2, .value = 0, }, + }; + + vcap_iter_init(&iter, 52, typegroups, 86); + + KUNIT_EXPECT_EQ(test, 52, iter.sw_width); + KUNIT_EXPECT_EQ(test, 86 + 2, iter.offset); + KUNIT_EXPECT_EQ(test, 3, iter.reg_idx); + KUNIT_EXPECT_EQ(test, 4, iter.reg_bitpos); + + vcap_iter_init(&iter, 49, typegroups2, 134); + + KUNIT_EXPECT_EQ(test, 49, iter.sw_width); + KUNIT_EXPECT_EQ(test, 134 + 7, iter.offset); + KUNIT_EXPECT_EQ(test, 5, iter.reg_idx); + KUNIT_EXPECT_EQ(test, 11, iter.reg_bitpos); +} + +static void vcap_api_iterator_next_test(struct kunit *test) +{ + struct vcap_stream_iter iter; + struct vcap_typegroup typegroups[] = { + { .offset = 0, .width = 4, .value = 8, }, + { .offset = 49, .width = 1, .value = 0, }, + { .offset = 98, .width = 2, .value = 0, }, + { .offset = 147, .width = 3, .value = 0, }, + { .offset = 196, .width = 2, .value = 0, }, + { .offset = 245, .width = 1, .value = 0, }, + }; + int idx; + + vcap_iter_init(&iter, 49, typegroups, 86); + + KUNIT_EXPECT_EQ(test, 49, iter.sw_width); + KUNIT_EXPECT_EQ(test, 86 + 5, iter.offset); + KUNIT_EXPECT_EQ(test, 3, iter.reg_idx); + KUNIT_EXPECT_EQ(test, 10, iter.reg_bitpos); + + vcap_iter_next(&iter); + + KUNIT_EXPECT_EQ(test, 91 + 1, iter.offset); + KUNIT_EXPECT_EQ(test, 3, iter.reg_idx); + KUNIT_EXPECT_EQ(test, 11, iter.reg_bitpos); + + for (idx = 0; idx < 6; idx++) + vcap_iter_next(&iter); + + KUNIT_EXPECT_EQ(test, 92 + 6 + 2, iter.offset); + KUNIT_EXPECT_EQ(test, 4, iter.reg_idx); + KUNIT_EXPECT_EQ(test, 2, iter.reg_bitpos); +} + +static void vcap_api_encode_typegroups_test(struct kunit *test) +{ + u32 stream[12] = {0}; + struct vcap_typegroup typegroups[] = { + { .offset = 0, .width = 4, .value = 8, }, + { .offset = 49, .width = 1, .value = 1, }, + { .offset = 98, .width = 2, .value = 3, }, + { .offset = 147, .width = 3, .value = 5, }, + { .offset = 196, .width = 2, .value = 2, }, + { .offset = 245, .width = 5, .value = 27, }, + { .offset = 0, .width = 0, .value = 0, }, + }; + + vcap_encode_typegroups(stream, 49, typegroups, false); + + KUNIT_EXPECT_EQ(test, (u32)0x8, stream[0]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[1]); + KUNIT_EXPECT_EQ(test, (u32)0x1, stream[2]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[3]); + KUNIT_EXPECT_EQ(test, (u32)0x3, stream[4]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[5]); + KUNIT_EXPECT_EQ(test, (u32)0x5, stream[6]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[7]); + KUNIT_EXPECT_EQ(test, (u32)0x2, stream[8]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[9]); + KUNIT_EXPECT_EQ(test, (u32)27, stream[10]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[11]); +} + +static void vcap_api_encode_bit_test(struct kunit *test) +{ + struct vcap_stream_iter iter; + u32 stream[4] = {0}; + struct vcap_typegroup typegroups[] = { + { .offset = 0, .width = 4, .value = 8, }, + { .offset = 49, .width = 1, .value = 1, }, + { .offset = 98, .width = 2, .value = 3, }, + { .offset = 147, .width = 3, .value = 5, }, + { .offset = 196, .width = 2, .value = 2, }, + { .offset = 245, .width = 1, .value = 0, }, + }; + + vcap_iter_init(&iter, 49, typegroups, 44); + + KUNIT_EXPECT_EQ(test, 48, iter.offset); + KUNIT_EXPECT_EQ(test, 1, iter.reg_idx); + KUNIT_EXPECT_EQ(test, 16, iter.reg_bitpos); + + vcap_encode_bit(stream, &iter, 1); + + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]); + KUNIT_EXPECT_EQ(test, (u32)BIT(16), stream[1]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[2]); +} + +static void vcap_api_encode_field_test(struct kunit *test) +{ + struct vcap_stream_iter iter; + u32 stream[16] = {0}; + struct vcap_typegroup typegroups[] = { + { .offset = 0, .width = 4, .value = 8, }, + { .offset = 49, .width = 1, .value = 1, }, + { .offset = 98, .width = 2, .value = 3, }, + { .offset = 147, .width = 3, .value = 5, }, + { .offset = 196, .width = 2, .value = 2, }, + { .offset = 245, .width = 5, .value = 27, }, + { .offset = 0, .width = 0, .value = 0, }, + }; + struct vcap_field rf = { + .type = VCAP_FIELD_U32, + .offset = 86, + .width = 4, + }; + u8 value[] = {0x5}; + + vcap_iter_init(&iter, 49, typegroups, rf.offset); + + KUNIT_EXPECT_EQ(test, 91, iter.offset); + KUNIT_EXPECT_EQ(test, 3, iter.reg_idx); + KUNIT_EXPECT_EQ(test, 10, iter.reg_bitpos); + + vcap_encode_field(stream, &iter, rf.width, value); + + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[1]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[2]); + KUNIT_EXPECT_EQ(test, (u32)(0x5 << 10), stream[3]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[4]); + + vcap_encode_typegroups(stream, 49, typegroups, false); + + KUNIT_EXPECT_EQ(test, (u32)0x8, stream[0]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[1]); + KUNIT_EXPECT_EQ(test, (u32)0x1, stream[2]); + KUNIT_EXPECT_EQ(test, (u32)(0x5 << 10), stream[3]); + KUNIT_EXPECT_EQ(test, (u32)0x3, stream[4]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[5]); + KUNIT_EXPECT_EQ(test, (u32)0x5, stream[6]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[7]); + KUNIT_EXPECT_EQ(test, (u32)0x2, stream[8]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[9]); + KUNIT_EXPECT_EQ(test, (u32)27, stream[10]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[11]); +} + +/* In this testcase the subword is smaller than a register */ +static void vcap_api_encode_short_field_test(struct kunit *test) +{ + struct vcap_stream_iter iter; + int sw_width = 21; + u32 stream[6] = {0}; + struct vcap_typegroup tgt[] = { + { .offset = 0, .width = 3, .value = 7, }, + { .offset = 21, .width = 2, .value = 3, }, + { .offset = 42, .width = 1, .value = 1, }, + { .offset = 0, .width = 0, .value = 0, }, + }; + struct vcap_field rf = { + .type = VCAP_FIELD_U32, + .offset = 25, + .width = 4, + }; + u8 value[] = {0x5}; + + vcap_iter_init(&iter, sw_width, tgt, rf.offset); + + KUNIT_EXPECT_EQ(test, 1, iter.regs_per_sw); + KUNIT_EXPECT_EQ(test, 21, iter.sw_width); + KUNIT_EXPECT_EQ(test, 25 + 3 + 2, iter.offset); + KUNIT_EXPECT_EQ(test, 1, iter.reg_idx); + KUNIT_EXPECT_EQ(test, 25 + 3 + 2 - sw_width, iter.reg_bitpos); + + vcap_encode_field(stream, &iter, rf.width, value); + + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]); + KUNIT_EXPECT_EQ(test, (u32)(0x5 << (25 + 3 + 2 - sw_width)), stream[1]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[2]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[3]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[4]); + KUNIT_EXPECT_EQ(test, (u32)0x0, stream[5]); + + vcap_encode_typegroups(stream, sw_width, tgt, false); + + KUNIT_EXPECT_EQ(test, (u32)7, stream[0]); + KUNIT_EXPECT_EQ(test, (u32)((0x5 << (25 + 3 + 2 - sw_width)) + 3), stream[1]); + KUNIT_EXPECT_EQ(test, (u32)1, stream[2]); + KUNIT_EXPECT_EQ(test, (u32)0, stream[3]); + KUNIT_EXPECT_EQ(test, (u32)0, stream[4]); + KUNIT_EXPECT_EQ(test, (u32)0, stream[5]); +} + +static void vcap_api_encode_keyfield_test(struct kunit *test) +{ + u32 keywords[16] = {0}; + u32 maskwords[16] = {0}; + struct vcap_admin admin = { + .vtype = VCAP_TYPE_IS2, + .cache = { + .keystream = keywords, + .maskstream = maskwords, + .actionstream = keywords, + }, + }; + struct vcap_rule_internal rule = { + .admin = &admin, + .data = { + .keyset = VCAP_KFS_MAC_ETYPE, + }, + .vctrl = &test_vctrl, + }; + struct vcap_client_keyfield ckf = { + .ctrl.list = {}, + .ctrl.key = VCAP_KF_ISDX_CLS, + .ctrl.type = VCAP_FIELD_U32, + .data.u32.value = 0xeef014a1, + .data.u32.mask = 0xfff, + }; + struct vcap_field rf = { + .type = VCAP_FIELD_U32, + .offset = 56, + .width = 12, + }; + struct vcap_typegroup tgt[] = { + { .offset = 0, .width = 2, .value = 2, }, + { .offset = 156, .width = 1, .value = 1, }, + { .offset = 0, .width = 0, .value = 0, }, + }; + + vcap_test_api_init(&admin); + vcap_encode_keyfield(&rule, &ckf, &rf, tgt); + + /* Key */ + KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[0]); + KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[1]); + KUNIT_EXPECT_EQ(test, (u32)(0x04a1 << 6), keywords[2]); + KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[3]); + KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[4]); + KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[5]); + KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[6]); + + /* Mask */ + KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[0]); + KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[1]); + KUNIT_EXPECT_EQ(test, (u32)(0x0fff << 6), maskwords[2]); + KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[3]); + KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[4]); + KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[5]); + KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[6]); +} + +static void vcap_api_encode_max_keyfield_test(struct kunit *test) +{ + int idx; + u32 keywords[6] = {0}; + u32 maskwords[6] = {0}; + struct vcap_admin admin = { + .vtype = VCAP_TYPE_IS2, + /* IS2 sw_width = 52 bit */ + .cache = { + .keystream = keywords, + .maskstream = maskwords, + .actionstream = keywords, + }, + }; + struct vcap_rule_internal rule = { + .admin = &admin, + .data = { + .keyset = VCAP_KFS_IP_7TUPLE, + }, + .vctrl = &test_vctrl, + }; + struct vcap_client_keyfield ckf = { + .ctrl.list = {}, + .ctrl.key = VCAP_KF_L3_IP6_DIP, + .ctrl.type = VCAP_FIELD_U128, + .data.u128.value = { 0xa1, 0xa2, 0xa3, 0xa4, 0, 0, 0x43, 0, + 0, 0, 0, 0, 0, 0, 0x78, 0x8e, }, + .data.u128.mask = { 0xff, 0xff, 0xff, 0xff, 0, 0, 0xff, 0, + 0, 0, 0, 0, 0, 0, 0xff, 0xff }, + }; + struct vcap_field rf = { + .type = VCAP_FIELD_U128, + .offset = 0, + .width = 128, + }; + struct vcap_typegroup tgt[] = { + { .offset = 0, .width = 2, .value = 2, }, + { .offset = 156, .width = 1, .value = 1, }, + { .offset = 0, .width = 0, .value = 0, }, + }; + u32 keyres[] = { + 0x928e8a84, + 0x000c0002, + 0x00000010, + 0x00000000, + 0x0239e000, + 0x00000000, + }; + u32 mskres[] = { + 0xfffffffc, + 0x000c0003, + 0x0000003f, + 0x00000000, + 0x03fffc00, + 0x00000000, + }; + + vcap_encode_keyfield(&rule, &ckf, &rf, tgt); + + /* Key */ + for (idx = 0; idx < ARRAY_SIZE(keyres); ++idx) + KUNIT_EXPECT_EQ(test, keyres[idx], keywords[idx]); + /* Mask */ + for (idx = 0; idx < ARRAY_SIZE(mskres); ++idx) + KUNIT_EXPECT_EQ(test, mskres[idx], maskwords[idx]); +} + +static void vcap_api_encode_actionfield_test(struct kunit *test) +{ + u32 actwords[16] = {0}; + int sw_width = 21; + struct vcap_admin admin = { + .vtype = VCAP_TYPE_ES2, /* act_width = 21 */ + .cache = { + .actionstream = actwords, + }, + }; + struct vcap_rule_internal rule = { + .admin = &admin, + .data = { + .actionset = VCAP_AFS_BASE_TYPE, + }, + .vctrl = &test_vctrl, + }; + struct vcap_client_actionfield caf = { + .ctrl.list = {}, + .ctrl.action = VCAP_AF_POLICE_IDX, + .ctrl.type = VCAP_FIELD_U32, + .data.u32.value = 0x67908032, + }; + struct vcap_field rf = { + .type = VCAP_FIELD_U32, + .offset = 35, + .width = 6, + }; + struct vcap_typegroup tgt[] = { + { .offset = 0, .width = 2, .value = 2, }, + { .offset = 21, .width = 1, .value = 1, }, + { .offset = 42, .width = 1, .value = 0, }, + { .offset = 0, .width = 0, .value = 0, }, + }; + + vcap_encode_actionfield(&rule, &caf, &rf, tgt); + + /* Action */ + KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[0]); + KUNIT_EXPECT_EQ(test, (u32)((0x32 << (35 + 2 + 1 - sw_width)) & 0x1fffff), actwords[1]); + KUNIT_EXPECT_EQ(test, (u32)((0x32 >> ((2 * sw_width) - 38 - 1))), actwords[2]); + KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[3]); + KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[4]); + KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[5]); + KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[6]); +} + +static void vcap_api_keyfield_typegroup_test(struct kunit *test) +{ + const struct vcap_typegroup *tg; + + tg = vcap_keyfield_typegroup(&test_vctrl, VCAP_TYPE_IS2, VCAP_KFS_MAC_ETYPE); + KUNIT_EXPECT_PTR_NE(test, NULL, tg); + KUNIT_EXPECT_EQ(test, 0, tg[0].offset); + KUNIT_EXPECT_EQ(test, 2, tg[0].width); + KUNIT_EXPECT_EQ(test, 2, tg[0].value); + KUNIT_EXPECT_EQ(test, 156, tg[1].offset); + KUNIT_EXPECT_EQ(test, 1, tg[1].width); + KUNIT_EXPECT_EQ(test, 0, tg[1].value); + KUNIT_EXPECT_EQ(test, 0, tg[2].offset); + KUNIT_EXPECT_EQ(test, 0, tg[2].width); + KUNIT_EXPECT_EQ(test, 0, tg[2].value); + + tg = vcap_keyfield_typegroup(&test_vctrl, VCAP_TYPE_ES2, VCAP_KFS_LL_FULL); + KUNIT_EXPECT_PTR_EQ(test, NULL, tg); +} + +static void vcap_api_actionfield_typegroup_test(struct kunit *test) +{ + const struct vcap_typegroup *tg; + + tg = vcap_actionfield_typegroup(&test_vctrl, VCAP_TYPE_IS0, VCAP_AFS_FULL); + KUNIT_EXPECT_PTR_NE(test, NULL, tg); + KUNIT_EXPECT_EQ(test, 0, tg[0].offset); + KUNIT_EXPECT_EQ(test, 3, tg[0].width); + KUNIT_EXPECT_EQ(test, 4, tg[0].value); + KUNIT_EXPECT_EQ(test, 110, tg[1].offset); + KUNIT_EXPECT_EQ(test, 2, tg[1].width); + KUNIT_EXPECT_EQ(test, 0, tg[1].value); + KUNIT_EXPECT_EQ(test, 220, tg[2].offset); + KUNIT_EXPECT_EQ(test, 2, tg[2].width); + KUNIT_EXPECT_EQ(test, 0, tg[2].value); + KUNIT_EXPECT_EQ(test, 0, tg[3].offset); + KUNIT_EXPECT_EQ(test, 0, tg[3].width); + KUNIT_EXPECT_EQ(test, 0, tg[3].value); + + tg = vcap_actionfield_typegroup(&test_vctrl, VCAP_TYPE_IS2, VCAP_AFS_CLASSIFICATION); + KUNIT_EXPECT_PTR_EQ(test, NULL, tg); +} + +static void vcap_api_vcap_keyfields_test(struct kunit *test) +{ + const struct vcap_field *ft; + + ft = vcap_keyfields(&test_vctrl, VCAP_TYPE_IS2, VCAP_KFS_MAC_ETYPE); + KUNIT_EXPECT_PTR_NE(test, NULL, ft); + + /* Keyset that is not available and within the maximum keyset enum value */ + ft = vcap_keyfields(&test_vctrl, VCAP_TYPE_ES2, VCAP_KFS_PURE_5TUPLE_IP4); + KUNIT_EXPECT_PTR_EQ(test, NULL, ft); + + /* Keyset that is not available and beyond the maximum keyset enum value */ + ft = vcap_keyfields(&test_vctrl, VCAP_TYPE_ES2, VCAP_KFS_LL_FULL); + KUNIT_EXPECT_PTR_EQ(test, NULL, ft); +} + +static void vcap_api_vcap_actionfields_test(struct kunit *test) +{ + const struct vcap_field *ft; + + ft = vcap_actionfields(&test_vctrl, VCAP_TYPE_IS0, VCAP_AFS_FULL); + KUNIT_EXPECT_PTR_NE(test, NULL, ft); + + ft = vcap_actionfields(&test_vctrl, VCAP_TYPE_IS2, VCAP_AFS_FULL); + KUNIT_EXPECT_PTR_EQ(test, NULL, ft); + + ft = vcap_actionfields(&test_vctrl, VCAP_TYPE_IS2, VCAP_AFS_CLASSIFICATION); + KUNIT_EXPECT_PTR_EQ(test, NULL, ft); +} + +static void vcap_api_encode_rule_keyset_test(struct kunit *test) +{ + u32 keywords[16] = {0}; + u32 maskwords[16] = {0}; + struct vcap_admin admin = { + .vtype = VCAP_TYPE_IS2, + .cache = { + .keystream = keywords, + .maskstream = maskwords, + }, + }; + struct vcap_rule_internal rule = { + .admin = &admin, + .data = { + .keyset = VCAP_KFS_MAC_ETYPE, + }, + .vctrl = &test_vctrl, + }; + struct vcap_client_keyfield ckf[] = { + { + .ctrl.key = VCAP_KF_TYPE, + .ctrl.type = VCAP_FIELD_U32, + .data.u32.value = 0x00, + .data.u32.mask = 0x0f, + }, + { + .ctrl.key = VCAP_KF_LOOKUP_FIRST_IS, + .ctrl.type = VCAP_FIELD_BIT, + .data.u1.value = 0x01, + .data.u1.mask = 0x01, + }, + { + .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK_L3, + .ctrl.type = VCAP_FIELD_BIT, + .data.u1.value = 0x00, + .data.u1.mask = 0x01, + }, + { + .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK_RNG, + .ctrl.type = VCAP_FIELD_U32, + .data.u32.value = 0x00, + .data.u32.mask = 0x0f, + }, + { + .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK, + .ctrl.type = VCAP_FIELD_U72, + .data.u72.value = {0x0, 0x00, 0x00, 0x00}, + .data.u72.mask = {0xfd, 0xff, 0xff, 0xff}, + }, + { + .ctrl.key = VCAP_KF_L2_DMAC, + .ctrl.type = VCAP_FIELD_U48, + /* Opposite endianness */ + .data.u48.value = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06}, + .data.u48.mask = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, + }, + { + .ctrl.key = VCAP_KF_ETYPE_LEN_IS, + .ctrl.type = VCAP_FIELD_BIT, + .data.u1.value = 0x01, + .data.u1.mask = 0x01, + }, + { + .ctrl.key = VCAP_KF_ETYPE, + .ctrl.type = VCAP_FIELD_U32, + .data.u32.value = 0xaabb, + .data.u32.mask = 0xffff, + }, + }; + int idx; + int ret; + + /* Empty entry list */ + INIT_LIST_HEAD(&rule.data.keyfields); + ret = vcap_encode_rule_keyset(&rule); + KUNIT_EXPECT_EQ(test, -EINVAL, ret); + + for (idx = 0; idx < ARRAY_SIZE(ckf); idx++) + list_add_tail(&ckf[idx].ctrl.list, &rule.data.keyfields); + ret = vcap_encode_rule_keyset(&rule); + KUNIT_EXPECT_EQ(test, 0, ret); + + /* The key and mask values below are from an actual Sparx5 rule config */ + /* Key */ + KUNIT_EXPECT_EQ(test, (u32)0x00000042, keywords[0]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[1]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[2]); + KUNIT_EXPECT_EQ(test, (u32)0x00020100, keywords[3]); + KUNIT_EXPECT_EQ(test, (u32)0x60504030, keywords[4]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[5]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[6]); + KUNIT_EXPECT_EQ(test, (u32)0x0002aaee, keywords[7]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[8]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[9]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[10]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[11]); + + /* Mask: they will be inverted when applied to the register */ + KUNIT_EXPECT_EQ(test, (u32)~0x00b07f80, maskwords[0]); + KUNIT_EXPECT_EQ(test, (u32)~0xfff00000, maskwords[1]); + KUNIT_EXPECT_EQ(test, (u32)~0xfffffffc, maskwords[2]); + KUNIT_EXPECT_EQ(test, (u32)~0xfff000ff, maskwords[3]); + KUNIT_EXPECT_EQ(test, (u32)~0x00000000, maskwords[4]); + KUNIT_EXPECT_EQ(test, (u32)~0xfffffff0, maskwords[5]); + KUNIT_EXPECT_EQ(test, (u32)~0xfffffffe, maskwords[6]); + KUNIT_EXPECT_EQ(test, (u32)~0xfffc0001, maskwords[7]); + KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[8]); + KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[9]); + KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[10]); + KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[11]); +} + +static void vcap_api_encode_rule_actionset_test(struct kunit *test) +{ + u32 actwords[16] = {0}; + struct vcap_admin admin = { + .vtype = VCAP_TYPE_IS2, + .cache = { + .actionstream = actwords, + }, + }; + struct vcap_rule_internal rule = { + .admin = &admin, + .data = { + .actionset = VCAP_AFS_BASE_TYPE, + }, + .vctrl = &test_vctrl, + }; + struct vcap_client_actionfield caf[] = { + { + .ctrl.action = VCAP_AF_MATCH_ID, + .ctrl.type = VCAP_FIELD_U32, + .data.u32.value = 0x01, + }, + { + .ctrl.action = VCAP_AF_MATCH_ID_MASK, + .ctrl.type = VCAP_FIELD_U32, + .data.u32.value = 0x01, + }, + { + .ctrl.action = VCAP_AF_CNT_ID, + .ctrl.type = VCAP_FIELD_U32, + .data.u32.value = 0x64, + }, + }; + int idx; + int ret; + + /* Empty entry list */ + INIT_LIST_HEAD(&rule.data.actionfields); + ret = vcap_encode_rule_actionset(&rule); + /* We allow rules with no actions */ + KUNIT_EXPECT_EQ(test, 0, ret); + + for (idx = 0; idx < ARRAY_SIZE(caf); idx++) + list_add_tail(&caf[idx].ctrl.list, &rule.data.actionfields); + ret = vcap_encode_rule_actionset(&rule); + KUNIT_EXPECT_EQ(test, 0, ret); + + /* The action values below are from an actual Sparx5 rule config */ + KUNIT_EXPECT_EQ(test, (u32)0x00000002, actwords[0]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[1]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[2]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[3]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[4]); + KUNIT_EXPECT_EQ(test, (u32)0x00100000, actwords[5]); + KUNIT_EXPECT_EQ(test, (u32)0x06400010, actwords[6]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[7]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[8]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[9]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[10]); + KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[11]); +} + +static struct kunit_case vcap_api_encoding_test_cases[] = { + KUNIT_CASE(vcap_api_set_bit_1_test), + KUNIT_CASE(vcap_api_set_bit_0_test), + KUNIT_CASE(vcap_api_iterator_init_test), + KUNIT_CASE(vcap_api_iterator_next_test), + KUNIT_CASE(vcap_api_encode_typegroups_test), + KUNIT_CASE(vcap_api_encode_bit_test), + KUNIT_CASE(vcap_api_encode_field_test), + KUNIT_CASE(vcap_api_encode_short_field_test), + KUNIT_CASE(vcap_api_encode_keyfield_test), + KUNIT_CASE(vcap_api_encode_max_keyfield_test), + KUNIT_CASE(vcap_api_encode_actionfield_test), + KUNIT_CASE(vcap_api_keyfield_typegroup_test), + KUNIT_CASE(vcap_api_actionfield_typegroup_test), + KUNIT_CASE(vcap_api_vcap_keyfields_test), + KUNIT_CASE(vcap_api_vcap_actionfields_test), + KUNIT_CASE(vcap_api_encode_rule_keyset_test), + KUNIT_CASE(vcap_api_encode_rule_actionset_test), + {} +}; + +static struct kunit_suite vcap_api_encoding_test_suite = { + .name = "VCAP_API_Encoding_Testsuite", + .test_cases = vcap_api_encoding_test_cases, +}; + +kunit_test_suite(vcap_api_encoding_test_suite); -- 2.38.1