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 18D9151FCB4; Mon, 31 Aug 2026 13:43:58 +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=1788183840; cv=none; b=kZm9JZanEMZg+IL9sp1U+KaJmGtUeBL1APpMcujl8gQRQaO8/udQRoJy4/8d+OrUp9f4DuKW/uQbsndzKv2o7SPSwzScH2o31L8e2TYWL+KW3RqBEuuVLUviVqPtTmMpkWeUYRyuqdJAHUUDkd2ZDMxGACefBqBdZZU0bRrUDGI= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788183840; c=relaxed/simple; bh=r50iPwsBao1PFw/YVuec++5XN914iDIQTjNbCTP0dzo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=kTKu5FflCqm8UZVhbkge2RjgsFck/kq4Cz1AKxnZP75afi60Ymbkp385KJXPt76NTshnmBxxWq5lkgiX0K5TL0+hy+HLYuVXwI2sHDdvq0p2ZyzDQxZ0hRlexQxLYgDc/4TrL8RjHTgAsrd7Lk8FAl12xhZ4brGHGYvf5f6OtFA= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=cx/l67t4; 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="cx/l67t4" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4906E1F00A3F; Mon, 31 Aug 2026 13:43:56 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788183838; bh=qGIPQnjyt4OQ6XoqGXnUCOervZ5TVfmZF9/N9wgWUXM=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=cx/l67t4HkB85mXPNRwkITyeR3Q4iJ4lqiNc4GX9clzrWgTcQTGUUns+aNByjImbF AUEwCfxLL0bYhyxhZn6v36XGTNFJC4F3iZ19jStNQRedePboqC2MCQajmaEjJew/L8 RfVp7J8v7R9SswEXl3BGEVnUFVpdWlXdtUFUWIdsc5Z7W81utjLkLly/JKWwcdIrxp XHJn7ANszJ/zLvA7itsMdMu8MsxNKXWOFVVx6bC2rtdyJIQBS0LenmZAg0kkWX2pQi E3rCIpG33X+PPQbrRG567sR9gHJglHlwHbDp9JkUDVyGLsS1jzlu9EjwCIGyQokJss sA24lcvkB1APQ== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: Hirokazu Honda , Sumit Garg , Jens Wiklander , Sasha Levin , jenswi@kernel.org, op-tee@lists.trustedfirmware.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 6.18-5.10] tee: optee: Allow MT_NORMAL_TAGGED shared memory Date: Mon, 31 Aug 2026 09:26:02 -0400 Message-ID: <20260831133314.4125787-334-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 X-stable: review X-Patchwork-Hint: Ignore X-stable-base: Linux 6.18.48 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit From: Hirokazu Honda [ Upstream commit 1a6e94a8ff32e7879effd1e4a45bf112e506edc1 ] On ARM64, shared memory can have MT_NORMAL_TAGGED attribute when using the Memory Tagging Extension (MTE). The OP-TEE driver needs to recognize this as normal memory to allow sharing such buffers with the Secure World. Signed-off-by: Hirokazu Honda Reviewed-by: Sumit Garg Signed-off-by: Jens Wiklander Signed-off-by: Sasha Levin --- LLM Generated explanations, may be completely bogus: Connection lost, reconnecting to https://agentn.us.api5.cursor.sh (attempt 1)... Retry attempt 1... # Stable Backport Analysis: `tee: optee: Allow MT_NORMAL_TAGGED shared memory` **Local tree:** Linux 6.18.43 (`git describe HEAD` → `v6.18.43`) --- ## PHASE 1: COMMIT MESSAGE FORENSICS ### Step 1.1: Subject Line **Record:** `[tee: optee]` `[Allow]` — Extend OP-TEE shared-memory validation to accept ARM64 `MT_NORMAL_TAGGED` pages (MTE-tagged normal memory). ### Step 1.2: Tags **Record:** - `Signed-off-by: Hirokazu Honda ` — author (Chrome team) - `Reviewed-by: Sumit Garg ` — OP-TEE maintainer review - `Signed-off-by: Jens Wiklander ` — TEE subsystem maintainer - No `Fixes:`, `Reported-by:`, `Cc: stable@vger.kernel.org`, `Link:`, `Tested-by:`, or `Acked-by:` tags - Notable: Reviewed by subsystem maintainers; no syzbot or crash report ### Step 1.3: Body Analysis **Record:** - **Bug:** On ARM64, userspace buffers mapped with MTE (`PROT_MTE`) use `MT_NORMAL_TAGGED` page attributes. `is_normal_memory()` only accepts `MT_NORMAL`, so `optee_check_mem_type()` rejects valid buffers. - **Symptom:** `-EINVAL` when registering shared memory with OP-TEE; secure-world communication fails for MTE-enabled processes. - **Root cause:** Incomplete memory-type check — `MT_NORMAL_TAGGED` is documented as a normal-memory variant but not recognized by the driver. ### Step 1.4: Hidden Bug Fix? **Record:** No — this is an explicit compatibility fix, not disguised cleanup. It corrects an overly narrow memory-type whitelist. --- ## PHASE 2: DIFF ANALYSIS ### Step 2.1: Inventory **Record:** - **Files:** `drivers/tee/optee/call.c` (+2 / -1) - **Functions:** `is_normal_memory()` only - **Scope:** Single-file, surgical ARM64-only change ### Step 2.2: Code Flow Change **Record:** - **Before:** ARM64 `is_normal_memory()` returns true only for `PTE_ATTRINDX(MT_NORMAL)`. - **After:** Also returns true for `PTE_ATTRINDX(MT_NORMAL_TAGGED)`. - **Path affected:** `optee_check_mem_type()` → `__check_mem_type()` → `is_normal_memory()` during shared-memory registration. ### Step 2.3: Bug Mechanism **Record:** **Logic / correctness fix** — incorrect rejection of a valid ARM64 memory type. Classification: platform-specific compatibility bug (ARM64 MTE + OP-TEE). ### Step 2.4: Fix Quality **Record:** Obviously correct — `arch/arm64/include/asm/memory.h` documents `MT_NORMAL_TAGGED` as the normal-memory type for `PROT_MTE` mappings. Minimal diff, no API changes, no regression risk on non-ARM64 builds (change is inside `#elif defined(CONFIG_ARM64)`). --- ## PHASE 3: GIT HISTORY INVESTIGATION ### Step 3.1: Blame **Record:** `is_normal_memory()` exists in this tree at `call.c:599-609`. The original check (only `MT_NORMAL`) dates to the 2017 introduction of shared-memory type validation (`[PATCH 2/2] tee: optee: check type of registered shared memory`). The stable tree's per- file history is flattened (entire `call.c` attributed to one upstream merge commit), but the function and its `MT_NORMAL`-only check are present in 6.18.43. ### Step 3.2: Fixes Tag **Record:** N/A — no `Fixes:` tag in the commit message. ### Step 3.3: Related File History **Record:** No related follow-up fixes found in this tree. Standalone one-line logical extension. ### Step 3.4: Author Context **Record:** Hirokazu Honda (Chromium). Jens Wiklander is TEE subsystem maintainer; Sumit Garg is OP-TEE maintainer. Both reviewed and accepted. ### Step 3.5: Dependencies **Record:** No prerequisites. `MT_NORMAL_TAGGED` is already defined in `arch/arm64/include/asm/memory.h` (value `1`). MTE userspace support (`PROT_MTE`) is present in this tree. Fix applies standalone. --- ## PHASE 4: MAILING LIST AND EXTERNAL RESEARCH ### Step 4.1: Original Discussion **Record:** Patch submitted Apr 16, 2026. Discussion at [spinics.net msg6157985](https://www.spinics.net/lists/kernel/msg6157985.html). Single-patch submission (not a series). Jens Wiklander: "Looks good. I'm picking up this." Merged via `optee-for-v7.2` tag. No NAKs. ### Step 4.2: Reviewers **Record:** To: Jens Wiklander. Cc: Sumit Garg, op- tee@lists.trustedfirmware.org, linux-kernel. Appropriate maintainers involved. ### Step 4.3: Bug Report **Record:** No formal bug report or syzbot link. Real-world motivation from Chrome/Android MTE + OP-TEE integration. ### Step 4.4: Related Patches **Record:** Standalone fix; no series dependencies. ### Step 4.5: Stable List History **Record:** No `Cc: stable` nomination found in review thread. Absence is expected per review pipeline rules and is not a negative signal. --- ## PHASE 5: CODE SEMANTIC ANALYSIS ### Step 5.1: Key Functions **Record:** `is_normal_memory()` (modified), `__check_mem_type()`, `optee_check_mem_type()` (callers unchanged). ### Step 5.2: Callers of `optee_check_mem_type()` **Record:** - `optee_shm_register()` in `smc_abi.c:467` — registers user/kernel shared memory with secure world - `optee_shm_register_supp()` in `smc_abi.c:570` — supplicant path validation - `optee_ffa_shm_register()` in `ffa_abi.c:289` — FF-A ABI shared memory registration ### Step 5.3: Callees **Record:** `__check_mem_type()` walks VMAs via `for_each_vma_range()`, checks `vma->vm_page_prot` against `is_normal_memory()`. ### Step 5.4: Reachability **Record:** Userspace → `/dev/tee*` ioctl `TEE_IOC_SHM_REGISTER` → `tee_ioctl_shm_register()` → `tee_shm_register_user_buf()` → `register_shm_helper()` → `optee_shm_register()` → `optee_check_mem_type()`. **Reachable from userspace** on ARM64 systems with OP-TEE enabled when registering MTE-tagged buffers. ### Step 5.5: Similar Patterns **Record:** `pte_tagged()` in `arch/arm64/include/asm/pgtable.h` uses the same `MT_NORMAL_TAGGED` check pattern. The kernel already treats this as a normal-memory variant elsewhere. --- ## PHASE 6: CROSS-REFERENCING AGAINST LOCAL TREE (6.18.43) ### Step 6.1: Buggy Code Present? **Record:** **YES.** Current `call.c:605` only checks `MT_NORMAL`: ```605:605:drivers/tee/optee/call.c return (pgprot_val(p) & PTE_ATTRINDX_MASK) == PTE_ATTRINDX(MT_NORMAL); ``` `MT_NORMAL_TAGGED` is defined at `arch/arm64/include/asm/memory.h:172`. MTE support is present (`PROT_MTE` in `Documentation/arch/arm64/memory- tagging-extension.rst`, `arch/arm64/kernel/mte.c`). ### Step 6.2: Backport Complications **Record:** **Clean apply expected** — 2-line change in existing function, identical context to mainline diff. ### Step 6.3: Related Fixes Already Present? **Record:** **No** — `git log --grep="MT_NORMAL_TAGGED"` and `--grep="Allow MT_NORMAL_TAGGED"` return nothing in this tree. Fix not yet applied. --- ## PHASE 7: SUBSYSTEM AND MAINTAINER CONTEXT ### Step 7.1: Subsystem **Record:** `drivers/tee/optee` — TEE/OP-TEE driver. **Criticality: IMPORTANT** for ARM64 embedded/Android platforms using secure services (Keymaster, DRM, biometrics). Not core kernel, but security- infrastructure relevant on those platforms. ### Step 7.2: Activity **Record:** OP-TEE driver is mature but actively maintained; MTE adoption is an ongoing ARM64 platform concern. --- ## PHASE 8: IMPACT AND RISK ASSESSMENT ### Step 8.1: Who Is Affected **Record:** **Platform-specific:** ARM64 + `CONFIG_OPTEE` + userspace using `PROT_MTE` on buffers shared with OP-TEE. Primarily Android/Chrome OS devices rolling out MTE. ### Step 8.2: Trigger Conditions **Record:** User/application maps anonymous memory with `PROT_MTE`, then registers it with OP-TEE via `TEE_IOC_SHM_REGISTER`. Trigger is deterministic (not a race). Unprivileged users can trigger via TEE ioctl on systems with accessible `/dev/tee*`. ### Step 8.3: Failure Mode Severity **Record:** **`-EINVAL` on shared-memory registration** — TEE/secure- world operations fail entirely for MTE-enabled processes. No crash, corruption, deadlock, or security exploit. **Severity: MEDIUM** (complete functional breakage for affected configuration, but not a stability/security crash). ### Step 8.4: Risk-Benefit **Record:** - **Benefit:** Restores OP-TEE functionality for MTE-enabled ARM64 processes; important for Chrome/Android MTE rollout on TEE-equipped hardware. - **Risk:** Very low — 2 lines, ARM64-only, matches existing kernel semantics for `MT_NORMAL_TAGGED`. - **Ratio:** Favorable — trivial fix, real production impact for a growing platform configuration. --- ## PHASE 9: FINAL SYNTHESIS ### Step 9.1: Evidence Summary **FOR backport:** - Real, reproducible bug in 6.18.43 (buggy code confirmed present) - Small, obviously correct, maintainer-reviewed fix - Userspace-reachable on ARM64 OP-TEE systems - `MT_NORMAL_TAGGED` prerequisite already in tree - Hardware-platform compatibility fix (ARM64 MTE), analogous to quirk/workaround category - Chrome production motivation for growing MTE deployment **AGAINST backport:** - Not a crash, corruption, deadlock, or security vulnerability - Niche configuration (ARM64 + OPTEE + MTE) - No syzbot report or explicit stable nomination - Functional `-EINVAL` rather than kernel oops **Unresolved:** Exact kernel version when MTE userspace + OP-TEE combination became common in production (not needed for decision — bug mechanism is clear). ### Step 9.2: Stable Rules Checklist 1. Obviously correct and tested? **PASS** — logic matches `memory.h` documentation; reviewed by OP-TEE and TEE maintainers. 2. Fixes a real bug affecting users? **PASS** — deterministic `-EINVAL` blocking TEE shared memory for MTE buffers. 3. Important issue? **PASS (borderline)** — not a crash/corruption, but complete breakage of secure-world communication for MTE processes on ARM64 Android/Chrome platforms. 4. Small and contained? **PASS** — 2 lines, 1 file, 1 function. 5. No new features or APIs? **PASS** — extends recognition of existing memory type; no new API. 6. Can apply to local tree? **PASS** — prerequisites present, clean apply expected. ### Step 9.3: Exception Category **Record:** **Hardware/platform workaround** — enables correct handling of ARM64 MTE-tagged normal memory, analogous to the quirk/compatibility exception category in stable rules. ### Step 9.4: Decision Rationale This commit fixes a real compatibility gap between ARM64 MTE (`MT_NORMAL_TAGGED`) and the OP-TEE driver's shared-memory validator. The bug exists in Linux 6.18.43, the fix is trivial and maintainer- approved, and all prerequisites (`MT_NORMAL_TAGGED`, MTE support) are already in this tree. While the failure mode is functional rather than a kernel crash, it completely blocks TEE operations for MTE-enabled processes — a growing concern on ARM64 Android/Chrome platforms where both OP-TEE and MTE are deployed together. The fix is low-risk and fits the stable pattern for small platform compatibility corrections. --- ## Verification - [Phase 1] Parsed subject, tags, body from provided commit message - [Phase 1] Confirmed no `Fixes:`, `Reported-by:`, or `Cc: stable` tags - [Phase 2] Read diff: +2/-1 in `is_normal_memory()`, ARM64 branch only - [Phase 2] Read `call.c:599-642` — confirmed current code only checks `MT_NORMAL` - [Phase 3] `git describe HEAD` → `v6.18.43`; `make kernelversion` → `6.18.43` - [Phase 3] `git blame -L 599,610 drivers/tee/optee/call.c` — function present in tree - [Phase 3] Web search: original `is_normal_memory` introduced ~2017 in OP-TEE shm type check patch - [Phase 3] `git log --grep="Allow MT_NORMAL_TAGGED"` — no match (fix not in tree) - [Phase 4] Fetched spinics.net msg6157985, msg6161595, msg6174403 — maintainer review, no NAKs, no stable Cc - [Phase 4] b4 dig unavailable for commit hash (fix not merged in this tree); used spinics/openwall instead - [Phase 5] `grep optee_check_mem_type` — 3 call sites in `smc_abi.c`, `ffa_abi.c` - [Phase 5] Read `tee_shm.c:496-516` — userspace registration path via `tee_shm_register_user_buf()` - [Phase 5] Read `smc_abi.c:453-469` — `optee_shm_register()` calls `optee_check_mem_type()` - [Phase 6] Confirmed `MT_NORMAL_TAGGED` defined at `arch/arm64/include/asm/memory.h:172` - [Phase 6] Confirmed `pte_tagged()` uses same `MT_NORMAL_TAGGED` pattern in `pgtable.h:191-192` - [Phase 6] `grep PROT_MTE` — MTE userspace support present in tree - [Phase 8] Traced call chain: ioctl → shm register → `optee_check_mem_type()` → `-EINVAL` on MTE buffers **YES**The background `git log -S "is_normal_memory"` search finished. It didn’t turn up a clean introduction point for `is_normal_memory()` in this 6.18.43 stable tree — the hits were unrelated (MIPS) or artifacts of the flattened per-file history (the whole `call.c` lumped under one upstream merge). External history still points to the original OP-TEE shared-memory type check from ~2017. That doesn’t change the earlier conclusion: the buggy `MT_NORMAL`-only check is present in this tree, the fix is small and correct, and it should be backported. **YES** drivers/tee/optee/call.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c index 16eb953e14bb6..e422e77b06fb8 100644 --- a/drivers/tee/optee/call.c +++ b/drivers/tee/optee/call.c @@ -602,7 +602,8 @@ static bool is_normal_memory(pgprot_t p) return (((pgprot_val(p) & L_PTE_MT_MASK) == L_PTE_MT_WRITEALLOC) || ((pgprot_val(p) & L_PTE_MT_MASK) == L_PTE_MT_WRITEBACK)); #elif defined(CONFIG_ARM64) - return (pgprot_val(p) & PTE_ATTRINDX_MASK) == PTE_ATTRINDX(MT_NORMAL); + return ((pgprot_val(p) & PTE_ATTRINDX_MASK) == PTE_ATTRINDX(MT_NORMAL)) || + ((pgprot_val(p) & PTE_ATTRINDX_MASK) == PTE_ATTRINDX(MT_NORMAL_TAGGED)); #else #error "Unsupported architecture" #endif -- 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 lists.trustedfirmware.org (lists.trustedfirmware.org [18.214.241.189]) (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 F2981C624CE for ; Mon, 31 Aug 2026 13:44:07 +0000 (UTC) Received: from lists.trustedfirmware.org (localhost [127.0.0.1]) by lists.trustedfirmware.org (Postfix) with ESMTP id 14BC345044 for ; Mon, 31 Aug 2026 13:44:07 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=lists.trustedfirmware.org; s=2024; t=1788183847; bh=sa0deLycJVmGO+/0qxlaLxPh9EYPznPZXS/3mJaTb4A=; h=To:Subject:Date:In-Reply-To:References:CC:List-Id:List-Archive: List-Help:List-Owner:List-Post:List-Subscribe:List-Unsubscribe: From:Reply-To:From; b=H2RNgM9ALA4uMAC1ApZfJSk/Y+c3L4EmYF6Hlb9c6QhCX0wWTFPPuOPMhdhU8UL6J yC4rFja6NfiyE/yDFlUz50gvSWG/pFPYhdXBqGhTs10aVluNjfjlJnah5lDSHfXc/H IvcPU10EGipPbOobKuJNRvs2fW9a0d80Y+KYjR9uaKAvF8zyIv0AgMCyvwHhD0NQJE 98LoBxfLfZA2YZrp7V+N/lvUNFGSWLXeVSUToU8/G2cYw0dsEfNlqM1CocKXn5glr+ 5yr4kWgANNam8w7hKvahOHUUhh0016/O/UO5Dyoh5LE0MK12gdN+Eqp7FVlnQr76Zn uk0NZyqksxHNQ== Received: from tor.source.kernel.org (tor.source.kernel.org [172.105.4.254]) by lists.trustedfirmware.org (Postfix) with ESMTPS id 025E24440E for ; Mon, 31 Aug 2026 13:43:59 +0000 (UTC) Authentication-Results: lists.trustedfirmware.org; dkim=pass (2048-bit key; unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=cx/l67t4; dkim-atps=neutral Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id 499C5602BA; Mon, 31 Aug 2026 13:43:58 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4906E1F00A3F; Mon, 31 Aug 2026 13:43:56 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788183838; bh=qGIPQnjyt4OQ6XoqGXnUCOervZ5TVfmZF9/N9wgWUXM=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=cx/l67t4HkB85mXPNRwkITyeR3Q4iJ4lqiNc4GX9clzrWgTcQTGUUns+aNByjImbF AUEwCfxLL0bYhyxhZn6v36XGTNFJC4F3iZ19jStNQRedePboqC2MCQajmaEjJew/L8 RfVp7J8v7R9SswEXl3BGEVnUFVpdWlXdtUFUWIdsc5Z7W81utjLkLly/JKWwcdIrxp XHJn7ANszJ/zLvA7itsMdMu8MsxNKXWOFVVx6bC2rtdyJIQBS0LenmZAg0kkWX2pQi E3rCIpG33X+PPQbrRG567sR9gHJglHlwHbDp9JkUDVyGLsS1jzlu9EjwCIGyQokJss sA24lcvkB1APQ== To: patches@lists.linux.dev, stable@vger.kernel.org Subject: [PATCH AUTOSEL 6.18-5.10] tee: optee: Allow MT_NORMAL_TAGGED shared memory Date: Mon, 31 Aug 2026 09:26:02 -0400 Message-ID: <20260831133314.4125787-334-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 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 X-Rspamd-Action: no action X-Spamd-Result: default: False [-6.00 / 15.00]; WHITELIST_SPF_DKIM(-3.00)[kernel.org:d:+,kernel.org:s:+]; BAYES_HAM(-3.00)[99.99%]; MID_CONTAINS_FROM(1.00)[]; DMARC_POLICY_ALLOW(-0.50)[kernel.org,quarantine]; R_DKIM_ALLOW(-0.20)[kernel.org:s=k20260515]; R_SPF_ALLOW(-0.20)[+ip4:172.105.4.254]; MIME_GOOD(-0.10)[text/plain]; MIME_TRACE(0.00)[0:+]; RCVD_VIA_SMTP_AUTH(0.00)[]; ARC_NA(0.00)[]; ASN(0.00)[asn:63949, ipnet:172.105.0.0/19, country:SG]; RCPT_COUNT_SEVEN(0.00)[9]; NEURAL_HAM(-0.00)[-1.000]; TO_DN_SOME(0.00)[]; FROM_EQ_ENVFROM(0.00)[]; FROM_HAS_DN(0.00)[]; DWL_DNSWL_BLOCKED(0.00)[kernel.org:dkim]; RCVD_COUNT_TWO(0.00)[2]; DNSWL_BLOCKED(0.00)[100.103.45.18:received]; TO_MATCH_ENVRCPT_SOME(0.00)[]; RCVD_TLS_LAST(0.00)[]; DKIM_TRACE(0.00)[kernel.org:+] X-Rspamd-Server: lists.trustedfirmware.org X-Rspamd-Queue-Id: 025E24440E X-Spamd-Bar: ----- Message-ID-Hash: 72TJ3N5ZQRXAVYAB7AQ4AG2ODBPC3P65 X-Message-ID-Hash: 72TJ3N5ZQRXAVYAB7AQ4AG2ODBPC3P65 X-MailFrom: sashal@kernel.org X-Mailman-Rule-Misses: dmarc-mitigation; no-senders; approved; emergency; loop; banned-address; member-moderation; header-match-op-tee.lists.trustedfirmware.org-0; nonmember-moderation; administrivia; implicit-dest; max-recipients; max-size; news-moderation; no-subject; digests; suspicious-header CC: Hirokazu Honda , Sumit Garg , Sasha Levin , jenswi@kernel.org, op-tee@lists.trustedfirmware.org, linux-kernel@vger.kernel.org X-Mailman-Version: 3.3.5 Precedence: list List-Id: Archived-At: List-Archive: List-Help: List-Owner: List-Post: List-Subscribe: List-Unsubscribe: From: Sasha Levin via OP-TEE Reply-To: Sasha Levin RnJvbTogSGlyb2thenUgSG9uZGEgPGhpcm9oQGNocm9taXVtLm9yZz4NCg0KWyBVcHN0cmVhbSBj b21taXQgMWE2ZTk0YThmZjMyZTc4NzllZmZkMWU0YTQ1YmYxMTJlNTA2ZWRjMSBdDQoNCk9uIEFS TTY0LCBzaGFyZWQgbWVtb3J5IGNhbiBoYXZlIE1UX05PUk1BTF9UQUdHRUQgYXR0cmlidXRlIHdo ZW4gdXNpbmcNCnRoZSBNZW1vcnkgVGFnZ2luZyBFeHRlbnNpb24gKE1URSkuIFRoZSBPUC1URUUg ZHJpdmVyIG5lZWRzIHRvDQpyZWNvZ25pemUgdGhpcyBhcyBub3JtYWwgbWVtb3J5IHRvIGFsbG93 IHNoYXJpbmcgc3VjaCBidWZmZXJzIHdpdGggdGhlDQpTZWN1cmUgV29ybGQuDQoNClNpZ25lZC1v ZmYtYnk6IEhpcm9rYXp1IEhvbmRhIDxoaXJvaEBjaHJvbWl1bS5vcmc+DQpSZXZpZXdlZC1ieTog U3VtaXQgR2FyZyA8c3VtaXQuZ2FyZ0Bvc3MucXVhbGNvbW0uY29tPg0KU2lnbmVkLW9mZi1ieTog SmVucyBXaWtsYW5kZXIgPGplbnMud2lrbGFuZGVyQGxpbmFyby5vcmc+DQpTaWduZWQtb2ZmLWJ5 OiBTYXNoYSBMZXZpbiA8c2FzaGFsQGtlcm5lbC5vcmc+DQotLS0NCg0KTExNIEdlbmVyYXRlZCBl eHBsYW5hdGlvbnMsIG1heSBiZSBjb21wbGV0ZWx5IGJvZ3VzOg0KDQpDb25uZWN0aW9uIGxvc3Qs IHJlY29ubmVjdGluZyB0byBodHRwczovL2FnZW50bi51cy5hcGk1LmN1cnNvci5zaA0KKGF0dGVt cHQgMSkuLi4NClJldHJ5IGF0dGVtcHQgMS4uLg0KIyBTdGFibGUgQmFja3BvcnQgQW5hbHlzaXM6 IGB0ZWU6IG9wdGVlOiBBbGxvdyBNVF9OT1JNQUxfVEFHR0VEIHNoYXJlZA0KbWVtb3J5YA0KDQoq KkxvY2FsIHRyZWU6KiogTGludXggNi4xOC40MyAoYGdpdCBkZXNjcmliZSBIRUFEYCDihpIgYHY2 LjE4LjQzYCkNCg0KLS0tDQoNCiMjIFBIQVNFIDE6IENPTU1JVCBNRVNTQUdFIEZPUkVOU0lDUw0K DQojIyMgU3RlcCAxLjE6IFN1YmplY3QgTGluZQ0KKipSZWNvcmQ6KiogYFt0ZWU6IG9wdGVlXWAg YFtBbGxvd11gIOKAlCBFeHRlbmQgT1AtVEVFIHNoYXJlZC1tZW1vcnkNCnZhbGlkYXRpb24gdG8g YWNjZXB0IEFSTTY0IGBNVF9OT1JNQUxfVEFHR0VEYCBwYWdlcyAoTVRFLXRhZ2dlZCBub3JtYWwN Cm1lbW9yeSkuDQoNCiMjIyBTdGVwIDEuMjogVGFncw0KKipSZWNvcmQ6KioNCi0gYFNpZ25lZC1v ZmYtYnk6IEhpcm9rYXp1IEhvbmRhIDxoaXJvaEBjaHJvbWl1bS5vcmc+YCDigJQgYXV0aG9yIChD aHJvbWUNCiAgdGVhbSkNCi0gYFJldmlld2VkLWJ5OiBTdW1pdCBHYXJnIDxzdW1pdC5nYXJnQG9z cy5xdWFsY29tbS5jb20+YCDigJQgT1AtVEVFDQogIG1haW50YWluZXIgcmV2aWV3DQotIGBTaWdu ZWQtb2ZmLWJ5OiBKZW5zIFdpa2xhbmRlciA8amVucy53aWtsYW5kZXJAbGluYXJvLm9yZz5gIOKA lCBURUUNCiAgc3Vic3lzdGVtIG1haW50YWluZXINCi0gTm8gYEZpeGVzOmAsIGBSZXBvcnRlZC1i eTpgLCBgQ2M6IHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmdgLCBgTGluazpgLA0KICBgVGVzdGVkLWJ5 OmAsIG9yIGBBY2tlZC1ieTpgIHRhZ3MNCi0gTm90YWJsZTogUmV2aWV3ZWQgYnkgc3Vic3lzdGVt IG1haW50YWluZXJzOyBubyBzeXpib3Qgb3IgY3Jhc2ggcmVwb3J0DQoNCiMjIyBTdGVwIDEuMzog Qm9keSBBbmFseXNpcw0KKipSZWNvcmQ6KioNCi0gKipCdWc6KiogT24gQVJNNjQsIHVzZXJzcGFj ZSBidWZmZXJzIG1hcHBlZCB3aXRoIE1URSAoYFBST1RfTVRFYCkgdXNlDQogIGBNVF9OT1JNQUxf VEFHR0VEYCBwYWdlIGF0dHJpYnV0ZXMuIGBpc19ub3JtYWxfbWVtb3J5KClgIG9ubHkgYWNjZXB0 cw0KICBgTVRfTk9STUFMYCwgc28gYG9wdGVlX2NoZWNrX21lbV90eXBlKClgIHJlamVjdHMgdmFs aWQgYnVmZmVycy4NCi0gKipTeW1wdG9tOioqIGAtRUlOVkFMYCB3aGVuIHJlZ2lzdGVyaW5nIHNo YXJlZCBtZW1vcnkgd2l0aCBPUC1URUU7DQogIHNlY3VyZS13b3JsZCBjb21tdW5pY2F0aW9uIGZh aWxzIGZvciBNVEUtZW5hYmxlZCBwcm9jZXNzZXMuDQotICoqUm9vdCBjYXVzZToqKiBJbmNvbXBs ZXRlIG1lbW9yeS10eXBlIGNoZWNrIOKAlCBgTVRfTk9STUFMX1RBR0dFRGAgaXMNCiAgZG9jdW1l bnRlZCBhcyBhIG5vcm1hbC1tZW1vcnkgdmFyaWFudCBidXQgbm90IHJlY29nbml6ZWQgYnkgdGhl DQogIGRyaXZlci4NCg0KIyMjIFN0ZXAgMS40OiBIaWRkZW4gQnVnIEZpeD8NCioqUmVjb3JkOioq IE5vIOKAlCB0aGlzIGlzIGFuIGV4cGxpY2l0IGNvbXBhdGliaWxpdHkgZml4LCBub3QgZGlzZ3Vp c2VkDQpjbGVhbnVwLiBJdCBjb3JyZWN0cyBhbiBvdmVybHkgbmFycm93IG1lbW9yeS10eXBlIHdo aXRlbGlzdC4NCg0KLS0tDQoNCiMjIFBIQVNFIDI6IERJRkYgQU5BTFlTSVMNCg0KIyMjIFN0ZXAg Mi4xOiBJbnZlbnRvcnkNCioqUmVjb3JkOioqDQotICoqRmlsZXM6KiogYGRyaXZlcnMvdGVlL29w dGVlL2NhbGwuY2AgKCsyIC8gLTEpDQotICoqRnVuY3Rpb25zOioqIGBpc19ub3JtYWxfbWVtb3J5 KClgIG9ubHkNCi0gKipTY29wZToqKiBTaW5nbGUtZmlsZSwgc3VyZ2ljYWwgQVJNNjQtb25seSBj aGFuZ2UNCg0KIyMjIFN0ZXAgMi4yOiBDb2RlIEZsb3cgQ2hhbmdlDQoqKlJlY29yZDoqKg0KLSAq KkJlZm9yZToqKiBBUk02NCBgaXNfbm9ybWFsX21lbW9yeSgpYCByZXR1cm5zIHRydWUgb25seSBm b3INCiAgYFBURV9BVFRSSU5EWChNVF9OT1JNQUwpYC4NCi0gKipBZnRlcjoqKiBBbHNvIHJldHVy bnMgdHJ1ZSBmb3IgYFBURV9BVFRSSU5EWChNVF9OT1JNQUxfVEFHR0VEKWAuDQotICoqUGF0aCBh ZmZlY3RlZDoqKiBgb3B0ZWVfY2hlY2tfbWVtX3R5cGUoKWAg4oaSIGBfX2NoZWNrX21lbV90eXBl KClgIOKGkg0KICBgaXNfbm9ybWFsX21lbW9yeSgpYCBkdXJpbmcgc2hhcmVkLW1lbW9yeSByZWdp c3RyYXRpb24uDQoNCiMjIyBTdGVwIDIuMzogQnVnIE1lY2hhbmlzbQ0KKipSZWNvcmQ6KiogKipM b2dpYyAvIGNvcnJlY3RuZXNzIGZpeCoqIOKAlCBpbmNvcnJlY3QgcmVqZWN0aW9uIG9mIGEgdmFs aWQNCkFSTTY0IG1lbW9yeSB0eXBlLiBDbGFzc2lmaWNhdGlvbjogcGxhdGZvcm0tc3BlY2lmaWMg Y29tcGF0aWJpbGl0eSBidWcNCihBUk02NCBNVEUgKyBPUC1URUUpLg0KDQojIyMgU3RlcCAyLjQ6 IEZpeCBRdWFsaXR5DQoqKlJlY29yZDoqKiBPYnZpb3VzbHkgY29ycmVjdCDigJQgYGFyY2gvYXJt NjQvaW5jbHVkZS9hc20vbWVtb3J5LmhgDQpkb2N1bWVudHMgYE1UX05PUk1BTF9UQUdHRURgIGFz IHRoZSBub3JtYWwtbWVtb3J5IHR5cGUgZm9yIGBQUk9UX01URWANCm1hcHBpbmdzLiBNaW5pbWFs IGRpZmYsIG5vIEFQSSBjaGFuZ2VzLCBubyByZWdyZXNzaW9uIHJpc2sgb24gbm9uLUFSTTY0DQpi dWlsZHMgKGNoYW5nZSBpcyBpbnNpZGUgYCNlbGlmIGRlZmluZWQoQ09ORklHX0FSTTY0KWApLg0K DQotLS0NCg0KIyMgUEhBU0UgMzogR0lUIEhJU1RPUlkgSU5WRVNUSUdBVElPTg0KDQojIyMgU3Rl cCAzLjE6IEJsYW1lDQoqKlJlY29yZDoqKiBgaXNfbm9ybWFsX21lbW9yeSgpYCBleGlzdHMgaW4g dGhpcyB0cmVlIGF0DQpgY2FsbC5jOjU5OS02MDlgLiBUaGUgb3JpZ2luYWwgY2hlY2sgKG9ubHkg YE1UX05PUk1BTGApIGRhdGVzIHRvIHRoZQ0KMjAxNyBpbnRyb2R1Y3Rpb24gb2Ygc2hhcmVkLW1l bW9yeSB0eXBlIHZhbGlkYXRpb24gKGBbUEFUQ0ggMi8yXSB0ZWU6DQpvcHRlZTogY2hlY2sgdHlw ZSBvZiByZWdpc3RlcmVkIHNoYXJlZCBtZW1vcnlgKS4gVGhlIHN0YWJsZSB0cmVlJ3MgcGVyLQ0K ZmlsZSBoaXN0b3J5IGlzIGZsYXR0ZW5lZCAoZW50aXJlIGBjYWxsLmNgIGF0dHJpYnV0ZWQgdG8g b25lIHVwc3RyZWFtDQptZXJnZSBjb21taXQpLCBidXQgdGhlIGZ1bmN0aW9uIGFuZCBpdHMgYE1U X05PUk1BTGAtb25seSBjaGVjayBhcmUNCnByZXNlbnQgaW4gNi4xOC40My4NCg0KIyMjIFN0ZXAg My4yOiBGaXhlcyBUYWcNCioqUmVjb3JkOioqIE4vQSDigJQgbm8gYEZpeGVzOmAgdGFnIGluIHRo ZSBjb21taXQgbWVzc2FnZS4NCg0KIyMjIFN0ZXAgMy4zOiBSZWxhdGVkIEZpbGUgSGlzdG9yeQ0K KipSZWNvcmQ6KiogTm8gcmVsYXRlZCBmb2xsb3ctdXAgZml4ZXMgZm91bmQgaW4gdGhpcyB0cmVl LiBTdGFuZGFsb25lDQpvbmUtbGluZSBsb2dpY2FsIGV4dGVuc2lvbi4NCg0KIyMjIFN0ZXAgMy40 OiBBdXRob3IgQ29udGV4dA0KKipSZWNvcmQ6KiogSGlyb2thenUgSG9uZGEgKENocm9taXVtKS4g SmVucyBXaWtsYW5kZXIgaXMgVEVFIHN1YnN5c3RlbQ0KbWFpbnRhaW5lcjsgU3VtaXQgR2FyZyBp cyBPUC1URUUgbWFpbnRhaW5lci4gQm90aCByZXZpZXdlZCBhbmQgYWNjZXB0ZWQuDQoNCiMjIyBT dGVwIDMuNTogRGVwZW5kZW5jaWVzDQoqKlJlY29yZDoqKiBObyBwcmVyZXF1aXNpdGVzLiBgTVRf Tk9STUFMX1RBR0dFRGAgaXMgYWxyZWFkeSBkZWZpbmVkIGluDQpgYXJjaC9hcm02NC9pbmNsdWRl L2FzbS9tZW1vcnkuaGAgKHZhbHVlIGAxYCkuIE1URSB1c2Vyc3BhY2Ugc3VwcG9ydA0KKGBQUk9U X01URWApIGlzIHByZXNlbnQgaW4gdGhpcyB0cmVlLiBGaXggYXBwbGllcyBzdGFuZGFsb25lLg0K DQotLS0NCg0KIyMgUEhBU0UgNDogTUFJTElORyBMSVNUIEFORCBFWFRFUk5BTCBSRVNFQVJDSA0K DQojIyMgU3RlcCA0LjE6IE9yaWdpbmFsIERpc2N1c3Npb24NCioqUmVjb3JkOioqIFBhdGNoIHN1 Ym1pdHRlZCBBcHIgMTYsIDIwMjYuIERpc2N1c3Npb24gYXQgW3NwaW5pY3MubmV0DQptc2c2MTU3 OTg1XShodHRwczovL3d3dy5zcGluaWNzLm5ldC9saXN0cy9rZXJuZWwvbXNnNjE1Nzk4NS5odG1s KS4NClNpbmdsZS1wYXRjaCBzdWJtaXNzaW9uIChub3QgYSBzZXJpZXMpLiBKZW5zIFdpa2xhbmRl cjogIkxvb2tzIGdvb2QuIEknbQ0KcGlja2luZyB1cCB0aGlzLiIgTWVyZ2VkIHZpYSBgb3B0ZWUt Zm9yLXY3LjJgIHRhZy4gTm8gTkFLcy4NCg0KIyMjIFN0ZXAgNC4yOiBSZXZpZXdlcnMNCioqUmVj b3JkOioqIFRvOiBKZW5zIFdpa2xhbmRlci4gQ2M6IFN1bWl0IEdhcmcsIG9wLQ0KdGVlQGxpc3Rz LnRydXN0ZWRmaXJtd2FyZS5vcmcsIGxpbnV4LWtlcm5lbC4gQXBwcm9wcmlhdGUgbWFpbnRhaW5l cnMNCmludm9sdmVkLg0KDQojIyMgU3RlcCA0LjM6IEJ1ZyBSZXBvcnQNCioqUmVjb3JkOioqIE5v IGZvcm1hbCBidWcgcmVwb3J0IG9yIHN5emJvdCBsaW5rLiBSZWFsLXdvcmxkIG1vdGl2YXRpb24N CmZyb20gQ2hyb21lL0FuZHJvaWQgTVRFICsgT1AtVEVFIGludGVncmF0aW9uLg0KDQojIyMgU3Rl cCA0LjQ6IFJlbGF0ZWQgUGF0Y2hlcw0KKipSZWNvcmQ6KiogU3RhbmRhbG9uZSBmaXg7IG5vIHNl cmllcyBkZXBlbmRlbmNpZXMuDQoNCiMjIyBTdGVwIDQuNTogU3RhYmxlIExpc3QgSGlzdG9yeQ0K KipSZWNvcmQ6KiogTm8gYENjOiBzdGFibGVgIG5vbWluYXRpb24gZm91bmQgaW4gcmV2aWV3IHRo cmVhZC4gQWJzZW5jZQ0KaXMgZXhwZWN0ZWQgcGVyIHJldmlldyBwaXBlbGluZSBydWxlcyBhbmQg aXMgbm90IGEgbmVnYXRpdmUgc2lnbmFsLg0KDQotLS0NCg0KIyMgUEhBU0UgNTogQ09ERSBTRU1B TlRJQyBBTkFMWVNJUw0KDQojIyMgU3RlcCA1LjE6IEtleSBGdW5jdGlvbnMNCioqUmVjb3JkOioq IGBpc19ub3JtYWxfbWVtb3J5KClgIChtb2RpZmllZCksIGBfX2NoZWNrX21lbV90eXBlKClgLA0K YG9wdGVlX2NoZWNrX21lbV90eXBlKClgIChjYWxsZXJzIHVuY2hhbmdlZCkuDQoNCiMjIyBTdGVw IDUuMjogQ2FsbGVycyBvZiBgb3B0ZWVfY2hlY2tfbWVtX3R5cGUoKWANCioqUmVjb3JkOioqDQot IGBvcHRlZV9zaG1fcmVnaXN0ZXIoKWAgaW4gYHNtY19hYmkuYzo0NjdgIOKAlCByZWdpc3RlcnMg dXNlci9rZXJuZWwNCiAgc2hhcmVkIG1lbW9yeSB3aXRoIHNlY3VyZSB3b3JsZA0KLSBgb3B0ZWVf c2htX3JlZ2lzdGVyX3N1cHAoKWAgaW4gYHNtY19hYmkuYzo1NzBgIOKAlCBzdXBwbGljYW50IHBh dGgNCiAgdmFsaWRhdGlvbg0KLSBgb3B0ZWVfZmZhX3NobV9yZWdpc3RlcigpYCBpbiBgZmZhX2Fi aS5jOjI4OWAg4oCUIEZGLUEgQUJJIHNoYXJlZCBtZW1vcnkNCiAgcmVnaXN0cmF0aW9uDQoNCiMj IyBTdGVwIDUuMzogQ2FsbGVlcw0KKipSZWNvcmQ6KiogYF9fY2hlY2tfbWVtX3R5cGUoKWAgd2Fs a3MgVk1BcyB2aWEgYGZvcl9lYWNoX3ZtYV9yYW5nZSgpYCwNCmNoZWNrcyBgdm1hLT52bV9wYWdl X3Byb3RgIGFnYWluc3QgYGlzX25vcm1hbF9tZW1vcnkoKWAuDQoNCiMjIyBTdGVwIDUuNDogUmVh Y2hhYmlsaXR5DQoqKlJlY29yZDoqKiBVc2Vyc3BhY2Ug4oaSIGAvZGV2L3RlZSpgIGlvY3RsIGBU RUVfSU9DX1NITV9SRUdJU1RFUmAg4oaSDQpgdGVlX2lvY3RsX3NobV9yZWdpc3RlcigpYCDihpIg YHRlZV9zaG1fcmVnaXN0ZXJfdXNlcl9idWYoKWAg4oaSDQpgcmVnaXN0ZXJfc2htX2hlbHBlcigp YCDihpIgYG9wdGVlX3NobV9yZWdpc3RlcigpYCDihpINCmBvcHRlZV9jaGVja19tZW1fdHlwZSgp YC4gKipSZWFjaGFibGUgZnJvbSB1c2Vyc3BhY2UqKiBvbiBBUk02NCBzeXN0ZW1zDQp3aXRoIE9Q LVRFRSBlbmFibGVkIHdoZW4gcmVnaXN0ZXJpbmcgTVRFLXRhZ2dlZCBidWZmZXJzLg0KDQojIyMg U3RlcCA1LjU6IFNpbWlsYXIgUGF0dGVybnMNCioqUmVjb3JkOioqIGBwdGVfdGFnZ2VkKClgIGlu IGBhcmNoL2FybTY0L2luY2x1ZGUvYXNtL3BndGFibGUuaGAgdXNlcw0KdGhlIHNhbWUgYE1UX05P Uk1BTF9UQUdHRURgIGNoZWNrIHBhdHRlcm4uIFRoZSBrZXJuZWwgYWxyZWFkeSB0cmVhdHMNCnRo aXMgYXMgYSBub3JtYWwtbWVtb3J5IHZhcmlhbnQgZWxzZXdoZXJlLg0KDQotLS0NCg0KIyMgUEhB U0UgNjogQ1JPU1MtUkVGRVJFTkNJTkcgQUdBSU5TVCBMT0NBTCBUUkVFICg2LjE4LjQzKQ0KDQoj IyMgU3RlcCA2LjE6IEJ1Z2d5IENvZGUgUHJlc2VudD8NCioqUmVjb3JkOioqICoqWUVTLioqIEN1 cnJlbnQgYGNhbGwuYzo2MDVgIG9ubHkgY2hlY2tzIGBNVF9OT1JNQUxgOg0KDQpgYGA2MDU6NjA1 OmRyaXZlcnMvdGVlL29wdGVlL2NhbGwuYw0KICAgICAgICByZXR1cm4gKHBncHJvdF92YWwocCkg JiBQVEVfQVRUUklORFhfTUFTSykgPT0NClBURV9BVFRSSU5EWChNVF9OT1JNQUwpOw0KYGBgDQoN CmBNVF9OT1JNQUxfVEFHR0VEYCBpcyBkZWZpbmVkIGF0IGBhcmNoL2FybTY0L2luY2x1ZGUvYXNt L21lbW9yeS5oOjE3MmAuDQpNVEUgc3VwcG9ydCBpcyBwcmVzZW50IChgUFJPVF9NVEVgIGluIGBE b2N1bWVudGF0aW9uL2FyY2gvYXJtNjQvbWVtb3J5LQ0KdGFnZ2luZy1leHRlbnNpb24ucnN0YCwg YGFyY2gvYXJtNjQva2VybmVsL210ZS5jYCkuDQoNCiMjIyBTdGVwIDYuMjogQmFja3BvcnQgQ29t cGxpY2F0aW9ucw0KKipSZWNvcmQ6KiogKipDbGVhbiBhcHBseSBleHBlY3RlZCoqIOKAlCAyLWxp bmUgY2hhbmdlIGluIGV4aXN0aW5nDQpmdW5jdGlvbiwgaWRlbnRpY2FsIGNvbnRleHQgdG8gbWFp bmxpbmUgZGlmZi4NCg0KIyMjIFN0ZXAgNi4zOiBSZWxhdGVkIEZpeGVzIEFscmVhZHkgUHJlc2Vu dD8NCioqUmVjb3JkOioqICoqTm8qKiDigJQgYGdpdCBsb2cgLS1ncmVwPSJNVF9OT1JNQUxfVEFH R0VEImAgYW5kDQpgLS1ncmVwPSJBbGxvdyBNVF9OT1JNQUxfVEFHR0VEImAgcmV0dXJuIG5vdGhp bmcgaW4gdGhpcyB0cmVlLiBGaXggbm90DQp5ZXQgYXBwbGllZC4NCg0KLS0tDQoNCiMjIFBIQVNF IDc6IFNVQlNZU1RFTSBBTkQgTUFJTlRBSU5FUiBDT05URVhUDQoNCiMjIyBTdGVwIDcuMTogU3Vi c3lzdGVtDQoqKlJlY29yZDoqKiBgZHJpdmVycy90ZWUvb3B0ZWVgIOKAlCBURUUvT1AtVEVFIGRy aXZlci4gKipDcml0aWNhbGl0eToNCklNUE9SVEFOVCoqIGZvciBBUk02NCBlbWJlZGRlZC9BbmRy b2lkIHBsYXRmb3JtcyB1c2luZyBzZWN1cmUgc2VydmljZXMNCihLZXltYXN0ZXIsIERSTSwgYmlv bWV0cmljcykuIE5vdCBjb3JlIGtlcm5lbCwgYnV0IHNlY3VyaXR5LQ0KaW5mcmFzdHJ1Y3R1cmUg cmVsZXZhbnQgb24gdGhvc2UgcGxhdGZvcm1zLg0KDQojIyMgU3RlcCA3LjI6IEFjdGl2aXR5DQoq KlJlY29yZDoqKiBPUC1URUUgZHJpdmVyIGlzIG1hdHVyZSBidXQgYWN0aXZlbHkgbWFpbnRhaW5l ZDsgTVRFDQphZG9wdGlvbiBpcyBhbiBvbmdvaW5nIEFSTTY0IHBsYXRmb3JtIGNvbmNlcm4uDQoN Ci0tLQ0KDQojIyBQSEFTRSA4OiBJTVBBQ1QgQU5EIFJJU0sgQVNTRVNTTUVOVA0KDQojIyMgU3Rl cCA4LjE6IFdobyBJcyBBZmZlY3RlZA0KKipSZWNvcmQ6KiogKipQbGF0Zm9ybS1zcGVjaWZpYzoq KiBBUk02NCArIGBDT05GSUdfT1BURUVgICsgdXNlcnNwYWNlDQp1c2luZyBgUFJPVF9NVEVgIG9u IGJ1ZmZlcnMgc2hhcmVkIHdpdGggT1AtVEVFLiBQcmltYXJpbHkgQW5kcm9pZC9DaHJvbWUNCk9T IGRldmljZXMgcm9sbGluZyBvdXQgTVRFLg0KDQojIyMgU3RlcCA4LjI6IFRyaWdnZXIgQ29uZGl0 aW9ucw0KKipSZWNvcmQ6KiogVXNlci9hcHBsaWNhdGlvbiBtYXBzIGFub255bW91cyBtZW1vcnkg d2l0aCBgUFJPVF9NVEVgLCB0aGVuDQpyZWdpc3RlcnMgaXQgd2l0aCBPUC1URUUgdmlhIGBURUVf SU9DX1NITV9SRUdJU1RFUmAuIFRyaWdnZXIgaXMNCmRldGVybWluaXN0aWMgKG5vdCBhIHJhY2Up LiBVbnByaXZpbGVnZWQgdXNlcnMgY2FuIHRyaWdnZXIgdmlhIFRFRSBpb2N0bA0Kb24gc3lzdGVt cyB3aXRoIGFjY2Vzc2libGUgYC9kZXYvdGVlKmAuDQoNCiMjIyBTdGVwIDguMzogRmFpbHVyZSBN b2RlIFNldmVyaXR5DQoqKlJlY29yZDoqKiAqKmAtRUlOVkFMYCBvbiBzaGFyZWQtbWVtb3J5IHJl Z2lzdHJhdGlvbioqIOKAlCBURUUvc2VjdXJlLQ0Kd29ybGQgb3BlcmF0aW9ucyBmYWlsIGVudGly ZWx5IGZvciBNVEUtZW5hYmxlZCBwcm9jZXNzZXMuIE5vIGNyYXNoLA0KY29ycnVwdGlvbiwgZGVh ZGxvY2ssIG9yIHNlY3VyaXR5IGV4cGxvaXQuICoqU2V2ZXJpdHk6IE1FRElVTSoqDQooY29tcGxl dGUgZnVuY3Rpb25hbCBicmVha2FnZSBmb3IgYWZmZWN0ZWQgY29uZmlndXJhdGlvbiwgYnV0IG5v dCBhDQpzdGFiaWxpdHkvc2VjdXJpdHkgY3Jhc2gpLg0KDQojIyMgU3RlcCA4LjQ6IFJpc2stQmVu ZWZpdA0KKipSZWNvcmQ6KioNCi0gKipCZW5lZml0OioqIFJlc3RvcmVzIE9QLVRFRSBmdW5jdGlv bmFsaXR5IGZvciBNVEUtZW5hYmxlZCBBUk02NA0KICBwcm9jZXNzZXM7IGltcG9ydGFudCBmb3Ig Q2hyb21lL0FuZHJvaWQgTVRFIHJvbGxvdXQgb24gVEVFLWVxdWlwcGVkDQogIGhhcmR3YXJlLg0K LSAqKlJpc2s6KiogVmVyeSBsb3cg4oCUIDIgbGluZXMsIEFSTTY0LW9ubHksIG1hdGNoZXMgZXhp c3Rpbmcga2VybmVsDQogIHNlbWFudGljcyBmb3IgYE1UX05PUk1BTF9UQUdHRURgLg0KLSAqKlJh dGlvOioqIEZhdm9yYWJsZSDigJQgdHJpdmlhbCBmaXgsIHJlYWwgcHJvZHVjdGlvbiBpbXBhY3Qg Zm9yIGENCiAgZ3Jvd2luZyBwbGF0Zm9ybSBjb25maWd1cmF0aW9uLg0KDQotLS0NCg0KIyMgUEhB U0UgOTogRklOQUwgU1lOVEhFU0lTDQoNCiMjIyBTdGVwIDkuMTogRXZpZGVuY2UgU3VtbWFyeQ0K DQoqKkZPUiBiYWNrcG9ydDoqKg0KLSBSZWFsLCByZXByb2R1Y2libGUgYnVnIGluIDYuMTguNDMg KGJ1Z2d5IGNvZGUgY29uZmlybWVkIHByZXNlbnQpDQotIFNtYWxsLCBvYnZpb3VzbHkgY29ycmVj dCwgbWFpbnRhaW5lci1yZXZpZXdlZCBmaXgNCi0gVXNlcnNwYWNlLXJlYWNoYWJsZSBvbiBBUk02 NCBPUC1URUUgc3lzdGVtcw0KLSBgTVRfTk9STUFMX1RBR0dFRGAgcHJlcmVxdWlzaXRlIGFscmVh ZHkgaW4gdHJlZQ0KLSBIYXJkd2FyZS1wbGF0Zm9ybSBjb21wYXRpYmlsaXR5IGZpeCAoQVJNNjQg TVRFKSwgYW5hbG9nb3VzIHRvDQogIHF1aXJrL3dvcmthcm91bmQgY2F0ZWdvcnkNCi0gQ2hyb21l IHByb2R1Y3Rpb24gbW90aXZhdGlvbiBmb3IgZ3Jvd2luZyBNVEUgZGVwbG95bWVudA0KDQoqKkFH QUlOU1QgYmFja3BvcnQ6KioNCi0gTm90IGEgY3Jhc2gsIGNvcnJ1cHRpb24sIGRlYWRsb2NrLCBv ciBzZWN1cml0eSB2dWxuZXJhYmlsaXR5DQotIE5pY2hlIGNvbmZpZ3VyYXRpb24gKEFSTTY0ICsg T1BURUUgKyBNVEUpDQotIE5vIHN5emJvdCByZXBvcnQgb3IgZXhwbGljaXQgc3RhYmxlIG5vbWlu YXRpb24NCi0gRnVuY3Rpb25hbCBgLUVJTlZBTGAgcmF0aGVyIHRoYW4ga2VybmVsIG9vcHMNCg0K KipVbnJlc29sdmVkOioqIEV4YWN0IGtlcm5lbCB2ZXJzaW9uIHdoZW4gTVRFIHVzZXJzcGFjZSAr IE9QLVRFRQ0KY29tYmluYXRpb24gYmVjYW1lIGNvbW1vbiBpbiBwcm9kdWN0aW9uIChub3QgbmVl ZGVkIGZvciBkZWNpc2lvbiDigJQgYnVnDQptZWNoYW5pc20gaXMgY2xlYXIpLg0KDQojIyMgU3Rl cCA5LjI6IFN0YWJsZSBSdWxlcyBDaGVja2xpc3QNCjEuIE9idmlvdXNseSBjb3JyZWN0IGFuZCB0 ZXN0ZWQ/ICoqUEFTUyoqIOKAlCBsb2dpYyBtYXRjaGVzIGBtZW1vcnkuaGANCiAgIGRvY3VtZW50 YXRpb247IHJldmlld2VkIGJ5IE9QLVRFRSBhbmQgVEVFIG1haW50YWluZXJzLg0KMi4gRml4ZXMg YSByZWFsIGJ1ZyBhZmZlY3RpbmcgdXNlcnM/ICoqUEFTUyoqIOKAlCBkZXRlcm1pbmlzdGljIGAt RUlOVkFMYA0KICAgYmxvY2tpbmcgVEVFIHNoYXJlZCBtZW1vcnkgZm9yIE1URSBidWZmZXJzLg0K My4gSW1wb3J0YW50IGlzc3VlPyAqKlBBU1MgKGJvcmRlcmxpbmUpKiog4oCUIG5vdCBhIGNyYXNo L2NvcnJ1cHRpb24sIGJ1dA0KICAgY29tcGxldGUgYnJlYWthZ2Ugb2Ygc2VjdXJlLXdvcmxkIGNv bW11bmljYXRpb24gZm9yIE1URSBwcm9jZXNzZXMgb24NCiAgIEFSTTY0IEFuZHJvaWQvQ2hyb21l IHBsYXRmb3Jtcy4NCjQuIFNtYWxsIGFuZCBjb250YWluZWQ/ICoqUEFTUyoqIOKAlCAyIGxpbmVz LCAxIGZpbGUsIDEgZnVuY3Rpb24uDQo1LiBObyBuZXcgZmVhdHVyZXMgb3IgQVBJcz8gKipQQVNT Kiog4oCUIGV4dGVuZHMgcmVjb2duaXRpb24gb2YgZXhpc3RpbmcNCiAgIG1lbW9yeSB0eXBlOyBu byBuZXcgQVBJLg0KNi4gQ2FuIGFwcGx5IHRvIGxvY2FsIHRyZWU/ICoqUEFTUyoqIOKAlCBwcmVy ZXF1aXNpdGVzIHByZXNlbnQsIGNsZWFuDQogICBhcHBseSBleHBlY3RlZC4NCg0KIyMjIFN0ZXAg OS4zOiBFeGNlcHRpb24gQ2F0ZWdvcnkNCioqUmVjb3JkOioqICoqSGFyZHdhcmUvcGxhdGZvcm0g d29ya2Fyb3VuZCoqIOKAlCBlbmFibGVzIGNvcnJlY3QgaGFuZGxpbmcNCm9mIEFSTTY0IE1URS10 YWdnZWQgbm9ybWFsIG1lbW9yeSwgYW5hbG9nb3VzIHRvIHRoZSBxdWlyay9jb21wYXRpYmlsaXR5 DQpleGNlcHRpb24gY2F0ZWdvcnkgaW4gc3RhYmxlIHJ1bGVzLg0KDQojIyMgU3RlcCA5LjQ6IERl Y2lzaW9uIFJhdGlvbmFsZQ0KDQpUaGlzIGNvbW1pdCBmaXhlcyBhIHJlYWwgY29tcGF0aWJpbGl0 eSBnYXAgYmV0d2VlbiBBUk02NCBNVEUNCihgTVRfTk9STUFMX1RBR0dFRGApIGFuZCB0aGUgT1At VEVFIGRyaXZlcidzIHNoYXJlZC1tZW1vcnkgdmFsaWRhdG9yLg0KVGhlIGJ1ZyBleGlzdHMgaW4g TGludXggNi4xOC40MywgdGhlIGZpeCBpcyB0cml2aWFsIGFuZCBtYWludGFpbmVyLQ0KYXBwcm92 ZWQsIGFuZCBhbGwgcHJlcmVxdWlzaXRlcyAoYE1UX05PUk1BTF9UQUdHRURgLCBNVEUgc3VwcG9y dCkgYXJlDQphbHJlYWR5IGluIHRoaXMgdHJlZS4gV2hpbGUgdGhlIGZhaWx1cmUgbW9kZSBpcyBm dW5jdGlvbmFsIHJhdGhlciB0aGFuIGENCmtlcm5lbCBjcmFzaCwgaXQgY29tcGxldGVseSBibG9j a3MgVEVFIG9wZXJhdGlvbnMgZm9yIE1URS1lbmFibGVkDQpwcm9jZXNzZXMg4oCUIGEgZ3Jvd2lu ZyBjb25jZXJuIG9uIEFSTTY0IEFuZHJvaWQvQ2hyb21lIHBsYXRmb3JtcyB3aGVyZQ0KYm90aCBP UC1URUUgYW5kIE1URSBhcmUgZGVwbG95ZWQgdG9nZXRoZXIuIFRoZSBmaXggaXMgbG93LXJpc2sg YW5kIGZpdHMNCnRoZSBzdGFibGUgcGF0dGVybiBmb3Igc21hbGwgcGxhdGZvcm0gY29tcGF0aWJp bGl0eSBjb3JyZWN0aW9ucy4NCg0KLS0tDQoNCiMjIFZlcmlmaWNhdGlvbg0KDQotIFtQaGFzZSAx XSBQYXJzZWQgc3ViamVjdCwgdGFncywgYm9keSBmcm9tIHByb3ZpZGVkIGNvbW1pdCBtZXNzYWdl DQotIFtQaGFzZSAxXSBDb25maXJtZWQgbm8gYEZpeGVzOmAsIGBSZXBvcnRlZC1ieTpgLCBvciBg Q2M6IHN0YWJsZWAgdGFncw0KLSBbUGhhc2UgMl0gUmVhZCBkaWZmOiArMi8tMSBpbiBgaXNfbm9y bWFsX21lbW9yeSgpYCwgQVJNNjQgYnJhbmNoIG9ubHkNCi0gW1BoYXNlIDJdIFJlYWQgYGNhbGwu Yzo1OTktNjQyYCDigJQgY29uZmlybWVkIGN1cnJlbnQgY29kZSBvbmx5IGNoZWNrcw0KICBgTVRf Tk9STUFMYA0KLSBbUGhhc2UgM10gYGdpdCBkZXNjcmliZSBIRUFEYCDihpIgYHY2LjE4LjQzYDsg YG1ha2Uga2VybmVsdmVyc2lvbmAg4oaSDQogIGA2LjE4LjQzYA0KLSBbUGhhc2UgM10gYGdpdCBi bGFtZSAtTCA1OTksNjEwIGRyaXZlcnMvdGVlL29wdGVlL2NhbGwuY2Ag4oCUIGZ1bmN0aW9uDQog IHByZXNlbnQgaW4gdHJlZQ0KLSBbUGhhc2UgM10gV2ViIHNlYXJjaDogb3JpZ2luYWwgYGlzX25v cm1hbF9tZW1vcnlgIGludHJvZHVjZWQgfjIwMTcgaW4NCiAgT1AtVEVFIHNobSB0eXBlIGNoZWNr IHBhdGNoDQotIFtQaGFzZSAzXSBgZ2l0IGxvZyAtLWdyZXA9IkFsbG93IE1UX05PUk1BTF9UQUdH RUQiYCDigJQgbm8gbWF0Y2ggKGZpeA0KICBub3QgaW4gdHJlZSkNCi0gW1BoYXNlIDRdIEZldGNo ZWQgc3Bpbmljcy5uZXQgbXNnNjE1Nzk4NSwgbXNnNjE2MTU5NSwgbXNnNjE3NDQwMyDigJQNCiAg bWFpbnRhaW5lciByZXZpZXcsIG5vIE5BS3MsIG5vIHN0YWJsZSBDYw0KLSBbUGhhc2UgNF0gYjQg ZGlnIHVuYXZhaWxhYmxlIGZvciBjb21taXQgaGFzaCAoZml4IG5vdCBtZXJnZWQgaW4gdGhpcw0K ICB0cmVlKTsgdXNlZCBzcGluaWNzL29wZW53YWxsIGluc3RlYWQNCi0gW1BoYXNlIDVdIGBncmVw IG9wdGVlX2NoZWNrX21lbV90eXBlYCDigJQgMyBjYWxsIHNpdGVzIGluIGBzbWNfYWJpLmNgLA0K ICBgZmZhX2FiaS5jYA0KLSBbUGhhc2UgNV0gUmVhZCBgdGVlX3NobS5jOjQ5Ni01MTZgIOKAlCB1 c2Vyc3BhY2UgcmVnaXN0cmF0aW9uIHBhdGggdmlhDQogIGB0ZWVfc2htX3JlZ2lzdGVyX3VzZXJf YnVmKClgDQotIFtQaGFzZSA1XSBSZWFkIGBzbWNfYWJpLmM6NDUzLTQ2OWAg4oCUIGBvcHRlZV9z aG1fcmVnaXN0ZXIoKWAgY2FsbHMNCiAgYG9wdGVlX2NoZWNrX21lbV90eXBlKClgDQotIFtQaGFz ZSA2XSBDb25maXJtZWQgYE1UX05PUk1BTF9UQUdHRURgIGRlZmluZWQgYXQNCiAgYGFyY2gvYXJt NjQvaW5jbHVkZS9hc20vbWVtb3J5Lmg6MTcyYA0KLSBbUGhhc2UgNl0gQ29uZmlybWVkIGBwdGVf dGFnZ2VkKClgIHVzZXMgc2FtZSBgTVRfTk9STUFMX1RBR0dFRGANCiAgcGF0dGVybiBpbiBgcGd0 YWJsZS5oOjE5MS0xOTJgDQotIFtQaGFzZSA2XSBgZ3JlcCBQUk9UX01URWAg4oCUIE1URSB1c2Vy c3BhY2Ugc3VwcG9ydCBwcmVzZW50IGluIHRyZWUNCi0gW1BoYXNlIDhdIFRyYWNlZCBjYWxsIGNo YWluOiBpb2N0bCDihpIgc2htIHJlZ2lzdGVyIOKGkg0KICBgb3B0ZWVfY2hlY2tfbWVtX3R5cGUo KWAg4oaSIGAtRUlOVkFMYCBvbiBNVEUgYnVmZmVycw0KDQoqKllFUyoqVGhlIGJhY2tncm91bmQg YGdpdCBsb2cgLVMgImlzX25vcm1hbF9tZW1vcnkiYCBzZWFyY2ggZmluaXNoZWQuDQpJdCBkaWRu 4oCZdCB0dXJuIHVwIGEgY2xlYW4gaW50cm9kdWN0aW9uIHBvaW50IGZvciBgaXNfbm9ybWFsX21l bW9yeSgpYCBpbg0KdGhpcyA2LjE4LjQzIHN0YWJsZSB0cmVlIOKAlCB0aGUgaGl0cyB3ZXJlIHVu cmVsYXRlZCAoTUlQUykgb3IgYXJ0aWZhY3RzDQpvZiB0aGUgZmxhdHRlbmVkIHBlci1maWxlIGhp c3RvcnkgKHRoZSB3aG9sZSBgY2FsbC5jYCBsdW1wZWQgdW5kZXIgb25lDQp1cHN0cmVhbSBtZXJn ZSkuIEV4dGVybmFsIGhpc3Rvcnkgc3RpbGwgcG9pbnRzIHRvIHRoZSBvcmlnaW5hbCBPUC1URUUN CnNoYXJlZC1tZW1vcnkgdHlwZSBjaGVjayBmcm9tIH4yMDE3Lg0KDQpUaGF0IGRvZXNu4oCZdCBj aGFuZ2UgdGhlIGVhcmxpZXIgY29uY2x1c2lvbjogdGhlIGJ1Z2d5IGBNVF9OT1JNQUxgLW9ubHkN CmNoZWNrIGlzIHByZXNlbnQgaW4gdGhpcyB0cmVlLCB0aGUgZml4IGlzIHNtYWxsIGFuZCBjb3Jy ZWN0LCBhbmQgaXQNCnNob3VsZCBiZSBiYWNrcG9ydGVkLg0KDQoqKllFUyoqDQoNCiBkcml2ZXJz L3RlZS9vcHRlZS9jYWxsLmMgfCAzICsrLQ0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMo KyksIDEgZGVsZXRpb24oLSkNCg0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGVlL29wdGVlL2NhbGwu YyBiL2RyaXZlcnMvdGVlL29wdGVlL2NhbGwuYw0KaW5kZXggMTZlYjk1M2UxNGJiNi4uZTQyMmU3 N2IwNmZiOCAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvdGVlL29wdGVlL2NhbGwuYw0KKysrIGIvZHJp dmVycy90ZWUvb3B0ZWUvY2FsbC5jDQpAQCAtNjAyLDcgKzYwMiw4IEBAIHN0YXRpYyBib29sIGlz X25vcm1hbF9tZW1vcnkocGdwcm90X3QgcCkNCiAJcmV0dXJuICgoKHBncHJvdF92YWwocCkgJiBM X1BURV9NVF9NQVNLKSA9PSBMX1BURV9NVF9XUklURUFMTE9DKSB8fA0KIAkJKChwZ3Byb3RfdmFs KHApICYgTF9QVEVfTVRfTUFTSykgPT0gTF9QVEVfTVRfV1JJVEVCQUNLKSk7DQogI2VsaWYgZGVm aW5lZChDT05GSUdfQVJNNjQpDQotCXJldHVybiAocGdwcm90X3ZhbChwKSAmIFBURV9BVFRSSU5E WF9NQVNLKSA9PSBQVEVfQVRUUklORFgoTVRfTk9STUFMKTsNCisJcmV0dXJuICgocGdwcm90X3Zh bChwKSAmIFBURV9BVFRSSU5EWF9NQVNLKSA9PSBQVEVfQVRUUklORFgoTVRfTk9STUFMKSkgfHwN CisJICAgICAgICgocGdwcm90X3ZhbChwKSAmIFBURV9BVFRSSU5EWF9NQVNLKSA9PSBQVEVfQVRU UklORFgoTVRfTk9STUFMX1RBR0dFRCkpOw0KICNlbHNlDQogI2Vycm9yICJVbnN1cHBvcnRlZCBh cmNoaXRlY3R1cmUiDQogI2VuZGlmDQotLSANCjIuNTMuMA0KDQo=