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=-8.3 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,URIBL_BLOCKED,USER_AGENT_MUTT autolearn=unavailable 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 DCAEAC282DD for ; Wed, 17 Apr 2019 14:33:28 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id A33A2206BA for ; Wed, 17 Apr 2019 14:33:28 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=ffwll.ch header.i=@ffwll.ch header.b="D1sTj+g+" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732579AbfDQOd1 (ORCPT ); Wed, 17 Apr 2019 10:33:27 -0400 Received: from mail-ed1-f68.google.com ([209.85.208.68]:38765 "EHLO mail-ed1-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1732557AbfDQOd0 (ORCPT ); Wed, 17 Apr 2019 10:33:26 -0400 Received: by mail-ed1-f68.google.com with SMTP id d13so21186925edr.5 for ; Wed, 17 Apr 2019 07:33:24 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=sender:date:from:to:subject:message-id:mail-followup-to:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to:user-agent; bh=9vp0xDRk0PcZdoGi3TTAy6TNoMlOylfEgoLEBq8+ymc=; b=D1sTj+g+FUumn2pYXFejKpK+hEg40IvZMjaVEP+pSJt9QvypykYwJb7NVEpaHk8qo6 XR33tLC/ZnE1S7SikfJABHcrVnx8h+GBep6bbtCuPMV9VU6NVVFcUGn1yArjQIcg+jWl PpmggEwofaelWcvhw2h06NNQOs9lBwGlBlVJo= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:from:to:subject:message-id :mail-followup-to:references:mime-version:content-disposition :content-transfer-encoding:in-reply-to:user-agent; bh=9vp0xDRk0PcZdoGi3TTAy6TNoMlOylfEgoLEBq8+ymc=; b=osBojX2rbtCsd0i4tkZSVS9De/OPpNmZhAVa+vci5qL72M5fq7XBj4THLSe2XL7Ca1 oDXeeEg3MviSRC/9T3aEyHKj0GxuvvYX8KkjQsnnqiY3VLy8CaLSDOoFdNYw2c7rp5R4 aBRgW0RwVxit0hPf9VyJoS6m7LYga55vI3n4WL9q7eWEN/c594qlCB7FPDCGsRTawbGy zYQkXTKHlgWvvyHsaRKeDtB7qq2Z4GzYjwKfwmFwXh8Pbt6DxzwiyYU17S592uBRjXbE RHnquVuKlbBoOaczwiLfpbv2Xoc9kL4nyzyGFRV12ogs8PblPXNBOfPNdON1XqxLI4Np J7xg== X-Gm-Message-State: APjAAAVeu+uOfpbySyIRC68hkuS71pWKQg5yvev3zhYLW2+rtnXqB6T7 hxajdWZm3C+zolq2gTNwSWtvTw== X-Google-Smtp-Source: APXvYqyHJXMY+hQcFl2Ka4NUSc8AB0uGMBucNnW736dovVFKvjixNuqWHATwKbkFuN6nWEm4K1+17A== X-Received: by 2002:a50:ee9a:: with SMTP id f26mr16022724edr.118.1555511603343; Wed, 17 Apr 2019 07:33:23 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:569e:0:3106:d637:d723:e855]) by smtp.gmail.com with ESMTPSA id p1sm8282108ejf.40.2019.04.17.07.33.22 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Wed, 17 Apr 2019 07:33:22 -0700 (PDT) Date: Wed, 17 Apr 2019 16:33:20 +0200 From: Daniel Vetter To: Christian =?iso-8859-1?Q?K=F6nig?= , sumit.semwal@linaro.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org, amd-gfx@lists.freedesktop.org Subject: Re: [PATCH 04/12] dma-buf: add optional invalidate_mappings callback v5 Message-ID: <20190417143320.GH13337@phenom.ffwll.local> Mail-Followup-To: Christian =?iso-8859-1?Q?K=F6nig?= , sumit.semwal@linaro.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org, amd-gfx@lists.freedesktop.org References: <20190416183841.1577-1-christian.koenig@amd.com> <20190416183841.1577-5-christian.koenig@amd.com> <20190417140116.GC13337@phenom.ffwll.local> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20190417140116.GC13337@phenom.ffwll.local> X-Operating-System: Linux phenom 4.19.0-1-amd64 User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Wed, Apr 17, 2019 at 04:01:16PM +0200, Daniel Vetter wrote: > On Tue, Apr 16, 2019 at 08:38:33PM +0200, Christian König wrote: > > Each importer can now provide an invalidate_mappings callback. > > > > This allows the exporter to provide the mappings without the need to pin > > the backing store. > > > > v2: don't try to invalidate mappings when the callback is NULL, > > lock the reservation obj while using the attachments, > > add helper to set the callback > > v3: move flag for invalidation support into the DMA-buf, > > use new attach_info structure to set the callback > > v4: use importer_priv field instead of mangling exporter priv. > > v5: drop invalidation_supported flag > > > > Signed-off-by: Christian König > > --- > > drivers/dma-buf/dma-buf.c | 37 +++++++++++++++++++++++++++++++++++++ > > include/linux/dma-buf.h | 33 +++++++++++++++++++++++++++++++-- > > 2 files changed, 68 insertions(+), 2 deletions(-) > > > > diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c > > index 83c92bfd964c..a3738fab3927 100644 > > --- a/drivers/dma-buf/dma-buf.c > > +++ b/drivers/dma-buf/dma-buf.c > > @@ -563,6 +563,8 @@ struct dma_buf_attachment *dma_buf_attach(const struct dma_buf_attach_info *info > > > > attach->dev = info->dev; > > attach->dmabuf = dmabuf; > > + attach->importer_priv = info->importer_priv; > > + attach->invalidate = info->invalidate; > > > > mutex_lock(&dmabuf->lock); > > > > @@ -571,7 +573,9 @@ struct dma_buf_attachment *dma_buf_attach(const struct dma_buf_attach_info *info > > if (ret) > > goto err_attach; > > } > > + reservation_object_lock(dmabuf->resv, NULL); > > list_add(&attach->node, &dmabuf->attachments); > > + reservation_object_unlock(dmabuf->resv); > > > > mutex_unlock(&dmabuf->lock); > > > > @@ -615,7 +619,9 @@ void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attach) > > DMA_BIDIRECTIONAL); > > > > mutex_lock(&dmabuf->lock); > > + reservation_object_lock(dmabuf->resv, NULL); > > list_del(&attach->node); > > + reservation_object_unlock(dmabuf->resv); > > if (dmabuf->ops->detach) > > dmabuf->ops->detach(dmabuf, attach); > > > > @@ -653,7 +659,16 @@ dma_buf_map_attachment_locked(struct dma_buf_attachment *attach, > > if (attach->sgt) > > return attach->sgt; > > > > + /* > > + * Mapping a DMA-buf can trigger its invalidation, prevent sending this > > + * event to the caller by temporary removing this attachment from the > > + * list. > > + */ > > + if (attach->invalidate) > > + list_del(&attach->node); > > sg_table = attach->dmabuf->ops->map_dma_buf(attach, direction); > > + if (attach->invalidate) > > + list_add(&attach->node, &attach->dmabuf->attachments); > > if (!sg_table) > > sg_table = ERR_PTR(-ENOMEM); > > > > @@ -751,6 +766,26 @@ void dma_buf_unmap_attachment(struct dma_buf_attachment *attach, > > } > > EXPORT_SYMBOL_GPL(dma_buf_unmap_attachment); > > > > +/** > > + * dma_buf_invalidate_mappings - invalidate all mappings of this dma_buf > > + * > > + * @dmabuf: [in] buffer which mappings should be invalidated > > + * > > + * Informs all attachmenst that they need to destroy and recreated all their > > + * mappings. > > + */ > > +void dma_buf_invalidate_mappings(struct dma_buf *dmabuf) > > +{ > > + struct dma_buf_attachment *attach; > > + > > + reservation_object_assert_held(dmabuf->resv); > > + > > + list_for_each_entry(attach, &dmabuf->attachments, node) > > + if (attach->invalidate) > > + attach->invalidate(attach); > > +} > > +EXPORT_SYMBOL_GPL(dma_buf_invalidate_mappings); > > + > > /** > > * DOC: cpu access > > * > > @@ -1163,10 +1198,12 @@ static int dma_buf_debug_show(struct seq_file *s, void *unused) > > seq_puts(s, "\tAttached Devices:\n"); > > attach_count = 0; > > > > + reservation_object_lock(buf_obj->resv, NULL); > > list_for_each_entry(attach_obj, &buf_obj->attachments, node) { > > seq_printf(s, "\t%s\n", dev_name(attach_obj->dev)); > > attach_count++; > > } > > + reservation_object_unlock(buf_obj->resv); > > > > seq_printf(s, "Total %d devices attached\n\n", > > attach_count); > > diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h > > index 7e23758db3a4..ece4638359a8 100644 > > --- a/include/linux/dma-buf.h > > +++ b/include/linux/dma-buf.h > > @@ -324,6 +324,7 @@ struct dma_buf { > > * @dev: device attached to the buffer. > > * @node: list of dma_buf_attachment. > > * @priv: exporter specific attachment data. > > + * @importer_priv: importer specific attachment data. > > * > > * This structure holds the attachment information between the dma_buf buffer > > * and its user device(s). The list contains one attachment struct per device > > @@ -340,6 +341,29 @@ struct dma_buf_attachment { > > struct list_head node; > > void *priv; > > struct sg_table *sgt; > > + void *importer_priv; > > + > > + /** > > + * @invalidate: > > + * > > + * Optional callback provided by the importer of the dma-buf. > > + * > > + * If provided the exporter can avoid pinning the backing store while > > + * mappings exists. > > + * > > + * The function is called with the lock of the reservation object > > + * associated with the dma_buf held and the mapping function must be > > + * called with this lock held as well. This makes sure that no mapping > > + * is created concurrently with an ongoing invalidation. > > + * > > + * After the callback all existing mappings are still valid until all > > + * fences in the dma_bufs reservation object are signaled, but should be > > + * destroyed by the importer as soon as possible. > > + * > > + * New mappings can be created immediately, but can't be used before the > > + * exclusive fence in the dma_bufs reservation object is signaled. > > + */ > > + void (*invalidate)(struct dma_buf_attachment *attach); > > I would put the long kerneldoc into dma_buf_attach_info (as an inline > comment, you can mix the styles). And reference it from here with > something like > > "Set from &dma_buf_attach_info.invalidate in dma_buf_attach(), see there > for more information." > > This here feels a bit too much hidden. Question on semantics: Is invalidate allowed to add new fences? I think we need that for pipelined buffer moves and stuff perhaps (or pipeline pagetable invalidates or whatever you feel like pipelining). And it should be possible (we already hold the reservation lock), and I think ttm copes (but no idea really). Either way, docs need to be clear on this. -Daniel -- 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: [PATCH 04/12] dma-buf: add optional invalidate_mappings callback v5 Date: Wed, 17 Apr 2019 16:33:20 +0200 Message-ID: <20190417143320.GH13337@phenom.ffwll.local> References: <20190416183841.1577-1-christian.koenig@amd.com> <20190416183841.1577-5-christian.koenig@amd.com> <20190417140116.GC13337@phenom.ffwll.local> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20190417140116.GC13337-dv86pmgwkMBes7Z6vYuT8azUEOm+Xw19@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: amd-gfx-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "amd-gfx" To: Christian =?iso-8859-1?Q?K=F6nig?= , sumit.semwal-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org, linux-media-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linaro-mm-sig-cunTk1MwBs8s++Sfvej+rw@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org List-Id: dri-devel@lists.freedesktop.org T24gV2VkLCBBcHIgMTcsIDIwMTkgYXQgMDQ6MDE6MTZQTSArMDIwMCwgRGFuaWVsIFZldHRlciB3 cm90ZToKPiBPbiBUdWUsIEFwciAxNiwgMjAxOSBhdCAwODozODozM1BNICswMjAwLCBDaHJpc3Rp YW4gS8O2bmlnIHdyb3RlOgo+ID4gRWFjaCBpbXBvcnRlciBjYW4gbm93IHByb3ZpZGUgYW4gaW52 YWxpZGF0ZV9tYXBwaW5ncyBjYWxsYmFjay4KPiA+IAo+ID4gVGhpcyBhbGxvd3MgdGhlIGV4cG9y dGVyIHRvIHByb3ZpZGUgdGhlIG1hcHBpbmdzIHdpdGhvdXQgdGhlIG5lZWQgdG8gcGluCj4gPiB0 aGUgYmFja2luZyBzdG9yZS4KPiA+IAo+ID4gdjI6IGRvbid0IHRyeSB0byBpbnZhbGlkYXRlIG1h cHBpbmdzIHdoZW4gdGhlIGNhbGxiYWNrIGlzIE5VTEwsCj4gPiAgICAgbG9jayB0aGUgcmVzZXJ2 YXRpb24gb2JqIHdoaWxlIHVzaW5nIHRoZSBhdHRhY2htZW50cywKPiA+ICAgICBhZGQgaGVscGVy IHRvIHNldCB0aGUgY2FsbGJhY2sKPiA+IHYzOiBtb3ZlIGZsYWcgZm9yIGludmFsaWRhdGlvbiBz dXBwb3J0IGludG8gdGhlIERNQS1idWYsCj4gPiAgICAgdXNlIG5ldyBhdHRhY2hfaW5mbyBzdHJ1 Y3R1cmUgdG8gc2V0IHRoZSBjYWxsYmFjawo+ID4gdjQ6IHVzZSBpbXBvcnRlcl9wcml2IGZpZWxk IGluc3RlYWQgb2YgbWFuZ2xpbmcgZXhwb3J0ZXIgcHJpdi4KPiA+IHY1OiBkcm9wIGludmFsaWRh dGlvbl9zdXBwb3J0ZWQgZmxhZwo+ID4gCj4gPiBTaWduZWQtb2ZmLWJ5OiBDaHJpc3RpYW4gS8O2 bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5jb20+Cj4gPiAtLS0KPiA+ICBkcml2ZXJzL2RtYS1i dWYvZG1hLWJ1Zi5jIHwgMzcgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ ID4gIGluY2x1ZGUvbGludXgvZG1hLWJ1Zi5oICAgfCAzMyArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrLS0KPiA+ICAyIGZpbGVzIGNoYW5nZWQsIDY4IGluc2VydGlvbnMoKyksIDIgZGVs ZXRpb25zKC0pCj4gPiAKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5j IGIvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYwo+ID4gaW5kZXggODNjOTJiZmQ5NjRjLi5hMzcz OGZhYjM5MjcgMTAwNjQ0Cj4gPiAtLS0gYS9kcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jCj4gPiAr KysgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jCj4gPiBAQCAtNTYzLDYgKzU2Myw4IEBAIHN0 cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmRtYV9idWZfYXR0YWNoKGNvbnN0IHN0cnVjdCBkbWFf YnVmX2F0dGFjaF9pbmZvICppbmZvCj4gPiAgCj4gPiAgCWF0dGFjaC0+ZGV2ID0gaW5mby0+ZGV2 Owo+ID4gIAlhdHRhY2gtPmRtYWJ1ZiA9IGRtYWJ1ZjsKPiA+ICsJYXR0YWNoLT5pbXBvcnRlcl9w cml2ID0gaW5mby0+aW1wb3J0ZXJfcHJpdjsKPiA+ICsJYXR0YWNoLT5pbnZhbGlkYXRlID0gaW5m by0+aW52YWxpZGF0ZTsKPiA+ICAKPiA+ICAJbXV0ZXhfbG9jaygmZG1hYnVmLT5sb2NrKTsKPiA+ ICAKPiA+IEBAIC01NzEsNyArNTczLDkgQEAgc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqZG1h X2J1Zl9hdHRhY2goY29uc3Qgc3RydWN0IGRtYV9idWZfYXR0YWNoX2luZm8gKmluZm8KPiA+ICAJ CWlmIChyZXQpCj4gPiAgCQkJZ290byBlcnJfYXR0YWNoOwo+ID4gIAl9Cj4gPiArCXJlc2VydmF0 aW9uX29iamVjdF9sb2NrKGRtYWJ1Zi0+cmVzdiwgTlVMTCk7Cj4gPiAgCWxpc3RfYWRkKCZhdHRh Y2gtPm5vZGUsICZkbWFidWYtPmF0dGFjaG1lbnRzKTsKPiA+ICsJcmVzZXJ2YXRpb25fb2JqZWN0 X3VubG9jayhkbWFidWYtPnJlc3YpOwo+ID4gIAo+ID4gIAltdXRleF91bmxvY2soJmRtYWJ1Zi0+ bG9jayk7Cj4gPiAgCj4gPiBAQCAtNjE1LDcgKzYxOSw5IEBAIHZvaWQgZG1hX2J1Zl9kZXRhY2go c3RydWN0IGRtYV9idWYgKmRtYWJ1Ziwgc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNo KQo+ID4gIAkJCQkJICAgRE1BX0JJRElSRUNUSU9OQUwpOwo+ID4gIAo+ID4gIAltdXRleF9sb2Nr KCZkbWFidWYtPmxvY2spOwo+ID4gKwlyZXNlcnZhdGlvbl9vYmplY3RfbG9jayhkbWFidWYtPnJl c3YsIE5VTEwpOwo+ID4gIAlsaXN0X2RlbCgmYXR0YWNoLT5ub2RlKTsKPiA+ICsJcmVzZXJ2YXRp b25fb2JqZWN0X3VubG9jayhkbWFidWYtPnJlc3YpOwo+ID4gIAlpZiAoZG1hYnVmLT5vcHMtPmRl dGFjaCkKPiA+ICAJCWRtYWJ1Zi0+b3BzLT5kZXRhY2goZG1hYnVmLCBhdHRhY2gpOwo+ID4gIAo+ ID4gQEAgLTY1Myw3ICs2NTksMTYgQEAgZG1hX2J1Zl9tYXBfYXR0YWNobWVudF9sb2NrZWQoc3Ry dWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoLAo+ID4gIAlpZiAoYXR0YWNoLT5zZ3QpCj4g PiAgCQlyZXR1cm4gYXR0YWNoLT5zZ3Q7Cj4gPiAgCj4gPiArCS8qCj4gPiArCSAqIE1hcHBpbmcg YSBETUEtYnVmIGNhbiB0cmlnZ2VyIGl0cyBpbnZhbGlkYXRpb24sIHByZXZlbnQgc2VuZGluZyB0 aGlzCj4gPiArCSAqIGV2ZW50IHRvIHRoZSBjYWxsZXIgYnkgdGVtcG9yYXJ5IHJlbW92aW5nIHRo aXMgYXR0YWNobWVudCBmcm9tIHRoZQo+ID4gKwkgKiBsaXN0Lgo+ID4gKwkgKi8KPiA+ICsJaWYg KGF0dGFjaC0+aW52YWxpZGF0ZSkKPiA+ICsJCWxpc3RfZGVsKCZhdHRhY2gtPm5vZGUpOwo+ID4g IAlzZ190YWJsZSA9IGF0dGFjaC0+ZG1hYnVmLT5vcHMtPm1hcF9kbWFfYnVmKGF0dGFjaCwgZGly ZWN0aW9uKTsKPiA+ICsJaWYgKGF0dGFjaC0+aW52YWxpZGF0ZSkKPiA+ICsJCWxpc3RfYWRkKCZh dHRhY2gtPm5vZGUsICZhdHRhY2gtPmRtYWJ1Zi0+YXR0YWNobWVudHMpOwo+ID4gIAlpZiAoIXNn X3RhYmxlKQo+ID4gIAkJc2dfdGFibGUgPSBFUlJfUFRSKC1FTk9NRU0pOwo+ID4gIAo+ID4gQEAg LTc1MSw2ICs3NjYsMjYgQEAgdm9pZCBkbWFfYnVmX3VubWFwX2F0dGFjaG1lbnQoc3RydWN0IGRt YV9idWZfYXR0YWNobWVudCAqYXR0YWNoLAo+ID4gIH0KPiA+ICBFWFBPUlRfU1lNQk9MX0dQTChk bWFfYnVmX3VubWFwX2F0dGFjaG1lbnQpOwo+ID4gIAo+ID4gKy8qKgo+ID4gKyAqIGRtYV9idWZf aW52YWxpZGF0ZV9tYXBwaW5ncyAtIGludmFsaWRhdGUgYWxsIG1hcHBpbmdzIG9mIHRoaXMgZG1h X2J1Zgo+ID4gKyAqCj4gPiArICogQGRtYWJ1ZjoJW2luXQlidWZmZXIgd2hpY2ggbWFwcGluZ3Mg c2hvdWxkIGJlIGludmFsaWRhdGVkCj4gPiArICoKPiA+ICsgKiBJbmZvcm1zIGFsbCBhdHRhY2ht ZW5zdCB0aGF0IHRoZXkgbmVlZCB0byBkZXN0cm95IGFuZCByZWNyZWF0ZWQgYWxsIHRoZWlyCj4g PiArICogbWFwcGluZ3MuCj4gPiArICovCj4gPiArdm9pZCBkbWFfYnVmX2ludmFsaWRhdGVfbWFw cGluZ3Moc3RydWN0IGRtYV9idWYgKmRtYWJ1ZikKPiA+ICt7Cj4gPiArCXN0cnVjdCBkbWFfYnVm X2F0dGFjaG1lbnQgKmF0dGFjaDsKPiA+ICsKPiA+ICsJcmVzZXJ2YXRpb25fb2JqZWN0X2Fzc2Vy dF9oZWxkKGRtYWJ1Zi0+cmVzdik7Cj4gPiArCj4gPiArCWxpc3RfZm9yX2VhY2hfZW50cnkoYXR0 YWNoLCAmZG1hYnVmLT5hdHRhY2htZW50cywgbm9kZSkKPiA+ICsJCWlmIChhdHRhY2gtPmludmFs aWRhdGUpCj4gPiArCQkJYXR0YWNoLT5pbnZhbGlkYXRlKGF0dGFjaCk7Cj4gPiArfQo+ID4gK0VY UE9SVF9TWU1CT0xfR1BMKGRtYV9idWZfaW52YWxpZGF0ZV9tYXBwaW5ncyk7Cj4gPiArCj4gPiAg LyoqCj4gPiAgICogRE9DOiBjcHUgYWNjZXNzCj4gPiAgICoKPiA+IEBAIC0xMTYzLDEwICsxMTk4 LDEyIEBAIHN0YXRpYyBpbnQgZG1hX2J1Zl9kZWJ1Z19zaG93KHN0cnVjdCBzZXFfZmlsZSAqcywg dm9pZCAqdW51c2VkKQo+ID4gIAkJc2VxX3B1dHMocywgIlx0QXR0YWNoZWQgRGV2aWNlczpcbiIp Owo+ID4gIAkJYXR0YWNoX2NvdW50ID0gMDsKPiA+ICAKPiA+ICsJCXJlc2VydmF0aW9uX29iamVj dF9sb2NrKGJ1Zl9vYmotPnJlc3YsIE5VTEwpOwo+ID4gIAkJbGlzdF9mb3JfZWFjaF9lbnRyeShh dHRhY2hfb2JqLCAmYnVmX29iai0+YXR0YWNobWVudHMsIG5vZGUpIHsKPiA+ICAJCQlzZXFfcHJp bnRmKHMsICJcdCVzXG4iLCBkZXZfbmFtZShhdHRhY2hfb2JqLT5kZXYpKTsKPiA+ICAJCQlhdHRh Y2hfY291bnQrKzsKPiA+ICAJCX0KPiA+ICsJCXJlc2VydmF0aW9uX29iamVjdF91bmxvY2soYnVm X29iai0+cmVzdik7Cj4gPiAgCj4gPiAgCQlzZXFfcHJpbnRmKHMsICJUb3RhbCAlZCBkZXZpY2Vz IGF0dGFjaGVkXG5cbiIsCj4gPiAgCQkJCWF0dGFjaF9jb3VudCk7Cj4gPiBkaWZmIC0tZ2l0IGEv aW5jbHVkZS9saW51eC9kbWEtYnVmLmggYi9pbmNsdWRlL2xpbnV4L2RtYS1idWYuaAo+ID4gaW5k ZXggN2UyMzc1OGRiM2E0Li5lY2U0NjM4MzU5YTggMTAwNjQ0Cj4gPiAtLS0gYS9pbmNsdWRlL2xp bnV4L2RtYS1idWYuaAo+ID4gKysrIGIvaW5jbHVkZS9saW51eC9kbWEtYnVmLmgKPiA+IEBAIC0z MjQsNiArMzI0LDcgQEAgc3RydWN0IGRtYV9idWYgewo+ID4gICAqIEBkZXY6IGRldmljZSBhdHRh Y2hlZCB0byB0aGUgYnVmZmVyLgo+ID4gICAqIEBub2RlOiBsaXN0IG9mIGRtYV9idWZfYXR0YWNo bWVudC4KPiA+ICAgKiBAcHJpdjogZXhwb3J0ZXIgc3BlY2lmaWMgYXR0YWNobWVudCBkYXRhLgo+ ID4gKyAqIEBpbXBvcnRlcl9wcml2OiBpbXBvcnRlciBzcGVjaWZpYyBhdHRhY2htZW50IGRhdGEu Cj4gPiAgICoKPiA+ICAgKiBUaGlzIHN0cnVjdHVyZSBob2xkcyB0aGUgYXR0YWNobWVudCBpbmZv cm1hdGlvbiBiZXR3ZWVuIHRoZSBkbWFfYnVmIGJ1ZmZlcgo+ID4gICAqIGFuZCBpdHMgdXNlciBk ZXZpY2UocykuIFRoZSBsaXN0IGNvbnRhaW5zIG9uZSBhdHRhY2htZW50IHN0cnVjdCBwZXIgZGV2 aWNlCj4gPiBAQCAtMzQwLDYgKzM0MSwyOSBAQCBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50IHsK PiA+ICAJc3RydWN0IGxpc3RfaGVhZCBub2RlOwo+ID4gIAl2b2lkICpwcml2Owo+ID4gIAlzdHJ1 Y3Qgc2dfdGFibGUgKnNndDsKPiA+ICsJdm9pZCAqaW1wb3J0ZXJfcHJpdjsKPiA+ICsKPiA+ICsJ LyoqCj4gPiArCSAqIEBpbnZhbGlkYXRlOgo+ID4gKwkgKgo+ID4gKwkgKiBPcHRpb25hbCBjYWxs YmFjayBwcm92aWRlZCBieSB0aGUgaW1wb3J0ZXIgb2YgdGhlIGRtYS1idWYuCj4gPiArCSAqCj4g PiArCSAqIElmIHByb3ZpZGVkIHRoZSBleHBvcnRlciBjYW4gYXZvaWQgcGlubmluZyB0aGUgYmFj a2luZyBzdG9yZSB3aGlsZQo+ID4gKwkgKiBtYXBwaW5ncyBleGlzdHMuCj4gPiArCSAqCj4gPiAr CSAqIFRoZSBmdW5jdGlvbiBpcyBjYWxsZWQgd2l0aCB0aGUgbG9jayBvZiB0aGUgcmVzZXJ2YXRp b24gb2JqZWN0Cj4gPiArCSAqIGFzc29jaWF0ZWQgd2l0aCB0aGUgZG1hX2J1ZiBoZWxkIGFuZCB0 aGUgbWFwcGluZyBmdW5jdGlvbiBtdXN0IGJlCj4gPiArCSAqIGNhbGxlZCB3aXRoIHRoaXMgbG9j ayBoZWxkIGFzIHdlbGwuIFRoaXMgbWFrZXMgc3VyZSB0aGF0IG5vIG1hcHBpbmcKPiA+ICsJICog aXMgY3JlYXRlZCBjb25jdXJyZW50bHkgd2l0aCBhbiBvbmdvaW5nIGludmFsaWRhdGlvbi4KPiA+ ICsJICoKPiA+ICsJICogQWZ0ZXIgdGhlIGNhbGxiYWNrIGFsbCBleGlzdGluZyBtYXBwaW5ncyBh cmUgc3RpbGwgdmFsaWQgdW50aWwgYWxsCj4gPiArCSAqIGZlbmNlcyBpbiB0aGUgZG1hX2J1ZnMg cmVzZXJ2YXRpb24gb2JqZWN0IGFyZSBzaWduYWxlZCwgYnV0IHNob3VsZCBiZQo+ID4gKwkgKiBk ZXN0cm95ZWQgYnkgdGhlIGltcG9ydGVyIGFzIHNvb24gYXMgcG9zc2libGUuCj4gPiArCSAqCj4g PiArCSAqIE5ldyBtYXBwaW5ncyBjYW4gYmUgY3JlYXRlZCBpbW1lZGlhdGVseSwgYnV0IGNhbid0 IGJlIHVzZWQgYmVmb3JlIHRoZQo+ID4gKwkgKiBleGNsdXNpdmUgZmVuY2UgaW4gdGhlIGRtYV9i dWZzIHJlc2VydmF0aW9uIG9iamVjdCBpcyBzaWduYWxlZC4KPiA+ICsJICovCj4gPiArCXZvaWQg KCppbnZhbGlkYXRlKShzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gpOwo+IAo+IEkg d291bGQgcHV0IHRoZSBsb25nIGtlcm5lbGRvYyBpbnRvIGRtYV9idWZfYXR0YWNoX2luZm8gKGFz IGFuIGlubGluZQo+IGNvbW1lbnQsIHlvdSBjYW4gbWl4IHRoZSBzdHlsZXMpLiBBbmQgcmVmZXJl bmNlIGl0IGZyb20gaGVyZSB3aXRoCj4gc29tZXRoaW5nIGxpa2UKPiAKPiAiU2V0IGZyb20gJmRt YV9idWZfYXR0YWNoX2luZm8uaW52YWxpZGF0ZSBpbiBkbWFfYnVmX2F0dGFjaCgpLCBzZWUgdGhl cmUKPiBmb3IgbW9yZSBpbmZvcm1hdGlvbi4iCj4gCj4gVGhpcyBoZXJlIGZlZWxzIGEgYml0IHRv byBtdWNoIGhpZGRlbi4KClF1ZXN0aW9uIG9uIHNlbWFudGljczogSXMgaW52YWxpZGF0ZSBhbGxv d2VkIHRvIGFkZCBuZXcgZmVuY2VzPyBJIHRoaW5rIHdlCm5lZWQgdGhhdCBmb3IgcGlwZWxpbmVk IGJ1ZmZlciBtb3ZlcyBhbmQgc3R1ZmYgcGVyaGFwcyAob3IgcGlwZWxpbmUKcGFnZXRhYmxlIGlu dmFsaWRhdGVzIG9yIHdoYXRldmVyIHlvdSBmZWVsIGxpa2UgcGlwZWxpbmluZykuIEFuZCBpdCBz aG91bGQKYmUgcG9zc2libGUgKHdlIGFscmVhZHkgaG9sZCB0aGUgcmVzZXJ2YXRpb24gbG9jayks IGFuZCBJIHRoaW5rIHR0bSBjb3BlcwooYnV0IG5vIGlkZWEgcmVhbGx5KS4KCkVpdGhlciB3YXks IGRvY3MgbmVlZCB0byBiZSBjbGVhciBvbiB0aGlzLgotRGFuaWVsCi0tIApEYW5pZWwgVmV0dGVy ClNvZnR3YXJlIEVuZ2luZWVyLCBJbnRlbCBDb3Jwb3JhdGlvbgpodHRwOi8vYmxvZy5mZndsbC5j aApfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwphbWQtZ2Z4 IG1haWxpbmcgbGlzdAphbWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3Rz LmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2FtZC1nZng=