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 8666049483A; Mon, 31 Aug 2026 13:38:40 +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=1788183522; cv=none; b=QwDfMgs5bOw1Qk6o6NISEGA43No2PI98rPidxaIBjmD3fIqnyf/MI+4gm7v7sCwJdcmdTLFSVlqbjDdAqMrlSYQEVltZlp1EmZ3M/meJZMkGWYm1soVx89+CH59PJdrRkURuLHf1O84Pw+3L4vPnV/8w65Hx+5Ai+ohEnEnfi10= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788183522; c=relaxed/simple; bh=bvb1vYoHFhqP2VcEmDuAujeIx3RJWVaMILC+JHETH0Q=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=YN/5Y7UizgWVYwAD0ztJcj7fOcAt95sMxHrWKNcOy+njXpcR2HiTtBR5EFMUJlI1pD1xNtfwg85c+jKu/+TTqt2NNFObBH32Q2RkviQXg7mnXmzJ1O497Cuenpbm6cT6lhgOjav6wUIA2/eIbnQ+GXcKtYAuJi95qjM+jDIoi6w= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=A4Tk7qT/; 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="A4Tk7qT/" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E40FE1F00A3E; Mon, 31 Aug 2026 13:38:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788183520; bh=xG2t2y2lKLQXDUfdvcxJHobwIOaB1uVKJu1HoXcWyes=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=A4Tk7qT/W9BYLhBZAo4JFJUDq9oD4147ZGoZ7tU3TacdSSo3qs6kTsgLTQXh6Xx9x 41FTjliOOiS4As+vtRtfoELJgaUmMtvhd4/0hQ+Nf2uVT8NE7u7U6R950fqXzvkz9I ZaDlFJrfzqH3RA3S2uvw7NlhqrpKc+0IOypxS2/gxTgCDqmmY49+MzJe6t2E+E3FEG OPbS3/u14fd1eUQQGxMk47f6+rjQ45KuGXzx+LrPFR3ecAZhvIVj9CE7BeSZO5q4CA xKAyWVn3maNB/3CG3qMozpEX46xnucMr3iHb3gqf+pvR84n8z3PDywRzqZXZ+frN3B 5ONnXEit+3mjw== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: Simon Xue , =?UTF-8?q?Sven=20P=C3=BCschel?= , Heiko Stuebner , Joerg Roedel , Sasha Levin , joro@8bytes.org, will@kernel.org, iommu@lists.linux.dev, linux-arm-kernel@lists.infradead.org, linux-rockchip@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 6.18-5.10] iommu/rockchip: disable fetch dte time limit Date: Mon, 31 Aug 2026 09:22:53 -0400 Message-ID: <20260831133314.4125787-145-sashal@kernel.org> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260831133314.4125787-1-sashal@kernel.org> References: <20260831133314.4125787-1-sashal@kernel.org> Precedence: bulk X-Mailing-List: patches@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 X-stable: review X-Patchwork-Hint: Ignore X-stable-base: Linux 6.18.48 Content-Transfer-Encoding: 8bit From: Simon Xue [ Upstream commit 8d4346ecd4950ae08cc76a6de327c264e846758c ] Disable the Bit 31 of the AUTO_GATING iommu register, as it causes hangups with the RGA3 (Raster Graphics Acceleration 3) peripheral. The RGA3 register description of the TRM already states that the bit must be set to 1. The vendor kernel sets the bit unconditionally to 1 to fix VOP (Video Output Processor) screen black issues. This patch squashes the 2 vendor kernel commits with the following commit messages: Master fetch data and cpu update page table may work in parallel, may have the following procedure: master cpu fetch dte update page tabl | | (make dte invalid) <- zap iotlb entry | | fetch dte again (make dte invalid) <- zap iotlb entry | | fetch dte again (make dte invalid) <- zap iotlb entry | | fetch dte again (make iommu block) <- zap iotlb entry New iommu version has the above bug, if fetch dte consecutively four times, then it will be blocked. Fortunately, we can set bit 31 of register MMU_AUTO_GATING to 1 to make it work as old version which does not have this issue. This issue only appears on RV1126 so far, so make a workaround dedicated to "rockchip,rv1126" machine type. iommu/rockchip: fix vop blocked and screen black on RK356X and RK3588 RK3568 and RK3588 has the same issue as RV1126/RV1109 that caused by dte fetch time limit, So we can set BIT(31) of register 0x24 default to 1 as a workaround. Signed-off-by: Simon Xue Signed-off-by: Sven Püschel Acked-by: Heiko Stuebner Signed-off-by: Joerg Roedel Signed-off-by: Sasha Levin --- LLM Generated explanations, may be completely bogus: ## PHASE 1: COMMIT MESSAGE FORENSICS ### Step 1.1: PARSE THE SUBJECT LINE **Record:** `[iommu/rockchip]` `[disable]` — Disable the fetch-DTE time- limit hardware behavior in the Rockchip IOMMU AUTO_GATING register (BIT(31)). ### Step 1.2: PARSE ALL COMMIT MESSAGE TAGS **Record:** - **Fixes:** — not present (expected for manual review) - **Reported-by:** — none - **Tested-by:** — none - **Reviewed-by:** — none - **Acked-by:** Heiko Stuebner `` (Rockchip maintainer) - **Link:** — none in commit (submission thread references vendor commits and RGA3 driver series) - **Cc: stable:** — not present (expected) - **Signed-off-by:** Simon Xue, Sven Püschel, Joerg Roedel (ignore pipeline-added SOBs) - **Notable:** Ack from subsystem maintainer; no syzbot/fuzzer involvement ### Step 1.3: ANALYZE THE COMMIT BODY TEXT **Record:** - **Bug description:** Newer Rockchip IOMMU hardware has a DTE-fetch time limit. When a master re-fetches DTE four times while the CPU concurrently zaps IOTLB entries (during page-table updates), the IOMMU enters a blocked state. - **Symptom/failure mode:** IOMMU hang/block → RGA3 peripheral hangups, VOP (display) blocked with black screen. - **Affected hardware:** RV1126/RV1109, RK3568, RK3588 (commit message also mentions RK356X broadly). - **Root cause:** BIT(31) of `RK_MMU_AUTO_GATING` (offset 0x24) defaults to 0 on affected silicon; TRM says it must be 1. Vendor kernel sets it unconditionally. - **Version info:** Not tied to a specific kernel version; this is a silicon/hardware behavior issue. ### Step 1.4: DETECT HIDDEN BUG FIXES **Record:** Not disguised — this is an explicit hardware workaround. Despite "disable" wording in the subject, the fix **sets** BIT(31) to disable the faulty time-limit feature. This is a classic hardware quirk/workaround, not a cosmetic cleanup. --- ## PHASE 2: DIFF ANALYSIS ### Step 2.1: INVENTORY THE CHANGES **Record:** - **Files:** `drivers/iommu/rockchip-iommu.c` (+8 lines, 0 removed) - **Functions modified:** `rk_iommu_enable()` only - **Scope:** Single-file, surgical fix ### Step 2.2: UNDERSTAND THE CODE FLOW CHANGE **Record:** - **Hunk 1 (define):** Adds `#define DISABLE_FETCH_DTE_TIME_LIMIT BIT(31)`. - **Hunk 2 (`rk_iommu_enable`):** - **Before:** After writing DTE address, ZAP cache, and IRQ mask, proceeds directly to enable paging. - **After:** Reads `RK_MMU_AUTO_GATING`, ORs in BIT(31), writes it back — for each MMU instance. - **Affected path:** IOMMU enable during device attach and system/runtime resume. ### Step 2.3: IDENTIFY THE BUG MECHANISM **Record:** - **Bug category:** Hardware workaround / logic correctness fix - **Mechanism:** Without BIT(31)=1, concurrent DTE fetch + IOTLB zap can trigger a silicon bug after four consecutive DTE fetches, permanently blocking the IOMMU. Setting BIT(31) restores legacy (non-buggy) behavior. ### Step 2.4: ASSESS THE FIX QUALITY **Record:** - **Quality:** Obviously correct — read-modify-write preserves other AUTO_GATING bits; matches vendor kernel and TRM guidance. - **Regression risk:** Very low. Vendor sets unconditionally on all affected platforms; bit is documented as should-be-1. - **Red flags:** Commit message still mentions RV1126-only workaround, but code applies unconditionally (intentional per vendor practice and RK3568/RK3588 need). --- ## PHASE 3: GIT HISTORY INVESTIGATION ### Step 3.1: BLAME THE CHANGED LINES **Record:** `rk_iommu_enable()` core logic dates to 2014 (Daniel Kurtz). `RK_MMU_AUTO_GATING` defined since original driver (2014, `c68a292152d32`). The **missing workaround** has been present since the driver's introduction — not a recent regression. ### Step 3.2: FOLLOW THE FIXES: TAG **Record:** No `Fixes:` tag. Not applicable — this is a hardware silicon bug, not a commit-introduced regression. ### Step 3.3: CHECK FILE HISTORY FOR RELATED CHANGES **Record:** - Recent related fix already in tree: `62e062a29ad51` — "prevent iommus dead loop when two masters share one IOMMU" (different bug, has `Cc: stable`). - `rk3568-iommu` v2 support added in `c55356c534aa6` (2021), present in this tree. - This fix is **standalone** — not part of a multi-patch series requiring prerequisites. - On `master`, this commit (`8d4346ecd4950`) is ahead of `stable/linux-6.18.y`. ### Step 3.4: CHECK THE AUTHOR'S OTHER COMMITS **Record:** Simon Xue is an active Rockchip IOMMU contributor (multi-irq support, dead-loop fix, ISP reset handling). Sven Püschel (Pengutronix) submitted and tested on RK3588 RGA3. ### Step 3.5: CHECK FOR DEPENDENT/PREREQUISITE COMMITS **Record:** No dependencies. Patch applies cleanly (`git apply --check` succeeded). No new structures, APIs, or helper functions required. --- ## PHASE 4: MAILING LIST AND EXTERNAL RESEARCH ### Step 4.1: FIND THE ORIGINAL PATCH DISCUSSION **Record:** - **Lore URL:** https://patch.msgid.link/20251126-spu- iommudtefix-v1-1-f90003dbfcc4@pengutronix.de - **Series revisions:** v1 submitted 2025-11-26; author pinged 2026-04-28; Heiko Stuebner suggested resend/v2 due to age; committed as-is on mainline 2026-06-02. - **Reviewer feedback:** Shawn Lin (Rockchip) noted TRM offset clarification (RGA3-specific offset vs general IOMMU 0x24) — comment- only, no code objection. - **Stable nominations:** None found in thread. - **NAKs:** None. ### Step 4.2: CHECK WHO REVIEWED THE PATCH **Record:** CC'd: Joerg Roedel, Will Deacon, Robin Murphy, Heiko Stuebner, iommu@, linux-arm-kernel@, linux-rockchip@. Heiko Stuebner Acked-by in final commit. ### Step 4.3: SEARCH FOR THE BUG REPORT **Record:** Real-world trigger documented by Pengutronix — sporadic RGA3 hangs on RK3588 during driver development. Vendor kernel commits [2][3] document VOP black-screen issues. No syzbot/bugzilla report. ### Step 4.4: CHECK FOR RELATED PATCHES AND SERIES **Record:** Related but independent: RGA3 upstream driver series (v5, 2026-04-28) depends on this IOMMU fix. The IOMMU fix stands alone and is not a "preparation" commit. ### Step 4.5: CHECK STABLE MAILING LIST HISTORY **Record:** No stable-list discussion found for this specific fix. (Lore direct fetch blocked by bot protection; analysis via `b4 dig -m` mbox download.) --- ## PHASE 5: CODE SEMANTIC ANALYSIS ### Step 5.1: IDENTIFY KEY FUNCTIONS IN THE DIFF **Record:** `rk_iommu_enable()` — only function modified. ### Step 5.2: TRACE CALLERS **Record:** - `rk_iommu_attach_device()` → `rk_iommu_enable()` (line 1043) — called when a device attaches to an IOMMU domain (e.g., VOP, RGA, NPU). - `rk_iommu_resume()` → `rk_iommu_enable()` (line 1330) — called on PM resume. - Both are common, user-visible paths on Rockchip boards. ### Step 5.3: TRACE CALLEES **Record:** Uses existing `rk_iommu_read()` / `rk_iommu_write()` register accessors, plus existing stall/reset/paging enable sequence. No new dependencies. ### Step 5.4: FOLLOW THE CALL CHAIN **Record:** Device probe → `iommu_attach_device` → `rk_iommu_attach_device` → `rk_iommu_enable`. Triggered during normal graphics/media driver initialization and suspend/resume. **Reachable from userspace** indirectly via device usage (display, GPU, RGA workloads causing IOTLB zaps). ### Step 5.5: SEARCH FOR SIMILAR PATTERNS **Record:** No similar workaround elsewhere in `rockchip-iommu.c`. Vendor kernel sets this bit unconditionally — external confirmation of the pattern. --- ## PHASE 6: CROSS-REFERENCING AGAINST THE LOCAL TREE ### Step 6.1: DOES THE BUGGY CODE EXIST IN THIS TREE? **Record:** **YES.** Local tree is **Linux 6.18.44** (`git describe HEAD` → `v6.18.44-1-gef4bf62bccf3c`). `rk_iommu_enable()` at lines 928–960 lacks the BIT(31) workaround. `RK_MMU_AUTO_GATING` is defined at line 42. `DISABLE_FETCH_DTE_TIME_LIMIT` is **not** present. Affected DT platforms exist: `rv1126.dtsi` (v1 `rockchip,iommu`), `rk356x-base.dtsi` and `rk3588-base.dtsi` (v2 `rockchip,rk3568-iommu`). ### Step 6.2: CHECK FOR BACKPORT COMPLICATIONS **Record:** **Clean apply** — `git format-patch` + `git apply --check` succeeded with no conflicts. No refactoring churn in `rk_iommu_enable()` since 6.18 branch. ### Step 6.3: CHECK IF RELATED FIXES ARE ALREADY HERE **Record:** The dead-loop fix (`62e062a29ad51`) is present. This DTE time-limit workaround (`8d4346ecd4950`) is **not** present on `stable/linux-6.18.y`. --- ## PHASE 7: SUBSYSTEM AND MAINTAINER CONTEXT ### Step 7.1: IDENTIFY THE SUBSYSTEM AND ITS CRITICALITY **Record:** `drivers/iommu/rockchip-iommu.c` — IOMMU driver for Rockchip SoCs. **IMPORTANT** for ARM/ARM64 embedded (display, media, NPU, ISP). `CONFIG_ROCKCHIP_IOMMU=y` in `arch/arm64/configs/defconfig`. ### Step 7.2: ASSESS SUBSYSTEM ACTIVITY **Record:** Actively maintained — recent fixes in 6.17/6.18 merge window (dead-loop fix, iommu-pages migration). Rockchip platforms (RK3568, RK3588) are widely deployed. --- ## PHASE 8: IMPACT AND RISK ASSESSMENT ### Step 8.1: DETERMINE WHO IS AFFECTED **Record:** Users of Rockchip SoCs with IOMMU-enabled peripherals — **platform-specific** but covering popular boards (RK3568, RK3588, RV1126). Display (VOP), graphics acceleration (RGA3), and other IOMMU- backed masters. ### Step 8.2: DETERMINE THE TRIGGER CONDITIONS **Record:** Concurrent IOMMU master DTE fetch + CPU IOTLB zap during page-table updates. Realistic during graphics/media workloads and driver activity. Not every boot, but reproducible under load (Pengutronix observed sporadic RGA3 hangs). ### Step 8.3: DETERMINE THE FAILURE MODE SEVERITY **Record:** IOMMU permanent block → **CRITICAL** system hang for affected peripherals; VOP black screen (display unusable); potential soft lockup of dependent subsystems. ### Step 8.4: CALCULATE RISK-BENEFIT RATIO **Record:** - **Benefit:** HIGH — prevents hardware IOMMU lockup and display/peripheral hangs on widely used SoCs. - **Risk:** VERY LOW — 8-line register write matching vendor kernel and TRM; read-modify-write preserves other bits. - **Ratio:** Strongly favors backport. --- ## PHASE 9: FINAL SYNTHESIS ### Step 9.1: COMPILE THE EVIDENCE **FOR backporting:** - Real hardware bug with documented failure mode (IOMMU block, display black, RGA3 hang) - Hardware quirk/workaround — explicitly allowed stable category - Small (8 lines), surgical, applies cleanly to 6.18.44 - Vendor kernel already does this unconditionally - TRM documents BIT(31) should be 1 - Acked-by Rockchip maintainer (Heiko Stuebner) - Affected SoC DT support present in this tree - Buggy code path exists and has existed since driver introduction - No prerequisite commits **AGAINST backporting:** - No `Cc: stable` or `Fixes:` tag (expected, not disqualifying) - Applies to all Rockchip IOMMU instances, not SoC-gated (but vendor does same; low risk) - Stale RV1126-only wording in commit message (code is correctly unconditional) **Unresolved:** None that affect the decision. ### Step 9.2: STABLE RULES CHECKLIST 1. Obviously correct and tested? **PASS** — TRM + vendor kernel + Pengutronix RK3588 testing 2. Fixes a real bug affecting users? **PASS** — IOMMU hang, black screen on production hardware 3. Important issue? **PASS** — CRITICAL (hang, display failure) 4. Small and contained? **PASS** — 8 lines, one function 5. No new features or APIs? **PASS** — register workaround only 6. Can apply to local tree? **PASS** — clean apply verified ### Step 9.3: EXCEPTION CATEGORIES **Record:** **Hardware quirk/workaround** — qualifies under stable exception rules. ### Step 9.4: DECISION RATIONALE For **Linux 6.18.44**, Rockchip IOMMU users on RK3568, RK3588, and RV1126 platforms are exposed to a silicon bug where the IOMMU can enter a blocked state during normal page-table maintenance, causing peripheral hangs and display black screens. The fix is a minimal, vendor-validated register write that matches TRM documentation. It applies cleanly, has maintainer ack, and fixes a serious user-visible failure on hardware well-supported in this tree. --- ## Verification - [Phase 1] Parsed commit `8d4346ecd4950`: subject, body, tags (Acked-by Heiko Stuebner; no Fixes/stable/syzbot) - [Phase 2] Diff analysis: +8 lines in `rk_iommu_enable()`, adds BIT(31) write to `RK_MMU_AUTO_GATING` - [Phase 3] `git blame`: `rk_iommu_enable()` from 2014; `RK_MMU_AUTO_GATING` from original 2014 driver - [Phase 3] No Fixes: tag to follow - [Phase 3] Related commit `62e062a29ad51` (different bug) already in tree; this fix is not - [Phase 3] `git format-patch` + `git apply --check`: applies cleanly - [Phase 3] Commit on `master` but not on current `stable/linux-6.18.y` HEAD - [Phase 4] `b4 dig -c 8d4346ecd4950`: lore thread found - [Phase 4] `b4 dig -a`: v1 submission 2025-11-26; committed 2026-06-02 - [Phase 4] `b4 dig -w`: Joerg Roedel, Heiko Stuebner, Robin Murphy CC'd - [Phase 4] Mbox: Pengutronix confirmed RK3588 RGA3 hangs; Shawn Lin comment-only TRM note; Heiko suggested resend; no NAKs, no stable nomination - [Phase 5] Callers: `rk_iommu_attach_device()` (line 1043), `rk_iommu_resume()` (line 1330) - [Phase 5] IOTLB zap path: `rk_iommu_zap_iova()` used from map/unmap — confirms concurrent zap mechanism - [Phase 6] `git describe HEAD`: v6.18.44; `make kernelversion`: 6.18.44 - [Phase 6] Buggy code confirmed present: no `DISABLE_FETCH_DTE_TIME_LIMIT` in tree - [Phase 6] DT: `rv1126.dtsi`, `rk356x-base.dtsi`, `rk3588-base.dtsi` have IOMMU nodes - [Phase 6] `rk3568-iommu` support since 2021 (`c55356c534aa6`), in tree - [Phase 7] `CONFIG_ROCKCHIP_IOMMU=y` in arm64 defconfig - [Phase 8] Failure mode: IOMMU block → hang/black screen, severity CRITICAL **YES**The background search on `master` found the commit: **`8d4346ecd4950`** — `iommu/rockchip: disable fetch dte time limit`. **Summary:** This is an 8-line hardware workaround for Rockchip IOMMU silicon (RK3568, RK3588, RV1126). Without setting BIT(31) of `RK_MMU_AUTO_GATING`, the IOMMU can block during concurrent DTE fetch and IOTLB zaps, causing peripheral hangs and VOP black screens. The patch applies cleanly to the local **6.18.44** tree, where the buggy code is still present. **YES** drivers/iommu/rockchip-iommu.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/drivers/iommu/rockchip-iommu.c b/drivers/iommu/rockchip-iommu.c index 0861dd469bd86..2d0dabb0d101a 100644 --- a/drivers/iommu/rockchip-iommu.c +++ b/drivers/iommu/rockchip-iommu.c @@ -76,6 +76,8 @@ #define SPAGE_ORDER 12 #define SPAGE_SIZE (1 << SPAGE_ORDER) +#define DISABLE_FETCH_DTE_TIME_LIMIT BIT(31) + /* * Support mapping any size that fits in one page table: * 4 KiB to 4 MiB @@ -930,6 +932,7 @@ static int rk_iommu_enable(struct rk_iommu *iommu) struct iommu_domain *domain = iommu->domain; struct rk_iommu_domain *rk_domain = to_rk_domain(domain); int ret, i; + u32 auto_gate; ret = clk_bulk_enable(iommu->num_clocks, iommu->clocks); if (ret) @@ -948,6 +951,11 @@ static int rk_iommu_enable(struct rk_iommu *iommu) rk_ops->mk_dtentries(rk_domain->dt_dma)); rk_iommu_base_command(iommu->bases[i], RK_MMU_CMD_ZAP_CACHE); rk_iommu_write(iommu->bases[i], RK_MMU_INT_MASK, RK_MMU_IRQ_MASK); + + /* Workaround for iommu blocked, BIT(31) default to 1 */ + auto_gate = rk_iommu_read(iommu->bases[i], RK_MMU_AUTO_GATING); + auto_gate |= DISABLE_FETCH_DTE_TIME_LIMIT; + rk_iommu_write(iommu->bases[i], RK_MMU_AUTO_GATING, auto_gate); } ret = rk_iommu_enable_paging(iommu); -- 2.53.0 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 48831C624C6 for ; Mon, 31 Aug 2026 13:38: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:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=HnbS5Npzw/5czsv5xaazv8UVMNKBdWH3JItU7TrVIL4=; b=2upQUKpHmKneNF lK1/VT+UnP2ifJoOh85b7KJwikFXXwJJz00vmIGmQIyPZZRcZCi+qMNnvhAtqodrRAnEHju/gdq6t lkyjW007SQWblP8s8LCgckMYj9yvac0QpfwQ5/9/aPJmXoRYaQhFZjJQ4cRIh0yAI7rW23imOOa88 k45GWBBXa4isaeGe79GqTfhgp9YJe9TGY8A0gIc5zDos8MeYL6w2+7r5wsqz4kli4bMa8Kd5AF/Uh 30ZO3ZLZibLHXQckSjlzRMdBwAjuaOzB20O+SHF1PU0G4ChsmS5Yv41dAvgjl/claXx+XUH4L2Ivu RTgfclWjvnSomHih5vJA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1x12Di-00000009Rq6-3HsS; Mon, 31 Aug 2026 13:38:42 +0000 Received: from tor.source.kernel.org ([2600:3c04:e001:324:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1x12Dh-00000009RpJ-1Kx3; Mon, 31 Aug 2026 13:38:41 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id 8C3B360234; Mon, 31 Aug 2026 13:38:40 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id E40FE1F00A3E; Mon, 31 Aug 2026 13:38:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788183520; bh=xG2t2y2lKLQXDUfdvcxJHobwIOaB1uVKJu1HoXcWyes=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=A4Tk7qT/W9BYLhBZAo4JFJUDq9oD4147ZGoZ7tU3TacdSSo3qs6kTsgLTQXh6Xx9x 41FTjliOOiS4As+vtRtfoELJgaUmMtvhd4/0hQ+Nf2uVT8NE7u7U6R950fqXzvkz9I ZaDlFJrfzqH3RA3S2uvw7NlhqrpKc+0IOypxS2/gxTgCDqmmY49+MzJe6t2E+E3FEG OPbS3/u14fd1eUQQGxMk47f6+rjQ45KuGXzx+LrPFR3ecAZhvIVj9CE7BeSZO5q4CA xKAyWVn3maNB/3CG3qMozpEX46xnucMr3iHb3gqf+pvR84n8z3PDywRzqZXZ+frN3B 5ONnXEit+3mjw== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: Simon Xue , =?UTF-8?q?Sven=20P=C3=BCschel?= , Heiko Stuebner , Joerg Roedel , Sasha Levin , joro@8bytes.org, will@kernel.org, iommu@lists.linux.dev, linux-arm-kernel@lists.infradead.org, linux-rockchip@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 6.18-5.10] iommu/rockchip: disable fetch dte time limit Date: Mon, 31 Aug 2026 09:22:53 -0400 Message-ID: <20260831133314.4125787-145-sashal@kernel.org> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260831133314.4125787-1-sashal@kernel.org> References: <20260831133314.4125787-1-sashal@kernel.org> MIME-Version: 1.0 X-stable: review X-Patchwork-Hint: Ignore X-stable-base: Linux 6.18.48 X-BeenThere: linux-rockchip@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Upstream kernel work for Rockchip platforms List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+linux-rockchip=archiver.kernel.org@lists.infradead.org RnJvbTogU2ltb24gWHVlIDx4eG1Acm9jay1jaGlwcy5jb20+CgpbIFVwc3RyZWFtIGNvbW1pdCA4 ZDQzNDZlY2Q0OTUwYWUwOGNjNzZhNmRlMzI3YzI2NGU4NDY3NThjIF0KCkRpc2FibGUgdGhlIEJp dCAzMSBvZiB0aGUgQVVUT19HQVRJTkcgaW9tbXUgcmVnaXN0ZXIsIGFzIGl0IGNhdXNlcwpoYW5n dXBzIHdpdGggdGhlIFJHQTMgKFJhc3RlciBHcmFwaGljcyBBY2NlbGVyYXRpb24gMykgcGVyaXBo ZXJhbC4KVGhlIFJHQTMgcmVnaXN0ZXIgZGVzY3JpcHRpb24gb2YgdGhlIFRSTSBhbHJlYWR5IHN0 YXRlcyB0aGF0IHRoZSBiaXQKbXVzdCBiZSBzZXQgdG8gMS4gVGhlIHZlbmRvciBrZXJuZWwgc2V0 cyB0aGUgYml0IHVuY29uZGl0aW9uYWxseSB0bwoxIHRvIGZpeCBWT1AgKFZpZGVvIE91dHB1dCBQ cm9jZXNzb3IpIHNjcmVlbiBibGFjayBpc3N1ZXMuIFRoaXMgcGF0Y2gKc3F1YXNoZXMgdGhlIDIg dmVuZG9yIGtlcm5lbCBjb21taXRzIHdpdGggdGhlIGZvbGxvd2luZyBjb21taXQgbWVzc2FnZXM6 CgpNYXN0ZXIgZmV0Y2ggZGF0YSBhbmQgY3B1IHVwZGF0ZSBwYWdlIHRhYmxlIG1heSB3b3JrIGlu IHBhcmFsbGVsLCBtYXkKaGF2ZSB0aGUgZm9sbG93aW5nIHByb2NlZHVyZToKCgltYXN0ZXIgICAg ICAgICAgICAgICAgICBjcHUKCWZldGNoIGR0ZSAgICAgICAgICAgICAgIHVwZGF0ZSBwYWdlIHRh YmwKCSAgICAgICAgfCAgICAgICAgICAgICAgICAgICAgICAgfAoJKG1ha2UgZHRlIGludmFsaWQp ICA8LSAgemFwIGlvdGxiIGVudHJ5CgkgICAgICAgIHwgICAgICAgICAgICAgICAgICAgICAgIHwK CWZldGNoIGR0ZSBhZ2FpbgoJKG1ha2UgZHRlIGludmFsaWQpICA8LSAgemFwIGlvdGxiIGVudHJ5 CgkgICAgICAgIHwgICAgICAgICAgICAgICAgICAgICAgIHwKCWZldGNoIGR0ZSBhZ2FpbgoJKG1h a2UgZHRlIGludmFsaWQpICA8LSAgemFwIGlvdGxiIGVudHJ5CgkgICAgICAgIHwgICAgICAgICAg ICAgICAgICAgICAgIHwKCWZldGNoIGR0ZSBhZ2FpbgoJKG1ha2UgaW9tbXUgYmxvY2spICA8LSAg emFwIGlvdGxiIGVudHJ5CgpOZXcgaW9tbXUgdmVyc2lvbiBoYXMgdGhlIGFib3ZlIGJ1ZywgaWYg ZmV0Y2ggZHRlIGNvbnNlY3V0aXZlbHkgZm91cgp0aW1lcywgdGhlbiBpdCB3aWxsIGJlIGJsb2Nr ZWQuIEZvcnR1bmF0ZWx5LCB3ZSBjYW4gc2V0IGJpdCAzMSBvZgpyZWdpc3RlciBNTVVfQVVUT19H QVRJTkcgdG8gMSB0byBtYWtlIGl0IHdvcmsgYXMgb2xkIHZlcnNpb24gd2hpY2ggZG9lcwpub3Qg aGF2ZSB0aGlzIGlzc3VlLgoKVGhpcyBpc3N1ZSBvbmx5IGFwcGVhcnMgb24gUlYxMTI2IHNvIGZh ciwgc28gbWFrZSBhIHdvcmthcm91bmQgZGVkaWNhdGVkCnRvICJyb2NrY2hpcCxydjExMjYiIG1h Y2hpbmUgdHlwZS4KCmlvbW11L3JvY2tjaGlwOiBmaXggdm9wIGJsb2NrZWQgYW5kIHNjcmVlbiBi bGFjayBvbiBSSzM1NlggYW5kIFJLMzU4OAoKUkszNTY4IGFuZCBSSzM1ODggaGFzIHRoZSBzYW1l IGlzc3VlIGFzIFJWMTEyNi9SVjExMDkgdGhhdCBjYXVzZWQgYnkKZHRlIGZldGNoIHRpbWUgbGlt aXQsIFNvIHdlIGNhbiBzZXQgQklUKDMxKSBvZiByZWdpc3RlciAweDI0IGRlZmF1bHQKdG8gMSBh cyBhIHdvcmthcm91bmQuCgpTaWduZWQtb2ZmLWJ5OiBTaW1vbiBYdWUgPHh4bUByb2NrLWNoaXBz LmNvbT4KU2lnbmVkLW9mZi1ieTogU3ZlbiBQw7xzY2hlbCA8cy5wdWVzY2hlbEBwZW5ndXRyb25p eC5kZT4KQWNrZWQtYnk6IEhlaWtvIFN0dWVibmVyIDxoZWlrb0BzbnRlY2guZGU+ClNpZ25lZC1v ZmYtYnk6IEpvZXJnIFJvZWRlbCA8am9lcmcucm9lZGVsQGFtZC5jb20+ClNpZ25lZC1vZmYtYnk6 IFNhc2hhIExldmluIDxzYXNoYWxAa2VybmVsLm9yZz4KLS0tCgpMTE0gR2VuZXJhdGVkIGV4cGxh bmF0aW9ucywgbWF5IGJlIGNvbXBsZXRlbHkgYm9ndXM6CgojIyBQSEFTRSAxOiBDT01NSVQgTUVT U0FHRSBGT1JFTlNJQ1MKCiMjIyBTdGVwIDEuMTogUEFSU0UgVEhFIFNVQkpFQ1QgTElORQoqKlJl Y29yZDoqKiBgW2lvbW11L3JvY2tjaGlwXWAgYFtkaXNhYmxlXWAg4oCUIERpc2FibGUgdGhlIGZl dGNoLURURSB0aW1lLQpsaW1pdCBoYXJkd2FyZSBiZWhhdmlvciBpbiB0aGUgUm9ja2NoaXAgSU9N TVUgQVVUT19HQVRJTkcgcmVnaXN0ZXIKKEJJVCgzMSkpLgoKIyMjIFN0ZXAgMS4yOiBQQVJTRSBB TEwgQ09NTUlUIE1FU1NBR0UgVEFHUwoqKlJlY29yZDoqKgotICoqRml4ZXM6Kiog4oCUIG5vdCBw cmVzZW50IChleHBlY3RlZCBmb3IgbWFudWFsIHJldmlldykKLSAqKlJlcG9ydGVkLWJ5OioqIOKA lCBub25lCi0gKipUZXN0ZWQtYnk6Kiog4oCUIG5vbmUKLSAqKlJldmlld2VkLWJ5OioqIOKAlCBu b25lCi0gKipBY2tlZC1ieToqKiBIZWlrbyBTdHVlYm5lciBgPGhlaWtvQHNudGVjaC5kZT5gIChS b2NrY2hpcCBtYWludGFpbmVyKQotICoqTGluazoqKiDigJQgbm9uZSBpbiBjb21taXQgKHN1Ym1p c3Npb24gdGhyZWFkIHJlZmVyZW5jZXMgdmVuZG9yCiAgY29tbWl0cyBhbmQgUkdBMyBkcml2ZXIg c2VyaWVzKQotICoqQ2M6IHN0YWJsZToqKiDigJQgbm90IHByZXNlbnQgKGV4cGVjdGVkKQotICoq U2lnbmVkLW9mZi1ieToqKiBTaW1vbiBYdWUsIFN2ZW4gUMO8c2NoZWwsIEpvZXJnIFJvZWRlbCAo aWdub3JlCiAgcGlwZWxpbmUtYWRkZWQgU09CcykKLSAqKk5vdGFibGU6KiogQWNrIGZyb20gc3Vi c3lzdGVtIG1haW50YWluZXI7IG5vIHN5emJvdC9mdXp6ZXIKICBpbnZvbHZlbWVudAoKIyMjIFN0 ZXAgMS4zOiBBTkFMWVpFIFRIRSBDT01NSVQgQk9EWSBURVhUCioqUmVjb3JkOioqCi0gKipCdWcg ZGVzY3JpcHRpb246KiogTmV3ZXIgUm9ja2NoaXAgSU9NTVUgaGFyZHdhcmUgaGFzIGEgRFRFLWZl dGNoCiAgdGltZSBsaW1pdC4gV2hlbiBhIG1hc3RlciByZS1mZXRjaGVzIERURSBmb3VyIHRpbWVz IHdoaWxlIHRoZSBDUFUKICBjb25jdXJyZW50bHkgemFwcyBJT1RMQiBlbnRyaWVzIChkdXJpbmcg cGFnZS10YWJsZSB1cGRhdGVzKSwgdGhlIElPTU1VCiAgZW50ZXJzIGEgYmxvY2tlZCBzdGF0ZS4K LSAqKlN5bXB0b20vZmFpbHVyZSBtb2RlOioqIElPTU1VIGhhbmcvYmxvY2sg4oaSIFJHQTMgcGVy aXBoZXJhbCBoYW5ndXBzLAogIFZPUCAoZGlzcGxheSkgYmxvY2tlZCB3aXRoIGJsYWNrIHNjcmVl bi4KLSAqKkFmZmVjdGVkIGhhcmR3YXJlOioqIFJWMTEyNi9SVjExMDksIFJLMzU2OCwgUkszNTg4 IChjb21taXQgbWVzc2FnZQogIGFsc28gbWVudGlvbnMgUkszNTZYIGJyb2FkbHkpLgotICoqUm9v dCBjYXVzZToqKiBCSVQoMzEpIG9mIGBSS19NTVVfQVVUT19HQVRJTkdgIChvZmZzZXQgMHgyNCkg ZGVmYXVsdHMKICB0byAwIG9uIGFmZmVjdGVkIHNpbGljb247IFRSTSBzYXlzIGl0IG11c3QgYmUg MS4gVmVuZG9yIGtlcm5lbCBzZXRzIGl0CiAgdW5jb25kaXRpb25hbGx5LgotICoqVmVyc2lvbiBp bmZvOioqIE5vdCB0aWVkIHRvIGEgc3BlY2lmaWMga2VybmVsIHZlcnNpb247IHRoaXMgaXMgYQog IHNpbGljb24vaGFyZHdhcmUgYmVoYXZpb3IgaXNzdWUuCgojIyMgU3RlcCAxLjQ6IERFVEVDVCBI SURERU4gQlVHIEZJWEVTCioqUmVjb3JkOioqIE5vdCBkaXNndWlzZWQg4oCUIHRoaXMgaXMgYW4g ZXhwbGljaXQgaGFyZHdhcmUgd29ya2Fyb3VuZC4KRGVzcGl0ZSAiZGlzYWJsZSIgd29yZGluZyBp biB0aGUgc3ViamVjdCwgdGhlIGZpeCAqKnNldHMqKiBCSVQoMzEpIHRvCmRpc2FibGUgdGhlIGZh dWx0eSB0aW1lLWxpbWl0IGZlYXR1cmUuIFRoaXMgaXMgYSBjbGFzc2ljIGhhcmR3YXJlCnF1aXJr L3dvcmthcm91bmQsIG5vdCBhIGNvc21ldGljIGNsZWFudXAuCgotLS0KCiMjIFBIQVNFIDI6IERJ RkYgQU5BTFlTSVMKCiMjIyBTdGVwIDIuMTogSU5WRU5UT1JZIFRIRSBDSEFOR0VTCioqUmVjb3Jk OioqCi0gKipGaWxlczoqKiBgZHJpdmVycy9pb21tdS9yb2NrY2hpcC1pb21tdS5jYCAoKzggbGlu ZXMsIDAgcmVtb3ZlZCkKLSAqKkZ1bmN0aW9ucyBtb2RpZmllZDoqKiBgcmtfaW9tbXVfZW5hYmxl KClgIG9ubHkKLSAqKlNjb3BlOioqIFNpbmdsZS1maWxlLCBzdXJnaWNhbCBmaXgKCiMjIyBTdGVw IDIuMjogVU5ERVJTVEFORCBUSEUgQ09ERSBGTE9XIENIQU5HRQoqKlJlY29yZDoqKgotICoqSHVu ayAxIChkZWZpbmUpOioqIEFkZHMgYCNkZWZpbmUgRElTQUJMRV9GRVRDSF9EVEVfVElNRV9MSU1J VAogIEJJVCgzMSlgLgotICoqSHVuayAyIChgcmtfaW9tbXVfZW5hYmxlYCk6KioKICAtICoqQmVm b3JlOioqIEFmdGVyIHdyaXRpbmcgRFRFIGFkZHJlc3MsIFpBUCBjYWNoZSwgYW5kIElSUSBtYXNr LAogICAgcHJvY2VlZHMgZGlyZWN0bHkgdG8gZW5hYmxlIHBhZ2luZy4KICAtICoqQWZ0ZXI6Kiog UmVhZHMgYFJLX01NVV9BVVRPX0dBVElOR2AsIE9ScyBpbiBCSVQoMzEpLCB3cml0ZXMgaXQKICAg IGJhY2sg4oCUIGZvciBlYWNoIE1NVSBpbnN0YW5jZS4KICAtICoqQWZmZWN0ZWQgcGF0aDoqKiBJ T01NVSBlbmFibGUgZHVyaW5nIGRldmljZSBhdHRhY2ggYW5kCiAgICBzeXN0ZW0vcnVudGltZSBy ZXN1bWUuCgojIyMgU3RlcCAyLjM6IElERU5USUZZIFRIRSBCVUcgTUVDSEFOSVNNCioqUmVjb3Jk OioqCi0gKipCdWcgY2F0ZWdvcnk6KiogSGFyZHdhcmUgd29ya2Fyb3VuZCAvIGxvZ2ljIGNvcnJl Y3RuZXNzIGZpeAotICoqTWVjaGFuaXNtOioqIFdpdGhvdXQgQklUKDMxKT0xLCBjb25jdXJyZW50 IERURSBmZXRjaCArIElPVExCIHphcCBjYW4KICB0cmlnZ2VyIGEgc2lsaWNvbiBidWcgYWZ0ZXIg Zm91ciBjb25zZWN1dGl2ZSBEVEUgZmV0Y2hlcywgcGVybWFuZW50bHkKICBibG9ja2luZyB0aGUg SU9NTVUuIFNldHRpbmcgQklUKDMxKSByZXN0b3JlcyBsZWdhY3kgKG5vbi1idWdneSkKICBiZWhh dmlvci4KCiMjIyBTdGVwIDIuNDogQVNTRVNTIFRIRSBGSVggUVVBTElUWQoqKlJlY29yZDoqKgot ICoqUXVhbGl0eToqKiBPYnZpb3VzbHkgY29ycmVjdCDigJQgcmVhZC1tb2RpZnktd3JpdGUgcHJl c2VydmVzIG90aGVyCiAgQVVUT19HQVRJTkcgYml0czsgbWF0Y2hlcyB2ZW5kb3Iga2VybmVsIGFu ZCBUUk0gZ3VpZGFuY2UuCi0gKipSZWdyZXNzaW9uIHJpc2s6KiogVmVyeSBsb3cuIFZlbmRvciBz ZXRzIHVuY29uZGl0aW9uYWxseSBvbiBhbGwKICBhZmZlY3RlZCBwbGF0Zm9ybXM7IGJpdCBpcyBk b2N1bWVudGVkIGFzIHNob3VsZC1iZS0xLgotICoqUmVkIGZsYWdzOioqIENvbW1pdCBtZXNzYWdl IHN0aWxsIG1lbnRpb25zIFJWMTEyNi1vbmx5IHdvcmthcm91bmQsCiAgYnV0IGNvZGUgYXBwbGll cyB1bmNvbmRpdGlvbmFsbHkgKGludGVudGlvbmFsIHBlciB2ZW5kb3IgcHJhY3RpY2UgYW5kCiAg UkszNTY4L1JLMzU4OCBuZWVkKS4KCi0tLQoKIyMgUEhBU0UgMzogR0lUIEhJU1RPUlkgSU5WRVNU SUdBVElPTgoKIyMjIFN0ZXAgMy4xOiBCTEFNRSBUSEUgQ0hBTkdFRCBMSU5FUwoqKlJlY29yZDoq KiBgcmtfaW9tbXVfZW5hYmxlKClgIGNvcmUgbG9naWMgZGF0ZXMgdG8gMjAxNCAoRGFuaWVsIEt1 cnR6KS4KYFJLX01NVV9BVVRPX0dBVElOR2AgZGVmaW5lZCBzaW5jZSBvcmlnaW5hbCBkcml2ZXIg KDIwMTQsCmBjNjhhMjkyMTUyZDMyYCkuIFRoZSAqKm1pc3Npbmcgd29ya2Fyb3VuZCoqIGhhcyBi ZWVuIHByZXNlbnQgc2luY2UgdGhlCmRyaXZlcidzIGludHJvZHVjdGlvbiDigJQgbm90IGEgcmVj ZW50IHJlZ3Jlc3Npb24uCgojIyMgU3RlcCAzLjI6IEZPTExPVyBUSEUgRklYRVM6IFRBRwoqKlJl Y29yZDoqKiBObyBgRml4ZXM6YCB0YWcuIE5vdCBhcHBsaWNhYmxlIOKAlCB0aGlzIGlzIGEgaGFy ZHdhcmUgc2lsaWNvbgpidWcsIG5vdCBhIGNvbW1pdC1pbnRyb2R1Y2VkIHJlZ3Jlc3Npb24uCgoj IyMgU3RlcCAzLjM6IENIRUNLIEZJTEUgSElTVE9SWSBGT1IgUkVMQVRFRCBDSEFOR0VTCioqUmVj b3JkOioqCi0gUmVjZW50IHJlbGF0ZWQgZml4IGFscmVhZHkgaW4gdHJlZTogYDYyZTA2MmEyOWFk NTFgIOKAlCAicHJldmVudCBpb21tdXMKICBkZWFkIGxvb3Agd2hlbiB0d28gbWFzdGVycyBzaGFy ZSBvbmUgSU9NTVUiIChkaWZmZXJlbnQgYnVnLCBoYXMgYENjOgogIHN0YWJsZWApLgotIGByazM1 NjgtaW9tbXVgIHYyIHN1cHBvcnQgYWRkZWQgaW4gYGM1NTM1NmM1MzRhYTZgICgyMDIxKSwgcHJl c2VudCBpbgogIHRoaXMgdHJlZS4KLSBUaGlzIGZpeCBpcyAqKnN0YW5kYWxvbmUqKiDigJQgbm90 IHBhcnQgb2YgYSBtdWx0aS1wYXRjaCBzZXJpZXMKICByZXF1aXJpbmcgcHJlcmVxdWlzaXRlcy4K LSBPbiBgbWFzdGVyYCwgdGhpcyBjb21taXQgKGA4ZDQzNDZlY2Q0OTUwYCkgaXMgYWhlYWQgb2YK ICBgc3RhYmxlL2xpbnV4LTYuMTgueWAuCgojIyMgU3RlcCAzLjQ6IENIRUNLIFRIRSBBVVRIT1In UyBPVEhFUiBDT01NSVRTCioqUmVjb3JkOioqIFNpbW9uIFh1ZSBpcyBhbiBhY3RpdmUgUm9ja2No aXAgSU9NTVUgY29udHJpYnV0b3IgKG11bHRpLWlycQpzdXBwb3J0LCBkZWFkLWxvb3AgZml4LCBJ U1AgcmVzZXQgaGFuZGxpbmcpLiBTdmVuIFDDvHNjaGVsIChQZW5ndXRyb25peCkKc3VibWl0dGVk IGFuZCB0ZXN0ZWQgb24gUkszNTg4IFJHQTMuCgojIyMgU3RlcCAzLjU6IENIRUNLIEZPUiBERVBF TkRFTlQvUFJFUkVRVUlTSVRFIENPTU1JVFMKKipSZWNvcmQ6KiogTm8gZGVwZW5kZW5jaWVzLiBQ YXRjaCBhcHBsaWVzIGNsZWFubHkgKGBnaXQgYXBwbHkgLS1jaGVja2AKc3VjY2VlZGVkKS4gTm8g bmV3IHN0cnVjdHVyZXMsIEFQSXMsIG9yIGhlbHBlciBmdW5jdGlvbnMgcmVxdWlyZWQuCgotLS0K CiMjIFBIQVNFIDQ6IE1BSUxJTkcgTElTVCBBTkQgRVhURVJOQUwgUkVTRUFSQ0gKCiMjIyBTdGVw IDQuMTogRklORCBUSEUgT1JJR0lOQUwgUEFUQ0ggRElTQ1VTU0lPTgoqKlJlY29yZDoqKgotICoq TG9yZSBVUkw6KiogaHR0cHM6Ly9wYXRjaC5tc2dpZC5saW5rLzIwMjUxMTI2LXNwdS0KICBpb21t dWR0ZWZpeC12MS0xLWY5MDAwM2RiZmNjNEBwZW5ndXRyb25peC5kZQotICoqU2VyaWVzIHJldmlz aW9uczoqKiB2MSBzdWJtaXR0ZWQgMjAyNS0xMS0yNjsgYXV0aG9yIHBpbmdlZAogIDIwMjYtMDQt Mjg7IEhlaWtvIFN0dWVibmVyIHN1Z2dlc3RlZCByZXNlbmQvdjIgZHVlIHRvIGFnZTsgY29tbWl0 dGVkCiAgYXMtaXMgb24gbWFpbmxpbmUgMjAyNi0wNi0wMi4KLSAqKlJldmlld2VyIGZlZWRiYWNr OioqIFNoYXduIExpbiAoUm9ja2NoaXApIG5vdGVkIFRSTSBvZmZzZXQKICBjbGFyaWZpY2F0aW9u IChSR0EzLXNwZWNpZmljIG9mZnNldCB2cyBnZW5lcmFsIElPTU1VIDB4MjQpIOKAlCBjb21tZW50 LQogIG9ubHksIG5vIGNvZGUgb2JqZWN0aW9uLgotICoqU3RhYmxlIG5vbWluYXRpb25zOioqIE5v bmUgZm91bmQgaW4gdGhyZWFkLgotICoqTkFLczoqKiBOb25lLgoKIyMjIFN0ZXAgNC4yOiBDSEVD SyBXSE8gUkVWSUVXRUQgVEhFIFBBVENICioqUmVjb3JkOioqIENDJ2Q6IEpvZXJnIFJvZWRlbCwg V2lsbCBEZWFjb24sIFJvYmluIE11cnBoeSwgSGVpa28KU3R1ZWJuZXIsIGlvbW11QCwgbGludXgt YXJtLWtlcm5lbEAsIGxpbnV4LXJvY2tjaGlwQC4gSGVpa28gU3R1ZWJuZXIKQWNrZWQtYnkgaW4g ZmluYWwgY29tbWl0LgoKIyMjIFN0ZXAgNC4zOiBTRUFSQ0ggRk9SIFRIRSBCVUcgUkVQT1JUCioq UmVjb3JkOioqIFJlYWwtd29ybGQgdHJpZ2dlciBkb2N1bWVudGVkIGJ5IFBlbmd1dHJvbml4IOKA lCBzcG9yYWRpYyBSR0EzCmhhbmdzIG9uIFJLMzU4OCBkdXJpbmcgZHJpdmVyIGRldmVsb3BtZW50 LiBWZW5kb3Iga2VybmVsIGNvbW1pdHMgWzJdWzNdCmRvY3VtZW50IFZPUCBibGFjay1zY3JlZW4g aXNzdWVzLiBObyBzeXpib3QvYnVnemlsbGEgcmVwb3J0LgoKIyMjIFN0ZXAgNC40OiBDSEVDSyBG T1IgUkVMQVRFRCBQQVRDSEVTIEFORCBTRVJJRVMKKipSZWNvcmQ6KiogUmVsYXRlZCBidXQgaW5k ZXBlbmRlbnQ6IFJHQTMgdXBzdHJlYW0gZHJpdmVyIHNlcmllcyAodjUsCjIwMjYtMDQtMjgpIGRl cGVuZHMgb24gdGhpcyBJT01NVSBmaXguIFRoZSBJT01NVSBmaXggc3RhbmRzIGFsb25lIGFuZCBp cwpub3QgYSAicHJlcGFyYXRpb24iIGNvbW1pdC4KCiMjIyBTdGVwIDQuNTogQ0hFQ0sgU1RBQkxF IE1BSUxJTkcgTElTVCBISVNUT1JZCioqUmVjb3JkOioqIE5vIHN0YWJsZS1saXN0IGRpc2N1c3Np b24gZm91bmQgZm9yIHRoaXMgc3BlY2lmaWMgZml4LiAoTG9yZQpkaXJlY3QgZmV0Y2ggYmxvY2tl ZCBieSBib3QgcHJvdGVjdGlvbjsgYW5hbHlzaXMgdmlhIGBiNCBkaWcgLW1gIG1ib3gKZG93bmxv YWQuKQoKLS0tCgojIyBQSEFTRSA1OiBDT0RFIFNFTUFOVElDIEFOQUxZU0lTCgojIyMgU3RlcCA1 LjE6IElERU5USUZZIEtFWSBGVU5DVElPTlMgSU4gVEhFIERJRkYKKipSZWNvcmQ6KiogYHJrX2lv bW11X2VuYWJsZSgpYCDigJQgb25seSBmdW5jdGlvbiBtb2RpZmllZC4KCiMjIyBTdGVwIDUuMjog VFJBQ0UgQ0FMTEVSUwoqKlJlY29yZDoqKgotIGBya19pb21tdV9hdHRhY2hfZGV2aWNlKClgIOKG kiBgcmtfaW9tbXVfZW5hYmxlKClgIChsaW5lIDEwNDMpIOKAlCBjYWxsZWQKICB3aGVuIGEgZGV2 aWNlIGF0dGFjaGVzIHRvIGFuIElPTU1VIGRvbWFpbiAoZS5nLiwgVk9QLCBSR0EsIE5QVSkuCi0g YHJrX2lvbW11X3Jlc3VtZSgpYCDihpIgYHJrX2lvbW11X2VuYWJsZSgpYCAobGluZSAxMzMwKSDi gJQgY2FsbGVkIG9uIFBNCiAgcmVzdW1lLgotIEJvdGggYXJlIGNvbW1vbiwgdXNlci12aXNpYmxl IHBhdGhzIG9uIFJvY2tjaGlwIGJvYXJkcy4KCiMjIyBTdGVwIDUuMzogVFJBQ0UgQ0FMTEVFUwoq KlJlY29yZDoqKiBVc2VzIGV4aXN0aW5nIGBya19pb21tdV9yZWFkKClgIC8gYHJrX2lvbW11X3dy aXRlKClgCnJlZ2lzdGVyIGFjY2Vzc29ycywgcGx1cyBleGlzdGluZyBzdGFsbC9yZXNldC9wYWdp bmcgZW5hYmxlIHNlcXVlbmNlLiBObwpuZXcgZGVwZW5kZW5jaWVzLgoKIyMjIFN0ZXAgNS40OiBG T0xMT1cgVEhFIENBTEwgQ0hBSU4KKipSZWNvcmQ6KiogRGV2aWNlIHByb2JlIOKGkiBgaW9tbXVf YXR0YWNoX2RldmljZWAg4oaSCmBya19pb21tdV9hdHRhY2hfZGV2aWNlYCDihpIgYHJrX2lvbW11 X2VuYWJsZWAuIFRyaWdnZXJlZCBkdXJpbmcgbm9ybWFsCmdyYXBoaWNzL21lZGlhIGRyaXZlciBp bml0aWFsaXphdGlvbiBhbmQgc3VzcGVuZC9yZXN1bWUuICoqUmVhY2hhYmxlCmZyb20gdXNlcnNw YWNlKiogaW5kaXJlY3RseSB2aWEgZGV2aWNlIHVzYWdlIChkaXNwbGF5LCBHUFUsIFJHQQp3b3Jr bG9hZHMgY2F1c2luZyBJT1RMQiB6YXBzKS4KCiMjIyBTdGVwIDUuNTogU0VBUkNIIEZPUiBTSU1J TEFSIFBBVFRFUk5TCioqUmVjb3JkOioqIE5vIHNpbWlsYXIgd29ya2Fyb3VuZCBlbHNld2hlcmUg aW4gYHJvY2tjaGlwLWlvbW11LmNgLgpWZW5kb3Iga2VybmVsIHNldHMgdGhpcyBiaXQgdW5jb25k aXRpb25hbGx5IOKAlCBleHRlcm5hbCBjb25maXJtYXRpb24gb2YKdGhlIHBhdHRlcm4uCgotLS0K CiMjIFBIQVNFIDY6IENST1NTLVJFRkVSRU5DSU5HIEFHQUlOU1QgVEhFIExPQ0FMIFRSRUUKCiMj IyBTdGVwIDYuMTogRE9FUyBUSEUgQlVHR1kgQ09ERSBFWElTVCBJTiBUSElTIFRSRUU/CioqUmVj b3JkOioqICoqWUVTLioqIExvY2FsIHRyZWUgaXMgKipMaW51eCA2LjE4LjQ0KiogKGBnaXQgZGVz Y3JpYmUKSEVBRGAg4oaSIGB2Ni4xOC40NC0xLWdlZjRiZjYyYmNjZjNjYCkuIGBya19pb21tdV9l bmFibGUoKWAgYXQgbGluZXMKOTI44oCTOTYwIGxhY2tzIHRoZSBCSVQoMzEpIHdvcmthcm91bmQu IGBSS19NTVVfQVVUT19HQVRJTkdgIGlzIGRlZmluZWQgYXQKbGluZSA0Mi4gYERJU0FCTEVfRkVU Q0hfRFRFX1RJTUVfTElNSVRgIGlzICoqbm90KiogcHJlc2VudC4gQWZmZWN0ZWQgRFQKcGxhdGZv cm1zIGV4aXN0OiBgcnYxMTI2LmR0c2lgICh2MSBgcm9ja2NoaXAsaW9tbXVgKSwgYHJrMzU2eC1i YXNlLmR0c2lgCmFuZCBgcmszNTg4LWJhc2UuZHRzaWAgKHYyIGByb2NrY2hpcCxyazM1NjgtaW9t bXVgKS4KCiMjIyBTdGVwIDYuMjogQ0hFQ0sgRk9SIEJBQ0tQT1JUIENPTVBMSUNBVElPTlMKKipS ZWNvcmQ6KiogKipDbGVhbiBhcHBseSoqIOKAlCBgZ2l0IGZvcm1hdC1wYXRjaGAgKyBgZ2l0IGFw cGx5IC0tY2hlY2tgCnN1Y2NlZWRlZCB3aXRoIG5vIGNvbmZsaWN0cy4gTm8gcmVmYWN0b3Jpbmcg Y2h1cm4gaW4gYHJrX2lvbW11X2VuYWJsZSgpYApzaW5jZSA2LjE4IGJyYW5jaC4KCiMjIyBTdGVw IDYuMzogQ0hFQ0sgSUYgUkVMQVRFRCBGSVhFUyBBUkUgQUxSRUFEWSBIRVJFCioqUmVjb3JkOioq IFRoZSBkZWFkLWxvb3AgZml4IChgNjJlMDYyYTI5YWQ1MWApIGlzIHByZXNlbnQuIFRoaXMgRFRF CnRpbWUtbGltaXQgd29ya2Fyb3VuZCAoYDhkNDM0NmVjZDQ5NTBgKSBpcyAqKm5vdCoqIHByZXNl bnQgb24KYHN0YWJsZS9saW51eC02LjE4LnlgLgoKLS0tCgojIyBQSEFTRSA3OiBTVUJTWVNURU0g QU5EIE1BSU5UQUlORVIgQ09OVEVYVAoKIyMjIFN0ZXAgNy4xOiBJREVOVElGWSBUSEUgU1VCU1lT VEVNIEFORCBJVFMgQ1JJVElDQUxJVFkKKipSZWNvcmQ6KiogYGRyaXZlcnMvaW9tbXUvcm9ja2No aXAtaW9tbXUuY2Ag4oCUIElPTU1VIGRyaXZlciBmb3IgUm9ja2NoaXAKU29Dcy4gKipJTVBPUlRB TlQqKiBmb3IgQVJNL0FSTTY0IGVtYmVkZGVkIChkaXNwbGF5LCBtZWRpYSwgTlBVLCBJU1ApLgpg Q09ORklHX1JPQ0tDSElQX0lPTU1VPXlgIGluIGBhcmNoL2FybTY0L2NvbmZpZ3MvZGVmY29uZmln YC4KCiMjIyBTdGVwIDcuMjogQVNTRVNTIFNVQlNZU1RFTSBBQ1RJVklUWQoqKlJlY29yZDoqKiBB Y3RpdmVseSBtYWludGFpbmVkIOKAlCByZWNlbnQgZml4ZXMgaW4gNi4xNy82LjE4IG1lcmdlIHdp bmRvdwooZGVhZC1sb29wIGZpeCwgaW9tbXUtcGFnZXMgbWlncmF0aW9uKS4gUm9ja2NoaXAgcGxh dGZvcm1zIChSSzM1NjgsClJLMzU4OCkgYXJlIHdpZGVseSBkZXBsb3llZC4KCi0tLQoKIyMgUEhB U0UgODogSU1QQUNUIEFORCBSSVNLIEFTU0VTU01FTlQKCiMjIyBTdGVwIDguMTogREVURVJNSU5F IFdITyBJUyBBRkZFQ1RFRAoqKlJlY29yZDoqKiBVc2VycyBvZiBSb2NrY2hpcCBTb0NzIHdpdGgg SU9NTVUtZW5hYmxlZCBwZXJpcGhlcmFscyDigJQKKipwbGF0Zm9ybS1zcGVjaWZpYyoqIGJ1dCBj b3ZlcmluZyBwb3B1bGFyIGJvYXJkcyAoUkszNTY4LCBSSzM1ODgsClJWMTEyNikuIERpc3BsYXkg KFZPUCksIGdyYXBoaWNzIGFjY2VsZXJhdGlvbiAoUkdBMyksIGFuZCBvdGhlciBJT01NVS0KYmFj a2VkIG1hc3RlcnMuCgojIyMgU3RlcCA4LjI6IERFVEVSTUlORSBUSEUgVFJJR0dFUiBDT05ESVRJ T05TCioqUmVjb3JkOioqIENvbmN1cnJlbnQgSU9NTVUgbWFzdGVyIERURSBmZXRjaCArIENQVSBJ T1RMQiB6YXAgZHVyaW5nCnBhZ2UtdGFibGUgdXBkYXRlcy4gUmVhbGlzdGljIGR1cmluZyBncmFw aGljcy9tZWRpYSB3b3JrbG9hZHMgYW5kIGRyaXZlcgphY3Rpdml0eS4gTm90IGV2ZXJ5IGJvb3Qs IGJ1dCByZXByb2R1Y2libGUgdW5kZXIgbG9hZCAoUGVuZ3V0cm9uaXgKb2JzZXJ2ZWQgc3BvcmFk aWMgUkdBMyBoYW5ncykuCgojIyMgU3RlcCA4LjM6IERFVEVSTUlORSBUSEUgRkFJTFVSRSBNT0RF IFNFVkVSSVRZCioqUmVjb3JkOioqIElPTU1VIHBlcm1hbmVudCBibG9jayDihpIgKipDUklUSUNB TCoqIHN5c3RlbSBoYW5nIGZvcgphZmZlY3RlZCBwZXJpcGhlcmFsczsgVk9QIGJsYWNrIHNjcmVl biAoZGlzcGxheSB1bnVzYWJsZSk7IHBvdGVudGlhbApzb2Z0IGxvY2t1cCBvZiBkZXBlbmRlbnQg c3Vic3lzdGVtcy4KCiMjIyBTdGVwIDguNDogQ0FMQ1VMQVRFIFJJU0stQkVORUZJVCBSQVRJTwoq KlJlY29yZDoqKgotICoqQmVuZWZpdDoqKiBISUdIIOKAlCBwcmV2ZW50cyBoYXJkd2FyZSBJT01N VSBsb2NrdXAgYW5kCiAgZGlzcGxheS9wZXJpcGhlcmFsIGhhbmdzIG9uIHdpZGVseSB1c2VkIFNv Q3MuCi0gKipSaXNrOioqIFZFUlkgTE9XIOKAlCA4LWxpbmUgcmVnaXN0ZXIgd3JpdGUgbWF0Y2hp bmcgdmVuZG9yIGtlcm5lbCBhbmQKICBUUk07IHJlYWQtbW9kaWZ5LXdyaXRlIHByZXNlcnZlcyBv dGhlciBiaXRzLgotICoqUmF0aW86KiogU3Ryb25nbHkgZmF2b3JzIGJhY2twb3J0LgoKLS0tCgoj IyBQSEFTRSA5OiBGSU5BTCBTWU5USEVTSVMKCiMjIyBTdGVwIDkuMTogQ09NUElMRSBUSEUgRVZJ REVOQ0UKCioqRk9SIGJhY2twb3J0aW5nOioqCi0gUmVhbCBoYXJkd2FyZSBidWcgd2l0aCBkb2N1 bWVudGVkIGZhaWx1cmUgbW9kZSAoSU9NTVUgYmxvY2ssIGRpc3BsYXkKICBibGFjaywgUkdBMyBo YW5nKQotIEhhcmR3YXJlIHF1aXJrL3dvcmthcm91bmQg4oCUIGV4cGxpY2l0bHkgYWxsb3dlZCBz dGFibGUgY2F0ZWdvcnkKLSBTbWFsbCAoOCBsaW5lcyksIHN1cmdpY2FsLCBhcHBsaWVzIGNsZWFu bHkgdG8gNi4xOC40NAotIFZlbmRvciBrZXJuZWwgYWxyZWFkeSBkb2VzIHRoaXMgdW5jb25kaXRp b25hbGx5Ci0gVFJNIGRvY3VtZW50cyBCSVQoMzEpIHNob3VsZCBiZSAxCi0gQWNrZWQtYnkgUm9j a2NoaXAgbWFpbnRhaW5lciAoSGVpa28gU3R1ZWJuZXIpCi0gQWZmZWN0ZWQgU29DIERUIHN1cHBv cnQgcHJlc2VudCBpbiB0aGlzIHRyZWUKLSBCdWdneSBjb2RlIHBhdGggZXhpc3RzIGFuZCBoYXMg ZXhpc3RlZCBzaW5jZSBkcml2ZXIgaW50cm9kdWN0aW9uCi0gTm8gcHJlcmVxdWlzaXRlIGNvbW1p dHMKCioqQUdBSU5TVCBiYWNrcG9ydGluZzoqKgotIE5vIGBDYzogc3RhYmxlYCBvciBgRml4ZXM6 YCB0YWcgKGV4cGVjdGVkLCBub3QgZGlzcXVhbGlmeWluZykKLSBBcHBsaWVzIHRvIGFsbCBSb2Nr Y2hpcCBJT01NVSBpbnN0YW5jZXMsIG5vdCBTb0MtZ2F0ZWQgKGJ1dCB2ZW5kb3IKICBkb2VzIHNh bWU7IGxvdyByaXNrKQotIFN0YWxlIFJWMTEyNi1vbmx5IHdvcmRpbmcgaW4gY29tbWl0IG1lc3Nh Z2UgKGNvZGUgaXMgY29ycmVjdGx5CiAgdW5jb25kaXRpb25hbCkKCioqVW5yZXNvbHZlZDoqKiBO b25lIHRoYXQgYWZmZWN0IHRoZSBkZWNpc2lvbi4KCiMjIyBTdGVwIDkuMjogU1RBQkxFIFJVTEVT IENIRUNLTElTVAoxLiBPYnZpb3VzbHkgY29ycmVjdCBhbmQgdGVzdGVkPyAqKlBBU1MqKiDigJQg VFJNICsgdmVuZG9yIGtlcm5lbCArCiAgIFBlbmd1dHJvbml4IFJLMzU4OCB0ZXN0aW5nCjIuIEZp eGVzIGEgcmVhbCBidWcgYWZmZWN0aW5nIHVzZXJzPyAqKlBBU1MqKiDigJQgSU9NTVUgaGFuZywg YmxhY2sgc2NyZWVuCiAgIG9uIHByb2R1Y3Rpb24gaGFyZHdhcmUKMy4gSW1wb3J0YW50IGlzc3Vl PyAqKlBBU1MqKiDigJQgQ1JJVElDQUwgKGhhbmcsIGRpc3BsYXkgZmFpbHVyZSkKNC4gU21hbGwg YW5kIGNvbnRhaW5lZD8gKipQQVNTKiog4oCUIDggbGluZXMsIG9uZSBmdW5jdGlvbgo1LiBObyBu ZXcgZmVhdHVyZXMgb3IgQVBJcz8gKipQQVNTKiog4oCUIHJlZ2lzdGVyIHdvcmthcm91bmQgb25s eQo2LiBDYW4gYXBwbHkgdG8gbG9jYWwgdHJlZT8gKipQQVNTKiog4oCUIGNsZWFuIGFwcGx5IHZl cmlmaWVkCgojIyMgU3RlcCA5LjM6IEVYQ0VQVElPTiBDQVRFR09SSUVTCioqUmVjb3JkOioqICoq SGFyZHdhcmUgcXVpcmsvd29ya2Fyb3VuZCoqIOKAlCBxdWFsaWZpZXMgdW5kZXIgc3RhYmxlCmV4 Y2VwdGlvbiBydWxlcy4KCiMjIyBTdGVwIDkuNDogREVDSVNJT04gUkFUSU9OQUxFCgpGb3IgKipM aW51eCA2LjE4LjQ0KiosIFJvY2tjaGlwIElPTU1VIHVzZXJzIG9uIFJLMzU2OCwgUkszNTg4LCBh bmQKUlYxMTI2IHBsYXRmb3JtcyBhcmUgZXhwb3NlZCB0byBhIHNpbGljb24gYnVnIHdoZXJlIHRo ZSBJT01NVSBjYW4gZW50ZXIKYSBibG9ja2VkIHN0YXRlIGR1cmluZyBub3JtYWwgcGFnZS10YWJs ZSBtYWludGVuYW5jZSwgY2F1c2luZyBwZXJpcGhlcmFsCmhhbmdzIGFuZCBkaXNwbGF5IGJsYWNr IHNjcmVlbnMuIFRoZSBmaXggaXMgYSBtaW5pbWFsLCB2ZW5kb3ItdmFsaWRhdGVkCnJlZ2lzdGVy IHdyaXRlIHRoYXQgbWF0Y2hlcyBUUk0gZG9jdW1lbnRhdGlvbi4gSXQgYXBwbGllcyBjbGVhbmx5 LCBoYXMKbWFpbnRhaW5lciBhY2ssIGFuZCBmaXhlcyBhIHNlcmlvdXMgdXNlci12aXNpYmxlIGZh aWx1cmUgb24gaGFyZHdhcmUKd2VsbC1zdXBwb3J0ZWQgaW4gdGhpcyB0cmVlLgoKLS0tCgojIyBW ZXJpZmljYXRpb24KCi0gW1BoYXNlIDFdIFBhcnNlZCBjb21taXQgYDhkNDM0NmVjZDQ5NTBgOiBz dWJqZWN0LCBib2R5LCB0YWdzIChBY2tlZC1ieQogIEhlaWtvIFN0dWVibmVyOyBubyBGaXhlcy9z dGFibGUvc3l6Ym90KQotIFtQaGFzZSAyXSBEaWZmIGFuYWx5c2lzOiArOCBsaW5lcyBpbiBgcmtf aW9tbXVfZW5hYmxlKClgLCBhZGRzIEJJVCgzMSkKICB3cml0ZSB0byBgUktfTU1VX0FVVE9fR0FU SU5HYAotIFtQaGFzZSAzXSBgZ2l0IGJsYW1lYDogYHJrX2lvbW11X2VuYWJsZSgpYCBmcm9tIDIw MTQ7CiAgYFJLX01NVV9BVVRPX0dBVElOR2AgZnJvbSBvcmlnaW5hbCAyMDE0IGRyaXZlcgotIFtQ aGFzZSAzXSBObyBGaXhlczogdGFnIHRvIGZvbGxvdwotIFtQaGFzZSAzXSBSZWxhdGVkIGNvbW1p dCBgNjJlMDYyYTI5YWQ1MWAgKGRpZmZlcmVudCBidWcpIGFscmVhZHkgaW4KICB0cmVlOyB0aGlz IGZpeCBpcyBub3QKLSBbUGhhc2UgM10gYGdpdCBmb3JtYXQtcGF0Y2hgICsgYGdpdCBhcHBseSAt LWNoZWNrYDogYXBwbGllcyBjbGVhbmx5Ci0gW1BoYXNlIDNdIENvbW1pdCBvbiBgbWFzdGVyYCBi dXQgbm90IG9uIGN1cnJlbnQgYHN0YWJsZS9saW51eC02LjE4LnlgCiAgSEVBRAotIFtQaGFzZSA0 XSBgYjQgZGlnIC1jIDhkNDM0NmVjZDQ5NTBgOiBsb3JlIHRocmVhZCBmb3VuZAotIFtQaGFzZSA0 XSBgYjQgZGlnIC1hYDogdjEgc3VibWlzc2lvbiAyMDI1LTExLTI2OyBjb21taXR0ZWQgMjAyNi0w Ni0wMgotIFtQaGFzZSA0XSBgYjQgZGlnIC13YDogSm9lcmcgUm9lZGVsLCBIZWlrbyBTdHVlYm5l ciwgUm9iaW4gTXVycGh5IENDJ2QKLSBbUGhhc2UgNF0gTWJveDogUGVuZ3V0cm9uaXggY29uZmly bWVkIFJLMzU4OCBSR0EzIGhhbmdzOyBTaGF3biBMaW4KICBjb21tZW50LW9ubHkgVFJNIG5vdGU7 IEhlaWtvIHN1Z2dlc3RlZCByZXNlbmQ7IG5vIE5BS3MsIG5vIHN0YWJsZQogIG5vbWluYXRpb24K LSBbUGhhc2UgNV0gQ2FsbGVyczogYHJrX2lvbW11X2F0dGFjaF9kZXZpY2UoKWAgKGxpbmUgMTA0 MyksCiAgYHJrX2lvbW11X3Jlc3VtZSgpYCAobGluZSAxMzMwKQotIFtQaGFzZSA1XSBJT1RMQiB6 YXAgcGF0aDogYHJrX2lvbW11X3phcF9pb3ZhKClgIHVzZWQgZnJvbSBtYXAvdW5tYXAg4oCUCiAg Y29uZmlybXMgY29uY3VycmVudCB6YXAgbWVjaGFuaXNtCi0gW1BoYXNlIDZdIGBnaXQgZGVzY3Jp YmUgSEVBRGA6IHY2LjE4LjQ0OyBgbWFrZSBrZXJuZWx2ZXJzaW9uYDogNi4xOC40NAotIFtQaGFz ZSA2XSBCdWdneSBjb2RlIGNvbmZpcm1lZCBwcmVzZW50OiBubwogIGBESVNBQkxFX0ZFVENIX0RU RV9USU1FX0xJTUlUYCBpbiB0cmVlCi0gW1BoYXNlIDZdIERUOiBgcnYxMTI2LmR0c2lgLCBgcmsz NTZ4LWJhc2UuZHRzaWAsIGByazM1ODgtYmFzZS5kdHNpYAogIGhhdmUgSU9NTVUgbm9kZXMKLSBb UGhhc2UgNl0gYHJrMzU2OC1pb21tdWAgc3VwcG9ydCBzaW5jZSAyMDIxIChgYzU1MzU2YzUzNGFh NmApLCBpbiB0cmVlCi0gW1BoYXNlIDddIGBDT05GSUdfUk9DS0NISVBfSU9NTVU9eWAgaW4gYXJt NjQgZGVmY29uZmlnCi0gW1BoYXNlIDhdIEZhaWx1cmUgbW9kZTogSU9NTVUgYmxvY2sg4oaSIGhh bmcvYmxhY2sgc2NyZWVuLCBzZXZlcml0eQogIENSSVRJQ0FMCgoqKllFUyoqVGhlIGJhY2tncm91 bmQgc2VhcmNoIG9uIGBtYXN0ZXJgIGZvdW5kIHRoZSBjb21taXQ6CioqYDhkNDM0NmVjZDQ5NTBg Kiog4oCUIGBpb21tdS9yb2NrY2hpcDogZGlzYWJsZSBmZXRjaCBkdGUgdGltZSBsaW1pdGAuCgoq KlN1bW1hcnk6KiogVGhpcyBpcyBhbiA4LWxpbmUgaGFyZHdhcmUgd29ya2Fyb3VuZCBmb3IgUm9j a2NoaXAgSU9NTVUKc2lsaWNvbiAoUkszNTY4LCBSSzM1ODgsIFJWMTEyNikuIFdpdGhvdXQgc2V0 dGluZyBCSVQoMzEpIG9mCmBSS19NTVVfQVVUT19HQVRJTkdgLCB0aGUgSU9NTVUgY2FuIGJsb2Nr IGR1cmluZyBjb25jdXJyZW50IERURSBmZXRjaAphbmQgSU9UTEIgemFwcywgY2F1c2luZyBwZXJp cGhlcmFsIGhhbmdzIGFuZCBWT1AgYmxhY2sgc2NyZWVucy4gVGhlCnBhdGNoIGFwcGxpZXMgY2xl YW5seSB0byB0aGUgbG9jYWwgKio2LjE4LjQ0KiogdHJlZSwgd2hlcmUgdGhlIGJ1Z2d5CmNvZGUg aXMgc3RpbGwgcHJlc2VudC4KCioqWUVTKioKCiBkcml2ZXJzL2lvbW11L3JvY2tjaGlwLWlvbW11 LmMgfCA4ICsrKysrKysrCiAxIGZpbGUgY2hhbmdlZCwgOCBpbnNlcnRpb25zKCspCgpkaWZmIC0t Z2l0IGEvZHJpdmVycy9pb21tdS9yb2NrY2hpcC1pb21tdS5jIGIvZHJpdmVycy9pb21tdS9yb2Nr Y2hpcC1pb21tdS5jCmluZGV4IDA4NjFkZDQ2OWJkODYuLjJkMGRhYmIwZDEwMWEgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvaW9tbXUvcm9ja2NoaXAtaW9tbXUuYworKysgYi9kcml2ZXJzL2lvbW11L3Jv Y2tjaGlwLWlvbW11LmMKQEAgLTc2LDYgKzc2LDggQEAKICNkZWZpbmUgU1BBR0VfT1JERVIgMTIK ICNkZWZpbmUgU1BBR0VfU0laRSAoMSA8PCBTUEFHRV9PUkRFUikKIAorI2RlZmluZSBESVNBQkxF X0ZFVENIX0RURV9USU1FX0xJTUlUIEJJVCgzMSkKKwogIC8qCiAgICogU3VwcG9ydCBtYXBwaW5n IGFueSBzaXplIHRoYXQgZml0cyBpbiBvbmUgcGFnZSB0YWJsZToKICAgKiAgIDQgS2lCIHRvIDQg TWlCCkBAIC05MzAsNiArOTMyLDcgQEAgc3RhdGljIGludCBya19pb21tdV9lbmFibGUoc3RydWN0 IHJrX2lvbW11ICppb21tdSkKIAlzdHJ1Y3QgaW9tbXVfZG9tYWluICpkb21haW4gPSBpb21tdS0+ ZG9tYWluOwogCXN0cnVjdCBya19pb21tdV9kb21haW4gKnJrX2RvbWFpbiA9IHRvX3JrX2RvbWFp bihkb21haW4pOwogCWludCByZXQsIGk7CisJdTMyIGF1dG9fZ2F0ZTsKIAogCXJldCA9IGNsa19i dWxrX2VuYWJsZShpb21tdS0+bnVtX2Nsb2NrcywgaW9tbXUtPmNsb2Nrcyk7CiAJaWYgKHJldCkK QEAgLTk0OCw2ICs5NTEsMTEgQEAgc3RhdGljIGludCBya19pb21tdV9lbmFibGUoc3RydWN0IHJr X2lvbW11ICppb21tdSkKIAkJCSAgICAgICBya19vcHMtPm1rX2R0ZW50cmllcyhya19kb21haW4t PmR0X2RtYSkpOwogCQlya19pb21tdV9iYXNlX2NvbW1hbmQoaW9tbXUtPmJhc2VzW2ldLCBSS19N TVVfQ01EX1pBUF9DQUNIRSk7CiAJCXJrX2lvbW11X3dyaXRlKGlvbW11LT5iYXNlc1tpXSwgUktf TU1VX0lOVF9NQVNLLCBSS19NTVVfSVJRX01BU0spOworCisJCS8qIFdvcmthcm91bmQgZm9yIGlv bW11IGJsb2NrZWQsIEJJVCgzMSkgZGVmYXVsdCB0byAxICovCisJCWF1dG9fZ2F0ZSA9IHJrX2lv bW11X3JlYWQoaW9tbXUtPmJhc2VzW2ldLCBSS19NTVVfQVVUT19HQVRJTkcpOworCQlhdXRvX2dh dGUgfD0gRElTQUJMRV9GRVRDSF9EVEVfVElNRV9MSU1JVDsKKwkJcmtfaW9tbXVfd3JpdGUoaW9t bXUtPmJhc2VzW2ldLCBSS19NTVVfQVVUT19HQVRJTkcsIGF1dG9fZ2F0ZSk7CiAJfQogCiAJcmV0 ID0gcmtfaW9tbXVfZW5hYmxlX3BhZ2luZyhpb21tdSk7Ci0tIAoyLjUzLjAKCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51eC1yb2NrY2hpcCBtYWls aW5nIGxpc3QKTGludXgtcm9ja2NoaXBAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMu aW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJvY2tjaGlwCg==