From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-14.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,HK_RANDOM_FROM,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id CC28CC4708A for ; Thu, 27 May 2021 08:53:54 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 896F26135F for ; Thu, 27 May 2021 08:53:54 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 896F26135F Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 82CF06E102; Thu, 27 May 2021 08:53:52 +0000 (UTC) Received: from mga12.intel.com (mga12.intel.com [192.55.52.136]) by gabe.freedesktop.org (Postfix) with ESMTPS id 152966E045; Thu, 27 May 2021 08:53:50 +0000 (UTC) IronPort-SDR: 2bfc94O2niXewDbv/BDAMQLK7t2oW17o0eEtGmj0SKlWpiwzj+X4TVmTzo2aDzVyUtMKdEgzbZ k5ZhvF1eEqGg== X-IronPort-AV: E=McAfee;i="6200,9189,9996"; a="182339458" X-IronPort-AV: E=Sophos;i="5.82,334,1613462400"; d="scan'208";a="182339458" Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by fmsmga106.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 27 May 2021 01:53:49 -0700 IronPort-SDR: /sVHfX/zrUvK3o/bu9Fk5hvP86TOyERbGHtC+lJq/3ciQe8gQF55BqsxQrX1RgniVMIe06IDH6 CSgJ+g7KtURA== X-IronPort-AV: E=Sophos;i="5.82,334,1613462400"; d="scan'208";a="547605361" Received: from amoses-mobl1.ger.corp.intel.com (HELO [10.213.211.53]) ([10.213.211.53]) by fmsmga001-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 27 May 2021 01:53:48 -0700 Subject: Re: [Intel-gfx] [RFC PATCH 60/97] drm/i915: Track 'serial' counts for virtual engines To: John Harrison , Matthew Brost References: <20210506191451.77768-1-matthew.brost@intel.com> <20210506191451.77768-61-matthew.brost@intel.com> <20210525175239.GA21324@sdutt-i7> <6f6a1266-fe48-9cf1-beba-0b4463000ca7@linux.intel.com> <15643bd8-a270-a84d-3bd7-5376af7e378c@intel.com> From: Tvrtko Ursulin Organization: Intel Corporation UK Plc Message-ID: <018044c0-d238-2060-99a4-a477d225781e@linux.intel.com> Date: Thu, 27 May 2021 09:53:46 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.8.1 MIME-Version: 1.0 In-Reply-To: <15643bd8-a270-a84d-3bd7-5376af7e378c@intel.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: jason.ekstrand@intel.com, daniel.vetter@intel.com, intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" On 26/05/2021 19:45, John Harrison wrote: > On 5/26/2021 01:40, Tvrtko Ursulin wrote: >> On 25/05/2021 18:52, Matthew Brost wrote: >>> On Tue, May 25, 2021 at 11:16:12AM +0100, Tvrtko Ursulin wrote: >>>> >>>> On 06/05/2021 20:14, Matthew Brost wrote: >>>>> From: John Harrison >>>>> >>>>> The serial number tracking of engines happens at the backend of >>>>> request submission and was expecting to only be given physical >>>>> engines. However, in GuC submission mode, the decomposition of virtual >>>>> to physical engines does not happen in i915. Instead, requests are >>>>> submitted to their virtual engine mask all the way through to the >>>>> hardware (i.e. to GuC). This would mean that the heart beat code >>>>> thinks the physical engines are idle due to the serial number not >>>>> incrementing. >>>>> >>>>> This patch updates the tracking to decompose virtual engines into >>>>> their physical constituents and tracks the request against each. This >>>>> is not entirely accurate as the GuC will only be issuing the request >>>>> to one physical engine. However, it is the best that i915 can do given >>>>> that it has no knowledge of the GuC's scheduling decisions. >>>> >>>> Commit text sounds a bit defeatist. I think instead of making up the >>>> serial >>>> counts, which has downsides (could you please document in the commit >>>> what >>>> they are), we should think how to design things properly. >>>> >>> >>> IMO, I don't think fixing serial counts is the scope of this series. We >>> should focus on getting GuC submission in not cleaning up all the crap >>> that is in the i915. Let's make a note of this though so we can revisit >>> later. >> >> I will say again - commit message implies it is introducing an >> unspecified downside by not fully fixing an also unspecified issue. It >> is completely reasonable, and customary even, to ask for both to be >> documented in the commit message. > Not sure what exactly is 'unspecified'. I thought the commit message > described both the problem (heartbeat not running when using virtual > engines) and the result (heartbeat running on more engines than strictly > necessary). But in greater detail... > > The serial number tracking is a hack for the heartbeat code to know > whether an engine is busy or idle, and therefore whether it should be > pinged for aliveness. Whenever a submission is made to an engine, the > serial number is incremented. The heartbeat code keeps a copy of the > value. If the value has changed, the engine is busy and needs to be pinged. > > This works fine for execlist mode where virtual engine decomposition is > done inside i915. It fails miserably for GuC mode where the > decomposition is done by the hardware. The reason being that the > heartbeat code only looks at physical engines but the serial count is > only incremented on the virtual engine. Thus, the heartbeat sees > everything as idle and does not ping. So hangcheck does not work. Or it works because GuC does it anyway. Either way, that's one thing to explicitly state in the commit message. > This patch decomposes the virtual engines for the sake of incrementing > the serial count on each sub-engine in order to keep the heartbeat code > happy. The downside is that now the heartbeat sees all sub-engines as > busy rather than only the one the submission actually ends up on. There > really isn't much that can be done about that. The heartbeat code is in > i915 not GuC, the scheduler is in GuC not i915. The only way to improve > it is to either move the heartbeat code into GuC as well and completely > disable the i915 side, or add some way for i915 to interrogate GuC as to > which engines are or are not active. Technically, we do have both. GuC > has (or at least had) an option to force a context switch on every > execution quantum pre-emption. However, that is much, much, more heavy > weight than the heartbeat. For the latter, we do (almost) have the > engine usage statistics for PMU and such like. I'm not sure how much > effort it would be to wire that up to the heartbeat code instead of > using the serial count. > > In short, the serial count is ever so slightly inefficient in that it > causes heartbeat pings on engines which are idle. On the other hand, it > is way more efficient and simpler than the current alternatives. And the hack to make hangcheck work creates this inefficiency where heartbeats are sent to idle engines. Which is probably fine just needs to be explained. > Does that answer the questions? With the two points I re-raise clearly explained, possibly even patch title changed, yeah. I am just wanting for it to be more easily obvious to patch reader what it is functionally about - not just what implementation details have been change but why as well. Regards, Tvrtko > John. > > >> >> If we are abandoning the normal review process someone please say so I >> don't waste my time reading it. >> >> Regards, >> >> Tvrtko >> >>> Matt >>> >>>> Regards, >>>> >>>> Tvrtko >>>> >>>>> Signed-off-by: John Harrison >>>>> Signed-off-by: Matthew Brost >>>>> --- >>>>>    drivers/gpu/drm/i915/gt/intel_engine_types.h     |  2 ++ >>>>>    .../gpu/drm/i915/gt/intel_execlists_submission.c |  6 ++++++ >>>>>    drivers/gpu/drm/i915/gt/intel_ring_submission.c  |  6 ++++++ >>>>>    drivers/gpu/drm/i915/gt/mock_engine.c            |  6 ++++++ >>>>>    .../gpu/drm/i915/gt/uc/intel_guc_submission.c    | 16 >>>>> ++++++++++++++++ >>>>>    drivers/gpu/drm/i915/i915_request.c              |  4 +++- >>>>>    6 files changed, 39 insertions(+), 1 deletion(-) >>>>> >>>>> diff --git a/drivers/gpu/drm/i915/gt/intel_engine_types.h >>>>> b/drivers/gpu/drm/i915/gt/intel_engine_types.h >>>>> index 86302e6d86b2..e2b5cda6dbc4 100644 >>>>> --- a/drivers/gpu/drm/i915/gt/intel_engine_types.h >>>>> +++ b/drivers/gpu/drm/i915/gt/intel_engine_types.h >>>>> @@ -389,6 +389,8 @@ struct intel_engine_cs { >>>>>        void        (*park)(struct intel_engine_cs *engine); >>>>>        void        (*unpark)(struct intel_engine_cs *engine); >>>>> +    void        (*bump_serial)(struct intel_engine_cs *engine); >>>>> + >>>>>        void        (*set_default_submission)(struct intel_engine_cs >>>>> *engine); >>>>>        const struct intel_context_ops *cops; >>>>> diff --git a/drivers/gpu/drm/i915/gt/intel_execlists_submission.c >>>>> b/drivers/gpu/drm/i915/gt/intel_execlists_submission.c >>>>> index ae12d7f19ecd..02880ea5d693 100644 >>>>> --- a/drivers/gpu/drm/i915/gt/intel_execlists_submission.c >>>>> +++ b/drivers/gpu/drm/i915/gt/intel_execlists_submission.c >>>>> @@ -3199,6 +3199,11 @@ static void execlists_release(struct >>>>> intel_engine_cs *engine) >>>>>        lrc_fini_wa_ctx(engine); >>>>>    } >>>>> +static void execlist_bump_serial(struct intel_engine_cs *engine) >>>>> +{ >>>>> +    engine->serial++; >>>>> +} >>>>> + >>>>>    static void >>>>>    logical_ring_default_vfuncs(struct intel_engine_cs *engine) >>>>>    { >>>>> @@ -3208,6 +3213,7 @@ logical_ring_default_vfuncs(struct >>>>> intel_engine_cs *engine) >>>>>        engine->cops = &execlists_context_ops; >>>>>        engine->request_alloc = execlists_request_alloc; >>>>> +    engine->bump_serial = execlist_bump_serial; >>>>>        engine->reset.prepare = execlists_reset_prepare; >>>>>        engine->reset.rewind = execlists_reset_rewind; >>>>> diff --git a/drivers/gpu/drm/i915/gt/intel_ring_submission.c >>>>> b/drivers/gpu/drm/i915/gt/intel_ring_submission.c >>>>> index 14aa31879a37..39dd7c4ed0a9 100644 >>>>> --- a/drivers/gpu/drm/i915/gt/intel_ring_submission.c >>>>> +++ b/drivers/gpu/drm/i915/gt/intel_ring_submission.c >>>>> @@ -1045,6 +1045,11 @@ static void setup_irq(struct intel_engine_cs >>>>> *engine) >>>>>        } >>>>>    } >>>>> +static void ring_bump_serial(struct intel_engine_cs *engine) >>>>> +{ >>>>> +    engine->serial++; >>>>> +} >>>>> + >>>>>    static void setup_common(struct intel_engine_cs *engine) >>>>>    { >>>>>        struct drm_i915_private *i915 = engine->i915; >>>>> @@ -1064,6 +1069,7 @@ static void setup_common(struct >>>>> intel_engine_cs *engine) >>>>>        engine->cops = &ring_context_ops; >>>>>        engine->request_alloc = ring_request_alloc; >>>>> +    engine->bump_serial = ring_bump_serial; >>>>>        /* >>>>>         * Using a global execution timeline; the previous final >>>>> breadcrumb is >>>>> diff --git a/drivers/gpu/drm/i915/gt/mock_engine.c >>>>> b/drivers/gpu/drm/i915/gt/mock_engine.c >>>>> index bd005c1b6fd5..97b10fd60b55 100644 >>>>> --- a/drivers/gpu/drm/i915/gt/mock_engine.c >>>>> +++ b/drivers/gpu/drm/i915/gt/mock_engine.c >>>>> @@ -292,6 +292,11 @@ static void mock_engine_release(struct >>>>> intel_engine_cs *engine) >>>>>        intel_engine_fini_retire(engine); >>>>>    } >>>>> +static void mock_bump_serial(struct intel_engine_cs *engine) >>>>> +{ >>>>> +    engine->serial++; >>>>> +} >>>>> + >>>>>    struct intel_engine_cs *mock_engine(struct drm_i915_private *i915, >>>>>                        const char *name, >>>>>                        int id) >>>>> @@ -318,6 +323,7 @@ struct intel_engine_cs *mock_engine(struct >>>>> drm_i915_private *i915, >>>>>        engine->base.cops = &mock_context_ops; >>>>>        engine->base.request_alloc = mock_request_alloc; >>>>> +    engine->base.bump_serial = mock_bump_serial; >>>>>        engine->base.emit_flush = mock_emit_flush; >>>>>        engine->base.emit_fini_breadcrumb = mock_emit_breadcrumb; >>>>>        engine->base.submit_request = mock_submit_request; >>>>> diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c >>>>> b/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c >>>>> index dc79d287c50a..f0e5731bcef6 100644 >>>>> --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c >>>>> +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c >>>>> @@ -1500,6 +1500,20 @@ static void guc_release(struct >>>>> intel_engine_cs *engine) >>>>>        lrc_fini_wa_ctx(engine); >>>>>    } >>>>> +static void guc_bump_serial(struct intel_engine_cs *engine) >>>>> +{ >>>>> +    engine->serial++; >>>>> +} >>>>> + >>>>> +static void virtual_guc_bump_serial(struct intel_engine_cs *engine) >>>>> +{ >>>>> +    struct intel_engine_cs *e; >>>>> +    intel_engine_mask_t tmp, mask = engine->mask; >>>>> + >>>>> +    for_each_engine_masked(e, engine->gt, mask, tmp) >>>>> +        e->serial++; >>>>> +} >>>>> + >>>>>    static void guc_default_vfuncs(struct intel_engine_cs *engine) >>>>>    { >>>>>        /* Default vfuncs which can be overridden by each engine. */ >>>>> @@ -1508,6 +1522,7 @@ static void guc_default_vfuncs(struct >>>>> intel_engine_cs *engine) >>>>>        engine->cops = &guc_context_ops; >>>>>        engine->request_alloc = guc_request_alloc; >>>>> +    engine->bump_serial = guc_bump_serial; >>>>>        engine->sched_engine->schedule = i915_schedule; >>>>> @@ -1843,6 +1858,7 @@ guc_create_virtual(struct intel_engine_cs >>>>> **siblings, unsigned int count) >>>>>        ve->base.cops = &virtual_guc_context_ops; >>>>>        ve->base.request_alloc = guc_request_alloc; >>>>> +    ve->base.bump_serial = virtual_guc_bump_serial; >>>>>        ve->base.submit_request = guc_submit_request; >>>>> diff --git a/drivers/gpu/drm/i915/i915_request.c >>>>> b/drivers/gpu/drm/i915/i915_request.c >>>>> index 9542a5baa45a..127d60b36422 100644 >>>>> --- a/drivers/gpu/drm/i915/i915_request.c >>>>> +++ b/drivers/gpu/drm/i915/i915_request.c >>>>> @@ -692,7 +692,9 @@ bool __i915_request_submit(struct i915_request >>>>> *request) >>>>>                         request->ring->vaddr + request->postfix); >>>>>        trace_i915_request_execute(request); >>>>> -    engine->serial++; >>>>> +    if (engine->bump_serial) >>>>> +        engine->bump_serial(engine); >>>>> + >>>>>        result = true; >>>>>        GEM_BUG_ON(test_bit(I915_FENCE_FLAG_ACTIVE, >>>>> &request->fence.flags)); >>>>> >> _______________________________________________ >> Intel-gfx mailing list >> Intel-gfx@lists.freedesktop.org >> https://lists.freedesktop.org/mailman/listinfo/intel-gfx > From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-14.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,HK_RANDOM_FROM,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 394E7C4707F for ; Thu, 27 May 2021 08:53:53 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id AA2236135F for ; Thu, 27 May 2021 08:53:52 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org AA2236135F Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 4BB8E6E045; Thu, 27 May 2021 08:53:52 +0000 (UTC) Received: from mga12.intel.com (mga12.intel.com [192.55.52.136]) by gabe.freedesktop.org (Postfix) with ESMTPS id 152966E045; Thu, 27 May 2021 08:53:50 +0000 (UTC) IronPort-SDR: 2bfc94O2niXewDbv/BDAMQLK7t2oW17o0eEtGmj0SKlWpiwzj+X4TVmTzo2aDzVyUtMKdEgzbZ k5ZhvF1eEqGg== X-IronPort-AV: E=McAfee;i="6200,9189,9996"; a="182339458" X-IronPort-AV: E=Sophos;i="5.82,334,1613462400"; d="scan'208";a="182339458" Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by fmsmga106.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 27 May 2021 01:53:49 -0700 IronPort-SDR: /sVHfX/zrUvK3o/bu9Fk5hvP86TOyERbGHtC+lJq/3ciQe8gQF55BqsxQrX1RgniVMIe06IDH6 CSgJ+g7KtURA== X-IronPort-AV: E=Sophos;i="5.82,334,1613462400"; d="scan'208";a="547605361" Received: from amoses-mobl1.ger.corp.intel.com (HELO [10.213.211.53]) ([10.213.211.53]) by fmsmga001-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 27 May 2021 01:53:48 -0700 To: John Harrison , Matthew Brost References: <20210506191451.77768-1-matthew.brost@intel.com> <20210506191451.77768-61-matthew.brost@intel.com> <20210525175239.GA21324@sdutt-i7> <6f6a1266-fe48-9cf1-beba-0b4463000ca7@linux.intel.com> <15643bd8-a270-a84d-3bd7-5376af7e378c@intel.com> From: Tvrtko Ursulin Organization: Intel Corporation UK Plc Message-ID: <018044c0-d238-2060-99a4-a477d225781e@linux.intel.com> Date: Thu, 27 May 2021 09:53:46 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.8.1 MIME-Version: 1.0 In-Reply-To: <15643bd8-a270-a84d-3bd7-5376af7e378c@intel.com> Content-Language: en-US Subject: Re: [Intel-gfx] [RFC PATCH 60/97] drm/i915: Track 'serial' counts for virtual engines X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: jason.ekstrand@intel.com, daniel.vetter@intel.com, intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" Ck9uIDI2LzA1LzIwMjEgMTk6NDUsIEpvaG4gSGFycmlzb24gd3JvdGU6Cj4gT24gNS8yNi8yMDIx IDAxOjQwLCBUdnJ0a28gVXJzdWxpbiB3cm90ZToKPj4gT24gMjUvMDUvMjAyMSAxODo1MiwgTWF0 dGhldyBCcm9zdCB3cm90ZToKPj4+IE9uIFR1ZSwgTWF5IDI1LCAyMDIxIGF0IDExOjE2OjEyQU0g KzAxMDAsIFR2cnRrbyBVcnN1bGluIHdyb3RlOgo+Pj4+Cj4+Pj4gT24gMDYvMDUvMjAyMSAyMDox NCwgTWF0dGhldyBCcm9zdCB3cm90ZToKPj4+Pj4gRnJvbTogSm9obiBIYXJyaXNvbiA8Sm9obi5D LkhhcnJpc29uQEludGVsLmNvbT4KPj4+Pj4KPj4+Pj4gVGhlIHNlcmlhbCBudW1iZXIgdHJhY2tp bmcgb2YgZW5naW5lcyBoYXBwZW5zIGF0IHRoZSBiYWNrZW5kIG9mCj4+Pj4+IHJlcXVlc3Qgc3Vi bWlzc2lvbiBhbmQgd2FzIGV4cGVjdGluZyB0byBvbmx5IGJlIGdpdmVuIHBoeXNpY2FsCj4+Pj4+ IGVuZ2luZXMuIEhvd2V2ZXIsIGluIEd1QyBzdWJtaXNzaW9uIG1vZGUsIHRoZSBkZWNvbXBvc2l0 aW9uIG9mIHZpcnR1YWwKPj4+Pj4gdG8gcGh5c2ljYWwgZW5naW5lcyBkb2VzIG5vdCBoYXBwZW4g aW4gaTkxNS4gSW5zdGVhZCwgcmVxdWVzdHMgYXJlCj4+Pj4+IHN1Ym1pdHRlZCB0byB0aGVpciB2 aXJ0dWFsIGVuZ2luZSBtYXNrIGFsbCB0aGUgd2F5IHRocm91Z2ggdG8gdGhlCj4+Pj4+IGhhcmR3 YXJlIChpLmUuIHRvIEd1QykuIFRoaXMgd291bGQgbWVhbiB0aGF0IHRoZSBoZWFydCBiZWF0IGNv ZGUKPj4+Pj4gdGhpbmtzIHRoZSBwaHlzaWNhbCBlbmdpbmVzIGFyZSBpZGxlIGR1ZSB0byB0aGUg c2VyaWFsIG51bWJlciBub3QKPj4+Pj4gaW5jcmVtZW50aW5nLgo+Pj4+Pgo+Pj4+PiBUaGlzIHBh dGNoIHVwZGF0ZXMgdGhlIHRyYWNraW5nIHRvIGRlY29tcG9zZSB2aXJ0dWFsIGVuZ2luZXMgaW50 bwo+Pj4+PiB0aGVpciBwaHlzaWNhbCBjb25zdGl0dWVudHMgYW5kIHRyYWNrcyB0aGUgcmVxdWVz dCBhZ2FpbnN0IGVhY2guIFRoaXMKPj4+Pj4gaXMgbm90IGVudGlyZWx5IGFjY3VyYXRlIGFzIHRo ZSBHdUMgd2lsbCBvbmx5IGJlIGlzc3VpbmcgdGhlIHJlcXVlc3QKPj4+Pj4gdG8gb25lIHBoeXNp Y2FsIGVuZ2luZS4gSG93ZXZlciwgaXQgaXMgdGhlIGJlc3QgdGhhdCBpOTE1IGNhbiBkbyBnaXZl bgo+Pj4+PiB0aGF0IGl0IGhhcyBubyBrbm93bGVkZ2Ugb2YgdGhlIEd1QydzIHNjaGVkdWxpbmcg ZGVjaXNpb25zLgo+Pj4+Cj4+Pj4gQ29tbWl0IHRleHQgc291bmRzIGEgYml0IGRlZmVhdGlzdC4g SSB0aGluayBpbnN0ZWFkIG9mIG1ha2luZyB1cCB0aGUgCj4+Pj4gc2VyaWFsCj4+Pj4gY291bnRz LCB3aGljaCBoYXMgZG93bnNpZGVzIChjb3VsZCB5b3UgcGxlYXNlIGRvY3VtZW50IGluIHRoZSBj b21taXQgCj4+Pj4gd2hhdAo+Pj4+IHRoZXkgYXJlKSwgd2Ugc2hvdWxkIHRoaW5rIGhvdyB0byBk ZXNpZ24gdGhpbmdzIHByb3Blcmx5Lgo+Pj4+Cj4+Pgo+Pj4gSU1PLCBJIGRvbid0IHRoaW5rIGZp eGluZyBzZXJpYWwgY291bnRzIGlzIHRoZSBzY29wZSBvZiB0aGlzIHNlcmllcy4gV2UKPj4+IHNo b3VsZCBmb2N1cyBvbiBnZXR0aW5nIEd1QyBzdWJtaXNzaW9uIGluIG5vdCBjbGVhbmluZyB1cCBh bGwgdGhlIGNyYXAKPj4+IHRoYXQgaXMgaW4gdGhlIGk5MTUuIExldCdzIG1ha2UgYSBub3RlIG9m IHRoaXMgdGhvdWdoIHNvIHdlIGNhbiByZXZpc2l0Cj4+PiBsYXRlci4KPj4KPj4gSSB3aWxsIHNh eSBhZ2FpbiAtIGNvbW1pdCBtZXNzYWdlIGltcGxpZXMgaXQgaXMgaW50cm9kdWNpbmcgYW4gCj4+ IHVuc3BlY2lmaWVkIGRvd25zaWRlIGJ5IG5vdCBmdWxseSBmaXhpbmcgYW4gYWxzbyB1bnNwZWNp ZmllZCBpc3N1ZS4gSXQgCj4+IGlzIGNvbXBsZXRlbHkgcmVhc29uYWJsZSwgYW5kIGN1c3RvbWFy eSBldmVuLCB0byBhc2sgZm9yIGJvdGggdG8gYmUgCj4+IGRvY3VtZW50ZWQgaW4gdGhlIGNvbW1p dCBtZXNzYWdlLgo+IE5vdCBzdXJlIHdoYXQgZXhhY3RseSBpcyAndW5zcGVjaWZpZWQnLiBJIHRo b3VnaHQgdGhlIGNvbW1pdCBtZXNzYWdlIAo+IGRlc2NyaWJlZCBib3RoIHRoZSBwcm9ibGVtICho ZWFydGJlYXQgbm90IHJ1bm5pbmcgd2hlbiB1c2luZyB2aXJ0dWFsIAo+IGVuZ2luZXMpIGFuZCB0 aGUgcmVzdWx0IChoZWFydGJlYXQgcnVubmluZyBvbiBtb3JlIGVuZ2luZXMgdGhhbiBzdHJpY3Rs eSAKPiBuZWNlc3NhcnkpLiBCdXQgaW4gZ3JlYXRlciBkZXRhaWwuLi4KPiAKPiBUaGUgc2VyaWFs IG51bWJlciB0cmFja2luZyBpcyBhIGhhY2sgZm9yIHRoZSBoZWFydGJlYXQgY29kZSB0byBrbm93 IAo+IHdoZXRoZXIgYW4gZW5naW5lIGlzIGJ1c3kgb3IgaWRsZSwgYW5kIHRoZXJlZm9yZSB3aGV0 aGVyIGl0IHNob3VsZCBiZSAKPiBwaW5nZWQgZm9yIGFsaXZlbmVzcy4gV2hlbmV2ZXIgYSBzdWJt aXNzaW9uIGlzIG1hZGUgdG8gYW4gZW5naW5lLCB0aGUgCj4gc2VyaWFsIG51bWJlciBpcyBpbmNy ZW1lbnRlZC4gVGhlIGhlYXJ0YmVhdCBjb2RlIGtlZXBzIGEgY29weSBvZiB0aGUgCj4gdmFsdWUu IElmIHRoZSB2YWx1ZSBoYXMgY2hhbmdlZCwgdGhlIGVuZ2luZSBpcyBidXN5IGFuZCBuZWVkcyB0 byBiZSBwaW5nZWQuCj4gCj4gVGhpcyB3b3JrcyBmaW5lIGZvciBleGVjbGlzdCBtb2RlIHdoZXJl IHZpcnR1YWwgZW5naW5lIGRlY29tcG9zaXRpb24gaXMgCj4gZG9uZSBpbnNpZGUgaTkxNS4gSXQg ZmFpbHMgbWlzZXJhYmx5IGZvciBHdUMgbW9kZSB3aGVyZSB0aGUgCj4gZGVjb21wb3NpdGlvbiBp cyBkb25lIGJ5IHRoZSBoYXJkd2FyZS4gVGhlIHJlYXNvbiBiZWluZyB0aGF0IHRoZSAKPiBoZWFy dGJlYXQgY29kZSBvbmx5IGxvb2tzIGF0IHBoeXNpY2FsIGVuZ2luZXMgYnV0IHRoZSBzZXJpYWwg Y291bnQgaXMgCj4gb25seSBpbmNyZW1lbnRlZCBvbiB0aGUgdmlydHVhbCBlbmdpbmUuIFRodXMs IHRoZSBoZWFydGJlYXQgc2VlcyAKPiBldmVyeXRoaW5nIGFzIGlkbGUgYW5kIGRvZXMgbm90IHBp bmcuCgpTbyBoYW5nY2hlY2sgZG9lcyBub3Qgd29yay4gT3IgaXQgd29ya3MgYmVjYXVzZSBHdUMg ZG9lcyBpdCBhbnl3YXkuIApFaXRoZXIgd2F5LCB0aGF0J3Mgb25lIHRoaW5nIHRvIGV4cGxpY2l0 bHkgc3RhdGUgaW4gdGhlIGNvbW1pdCBtZXNzYWdlLgoKPiBUaGlzIHBhdGNoIGRlY29tcG9zZXMg dGhlIHZpcnR1YWwgZW5naW5lcyBmb3IgdGhlIHNha2Ugb2YgaW5jcmVtZW50aW5nIAo+IHRoZSBz ZXJpYWwgY291bnQgb24gZWFjaCBzdWItZW5naW5lIGluIG9yZGVyIHRvIGtlZXAgdGhlIGhlYXJ0 YmVhdCBjb2RlIAo+IGhhcHB5LiBUaGUgZG93bnNpZGUgaXMgdGhhdCBub3cgdGhlIGhlYXJ0YmVh dCBzZWVzIGFsbCBzdWItZW5naW5lcyBhcyAKPiBidXN5IHJhdGhlciB0aGFuIG9ubHkgdGhlIG9u ZSB0aGUgc3VibWlzc2lvbiBhY3R1YWxseSBlbmRzIHVwIG9uLiBUaGVyZSAKPiByZWFsbHkgaXNu J3QgbXVjaCB0aGF0IGNhbiBiZSBkb25lIGFib3V0IHRoYXQuIFRoZSBoZWFydGJlYXQgY29kZSBp cyBpbiAKPiBpOTE1IG5vdCBHdUMsIHRoZSBzY2hlZHVsZXIgaXMgaW4gR3VDIG5vdCBpOTE1LiBU aGUgb25seSB3YXkgdG8gaW1wcm92ZSAKPiBpdCBpcyB0byBlaXRoZXIgbW92ZSB0aGUgaGVhcnRi ZWF0IGNvZGUgaW50byBHdUMgYXMgd2VsbCBhbmQgY29tcGxldGVseSAKPiBkaXNhYmxlIHRoZSBp OTE1IHNpZGUsIG9yIGFkZCBzb21lIHdheSBmb3IgaTkxNSB0byBpbnRlcnJvZ2F0ZSBHdUMgYXMg dG8gCj4gd2hpY2ggZW5naW5lcyBhcmUgb3IgYXJlIG5vdCBhY3RpdmUuIFRlY2huaWNhbGx5LCB3 ZSBkbyBoYXZlIGJvdGguIEd1QyAKPiBoYXMgKG9yIGF0IGxlYXN0IGhhZCkgYW4gb3B0aW9uIHRv IGZvcmNlIGEgY29udGV4dCBzd2l0Y2ggb24gZXZlcnkgCj4gZXhlY3V0aW9uIHF1YW50dW0gcHJl LWVtcHRpb24uIEhvd2V2ZXIsIHRoYXQgaXMgbXVjaCwgbXVjaCwgbW9yZSBoZWF2eSAKPiB3ZWln aHQgdGhhbiB0aGUgaGVhcnRiZWF0LiBGb3IgdGhlIGxhdHRlciwgd2UgZG8gKGFsbW9zdCkgaGF2 ZSB0aGUgCj4gZW5naW5lIHVzYWdlIHN0YXRpc3RpY3MgZm9yIFBNVSBhbmQgc3VjaCBsaWtlLiBJ J20gbm90IHN1cmUgaG93IG11Y2ggCj4gZWZmb3J0IGl0IHdvdWxkIGJlIHRvIHdpcmUgdGhhdCB1 cCB0byB0aGUgaGVhcnRiZWF0IGNvZGUgaW5zdGVhZCBvZiAKPiB1c2luZyB0aGUgc2VyaWFsIGNv dW50Lgo+IAo+IEluIHNob3J0LCB0aGUgc2VyaWFsIGNvdW50IGlzIGV2ZXIgc28gc2xpZ2h0bHkg aW5lZmZpY2llbnQgaW4gdGhhdCBpdCAKPiBjYXVzZXMgaGVhcnRiZWF0IHBpbmdzIG9uIGVuZ2lu ZXMgd2hpY2ggYXJlIGlkbGUuIE9uIHRoZSBvdGhlciBoYW5kLCBpdCAKPiBpcyB3YXkgbW9yZSBl ZmZpY2llbnQgYW5kIHNpbXBsZXIgdGhhbiB0aGUgY3VycmVudCBhbHRlcm5hdGl2ZXMuCgpBbmQg dGhlIGhhY2sgdG8gbWFrZSBoYW5nY2hlY2sgd29yayBjcmVhdGVzIHRoaXMgaW5lZmZpY2llbmN5 IHdoZXJlIApoZWFydGJlYXRzIGFyZSBzZW50IHRvIGlkbGUgZW5naW5lcy4gV2hpY2ggaXMgcHJv YmFibHkgZmluZSBqdXN0IG5lZWRzIAp0byBiZSBleHBsYWluZWQuCgo+IERvZXMgdGhhdCBhbnN3 ZXIgdGhlIHF1ZXN0aW9ucz8KCldpdGggdGhlIHR3byBwb2ludHMgSSByZS1yYWlzZSBjbGVhcmx5 IGV4cGxhaW5lZCwgcG9zc2libHkgZXZlbiBwYXRjaCAKdGl0bGUgY2hhbmdlZCwgeWVhaC4gSSBh bSBqdXN0IHdhbnRpbmcgZm9yIGl0IHRvIGJlIG1vcmUgZWFzaWx5IG9idmlvdXMgCnRvIHBhdGNo IHJlYWRlciB3aGF0IGl0IGlzIGZ1bmN0aW9uYWxseSBhYm91dCAtIG5vdCBqdXN0IHdoYXQgCmlt cGxlbWVudGF0aW9uIGRldGFpbHMgaGF2ZSBiZWVuIGNoYW5nZSBidXQgd2h5IGFzIHdlbGwuCgpS ZWdhcmRzLAoKVHZydGtvCgo+IEpvaG4uCj4gCj4gCj4+Cj4+IElmIHdlIGFyZSBhYmFuZG9uaW5n IHRoZSBub3JtYWwgcmV2aWV3IHByb2Nlc3Mgc29tZW9uZSBwbGVhc2Ugc2F5IHNvIEkgCj4+IGRv bid0IHdhc3RlIG15IHRpbWUgcmVhZGluZyBpdC4KPj4KPj4gUmVnYXJkcywKPj4KPj4gVHZydGtv Cj4+Cj4+PiBNYXR0Cj4+Pgo+Pj4+IFJlZ2FyZHMsCj4+Pj4KPj4+PiBUdnJ0a28KPj4+Pgo+Pj4+ PiBTaWduZWQtb2ZmLWJ5OiBKb2huIEhhcnJpc29uIDxKb2huLkMuSGFycmlzb25ASW50ZWwuY29t Pgo+Pj4+PiBTaWduZWQtb2ZmLWJ5OiBNYXR0aGV3IEJyb3N0IDxtYXR0aGV3LmJyb3N0QGludGVs LmNvbT4KPj4+Pj4gLS0tCj4+Pj4+IMKgwqAgZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxf ZW5naW5lX3R5cGVzLmjCoMKgwqDCoCB8wqAgMiArKwo+Pj4+PiDCoMKgIC4uLi9ncHUvZHJtL2k5 MTUvZ3QvaW50ZWxfZXhlY2xpc3RzX3N1Ym1pc3Npb24uYyB8wqAgNiArKysrKysKPj4+Pj4gwqDC oCBkcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9yaW5nX3N1Ym1pc3Npb24uY8KgIHzCoCA2 ICsrKysrKwo+Pj4+PiDCoMKgIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L21vY2tfZW5naW5lLmPC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIHzCoCA2ICsrKysrKwo+Pj4+PiDCoMKgIC4uLi9ncHUvZHJt L2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX3N1Ym1pc3Npb24uY8KgwqDCoCB8IDE2IAo+Pj4+PiArKysr KysrKysrKysrKysrCj4+Pj4+IMKgwqAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9yZXF1ZXN0 LmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8wqAgNCArKystCj4+Pj4+IMKgwqAgNiBmaWxl cyBjaGFuZ2VkLCAzOSBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCj4+Pj4+Cj4+Pj4+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9lbmdpbmVfdHlwZXMuaCAK Pj4+Pj4gYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9lbmdpbmVfdHlwZXMuaAo+Pj4+ PiBpbmRleCA4NjMwMmU2ZDg2YjIuLmUyYjVjZGE2ZGJjNCAxMDA2NDQKPj4+Pj4gLS0tIGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfZW5naW5lX3R5cGVzLmgKPj4+Pj4gKysrIGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfZW5naW5lX3R5cGVzLmgKPj4+Pj4gQEAgLTM4OSw2 ICszODksOCBAQCBzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzIHsKPj4+Pj4gwqDCoMKgwqDCoMKgIHZv aWTCoMKgwqDCoMKgwqDCoCAoKnBhcmspKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSk7 Cj4+Pj4+IMKgwqDCoMKgwqDCoCB2b2lkwqDCoMKgwqDCoMKgwqAgKCp1bnBhcmspKHN0cnVjdCBp bnRlbF9lbmdpbmVfY3MgKmVuZ2luZSk7Cj4+Pj4+ICvCoMKgwqAgdm9pZMKgwqDCoMKgwqDCoMKg ICgqYnVtcF9zZXJpYWwpKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSk7Cj4+Pj4+ICsK Pj4+Pj4gwqDCoMKgwqDCoMKgIHZvaWTCoMKgwqDCoMKgwqDCoCAoKnNldF9kZWZhdWx0X3N1Ym1p c3Npb24pKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgCj4+Pj4+ICplbmdpbmUpOwo+Pj4+PiDCoMKg wqDCoMKgwqAgY29uc3Qgc3RydWN0IGludGVsX2NvbnRleHRfb3BzICpjb3BzOwo+Pj4+PiBkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfZXhlY2xpc3RzX3N1Ym1pc3Np b24uYyAKPj4+Pj4gYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9leGVjbGlzdHNfc3Vi bWlzc2lvbi5jCj4+Pj4+IGluZGV4IGFlMTJkN2YxOWVjZC4uMDI4ODBlYTVkNjkzIDEwMDY0NAo+ Pj4+PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9leGVjbGlzdHNfc3VibWlz c2lvbi5jCj4+Pj4+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2V4ZWNsaXN0 c19zdWJtaXNzaW9uLmMKPj4+Pj4gQEAgLTMxOTksNiArMzE5OSwxMSBAQCBzdGF0aWMgdm9pZCBl eGVjbGlzdHNfcmVsZWFzZShzdHJ1Y3QgCj4+Pj4+IGludGVsX2VuZ2luZV9jcyAqZW5naW5lKQo+ Pj4+PiDCoMKgwqDCoMKgwqAgbHJjX2Zpbmlfd2FfY3R4KGVuZ2luZSk7Cj4+Pj4+IMKgwqAgfQo+ Pj4+PiArc3RhdGljIHZvaWQgZXhlY2xpc3RfYnVtcF9zZXJpYWwoc3RydWN0IGludGVsX2VuZ2lu ZV9jcyAqZW5naW5lKQo+Pj4+PiArewo+Pj4+PiArwqDCoMKgIGVuZ2luZS0+c2VyaWFsKys7Cj4+ Pj4+ICt9Cj4+Pj4+ICsKPj4+Pj4gwqDCoCBzdGF0aWMgdm9pZAo+Pj4+PiDCoMKgIGxvZ2ljYWxf cmluZ19kZWZhdWx0X3ZmdW5jcyhzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCj4+Pj4+ IMKgwqAgewo+Pj4+PiBAQCAtMzIwOCw2ICszMjEzLDcgQEAgbG9naWNhbF9yaW5nX2RlZmF1bHRf dmZ1bmNzKHN0cnVjdCAKPj4+Pj4gaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCj4+Pj4+IMKgwqDC oMKgwqDCoCBlbmdpbmUtPmNvcHMgPSAmZXhlY2xpc3RzX2NvbnRleHRfb3BzOwo+Pj4+PiDCoMKg wqDCoMKgwqAgZW5naW5lLT5yZXF1ZXN0X2FsbG9jID0gZXhlY2xpc3RzX3JlcXVlc3RfYWxsb2M7 Cj4+Pj4+ICvCoMKgwqAgZW5naW5lLT5idW1wX3NlcmlhbCA9IGV4ZWNsaXN0X2J1bXBfc2VyaWFs Owo+Pj4+PiDCoMKgwqDCoMKgwqAgZW5naW5lLT5yZXNldC5wcmVwYXJlID0gZXhlY2xpc3RzX3Jl c2V0X3ByZXBhcmU7Cj4+Pj4+IMKgwqDCoMKgwqDCoCBlbmdpbmUtPnJlc2V0LnJld2luZCA9IGV4 ZWNsaXN0c19yZXNldF9yZXdpbmQ7Cj4+Pj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9ndC9pbnRlbF9yaW5nX3N1Ym1pc3Npb24uYyAKPj4+Pj4gYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9ndC9pbnRlbF9yaW5nX3N1Ym1pc3Npb24uYwo+Pj4+PiBpbmRleCAxNGFhMzE4NzlhMzcu LjM5ZGQ3YzRlZDBhOSAxMDA2NDQKPj4+Pj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qv aW50ZWxfcmluZ19zdWJtaXNzaW9uLmMKPj4+Pj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv Z3QvaW50ZWxfcmluZ19zdWJtaXNzaW9uLmMKPj4+Pj4gQEAgLTEwNDUsNiArMTA0NSwxMSBAQCBz dGF0aWMgdm9pZCBzZXR1cF9pcnEoc3RydWN0IGludGVsX2VuZ2luZV9jcyAKPj4+Pj4gKmVuZ2lu ZSkKPj4+Pj4gwqDCoMKgwqDCoMKgIH0KPj4+Pj4gwqDCoCB9Cj4+Pj4+ICtzdGF0aWMgdm9pZCBy aW5nX2J1bXBfc2VyaWFsKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKPj4+Pj4gK3sK Pj4+Pj4gK8KgwqDCoCBlbmdpbmUtPnNlcmlhbCsrOwo+Pj4+PiArfQo+Pj4+PiArCj4+Pj4+IMKg wqAgc3RhdGljIHZvaWQgc2V0dXBfY29tbW9uKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2lu ZSkKPj4+Pj4gwqDCoCB7Cj4+Pj4+IMKgwqDCoMKgwqDCoCBzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0 ZSAqaTkxNSA9IGVuZ2luZS0+aTkxNTsKPj4+Pj4gQEAgLTEwNjQsNiArMTA2OSw3IEBAIHN0YXRp YyB2b2lkIHNldHVwX2NvbW1vbihzdHJ1Y3QgCj4+Pj4+IGludGVsX2VuZ2luZV9jcyAqZW5naW5l KQo+Pj4+PiDCoMKgwqDCoMKgwqAgZW5naW5lLT5jb3BzID0gJnJpbmdfY29udGV4dF9vcHM7Cj4+ Pj4+IMKgwqDCoMKgwqDCoCBlbmdpbmUtPnJlcXVlc3RfYWxsb2MgPSByaW5nX3JlcXVlc3RfYWxs b2M7Cj4+Pj4+ICvCoMKgwqAgZW5naW5lLT5idW1wX3NlcmlhbCA9IHJpbmdfYnVtcF9zZXJpYWw7 Cj4+Pj4+IMKgwqDCoMKgwqDCoCAvKgo+Pj4+PiDCoMKgwqDCoMKgwqDCoCAqIFVzaW5nIGEgZ2xv YmFsIGV4ZWN1dGlvbiB0aW1lbGluZTsgdGhlIHByZXZpb3VzIGZpbmFsIAo+Pj4+PiBicmVhZGNy dW1iIGlzCj4+Pj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9tb2NrX2Vu Z2luZS5jIAo+Pj4+PiBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L21vY2tfZW5naW5lLmMKPj4+ Pj4gaW5kZXggYmQwMDVjMWI2ZmQ1Li45N2IxMGZkNjBiNTUgMTAwNjQ0Cj4+Pj4+IC0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2d0L21vY2tfZW5naW5lLmMKPj4+Pj4gKysrIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ3QvbW9ja19lbmdpbmUuYwo+Pj4+PiBAQCAtMjkyLDYgKzI5MiwxMSBAQCBz dGF0aWMgdm9pZCBtb2NrX2VuZ2luZV9yZWxlYXNlKHN0cnVjdCAKPj4+Pj4gaW50ZWxfZW5naW5l X2NzICplbmdpbmUpCj4+Pj4+IMKgwqDCoMKgwqDCoCBpbnRlbF9lbmdpbmVfZmluaV9yZXRpcmUo ZW5naW5lKTsKPj4+Pj4gwqDCoCB9Cj4+Pj4+ICtzdGF0aWMgdm9pZCBtb2NrX2J1bXBfc2VyaWFs KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKPj4+Pj4gK3sKPj4+Pj4gK8KgwqDCoCBl bmdpbmUtPnNlcmlhbCsrOwo+Pj4+PiArfQo+Pj4+PiArCj4+Pj4+IMKgwqAgc3RydWN0IGludGVs X2VuZ2luZV9jcyAqbW9ja19lbmdpbmUoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCj4+ Pj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGNvbnN0IGNo YXIgKm5hbWUsCj4+Pj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIGludCBpZCkKPj4+Pj4gQEAgLTMxOCw2ICszMjMsNyBAQCBzdHJ1Y3QgaW50ZWxfZW5naW5l X2NzICptb2NrX2VuZ2luZShzdHJ1Y3QgCj4+Pj4+IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCj4+ Pj4+IMKgwqDCoMKgwqDCoCBlbmdpbmUtPmJhc2UuY29wcyA9ICZtb2NrX2NvbnRleHRfb3BzOwo+ Pj4+PiDCoMKgwqDCoMKgwqAgZW5naW5lLT5iYXNlLnJlcXVlc3RfYWxsb2MgPSBtb2NrX3JlcXVl c3RfYWxsb2M7Cj4+Pj4+ICvCoMKgwqAgZW5naW5lLT5iYXNlLmJ1bXBfc2VyaWFsID0gbW9ja19i dW1wX3NlcmlhbDsKPj4+Pj4gwqDCoMKgwqDCoMKgIGVuZ2luZS0+YmFzZS5lbWl0X2ZsdXNoID0g bW9ja19lbWl0X2ZsdXNoOwo+Pj4+PiDCoMKgwqDCoMKgwqAgZW5naW5lLT5iYXNlLmVtaXRfZmlu aV9icmVhZGNydW1iID0gbW9ja19lbWl0X2JyZWFkY3J1bWI7Cj4+Pj4+IMKgwqDCoMKgwqDCoCBl bmdpbmUtPmJhc2Uuc3VibWl0X3JlcXVlc3QgPSBtb2NrX3N1Ym1pdF9yZXF1ZXN0Owo+Pj4+PiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX3N1Ym1pc3Np b24uYyAKPj4+Pj4gYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfc3VibWlz c2lvbi5jCj4+Pj4+IGluZGV4IGRjNzlkMjg3YzUwYS4uZjBlNTczMWJjZWY2IDEwMDY0NAo+Pj4+ PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfc3VibWlzc2lvbi5j Cj4+Pj4+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19zdWJtaXNz aW9uLmMKPj4+Pj4gQEAgLTE1MDAsNiArMTUwMCwyMCBAQCBzdGF0aWMgdm9pZCBndWNfcmVsZWFz ZShzdHJ1Y3QgCj4+Pj4+IGludGVsX2VuZ2luZV9jcyAqZW5naW5lKQo+Pj4+PiDCoMKgwqDCoMKg wqAgbHJjX2Zpbmlfd2FfY3R4KGVuZ2luZSk7Cj4+Pj4+IMKgwqAgfQo+Pj4+PiArc3RhdGljIHZv aWQgZ3VjX2J1bXBfc2VyaWFsKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKPj4+Pj4g K3sKPj4+Pj4gK8KgwqDCoCBlbmdpbmUtPnNlcmlhbCsrOwo+Pj4+PiArfQo+Pj4+PiArCj4+Pj4+ ICtzdGF0aWMgdm9pZCB2aXJ0dWFsX2d1Y19idW1wX3NlcmlhbChzdHJ1Y3QgaW50ZWxfZW5naW5l X2NzICplbmdpbmUpCj4+Pj4+ICt7Cj4+Pj4+ICvCoMKgwqAgc3RydWN0IGludGVsX2VuZ2luZV9j cyAqZTsKPj4+Pj4gK8KgwqDCoCBpbnRlbF9lbmdpbmVfbWFza190IHRtcCwgbWFzayA9IGVuZ2lu ZS0+bWFzazsKPj4+Pj4gKwo+Pj4+PiArwqDCoMKgIGZvcl9lYWNoX2VuZ2luZV9tYXNrZWQoZSwg ZW5naW5lLT5ndCwgbWFzaywgdG1wKQo+Pj4+PiArwqDCoMKgwqDCoMKgwqAgZS0+c2VyaWFsKys7 Cj4+Pj4+ICt9Cj4+Pj4+ICsKPj4+Pj4gwqDCoCBzdGF0aWMgdm9pZCBndWNfZGVmYXVsdF92ZnVu Y3Moc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lKQo+Pj4+PiDCoMKgIHsKPj4+Pj4gwqDC oMKgwqDCoMKgIC8qIERlZmF1bHQgdmZ1bmNzIHdoaWNoIGNhbiBiZSBvdmVycmlkZGVuIGJ5IGVh Y2ggZW5naW5lLiAqLwo+Pj4+PiBAQCAtMTUwOCw2ICsxNTIyLDcgQEAgc3RhdGljIHZvaWQgZ3Vj X2RlZmF1bHRfdmZ1bmNzKHN0cnVjdCAKPj4+Pj4gaW50ZWxfZW5naW5lX2NzICplbmdpbmUpCj4+ Pj4+IMKgwqDCoMKgwqDCoCBlbmdpbmUtPmNvcHMgPSAmZ3VjX2NvbnRleHRfb3BzOwo+Pj4+PiDC oMKgwqDCoMKgwqAgZW5naW5lLT5yZXF1ZXN0X2FsbG9jID0gZ3VjX3JlcXVlc3RfYWxsb2M7Cj4+ Pj4+ICvCoMKgwqAgZW5naW5lLT5idW1wX3NlcmlhbCA9IGd1Y19idW1wX3NlcmlhbDsKPj4+Pj4g wqDCoMKgwqDCoMKgIGVuZ2luZS0+c2NoZWRfZW5naW5lLT5zY2hlZHVsZSA9IGk5MTVfc2NoZWR1 bGU7Cj4+Pj4+IEBAIC0xODQzLDYgKzE4NTgsNyBAQCBndWNfY3JlYXRlX3ZpcnR1YWwoc3RydWN0 IGludGVsX2VuZ2luZV9jcyAKPj4+Pj4gKipzaWJsaW5ncywgdW5zaWduZWQgaW50IGNvdW50KQo+ Pj4+PiDCoMKgwqDCoMKgwqAgdmUtPmJhc2UuY29wcyA9ICZ2aXJ0dWFsX2d1Y19jb250ZXh0X29w czsKPj4+Pj4gwqDCoMKgwqDCoMKgIHZlLT5iYXNlLnJlcXVlc3RfYWxsb2MgPSBndWNfcmVxdWVz dF9hbGxvYzsKPj4+Pj4gK8KgwqDCoCB2ZS0+YmFzZS5idW1wX3NlcmlhbCA9IHZpcnR1YWxfZ3Vj X2J1bXBfc2VyaWFsOwo+Pj4+PiDCoMKgwqDCoMKgwqAgdmUtPmJhc2Uuc3VibWl0X3JlcXVlc3Qg PSBndWNfc3VibWl0X3JlcXVlc3Q7Cj4+Pj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X3JlcXVlc3QuYyAKPj4+Pj4gYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3Jl cXVlc3QuYwo+Pj4+PiBpbmRleCA5NTQyYTViYWE0NWEuLjEyN2Q2MGIzNjQyMiAxMDA2NDQKPj4+ Pj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9yZXF1ZXN0LmMKPj4+Pj4gKysrIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9yZXF1ZXN0LmMKPj4+Pj4gQEAgLTY5Miw3ICs2OTIs OSBAQCBib29sIF9faTkxNV9yZXF1ZXN0X3N1Ym1pdChzdHJ1Y3QgaTkxNV9yZXF1ZXN0IAo+Pj4+ PiAqcmVxdWVzdCkKPj4+Pj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCByZXF1ZXN0LT5yaW5nLT52YWRkciArIHJlcXVlc3QtPnBvc3RmaXgpOwo+Pj4+PiDC oMKgwqDCoMKgwqAgdHJhY2VfaTkxNV9yZXF1ZXN0X2V4ZWN1dGUocmVxdWVzdCk7Cj4+Pj4+IC3C oMKgwqAgZW5naW5lLT5zZXJpYWwrKzsKPj4+Pj4gK8KgwqDCoCBpZiAoZW5naW5lLT5idW1wX3Nl cmlhbCkKPj4+Pj4gK8KgwqDCoMKgwqDCoMKgIGVuZ2luZS0+YnVtcF9zZXJpYWwoZW5naW5lKTsK Pj4+Pj4gKwo+Pj4+PiDCoMKgwqDCoMKgwqAgcmVzdWx0ID0gdHJ1ZTsKPj4+Pj4gwqDCoMKgwqDC oMKgIEdFTV9CVUdfT04odGVzdF9iaXQoSTkxNV9GRU5DRV9GTEFHX0FDVElWRSwgCj4+Pj4+ICZy ZXF1ZXN0LT5mZW5jZS5mbGFncykpOwo+Pj4+Pgo+PiBfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwo+PiBJbnRlbC1nZnggbWFpbGluZyBsaXN0Cj4+IEludGVs LWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKPj4gaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5v cmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngKPiAKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhA bGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxt YW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg==