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=-16.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B274DC48BE5 for ; Wed, 23 Jun 2021 16:20:08 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (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 7E2816024A for ; Wed, 23 Jun 2021 16:20:08 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 7E2816024A Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ffwll.ch Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 18A556E956; Wed, 23 Jun 2021 16:20:05 +0000 (UTC) Received: from mail-ed1-x52b.google.com (mail-ed1-x52b.google.com [IPv6:2a00:1450:4864:20::52b]) by gabe.freedesktop.org (Postfix) with ESMTPS id 4F5286E944 for ; Wed, 23 Jun 2021 16:20:03 +0000 (UTC) Received: by mail-ed1-x52b.google.com with SMTP id df12so4311510edb.2 for ; Wed, 23 Jun 2021 09:20:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=18nsKlNRPeSGzK/GtnkV65GHuS4sYhXYKk8mOhr9KfE=; b=TuPLi5hS5A53DBo+f8uhcVE1txIOQXShrAJF3YLB8j0FAHlj1BRP3LogkRA3DiBVjU JMzxb7oAOUi87Hr6V3vp8P3KZWvxYY7DEhTClRYkoFWpLiC5vy+s78mGKg7eivhTEidY KJ4TvOQ4DGB26WELxg8qT5ukAtQIRSPiMmEco= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=18nsKlNRPeSGzK/GtnkV65GHuS4sYhXYKk8mOhr9KfE=; b=OUGoSZcV3fwccXnh9KLqbDqjsCUClj0j+/G/i41yilZiyDJShseA/tuuvwBCInCvd7 yBBpBtN0LG3CQHgt3o4jObm01hznQLjluctA9GC8iW0WIP8eaAyYqoTDDTXbJNyba+BH s5Rt8TPm9Jqu2w8n3XyNZRiH5leuJDJja6Osi15O+I5XI2c7w16cAwldcL++PWTU92MH DvVdBXnySJlNp7u74/gQgRoCCpf6cToxdPxAWj+VmtCYA4QW67Uyc32rMppzKBjRO3e5 nRwNBt5ZBe/4SeAzjYzjPuY7HxkJ108FKo4A/Vmsebq3qZ/aUVRxIrnlH9KU9cs/gOo2 xkmA== X-Gm-Message-State: AOAM532mfzDTpHFWcshiXyvlkAGIbQd7NoP26G8j1QA3b/VD2tQudDyh QbrVJksAUY73Mc0wHnDmhIv1QRM/2pP4+w== X-Google-Smtp-Source: ABdhPJwjxcIdheXhNHV4FNEf4j5HbPzwCWsR0AfvzJdQN1VDjWxSlGzeIsVeQ3oXGvUYSFzYSxfLGg== X-Received: by 2002:a50:85cd:: with SMTP id q13mr759508edh.216.1624465201697; Wed, 23 Jun 2021 09:20:01 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa]) by smtp.gmail.com with ESMTPSA id h6sm296018edj.91.2021.06.23.09.20.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 23 Jun 2021 09:20:01 -0700 (PDT) From: Daniel Vetter To: DRI Development Subject: [PATCH] dma-buf: Document dma-buf implicit fencing/resv fencing rules Date: Wed, 23 Jun 2021 18:19:55 +0200 Message-Id: <20210623161955.3371466-1-daniel.vetter@ffwll.ch> X-Mailer: git-send-email 2.32.0.rc2 In-Reply-To: <20210622165511.3169559-4-daniel.vetter@ffwll.ch> References: <20210622165511.3169559-4-daniel.vetter@ffwll.ch> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Rob Clark , linaro-mm-sig@lists.linaro.org, Daniel Stone , Daniel Vetter , Daniel Vetter , Intel Graphics Development , Kevin Wang , =?UTF-8?q?Michel=20D=C3=A4nzer?= , Luben Tuikov , "Kristian H . Kristensen" , Chen Li , Alex Deucher , mesa-dev@lists.freedesktop.org, =?UTF-8?q?Christian=20K=C3=B6nig?= , Dennis Li , Deepak R Varma Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Docs for struct dma_resv are fairly clear: "A reservation object can have attached one exclusive fence (normally associated with write operations) or N shared fences (read operations)." https://dri.freedesktop.org/docs/drm/driver-api/dma-buf.html#reservation-objects Furthermore a review across all of upstream. First of render drivers and how they set implicit fences: - nouveau follows this contract, see in validate_fini_no_ticket() nouveau_bo_fence(nvbo, fence, !!b->write_domains); and that last boolean controls whether the exclusive or shared fence slot is used. - radeon follows this contract by setting p->relocs[i].tv.num_shared = !r->write_domain; in radeon_cs_parser_relocs(), which ensures that the call to ttm_eu_fence_buffer_objects() in radeon_cs_parser_fini() will do the right thing. - vmwgfx seems to follow this contract with the shotgun approach of always setting ttm_val_buf->num_shared = 0, which means ttm_eu_fence_buffer_objects() will only use the exclusive slot. - etnaviv follows this contract, as can be trivially seen by looking at submit_attach_object_fences() - i915 is a bit a convoluted maze with multiple paths leading to i915_vma_move_to_active(). Which sets the exclusive flag if EXEC_OBJECT_WRITE is set. This can either come as a buffer flag for softpin mode, or through the write_domain when using relocations. It follows this contract. - lima follows this contract, see lima_gem_submit() which sets the exclusive fence when the LIMA_SUBMIT_BO_WRITE flag is set for that bo - msm follows this contract, see msm_gpu_submit() which sets the exclusive flag when the MSM_SUBMIT_BO_WRITE is set for that buffer - panfrost follows this contract with the shotgun approach of just always setting the exclusive fence, see panfrost_attach_object_fences(). Benefits of a single engine I guess - v3d follows this contract with the same shotgun approach in v3d_attach_fences_and_unlock_reservation(), but it has at least an XXX comment that maybe this should be improved - v4c uses the same shotgun approach of always setting an exclusive fence, see vc4_update_bo_seqnos() - vgem also follows this contract, see vgem_fence_attach_ioctl() and the VGEM_FENCE_WRITE. This is used in some igts to validate prime sharing with i915.ko without the need of a 2nd gpu - vritio follows this contract again with the shotgun approach of always setting an exclusive fence, see virtio_gpu_array_add_fence() This covers the setting of the exclusive fences when writing. Synchronizing against the exclusive fence is a lot more tricky, and I only spot checked a few: - i915 does it, with the optional EXEC_OBJECT_ASYNC to skip all implicit dependencies (which is used by vulkan) - etnaviv does this. Implicit dependencies are collected in submit_fence_sync(), again with an opt-out flag ETNA_SUBMIT_NO_IMPLICIT. These are then picked up in etnaviv_sched_dependency which is the drm_sched_backend_ops->dependency callback. - v4c seems to not do much here, maybe gets away with it by not having a scheduler and only a single engine. Since all newer broadcom chips than the OG vc4 use v3d for rendering, which follows this contract, the impact of this issue is fairly small. - v3d does this using the drm_gem_fence_array_add_implicit() helper, which then it's drm_sched_backend_ops->dependency callback v3d_job_dependency() picks up. - panfrost is nice here and tracks the implicit fences in panfrost_job->implicit_fences, which again the drm_sched_backend_ops->dependency callback panfrost_job_dependency() picks up. It is mildly questionable though since it only picks up exclusive fences in panfrost_acquire_object_fences(), but not buggy in practice because it also always sets the exclusive fence. It should pick up both sets of fences, just in case there's ever going to be a 2nd gpu in a SoC with a mali gpu. Or maybe a mali SoC with a pcie port and a real gpu, which might actually happen eventually. A bug, but easy to fix. Should probably use the drm_gem_fence_array_add_implicit() helper. - lima is nice an easy, uses drm_gem_fence_array_add_implicit() and the same schema as v3d. - msm is mildly entertaining. It also supports MSM_SUBMIT_NO_IMPLICIT, but because it doesn't use the drm/scheduler it handles fences from the wrong context with a synchronous dma_fence_wait. See submit_fence_sync() leading to msm_gem_sync_object(). Investing into a scheduler might be a good idea. - all the remaining drivers are ttm based, where I hope they do appropriately obey implicit fences already. I didn't do the full audit there because a) not follow the contract would confuse ttm quite well and b) reading non-standard scheduler and submit code which isn't based on drm/scheduler is a pain. Onwards to the display side. - Any driver using the drm_gem_plane_helper_prepare_fb() helper will correctly. Overwhelmingly most drivers get this right, except a few totally dont. I'll follow up with a patch to make this the default and avoid a bunch of bugs. - I didn't audit the ttm drivers, but given that dma_resv started there I hope they get this right. In conclusion this IS the contract, both as documented and overwhelmingly implemented, specically as implemented by all render drivers except amdgpu. Amdgpu tried to fix this already in commit 049aca4363d8af87cab8d53de5401602db3b9999 Author: Christian König Date: Wed Sep 19 16:54:35 2018 +0200 drm/amdgpu: fix using shared fence for exported BOs v2 but this fix falls short on a number of areas: - It's racy, by the time the buffer is shared it might be too late. To make sure there's definitely never a problem we need to set the fences correctly for any buffer that's potentially exportable. - It's breaking uapi, dma-buf fds support poll() and differentitiate between, which was introduced in commit 9b495a5887994a6d74d5c261d012083a92b94738 Author: Maarten Lankhorst Date: Tue Jul 1 12:57:43 2014 +0200 dma-buf: add poll support, v3 - Christian König wants to nack new uapi building further on this dma_resv contract because it breaks amdgpu, quoting "Yeah, and that is exactly the reason why I will NAK this uAPI change. "This doesn't works for amdgpu at all for the reasons outlined above." https://lore.kernel.org/dri-devel/f2eb6751-2f82-9b23-f57e-548de5b729de@gmail.com/ Rejecting new development because your own driver is broken and violates established cross driver contracts and uapi is really not how upstream works. Now this patch will have a severe performance impact on anything that runs on multiple engines. So we can't just merge it outright, but need a bit a plan: - amdgpu needs a proper uapi for handling implicit fencing. The funny thing is that to do it correctly, implicit fencing must be treated as a very strange IPC mechanism for transporting fences, where both setting the fence and dependency intercepts must be handled explicitly. Current best practices is a per-bo flag to indicate writes, and a per-bo flag to to skip implicit fencing in the CS ioctl as a new chunk. - Since amdgpu has been shipping with broken behaviour we need an opt-out flag from the butchered implicit fencing model to enable the proper explicit implicit fencing model. - for kernel memory fences due to bo moves at least the i915 idea is to use ttm_bo->moving. amdgpu probably needs the same. - since the current p2p dma-buf interface assumes the kernel memory fence is in the exclusive dma_resv fence slot we need to add a new fence slot for kernel fences, which must never be ignored. Since currently only amdgpu supports this there's no real problem here yet, until amdgpu gains a NO_IMPLICIT CS flag. - New userspace needs to ship in enough desktop distros so that users wont notice the perf impact. I think we can ignore LTS distros who upgrade their kernels but not their mesa3d snapshot. - Then when this is all in place we can merge this patch here. What is not a solution to this problem here is trying to make the dma_resv rules in the kernel more clever. The fundamental issue here is that the amdgpu CS uapi is the least expressive one across all drivers (only equalled by panfrost, which has an actual excuse) by not allowing any userspace control over how implicit sync is conducted. Until this is fixed it's completely pointless to make the kernel more clever to improve amdgpu, because all we're doing is papering over this uapi design issue. amdgpu needs to attain the status quo established by other drivers first, once that's achieved we can tackle the remaining issues in a consistent way across drivers. v2: Bas pointed me at AMDGPU_GEM_CREATE_EXPLICIT_SYNC, which I entirely missed. This is great because it means the amdgpu specific piece for proper implicit fence handling exists already, and that since a while. The only thing that's now missing is - fishing the implicit fences out of a shared object at the right time - setting the exclusive implicit fence slot at the right time. Jason has a patch series to fill that gap with a bunch of generic ioctl on the dma-buf fd: https://lore.kernel.org/dri-devel/20210520190007.534046-1-jason@jlekstrand.net/ v3: Since Christian has fixed amdgpu now in commit 8c505bdc9c8b955223b054e34a0be9c3d841cd20 (drm-misc/drm-misc-next) Author: Christian König Date: Wed Jun 9 13:51:36 2021 +0200 drm/amdgpu: rework dma_resv handling v3 Use the audit covered in this commit message as the excuse to update the dma-buf docs around dma_buf.resv usage across drivers. Since dynamic importers have different rules also hammer these in again while we're at it. v4: - Add the missing "through the device" in the dynamic section that I overlooked. - Fix a kerneldoc markup mistake, the link didn't connect Reviewed-by: Christian König (v3) Cc: mesa-dev@lists.freedesktop.org Cc: Bas Nieuwenhuizen Cc: Dave Airlie Cc: Rob Clark Cc: Kristian H. Kristensen Cc: Michel Dänzer Cc: Daniel Stone Cc: Sumit Semwal Cc: "Christian König" Cc: Alex Deucher Cc: Daniel Vetter Cc: Deepak R Varma Cc: Chen Li Cc: Kevin Wang Cc: Dennis Li Cc: Luben Tuikov Cc: linaro-mm-sig@lists.linaro.org Signed-off-by: Daniel Vetter --- include/linux/dma-buf.h | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h index 81cebf414505..494f639ee486 100644 --- a/include/linux/dma-buf.h +++ b/include/linux/dma-buf.h @@ -386,6 +386,45 @@ struct dma_buf { * @resv: * * Reservation object linked to this dma-buf. + * + * IMPLICIT SYNCHRONIZATION RULES: + * + * Drivers which support implicit synchronization of buffer access as + * e.g. exposed in `Implicit Fence Poll Support`_ should follow the + * below rules. + * + * - Drivers should add a shared fence through + * dma_resv_add_shared_fence() for anything the userspace API + * considers a read access. This highly depends upon the API and + * window system: E.g. OpenGL is generally implicitly synchronized on + * Linux, but explicitly synchronized on Android. Whereas Vulkan is + * generally explicitly synchronized for everything, and window system + * buffers have explicit API calls (which then need to make sure the + * implicit fences store here in @resv are updated correctly). + * + * - Similarly drivers should set the exclusive fence through + * dma_resv_add_excl_fence() for anything the userspace API considers + * write access. + * + * - Drivers may just always set the exclusive fence, since that only + * causes unecessarily synchronization, but no correctness issues. + * + * - Some drivers only expose a synchronous userspace API with no + * pipelining across drivers. These do not set any fences for their + * access. An example here is v4l. + * + * DYNAMIC IMPORTER RULES: + * + * Dynamic importers, see dma_buf_attachment_is_dynamic(), have + * additional constraints on how they set up fences: + * + * - Dynamic importers must obey the exclusive fence and wait for it to + * signal before allowing access to the buffer's underlying storage + * through the device. + * + * - Dynamic importers should set fences for any access that they can't + * disable immediately from their &dma_buf_attach_ops.move_notify + * callback. */ struct dma_resv *resv; -- 2.32.0.rc2 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=-16.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 597C8C4743C for ; Wed, 23 Jun 2021 16:20:07 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (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 07C836024A for ; Wed, 23 Jun 2021 16:20:07 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 07C836024A Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ffwll.ch Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id B78336E955; Wed, 23 Jun 2021 16:20:04 +0000 (UTC) Received: from mail-ed1-x52e.google.com (mail-ed1-x52e.google.com [IPv6:2a00:1450:4864:20::52e]) by gabe.freedesktop.org (Postfix) with ESMTPS id 2213E89BF8 for ; Wed, 23 Jun 2021 16:20:03 +0000 (UTC) Received: by mail-ed1-x52e.google.com with SMTP id r7so4230245edv.12 for ; Wed, 23 Jun 2021 09:20:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=18nsKlNRPeSGzK/GtnkV65GHuS4sYhXYKk8mOhr9KfE=; b=TuPLi5hS5A53DBo+f8uhcVE1txIOQXShrAJF3YLB8j0FAHlj1BRP3LogkRA3DiBVjU JMzxb7oAOUi87Hr6V3vp8P3KZWvxYY7DEhTClRYkoFWpLiC5vy+s78mGKg7eivhTEidY KJ4TvOQ4DGB26WELxg8qT5ukAtQIRSPiMmEco= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=18nsKlNRPeSGzK/GtnkV65GHuS4sYhXYKk8mOhr9KfE=; b=RtF+Fgqki3KDKPxnMz1sDA3w8K+JAxpIg3NRzAnaFlBAl6n16v60ejnsxbCIkDkAXQ 6eNCwTvqlrLMR/YhyOHp8nqkTlHHqI8NjBVxyXJHeDvbaXhL7plyPcgOpeFF6BqMEhtb E54z8K1cfvju3eyqcn0f9p10fAltBk8NLve4hpaejc7zNlNZZGyCnTDGGb8uPixKByT+ lFdepgIZ7pSn2jrgQw/fVwebO7kZXl/mrWkFifTjSjL2yC4O9ZrdmP9cWog5wAmSRokB i+YU4Tvvyjh53TZMa/clGcYuE8fGQRXR+YNLsddtL2DONOFWKnvTkO3fIhe5+Xd1KYJW yD1w== X-Gm-Message-State: AOAM530r166xd6i+5B6HY8bNQalEbnfiFX6SRaIN0BzTwx2xY3H/3Vaw t6iGvnHHCfiso0U62dWljmKFJA== X-Google-Smtp-Source: ABdhPJwjxcIdheXhNHV4FNEf4j5HbPzwCWsR0AfvzJdQN1VDjWxSlGzeIsVeQ3oXGvUYSFzYSxfLGg== X-Received: by 2002:a50:85cd:: with SMTP id q13mr759508edh.216.1624465201697; Wed, 23 Jun 2021 09:20:01 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa]) by smtp.gmail.com with ESMTPSA id h6sm296018edj.91.2021.06.23.09.20.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 23 Jun 2021 09:20:01 -0700 (PDT) From: Daniel Vetter To: DRI Development Date: Wed, 23 Jun 2021 18:19:55 +0200 Message-Id: <20210623161955.3371466-1-daniel.vetter@ffwll.ch> X-Mailer: git-send-email 2.32.0.rc2 In-Reply-To: <20210622165511.3169559-4-daniel.vetter@ffwll.ch> References: <20210622165511.3169559-4-daniel.vetter@ffwll.ch> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH] dma-buf: Document dma-buf implicit fencing/resv fencing rules X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Rob Clark , linaro-mm-sig@lists.linaro.org, Daniel Stone , Daniel Vetter , Daniel Vetter , Intel Graphics Development , Kevin Wang , Sumit Semwal , =?UTF-8?q?Michel=20D=C3=A4nzer?= , Luben Tuikov , "Kristian H . Kristensen" , Chen Li , Bas Nieuwenhuizen , Alex Deucher , mesa-dev@lists.freedesktop.org, Dave Airlie , =?UTF-8?q?Christian=20K=C3=B6nig?= , Dennis Li , Deepak R Varma Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" RG9jcyBmb3Igc3RydWN0IGRtYV9yZXN2IGFyZSBmYWlybHkgY2xlYXI6CgoiQSByZXNlcnZhdGlv biBvYmplY3QgY2FuIGhhdmUgYXR0YWNoZWQgb25lIGV4Y2x1c2l2ZSBmZW5jZSAobm9ybWFsbHkK YXNzb2NpYXRlZCB3aXRoIHdyaXRlIG9wZXJhdGlvbnMpIG9yIE4gc2hhcmVkIGZlbmNlcyAocmVh ZApvcGVyYXRpb25zKS4iCgpodHRwczovL2RyaS5mcmVlZGVza3RvcC5vcmcvZG9jcy9kcm0vZHJp dmVyLWFwaS9kbWEtYnVmLmh0bWwjcmVzZXJ2YXRpb24tb2JqZWN0cwoKRnVydGhlcm1vcmUgYSBy ZXZpZXcgYWNyb3NzIGFsbCBvZiB1cHN0cmVhbS4KCkZpcnN0IG9mIHJlbmRlciBkcml2ZXJzIGFu ZCBob3cgdGhleSBzZXQgaW1wbGljaXQgZmVuY2VzOgoKLSBub3V2ZWF1IGZvbGxvd3MgdGhpcyBj b250cmFjdCwgc2VlIGluIHZhbGlkYXRlX2Zpbmlfbm9fdGlja2V0KCkKCgkJCW5vdXZlYXVfYm9f ZmVuY2UobnZibywgZmVuY2UsICEhYi0+d3JpdGVfZG9tYWlucyk7CgogIGFuZCB0aGF0IGxhc3Qg Ym9vbGVhbiBjb250cm9scyB3aGV0aGVyIHRoZSBleGNsdXNpdmUgb3Igc2hhcmVkIGZlbmNlCiAg c2xvdCBpcyB1c2VkLgoKLSByYWRlb24gZm9sbG93cyB0aGlzIGNvbnRyYWN0IGJ5IHNldHRpbmcK CgkJcC0+cmVsb2NzW2ldLnR2Lm51bV9zaGFyZWQgPSAhci0+d3JpdGVfZG9tYWluOwoKICBpbiBy YWRlb25fY3NfcGFyc2VyX3JlbG9jcygpLCB3aGljaCBlbnN1cmVzIHRoYXQgdGhlIGNhbGwgdG8K ICB0dG1fZXVfZmVuY2VfYnVmZmVyX29iamVjdHMoKSBpbiByYWRlb25fY3NfcGFyc2VyX2Zpbmko KSB3aWxsIGRvIHRoZQogIHJpZ2h0IHRoaW5nLgoKLSB2bXdnZnggc2VlbXMgdG8gZm9sbG93IHRo aXMgY29udHJhY3Qgd2l0aCB0aGUgc2hvdGd1biBhcHByb2FjaCBvZgogIGFsd2F5cyBzZXR0aW5n IHR0bV92YWxfYnVmLT5udW1fc2hhcmVkID0gMCwgd2hpY2ggbWVhbnMKICB0dG1fZXVfZmVuY2Vf YnVmZmVyX29iamVjdHMoKSB3aWxsIG9ubHkgdXNlIHRoZSBleGNsdXNpdmUgc2xvdC4KCi0gZXRu YXZpdiBmb2xsb3dzIHRoaXMgY29udHJhY3QsIGFzIGNhbiBiZSB0cml2aWFsbHkgc2VlbiBieSBs b29raW5nCiAgYXQgc3VibWl0X2F0dGFjaF9vYmplY3RfZmVuY2VzKCkKCi0gaTkxNSBpcyBhIGJp dCBhIGNvbnZvbHV0ZWQgbWF6ZSB3aXRoIG11bHRpcGxlIHBhdGhzIGxlYWRpbmcgdG8KICBpOTE1 X3ZtYV9tb3ZlX3RvX2FjdGl2ZSgpLiBXaGljaCBzZXRzIHRoZSBleGNsdXNpdmUgZmxhZyBpZgog IEVYRUNfT0JKRUNUX1dSSVRFIGlzIHNldC4gVGhpcyBjYW4gZWl0aGVyIGNvbWUgYXMgYSBidWZm ZXIgZmxhZyBmb3IKICBzb2Z0cGluIG1vZGUsIG9yIHRocm91Z2ggdGhlIHdyaXRlX2RvbWFpbiB3 aGVuIHVzaW5nIHJlbG9jYXRpb25zLiBJdAogIGZvbGxvd3MgdGhpcyBjb250cmFjdC4KCi0gbGlt YSBmb2xsb3dzIHRoaXMgY29udHJhY3QsIHNlZSBsaW1hX2dlbV9zdWJtaXQoKSB3aGljaCBzZXRz IHRoZQogIGV4Y2x1c2l2ZSBmZW5jZSB3aGVuIHRoZSBMSU1BX1NVQk1JVF9CT19XUklURSBmbGFn IGlzIHNldCBmb3IgdGhhdAogIGJvCgotIG1zbSBmb2xsb3dzIHRoaXMgY29udHJhY3QsIHNlZSBt c21fZ3B1X3N1Ym1pdCgpIHdoaWNoIHNldHMgdGhlCiAgZXhjbHVzaXZlIGZsYWcgd2hlbiB0aGUg TVNNX1NVQk1JVF9CT19XUklURSBpcyBzZXQgZm9yIHRoYXQgYnVmZmVyCgotIHBhbmZyb3N0IGZv bGxvd3MgdGhpcyBjb250cmFjdCB3aXRoIHRoZSBzaG90Z3VuIGFwcHJvYWNoIG9mIGp1c3QKICBh bHdheXMgc2V0dGluZyB0aGUgZXhjbHVzaXZlIGZlbmNlLCBzZWUKICBwYW5mcm9zdF9hdHRhY2hf b2JqZWN0X2ZlbmNlcygpLiBCZW5lZml0cyBvZiBhIHNpbmdsZSBlbmdpbmUgSSBndWVzcwoKLSB2 M2QgZm9sbG93cyB0aGlzIGNvbnRyYWN0IHdpdGggdGhlIHNhbWUgc2hvdGd1biBhcHByb2FjaCBp bgogIHYzZF9hdHRhY2hfZmVuY2VzX2FuZF91bmxvY2tfcmVzZXJ2YXRpb24oKSwgYnV0IGl0IGhh cyBhdCBsZWFzdCBhbgogIFhYWCBjb21tZW50IHRoYXQgbWF5YmUgdGhpcyBzaG91bGQgYmUgaW1w cm92ZWQKCi0gdjRjIHVzZXMgdGhlIHNhbWUgc2hvdGd1biBhcHByb2FjaCBvZiBhbHdheXMgc2V0 dGluZyBhbiBleGNsdXNpdmUKICBmZW5jZSwgc2VlIHZjNF91cGRhdGVfYm9fc2Vxbm9zKCkKCi0g dmdlbSBhbHNvIGZvbGxvd3MgdGhpcyBjb250cmFjdCwgc2VlIHZnZW1fZmVuY2VfYXR0YWNoX2lv Y3RsKCkgYW5kCiAgdGhlIFZHRU1fRkVOQ0VfV1JJVEUuIFRoaXMgaXMgdXNlZCBpbiBzb21lIGln dHMgdG8gdmFsaWRhdGUgcHJpbWUKICBzaGFyaW5nIHdpdGggaTkxNS5rbyB3aXRob3V0IHRoZSBu ZWVkIG9mIGEgMm5kIGdwdQoKLSB2cml0aW8gZm9sbG93cyB0aGlzIGNvbnRyYWN0IGFnYWluIHdp dGggdGhlIHNob3RndW4gYXBwcm9hY2ggb2YKICBhbHdheXMgc2V0dGluZyBhbiBleGNsdXNpdmUg ZmVuY2UsIHNlZSB2aXJ0aW9fZ3B1X2FycmF5X2FkZF9mZW5jZSgpCgpUaGlzIGNvdmVycyB0aGUg c2V0dGluZyBvZiB0aGUgZXhjbHVzaXZlIGZlbmNlcyB3aGVuIHdyaXRpbmcuCgpTeW5jaHJvbml6 aW5nIGFnYWluc3QgdGhlIGV4Y2x1c2l2ZSBmZW5jZSBpcyBhIGxvdCBtb3JlIHRyaWNreSwgYW5k IEkKb25seSBzcG90IGNoZWNrZWQgYSBmZXc6CgotIGk5MTUgZG9lcyBpdCwgd2l0aCB0aGUgb3B0 aW9uYWwgRVhFQ19PQkpFQ1RfQVNZTkMgdG8gc2tpcCBhbGwKICBpbXBsaWNpdCBkZXBlbmRlbmNp ZXMgKHdoaWNoIGlzIHVzZWQgYnkgdnVsa2FuKQoKLSBldG5hdml2IGRvZXMgdGhpcy4gSW1wbGlj aXQgZGVwZW5kZW5jaWVzIGFyZSBjb2xsZWN0ZWQgaW4KICBzdWJtaXRfZmVuY2Vfc3luYygpLCBh Z2FpbiB3aXRoIGFuIG9wdC1vdXQgZmxhZwogIEVUTkFfU1VCTUlUX05PX0lNUExJQ0lULiBUaGVz ZSBhcmUgdGhlbiBwaWNrZWQgdXAgaW4KICBldG5hdml2X3NjaGVkX2RlcGVuZGVuY3kgd2hpY2gg aXMgdGhlCiAgZHJtX3NjaGVkX2JhY2tlbmRfb3BzLT5kZXBlbmRlbmN5IGNhbGxiYWNrLgoKLSB2 NGMgc2VlbXMgdG8gbm90IGRvIG11Y2ggaGVyZSwgbWF5YmUgZ2V0cyBhd2F5IHdpdGggaXQgYnkg bm90IGhhdmluZwogIGEgc2NoZWR1bGVyIGFuZCBvbmx5IGEgc2luZ2xlIGVuZ2luZS4gU2luY2Ug YWxsIG5ld2VyIGJyb2FkY29tIGNoaXBzIHRoYW4KICB0aGUgT0cgdmM0IHVzZSB2M2QgZm9yIHJl bmRlcmluZywgd2hpY2ggZm9sbG93cyB0aGlzIGNvbnRyYWN0LCB0aGUKICBpbXBhY3Qgb2YgdGhp cyBpc3N1ZSBpcyBmYWlybHkgc21hbGwuCgotIHYzZCBkb2VzIHRoaXMgdXNpbmcgdGhlIGRybV9n ZW1fZmVuY2VfYXJyYXlfYWRkX2ltcGxpY2l0KCkgaGVscGVyLAogIHdoaWNoIHRoZW4gaXQncyBk cm1fc2NoZWRfYmFja2VuZF9vcHMtPmRlcGVuZGVuY3kgY2FsbGJhY2sKICB2M2Rfam9iX2RlcGVu ZGVuY3koKSBwaWNrcyB1cC4KCi0gcGFuZnJvc3QgaXMgbmljZSBoZXJlIGFuZCB0cmFja3MgdGhl IGltcGxpY2l0IGZlbmNlcyBpbgogIHBhbmZyb3N0X2pvYi0+aW1wbGljaXRfZmVuY2VzLCB3aGlj aCBhZ2FpbiB0aGUKICBkcm1fc2NoZWRfYmFja2VuZF9vcHMtPmRlcGVuZGVuY3kgY2FsbGJhY2sg cGFuZnJvc3Rfam9iX2RlcGVuZGVuY3koKQogIHBpY2tzIHVwLiBJdCBpcyBtaWxkbHkgcXVlc3Rp b25hYmxlIHRob3VnaCBzaW5jZSBpdCBvbmx5IHBpY2tzIHVwCiAgZXhjbHVzaXZlIGZlbmNlcyBp biBwYW5mcm9zdF9hY3F1aXJlX29iamVjdF9mZW5jZXMoKSwgYnV0IG5vdCBidWdneQogIGluIHBy YWN0aWNlIGJlY2F1c2UgaXQgYWxzbyBhbHdheXMgc2V0cyB0aGUgZXhjbHVzaXZlIGZlbmNlLiBJ dAogIHNob3VsZCBwaWNrIHVwIGJvdGggc2V0cyBvZiBmZW5jZXMsIGp1c3QgaW4gY2FzZSB0aGVy ZSdzIGV2ZXIgZ29pbmcKICB0byBiZSBhIDJuZCBncHUgaW4gYSBTb0Mgd2l0aCBhIG1hbGkgZ3B1 LiBPciBtYXliZSBhIG1hbGkgU29DIHdpdGggYQogIHBjaWUgcG9ydCBhbmQgYSByZWFsIGdwdSwg d2hpY2ggbWlnaHQgYWN0dWFsbHkgaGFwcGVuIGV2ZW50dWFsbHkuIEEKICBidWcsIGJ1dCBlYXN5 IHRvIGZpeC4gU2hvdWxkIHByb2JhYmx5IHVzZSB0aGUKICBkcm1fZ2VtX2ZlbmNlX2FycmF5X2Fk ZF9pbXBsaWNpdCgpIGhlbHBlci4KCi0gbGltYSBpcyBuaWNlIGFuIGVhc3ksIHVzZXMgZHJtX2dl bV9mZW5jZV9hcnJheV9hZGRfaW1wbGljaXQoKSBhbmQKICB0aGUgc2FtZSBzY2hlbWEgYXMgdjNk LgoKLSBtc20gaXMgbWlsZGx5IGVudGVydGFpbmluZy4gSXQgYWxzbyBzdXBwb3J0cyBNU01fU1VC TUlUX05PX0lNUExJQ0lULAogIGJ1dCBiZWNhdXNlIGl0IGRvZXNuJ3QgdXNlIHRoZSBkcm0vc2No ZWR1bGVyIGl0IGhhbmRsZXMgZmVuY2VzIGZyb20KICB0aGUgd3JvbmcgY29udGV4dCB3aXRoIGEg c3luY2hyb25vdXMgZG1hX2ZlbmNlX3dhaXQuIFNlZQogIHN1Ym1pdF9mZW5jZV9zeW5jKCkgbGVh ZGluZyB0byBtc21fZ2VtX3N5bmNfb2JqZWN0KCkuIEludmVzdGluZyBpbnRvCiAgYSBzY2hlZHVs ZXIgbWlnaHQgYmUgYSBnb29kIGlkZWEuCgotIGFsbCB0aGUgcmVtYWluaW5nIGRyaXZlcnMgYXJl IHR0bSBiYXNlZCwgd2hlcmUgSSBob3BlIHRoZXkgZG8KICBhcHByb3ByaWF0ZWx5IG9iZXkgaW1w bGljaXQgZmVuY2VzIGFscmVhZHkuIEkgZGlkbid0IGRvIHRoZSBmdWxsCiAgYXVkaXQgdGhlcmUg YmVjYXVzZSBhKSBub3QgZm9sbG93IHRoZSBjb250cmFjdCB3b3VsZCBjb25mdXNlIHR0bQogIHF1 aXRlIHdlbGwgYW5kIGIpIHJlYWRpbmcgbm9uLXN0YW5kYXJkIHNjaGVkdWxlciBhbmQgc3VibWl0 IGNvZGUKICB3aGljaCBpc24ndCBiYXNlZCBvbiBkcm0vc2NoZWR1bGVyIGlzIGEgcGFpbi4KCk9u d2FyZHMgdG8gdGhlIGRpc3BsYXkgc2lkZS4KCi0gQW55IGRyaXZlciB1c2luZyB0aGUgZHJtX2dl bV9wbGFuZV9oZWxwZXJfcHJlcGFyZV9mYigpIGhlbHBlciB3aWxsCiAgY29ycmVjdGx5LiBPdmVy d2hlbG1pbmdseSBtb3N0IGRyaXZlcnMgZ2V0IHRoaXMgcmlnaHQsIGV4Y2VwdCBhIGZldwogIHRv dGFsbHkgZG9udC4gSSdsbCBmb2xsb3cgdXAgd2l0aCBhIHBhdGNoIHRvIG1ha2UgdGhpcyB0aGUg ZGVmYXVsdAogIGFuZCBhdm9pZCBhIGJ1bmNoIG9mIGJ1Z3MuCgotIEkgZGlkbid0IGF1ZGl0IHRo ZSB0dG0gZHJpdmVycywgYnV0IGdpdmVuIHRoYXQgZG1hX3Jlc3Ygc3RhcnRlZAogIHRoZXJlIEkg aG9wZSB0aGV5IGdldCB0aGlzIHJpZ2h0LgoKSW4gY29uY2x1c2lvbiB0aGlzIElTIHRoZSBjb250 cmFjdCwgYm90aCBhcyBkb2N1bWVudGVkIGFuZApvdmVyd2hlbG1pbmdseSBpbXBsZW1lbnRlZCwg c3BlY2ljYWxseSBhcyBpbXBsZW1lbnRlZCBieSBhbGwgcmVuZGVyCmRyaXZlcnMgZXhjZXB0IGFt ZGdwdS4KCkFtZGdwdSB0cmllZCB0byBmaXggdGhpcyBhbHJlYWR5IGluCgpjb21taXQgMDQ5YWNh NDM2M2Q4YWY4N2NhYjhkNTNkZTU0MDE2MDJkYjNiOTk5OQpBdXRob3I6IENocmlzdGlhbiBLw7Zu aWcgPGNocmlzdGlhbi5rb2VuaWdAYW1kLmNvbT4KRGF0ZTogICBXZWQgU2VwIDE5IDE2OjU0OjM1 IDIwMTggKzAyMDAKCiAgICBkcm0vYW1kZ3B1OiBmaXggdXNpbmcgc2hhcmVkIGZlbmNlIGZvciBl eHBvcnRlZCBCT3MgdjIKCmJ1dCB0aGlzIGZpeCBmYWxscyBzaG9ydCBvbiBhIG51bWJlciBvZiBh cmVhczoKCi0gSXQncyByYWN5LCBieSB0aGUgdGltZSB0aGUgYnVmZmVyIGlzIHNoYXJlZCBpdCBt aWdodCBiZSB0b28gbGF0ZS4gVG8KICBtYWtlIHN1cmUgdGhlcmUncyBkZWZpbml0ZWx5IG5ldmVy IGEgcHJvYmxlbSB3ZSBuZWVkIHRvIHNldCB0aGUKICBmZW5jZXMgY29ycmVjdGx5IGZvciBhbnkg YnVmZmVyIHRoYXQncyBwb3RlbnRpYWxseSBleHBvcnRhYmxlLgoKLSBJdCdzIGJyZWFraW5nIHVh cGksIGRtYS1idWYgZmRzIHN1cHBvcnQgcG9sbCgpIGFuZCBkaWZmZXJlbnRpdGlhdGUKICBiZXR3 ZWVuLCB3aGljaCB3YXMgaW50cm9kdWNlZCBpbgoKCWNvbW1pdCA5YjQ5NWE1ODg3OTk0YTZkNzRk NWMyNjFkMDEyMDgzYTkyYjk0NzM4CglBdXRob3I6IE1hYXJ0ZW4gTGFua2hvcnN0IDxtYWFydGVu Lmxhbmtob3JzdEBjYW5vbmljYWwuY29tPgoJRGF0ZTogICBUdWUgSnVsIDEgMTI6NTc6NDMgMjAx NCArMDIwMAoKCSAgICBkbWEtYnVmOiBhZGQgcG9sbCBzdXBwb3J0LCB2MwoKLSBDaHJpc3RpYW4g S8O2bmlnIHdhbnRzIHRvIG5hY2sgbmV3IHVhcGkgYnVpbGRpbmcgZnVydGhlciBvbiB0aGlzCiAg ZG1hX3Jlc3YgY29udHJhY3QgYmVjYXVzZSBpdCBicmVha3MgYW1kZ3B1LCBxdW90aW5nCgogICJZ ZWFoLCBhbmQgdGhhdCBpcyBleGFjdGx5IHRoZSByZWFzb24gd2h5IEkgd2lsbCBOQUsgdGhpcyB1 QVBJIGNoYW5nZS4KCiAgIlRoaXMgZG9lc24ndCB3b3JrcyBmb3IgYW1kZ3B1IGF0IGFsbCBmb3Ig dGhlIHJlYXNvbnMgb3V0bGluZWQgYWJvdmUuIgoKICBodHRwczovL2xvcmUua2VybmVsLm9yZy9k cmktZGV2ZWwvZjJlYjY3NTEtMmY4Mi05YjIzLWY1N2UtNTQ4ZGU1YjcyOWRlQGdtYWlsLmNvbS8K CiAgUmVqZWN0aW5nIG5ldyBkZXZlbG9wbWVudCBiZWNhdXNlIHlvdXIgb3duIGRyaXZlciBpcyBi cm9rZW4gYW5kCiAgdmlvbGF0ZXMgZXN0YWJsaXNoZWQgY3Jvc3MgZHJpdmVyIGNvbnRyYWN0cyBh bmQgdWFwaSBpcyByZWFsbHkgbm90CiAgaG93IHVwc3RyZWFtIHdvcmtzLgoKTm93IHRoaXMgcGF0 Y2ggd2lsbCBoYXZlIGEgc2V2ZXJlIHBlcmZvcm1hbmNlIGltcGFjdCBvbiBhbnl0aGluZyB0aGF0 CnJ1bnMgb24gbXVsdGlwbGUgZW5naW5lcy4gU28gd2UgY2FuJ3QganVzdCBtZXJnZSBpdCBvdXRy aWdodCwgYnV0IG5lZWQKYSBiaXQgYSBwbGFuOgoKLSBhbWRncHUgbmVlZHMgYSBwcm9wZXIgdWFw aSBmb3IgaGFuZGxpbmcgaW1wbGljaXQgZmVuY2luZy4gVGhlIGZ1bm55CiAgdGhpbmcgaXMgdGhh dCB0byBkbyBpdCBjb3JyZWN0bHksIGltcGxpY2l0IGZlbmNpbmcgbXVzdCBiZSB0cmVhdGVkCiAg YXMgYSB2ZXJ5IHN0cmFuZ2UgSVBDIG1lY2hhbmlzbSBmb3IgdHJhbnNwb3J0aW5nIGZlbmNlcywg d2hlcmUgYm90aAogIHNldHRpbmcgdGhlIGZlbmNlIGFuZCBkZXBlbmRlbmN5IGludGVyY2VwdHMg bXVzdCBiZSBoYW5kbGVkCiAgZXhwbGljaXRseS4gQ3VycmVudCBiZXN0IHByYWN0aWNlcyBpcyBh IHBlci1ibyBmbGFnIHRvIGluZGljYXRlCiAgd3JpdGVzLCBhbmQgYSBwZXItYm8gZmxhZyB0byB0 byBza2lwIGltcGxpY2l0IGZlbmNpbmcgaW4gdGhlIENTCiAgaW9jdGwgYXMgYSBuZXcgY2h1bmsu CgotIFNpbmNlIGFtZGdwdSBoYXMgYmVlbiBzaGlwcGluZyB3aXRoIGJyb2tlbiBiZWhhdmlvdXIg d2UgbmVlZCBhbgogIG9wdC1vdXQgZmxhZyBmcm9tIHRoZSBidXRjaGVyZWQgaW1wbGljaXQgZmVu Y2luZyBtb2RlbCB0byBlbmFibGUgdGhlCiAgcHJvcGVyIGV4cGxpY2l0IGltcGxpY2l0IGZlbmNp bmcgbW9kZWwuCgotIGZvciBrZXJuZWwgbWVtb3J5IGZlbmNlcyBkdWUgdG8gYm8gbW92ZXMgYXQg bGVhc3QgdGhlIGk5MTUgaWRlYSBpcwogIHRvIHVzZSB0dG1fYm8tPm1vdmluZy4gYW1kZ3B1IHBy b2JhYmx5IG5lZWRzIHRoZSBzYW1lLgoKLSBzaW5jZSB0aGUgY3VycmVudCBwMnAgZG1hLWJ1ZiBp bnRlcmZhY2UgYXNzdW1lcyB0aGUga2VybmVsIG1lbW9yeQogIGZlbmNlIGlzIGluIHRoZSBleGNs dXNpdmUgZG1hX3Jlc3YgZmVuY2Ugc2xvdCB3ZSBuZWVkIHRvIGFkZCBhIG5ldwogIGZlbmNlIHNs b3QgZm9yIGtlcm5lbCBmZW5jZXMsIHdoaWNoIG11c3QgbmV2ZXIgYmUgaWdub3JlZC4gU2luY2UK ICBjdXJyZW50bHkgb25seSBhbWRncHUgc3VwcG9ydHMgdGhpcyB0aGVyZSdzIG5vIHJlYWwgcHJv YmxlbSBoZXJlCiAgeWV0LCB1bnRpbCBhbWRncHUgZ2FpbnMgYSBOT19JTVBMSUNJVCBDUyBmbGFn LgoKLSBOZXcgdXNlcnNwYWNlIG5lZWRzIHRvIHNoaXAgaW4gZW5vdWdoIGRlc2t0b3AgZGlzdHJv cyBzbyB0aGF0IHVzZXJzCiAgd29udCBub3RpY2UgdGhlIHBlcmYgaW1wYWN0LiBJIHRoaW5rIHdl IGNhbiBpZ25vcmUgTFRTIGRpc3Ryb3Mgd2hvCiAgdXBncmFkZSB0aGVpciBrZXJuZWxzIGJ1dCBu b3QgdGhlaXIgbWVzYTNkIHNuYXBzaG90LgoKLSBUaGVuIHdoZW4gdGhpcyBpcyBhbGwgaW4gcGxh Y2Ugd2UgY2FuIG1lcmdlIHRoaXMgcGF0Y2ggaGVyZS4KCldoYXQgaXMgbm90IGEgc29sdXRpb24g dG8gdGhpcyBwcm9ibGVtIGhlcmUgaXMgdHJ5aW5nIHRvIG1ha2UgdGhlCmRtYV9yZXN2IHJ1bGVz IGluIHRoZSBrZXJuZWwgbW9yZSBjbGV2ZXIuIFRoZSBmdW5kYW1lbnRhbCBpc3N1ZSBoZXJlCmlz IHRoYXQgdGhlIGFtZGdwdSBDUyB1YXBpIGlzIHRoZSBsZWFzdCBleHByZXNzaXZlIG9uZSBhY3Jv c3MgYWxsCmRyaXZlcnMgKG9ubHkgZXF1YWxsZWQgYnkgcGFuZnJvc3QsIHdoaWNoIGhhcyBhbiBh Y3R1YWwgZXhjdXNlKSBieSBub3QKYWxsb3dpbmcgYW55IHVzZXJzcGFjZSBjb250cm9sIG92ZXIg aG93IGltcGxpY2l0IHN5bmMgaXMgY29uZHVjdGVkLgoKVW50aWwgdGhpcyBpcyBmaXhlZCBpdCdz IGNvbXBsZXRlbHkgcG9pbnRsZXNzIHRvIG1ha2UgdGhlIGtlcm5lbCBtb3JlCmNsZXZlciB0byBp bXByb3ZlIGFtZGdwdSwgYmVjYXVzZSBhbGwgd2UncmUgZG9pbmcgaXMgcGFwZXJpbmcgb3Zlcgp0 aGlzIHVhcGkgZGVzaWduIGlzc3VlLiBhbWRncHUgbmVlZHMgdG8gYXR0YWluIHRoZSBzdGF0dXMg cXVvCmVzdGFibGlzaGVkIGJ5IG90aGVyIGRyaXZlcnMgZmlyc3QsIG9uY2UgdGhhdCdzIGFjaGll dmVkIHdlIGNhbiB0YWNrbGUKdGhlIHJlbWFpbmluZyBpc3N1ZXMgaW4gYSBjb25zaXN0ZW50IHdh eSBhY3Jvc3MgZHJpdmVycy4KCnYyOiBCYXMgcG9pbnRlZCBtZSBhdCBBTURHUFVfR0VNX0NSRUFU RV9FWFBMSUNJVF9TWU5DLCB3aGljaCBJCmVudGlyZWx5IG1pc3NlZC4KClRoaXMgaXMgZ3JlYXQg YmVjYXVzZSBpdCBtZWFucyB0aGUgYW1kZ3B1IHNwZWNpZmljIHBpZWNlIGZvciBwcm9wZXIKaW1w bGljaXQgZmVuY2UgaGFuZGxpbmcgZXhpc3RzIGFscmVhZHksIGFuZCB0aGF0IHNpbmNlIGEgd2hp bGUuIFRoZQpvbmx5IHRoaW5nIHRoYXQncyBub3cgbWlzc2luZyBpcwotIGZpc2hpbmcgdGhlIGlt cGxpY2l0IGZlbmNlcyBvdXQgb2YgYSBzaGFyZWQgb2JqZWN0IGF0IHRoZSByaWdodCB0aW1lCi0g c2V0dGluZyB0aGUgZXhjbHVzaXZlIGltcGxpY2l0IGZlbmNlIHNsb3QgYXQgdGhlIHJpZ2h0IHRp bWUuCgpKYXNvbiBoYXMgYSBwYXRjaCBzZXJpZXMgdG8gZmlsbCB0aGF0IGdhcCB3aXRoIGEgYnVu Y2ggb2YgZ2VuZXJpYwppb2N0bCBvbiB0aGUgZG1hLWJ1ZiBmZDoKCmh0dHBzOi8vbG9yZS5rZXJu ZWwub3JnL2RyaS1kZXZlbC8yMDIxMDUyMDE5MDAwNy41MzQwNDYtMS1qYXNvbkBqbGVrc3RyYW5k Lm5ldC8KCnYzOiBTaW5jZSBDaHJpc3RpYW4gaGFzIGZpeGVkIGFtZGdwdSBub3cgaW4KCmNvbW1p dCA4YzUwNWJkYzljOGI5NTUyMjNiMDU0ZTM0YTBiZTljM2Q4NDFjZDIwIChkcm0tbWlzYy9kcm0t bWlzYy1uZXh0KQpBdXRob3I6IENocmlzdGlhbiBLw7ZuaWcgPGNocmlzdGlhbi5rb2VuaWdAYW1k LmNvbT4KRGF0ZTogICBXZWQgSnVuIDkgMTM6NTE6MzYgMjAyMSArMDIwMAoKICAgIGRybS9hbWRn cHU6IHJld29yayBkbWFfcmVzdiBoYW5kbGluZyB2MwoKVXNlIHRoZSBhdWRpdCBjb3ZlcmVkIGlu IHRoaXMgY29tbWl0IG1lc3NhZ2UgYXMgdGhlIGV4Y3VzZSB0byB1cGRhdGUKdGhlIGRtYS1idWYg ZG9jcyBhcm91bmQgZG1hX2J1Zi5yZXN2IHVzYWdlIGFjcm9zcyBkcml2ZXJzLgoKU2luY2UgZHlu YW1pYyBpbXBvcnRlcnMgaGF2ZSBkaWZmZXJlbnQgcnVsZXMgYWxzbyBoYW1tZXIgdGhlc2UgaW4K YWdhaW4gd2hpbGUgd2UncmUgYXQgaXQuCgp2NDoKLSBBZGQgdGhlIG1pc3NpbmcgInRocm91Z2gg dGhlIGRldmljZSIgaW4gdGhlIGR5bmFtaWMgc2VjdGlvbiB0aGF0IEkKICBvdmVybG9va2VkLgot IEZpeCBhIGtlcm5lbGRvYyBtYXJrdXAgbWlzdGFrZSwgdGhlIGxpbmsgZGlkbid0IGNvbm5lY3QK ClJldmlld2VkLWJ5OiBDaHJpc3RpYW4gS8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5jb20+ ICh2MykKCkNjOiBtZXNhLWRldkBsaXN0cy5mcmVlZGVza3RvcC5vcmcKQ2M6IEJhcyBOaWV1d2Vu aHVpemVuIDxiYXNAYmFzbmlldXdlbmh1aXplbi5ubD4KQ2M6IERhdmUgQWlybGllIDxhaXJsaWVk QGdtYWlsLmNvbT4KQ2M6IFJvYiBDbGFyayA8cm9iZGNsYXJrQGNocm9taXVtLm9yZz4KQ2M6IEty aXN0aWFuIEguIEtyaXN0ZW5zZW4gPGhvZWdzYmVyZ0Bnb29nbGUuY29tPgpDYzogTWljaGVsIETD pG56ZXIgPG1pY2hlbEBkYWVuemVyLm5ldD4KQ2M6IERhbmllbCBTdG9uZSA8ZGFuaWVsc0Bjb2xs YWJvcmEuY29tPgpDYzogU3VtaXQgU2Vtd2FsIDxzdW1pdC5zZW13YWxAbGluYXJvLm9yZz4KQ2M6 ICJDaHJpc3RpYW4gS8O2bmlnIiA8Y2hyaXN0aWFuLmtvZW5pZ0BhbWQuY29tPgpDYzogQWxleCBE ZXVjaGVyIDxhbGV4YW5kZXIuZGV1Y2hlckBhbWQuY29tPgpDYzogRGFuaWVsIFZldHRlciA8ZGFu aWVsLnZldHRlckBmZndsbC5jaD4KQ2M6IERlZXBhayBSIFZhcm1hIDxtaDEyZ3gyODI1QGdtYWls LmNvbT4KQ2M6IENoZW4gTGkgPGNoZW5saUB1bmlvbnRlY2guY29tPgpDYzogS2V2aW4gV2FuZyA8 a2V2aW4xLndhbmdAYW1kLmNvbT4KQ2M6IERlbm5pcyBMaSA8RGVubmlzLkxpQGFtZC5jb20+CkNj OiBMdWJlbiBUdWlrb3YgPGx1YmVuLnR1aWtvdkBhbWQuY29tPgpDYzogbGluYXJvLW1tLXNpZ0Bs aXN0cy5saW5hcm8ub3JnClNpZ25lZC1vZmYtYnk6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0 ZXJAaW50ZWwuY29tPgotLS0KIGluY2x1ZGUvbGludXgvZG1hLWJ1Zi5oIHwgMzkgKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAxIGZpbGUgY2hhbmdlZCwgMzkgaW5zZXJ0 aW9ucygrKQoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZG1hLWJ1Zi5oIGIvaW5jbHVkZS9s aW51eC9kbWEtYnVmLmgKaW5kZXggODFjZWJmNDE0NTA1Li40OTRmNjM5ZWU0ODYgMTAwNjQ0Ci0t LSBhL2luY2x1ZGUvbGludXgvZG1hLWJ1Zi5oCisrKyBiL2luY2x1ZGUvbGludXgvZG1hLWJ1Zi5o CkBAIC0zODYsNiArMzg2LDQ1IEBAIHN0cnVjdCBkbWFfYnVmIHsKIAkgKiBAcmVzdjoKIAkgKgog CSAqIFJlc2VydmF0aW9uIG9iamVjdCBsaW5rZWQgdG8gdGhpcyBkbWEtYnVmLgorCSAqCisJICog SU1QTElDSVQgU1lOQ0hST05JWkFUSU9OIFJVTEVTOgorCSAqCisJICogRHJpdmVycyB3aGljaCBz dXBwb3J0IGltcGxpY2l0IHN5bmNocm9uaXphdGlvbiBvZiBidWZmZXIgYWNjZXNzIGFzCisJICog ZS5nLiBleHBvc2VkIGluIGBJbXBsaWNpdCBGZW5jZSBQb2xsIFN1cHBvcnRgXyBzaG91bGQgZm9s bG93IHRoZQorCSAqIGJlbG93IHJ1bGVzLgorCSAqCisJICogLSBEcml2ZXJzIHNob3VsZCBhZGQg YSBzaGFyZWQgZmVuY2UgdGhyb3VnaAorCSAqICAgZG1hX3Jlc3ZfYWRkX3NoYXJlZF9mZW5jZSgp IGZvciBhbnl0aGluZyB0aGUgdXNlcnNwYWNlIEFQSQorCSAqICAgY29uc2lkZXJzIGEgcmVhZCBh Y2Nlc3MuIFRoaXMgaGlnaGx5IGRlcGVuZHMgdXBvbiB0aGUgQVBJIGFuZAorCSAqICAgd2luZG93 IHN5c3RlbTogRS5nLiBPcGVuR0wgaXMgZ2VuZXJhbGx5IGltcGxpY2l0bHkgc3luY2hyb25pemVk IG9uCisJICogICBMaW51eCwgYnV0IGV4cGxpY2l0bHkgc3luY2hyb25pemVkIG9uIEFuZHJvaWQu IFdoZXJlYXMgVnVsa2FuIGlzCisJICogICBnZW5lcmFsbHkgZXhwbGljaXRseSBzeW5jaHJvbml6 ZWQgZm9yIGV2ZXJ5dGhpbmcsIGFuZCB3aW5kb3cgc3lzdGVtCisJICogICBidWZmZXJzIGhhdmUg ZXhwbGljaXQgQVBJIGNhbGxzICh3aGljaCB0aGVuIG5lZWQgdG8gbWFrZSBzdXJlIHRoZQorCSAq ICAgaW1wbGljaXQgZmVuY2VzIHN0b3JlIGhlcmUgaW4gQHJlc3YgYXJlIHVwZGF0ZWQgY29ycmVj dGx5KS4KKwkgKgorCSAqIC0gU2ltaWxhcmx5IGRyaXZlcnMgc2hvdWxkIHNldCB0aGUgZXhjbHVz aXZlIGZlbmNlIHRocm91Z2gKKwkgKiAgIGRtYV9yZXN2X2FkZF9leGNsX2ZlbmNlKCkgZm9yIGFu eXRoaW5nIHRoZSB1c2Vyc3BhY2UgQVBJIGNvbnNpZGVycworCSAqICAgd3JpdGUgYWNjZXNzLgor CSAqCisJICogLSBEcml2ZXJzIG1heSBqdXN0IGFsd2F5cyBzZXQgdGhlIGV4Y2x1c2l2ZSBmZW5j ZSwgc2luY2UgdGhhdCBvbmx5CisJICogICBjYXVzZXMgdW5lY2Vzc2FyaWx5IHN5bmNocm9uaXph dGlvbiwgYnV0IG5vIGNvcnJlY3RuZXNzIGlzc3Vlcy4KKwkgKgorCSAqIC0gU29tZSBkcml2ZXJz IG9ubHkgZXhwb3NlIGEgc3luY2hyb25vdXMgdXNlcnNwYWNlIEFQSSB3aXRoIG5vCisJICogICBw aXBlbGluaW5nIGFjcm9zcyBkcml2ZXJzLiBUaGVzZSBkbyBub3Qgc2V0IGFueSBmZW5jZXMgZm9y IHRoZWlyCisJICogICBhY2Nlc3MuIEFuIGV4YW1wbGUgaGVyZSBpcyB2NGwuCisJICoKKwkgKiBE WU5BTUlDIElNUE9SVEVSIFJVTEVTOgorCSAqCisJICogRHluYW1pYyBpbXBvcnRlcnMsIHNlZSBk bWFfYnVmX2F0dGFjaG1lbnRfaXNfZHluYW1pYygpLCBoYXZlCisJICogYWRkaXRpb25hbCBjb25z dHJhaW50cyBvbiBob3cgdGhleSBzZXQgdXAgZmVuY2VzOgorCSAqCisJICogLSBEeW5hbWljIGlt cG9ydGVycyBtdXN0IG9iZXkgdGhlIGV4Y2x1c2l2ZSBmZW5jZSBhbmQgd2FpdCBmb3IgaXQgdG8K KwkgKiAgIHNpZ25hbCBiZWZvcmUgYWxsb3dpbmcgYWNjZXNzIHRvIHRoZSBidWZmZXIncyB1bmRl cmx5aW5nIHN0b3JhZ2UKKwkgKiAgIHRocm91Z2ggdGhlIGRldmljZS4KKwkgKgorCSAqIC0gRHlu YW1pYyBpbXBvcnRlcnMgc2hvdWxkIHNldCBmZW5jZXMgZm9yIGFueSBhY2Nlc3MgdGhhdCB0aGV5 IGNhbid0CisJICogICBkaXNhYmxlIGltbWVkaWF0ZWx5IGZyb20gdGhlaXIgJmRtYV9idWZfYXR0 YWNoX29wcy5tb3ZlX25vdGlmeQorCSAqICAgY2FsbGJhY2suCiAJICovCiAJc3RydWN0IGRtYV9y ZXN2ICpyZXN2OwogCi0tIAoyLjMyLjAucmMyCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0 cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9s aXN0aW5mby9pbnRlbC1nZngK