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.2 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED 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 AC982C65C14 for ; Fri, 18 Jan 2019 20:20:53 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 6A6AB20657 for ; Fri, 18 Jan 2019 20:20:53 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=ti.com header.i=@ti.com header.b="ZBCXI76N" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729462AbfARUUv (ORCPT ); Fri, 18 Jan 2019 15:20:51 -0500 Received: from fllv0016.ext.ti.com ([198.47.19.142]:49986 "EHLO fllv0016.ext.ti.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729381AbfARUUv (ORCPT ); Fri, 18 Jan 2019 15:20:51 -0500 Received: from lelv0266.itg.ti.com ([10.180.67.225]) by fllv0016.ext.ti.com (8.15.2/8.15.2) with ESMTP id x0IKKgJ3020110; Fri, 18 Jan 2019 14:20:42 -0600 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ti.com; s=ti-com-17Q1; t=1547842842; bh=aufRV8DxPBlCH1R+TJXTjW299Jj7QbDj1aFMqdBqcdQ=; h=Subject:To:CC:References:From:Date:In-Reply-To; b=ZBCXI76NjRC3K0DYdc6kgHzAw9g/dvybIkh0XvXF3ilConZl3qujLISbMW7lIUDvT a3wWS8bFzFw4k+11aPUo/tSkknGthHroPUAVUuTWONWDSOLBwwW3h6p3xhZpJQfC49 pBgKVPb6CBysx1tS05Dk7aGtMN3Aa6t1I2KKjjbw= Received: from DFLE102.ent.ti.com (dfle102.ent.ti.com [10.64.6.23]) by lelv0266.itg.ti.com (8.15.2/8.15.2) with ESMTPS id x0IKKgHG060324 (version=TLSv1.2 cipher=AES256-GCM-SHA384 bits=256 verify=FAIL); Fri, 18 Jan 2019 14:20:42 -0600 Received: from DFLE112.ent.ti.com (10.64.6.33) by DFLE102.ent.ti.com (10.64.6.23) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1591.10; Fri, 18 Jan 2019 14:20:42 -0600 Received: from dflp32.itg.ti.com (10.64.6.15) by DFLE112.ent.ti.com (10.64.6.33) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_RSA_WITH_AES_256_CBC_SHA) id 15.1.1591.10 via Frontend Transport; Fri, 18 Jan 2019 14:20:42 -0600 Received: from [172.22.84.228] (ileax41-snat.itg.ti.com [10.172.224.153]) by dflp32.itg.ti.com (8.14.3/8.13.8) with ESMTP id x0IKKfKX012468; Fri, 18 Jan 2019 14:20:41 -0600 Subject: Re: [PATCH 2/4] staging: android: ion: Restrict cache maintenance to dma mapped memory To: Liam Mark , , CC: , , , , , , , , , References: <1547836667-13695-1-git-send-email-lmark@codeaurora.org> <1547836667-13695-3-git-send-email-lmark@codeaurora.org> From: "Andrew F. Davis" Message-ID: <69b18f39-8ce0-3c4d-3528-dfab8399f24f@ti.com> Date: Fri, 18 Jan 2019 14:20:41 -0600 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.2.1 MIME-Version: 1.0 In-Reply-To: <1547836667-13695-3-git-send-email-lmark@codeaurora.org> Content-Type: text/plain; charset="utf-8" Content-Language: en-US Content-Transfer-Encoding: 8bit X-EXCLAIMER-MD-CONFIG: e1e8a2fd-e40a-4ac6-ac9b-f7e9cc9ee180 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 1/18/19 12:37 PM, Liam Mark wrote: > The ION begin_cpu_access and end_cpu_access functions use the > dma_sync_sg_for_cpu and dma_sync_sg_for_device APIs to perform cache > maintenance. > > Currently it is possible to apply cache maintenance, via the > begin_cpu_access and end_cpu_access APIs, to ION buffers which are not > dma mapped. > > The dma sync sg APIs should not be called on sg lists which have not been > dma mapped as this can result in cache maintenance being applied to the > wrong address. If an sg list has not been dma mapped then its dma_address > field has not been populated, some dma ops such as the swiotlb_dma_ops ops > use the dma_address field to calculate the address onto which to apply > cache maintenance. > > Also I don’t think we want CMOs to be applied to a buffer which is not > dma mapped as the memory should already be coherent for access from the > CPU. Any CMOs required for device access taken care of in the > dma_buf_map_attachment and dma_buf_unmap_attachment calls. > So really it only makes sense for begin_cpu_access and end_cpu_access to > apply CMOs if the buffer is dma mapped. > > Fix the ION begin_cpu_access and end_cpu_access functions to only apply > cache maintenance to buffers which are dma mapped. > > Fixes: 2a55e7b5e544 ("staging: android: ion: Call dma_map_sg for syncing and mapping") > Signed-off-by: Liam Mark > --- > drivers/staging/android/ion/ion.c | 26 +++++++++++++++++++++----- > 1 file changed, 21 insertions(+), 5 deletions(-) > > diff --git a/drivers/staging/android/ion/ion.c b/drivers/staging/android/ion/ion.c > index 6f5afab7c1a1..1fe633a7fdba 100644 > --- a/drivers/staging/android/ion/ion.c > +++ b/drivers/staging/android/ion/ion.c > @@ -210,6 +210,7 @@ struct ion_dma_buf_attachment { > struct device *dev; > struct sg_table *table; > struct list_head list; > + bool dma_mapped; > }; > > static int ion_dma_buf_attach(struct dma_buf *dmabuf, > @@ -231,6 +232,7 @@ static int ion_dma_buf_attach(struct dma_buf *dmabuf, > > a->table = table; > a->dev = attachment->dev; > + a->dma_mapped = false; > INIT_LIST_HEAD(&a->list); > > attachment->priv = a; > @@ -261,12 +263,18 @@ static struct sg_table *ion_map_dma_buf(struct dma_buf_attachment *attachment, > { > struct ion_dma_buf_attachment *a = attachment->priv; > struct sg_table *table; > + struct ion_buffer *buffer = attachment->dmabuf->priv; > > table = a->table; > > + mutex_lock(&buffer->lock); > if (!dma_map_sg(attachment->dev, table->sgl, table->nents, > - direction)) > + direction)) { > + mutex_unlock(&buffer->lock); > return ERR_PTR(-ENOMEM); > + } > + a->dma_mapped = true; > + mutex_unlock(&buffer->lock); > > return table; > } > @@ -275,7 +283,13 @@ static void ion_unmap_dma_buf(struct dma_buf_attachment *attachment, > struct sg_table *table, > enum dma_data_direction direction) > { > + struct ion_dma_buf_attachment *a = attachment->priv; > + struct ion_buffer *buffer = attachment->dmabuf->priv; > + > + mutex_lock(&buffer->lock); > dma_unmap_sg(attachment->dev, table->sgl, table->nents, direction); > + a->dma_mapped = false; > + mutex_unlock(&buffer->lock); > } > > static int ion_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma) > @@ -346,8 +360,9 @@ static int ion_dma_buf_begin_cpu_access(struct dma_buf *dmabuf, > > mutex_lock(&buffer->lock); > list_for_each_entry(a, &buffer->attachments, list) { When no devices are attached then buffer->attachments is empty and the below does not run, so if I understand this patch correctly then what you are protecting against is CPU access in the window after dma_buf_attach but before dma_buf_map. This is the kind of thing that again makes me think a couple more ordering requirements on DMA-BUF ops are needed. DMA-BUFs do not require the backing memory to be allocated until map time, this is why the dma_address field would still be null as you note in the commit message. So why should the CPU be performing accesses on a buffer that is not actually backed yet? I can think of two solutions: 1) Only allow CPU access (mmap, kmap, {begin,end}_cpu_access) while at least one device is mapped. 2) Treat the CPU access request like the a device map request and trigger the allocation of backing memory just like if a device map had come in. I know the current Ion heaps (and most other DMA-BUF exporters) all do the allocation up front so the memory is already there, but DMA-BUF was designed with late allocation in mind. I have a use-case I'm working on that finally exercises this DMA-BUF functionality and I would like to have it export through ION. This patch doesn't prevent that, but seems like it is endorsing the the idea that buffers always need to be backed, even before device attach/map is has occurred. Either of the above two solutions would need to target the DMA-BUF framework, Sumit, Any comment? Thanks, Andrew > - dma_sync_sg_for_cpu(a->dev, a->table->sgl, a->table->nents, > - direction); > + if (a->dma_mapped) > + dma_sync_sg_for_cpu(a->dev, a->table->sgl, > + a->table->nents, direction); > } > > unlock: > @@ -369,8 +384,9 @@ static int ion_dma_buf_end_cpu_access(struct dma_buf *dmabuf, > > mutex_lock(&buffer->lock); > list_for_each_entry(a, &buffer->attachments, list) { > - dma_sync_sg_for_device(a->dev, a->table->sgl, a->table->nents, > - direction); > + if (a->dma_mapped) > + dma_sync_sg_for_device(a->dev, a->table->sgl, > + a->table->nents, direction); > } > mutex_unlock(&buffer->lock); > > From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Andrew F. Davis" Subject: Re: [PATCH 2/4] staging: android: ion: Restrict cache maintenance to dma mapped memory Date: Fri, 18 Jan 2019 14:20:41 -0600 Message-ID: <69b18f39-8ce0-3c4d-3528-dfab8399f24f@ti.com> References: <1547836667-13695-1-git-send-email-lmark@codeaurora.org> <1547836667-13695-3-git-send-email-lmark@codeaurora.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1547836667-13695-3-git-send-email-lmark@codeaurora.org> Content-Language: en-US List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: driverdev-devel-bounces@linuxdriverproject.org Sender: "devel" To: Liam Mark , labbott@redhat.com, sumit.semwal@linaro.org Cc: devel@driverdev.osuosl.org, tkjos@android.com, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, arve@android.com, john.stultz@linaro.org, joel@joelfernandes.org, maco@android.com, christian@brauner.io List-Id: dri-devel@lists.freedesktop.org T24gMS8xOC8xOSAxMjozNyBQTSwgTGlhbSBNYXJrIHdyb3RlOgo+IFRoZSBJT04gYmVnaW5fY3B1 X2FjY2VzcyBhbmQgZW5kX2NwdV9hY2Nlc3MgZnVuY3Rpb25zIHVzZSB0aGUKPiBkbWFfc3luY19z Z19mb3JfY3B1IGFuZCBkbWFfc3luY19zZ19mb3JfZGV2aWNlIEFQSXMgdG8gcGVyZm9ybSBjYWNo ZQo+IG1haW50ZW5hbmNlLgo+IAo+IEN1cnJlbnRseSBpdCBpcyBwb3NzaWJsZSB0byBhcHBseSBj YWNoZSBtYWludGVuYW5jZSwgdmlhIHRoZQo+IGJlZ2luX2NwdV9hY2Nlc3MgYW5kIGVuZF9jcHVf YWNjZXNzIEFQSXMsIHRvIElPTiBidWZmZXJzIHdoaWNoIGFyZSBub3QKPiBkbWEgbWFwcGVkLgo+ IAo+IFRoZSBkbWEgc3luYyBzZyBBUElzIHNob3VsZCBub3QgYmUgY2FsbGVkIG9uIHNnIGxpc3Rz IHdoaWNoIGhhdmUgbm90IGJlZW4KPiBkbWEgbWFwcGVkIGFzIHRoaXMgY2FuIHJlc3VsdCBpbiBj YWNoZSBtYWludGVuYW5jZSBiZWluZyBhcHBsaWVkIHRvIHRoZQo+IHdyb25nIGFkZHJlc3MuIElm IGFuIHNnIGxpc3QgaGFzIG5vdCBiZWVuIGRtYSBtYXBwZWQgdGhlbiBpdHMgZG1hX2FkZHJlc3MK PiBmaWVsZCBoYXMgbm90IGJlZW4gcG9wdWxhdGVkLCBzb21lIGRtYSBvcHMgc3VjaCBhcyB0aGUg c3dpb3RsYl9kbWFfb3BzIG9wcwo+IHVzZSB0aGUgZG1hX2FkZHJlc3MgZmllbGQgdG8gY2FsY3Vs YXRlIHRoZSBhZGRyZXNzIG9udG8gd2hpY2ggdG8gYXBwbHkKPiBjYWNoZSBtYWludGVuYW5jZS4K PiAKPiBBbHNvIEkgZG9u4oCZdCB0aGluayB3ZSB3YW50IENNT3MgdG8gYmUgYXBwbGllZCB0byBh IGJ1ZmZlciB3aGljaCBpcyBub3QKPiBkbWEgbWFwcGVkIGFzIHRoZSBtZW1vcnkgc2hvdWxkIGFs cmVhZHkgYmUgY29oZXJlbnQgZm9yIGFjY2VzcyBmcm9tIHRoZQo+IENQVS4gQW55IENNT3MgcmVx dWlyZWQgZm9yIGRldmljZSBhY2Nlc3MgdGFrZW4gY2FyZSBvZiBpbiB0aGUKPiBkbWFfYnVmX21h cF9hdHRhY2htZW50IGFuZCBkbWFfYnVmX3VubWFwX2F0dGFjaG1lbnQgY2FsbHMuCj4gU28gcmVh bGx5IGl0IG9ubHkgbWFrZXMgc2Vuc2UgZm9yIGJlZ2luX2NwdV9hY2Nlc3MgYW5kIGVuZF9jcHVf YWNjZXNzIHRvCj4gYXBwbHkgQ01PcyBpZiB0aGUgYnVmZmVyIGlzIGRtYSBtYXBwZWQuCj4gCj4g Rml4IHRoZSBJT04gYmVnaW5fY3B1X2FjY2VzcyBhbmQgZW5kX2NwdV9hY2Nlc3MgZnVuY3Rpb25z IHRvIG9ubHkgYXBwbHkKPiBjYWNoZSBtYWludGVuYW5jZSB0byBidWZmZXJzIHdoaWNoIGFyZSBk bWEgbWFwcGVkLgo+IAo+IEZpeGVzOiAyYTU1ZTdiNWU1NDQgKCJzdGFnaW5nOiBhbmRyb2lkOiBp b246IENhbGwgZG1hX21hcF9zZyBmb3Igc3luY2luZyBhbmQgbWFwcGluZyIpCj4gU2lnbmVkLW9m Zi1ieTogTGlhbSBNYXJrIDxsbWFya0Bjb2RlYXVyb3JhLm9yZz4KPiAtLS0KPiAgZHJpdmVycy9z dGFnaW5nL2FuZHJvaWQvaW9uL2lvbi5jIHwgMjYgKysrKysrKysrKysrKysrKysrKysrLS0tLS0K PiAgMSBmaWxlIGNoYW5nZWQsIDIxIGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCj4gCj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL2lvbi9pb24uYyBiL2RyaXZlcnMv c3RhZ2luZy9hbmRyb2lkL2lvbi9pb24uYwo+IGluZGV4IDZmNWFmYWI3YzFhMS4uMWZlNjMzYTdm ZGJhIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL2lvbi9pb24uYwo+ICsr KyBiL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL2lvbi9pb24uYwo+IEBAIC0yMTAsNiArMjEwLDcg QEAgc3RydWN0IGlvbl9kbWFfYnVmX2F0dGFjaG1lbnQgewo+ICAJc3RydWN0IGRldmljZSAqZGV2 Owo+ICAJc3RydWN0IHNnX3RhYmxlICp0YWJsZTsKPiAgCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsK PiArCWJvb2wgZG1hX21hcHBlZDsKPiAgfTsKPiAgCj4gIHN0YXRpYyBpbnQgaW9uX2RtYV9idWZf YXR0YWNoKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsCj4gQEAgLTIzMSw2ICsyMzIsNyBAQCBzdGF0 aWMgaW50IGlvbl9kbWFfYnVmX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAo+ICAKPiAg CWEtPnRhYmxlID0gdGFibGU7Cj4gIAlhLT5kZXYgPSBhdHRhY2htZW50LT5kZXY7Cj4gKwlhLT5k bWFfbWFwcGVkID0gZmFsc2U7Cj4gIAlJTklUX0xJU1RfSEVBRCgmYS0+bGlzdCk7Cj4gIAo+ICAJ YXR0YWNobWVudC0+cHJpdiA9IGE7Cj4gQEAgLTI2MSwxMiArMjYzLDE4IEBAIHN0YXRpYyBzdHJ1 Y3Qgc2dfdGFibGUgKmlvbl9tYXBfZG1hX2J1ZihzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICph dHRhY2htZW50LAo+ICB7Cj4gIAlzdHJ1Y3QgaW9uX2RtYV9idWZfYXR0YWNobWVudCAqYSA9IGF0 dGFjaG1lbnQtPnByaXY7Cj4gIAlzdHJ1Y3Qgc2dfdGFibGUgKnRhYmxlOwo+ICsJc3RydWN0IGlv bl9idWZmZXIgKmJ1ZmZlciA9IGF0dGFjaG1lbnQtPmRtYWJ1Zi0+cHJpdjsKPiAgCj4gIAl0YWJs ZSA9IGEtPnRhYmxlOwo+ICAKPiArCW11dGV4X2xvY2soJmJ1ZmZlci0+bG9jayk7Cj4gIAlpZiAo IWRtYV9tYXBfc2coYXR0YWNobWVudC0+ZGV2LCB0YWJsZS0+c2dsLCB0YWJsZS0+bmVudHMsCj4g LQkJCWRpcmVjdGlvbikpCj4gKwkJCWRpcmVjdGlvbikpIHsKPiArCQltdXRleF91bmxvY2soJmJ1 ZmZlci0+bG9jayk7Cj4gIAkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7Cj4gKwl9Cj4gKwlhLT5k bWFfbWFwcGVkID0gdHJ1ZTsKPiArCW11dGV4X3VubG9jaygmYnVmZmVyLT5sb2NrKTsKPiAgCj4g IAlyZXR1cm4gdGFibGU7Cj4gIH0KPiBAQCAtMjc1LDcgKzI4MywxMyBAQCBzdGF0aWMgdm9pZCBp b25fdW5tYXBfZG1hX2J1ZihzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2htZW50LAo+ ICAJCQkgICAgICBzdHJ1Y3Qgc2dfdGFibGUgKnRhYmxlLAo+ICAJCQkgICAgICBlbnVtIGRtYV9k YXRhX2RpcmVjdGlvbiBkaXJlY3Rpb24pCj4gIHsKPiArCXN0cnVjdCBpb25fZG1hX2J1Zl9hdHRh Y2htZW50ICphID0gYXR0YWNobWVudC0+cHJpdjsKPiArCXN0cnVjdCBpb25fYnVmZmVyICpidWZm ZXIgPSBhdHRhY2htZW50LT5kbWFidWYtPnByaXY7Cj4gKwo+ICsJbXV0ZXhfbG9jaygmYnVmZmVy LT5sb2NrKTsKPiAgCWRtYV91bm1hcF9zZyhhdHRhY2htZW50LT5kZXYsIHRhYmxlLT5zZ2wsIHRh YmxlLT5uZW50cywgZGlyZWN0aW9uKTsKPiArCWEtPmRtYV9tYXBwZWQgPSBmYWxzZTsKPiArCW11 dGV4X3VubG9jaygmYnVmZmVyLT5sb2NrKTsKPiAgfQo+ICAKPiAgc3RhdGljIGludCBpb25fbW1h cChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKPiBA QCAtMzQ2LDggKzM2MCw5IEBAIHN0YXRpYyBpbnQgaW9uX2RtYV9idWZfYmVnaW5fY3B1X2FjY2Vz cyhzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAo+ICAKPiAgCW11dGV4X2xvY2soJmJ1ZmZlci0+bG9j ayk7Cj4gIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KGEsICZidWZmZXItPmF0dGFjaG1lbnRzLCBsaXN0 KSB7CgpXaGVuIG5vIGRldmljZXMgYXJlIGF0dGFjaGVkIHRoZW4gYnVmZmVyLT5hdHRhY2htZW50 cyBpcyBlbXB0eSBhbmQgdGhlCmJlbG93IGRvZXMgbm90IHJ1biwgc28gaWYgSSB1bmRlcnN0YW5k IHRoaXMgcGF0Y2ggY29ycmVjdGx5IHRoZW4gd2hhdAp5b3UgYXJlIHByb3RlY3RpbmcgYWdhaW5z dCBpcyBDUFUgYWNjZXNzIGluIHRoZSB3aW5kb3cgYWZ0ZXIKZG1hX2J1Zl9hdHRhY2ggYnV0IGJl Zm9yZSBkbWFfYnVmX21hcC4KClRoaXMgaXMgdGhlIGtpbmQgb2YgdGhpbmcgdGhhdCBhZ2FpbiBt YWtlcyBtZSB0aGluayBhIGNvdXBsZSBtb3JlCm9yZGVyaW5nIHJlcXVpcmVtZW50cyBvbiBETUEt QlVGIG9wcyBhcmUgbmVlZGVkLiBETUEtQlVGcyBkbyBub3QgcmVxdWlyZQp0aGUgYmFja2luZyBt ZW1vcnkgdG8gYmUgYWxsb2NhdGVkIHVudGlsIG1hcCB0aW1lLCB0aGlzIGlzIHdoeSB0aGUKZG1h X2FkZHJlc3MgZmllbGQgd291bGQgc3RpbGwgYmUgbnVsbCBhcyB5b3Ugbm90ZSBpbiB0aGUgY29t bWl0IG1lc3NhZ2UuClNvIHdoeSBzaG91bGQgdGhlIENQVSBiZSBwZXJmb3JtaW5nIGFjY2Vzc2Vz IG9uIGEgYnVmZmVyIHRoYXQgaXMgbm90CmFjdHVhbGx5IGJhY2tlZCB5ZXQ/CgpJIGNhbiB0aGlu ayBvZiB0d28gc29sdXRpb25zOgoKMSkgT25seSBhbGxvdyBDUFUgYWNjZXNzIChtbWFwLCBrbWFw LCB7YmVnaW4sZW5kfV9jcHVfYWNjZXNzKSB3aGlsZSBhdApsZWFzdCBvbmUgZGV2aWNlIGlzIG1h cHBlZC4KCjIpIFRyZWF0IHRoZSBDUFUgYWNjZXNzIHJlcXVlc3QgbGlrZSB0aGUgYSBkZXZpY2Ug bWFwIHJlcXVlc3QgYW5kCnRyaWdnZXIgdGhlIGFsbG9jYXRpb24gb2YgYmFja2luZyBtZW1vcnkg anVzdCBsaWtlIGlmIGEgZGV2aWNlIG1hcCBoYWQKY29tZSBpbi4KCkkga25vdyB0aGUgY3VycmVu dCBJb24gaGVhcHMgKGFuZCBtb3N0IG90aGVyIERNQS1CVUYgZXhwb3J0ZXJzKSBhbGwgZG8KdGhl IGFsbG9jYXRpb24gdXAgZnJvbnQgc28gdGhlIG1lbW9yeSBpcyBhbHJlYWR5IHRoZXJlLCBidXQg RE1BLUJVRiB3YXMKZGVzaWduZWQgd2l0aCBsYXRlIGFsbG9jYXRpb24gaW4gbWluZC4gSSBoYXZl IGEgdXNlLWNhc2UgSSdtIHdvcmtpbmcgb24KdGhhdCBmaW5hbGx5IGV4ZXJjaXNlcyB0aGlzIERN QS1CVUYgZnVuY3Rpb25hbGl0eSBhbmQgSSB3b3VsZCBsaWtlIHRvCmhhdmUgaXQgZXhwb3J0IHRo cm91Z2ggSU9OLiBUaGlzIHBhdGNoIGRvZXNuJ3QgcHJldmVudCB0aGF0LCBidXQgc2VlbXMKbGlr ZSBpdCBpcyBlbmRvcnNpbmcgdGhlIHRoZSBpZGVhIHRoYXQgYnVmZmVycyBhbHdheXMgbmVlZCB0 byBiZSBiYWNrZWQsCmV2ZW4gYmVmb3JlIGRldmljZSBhdHRhY2gvbWFwIGlzIGhhcyBvY2N1cnJl ZC4KCkVpdGhlciBvZiB0aGUgYWJvdmUgdHdvIHNvbHV0aW9ucyB3b3VsZCBuZWVkIHRvIHRhcmdl dCB0aGUgRE1BLUJVRgpmcmFtZXdvcmssCgpTdW1pdCwKCkFueSBjb21tZW50PwoKVGhhbmtzLApB bmRyZXcKCj4gLQkJZG1hX3N5bmNfc2dfZm9yX2NwdShhLT5kZXYsIGEtPnRhYmxlLT5zZ2wsIGEt PnRhYmxlLT5uZW50cywKPiAtCQkJCSAgICBkaXJlY3Rpb24pOwo+ICsJCWlmIChhLT5kbWFfbWFw cGVkKQo+ICsJCQlkbWFfc3luY19zZ19mb3JfY3B1KGEtPmRldiwgYS0+dGFibGUtPnNnbCwKPiAr CQkJCQkgICAgYS0+dGFibGUtPm5lbnRzLCBkaXJlY3Rpb24pOwo+ICAJfQo+ICAKPiAgdW5sb2Nr Ogo+IEBAIC0zNjksOCArMzg0LDkgQEAgc3RhdGljIGludCBpb25fZG1hX2J1Zl9lbmRfY3B1X2Fj Y2VzcyhzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAo+ICAKPiAgCW11dGV4X2xvY2soJmJ1ZmZlci0+ bG9jayk7Cj4gIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KGEsICZidWZmZXItPmF0dGFjaG1lbnRzLCBs aXN0KSB7Cj4gLQkJZG1hX3N5bmNfc2dfZm9yX2RldmljZShhLT5kZXYsIGEtPnRhYmxlLT5zZ2ws IGEtPnRhYmxlLT5uZW50cywKPiAtCQkJCSAgICAgICBkaXJlY3Rpb24pOwo+ICsJCWlmIChhLT5k bWFfbWFwcGVkKQo+ICsJCQlkbWFfc3luY19zZ19mb3JfZGV2aWNlKGEtPmRldiwgYS0+dGFibGUt PnNnbCwKPiArCQkJCQkgICAgICAgYS0+dGFibGUtPm5lbnRzLCBkaXJlY3Rpb24pOwo+ICAJfQo+ ICAJbXV0ZXhfdW5sb2NrKCZidWZmZXItPmxvY2spOwo+ICAKPiAKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZGV2ZWwgbWFpbGluZyBsaXN0CmRldmVsQGxp bnV4ZHJpdmVycHJvamVjdC5vcmcKaHR0cDovL2RyaXZlcmRldi5saW51eGRyaXZlcnByb2plY3Qu b3JnL21haWxtYW4vbGlzdGluZm8vZHJpdmVyZGV2LWRldmVsCg==