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=-15.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,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 D1A3FC11F66 for ; Wed, 30 Jun 2021 22:53:05 +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 8575261449 for ; Wed, 30 Jun 2021 22:53:05 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8575261449 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=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 CC2216EA90; Wed, 30 Jun 2021 22:53:03 +0000 (UTC) Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by gabe.freedesktop.org (Postfix) with ESMTPS id CB33D6EA90; Wed, 30 Jun 2021 22:53:02 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10031"; a="208390156" X-IronPort-AV: E=Sophos;i="5.83,312,1616482800"; d="scan'208";a="208390156" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by orsmga102.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 30 Jun 2021 15:53:01 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.83,312,1616482800"; d="scan'208";a="457424289" Received: from irvmail001.ir.intel.com ([10.43.11.63]) by fmsmga008.fm.intel.com with ESMTP; 30 Jun 2021 15:53:00 -0700 Received: from [10.249.131.154] (mwajdecz-MOBL.ger.corp.intel.com [10.249.131.154]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id 15UMqwYa014600; Wed, 30 Jun 2021 23:52:59 +0100 Subject: Re: [PATCH 4/7] drm/i915/guc: Add non blocking CTB send function To: Matthew Brost , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org References: <20210627231439.138612-1-matthew.brost@intel.com> <20210627231439.138612-5-matthew.brost@intel.com> From: Michal Wajdeczko Message-ID: <24adbae6-61b7-7c8e-5034-7419a3a5dfa7@intel.com> Date: Thu, 1 Jul 2021 00:52:58 +0200 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.11.0 MIME-Version: 1.0 In-Reply-To: <20210627231439.138612-5-matthew.brost@intel.com> Content-Type: text/plain; charset=utf-8 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: daniele.ceraolospurio@intel.com, john.c.harrison@intel.com Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" On 28.06.2021 01:14, Matthew Brost wrote: > Add non blocking CTB send function, intel_guc_send_nb. GuC submission > will send CTBs in the critical path and does not need to wait for these > CTBs to complete before moving on, hence the need for this new function. > > The non-blocking CTB now must have a flow control mechanism to ensure > the buffer isn't overrun. A lazy spin wait is used as we believe the > flow control condition should be rare with a properly sized buffer. > > The function, intel_guc_send_nb, is exported in this patch but unused. > Several patches later in the series make use of this function. > > v2: > (Michal) > - Use define for H2G room calculations > - Move INTEL_GUC_SEND_NB define > (Daniel Vetter) > - Use msleep_interruptible rather than cond_resched > > Signed-off-by: John Harrison > Signed-off-by: Matthew Brost > --- > .../gt/uc/abi/guc_communication_ctb_abi.h | 3 +- > drivers/gpu/drm/i915/gt/uc/intel_guc.h | 11 ++- > drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c | 90 +++++++++++++++++-- > drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h | 4 +- > 4 files changed, 94 insertions(+), 14 deletions(-) > > diff --git a/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_ctb_abi.h b/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_ctb_abi.h > index e933ca02d0eb..99e1fad5ca20 100644 > --- a/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_ctb_abi.h > +++ b/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_ctb_abi.h > @@ -79,7 +79,8 @@ static_assert(sizeof(struct guc_ct_buffer_desc) == 64); > * +---+-------+--------------------------------------------------------------+ > */ > > -#define GUC_CTB_MSG_MIN_LEN 1u > +#define GUC_CTB_HDR_LEN 1u > +#define GUC_CTB_MSG_MIN_LEN GUC_CTB_HDR_LEN if you insist to use dedicated macro for the CTB header len then to be consistent you need rename header bitfield macros as well, thus sections/tables will look like: /** * DOC: CTB Message * * +---+-------+-------------------------------------+ * | | Bits | Description | * +===+=======+=====================================+ * | 0 | 31:0 | `CTB Header`_ | * +---+-------+-------------------------------------+ * | 1 | 31:0 | +-------------------------------+ | * +---+-------+ | | | * |...| | | CTB Payload | | * +---+-------+ | | | * | n | 31:0 | +-------------------------------+ | * +---+-------+-------------------------------------+ */ /** * DOC: CTB Header * * +---+-------+-------------------------------------+ * | | Bits | Description | * +===+=======+=====================================+ * | 0 | 31:16 | **FENCE** - ... | * | +-------+-------------------------------------+ * | | 15:12 | **FORMAT** - ... | * | +-------+-------------------------------------+ * | | 11:8 | **RESERVED** | * | +-------+-------------------------------------+ * | | 7:0 | **NUM_DWORDS** - ... | * +---+-------+-------------------------------------+ */ #define GUC_CTB_HDR_0_FENCE (0xffff << 16) #define GUC_CTB_HDR_0_FORMAT (0xf << 12) #define GUC_CTB_FORMAT_HXG 0u #define GUC_CTB_HDR_0_RESERVED (0xf << 8) #define GUC_CTB_HDR_0_NUM_DWORDS (0xff << 0) #define GUC_CTB_MAX_DWORDS 255u #define GUC_CTB_MSG_MIN_LEN GUC_CTB_HDR_LEN #define GUC_CTB_MSG_MAX_LEN (GUC_CTB_HDR_LEN + GUC_CTB_MAX_DWORDS) alternatively leave ABI defs as-as and just move your HDR definition out of ABI headers to inteL_guc_fwif.h as: #define GUC_CTB_HDR_LEN GUC_CTB_MSG_MIN_LEN > #define GUC_CTB_MSG_MAX_LEN 256u > #define GUC_CTB_MSG_0_FENCE (0xffff << 16) > #define GUC_CTB_MSG_0_FORMAT (0xf << 12) > diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc.h b/drivers/gpu/drm/i915/gt/uc/intel_guc.h > index 4abc59f6f3cd..efc690fc8fb1 100644 > --- a/drivers/gpu/drm/i915/gt/uc/intel_guc.h > +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc.h > @@ -74,7 +74,14 @@ static inline struct intel_guc *log_to_guc(struct intel_guc_log *log) > static > inline int intel_guc_send(struct intel_guc *guc, const u32 *action, u32 len) > { > - return intel_guc_ct_send(&guc->ct, action, len, NULL, 0); > + return intel_guc_ct_send(&guc->ct, action, len, NULL, 0, 0); > +} > + > +static > +inline int intel_guc_send_nb(struct intel_guc *guc, const u32 *action, u32 len) > +{ > + return intel_guc_ct_send(&guc->ct, action, len, NULL, 0, > + INTEL_GUC_SEND_NB); > } > > static inline int > @@ -82,7 +89,7 @@ intel_guc_send_and_receive(struct intel_guc *guc, const u32 *action, u32 len, > u32 *response_buf, u32 response_buf_size) > { > return intel_guc_ct_send(&guc->ct, action, len, > - response_buf, response_buf_size); > + response_buf, response_buf_size, 0); > } > > static inline void intel_guc_to_host_event_handler(struct intel_guc *guc) > diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c > index 43e03aa2dde8..90ee95a240e8 100644 > --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c > +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c > @@ -3,6 +3,11 @@ > * Copyright © 2016-2019 Intel Corporation > */ > > +#include > +#include > +#include > +#include these headers should likely be part of patch 5/7 > + > #include "i915_drv.h" > #include "intel_guc_ct.h" > #include "gt/intel_gt.h" > @@ -373,7 +378,7 @@ static void write_barrier(struct intel_guc_ct *ct) > static int ct_write(struct intel_guc_ct *ct, > const u32 *action, > u32 len /* in dwords */, > - u32 fence) > + u32 fence, u32 flags) > { > struct intel_guc_ct_buffer *ctb = &ct->ctbs.send; > struct guc_ct_buffer_desc *desc = ctb->desc; > @@ -409,7 +414,7 @@ static int ct_write(struct intel_guc_ct *ct, > used = tail - head; ^^^^ code above for blocking path is likely calculating free space in old fashion, while below you are using CIRC_BUF ... so maybe switch to use circ_buf could be done as separate earlier step (not part of intro of non-blocking send) so then below use of CIRC_BUF in non-blocking path will look natural > > /* make sure there is a space including extra dw for the fence */ this extra DW is now "header" not just fence > - if (unlikely(used + len + 1 >= size)) > + if (unlikely(used + len + GUC_CTB_HDR_LEN >= size)) > return -ENOSPC; > > /* > @@ -421,9 +426,13 @@ static int ct_write(struct intel_guc_ct *ct, > FIELD_PREP(GUC_CTB_MSG_0_NUM_DWORDS, len) | > FIELD_PREP(GUC_CTB_MSG_0_FENCE, fence); > > - hxg = FIELD_PREP(GUC_HXG_MSG_0_TYPE, GUC_HXG_TYPE_REQUEST) | > - FIELD_PREP(GUC_HXG_REQUEST_MSG_0_ACTION | > - GUC_HXG_REQUEST_MSG_0_DATA0, action[0]); > + hxg = (flags & INTEL_GUC_SEND_NB) ? > + (FIELD_PREP(GUC_HXG_MSG_0_TYPE, GUC_HXG_TYPE_EVENT) | > + FIELD_PREP(GUC_HXG_EVENT_MSG_0_ACTION | > + GUC_HXG_EVENT_MSG_0_DATA0, action[0])) : > + (FIELD_PREP(GUC_HXG_MSG_0_TYPE, GUC_HXG_TYPE_REQUEST) | > + FIELD_PREP(GUC_HXG_REQUEST_MSG_0_ACTION | > + GUC_HXG_REQUEST_MSG_0_DATA0, action[0])); > > CT_DEBUG(ct, "writing (tail %u) %*ph %*ph %*ph\n", > tail, 4, &header, 4, &hxg, 4 * (len - 1), &action[1]); > @@ -500,6 +509,48 @@ static int wait_for_ct_request_update(struct ct_request *req, u32 *status) > return err; > } > > +static inline bool h2g_has_room(struct intel_guc_ct_buffer *ctb, u32 len_dw) why h2g prefix ? function is taking pure *ctb, so maybe: static bool ctb_has_room(struct intel_guc_ct_buffer *ctb, u32 len_dw) { ... } static bool ct_can_send(struct intel_guc_ct *ct, u32 len_dw) { return ctb_has_room(&ct->ctbs.send, len_dw + CTB_HDR_LEN); } as we use send/recv, not h2g/g2h and to avoid mistakes add extra header len here (not by caller - same as in call to ct_write) > +{ > + struct guc_ct_buffer_desc *desc = ctb->desc; > + u32 head = READ_ONCE(desc->head); > + u32 space; > + > + space = CIRC_SPACE(desc->tail, head, ctb->size); > + > + return space >= len_dw; > +} > + > +static int ct_send_nb(struct intel_guc_ct *ct, > + const u32 *action, > + u32 len, > + u32 flags) > +{ > + struct intel_guc_ct_buffer *ctb = &ct->ctbs.send; > + unsigned long spin_flags; > + u32 fence; > + int ret; > + > + spin_lock_irqsave(&ctb->lock, spin_flags); > + > + ret = h2g_has_room(ctb, len + GUC_CTB_HDR_LEN); > + if (unlikely(!ret)) { > + ret = -EBUSY; > + goto out; > + } > + > + fence = ct_get_next_fence(ct); > + ret = ct_write(ct, action, len, fence, flags); > + if (unlikely(ret)) > + goto out; > + > + intel_guc_notify(ct_to_guc(ct)); > + > +out: > + spin_unlock_irqrestore(&ctb->lock, spin_flags); > + > + return ret; > +} > + > static int ct_send(struct intel_guc_ct *ct, > const u32 *action, > u32 len, > @@ -507,8 +558,10 @@ static int ct_send(struct intel_guc_ct *ct, > u32 response_buf_size, > u32 *status) > { > + struct intel_guc_ct_buffer *ctb = &ct->ctbs.send; > struct ct_request request; > unsigned long flags; > + unsigned int sleep_period_ms = 1; > u32 fence; > int err; > > @@ -516,8 +569,24 @@ static int ct_send(struct intel_guc_ct *ct, > GEM_BUG_ON(!len); > GEM_BUG_ON(len & ~GUC_CT_MSG_LEN_MASK); > GEM_BUG_ON(!response_buf && response_buf_size); > + might_sleep(); > + > + /* > + * We use a lazy spin wait loop here as we believe that if the CT > + * buffers are sized correctly the flow control condition should be > + * rare. > + */ > +retry: > + spin_lock_irqsave(&ctb->lock, flags); > + if (unlikely(!h2g_has_room(ctb, len + GUC_CTB_HDR_LEN))) { > + spin_unlock_irqrestore(&ctb->lock, flags); > > - spin_lock_irqsave(&ct->ctbs.send.lock, flags); > + if (msleep_interruptible(sleep_period_ms)) > + return -EINTR; > + sleep_period_ms = sleep_period_ms << 1; > + > + goto retry; > + } I'm still not convinced that this chunk should be exactly in the same patch that adds non-blocking path, it's not that with very first use of one NB call we will hit such problem so IMHO it can be done earlier, in by anticipating such problem, or later as fix for potential problem due to stress note that in the commit message you admitted that new NB variant is not used yet, so we can't be hit in other words, try to make patches focused on one item at the time. > > fence = ct_get_next_fence(ct); > request.fence = fence; > @@ -529,9 +598,9 @@ static int ct_send(struct intel_guc_ct *ct, > list_add_tail(&request.link, &ct->requests.pending); > spin_unlock(&ct->requests.lock); > > - err = ct_write(ct, action, len, fence); > + err = ct_write(ct, action, len, fence, 0); > > - spin_unlock_irqrestore(&ct->ctbs.send.lock, flags); > + spin_unlock_irqrestore(&ctb->lock, flags); > > if (unlikely(err)) > goto unlink; > @@ -571,7 +640,7 @@ static int ct_send(struct intel_guc_ct *ct, > * Command Transport (CT) buffer based GuC send function. > */ > int intel_guc_ct_send(struct intel_guc_ct *ct, const u32 *action, u32 len, > - u32 *response_buf, u32 response_buf_size) > + u32 *response_buf, u32 response_buf_size, u32 flags) > { > u32 status = ~0; /* undefined */ > int ret; > @@ -581,6 +650,9 @@ int intel_guc_ct_send(struct intel_guc_ct *ct, const u32 *action, u32 len, > return -ENODEV; > } > > + if (flags & INTEL_GUC_SEND_NB) > + return ct_send_nb(ct, action, len, flags); > + > ret = ct_send(ct, action, len, response_buf, response_buf_size, &status); > if (unlikely(ret < 0)) { > CT_ERROR(ct, "Sending action %#x failed (err=%d status=%#X)\n", > diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h > index 1ae2dde6db93..f6a4d5b33467 100644 > --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h > +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.h > @@ -42,7 +42,6 @@ struct intel_guc_ct_buffer { > bool broken; > }; > > - > /** Top-level structure for Command Transport related data > * > * Includes a pair of CT buffers for bi-directional communication and tracking > @@ -87,8 +86,9 @@ static inline bool intel_guc_ct_enabled(struct intel_guc_ct *ct) > return ct->enabled; > } > > +#define INTEL_GUC_SEND_NB BIT(31) INTEL_GUC_CT_SEND_NB ? ^^^^ > int intel_guc_ct_send(struct intel_guc_ct *ct, const u32 *action, u32 len, > - u32 *response_buf, u32 response_buf_size); > + u32 *response_buf, u32 response_buf_size, u32 flags); > void intel_guc_ct_event_handler(struct intel_guc_ct *ct); > > #endif /* _INTEL_GUC_CT_H_ */ > 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=-15.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,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 86528C11F68 for ; Wed, 30 Jun 2021 22:53:09 +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 52CCF60233 for ; Wed, 30 Jun 2021 22:53:09 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 52CCF60233 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=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 723436EA93; Wed, 30 Jun 2021 22:53:04 +0000 (UTC) Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by gabe.freedesktop.org (Postfix) with ESMTPS id CB33D6EA90; Wed, 30 Jun 2021 22:53:02 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10031"; a="208390156" X-IronPort-AV: E=Sophos;i="5.83,312,1616482800"; d="scan'208";a="208390156" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by orsmga102.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 30 Jun 2021 15:53:01 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.83,312,1616482800"; d="scan'208";a="457424289" Received: from irvmail001.ir.intel.com ([10.43.11.63]) by fmsmga008.fm.intel.com with ESMTP; 30 Jun 2021 15:53:00 -0700 Received: from [10.249.131.154] (mwajdecz-MOBL.ger.corp.intel.com [10.249.131.154]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id 15UMqwYa014600; Wed, 30 Jun 2021 23:52:59 +0100 To: Matthew Brost , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org References: <20210627231439.138612-1-matthew.brost@intel.com> <20210627231439.138612-5-matthew.brost@intel.com> From: Michal Wajdeczko Message-ID: <24adbae6-61b7-7c8e-5034-7419a3a5dfa7@intel.com> Date: Thu, 1 Jul 2021 00:52:58 +0200 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.11.0 MIME-Version: 1.0 In-Reply-To: <20210627231439.138612-5-matthew.brost@intel.com> Content-Language: en-US Subject: Re: [Intel-gfx] [PATCH 4/7] drm/i915/guc: Add non blocking CTB send function 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: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" CgpPbiAyOC4wNi4yMDIxIDAxOjE0LCBNYXR0aGV3IEJyb3N0IHdyb3RlOgo+IEFkZCBub24gYmxv Y2tpbmcgQ1RCIHNlbmQgZnVuY3Rpb24sIGludGVsX2d1Y19zZW5kX25iLiBHdUMgc3VibWlzc2lv bgo+IHdpbGwgc2VuZCBDVEJzIGluIHRoZSBjcml0aWNhbCBwYXRoIGFuZCBkb2VzIG5vdCBuZWVk IHRvIHdhaXQgZm9yIHRoZXNlCj4gQ1RCcyB0byBjb21wbGV0ZSBiZWZvcmUgbW92aW5nIG9uLCBo ZW5jZSB0aGUgbmVlZCBmb3IgdGhpcyBuZXcgZnVuY3Rpb24uCj4gCj4gVGhlIG5vbi1ibG9ja2lu ZyBDVEIgbm93IG11c3QgaGF2ZSBhIGZsb3cgY29udHJvbCBtZWNoYW5pc20gdG8gZW5zdXJlCj4g dGhlIGJ1ZmZlciBpc24ndCBvdmVycnVuLiBBIGxhenkgc3BpbiB3YWl0IGlzIHVzZWQgYXMgd2Ug YmVsaWV2ZSB0aGUKPiBmbG93IGNvbnRyb2wgY29uZGl0aW9uIHNob3VsZCBiZSByYXJlIHdpdGgg YSBwcm9wZXJseSBzaXplZCBidWZmZXIuCj4gCj4gVGhlIGZ1bmN0aW9uLCBpbnRlbF9ndWNfc2Vu ZF9uYiwgaXMgZXhwb3J0ZWQgaW4gdGhpcyBwYXRjaCBidXQgdW51c2VkLgo+IFNldmVyYWwgcGF0 Y2hlcyBsYXRlciBpbiB0aGUgc2VyaWVzIG1ha2UgdXNlIG9mIHRoaXMgZnVuY3Rpb24uCj4gCj4g djI6Cj4gIChNaWNoYWwpCj4gICAtIFVzZSBkZWZpbmUgZm9yIEgyRyByb29tIGNhbGN1bGF0aW9u cwo+ICAgLSBNb3ZlIElOVEVMX0dVQ19TRU5EX05CIGRlZmluZQo+ICAoRGFuaWVsIFZldHRlcikK PiAgIC0gVXNlIG1zbGVlcF9pbnRlcnJ1cHRpYmxlIHJhdGhlciB0aGFuIGNvbmRfcmVzY2hlZAo+ IAo+IFNpZ25lZC1vZmYtYnk6IEpvaG4gSGFycmlzb24gPEpvaG4uQy5IYXJyaXNvbkBJbnRlbC5j b20+Cj4gU2lnbmVkLW9mZi1ieTogTWF0dGhldyBCcm9zdCA8bWF0dGhldy5icm9zdEBpbnRlbC5j b20+Cj4gLS0tCj4gIC4uLi9ndC91Yy9hYmkvZ3VjX2NvbW11bmljYXRpb25fY3RiX2FiaS5oICAg ICB8ICAzICstCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Yy5oICAgICAg ICB8IDExICsrLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfY3QuYyAg ICAgfCA5MCArKysrKysrKysrKysrKysrKy0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3Vj L2ludGVsX2d1Y19jdC5oICAgICB8ICA0ICstCj4gIDQgZmlsZXMgY2hhbmdlZCwgOTQgaW5zZXJ0 aW9ucygrKSwgMTQgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2d0L3VjL2FiaS9ndWNfY29tbXVuaWNhdGlvbl9jdGJfYWJpLmggYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC91Yy9hYmkvZ3VjX2NvbW11bmljYXRpb25fY3RiX2FiaS5oCj4gaW5kZXgg ZTkzM2NhMDJkMGViLi45OWUxZmFkNWNhMjAgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ3QvdWMvYWJpL2d1Y19jb21tdW5pY2F0aW9uX2N0Yl9hYmkuaAo+ICsrKyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2d0L3VjL2FiaS9ndWNfY29tbXVuaWNhdGlvbl9jdGJfYWJpLmgKPiBA QCAtNzksNyArNzksOCBAQCBzdGF0aWNfYXNzZXJ0KHNpemVvZihzdHJ1Y3QgZ3VjX2N0X2J1ZmZl cl9kZXNjKSA9PSA2NCk7Cj4gICAqICArLS0tKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCj4gICAqLwo+ICAKPiAt I2RlZmluZSBHVUNfQ1RCX01TR19NSU5fTEVOCQkJMXUKPiArI2RlZmluZSBHVUNfQ1RCX0hEUl9M RU4JCQkJMXUKPiArI2RlZmluZSBHVUNfQ1RCX01TR19NSU5fTEVOCQkJR1VDX0NUQl9IRFJfTEVO CgppZiB5b3UgaW5zaXN0IHRvIHVzZSBkZWRpY2F0ZWQgbWFjcm8gZm9yIHRoZSBDVEIgaGVhZGVy IGxlbiB0aGVuIHRvIGJlCmNvbnNpc3RlbnQgeW91IG5lZWQgcmVuYW1lIGhlYWRlciBiaXRmaWVs ZCBtYWNyb3MgYXMgd2VsbCwgdGh1cwpzZWN0aW9ucy90YWJsZXMgd2lsbCBsb29rIGxpa2U6Cgov KioKICogRE9DOiBDVEIgTWVzc2FnZQogKgogKiAgKy0tLSstLS0tLS0tKy0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAqICB8ICAgfCBCaXRzICB8IERlc2NyaXB0aW9uICAg ICAgICAgICAgICAgICAgICAgICAgIHwKICogICs9PT0rPT09PT09PSs9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09KwogKiAgfCAwIHwgIDMxOjAgfCBgQ1RCIEhlYWRlcmBfICAg ICAgICAgICAgICAgICAgICAgICB8CiAqICArLS0tKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLSsKICogIHwgMSB8ICAzMTowIHwgICstLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tKyAgfAogKiAgKy0tLSstLS0tLS0tKyAgfCAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB8ICB8CiAqICB8Li4ufCAgICAgICB8ICB8ICBDVEIgUGF5bG9hZCAgICAg ICAgICAgICAgICAgIHwgIHwKICogICstLS0rLS0tLS0tLSsgIHwgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgfAogKiAgfCBuIHwgIDMxOjAgfCAgKy0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0rICB8CiAqICArLS0tKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLSsKICovCgovKioKICogRE9DOiBDVEIgSGVhZGVyCiAqCiAqICArLS0tKy0t LS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICogIHwgICB8IEJp dHMgIHwgRGVzY3JpcHRpb24gICAgICAgICAgICAgICAgICAgICAgICAgfAogKiAgKz09PSs9PT09 PT09Kz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0rCiAqICB8IDAgfCAzMTox NiB8ICoqRkVOQ0UqKiAtIC4uLiAgICAgICAgICAgICAgICAgICAgIHwKICogIHwgICArLS0tLS0t LSstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogKiAgfCAgIHwgMTU6MTIg fCAqKkZPUk1BVCoqIC0gLi4uICAgICAgICAgICAgICAgICAgICB8CiAqICB8ICAgKy0tLS0tLS0r LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKICogIHwgICB8ICAxMTo4IHwg KipSRVNFUlZFRCoqICAgICAgICAgICAgICAgICAgICAgICAgfAogKiAgfCAgICstLS0tLS0tKy0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCiAqICB8ICAgfCAgIDc6MCB8ICoq TlVNX0RXT1JEUyoqIC0gLi4uICAgICAgICAgICAgICAgIHwKICogICstLS0rLS0tLS0tLSstLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwogKi8KCiNkZWZpbmUgR1VDX0NUQl9I RFJfMF9GRU5DRQkJCSgweGZmZmYgPDwgMTYpCiNkZWZpbmUgR1VDX0NUQl9IRFJfMF9GT1JNQVQJ CQkoMHhmIDw8IDEyKQojZGVmaW5lICAgR1VDX0NUQl9GT1JNQVRfSFhHCQkJMHUKI2RlZmluZSBH VUNfQ1RCX0hEUl8wX1JFU0VSVkVECQkJKDB4ZiA8PCA4KQojZGVmaW5lIEdVQ19DVEJfSERSXzBf TlVNX0RXT1JEUwkJKDB4ZmYgPDwgMCkKI2RlZmluZSAgIEdVQ19DVEJfTUFYX0RXT1JEUwkJCTI1 NXUKCiNkZWZpbmUgR1VDX0NUQl9NU0dfTUlOX0xFTglHVUNfQ1RCX0hEUl9MRU4KI2RlZmluZSBH VUNfQ1RCX01TR19NQVhfTEVOCShHVUNfQ1RCX0hEUl9MRU4gKyBHVUNfQ1RCX01BWF9EV09SRFMp CgoKYWx0ZXJuYXRpdmVseSBsZWF2ZSBBQkkgZGVmcyBhcy1hcyBhbmQganVzdCBtb3ZlIHlvdXIg SERSIGRlZmluaXRpb24gb3V0Cm9mIEFCSSBoZWFkZXJzIHRvIGludGVMX2d1Y19md2lmLmggYXM6 CgojZGVmaW5lIEdVQ19DVEJfSERSX0xFTiBHVUNfQ1RCX01TR19NSU5fTEVOCgoKPiAgI2RlZmlu ZSBHVUNfQ1RCX01TR19NQVhfTEVOCQkJMjU2dQo+ICAjZGVmaW5lIEdVQ19DVEJfTVNHXzBfRkVO Q0UJCQkoMHhmZmZmIDw8IDE2KQo+ICAjZGVmaW5lIEdVQ19DVEJfTVNHXzBfRk9STUFUCQkJKDB4 ZiA8PCAxMikKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxf Z3VjLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWMuaAo+IGluZGV4IDRh YmM1OWY2ZjNjZC4uZWZjNjkwZmM4ZmIxIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2d0L3VjL2ludGVsX2d1Yy5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMv aW50ZWxfZ3VjLmgKPiBAQCAtNzQsNyArNzQsMTQgQEAgc3RhdGljIGlubGluZSBzdHJ1Y3QgaW50 ZWxfZ3VjICpsb2dfdG9fZ3VjKHN0cnVjdCBpbnRlbF9ndWNfbG9nICpsb2cpCj4gIHN0YXRpYwo+ ICBpbmxpbmUgaW50IGludGVsX2d1Y19zZW5kKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywgY29uc3Qg dTMyICphY3Rpb24sIHUzMiBsZW4pCj4gIHsKPiAtCXJldHVybiBpbnRlbF9ndWNfY3Rfc2VuZCgm Z3VjLT5jdCwgYWN0aW9uLCBsZW4sIE5VTEwsIDApOwo+ICsJcmV0dXJuIGludGVsX2d1Y19jdF9z ZW5kKCZndWMtPmN0LCBhY3Rpb24sIGxlbiwgTlVMTCwgMCwgMCk7Cj4gK30KPiArCj4gK3N0YXRp Ywo+ICtpbmxpbmUgaW50IGludGVsX2d1Y19zZW5kX25iKHN0cnVjdCBpbnRlbF9ndWMgKmd1Yywg Y29uc3QgdTMyICphY3Rpb24sIHUzMiBsZW4pCj4gK3sKPiArCXJldHVybiBpbnRlbF9ndWNfY3Rf c2VuZCgmZ3VjLT5jdCwgYWN0aW9uLCBsZW4sIE5VTEwsIDAsCj4gKwkJCQkgSU5URUxfR1VDX1NF TkRfTkIpOwo+ICB9Cj4gIAo+ICBzdGF0aWMgaW5saW5lIGludAo+IEBAIC04Miw3ICs4OSw3IEBA IGludGVsX2d1Y19zZW5kX2FuZF9yZWNlaXZlKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywgY29uc3Qg dTMyICphY3Rpb24sIHUzMiBsZW4sCj4gIAkJCSAgIHUzMiAqcmVzcG9uc2VfYnVmLCB1MzIgcmVz cG9uc2VfYnVmX3NpemUpCj4gIHsKPiAgCXJldHVybiBpbnRlbF9ndWNfY3Rfc2VuZCgmZ3VjLT5j dCwgYWN0aW9uLCBsZW4sCj4gLQkJCQkgcmVzcG9uc2VfYnVmLCByZXNwb25zZV9idWZfc2l6ZSk7 Cj4gKwkJCQkgcmVzcG9uc2VfYnVmLCByZXNwb25zZV9idWZfc2l6ZSwgMCk7Cj4gIH0KPiAgCj4g IHN0YXRpYyBpbmxpbmUgdm9pZCBpbnRlbF9ndWNfdG9faG9zdF9ldmVudF9oYW5kbGVyKHN0cnVj dCBpbnRlbF9ndWMgKmd1YykKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qv dWMvaW50ZWxfZ3VjX2N0LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNf Y3QuYwo+IGluZGV4IDQzZTAzYWEyZGRlOC4uOTBlZTk1YTI0MGU4IDEwMDY0NAo+IC0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19jdC5jCj4gKysrIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2N0LmMKPiBAQCAtMyw2ICszLDExIEBACj4gICAq IENvcHlyaWdodCDCqSAyMDE2LTIwMTkgSW50ZWwgQ29ycG9yYXRpb24KPiAgICovCj4gIAo+ICsj aW5jbHVkZSA8bGludXgvY2lyY19idWYuaD4KCj4gKyNpbmNsdWRlIDxsaW51eC9rdGltZS5oPgo+ ICsjaW5jbHVkZSA8bGludXgvdGltZTY0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC90aW1la2VlcGlu Zy5oPgoKdGhlc2UgaGVhZGVycyBzaG91bGQgbGlrZWx5IGJlIHBhcnQgb2YgcGF0Y2ggNS83Cgo+ ICsKPiAgI2luY2x1ZGUgImk5MTVfZHJ2LmgiCj4gICNpbmNsdWRlICJpbnRlbF9ndWNfY3QuaCIK PiAgI2luY2x1ZGUgImd0L2ludGVsX2d0LmgiCj4gQEAgLTM3Myw3ICszNzgsNyBAQCBzdGF0aWMg dm9pZCB3cml0ZV9iYXJyaWVyKHN0cnVjdCBpbnRlbF9ndWNfY3QgKmN0KQo+ICBzdGF0aWMgaW50 IGN0X3dyaXRlKHN0cnVjdCBpbnRlbF9ndWNfY3QgKmN0LAo+ICAJCSAgICBjb25zdCB1MzIgKmFj dGlvbiwKPiAgCQkgICAgdTMyIGxlbiAvKiBpbiBkd29yZHMgKi8sCj4gLQkJICAgIHUzMiBmZW5j ZSkKPiArCQkgICAgdTMyIGZlbmNlLCB1MzIgZmxhZ3MpCj4gIHsKPiAgCXN0cnVjdCBpbnRlbF9n dWNfY3RfYnVmZmVyICpjdGIgPSAmY3QtPmN0YnMuc2VuZDsKPiAgCXN0cnVjdCBndWNfY3RfYnVm ZmVyX2Rlc2MgKmRlc2MgPSBjdGItPmRlc2M7Cj4gQEAgLTQwOSw3ICs0MTQsNyBAQCBzdGF0aWMg aW50IGN0X3dyaXRlKHN0cnVjdCBpbnRlbF9ndWNfY3QgKmN0LAo+ICAJCXVzZWQgPSB0YWlsIC0g aGVhZDsKICAgICAgICAgICAgICAgIF5eXl4KY29kZSBhYm92ZSBmb3IgYmxvY2tpbmcgcGF0aCBp cyBsaWtlbHkgY2FsY3VsYXRpbmcgZnJlZSBzcGFjZSBpbiBvbGQKZmFzaGlvbiwgd2hpbGUgYmVs b3cgeW91IGFyZSB1c2luZyBDSVJDX0JVRiAuLi4KCnNvIG1heWJlIHN3aXRjaCB0byB1c2UgY2ly Y19idWYgY291bGQgYmUgZG9uZSBhcyBzZXBhcmF0ZSBlYXJsaWVyIHN0ZXAKKG5vdCBwYXJ0IG9m IGludHJvIG9mIG5vbi1ibG9ja2luZyBzZW5kKSBzbyB0aGVuIGJlbG93IHVzZSBvZiBDSVJDX0JV RgppbiBub24tYmxvY2tpbmcgcGF0aCB3aWxsIGxvb2sgbmF0dXJhbAoKPiAgCj4gIAkvKiBtYWtl IHN1cmUgdGhlcmUgaXMgYSBzcGFjZSBpbmNsdWRpbmcgZXh0cmEgZHcgZm9yIHRoZSBmZW5jZSAq LwoKdGhpcyBleHRyYSBEVyBpcyBub3cgImhlYWRlciIgbm90IGp1c3QgZmVuY2UKCj4gLQlpZiAo dW5saWtlbHkodXNlZCArIGxlbiArIDEgPj0gc2l6ZSkpCj4gKwlpZiAodW5saWtlbHkodXNlZCAr IGxlbiArIEdVQ19DVEJfSERSX0xFTiA+PSBzaXplKSkKPiAgCQlyZXR1cm4gLUVOT1NQQzsKPiAg Cj4gIAkvKgo+IEBAIC00MjEsOSArNDI2LDEzIEBAIHN0YXRpYyBpbnQgY3Rfd3JpdGUoc3RydWN0 IGludGVsX2d1Y19jdCAqY3QsCj4gIAkJIEZJRUxEX1BSRVAoR1VDX0NUQl9NU0dfMF9OVU1fRFdP UkRTLCBsZW4pIHwKPiAgCQkgRklFTERfUFJFUChHVUNfQ1RCX01TR18wX0ZFTkNFLCBmZW5jZSk7 Cj4gIAo+IC0JaHhnID0gRklFTERfUFJFUChHVUNfSFhHX01TR18wX1RZUEUsIEdVQ19IWEdfVFlQ RV9SRVFVRVNUKSB8Cj4gLQkgICAgICBGSUVMRF9QUkVQKEdVQ19IWEdfUkVRVUVTVF9NU0dfMF9B Q1RJT04gfAo+IC0JCQkgR1VDX0hYR19SRVFVRVNUX01TR18wX0RBVEEwLCBhY3Rpb25bMF0pOwo+ ICsJaHhnID0gKGZsYWdzICYgSU5URUxfR1VDX1NFTkRfTkIpID8KPiArCQkoRklFTERfUFJFUChH VUNfSFhHX01TR18wX1RZUEUsIEdVQ19IWEdfVFlQRV9FVkVOVCkgfAo+ICsJCSBGSUVMRF9QUkVQ KEdVQ19IWEdfRVZFTlRfTVNHXzBfQUNUSU9OIHwKPiArCQkJICAgIEdVQ19IWEdfRVZFTlRfTVNH XzBfREFUQTAsIGFjdGlvblswXSkpIDoKPiArCQkoRklFTERfUFJFUChHVUNfSFhHX01TR18wX1RZ UEUsIEdVQ19IWEdfVFlQRV9SRVFVRVNUKSB8Cj4gKwkJIEZJRUxEX1BSRVAoR1VDX0hYR19SRVFV RVNUX01TR18wX0FDVElPTiB8Cj4gKwkJCSAgICBHVUNfSFhHX1JFUVVFU1RfTVNHXzBfREFUQTAs IGFjdGlvblswXSkpOwo+ICAKPiAgCUNUX0RFQlVHKGN0LCAid3JpdGluZyAodGFpbCAldSkgJSpw aCAlKnBoICUqcGhcbiIsCj4gIAkJIHRhaWwsIDQsICZoZWFkZXIsIDQsICZoeGcsIDQgKiAobGVu IC0gMSksICZhY3Rpb25bMV0pOwo+IEBAIC01MDAsNiArNTA5LDQ4IEBAIHN0YXRpYyBpbnQgd2Fp dF9mb3JfY3RfcmVxdWVzdF91cGRhdGUoc3RydWN0IGN0X3JlcXVlc3QgKnJlcSwgdTMyICpzdGF0 dXMpCj4gIAlyZXR1cm4gZXJyOwo+ICB9Cj4gIAo+ICtzdGF0aWMgaW5saW5lIGJvb2wgaDJnX2hh c19yb29tKHN0cnVjdCBpbnRlbF9ndWNfY3RfYnVmZmVyICpjdGIsIHUzMiBsZW5fZHcpCgp3aHkg aDJnIHByZWZpeCA/IGZ1bmN0aW9uIGlzIHRha2luZyBwdXJlICpjdGIsIHNvIG1heWJlOgoKCnN0 YXRpYyBib29sIGN0Yl9oYXNfcm9vbShzdHJ1Y3QgaW50ZWxfZ3VjX2N0X2J1ZmZlciAqY3RiLCB1 MzIgbGVuX2R3KQp7IC4uLiB9CgpzdGF0aWMgYm9vbCBjdF9jYW5fc2VuZChzdHJ1Y3QgaW50ZWxf Z3VjX2N0ICpjdCwgdTMyIGxlbl9kdykKewoJcmV0dXJuIGN0Yl9oYXNfcm9vbSgmY3QtPmN0YnMu c2VuZCwgbGVuX2R3ICsgQ1RCX0hEUl9MRU4pOwp9CgoKYXMgd2UgdXNlIHNlbmQvcmVjdiwgbm90 IGgyZy9nMmggYW5kIHRvIGF2b2lkIG1pc3Rha2VzIGFkZCBleHRyYSBoZWFkZXIKbGVuIGhlcmUg KG5vdCBieSBjYWxsZXIgLSBzYW1lIGFzIGluIGNhbGwgdG8gY3Rfd3JpdGUpCgo+ICt7Cj4gKwlz dHJ1Y3QgZ3VjX2N0X2J1ZmZlcl9kZXNjICpkZXNjID0gY3RiLT5kZXNjOwo+ICsJdTMyIGhlYWQg PSBSRUFEX09OQ0UoZGVzYy0+aGVhZCk7Cj4gKwl1MzIgc3BhY2U7Cj4gKwo+ICsJc3BhY2UgPSBD SVJDX1NQQUNFKGRlc2MtPnRhaWwsIGhlYWQsIGN0Yi0+c2l6ZSk7Cj4gKwo+ICsJcmV0dXJuIHNw YWNlID49IGxlbl9kdzsKPiArfQo+ICsKPiArc3RhdGljIGludCBjdF9zZW5kX25iKHN0cnVjdCBp bnRlbF9ndWNfY3QgKmN0LAo+ICsJCSAgICAgIGNvbnN0IHUzMiAqYWN0aW9uLAo+ICsJCSAgICAg IHUzMiBsZW4sCj4gKwkJICAgICAgdTMyIGZsYWdzKQo+ICt7Cj4gKwlzdHJ1Y3QgaW50ZWxfZ3Vj X2N0X2J1ZmZlciAqY3RiID0gJmN0LT5jdGJzLnNlbmQ7Cj4gKwl1bnNpZ25lZCBsb25nIHNwaW5f ZmxhZ3M7Cj4gKwl1MzIgZmVuY2U7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXNwaW5fbG9ja19pcnFz YXZlKCZjdGItPmxvY2ssIHNwaW5fZmxhZ3MpOwo+ICsKPiArCXJldCA9IGgyZ19oYXNfcm9vbShj dGIsIGxlbiArIEdVQ19DVEJfSERSX0xFTik7Cj4gKwlpZiAodW5saWtlbHkoIXJldCkpIHsKPiAr CQlyZXQgPSAtRUJVU1k7Cj4gKwkJZ290byBvdXQ7Cj4gKwl9Cj4gKwo+ICsJZmVuY2UgPSBjdF9n ZXRfbmV4dF9mZW5jZShjdCk7Cj4gKwlyZXQgPSBjdF93cml0ZShjdCwgYWN0aW9uLCBsZW4sIGZl bmNlLCBmbGFncyk7Cj4gKwlpZiAodW5saWtlbHkocmV0KSkKPiArCQlnb3RvIG91dDsKPiArCj4g KwlpbnRlbF9ndWNfbm90aWZ5KGN0X3RvX2d1YyhjdCkpOwo+ICsKPiArb3V0Ogo+ICsJc3Bpbl91 bmxvY2tfaXJxcmVzdG9yZSgmY3RiLT5sb2NrLCBzcGluX2ZsYWdzKTsKPiArCj4gKwlyZXR1cm4g cmV0Owo+ICt9Cj4gKwo+ICBzdGF0aWMgaW50IGN0X3NlbmQoc3RydWN0IGludGVsX2d1Y19jdCAq Y3QsCj4gIAkJICAgY29uc3QgdTMyICphY3Rpb24sCj4gIAkJICAgdTMyIGxlbiwKPiBAQCAtNTA3 LDggKzU1OCwxMCBAQCBzdGF0aWMgaW50IGN0X3NlbmQoc3RydWN0IGludGVsX2d1Y19jdCAqY3Qs Cj4gIAkJICAgdTMyIHJlc3BvbnNlX2J1Zl9zaXplLAo+ICAJCSAgIHUzMiAqc3RhdHVzKQo+ICB7 Cj4gKwlzdHJ1Y3QgaW50ZWxfZ3VjX2N0X2J1ZmZlciAqY3RiID0gJmN0LT5jdGJzLnNlbmQ7Cj4g IAlzdHJ1Y3QgY3RfcmVxdWVzdCByZXF1ZXN0Owo+ICAJdW5zaWduZWQgbG9uZyBmbGFnczsKPiAr CXVuc2lnbmVkIGludCBzbGVlcF9wZXJpb2RfbXMgPSAxOwo+ICAJdTMyIGZlbmNlOwo+ICAJaW50 IGVycjsKPiAgCj4gQEAgLTUxNiw4ICs1NjksMjQgQEAgc3RhdGljIGludCBjdF9zZW5kKHN0cnVj dCBpbnRlbF9ndWNfY3QgKmN0LAo+ICAJR0VNX0JVR19PTighbGVuKTsKPiAgCUdFTV9CVUdfT04o bGVuICYgfkdVQ19DVF9NU0dfTEVOX01BU0spOwo+ICAJR0VNX0JVR19PTighcmVzcG9uc2VfYnVm ICYmIHJlc3BvbnNlX2J1Zl9zaXplKTsKPiArCW1pZ2h0X3NsZWVwKCk7Cj4gKwo+ICsJLyoKPiAr CSAqIFdlIHVzZSBhIGxhenkgc3BpbiB3YWl0IGxvb3AgaGVyZSBhcyB3ZSBiZWxpZXZlIHRoYXQg aWYgdGhlIENUCj4gKwkgKiBidWZmZXJzIGFyZSBzaXplZCBjb3JyZWN0bHkgdGhlIGZsb3cgY29u dHJvbCBjb25kaXRpb24gc2hvdWxkIGJlCj4gKwkgKiByYXJlLgo+ICsJICovCj4gK3JldHJ5Ogo+ ICsJc3Bpbl9sb2NrX2lycXNhdmUoJmN0Yi0+bG9jaywgZmxhZ3MpOwo+ICsJaWYgKHVubGlrZWx5 KCFoMmdfaGFzX3Jvb20oY3RiLCBsZW4gKyBHVUNfQ1RCX0hEUl9MRU4pKSkgewo+ICsJCXNwaW5f dW5sb2NrX2lycXJlc3RvcmUoJmN0Yi0+bG9jaywgZmxhZ3MpOwo+ICAKPiAtCXNwaW5fbG9ja19p cnFzYXZlKCZjdC0+Y3Ricy5zZW5kLmxvY2ssIGZsYWdzKTsKPiArCQlpZiAobXNsZWVwX2ludGVy cnVwdGlibGUoc2xlZXBfcGVyaW9kX21zKSkKPiArCQkJcmV0dXJuIC1FSU5UUjsKPiArCQlzbGVl cF9wZXJpb2RfbXMgPSBzbGVlcF9wZXJpb2RfbXMgPDwgMTsKPiArCj4gKwkJZ290byByZXRyeTsK PiArCX0KCkknbSBzdGlsbCBub3QgY29udmluY2VkIHRoYXQgdGhpcyBjaHVuayBzaG91bGQgYmUg ZXhhY3RseSBpbiB0aGUgc2FtZQpwYXRjaCB0aGF0IGFkZHMgbm9uLWJsb2NraW5nIHBhdGgsIGl0 J3Mgbm90IHRoYXQgd2l0aCB2ZXJ5IGZpcnN0IHVzZSBvZgpvbmUgTkIgY2FsbCB3ZSB3aWxsIGhp dCBzdWNoIHByb2JsZW0KCnNvIElNSE8gaXQgY2FuIGJlIGRvbmUgZWFybGllciwgaW4gYnkgYW50 aWNpcGF0aW5nIHN1Y2ggcHJvYmxlbSwgb3IKbGF0ZXIgYXMgZml4IGZvciBwb3RlbnRpYWwgcHJv YmxlbSBkdWUgdG8gc3RyZXNzCgpub3RlIHRoYXQgaW4gdGhlIGNvbW1pdCBtZXNzYWdlIHlvdSBh ZG1pdHRlZCB0aGF0IG5ldyBOQiB2YXJpYW50IGlzIG5vdAp1c2VkIHlldCwgc28gd2UgY2FuJ3Qg YmUgaGl0CgppbiBvdGhlciB3b3JkcywgdHJ5IHRvIG1ha2UgcGF0Y2hlcyBmb2N1c2VkIG9uIG9u ZSBpdGVtIGF0IHRoZSB0aW1lLgoKPiAgCj4gIAlmZW5jZSA9IGN0X2dldF9uZXh0X2ZlbmNlKGN0 KTsKPiAgCXJlcXVlc3QuZmVuY2UgPSBmZW5jZTsKPiBAQCAtNTI5LDkgKzU5OCw5IEBAIHN0YXRp YyBpbnQgY3Rfc2VuZChzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCwKPiAgCWxpc3RfYWRkX3RhaWwo JnJlcXVlc3QubGluaywgJmN0LT5yZXF1ZXN0cy5wZW5kaW5nKTsKPiAgCXNwaW5fdW5sb2NrKCZj dC0+cmVxdWVzdHMubG9jayk7Cj4gIAo+IC0JZXJyID0gY3Rfd3JpdGUoY3QsIGFjdGlvbiwgbGVu LCBmZW5jZSk7Cj4gKwllcnIgPSBjdF93cml0ZShjdCwgYWN0aW9uLCBsZW4sIGZlbmNlLCAwKTsK PiAgCj4gLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjdC0+Y3Ricy5zZW5kLmxvY2ssIGZsYWdz KTsKPiArCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmN0Yi0+bG9jaywgZmxhZ3MpOwo+ICAKPiAg CWlmICh1bmxpa2VseShlcnIpKQo+ICAJCWdvdG8gdW5saW5rOwo+IEBAIC01NzEsNyArNjQwLDcg QEAgc3RhdGljIGludCBjdF9zZW5kKHN0cnVjdCBpbnRlbF9ndWNfY3QgKmN0LAo+ICAgKiBDb21t YW5kIFRyYW5zcG9ydCAoQ1QpIGJ1ZmZlciBiYXNlZCBHdUMgc2VuZCBmdW5jdGlvbi4KPiAgICov Cj4gIGludCBpbnRlbF9ndWNfY3Rfc2VuZChzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCwgY29uc3Qg dTMyICphY3Rpb24sIHUzMiBsZW4sCj4gLQkJICAgICAgdTMyICpyZXNwb25zZV9idWYsIHUzMiBy ZXNwb25zZV9idWZfc2l6ZSkKPiArCQkgICAgICB1MzIgKnJlc3BvbnNlX2J1ZiwgdTMyIHJlc3Bv bnNlX2J1Zl9zaXplLCB1MzIgZmxhZ3MpCj4gIHsKPiAgCXUzMiBzdGF0dXMgPSB+MDsgLyogdW5k ZWZpbmVkICovCj4gIAlpbnQgcmV0Owo+IEBAIC01ODEsNiArNjUwLDkgQEAgaW50IGludGVsX2d1 Y19jdF9zZW5kKHN0cnVjdCBpbnRlbF9ndWNfY3QgKmN0LCBjb25zdCB1MzIgKmFjdGlvbiwgdTMy IGxlbiwKPiAgCQlyZXR1cm4gLUVOT0RFVjsKPiAgCX0KPiAgCj4gKwlpZiAoZmxhZ3MgJiBJTlRF TF9HVUNfU0VORF9OQikKPiArCQlyZXR1cm4gY3Rfc2VuZF9uYihjdCwgYWN0aW9uLCBsZW4sIGZs YWdzKTsKPiArCj4gIAlyZXQgPSBjdF9zZW5kKGN0LCBhY3Rpb24sIGxlbiwgcmVzcG9uc2VfYnVm LCByZXNwb25zZV9idWZfc2l6ZSwgJnN0YXR1cyk7Cj4gIAlpZiAodW5saWtlbHkocmV0IDwgMCkp IHsKPiAgCQlDVF9FUlJPUihjdCwgIlNlbmRpbmcgYWN0aW9uICUjeCBmYWlsZWQgKGVycj0lZCBz dGF0dXM9JSNYKVxuIiwKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMv aW50ZWxfZ3VjX2N0LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfY3Qu aAo+IGluZGV4IDFhZTJkZGU2ZGI5My4uZjZhNGQ1YjMzNDY3IDEwMDY0NAo+IC0tLSBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19jdC5oCj4gKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2N0LmgKPiBAQCAtNDIsNyArNDIsNiBAQCBzdHJ1Y3Qg aW50ZWxfZ3VjX2N0X2J1ZmZlciB7Cj4gIAlib29sIGJyb2tlbjsKPiAgfTsKPiAgCj4gLQo+ICAv KiogVG9wLWxldmVsIHN0cnVjdHVyZSBmb3IgQ29tbWFuZCBUcmFuc3BvcnQgcmVsYXRlZCBkYXRh Cj4gICAqCj4gICAqIEluY2x1ZGVzIGEgcGFpciBvZiBDVCBidWZmZXJzIGZvciBiaS1kaXJlY3Rp b25hbCBjb21tdW5pY2F0aW9uIGFuZCB0cmFja2luZwo+IEBAIC04Nyw4ICs4Niw5IEBAIHN0YXRp YyBpbmxpbmUgYm9vbCBpbnRlbF9ndWNfY3RfZW5hYmxlZChzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpj dCkKPiAgCXJldHVybiBjdC0+ZW5hYmxlZDsKPiAgfQo+ICAKPiArI2RlZmluZSBJTlRFTF9HVUNf U0VORF9OQgkJQklUKDMxKQoKSU5URUxfR1VDX0NUX1NFTkRfTkIgPwogICAgICAgICBeXl5eCgo+ ICBpbnQgaW50ZWxfZ3VjX2N0X3NlbmQoc3RydWN0IGludGVsX2d1Y19jdCAqY3QsIGNvbnN0IHUz MiAqYWN0aW9uLCB1MzIgbGVuLAo+IC0JCSAgICAgIHUzMiAqcmVzcG9uc2VfYnVmLCB1MzIgcmVz cG9uc2VfYnVmX3NpemUpOwo+ICsJCSAgICAgIHUzMiAqcmVzcG9uc2VfYnVmLCB1MzIgcmVzcG9u c2VfYnVmX3NpemUsIHUzMiBmbGFncyk7Cj4gIHZvaWQgaW50ZWxfZ3VjX2N0X2V2ZW50X2hhbmRs ZXIoc3RydWN0IGludGVsX2d1Y19jdCAqY3QpOwo+ICAKPiAgI2VuZGlmIC8qIF9JTlRFTF9HVUNf Q1RfSF8gKi8KPiAKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3Jn Cmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4 Cg==