From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from galahad.ideasonboard.com ([185.26.127.97]:52368 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752323AbdCDXyc (ORCPT ); Sat, 4 Mar 2017 18:54:32 -0500 From: Laurent Pinchart To: Kieran Bingham Cc: linux-media@vger.kernel.org, linux-renesas-soc@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: Re: [PATCH v2 2/3] v4l: vsp1: Postpone page flip in event of display list race Date: Sun, 05 Mar 2017 01:46:57 +0200 Message-ID: <2000889.heoPCI45nc@avalon> In-Reply-To: <7b4ce1b20550d8651feceacf638ffc46be7400f7.1488592678.git-series.kieran.bingham+renesas@ideasonboard.com> References: <7b4ce1b20550d8651feceacf638ffc46be7400f7.1488592678.git-series.kieran.bingham+renesas@ideasonboard.com> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" Sender: linux-renesas-soc-owner@vger.kernel.org List-ID: Hi Kieran, Thank you for the patch. On Saturday 04 Mar 2017 02:01:18 Kieran Bingham wrote: > If we try to commit the display list while an update is pending, we have > missed our opportunity. The display list manager will hold the commit > until the next interrupt. > > In this event, we inform the vsp1 completion callback handler so that > the du will not perform a page flip out of turn. > > Signed-off-by: Kieran Bingham > --- > drivers/media/platform/vsp1/vsp1_dl.c | 9 +++++++-- > drivers/media/platform/vsp1/vsp1_dl.h | 2 +- > drivers/media/platform/vsp1/vsp1_drm.c | 4 +++- > drivers/media/platform/vsp1/vsp1_pipe.c | 6 +++++- > drivers/media/platform/vsp1/vsp1_pipe.h | 2 ++ > 5 files changed, 18 insertions(+), 5 deletions(-) > > diff --git a/drivers/media/platform/vsp1/vsp1_dl.c > b/drivers/media/platform/vsp1/vsp1_dl.c index ad545aff4e35..f8e8c90f22bc > 100644 > --- a/drivers/media/platform/vsp1/vsp1_dl.c > +++ b/drivers/media/platform/vsp1/vsp1_dl.c > @@ -557,9 +557,10 @@ void vsp1_dlm_irq_display_start(struct vsp1_dl_manager > *dlm) > spin_unlock(&dlm->lock); > } > > -void vsp1_dlm_irq_frame_end(struct vsp1_dl_manager *dlm) > +int vsp1_dlm_irq_frame_end(struct vsp1_dl_manager *dlm) > { > struct vsp1_device *vsp1 = dlm->vsp1; > + int ret = 0; > > spin_lock(&dlm->lock); > > @@ -578,8 +579,10 @@ void vsp1_dlm_irq_frame_end(struct vsp1_dl_manager > *dlm) * before interrupt processing. The hardware hasn't taken the update * > into account yet, we'll thus skip one frame and retry. > */ > - if (vsp1_read(vsp1, VI6_DL_BODY_SIZE) & VI6_DL_BODY_SIZE_UPD) > + if (vsp1_read(vsp1, VI6_DL_BODY_SIZE) & VI6_DL_BODY_SIZE_UPD) { > + ret = -EBUSY; Getting there, but not quite :-) What we need to protect against is the display list not being committed early enough, resulting in one frame skip in the hardware. The good news is that the driver already detects the opposite condition just below. > goto done; > + } > > /* The device starts processing the queued display list right after the > * frame end interrupt. The display list thus becomes active. This is what we want to report. You can simply return a bool that will tell whether the previous display list has completed at frame end. You should return true when the condition right below this comment is true, as well as when using header mode (to avoid breaking mem-to-mem pipelines), and false in all other cases. > @@ -606,6 +609,8 @@ void vsp1_dlm_irq_frame_end(struct vsp1_dl_manager *dlm) > > done: > spin_unlock(&dlm->lock); > + > + return ret; > } > > /* Hardware Setup */ > diff --git a/drivers/media/platform/vsp1/vsp1_dl.h > b/drivers/media/platform/vsp1/vsp1_dl.h index 7131aa3c5978..c772a1d92513 > 100644 > --- a/drivers/media/platform/vsp1/vsp1_dl.h > +++ b/drivers/media/platform/vsp1/vsp1_dl.h > @@ -28,7 +28,7 @@ struct vsp1_dl_manager *vsp1_dlm_create(struct vsp1_device > *vsp1, void vsp1_dlm_destroy(struct vsp1_dl_manager *dlm); > void vsp1_dlm_reset(struct vsp1_dl_manager *dlm); > void vsp1_dlm_irq_display_start(struct vsp1_dl_manager *dlm); > -void vsp1_dlm_irq_frame_end(struct vsp1_dl_manager *dlm); > +int vsp1_dlm_irq_frame_end(struct vsp1_dl_manager *dlm); > > struct vsp1_dl_list *vsp1_dl_list_get(struct vsp1_dl_manager *dlm); > void vsp1_dl_list_put(struct vsp1_dl_list *dl); > diff --git a/drivers/media/platform/vsp1/vsp1_drm.c > b/drivers/media/platform/vsp1/vsp1_drm.c index 85e5ebca82a5..6f2dd42ca01b > 100644 > --- a/drivers/media/platform/vsp1/vsp1_drm.c > +++ b/drivers/media/platform/vsp1/vsp1_drm.c > @@ -40,10 +40,12 @@ static void vsp1_du_pipeline_frame_end(struct > vsp1_pipeline *pipe) { > struct vsp1_drm *drm = to_vsp1_drm(pipe); > > - if (drm->du_complete && drm->du_pending) { > + if (drm->du_complete && drm->du_pending && !pipe->dl_postponed) { > drm->du_complete(drm->du_private); > drm->du_pending = false; > } > + > + pipe->dl_postponed = false; > } > > /* ------------------------------------------------------------------------ > diff --git a/drivers/media/platform/vsp1/vsp1_pipe.c > b/drivers/media/platform/vsp1/vsp1_pipe.c index 280ba0804699..3c5aae8767dd > 100644 > --- a/drivers/media/platform/vsp1/vsp1_pipe.c > +++ b/drivers/media/platform/vsp1/vsp1_pipe.c > @@ -297,10 +297,14 @@ bool vsp1_pipeline_ready(struct vsp1_pipeline *pipe) > > void vsp1_pipeline_frame_end(struct vsp1_pipeline *pipe) > { > + int ret; > + > if (pipe == NULL) > return; > > - vsp1_dlm_irq_frame_end(pipe->output->dlm); > + ret = vsp1_dlm_irq_frame_end(pipe->output->dlm); > + if (ret) > + pipe->dl_postponed = true; This can be simplified greatly. If vsp1_dlm_irq_frame_end() returns false, return immediately without calling the pipe->frame_end() handler or incrementing the sequence number, as the frame has not completed. You can then remove the dl_postponed field from the vsp1_pipeline structure and call the .du_complete() handler unconditionally in vsp1_du_pipeline_frame_end() (provided it's not NULL of course). As the vsp1_dlm_irq_frame_end() function can't return true if a commit hasn't been queued in the first place, there's no need for a dl_pending flag either. > > if (pipe->frame_end) > pipe->frame_end(pipe); > diff --git a/drivers/media/platform/vsp1/vsp1_pipe.h > b/drivers/media/platform/vsp1/vsp1_pipe.h index ac4ad2655551..65cc8fb76662 > 100644 > --- a/drivers/media/platform/vsp1/vsp1_pipe.h > +++ b/drivers/media/platform/vsp1/vsp1_pipe.h > @@ -77,6 +77,7 @@ enum vsp1_pipeline_state { > * @uds_input: entity at the input of the UDS, if the UDS is present > * @entities: list of entities in the pipeline > * @dl: display list associated with the pipeline > + * @dl_postponed: identifies if the dl commit was caught by a race > condition * @div_size: The maximum allowed partition size for the pipeline > * @partitions: The number of partitions used to process one frame * > @current_partition: The partition number currently being configured @@ > -107,6 +108,7 @@ struct vsp1_pipeline { > struct list_head entities; > > struct vsp1_dl_list *dl; > + bool dl_postponed; > > unsigned int div_size; > unsigned int partitions; -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v2 2/3] v4l: vsp1: Postpone page flip in event of display list race Date: Sun, 05 Mar 2017 01:46:57 +0200 Message-ID: <2000889.heoPCI45nc@avalon> References: <7b4ce1b20550d8651feceacf638ffc46be7400f7.1488592678.git-series.kieran.bingham+renesas@ideasonboard.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from galahad.ideasonboard.com (galahad.ideasonboard.com [IPv6:2001:4b98:dc2:45:216:3eff:febb:480d]) by gabe.freedesktop.org (Postfix) with ESMTPS id 134056E080 for ; Sat, 4 Mar 2017 23:46:23 +0000 (UTC) In-Reply-To: <7b4ce1b20550d8651feceacf638ffc46be7400f7.1488592678.git-series.kieran.bingham+renesas@ideasonboard.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Kieran Bingham Cc: linux-renesas-soc@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGkgS2llcmFuLAoKVGhhbmsgeW91IGZvciB0aGUgcGF0Y2guCgpPbiBTYXR1cmRheSAwNCBNYXIg MjAxNyAwMjowMToxOCBLaWVyYW4gQmluZ2hhbSB3cm90ZToKPiBJZiB3ZSB0cnkgdG8gY29tbWl0 IHRoZSBkaXNwbGF5IGxpc3Qgd2hpbGUgYW4gdXBkYXRlIGlzIHBlbmRpbmcsIHdlIGhhdmUKPiBt aXNzZWQgb3VyIG9wcG9ydHVuaXR5LiBUaGUgZGlzcGxheSBsaXN0IG1hbmFnZXIgd2lsbCBob2xk IHRoZSBjb21taXQKPiB1bnRpbCB0aGUgbmV4dCBpbnRlcnJ1cHQuCj4gCj4gSW4gdGhpcyBldmVu dCwgd2UgaW5mb3JtIHRoZSB2c3AxIGNvbXBsZXRpb24gY2FsbGJhY2sgaGFuZGxlciBzbyB0aGF0 Cj4gdGhlIGR1IHdpbGwgbm90IHBlcmZvcm0gYSBwYWdlIGZsaXAgb3V0IG9mIHR1cm4uCj4gCj4g U2lnbmVkLW9mZi1ieTogS2llcmFuIEJpbmdoYW0gPGtpZXJhbi5iaW5naGFtK3JlbmVzYXNAaWRl YXNvbmJvYXJkLmNvbT4KPiAtLS0KPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf ZGwuYyAgIHwgIDkgKysrKysrKy0tCj4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3Ax X2RsLmggICB8ICAyICstCj4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5j ICB8ICA0ICsrKy0KPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfcGlwZS5jIHwg IDYgKysrKystCj4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3BpcGUuaCB8ICAy ICsrCj4gIDUgZmlsZXMgY2hhbmdlZCwgMTggaW5zZXJ0aW9ucygrKSwgNSBkZWxldGlvbnMoLSkK PiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYwo+ IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYyBpbmRleCBhZDU0NWFmZjRl MzUuLmY4ZThjOTBmMjJiYwo+IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0v dnNwMS92c3AxX2RsLmMKPiArKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9k bC5jCj4gQEAgLTU1Nyw5ICs1NTcsMTAgQEAgdm9pZCB2c3AxX2RsbV9pcnFfZGlzcGxheV9zdGFy dChzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyCj4gKmRsbSkKPiAgCXNwaW5fdW5sb2NrKCZkbG0tPmxv Y2spOwo+ICB9Cj4gCj4gLXZvaWQgdnNwMV9kbG1faXJxX2ZyYW1lX2VuZChzdHJ1Y3QgdnNwMV9k bF9tYW5hZ2VyICpkbG0pCj4gK2ludCB2c3AxX2RsbV9pcnFfZnJhbWVfZW5kKHN0cnVjdCB2c3Ax X2RsX21hbmFnZXIgKmRsbSkKPiAgewo+ICAJc3RydWN0IHZzcDFfZGV2aWNlICp2c3AxID0gZGxt LT52c3AxOwo+ICsJaW50IHJldCA9IDA7Cj4gCj4gIAlzcGluX2xvY2soJmRsbS0+bG9jayk7Cj4g Cj4gQEAgLTU3OCw4ICs1NzksMTAgQEAgdm9pZCB2c3AxX2RsbV9pcnFfZnJhbWVfZW5kKHN0cnVj dCB2c3AxX2RsX21hbmFnZXIKPiAqZGxtKSAqIGJlZm9yZSBpbnRlcnJ1cHQgcHJvY2Vzc2luZy4g VGhlIGhhcmR3YXJlIGhhc24ndCB0YWtlbiB0aGUgdXBkYXRlICoKPiBpbnRvIGFjY291bnQgeWV0 LCB3ZSdsbCB0aHVzIHNraXAgb25lIGZyYW1lIGFuZCByZXRyeS4KPiAgCSAqLwo+IC0JaWYgKHZz cDFfcmVhZCh2c3AxLCBWSTZfRExfQk9EWV9TSVpFKSAmIFZJNl9ETF9CT0RZX1NJWkVfVVBEKQo+ ICsJaWYgKHZzcDFfcmVhZCh2c3AxLCBWSTZfRExfQk9EWV9TSVpFKSAmIFZJNl9ETF9CT0RZX1NJ WkVfVVBEKSB7Cj4gKwkJcmV0ID0gLUVCVVNZOwoKR2V0dGluZyB0aGVyZSwgYnV0IG5vdCBxdWl0 ZSA6LSkKCldoYXQgd2UgbmVlZCB0byBwcm90ZWN0IGFnYWluc3QgaXMgdGhlIGRpc3BsYXkgbGlz dCBub3QgYmVpbmcgY29tbWl0dGVkIGVhcmx5IAplbm91Z2gsIHJlc3VsdGluZyBpbiBvbmUgZnJh bWUgc2tpcCBpbiB0aGUgaGFyZHdhcmUuIFRoZSBnb29kIG5ld3MgaXMgdGhhdCB0aGUgCmRyaXZl ciBhbHJlYWR5IGRldGVjdHMgdGhlIG9wcG9zaXRlIGNvbmRpdGlvbiBqdXN0IGJlbG93LiAKCj4g IAkJZ290byBkb25lOwo+ICsJfQo+IAo+ICAJLyogVGhlIGRldmljZSBzdGFydHMgcHJvY2Vzc2lu ZyB0aGUgcXVldWVkIGRpc3BsYXkgbGlzdCByaWdodCBhZnRlciAKdGhlCj4gIAkgKiBmcmFtZSBl bmQgaW50ZXJydXB0LiBUaGUgZGlzcGxheSBsaXN0IHRodXMgYmVjb21lcyBhY3RpdmUuCgpUaGlz IGlzIHdoYXQgd2Ugd2FudCB0byByZXBvcnQuIFlvdSBjYW4gc2ltcGx5IHJldHVybiBhIGJvb2wg dGhhdCB3aWxsIHRlbGwgCndoZXRoZXIgdGhlIHByZXZpb3VzIGRpc3BsYXkgbGlzdCBoYXMgY29t cGxldGVkIGF0IGZyYW1lIGVuZC4gWW91IHNob3VsZCAKcmV0dXJuIHRydWUgd2hlbiB0aGUgY29u ZGl0aW9uIHJpZ2h0IGJlbG93IHRoaXMgY29tbWVudCBpcyB0cnVlLCBhcyB3ZWxsIGFzIAp3aGVu IHVzaW5nIGhlYWRlciBtb2RlICh0byBhdm9pZCBicmVha2luZyBtZW0tdG8tbWVtIHBpcGVsaW5l cyksIGFuZCBmYWxzZSBpbiAKYWxsIG90aGVyIGNhc2VzLgoKPiBAQCAtNjA2LDYgKzYwOSw4IEBA IHZvaWQgdnNwMV9kbG1faXJxX2ZyYW1lX2VuZChzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyICpkbG0p Cj4gCj4gIGRvbmU6Cj4gIAlzcGluX3VubG9jaygmZGxtLT5sb2NrKTsKPiArCj4gKwlyZXR1cm4g cmV0Owo+ICB9Cj4gCj4gIC8qIEhhcmR3YXJlIFNldHVwICovCj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmgKPiBiL2RyaXZlcnMvbWVkaWEvcGxhdGZv cm0vdnNwMS92c3AxX2RsLmggaW5kZXggNzEzMWFhM2M1OTc4Li5jNzcyYTFkOTI1MTMKPiAxMDA2 NDQKPiAtLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5oCj4gKysrIGIv ZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuaAo+IEBAIC0yOCw3ICsyOCw3IEBA IHN0cnVjdCB2c3AxX2RsX21hbmFnZXIgKnZzcDFfZGxtX2NyZWF0ZShzdHJ1Y3QgdnNwMV9kZXZp Y2UKPiAqdnNwMSwgdm9pZCB2c3AxX2RsbV9kZXN0cm95KHN0cnVjdCB2c3AxX2RsX21hbmFnZXIg KmRsbSk7Cj4gIHZvaWQgdnNwMV9kbG1fcmVzZXQoc3RydWN0IHZzcDFfZGxfbWFuYWdlciAqZGxt KTsKPiAgdm9pZCB2c3AxX2RsbV9pcnFfZGlzcGxheV9zdGFydChzdHJ1Y3QgdnNwMV9kbF9tYW5h Z2VyICpkbG0pOwo+IC12b2lkIHZzcDFfZGxtX2lycV9mcmFtZV9lbmQoc3RydWN0IHZzcDFfZGxf bWFuYWdlciAqZGxtKTsKPiAraW50IHZzcDFfZGxtX2lycV9mcmFtZV9lbmQoc3RydWN0IHZzcDFf ZGxfbWFuYWdlciAqZGxtKTsKPiAKPiAgc3RydWN0IHZzcDFfZGxfbGlzdCAqdnNwMV9kbF9saXN0 X2dldChzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyICpkbG0pOwo+ICB2b2lkIHZzcDFfZGxfbGlzdF9w dXQoc3RydWN0IHZzcDFfZGxfbGlzdCAqZGwpOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlh L3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uYwo+IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3Ax L3ZzcDFfZHJtLmMgaW5kZXggODVlNWViY2E4MmE1Li42ZjJkZDQyY2EwMWIKPiAxMDA2NDQKPiAt LS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uYwo+ICsrKyBiL2RyaXZl cnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5jCj4gQEAgLTQwLDEwICs0MCwxMiBAQCBz dGF0aWMgdm9pZCB2c3AxX2R1X3BpcGVsaW5lX2ZyYW1lX2VuZChzdHJ1Y3QKPiB2c3AxX3BpcGVs aW5lICpwaXBlKSB7Cj4gIAlzdHJ1Y3QgdnNwMV9kcm0gKmRybSA9IHRvX3ZzcDFfZHJtKHBpcGUp Owo+IAo+IC0JaWYgKGRybS0+ZHVfY29tcGxldGUgJiYgZHJtLT5kdV9wZW5kaW5nKSB7Cj4gKwlp ZiAoZHJtLT5kdV9jb21wbGV0ZSAmJiBkcm0tPmR1X3BlbmRpbmcgJiYgIXBpcGUtPmRsX3Bvc3Rw b25lZCkgewo+ICAJCWRybS0+ZHVfY29tcGxldGUoZHJtLT5kdV9wcml2YXRlKTsKPiAgCQlkcm0t PmR1X3BlbmRpbmcgPSBmYWxzZTsKPiAgCX0KPiArCj4gKwlwaXBlLT5kbF9wb3N0cG9uZWQgPSBm YWxzZTsKPiAgfQo+IAo+ICAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfcGlwZS5jCj4gYi9kcml2ZXJzL21lZGlhL3BsYXRm b3JtL3ZzcDEvdnNwMV9waXBlLmMgaW5kZXggMjgwYmEwODA0Njk5Li4zYzVhYWU4NzY3ZGQKPiAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9waXBlLmMKPiAr KysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9waXBlLmMKPiBAQCAtMjk3LDEw ICsyOTcsMTQgQEAgYm9vbCB2c3AxX3BpcGVsaW5lX3JlYWR5KHN0cnVjdCB2c3AxX3BpcGVsaW5l ICpwaXBlKQo+IAo+ICB2b2lkIHZzcDFfcGlwZWxpbmVfZnJhbWVfZW5kKHN0cnVjdCB2c3AxX3Bp cGVsaW5lICpwaXBlKQo+ICB7Cj4gKwlpbnQgcmV0Owo+ICsKPiAgCWlmIChwaXBlID09IE5VTEwp Cj4gIAkJcmV0dXJuOwo+IAo+IC0JdnNwMV9kbG1faXJxX2ZyYW1lX2VuZChwaXBlLT5vdXRwdXQt PmRsbSk7Cj4gKwlyZXQgPSB2c3AxX2RsbV9pcnFfZnJhbWVfZW5kKHBpcGUtPm91dHB1dC0+ZGxt KTsKPiArCWlmIChyZXQpCj4gKwkJcGlwZS0+ZGxfcG9zdHBvbmVkID0gdHJ1ZTsKClRoaXMgY2Fu IGJlIHNpbXBsaWZpZWQgZ3JlYXRseS4gSWYgdnNwMV9kbG1faXJxX2ZyYW1lX2VuZCgpIHJldHVy bnMgZmFsc2UsIApyZXR1cm4gaW1tZWRpYXRlbHkgd2l0aG91dCBjYWxsaW5nIHRoZSBwaXBlLT5m cmFtZV9lbmQoKSBoYW5kbGVyIG9yIAppbmNyZW1lbnRpbmcgdGhlIHNlcXVlbmNlIG51bWJlciwg YXMgdGhlIGZyYW1lIGhhcyBub3QgY29tcGxldGVkLiBZb3UgY2FuIHRoZW4gCnJlbW92ZSB0aGUg ZGxfcG9zdHBvbmVkIGZpZWxkIGZyb20gdGhlIHZzcDFfcGlwZWxpbmUgc3RydWN0dXJlIGFuZCBj YWxsIHRoZSAKLmR1X2NvbXBsZXRlKCkgaGFuZGxlciB1bmNvbmRpdGlvbmFsbHkgaW4gdnNwMV9k dV9waXBlbGluZV9mcmFtZV9lbmQoKSAKKHByb3ZpZGVkIGl0J3Mgbm90IE5VTEwgb2YgY291cnNl KS4gQXMgdGhlIHZzcDFfZGxtX2lycV9mcmFtZV9lbmQoKSBmdW5jdGlvbiAKY2FuJ3QgcmV0dXJu IHRydWUgaWYgYSBjb21taXQgaGFzbid0IGJlZW4gcXVldWVkIGluIHRoZSBmaXJzdCBwbGFjZSwg dGhlcmUncyAKbm8gbmVlZCBmb3IgYSBkbF9wZW5kaW5nIGZsYWcgZWl0aGVyLgoKPiAKPiAgCWlm IChwaXBlLT5mcmFtZV9lbmQpCj4gIAkJcGlwZS0+ZnJhbWVfZW5kKHBpcGUpOwo+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9waXBlLmgKPiBiL2RyaXZlcnMv bWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3BpcGUuaCBpbmRleCBhYzRhZDI2NTU1NTEuLjY1Y2M4 ZmI3NjY2Mgo+IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3Ax X3BpcGUuaAo+ICsrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3BpcGUuaAo+ IEBAIC03Nyw2ICs3Nyw3IEBAIGVudW0gdnNwMV9waXBlbGluZV9zdGF0ZSB7Cj4gICAqIEB1ZHNf aW5wdXQ6IGVudGl0eSBhdCB0aGUgaW5wdXQgb2YgdGhlIFVEUywgaWYgdGhlIFVEUyBpcyBwcmVz ZW50Cj4gICAqIEBlbnRpdGllczogbGlzdCBvZiBlbnRpdGllcyBpbiB0aGUgcGlwZWxpbmUKPiAg ICogQGRsOiBkaXNwbGF5IGxpc3QgYXNzb2NpYXRlZCB3aXRoIHRoZSBwaXBlbGluZQo+ICsgKiBA ZGxfcG9zdHBvbmVkOiBpZGVudGlmaWVzIGlmIHRoZSBkbCBjb21taXQgd2FzIGNhdWdodCBieSBh IHJhY2UKPiBjb25kaXRpb24gKiBAZGl2X3NpemU6IFRoZSBtYXhpbXVtIGFsbG93ZWQgcGFydGl0 aW9uIHNpemUgZm9yIHRoZSBwaXBlbGluZQo+ICogQHBhcnRpdGlvbnM6IFRoZSBudW1iZXIgb2Yg cGFydGl0aW9ucyB1c2VkIHRvIHByb2Nlc3Mgb25lIGZyYW1lICoKPiBAY3VycmVudF9wYXJ0aXRp b246IFRoZSBwYXJ0aXRpb24gbnVtYmVyIGN1cnJlbnRseSBiZWluZyBjb25maWd1cmVkIEBACj4g LTEwNyw2ICsxMDgsNyBAQCBzdHJ1Y3QgdnNwMV9waXBlbGluZSB7Cj4gIAlzdHJ1Y3QgbGlzdF9o ZWFkIGVudGl0aWVzOwo+IAo+ICAJc3RydWN0IHZzcDFfZGxfbGlzdCAqZGw7Cj4gKwlib29sIGRs X3Bvc3Rwb25lZDsKPiAKPiAgCXVuc2lnbmVkIGludCBkaXZfc2l6ZTsKPiAgCXVuc2lnbmVkIGlu dCBwYXJ0aXRpb25zOwoKLS0gClJlZ2FyZHMsCgpMYXVyZW50IFBpbmNoYXJ0CgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBs aXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVz a3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK