From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753193AbeBSRBf (ORCPT ); Mon, 19 Feb 2018 12:01:35 -0500 Received: from mail-wm0-f44.google.com ([74.125.82.44]:52197 "EHLO mail-wm0-f44.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753108AbeBSRBd (ORCPT ); Mon, 19 Feb 2018 12:01:33 -0500 X-Google-Smtp-Source: AH8x226ADKF6SvRIRVPbZKUkk7zhlYCtWQR/+RB5BT/y5iXOf2NBVU6//FvAJLTenqLYIKEOcSZcjQ== Date: Mon, 19 Feb 2018 18:01:29 +0100 From: Daniel Vetter To: Dongwon Kim Cc: linux-kernel@vger.kernel.org, linaro-mm-sig@lists.linaro.org, xen-devel@lists.xenproject.org, dri-devel@lists.freedesktop.org, mateuszx.potrola@intel.com Subject: Re: [RFC PATCH v2 0/9] hyper_dmabuf: Hyper_DMABUF driver Message-ID: <20180219170129.GC22199@phenom.ffwll.local> Mail-Followup-To: Dongwon Kim , linux-kernel@vger.kernel.org, linaro-mm-sig@lists.linaro.org, xen-devel@lists.xenproject.org, dri-devel@lists.freedesktop.org, mateuszx.potrola@intel.com References: <20180214015008.9513-1-dongwon.kim@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20180214015008.9513-1-dongwon.kim@intel.com> X-Operating-System: Linux phenom 4.14.0-3-amd64 User-Agent: Mutt/1.9.3 (2018-01-21) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Tue, Feb 13, 2018 at 05:49:59PM -0800, Dongwon Kim wrote: > This patch series contains the implementation of a new device driver, > hyper_DMABUF driver, which provides a way to expand the boundary of > Linux DMA-BUF sharing to across different VM instances in Multi-OS platform > enabled by a Hypervisor (e.g. XEN) > > This version 2 series is basically refactored version of old series starting > with "[RFC PATCH 01/60] hyper_dmabuf: initial working version of hyper_dmabuf > drv" > > Implementation details of this driver are described in the reference guide > added by the second patch, "[RFC PATCH v2 2/5] hyper_dmabuf: architecture > specification and reference guide". > > Attaching 'Overview' section here as a quick summary. > > ------------------------------------------------------------------------------ > Section 1. Overview > ------------------------------------------------------------------------------ > > Hyper_DMABUF driver is a Linux device driver running on multiple Virtual > achines (VMs), which expands DMA-BUF sharing capability to the VM environment > where multiple different OS instances need to share same physical data without > data-copy across VMs. > > To share a DMA_BUF across VMs, an instance of the Hyper_DMABUF drv on the > exporting VM (so called, “exporter”) imports a local DMA_BUF from the original > producer of the buffer, then re-exports it with an unique ID, hyper_dmabuf_id > for the buffer to the importing VM (so called, “importer”). > > Another instance of the Hyper_DMABUF driver on importer registers > a hyper_dmabuf_id together with reference information for the shared physical > pages associated with the DMA_BUF to its database when the export happens. > > The actual mapping of the DMA_BUF on the importer’s side is done by > the Hyper_DMABUF driver when user space issues the IOCTL command to access > the shared DMA_BUF. The Hyper_DMABUF driver works as both an importing and > exporting driver as is, that is, no special configuration is required. > Consequently, only a single module per VM is needed to enable cross-VM DMA_BUF > exchange. > > ------------------------------------------------------------------------------ > > There is a git repository at github.com where this series of patches are all > integrated in Linux kernel tree based on the commit: > > commit ae64f9bd1d3621b5e60d7363bc20afb46aede215 > Author: Linus Torvalds > Date: Sun Dec 3 11:01:47 2018 -0500 > > Linux 4.15-rc2 > > https://github.com/downor/linux_hyper_dmabuf.git hyper_dmabuf_integration_v4 Since you place this under drivers/dma-buf I'm assuming you want to maintain this as part of the core dma-buf support, and not as some Xen-specific thing. Given that, usual graphics folks rules apply: Where's the userspace for this (must be open source)? What exactly is the use-case you're trying to solve by sharing dma-bufs in this fashion? Iirc my feedback on v1 was why exactly you really need to be able to import a normal dma-buf into a hyper-dmabuf, instead of allocating them directly in the hyper-dmabuf driver. Which would _massively_ simplify your design, since you don't need to marshall all the attach and map business around (since the hypervisor would be in control of the dma-buf, not a guest OS). Also, all this marshalling leaves me with the impression that the guest that exports the dma-buf could take down the importer. That kinda nukes all the separation guarantees that vms provide. Or you just stuff this somewhere deeply hidden within Xen where gpu folks can't find it :-) -Daniel > > Dongwon Kim, Mateusz Polrola (9): > hyper_dmabuf: initial upload of hyper_dmabuf drv core framework > hyper_dmabuf: architecture specification and reference guide > MAINTAINERS: adding Hyper_DMABUF driver section in MAINTAINERS > hyper_dmabuf: user private data attached to hyper_DMABUF > hyper_dmabuf: hyper_DMABUF synchronization across VM > hyper_dmabuf: query ioctl for retreiving various hyper_DMABUF info > hyper_dmabuf: event-polling mechanism for detecting a new hyper_DMABUF > hyper_dmabuf: threaded interrupt in Xen-backend > hyper_dmabuf: default backend for XEN hypervisor > > Documentation/hyper-dmabuf-sharing.txt | 734 ++++++++++++++++ > MAINTAINERS | 11 + > drivers/dma-buf/Kconfig | 2 + > drivers/dma-buf/Makefile | 1 + > drivers/dma-buf/hyper_dmabuf/Kconfig | 50 ++ > drivers/dma-buf/hyper_dmabuf/Makefile | 44 + > .../backends/xen/hyper_dmabuf_xen_comm.c | 944 +++++++++++++++++++++ > .../backends/xen/hyper_dmabuf_xen_comm.h | 78 ++ > .../backends/xen/hyper_dmabuf_xen_comm_list.c | 158 ++++ > .../backends/xen/hyper_dmabuf_xen_comm_list.h | 67 ++ > .../backends/xen/hyper_dmabuf_xen_drv.c | 46 + > .../backends/xen/hyper_dmabuf_xen_drv.h | 53 ++ > .../backends/xen/hyper_dmabuf_xen_shm.c | 525 ++++++++++++ > .../backends/xen/hyper_dmabuf_xen_shm.h | 46 + > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_drv.c | 410 +++++++++ > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_drv.h | 122 +++ > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_event.c | 122 +++ > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_event.h | 38 + > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_id.c | 135 +++ > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_id.h | 53 ++ > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_ioctl.c | 794 +++++++++++++++++ > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_ioctl.h | 52 ++ > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_list.c | 295 +++++++ > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_list.h | 73 ++ > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_msg.c | 416 +++++++++ > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_msg.h | 89 ++ > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_ops.c | 415 +++++++++ > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_ops.h | 34 + > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.c | 174 ++++ > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.h | 36 + > .../hyper_dmabuf/hyper_dmabuf_remote_sync.c | 324 +++++++ > .../hyper_dmabuf/hyper_dmabuf_remote_sync.h | 32 + > .../dma-buf/hyper_dmabuf/hyper_dmabuf_sgl_proc.c | 257 ++++++ > .../dma-buf/hyper_dmabuf/hyper_dmabuf_sgl_proc.h | 43 + > drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_struct.h | 143 ++++ > include/uapi/linux/hyper_dmabuf.h | 134 +++ > 36 files changed, 6950 insertions(+) > create mode 100644 Documentation/hyper-dmabuf-sharing.txt > create mode 100644 drivers/dma-buf/hyper_dmabuf/Kconfig > create mode 100644 drivers/dma-buf/hyper_dmabuf/Makefile > create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm_list.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm_list.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_drv.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_drv.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_shm.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_shm.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_drv.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_drv.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_event.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_event.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_id.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_id.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_ioctl.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_ioctl.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_list.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_list.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_msg.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_msg.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_ops.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_ops.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_remote_sync.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_remote_sync.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_sgl_proc.c > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_sgl_proc.h > create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_struct.h > create mode 100644 include/uapi/linux/hyper_dmabuf.h > > -- > 2.16.1 > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [RFC PATCH v2 0/9] hyper_dmabuf: Hyper_DMABUF driver Date: Mon, 19 Feb 2018 18:01:29 +0100 Message-ID: <20180219170129.GC22199@phenom.ffwll.local> References: <20180214015008.9513-1-dongwon.kim@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-x230.google.com (mail-wm0-x230.google.com [IPv6:2a00:1450:400c:c09::230]) by gabe.freedesktop.org (Postfix) with ESMTPS id DB97E6E26E for ; Mon, 19 Feb 2018 17:01:33 +0000 (UTC) Received: by mail-wm0-x230.google.com with SMTP id k87so16450537wmi.0 for ; Mon, 19 Feb 2018 09:01:33 -0800 (PST) Content-Disposition: inline In-Reply-To: <20180214015008.9513-1-dongwon.kim@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Dongwon Kim Cc: linaro-mm-sig@lists.linaro.org, xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, mateuszx.potrola@intel.com List-Id: dri-devel@lists.freedesktop.org T24gVHVlLCBGZWIgMTMsIDIwMTggYXQgMDU6NDk6NTlQTSAtMDgwMCwgRG9uZ3dvbiBLaW0gd3Jv dGU6Cj4gVGhpcyBwYXRjaCBzZXJpZXMgY29udGFpbnMgdGhlIGltcGxlbWVudGF0aW9uIG9mIGEg bmV3IGRldmljZSBkcml2ZXIsCj4gaHlwZXJfRE1BQlVGIGRyaXZlciwgd2hpY2ggcHJvdmlkZXMg YSB3YXkgdG8gZXhwYW5kIHRoZSBib3VuZGFyeSBvZgo+IExpbnV4IERNQS1CVUYgc2hhcmluZyB0 byBhY3Jvc3MgZGlmZmVyZW50IFZNIGluc3RhbmNlcyBpbiBNdWx0aS1PUyBwbGF0Zm9ybQo+IGVu YWJsZWQgYnkgYSBIeXBlcnZpc29yIChlLmcuIFhFTikKPiAKPiBUaGlzIHZlcnNpb24gMiBzZXJp ZXMgaXMgYmFzaWNhbGx5IHJlZmFjdG9yZWQgdmVyc2lvbiBvZiBvbGQgc2VyaWVzIHN0YXJ0aW5n Cj4gd2l0aCAiW1JGQyBQQVRDSCAwMS82MF0gaHlwZXJfZG1hYnVmOiBpbml0aWFsIHdvcmtpbmcg dmVyc2lvbiBvZiBoeXBlcl9kbWFidWYKPiBkcnYiCj4gCj4gSW1wbGVtZW50YXRpb24gZGV0YWls cyBvZiB0aGlzIGRyaXZlciBhcmUgZGVzY3JpYmVkIGluIHRoZSByZWZlcmVuY2UgZ3VpZGUKPiBh ZGRlZCBieSB0aGUgc2Vjb25kIHBhdGNoLCAiW1JGQyBQQVRDSCB2MiAyLzVdIGh5cGVyX2RtYWJ1 ZjogYXJjaGl0ZWN0dXJlCj4gc3BlY2lmaWNhdGlvbiBhbmQgcmVmZXJlbmNlIGd1aWRlIi4KPiAK PiBBdHRhY2hpbmcgJ092ZXJ2aWV3JyBzZWN0aW9uIGhlcmUgYXMgYSBxdWljayBzdW1tYXJ5Lgo+ IAo+IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+IFNlY3Rpb24gMS4gT3ZlcnZpZXcKPiAtLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KPiAKPiBIeXBlcl9ETUFCVUYgZHJpdmVyIGlzIGEgTGludXggZGV2aWNl IGRyaXZlciBydW5uaW5nIG9uIG11bHRpcGxlIFZpcnR1YWwKPiBhY2hpbmVzIChWTXMpLCB3aGlj aCBleHBhbmRzIERNQS1CVUYgc2hhcmluZyBjYXBhYmlsaXR5IHRvIHRoZSBWTSBlbnZpcm9ubWVu dAo+IHdoZXJlIG11bHRpcGxlIGRpZmZlcmVudCBPUyBpbnN0YW5jZXMgbmVlZCB0byBzaGFyZSBz YW1lIHBoeXNpY2FsIGRhdGEgd2l0aG91dAo+IGRhdGEtY29weSBhY3Jvc3MgVk1zLgo+IAo+IFRv IHNoYXJlIGEgRE1BX0JVRiBhY3Jvc3MgVk1zLCBhbiBpbnN0YW5jZSBvZiB0aGUgSHlwZXJfRE1B QlVGIGRydiBvbiB0aGUKPiBleHBvcnRpbmcgVk0gKHNvIGNhbGxlZCwg4oCcZXhwb3J0ZXLigJ0p IGltcG9ydHMgYSBsb2NhbCBETUFfQlVGIGZyb20gdGhlIG9yaWdpbmFsCj4gcHJvZHVjZXIgb2Yg dGhlIGJ1ZmZlciwgdGhlbiByZS1leHBvcnRzIGl0IHdpdGggYW4gdW5pcXVlIElELCBoeXBlcl9k bWFidWZfaWQKPiBmb3IgdGhlIGJ1ZmZlciB0byB0aGUgaW1wb3J0aW5nIFZNIChzbyBjYWxsZWQs IOKAnGltcG9ydGVy4oCdKS4KPiAKPiBBbm90aGVyIGluc3RhbmNlIG9mIHRoZSBIeXBlcl9ETUFC VUYgZHJpdmVyIG9uIGltcG9ydGVyIHJlZ2lzdGVycwo+IGEgaHlwZXJfZG1hYnVmX2lkIHRvZ2V0 aGVyIHdpdGggcmVmZXJlbmNlIGluZm9ybWF0aW9uIGZvciB0aGUgc2hhcmVkIHBoeXNpY2FsCj4g cGFnZXMgYXNzb2NpYXRlZCB3aXRoIHRoZSBETUFfQlVGIHRvIGl0cyBkYXRhYmFzZSB3aGVuIHRo ZSBleHBvcnQgaGFwcGVucy4KPiAKPiBUaGUgYWN0dWFsIG1hcHBpbmcgb2YgdGhlIERNQV9CVUYg b24gdGhlIGltcG9ydGVy4oCZcyBzaWRlIGlzIGRvbmUgYnkKPiB0aGUgSHlwZXJfRE1BQlVGIGRy aXZlciB3aGVuIHVzZXIgc3BhY2UgaXNzdWVzIHRoZSBJT0NUTCBjb21tYW5kIHRvIGFjY2Vzcwo+ IHRoZSBzaGFyZWQgRE1BX0JVRi4gVGhlIEh5cGVyX0RNQUJVRiBkcml2ZXIgd29ya3MgYXMgYm90 aCBhbiBpbXBvcnRpbmcgYW5kCj4gZXhwb3J0aW5nIGRyaXZlciBhcyBpcywgdGhhdCBpcywgbm8g c3BlY2lhbCBjb25maWd1cmF0aW9uIGlzIHJlcXVpcmVkLgo+IENvbnNlcXVlbnRseSwgb25seSBh IHNpbmdsZSBtb2R1bGUgcGVyIFZNIGlzIG5lZWRlZCB0byBlbmFibGUgY3Jvc3MtVk0gRE1BX0JV Rgo+IGV4Y2hhbmdlLgo+IAo+IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+IAo+IFRoZXJlIGlzIGEg Z2l0IHJlcG9zaXRvcnkgYXQgZ2l0aHViLmNvbSB3aGVyZSB0aGlzIHNlcmllcyBvZiBwYXRjaGVz IGFyZSBhbGwKPiBpbnRlZ3JhdGVkIGluIExpbnV4IGtlcm5lbCB0cmVlIGJhc2VkIG9uIHRoZSBj b21taXQ6Cj4gCj4gICAgICAgICBjb21taXQgYWU2NGY5YmQxZDM2MjFiNWU2MGQ3MzYzYmMyMGFm YjQ2YWVkZTIxNQo+ICAgICAgICAgQXV0aG9yOiBMaW51cyBUb3J2YWxkcyA8dG9ydmFsZHNAeHh4 eHh4eHh4eHh4eHh4eHh4eHg+Cj4gICAgICAgICBEYXRlOiAgIFN1biBEZWMgMyAxMTowMTo0NyAy MDE4IC0wNTAwCj4gCj4gICAgICAgICAgICAgTGludXggNC4xNS1yYzIKPiAKPiBodHRwczovL2dp dGh1Yi5jb20vZG93bm9yL2xpbnV4X2h5cGVyX2RtYWJ1Zi5naXQgaHlwZXJfZG1hYnVmX2ludGVn cmF0aW9uX3Y0CgpTaW5jZSB5b3UgcGxhY2UgdGhpcyB1bmRlciBkcml2ZXJzL2RtYS1idWYgSSdt IGFzc3VtaW5nIHlvdSB3YW50IHRvCm1haW50YWluIHRoaXMgYXMgcGFydCBvZiB0aGUgY29yZSBk bWEtYnVmIHN1cHBvcnQsIGFuZCBub3QgYXMgc29tZQpYZW4tc3BlY2lmaWMgdGhpbmcuIEdpdmVu IHRoYXQsIHVzdWFsIGdyYXBoaWNzIGZvbGtzIHJ1bGVzIGFwcGx5OgoKV2hlcmUncyB0aGUgdXNl cnNwYWNlIGZvciB0aGlzIChtdXN0IGJlIG9wZW4gc291cmNlKT8gV2hhdCBleGFjdGx5IGlzIHRo ZQp1c2UtY2FzZSB5b3UncmUgdHJ5aW5nIHRvIHNvbHZlIGJ5IHNoYXJpbmcgZG1hLWJ1ZnMgaW4g dGhpcyBmYXNoaW9uPwoKSWlyYyBteSBmZWVkYmFjayBvbiB2MSB3YXMgd2h5IGV4YWN0bHkgeW91 IHJlYWxseSBuZWVkIHRvIGJlIGFibGUgdG8KaW1wb3J0IGEgbm9ybWFsIGRtYS1idWYgaW50byBh IGh5cGVyLWRtYWJ1ZiwgaW5zdGVhZCBvZiBhbGxvY2F0aW5nIHRoZW0KZGlyZWN0bHkgaW4gdGhl IGh5cGVyLWRtYWJ1ZiBkcml2ZXIuIFdoaWNoIHdvdWxkIF9tYXNzaXZlbHlfIHNpbXBsaWZ5IHlv dXIKZGVzaWduLCBzaW5jZSB5b3UgZG9uJ3QgbmVlZCB0byBtYXJzaGFsbCBhbGwgdGhlIGF0dGFj aCBhbmQgbWFwIGJ1c2luZXNzCmFyb3VuZCAoc2luY2UgdGhlIGh5cGVydmlzb3Igd291bGQgYmUg aW4gY29udHJvbCBvZiB0aGUgZG1hLWJ1Ziwgbm90IGEKZ3Vlc3QgT1MpLiBBbHNvLCBhbGwgdGhp cyBtYXJzaGFsbGluZyBsZWF2ZXMgbWUgd2l0aCB0aGUgaW1wcmVzc2lvbiB0aGF0CnRoZSBndWVz dCB0aGF0IGV4cG9ydHMgdGhlIGRtYS1idWYgY291bGQgdGFrZSBkb3duIHRoZSBpbXBvcnRlci4g VGhhdApraW5kYSBudWtlcyBhbGwgdGhlIHNlcGFyYXRpb24gZ3VhcmFudGVlcyB0aGF0IHZtcyBw cm92aWRlLgoKT3IgeW91IGp1c3Qgc3R1ZmYgdGhpcyBzb21ld2hlcmUgZGVlcGx5IGhpZGRlbiB3 aXRoaW4gWGVuIHdoZXJlIGdwdSBmb2xrcwpjYW4ndCBmaW5kIGl0IDotKQotRGFuaWVsCgo+IAo+ IERvbmd3b24gS2ltLCBNYXRldXN6IFBvbHJvbGEgKDkpOgo+ICAgaHlwZXJfZG1hYnVmOiBpbml0 aWFsIHVwbG9hZCBvZiBoeXBlcl9kbWFidWYgZHJ2IGNvcmUgZnJhbWV3b3JrCj4gICBoeXBlcl9k bWFidWY6IGFyY2hpdGVjdHVyZSBzcGVjaWZpY2F0aW9uIGFuZCByZWZlcmVuY2UgZ3VpZGUKPiAg IE1BSU5UQUlORVJTOiBhZGRpbmcgSHlwZXJfRE1BQlVGIGRyaXZlciBzZWN0aW9uIGluIE1BSU5U QUlORVJTCj4gICBoeXBlcl9kbWFidWY6IHVzZXIgcHJpdmF0ZSBkYXRhIGF0dGFjaGVkIHRvIGh5 cGVyX0RNQUJVRgo+ICAgaHlwZXJfZG1hYnVmOiBoeXBlcl9ETUFCVUYgc3luY2hyb25pemF0aW9u IGFjcm9zcyBWTQo+ICAgaHlwZXJfZG1hYnVmOiBxdWVyeSBpb2N0bCBmb3IgcmV0cmVpdmluZyB2 YXJpb3VzIGh5cGVyX0RNQUJVRiBpbmZvCj4gICBoeXBlcl9kbWFidWY6IGV2ZW50LXBvbGxpbmcg bWVjaGFuaXNtIGZvciBkZXRlY3RpbmcgYSBuZXcgaHlwZXJfRE1BQlVGCj4gICBoeXBlcl9kbWFi dWY6IHRocmVhZGVkIGludGVycnVwdCBpbiBYZW4tYmFja2VuZAo+ICAgaHlwZXJfZG1hYnVmOiBk ZWZhdWx0IGJhY2tlbmQgZm9yIFhFTiBoeXBlcnZpc29yCj4gCj4gIERvY3VtZW50YXRpb24vaHlw ZXItZG1hYnVmLXNoYXJpbmcudHh0ICAgICAgICAgICAgIHwgNzM0ICsrKysrKysrKysrKysrKysK PiAgTUFJTlRBSU5FUlMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg MTEgKwo+ICBkcml2ZXJzL2RtYS1idWYvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAg ICB8ICAgMiArCj4gIGRyaXZlcnMvZG1hLWJ1Zi9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAg ICAgICAgIHwgICAxICsKPiAgZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9LY29uZmlnICAg ICAgICAgICAgICAgfCAgNTAgKysKPiAgZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9NYWtl ZmlsZSAgICAgICAgICAgICAgfCAgNDQgKwo+ICAuLi4vYmFja2VuZHMveGVuL2h5cGVyX2RtYWJ1 Zl94ZW5fY29tbS5jICAgICAgICAgICB8IDk0NCArKysrKysrKysrKysrKysrKysrKysKPiAgLi4u L2JhY2tlbmRzL3hlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0uaCAgICAgICAgICAgfCAgNzggKysK PiAgLi4uL2JhY2tlbmRzL3hlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW1fbGlzdC5jICAgICAgfCAx NTggKysrKwo+ICAuLi4vYmFja2VuZHMveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29tbV9saXN0Lmgg ICAgICB8ICA2NyArKwo+ICAuLi4vYmFja2VuZHMveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fZHJ2LmMg ICAgICAgICAgICB8ICA0NiArCj4gIC4uLi9iYWNrZW5kcy94ZW4vaHlwZXJfZG1hYnVmX3hlbl9k cnYuaCAgICAgICAgICAgIHwgIDUzICsrCj4gIC4uLi9iYWNrZW5kcy94ZW4vaHlwZXJfZG1hYnVm X3hlbl9zaG0uYyAgICAgICAgICAgIHwgNTI1ICsrKysrKysrKysrKwo+ICAuLi4vYmFja2VuZHMv eGVuL2h5cGVyX2RtYWJ1Zl94ZW5fc2htLmggICAgICAgICAgICB8ICA0NiArCj4gIGRyaXZlcnMv ZG1hLWJ1Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Rydi5jICAgIHwgNDEwICsrKysrKysr Kwo+ICBkcml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9kcnYuaCAgICB8 IDEyMiArKysKPiAgZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfZXZl bnQuYyAgfCAxMjIgKysrCj4gIGRyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1h YnVmX2V2ZW50LmggIHwgIDM4ICsKPiAgZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9oeXBl cl9kbWFidWZfaWQuYyAgICAgfCAxMzUgKysrCj4gIGRyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFi dWYvaHlwZXJfZG1hYnVmX2lkLmggICAgIHwgIDUzICsrCj4gIGRyaXZlcnMvZG1hLWJ1Zi9oeXBl cl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMgIHwgNzk0ICsrKysrKysrKysrKysrKysrCj4g IGRyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmggIHwgIDUy ICsrCj4gIGRyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2xpc3QuYyAg IHwgMjk1ICsrKysrKysKPiAgZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFi dWZfbGlzdC5oICAgfCAgNzMgKysKPiAgZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9oeXBl cl9kbWFidWZfbXNnLmMgICAgfCA0MTYgKysrKysrKysrCj4gIGRyaXZlcnMvZG1hLWJ1Zi9oeXBl cl9kbWFidWYvaHlwZXJfZG1hYnVmX21zZy5oICAgIHwgIDg5ICsrCj4gIGRyaXZlcnMvZG1hLWJ1 Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX29wcy5jICAgIHwgNDE1ICsrKysrKysrKwo+ICBk cml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9vcHMuaCAgICB8ICAzNCAr Cj4gIGRyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3F1ZXJ5LmMgIHwg MTc0ICsrKysKPiAgZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfcXVl cnkuaCAgfCAgMzYgKwo+ICAuLi4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9yZW1vdGVfc3lu Yy5jICAgICAgICB8IDMyNCArKysrKysrCj4gIC4uLi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVm X3JlbW90ZV9zeW5jLmggICAgICAgIHwgIDMyICsKPiAgLi4uL2RtYS1idWYvaHlwZXJfZG1hYnVm L2h5cGVyX2RtYWJ1Zl9zZ2xfcHJvYy5jICAgfCAyNTcgKysrKysrCj4gIC4uLi9kbWEtYnVmL2h5 cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfc2dsX3Byb2MuaCAgIHwgIDQzICsKPiAgZHJpdmVycy9k bWEtYnVmL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfc3RydWN0LmggfCAxNDMgKysrKwo+ICBp bmNsdWRlL3VhcGkvbGludXgvaHlwZXJfZG1hYnVmLmggICAgICAgICAgICAgICAgICB8IDEzNCAr KysKPiAgMzYgZmlsZXMgY2hhbmdlZCwgNjk1MCBpbnNlcnRpb25zKCspCj4gIGNyZWF0ZSBtb2Rl IDEwMDY0NCBEb2N1bWVudGF0aW9uL2h5cGVyLWRtYWJ1Zi1zaGFyaW5nLnR4dAo+ICBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9LY29uZmlnCj4gIGNyZWF0 ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL01ha2VmaWxlCj4gIGNy ZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2JhY2tlbmRzL3hl bi9oeXBlcl9kbWFidWZfeGVuX2NvbW0uYwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9k bWEtYnVmL2h5cGVyX2RtYWJ1Zi9iYWNrZW5kcy94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmgK PiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvYmFja2Vu ZHMveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29tbV9saXN0LmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0 IGRyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvYmFja2VuZHMveGVuL2h5cGVyX2RtYWJ1Zl94 ZW5fY29tbV9saXN0LmgKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZG1hLWJ1Zi9oeXBl cl9kbWFidWYvYmFja2VuZHMveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fZHJ2LmMKPiAgY3JlYXRlIG1v ZGUgMTAwNjQ0IGRyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvYmFja2VuZHMveGVuL2h5cGVy X2RtYWJ1Zl94ZW5fZHJ2LmgKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZG1hLWJ1Zi9o eXBlcl9kbWFidWYvYmFja2VuZHMveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fc2htLmMKPiAgY3JlYXRl IG1vZGUgMTAwNjQ0IGRyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvYmFja2VuZHMveGVuL2h5 cGVyX2RtYWJ1Zl94ZW5fc2htLmgKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZG1hLWJ1 Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Rydi5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9kcnYuaAo+ICBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfZXZl bnQuYwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9o eXBlcl9kbWFidWZfZXZlbnQuaAo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVm L2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaWQuYwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJp dmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaWQuaAo+ICBjcmVhdGUgbW9k ZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwu Ywo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9oeXBl cl9kbWFidWZfaW9jdGwuaAo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVmL2h5 cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbGlzdC5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9saXN0LmgKPiAgY3JlYXRlIG1v ZGUgMTAwNjQ0IGRyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX21zZy5j Cj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2h5cGVy X2RtYWJ1Zl9tc2cuaAo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVmL2h5cGVy X2RtYWJ1Zi9oeXBlcl9kbWFidWZfb3BzLmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMv ZG1hLWJ1Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX29wcy5oCj4gIGNyZWF0ZSBtb2RlIDEw MDY0NCBkcml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9xdWVyeS5jCj4g IGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2h5cGVyX2Rt YWJ1Zl9xdWVyeS5oCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2RtYS1idWYvaHlwZXJf ZG1hYnVmL2h5cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYy5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYy5oCj4g IGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2h5cGVyX2Rt YWJ1Zl9zZ2xfcHJvYy5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2RtYS1idWYvaHlw ZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9zZ2xfcHJvYy5oCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9zdHJ1Y3QuaAo+ICBjcmVh dGUgbW9kZSAxMDA2NDQgaW5jbHVkZS91YXBpL2xpbnV4L2h5cGVyX2RtYWJ1Zi5oCj4gCj4gLS0g Cj4gMi4xNi4xCj4gCj4gX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KPiBkcmktZGV2ZWwgbWFpbGluZyBsaXN0Cj4gZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNr dG9wLm9yZwo+IGh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8v ZHJpLWRldmVsCgotLSAKRGFuaWVsIFZldHRlcgpTb2Z0d2FyZSBFbmdpbmVlciwgSW50ZWwgQ29y cG9yYXRpb24KaHR0cDovL2Jsb2cuZmZ3bGwuY2gKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlz dHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4v bGlzdGluZm8vZHJpLWRldmVsCg==