From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2F242199E89 for ; Sun, 9 Aug 2026 13:31:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786282305; cv=none; b=tCCZ/laVGgrmxpbnlmTD6N7us1lHMCW1x3LWcTKkWi5kh6ugbtXb00FEcxpereNYGHFhwKqDZ36us7Sl5NbWgBdIauEExeer9PzeDCqZgmy/ydOKBN1fZYyXaxzfiohkdxeh7uvga5vz8U3HYYMzNu2LqfJQVWVK1jbcL/LFRu4= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786282305; c=relaxed/simple; bh=65KhCPQH+zwrhT5rufOLH8O2pBIMyg/R1/X10vGsRgw=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=In9Dfc2kWtGbtZo4SkRf9Ngy59Pz1LdxO4HKUyadtw7PYWVAm590x5z9u2M00IsGvwYT6vTfVIKGGOpz4O3mLHZlL+IL7wN3EuImsTpFC2XHKtuIxcK/FbvfUhock9iL50LZ9pNhAk9KOFuyf2Wsk30kWW3J0Z3fU4pcErTi8t8= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=UuVJzp4P; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="UuVJzp4P" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 5776C1F000E9; Sun, 9 Aug 2026 13:31:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1786282303; bh=ejPdgbVfgw5V8U8PhcQ2tH70UH1Z9rPYw9PMMJnGwHU=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=UuVJzp4PYwlqPSwVgHUO7rSfedE3//qrQYrjLj56OhPQ1RPltuHwZJsvh2dKhLcA2 IICF+agHlgbdqrCnrxpGFGp64D3eCO1bUq3Bj2Gr4U3cmo4clodrxv/RoGVZuiiv/I RI07nMXVlPIpqV+8FTWBcHbJdNTqC/yWoXl3aZjCk9RLxAXJylBbrGO5tMCkY57npf WnMOWY1b1NpLkNt3/BDowiWPi/ohpt+vinv7lZOdX5tE5DFK1seFmuybw/lvZZBUYt ASL8Pw4l8KP3zuMSQbGQinHlk1m2vP37YbGPdH6EF2f2mOO6GbEVOsYLQD3C0oR+KX U9E0YT6F8SJrg== From: sashiko-bot@kernel.org Subject: Re: [PATCH v2 09/17] drm/spacemit: add Saturn DPU hardware backend Reply-To: sashiko-reviews@lists.linux.dev To: "Cody Kang" Cc: neil.armstrong@linaro.org, olteanv@gmail.com, robh@kernel.org, linux-phy@lists.infradead.org, devicetree@vger.kernel.org, vkoul@kernel.org, dri-devel@lists.freedesktop.org, conor+dt@kernel.org In-Reply-To: <20260809-k3-display-v2-9-327d7910bf71@gmail.com> References: <20260809-k3-display-v2-0-327d7910bf71@gmail.com> <20260809-k3-display-v2-9-327d7910bf71@gmail.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Sun, 09 Aug 2026 13:31:42 +0000 Message-Id: <20260809133143.5776C1F000E9@smtp.kernel.org> Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Thank you for your contribution! Sashiko AI review found 14 potential issue= (s) to consider: - [High] Dynamic memory allocation using GFP_KERNEL inside plane atomic upd= ate, disable, and CRTC flush paths. - [High] If cmdlist memory allocation fails, the driver falls back to direc= t MMIO writes during atomic updates, breaking transaction semantics. - [High] Unsynchronized lockless access to `flip_done` between ISR and time= r handler allows double `drm_crtc_vblank_put()`. - [High] Dereferencing `state->fb` without checking for NULL causes a crash= when configuring pixel blending for solid fill planes. - [High] Potential NULL pointer dereference of `state->fb` in `saturn_cal_l= ayer_fbcmem_size`. - [High] The `dpu_init` function uses the sleeping function `usleep_range()= ` while executing from an atomic commit path. - [High] The `cfg_rdy_timer` is not synchronously cancelled during device t= eardown, leading to a potential use-after-free. - [High] The VBLANK ISR and timer handler directly access `crtc->state->eve= nt`, causing a race condition with concurrent atomic commits. - [High] Silently dropped cmdlist rows cause the hardware DMA to read out-o= f-bounds memory. - [Medium] Hardware clocks are disabled in the same forward order they were= enabled, violating clock dependencies. - [Medium] C bitfields are used for defining hardware DMA descriptor layout= s. - [Medium] Unchecked `drm_crtc_vblank_get` return value leads to refcount u= nderflow. - [Medium] Double-clearing of underrun interrupt status due to stale irq_ra= w snapshot. - [Medium] Useless and contextually incorrect read memory barrier (dma_rmb). -- --- Patch [9]: [PATCH v2 09/17] drm/spacemit: add Saturn DPU hardware backe= nd --- commit 203a676effd210733651accaca4eebc02e32d9c2 Author: Cody Kang Subject: drm/spacemit: add Saturn DPU hardware backend This commit adds the register-level programming of the Saturn instance, including clock and reset bring-up, scene control, and timing generator set= up. The backend is exposed as an ops table for the KMS layer. > diff --git a/drivers/gpu/drm/spacemit/dpu/dpu_saturn.c b/drivers/gpu/drm/= spacemit/dpu/dpu_saturn.c > --- /dev/null > +++ b/drivers/gpu/drm/spacemit/dpu/dpu_saturn.c [ ... ] > +static int dpu_disable_clocks(struct spacemit_crtc *a_crtc) > +{ > + struct dpu_clk_context *clk_ctx =3D &a_crtc->clk_ctx; > + > + trace_dpu_disable_clocks(a_crtc->dev_id); > + > + clk_disable_unprepare(clk_ctx->pxclk); > + clk_disable_unprepare(clk_ctx->mclk); > + clk_disable_unprepare(clk_ctx->escclk); > + > + clk_disable_unprepare(clk_ctx->aclk); > + clk_disable_unprepare(clk_ctx->dscclk); [Severity: Medium] Providers should usually be disabled after their consumers, but this matches the exact forward order they were enabled in dpu_enable_clocks(). Are these clocks being disabled in the correct order? [ ... ] > +static int dpu_init(struct spacemit_crtc *a_crtc) > +{ > + unsigned int timeout =3D 1000; > + struct spacemit_drm_private *priv =3D a_crtc->crtc.dev->dev_private; > + struct spacemit_hw_device *hwdev =3D priv->hwdev; > + > + if (!a_crtc->clocks_on) > + return 0; > + > + while (timeout) { > + if (hwdev->get_cfg_rdy(a_crtc, hwdev) =3D=3D 0) > + break; > + usleep_range(100, 200); [Severity: High] dpu_init() appears to be called from the CRTC's atomic enable sequence, where sleeping is strictly forbidden and can cause kernel warnings or deadlocks. Is it safe to call a sleeping function like usleep_range() here? [ ... ] > +static void dpu_uninit(struct spacemit_crtc *a_crtc) > +{ > + struct spacemit_drm_private *priv =3D a_crtc->crtc.dev->dev_private; > + struct spacemit_hw_device *hwdev =3D priv->hwdev; > + > + if (!a_crtc->clocks_on) > + return; > + > + trace_dpu_uninit(a_crtc->dev_id); > + hwdev->irq_enable(a_crtc, false); > +} [Severity: High] If the driver unbinds while the timer is pending, the timer callback could execute on freed spacemit_crtc memory, leading to a use-after-free. Should there be a synchronous cancellation of cfg_rdy_timer here? [ ... ] > +static inline void dpu_isr_vblank(struct spacemit_crtc *a_crtc, bool *fl= ip) > +{ > + struct drm_crtc *crtc =3D &a_crtc->crtc; > + struct drm_device *drm =3D crtc->dev; > + struct drm_pending_vblank_event *event; > + > + drm_crtc_handle_vblank(crtc); > + > + if (*flip) > + return; > + *flip =3D true; > + > + /* > + * event_lock serialises this against the commit arming > + * crtc->state->event. > + */ > + spin_lock(&drm->event_lock); > + event =3D crtc->state->event; > + if (event) { [Severity: High] The crtc->state can be swapped asynchronously by drm_atomic_helper_swap_state(), which could cause this handler to point to a new event and lose the old one if multiple commits are queued rapidly. Is it safe to directly dereference crtc->state->event dynamically from an asynchronous context? [ ... ] > +static u32 dpu_online_isr(struct spacemit_crtc *a_crtc) > +{ [ ... ] > + irq_raw =3D hwdev->get_int_sts(hwdev, dev_id); > + trace_dpu_isr_status("ONLINE", irq_raw); > + irq_bit =3D hwdev->get_irq_bit(INT_UNDERRUN, dev_id); > + irq_ur_bit =3D irq_raw & irq_bit; > + if (irq_ur_bit && !a_crtc->ur_reported) { > + hwdev->clr_int_sts(a_crtc, irq_ur_bit, dev_id); > + trace_dpu_isr_status("underrun", irq_ur_bit); > + drm_err_ratelimited(a_crtc->crtc.dev, "underrun\n"); > + a_crtc->ur_reported =3D true; > + } > + irq_bit =3D hwdev->get_irq_bit(INT_CFG_RDY, dev_id); > + if (irq_raw & irq_bit) { > + hwdev->clr_int_sts(a_crtc, irq_bit, dev_id); > + trace_dpu_isr_status("cfg_rdy_clr", irq_raw & irq_bit); > + /* > + * A fired watchdog already sent the event and put this flip's > + * vblank reference; re-arming the vsync path would put twice. > + */ > + if (timer_delete(&a_crtc->cfg_rdy_timer)) > + a_crtc->flip_done =3D false; [Severity: High] If the timer executes on another CPU, timer_delete() returns 0 and both the ISR and the timer handler could execute lockless modifications to flip_done and call drm_crtc_vblank_put() twice. Could this non-synchronous timer cancellation leave the callback running concurrently? [ ... ] > + irq_bit =3D hwdev->get_irq_bit(INT_REST, dev_id) | irq_ur_bit; > + if (irq_raw & irq_bit) > + hwdev->clr_int_sts(a_crtc, irq_bit, dev_id); [Severity: Medium] The code takes a single snapshot of irq_raw at the start of the ISR, clears irq_ur_bit if present, and then clears it again here using the stale snapshot. A new underrun firing in that window could be cleared without being processed. Does double-clearing the underrun interrupt status risk losing interrupts? [ ... ] > +static void dpu_run(struct drm_crtc *crtc, > + struct drm_crtc_state *old_state) > +{ [ ... ] > + /* flush all config register writes before CFG_RDY is raised */ > + mb(); > + > + drm_crtc_vblank_get(crtc); [Severity: Medium] If getting the vblank fails, the reference is not taken, but the ISR still unconditionally calls drm_crtc_vblank_put(), which can lead to a vblank reference count underflow. Should the return value of drm_crtc_vblank_get() be checked? > + if (hwdev->enable_cfg_irq) > + hwdev->enable_cfg_irq(a_crtc, hwdev, true); > + > + saturn_ctrl_cfg_ready(a_crtc, true); > + > + if (unlikely(a_crtc->is_1st_f)) { > + drm_dbg(a_crtc->crtc.dev, "DPU start\n"); > + a_crtc->is_1st_f =3D false; > + saturn_ctrl_sw_start(a_crtc, true); > + } > + dma_rmb(); > +} [Severity: Medium] A read memory barrier strictly enforces ordering between CPU reads, but the preceding operation writes to DMA control registers to start the engine. Is this read memory barrier required here? It seems semantically out of place. > diff --git a/drivers/gpu/drm/spacemit/dpu/dpu_saturn_hee.c b/drivers/gpu/= drm/spacemit/dpu/dpu_saturn_hee.c > --- /dev/null > +++ b/drivers/gpu/drm/spacemit/dpu/dpu_saturn_hee.c [ ... ] > +void saturn_hee_plane_update_hw_channel(struct drm_plane *plane) > +{ [ ... ] > + if (state->fb->format && state->fb->format->has_alpha && > + pixel_alpha !=3D DRM_MODE_BLEND_PIXEL_NONE) { [Severity: High] For solid fill planes, state->fb is typically NULL. Evaluating state->fb->format without a NULL check could cause a kernel oops when userspace submits an atomic commit for a solid-color plane. Can state->fb be NULL here? [ ... ] > + cl_cmp =3D alloc_cmdlist_regs(CMPS_X_REG); > + > + base =3D CMP_BASE_ADDR[a_crtc->dev_id]; > + dpu_write(hwdev, CMPS_X_REG, base, dst_w, mode->hdisplay, cl_cmp); > + dpu_write(hwdev, CMPS_X_REG, base, dst_h, mode->vdisplay, cl_cmp); > + > + SATURN_WRITE_COMPOSER_LAYER(00); [Severity: High] The alloc_cmdlist_regs macro internally uses kzalloc with GFP_KERNEL. Can this allocation sleep in an atomic context and trigger deadlock warning= s, since it is called from the plane atomic update callback? Also, if this allocation fails and returns NULL, cl_cmp is passed directly = to SATURN_WRITE_COMPOSER_LAYER and dpu_write. The dpu_write logic falls back to direct MMIO writes when the command list is NULL. Does this bypass command list synchronization to VBLANK and risk applying partial state immediately? [ ... ] > +struct cmdlist_header { > + u64 next_list_addr : 39; > + /* reserved */ > + u32: 1; > + u32 nod_len : 16; > + /* 1: the last cmdlist node, 2: pending node, otherwise 0 */ > + u32 nod_type : 2; > + u32 next_nod_secu : 1; > + u64 wait_event_low : 5; > + u64 wait_event : 59; > + /* reserved */ > + u32: 5; > +}; [Severity: Medium] Bitfield packing and ordering are heavily compiler and architecture depende= nt, which might produce incorrect structures in memory for the hardware DMA to read. Is it safe to use C bitfields for hardware DMA descriptor layouts? [ ... ] > +void saturn_hee_cmdlist_fill_data_row(struct cmdlist *cl, u32 strobe, > + u32 offset, u32 value[]) > +{ > + struct cmdlist_row *row; > + u8 i; > + > + /* > + * packing counts rows blindly; drop the row rather than the buffer end > + */ > + if (WARN_ONCE(CL_HEADER_SZ + (cl->nod_len + 1) * CL_ROW_SZ > cl->size, > + "cmdlist buffer full (rows %u)\n", cl->nod_len)) > + return; [Severity: High] Since this function silently drops the row and returns void, the caller cmdlist_regs_packing() will blindly increment cl->nod_len regardless of buffer truncation. Could this inflated length cause the DMA engine to read past the end of the initialized buffer? > diff --git a/drivers/gpu/drm/spacemit/dpu/saturn_fbcmem.c b/drivers/gpu/d= rm/spacemit/dpu/saturn_fbcmem.c > --- /dev/null > +++ b/drivers/gpu/drm/spacemit/dpu/saturn_fbcmem.c [ ... ] > +int saturn_cal_layer_fbcmem_size(struct drm_plane *plane, > + struct drm_plane_state *state) > +{ > + struct spacemit_plane_state *pstate =3D to_spacemit_plane_state(state); > + u32 drm_4cc_fmt =3D pstate->state.fb->format->format; [Severity: High] If a plane is being disabled or is in a solid fill mode, the framebuffer pointer will be NULL, which would cause an immediate crash during the atomic check phase. Is it guaranteed that pstate->state.fb is non-NULL here? --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260809-k3-display= -v2-0-327d7910bf71@gmail.com?part=3D9 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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 87180C5AC80 for ; Sun, 9 Aug 2026 13:31:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Reply-To:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:Message-Id:Date: References:In-Reply-To:Cc:To:Subject:From:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=JpKaaRIEd5M6Kh6NQkugyLgnIPXVigIaA1Ti6Dza+Kk=; b=f8qaz+/laTiv+t NsGABZ8a3Eqizc5aiEU9Fuj8jJ2S+l/P6Dr74SzQ/9o/Ng39y0GM73hmIAmhgz5x9ykk9v/2Xkop8 IWDjU2IfRW/ZrZQTV7cYk/pEwDVNxhLd/2tunOSIE5FA/X9d9SMGoe3QtLjXVwT2w2UyBsPGDkhSc vCWyweCidjmTvwd4XLfXuC2De0g4PzgHTlHNSBxo9RP1akJ8ia83r1PDZAoH1BiJrxlviaQYu5taR 8DX6iAPIQLycL0q3DS7MiXxrBrgR9Lqn5MJm2WOgH0g4aeRvx3e6DPCv4YlrV7yIAizevwxnEu2pU r5y1S5D4rJY8PAxVSN9A==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wt3cv-0000000AMFJ-12Cz; Sun, 09 Aug 2026 13:31:45 +0000 Received: from tor.source.kernel.org ([172.105.4.254]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wt3cu-0000000AMFC-2yc9 for linux-phy@lists.infradead.org; Sun, 09 Aug 2026 13:31:44 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id 1D7C5600AB; Sun, 9 Aug 2026 13:31:44 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 5776C1F000E9; Sun, 9 Aug 2026 13:31:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1786282303; bh=ejPdgbVfgw5V8U8PhcQ2tH70UH1Z9rPYw9PMMJnGwHU=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=UuVJzp4PYwlqPSwVgHUO7rSfedE3//qrQYrjLj56OhPQ1RPltuHwZJsvh2dKhLcA2 IICF+agHlgbdqrCnrxpGFGp64D3eCO1bUq3Bj2Gr4U3cmo4clodrxv/RoGVZuiiv/I RI07nMXVlPIpqV+8FTWBcHbJdNTqC/yWoXl3aZjCk9RLxAXJylBbrGO5tMCkY57npf WnMOWY1b1NpLkNt3/BDowiWPi/ohpt+vinv7lZOdX5tE5DFK1seFmuybw/lvZZBUYt ASL8Pw4l8KP3zuMSQbGQinHlk1m2vP37YbGPdH6EF2f2mOO6GbEVOsYLQD3C0oR+KX U9E0YT6F8SJrg== From: sashiko-bot@kernel.org Subject: Re: [PATCH v2 09/17] drm/spacemit: add Saturn DPU hardware backend To: "Cody Kang" Cc: neil.armstrong@linaro.org, olteanv@gmail.com, robh@kernel.org, linux-phy@lists.infradead.org, devicetree@vger.kernel.org, vkoul@kernel.org, dri-devel@lists.freedesktop.org, conor+dt@kernel.org In-Reply-To: <20260809-k3-display-v2-9-327d7910bf71@gmail.com> References: <20260809-k3-display-v2-0-327d7910bf71@gmail.com> <20260809-k3-display-v2-9-327d7910bf71@gmail.com> Date: Sun, 09 Aug 2026 13:31:42 +0000 Message-Id: <20260809133143.5776C1F000E9@smtp.kernel.org> X-BeenThere: linux-phy@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux Phy Mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: sashiko-reviews@lists.linux.dev MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-phy" Errors-To: linux-phy-bounces+linux-phy=archiver.kernel.org@lists.infradead.org VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg MTQgcG90ZW50aWFsIGlzc3VlKHMpIHRvIGNvbnNpZGVyOgotIFtIaWdoXSBEeW5hbWljIG1lbW9y eSBhbGxvY2F0aW9uIHVzaW5nIEdGUF9LRVJORUwgaW5zaWRlIHBsYW5lIGF0b21pYyB1cGRhdGUs IGRpc2FibGUsIGFuZCBDUlRDIGZsdXNoIHBhdGhzLgotIFtIaWdoXSBJZiBjbWRsaXN0IG1lbW9y eSBhbGxvY2F0aW9uIGZhaWxzLCB0aGUgZHJpdmVyIGZhbGxzIGJhY2sgdG8gZGlyZWN0IE1NSU8g d3JpdGVzIGR1cmluZyBhdG9taWMgdXBkYXRlcywgYnJlYWtpbmcgdHJhbnNhY3Rpb24gc2VtYW50 aWNzLgotIFtIaWdoXSBVbnN5bmNocm9uaXplZCBsb2NrbGVzcyBhY2Nlc3MgdG8gYGZsaXBfZG9u ZWAgYmV0d2VlbiBJU1IgYW5kIHRpbWVyIGhhbmRsZXIgYWxsb3dzIGRvdWJsZSBgZHJtX2NydGNf dmJsYW5rX3B1dCgpYC4KLSBbSGlnaF0gRGVyZWZlcmVuY2luZyBgc3RhdGUtPmZiYCB3aXRob3V0 IGNoZWNraW5nIGZvciBOVUxMIGNhdXNlcyBhIGNyYXNoIHdoZW4gY29uZmlndXJpbmcgcGl4ZWwg YmxlbmRpbmcgZm9yIHNvbGlkIGZpbGwgcGxhbmVzLgotIFtIaWdoXSBQb3RlbnRpYWwgTlVMTCBw b2ludGVyIGRlcmVmZXJlbmNlIG9mIGBzdGF0ZS0+ZmJgIGluIGBzYXR1cm5fY2FsX2xheWVyX2Zi Y21lbV9zaXplYC4KLSBbSGlnaF0gVGhlIGBkcHVfaW5pdGAgZnVuY3Rpb24gdXNlcyB0aGUgc2xl ZXBpbmcgZnVuY3Rpb24gYHVzbGVlcF9yYW5nZSgpYCB3aGlsZSBleGVjdXRpbmcgZnJvbSBhbiBh dG9taWMgY29tbWl0IHBhdGguCi0gW0hpZ2hdIFRoZSBgY2ZnX3JkeV90aW1lcmAgaXMgbm90IHN5 bmNocm9ub3VzbHkgY2FuY2VsbGVkIGR1cmluZyBkZXZpY2UgdGVhcmRvd24sIGxlYWRpbmcgdG8g YSBwb3RlbnRpYWwgdXNlLWFmdGVyLWZyZWUuCi0gW0hpZ2hdIFRoZSBWQkxBTksgSVNSIGFuZCB0 aW1lciBoYW5kbGVyIGRpcmVjdGx5IGFjY2VzcyBgY3J0Yy0+c3RhdGUtPmV2ZW50YCwgY2F1c2lu ZyBhIHJhY2UgY29uZGl0aW9uIHdpdGggY29uY3VycmVudCBhdG9taWMgY29tbWl0cy4KLSBbSGln aF0gU2lsZW50bHkgZHJvcHBlZCBjbWRsaXN0IHJvd3MgY2F1c2UgdGhlIGhhcmR3YXJlIERNQSB0 byByZWFkIG91dC1vZi1ib3VuZHMgbWVtb3J5LgotIFtNZWRpdW1dIEhhcmR3YXJlIGNsb2NrcyBh cmUgZGlzYWJsZWQgaW4gdGhlIHNhbWUgZm9yd2FyZCBvcmRlciB0aGV5IHdlcmUgZW5hYmxlZCwg dmlvbGF0aW5nIGNsb2NrIGRlcGVuZGVuY2llcy4KLSBbTWVkaXVtXSBDIGJpdGZpZWxkcyBhcmUg dXNlZCBmb3IgZGVmaW5pbmcgaGFyZHdhcmUgRE1BIGRlc2NyaXB0b3IgbGF5b3V0cy4KLSBbTWVk aXVtXSBVbmNoZWNrZWQgYGRybV9jcnRjX3ZibGFua19nZXRgIHJldHVybiB2YWx1ZSBsZWFkcyB0 byByZWZjb3VudCB1bmRlcmZsb3cuCi0gW01lZGl1bV0gRG91YmxlLWNsZWFyaW5nIG9mIHVuZGVy cnVuIGludGVycnVwdCBzdGF0dXMgZHVlIHRvIHN0YWxlIGlycV9yYXcgc25hcHNob3QuCi0gW01l ZGl1bV0gVXNlbGVzcyBhbmQgY29udGV4dHVhbGx5IGluY29ycmVjdCByZWFkIG1lbW9yeSBiYXJy aWVyIChkbWFfcm1iKS4KLS0KCi0tLSBQYXRjaCBbOV06IFtQQVRDSCB2MiAwOS8xN10gZHJtL3Nw YWNlbWl0OiBhZGQgU2F0dXJuIERQVSBoYXJkd2FyZSBiYWNrZW5kIC0tLQpjb21taXQgMjAzYTY3 NmVmZmQyMTA3MzM2NTFhY2NhY2E0ZWViYzAyZTMyZDljMgpBdXRob3I6IENvZHkgS2FuZyA8Y29k eWthbmcuaGtAZ21haWwuY29tPgpTdWJqZWN0OiBkcm0vc3BhY2VtaXQ6IGFkZCBTYXR1cm4gRFBV IGhhcmR3YXJlIGJhY2tlbmQKClRoaXMgY29tbWl0IGFkZHMgdGhlIHJlZ2lzdGVyLWxldmVsIHBy b2dyYW1taW5nIG9mIHRoZSBTYXR1cm4gaW5zdGFuY2UsCmluY2x1ZGluZyBjbG9jayBhbmQgcmVz ZXQgYnJpbmctdXAsIHNjZW5lIGNvbnRyb2wsIGFuZCB0aW1pbmcgZ2VuZXJhdG9yIHNldHVwLgpU aGUgYmFja2VuZCBpcyBleHBvc2VkIGFzIGFuIG9wcyB0YWJsZSBmb3IgdGhlIEtNUyBsYXllci4K Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9zcGFjZW1pdC9kcHUvZHB1X3NhdHVybi5j IGIvZHJpdmVycy9ncHUvZHJtL3NwYWNlbWl0L2RwdS9kcHVfc2F0dXJuLmMKPiAtLS0gL2Rldi9u dWxsCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3NwYWNlbWl0L2RwdS9kcHVfc2F0dXJuLmMKWyAu Li4gXQo+ICtzdGF0aWMgaW50IGRwdV9kaXNhYmxlX2Nsb2NrcyhzdHJ1Y3Qgc3BhY2VtaXRfY3J0 YyAqYV9jcnRjKQo+ICt7Cj4gKwlzdHJ1Y3QgZHB1X2Nsa19jb250ZXh0ICpjbGtfY3R4ID0gJmFf Y3J0Yy0+Y2xrX2N0eDsKPiArCj4gKwl0cmFjZV9kcHVfZGlzYWJsZV9jbG9ja3MoYV9jcnRjLT5k ZXZfaWQpOwo+ICsKPiArCWNsa19kaXNhYmxlX3VucHJlcGFyZShjbGtfY3R4LT5weGNsayk7Cj4g KwljbGtfZGlzYWJsZV91bnByZXBhcmUoY2xrX2N0eC0+bWNsayk7Cj4gKwljbGtfZGlzYWJsZV91 bnByZXBhcmUoY2xrX2N0eC0+ZXNjY2xrKTsKPiArCj4gKwljbGtfZGlzYWJsZV91bnByZXBhcmUo Y2xrX2N0eC0+YWNsayk7Cj4gKwljbGtfZGlzYWJsZV91bnByZXBhcmUoY2xrX2N0eC0+ZHNjY2xr KTsKCltTZXZlcml0eTogTWVkaXVtXQpQcm92aWRlcnMgc2hvdWxkIHVzdWFsbHkgYmUgZGlzYWJs ZWQgYWZ0ZXIgdGhlaXIgY29uc3VtZXJzLCBidXQgdGhpcyBtYXRjaGVzCnRoZSBleGFjdCBmb3J3 YXJkIG9yZGVyIHRoZXkgd2VyZSBlbmFibGVkIGluIGRwdV9lbmFibGVfY2xvY2tzKCkuCgpBcmUg dGhlc2UgY2xvY2tzIGJlaW5nIGRpc2FibGVkIGluIHRoZSBjb3JyZWN0IG9yZGVyPwoKWyAuLi4g XQo+ICtzdGF0aWMgaW50IGRwdV9pbml0KHN0cnVjdCBzcGFjZW1pdF9jcnRjICphX2NydGMpCj4g K3sKPiArCXVuc2lnbmVkIGludCB0aW1lb3V0ID0gMTAwMDsKPiArCXN0cnVjdCBzcGFjZW1pdF9k cm1fcHJpdmF0ZSAqcHJpdiA9IGFfY3J0Yy0+Y3J0Yy5kZXYtPmRldl9wcml2YXRlOwo+ICsJc3Ry dWN0IHNwYWNlbWl0X2h3X2RldmljZSAqaHdkZXYgPSBwcml2LT5od2RldjsKPiArCj4gKwlpZiAo IWFfY3J0Yy0+Y2xvY2tzX29uKQo+ICsJCXJldHVybiAwOwo+ICsKPiArCXdoaWxlICh0aW1lb3V0 KSB7Cj4gKwkJaWYgKGh3ZGV2LT5nZXRfY2ZnX3JkeShhX2NydGMsIGh3ZGV2KSA9PSAwKQo+ICsJ CQlicmVhazsKPiArCQl1c2xlZXBfcmFuZ2UoMTAwLCAyMDApOwoKW1NldmVyaXR5OiBIaWdoXQpk cHVfaW5pdCgpIGFwcGVhcnMgdG8gYmUgY2FsbGVkIGZyb20gdGhlIENSVEMncyBhdG9taWMgZW5h YmxlIHNlcXVlbmNlLAp3aGVyZSBzbGVlcGluZyBpcyBzdHJpY3RseSBmb3JiaWRkZW4gYW5kIGNh biBjYXVzZSBrZXJuZWwgd2FybmluZ3Mgb3IKZGVhZGxvY2tzLgoKSXMgaXQgc2FmZSB0byBjYWxs IGEgc2xlZXBpbmcgZnVuY3Rpb24gbGlrZSB1c2xlZXBfcmFuZ2UoKSBoZXJlPwoKWyAuLi4gXQo+ ICtzdGF0aWMgdm9pZCBkcHVfdW5pbml0KHN0cnVjdCBzcGFjZW1pdF9jcnRjICphX2NydGMpCj4g K3sKPiArCXN0cnVjdCBzcGFjZW1pdF9kcm1fcHJpdmF0ZSAqcHJpdiA9IGFfY3J0Yy0+Y3J0Yy5k ZXYtPmRldl9wcml2YXRlOwo+ICsJc3RydWN0IHNwYWNlbWl0X2h3X2RldmljZSAqaHdkZXYgPSBw cml2LT5od2RldjsKPiArCj4gKwlpZiAoIWFfY3J0Yy0+Y2xvY2tzX29uKQo+ICsJCXJldHVybjsK PiArCj4gKwl0cmFjZV9kcHVfdW5pbml0KGFfY3J0Yy0+ZGV2X2lkKTsKPiArCWh3ZGV2LT5pcnFf ZW5hYmxlKGFfY3J0YywgZmFsc2UpOwo+ICt9CgpbU2V2ZXJpdHk6IEhpZ2hdCklmIHRoZSBkcml2 ZXIgdW5iaW5kcyB3aGlsZSB0aGUgdGltZXIgaXMgcGVuZGluZywgdGhlIHRpbWVyIGNhbGxiYWNr IGNvdWxkCmV4ZWN1dGUgb24gZnJlZWQgc3BhY2VtaXRfY3J0YyBtZW1vcnksIGxlYWRpbmcgdG8g YSB1c2UtYWZ0ZXItZnJlZS4KClNob3VsZCB0aGVyZSBiZSBhIHN5bmNocm9ub3VzIGNhbmNlbGxh dGlvbiBvZiBjZmdfcmR5X3RpbWVyIGhlcmU/CgpbIC4uLiBdCj4gK3N0YXRpYyBpbmxpbmUgdm9p ZCBkcHVfaXNyX3ZibGFuayhzdHJ1Y3Qgc3BhY2VtaXRfY3J0YyAqYV9jcnRjLCBib29sICpmbGlw KQo+ICt7Cj4gKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGMgPSAmYV9jcnRjLT5jcnRjOwo+ICsJc3Ry dWN0IGRybV9kZXZpY2UgKmRybSA9IGNydGMtPmRldjsKPiArCXN0cnVjdCBkcm1fcGVuZGluZ192 YmxhbmtfZXZlbnQgKmV2ZW50Owo+ICsKPiArCWRybV9jcnRjX2hhbmRsZV92YmxhbmsoY3J0Yyk7 Cj4gKwo+ICsJaWYgKCpmbGlwKQo+ICsJCXJldHVybjsKPiArCSpmbGlwID0gdHJ1ZTsKPiArCj4g KwkvKgo+ICsJICogZXZlbnRfbG9jayBzZXJpYWxpc2VzIHRoaXMgYWdhaW5zdCB0aGUgY29tbWl0 IGFybWluZwo+ICsJICogY3J0Yy0+c3RhdGUtPmV2ZW50Lgo+ICsJICovCj4gKwlzcGluX2xvY2so JmRybS0+ZXZlbnRfbG9jayk7Cj4gKwlldmVudCA9IGNydGMtPnN0YXRlLT5ldmVudDsKPiArCWlm IChldmVudCkgewoKW1NldmVyaXR5OiBIaWdoXQpUaGUgY3J0Yy0+c3RhdGUgY2FuIGJlIHN3YXBw ZWQgYXN5bmNocm9ub3VzbHkgYnkKZHJtX2F0b21pY19oZWxwZXJfc3dhcF9zdGF0ZSgpLCB3aGlj aCBjb3VsZCBjYXVzZSB0aGlzIGhhbmRsZXIgdG8gcG9pbnQgdG8gYQpuZXcgZXZlbnQgYW5kIGxv c2UgdGhlIG9sZCBvbmUgaWYgbXVsdGlwbGUgY29tbWl0cyBhcmUgcXVldWVkIHJhcGlkbHkuCgpJ cyBpdCBzYWZlIHRvIGRpcmVjdGx5IGRlcmVmZXJlbmNlIGNydGMtPnN0YXRlLT5ldmVudCBkeW5h bWljYWxseSBmcm9tIGFuCmFzeW5jaHJvbm91cyBjb250ZXh0PwoKWyAuLi4gXQo+ICtzdGF0aWMg dTMyIGRwdV9vbmxpbmVfaXNyKHN0cnVjdCBzcGFjZW1pdF9jcnRjICphX2NydGMpCj4gK3sKWyAu Li4gXQo+ICsJaXJxX3JhdyA9IGh3ZGV2LT5nZXRfaW50X3N0cyhod2RldiwgZGV2X2lkKTsKPiAr CXRyYWNlX2RwdV9pc3Jfc3RhdHVzKCJPTkxJTkUiLCBpcnFfcmF3KTsKPiArCWlycV9iaXQgPSBo d2Rldi0+Z2V0X2lycV9iaXQoSU5UX1VOREVSUlVOLCBkZXZfaWQpOwo+ICsJaXJxX3VyX2JpdCA9 IGlycV9yYXcgJiBpcnFfYml0Owo+ICsJaWYgKGlycV91cl9iaXQgJiYgIWFfY3J0Yy0+dXJfcmVw b3J0ZWQpIHsKPiArCQlod2Rldi0+Y2xyX2ludF9zdHMoYV9jcnRjLCBpcnFfdXJfYml0LCBkZXZf aWQpOwo+ICsJCXRyYWNlX2RwdV9pc3Jfc3RhdHVzKCJ1bmRlcnJ1biIsIGlycV91cl9iaXQpOwo+ ICsJCWRybV9lcnJfcmF0ZWxpbWl0ZWQoYV9jcnRjLT5jcnRjLmRldiwgInVuZGVycnVuXG4iKTsK PiArCQlhX2NydGMtPnVyX3JlcG9ydGVkID0gdHJ1ZTsKPiArCX0KPiArCWlycV9iaXQgPSBod2Rl di0+Z2V0X2lycV9iaXQoSU5UX0NGR19SRFksIGRldl9pZCk7Cj4gKwlpZiAoaXJxX3JhdyAmIGly cV9iaXQpIHsKPiArCQlod2Rldi0+Y2xyX2ludF9zdHMoYV9jcnRjLCBpcnFfYml0LCBkZXZfaWQp Owo+ICsJCXRyYWNlX2RwdV9pc3Jfc3RhdHVzKCJjZmdfcmR5X2NsciIsIGlycV9yYXcgJiBpcnFf Yml0KTsKPiArCQkvKgo+ICsJCSAqIEEgZmlyZWQgd2F0Y2hkb2cgYWxyZWFkeSBzZW50IHRoZSBl dmVudCBhbmQgcHV0IHRoaXMgZmxpcCdzCj4gKwkJICogdmJsYW5rIHJlZmVyZW5jZTsgcmUtYXJt aW5nIHRoZSB2c3luYyBwYXRoIHdvdWxkIHB1dCB0d2ljZS4KPiArCQkgKi8KPiArCQlpZiAodGlt ZXJfZGVsZXRlKCZhX2NydGMtPmNmZ19yZHlfdGltZXIpKQo+ICsJCQlhX2NydGMtPmZsaXBfZG9u ZSA9IGZhbHNlOwoKW1NldmVyaXR5OiBIaWdoXQpJZiB0aGUgdGltZXIgZXhlY3V0ZXMgb24gYW5v dGhlciBDUFUsIHRpbWVyX2RlbGV0ZSgpIHJldHVybnMgMCBhbmQgYm90aCB0aGUKSVNSIGFuZCB0 aGUgdGltZXIgaGFuZGxlciBjb3VsZCBleGVjdXRlIGxvY2tsZXNzIG1vZGlmaWNhdGlvbnMgdG8g ZmxpcF9kb25lCmFuZCBjYWxsIGRybV9jcnRjX3ZibGFua19wdXQoKSB0d2ljZS4KCkNvdWxkIHRo aXMgbm9uLXN5bmNocm9ub3VzIHRpbWVyIGNhbmNlbGxhdGlvbiBsZWF2ZSB0aGUgY2FsbGJhY2sg cnVubmluZwpjb25jdXJyZW50bHk/CgpbIC4uLiBdCj4gKwlpcnFfYml0ID0gaHdkZXYtPmdldF9p cnFfYml0KElOVF9SRVNULCBkZXZfaWQpIHwgaXJxX3VyX2JpdDsKPiArCWlmIChpcnFfcmF3ICYg aXJxX2JpdCkKPiArCQlod2Rldi0+Y2xyX2ludF9zdHMoYV9jcnRjLCBpcnFfYml0LCBkZXZfaWQp OwoKW1NldmVyaXR5OiBNZWRpdW1dClRoZSBjb2RlIHRha2VzIGEgc2luZ2xlIHNuYXBzaG90IG9m IGlycV9yYXcgYXQgdGhlIHN0YXJ0IG9mIHRoZSBJU1IsIGNsZWFycwppcnFfdXJfYml0IGlmIHBy ZXNlbnQsIGFuZCB0aGVuIGNsZWFycyBpdCBhZ2FpbiBoZXJlIHVzaW5nIHRoZSBzdGFsZQpzbmFw c2hvdC4gQSBuZXcgdW5kZXJydW4gZmlyaW5nIGluIHRoYXQgd2luZG93IGNvdWxkIGJlIGNsZWFy ZWQgd2l0aG91dApiZWluZyBwcm9jZXNzZWQuCgpEb2VzIGRvdWJsZS1jbGVhcmluZyB0aGUgdW5k ZXJydW4gaW50ZXJydXB0IHN0YXR1cyByaXNrIGxvc2luZyBpbnRlcnJ1cHRzPwoKWyAuLi4gXQo+ ICtzdGF0aWMgdm9pZCBkcHVfcnVuKHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKPiArCQkgICAgc3Ry dWN0IGRybV9jcnRjX3N0YXRlICpvbGRfc3RhdGUpCj4gK3sKWyAuLi4gXQo+ICsJLyogZmx1c2gg YWxsIGNvbmZpZyByZWdpc3RlciB3cml0ZXMgYmVmb3JlIENGR19SRFkgaXMgcmFpc2VkICovCj4g KwltYigpOwo+ICsKPiArCWRybV9jcnRjX3ZibGFua19nZXQoY3J0Yyk7CgpbU2V2ZXJpdHk6IE1l ZGl1bV0KSWYgZ2V0dGluZyB0aGUgdmJsYW5rIGZhaWxzLCB0aGUgcmVmZXJlbmNlIGlzIG5vdCB0 YWtlbiwgYnV0IHRoZSBJU1Igc3RpbGwKdW5jb25kaXRpb25hbGx5IGNhbGxzIGRybV9jcnRjX3Zi bGFua19wdXQoKSwgd2hpY2ggY2FuIGxlYWQgdG8gYSB2YmxhbmsKcmVmZXJlbmNlIGNvdW50IHVu ZGVyZmxvdy4KClNob3VsZCB0aGUgcmV0dXJuIHZhbHVlIG9mIGRybV9jcnRjX3ZibGFua19nZXQo KSBiZSBjaGVja2VkPwoKPiArCWlmIChod2Rldi0+ZW5hYmxlX2NmZ19pcnEpCj4gKwkJaHdkZXYt PmVuYWJsZV9jZmdfaXJxKGFfY3J0YywgaHdkZXYsIHRydWUpOwo+ICsKPiArCXNhdHVybl9jdHJs X2NmZ19yZWFkeShhX2NydGMsIHRydWUpOwo+ICsKPiArCWlmICh1bmxpa2VseShhX2NydGMtPmlz XzFzdF9mKSkgewo+ICsJCWRybV9kYmcoYV9jcnRjLT5jcnRjLmRldiwgIkRQVSBzdGFydFxuIik7 Cj4gKwkJYV9jcnRjLT5pc18xc3RfZiA9IGZhbHNlOwo+ICsJCXNhdHVybl9jdHJsX3N3X3N0YXJ0 KGFfY3J0YywgdHJ1ZSk7Cj4gKwl9Cj4gKwlkbWFfcm1iKCk7Cj4gK30KCltTZXZlcml0eTogTWVk aXVtXQpBIHJlYWQgbWVtb3J5IGJhcnJpZXIgc3RyaWN0bHkgZW5mb3JjZXMgb3JkZXJpbmcgYmV0 d2VlbiBDUFUgcmVhZHMsIGJ1dCB0aGUKcHJlY2VkaW5nIG9wZXJhdGlvbiB3cml0ZXMgdG8gRE1B IGNvbnRyb2wgcmVnaXN0ZXJzIHRvIHN0YXJ0IHRoZSBlbmdpbmUuCgpJcyB0aGlzIHJlYWQgbWVt b3J5IGJhcnJpZXIgcmVxdWlyZWQgaGVyZT8gSXQgc2VlbXMgc2VtYW50aWNhbGx5IG91dCBvZgpw bGFjZS4KCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9zcGFjZW1pdC9kcHUvZHB1X3Nh dHVybl9oZWUuYyBiL2RyaXZlcnMvZ3B1L2RybS9zcGFjZW1pdC9kcHUvZHB1X3NhdHVybl9oZWUu Ywo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vc3BhY2VtaXQvZHB1L2Rw dV9zYXR1cm5faGVlLmMKWyAuLi4gXQo+ICt2b2lkIHNhdHVybl9oZWVfcGxhbmVfdXBkYXRlX2h3 X2NoYW5uZWwoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUpCj4gK3sKWyAuLi4gXQo+ICsJaWYgKHN0 YXRlLT5mYi0+Zm9ybWF0ICYmIHN0YXRlLT5mYi0+Zm9ybWF0LT5oYXNfYWxwaGEgJiYKPiArCSAg ICBwaXhlbF9hbHBoYSAhPSBEUk1fTU9ERV9CTEVORF9QSVhFTF9OT05FKSB7CgpbU2V2ZXJpdHk6 IEhpZ2hdCkZvciBzb2xpZCBmaWxsIHBsYW5lcywgc3RhdGUtPmZiIGlzIHR5cGljYWxseSBOVUxM LiBFdmFsdWF0aW5nCnN0YXRlLT5mYi0+Zm9ybWF0IHdpdGhvdXQgYSBOVUxMIGNoZWNrIGNvdWxk IGNhdXNlIGEga2VybmVsIG9vcHMgd2hlbgp1c2Vyc3BhY2Ugc3VibWl0cyBhbiBhdG9taWMgY29t bWl0IGZvciBhIHNvbGlkLWNvbG9yIHBsYW5lLgoKQ2FuIHN0YXRlLT5mYiBiZSBOVUxMIGhlcmU/ CgpbIC4uLiBdCj4gKwljbF9jbXAgPSBhbGxvY19jbWRsaXN0X3JlZ3MoQ01QU19YX1JFRyk7Cj4g Kwo+ICsJYmFzZSA9IENNUF9CQVNFX0FERFJbYV9jcnRjLT5kZXZfaWRdOwo+ICsJZHB1X3dyaXRl KGh3ZGV2LCBDTVBTX1hfUkVHLCBiYXNlLCBkc3RfdywgbW9kZS0+aGRpc3BsYXksIGNsX2NtcCk7 Cj4gKwlkcHVfd3JpdGUoaHdkZXYsIENNUFNfWF9SRUcsIGJhc2UsIGRzdF9oLCBtb2RlLT52ZGlz cGxheSwgY2xfY21wKTsKPiArCj4gKwlTQVRVUk5fV1JJVEVfQ09NUE9TRVJfTEFZRVIoMDApOwoK W1NldmVyaXR5OiBIaWdoXQpUaGUgYWxsb2NfY21kbGlzdF9yZWdzIG1hY3JvIGludGVybmFsbHkg dXNlcyBremFsbG9jIHdpdGggR0ZQX0tFUk5FTC4KCkNhbiB0aGlzIGFsbG9jYXRpb24gc2xlZXAg aW4gYW4gYXRvbWljIGNvbnRleHQgYW5kIHRyaWdnZXIgZGVhZGxvY2sgd2FybmluZ3MsCnNpbmNl IGl0IGlzIGNhbGxlZCBmcm9tIHRoZSBwbGFuZSBhdG9taWMgdXBkYXRlIGNhbGxiYWNrPwoKQWxz bywgaWYgdGhpcyBhbGxvY2F0aW9uIGZhaWxzIGFuZCByZXR1cm5zIE5VTEwsIGNsX2NtcCBpcyBw YXNzZWQgZGlyZWN0bHkgdG8KU0FUVVJOX1dSSVRFX0NPTVBPU0VSX0xBWUVSIGFuZCBkcHVfd3Jp dGUuIFRoZSBkcHVfd3JpdGUgbG9naWMgZmFsbHMgYmFjayB0bwpkaXJlY3QgTU1JTyB3cml0ZXMg d2hlbiB0aGUgY29tbWFuZCBsaXN0IGlzIE5VTEwuCgpEb2VzIHRoaXMgYnlwYXNzIGNvbW1hbmQg bGlzdCBzeW5jaHJvbml6YXRpb24gdG8gVkJMQU5LIGFuZCByaXNrIGFwcGx5aW5nCnBhcnRpYWwg c3RhdGUgaW1tZWRpYXRlbHk/CgpbIC4uLiBdCj4gK3N0cnVjdCBjbWRsaXN0X2hlYWRlciB7Cj4g Kwl1NjQgbmV4dF9saXN0X2FkZHIgOiAzOTsKPiArCS8qIHJlc2VydmVkICovCj4gKwl1MzI6IDE7 Cj4gKwl1MzIgbm9kX2xlbiA6IDE2Owo+ICsJLyogMTogdGhlIGxhc3QgY21kbGlzdCBub2RlLCAy OiBwZW5kaW5nIG5vZGUsIG90aGVyd2lzZSAwICovCj4gKwl1MzIgbm9kX3R5cGUgOiAyOwo+ICsJ dTMyIG5leHRfbm9kX3NlY3UgOiAxOwo+ICsJdTY0IHdhaXRfZXZlbnRfbG93ICAgIDogNTsKPiAr CXU2NCB3YWl0X2V2ZW50ICAgIDogNTk7Cj4gKwkvKiByZXNlcnZlZCAqLwo+ICsJdTMyOiA1Owo+ ICt9OwoKW1NldmVyaXR5OiBNZWRpdW1dCkJpdGZpZWxkIHBhY2tpbmcgYW5kIG9yZGVyaW5nIGFy ZSBoZWF2aWx5IGNvbXBpbGVyIGFuZCBhcmNoaXRlY3R1cmUgZGVwZW5kZW50LAp3aGljaCBtaWdo dCBwcm9kdWNlIGluY29ycmVjdCBzdHJ1Y3R1cmVzIGluIG1lbW9yeSBmb3IgdGhlIGhhcmR3YXJl IERNQSB0bwpyZWFkLgoKSXMgaXQgc2FmZSB0byB1c2UgQyBiaXRmaWVsZHMgZm9yIGhhcmR3YXJl IERNQSBkZXNjcmlwdG9yIGxheW91dHM/CgpbIC4uLiBdCj4gK3ZvaWQgc2F0dXJuX2hlZV9jbWRs aXN0X2ZpbGxfZGF0YV9yb3coc3RydWN0IGNtZGxpc3QgKmNsLCB1MzIgc3Ryb2JlLAo+ICsJCQkJ ICAgICAgdTMyIG9mZnNldCwgdTMyIHZhbHVlW10pCj4gK3sKPiArCXN0cnVjdCBjbWRsaXN0X3Jv dyAqcm93Owo+ICsJdTggaTsKPiArCj4gKwkvKgo+ICsJICogcGFja2luZyBjb3VudHMgcm93cyBi bGluZGx5OyBkcm9wIHRoZSByb3cgcmF0aGVyIHRoYW4gdGhlIGJ1ZmZlciBlbmQKPiArCSAqLwo+ ICsJaWYgKFdBUk5fT05DRShDTF9IRUFERVJfU1ogKyAoY2wtPm5vZF9sZW4gKyAxKSAqIENMX1JP V19TWiA+IGNsLT5zaXplLAo+ICsJCSAgICAgICJjbWRsaXN0IGJ1ZmZlciBmdWxsIChyb3dzICV1 KVxuIiwgY2wtPm5vZF9sZW4pKQo+ICsJCXJldHVybjsKCltTZXZlcml0eTogSGlnaF0KU2luY2Ug dGhpcyBmdW5jdGlvbiBzaWxlbnRseSBkcm9wcyB0aGUgcm93IGFuZCByZXR1cm5zIHZvaWQsIHRo ZSBjYWxsZXIKY21kbGlzdF9yZWdzX3BhY2tpbmcoKSB3aWxsIGJsaW5kbHkgaW5jcmVtZW50IGNs LT5ub2RfbGVuIHJlZ2FyZGxlc3Mgb2YKYnVmZmVyIHRydW5jYXRpb24uCgpDb3VsZCB0aGlzIGlu ZmxhdGVkIGxlbmd0aCBjYXVzZSB0aGUgRE1BIGVuZ2luZSB0byByZWFkIHBhc3QgdGhlIGVuZCBv ZiB0aGUKaW5pdGlhbGl6ZWQgYnVmZmVyPwoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L3NwYWNlbWl0L2RwdS9zYXR1cm5fZmJjbWVtLmMgYi9kcml2ZXJzL2dwdS9kcm0vc3BhY2VtaXQv ZHB1L3NhdHVybl9mYmNtZW0uYwo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9k cm0vc3BhY2VtaXQvZHB1L3NhdHVybl9mYmNtZW0uYwpbIC4uLiBdCj4gK2ludCBzYXR1cm5fY2Fs X2xheWVyX2ZiY21lbV9zaXplKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAo+ICsJCQkJIHN0cnVj dCBkcm1fcGxhbmVfc3RhdGUgKnN0YXRlKQo+ICt7Cj4gKwlzdHJ1Y3Qgc3BhY2VtaXRfcGxhbmVf c3RhdGUgKnBzdGF0ZSA9IHRvX3NwYWNlbWl0X3BsYW5lX3N0YXRlKHN0YXRlKTsKPiArCXUzMiBk cm1fNGNjX2ZtdCA9IHBzdGF0ZS0+c3RhdGUuZmItPmZvcm1hdC0+Zm9ybWF0OwoKW1NldmVyaXR5 OiBIaWdoXQpJZiBhIHBsYW5lIGlzIGJlaW5nIGRpc2FibGVkIG9yIGlzIGluIGEgc29saWQgZmls bCBtb2RlLCB0aGUgZnJhbWVidWZmZXIKcG9pbnRlciB3aWxsIGJlIE5VTEwsIHdoaWNoIHdvdWxk IGNhdXNlIGFuIGltbWVkaWF0ZSBjcmFzaCBkdXJpbmcgdGhlIGF0b21pYwpjaGVjayBwaGFzZS4K CklzIGl0IGd1YXJhbnRlZWQgdGhhdCBwc3RhdGUtPnN0YXRlLmZiIGlzIG5vbi1OVUxMIGhlcmU/ CgotLSAKU2FzaGlrbyBBSSByZXZpZXcgwrcgaHR0cHM6Ly9zYXNoaWtvLmRldi8jL3BhdGNoc2V0 LzIwMjYwODA5LWszLWRpc3BsYXktdjItMC0zMjdkNzkxMGJmNzFAZ21haWwuY29tP3BhcnQ9OQoK LS0gCmxpbnV4LXBoeSBtYWlsaW5nIGxpc3QKbGludXgtcGh5QGxpc3RzLmluZnJhZGVhZC5vcmcK aHR0cHM6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcGh5Cg==