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 A35E4ECAAD4 for ; Sat, 3 Sep 2022 18:31:15 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231879AbiICSbN (ORCPT ); Sat, 3 Sep 2022 14:31:13 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42944 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229493AbiICSbL (ORCPT ); Sat, 3 Sep 2022 14:31:11 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 4A29D52809 for ; Sat, 3 Sep 2022 11:31:09 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 013A2ED1; Sat, 3 Sep 2022 11:31:15 -0700 (PDT) Received: from e120937-lin.home (unknown [172.31.20.19]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id BD2683F71A; Sat, 3 Sep 2022 11:31:06 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Cc: sudeep.holla@arm.com, james.quinlan@broadcom.com, Jonathan.Cameron@Huawei.com, f.fainelli@gmail.com, etienne.carriere@linaro.org, vincent.guittot@linaro.org, souvik.chakravarty@arm.com, wleavitt@marvell.com, peter.hilber@opensynergy.com, nicola.mazzucato@arm.com, tarek.el-sherbiny@arm.com, cristian.marussi@arm.com Subject: [PATCH v3 0/9] Introduce a unified API for SCMI Server testing Date: Sat, 3 Sep 2022 19:30:33 +0100 Message-Id: <20220903183042.3913053-1-cristian.marussi@arm.com> X-Mailer: git-send-email 2.32.0 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 Hi all, This series aims to introduce a new SCMI unified userspace interface meant to ease testing an SCMI Server implementation for compliance, fuzzing etc., from the perspective of the OSPM agent (non-secure world only ...) It is proposed as a testing/development facility, it is NOT meant to be a feature to use in production, but only enabled in Kconfig for test deployments. Currently an SCMI Compliance Suite like the one at [1] can only work by injecting SCMI messages at the SCMI transport layer using the mailbox test driver (CONFIG_MAILBOX_TEST) via its few debugfs entries and looking at the related replies from the SCMI backend Server. This approach has a few drawbacks: - the SCMI Server under test MUST be reachable through a mailbox based SCMI transport: any other SCMI Server placement is not possible (like in a VM reachable via SCMI Virtio). In order to cover other placements in the current scenario we should write some sort of test driver for each and every existent SCMI transport and for any future additional transport ...this clearly does not scale. - even in the mailbox case the userspace Compliance suite cannot simply send and receive bare SCMI messages BUT it has to properly lay them out into the shared memory exposed by the mailbox test driver as expected by the transport definitions. In other words such a userspace test application has to, not only use a proper transport driver for the system at hand, but it also has to have a comprehensive knowledge of the internals of the underlying transport in order to operate. - last but not least, the system under test has to be specifically configured and built, in terms of Kconfig and DT, to perform such kind of testing, it cannot be used for anything else, which is unfortunate for CI/CD deployments. This series introduces a new SCMI Raw mode support feature that, when configured and enabled exposes a new interface in debugfs through which: - a userspace application can inject bare SCMI binary messages into the SCMI core stack; such messages will be routed by the SCMI regular kernel stack to the backend Server using the currently configured transport transparently: in other words you can test the SCMI server, no matter where it is placed, as long as it is reachable from the currently configured SCMI stack. Same goes the other way around on the reading path: any SCMI server reply can be read as a bare SCMI binary message from the same debugfs path. - as a direct consequence of this way of injecting bare messages in the middle of the SCMI stack (instead of beneath it at the transport layer) the user application has to handle only bare SCMI messages without having to worry about the specific underlying transport internals that will be taken care of by the SCMI core stack itself using its own machinery, without duplicating such logic. - a system under test, once configured with SCMI Raw support enabled in Kconfig, can be booted without any particular DT change. In V2 the runtime enable/disable switching capability has been removed (for now) since still not deemed to be stable/reliable enough: as a consequence when SCMI Raw support is compiled in, the regular SCMI stack drivers are now inhibited permanently for that Kernel. A quick and trivial example from the shell...reading from a sensor injecting a properly crafted packet in raw mode: # INJECT THE SENSOR_READING MESSAGE FOR SENSOR ID=1 (binary little endian) root@deb-buster-arm64:~# echo -e -n \\x06\\x54\\x00\\x00\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00 > /sys/kernel/debug/scmi_raw/message # READING BACK THE REPLY... root@deb-buster-arm64:~# cat /sys/kernel/debug/scmi_raw/message | od --endian=little -t x4 0000000 00005406 00000000 00000335 00000000 0000020 while doing that, since Raw mode makes (partial) use of the regular SCMI stack, you can observe the messages going through the SCMI stack with the usual traces: bash-329 [000] ..... 14183.446808: scmi_msg_dump: pt=15 t=CMND msg_id=06 seq=0000 s=0 pyld=0100000000000000 irq/35-mhu_db_l-81 [000] ..... 14183.447809: scmi_msg_dump: pt=15 t=RESP msg_id=06 seq=0000 s=0 pyld=3503000000000000 ..trying to read in async when the backend server does NOT supports asyncs: # AN ASYNC SENSOR READING REQUEST... root@deb-buster-arm64:~# echo -e -n \\x06\\x54\\x00\\x00\\x01\\x00\\x00\\x00\\x01\\x00\\x00\\x00 > /sys/kernel/debug/scmi_raw/message_async bash-329 [000] ..... 16415.938739: scmi_msg_dump: pt=15 t=CMND msg_id=06 seq=0000 s=0 pyld=0100000001000000 irq/35-mhu_db_l-81 [000] ..... 16415.944129: scmi_msg_dump: pt=15 t=RESP msg_id=06 seq=0000 s=-1 pyld= # RETURNS A STATUS -1 FROM THE SERVER NOT SUPPORTING IT root@deb-buster-arm64:~# cat /sys/kernel/debug/scmi_raw/message | od --endian=little -t x4 0000000 00005406 ffffffff 0000010 Note that this was on a JUNO, BUT exactly the same steps can be used to reach an SCMI Server living on a VM reachable via virtio as long as the system under test if properly configured to work with a virtio transport. In a nutshell the exposed API is as follows: /sys/kernel/debug/scmi_raw/ ├── errors ├── message ├── message_async ├── notification ├── reset ├── transport_max_msg_size ├── transport_rx_timeout_ms └── transport_tx_max_msg where: - message*: used to send sync/async commands and read back immediate and delayed responses (if any) - errors: used to report timeout and unexpected replies - reset: used to reset the SCMI Raw stack, flushing all queues from received messages still pending to be read out (useful to be sure to cleanup between test suite runs...) - notification: used to read any notification being spit by the system (if previously enabled by the user app) - transport*: a bunch of configuration useful to setup the user application expectations in terms of timeouts and message characteristics. Each write corresponds to one command request and the replies or delayed response are read back one message at time (receiving an EOF at each message boundary). The user application running the test is in charge of handling timeouts and properly choosing SCMI sequence numbers for the outgoing requests: note that the same fixed number can be re-used (...though discouraged...) as long as the suite does NOT expect to send multiple in-flight commands concurrently. Since the SCMI core regular stack is partially used to deliver and collect the messages, late replies after timeouts and any other sort of unexpected message sent by the SCMI server platform back can be identified by the SCMI core as usual and it will be reported under /errors for later analysis. (a userspace test-app will have anyway properly detected the timeout on /message* ...) All of the above has been roughly tested against a standard JUNO SCP SCMI Server (mailbox trans) and an emulated SCMI Server living in a VM (virtio trans) using a custom experimental version of the scmi-tests Compliance suite patched to support Raw mode and posted at [2]. (still in development ...certainly not up for review as of now...it is just a mean for me to test the testing API ... O_o) The series is based on sudeep/for-next/scmi [3] on top of: commit 40d30cf680cb ("firmware: arm_scmi: Harmonize SCMI tracing message format") Still todo: - needs more complete testing, ideally running to completion at least the full SCMI compliance suite at [2] to use it as a reference - more feedback on the API Having said that (in such a concise and brief way :P) ... ...any feedback/comments are welcome ! Thanks, Cristian --- v2 --> v3 - fixed some sparse warning on LE and __poll_t - reworked and simplified deferred worker in charge of xfer delayed waiting - allow for injection of DT-unknown protocols messages when in Raw mode (needed for any kind of fuzzing...) v1 --> v2 - added comments and debugfs docs - added dedicated transport devices for channels initialization - better channels handling in Raw mode - removed runtime enable, moved to static compile time exclusion of SCMI regular stack [1]: https://gitlab.arm.com/tests/scmi-tests [2]: https://gitlab.arm.com/linux-arm/scmi-tests-cm/-/commits/raw_mode_support_V3/ [3]: https://git.kernel.org/pub/scm/linux/kernel/git/sudeep.holla/linux.git/log/?h=for-next/scmi Cristian Marussi (9): firmware: arm_scmi: Refactor xfer in-flight registration routines firmware: arm_scmi: Simplify chan_available transport operation firmware: arm_scmi: Use dedicated devices to initialize channels firmware: arm_scmi: Add xfer raw helpers firmware: arm_scmi: Move errors defs and code to common.h firmware: arm_scmi: Add raw transmission support firmware: arm_scmi: Add debugfs ABI documentation for Raw mode firmware: arm_scmi: Reject SCMI drivers while in Raw mode firmware: arm_scmi: Call Raw mode hooks from the core stack Documentation/ABI/testing/debugfs-scmi-raw | 88 ++ drivers/firmware/arm_scmi/Kconfig | 13 + drivers/firmware/arm_scmi/Makefile | 1 + drivers/firmware/arm_scmi/common.h | 51 +- drivers/firmware/arm_scmi/driver.c | 389 ++++-- drivers/firmware/arm_scmi/mailbox.c | 4 +- drivers/firmware/arm_scmi/optee.c | 4 +- drivers/firmware/arm_scmi/raw_mode.c | 1235 ++++++++++++++++++++ drivers/firmware/arm_scmi/raw_mode.h | 29 + drivers/firmware/arm_scmi/smc.c | 4 +- drivers/firmware/arm_scmi/virtio.c | 2 +- 11 files changed, 1714 insertions(+), 106 deletions(-) create mode 100644 Documentation/ABI/testing/debugfs-scmi-raw create mode 100644 drivers/firmware/arm_scmi/raw_mode.c create mode 100644 drivers/firmware/arm_scmi/raw_mode.h -- 2.32.0 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 4DCE5C6FA83 for ; Sat, 3 Sep 2022 18:32:47 +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: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:In-Reply-To:References: List-Owner; bh=c/X8OWJlebKcOJasbmo/dP0yl1TDSFe0A74kjEkz6pc=; b=u2w3FPKtSsPAaP eOgeZd5xETzkl3P5gRAcICmkZtecFz75JQrFyrq/NlmZgR5NLon1utDuq9l8dkmKJs65nKuwFkWY1 ns4cfhJdAg7ZsnIdivopiOclJ6xQBstx+4d0asWvP21zuCQXXjlyojsa7EzdXd9uanDuUdrMGqgLM s7v3KhItt1pLM7p71J8hcfq0jcYQp4jyHNGbZSILgfRmke/wt2v0CJfU0FalVpeeBH3GSgj3tCxo3 lFz8DAGNjQkCwZVzs/YS60fEKKmb429P5CV2yIKQ8qKtQbRqF2XHf7KuYMX4BQ5/cug4ynSS8sl5C U9BScXVMzVxjV5395l6Q==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1oUXvU-00FZQr-Ak; Sat, 03 Sep 2022 18:31:28 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1oUXvG-00FYnY-EF for linux-arm-kernel@lists.infradead.org; Sat, 03 Sep 2022 18:31:16 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 013A2ED1; Sat, 3 Sep 2022 11:31:15 -0700 (PDT) Received: from e120937-lin.home (unknown [172.31.20.19]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id BD2683F71A; Sat, 3 Sep 2022 11:31:06 -0700 (PDT) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Cc: sudeep.holla@arm.com, james.quinlan@broadcom.com, Jonathan.Cameron@Huawei.com, f.fainelli@gmail.com, etienne.carriere@linaro.org, vincent.guittot@linaro.org, souvik.chakravarty@arm.com, wleavitt@marvell.com, peter.hilber@opensynergy.com, nicola.mazzucato@arm.com, tarek.el-sherbiny@arm.com, cristian.marussi@arm.com Subject: [PATCH v3 0/9] Introduce a unified API for SCMI Server testing Date: Sat, 3 Sep 2022 19:30:33 +0100 Message-Id: <20220903183042.3913053-1-cristian.marussi@arm.com> X-Mailer: git-send-email 2.32.0 MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220903_113114_595902_90ABD8BD X-CRM114-Status: GOOD ( 35.45 ) 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 SGkgYWxsLAoKVGhpcyBzZXJpZXMgYWltcyB0byBpbnRyb2R1Y2UgYSBuZXcgU0NNSSB1bmlmaWVk IHVzZXJzcGFjZSBpbnRlcmZhY2UgbWVhbnQKdG8gZWFzZSB0ZXN0aW5nIGFuIFNDTUkgU2VydmVy IGltcGxlbWVudGF0aW9uIGZvciBjb21wbGlhbmNlLCBmdXp6aW5nIGV0Yy4sCmZyb20gdGhlIHBl cnNwZWN0aXZlIG9mIHRoZSBPU1BNIGFnZW50IChub24tc2VjdXJlIHdvcmxkIG9ubHkgLi4uKQoK SXQgaXMgcHJvcG9zZWQgYXMgYSB0ZXN0aW5nL2RldmVsb3BtZW50IGZhY2lsaXR5LCBpdCBpcyBO T1QgbWVhbnQgdG8gYmUgYQpmZWF0dXJlIHRvIHVzZSBpbiBwcm9kdWN0aW9uLCBidXQgb25seSBl bmFibGVkIGluIEtjb25maWcgZm9yIHRlc3QKZGVwbG95bWVudHMuCgpDdXJyZW50bHkgYW4gU0NN SSBDb21wbGlhbmNlIFN1aXRlIGxpa2UgdGhlIG9uZSBhdCBbMV0gY2FuIG9ubHkgd29yayBieQpp bmplY3RpbmcgU0NNSSBtZXNzYWdlcyBhdCB0aGUgU0NNSSB0cmFuc3BvcnQgbGF5ZXIgdXNpbmcg dGhlIG1haWxib3ggdGVzdApkcml2ZXIgKENPTkZJR19NQUlMQk9YX1RFU1QpIHZpYSBpdHMgZmV3 IGRlYnVnZnMgZW50cmllcyBhbmQgbG9va2luZyBhdAp0aGUgcmVsYXRlZCByZXBsaWVzIGZyb20g dGhlIFNDTUkgYmFja2VuZCBTZXJ2ZXIuCgpUaGlzIGFwcHJvYWNoIGhhcyBhIGZldyBkcmF3YmFj a3M6CgotIHRoZSBTQ01JIFNlcnZlciB1bmRlciB0ZXN0IE1VU1QgYmUgcmVhY2hhYmxlIHRocm91 Z2ggYSBtYWlsYm94IGJhc2VkCiAgU0NNSSB0cmFuc3BvcnQ6IGFueSBvdGhlciBTQ01JIFNlcnZl ciBwbGFjZW1lbnQgaXMgbm90IHBvc3NpYmxlIChsaWtlIGluCiAgYSBWTSByZWFjaGFibGUgdmlh IFNDTUkgVmlydGlvKS4gSW4gb3JkZXIgdG8gY292ZXIgb3RoZXIgcGxhY2VtZW50cyBpbgogIHRo ZSBjdXJyZW50IHNjZW5hcmlvIHdlIHNob3VsZCB3cml0ZSBzb21lIHNvcnQgb2YgdGVzdCBkcml2 ZXIgZm9yIGVhY2gKICBhbmQgZXZlcnkgZXhpc3RlbnQgU0NNSSB0cmFuc3BvcnQgYW5kIGZvciBh bnkgZnV0dXJlIGFkZGl0aW9uYWwgdHJhbnNwb3J0CiAgLi4udGhpcyBjbGVhcmx5IGRvZXMgbm90 IHNjYWxlLgoKLSBldmVuIGluIHRoZSBtYWlsYm94IGNhc2UgdGhlIHVzZXJzcGFjZSBDb21wbGlh bmNlIHN1aXRlIGNhbm5vdCBzaW1wbHkKICBzZW5kIGFuZCByZWNlaXZlIGJhcmUgU0NNSSBtZXNz YWdlcyBCVVQgaXQgaGFzIHRvIHByb3Blcmx5IGxheSB0aGVtIG91dAogIGludG8gdGhlIHNoYXJl ZCBtZW1vcnkgZXhwb3NlZCBieSB0aGUgbWFpbGJveCB0ZXN0IGRyaXZlciBhcyBleHBlY3RlZCBi eQogIHRoZSB0cmFuc3BvcnQgZGVmaW5pdGlvbnMuIEluIG90aGVyIHdvcmRzIHN1Y2ggYSB1c2Vy c3BhY2UgdGVzdAogIGFwcGxpY2F0aW9uIGhhcyB0bywgbm90IG9ubHkgdXNlIGEgcHJvcGVyIHRy YW5zcG9ydCBkcml2ZXIgZm9yIHRoZSBzeXN0ZW0KICBhdCBoYW5kLCBidXQgaXQgYWxzbyBoYXMg dG8gaGF2ZSBhIGNvbXByZWhlbnNpdmUga25vd2xlZGdlIG9mIHRoZQogIGludGVybmFscyBvZiB0 aGUgdW5kZXJseWluZyB0cmFuc3BvcnQgaW4gb3JkZXIgdG8gb3BlcmF0ZS4KCi0gbGFzdCBidXQg bm90IGxlYXN0LCB0aGUgc3lzdGVtIHVuZGVyIHRlc3QgaGFzIHRvIGJlIHNwZWNpZmljYWxseQog IGNvbmZpZ3VyZWQgYW5kIGJ1aWx0LCBpbiB0ZXJtcyBvZiBLY29uZmlnIGFuZCBEVCwgdG8gcGVy Zm9ybSBzdWNoIGtpbmQgb2YKICB0ZXN0aW5nLCBpdCBjYW5ub3QgYmUgdXNlZCBmb3IgYW55dGhp bmcgZWxzZSwgd2hpY2ggaXMgdW5mb3J0dW5hdGUgZm9yCiAgQ0kvQ0QgZGVwbG95bWVudHMuCgpU aGlzIHNlcmllcyBpbnRyb2R1Y2VzIGEgbmV3IFNDTUkgUmF3IG1vZGUgc3VwcG9ydCBmZWF0dXJl IHRoYXQsIHdoZW4KY29uZmlndXJlZCBhbmQgZW5hYmxlZCBleHBvc2VzIGEgbmV3IGludGVyZmFj ZSBpbiBkZWJ1Z2ZzIHRocm91Z2ggd2hpY2g6CgotIGEgdXNlcnNwYWNlIGFwcGxpY2F0aW9uIGNh biBpbmplY3QgYmFyZSBTQ01JIGJpbmFyeSBtZXNzYWdlcyBpbnRvIHRoZQogIFNDTUkgY29yZSBz dGFjazsgc3VjaCBtZXNzYWdlcyB3aWxsIGJlIHJvdXRlZCBieSB0aGUgU0NNSSByZWd1bGFyIGtl cm5lbAogIHN0YWNrIHRvIHRoZSBiYWNrZW5kIFNlcnZlciB1c2luZyB0aGUgY3VycmVudGx5IGNv bmZpZ3VyZWQgdHJhbnNwb3J0CiAgdHJhbnNwYXJlbnRseTogaW4gb3RoZXIgd29yZHMgeW91IGNh biB0ZXN0IHRoZSBTQ01JIHNlcnZlciwgbm8gbWF0dGVyCiAgd2hlcmUgaXQgaXMgcGxhY2VkLCBh cyBsb25nIGFzIGl0IGlzIHJlYWNoYWJsZSBmcm9tIHRoZSBjdXJyZW50bHkKICBjb25maWd1cmVk IFNDTUkgc3RhY2suCiAgU2FtZSBnb2VzIHRoZSBvdGhlciB3YXkgYXJvdW5kIG9uIHRoZSByZWFk aW5nIHBhdGg6IGFueSBTQ01JIHNlcnZlciByZXBseQogIGNhbiBiZSByZWFkIGFzIGEgYmFyZSBT Q01JIGJpbmFyeSBtZXNzYWdlIGZyb20gdGhlIHNhbWUgZGVidWdmcyBwYXRoLgoKLSBhcyBhIGRp cmVjdCBjb25zZXF1ZW5jZSBvZiB0aGlzIHdheSBvZiBpbmplY3RpbmcgYmFyZSBtZXNzYWdlcyBp biB0aGUKICBtaWRkbGUgb2YgdGhlIFNDTUkgc3RhY2sgKGluc3RlYWQgb2YgYmVuZWF0aCBpdCBh dCB0aGUgdHJhbnNwb3J0IGxheWVyKQogIHRoZSB1c2VyIGFwcGxpY2F0aW9uIGhhcyB0byBoYW5k bGUgb25seSBiYXJlIFNDTUkgbWVzc2FnZXMgd2l0aG91dCBoYXZpbmcKICB0byB3b3JyeSBhYm91 dCB0aGUgc3BlY2lmaWMgdW5kZXJseWluZyB0cmFuc3BvcnQgaW50ZXJuYWxzIHRoYXQgd2lsbCBi ZQogIHRha2VuIGNhcmUgb2YgYnkgdGhlIFNDTUkgY29yZSBzdGFjayBpdHNlbGYgdXNpbmcgaXRz IG93biBtYWNoaW5lcnksCiAgd2l0aG91dCBkdXBsaWNhdGluZyBzdWNoIGxvZ2ljLgoKLSBhIHN5 c3RlbSB1bmRlciB0ZXN0LCBvbmNlIGNvbmZpZ3VyZWQgd2l0aCBTQ01JIFJhdyBzdXBwb3J0IGVu YWJsZWQgaW4KICBLY29uZmlnLCBjYW4gYmUgYm9vdGVkIHdpdGhvdXQgYW55IHBhcnRpY3VsYXIg RFQgY2hhbmdlLgoKSW4gVjIgdGhlIHJ1bnRpbWUgZW5hYmxlL2Rpc2FibGUgc3dpdGNoaW5nIGNh cGFiaWxpdHkgaGFzIGJlZW4gcmVtb3ZlZAooZm9yIG5vdykgc2luY2Ugc3RpbGwgbm90IGRlZW1l ZCB0byBiZSBzdGFibGUvcmVsaWFibGUgZW5vdWdoOiBhcyBhCmNvbnNlcXVlbmNlIHdoZW4gU0NN SSBSYXcgc3VwcG9ydCBpcyBjb21waWxlZCBpbiwgdGhlIHJlZ3VsYXIgU0NNSSBzdGFjawpkcml2 ZXJzIGFyZSBub3cgaW5oaWJpdGVkIHBlcm1hbmVudGx5IGZvciB0aGF0IEtlcm5lbC4KCkEgcXVp Y2sgYW5kIHRyaXZpYWwgZXhhbXBsZSBmcm9tIHRoZSBzaGVsbC4uLnJlYWRpbmcgZnJvbSBhIHNl bnNvcgppbmplY3RpbmcgYSBwcm9wZXJseSBjcmFmdGVkIHBhY2tldCBpbiByYXcgbW9kZToKCgkj IElOSkVDVCBUSEUgU0VOU09SX1JFQURJTkcgTUVTU0FHRSBGT1IgU0VOU09SIElEPTEgKGJpbmFy eSBsaXR0bGUgZW5kaWFuKQoJcm9vdEBkZWItYnVzdGVyLWFybTY0On4jIGVjaG8gLWUgLW4gXFx4 MDZcXHg1NFxceDAwXFx4MDBcXHgwMVxceDAwXFx4MDBcXHgwMFxceDAwXFx4MDBcXHgwMFxceDAw ID4gL3N5cy9rZXJuZWwvZGVidWcvc2NtaV9yYXcvbWVzc2FnZQoKCSMgUkVBRElORyBCQUNLIFRI RSBSRVBMWS4uLgoJcm9vdEBkZWItYnVzdGVyLWFybTY0On4jIGNhdCAvc3lzL2tlcm5lbC9kZWJ1 Zy9zY21pX3Jhdy9tZXNzYWdlIHwgb2QgLS1lbmRpYW49bGl0dGxlIC10IHg0CgkwMDAwMDAwIDAw MDA1NDA2IDAwMDAwMDAwIDAwMDAwMzM1IDAwMDAwMDAwCgkwMDAwMDIwCgp3aGlsZSBkb2luZyB0 aGF0LCBzaW5jZSBSYXcgbW9kZSBtYWtlcyAocGFydGlhbCkgdXNlIG9mIHRoZSByZWd1bGFyIFND TUkKc3RhY2ssIHlvdSBjYW4gb2JzZXJ2ZSB0aGUgbWVzc2FnZXMgZ29pbmcgdGhyb3VnaCB0aGUg U0NNSSBzdGFjayB3aXRoIHRoZQp1c3VhbCB0cmFjZXM6CgogICAgICAgICAgICAgIGJhc2gtMzI5 ICAgICBbMDAwXSAuLi4uLiAxNDE4My40NDY4MDg6IHNjbWlfbXNnX2R1bXA6IHB0PTE1IHQ9Q01O RCBtc2dfaWQ9MDYgc2VxPTAwMDAgcz0wIHB5bGQ9MDEwMDAwMDAwMDAwMDAwMAogICBpcnEvMzUt bWh1X2RiX2wtODEgICAgICBbMDAwXSAuLi4uLiAxNDE4My40NDc4MDk6IHNjbWlfbXNnX2R1bXA6 IHB0PTE1IHQ9UkVTUCBtc2dfaWQ9MDYgc2VxPTAwMDAgcz0wIHB5bGQ9MzUwMzAwMDAwMDAwMDAw MAoKCi4udHJ5aW5nIHRvIHJlYWQgaW4gYXN5bmMgd2hlbiB0aGUgYmFja2VuZCBzZXJ2ZXIgZG9l cyBOT1Qgc3VwcG9ydHMgYXN5bmNzOgoKCSMgQU4gQVNZTkMgU0VOU09SIFJFQURJTkcgUkVRVUVT VC4uLgoJcm9vdEBkZWItYnVzdGVyLWFybTY0On4jIGVjaG8gLWUgLW4gXFx4MDZcXHg1NFxceDAw XFx4MDBcXHgwMVxceDAwXFx4MDBcXHgwMFxceDAxXFx4MDBcXHgwMFxceDAwID4gL3N5cy9rZXJu ZWwvZGVidWcvc2NtaV9yYXcvbWVzc2FnZV9hc3luYwoKICAgICAgICAgICAgICBiYXNoLTMyOSAg ICAgWzAwMF0gLi4uLi4gMTY0MTUuOTM4NzM5OiBzY21pX21zZ19kdW1wOiBwdD0xNSB0PUNNTkQg bXNnX2lkPTA2IHNlcT0wMDAwIHM9MCBweWxkPTAxMDAwMDAwMDEwMDAwMDAKICAgaXJxLzM1LW1o dV9kYl9sLTgxICAgICAgWzAwMF0gLi4uLi4gMTY0MTUuOTQ0MTI5OiBzY21pX21zZ19kdW1wOiBw dD0xNSB0PVJFU1AgbXNnX2lkPTA2IHNlcT0wMDAwIHM9LTEgcHlsZD0KCgkjIFJFVFVSTlMgQSBT VEFUVVMgLTEgRlJPTSBUSEUgU0VSVkVSIE5PVCBTVVBQT1JUSU5HIElUCglyb290QGRlYi1idXN0 ZXItYXJtNjQ6fiMgY2F0IC9zeXMva2VybmVsL2RlYnVnL3NjbWlfcmF3L21lc3NhZ2UgfCBvZCAt LWVuZGlhbj1saXR0bGUgLXQgeDQKCTAwMDAwMDAgMDAwMDU0MDYgZmZmZmZmZmYKCTAwMDAwMTAK Ck5vdGUgdGhhdCB0aGlzIHdhcyBvbiBhIEpVTk8sIEJVVCBleGFjdGx5IHRoZSBzYW1lIHN0ZXBz IGNhbiBiZSB1c2VkIHRvCnJlYWNoIGFuIFNDTUkgU2VydmVyIGxpdmluZyBvbiBhIFZNIHJlYWNo YWJsZSB2aWEgdmlydGlvIGFzIGxvbmcgYXMgdGhlCnN5c3RlbSB1bmRlciB0ZXN0IGlmIHByb3Bl cmx5IGNvbmZpZ3VyZWQgdG8gd29yayB3aXRoIGEgdmlydGlvIHRyYW5zcG9ydC4KCkluIGEgbnV0 c2hlbGwgdGhlIGV4cG9zZWQgQVBJIGlzIGFzIGZvbGxvd3M6Cgovc3lzL2tlcm5lbC9kZWJ1Zy9z Y21pX3Jhdy8K4pSc4pSA4pSAIGVycm9ycwrilJzilIDilIAgbWVzc2FnZQrilJzilIDilIAgbWVz c2FnZV9hc3luYwrilJzilIDilIAgbm90aWZpY2F0aW9uCuKUnOKUgOKUgCByZXNldArilJzilIDi lIAgdHJhbnNwb3J0X21heF9tc2dfc2l6ZQrilJzilIDilIAgdHJhbnNwb3J0X3J4X3RpbWVvdXRf bXMK4pSU4pSA4pSAIHRyYW5zcG9ydF90eF9tYXhfbXNnCgp3aGVyZToKCiAtIG1lc3NhZ2UqOiB1 c2VkIHRvIHNlbmQgc3luYy9hc3luYyBjb21tYW5kcyBhbmQgcmVhZCBiYWNrIGltbWVkaWF0ZSBh bmQKICAgZGVsYXllZCByZXNwb25zZXMgKGlmIGFueSkKIC0gZXJyb3JzOiB1c2VkIHRvIHJlcG9y dCB0aW1lb3V0IGFuZCB1bmV4cGVjdGVkIHJlcGxpZXMKIC0gcmVzZXQ6IHVzZWQgdG8gcmVzZXQg dGhlIFNDTUkgUmF3IHN0YWNrLCBmbHVzaGluZyBhbGwgcXVldWVzIGZyb20KICAgcmVjZWl2ZWQg bWVzc2FnZXMgc3RpbGwgcGVuZGluZyB0byBiZSByZWFkIG91dCAodXNlZnVsIHRvIGJlIHN1cmUg dG8KICAgY2xlYW51cCBiZXR3ZWVuIHRlc3Qgc3VpdGUgcnVucy4uLikKIC0gbm90aWZpY2F0aW9u OiB1c2VkIHRvIHJlYWQgYW55IG5vdGlmaWNhdGlvbiBiZWluZyBzcGl0IGJ5IHRoZSBzeXN0ZW0K ICAgKGlmIHByZXZpb3VzbHkgZW5hYmxlZCBieSB0aGUgdXNlciBhcHApCiAtIHRyYW5zcG9ydCo6 IGEgYnVuY2ggb2YgY29uZmlndXJhdGlvbiB1c2VmdWwgdG8gc2V0dXAgdGhlIHVzZXIKICAgYXBw bGljYXRpb24gZXhwZWN0YXRpb25zIGluIHRlcm1zIG9mIHRpbWVvdXRzIGFuZCBtZXNzYWdlCiAg IGNoYXJhY3RlcmlzdGljcy4KCkVhY2ggd3JpdGUgY29ycmVzcG9uZHMgdG8gb25lIGNvbW1hbmQg cmVxdWVzdCBhbmQgdGhlIHJlcGxpZXMgb3IgZGVsYXllZApyZXNwb25zZSBhcmUgcmVhZCBiYWNr IG9uZSBtZXNzYWdlIGF0IHRpbWUgKHJlY2VpdmluZyBhbiBFT0YgYXQgZWFjaAptZXNzYWdlIGJv dW5kYXJ5KS4KClRoZSB1c2VyIGFwcGxpY2F0aW9uIHJ1bm5pbmcgdGhlIHRlc3QgaXMgaW4gY2hh cmdlIG9mIGhhbmRsaW5nIHRpbWVvdXRzCmFuZCBwcm9wZXJseSBjaG9vc2luZyBTQ01JIHNlcXVl bmNlIG51bWJlcnMgZm9yIHRoZSBvdXRnb2luZyByZXF1ZXN0czogbm90ZQp0aGF0IHRoZSBzYW1l IGZpeGVkIG51bWJlciBjYW4gYmUgcmUtdXNlZCAoLi4udGhvdWdoIGRpc2NvdXJhZ2VkLi4uKSBh cwpsb25nIGFzIHRoZSBzdWl0ZSBkb2VzIE5PVCBleHBlY3QgdG8gc2VuZCBtdWx0aXBsZSBpbi1m bGlnaHQgY29tbWFuZHMKY29uY3VycmVudGx5LgoKU2luY2UgdGhlIFNDTUkgY29yZSByZWd1bGFy IHN0YWNrIGlzIHBhcnRpYWxseSB1c2VkIHRvIGRlbGl2ZXIgYW5kIGNvbGxlY3QKdGhlIG1lc3Nh Z2VzLCBsYXRlIHJlcGxpZXMgYWZ0ZXIgdGltZW91dHMgYW5kIGFueSBvdGhlciBzb3J0IG9mIHVu ZXhwZWN0ZWQKbWVzc2FnZSBzZW50IGJ5IHRoZSBTQ01JIHNlcnZlciBwbGF0Zm9ybSBiYWNrIGNh biBiZSBpZGVudGlmaWVkIGJ5IHRoZSBTQ01JCmNvcmUgYXMgdXN1YWwgYW5kIGl0IHdpbGwgYmUg cmVwb3J0ZWQgdW5kZXIgL2Vycm9ycyBmb3IgbGF0ZXIgYW5hbHlzaXMuCihhIHVzZXJzcGFjZSB0 ZXN0LWFwcCB3aWxsIGhhdmUgYW55d2F5IHByb3Blcmx5IGRldGVjdGVkIHRoZSB0aW1lb3V0IG9u CiAvbWVzc2FnZSogLi4uKQoKQWxsIG9mIHRoZSBhYm92ZSBoYXMgYmVlbiByb3VnaGx5IHRlc3Rl ZCBhZ2FpbnN0IGEgc3RhbmRhcmQgSlVOTyBTQ1AgU0NNSQpTZXJ2ZXIgKG1haWxib3ggdHJhbnMp IGFuZCBhbiBlbXVsYXRlZCBTQ01JIFNlcnZlciBsaXZpbmcgaW4gYSBWTSAodmlydGlvCnRyYW5z KSB1c2luZyBhIGN1c3RvbSBleHBlcmltZW50YWwgdmVyc2lvbiBvZiB0aGUgc2NtaS10ZXN0cyBD b21wbGlhbmNlCnN1aXRlIHBhdGNoZWQgdG8gc3VwcG9ydCBSYXcgbW9kZSBhbmQgcG9zdGVkIGF0 IFsyXS4gKHN0aWxsIGluIGRldmVsb3BtZW50Ci4uLmNlcnRhaW5seSBub3QgdXAgZm9yIHJldmll dyBhcyBvZiBub3cuLi5pdCBpcyBqdXN0IGEgbWVhbiBmb3IgbWUgdG8KdGVzdCB0aGUgdGVzdGlu ZyBBUEkgLi4uIE9fbykKClRoZSBzZXJpZXMgaXMgYmFzZWQgb24gc3VkZWVwL2Zvci1uZXh0L3Nj bWkgWzNdIG9uIHRvcCBvZjoKCmNvbW1pdCA0MGQzMGNmNjgwY2IgKCJmaXJtd2FyZTogYXJtX3Nj bWk6IEhhcm1vbml6ZSBTQ01JIHRyYWNpbmcgbWVzc2FnZSBmb3JtYXQiKQoKU3RpbGwgdG9kbzoK Ci0gbmVlZHMgbW9yZSBjb21wbGV0ZSB0ZXN0aW5nLCBpZGVhbGx5IHJ1bm5pbmcgdG8gY29tcGxl dGlvbiBhdCBsZWFzdCB0aGUgZnVsbAogIFNDTUkgY29tcGxpYW5jZSBzdWl0ZSBhdCBbMl0gdG8g dXNlIGl0IGFzIGEgcmVmZXJlbmNlCi0gbW9yZSBmZWVkYmFjayBvbiB0aGUgQVBJCgpIYXZpbmcg c2FpZCB0aGF0IChpbiBzdWNoIGEgY29uY2lzZSBhbmQgYnJpZWYgd2F5IDpQKSAuLi4KCQouLi5h bnkgZmVlZGJhY2svY29tbWVudHMgYXJlIHdlbGNvbWUgIQoKVGhhbmtzLApDcmlzdGlhbgoKLS0t CnYyIC0tPiB2MwotIGZpeGVkIHNvbWUgc3BhcnNlIHdhcm5pbmcgb24gTEUgYW5kIF9fcG9sbF90 Ci0gcmV3b3JrZWQgYW5kIHNpbXBsaWZpZWQgZGVmZXJyZWQgd29ya2VyIGluIGNoYXJnZSBvZiB4 ZmVyIGRlbGF5ZWQgd2FpdGluZwotIGFsbG93IGZvciBpbmplY3Rpb24gb2YgRFQtdW5rbm93biBw cm90b2NvbHMgbWVzc2FnZXMgd2hlbiBpbiBSYXcgbW9kZQogIChuZWVkZWQgZm9yIGFueSBraW5k IG9mIGZ1enppbmcuLi4pCgp2MSAtLT4gdjIKLSBhZGRlZCBjb21tZW50cyBhbmQgZGVidWdmcyBk b2NzCi0gYWRkZWQgZGVkaWNhdGVkIHRyYW5zcG9ydCBkZXZpY2VzIGZvciBjaGFubmVscyBpbml0 aWFsaXphdGlvbgotIGJldHRlciBjaGFubmVscyBoYW5kbGluZyBpbiBSYXcgbW9kZQotIHJlbW92 ZWQgcnVudGltZSBlbmFibGUsIG1vdmVkIHRvIHN0YXRpYyBjb21waWxlIHRpbWUgZXhjbHVzaW9u CiAgb2YgU0NNSSByZWd1bGFyIHN0YWNrCgpbMV06IGh0dHBzOi8vZ2l0bGFiLmFybS5jb20vdGVz dHMvc2NtaS10ZXN0cwpbMl06IGh0dHBzOi8vZ2l0bGFiLmFybS5jb20vbGludXgtYXJtL3NjbWkt dGVzdHMtY20vLS9jb21taXRzL3Jhd19tb2RlX3N1cHBvcnRfVjMvClszXTogaHR0cHM6Ly9naXQu a2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4L2tlcm5lbC9naXQvc3VkZWVwLmhvbGxhL2xpbnV4Lmdp dC9sb2cvP2g9Zm9yLW5leHQvc2NtaQoKQ3Jpc3RpYW4gTWFydXNzaSAoOSk6CiAgZmlybXdhcmU6 IGFybV9zY21pOiBSZWZhY3RvciB4ZmVyIGluLWZsaWdodCByZWdpc3RyYXRpb24gcm91dGluZXMK ICBmaXJtd2FyZTogYXJtX3NjbWk6IFNpbXBsaWZ5IGNoYW5fYXZhaWxhYmxlIHRyYW5zcG9ydCBv cGVyYXRpb24KICBmaXJtd2FyZTogYXJtX3NjbWk6IFVzZSBkZWRpY2F0ZWQgZGV2aWNlcyB0byBp bml0aWFsaXplIGNoYW5uZWxzCiAgZmlybXdhcmU6IGFybV9zY21pOiBBZGQgeGZlciByYXcgaGVs cGVycwogIGZpcm13YXJlOiBhcm1fc2NtaTogTW92ZSBlcnJvcnMgZGVmcyBhbmQgY29kZSB0byBj b21tb24uaAogIGZpcm13YXJlOiBhcm1fc2NtaTogQWRkIHJhdyB0cmFuc21pc3Npb24gc3VwcG9y dAogIGZpcm13YXJlOiBhcm1fc2NtaTogQWRkIGRlYnVnZnMgQUJJIGRvY3VtZW50YXRpb24gZm9y IFJhdyBtb2RlCiAgZmlybXdhcmU6IGFybV9zY21pOiBSZWplY3QgU0NNSSBkcml2ZXJzIHdoaWxl IGluIFJhdyBtb2RlCiAgZmlybXdhcmU6IGFybV9zY21pOiBDYWxsIFJhdyBtb2RlIGhvb2tzIGZy b20gdGhlIGNvcmUgc3RhY2sKCiBEb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL2RlYnVnZnMtc2Nt aS1yYXcgfCAgIDg4ICsrCiBkcml2ZXJzL2Zpcm13YXJlL2FybV9zY21pL0tjb25maWcgICAgICAg ICAgfCAgIDEzICsKIGRyaXZlcnMvZmlybXdhcmUvYXJtX3NjbWkvTWFrZWZpbGUgICAgICAgICB8 ICAgIDEgKwogZHJpdmVycy9maXJtd2FyZS9hcm1fc2NtaS9jb21tb24uaCAgICAgICAgIHwgICA1 MSArLQogZHJpdmVycy9maXJtd2FyZS9hcm1fc2NtaS9kcml2ZXIuYyAgICAgICAgIHwgIDM4OSAr KysrLS0KIGRyaXZlcnMvZmlybXdhcmUvYXJtX3NjbWkvbWFpbGJveC5jICAgICAgICB8ICAgIDQg Ky0KIGRyaXZlcnMvZmlybXdhcmUvYXJtX3NjbWkvb3B0ZWUuYyAgICAgICAgICB8ICAgIDQgKy0K IGRyaXZlcnMvZmlybXdhcmUvYXJtX3NjbWkvcmF3X21vZGUuYyAgICAgICB8IDEyMzUgKysrKysr KysrKysrKysrKysrKysKIGRyaXZlcnMvZmlybXdhcmUvYXJtX3NjbWkvcmF3X21vZGUuaCAgICAg ICB8ICAgMjkgKwogZHJpdmVycy9maXJtd2FyZS9hcm1fc2NtaS9zbWMuYyAgICAgICAgICAgIHwg ICAgNCArLQogZHJpdmVycy9maXJtd2FyZS9hcm1fc2NtaS92aXJ0aW8uYyAgICAgICAgIHwgICAg MiArLQogMTEgZmlsZXMgY2hhbmdlZCwgMTcxNCBpbnNlcnRpb25zKCspLCAxMDYgZGVsZXRpb25z KC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9BQkkvdGVzdGluZy9kZWJ1Z2Zz LXNjbWktcmF3CiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9maXJtd2FyZS9hcm1fc2NtaS9y YXdfbW9kZS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9maXJtd2FyZS9hcm1fc2NtaS9y YXdfbW9kZS5oCgotLSAKMi4zMi4wCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtl cm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxt YW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=