From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751827AbeBTMtY (ORCPT ); Tue, 20 Feb 2018 07:49:24 -0500 Received: from mail-wr0-f193.google.com ([209.85.128.193]:33170 "EHLO mail-wr0-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751539AbeBTMtX (ORCPT ); Tue, 20 Feb 2018 07:49:23 -0500 X-Google-Smtp-Source: AH8x224h+9NKPIzZL0tN12hPWnJa5p4Q9Zt/swqlFGXoIaTuPADcNuPFGhGDG766Q2j3m5vUipg9LQ== Date: Tue, 20 Feb 2018 13:49:19 +0100 From: Daniel Vetter To: Oleksandr Andrushchenko Cc: Oleksandr Andrushchenko , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, airlied@linux.ie, daniel.vetter@intel.com Subject: Re: [PATCH] drm/simple_kms_helper: Fix NULL pointer dereference with no active CRTC Message-ID: <20180220124919.GS22199@phenom.ffwll.local> Mail-Followup-To: Oleksandr Andrushchenko , Oleksandr Andrushchenko , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, airlied@linux.ie, daniel.vetter@intel.com References: <1518511456-28257-1-git-send-email-andr2000@gmail.com> <20180219143002.GC22199@phenom.ffwll.local> <20180220111748.GJ22199@phenom.ffwll.local> <38f46c4f-3c0d-cf86-3d50-cf0f9313b205@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <38f46c4f-3c0d-cf86-3d50-cf0f9313b205@gmail.com> X-Operating-System: Linux phenom 4.14.0-3-amd64 User-Agent: Mutt/1.9.3 (2018-01-21) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Tue, Feb 20, 2018 at 02:36:05PM +0200, Oleksandr Andrushchenko wrote: > On 02/20/2018 01:17 PM, Daniel Vetter wrote: > > On Mon, Feb 19, 2018 at 04:58:43PM +0200, Oleksandr Andrushchenko wrote: > > > On 02/19/2018 04:30 PM, Daniel Vetter wrote: > > > > On Tue, Feb 13, 2018 at 10:44:16AM +0200, Oleksandr Andrushchenko wrote: > > > > > From: Oleksandr Andrushchenko > > > > > > > > > > It is possible that drm_simple_kms_plane_atomic_check called > > > > > with no CRTC set, e.g. when user-space application sets CRTC_ID/FB_ID > > > > > to 0 before doing any actual drawing. This leads to NULL pointer > > > > > dereference because in this case new CRTC state is NULL and must be > > > > > checked before accessing. > > > > > > > > > > Signed-off-by: Oleksandr Andrushchenko > > > > > --- > > > > > drivers/gpu/drm/drm_simple_kms_helper.c | 6 ++++-- > > > > > 1 file changed, 4 insertions(+), 2 deletions(-) > > > > > > > > > > diff --git a/drivers/gpu/drm/drm_simple_kms_helper.c b/drivers/gpu/drm/drm_simple_kms_helper.c > > > > > index 9ca8a4a59b74..a05eca9cec8b 100644 > > > > > --- a/drivers/gpu/drm/drm_simple_kms_helper.c > > > > > +++ b/drivers/gpu/drm/drm_simple_kms_helper.c > > > > > @@ -121,8 +121,10 @@ static int drm_simple_kms_plane_atomic_check(struct drm_plane *plane, > > > > > pipe = container_of(plane, struct drm_simple_display_pipe, plane); > > > > > crtc_state = drm_atomic_get_new_crtc_state(plane_state->state, > > > > > &pipe->crtc); > > > > > - if (!crtc_state->enable) > > > > > - return 0; /* nothing to check when disabling or disabled */ > > > > > + > > > > > + if (!crtc_state || !crtc_state->enable) > > > > > + /* nothing to check when disabling or disabled or no CRTC set */ > > > > > + return 0; > > > > > if (crtc_state->enable) > > > > > drm_mode_get_hv_timing(&crtc_state->mode, > > > > Hm, this is a bit annoying, since the can_position = false parameter to > > > > drm_atomic_helper_check_plane_state is supposed to catch all this. Would > > > > moving all the checks after the call to that helper, and gating them on > > > > plane_state->visible also work? > > > Yes, it does work if this is what you mean: > > I wasn't sure, thanks for figuring this out! > > > > > diff --git a/drivers/gpu/drm/drm_simple_kms_helper.c > > > b/drivers/gpu/drm/drm_simple_kms_helper.c > > > index a05eca9cec8b..c48858bb2823 100644 > > > --- a/drivers/gpu/drm/drm_simple_kms_helper.c > > > +++ b/drivers/gpu/drm/drm_simple_kms_helper.c > > > @@ -122,14 +122,6 @@ static int drm_simple_kms_plane_atomic_check(struct > > > drm_plane *plane, > > >         crtc_state = drm_atomic_get_new_crtc_state(plane_state->state, > > > &pipe->crtc); > > > > > > -       if (!crtc_state || !crtc_state->enable) > > > -               /* nothing to check when disabling or disabled or no CRTC > > > set */ > > > -               return 0; > > > - > > > -       if (crtc_state->enable) > > > -               drm_mode_get_hv_timing(&crtc_state->mode, > > > -                                      &clip.x2, &clip.y2); > > > - > > >         ret = drm_atomic_helper_check_plane_state(plane_state, crtc_state, > > >                                                   &clip, > > > DRM_PLANE_HELPER_NO_SCALING, > > > @@ -138,6 +130,13 @@ static int drm_simple_kms_plane_atomic_check(struct > > > drm_plane *plane, > > >         if (ret) > > >                 return ret; > > > > > > +       if (!plane_state->visible || !crtc_state->enable) > > > +               return 0; /* nothing to check when disabling or disabled */ > > if (!plane_state->visible) { > > WARN_ON(crtc_state->enabled); > > return 0; > > } > > > > The helper call above should guarantee this. > Yes, but I still see cases when crtc_state is NULL, thus > making crtc_state->enable to fail Right, when the plane is completely off there's no CRTC state. Correct check should be WARN_ON(crtc_state && crtc_state->enabled); > > > + > > > +       if (plane_state->visible && crtc_state->enable) > > Similar here. > > > > > +               drm_mode_get_hv_timing(&crtc_state->mode, > > > +                                      &clip.x2, &clip.y2); > > > + > > >         if (!plane_state->visible) > > >                 return -EINVAL; > > This can now be removed, the plane helper takes care of checking for > > plane_state->visible != crtc_state->enable. Please also remove. > > > > > > We'd need to add a guarantee to drm_atomic_helper_check_plane_state that > > > > it can cope with crtc_state == NULL, but I think that's a good idea > > > > anyway. Atm it shouldn't end up looking at the crtc_state pointer in that > > > > case. > > > It doesn't look at it at the moment > > > > Otherwise we'll just go with your fix, but it feels all a bit too fragile, > > > > hence why I want to explore more robust options a bit. > > > At list with the change above it passes my test which failed > > > before. Although I cannot confirm it works for others, but it > > > certainly does for me. > > > > -Daniel > > > Do you want me to send v1 with the code above? > > Yes please, with my above cleanup suggestions. > Please see the patch under test attached (I believe it is what you mean, > with the only change that >     if (!plane_state->visible) { >         *if (crtc_state)* >             WARN_ON(crtc_state->enable); >         return 0; >     } > check is used). > > Whith this patch + additional logs I have: > > [   18.939204] [drm:drm_ioctl [drm]] pid=2105, dev=0xe200, auth=1, > DRM_IOCTL_MODE_ATOMIC > [...] > [   18.939681] [drm:drm_atomic_set_crtc_for_plane [drm]] Link plane state > 00000000c302cbbf to [NOCRTC] > [   18.939822] [drm:drm_atomic_set_fb_for_plane [drm]] Set [NOFB] for plane > state 00000000c302cbbf > [   18.939963] [drm:drm_atomic_print_state [drm]] checking 000000000bc224e7 > [   18.939988] vdispl vdispl.0: [drm] plane[29]: plane-0 > [   18.940003] vdispl vdispl.0: [drm]   crtc=(null) > [   18.940018] vdispl vdispl.0: [drm]   fb=0 > [   18.940032] vdispl vdispl.0: [drm]   crtc-pos=0x0+0+0 > [   18.940048] vdispl vdispl.0: [drm] > src-pos=0.000000x0.000000+0.000000+0.000000 > [   18.940067] vdispl vdispl.0: [drm]   rotation=1 > [   18.940199] [drm:drm_atomic_check_only [drm]] checking 000000000bc224e7 > [   18.940226] ================================= plane_state->visible 0 > crtc_state           (null) > [...] > [   18.978146] [drm:drm_atomic_set_crtc_for_plane [drm]] Link plane state > 000000006bd50580 to [CRTC:30:crtc-0] > [   18.978292] [drm:drm_atomic_set_fb_for_plane [drm]] Set [FB:35] for plane > state 000000006bd50580 > [   18.978993] [drm:drm_atomic_set_mode_prop_for_crtc [drm]] Set > [MODE:1024x768] for CRTC state 00000000e5a28f6a > [   18.979425] [drm:drm_atomic_check_only [drm]] checking 000000000bc224e7 > [   18.979540] [drm:drm_atomic_helper_check_modeset [drm_kms_helper]] > [CRTC:30:crtc-0] mode changed > [   18.979632] [drm:drm_atomic_helper_check_modeset [drm_kms_helper]] > [CRTC:30:crtc-0] enable changed > [   18.979708] [drm:drm_atomic_helper_check_modeset [drm_kms_helper]] > [CRTC:30:crtc-0] active changed > [   18.979792] [drm:drm_atomic_helper_check_modeset [drm_kms_helper]] > Updating routing for [CONNECTOR:28:Virtual-1] > [   18.979877] [drm:drm_atomic_helper_check_modeset [drm_kms_helper]] > [CONNECTOR:28:Virtual-1] using [ENCODER:31:None-31] on [CRTC:30:crtc-0] > [   18.979960] [drm:drm_atomic_helper_check_modeset [drm_kms_helper]] > [CRTC:30:crtc-0] needs all connectors, enable: y, active: y > [   18.980139] [drm:drm_atomic_add_affected_connectors [drm]] Adding all > current connectors for [CRTC:30:crtc-0] to 000000000bc224e7 > [   18.980184] ================================= plane_state->visible 0 > crtc_state 00000000e5a28f6a > [   18.980205] crtc_state->enable 1 > > *[   19.022608] WARNING: CPU: 1 PID: 2105 at > drivers/gpu/drm/drm_simple_kms_helper.c:137 > drm_simple_kms_plane_atomic_check+0xdc/0xf8 [drm_kms_helper]* > > [...] > > [   19.113601] ================================= plane_state->visible 0 > crtc_state 00000000e5a28f6a > [   19.113623] crtc_state->enable 1 > [   19.113792] WARNING: CPU: 1 PID: 2105 at > drivers/gpu/drm/drm_simple_kms_helper.c:137 > drm_simple_kms_plane_atomic_check+0xdc/0xf8 [drm_kms_helper] > > [...] > > And finally > > [   19.340249] ================================= plane_state->visible 0 > crtc_state 0000000036a1b1f5 > [   19.340271] crtc_state->enable 0 > > So, it seems that crtc_state can still be NULL if "!plane_state->visible" > making > NULL pointer dereference, so we need a check for that. > Yet, !plane_state->visible && crtc_state->enable makes WARN_ON to fire > always. So, probably we may want removing it. > > > > Thanks, Daniel > Thank you, > Oleksandr > From dbcce708b237740158a2c16029c56a579324f269 Mon Sep 17 00:00:00 2001 > From: Oleksandr Andrushchenko > Date: Tue, 13 Feb 2018 10:32:20 +0200 > Subject: [PATCH] drm/simple_kms_helper: Fix NULL pointer dereference with no > active CRTC > > It is possible that drm_simple_kms_plane_atomic_check called > with no CRTC set, e.g. when user-space application sets CRTC_ID/FB_ID > to 0 before doing any actual drawing. This leads to NULL pointer > dereference because in this case new CRTC state is NULL and must be > checked before accessing. > > Signed-off-by: Oleksandr Andrushchenko > --- > drivers/gpu/drm/drm_simple_kms_helper.c | 15 +++++++-------- > 1 file changed, 7 insertions(+), 8 deletions(-) > > diff --git a/drivers/gpu/drm/drm_simple_kms_helper.c b/drivers/gpu/drm/drm_simple_kms_helper.c > index 9ca8a4a59b74..f54711ff9767 100644 > --- a/drivers/gpu/drm/drm_simple_kms_helper.c > +++ b/drivers/gpu/drm/drm_simple_kms_helper.c > @@ -121,12 +121,6 @@ static int drm_simple_kms_plane_atomic_check(struct drm_plane *plane, > pipe = container_of(plane, struct drm_simple_display_pipe, plane); > crtc_state = drm_atomic_get_new_crtc_state(plane_state->state, > &pipe->crtc); > - if (!crtc_state->enable) > - return 0; /* nothing to check when disabling or disabled */ > - > - if (crtc_state->enable) > - drm_mode_get_hv_timing(&crtc_state->mode, > - &clip.x2, &clip.y2); > > ret = drm_atomic_helper_check_plane_state(plane_state, crtc_state, > &clip, > @@ -136,8 +130,13 @@ static int drm_simple_kms_plane_atomic_check(struct drm_plane *plane, > if (ret) > return ret; > > - if (!plane_state->visible) > - return -EINVAL; > + if (!plane_state->visible) { > + if (crtc_state) > + WARN_ON(crtc_state->enable); > + return 0; > + } > + > + drm_mode_get_hv_timing(&crtc_state->mode, &clip.x2, &clip.y2); lgtm. With or without the bikeshed to pull the crtc_state check into the WARN_ON. Reviewed-by: Daniel Vetter Please resubmit as a stand-alone patch, patchwork can't pull patches out of attachments :-/ -Daniel > > if (!pipe->funcs || !pipe->funcs->check) > return 0; > -- > 2.7.4 > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- 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] drm/simple_kms_helper: Fix NULL pointer dereference with no active CRTC Date: Tue, 20 Feb 2018 13:49:19 +0100 Message-ID: <20180220124919.GS22199@phenom.ffwll.local> References: <1518511456-28257-1-git-send-email-andr2000@gmail.com> <20180219143002.GC22199@phenom.ffwll.local> <20180220111748.GJ22199@phenom.ffwll.local> <38f46c4f-3c0d-cf86-3d50-cf0f9313b205@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wr0-x242.google.com (mail-wr0-x242.google.com [IPv6:2a00:1450:400c:c0c::242]) by gabe.freedesktop.org (Postfix) with ESMTPS id A3DFB6E3E3 for ; Tue, 20 Feb 2018 12:49:23 +0000 (UTC) Received: by mail-wr0-x242.google.com with SMTP id k9so14018104wre.9 for ; Tue, 20 Feb 2018 04:49:23 -0800 (PST) Content-Disposition: inline In-Reply-To: <38f46c4f-3c0d-cf86-3d50-cf0f9313b205@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Oleksandr Andrushchenko Cc: airlied@linux.ie, daniel.vetter@intel.com, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Oleksandr Andrushchenko List-Id: dri-devel@lists.freedesktop.org T24gVHVlLCBGZWIgMjAsIDIwMTggYXQgMDI6MzY6MDVQTSArMDIwMCwgT2xla3NhbmRyIEFuZHJ1 c2hjaGVua28gd3JvdGU6Cj4gT24gMDIvMjAvMjAxOCAwMToxNyBQTSwgRGFuaWVsIFZldHRlciB3 cm90ZToKPiA+IE9uIE1vbiwgRmViIDE5LCAyMDE4IGF0IDA0OjU4OjQzUE0gKzAyMDAsIE9sZWtz YW5kciBBbmRydXNoY2hlbmtvIHdyb3RlOgo+ID4gPiBPbiAwMi8xOS8yMDE4IDA0OjMwIFBNLCBE YW5pZWwgVmV0dGVyIHdyb3RlOgo+ID4gPiA+IE9uIFR1ZSwgRmViIDEzLCAyMDE4IGF0IDEwOjQ0 OjE2QU0gKzAyMDAsIE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIHdyb3RlOgo+ID4gPiA+ID4gRnJv bTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0u Y29tPgo+ID4gPiA+ID4gCj4gPiA+ID4gPiBJdCBpcyBwb3NzaWJsZSB0aGF0IGRybV9zaW1wbGVf a21zX3BsYW5lX2F0b21pY19jaGVjayBjYWxsZWQKPiA+ID4gPiA+IHdpdGggbm8gQ1JUQyBzZXQs IGUuZy4gd2hlbiB1c2VyLXNwYWNlIGFwcGxpY2F0aW9uIHNldHMgQ1JUQ19JRC9GQl9JRAo+ID4g PiA+ID4gdG8gMCBiZWZvcmUgZG9pbmcgYW55IGFjdHVhbCBkcmF3aW5nLiBUaGlzIGxlYWRzIHRv IE5VTEwgcG9pbnRlcgo+ID4gPiA+ID4gZGVyZWZlcmVuY2UgYmVjYXVzZSBpbiB0aGlzIGNhc2Ug bmV3IENSVEMgc3RhdGUgaXMgTlVMTCBhbmQgbXVzdCBiZQo+ID4gPiA+ID4gY2hlY2tlZCBiZWZv cmUgYWNjZXNzaW5nLgo+ID4gPiA+ID4gCj4gPiA+ID4gPiBTaWduZWQtb2ZmLWJ5OiBPbGVrc2Fu ZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+Cj4gPiA+ ID4gPiAtLS0KPiA+ID4gPiA+ICAgIGRyaXZlcnMvZ3B1L2RybS9kcm1fc2ltcGxlX2ttc19oZWxw ZXIuYyB8IDYgKysrKy0tCj4gPiA+ID4gPiAgICAxIGZpbGUgY2hhbmdlZCwgNCBpbnNlcnRpb25z KCspLCAyIGRlbGV0aW9ucygtKQo+ID4gPiA+ID4gCj4gPiA+ID4gPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2RybV9zaW1wbGVfa21zX2hlbHBlci5jIGIvZHJpdmVycy9ncHUvZHJtL2Ry bV9zaW1wbGVfa21zX2hlbHBlci5jCj4gPiA+ID4gPiBpbmRleCA5Y2E4YTRhNTliNzQuLmEwNWVj YTljZWM4YiAxMDA2NDQKPiA+ID4gPiA+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fc2ltcGxl X2ttc19oZWxwZXIuYwo+ID4gPiA+ID4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9zaW1wbGVf a21zX2hlbHBlci5jCj4gPiA+ID4gPiBAQCAtMTIxLDggKzEyMSwxMCBAQCBzdGF0aWMgaW50IGRy bV9zaW1wbGVfa21zX3BsYW5lX2F0b21pY19jaGVjayhzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwK PiA+ID4gPiA+ICAgIAlwaXBlID0gY29udGFpbmVyX29mKHBsYW5lLCBzdHJ1Y3QgZHJtX3NpbXBs ZV9kaXNwbGF5X3BpcGUsIHBsYW5lKTsKPiA+ID4gPiA+ICAgIAljcnRjX3N0YXRlID0gZHJtX2F0 b21pY19nZXRfbmV3X2NydGNfc3RhdGUocGxhbmVfc3RhdGUtPnN0YXRlLAo+ID4gPiA+ID4gICAg CQkJCQkJICAgJnBpcGUtPmNydGMpOwo+ID4gPiA+ID4gLQlpZiAoIWNydGNfc3RhdGUtPmVuYWJs ZSkKPiA+ID4gPiA+IC0JCXJldHVybiAwOyAvKiBub3RoaW5nIHRvIGNoZWNrIHdoZW4gZGlzYWJs aW5nIG9yIGRpc2FibGVkICovCj4gPiA+ID4gPiArCj4gPiA+ID4gPiArCWlmICghY3J0Y19zdGF0 ZSB8fCAhY3J0Y19zdGF0ZS0+ZW5hYmxlKQo+ID4gPiA+ID4gKwkJLyogbm90aGluZyB0byBjaGVj ayB3aGVuIGRpc2FibGluZyBvciBkaXNhYmxlZCBvciBubyBDUlRDIHNldCAqLwo+ID4gPiA+ID4g KwkJcmV0dXJuIDA7Cj4gPiA+ID4gPiAgICAJaWYgKGNydGNfc3RhdGUtPmVuYWJsZSkKPiA+ID4g PiA+ICAgIAkJZHJtX21vZGVfZ2V0X2h2X3RpbWluZygmY3J0Y19zdGF0ZS0+bW9kZSwKPiA+ID4g PiBIbSwgdGhpcyBpcyBhIGJpdCBhbm5veWluZywgc2luY2UgdGhlIGNhbl9wb3NpdGlvbiA9IGZh bHNlIHBhcmFtZXRlciB0bwo+ID4gPiA+IGRybV9hdG9taWNfaGVscGVyX2NoZWNrX3BsYW5lX3N0 YXRlIGlzIHN1cHBvc2VkIHRvIGNhdGNoIGFsbCB0aGlzLiBXb3VsZAo+ID4gPiA+IG1vdmluZyBh bGwgdGhlIGNoZWNrcyBhZnRlciB0aGUgY2FsbCB0byB0aGF0IGhlbHBlciwgYW5kIGdhdGluZyB0 aGVtIG9uCj4gPiA+ID4gcGxhbmVfc3RhdGUtPnZpc2libGUgYWxzbyB3b3JrPwo+ID4gPiBZZXMs IGl0IGRvZXMgd29yayBpZiB0aGlzIGlzIHdoYXQgeW91IG1lYW46Cj4gPiBJIHdhc24ndCBzdXJl LCB0aGFua3MgZm9yIGZpZ3VyaW5nIHRoaXMgb3V0IQo+ID4gCj4gPiA+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vZHJtX3NpbXBsZV9rbXNfaGVscGVyLmMKPiA+ID4gYi9kcml2ZXJzL2dw dS9kcm0vZHJtX3NpbXBsZV9rbXNfaGVscGVyLmMKPiA+ID4gaW5kZXggYTA1ZWNhOWNlYzhiLi5j NDg4NThiYjI4MjMgMTAwNjQ0Cj4gPiA+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fc2ltcGxl X2ttc19oZWxwZXIuYwo+ID4gPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX3NpbXBsZV9rbXNf aGVscGVyLmMKPiA+ID4gQEAgLTEyMiwxNCArMTIyLDYgQEAgc3RhdGljIGludCBkcm1fc2ltcGxl X2ttc19wbGFuZV9hdG9taWNfY2hlY2soc3RydWN0Cj4gPiA+IGRybV9wbGFuZSAqcGxhbmUsCj4g PiA+ICDCoMKgwqDCoMKgwqDCoCBjcnRjX3N0YXRlID0gZHJtX2F0b21pY19nZXRfbmV3X2NydGNf c3RhdGUocGxhbmVfc3RhdGUtPnN0YXRlLAo+ID4gPiAmcGlwZS0+Y3J0Yyk7Cj4gPiA+IAo+ID4g PiAtwqDCoMKgwqDCoMKgIGlmICghY3J0Y19zdGF0ZSB8fCAhY3J0Y19zdGF0ZS0+ZW5hYmxlKQo+ ID4gPiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAvKiBub3RoaW5nIHRvIGNoZWNrIHdo ZW4gZGlzYWJsaW5nIG9yIGRpc2FibGVkIG9yIG5vIENSVEMKPiA+ID4gc2V0ICovCj4gPiA+IC3C oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiAwOwo+ID4gPiAtCj4gPiA+IC3CoMKg wqDCoMKgwqAgaWYgKGNydGNfc3RhdGUtPmVuYWJsZSkKPiA+ID4gLcKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqAgZHJtX21vZGVfZ2V0X2h2X3RpbWluZygmY3J0Y19zdGF0ZS0+bW9kZSwKPiA+ ID4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgICZjbGlwLngyLCAmY2xpcC55Mik7Cj4gPiA+IC0KPiA+ID4g IMKgwqDCoMKgwqDCoMKgIHJldCA9IGRybV9hdG9taWNfaGVscGVyX2NoZWNrX3BsYW5lX3N0YXRl KHBsYW5lX3N0YXRlLCBjcnRjX3N0YXRlLAo+ID4gPiAgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqAgJmNsaXAsCj4gPiA+IERSTV9QTEFORV9IRUxQRVJfTk9fU0NBTElO RywKPiA+ID4gQEAgLTEzOCw2ICsxMzAsMTMgQEAgc3RhdGljIGludCBkcm1fc2ltcGxlX2ttc19w bGFuZV9hdG9taWNfY2hlY2soc3RydWN0Cj4gPiA+IGRybV9wbGFuZSAqcGxhbmUsCj4gPiA+ICDC oMKgwqDCoMKgwqDCoCBpZiAocmV0KQo+ID4gPiAgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIHJldHVybiByZXQ7Cj4gPiA+IAo+ID4gPiArwqDCoMKgwqDCoMKgIGlmICghcGxhbmVfc3Rh dGUtPnZpc2libGUgfHwgIWNydGNfc3RhdGUtPmVuYWJsZSkKPiA+ID4gK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqAgcmV0dXJuIDA7IC8qIG5vdGhpbmcgdG8gY2hlY2sgd2hlbiBkaXNhYmxp bmcgb3IgZGlzYWJsZWQgKi8KPiA+IGlmICghcGxhbmVfc3RhdGUtPnZpc2libGUpIHsKPiA+IAlX QVJOX09OKGNydGNfc3RhdGUtPmVuYWJsZWQpOwo+ID4gCXJldHVybiAwOwo+ID4gfQo+ID4gCj4g PiBUaGUgaGVscGVyIGNhbGwgYWJvdmUgc2hvdWxkIGd1YXJhbnRlZSB0aGlzLgo+IFllcywgYnV0 IEkgc3RpbGwgc2VlIGNhc2VzIHdoZW4gY3J0Y19zdGF0ZSBpcyBOVUxMLCB0aHVzCj4gbWFraW5n IGNydGNfc3RhdGUtPmVuYWJsZSB0byBmYWlsCgpSaWdodCwgd2hlbiB0aGUgcGxhbmUgaXMgY29t cGxldGVseSBvZmYgdGhlcmUncyBubyBDUlRDIHN0YXRlLiBDb3JyZWN0CmNoZWNrIHNob3VsZCBi ZQoKCVdBUk5fT04oY3J0Y19zdGF0ZSAmJiBjcnRjX3N0YXRlLT5lbmFibGVkKTsKCgo+ID4gPiAr Cj4gPiA+ICvCoMKgwqDCoMKgwqAgaWYgKHBsYW5lX3N0YXRlLT52aXNpYmxlICYmIGNydGNfc3Rh dGUtPmVuYWJsZSkKPiA+IFNpbWlsYXIgaGVyZS4KPiA+IAo+ID4gPiArwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoCBkcm1fbW9kZV9nZXRfaHZfdGltaW5nKCZjcnRjX3N0YXRlLT5tb2RlLAo+ ID4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgJmNsaXAueDIsICZjbGlwLnkyKTsKPiA+ID4gKwo+ID4g PiAgwqDCoMKgwqDCoMKgwqAgaWYgKCFwbGFuZV9zdGF0ZS0+dmlzaWJsZSkKPiA+ID4gIMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCByZXR1cm4gLUVJTlZBTDsKPiA+IFRoaXMgY2FuIG5v dyBiZSByZW1vdmVkLCB0aGUgcGxhbmUgaGVscGVyIHRha2VzIGNhcmUgb2YgY2hlY2tpbmcgZm9y Cj4gPiBwbGFuZV9zdGF0ZS0+dmlzaWJsZSAhPSBjcnRjX3N0YXRlLT5lbmFibGUuIFBsZWFzZSBh bHNvIHJlbW92ZS4KPiA+IAo+ID4gPiA+IFdlJ2QgbmVlZCB0byBhZGQgYSBndWFyYW50ZWUgdG8g ZHJtX2F0b21pY19oZWxwZXJfY2hlY2tfcGxhbmVfc3RhdGUgdGhhdAo+ID4gPiA+IGl0IGNhbiBj b3BlIHdpdGggY3J0Y19zdGF0ZSA9PSBOVUxMLCBidXQgSSB0aGluayB0aGF0J3MgYSBnb29kIGlk ZWEKPiA+ID4gPiBhbnl3YXkuIEF0bSBpdCBzaG91bGRuJ3QgZW5kIHVwIGxvb2tpbmcgYXQgdGhl IGNydGNfc3RhdGUgcG9pbnRlciBpbiB0aGF0Cj4gPiA+ID4gY2FzZS4KPiA+ID4gSXQgZG9lc24n dCBsb29rIGF0IGl0IGF0IHRoZSBtb21lbnQKPiA+ID4gPiBPdGhlcndpc2Ugd2UnbGwganVzdCBn byB3aXRoIHlvdXIgZml4LCBidXQgaXQgZmVlbHMgYWxsIGEgYml0IHRvbyBmcmFnaWxlLAo+ID4g PiA+IGhlbmNlIHdoeSBJIHdhbnQgdG8gZXhwbG9yZSBtb3JlIHJvYnVzdCBvcHRpb25zIGEgYml0 Lgo+ID4gPiBBdCBsaXN0IHdpdGggdGhlIGNoYW5nZSBhYm92ZSBpdCBwYXNzZXMgbXkgdGVzdCB3 aGljaCBmYWlsZWQKPiA+ID4gYmVmb3JlLiBBbHRob3VnaCBJIGNhbm5vdCBjb25maXJtIGl0IHdv cmtzIGZvciBvdGhlcnMsIGJ1dCBpdAo+ID4gPiBjZXJ0YWlubHkgZG9lcyBmb3IgbWUuCj4gPiA+ ID4gLURhbmllbAo+ID4gPiBEbyB5b3Ugd2FudCBtZSB0byBzZW5kIHYxIHdpdGggdGhlIGNvZGUg YWJvdmU/Cj4gPiBZZXMgcGxlYXNlLCB3aXRoIG15IGFib3ZlIGNsZWFudXAgc3VnZ2VzdGlvbnMu Cj4gUGxlYXNlIHNlZSB0aGUgcGF0Y2ggdW5kZXIgdGVzdCBhdHRhY2hlZCAoSSBiZWxpZXZlIGl0 IGlzIHdoYXQgeW91IG1lYW4sCj4gd2l0aCB0aGUgb25seSBjaGFuZ2UgdGhhdAo+IMKgwqDCoCBp ZiAoIXBsYW5lX3N0YXRlLT52aXNpYmxlKSB7Cj4gwqDCoMKgIMKgwqDCoCAqaWYgKGNydGNfc3Rh dGUpKgo+IMKgwqDCoCDCoMKgwqAgwqDCoMKgIFdBUk5fT04oY3J0Y19zdGF0ZS0+ZW5hYmxlKTsK PiDCoMKgwqAgwqDCoMKgIHJldHVybiAwOwo+IMKgwqDCoCB9Cj4gY2hlY2sgaXMgdXNlZCkuCj4g Cj4gV2hpdGggdGhpcyBwYXRjaCArIGFkZGl0aW9uYWwgbG9ncyBJIGhhdmU6Cj4gCj4gW8KgwqAg MTguOTM5MjA0XSBbZHJtOmRybV9pb2N0bCBbZHJtXV0gcGlkPTIxMDUsIGRldj0weGUyMDAsIGF1 dGg9MSwKPiBEUk1fSU9DVExfTU9ERV9BVE9NSUMKPiBbLi4uXQo+IFvCoMKgIDE4LjkzOTY4MV0g W2RybTpkcm1fYXRvbWljX3NldF9jcnRjX2Zvcl9wbGFuZSBbZHJtXV0gTGluayBwbGFuZSBzdGF0 ZQo+IDAwMDAwMDAwYzMwMmNiYmYgdG8gW05PQ1JUQ10KPiBbwqDCoCAxOC45Mzk4MjJdIFtkcm06 ZHJtX2F0b21pY19zZXRfZmJfZm9yX3BsYW5lIFtkcm1dXSBTZXQgW05PRkJdIGZvciBwbGFuZQo+ IHN0YXRlIDAwMDAwMDAwYzMwMmNiYmYKPiBbwqDCoCAxOC45Mzk5NjNdIFtkcm06ZHJtX2F0b21p Y19wcmludF9zdGF0ZSBbZHJtXV0gY2hlY2tpbmcgMDAwMDAwMDAwYmMyMjRlNwo+IFvCoMKgIDE4 LjkzOTk4OF0gdmRpc3BsIHZkaXNwbC4wOiBbZHJtXSBwbGFuZVsyOV06IHBsYW5lLTAKPiBbwqDC oCAxOC45NDAwMDNdIHZkaXNwbCB2ZGlzcGwuMDogW2RybV3CoMKgIGNydGM9KG51bGwpCj4gW8Kg wqAgMTguOTQwMDE4XSB2ZGlzcGwgdmRpc3BsLjA6IFtkcm1dwqDCoCBmYj0wCj4gW8KgwqAgMTgu OTQwMDMyXSB2ZGlzcGwgdmRpc3BsLjA6IFtkcm1dwqDCoCBjcnRjLXBvcz0weDArMCswCj4gW8Kg wqAgMTguOTQwMDQ4XSB2ZGlzcGwgdmRpc3BsLjA6IFtkcm1dCj4gc3JjLXBvcz0wLjAwMDAwMHgw LjAwMDAwMCswLjAwMDAwMCswLjAwMDAwMAo+IFvCoMKgIDE4Ljk0MDA2N10gdmRpc3BsIHZkaXNw bC4wOiBbZHJtXcKgwqAgcm90YXRpb249MQo+IFvCoMKgIDE4Ljk0MDE5OV0gW2RybTpkcm1fYXRv bWljX2NoZWNrX29ubHkgW2RybV1dIGNoZWNraW5nIDAwMDAwMDAwMGJjMjI0ZTcKPiBbwqDCoCAx OC45NDAyMjZdID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSBwbGFuZV9zdGF0ZS0+ dmlzaWJsZSAwCj4gY3J0Y19zdGF0ZcKgwqDCoMKgwqDCoMKgwqDCoMKgIChudWxsKQo+IFsuLi5d Cj4gW8KgwqAgMTguOTc4MTQ2XSBbZHJtOmRybV9hdG9taWNfc2V0X2NydGNfZm9yX3BsYW5lIFtk cm1dXSBMaW5rIHBsYW5lIHN0YXRlCj4gMDAwMDAwMDA2YmQ1MDU4MCB0byBbQ1JUQzozMDpjcnRj LTBdCj4gW8KgwqAgMTguOTc4MjkyXSBbZHJtOmRybV9hdG9taWNfc2V0X2ZiX2Zvcl9wbGFuZSBb ZHJtXV0gU2V0IFtGQjozNV0gZm9yIHBsYW5lCj4gc3RhdGUgMDAwMDAwMDA2YmQ1MDU4MAo+IFvC oMKgIDE4Ljk3ODk5M10gW2RybTpkcm1fYXRvbWljX3NldF9tb2RlX3Byb3BfZm9yX2NydGMgW2Ry bV1dIFNldAo+IFtNT0RFOjEwMjR4NzY4XSBmb3IgQ1JUQyBzdGF0ZSAwMDAwMDAwMGU1YTI4ZjZh Cj4gW8KgwqAgMTguOTc5NDI1XSBbZHJtOmRybV9hdG9taWNfY2hlY2tfb25seSBbZHJtXV0gY2hl Y2tpbmcgMDAwMDAwMDAwYmMyMjRlNwo+IFvCoMKgIDE4Ljk3OTU0MF0gW2RybTpkcm1fYXRvbWlj X2hlbHBlcl9jaGVja19tb2Rlc2V0IFtkcm1fa21zX2hlbHBlcl1dCj4gW0NSVEM6MzA6Y3J0Yy0w XSBtb2RlIGNoYW5nZWQKPiBbwqDCoCAxOC45Nzk2MzJdIFtkcm06ZHJtX2F0b21pY19oZWxwZXJf Y2hlY2tfbW9kZXNldCBbZHJtX2ttc19oZWxwZXJdXQo+IFtDUlRDOjMwOmNydGMtMF0gZW5hYmxl IGNoYW5nZWQKPiBbwqDCoCAxOC45Nzk3MDhdIFtkcm06ZHJtX2F0b21pY19oZWxwZXJfY2hlY2tf bW9kZXNldCBbZHJtX2ttc19oZWxwZXJdXQo+IFtDUlRDOjMwOmNydGMtMF0gYWN0aXZlIGNoYW5n ZWQKPiBbwqDCoCAxOC45Nzk3OTJdIFtkcm06ZHJtX2F0b21pY19oZWxwZXJfY2hlY2tfbW9kZXNl dCBbZHJtX2ttc19oZWxwZXJdXQo+IFVwZGF0aW5nIHJvdXRpbmcgZm9yIFtDT05ORUNUT1I6Mjg6 VmlydHVhbC0xXQo+IFvCoMKgIDE4Ljk3OTg3N10gW2RybTpkcm1fYXRvbWljX2hlbHBlcl9jaGVj a19tb2Rlc2V0IFtkcm1fa21zX2hlbHBlcl1dCj4gW0NPTk5FQ1RPUjoyODpWaXJ0dWFsLTFdIHVz aW5nIFtFTkNPREVSOjMxOk5vbmUtMzFdIG9uIFtDUlRDOjMwOmNydGMtMF0KPiBbwqDCoCAxOC45 Nzk5NjBdIFtkcm06ZHJtX2F0b21pY19oZWxwZXJfY2hlY2tfbW9kZXNldCBbZHJtX2ttc19oZWxw ZXJdXQo+IFtDUlRDOjMwOmNydGMtMF0gbmVlZHMgYWxsIGNvbm5lY3RvcnMsIGVuYWJsZTogeSwg YWN0aXZlOiB5Cj4gW8KgwqAgMTguOTgwMTM5XSBbZHJtOmRybV9hdG9taWNfYWRkX2FmZmVjdGVk X2Nvbm5lY3RvcnMgW2RybV1dIEFkZGluZyBhbGwKPiBjdXJyZW50IGNvbm5lY3RvcnMgZm9yIFtD UlRDOjMwOmNydGMtMF0gdG8gMDAwMDAwMDAwYmMyMjRlNwo+IFvCoMKgIDE4Ljk4MDE4NF0gPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IHBsYW5lX3N0YXRlLT52aXNpYmxlIDAKPiBj cnRjX3N0YXRlIDAwMDAwMDAwZTVhMjhmNmEKPiBbwqDCoCAxOC45ODAyMDVdIGNydGNfc3RhdGUt PmVuYWJsZSAxCj4gCj4gKlvCoMKgIDE5LjAyMjYwOF0gV0FSTklORzogQ1BVOiAxIFBJRDogMjEw NSBhdAo+IGRyaXZlcnMvZ3B1L2RybS9kcm1fc2ltcGxlX2ttc19oZWxwZXIuYzoxMzcKPiBkcm1f c2ltcGxlX2ttc19wbGFuZV9hdG9taWNfY2hlY2srMHhkYy8weGY4IFtkcm1fa21zX2hlbHBlcl0q Cj4gCj4gWy4uLl0KPiAKPiBbwqDCoCAxOS4xMTM2MDFdID09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PSBwbGFuZV9zdGF0ZS0+dmlzaWJsZSAwCj4gY3J0Y19zdGF0ZSAwMDAwMDAwMGU1 YTI4ZjZhCj4gW8KgwqAgMTkuMTEzNjIzXSBjcnRjX3N0YXRlLT5lbmFibGUgMQo+IFvCoMKgIDE5 LjExMzc5Ml0gV0FSTklORzogQ1BVOiAxIFBJRDogMjEwNSBhdAo+IGRyaXZlcnMvZ3B1L2RybS9k cm1fc2ltcGxlX2ttc19oZWxwZXIuYzoxMzcKPiBkcm1fc2ltcGxlX2ttc19wbGFuZV9hdG9taWNf Y2hlY2srMHhkYy8weGY4IFtkcm1fa21zX2hlbHBlcl0KPiAKPiBbLi4uXQo+IAo+IEFuZCBmaW5h bGx5Cj4gCj4gW8KgwqAgMTkuMzQwMjQ5XSA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0gcGxhbmVfc3RhdGUtPnZpc2libGUgMAo+IGNydGNfc3RhdGUgMDAwMDAwMDAzNmExYjFmNQo+ IFvCoMKgIDE5LjM0MDI3MV0gY3J0Y19zdGF0ZS0+ZW5hYmxlIDAKPiAKPiBTbywgaXQgc2VlbXMg dGhhdCBjcnRjX3N0YXRlIGNhbiBzdGlsbCBiZSBOVUxMIGlmICIhcGxhbmVfc3RhdGUtPnZpc2li bGUiCj4gbWFraW5nCj4gTlVMTCBwb2ludGVyIGRlcmVmZXJlbmNlLCBzbyB3ZSBuZWVkIGEgY2hl Y2sgZm9yIHRoYXQuCj4gWWV0LCAhcGxhbmVfc3RhdGUtPnZpc2libGUgJiYgY3J0Y19zdGF0ZS0+ ZW5hYmxlIG1ha2VzIFdBUk5fT04gdG8gZmlyZQo+IGFsd2F5cy4gU28sIHByb2JhYmx5IHdlIG1h eSB3YW50IHJlbW92aW5nIGl0Lgo+ID4gCj4gPiBUaGFua3MsIERhbmllbAo+IFRoYW5rIHlvdSwK PiBPbGVrc2FuZHIKCj4gRnJvbSBkYmNjZTcwOGIyMzc3NDAxNThhMmMxNjAyOWM1NmE1NzkzMjRm MjY5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQo+IEZyb206IE9sZWtzYW5kciBBbmRydXNoY2hl bmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KPiBEYXRlOiBUdWUsIDEzIEZl YiAyMDE4IDEwOjMyOjIwICswMjAwCj4gU3ViamVjdDogW1BBVENIXSBkcm0vc2ltcGxlX2ttc19o ZWxwZXI6IEZpeCBOVUxMIHBvaW50ZXIgZGVyZWZlcmVuY2Ugd2l0aCBubwo+ICBhY3RpdmUgQ1JU Qwo+IAo+IEl0IGlzIHBvc3NpYmxlIHRoYXQgZHJtX3NpbXBsZV9rbXNfcGxhbmVfYXRvbWljX2No ZWNrIGNhbGxlZAo+IHdpdGggbm8gQ1JUQyBzZXQsIGUuZy4gd2hlbiB1c2VyLXNwYWNlIGFwcGxp Y2F0aW9uIHNldHMgQ1JUQ19JRC9GQl9JRAo+IHRvIDAgYmVmb3JlIGRvaW5nIGFueSBhY3R1YWwg ZHJhd2luZy4gVGhpcyBsZWFkcyB0byBOVUxMIHBvaW50ZXIKPiBkZXJlZmVyZW5jZSBiZWNhdXNl IGluIHRoaXMgY2FzZSBuZXcgQ1JUQyBzdGF0ZSBpcyBOVUxMIGFuZCBtdXN0IGJlCj4gY2hlY2tl ZCBiZWZvcmUgYWNjZXNzaW5nLgo+IAo+IFNpZ25lZC1vZmYtYnk6IE9sZWtzYW5kciBBbmRydXNo Y2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KPiAtLS0KPiAgZHJpdmVy cy9ncHUvZHJtL2RybV9zaW1wbGVfa21zX2hlbHBlci5jIHwgMTUgKysrKysrKy0tLS0tLS0tCj4g IDEgZmlsZSBjaGFuZ2VkLCA3IGluc2VydGlvbnMoKyksIDggZGVsZXRpb25zKC0pCj4gCj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fc2ltcGxlX2ttc19oZWxwZXIuYyBiL2RyaXZl cnMvZ3B1L2RybS9kcm1fc2ltcGxlX2ttc19oZWxwZXIuYwo+IGluZGV4IDljYThhNGE1OWI3NC4u ZjU0NzExZmY5NzY3IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fc2ltcGxlX2tt c19oZWxwZXIuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fc2ltcGxlX2ttc19oZWxwZXIu Ywo+IEBAIC0xMjEsMTIgKzEyMSw2IEBAIHN0YXRpYyBpbnQgZHJtX3NpbXBsZV9rbXNfcGxhbmVf YXRvbWljX2NoZWNrKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAo+ICAJcGlwZSA9IGNvbnRhaW5l cl9vZihwbGFuZSwgc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlLCBwbGFuZSk7Cj4gIAlj cnRjX3N0YXRlID0gZHJtX2F0b21pY19nZXRfbmV3X2NydGNfc3RhdGUocGxhbmVfc3RhdGUtPnN0 YXRlLAo+ICAJCQkJCQkgICAmcGlwZS0+Y3J0Yyk7Cj4gLQlpZiAoIWNydGNfc3RhdGUtPmVuYWJs ZSkKPiAtCQlyZXR1cm4gMDsgLyogbm90aGluZyB0byBjaGVjayB3aGVuIGRpc2FibGluZyBvciBk aXNhYmxlZCAqLwo+IC0KPiAtCWlmIChjcnRjX3N0YXRlLT5lbmFibGUpCj4gLQkJZHJtX21vZGVf Z2V0X2h2X3RpbWluZygmY3J0Y19zdGF0ZS0+bW9kZSwKPiAtCQkJCSAgICAgICAmY2xpcC54Miwg JmNsaXAueTIpOwo+ICAKPiAgCXJldCA9IGRybV9hdG9taWNfaGVscGVyX2NoZWNrX3BsYW5lX3N0 YXRlKHBsYW5lX3N0YXRlLCBjcnRjX3N0YXRlLAo+ICAJCQkJCQkgICZjbGlwLAo+IEBAIC0xMzYs OCArMTMwLDEzIEBAIHN0YXRpYyBpbnQgZHJtX3NpbXBsZV9rbXNfcGxhbmVfYXRvbWljX2NoZWNr KHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAo+ICAJaWYgKHJldCkKPiAgCQlyZXR1cm4gcmV0Owo+ ICAKPiAtCWlmICghcGxhbmVfc3RhdGUtPnZpc2libGUpCj4gLQkJcmV0dXJuIC1FSU5WQUw7Cj4g KwlpZiAoIXBsYW5lX3N0YXRlLT52aXNpYmxlKSB7Cj4gKwkJaWYgKGNydGNfc3RhdGUpCj4gKwkJ CVdBUk5fT04oY3J0Y19zdGF0ZS0+ZW5hYmxlKTsKPiArCQlyZXR1cm4gMDsKPiArCX0KPiArCj4g Kwlkcm1fbW9kZV9nZXRfaHZfdGltaW5nKCZjcnRjX3N0YXRlLT5tb2RlLCAmY2xpcC54MiwgJmNs aXAueTIpOwoKbGd0bS4gV2l0aCBvciB3aXRob3V0IHRoZSBiaWtlc2hlZCB0byBwdWxsIHRoZSBj cnRjX3N0YXRlIGNoZWNrIGludG8gdGhlCldBUk5fT04uCgpSZXZpZXdlZC1ieTogRGFuaWVsIFZl dHRlciA8ZGFuaWVsLnZldHRlckBmZndsbC5jaD4KClBsZWFzZSByZXN1Ym1pdCBhcyBhIHN0YW5k LWFsb25lIHBhdGNoLCBwYXRjaHdvcmsgY2FuJ3QgcHVsbCBwYXRjaGVzIG91dApvZiBhdHRhY2ht ZW50cyA6LS8KLURhbmllbAoKPiAgCj4gIAlpZiAoIXBpcGUtPmZ1bmNzIHx8ICFwaXBlLT5mdW5j cy0+Y2hlY2spCj4gIAkJcmV0dXJuIDA7Cj4gLS0gCj4gMi43LjQKPiAKCj4gX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KPiBkcmktZGV2ZWwgbWFpbGluZyBs aXN0Cj4gZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwo+IGh0dHBzOi8vbGlzdHMuZnJl ZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCgoKLS0gCkRhbmllbCBWZXR0 ZXIKU29mdHdhcmUgRW5naW5lZXIsIEludGVsIENvcnBvcmF0aW9uCmh0dHA6Ly9ibG9nLmZmd2xs LmNoCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1k ZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczov L2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=