From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751812AbeBTMxp (ORCPT ); Tue, 20 Feb 2018 07:53:45 -0500 Received: from mail-lf0-f65.google.com ([209.85.215.65]:40170 "EHLO mail-lf0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751551AbeBTMxn (ORCPT ); Tue, 20 Feb 2018 07:53:43 -0500 X-Google-Smtp-Source: AH8x224ApqxVx8EARe1hDAcY6sGaeCOLFvzN9g1t5giUifju5/6ScyPpY2KHPjOaIbtCyJx7EXbEUA== Subject: Re: [PATCH] drm/simple_kms_helper: Fix NULL pointer dereference with no active CRTC To: 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> <20180220124919.GS22199@phenom.ffwll.local> From: Oleksandr Andrushchenko Message-ID: <94327c23-af1c-a348-5dd2-dfb963b71c96@gmail.com> Date: Tue, 20 Feb 2018 14:53:39 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.6.0 MIME-Version: 1.0 In-Reply-To: <20180220124919.GS22199@phenom.ffwll.local> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-US Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 02/20/2018 02:49 PM, Daniel Vetter wrote: > 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); ok, will update with this additional check > >>>> + >>>> +       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 Thank you > > Please resubmit as a stand-alone patch, patchwork can't pull patches out > of attachments :-/ oh, that was for demonstration purpose only, so we are on the same page and see the patch we are discussing ;) > -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 > From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: Re: [PATCH] drm/simple_kms_helper: Fix NULL pointer dereference with no active CRTC Date: Tue, 20 Feb 2018 14:53:39 +0200 Message-ID: <94327c23-af1c-a348-5dd2-dfb963b71c96@gmail.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> <20180220124919.GS22199@phenom.ffwll.local> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x243.google.com (mail-lf0-x243.google.com [IPv6:2a00:1450:4010:c07::243]) by gabe.freedesktop.org (Postfix) with ESMTPS id 89CCC6E3E7 for ; Tue, 20 Feb 2018 12:53:43 +0000 (UTC) Received: by mail-lf0-x243.google.com with SMTP id t204so4005329lff.9 for ; Tue, 20 Feb 2018 04:53:43 -0800 (PST) In-Reply-To: <20180220124919.GS22199@phenom.ffwll.local> Content-Language: en-US List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Oleksandr Andrushchenko , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, airlied@linux.ie, daniel.vetter@intel.com List-Id: dri-devel@lists.freedesktop.org T24gMDIvMjAvMjAxOCAwMjo0OSBQTSwgRGFuaWVsIFZldHRlciB3cm90ZToKPiBPbiBUdWUsIEZl YiAyMCwgMjAxOCBhdCAwMjozNjowNVBNICswMjAwLCBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyB3 cm90ZToKPj4gT24gMDIvMjAvMjAxOCAwMToxNyBQTSwgRGFuaWVsIFZldHRlciB3cm90ZToKPj4+ IE9uIE1vbiwgRmViIDE5LCAyMDE4IGF0IDA0OjU4OjQzUE0gKzAyMDAsIE9sZWtzYW5kciBBbmRy dXNoY2hlbmtvIHdyb3RlOgo+Pj4+IE9uIDAyLzE5LzIwMTggMDQ6MzAgUE0sIERhbmllbCBWZXR0 ZXIgd3JvdGU6Cj4+Pj4+IE9uIFR1ZSwgRmViIDEzLCAyMDE4IGF0IDEwOjQ0OjE2QU0gKzAyMDAs IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIHdyb3RlOgo+Pj4+Pj4gRnJvbTogT2xla3NhbmRyIEFu ZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgo+Pj4+Pj4KPj4+ Pj4+IEl0IGlzIHBvc3NpYmxlIHRoYXQgZHJtX3NpbXBsZV9rbXNfcGxhbmVfYXRvbWljX2NoZWNr IGNhbGxlZAo+Pj4+Pj4gd2l0aCBubyBDUlRDIHNldCwgZS5nLiB3aGVuIHVzZXItc3BhY2UgYXBw bGljYXRpb24gc2V0cyBDUlRDX0lEL0ZCX0lECj4+Pj4+PiB0byAwIGJlZm9yZSBkb2luZyBhbnkg YWN0dWFsIGRyYXdpbmcuIFRoaXMgbGVhZHMgdG8gTlVMTCBwb2ludGVyCj4+Pj4+PiBkZXJlZmVy ZW5jZSBiZWNhdXNlIGluIHRoaXMgY2FzZSBuZXcgQ1JUQyBzdGF0ZSBpcyBOVUxMIGFuZCBtdXN0 IGJlCj4+Pj4+PiBjaGVja2VkIGJlZm9yZSBhY2Nlc3NpbmcuCj4+Pj4+Pgo+Pj4+Pj4gU2lnbmVk LW9mZi1ieTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtv QGVwYW0uY29tPgo+Pj4+Pj4gLS0tCj4+Pj4+PiAgICAgZHJpdmVycy9ncHUvZHJtL2RybV9zaW1w bGVfa21zX2hlbHBlci5jIHwgNiArKysrLS0KPj4+Pj4+ICAgICAxIGZpbGUgY2hhbmdlZCwgNCBp bnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQo+Pj4+Pj4KPj4+Pj4+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vZHJtX3NpbXBsZV9rbXNfaGVscGVyLmMgYi9kcml2ZXJzL2dwdS9kcm0v ZHJtX3NpbXBsZV9rbXNfaGVscGVyLmMKPj4+Pj4+IGluZGV4IDljYThhNGE1OWI3NC4uYTA1ZWNh OWNlYzhiIDEwMDY0NAo+Pj4+Pj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9zaW1wbGVfa21z X2hlbHBlci5jCj4+Pj4+PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX3NpbXBsZV9rbXNfaGVs cGVyLmMKPj4+Pj4+IEBAIC0xMjEsOCArMTIxLDEwIEBAIHN0YXRpYyBpbnQgZHJtX3NpbXBsZV9r bXNfcGxhbmVfYXRvbWljX2NoZWNrKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAo+Pj4+Pj4gICAg IAlwaXBlID0gY29udGFpbmVyX29mKHBsYW5lLCBzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3Bp cGUsIHBsYW5lKTsKPj4+Pj4+ICAgICAJY3J0Y19zdGF0ZSA9IGRybV9hdG9taWNfZ2V0X25ld19j cnRjX3N0YXRlKHBsYW5lX3N0YXRlLT5zdGF0ZSwKPj4+Pj4+ICAgICAJCQkJCQkgICAmcGlwZS0+ Y3J0Yyk7Cj4+Pj4+PiAtCWlmICghY3J0Y19zdGF0ZS0+ZW5hYmxlKQo+Pj4+Pj4gLQkJcmV0dXJu IDA7IC8qIG5vdGhpbmcgdG8gY2hlY2sgd2hlbiBkaXNhYmxpbmcgb3IgZGlzYWJsZWQgKi8KPj4+ Pj4+ICsKPj4+Pj4+ICsJaWYgKCFjcnRjX3N0YXRlIHx8ICFjcnRjX3N0YXRlLT5lbmFibGUpCj4+ Pj4+PiArCQkvKiBub3RoaW5nIHRvIGNoZWNrIHdoZW4gZGlzYWJsaW5nIG9yIGRpc2FibGVkIG9y IG5vIENSVEMgc2V0ICovCj4+Pj4+PiArCQlyZXR1cm4gMDsKPj4+Pj4+ICAgICAJaWYgKGNydGNf c3RhdGUtPmVuYWJsZSkKPj4+Pj4+ICAgICAJCWRybV9tb2RlX2dldF9odl90aW1pbmcoJmNydGNf c3RhdGUtPm1vZGUsCj4+Pj4+IEhtLCB0aGlzIGlzIGEgYml0IGFubm95aW5nLCBzaW5jZSB0aGUg Y2FuX3Bvc2l0aW9uID0gZmFsc2UgcGFyYW1ldGVyIHRvCj4+Pj4+IGRybV9hdG9taWNfaGVscGVy X2NoZWNrX3BsYW5lX3N0YXRlIGlzIHN1cHBvc2VkIHRvIGNhdGNoIGFsbCB0aGlzLiBXb3VsZAo+ Pj4+PiBtb3ZpbmcgYWxsIHRoZSBjaGVja3MgYWZ0ZXIgdGhlIGNhbGwgdG8gdGhhdCBoZWxwZXIs IGFuZCBnYXRpbmcgdGhlbSBvbgo+Pj4+PiBwbGFuZV9zdGF0ZS0+dmlzaWJsZSBhbHNvIHdvcms/ Cj4+Pj4gWWVzLCBpdCBkb2VzIHdvcmsgaWYgdGhpcyBpcyB3aGF0IHlvdSBtZWFuOgo+Pj4gSSB3 YXNuJ3Qgc3VyZSwgdGhhbmtzIGZvciBmaWd1cmluZyB0aGlzIG91dCEKPj4+Cj4+Pj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fc2ltcGxlX2ttc19oZWxwZXIuYwo+Pj4+IGIvZHJp dmVycy9ncHUvZHJtL2RybV9zaW1wbGVfa21zX2hlbHBlci5jCj4+Pj4gaW5kZXggYTA1ZWNhOWNl YzhiLi5jNDg4NThiYjI4MjMgMTAwNjQ0Cj4+Pj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9z aW1wbGVfa21zX2hlbHBlci5jCj4+Pj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9zaW1wbGVf a21zX2hlbHBlci5jCj4+Pj4gQEAgLTEyMiwxNCArMTIyLDYgQEAgc3RhdGljIGludCBkcm1fc2lt cGxlX2ttc19wbGFuZV9hdG9taWNfY2hlY2soc3RydWN0Cj4+Pj4gZHJtX3BsYW5lICpwbGFuZSwK Pj4+PiAgIMKgwqDCoMKgwqDCoMKgIGNydGNfc3RhdGUgPSBkcm1fYXRvbWljX2dldF9uZXdfY3J0 Y19zdGF0ZShwbGFuZV9zdGF0ZS0+c3RhdGUsCj4+Pj4gJnBpcGUtPmNydGMpOwo+Pj4+Cj4+Pj4g LcKgwqDCoMKgwqDCoCBpZiAoIWNydGNfc3RhdGUgfHwgIWNydGNfc3RhdGUtPmVuYWJsZSkKPj4+ PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAvKiBub3RoaW5nIHRvIGNoZWNrIHdoZW4g ZGlzYWJsaW5nIG9yIGRpc2FibGVkIG9yIG5vIENSVEMKPj4+PiBzZXQgKi8KPj4+PiAtwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCByZXR1cm4gMDsKPj4+PiAtCj4+Pj4gLcKgwqDCoMKgwqDC oCBpZiAoY3J0Y19zdGF0ZS0+ZW5hYmxlKQo+Pj4+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIGRybV9tb2RlX2dldF9odl90aW1pbmcoJmNydGNfc3RhdGUtPm1vZGUsCj4+Pj4gLcKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgICZjbGlwLngyLCAmY2xpcC55Mik7Cj4+Pj4gLQo+Pj4+ICAgwqDCoMKgwqDC oMKgwqAgcmV0ID0gZHJtX2F0b21pY19oZWxwZXJfY2hlY2tfcGxhbmVfc3RhdGUocGxhbmVfc3Rh dGUsIGNydGNfc3RhdGUsCj4+Pj4gICDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCAmY2xpcCwKPj4+PiBEUk1fUExBTkVfSEVMUEVSX05PX1NDQUxJTkcsCj4+Pj4gQEAg LTEzOCw2ICsxMzAsMTMgQEAgc3RhdGljIGludCBkcm1fc2ltcGxlX2ttc19wbGFuZV9hdG9taWNf Y2hlY2soc3RydWN0Cj4+Pj4gZHJtX3BsYW5lICpwbGFuZSwKPj4+PiAgIMKgwqDCoMKgwqDCoMKg IGlmIChyZXQpCj4+Pj4gICDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJuIHJl dDsKPj4+Pgo+Pj4+ICvCoMKgwqDCoMKgwqAgaWYgKCFwbGFuZV9zdGF0ZS0+dmlzaWJsZSB8fCAh Y3J0Y19zdGF0ZS0+ZW5hYmxlKQo+Pj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJl dHVybiAwOyAvKiBub3RoaW5nIHRvIGNoZWNrIHdoZW4gZGlzYWJsaW5nIG9yIGRpc2FibGVkICov Cj4+PiBpZiAoIXBsYW5lX3N0YXRlLT52aXNpYmxlKSB7Cj4+PiAJV0FSTl9PTihjcnRjX3N0YXRl LT5lbmFibGVkKTsKPj4+IAlyZXR1cm4gMDsKPj4+IH0KPj4+Cj4+PiBUaGUgaGVscGVyIGNhbGwg YWJvdmUgc2hvdWxkIGd1YXJhbnRlZSB0aGlzLgo+PiBZZXMsIGJ1dCBJIHN0aWxsIHNlZSBjYXNl cyB3aGVuIGNydGNfc3RhdGUgaXMgTlVMTCwgdGh1cwo+PiBtYWtpbmcgY3J0Y19zdGF0ZS0+ZW5h YmxlIHRvIGZhaWwKPiBSaWdodCwgd2hlbiB0aGUgcGxhbmUgaXMgY29tcGxldGVseSBvZmYgdGhl cmUncyBubyBDUlRDIHN0YXRlLiBDb3JyZWN0Cj4gY2hlY2sgc2hvdWxkIGJlCj4KPiAJV0FSTl9P TihjcnRjX3N0YXRlICYmIGNydGNfc3RhdGUtPmVuYWJsZWQpOwpvaywgd2lsbCB1cGRhdGUgd2l0 aCB0aGlzIGFkZGl0aW9uYWwgY2hlY2sKPgo+Pj4+ICsKPj4+PiArwqDCoMKgwqDCoMKgIGlmIChw bGFuZV9zdGF0ZS0+dmlzaWJsZSAmJiBjcnRjX3N0YXRlLT5lbmFibGUpCj4+PiBTaW1pbGFyIGhl cmUuCj4+Pgo+Pj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRybV9tb2RlX2dldF9o dl90aW1pbmcoJmNydGNfc3RhdGUtPm1vZGUsCj4+Pj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgICZjbGlw LngyLCAmY2xpcC55Mik7Cj4+Pj4gKwo+Pj4+ICAgwqDCoMKgwqDCoMKgwqAgaWYgKCFwbGFuZV9z dGF0ZS0+dmlzaWJsZSkKPj4+PiAgIMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCByZXR1 cm4gLUVJTlZBTDsKPj4+IFRoaXMgY2FuIG5vdyBiZSByZW1vdmVkLCB0aGUgcGxhbmUgaGVscGVy IHRha2VzIGNhcmUgb2YgY2hlY2tpbmcgZm9yCj4+PiBwbGFuZV9zdGF0ZS0+dmlzaWJsZSAhPSBj cnRjX3N0YXRlLT5lbmFibGUuIFBsZWFzZSBhbHNvIHJlbW92ZS4KPj4+Cj4+Pj4+IFdlJ2QgbmVl ZCB0byBhZGQgYSBndWFyYW50ZWUgdG8gZHJtX2F0b21pY19oZWxwZXJfY2hlY2tfcGxhbmVfc3Rh dGUgdGhhdAo+Pj4+PiBpdCBjYW4gY29wZSB3aXRoIGNydGNfc3RhdGUgPT0gTlVMTCwgYnV0IEkg dGhpbmsgdGhhdCdzIGEgZ29vZCBpZGVhCj4+Pj4+IGFueXdheS4gQXRtIGl0IHNob3VsZG4ndCBl bmQgdXAgbG9va2luZyBhdCB0aGUgY3J0Y19zdGF0ZSBwb2ludGVyIGluIHRoYXQKPj4+Pj4gY2Fz ZS4KPj4+PiBJdCBkb2Vzbid0IGxvb2sgYXQgaXQgYXQgdGhlIG1vbWVudAo+Pj4+PiBPdGhlcndp c2Ugd2UnbGwganVzdCBnbyB3aXRoIHlvdXIgZml4LCBidXQgaXQgZmVlbHMgYWxsIGEgYml0IHRv byBmcmFnaWxlLAo+Pj4+PiBoZW5jZSB3aHkgSSB3YW50IHRvIGV4cGxvcmUgbW9yZSByb2J1c3Qg b3B0aW9ucyBhIGJpdC4KPj4+PiBBdCBsaXN0IHdpdGggdGhlIGNoYW5nZSBhYm92ZSBpdCBwYXNz ZXMgbXkgdGVzdCB3aGljaCBmYWlsZWQKPj4+PiBiZWZvcmUuIEFsdGhvdWdoIEkgY2Fubm90IGNv bmZpcm0gaXQgd29ya3MgZm9yIG90aGVycywgYnV0IGl0Cj4+Pj4gY2VydGFpbmx5IGRvZXMgZm9y IG1lLgo+Pj4+PiAtRGFuaWVsCj4+Pj4gRG8geW91IHdhbnQgbWUgdG8gc2VuZCB2MSB3aXRoIHRo ZSBjb2RlIGFib3ZlPwo+Pj4gWWVzIHBsZWFzZSwgd2l0aCBteSBhYm92ZSBjbGVhbnVwIHN1Z2dl c3Rpb25zLgo+PiBQbGVhc2Ugc2VlIHRoZSBwYXRjaCB1bmRlciB0ZXN0IGF0dGFjaGVkIChJIGJl bGlldmUgaXQgaXMgd2hhdCB5b3UgbWVhbiwKPj4gd2l0aCB0aGUgb25seSBjaGFuZ2UgdGhhdAo+ PiAgwqDCoMKgIGlmICghcGxhbmVfc3RhdGUtPnZpc2libGUpIHsKPj4gIMKgwqDCoCDCoMKgwqAg KmlmIChjcnRjX3N0YXRlKSoKPj4gIMKgwqDCoCDCoMKgwqAgwqDCoMKgIFdBUk5fT04oY3J0Y19z dGF0ZS0+ZW5hYmxlKTsKPj4gIMKgwqDCoCDCoMKgwqAgcmV0dXJuIDA7Cj4+ICDCoMKgwqAgfQo+ PiBjaGVjayBpcyB1c2VkKS4KPj4KPj4gV2hpdGggdGhpcyBwYXRjaCArIGFkZGl0aW9uYWwgbG9n cyBJIGhhdmU6Cj4+Cj4+IFvCoMKgIDE4LjkzOTIwNF0gW2RybTpkcm1faW9jdGwgW2RybV1dIHBp ZD0yMTA1LCBkZXY9MHhlMjAwLCBhdXRoPTEsCj4+IERSTV9JT0NUTF9NT0RFX0FUT01JQwo+PiBb Li4uXQo+PiBbwqDCoCAxOC45Mzk2ODFdIFtkcm06ZHJtX2F0b21pY19zZXRfY3J0Y19mb3JfcGxh bmUgW2RybV1dIExpbmsgcGxhbmUgc3RhdGUKPj4gMDAwMDAwMDBjMzAyY2JiZiB0byBbTk9DUlRD XQo+PiBbwqDCoCAxOC45Mzk4MjJdIFtkcm06ZHJtX2F0b21pY19zZXRfZmJfZm9yX3BsYW5lIFtk cm1dXSBTZXQgW05PRkJdIGZvciBwbGFuZQo+PiBzdGF0ZSAwMDAwMDAwMGMzMDJjYmJmCj4+IFvC oMKgIDE4LjkzOTk2M10gW2RybTpkcm1fYXRvbWljX3ByaW50X3N0YXRlIFtkcm1dXSBjaGVja2lu ZyAwMDAwMDAwMDBiYzIyNGU3Cj4+IFvCoMKgIDE4LjkzOTk4OF0gdmRpc3BsIHZkaXNwbC4wOiBb ZHJtXSBwbGFuZVsyOV06IHBsYW5lLTAKPj4gW8KgwqAgMTguOTQwMDAzXSB2ZGlzcGwgdmRpc3Bs LjA6IFtkcm1dwqDCoCBjcnRjPShudWxsKQo+PiBbwqDCoCAxOC45NDAwMThdIHZkaXNwbCB2ZGlz cGwuMDogW2RybV3CoMKgIGZiPTAKPj4gW8KgwqAgMTguOTQwMDMyXSB2ZGlzcGwgdmRpc3BsLjA6 IFtkcm1dwqDCoCBjcnRjLXBvcz0weDArMCswCj4+IFvCoMKgIDE4Ljk0MDA0OF0gdmRpc3BsIHZk aXNwbC4wOiBbZHJtXQo+PiBzcmMtcG9zPTAuMDAwMDAweDAuMDAwMDAwKzAuMDAwMDAwKzAuMDAw MDAwCj4+IFvCoMKgIDE4Ljk0MDA2N10gdmRpc3BsIHZkaXNwbC4wOiBbZHJtXcKgwqAgcm90YXRp b249MQo+PiBbwqDCoCAxOC45NDAxOTldIFtkcm06ZHJtX2F0b21pY19jaGVja19vbmx5IFtkcm1d XSBjaGVja2luZyAwMDAwMDAwMDBiYzIyNGU3Cj4+IFvCoMKgIDE4Ljk0MDIyNl0gPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09IHBsYW5lX3N0YXRlLT52aXNpYmxlIDAKPj4gY3J0Y19z dGF0ZcKgwqDCoMKgwqDCoMKgwqDCoMKgIChudWxsKQo+PiBbLi4uXQo+PiBbwqDCoCAxOC45Nzgx NDZdIFtkcm06ZHJtX2F0b21pY19zZXRfY3J0Y19mb3JfcGxhbmUgW2RybV1dIExpbmsgcGxhbmUg c3RhdGUKPj4gMDAwMDAwMDA2YmQ1MDU4MCB0byBbQ1JUQzozMDpjcnRjLTBdCj4+IFvCoMKgIDE4 Ljk3ODI5Ml0gW2RybTpkcm1fYXRvbWljX3NldF9mYl9mb3JfcGxhbmUgW2RybV1dIFNldCBbRkI6 MzVdIGZvciBwbGFuZQo+PiBzdGF0ZSAwMDAwMDAwMDZiZDUwNTgwCj4+IFvCoMKgIDE4Ljk3ODk5 M10gW2RybTpkcm1fYXRvbWljX3NldF9tb2RlX3Byb3BfZm9yX2NydGMgW2RybV1dIFNldAo+PiBb TU9ERToxMDI0eDc2OF0gZm9yIENSVEMgc3RhdGUgMDAwMDAwMDBlNWEyOGY2YQo+PiBbwqDCoCAx OC45Nzk0MjVdIFtkcm06ZHJtX2F0b21pY19jaGVja19vbmx5IFtkcm1dXSBjaGVja2luZyAwMDAw MDAwMDBiYzIyNGU3Cj4+IFvCoMKgIDE4Ljk3OTU0MF0gW2RybTpkcm1fYXRvbWljX2hlbHBlcl9j aGVja19tb2Rlc2V0IFtkcm1fa21zX2hlbHBlcl1dCj4+IFtDUlRDOjMwOmNydGMtMF0gbW9kZSBj aGFuZ2VkCj4+IFvCoMKgIDE4Ljk3OTYzMl0gW2RybTpkcm1fYXRvbWljX2hlbHBlcl9jaGVja19t b2Rlc2V0IFtkcm1fa21zX2hlbHBlcl1dCj4+IFtDUlRDOjMwOmNydGMtMF0gZW5hYmxlIGNoYW5n ZWQKPj4gW8KgwqAgMTguOTc5NzA4XSBbZHJtOmRybV9hdG9taWNfaGVscGVyX2NoZWNrX21vZGVz ZXQgW2RybV9rbXNfaGVscGVyXV0KPj4gW0NSVEM6MzA6Y3J0Yy0wXSBhY3RpdmUgY2hhbmdlZAo+ PiBbwqDCoCAxOC45Nzk3OTJdIFtkcm06ZHJtX2F0b21pY19oZWxwZXJfY2hlY2tfbW9kZXNldCBb ZHJtX2ttc19oZWxwZXJdXQo+PiBVcGRhdGluZyByb3V0aW5nIGZvciBbQ09OTkVDVE9SOjI4OlZp cnR1YWwtMV0KPj4gW8KgwqAgMTguOTc5ODc3XSBbZHJtOmRybV9hdG9taWNfaGVscGVyX2NoZWNr X21vZGVzZXQgW2RybV9rbXNfaGVscGVyXV0KPj4gW0NPTk5FQ1RPUjoyODpWaXJ0dWFsLTFdIHVz aW5nIFtFTkNPREVSOjMxOk5vbmUtMzFdIG9uIFtDUlRDOjMwOmNydGMtMF0KPj4gW8KgwqAgMTgu OTc5OTYwXSBbZHJtOmRybV9hdG9taWNfaGVscGVyX2NoZWNrX21vZGVzZXQgW2RybV9rbXNfaGVs cGVyXV0KPj4gW0NSVEM6MzA6Y3J0Yy0wXSBuZWVkcyBhbGwgY29ubmVjdG9ycywgZW5hYmxlOiB5 LCBhY3RpdmU6IHkKPj4gW8KgwqAgMTguOTgwMTM5XSBbZHJtOmRybV9hdG9taWNfYWRkX2FmZmVj dGVkX2Nvbm5lY3RvcnMgW2RybV1dIEFkZGluZyBhbGwKPj4gY3VycmVudCBjb25uZWN0b3JzIGZv ciBbQ1JUQzozMDpjcnRjLTBdIHRvIDAwMDAwMDAwMGJjMjI0ZTcKPj4gW8KgwqAgMTguOTgwMTg0 XSA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gcGxhbmVfc3RhdGUtPnZpc2libGUg MAo+PiBjcnRjX3N0YXRlIDAwMDAwMDAwZTVhMjhmNmEKPj4gW8KgwqAgMTguOTgwMjA1XSBjcnRj X3N0YXRlLT5lbmFibGUgMQo+Pgo+PiAqW8KgwqAgMTkuMDIyNjA4XSBXQVJOSU5HOiBDUFU6IDEg UElEOiAyMTA1IGF0Cj4+IGRyaXZlcnMvZ3B1L2RybS9kcm1fc2ltcGxlX2ttc19oZWxwZXIuYzox MzcKPj4gZHJtX3NpbXBsZV9rbXNfcGxhbmVfYXRvbWljX2NoZWNrKzB4ZGMvMHhmOCBbZHJtX2tt c19oZWxwZXJdKgo+Pgo+PiBbLi4uXQo+Pgo+PiBbwqDCoCAxOS4xMTM2MDFdID09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PSBwbGFuZV9zdGF0ZS0+dmlzaWJsZSAwCj4+IGNydGNfc3Rh dGUgMDAwMDAwMDBlNWEyOGY2YQo+PiBbwqDCoCAxOS4xMTM2MjNdIGNydGNfc3RhdGUtPmVuYWJs ZSAxCj4+IFvCoMKgIDE5LjExMzc5Ml0gV0FSTklORzogQ1BVOiAxIFBJRDogMjEwNSBhdAo+PiBk cml2ZXJzL2dwdS9kcm0vZHJtX3NpbXBsZV9rbXNfaGVscGVyLmM6MTM3Cj4+IGRybV9zaW1wbGVf a21zX3BsYW5lX2F0b21pY19jaGVjaysweGRjLzB4ZjggW2RybV9rbXNfaGVscGVyXQo+Pgo+PiBb Li4uXQo+Pgo+PiBBbmQgZmluYWxseQo+Pgo+PiBbwqDCoCAxOS4zNDAyNDldID09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PSBwbGFuZV9zdGF0ZS0+dmlzaWJsZSAwCj4+IGNydGNfc3Rh dGUgMDAwMDAwMDAzNmExYjFmNQo+PiBbwqDCoCAxOS4zNDAyNzFdIGNydGNfc3RhdGUtPmVuYWJs ZSAwCj4+Cj4+IFNvLCBpdCBzZWVtcyB0aGF0IGNydGNfc3RhdGUgY2FuIHN0aWxsIGJlIE5VTEwg aWYgIiFwbGFuZV9zdGF0ZS0+dmlzaWJsZSIKPj4gbWFraW5nCj4+IE5VTEwgcG9pbnRlciBkZXJl ZmVyZW5jZSwgc28gd2UgbmVlZCBhIGNoZWNrIGZvciB0aGF0Lgo+PiBZZXQsICFwbGFuZV9zdGF0 ZS0+dmlzaWJsZSAmJiBjcnRjX3N0YXRlLT5lbmFibGUgbWFrZXMgV0FSTl9PTiB0byBmaXJlCj4+ IGFsd2F5cy4gU28sIHByb2JhYmx5IHdlIG1heSB3YW50IHJlbW92aW5nIGl0Lgo+Pj4gVGhhbmtz LCBEYW5pZWwKPj4gVGhhbmsgeW91LAo+PiBPbGVrc2FuZHIKPj4gIEZyb20gZGJjY2U3MDhiMjM3 NzQwMTU4YTJjMTYwMjljNTZhNTc5MzI0ZjI2OSBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKPj4g RnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgo+PiBEYXRlOiBUdWUsIDEzIEZlYiAyMDE4IDEwOjMyOjIwICswMjAwCj4+IFN1Ympl Y3Q6IFtQQVRDSF0gZHJtL3NpbXBsZV9rbXNfaGVscGVyOiBGaXggTlVMTCBwb2ludGVyIGRlcmVm ZXJlbmNlIHdpdGggbm8KPj4gICBhY3RpdmUgQ1JUQwo+Pgo+PiBJdCBpcyBwb3NzaWJsZSB0aGF0 IGRybV9zaW1wbGVfa21zX3BsYW5lX2F0b21pY19jaGVjayBjYWxsZWQKPj4gd2l0aCBubyBDUlRD IHNldCwgZS5nLiB3aGVuIHVzZXItc3BhY2UgYXBwbGljYXRpb24gc2V0cyBDUlRDX0lEL0ZCX0lE Cj4+IHRvIDAgYmVmb3JlIGRvaW5nIGFueSBhY3R1YWwgZHJhd2luZy4gVGhpcyBsZWFkcyB0byBO VUxMIHBvaW50ZXIKPj4gZGVyZWZlcmVuY2UgYmVjYXVzZSBpbiB0aGlzIGNhc2UgbmV3IENSVEMg c3RhdGUgaXMgTlVMTCBhbmQgbXVzdCBiZQo+PiBjaGVja2VkIGJlZm9yZSBhY2Nlc3NpbmcuCj4+ Cj4+IFNpZ25lZC1vZmYtYnk6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5k cnVzaGNoZW5rb0BlcGFtLmNvbT4KPj4gLS0tCj4+ICAgZHJpdmVycy9ncHUvZHJtL2RybV9zaW1w bGVfa21zX2hlbHBlci5jIHwgMTUgKysrKysrKy0tLS0tLS0tCj4+ICAgMSBmaWxlIGNoYW5nZWQs IDcgaW5zZXJ0aW9ucygrKSwgOCBkZWxldGlvbnMoLSkKPj4KPj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9kcm1fc2ltcGxlX2ttc19oZWxwZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1f c2ltcGxlX2ttc19oZWxwZXIuYwo+PiBpbmRleCA5Y2E4YTRhNTliNzQuLmY1NDcxMWZmOTc2NyAx MDA2NDQKPj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9zaW1wbGVfa21zX2hlbHBlci5jCj4+ ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fc2ltcGxlX2ttc19oZWxwZXIuYwo+PiBAQCAtMTIx LDEyICsxMjEsNiBAQCBzdGF0aWMgaW50IGRybV9zaW1wbGVfa21zX3BsYW5lX2F0b21pY19jaGVj ayhzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwKPj4gICAJcGlwZSA9IGNvbnRhaW5lcl9vZihwbGFu ZSwgc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlLCBwbGFuZSk7Cj4+ICAgCWNydGNfc3Rh dGUgPSBkcm1fYXRvbWljX2dldF9uZXdfY3J0Y19zdGF0ZShwbGFuZV9zdGF0ZS0+c3RhdGUsCj4+ ICAgCQkJCQkJICAgJnBpcGUtPmNydGMpOwo+PiAtCWlmICghY3J0Y19zdGF0ZS0+ZW5hYmxlKQo+ PiAtCQlyZXR1cm4gMDsgLyogbm90aGluZyB0byBjaGVjayB3aGVuIGRpc2FibGluZyBvciBkaXNh YmxlZCAqLwo+PiAtCj4+IC0JaWYgKGNydGNfc3RhdGUtPmVuYWJsZSkKPj4gLQkJZHJtX21vZGVf Z2V0X2h2X3RpbWluZygmY3J0Y19zdGF0ZS0+bW9kZSwKPj4gLQkJCQkgICAgICAgJmNsaXAueDIs ICZjbGlwLnkyKTsKPj4gICAKPj4gICAJcmV0ID0gZHJtX2F0b21pY19oZWxwZXJfY2hlY2tfcGxh bmVfc3RhdGUocGxhbmVfc3RhdGUsIGNydGNfc3RhdGUsCj4+ICAgCQkJCQkJICAmY2xpcCwKPj4g QEAgLTEzNiw4ICsxMzAsMTMgQEAgc3RhdGljIGludCBkcm1fc2ltcGxlX2ttc19wbGFuZV9hdG9t aWNfY2hlY2soc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCj4+ICAgCWlmIChyZXQpCj4+ICAgCQly ZXR1cm4gcmV0Owo+PiAgIAo+PiAtCWlmICghcGxhbmVfc3RhdGUtPnZpc2libGUpCj4+IC0JCXJl dHVybiAtRUlOVkFMOwo+PiArCWlmICghcGxhbmVfc3RhdGUtPnZpc2libGUpIHsKPj4gKwkJaWYg KGNydGNfc3RhdGUpCj4+ICsJCQlXQVJOX09OKGNydGNfc3RhdGUtPmVuYWJsZSk7Cj4+ICsJCXJl dHVybiAwOwo+PiArCX0KPj4gKwo+PiArCWRybV9tb2RlX2dldF9odl90aW1pbmcoJmNydGNfc3Rh dGUtPm1vZGUsICZjbGlwLngyLCAmY2xpcC55Mik7Cj4gbGd0bS4gV2l0aCBvciB3aXRob3V0IHRo ZSBiaWtlc2hlZCB0byBwdWxsIHRoZSBjcnRjX3N0YXRlIGNoZWNrIGludG8gdGhlCj4gV0FSTl9P Ti4KPgo+IFJldmlld2VkLWJ5OiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGZmd2xsLmNo PgpUaGFuayB5b3UKPgo+IFBsZWFzZSByZXN1Ym1pdCBhcyBhIHN0YW5kLWFsb25lIHBhdGNoLCBw YXRjaHdvcmsgY2FuJ3QgcHVsbCBwYXRjaGVzIG91dAo+IG9mIGF0dGFjaG1lbnRzIDotLwpvaCwg dGhhdCB3YXMgZm9yIGRlbW9uc3RyYXRpb24gcHVycG9zZSBvbmx5LCBzbyB3ZQphcmUgb24gdGhl IHNhbWUgcGFnZSBhbmQgc2VlIHRoZSBwYXRjaCB3ZSBhcmUgZGlzY3Vzc2luZyA7KQo+IC1EYW5p ZWwKPgo+PiAgIAo+PiAgIAlpZiAoIXBpcGUtPmZ1bmNzIHx8ICFwaXBlLT5mdW5jcy0+Y2hlY2sp Cj4+ICAgCQlyZXR1cm4gMDsKPj4gLS0gCj4+IDIuNy40Cj4+Cj4+IF9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCj4+IGRyaS1kZXZlbCBtYWlsaW5nIGxpc3QK Pj4gZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwo+PiBodHRwczovL2xpc3RzLmZyZWVk ZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo+CgpfX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRy aS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5v cmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK