From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from galahad.ideasonboard.com ([185.26.127.97]:39352 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751350AbdGNAan (ORCPT ); Thu, 13 Jul 2017 20:30:43 -0400 From: Laurent Pinchart To: kieran.bingham@ideasonboard.com Cc: Laurent Pinchart , dri-devel@lists.freedesktop.org, linux-renesas-soc@vger.kernel.org Subject: Re: [PATCH] drm: rcar-du: Setup planes before enabling CRTC to avoid flicker Date: Fri, 14 Jul 2017 03:30:45 +0300 Message-ID: <1925845.hJTmtBTYaG@avalon> In-Reply-To: <9120be80-cefe-e52a-e512-15145ded1e82@ideasonboard.com> References: <20170628185055.16379-1-laurent.pinchart+renesas@ideasonboard.com> <9120be80-cefe-e52a-e512-15145ded1e82@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, On Wednesday 12 Jul 2017 17:35:53 Kieran Bingham wrote: > On 28/06/17 19:50, Laurent Pinchart wrote: > > Commit 52055bafa1ff ("drm: rcar-du: Move plane commit code from CRTC > > start to CRTC resume") changed the order of the plane commit and CRTC > > enable operations to accommodate the runtime PM requirements. However, > > this introduced corruption in the first displayed frame, as the CRTC is > > now enabled without any plane configured. On Gen2 hardware the first > > frame will be black and likely unnoticed, but on Gen3 hardware we end up > > starting the display before the VSP compositor, which is more > > noticeable. > > > > To fix this, revert the order of the commit operations back, and handle > > runtime PM requirements in the CRTC .atomic_begin() and .atomic_enable() > > helper operation handlers. > > > > Signed-off-by: Laurent Pinchart > > > > I only have code reduction or comment suggestions below - so either with or > without those changes, feel free to add my: > > Reviewed-by: Kieran Bingham > > > --- > > > > drivers/gpu/drm/rcar-du/rcar_du_crtc.c | 66 +++++++++++++++++------------ > > drivers/gpu/drm/rcar-du/rcar_du_crtc.h | 4 +-- > > drivers/gpu/drm/rcar-du/rcar_du_kms.c | 2 +- > > 3 files changed, 43 insertions(+), 29 deletions(-) > > > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_crtc.c > > b/drivers/gpu/drm/rcar-du/rcar_du_crtc.c index 6b5219ef0ad2..76cdb88b2b8e > > 100644 > > --- a/drivers/gpu/drm/rcar-du/rcar_du_crtc.c > > +++ b/drivers/gpu/drm/rcar-du/rcar_du_crtc.c [snip] > > @@ -467,6 +461,18 @@ static void rcar_du_crtc_start(struct rcar_du_crtc > > *rcrtc) > > /* Start with all planes disabled. */ > > rcar_du_group_write(rcrtc->group, rcrtc->index % 2 ? DS2PR : DS1PR, 0); > > > > + /* Enable the VSP compositor. */ > > + if (rcar_du_has(rcrtc->group->dev, RCAR_DU_FEATURE_VSP1_SOURCE)) > > + rcar_du_vsp_enable(rcrtc); > > + > > + /* Turn vertical blanking interrupt reporting on. */ > > + drm_crtc_vblank_on(&rcrtc->crtc); > > +} > > + > > +static void rcar_du_crtc_start(struct rcar_du_crtc *rcrtc) > > +{ > > + bool interlaced; > > + > > /* Select master sync mode. This enables display operation in master > > Are we close enough here to fix this multiline comment style ? > (Not worth doing unless the patch is respun for other reasons ...) > > Actually - there are a lot in this file, so it would be better to do them > all in one hit/patch at a point of least conflicts ... Done :-) I actually had such a patch in my tree before receiving your comment. > > * sync mode (with the HSYNC and VSYNC signals configured as outputs and > > * actively driven). [snip] > > @@ -546,12 +538,10 @@ void rcar_du_crtc_resume(struct rcar_du_crtc *rcrtc) > > return; > > > > rcar_du_crtc_get(rcrtc); > > - rcar_du_crtc_start(rcrtc); > > + rcar_du_crtc_setup(rcrtc); > > Every call to _setup is immediately prefixed by a call to _get() > > Could the _get() be done in the _setup() for code reduction? > > I'm entirely open to that not happening here as it might be preferred to > keep the _get() and _start() separate for style purposes. Please see below. > > /* Commit the planes state. */ > > - if (rcar_du_has(rcrtc->group->dev, RCAR_DU_FEATURE_VSP1_SOURCE)) { > > - rcar_du_vsp_enable(rcrtc); > > - } else { > > + if (!rcar_du_has(rcrtc->group->dev, RCAR_DU_FEATURE_VSP1_SOURCE)) { > > for (i = 0; i < rcrtc->group->num_planes; ++i) { > > struct rcar_du_plane *plane = &rcrtc->group->planes[i]; > > [snip] > > @@ -601,6 +602,19 @@ static void rcar_du_crtc_atomic_begin(struct drm_crtc > > *crtc, > > { > > struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc); > > > > + WARN_ON(!crtc->state->enable); > > Is this necessary if it's handled by the rcrtc->initialized flag? or is it > so that we find out if it happens ? > > (Or is this due to the re-ordering of the _commit_tail() function below?) It's to find out whether it happens. Before this patch the plane update occurred after enabling the CRTC (through drm_atomic_helper_commit_modeset_enables()). With this patch the CRTC can be disabled at the hardware level, but only if it will be enabled right after plane update. The state->enable flag should thus always be true, and I added a WARN_ON to ensure that. I'd like to keep it a bit, we can remove it after running more tests. > > + > > + /* > > + * If a mode set is in progress we can be called with the CRTC disabled. > > + * We then need to first setup the CRTC in order to configure planes. > > + * The .atomic_enable() handler will notice and skip the CRTC setup. > > + */ > > I'm assuming this comment is the reason for the WARN_ON above ... > > > + if (!rcrtc->initialized) { > > + rcar_du_crtc_get(rcrtc); > > + rcar_du_crtc_setup(rcrtc); > > + rcrtc->initialized = true; > > + } > > If the _get() was moved into the _setup(), and _setup() was protected by the > rcrtc->initialized flag, then _atomic_begin() _enable() and _resume() could > all just simply call _setup(). The _resume() should only ever be called > with rcrtc->initialized = false anyway, as that is set in _suspend() I think that makes sense, but I wonder whether it would make sense to address that when fixing the currently broken suspend/resume code, as I expect the get/setup/start sequence to be reworked then. To help you decide, here's what we would merge now on top of this patch if we don't wait. -------------------------------------- 8< ------------------------------------commit 4e43b3a5400e40e8ef7ecc50640a2ca77fb8effa Author: Laurent Pinchart Date: Fri Jul 14 03:26:17 2017 +0300 drm: rcar-du: Perform the initial CRTC setup from rcar_du_crtc_get() The rcar_du_crtc_get() function is always immediately followed by a call to rcar_du_crtc_setup(). Call the later from the former to simplify the code, and add a comment to explain how the get and put calls are balanced. Signed-off-by: Laurent Pinchart diff --git a/drivers/gpu/drm/rcar-du/rcar_du_crtc.c b/drivers/gpu/drm/rcar-du/rcar_du_crtc.c index 98cf446391dc..e29d8d494720 100644 --- a/drivers/gpu/drm/rcar-du/rcar_du_crtc.c +++ b/drivers/gpu/drm/rcar-du/rcar_du_crtc.c @@ -70,39 +70,6 @@ static void rcar_du_crtc_clr_set(struct rcar_du_crtc *rcrtc, u32 reg, rcar_du_write(rcdu, rcrtc->mmio_offset + reg, (value & ~clr) | set); } -static int rcar_du_crtc_get(struct rcar_du_crtc *rcrtc) -{ - int ret; - - ret = clk_prepare_enable(rcrtc->clock); - if (ret < 0) - return ret; - - ret = clk_prepare_enable(rcrtc->extclock); - if (ret < 0) - goto error_clock; - - ret = rcar_du_group_get(rcrtc->group); - if (ret < 0) - goto error_group; - - return 0; - -error_group: - clk_disable_unprepare(rcrtc->extclock); -error_clock: - clk_disable_unprepare(rcrtc->clock); - return ret; -} - -static void rcar_du_crtc_put(struct rcar_du_crtc *rcrtc) -{ - rcar_du_group_put(rcrtc->group); - - clk_disable_unprepare(rcrtc->extclock); - clk_disable_unprepare(rcrtc->clock); -} - /* ----------------------------------------------------------------------------- * Hardware Setup */ @@ -473,6 +440,49 @@ static void rcar_du_crtc_setup(struct rcar_du_crtc *rcrtc) drm_crtc_vblank_on(&rcrtc->crtc); } +static int rcar_du_crtc_get(struct rcar_du_crtc *rcrtc) +{ + int ret; + + /* + * Guard against double-get, as the function is called from both the + * .atomic_enable() and .atomic_begin() handlers. + */ + if (rcrtc->initialized) + return 0; + + ret = clk_prepare_enable(rcrtc->clock); + if (ret < 0) + return ret; + + ret = clk_prepare_enable(rcrtc->extclock); + if (ret < 0) + goto error_clock; + + ret = rcar_du_group_get(rcrtc->group); + if (ret < 0) + goto error_group; + + rcar_du_crtc_setup(rcrtc); + rcrtc->initialized = true; + + return 0; + +error_group: + clk_disable_unprepare(rcrtc->extclock); +error_clock: + clk_disable_unprepare(rcrtc->clock); + return ret; +} + +static void rcar_du_crtc_put(struct rcar_du_crtc *rcrtc) +{ + rcar_du_group_put(rcrtc->group); + + clk_disable_unprepare(rcrtc->extclock); + clk_disable_unprepare(rcrtc->clock); +} + static void rcar_du_crtc_start(struct rcar_du_crtc *rcrtc) { bool interlaced; @@ -546,7 +556,6 @@ void rcar_du_crtc_resume(struct rcar_du_crtc *rcrtc) return; rcar_du_crtc_get(rcrtc); - rcar_du_crtc_setup(rcrtc); /* Commit the planes state. */ if (!rcar_du_has(rcrtc->group->dev, RCAR_DU_FEATURE_VSP1_SOURCE)) { @@ -573,16 +582,7 @@ static void rcar_du_crtc_atomic_enable(struct drm_crtc *crtc, { struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc); - /* - * If the CRTC has already been setup by the .atomic_begin() handler we - * can skip the setup stage. - */ - if (!rcrtc->initialized) { - rcar_du_crtc_get(rcrtc); - rcar_du_crtc_setup(rcrtc); - rcrtc->initialized = true; - } - + rcar_du_crtc_get(rcrtc); rcar_du_crtc_start(rcrtc); } @@ -614,14 +614,17 @@ static void rcar_du_crtc_atomic_begin(struct drm_crtc *crtc, /* * If a mode set is in progress we can be called with the CRTC disabled. - * We then need to first setup the CRTC in order to configure planes. - * The .atomic_enable() handler will notice and skip the CRTC setup. + * We thus need to first get and setup the CRTC in order to configure + * planes. We must *not* put the CRTC in .atomic_flush(), as it must be + * kept awake until the .atomic_enable() call that will follow. The get + * operation in .atomic_enable() will in that case be a no-op, and the + * CRTC will be put later in .atomic_disable(). + * + * If a mode set is not in progress the CRTC is enabled, and the + * following get call will be a no-op. There is thus no need to belance + * it in .atomic_flush() either. */ - if (!rcrtc->initialized) { - rcar_du_crtc_get(rcrtc); - rcar_du_crtc_setup(rcrtc); - rcrtc->initialized = true; - } + rcar_du_crtc_get(rcrtc); if (rcar_du_has(rcrtc->group->dev, RCAR_DU_FEATURE_VSP1_SOURCE)) rcar_du_vsp_atomic_begin(rcrtc); -------------------------------------- 8< ------------------------------------ > > + > > if (rcar_du_has(rcrtc->group->dev, RCAR_DU_FEATURE_VSP1_SOURCE)) > > rcar_du_vsp_atomic_begin(rcrtc); > > } [snip] > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_kms.c > > b/drivers/gpu/drm/rcar-du/rcar_du_kms.c index 82b978a5dae6..c2f382feca07 > > 100644 > > --- a/drivers/gpu/drm/rcar-du/rcar_du_kms.c > > +++ b/drivers/gpu/drm/rcar-du/rcar_du_kms.c > > @@ -255,9 +255,9 @@ static void rcar_du_atomic_commit_tail(struct > > drm_atomic_state *old_state) > > > > /* Apply the atomic update. */ > > drm_atomic_helper_commit_modeset_disables(dev, old_state); > > - drm_atomic_helper_commit_modeset_enables(dev, old_state); > > drm_atomic_helper_commit_planes(dev, old_state, > > DRM_PLANE_COMMIT_ACTIVE_ONLY); > > Except for DRM_PLANE_COMMIT_ACTIVE_ONLY, this function now looks very much > like the default drm_atomic_helper_commit_tail() code. > > Reading around other uses /variants of commit_tail() style functions in > other drivers has left me confused as to how the ordering affects things > here. > > Could be worth adding a comment at least to describe why we can't use the > default helper... The first reason, as you mentioned, is DRM_PLANE_COMMIT_ACTIVE_ONLY, as we don't need to receive plane updates for disabled CRTCs. The second reason is patch "[PATCH] drm: rcar-du: Wait for flip completion instead of vblank in commit tail" that I have just submitted, which replaces the drm_atomic_helper_wait_for_vblanks() call with drm_atomic_helper_wait_flip_done(). I can add a comment to that patch if you think that would be helpful. > > + drm_atomic_helper_commit_modeset_enables(dev, old_state); > > > > drm_atomic_helper_commit_hw_done(old_state); > > drm_atomic_helper_wait_for_vblanks(dev, old_state); -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH] drm: rcar-du: Setup planes before enabling CRTC to avoid flicker Date: Fri, 14 Jul 2017 03:30:45 +0300 Message-ID: <1925845.hJTmtBTYaG@avalon> References: <20170628185055.16379-1-laurent.pinchart+renesas@ideasonboard.com> <9120be80-cefe-e52a-e512-15145ded1e82@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 0D4326E0F9 for ; Fri, 14 Jul 2017 00:30:42 +0000 (UTC) In-Reply-To: <9120be80-cefe-e52a-e512-15145ded1e82@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@ideasonboard.com Cc: linux-renesas-soc@vger.kernel.org, Laurent Pinchart , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org SGkgS2llcmFuLAoKT24gV2VkbmVzZGF5IDEyIEp1bCAyMDE3IDE3OjM1OjUzIEtpZXJhbiBCaW5n aGFtIHdyb3RlOgo+IE9uIDI4LzA2LzE3IDE5OjUwLCBMYXVyZW50IFBpbmNoYXJ0IHdyb3RlOgo+ ID4gQ29tbWl0IDUyMDU1YmFmYTFmZiAoImRybTogcmNhci1kdTogTW92ZSBwbGFuZSBjb21taXQg Y29kZSBmcm9tIENSVEMKPiA+IHN0YXJ0IHRvIENSVEMgcmVzdW1lIikgY2hhbmdlZCB0aGUgb3Jk ZXIgb2YgdGhlIHBsYW5lIGNvbW1pdCBhbmQgQ1JUQwo+ID4gZW5hYmxlIG9wZXJhdGlvbnMgdG8g YWNjb21tb2RhdGUgdGhlIHJ1bnRpbWUgUE0gcmVxdWlyZW1lbnRzLiBIb3dldmVyLAo+ID4gdGhp cyBpbnRyb2R1Y2VkIGNvcnJ1cHRpb24gaW4gdGhlIGZpcnN0IGRpc3BsYXllZCBmcmFtZSwgYXMg dGhlIENSVEMgaXMKPiA+IG5vdyBlbmFibGVkIHdpdGhvdXQgYW55IHBsYW5lIGNvbmZpZ3VyZWQu IE9uIEdlbjIgaGFyZHdhcmUgdGhlIGZpcnN0Cj4gPiBmcmFtZSB3aWxsIGJlIGJsYWNrIGFuZCBs aWtlbHkgdW5ub3RpY2VkLCBidXQgb24gR2VuMyBoYXJkd2FyZSB3ZSBlbmQgdXAKPiA+IHN0YXJ0 aW5nIHRoZSBkaXNwbGF5IGJlZm9yZSB0aGUgVlNQIGNvbXBvc2l0b3IsIHdoaWNoIGlzIG1vcmUK PiA+IG5vdGljZWFibGUuCj4gPiAKPiA+IFRvIGZpeCB0aGlzLCByZXZlcnQgdGhlIG9yZGVyIG9m IHRoZSBjb21taXQgb3BlcmF0aW9ucyBiYWNrLCBhbmQgaGFuZGxlCj4gPiBydW50aW1lIFBNIHJl cXVpcmVtZW50cyBpbiB0aGUgQ1JUQyAuYXRvbWljX2JlZ2luKCkgYW5kIC5hdG9taWNfZW5hYmxl KCkKPiA+IGhlbHBlciBvcGVyYXRpb24gaGFuZGxlcnMuCj4gPiAKPiA+IFNpZ25lZC1vZmYtYnk6 IExhdXJlbnQgUGluY2hhcnQKPiA+IDxsYXVyZW50LnBpbmNoYXJ0K3JlbmVzYXNAaWRlYXNvbmJv YXJkLmNvbT4KPiAKPiBJIG9ubHkgaGF2ZSBjb2RlIHJlZHVjdGlvbiBvciBjb21tZW50IHN1Z2dl c3Rpb25zIGJlbG93IC0gc28gZWl0aGVyIHdpdGggb3IKPiB3aXRob3V0IHRob3NlIGNoYW5nZXMs IGZlZWwgZnJlZSB0byBhZGQgbXk6Cj4gCj4gUmV2aWV3ZWQtYnk6IEtpZXJhbiBCaW5naGFtIDxr aWVyYW4uYmluZ2hhbStyZW5lc2FzQGlkZWFzb25ib2FyZC5jb20+Cj4gCj4gPiAtLS0KPiA+IAo+ ID4gIGRyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5jIHwgNjYgKysrKysrKysr KysrKysrKystLS0tLS0tLS0tLS0KPiA+ICBkcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1 X2NydGMuaCB8ICA0ICstLQo+ID4gIGRyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfa21z LmMgIHwgIDIgKy0KPiA+ICAzIGZpbGVzIGNoYW5nZWQsIDQzIGluc2VydGlvbnMoKyksIDI5IGRl bGV0aW9ucygtKQo+ID4gCj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUv cmNhcl9kdV9jcnRjLmMKPiA+IGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9jcnRj LmMgaW5kZXggNmI1MjE5ZWYwYWQyLi43NmNkYjg4YjJiOGUKPiA+IDEwMDY0NAo+ID4gLS0tIGEv ZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9jcnRjLmMKPiA+ICsrKyBiL2RyaXZlcnMv Z3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5jCgpbc25pcF0KCj4gPiBAQCAtNDY3LDYgKzQ2 MSwxOCBAQCBzdGF0aWMgdm9pZCByY2FyX2R1X2NydGNfc3RhcnQoc3RydWN0IHJjYXJfZHVfY3J0 Ywo+ID4gKnJjcnRjKQo+ID4gIAkvKiBTdGFydCB3aXRoIGFsbCBwbGFuZXMgZGlzYWJsZWQuICov Cj4gPiAgCXJjYXJfZHVfZ3JvdXBfd3JpdGUocmNydGMtPmdyb3VwLCByY3J0Yy0+aW5kZXggJSAy ID8gRFMyUFIgOiBEUzFQUiwgMCk7Cj4gPiAKPiA+ICsJLyogRW5hYmxlIHRoZSBWU1AgY29tcG9z aXRvci4gKi8KPiA+ICsJaWYgKHJjYXJfZHVfaGFzKHJjcnRjLT5ncm91cC0+ZGV2LCBSQ0FSX0RV X0ZFQVRVUkVfVlNQMV9TT1VSQ0UpKQo+ID4gKwkJcmNhcl9kdV92c3BfZW5hYmxlKHJjcnRjKTsK PiA+ICsKPiA+ICsJLyogVHVybiB2ZXJ0aWNhbCBibGFua2luZyBpbnRlcnJ1cHQgcmVwb3J0aW5n IG9uLiAqLwo+ID4gKwlkcm1fY3J0Y192Ymxhbmtfb24oJnJjcnRjLT5jcnRjKTsKPiA+ICt9Cj4g PiArCj4gPiArc3RhdGljIHZvaWQgcmNhcl9kdV9jcnRjX3N0YXJ0KHN0cnVjdCByY2FyX2R1X2Ny dGMgKnJjcnRjKQo+ID4gK3sKPiA+ICsJYm9vbCBpbnRlcmxhY2VkOwo+ID4gKwo+ID4gIAkvKiBT ZWxlY3QgbWFzdGVyIHN5bmMgbW9kZS4gVGhpcyBlbmFibGVzIGRpc3BsYXkgb3BlcmF0aW9uIGlu IG1hc3Rlcgo+IAo+IEFyZSB3ZSBjbG9zZSBlbm91Z2ggaGVyZSB0byBmaXggdGhpcyBtdWx0aWxp bmUgY29tbWVudCBzdHlsZSA/Cj4gKE5vdCB3b3J0aCBkb2luZyB1bmxlc3MgdGhlIHBhdGNoIGlz IHJlc3B1biBmb3Igb3RoZXIgcmVhc29ucyAuLi4pCj4gCj4gQWN0dWFsbHkgLSB0aGVyZSBhcmUg YSBsb3QgaW4gdGhpcyBmaWxlLCBzbyBpdCB3b3VsZCBiZSBiZXR0ZXIgdG8gZG8gdGhlbQo+IGFs bCBpbiBvbmUgaGl0L3BhdGNoIGF0IGEgcG9pbnQgb2YgbGVhc3QgY29uZmxpY3RzIC4uLgoKRG9u ZSA6LSkgSSBhY3R1YWxseSBoYWQgc3VjaCBhIHBhdGNoIGluIG15IHRyZWUgYmVmb3JlIHJlY2Vp dmluZyB5b3VyIGNvbW1lbnQuCgo+ID4gIAkgKiBzeW5jIG1vZGUgKHdpdGggdGhlIEhTWU5DIGFu ZCBWU1lOQyBzaWduYWxzIGNvbmZpZ3VyZWQgYXMgb3V0cHV0cyBhbmQKPiA+ICAJICogYWN0aXZl bHkgZHJpdmVuKS4KCltzbmlwXQoKPiA+IEBAIC01NDYsMTIgKzUzOCwxMCBAQCB2b2lkIHJjYXJf ZHVfY3J0Y19yZXN1bWUoc3RydWN0IHJjYXJfZHVfY3J0YyAqcmNydGMpCj4gPiAgCQlyZXR1cm47 Cj4gPiAgCQo+ID4gIAlyY2FyX2R1X2NydGNfZ2V0KHJjcnRjKTsKPiA+IC0JcmNhcl9kdV9jcnRj X3N0YXJ0KHJjcnRjKTsKPiA+ICsJcmNhcl9kdV9jcnRjX3NldHVwKHJjcnRjKTsKPiAKPiBFdmVy eSBjYWxsIHRvIF9zZXR1cCBpcyBpbW1lZGlhdGVseSBwcmVmaXhlZCBieSBhIGNhbGwgdG8gX2dl dCgpCj4gCj4gQ291bGQgdGhlIF9nZXQoKSBiZSBkb25lIGluIHRoZSBfc2V0dXAoKSBmb3IgY29k ZSByZWR1Y3Rpb24/Cj4gCj4gSSdtIGVudGlyZWx5IG9wZW4gdG8gdGhhdCBub3QgaGFwcGVuaW5n IGhlcmUgYXMgaXQgbWlnaHQgYmUgcHJlZmVycmVkIHRvCj4ga2VlcCB0aGUgX2dldCgpIGFuZCBf c3RhcnQoKSBzZXBhcmF0ZSBmb3Igc3R5bGUgcHVycG9zZXMuCgpQbGVhc2Ugc2VlIGJlbG93LgoK PiA+ICAJLyogQ29tbWl0IHRoZSBwbGFuZXMgc3RhdGUuICovCj4gPiAtCWlmIChyY2FyX2R1X2hh cyhyY3J0Yy0+Z3JvdXAtPmRldiwgUkNBUl9EVV9GRUFUVVJFX1ZTUDFfU09VUkNFKSkgewo+ID4g LQkJcmNhcl9kdV92c3BfZW5hYmxlKHJjcnRjKTsKPiA+IC0JfSBlbHNlIHsKPiA+ICsJaWYgKCFy Y2FyX2R1X2hhcyhyY3J0Yy0+Z3JvdXAtPmRldiwgUkNBUl9EVV9GRUFUVVJFX1ZTUDFfU09VUkNF KSkgewo+ID4gIAkJZm9yIChpID0gMDsgaSA8IHJjcnRjLT5ncm91cC0+bnVtX3BsYW5lczsgKytp KSB7Cj4gPiAgCQkJc3RydWN0IHJjYXJfZHVfcGxhbmUgKnBsYW5lID0gJnJjcnRjLT5ncm91cC0+ cGxhbmVzW2ldOwo+ID4gCgpbc25pcF0KCj4gPiBAQCAtNjAxLDYgKzYwMiwxOSBAQCBzdGF0aWMg dm9pZCByY2FyX2R1X2NydGNfYXRvbWljX2JlZ2luKHN0cnVjdCBkcm1fY3J0Ywo+ID4gKmNydGMs Cj4gPiAgewo+ID4gIAlzdHJ1Y3QgcmNhcl9kdV9jcnRjICpyY3J0YyA9IHRvX3JjYXJfY3J0Yyhj cnRjKTsKPiA+IAo+ID4gKwlXQVJOX09OKCFjcnRjLT5zdGF0ZS0+ZW5hYmxlKTsKPiAKPiBJcyB0 aGlzIG5lY2Vzc2FyeSBpZiBpdCdzIGhhbmRsZWQgYnkgdGhlIHJjcnRjLT5pbml0aWFsaXplZCBm bGFnPyBvciBpcyBpdAo+IHNvIHRoYXQgd2UgZmluZCBvdXQgaWYgaXQgaGFwcGVucyA/Cj4gCj4g KE9yIGlzIHRoaXMgZHVlIHRvIHRoZSByZS1vcmRlcmluZyBvZiB0aGUgX2NvbW1pdF90YWlsKCkg ZnVuY3Rpb24gYmVsb3c/KQoKSXQncyB0byBmaW5kIG91dCB3aGV0aGVyIGl0IGhhcHBlbnMuIEJl Zm9yZSB0aGlzIHBhdGNoIHRoZSBwbGFuZSB1cGRhdGUKb2NjdXJyZWQgYWZ0ZXIgZW5hYmxpbmcg dGhlIENSVEMgKHRocm91Z2gKZHJtX2F0b21pY19oZWxwZXJfY29tbWl0X21vZGVzZXRfZW5hYmxl cygpKS4gV2l0aCB0aGlzIHBhdGNoIHRoZSBDUlRDIGNhbiBiZQpkaXNhYmxlZCBhdCB0aGUgaGFy ZHdhcmUgbGV2ZWwsIGJ1dCBvbmx5IGlmIGl0IHdpbGwgYmUgZW5hYmxlZCByaWdodCBhZnRlcgpw bGFuZSB1cGRhdGUuIFRoZSBzdGF0ZS0+ZW5hYmxlIGZsYWcgc2hvdWxkIHRodXMgYWx3YXlzIGJl IHRydWUsIGFuZCBJIGFkZGVkCmEgV0FSTl9PTiB0byBlbnN1cmUgdGhhdC4gSSdkIGxpa2UgdG8g a2VlcCBpdCBhIGJpdCwgd2UgY2FuIHJlbW92ZSBpdCBhZnRlcgpydW5uaW5nIG1vcmUgdGVzdHMu Cgo+ID4gKwo+ID4gKwkvKgo+ID4gKwkgKiBJZiBhIG1vZGUgc2V0IGlzIGluIHByb2dyZXNzIHdl IGNhbiBiZSBjYWxsZWQgd2l0aCB0aGUgQ1JUQyBkaXNhYmxlZC4KPiA+ICsJICogV2UgdGhlbiBu ZWVkIHRvIGZpcnN0IHNldHVwIHRoZSBDUlRDIGluIG9yZGVyIHRvIGNvbmZpZ3VyZSBwbGFuZXMu Cj4gPiArCSAqIFRoZSAuYXRvbWljX2VuYWJsZSgpIGhhbmRsZXIgd2lsbCBub3RpY2UgYW5kIHNr aXAgdGhlIENSVEMgc2V0dXAuCj4gPiArCSAqLwo+IAo+IEknbSBhc3N1bWluZyB0aGlzIGNvbW1l bnQgaXMgdGhlIHJlYXNvbiBmb3IgdGhlIFdBUk5fT04gYWJvdmUgLi4uCj4gCj4gPiArCWlmICgh cmNydGMtPmluaXRpYWxpemVkKSB7Cj4gPiArCQlyY2FyX2R1X2NydGNfZ2V0KHJjcnRjKTsKPiA+ ICsJCXJjYXJfZHVfY3J0Y19zZXR1cChyY3J0Yyk7Cj4gPiArCQlyY3J0Yy0+aW5pdGlhbGl6ZWQg PSB0cnVlOwo+ID4gKwl9Cj4gCj4gSWYgdGhlIF9nZXQoKSB3YXMgbW92ZWQgaW50byB0aGUgX3Nl dHVwKCksIGFuZCBfc2V0dXAoKSB3YXMgcHJvdGVjdGVkIGJ5IHRoZQo+IHJjcnRjLT5pbml0aWFs aXplZCBmbGFnLCB0aGVuIF9hdG9taWNfYmVnaW4oKSBfZW5hYmxlKCkgYW5kIF9yZXN1bWUoKSBj b3VsZAo+IGFsbCBqdXN0IHNpbXBseSBjYWxsIF9zZXR1cCgpLiBUaGUgX3Jlc3VtZSgpIHNob3Vs ZCBvbmx5IGV2ZXIgYmUgY2FsbGVkCj4gd2l0aCByY3J0Yy0+aW5pdGlhbGl6ZWQgPSBmYWxzZSBh bnl3YXksIGFzIHRoYXQgaXMgc2V0IGluIF9zdXNwZW5kKCkKCkkgdGhpbmsgdGhhdCBtYWtlcyBz ZW5zZSwgYnV0IEkgd29uZGVyIHdoZXRoZXIgaXQgd291bGQgbWFrZSBzZW5zZSB0byBhZGRyZXNz CnRoYXQgd2hlbiBmaXhpbmcgdGhlIGN1cnJlbnRseSBicm9rZW4gc3VzcGVuZC9yZXN1bWUgY29k ZSwgYXMgSSBleHBlY3QgdGhlCmdldC9zZXR1cC9zdGFydCBzZXF1ZW5jZSB0byBiZSByZXdvcmtl ZCB0aGVuLgoKVG8gaGVscCB5b3UgZGVjaWRlLCBoZXJlJ3Mgd2hhdCB3ZSB3b3VsZCBtZXJnZSBu b3cgb24gdG9wIG9mIHRoaXMgcGF0Y2ggaWYgd2UKZG9uJ3Qgd2FpdC4KCi0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIDg8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLWNvbW1pdCA0ZTQzYjNhNTQwMGU0MGU4ZWY3ZWNjNTA2NDBhMmNhNzdmYjhlZmZhCkF1 dGhvcjogTGF1cmVudCBQaW5jaGFydCA8bGF1cmVudC5waW5jaGFydCtyZW5lc2FzQGlkZWFzb25i b2FyZC5jb20+CkRhdGU6ICAgRnJpIEp1bCAxNCAwMzoyNjoxNyAyMDE3ICswMzAwCgogICAgZHJt OiByY2FyLWR1OiBQZXJmb3JtIHRoZSBpbml0aWFsIENSVEMgc2V0dXAgZnJvbSByY2FyX2R1X2Ny dGNfZ2V0KCkKICAgIAogICAgVGhlIHJjYXJfZHVfY3J0Y19nZXQoKSBmdW5jdGlvbiBpcyBhbHdh eXMgaW1tZWRpYXRlbHkgZm9sbG93ZWQgYnkgYSBjYWxsCiAgICB0byByY2FyX2R1X2NydGNfc2V0 dXAoKS4gQ2FsbCB0aGUgbGF0ZXIgZnJvbSB0aGUgZm9ybWVyIHRvIHNpbXBsaWZ5IHRoZQogICAg Y29kZSwgYW5kIGFkZCBhIGNvbW1lbnQgdG8gZXhwbGFpbiBob3cgdGhlIGdldCBhbmQgcHV0IGNh bGxzIGFyZQogICAgYmFsYW5jZWQuCiAgICAKICAgIFNpZ25lZC1vZmYtYnk6IExhdXJlbnQgUGlu Y2hhcnQgPGxhdXJlbnQucGluY2hhcnQrcmVuZXNhc0BpZGVhc29uYm9hcmQuY29tPgoKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5jIGIvZHJpdmVycy9n cHUvZHJtL3JjYXItZHUvcmNhcl9kdV9jcnRjLmMKaW5kZXggOThjZjQ0NjM5MWRjLi5lMjlkOGQ0 OTQ3MjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5j CisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5jCkBAIC03MCwzOSAr NzAsNiBAQCBzdGF0aWMgdm9pZCByY2FyX2R1X2NydGNfY2xyX3NldChzdHJ1Y3QgcmNhcl9kdV9j cnRjICpyY3J0YywgdTMyIHJlZywKIAlyY2FyX2R1X3dyaXRlKHJjZHUsIHJjcnRjLT5tbWlvX29m ZnNldCArIHJlZywgKHZhbHVlICYgfmNscikgfCBzZXQpOwogfQogCi1zdGF0aWMgaW50IHJjYXJf ZHVfY3J0Y19nZXQoc3RydWN0IHJjYXJfZHVfY3J0YyAqcmNydGMpCi17Ci0JaW50IHJldDsKLQot CXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShyY3J0Yy0+Y2xvY2spOwotCWlmIChyZXQgPCAwKQot CQlyZXR1cm4gcmV0OwotCi0JcmV0ID0gY2xrX3ByZXBhcmVfZW5hYmxlKHJjcnRjLT5leHRjbG9j ayk7Ci0JaWYgKHJldCA8IDApCi0JCWdvdG8gZXJyb3JfY2xvY2s7Ci0KLQlyZXQgPSByY2FyX2R1 X2dyb3VwX2dldChyY3J0Yy0+Z3JvdXApOwotCWlmIChyZXQgPCAwKQotCQlnb3RvIGVycm9yX2dy b3VwOwotCi0JcmV0dXJuIDA7Ci0KLWVycm9yX2dyb3VwOgotCWNsa19kaXNhYmxlX3VucHJlcGFy ZShyY3J0Yy0+ZXh0Y2xvY2spOwotZXJyb3JfY2xvY2s6Ci0JY2xrX2Rpc2FibGVfdW5wcmVwYXJl KHJjcnRjLT5jbG9jayk7Ci0JcmV0dXJuIHJldDsKLX0KLQotc3RhdGljIHZvaWQgcmNhcl9kdV9j cnRjX3B1dChzdHJ1Y3QgcmNhcl9kdV9jcnRjICpyY3J0YykKLXsKLQlyY2FyX2R1X2dyb3VwX3B1 dChyY3J0Yy0+Z3JvdXApOwotCi0JY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHJjcnRjLT5leHRjbG9j ayk7Ci0JY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHJjcnRjLT5jbG9jayk7Ci19Ci0KIC8qIC0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCiAgKiBIYXJkd2FyZSBTZXR1cAogICovCkBAIC00NzMsNiArNDQwLDQ5 IEBAIHN0YXRpYyB2b2lkIHJjYXJfZHVfY3J0Y19zZXR1cChzdHJ1Y3QgcmNhcl9kdV9jcnRjICpy Y3J0YykKIAlkcm1fY3J0Y192Ymxhbmtfb24oJnJjcnRjLT5jcnRjKTsKIH0KIAorc3RhdGljIGlu dCByY2FyX2R1X2NydGNfZ2V0KHN0cnVjdCByY2FyX2R1X2NydGMgKnJjcnRjKQoreworCWludCBy ZXQ7CisKKwkvKgorCSAqIEd1YXJkIGFnYWluc3QgZG91YmxlLWdldCwgYXMgdGhlIGZ1bmN0aW9u IGlzIGNhbGxlZCBmcm9tIGJvdGggdGhlCisJICogLmF0b21pY19lbmFibGUoKSBhbmQgLmF0b21p Y19iZWdpbigpIGhhbmRsZXJzLgorCSAqLworCWlmIChyY3J0Yy0+aW5pdGlhbGl6ZWQpCisJCXJl dHVybiAwOworCisJcmV0ID0gY2xrX3ByZXBhcmVfZW5hYmxlKHJjcnRjLT5jbG9jayk7CisJaWYg KHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlyZXQgPSBjbGtfcHJlcGFyZV9lbmFibGUocmNy dGMtPmV4dGNsb2NrKTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBlcnJvcl9jbG9jazsKKworCXJl dCA9IHJjYXJfZHVfZ3JvdXBfZ2V0KHJjcnRjLT5ncm91cCk7CisJaWYgKHJldCA8IDApCisJCWdv dG8gZXJyb3JfZ3JvdXA7CisKKwlyY2FyX2R1X2NydGNfc2V0dXAocmNydGMpOworCXJjcnRjLT5p bml0aWFsaXplZCA9IHRydWU7CisKKwlyZXR1cm4gMDsKKworZXJyb3JfZ3JvdXA6CisJY2xrX2Rp c2FibGVfdW5wcmVwYXJlKHJjcnRjLT5leHRjbG9jayk7CitlcnJvcl9jbG9jazoKKwljbGtfZGlz YWJsZV91bnByZXBhcmUocmNydGMtPmNsb2NrKTsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMg dm9pZCByY2FyX2R1X2NydGNfcHV0KHN0cnVjdCByY2FyX2R1X2NydGMgKnJjcnRjKQoreworCXJj YXJfZHVfZ3JvdXBfcHV0KHJjcnRjLT5ncm91cCk7CisKKwljbGtfZGlzYWJsZV91bnByZXBhcmUo cmNydGMtPmV4dGNsb2NrKTsKKwljbGtfZGlzYWJsZV91bnByZXBhcmUocmNydGMtPmNsb2NrKTsK K30KKwogc3RhdGljIHZvaWQgcmNhcl9kdV9jcnRjX3N0YXJ0KHN0cnVjdCByY2FyX2R1X2NydGMg KnJjcnRjKQogewogCWJvb2wgaW50ZXJsYWNlZDsKQEAgLTU0Niw3ICs1NTYsNiBAQCB2b2lkIHJj YXJfZHVfY3J0Y19yZXN1bWUoc3RydWN0IHJjYXJfZHVfY3J0YyAqcmNydGMpCiAJCXJldHVybjsK IAogCXJjYXJfZHVfY3J0Y19nZXQocmNydGMpOwotCXJjYXJfZHVfY3J0Y19zZXR1cChyY3J0Yyk7 CiAKIAkvKiBDb21taXQgdGhlIHBsYW5lcyBzdGF0ZS4gKi8KIAlpZiAoIXJjYXJfZHVfaGFzKHJj cnRjLT5ncm91cC0+ZGV2LCBSQ0FSX0RVX0ZFQVRVUkVfVlNQMV9TT1VSQ0UpKSB7CkBAIC01NzMs MTYgKzU4Miw3IEBAIHN0YXRpYyB2b2lkIHJjYXJfZHVfY3J0Y19hdG9taWNfZW5hYmxlKHN0cnVj dCBkcm1fY3J0YyAqY3J0YywKIHsKIAlzdHJ1Y3QgcmNhcl9kdV9jcnRjICpyY3J0YyA9IHRvX3Jj YXJfY3J0YyhjcnRjKTsKIAotCS8qCi0JICogSWYgdGhlIENSVEMgaGFzIGFscmVhZHkgYmVlbiBz ZXR1cCBieSB0aGUgLmF0b21pY19iZWdpbigpIGhhbmRsZXIgd2UKLQkgKiBjYW4gc2tpcCB0aGUg c2V0dXAgc3RhZ2UuCi0JICovCi0JaWYgKCFyY3J0Yy0+aW5pdGlhbGl6ZWQpIHsKLQkJcmNhcl9k dV9jcnRjX2dldChyY3J0Yyk7Ci0JCXJjYXJfZHVfY3J0Y19zZXR1cChyY3J0Yyk7Ci0JCXJjcnRj LT5pbml0aWFsaXplZCA9IHRydWU7Ci0JfQotCisJcmNhcl9kdV9jcnRjX2dldChyY3J0Yyk7CiAJ cmNhcl9kdV9jcnRjX3N0YXJ0KHJjcnRjKTsKIH0KIApAQCAtNjE0LDE0ICs2MTQsMTcgQEAgc3Rh dGljIHZvaWQgcmNhcl9kdV9jcnRjX2F0b21pY19iZWdpbihzdHJ1Y3QgZHJtX2NydGMgKmNydGMs CiAKIAkvKgogCSAqIElmIGEgbW9kZSBzZXQgaXMgaW4gcHJvZ3Jlc3Mgd2UgY2FuIGJlIGNhbGxl ZCB3aXRoIHRoZSBDUlRDIGRpc2FibGVkLgotCSAqIFdlIHRoZW4gbmVlZCB0byBmaXJzdCBzZXR1 cCB0aGUgQ1JUQyBpbiBvcmRlciB0byBjb25maWd1cmUgcGxhbmVzLgotCSAqIFRoZSAuYXRvbWlj X2VuYWJsZSgpIGhhbmRsZXIgd2lsbCBub3RpY2UgYW5kIHNraXAgdGhlIENSVEMgc2V0dXAuCisJ ICogV2UgdGh1cyBuZWVkIHRvIGZpcnN0IGdldCBhbmQgc2V0dXAgdGhlIENSVEMgaW4gb3JkZXIg dG8gY29uZmlndXJlCisJICogcGxhbmVzLiBXZSBtdXN0ICpub3QqIHB1dCB0aGUgQ1JUQyBpbiAu YXRvbWljX2ZsdXNoKCksIGFzIGl0IG11c3QgYmUKKwkgKiBrZXB0IGF3YWtlIHVudGlsIHRoZSAu YXRvbWljX2VuYWJsZSgpIGNhbGwgdGhhdCB3aWxsIGZvbGxvdy4gVGhlIGdldAorCSAqIG9wZXJh dGlvbiBpbiAuYXRvbWljX2VuYWJsZSgpIHdpbGwgaW4gdGhhdCBjYXNlIGJlIGEgbm8tb3AsIGFu ZCB0aGUKKwkgKiBDUlRDIHdpbGwgYmUgcHV0IGxhdGVyIGluIC5hdG9taWNfZGlzYWJsZSgpLgor CSAqCisJICogSWYgYSBtb2RlIHNldCBpcyBub3QgaW4gcHJvZ3Jlc3MgdGhlIENSVEMgaXMgZW5h YmxlZCwgYW5kIHRoZQorCSAqIGZvbGxvd2luZyBnZXQgY2FsbCB3aWxsIGJlIGEgbm8tb3AuIFRo ZXJlIGlzIHRodXMgbm8gbmVlZCB0byBiZWxhbmNlCisJICogaXQgaW4gLmF0b21pY19mbHVzaCgp IGVpdGhlci4KIAkgKi8KLQlpZiAoIXJjcnRjLT5pbml0aWFsaXplZCkgewotCQlyY2FyX2R1X2Ny dGNfZ2V0KHJjcnRjKTsKLQkJcmNhcl9kdV9jcnRjX3NldHVwKHJjcnRjKTsKLQkJcmNydGMtPmlu aXRpYWxpemVkID0gdHJ1ZTsKLQl9CisJcmNhcl9kdV9jcnRjX2dldChyY3J0Yyk7CiAKIAlpZiAo cmNhcl9kdV9oYXMocmNydGMtPmdyb3VwLT5kZXYsIFJDQVJfRFVfRkVBVFVSRV9WU1AxX1NPVVJD RSkpCiAJCXJjYXJfZHVfdnNwX2F0b21pY19iZWdpbihyY3J0Yyk7Ci0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tIDg8IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLQoKPiA+ICsKPiA+ICAJaWYgKHJjYXJfZHVfaGFzKHJjcnRjLT5ncm91cC0+ZGV2LCBSQ0FS X0RVX0ZFQVRVUkVfVlNQMV9TT1VSQ0UpKQo+ID4gIAkJcmNhcl9kdV92c3BfYXRvbWljX2JlZ2lu KHJjcnRjKTsKPiA+ICB9Cgpbc25pcF0KCj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L3JjYXItZHUvcmNhcl9kdV9rbXMuYwo+ID4gYi9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2Fy X2R1X2ttcy5jIGluZGV4IDgyYjk3OGE1ZGFlNi4uYzJmMzgyZmVjYTA3Cj4gPiAxMDA2NDQKPiA+ IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfa21zLmMKPiA+ICsrKyBiL2Ry aXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfa21zLmMKPiA+IEBAIC0yNTUsOSArMjU1LDkg QEAgc3RhdGljIHZvaWQgcmNhcl9kdV9hdG9taWNfY29tbWl0X3RhaWwoc3RydWN0Cj4gPiBkcm1f YXRvbWljX3N0YXRlICpvbGRfc3RhdGUpCj4gPiAKPiA+ICAJLyogQXBwbHkgdGhlIGF0b21pYyB1 cGRhdGUuICovCj4gPiAgCWRybV9hdG9taWNfaGVscGVyX2NvbW1pdF9tb2Rlc2V0X2Rpc2FibGVz KGRldiwgb2xkX3N0YXRlKTsKPiA+IC0JZHJtX2F0b21pY19oZWxwZXJfY29tbWl0X21vZGVzZXRf ZW5hYmxlcyhkZXYsIG9sZF9zdGF0ZSk7Cj4gPiAgCWRybV9hdG9taWNfaGVscGVyX2NvbW1pdF9w bGFuZXMoZGV2LCBvbGRfc3RhdGUsCj4gPiAgCQkJCQlEUk1fUExBTkVfQ09NTUlUX0FDVElWRV9P TkxZKTsKPiAKPiBFeGNlcHQgZm9yIERSTV9QTEFORV9DT01NSVRfQUNUSVZFX09OTFksIHRoaXMg ZnVuY3Rpb24gbm93IGxvb2tzIHZlcnkgbXVjaAo+IGxpa2UgdGhlIGRlZmF1bHQgZHJtX2F0b21p Y19oZWxwZXJfY29tbWl0X3RhaWwoKSBjb2RlLgo+IAo+IFJlYWRpbmcgYXJvdW5kIG90aGVyIHVz ZXMgL3ZhcmlhbnRzIG9mIGNvbW1pdF90YWlsKCkgc3R5bGUgZnVuY3Rpb25zIGluCj4gb3RoZXIg ZHJpdmVycyBoYXMgbGVmdCBtZSBjb25mdXNlZCBhcyB0byBob3cgdGhlIG9yZGVyaW5nIGFmZmVj dHMgdGhpbmdzCj4gaGVyZS4KPiAKPiBDb3VsZCBiZSB3b3J0aCBhZGRpbmcgYSBjb21tZW50IGF0 IGxlYXN0IHRvIGRlc2NyaWJlIHdoeSB3ZSBjYW4ndCB1c2UgdGhlCj4gZGVmYXVsdCBoZWxwZXIu Li4KClRoZSBmaXJzdCByZWFzb24sIGFzIHlvdSBtZW50aW9uZWQsIGlzIERSTV9QTEFORV9DT01N SVRfQUNUSVZFX09OTFksIGFzIHdlCmRvbid0IG5lZWQgdG8gcmVjZWl2ZSBwbGFuZSB1cGRhdGVz IGZvciBkaXNhYmxlZCBDUlRDcy4KClRoZSBzZWNvbmQgcmVhc29uIGlzIHBhdGNoICJbUEFUQ0hd IGRybTogcmNhci1kdTogV2FpdCBmb3IgZmxpcCBjb21wbGV0aW9uCmluc3RlYWQgb2YgdmJsYW5r IGluICBjb21taXQgdGFpbCIgdGhhdCBJIGhhdmUganVzdCBzdWJtaXR0ZWQsIHdoaWNoIHJlcGxh Y2VzCnRoZSBkcm1fYXRvbWljX2hlbHBlcl93YWl0X2Zvcl92YmxhbmtzKCkgY2FsbCB3aXRoCmRy bV9hdG9taWNfaGVscGVyX3dhaXRfZmxpcF9kb25lKCkuIEkgY2FuIGFkZCBhIGNvbW1lbnQgdG8g dGhhdCBwYXRjaCBpZiB5b3UKdGhpbmsgdGhhdCB3b3VsZCBiZSBoZWxwZnVsLgoKPiA+ICsJZHJt X2F0b21pY19oZWxwZXJfY29tbWl0X21vZGVzZXRfZW5hYmxlcyhkZXYsIG9sZF9zdGF0ZSk7Cj4g PiAKPiA+ICAgCWRybV9hdG9taWNfaGVscGVyX2NvbW1pdF9od19kb25lKG9sZF9zdGF0ZSk7Cj4g PiAgCWRybV9hdG9taWNfaGVscGVyX3dhaXRfZm9yX3ZibGFua3MoZGV2LCBvbGRfc3RhdGUpOwoK LS0gClJlZ2FyZHMsCgpMYXVyZW50IFBpbmNoYXJ0CgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBs aXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1h bi9saXN0aW5mby9kcmktZGV2ZWwK