From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-2.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=no autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2B453C433DF for ; Tue, 9 Jun 2020 17:41:37 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 0CCD92074B for ; Tue, 9 Jun 2020 17:41:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731153AbgFIRlf (ORCPT ); Tue, 9 Jun 2020 13:41:35 -0400 Received: from foss.arm.com ([217.140.110.172]:45884 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728603AbgFIRlf (ORCPT ); Tue, 9 Jun 2020 13:41:35 -0400 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 DFDAB1F1; Tue, 9 Jun 2020 10:41:32 -0700 (PDT) Received: from bogus (unknown [10.37.12.97]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 1ECB93F73D; Tue, 9 Jun 2020 10:41:30 -0700 (PDT) Date: Tue, 9 Jun 2020 18:41:23 +0100 From: Sudeep Holla To: Will Deacon Cc: devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Marc Zyngier , tabba@google.com, qwandor@google.com, ardb@kernel.org, Sudeep Holla Subject: Re: [RFC PATCH 0/3] firmware: Add support for PSA FF-A interface Message-ID: <20200609174123.GA5732@bogus> References: <20200601094512.50509-1-sudeep.holla@arm.com> <20200604133746.GA2951@willie-the-truck> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20200604133746.GA2951@willie-the-truck> User-Agent: Mutt/1.9.4 (2018-02-28) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org (Sorry for the delay, got distracted with some other bug fix.) On Thu, Jun 04, 2020 at 02:37:46PM +0100, Will Deacon wrote: > Hi Sudeep, [+Fuad, Andrew and Ard] > > (To other interested readers: if you haven't seen it, the FF-A spec is here: > https://static.docs.arm.com/den0077/a/DEN0077A_PSA_Firmware_Framework_Arm_v8-A_1.0_EAC.pdf > since this discussion makes no sense without that, and a tiny bit of sense > with it. It used to be called "SPCI" but it was recently renamed.) > Thanks for adding all interested parties. > On Mon, Jun 01, 2020 at 10:45:09AM +0100, Sudeep Holla wrote: > > Sorry for posting in the middle of merge window and I must have done > > this last week itself. This is not the driver I had thought about posting > > last week. After I started cleaning up and looking at Will's KVM prototype[1] > > for PSA FF-A (previously known as SPCI), > > Yes, I need to do the Big Rename at some point. Joy. > 😁 > > I got more doubts on alignment and dropped huge chunk of interface APIs in > > the driver in order to keep it simple, and get aligned more with that > > prototype and avoid scanning lots of code unnecessary. > > You also dropped most of the code, so this doesn't really do anything in > its current form ;) > Yes, it was intentional 😉 > > Here are few things to clarify: > > > > 1. DT bindings > > --------------- > > I was initially against adding bindings for Tx/Rx buffers for > > partitions. As per the spec, an endpoint could allocate the > > buffer pair and use the FFA_RXTX_MAP interface to map it with the > > Hypervisor(KVM here). However looking at the prototype and also > > I remember you mentioning that it is not possible to manage buffers > > in that way. Please confirm if you plan to add the buffer details > > fetcthing them through ioctls in KVM and adding them to VM DT nodes > > in KVM userspace. I will update the bindings accordingly. > > I think it's useful to have a mode of operation where the hypervisor > allocates the RX/TX buffers and advertises them in the DT. However, we > can always add this later, so there's no need to have it in the binding > from the start. Best start as simple as possible, I reckon. > OK > Setting the static RX/TX buffer allocation aside, why is a DT node needed > at all for the case where Linux is running purely as an FF-A client? I > thought everything should be discoverable via FFA_VERSION, FFA_FEATURES, > FFA_PARTITION_INFO_GET and FFA_ID_GET? That should mean we can get away > without a binding at all for the client case. > Agreed, I added for RxTx buffers and initially to build the parent/child hierarchy for all users of the driver. Initially I was assuming only in-kernel users and now I agree we should avoid any in kernel users if possible. One thing to note FFA_PARTITION_INFO_GET relies on Rx buffers to send the information to the caller. So we need to have established buffers before that and one of the reason you don't find that in this RFC. I dropped that too which I wanted initially. > > 2. Driver > > --------- > > a. Support for multiple partitions in a VM > > ------------------------------------------ > > I am not sure if there is need for supporting multiple partitions > > within a VM. It should be possible to do so as I expect to create > > device for each partition entry under arm-psa-ffa devicetree node. > > However, I don't want to assume something that will never be a > > usecase. However I don't think this will change must of the > > abstraction as we need to keep the interface API implementation > > separate to support different partitions on various platforms. > > I think Ard has a case for something like this, where a VM actually consists > of multiple partitions so that S-EL0 services can be provided from NS-EL0. > However, he probably wants that for a dynamically created VM, so we'd > need a way to instantiate an FFA namespace for the VM. Maybe that can be > done entirely in userspace by the VMM... > Interesting... > > b. SMCCC interface > > ------------------ > > This is something I messed up completely while trying to add > > support for SMCCC v1.2. It now supports x0-x17 as parameter > > registers(input) and return registers(output). I started simple > > with x0-x7 as both input and output as PSA FF-A needs that at > > most. But extending to x0-x17 then became with messy in my > > implementation. That's the reason I dropped it completely > > here and thought of checking it first. > > > > Do we need to extend the optimisations that were done to handle > > ARCH_WORKAROUND_{1,2}. Or should be just use a version with x0-x7 > > as both input and ouput. Hyper-V guys need full x0-x17 support. > > > > I need some guidance as what is the approach preferred ? > > I think we can start off with x0-x7 and extend if later if we need to. > Sure > > 3. Partitions > > ------------- > > I am not sure if we have a full define partition that we plan to > > push upstream. Without one, we can have a sample/example partition > > to test all the interface APIs, but is that fine with respect to > > what we want upstream ? Any other thoughts that helps to test the > > driver ? > > I think that's the best you can do for now. We can probably help with > testing as our stuff gets off the ground. > OK > > Sorry for long email and too many questions, but I thought it is easier > > this way to begin with than throwing huge code implementing loads of APIs > > with no users(expect example partition) especially that I am posting this > > during merge window. > > No problem. Maybe it would help if I described roughly what we were thinking > of doing for KVM (this is open for discussion, of course): > > 1. Describe KVM-managed partitions in the DT, along the lines of [1] > 2. Expose each partition as a file to userspace. E.g.: > > /dev/spci/: > > self > e3a48fa5-dc54-4a8b-898b-bdc4dfeeb7b8 > 49f65057-d002-4ae2-b4ee-d31c7940a13d > > Here, self would be a symlink to the host uuid. The host uuid file > would implement FFA_MEM operations using an ioctl(), so you could, > for example, share a user buffer with multiple partitions by issuing > a MEM_SHARE ioctl() on self, passing the fds for the borrower partitions > as arguments. Messaging would be implemented as ioctl()s on the > partition uuid files themselves. > OK, IIUC that covers mostly KVM implementation. We still need a way to share the RxTx buffer info to the partitions and DT/ACPI(?) is one possible way. Based on you comment about not needing DT node, do you have any other way to communicate the buffer info to the partitions ? > 3. We'll need some (all?) of these patches to unmap memory from the host > when necessary: > > https://lwn.net/Articles/821215/ > > (for nVHE, we'll have a stage-2 for the host so we can unmap there as > well) > Sounds more fun. > For communicating with partitions that are not managed by KVM (e.g. trusted > applications), it's not clear to me how much of that will be handled in > kernel or user. I think it would still be worth exposing the partitions as > files, but perhaps having them root only or just returning -EPERM for the > ioctl() if a kernel driver has claimed the partition as its own? Ideally, > FF-A would allow us to transition some of the Trusted OS interfacing code > out to userspace, but I don't know how realistic that is. > Ah good, so we can still manage in-kernel users this way but we need to provide interface to such a driver which I agree that we need to avoid if possible. > Anyway, to enable this, I think we need a clear separation in the kernel > between the FF-A code and the users: Agreed. > KVM will want to expose things as above, but if drivers need to use this > stuff as well then they can plug in as additional users and we don't have to > worry about tripping over the RX/TX buffers etc. > I am confused a bit. When you refer drivers above, are you referring to drivers in host kernel(hypervisor) or in the partitions. I fail to imagine need for the former. > What do you think, and do you reckon you can spin a cut-down driver that > implements the common part of the logic (since I know you've written much > of this code already)? > I am not sure if I am aligned with your thoughts on the buffer sharing yet. -- Regards, Sudeep From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-2.3 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,SPF_HELO_NONE, SPF_PASS,USER_AGENT_SANE_1 autolearn=no autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5FAB0C433E1 for ; Tue, 9 Jun 2020 17:41:40 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 2E8DA20774 for ; Tue, 9 Jun 2020 17:41:40 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="Z466myxt" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2E8DA20774 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=MC7EIg6NZS9Gs/EhjLnosTNlT+8rUrfy7/Zff6SFSbw=; b=Z466myxtKeTMJk VLd+50+80kig+B6bFy3BWqysRxt2KhjDrn3LRsnBHkkWvIrPDOrwqaGcwH7lNIsCKmiM1/e7/1iiM d4n0LmAapCD0qgq/JSErxKq3+VLzOEJLBqfDarbRom19z8RwDzYh6dPS2xbqTMNElx+kmix5XFoSo 6qAYGDNWqUPVAVT8iBXOavfXfNK7mD/B/WnPy08Qu9p3SWSkdjMkoqHmYju3jer0HObdn1wRccRn0 MRRcBgQ0fY4hoXnWZkIeqHfTZNWojOePbLT6t+MJk6YiXN0TMIc0UUiHtwaB7SDS72oPmGmk7Q1QT pLWMDXfO/8P+037QeMZQ==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1jiiFn-0002b3-K7; Tue, 09 Jun 2020 17:41:39 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1jiiFj-0002Zj-SU for linux-arm-kernel@lists.infradead.org; Tue, 09 Jun 2020 17:41:37 +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 DFDAB1F1; Tue, 9 Jun 2020 10:41:32 -0700 (PDT) Received: from bogus (unknown [10.37.12.97]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 1ECB93F73D; Tue, 9 Jun 2020 10:41:30 -0700 (PDT) Date: Tue, 9 Jun 2020 18:41:23 +0100 From: Sudeep Holla To: Will Deacon Subject: Re: [RFC PATCH 0/3] firmware: Add support for PSA FF-A interface Message-ID: <20200609174123.GA5732@bogus> References: <20200601094512.50509-1-sudeep.holla@arm.com> <20200604133746.GA2951@willie-the-truck> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20200604133746.GA2951@willie-the-truck> User-Agent: Mutt/1.9.4 (2018-02-28) X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200609_104136_010551_F98052A4 X-CRM114-Status: GOOD ( 44.21 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: devicetree@vger.kernel.org, qwandor@google.com, Marc Zyngier , linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Sudeep Holla , ardb@kernel.org, tabba@google.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org KFNvcnJ5IGZvciB0aGUgZGVsYXksIGdvdCBkaXN0cmFjdGVkIHdpdGggc29tZSBvdGhlciBidWcg Zml4LikKCk9uIFRodSwgSnVuIDA0LCAyMDIwIGF0IDAyOjM3OjQ2UE0gKzAxMDAsIFdpbGwgRGVh Y29uIHdyb3RlOgo+IEhpIFN1ZGVlcCwgWytGdWFkLCBBbmRyZXcgYW5kIEFyZF0KPgo+IChUbyBv dGhlciBpbnRlcmVzdGVkIHJlYWRlcnM6IGlmIHlvdSBoYXZlbid0IHNlZW4gaXQsIHRoZSBGRi1B IHNwZWMgaXMgaGVyZToKPiAgaHR0cHM6Ly9zdGF0aWMuZG9jcy5hcm0uY29tL2RlbjAwNzcvYS9E RU4wMDc3QV9QU0FfRmlybXdhcmVfRnJhbWV3b3JrX0FybV92OC1BXzEuMF9FQUMucGRmCj4gIHNp bmNlIHRoaXMgZGlzY3Vzc2lvbiBtYWtlcyBubyBzZW5zZSB3aXRob3V0IHRoYXQsIGFuZCBhIHRp bnkgYml0IG9mIHNlbnNlCj4gIHdpdGggaXQuIEl0IHVzZWQgdG8gYmUgY2FsbGVkICJTUENJIiBi dXQgaXQgd2FzIHJlY2VudGx5IHJlbmFtZWQuKQo+CgpUaGFua3MgZm9yIGFkZGluZyBhbGwgaW50 ZXJlc3RlZCBwYXJ0aWVzLgoKPiBPbiBNb24sIEp1biAwMSwgMjAyMCBhdCAxMDo0NTowOUFNICsw MTAwLCBTdWRlZXAgSG9sbGEgd3JvdGU6Cj4gPiBTb3JyeSBmb3IgcG9zdGluZyBpbiB0aGUgbWlk ZGxlIG9mIG1lcmdlIHdpbmRvdyBhbmQgSSBtdXN0IGhhdmUgZG9uZQo+ID4gdGhpcyBsYXN0IHdl ZWsgaXRzZWxmLiBUaGlzIGlzIG5vdCB0aGUgZHJpdmVyIEkgaGFkIHRob3VnaHQgYWJvdXQgcG9z dGluZwo+ID4gbGFzdCB3ZWVrLiBBZnRlciBJIHN0YXJ0ZWQgY2xlYW5pbmcgdXAgYW5kIGxvb2tp bmcgYXQgV2lsbCdzIEtWTSBwcm90b3R5cGVbMV0KPiA+IGZvciBQU0EgRkYtQSAocHJldmlvdXNs eSBrbm93biBhcyBTUENJKSwKPgo+IFllcywgSSBuZWVkIHRvIGRvIHRoZSBCaWcgUmVuYW1lIGF0 IHNvbWUgcG9pbnQuIEpveS4KPgoK8J+YgSAKCj4gPiBJIGdvdCBtb3JlIGRvdWJ0cyBvbiBhbGln bm1lbnQgYW5kIGRyb3BwZWQgaHVnZSBjaHVuayBvZiBpbnRlcmZhY2UgQVBJcyBpbgo+ID4gdGhl IGRyaXZlciBpbiBvcmRlciB0byBrZWVwIGl0IHNpbXBsZSwgYW5kIGdldCBhbGlnbmVkIG1vcmUg d2l0aCB0aGF0Cj4gPiBwcm90b3R5cGUgYW5kIGF2b2lkIHNjYW5uaW5nIGxvdHMgb2YgY29kZSB1 bm5lY2Vzc2FyeS4KPgo+IFlvdSBhbHNvIGRyb3BwZWQgbW9zdCBvZiB0aGUgY29kZSwgc28gdGhp cyBkb2Vzbid0IHJlYWxseSBkbyBhbnl0aGluZyBpbgo+IGl0cyBjdXJyZW50IGZvcm0gOykKPgoK WWVzLCBpdCB3YXMgaW50ZW50aW9uYWwg8J+YiSAKCj4gPiBIZXJlIGFyZSBmZXcgdGhpbmdzIHRv IGNsYXJpZnk6Cj4gPgo+ID4gMS4gRFQgYmluZGluZ3MKPiA+IC0tLS0tLS0tLS0tLS0tLQo+ID4g CUkgd2FzIGluaXRpYWxseSBhZ2FpbnN0IGFkZGluZyBiaW5kaW5ncyBmb3IgVHgvUnggYnVmZmVy cyBmb3IKPiA+IAlwYXJ0aXRpb25zLiBBcyBwZXIgdGhlIHNwZWMsIGFuIGVuZHBvaW50IGNvdWxk IGFsbG9jYXRlIHRoZQo+ID4gCWJ1ZmZlciBwYWlyIGFuZCB1c2UgdGhlIEZGQV9SWFRYX01BUCBp bnRlcmZhY2UgdG8gbWFwIGl0IHdpdGggdGhlCj4gPiAJSHlwZXJ2aXNvcihLVk0gaGVyZSkuIEhv d2V2ZXIgbG9va2luZyBhdCB0aGUgcHJvdG90eXBlIGFuZCBhbHNvCj4gPiAJSSByZW1lbWJlciB5 b3UgbWVudGlvbmluZyB0aGF0IGl0IGlzIG5vdCBwb3NzaWJsZSB0byBtYW5hZ2UgYnVmZmVycwo+ ID4gCWluIHRoYXQgd2F5LiBQbGVhc2UgY29uZmlybSBpZiB5b3UgcGxhbiB0byBhZGQgdGhlIGJ1 ZmZlciBkZXRhaWxzCj4gPiAJZmV0Y3RoaW5nIHRoZW0gdGhyb3VnaCBpb2N0bHMgaW4gS1ZNIGFu ZCBhZGRpbmcgdGhlbSB0byBWTSBEVCBub2Rlcwo+ID4gCWluIEtWTSB1c2Vyc3BhY2UuIEkgd2ls bCB1cGRhdGUgdGhlIGJpbmRpbmdzIGFjY29yZGluZ2x5Lgo+Cj4gSSB0aGluayBpdCdzIHVzZWZ1 bCB0byBoYXZlIGEgbW9kZSBvZiBvcGVyYXRpb24gd2hlcmUgdGhlIGh5cGVydmlzb3IKPiBhbGxv Y2F0ZXMgdGhlIFJYL1RYIGJ1ZmZlcnMgYW5kIGFkdmVydGlzZXMgdGhlbSBpbiB0aGUgRFQuIEhv d2V2ZXIsIHdlCj4gY2FuIGFsd2F5cyBhZGQgdGhpcyBsYXRlciwgc28gdGhlcmUncyBubyBuZWVk IHRvIGhhdmUgaXQgaW4gdGhlIGJpbmRpbmcKPiBmcm9tIHRoZSBzdGFydC4gQmVzdCBzdGFydCBh cyBzaW1wbGUgYXMgcG9zc2libGUsIEkgcmVja29uLgo+CgpPSwoKPiBTZXR0aW5nIHRoZSBzdGF0 aWMgUlgvVFggYnVmZmVyIGFsbG9jYXRpb24gYXNpZGUsIHdoeSBpcyBhIERUIG5vZGUgbmVlZGVk Cj4gYXQgYWxsIGZvciB0aGUgY2FzZSB3aGVyZSBMaW51eCBpcyBydW5uaW5nIHB1cmVseSBhcyBh biBGRi1BIGNsaWVudD8gSQo+IHRob3VnaHQgZXZlcnl0aGluZyBzaG91bGQgYmUgZGlzY292ZXJh YmxlIHZpYSBGRkFfVkVSU0lPTiwgRkZBX0ZFQVRVUkVTLAo+IEZGQV9QQVJUSVRJT05fSU5GT19H RVQgYW5kIEZGQV9JRF9HRVQ/IFRoYXQgc2hvdWxkIG1lYW4gd2UgY2FuIGdldCBhd2F5Cj4gd2l0 aG91dCBhIGJpbmRpbmcgYXQgYWxsIGZvciB0aGUgY2xpZW50IGNhc2UuCj4KCkFncmVlZCwgSSBh ZGRlZCBmb3IgUnhUeCBidWZmZXJzIGFuZCBpbml0aWFsbHkgdG8gYnVpbGQgdGhlIHBhcmVudC9j aGlsZApoaWVyYXJjaHkgZm9yIGFsbCB1c2VycyBvZiB0aGUgZHJpdmVyLiBJbml0aWFsbHkgSSB3 YXMgYXNzdW1pbmcgb25seQppbi1rZXJuZWwgdXNlcnMgYW5kIG5vdyBJIGFncmVlIHdlIHNob3Vs ZCBhdm9pZCBhbnkgaW4ga2VybmVsIHVzZXJzIGlmCnBvc3NpYmxlLgoKT25lIHRoaW5nIHRvIG5v dGUgRkZBX1BBUlRJVElPTl9JTkZPX0dFVCByZWxpZXMgb24gUnggYnVmZmVycyB0byBzZW5kIHRo ZQppbmZvcm1hdGlvbiB0byB0aGUgY2FsbGVyLiBTbyB3ZSBuZWVkIHRvIGhhdmUgZXN0YWJsaXNo ZWQgYnVmZmVycyBiZWZvcmUKdGhhdCBhbmQgb25lIG9mIHRoZSByZWFzb24geW91IGRvbid0IGZp bmQgdGhhdCBpbiB0aGlzIFJGQy4gSSBkcm9wcGVkIHRoYXQKdG9vIHdoaWNoIEkgd2FudGVkIGlu aXRpYWxseS4KCj4gPiAyLiBEcml2ZXIKPiA+IC0tLS0tLS0tLQo+ID4gYS4gU3VwcG9ydCBmb3Ig bXVsdGlwbGUgcGFydGl0aW9ucyBpbiBhIFZNCj4gPiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KPiA+IAlJIGFtIG5vdCBzdXJlIGlmIHRoZXJlIGlzIG5lZWQgZm9y IHN1cHBvcnRpbmcgbXVsdGlwbGUgcGFydGl0aW9ucwo+ID4gCXdpdGhpbiBhIFZNLiBJdCBzaG91 bGQgYmUgcG9zc2libGUgdG8gZG8gc28gYXMgSSBleHBlY3QgdG8gY3JlYXRlCj4gPiAJZGV2aWNl IGZvciBlYWNoIHBhcnRpdGlvbiBlbnRyeSB1bmRlciBhcm0tcHNhLWZmYSBkZXZpY2V0cmVlIG5v ZGUuCj4gPiAJSG93ZXZlciwgSSBkb24ndCB3YW50IHRvIGFzc3VtZSBzb21ldGhpbmcgdGhhdCB3 aWxsIG5ldmVyIGJlIGEKPiA+IAl1c2VjYXNlLiBIb3dldmVyIEkgZG9uJ3QgdGhpbmsgdGhpcyB3 aWxsIGNoYW5nZSBtdXN0IG9mIHRoZQo+ID4gCWFic3RyYWN0aW9uIGFzIHdlIG5lZWQgdG8ga2Vl cCB0aGUgaW50ZXJmYWNlIEFQSSBpbXBsZW1lbnRhdGlvbgo+ID4gCXNlcGFyYXRlIHRvIHN1cHBv cnQgZGlmZmVyZW50IHBhcnRpdGlvbnMgb24gdmFyaW91cyBwbGF0Zm9ybXMuCj4KPiBJIHRoaW5r IEFyZCBoYXMgYSBjYXNlIGZvciBzb21ldGhpbmcgbGlrZSB0aGlzLCB3aGVyZSBhIFZNIGFjdHVh bGx5IGNvbnNpc3RzCj4gb2YgbXVsdGlwbGUgcGFydGl0aW9ucyBzbyB0aGF0IFMtRUwwIHNlcnZp Y2VzIGNhbiBiZSBwcm92aWRlZCBmcm9tIE5TLUVMMC4KPiBIb3dldmVyLCBoZSBwcm9iYWJseSB3 YW50cyB0aGF0IGZvciBhIGR5bmFtaWNhbGx5IGNyZWF0ZWQgVk0sIHNvIHdlJ2QKPiBuZWVkIGEg d2F5IHRvIGluc3RhbnRpYXRlIGFuIEZGQSBuYW1lc3BhY2UgZm9yIHRoZSBWTS4gTWF5YmUgdGhh dCBjYW4gYmUKPiBkb25lIGVudGlyZWx5IGluIHVzZXJzcGFjZSBieSB0aGUgVk1NLi4uCj4KCklu dGVyZXN0aW5nLi4uCgo+ID4gYi4gU01DQ0MgaW50ZXJmYWNlCj4gPiAtLS0tLS0tLS0tLS0tLS0t LS0KPiA+IAlUaGlzIGlzIHNvbWV0aGluZyBJIG1lc3NlZCB1cCBjb21wbGV0ZWx5IHdoaWxlIHRy eWluZyB0byBhZGQKPiA+IAlzdXBwb3J0IGZvciBTTUNDQyB2MS4yLiBJdCBub3cgc3VwcG9ydHMg eDAteDE3IGFzIHBhcmFtZXRlcgo+ID4gCXJlZ2lzdGVycyhpbnB1dCkgYW5kIHJldHVybiByZWdp c3RlcnMob3V0cHV0KS4gSSBzdGFydGVkIHNpbXBsZQo+ID4gCXdpdGggeDAteDcgYXMgYm90aCBp bnB1dCBhbmQgb3V0cHV0IGFzIFBTQSBGRi1BIG5lZWRzIHRoYXQgYXQKPiA+IAltb3N0LiBCdXQg ZXh0ZW5kaW5nIHRvIHgwLXgxNyB0aGVuIGJlY2FtZSB3aXRoIG1lc3N5IGluIG15Cj4gPiAJaW1w bGVtZW50YXRpb24uIFRoYXQncyB0aGUgcmVhc29uIEkgZHJvcHBlZCBpdCBjb21wbGV0ZWx5Cj4g PiAJaGVyZSBhbmQgdGhvdWdodCBvZiBjaGVja2luZyBpdCBmaXJzdC4KPiA+Cj4gPiAJRG8gd2Ug bmVlZCB0byBleHRlbmQgdGhlIG9wdGltaXNhdGlvbnMgdGhhdCB3ZXJlIGRvbmUgdG8gaGFuZGxl Cj4gPiAJQVJDSF9XT1JLQVJPVU5EX3sxLDJ9LiBPciBzaG91bGQgYmUganVzdCB1c2UgYSB2ZXJz aW9uIHdpdGggeDAteDcKPiA+IAlhcyBib3RoIGlucHV0IGFuZCBvdXB1dC4gSHlwZXItViBndXlz IG5lZWQgZnVsbCB4MC14MTcgc3VwcG9ydC4KPiA+Cj4gPiAJSSBuZWVkIHNvbWUgZ3VpZGFuY2Ug YXMgd2hhdCBpcyB0aGUgYXBwcm9hY2ggcHJlZmVycmVkID8KPgo+IEkgdGhpbmsgd2UgY2FuIHN0 YXJ0IG9mZiB3aXRoIHgwLXg3IGFuZCBleHRlbmQgaWYgbGF0ZXIgaWYgd2UgbmVlZCB0by4KPgoK U3VyZQoKPiA+IDMuIFBhcnRpdGlvbnMKPiA+IC0tLS0tLS0tLS0tLS0KPiA+IAlJIGFtIG5vdCBz dXJlIGlmIHdlIGhhdmUgYSBmdWxsIGRlZmluZSBwYXJ0aXRpb24gdGhhdCB3ZSBwbGFuIHRvCj4g PiAJcHVzaCB1cHN0cmVhbS4gV2l0aG91dCBvbmUsIHdlIGNhbiBoYXZlIGEgc2FtcGxlL2V4YW1w bGUgcGFydGl0aW9uCj4gPiAJdG8gdGVzdCBhbGwgdGhlIGludGVyZmFjZSBBUElzLCBidXQgaXMg dGhhdCBmaW5lIHdpdGggcmVzcGVjdCB0bwo+ID4gCXdoYXQgd2Ugd2FudCB1cHN0cmVhbSA/IEFu eSBvdGhlciB0aG91Z2h0cyB0aGF0IGhlbHBzIHRvIHRlc3QgdGhlCj4gPiAJZHJpdmVyID8KPgo+ IEkgdGhpbmsgdGhhdCdzIHRoZSBiZXN0IHlvdSBjYW4gZG8gZm9yIG5vdy4gV2UgY2FuIHByb2Jh Ymx5IGhlbHAgd2l0aAo+IHRlc3RpbmcgYXMgb3VyIHN0dWZmIGdldHMgb2ZmIHRoZSBncm91bmQu Cj4KCk9LCgo+ID4gU29ycnkgZm9yIGxvbmcgZW1haWwgYW5kIHRvbyBtYW55IHF1ZXN0aW9ucywg YnV0IEkgdGhvdWdodCBpdCBpcyBlYXNpZXIKPiA+IHRoaXMgd2F5IHRvIGJlZ2luIHdpdGggdGhh biB0aHJvd2luZyBodWdlIGNvZGUgaW1wbGVtZW50aW5nIGxvYWRzIG9mIEFQSXMKPiA+IHdpdGgg bm8gdXNlcnMoZXhwZWN0IGV4YW1wbGUgcGFydGl0aW9uKSBlc3BlY2lhbGx5IHRoYXQgSSBhbSBw b3N0aW5nIHRoaXMKPiA+IGR1cmluZyBtZXJnZSB3aW5kb3cuCj4KPiBObyBwcm9ibGVtLiBNYXli ZSBpdCB3b3VsZCBoZWxwIGlmIEkgZGVzY3JpYmVkIHJvdWdobHkgd2hhdCB3ZSB3ZXJlIHRoaW5r aW5nCj4gb2YgZG9pbmcgZm9yIEtWTSAodGhpcyBpcyBvcGVuIGZvciBkaXNjdXNzaW9uLCBvZiBj b3Vyc2UpOgo+Cj4gIDEuIERlc2NyaWJlIEtWTS1tYW5hZ2VkIHBhcnRpdGlvbnMgaW4gdGhlIERU LCBhbG9uZyB0aGUgbGluZXMgb2YgWzFdCj4gIDIuIEV4cG9zZSBlYWNoIHBhcnRpdGlvbiBhcyBh IGZpbGUgdG8gdXNlcnNwYWNlLiBFLmcuOgo+Cj4gICAgIC9kZXYvc3BjaS86Cj4KPiAJc2VsZgo+ IAllM2E0OGZhNS1kYzU0LTRhOGItODk4Yi1iZGM0ZGZlZWI3YjgKPiAJNDlmNjUwNTctZDAwMi00 YWUyLWI0ZWUtZDMxYzc5NDBhMTNkCj4KPiAgICAgSGVyZSwgc2VsZiB3b3VsZCBiZSBhIHN5bWxp bmsgdG8gdGhlIGhvc3QgdXVpZC4gVGhlIGhvc3QgdXVpZCBmaWxlCj4gICAgIHdvdWxkIGltcGxl bWVudCBGRkFfTUVNIG9wZXJhdGlvbnMgdXNpbmcgYW4gaW9jdGwoKSwgc28geW91IGNvdWxkLAo+ ICAgICBmb3IgZXhhbXBsZSwgc2hhcmUgYSB1c2VyIGJ1ZmZlciB3aXRoIG11bHRpcGxlIHBhcnRp dGlvbnMgYnkgaXNzdWluZwo+ICAgICBhIE1FTV9TSEFSRSBpb2N0bCgpIG9uIHNlbGYsIHBhc3Np bmcgdGhlIGZkcyBmb3IgdGhlIGJvcnJvd2VyIHBhcnRpdGlvbnMKPiAgICAgYXMgYXJndW1lbnRz LiBNZXNzYWdpbmcgd291bGQgYmUgaW1wbGVtZW50ZWQgYXMgaW9jdGwoKXMgb24gdGhlCj4gICAg IHBhcnRpdGlvbiB1dWlkIGZpbGVzIHRoZW1zZWx2ZXMuCj4KCk9LLCBJSVVDIHRoYXQgY292ZXJz IG1vc3RseSBLVk0gaW1wbGVtZW50YXRpb24uIFdlIHN0aWxsIG5lZWQgYSB3YXkgdG8Kc2hhcmUg dGhlIFJ4VHggYnVmZmVyIGluZm8gdG8gdGhlIHBhcnRpdGlvbnMgYW5kIERUL0FDUEkoPykgaXMg b25lCnBvc3NpYmxlIHdheS4gQmFzZWQgb24geW91IGNvbW1lbnQgYWJvdXQgbm90IG5lZWRpbmcg RFQgbm9kZSwgZG8geW91IGhhdmUKYW55IG90aGVyIHdheSB0byBjb21tdW5pY2F0ZSB0aGUgYnVm ZmVyIGluZm8gdG8gdGhlIHBhcnRpdGlvbnMgPwoKPiAgMy4gV2UnbGwgbmVlZCBzb21lIChhbGw/ KSBvZiB0aGVzZSBwYXRjaGVzIHRvIHVubWFwIG1lbW9yeSBmcm9tIHRoZSBob3N0Cj4gICAgIHdo ZW4gbmVjZXNzYXJ5Ogo+Cj4gICAgIGh0dHBzOi8vbHduLm5ldC9BcnRpY2xlcy84MjEyMTUvCj4K PiAgICAgKGZvciBuVkhFLCB3ZSdsbCBoYXZlIGEgc3RhZ2UtMiBmb3IgdGhlIGhvc3Qgc28gd2Ug Y2FuIHVubWFwIHRoZXJlIGFzCj4gICAgIHdlbGwpCj4KClNvdW5kcyBtb3JlIGZ1bi4KCj4gRm9y IGNvbW11bmljYXRpbmcgd2l0aCBwYXJ0aXRpb25zIHRoYXQgYXJlIG5vdCBtYW5hZ2VkIGJ5IEtW TSAoZS5nLiB0cnVzdGVkCj4gYXBwbGljYXRpb25zKSwgaXQncyBub3QgY2xlYXIgdG8gbWUgaG93 IG11Y2ggb2YgdGhhdCB3aWxsIGJlIGhhbmRsZWQgaW4KPiBrZXJuZWwgb3IgdXNlci4gSSB0aGlu ayBpdCB3b3VsZCBzdGlsbCBiZSB3b3J0aCBleHBvc2luZyB0aGUgcGFydGl0aW9ucyBhcwo+IGZp bGVzLCBidXQgcGVyaGFwcyBoYXZpbmcgdGhlbSByb290IG9ubHkgb3IganVzdCByZXR1cm5pbmcg LUVQRVJNIGZvciB0aGUKPiBpb2N0bCgpIGlmIGEga2VybmVsIGRyaXZlciBoYXMgY2xhaW1lZCB0 aGUgcGFydGl0aW9uIGFzIGl0cyBvd24/IElkZWFsbHksCj4gRkYtQSB3b3VsZCBhbGxvdyB1cyB0 byB0cmFuc2l0aW9uIHNvbWUgb2YgdGhlIFRydXN0ZWQgT1MgaW50ZXJmYWNpbmcgY29kZQo+IG91 dCB0byB1c2Vyc3BhY2UsIGJ1dCBJIGRvbid0IGtub3cgaG93IHJlYWxpc3RpYyB0aGF0IGlzLgo+ CgpBaCBnb29kLCBzbyB3ZSBjYW4gc3RpbGwgbWFuYWdlIGluLWtlcm5lbCB1c2VycyB0aGlzIHdh eSBidXQgd2UgbmVlZCB0bwpwcm92aWRlIGludGVyZmFjZSB0byBzdWNoIGEgZHJpdmVyIHdoaWNo IEkgYWdyZWUgdGhhdCB3ZSBuZWVkIHRvIGF2b2lkCmlmIHBvc3NpYmxlLgoKPiBBbnl3YXksIHRv IGVuYWJsZSB0aGlzLCBJIHRoaW5rIHdlIG5lZWQgYSBjbGVhciBzZXBhcmF0aW9uIGluIHRoZSBr ZXJuZWwKPiBiZXR3ZWVuIHRoZSBGRi1BIGNvZGUgYW5kIHRoZSB1c2VyczoKQWdyZWVkLgoKPiBL Vk0gd2lsbCB3YW50IHRvIGV4cG9zZSB0aGluZ3MgYXMgYWJvdmUsIGJ1dCBpZiBkcml2ZXJzIG5l ZWQgdG8gdXNlIHRoaXMKPiBzdHVmZiBhcyB3ZWxsIHRoZW4gdGhleSBjYW4gcGx1ZyBpbiBhcyBh ZGRpdGlvbmFsIHVzZXJzIGFuZCB3ZSBkb24ndCBoYXZlIHRvCj4gd29ycnkgYWJvdXQgdHJpcHBp bmcgb3ZlciB0aGUgUlgvVFggYnVmZmVycyBldGMuCj4KCkkgYW0gY29uZnVzZWQgYSBiaXQuIFdo ZW4geW91IHJlZmVyIGRyaXZlcnMgYWJvdmUsIGFyZSB5b3UgcmVmZXJyaW5nIHRvCmRyaXZlcnMg aW4gaG9zdCBrZXJuZWwoaHlwZXJ2aXNvcikgb3IgaW4gdGhlIHBhcnRpdGlvbnMuIEkgZmFpbCB0 bwppbWFnaW5lIG5lZWQgZm9yIHRoZSBmb3JtZXIuCgo+IFdoYXQgZG8geW91IHRoaW5rLCBhbmQg ZG8geW91IHJlY2tvbiB5b3UgY2FuIHNwaW4gYSBjdXQtZG93biBkcml2ZXIgdGhhdAo+IGltcGxl bWVudHMgdGhlIGNvbW1vbiBwYXJ0IG9mIHRoZSBsb2dpYyAoc2luY2UgSSBrbm93IHlvdSd2ZSB3 cml0dGVuIG11Y2gKPiBvZiB0aGlzIGNvZGUgYWxyZWFkeSk/Cj4KCkkgYW0gbm90IHN1cmUgaWYg SSBhbSBhbGlnbmVkIHdpdGggeW91ciB0aG91Z2h0cyBvbiB0aGUgYnVmZmVyIHNoYXJpbmcKeWV0 LgoKLS0KUmVnYXJkcywKU3VkZWVwCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2Vy bmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1h bi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==