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 EDABD3F8257 for ; Mon, 14 Sep 2026 08: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=1789374705; cv=none; b=SpKOs/QP3//kLrr8S8lLwLH5ocepoKQ7HQBFmB8+twKzF4Jg54soBS/wr/pmbpXTI1PhNTKvlCQSxqkM6P04t+ub+1QvA2CuF2+Ox/mKX4hP/oYkT2ZH54ZhYl1vLkiMqhcXlTCRHuixZNe/Dydxw0anpzRE6PDNGnBUv+RUF5M= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789374705; c=relaxed/simple; bh=oEcPZHaLQvwycsmLQhonIuZiTkPu9VaqNL5TysAWdQk=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=JAncvqel2V+fkdfhzrMFOlVVgtYsG4JDyQXVVQeu9/d1Cnd9kbZJv6RDF+fLcVjrF7Suxmlq9TtAnQEVwhjPSDcGf4q0kDMK1EAcD5NXfFBDWQEqCVL4XyNGRR1x1VNFr3vvqXQOnBQkmUEnlaT5uZo4kQy+BjLcIqHVU3c0pmQ= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=FgipXaIC; 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="FgipXaIC" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 589761F000FF; Mon, 14 Sep 2026 08:31:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1789374703; bh=OEEnKb1ph5sj4yiLGstEyb9833qHCZnX01jq0OlwEWo=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=FgipXaICQDK6EwBFb74pcb/6ZVL/bAyBkDsJvMWSs5CcxF9NUhi8aONANxh6J1UDa 4tk5cFZ3TQUk+oT8kqokkBcB8KDAP9C+drD3UWOXmIK9jk5PvMreLS+owdDvEFYdDT J4QfXyTrhpcytvKKkMfPpmUTy2Hf1VL4yCNESCk9BJKPSRfP2cJKsnQu/ZPyjBmHIU T4fWls9XZS922z47GB7szFaWQziNp0Aiyj2wySh5bjFpgvEAzXQo4Kknx0SycpAyQP FjA5YjsiCVh6AA3mS8BFwEB7tgE7Y8ZYdhGfgrS7ZcdHaUHb5p8xOBAGfgB9RB+K6j Tm7wZM6VAaSJw== From: sashiko-bot@kernel.org Subject: Re: [PATCH v9 4/6] decoder: Add V4L2 stateless H.264 decoder driver Reply-To: sashiko-reviews@lists.linux.dev To: "Zhentao Guo" Cc: robh@kernel.org, devicetree@vger.kernel.org, neil.armstrong@linaro.org, conor+dt@kernel.org, media-ci@linuxtv.org, linux-amlogic@lists.infradead.org In-Reply-To: <20260914-b4-s4-vdec-upstream-v9-4-72fdb0d71b02@amlogic.com> References: <20260914-b4-s4-vdec-upstream-v9-0-72fdb0d71b02@amlogic.com> <20260914-b4-s4-vdec-upstream-v9-4-72fdb0d71b02@amlogic.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Mon, 14 Sep 2026 08:31:42 +0000 Message-Id: <20260914083143.589761F000FF@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: - [Critical] Missing synchronization between streamoff and the M2M worker c= auses Use-After-Free and permanent M2M deadlocks. - [High] Firmware loading loop silently skips chunks when TEEC_ERROR_BUSY i= s returned. - [High] Colocated MV CMA buffer is not resized on dynamic resolution chang= e, leading to hardware DMA buffer overflow. - [High] Static global array retains stale device and link pointers, causin= g double-free on power domain release. - [High] Hardware DMA buffer overflow into capture queue buffers due to mis= sing size validation. - [High] Hardware Out-of-Bounds Read due to artificially increased VIFIFO W= rite Pointer. - [High] Slot leaks and array collisions because `INVALID_POC` aliases with= valid POC -1. - [High] `h264_config_decode_spec` unconditionally dereferences the result = of `v4l2_m2m_next_dst_buf()`, which can be NULL if the capture queue was st= opped. - [High] Premature freeing of m2m_dev and device context in remove() leads = to Use-After-Free if file descriptors remain open. - [High] Race condition between the timeout handler and threaded ISR causes= unsynchronized hardware register accesses. - [Medium] `tee_pta_invoke_cmd` masks internal errors from `tee_client_invo= ke_func()`. - [Medium] `aml_vdec_drv_probe` dereferences `pvdec_data` without checking = if `of_device_get_match_data()` returned NULL. - [Medium] Kernel stack memory leak to DMA-coherent buffer due to uninitial= ized array in `config_sps_params()` and `config_pps_params()`. - [Medium] Manual 16-bit word swapping of DMA data assumes CPU endianness, = breaking on big-endian architectures. -- commit 32d79a55cb39fe35641a2ada550274595010cdce Author: Zhentao Guo Subject: decoder: Add V4L2 stateless H.264 decoder driver Add initial support for V4L2 stateless video decoder driver on Amlogic S4(S805X2) platform. It supports 8bit H.264 bitstreams decoding, currently only progressive streams. > --- a/drivers/media/platform/amlogic/vdec/aml_vdec_drv.c > +++ b/drivers/media/platform/amlogic/vdec/aml_vdec_drv.c > @@ -68,14 +68,8 @@ static int fops_vcodec_release(struct file *file) > { > struct aml_vdec_ctx *ctx =3D fh_to_dec_ctx(file); > =20 > v4l2_m2m_ctx_release(ctx->m2m_ctx); [Severity: High] Does fops_vcodec_release() trigger a use-after-free here? If the v4l2 device was unregistered and the driver unbound, aml_vdec_drv_remove() will have already destroyed the m2m_dev_dec structure. When an application subsequently closes a retained file descriptor, this accesses the freed m2m structure. > v4l2_ctrl_handler_free(&ctx->ctrl_handler); > v4l2_fh_del(&ctx->fh, file); > v4l2_fh_exit(&ctx->fh); > kfree(ctx); > =20 > return 0; > } > =20 > [ ... ] > =20 > @@ -148,6 +148,8 @@ static int aml_vdec_drv_probe(struct platform_device = *pdev) > } > dev->dec_hw =3D hw; > =20 > dev->pvdec_data =3D of_device_get_match_data(&pdev->dev); > ret =3D dev->pvdec_data->req_hw_resource(dev); [Severity: Medium] Will aml_vdec_drv_probe() crash if of_device_get_match_data() returns null? If the driver is bound manually via sysfs driver_override, there won't be any match data, causing a null pointer dereference when accessing req_hw_resource(). > if (ret < 0) > =20 > [ ... ] > =20 > @@ -226,9 +226,6 @@ static void aml_vdec_drv_remove(struct platform_devic= e *pdev) > video_unregister_device(dev->vfd); > media_device_cleanup(&dev->mdev); > =20 > v4l2_m2m_release(dev->m2m_dev_dec); [Severity: High] Can this cause a use-after-free if file descriptors remain open? This prematurely frees the core v4l2 m2m structures and triggers cleanup of devm allocations before all file descriptors have been closed. A subsequent close by userspace will hit the use-after-free in fops_vcodec_release(). > dev->pvdec_data->destroy_hw_resource(dev); > v4l2_device_unregister(&dev->v4l2_dev); > } > --- a/drivers/media/platform/amlogic/vdec/aml_vdec_hw.c > +++ b/drivers/media/platform/amlogic/vdec/aml_vdec_hw.c > @@ -160,8 +160,8 @@ static void pm_vdec_power_domain_release(struct aml_v= dec_hw *hw) > for (i =3D 0; i < VDEC_MAX; i++) { > if (!IS_ERR_OR_NULL(pd[i].link)) > device_link_del(pd[i].link); > =20 > if (!IS_ERR_OR_NULL(pd[i].dev)) > dev_pm_domain_detach(pd[i].dev, true); [Severity: High] Does pm_vdec_power_domain_release() leave dangling pointers in the global vdec_domain_data array? Because the global pd[i].link and pd[i].dev pointers are never set to null, a sequence where the driver is unbound and rebound, or encounters consecuti= ve probe failures, will result in a double-free of the device_link and power domain. > } > } > --- a/drivers/media/platform/amlogic/vdec/aml_vdec_tee_fw.c > +++ b/drivers/media/platform/amlogic/vdec/aml_vdec_tee_fw.c > @@ -124,12 +124,12 @@ static int tee_pta_invoke_cmd(struct aml_vdec_hw *h= w, struct tee_context *ctx, > param_invoke[0].u.memref.shm =3D shm; > ret =3D tee_client_invoke_func(ctx, &inv_arg, param_invoke); > if (ret < 0 || (inv_arg.ret !=3D TEEC_SUCCESS && inv_arg.ret !=3D TEEC= _ERROR_BUSY)) { [Severity: High] Does tee_pta_invoke_cmd() bypass error handling when the tee returns TEEC_ERROR_BUSY? If the tee subsystem is busy, this condition evaluates to false, causing the firmware loading loop to silently skip the chunk without any retry. This will corrupt the hardware firmware and cause the device to fail. > dev_info(hw->dev, > "%s invoke func failed, cmd =3D %u, ret=3D %d, res =3D 0x%x, origin= =3D 0x%x\n", > __func__, cmd, ret, inv_arg.ret, > inv_arg.ret_origin); > ret =3D inv_arg.ret; > goto close_session; [Severity: Medium] Will this return success if tee_client_invoke_func() fails internally? If tee_client_invoke_func() encounters an internal error (like -ENOMEM) before invoking the command, it returns a negative code. Since the command didn't run, inv_arg.ret remains its default TEEC_SUCCESS (0). Setting ret to inv_arg.ret here masks the failure and returns success. > } > sent_size +=3D param_invoke[0].u.memref.size; [Severity: High] Can this advance the buffer pointer even when the chunk was rejected? If TEEC_ERROR_BUSY was returned, the loop skips the error branch and erroneously advances sent_size, permanently losing the chunk. > } > --- a/drivers/media/platform/amlogic/vdec/aml_vdec.c > +++ b/drivers/media/platform/amlogic/vdec/aml_vdec.c > @@ -150,6 +150,8 @@ static void m2mops_vdec_device_run(void *m2m_priv) > v4l2_ctrl_request_complete(src_req, &ctx->ctrl_handler); > if (ret < 0 || ctx->curr_frm_err_flag) > goto err_cancel_job; > v4l2_m2m_buf_done_and_job_finish(dev->m2m_dev_dec, ctx->m2m_ctx, > VB2_BUF_STATE_DONE); [Severity: Critical] Can m2mops_vdec_device_run() deadlock the v4l2 m2m core? If userspace unbinds the stream using VIDIOC_STREAMOFF concurrently, vb2ops_vdec_stop_streaming() removes all buffers and frees ctx->codec_priv. Because the buffers were aggressively stripped, v4l2_m2m_buf_done_and_job_finish() will trigger a v4l2 WARN_ON and abort, permanently hanging the m2m queue. > return; > =20 > [ ... ] > =20 > @@ -404,6 +404,7 @@ static void vb2ops_vdec_stop_streaming(struct vb2_que= ue *q) > } > =20 > if (!ctx->is_output_streamon && !ctx->is_cap_streamon) > aml_vdec_release_instance(ctx); [Severity: Critical] Is it safe to tear down the instance context without synchronizing against the m2m worker thread? This frees ctx->codec_priv synchronously via aml_vdec_release_instance(), but the m2mops_vdec_device_run() worker thread might still be blocked in aml_h264_dec_run(). When the thread resumes, it will write to the freed h264_ctx, causing a use-after-free. > } > --- a/drivers/media/platform/amlogic/vdec/h264.c > +++ b/drivers/media/platform/amlogic/vdec/h264.c > @@ -13,2 +13,2 @@ > #define INVALID_POC 0xffffffff [Severity: High] Does this sentinel mathematically alias with a valid h264 poc of -1? A picture order count of -1 evaluates to 0xffffffff. Using this as the INVALID_POC sentinel causes valid reference frames with a -1 poc to be skipped during buffer release and incorrectly matched when searching. > [ ... ] > =20 > @@ -200,6 +200,8 @@ static int config_sps_params(struct aml_h264_ctx *h26= 4_ctx, > u32 offset =3D 0; > unsigned short data_tmp[0x100]; [Severity: Medium] Does this leak uninitialized stack memory? Only the first few words of this 256-word array are populated before the entire 512-byte buffer is copied into dma memory below. > int i, ii; > =20 > memset(sps_base, 0, 0x100); > =20 > [ ... ] > =20 > @@ -248,8 +248,8 @@ static int config_sps_params(struct aml_h264_ctx *h26= 4_ctx, > =20 > for (i =3D 0; i < 0x100; i +=3D 4) { > for (ii =3D 0; ii < 4; ii++) > sps_base[i + 3 - ii] =3D data_tmp[i + ii]; [Severity: Medium] Will this break on big-endian cpus? The code treats dma-mapped memory as an array of unsigned short, which will byte-swap the parameter blocks on a big-endian cpu before the hardware reads it. > } > =20 > [ ... ] > =20 > @@ -347,6 +347,8 @@ static int h264_prepare_input(struct aml_vdec_ctx *ct= x) > regmap_write(hw->map[DOS_BUS], VLD_MEM_VIFIFO_RP, > round_down(src_dma, VDEC_FIFO_ALIGN)); > dummy =3D payload_size + VLD_PADDING_SIZE; > regmap_write(hw->map[DOS_BUS], VLD_MEM_VIFIFO_WP, > round_down((src_dma + dummy), VDEC_FIFO_ALIGN)); [Severity: High] Does h264_prepare_input() instruct the hardware to read past the end of the buffer? The hardware write pointer is artificially increased by VLD_PADDING_SIZE (1024 bytes) beyond payload_size without verifying the physical vb2_plane_size() is large enough to contain it. > [ ... ] > =20 > @@ -398,6 +398,6 @@ static int config_sps_params(struct aml_h264_ctx *h26= 4_ctx, > h264_ctx->frame_height =3D (sps->pic_height_in_map_units_minus1 + 1) <<= 4; > =20 > if (!frame_size_in_range(stepwise, h264_ctx->frame_width, > h264_ctx->frame_height)) { > dev_info(&ctx->dev->plat_dev->dev, [Severity: High] Can a mismatched sps trigger a buffer overflow? This checks the sps against the global maximums but ignores the actual size of the currently allocated v4l2 capture buffer. If userspace allocates a small buffer and submits a 1080p sps, the hardware will overflow the buffer during config_decode_canvas(). > [ ... ] > =20 > @@ -425,6 +425,8 @@ static int alloc_colocate_cma(struct aml_h264_ctx *h2= 64_ctx, > gfp_t gfp =3D GFP_KERNEL | GFP_DMA32; > =20 > if (h264_ctx->collated_cma_vaddr) > return 0; [Severity: High] Does alloc_colocate_cma() prevent the cma buffer from resizing? If the stream dynamic resolution increases, returning early here leaves one_col_buf_size at its old, smaller value. Later, h264_config_decode_buf() bounds checks using the stale size, overflowing the contiguous memory area. > hw =3D vdec_get_hw(ctx->dev); > =20 > [ ... ] > =20 > @@ -490,6 +490,8 @@ static int config_decode_canvas(struct aml_vdec_hw *h= w, > buf_spec->canvas_allocated =3D 1; > =20 > /* config y canvas */ > meson_canvas_config(hw->canvas, > buf_spec->y_canvas_index, buf_spec->y_dma_addr, > mb_width << 4, mb_height << 4, [Severity: High] Does config_decode_canvas() command the hardware to write past the end of the dma buffer? Because the sps dimensions are unvalidated against the actual buffer size, this can configure the canvas to write a 1080p frame into a much smaller v4l2 buffer. > [ ... ] > =20 > @@ -540,6 +540,8 @@ static void release_colocate_buf(struct aml_h264_ctx = *h264_ctx, int index) > __func__, index, h264_ctx->max_num_ref_frames); > } else { > if (h264_ctx->colocated_buf_poc[index] !=3D INVALID_POC && > ((h264_ctx->colocated_buf_map >> index) & 0x1) =3D=3D 0x1) { > h264_ctx->colocated_buf_map &=3D (~(1 << index)); [Severity: High] Does release_colocate_buf() leak buffer slots for valid reference frames? Since INVALID_POC aliases with -1, reference frames with a poc of -1 fail this condition and are never released. > [ ... ] > =20 > @@ -611,6 +611,6 @@ static int h264_config_decode_spec(struct aml_vdec_hw= *hw, struct aml_vdec_ctx * > =20 > vb2_v4l2 =3D v4l2_m2m_next_dst_buf(ctx->m2m_ctx); > vb =3D &vb2_v4l2->vb2_buf; [Severity: High] Will h264_config_decode_spec() crash if v4l2_m2m_next_dst_buf() returns nul= l? If the capture queue was stopped by VIDIOC_STREAMOFF, the destination buffers are removed. This unconditionally dereferences a null pointer inside the interrupt handler context. > h264_ctx->curr_spec.y_dma_addr =3D vb2_dma_contig_plane_dma_addr(vb, 0); > =20 > [ ... ] > =20 > @@ -916,6 +916,8 @@ void aml_h264_exit(void *priv) > h264_ctx->cma_alloc_addr); > =20 > kfree(ctx->codec_priv); > ctx->codec_priv =3D NULL; > } [Severity: Critical] Does aml_h264_exit() trigger a use-after-free? This frees the context while the m2m worker thread is actively executing and waiting. When the thread resumes, it dereferences the freed memory. > [ ... ] > =20 > @@ -966,6 +966,8 @@ int aml_h264_dec_run(void *priv) > * h264_release_decode_spec() concurrently. > */ > aml_stop_vdec_hw(dec_hw); > synchronize_irq(dec_hw->dec_irq); > h264_release_decode_spec(dec_hw, ctx); > } else if (-ERESTARTSYS =3D=3D ret) { > ret =3D -1; [Severity: High] Can aml_h264_dec_run() race with the threaded isr and corrupt hardware stat= e? aml_stop_vdec_hw() immediately executes hardware resets via DOS_SW_RESET0. If the threaded isr is concurrently writing configuration blocks to DOS_BUS registers, the accesses will interleave and corrupt the decoder state. > [ ... ] > =20 > @@ -979,6 +979,8 @@ int aml_h264_dec_run(void *priv) > =20 > h264_ctx->init_flag =3D 0; > aml_vdec_set_curr_ctx(dec_hw, NULL); [Severity: Critical] Is it possible to use a freed pointer here? If aml_h264_exit() was invoked concurrently via streamoff, h264_ctx was already freed, resulting in a use-after-free when modifying init_flag. > return ret; > =20 > [ ... ] > =20 > @@ -1436,6 +1436,8 @@ static int h264_config_decode_buf(struct aml_vdec_h= w *hw, > colocate_wr_adr =3D (unsigned int)h264_ctx->collated_cma_addr + > ((h264_ctx->one_col_buf_size * > h264_ctx->curr_spec.col_buf_index) >> (use_mode_8x8_flag ? 2 : 0= )); > if (colocate_adr_offset > h264_ctx->one_col_buf_size || > colocate_wr_adr + h264_ctx->one_col_buf_size > > (unsigned int)h264_ctx->collated_cma_addr_end) { [Severity: High] Does this bounds check fail during dynamic resolution changes? Because alloc_colocate_cma() bails out early instead of updating one_col_buf_size, this logic uses the stale size to validate a hardware write, leading to a dma overflow. > [ ... ] > =20 > @@ -1676,6 +1676,8 @@ static irqreturn_t h264_isr(int irq, void *priv) > return IRQ_WAKE_THREAD; > } > =20 > static irqreturn_t h264_threaded_isr_func(int irq, void *priv) > { > u32 dec_status; [Severity: High] Does h264_threaded_isr_func() perform register writes that race with the timeout handler? The threaded isr handles configuration and starts the hardware. If the main thread's wait times out, the timeout handler will reset the hardware concurrently, causing the register writes here to collide. > [ ... ] > =20 > @@ -1687,6 +1687,8 @@ static irqreturn_t h264_threaded_isr_func(int irq, = void *priv) > switch (dec_status) { > case H264_SLICE_HEADER_DONE: > for (i =3D 0; i < 0x400; i +=3D 4) > for (ii =3D 0; ii < 4; ii++) > h264_ctx->dpb_param.l.data[i + ii] =3D p[i + 3 - ii]; [Severity: Medium] Will this loop break on big-endian architectures? Using cpu-native unsigned short accesses to read the hardware's dma output memory assumes the cpu uses the same endianness as the hardware. On big-endian, this will byte-swap the data incorrectly. > save_reg_status(h264_ctx); --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260914-b4-s4-vdec= -upstream-v9-0-72fdb0d71b02@amlogic.com?part=3D4 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 A7A2FC88E64 for ; Mon, 14 Sep 2026 08:31:50 +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=ywGwy2OU9HyBHNwt09O+1NxWmi5mIeO3iyvox2CBSUc=; b=luVHYRK3lbBmJJ HB/SHI6O2CHS6vJ+bu7FZHWm3KO4PujxL7euJogoLoWSvyAlDKpK6SSs3CJjlIpR1Pj9dp/fxuwVz GaIfNFWI+w2VIeRfYchxdDw2C5AtSH4FGYHX2XluzeGvfXAmuoi0rOA4c9HeplTArgIWcYluqmQ+a wFd1TELmyBThZrTPk2EME9QJTL8cZ1taTZe/urIEYgFAJbaxzCsu8Fa2X4Lfhv4AZod+1oCKJaadJ rZkHbr/jSqJWkXywQWXGpC29MGQyPnzBv+CeBm1Jge5yWCp8MV5q/196OejK9KyGCJ50ZAS45XsDB plpWIppgCq9MG3sL+6pg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1x626K-00000002kPO-1ubB; Mon, 14 Sep 2026 08:31:44 +0000 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1x626J-00000002kPA-41VJ for linux-amlogic@lists.infradead.org; Mon, 14 Sep 2026 08:31:44 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id B404941924; Mon, 14 Sep 2026 08:31:43 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 589761F000FF; Mon, 14 Sep 2026 08:31:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1789374703; bh=OEEnKb1ph5sj4yiLGstEyb9833qHCZnX01jq0OlwEWo=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=FgipXaICQDK6EwBFb74pcb/6ZVL/bAyBkDsJvMWSs5CcxF9NUhi8aONANxh6J1UDa 4tk5cFZ3TQUk+oT8kqokkBcB8KDAP9C+drD3UWOXmIK9jk5PvMreLS+owdDvEFYdDT J4QfXyTrhpcytvKKkMfPpmUTy2Hf1VL4yCNESCk9BJKPSRfP2cJKsnQu/ZPyjBmHIU T4fWls9XZS922z47GB7szFaWQziNp0Aiyj2wySh5bjFpgvEAzXQo4Kknx0SycpAyQP FjA5YjsiCVh6AA3mS8BFwEB7tgE7Y8ZYdhGfgrS7ZcdHaUHb5p8xOBAGfgB9RB+K6j Tm7wZM6VAaSJw== From: sashiko-bot@kernel.org Subject: Re: [PATCH v9 4/6] decoder: Add V4L2 stateless H.264 decoder driver To: "Zhentao Guo" Cc: robh@kernel.org, devicetree@vger.kernel.org, neil.armstrong@linaro.org, conor+dt@kernel.org, media-ci@linuxtv.org, linux-amlogic@lists.infradead.org In-Reply-To: <20260914-b4-s4-vdec-upstream-v9-4-72fdb0d71b02@amlogic.com> References: <20260914-b4-s4-vdec-upstream-v9-0-72fdb0d71b02@amlogic.com> <20260914-b4-s4-vdec-upstream-v9-4-72fdb0d71b02@amlogic.com> Date: Mon, 14 Sep 2026 08:31:42 +0000 Message-Id: <20260914083143.589761F000FF@smtp.kernel.org> X-BeenThere: linux-amlogic@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: 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-amlogic" Errors-To: linux-amlogic-bounces+linux-amlogic=archiver.kernel.org@lists.infradead.org VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg MTQgcG90ZW50aWFsIGlzc3VlKHMpIHRvIGNvbnNpZGVyOgotIFtDcml0aWNhbF0gTWlzc2luZyBz eW5jaHJvbml6YXRpb24gYmV0d2VlbiBzdHJlYW1vZmYgYW5kIHRoZSBNMk0gd29ya2VyIGNhdXNl cyBVc2UtQWZ0ZXItRnJlZSBhbmQgcGVybWFuZW50IE0yTSBkZWFkbG9ja3MuCi0gW0hpZ2hdIEZp cm13YXJlIGxvYWRpbmcgbG9vcCBzaWxlbnRseSBza2lwcyBjaHVua3Mgd2hlbiBURUVDX0VSUk9S X0JVU1kgaXMgcmV0dXJuZWQuCi0gW0hpZ2hdIENvbG9jYXRlZCBNViBDTUEgYnVmZmVyIGlzIG5v dCByZXNpemVkIG9uIGR5bmFtaWMgcmVzb2x1dGlvbiBjaGFuZ2UsIGxlYWRpbmcgdG8gaGFyZHdh cmUgRE1BIGJ1ZmZlciBvdmVyZmxvdy4KLSBbSGlnaF0gU3RhdGljIGdsb2JhbCBhcnJheSByZXRh aW5zIHN0YWxlIGRldmljZSBhbmQgbGluayBwb2ludGVycywgY2F1c2luZyBkb3VibGUtZnJlZSBv biBwb3dlciBkb21haW4gcmVsZWFzZS4KLSBbSGlnaF0gSGFyZHdhcmUgRE1BIGJ1ZmZlciBvdmVy ZmxvdyBpbnRvIGNhcHR1cmUgcXVldWUgYnVmZmVycyBkdWUgdG8gbWlzc2luZyBzaXplIHZhbGlk YXRpb24uCi0gW0hpZ2hdIEhhcmR3YXJlIE91dC1vZi1Cb3VuZHMgUmVhZCBkdWUgdG8gYXJ0aWZp Y2lhbGx5IGluY3JlYXNlZCBWSUZJRk8gV3JpdGUgUG9pbnRlci4KLSBbSGlnaF0gU2xvdCBsZWFr cyBhbmQgYXJyYXkgY29sbGlzaW9ucyBiZWNhdXNlIGBJTlZBTElEX1BPQ2AgYWxpYXNlcyB3aXRo IHZhbGlkIFBPQyAtMS4KLSBbSGlnaF0gYGgyNjRfY29uZmlnX2RlY29kZV9zcGVjYCB1bmNvbmRp dGlvbmFsbHkgZGVyZWZlcmVuY2VzIHRoZSByZXN1bHQgb2YgYHY0bDJfbTJtX25leHRfZHN0X2J1 ZigpYCwgd2hpY2ggY2FuIGJlIE5VTEwgaWYgdGhlIGNhcHR1cmUgcXVldWUgd2FzIHN0b3BwZWQu Ci0gW0hpZ2hdIFByZW1hdHVyZSBmcmVlaW5nIG9mIG0ybV9kZXYgYW5kIGRldmljZSBjb250ZXh0 IGluIHJlbW92ZSgpIGxlYWRzIHRvIFVzZS1BZnRlci1GcmVlIGlmIGZpbGUgZGVzY3JpcHRvcnMg cmVtYWluIG9wZW4uCi0gW0hpZ2hdIFJhY2UgY29uZGl0aW9uIGJldHdlZW4gdGhlIHRpbWVvdXQg aGFuZGxlciBhbmQgdGhyZWFkZWQgSVNSIGNhdXNlcyB1bnN5bmNocm9uaXplZCBoYXJkd2FyZSBy ZWdpc3RlciBhY2Nlc3Nlcy4KLSBbTWVkaXVtXSBgdGVlX3B0YV9pbnZva2VfY21kYCBtYXNrcyBp bnRlcm5hbCBlcnJvcnMgZnJvbSBgdGVlX2NsaWVudF9pbnZva2VfZnVuYygpYC4KLSBbTWVkaXVt XSBgYW1sX3ZkZWNfZHJ2X3Byb2JlYCBkZXJlZmVyZW5jZXMgYHB2ZGVjX2RhdGFgIHdpdGhvdXQg Y2hlY2tpbmcgaWYgYG9mX2RldmljZV9nZXRfbWF0Y2hfZGF0YSgpYCByZXR1cm5lZCBOVUxMLgot IFtNZWRpdW1dIEtlcm5lbCBzdGFjayBtZW1vcnkgbGVhayB0byBETUEtY29oZXJlbnQgYnVmZmVy IGR1ZSB0byB1bmluaXRpYWxpemVkIGFycmF5IGluIGBjb25maWdfc3BzX3BhcmFtcygpYCBhbmQg YGNvbmZpZ19wcHNfcGFyYW1zKClgLgotIFtNZWRpdW1dIE1hbnVhbCAxNi1iaXQgd29yZCBzd2Fw cGluZyBvZiBETUEgZGF0YSBhc3N1bWVzIENQVSBlbmRpYW5uZXNzLCBicmVha2luZyBvbiBiaWct ZW5kaWFuIGFyY2hpdGVjdHVyZXMuCi0tCgpjb21taXQgMzJkNzlhNTVjYjM5ZmUzNTY0MWEyYWRh NTUwMjc0NTk1MDEwY2RjZQpBdXRob3I6IFpoZW50YW8gR3VvIDx6aGVudGFvLmd1b0BhbWxvZ2lj LmNvbT4KU3ViamVjdDogZGVjb2RlcjogQWRkIFY0TDIgc3RhdGVsZXNzIEguMjY0IGRlY29kZXIg ZHJpdmVyCgpBZGQgaW5pdGlhbCBzdXBwb3J0IGZvciBWNEwyIHN0YXRlbGVzcyB2aWRlbyBkZWNv ZGVyIGRyaXZlciBvbiBBbWxvZ2ljClM0KFM4MDVYMikgcGxhdGZvcm0uIEl0IHN1cHBvcnRzIDhi aXQgSC4yNjQgYml0c3RyZWFtcyBkZWNvZGluZywgY3VycmVudGx5Cm9ubHkgcHJvZ3Jlc3NpdmUg c3RyZWFtcy4KCj4gLS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9hbWxvZ2ljL3ZkZWMvYW1s X3ZkZWNfZHJ2LmMKPiArKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL2FtbG9naWMvdmRlYy9h bWxfdmRlY19kcnYuYwo+IEBAIC02OCwxNCArNjgsOCBAQCBzdGF0aWMgaW50IGZvcHNfdmNvZGVj X3JlbGVhc2Uoc3RydWN0IGZpbGUgKmZpbGUpCj4gIHsKPiAgCXN0cnVjdCBhbWxfdmRlY19jdHgg KmN0eCA9IGZoX3RvX2RlY19jdHgoZmlsZSk7Cj4gIAo+ICAJdjRsMl9tMm1fY3R4X3JlbGVhc2Uo Y3R4LT5tMm1fY3R4KTsKCltTZXZlcml0eTogSGlnaF0KRG9lcyBmb3BzX3Zjb2RlY19yZWxlYXNl KCkgdHJpZ2dlciBhIHVzZS1hZnRlci1mcmVlIGhlcmU/CgpJZiB0aGUgdjRsMiBkZXZpY2Ugd2Fz IHVucmVnaXN0ZXJlZCBhbmQgdGhlIGRyaXZlciB1bmJvdW5kLAphbWxfdmRlY19kcnZfcmVtb3Zl KCkgd2lsbCBoYXZlIGFscmVhZHkgZGVzdHJveWVkIHRoZSBtMm1fZGV2X2RlYyBzdHJ1Y3R1cmUu CldoZW4gYW4gYXBwbGljYXRpb24gc3Vic2VxdWVudGx5IGNsb3NlcyBhIHJldGFpbmVkIGZpbGUg ZGVzY3JpcHRvciwgdGhpcwphY2Nlc3NlcyB0aGUgZnJlZWQgbTJtIHN0cnVjdHVyZS4KCj4gIAl2 NGwyX2N0cmxfaGFuZGxlcl9mcmVlKCZjdHgtPmN0cmxfaGFuZGxlcik7Cj4gIAl2NGwyX2ZoX2Rl bCgmY3R4LT5maCwgZmlsZSk7Cj4gIAl2NGwyX2ZoX2V4aXQoJmN0eC0+ZmgpOwo+ICAJa2ZyZWUo Y3R4KTsKPiAgCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAKPiBbIC4uLiBdCj4gIAo+IEBAIC0xNDgs NiArMTQ4LDggQEAgc3RhdGljIGludCBhbWxfdmRlY19kcnZfcHJvYmUoc3RydWN0IHBsYXRmb3Jt X2RldmljZSAqcGRldikKPiAgCX0KPiAgCWRldi0+ZGVjX2h3ID0gaHc7Cj4gIAo+ICAJZGV2LT5w dmRlY19kYXRhID0gb2ZfZGV2aWNlX2dldF9tYXRjaF9kYXRhKCZwZGV2LT5kZXYpOwo+ICAJcmV0 ID0gZGV2LT5wdmRlY19kYXRhLT5yZXFfaHdfcmVzb3VyY2UoZGV2KTsKCltTZXZlcml0eTogTWVk aXVtXQpXaWxsIGFtbF92ZGVjX2Rydl9wcm9iZSgpIGNyYXNoIGlmIG9mX2RldmljZV9nZXRfbWF0 Y2hfZGF0YSgpIHJldHVybnMgbnVsbD8KCklmIHRoZSBkcml2ZXIgaXMgYm91bmQgbWFudWFsbHkg dmlhIHN5c2ZzIGRyaXZlcl9vdmVycmlkZSwgdGhlcmUgd29uJ3QgYmUKYW55IG1hdGNoIGRhdGEs IGNhdXNpbmcgYSBudWxsIHBvaW50ZXIgZGVyZWZlcmVuY2Ugd2hlbiBhY2Nlc3NpbmcKcmVxX2h3 X3Jlc291cmNlKCkuCgo+ICAJaWYgKHJldCA8IDApCj4gIAo+IFsgLi4uIF0KPiAgCj4gQEAgLTIy Niw5ICsyMjYsNiBAQCBzdGF0aWMgdm9pZCBhbWxfdmRlY19kcnZfcmVtb3ZlKHN0cnVjdCBwbGF0 Zm9ybV9kZXZpY2UgKnBkZXYpCj4gIAl2aWRlb191bnJlZ2lzdGVyX2RldmljZShkZXYtPnZmZCk7 Cj4gIAltZWRpYV9kZXZpY2VfY2xlYW51cCgmZGV2LT5tZGV2KTsKPiAgCj4gIAl2NGwyX20ybV9y ZWxlYXNlKGRldi0+bTJtX2Rldl9kZWMpOwoKW1NldmVyaXR5OiBIaWdoXQpDYW4gdGhpcyBjYXVz ZSBhIHVzZS1hZnRlci1mcmVlIGlmIGZpbGUgZGVzY3JpcHRvcnMgcmVtYWluIG9wZW4/CgpUaGlz IHByZW1hdHVyZWx5IGZyZWVzIHRoZSBjb3JlIHY0bDIgbTJtIHN0cnVjdHVyZXMgYW5kIHRyaWdn ZXJzIGNsZWFudXAKb2YgZGV2bSBhbGxvY2F0aW9ucyBiZWZvcmUgYWxsIGZpbGUgZGVzY3JpcHRv cnMgaGF2ZSBiZWVuIGNsb3NlZC4gQQpzdWJzZXF1ZW50IGNsb3NlIGJ5IHVzZXJzcGFjZSB3aWxs IGhpdCB0aGUgdXNlLWFmdGVyLWZyZWUgaW4KZm9wc192Y29kZWNfcmVsZWFzZSgpLgoKPiAgCWRl di0+cHZkZWNfZGF0YS0+ZGVzdHJveV9od19yZXNvdXJjZShkZXYpOwo+ICAJdjRsMl9kZXZpY2Vf dW5yZWdpc3RlcigmZGV2LT52NGwyX2Rldik7Cj4gIH0KCj4gLS0tIGEvZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS9hbWxvZ2ljL3ZkZWMvYW1sX3ZkZWNfaHcuYwo+ICsrKyBiL2RyaXZlcnMvbWVkaWEv cGxhdGZvcm0vYW1sb2dpYy92ZGVjL2FtbF92ZGVjX2h3LmMKPiBAQCAtMTYwLDggKzE2MCw4IEBA IHN0YXRpYyB2b2lkIHBtX3ZkZWNfcG93ZXJfZG9tYWluX3JlbGVhc2Uoc3RydWN0IGFtbF92ZGVj X2h3ICpodykKPiAgCWZvciAoaSA9IDA7IGkgPCBWREVDX01BWDsgaSsrKSB7Cj4gIAkJaWYgKCFJ U19FUlJfT1JfTlVMTChwZFtpXS5saW5rKSkKPiAgCQkJZGV2aWNlX2xpbmtfZGVsKHBkW2ldLmxp bmspOwo+ICAKPiAgCQlpZiAoIUlTX0VSUl9PUl9OVUxMKHBkW2ldLmRldikpCj4gIAkJCWRldl9w bV9kb21haW5fZGV0YWNoKHBkW2ldLmRldiwgdHJ1ZSk7CgpbU2V2ZXJpdHk6IEhpZ2hdCkRvZXMg cG1fdmRlY19wb3dlcl9kb21haW5fcmVsZWFzZSgpIGxlYXZlIGRhbmdsaW5nIHBvaW50ZXJzIGlu IHRoZSBnbG9iYWwKdmRlY19kb21haW5fZGF0YSBhcnJheT8KCkJlY2F1c2UgdGhlIGdsb2JhbCBw ZFtpXS5saW5rIGFuZCBwZFtpXS5kZXYgcG9pbnRlcnMgYXJlIG5ldmVyIHNldCB0byBudWxsLAph IHNlcXVlbmNlIHdoZXJlIHRoZSBkcml2ZXIgaXMgdW5ib3VuZCBhbmQgcmVib3VuZCwgb3IgZW5j b3VudGVycyBjb25zZWN1dGl2ZQpwcm9iZSBmYWlsdXJlcywgd2lsbCByZXN1bHQgaW4gYSBkb3Vi bGUtZnJlZSBvZiB0aGUgZGV2aWNlX2xpbmsgYW5kIHBvd2VyCmRvbWFpbi4KCj4gIAl9Cj4gIH0K Cj4gLS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9hbWxvZ2ljL3ZkZWMvYW1sX3ZkZWNfdGVl X2Z3LmMKPiArKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL2FtbG9naWMvdmRlYy9hbWxfdmRl Y190ZWVfZncuYwo+IEBAIC0xMjQsMTIgKzEyNCwxMiBAQCBzdGF0aWMgaW50IHRlZV9wdGFfaW52 b2tlX2NtZChzdHJ1Y3QgYW1sX3ZkZWNfaHcgKmh3LCBzdHJ1Y3QgdGVlX2NvbnRleHQgKmN0eCwK PiAgCQlwYXJhbV9pbnZva2VbMF0udS5tZW1yZWYuc2htID0gc2htOwo+ICAJCXJldCA9IHRlZV9j bGllbnRfaW52b2tlX2Z1bmMoY3R4LCAmaW52X2FyZywgcGFyYW1faW52b2tlKTsKPiAgCQlpZiAo cmV0IDwgMCB8fCAoaW52X2FyZy5yZXQgIT0gVEVFQ19TVUNDRVNTICYmIGludl9hcmcucmV0ICE9 IFRFRUNfRVJST1JfQlVTWSkpIHsKCltTZXZlcml0eTogSGlnaF0KRG9lcyB0ZWVfcHRhX2ludm9r ZV9jbWQoKSBieXBhc3MgZXJyb3IgaGFuZGxpbmcgd2hlbiB0aGUgdGVlIHJldHVybnMKVEVFQ19F UlJPUl9CVVNZPwoKSWYgdGhlIHRlZSBzdWJzeXN0ZW0gaXMgYnVzeSwgdGhpcyBjb25kaXRpb24g ZXZhbHVhdGVzIHRvIGZhbHNlLCBjYXVzaW5nCnRoZSBmaXJtd2FyZSBsb2FkaW5nIGxvb3AgdG8g c2lsZW50bHkgc2tpcCB0aGUgY2h1bmsgd2l0aG91dCBhbnkgcmV0cnkuClRoaXMgd2lsbCBjb3Jy dXB0IHRoZSBoYXJkd2FyZSBmaXJtd2FyZSBhbmQgY2F1c2UgdGhlIGRldmljZSB0byBmYWlsLgoK PiAgCQkJZGV2X2luZm8oaHctPmRldiwKPiAgCQkJCSAiJXMgaW52b2tlIGZ1bmMgZmFpbGVkLCBj bWQgPSAldSwgcmV0PSAlZCwgcmVzID0gMHgleCwgb3JpZ2luID0gMHgleFxuIiwKPiAgCQkJCSBf X2Z1bmNfXywgY21kLCByZXQsIGludl9hcmcucmV0LAo+ICAJCQkJIGludl9hcmcucmV0X29yaWdp bik7Cj4gIAkJCXJldCA9IGludl9hcmcucmV0Owo+ICAJCQlnb3RvIGNsb3NlX3Nlc3Npb247Cgpb U2V2ZXJpdHk6IE1lZGl1bV0KV2lsbCB0aGlzIHJldHVybiBzdWNjZXNzIGlmIHRlZV9jbGllbnRf aW52b2tlX2Z1bmMoKSBmYWlscyBpbnRlcm5hbGx5PwoKSWYgdGVlX2NsaWVudF9pbnZva2VfZnVu YygpIGVuY291bnRlcnMgYW4gaW50ZXJuYWwgZXJyb3IgKGxpa2UgLUVOT01FTSkKYmVmb3JlIGlu dm9raW5nIHRoZSBjb21tYW5kLCBpdCByZXR1cm5zIGEgbmVnYXRpdmUgY29kZS4gU2luY2UgdGhl IGNvbW1hbmQKZGlkbid0IHJ1biwgaW52X2FyZy5yZXQgcmVtYWlucyBpdHMgZGVmYXVsdCBURUVD X1NVQ0NFU1MgKDApLiBTZXR0aW5nIHJldAp0byBpbnZfYXJnLnJldCBoZXJlIG1hc2tzIHRoZSBm YWlsdXJlIGFuZCByZXR1cm5zIHN1Y2Nlc3MuCgo+ICAJCX0KPiAgCQlzZW50X3NpemUgKz0gcGFy YW1faW52b2tlWzBdLnUubWVtcmVmLnNpemU7CgpbU2V2ZXJpdHk6IEhpZ2hdCkNhbiB0aGlzIGFk dmFuY2UgdGhlIGJ1ZmZlciBwb2ludGVyIGV2ZW4gd2hlbiB0aGUgY2h1bmsgd2FzIHJlamVjdGVk PwoKSWYgVEVFQ19FUlJPUl9CVVNZIHdhcyByZXR1cm5lZCwgdGhlIGxvb3Agc2tpcHMgdGhlIGVy cm9yIGJyYW5jaCBhbmQKZXJyb25lb3VzbHkgYWR2YW5jZXMgc2VudF9zaXplLCBwZXJtYW5lbnRs eSBsb3NpbmcgdGhlIGNodW5rLgoKPiAgCX0KCj4gLS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9y bS9hbWxvZ2ljL3ZkZWMvYW1sX3ZkZWMuYwo+ICsrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0v YW1sb2dpYy92ZGVjL2FtbF92ZGVjLmMKPiBAQCAtMTUwLDYgKzE1MCw4IEBAIHN0YXRpYyB2b2lk IG0ybW9wc192ZGVjX2RldmljZV9ydW4odm9pZCAqbTJtX3ByaXYpCj4gIAkJdjRsMl9jdHJsX3Jl cXVlc3RfY29tcGxldGUoc3JjX3JlcSwgJmN0eC0+Y3RybF9oYW5kbGVyKTsKPiAgCWlmIChyZXQg PCAwIHx8IGN0eC0+Y3Vycl9mcm1fZXJyX2ZsYWcpCj4gIAkJZ290byBlcnJfY2FuY2VsX2pvYjsK PiAgCXY0bDJfbTJtX2J1Zl9kb25lX2FuZF9qb2JfZmluaXNoKGRldi0+bTJtX2Rldl9kZWMsIGN0 eC0+bTJtX2N0eCwKPiAgCQkJCQkgVkIyX0JVRl9TVEFURV9ET05FKTsKCltTZXZlcml0eTogQ3Jp dGljYWxdCkNhbiBtMm1vcHNfdmRlY19kZXZpY2VfcnVuKCkgZGVhZGxvY2sgdGhlIHY0bDIgbTJt IGNvcmU/CgpJZiB1c2Vyc3BhY2UgdW5iaW5kcyB0aGUgc3RyZWFtIHVzaW5nIFZJRElPQ19TVFJF QU1PRkYgY29uY3VycmVudGx5LAp2YjJvcHNfdmRlY19zdG9wX3N0cmVhbWluZygpIHJlbW92ZXMg YWxsIGJ1ZmZlcnMgYW5kIGZyZWVzIGN0eC0+Y29kZWNfcHJpdi4KQmVjYXVzZSB0aGUgYnVmZmVy cyB3ZXJlIGFnZ3Jlc3NpdmVseSBzdHJpcHBlZCwKdjRsMl9tMm1fYnVmX2RvbmVfYW5kX2pvYl9m aW5pc2goKSB3aWxsIHRyaWdnZXIgYSB2NGwyIFdBUk5fT04gYW5kIGFib3J0LApwZXJtYW5lbnRs eSBoYW5naW5nIHRoZSBtMm0gcXVldWUuCgo+ICAJcmV0dXJuOwo+ICAKPiAgWyAuLi4gXQo+ICAK PiBAQCAtNDA0LDYgKzQwNCw3IEBAIHN0YXRpYyB2b2lkIHZiMm9wc192ZGVjX3N0b3Bfc3RyZWFt aW5nKHN0cnVjdCB2YjJfcXVldWUgKnEpCj4gIAl9Cj4gIAo+ICAJaWYgKCFjdHgtPmlzX291dHB1 dF9zdHJlYW1vbiAmJiAhY3R4LT5pc19jYXBfc3RyZWFtb24pCj4gIAkJYW1sX3ZkZWNfcmVsZWFz ZV9pbnN0YW5jZShjdHgpOwoKW1NldmVyaXR5OiBDcml0aWNhbF0KSXMgaXQgc2FmZSB0byB0ZWFy IGRvd24gdGhlIGluc3RhbmNlIGNvbnRleHQgd2l0aG91dCBzeW5jaHJvbml6aW5nIGFnYWluc3QK dGhlIG0ybSB3b3JrZXIgdGhyZWFkPwoKVGhpcyBmcmVlcyBjdHgtPmNvZGVjX3ByaXYgc3luY2hy b25vdXNseSB2aWEgYW1sX3ZkZWNfcmVsZWFzZV9pbnN0YW5jZSgpLApidXQgdGhlIG0ybW9wc192 ZGVjX2RldmljZV9ydW4oKSB3b3JrZXIgdGhyZWFkIG1pZ2h0IHN0aWxsIGJlIGJsb2NrZWQgaW4K YW1sX2gyNjRfZGVjX3J1bigpLiBXaGVuIHRoZSB0aHJlYWQgcmVzdW1lcywgaXQgd2lsbCB3cml0 ZSB0byB0aGUgZnJlZWQKaDI2NF9jdHgsIGNhdXNpbmcgYSB1c2UtYWZ0ZXItZnJlZS4KCj4gIH0K Cj4gLS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9hbWxvZ2ljL3ZkZWMvaDI2NC5jCj4gKysr IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9hbWxvZ2ljL3ZkZWMvaDI2NC5jCj4gQEAgLTEzLDIg KzEzLDIgQEAKPiAgI2RlZmluZSBJTlZBTElEX1BPQyAweGZmZmZmZmZmCgpbU2V2ZXJpdHk6IEhp Z2hdCkRvZXMgdGhpcyBzZW50aW5lbCBtYXRoZW1hdGljYWxseSBhbGlhcyB3aXRoIGEgdmFsaWQg aDI2NCBwb2Mgb2YgLTE/CgpBIHBpY3R1cmUgb3JkZXIgY291bnQgb2YgLTEgZXZhbHVhdGVzIHRv IDB4ZmZmZmZmZmYuIFVzaW5nIHRoaXMgYXMgdGhlCklOVkFMSURfUE9DIHNlbnRpbmVsIGNhdXNl cyB2YWxpZCByZWZlcmVuY2UgZnJhbWVzIHdpdGggYSAtMSBwb2MgdG8gYmUKc2tpcHBlZCBkdXJp bmcgYnVmZmVyIHJlbGVhc2UgYW5kIGluY29ycmVjdGx5IG1hdGNoZWQgd2hlbiBzZWFyY2hpbmcu Cgo+ICBbIC4uLiBdCj4gIAo+IEBAIC0yMDAsNiArMjAwLDggQEAgc3RhdGljIGludCBjb25maWdf c3BzX3BhcmFtcyhzdHJ1Y3QgYW1sX2gyNjRfY3R4ICpoMjY0X2N0eCwKPiAgCXUzMiBvZmZzZXQg PSAwOwo+ICAJdW5zaWduZWQgc2hvcnQgZGF0YV90bXBbMHgxMDBdOwoKW1NldmVyaXR5OiBNZWRp dW1dCkRvZXMgdGhpcyBsZWFrIHVuaW5pdGlhbGl6ZWQgc3RhY2sgbWVtb3J5PwoKT25seSB0aGUg Zmlyc3QgZmV3IHdvcmRzIG9mIHRoaXMgMjU2LXdvcmQgYXJyYXkgYXJlIHBvcHVsYXRlZCBiZWZv cmUgdGhlCmVudGlyZSA1MTItYnl0ZSBidWZmZXIgaXMgY29waWVkIGludG8gZG1hIG1lbW9yeSBi ZWxvdy4KCj4gIAlpbnQgaSwgaWk7Cj4gIAo+ICAJbWVtc2V0KHNwc19iYXNlLCAwLCAweDEwMCk7 Cj4gIAo+ICBbIC4uLiBdCj4gIAo+IEBAIC0yNDgsOCArMjQ4LDggQEAgc3RhdGljIGludCBjb25m aWdfc3BzX3BhcmFtcyhzdHJ1Y3QgYW1sX2gyNjRfY3R4ICpoMjY0X2N0eCwKPiAgCj4gIAlmb3Ig KGkgPSAwOyBpIDwgMHgxMDA7IGkgKz0gNCkgewo+ICAJCWZvciAoaWkgPSAwOyBpaSA8IDQ7IGlp KyspCj4gIAkJCXNwc19iYXNlW2kgKyAzIC0gaWldID0gZGF0YV90bXBbaSArIGlpXTsKCltTZXZl cml0eTogTWVkaXVtXQpXaWxsIHRoaXMgYnJlYWsgb24gYmlnLWVuZGlhbiBjcHVzPwoKVGhlIGNv ZGUgdHJlYXRzIGRtYS1tYXBwZWQgbWVtb3J5IGFzIGFuIGFycmF5IG9mIHVuc2lnbmVkIHNob3J0 LCB3aGljaCB3aWxsCmJ5dGUtc3dhcCB0aGUgcGFyYW1ldGVyIGJsb2NrcyBvbiBhIGJpZy1lbmRp YW4gY3B1IGJlZm9yZSB0aGUgaGFyZHdhcmUgcmVhZHMKaXQuCgo+ICAJfQo+ICAKPiAgWyAuLi4g XQo+ICAKPiBAQCAtMzQ3LDYgKzM0Nyw4IEBAIHN0YXRpYyBpbnQgaDI2NF9wcmVwYXJlX2lucHV0 KHN0cnVjdCBhbWxfdmRlY19jdHggKmN0eCkKPiAgCXJlZ21hcF93cml0ZShody0+bWFwW0RPU19C VVNdLCBWTERfTUVNX1ZJRklGT19SUCwKPiAgCQkgICAgIHJvdW5kX2Rvd24oc3JjX2RtYSwgVkRF Q19GSUZPX0FMSUdOKSk7Cj4gIAlkdW1teSA9IHBheWxvYWRfc2l6ZSArIFZMRF9QQURESU5HX1NJ WkU7Cj4gIAlyZWdtYXBfd3JpdGUoaHctPm1hcFtET1NfQlVTXSwgVkxEX01FTV9WSUZJRk9fV1As Cj4gIAkJICAgICByb3VuZF9kb3duKChzcmNfZG1hICsgZHVtbXkpLCBWREVDX0ZJRk9fQUxJR04p KTsKCltTZXZlcml0eTogSGlnaF0KRG9lcyBoMjY0X3ByZXBhcmVfaW5wdXQoKSBpbnN0cnVjdCB0 aGUgaGFyZHdhcmUgdG8gcmVhZCBwYXN0IHRoZSBlbmQgb2YgdGhlCmJ1ZmZlcj8KClRoZSBoYXJk d2FyZSB3cml0ZSBwb2ludGVyIGlzIGFydGlmaWNpYWxseSBpbmNyZWFzZWQgYnkgVkxEX1BBRERJ TkdfU0laRQooMTAyNCBieXRlcykgYmV5b25kIHBheWxvYWRfc2l6ZSB3aXRob3V0IHZlcmlmeWlu ZyB0aGUgcGh5c2ljYWwKdmIyX3BsYW5lX3NpemUoKSBpcyBsYXJnZSBlbm91Z2ggdG8gY29udGFp biBpdC4KCj4gIFsgLi4uIF0KPiAgCj4gQEAgLTM5OCw2ICszOTgsNiBAQCBzdGF0aWMgaW50IGNv bmZpZ19zcHNfcGFyYW1zKHN0cnVjdCBhbWxfaDI2NF9jdHggKmgyNjRfY3R4LAo+ICAJaDI2NF9j dHgtPmZyYW1lX2hlaWdodCA9IChzcHMtPnBpY19oZWlnaHRfaW5fbWFwX3VuaXRzX21pbnVzMSAr IDEpIDw8IDQ7Cj4gIAo+ICAJaWYgKCFmcmFtZV9zaXplX2luX3JhbmdlKHN0ZXB3aXNlLCBoMjY0 X2N0eC0+ZnJhbWVfd2lkdGgsCj4gIAkJCQkgaDI2NF9jdHgtPmZyYW1lX2hlaWdodCkpIHsKPiAg CQlkZXZfaW5mbygmY3R4LT5kZXYtPnBsYXRfZGV2LT5kZXYsCgpbU2V2ZXJpdHk6IEhpZ2hdCkNh biBhIG1pc21hdGNoZWQgc3BzIHRyaWdnZXIgYSBidWZmZXIgb3ZlcmZsb3c/CgpUaGlzIGNoZWNr cyB0aGUgc3BzIGFnYWluc3QgdGhlIGdsb2JhbCBtYXhpbXVtcyBidXQgaWdub3JlcyB0aGUgYWN0 dWFsIHNpemUKb2YgdGhlIGN1cnJlbnRseSBhbGxvY2F0ZWQgdjRsMiBjYXB0dXJlIGJ1ZmZlci4g SWYgdXNlcnNwYWNlIGFsbG9jYXRlcyBhCnNtYWxsIGJ1ZmZlciBhbmQgc3VibWl0cyBhIDEwODBw IHNwcywgdGhlIGhhcmR3YXJlIHdpbGwgb3ZlcmZsb3cgdGhlIGJ1ZmZlcgpkdXJpbmcgY29uZmln X2RlY29kZV9jYW52YXMoKS4KCj4gIFsgLi4uIF0KPiAgCj4gQEAgLTQyNSw2ICs0MjUsOCBAQCBz dGF0aWMgaW50IGFsbG9jX2NvbG9jYXRlX2NtYShzdHJ1Y3QgYW1sX2gyNjRfY3R4ICpoMjY0X2N0 eCwKPiAgCWdmcF90IGdmcCA9IEdGUF9LRVJORUwgfCBHRlBfRE1BMzI7Cj4gIAo+ICAJaWYgKGgy NjRfY3R4LT5jb2xsYXRlZF9jbWFfdmFkZHIpCj4gIAkJcmV0dXJuIDA7CgpbU2V2ZXJpdHk6IEhp Z2hdCkRvZXMgYWxsb2NfY29sb2NhdGVfY21hKCkgcHJldmVudCB0aGUgY21hIGJ1ZmZlciBmcm9t IHJlc2l6aW5nPwoKSWYgdGhlIHN0cmVhbSBkeW5hbWljIHJlc29sdXRpb24gaW5jcmVhc2VzLCBy ZXR1cm5pbmcgZWFybHkgaGVyZSBsZWF2ZXMKb25lX2NvbF9idWZfc2l6ZSBhdCBpdHMgb2xkLCBz bWFsbGVyIHZhbHVlLiBMYXRlciwgaDI2NF9jb25maWdfZGVjb2RlX2J1ZigpCmJvdW5kcyBjaGVj a3MgdXNpbmcgdGhlIHN0YWxlIHNpemUsIG92ZXJmbG93aW5nIHRoZSBjb250aWd1b3VzIG1lbW9y eSBhcmVhLgoKPiAgCWh3ID0gdmRlY19nZXRfaHcoY3R4LT5kZXYpOwo+ICAKPiAgWyAuLi4gXQo+ ICAKPiBAQCAtNDkwLDYgKzQ5MCw4IEBAIHN0YXRpYyBpbnQgY29uZmlnX2RlY29kZV9jYW52YXMo c3RydWN0IGFtbF92ZGVjX2h3ICpodywKPiAgCWJ1Zl9zcGVjLT5jYW52YXNfYWxsb2NhdGVkID0g MTsKPiAgCj4gIAkvKiBjb25maWcgeSBjYW52YXMgKi8KPiAgCW1lc29uX2NhbnZhc19jb25maWco aHctPmNhbnZhcywKPiAgCQkJICAgIGJ1Zl9zcGVjLT55X2NhbnZhc19pbmRleCwgYnVmX3NwZWMt PnlfZG1hX2FkZHIsCj4gIAkJCSAgICBtYl93aWR0aCA8PCA0LCBtYl9oZWlnaHQgPDwgNCwKCltT ZXZlcml0eTogSGlnaF0KRG9lcyBjb25maWdfZGVjb2RlX2NhbnZhcygpIGNvbW1hbmQgdGhlIGhh cmR3YXJlIHRvIHdyaXRlIHBhc3QgdGhlIGVuZCBvZgp0aGUgZG1hIGJ1ZmZlcj8KCkJlY2F1c2Ug dGhlIHNwcyBkaW1lbnNpb25zIGFyZSB1bnZhbGlkYXRlZCBhZ2FpbnN0IHRoZSBhY3R1YWwgYnVm ZmVyIHNpemUsCnRoaXMgY2FuIGNvbmZpZ3VyZSB0aGUgY2FudmFzIHRvIHdyaXRlIGEgMTA4MHAg ZnJhbWUgaW50byBhIG11Y2ggc21hbGxlcgp2NGwyIGJ1ZmZlci4KCj4gIFsgLi4uIF0KPiAgCj4g QEAgLTU0MCw2ICs1NDAsOCBAQCBzdGF0aWMgdm9pZCByZWxlYXNlX2NvbG9jYXRlX2J1ZihzdHJ1 Y3QgYW1sX2gyNjRfY3R4ICpoMjY0X2N0eCwgaW50IGluZGV4KQo+ICAJCQkgICAgIF9fZnVuY19f LCBpbmRleCwgaDI2NF9jdHgtPm1heF9udW1fcmVmX2ZyYW1lcyk7Cj4gIAkJfSBlbHNlIHsKPiAg CQkJaWYgKGgyNjRfY3R4LT5jb2xvY2F0ZWRfYnVmX3BvY1tpbmRleF0gIT0gSU5WQUxJRF9QT0Mg JiYKPiAgCQkJICAgICgoaDI2NF9jdHgtPmNvbG9jYXRlZF9idWZfbWFwID4+IGluZGV4KSAmIDB4 MSkgPT0gMHgxKSB7Cj4gIAkJCQloMjY0X2N0eC0+Y29sb2NhdGVkX2J1Zl9tYXAgJj0gKH4oMSA8 PCBpbmRleCkpOwoKW1NldmVyaXR5OiBIaWdoXQpEb2VzIHJlbGVhc2VfY29sb2NhdGVfYnVmKCkg bGVhayBidWZmZXIgc2xvdHMgZm9yIHZhbGlkIHJlZmVyZW5jZSBmcmFtZXM/CgpTaW5jZSBJTlZB TElEX1BPQyBhbGlhc2VzIHdpdGggLTEsIHJlZmVyZW5jZSBmcmFtZXMgd2l0aCBhIHBvYyBvZiAt MSBmYWlsCnRoaXMgY29uZGl0aW9uIGFuZCBhcmUgbmV2ZXIgcmVsZWFzZWQuCgo+ICBbIC4uLiBd Cj4gIAo+IEBAIC02MTEsNiArNjExLDYgQEAgc3RhdGljIGludCBoMjY0X2NvbmZpZ19kZWNvZGVf c3BlYyhzdHJ1Y3QgYW1sX3ZkZWNfaHcgKmh3LCBzdHJ1Y3QgYW1sX3ZkZWNfY3R4ICoKPiAgCj4g IAl2YjJfdjRsMiA9IHY0bDJfbTJtX25leHRfZHN0X2J1ZihjdHgtPm0ybV9jdHgpOwo+ICAJdmIg PSAmdmIyX3Y0bDItPnZiMl9idWY7CgpbU2V2ZXJpdHk6IEhpZ2hdCldpbGwgaDI2NF9jb25maWdf ZGVjb2RlX3NwZWMoKSBjcmFzaCBpZiB2NGwyX20ybV9uZXh0X2RzdF9idWYoKSByZXR1cm5zIG51 bGw/CgpJZiB0aGUgY2FwdHVyZSBxdWV1ZSB3YXMgc3RvcHBlZCBieSBWSURJT0NfU1RSRUFNT0ZG LCB0aGUgZGVzdGluYXRpb24KYnVmZmVycyBhcmUgcmVtb3ZlZC4gVGhpcyB1bmNvbmRpdGlvbmFs bHkgZGVyZWZlcmVuY2VzIGEgbnVsbCBwb2ludGVyIGluc2lkZQp0aGUgaW50ZXJydXB0IGhhbmRs ZXIgY29udGV4dC4KCj4gIAloMjY0X2N0eC0+Y3Vycl9zcGVjLnlfZG1hX2FkZHIgPSB2YjJfZG1h X2NvbnRpZ19wbGFuZV9kbWFfYWRkcih2YiwgMCk7Cj4gIAo+ICBbIC4uLiBdCj4gIAo+IEBAIC05 MTYsNiArOTE2LDggQEAgdm9pZCBhbWxfaDI2NF9leGl0KHZvaWQgKnByaXYpCj4gIAkJCQkgIGgy NjRfY3R4LT5jbWFfYWxsb2NfYWRkcik7Cj4gIAo+ICAJa2ZyZWUoY3R4LT5jb2RlY19wcml2KTsK PiAgCWN0eC0+Y29kZWNfcHJpdiA9IE5VTEw7Cj4gIH0KCltTZXZlcml0eTogQ3JpdGljYWxdCkRv ZXMgYW1sX2gyNjRfZXhpdCgpIHRyaWdnZXIgYSB1c2UtYWZ0ZXItZnJlZT8KClRoaXMgZnJlZXMg dGhlIGNvbnRleHQgd2hpbGUgdGhlIG0ybSB3b3JrZXIgdGhyZWFkIGlzIGFjdGl2ZWx5IGV4ZWN1 dGluZyBhbmQKd2FpdGluZy4gV2hlbiB0aGUgdGhyZWFkIHJlc3VtZXMsIGl0IGRlcmVmZXJlbmNl cyB0aGUgZnJlZWQgbWVtb3J5LgoKPiAgWyAuLi4gXQo+ICAKPiBAQCAtOTY2LDYgKzk2Niw4IEBA IGludCBhbWxfaDI2NF9kZWNfcnVuKHZvaWQgKnByaXYpCj4gIAkJICogaDI2NF9yZWxlYXNlX2Rl Y29kZV9zcGVjKCkgY29uY3VycmVudGx5Lgo+ICAJCSAqLwo+ICAJCWFtbF9zdG9wX3ZkZWNfaHco ZGVjX2h3KTsKPiAgCQlzeW5jaHJvbml6ZV9pcnEoZGVjX2h3LT5kZWNfaXJxKTsKPiAgCQloMjY0 X3JlbGVhc2VfZGVjb2RlX3NwZWMoZGVjX2h3LCBjdHgpOwo+ICAJfSBlbHNlIGlmICgtRVJFU1RB UlRTWVMgPT0gcmV0KSB7Cj4gIAkJcmV0ID0gLTE7CgpbU2V2ZXJpdHk6IEhpZ2hdCkNhbiBhbWxf aDI2NF9kZWNfcnVuKCkgcmFjZSB3aXRoIHRoZSB0aHJlYWRlZCBpc3IgYW5kIGNvcnJ1cHQgaGFy ZHdhcmUgc3RhdGU/CgphbWxfc3RvcF92ZGVjX2h3KCkgaW1tZWRpYXRlbHkgZXhlY3V0ZXMgaGFy ZHdhcmUgcmVzZXRzIHZpYSBET1NfU1dfUkVTRVQwLgpJZiB0aGUgdGhyZWFkZWQgaXNyIGlzIGNv bmN1cnJlbnRseSB3cml0aW5nIGNvbmZpZ3VyYXRpb24gYmxvY2tzIHRvIERPU19CVVMKcmVnaXN0 ZXJzLCB0aGUgYWNjZXNzZXMgd2lsbCBpbnRlcmxlYXZlIGFuZCBjb3JydXB0IHRoZSBkZWNvZGVy IHN0YXRlLgoKPiAgWyAuLi4gXQo+ICAKPiBAQCAtOTc5LDYgKzk3OSw4IEBAIGludCBhbWxfaDI2 NF9kZWNfcnVuKHZvaWQgKnByaXYpCj4gIAo+ICAJaDI2NF9jdHgtPmluaXRfZmxhZyA9IDA7Cj4g IAlhbWxfdmRlY19zZXRfY3Vycl9jdHgoZGVjX2h3LCBOVUxMKTsKCltTZXZlcml0eTogQ3JpdGlj YWxdCklzIGl0IHBvc3NpYmxlIHRvIHVzZSBhIGZyZWVkIHBvaW50ZXIgaGVyZT8KCklmIGFtbF9o MjY0X2V4aXQoKSB3YXMgaW52b2tlZCBjb25jdXJyZW50bHkgdmlhIHN0cmVhbW9mZiwgaDI2NF9j dHggd2FzCmFscmVhZHkgZnJlZWQsIHJlc3VsdGluZyBpbiBhIHVzZS1hZnRlci1mcmVlIHdoZW4g bW9kaWZ5aW5nIGluaXRfZmxhZy4KCj4gIAlyZXR1cm4gcmV0Owo+ICAKPiAgWyAuLi4gXQo+ICAK PiBAQCAtMTQzNiw2ICsxNDM2LDggQEAgc3RhdGljIGludCBoMjY0X2NvbmZpZ19kZWNvZGVfYnVm KHN0cnVjdCBhbWxfdmRlY19odyAqaHcsCj4gIAkJY29sb2NhdGVfd3JfYWRyID0gKHVuc2lnbmVk IGludCloMjY0X2N0eC0+Y29sbGF0ZWRfY21hX2FkZHIgKwo+ICAJCSAgICAoKGgyNjRfY3R4LT5v bmVfY29sX2J1Zl9zaXplICoKPiAgCQkgICAgICBoMjY0X2N0eC0+Y3Vycl9zcGVjLmNvbF9idWZf aW5kZXgpID4+ICh1c2VfbW9kZV84eDhfZmxhZyA/IDIgOiAwKSk7Cj4gIAkJaWYgKGNvbG9jYXRl X2Fkcl9vZmZzZXQgPiBoMjY0X2N0eC0+b25lX2NvbF9idWZfc2l6ZSB8fAo+ICAJCSAgICBjb2xv Y2F0ZV93cl9hZHIgKyBoMjY0X2N0eC0+b25lX2NvbF9idWZfc2l6ZSA+Cj4gIAkJICAgICh1bnNp Z25lZCBpbnQpaDI2NF9jdHgtPmNvbGxhdGVkX2NtYV9hZGRyX2VuZCkgewoKW1NldmVyaXR5OiBI aWdoXQpEb2VzIHRoaXMgYm91bmRzIGNoZWNrIGZhaWwgZHVyaW5nIGR5bmFtaWMgcmVzb2x1dGlv biBjaGFuZ2VzPwoKQmVjYXVzZSBhbGxvY19jb2xvY2F0ZV9jbWEoKSBiYWlscyBvdXQgZWFybHkg aW5zdGVhZCBvZiB1cGRhdGluZwpvbmVfY29sX2J1Zl9zaXplLCB0aGlzIGxvZ2ljIHVzZXMgdGhl IHN0YWxlIHNpemUgdG8gdmFsaWRhdGUgYSBoYXJkd2FyZQp3cml0ZSwgbGVhZGluZyB0byBhIGRt YSBvdmVyZmxvdy4KCj4gIFsgLi4uIF0KPiAgCj4gQEAgLTE2NzYsNiArMTY3Niw4IEBAIHN0YXRp YyBpcnFyZXR1cm5fdCBoMjY0X2lzcihpbnQgaXJxLCB2b2lkICpwcml2KQo+ICAJcmV0dXJuIElS UV9XQUtFX1RIUkVBRDsKPiAgfQo+ICAKPiAgc3RhdGljIGlycXJldHVybl90IGgyNjRfdGhyZWFk ZWRfaXNyX2Z1bmMoaW50IGlycSwgdm9pZCAqcHJpdikKPiAgewo+ICAJdTMyIGRlY19zdGF0dXM7 CgpbU2V2ZXJpdHk6IEhpZ2hdCkRvZXMgaDI2NF90aHJlYWRlZF9pc3JfZnVuYygpIHBlcmZvcm0g cmVnaXN0ZXIgd3JpdGVzIHRoYXQgcmFjZSB3aXRoIHRoZQp0aW1lb3V0IGhhbmRsZXI/CgpUaGUg dGhyZWFkZWQgaXNyIGhhbmRsZXMgY29uZmlndXJhdGlvbiBhbmQgc3RhcnRzIHRoZSBoYXJkd2Fy ZS4gSWYgdGhlIG1haW4KdGhyZWFkJ3Mgd2FpdCB0aW1lcyBvdXQsIHRoZSB0aW1lb3V0IGhhbmRs ZXIgd2lsbCByZXNldCB0aGUgaGFyZHdhcmUKY29uY3VycmVudGx5LCBjYXVzaW5nIHRoZSByZWdp c3RlciB3cml0ZXMgaGVyZSB0byBjb2xsaWRlLgoKPiAgWyAuLi4gXQo+ICAKPiBAQCAtMTY4Nyw2 ICsxNjg3LDggQEAgc3RhdGljIGlycXJldHVybl90IGgyNjRfdGhyZWFkZWRfaXNyX2Z1bmMoaW50 IGlycSwgdm9pZCAqcHJpdikKPiAgCXN3aXRjaCAoZGVjX3N0YXR1cykgewo+ICAJY2FzZSBIMjY0 X1NMSUNFX0hFQURFUl9ET05FOgo+ICAJCWZvciAoaSA9IDA7IGkgPCAweDQwMDsgaSArPSA0KQo+ ICAJCQlmb3IgKGlpID0gMDsgaWkgPCA0OyBpaSsrKQo+ICAJCQkJaDI2NF9jdHgtPmRwYl9wYXJh bS5sLmRhdGFbaSArIGlpXSA9IHBbaSArIDMgLSBpaV07CgpbU2V2ZXJpdHk6IE1lZGl1bV0KV2ls bCB0aGlzIGxvb3AgYnJlYWsgb24gYmlnLWVuZGlhbiBhcmNoaXRlY3R1cmVzPwoKVXNpbmcgY3B1 LW5hdGl2ZSB1bnNpZ25lZCBzaG9ydCBhY2Nlc3NlcyB0byByZWFkIHRoZSBoYXJkd2FyZSdzIGRt YSBvdXRwdXQKbWVtb3J5IGFzc3VtZXMgdGhlIGNwdSB1c2VzIHRoZSBzYW1lIGVuZGlhbm5lc3Mg YXMgdGhlIGhhcmR3YXJlLiBPbgpiaWctZW5kaWFuLCB0aGlzIHdpbGwgYnl0ZS1zd2FwIHRoZSBk YXRhIGluY29ycmVjdGx5LgoKPiAgCQlzYXZlX3JlZ19zdGF0dXMoaDI2NF9jdHgpOwoKLS0gClNh c2hpa28gQUkgcmV2aWV3IMK3IGh0dHBzOi8vc2FzaGlrby5kZXYvIy9wYXRjaHNldC8yMDI2MDkx NC1iNC1zNC12ZGVjLXVwc3RyZWFtLXY5LTAtNzJmZGIwZDcxYjAyQGFtbG9naWMuY29tP3BhcnQ9 NAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgt YW1sb2dpYyBtYWlsaW5nIGxpc3QKbGludXgtYW1sb2dpY0BsaXN0cy5pbmZyYWRlYWQub3JnCmh0 dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYW1sb2dpYwo=