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 616A84A33ED; Mon, 31 Aug 2026 13:38:50 +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=1788183534; cv=none; b=P68E/SQsn+2HFdKf59hucVK1fVCAmnspagc9W5KgF8V8Q2+WHP21sUWQcl1jnB9vyueSIUIx7pB9Q3LRK+hSXTe9rG0LvSoXBiwJ3tFWxdPOtMJcbfyH1YYHc5uIIBLzER47pk2sGfR2JvgGnIVxv9Qoe31+XFrmvSGmtVgNlw0= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788183534; c=relaxed/simple; bh=rhCm0geAEcF9Tc1PkDh0hEw8dNE+axynZR4UwU+wN44=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=uuomDr49jlo0RHYOAxAq6fNsqaZdyueOzXRWUmSU6R2zVr/KBKT3fmUfWPfiHA+nFHMR6JbMevrPAIoUU47TpcbmkMUhXug2pQT4qdLQwjwlaXXgz7A+xR8rCoI2XZeiaTJfhx6ch1Ll7qJsRL5+OwTg7xX7l9Zvnz5LfwtAvzc= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=BOmNNTTS; 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="BOmNNTTS" Received: by smtp.kernel.org (Postfix) with ESMTPSA id C3E651F00A3D; Mon, 31 Aug 2026 13:38:48 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788183529; bh=GTJoiATLXiVe4pp58dNbtYx4Hn8uoVn3LxZcZyWNLCg=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=BOmNNTTSjjCCuSfmyoaf0qle6/YjxFJNDuXvIB2/fwTjJw7tk2yfzTfw+mQyWlaLv e8vLDEuRooziplxOpPQM6WaYPoMnpsDzSVH0dOCdQRwJzjyZRqIq3qjA58yTY9dc4A tl8abjZQbMlu9bvICbC/Sz7JjOHiHtzQGrACO2aEvIfb6x8jXO5Bz36vkEAv2PsYK2 NxTbVxjtV+o9CWBk0GfSvlLzMbw4j9ABGwvNmCBR62uiU2nHA3dH+0ese/E4g2sYCD kshT/tuIRCF4457nvigcbVhTOWimP7MsXQBNlFLaNbzHxNw4VWjYeZ9BbfrQXLq1WK ex7MQOaRfmpvQ== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: Han Gao , Paul Walmsley , Sasha Levin , palmer@dabbelt.com, aou@eecs.berkeley.edu, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 6.18] riscv: kexec_file: Constrain segment placement to direct map Date: Mon, 31 Aug 2026 09:22:59 -0400 Message-ID: <20260831133314.4125787-151-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: Han Gao [ Upstream commit b67a1ee0db0094c6cc158b087be6c334ad881a41 ] When kexec_file_load places segments with buf_max=ULONG_MAX and top_down=true, they land at the highest available physical addresses. On RISC-V the size of the linear mapping is determined by the active VM mode: SV39 caps the direct map at roughly 128GB, while SV48/SV57 extend the range substantially further. When the installed physical memory exceeds the direct map size of the active mode, top-down placement puts DTB/initrd at physical addresses outside the linearly mapped region. The kexec'd kernel cannot reach them during early boot, triggering a page fault at memcmp in start_kernel. Fix by constraining buf_max to PFN_PHYS(max_low_pfn), which reflects the runtime direct map boundary for the active VM mode (SV39/SV48/ SV57). This keeps all kexec segments within the linearly mapped region while preserving the upstream top_down allocation strategy. Signed-off-by: Han Gao Link: https://patch.msgid.link/20260519170641.123517-1-gaohan@iscas.ac.cn Signed-off-by: Paul Walmsley Signed-off-by: Sasha Levin --- LLM Generated explanations, may be completely bogus: ## Phase 1: Commit Message Forensics **Step 1.1 — Subject line** Record: `[riscv: kexec_file]` `[Constrain]` — Constrain kexec_file segment placement to stay within the RISC-V direct (linear) map. **Step 1.2 — Tags** Record: - `Signed-off-by: Han Gao ` (author) - `Link: https://patch.msgid.link/20260519170641.123517-1-gaohan@iscas.ac.cn` - `Signed-off-by: Paul Walmsley ` (RISC-V maintainer) - No `Fixes:`, `Reported-by:`, `Tested-by:`, `Reviewed-by:`, `Cc: stable@vger.kernel.org` - Notable: maintainer ack; no syzbot or user bug report tags **Step 1.3 — Body analysis** Record: - **Bug:** With `buf_max=ULONG_MAX` and `top_down=true`, kexec_file segments (DTB, initrd, purgatory, elfcorehdr) are placed at the highest physical addresses. On RISC-V, the linear map size depends on the active VM mode (SV39 ≈ 128 GB; SV48/SV57 larger). When installed RAM exceeds the direct-map limit, segments land outside the linearly mapped region. - **Symptom:** The kexec'd kernel page-faults in `memcmp` during `start_kernel` because it cannot access initrd/DTB. - **Root cause:** Top-down placement is unconstrained by the direct-map boundary. - **Fix approach:** Set `buf_max = PFN_PHYS(max_low_pfn)` to cap placement at the runtime direct-map limit. **Step 1.4 — Hidden bug fix?** Record: No — this is an explicit bug fix, not disguised cleanup. It prevents a deterministic boot crash on affected hardware. --- ## Phase 2: Diff Analysis **Step 2.1 — Inventory** Record: - **Files:** `arch/riscv/kernel/machine_kexec_file.c` (+2, −1) - **Functions:** `load_extra_segments()` - **Scope:** Single-file, surgical (3 lines net) **Step 2.2 — Code flow change** Record: - **Before:** `kbuf.buf_max = ULONG_MAX` — top-down placement can use any system RAM address up to `ULONG_MAX`. - **After:** `kbuf.buf_max = PFN_PHYS(max_low_pfn)` — top-down placement is capped at the end of the linearly mapped region. - **Path affected:** `load_extra_segments()` → `kexec_add_buffer()` → `kexec_locate_mem_hole()` → `locate_mem_hole_top_down()`, which uses `temp_end = min(end, kbuf->buf_max)`. **Step 2.3 — Bug mechanism** Record: - **Category:** Logic/correctness — incorrect memory placement. - **Mechanism:** `locate_mem_hole_top_down()` in `kernel/kexec_file.c` places buffers at the top of each RAM range, bounded only by `buf_max`. With `ULONG_MAX`, segments can be placed beyond the direct map. The kexec'd kernel's early boot uses `__va()`/linear mapping to access DTB/initrd, causing a page fault if those addresses are not linearly mapped. **Step 2.4 — Fix quality** Record: - Fix is minimal and clearly correct: `max_low_pfn` is set after memblock capping in `arch/riscv/mm/init.c` when RAM exceeds `KERN_VIRT_SIZE`. - `max_low_pfn` is already declared in `linux/memblock.h` (already included). - Regression risk is very low; worst case is `-EADDRNOTAVAIL` if no hole exists within the constrained range (preferable to a boot crash). --- ## Phase 3: Git History Investigation **Step 3.1 — Blame** Record: `kbuf.buf_max = ULONG_MAX` introduced in `1df45f8a9fea5` (Song Shuai, 2025-04-09) during the `load_extra_segments()` refactor. The underlying `top_down=true` + `ULONG_MAX` pattern dates to `49af7a2cd5f67` (Torsten Duwe, 2023-08-04) in the pre-refactor `elf_kexec.c`. **Step 3.2 — Fixes: tag** Record: No `Fixes:` tag. The regression was introduced by `49af7a2cd5f67` ("riscv/kexec: load initrd high in available memory"), which is an ancestor of this 6.18.y tree. **Step 3.3 — Related commits** Record: - `1df45f8a9fea5` — split loading into `load_extra_segments()` (present in tree) - `809a11eea8e8c` — Image binary kexec_file support (present) - `49af7a2cd5f67` — top_down initrd loading (present; had `Cc: stable@vger.kernel.org`) - `b67a1ee0db009` — this fix (on master; **not** in 6.18.y) - Standalone fix, not part of a series. **Step 3.4 — Author context** Record: Han Gao is an active RISC-V contributor (DTS, ACPI). Paul Walmsley committed the fix. No prior kexec work from this author in this tree. **Step 3.5 — Dependencies** Record: No prerequisites. Patch applies cleanly (`git apply --check` passed). `load_extra_segments()` and `machine_kexec_file.c` exist in 6.18.44. --- ## Phase 4: Mailing List and External Research **Step 4.1 — Original discussion** Record: - `b4 dig -c b67a1ee0db009`: https://patch.msgid.link/20260519170641.123517-1-gaohan@iscas.ac.cn - Single v1 patch (no revisions) - Paul Walmsley replied: "Thanks, queued for v7.1-rc." - No explicit stable nomination in thread; no NAKs **Step 4.2 — Reviewers** Record: CC'd to Paul Walmsley, Palmer Dabbelt, Alexandre Ghiti, Song Shuai, Björn Töpel, Breno Leitao, Kees Cook, linux-riscv@, linux-kernel@ **Step 4.3 — Bug report** Record: No external bug report or syzbot link. Bug described in commit message with concrete failure mode (`memcmp` page fault in `start_kernel`). **Step 4.4 — Series context** Record: Standalone 1-patch fix. **Step 4.5 — Stable list** Record: No stable-list discussion found for this specific fix. The original top_down commit (`49af7a2cd5f67`) was nominated for stable. --- ## Phase 5: Code Semantic Analysis **Step 5.1 — Key functions** Record: `load_extra_segments()` (modified); callers: `elf_kexec_load()` in `kexec_elf.c`, `image_load()` in `kexec_image.c`. **Step 5.2 — Callers** Record: - `elf_kexec_load()` — ELF vmlinux kexec_file path - `image_load()` — raw Image kexec_file path - Both invoked from the kexec_file syscall path (`kexec_file_load`) **Step 5.3 — Callees** Record: `kexec_add_buffer()`, `kexec_load_purgatory()`, `of_kexec_alloc_and_setup_fdt()`, `prepare_elf_headers()` (kdump). **Step 5.4 — Reachability** Record: Reachable from userspace via `kexec_file_load()` when `CONFIG_KEXEC_FILE` is enabled on RISC-V. Affects initrd, DTB, purgatory, and kdump elfcorehdr placement. Trigger requires physical RAM exceeding the direct-map size (e.g. >~128 GB on SV39). **Step 5.5 — Similar patterns** Record: `kexec_elf.c` and `kexec_image.c` still use `buf_max = ULONG_MAX` for kernel loading, but with `top_down = false` (bottom-up), so they are not affected. Only `load_extra_segments()` uses `top_down = true` with unconstrained `buf_max`. --- ## Phase 6: Cross-Reference Against Local Tree (6.18.44) **Step 6.1 — Buggy code present?** Record: **Yes.** Local tree is `v6.18.44` on `stable/linux-6.18.y`. Line 269 of `arch/riscv/kernel/machine_kexec_file.c` still has `kbuf.buf_max = ULONG_MAX`. Bug present since `49af7a2cd5f67` (2023); refactor in `1df45f8a9fea5` (merged in 6.16) moved code without fixing the issue. **Step 6.2 — Backport complications** Record: Patch applies cleanly with no conflicts. Two-line functional change plus one include. **Step 6.3 — Related fixes already present?** Record: Fix commit `b67a1ee0db009` is **not** in 6.18.y (`git merge-base --is-ancestor` confirms). No alternative fix found. --- ## Phase 7: Subsystem and Maintainer Context **Step 7.1 — Subsystem** Record: `arch/riscv` — kexec_file boot path. Criticality: **IMPORTANT** (not universal core, but boot/crash-dump infrastructure for RISC-V servers). **Step 7.2 — Activity** Record: Active subsystem; recent kexec_file work includes Image support (6.16) and `load_extra_segments()` refactor. --- ## Phase 8: Impact and Risk Assessment **Step 8.1 — Who is affected** Record: RISC-V systems with `CONFIG_KEXEC_FILE` (and optionally `CONFIG_CRASH_DUMP`) where installed RAM exceeds the direct-map size for the active VM mode (most commonly SV39 with >~128 GB). Server-class hardware (e.g. high-memory SG2042-class platforms). **Step 8.2 — Trigger conditions** Record: - User/admin invokes `kexec_file_load` (fast reboot or kdump setup) - System RAM exceeds linear-map capacity - Not timing-dependent; deterministic on affected configs - Requires root (kexec syscall), not an unprivileged attack vector **Step 8.3 — Failure severity** Record: **CRITICAL** — kexec'd kernel cannot boot; page fault during early `start_kernel`. kdump may also fail to capture crashes on large- memory systems. **Step 8.4 — Risk-benefit** Record: - **Benefit:** HIGH for affected RISC-V kexec/kdump users - **Risk:** VERY LOW — 3-line change, well-understood boundary, maintainer-reviewed - **Ratio:** Strongly favors backport --- ## Phase 9: Final Synthesis **Evidence FOR backport:** - Fixes a real, reproducible boot crash on large-memory RISC-V systems - Small, surgical, maintainer-committed fix - Applies cleanly to 6.18.y - Bug has existed since Aug 2023 (top_down placement) - Underlying regression commit is in this tree - Same pattern as the original top_down commit, which was stable- nominated **Evidence AGAINST:** - Affects a config-specific subset (RISC-V + kexec_file + high memory) - No syzbot/user Reported-by tags - No explicit stable nomination on this patch **Stable rules checklist:** 1. Obviously correct and tested? **PASS** — logic verified against `locate_mem_hole_top_down()` and `max_low_pfn` setup in `arch/riscv/mm/init.c`; maintainer committed 2. Fixes a real bug? **PASS** — kexec boot failure on large-memory RISC-V 3. Important issue? **PASS** — boot crash / kdump failure (CRITICAL for affected users) 4. Small and contained? **PASS** — 3 lines, one file 5. No new features/APIs? **PASS** — constraint only 6. Can apply to local tree? **PASS** — clean apply verified **Exception category:** N/A (standard bug fix) --- ## Verification - [Phase 1] Parsed commit message and tags from user-provided diff and `git show b67a1ee0db009` - [Phase 2] Read current `machine_kexec_file.c` and `locate_mem_hole_top_down()` in `kernel/kexec_file.c` - [Phase 3] `git blame`: buggy line from `1df45f8a9fea5`; top_down from `49af7a2cd5f67` - [Phase 3] `git merge-base --is-ancestor`: bug commit in tree, fix commit not in tree - [Phase 3] `git log --oneline -20 -- arch/riscv/kernel/machine_kexec_file.c` - [Phase 3] `git apply --check` on fix patch: applies cleanly - [Phase 4] `b4 dig -c b67a1ee0db009 -w -a -m`: lore URL, recipients, v1 only, Paul Walmsley ack - [Phase 4] Read `/tmp/kexec_direct_map.mbox`: no stable nomination, no NAKs - [Phase 5] `grep load_extra_segments`: callers in `kexec_elf.c`, `kexec_image.c` - [Phase 5] Verified `kexec_locate_mem_hole()` uses `kexec_walk_resources()` on non-ACPI RISC-V (no `ARCH_KEEP_MEMBLOCK`) - [Phase 6] `git describe HEAD`: v6.18.44; buggy `ULONG_MAX` at line 269 confirmed - [Phase 6] Read `arch/riscv/mm/init.c` lines 264–295: memblock capping and `max_low_pfn` assignment - [Phase 6] Read `arch/riscv/include/asm/pgtable.h`: `KERN_VIRT_SIZE`, `DIRECT_MAP_PHYSMEM_END` - [Phase 8] Confirmed failure mode: page fault in early boot of kexec'd kernel This fix prevents kexec_file and kdump failures on RISC-V systems where physical memory exceeds the SV39 direct-map limit (~128 GB). The bug is present in 6.18.44, the patch is minimal and applies cleanly, and the failure mode is a boot crash — a clear stable backport candidate for this tree. **YES**The background search finished successfully. It didn’t print matches on its own, but the earlier investigation already pinned the fix to **`b67a1ee0db009`** on master (`riscv: kexec_file: Constrain segment placement to direct map`). **Verdict for this tree (linux-6.18.y / v6.18.44): YES** - The bug is present: `load_extra_segments()` still uses `buf_max = ULONG_MAX` with top-down placement. - On RISC-V systems with RAM beyond the SV39 direct map (~128 GB), kexec_file can place DTB/initrd outside the linear map, causing the kexec'd kernel to page-fault during early boot. - The fix is a 3-line change that applies cleanly; it should be backported to 6.18.y. arch/riscv/kernel/machine_kexec_file.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/arch/riscv/kernel/machine_kexec_file.c b/arch/riscv/kernel/machine_kexec_file.c index dd9d92a965174..b5fe17238df2f 100644 --- a/arch/riscv/kernel/machine_kexec_file.c +++ b/arch/riscv/kernel/machine_kexec_file.c @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include @@ -266,7 +267,7 @@ int load_extra_segments(struct kimage *image, unsigned long kernel_start, kbuf.image = image; kbuf.buf_min = kernel_start + kernel_len; - kbuf.buf_max = ULONG_MAX; + kbuf.buf_max = PFN_PHYS(max_low_pfn); #ifdef CONFIG_CRASH_DUMP /* Add elfcorehdr */ -- 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 37A58C624A4 for ; Mon, 31 Aug 2026 13:39:06 +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=xSBrCpJQdHtFacKy2BdIf8Lrzn57WXqYocRWJRG2LtE=; b=FmY5lbM4xqUlIc 03i4Vr/LmgjD7Zbe5hIhX3OiMD0KtwqnZOiwqNBj/siKwv/z49t7MoS4AJeUoZrmUhWgeRMQJMdf6 lL3GXqrX7PM5RGRPOWO0es1KrJEJXHMdo986l06iu6CsOU3Jc9xTB4PvMLlY4tBxba6C1Gr4QxEDG j+kFjuETI9MFPxul/RtKiix1gfzDLQ863fRghlkXg07Gqgma2ydTxjRZHkTSy08VAqXciWfCZrihe fxgH6kHwt100OSUceDmjFTeDN1ZII9Y7hIO3NgN2MMN7mZDHUUCf6v8awX2hbeKv0SVMgMd5we0/o +avJ+ZJN4Lxigc00WBRw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1x12Dt-00000009RwR-0g0t; Mon, 31 Aug 2026 13:38:53 +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 1x12Dr-00000009RvQ-18Pf for linux-riscv@lists.infradead.org; Mon, 31 Aug 2026 13:38:51 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 0AC3A4050A; Mon, 31 Aug 2026 13:38:50 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id C3E651F00A3D; Mon, 31 Aug 2026 13:38:48 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788183529; bh=GTJoiATLXiVe4pp58dNbtYx4Hn8uoVn3LxZcZyWNLCg=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=BOmNNTTSjjCCuSfmyoaf0qle6/YjxFJNDuXvIB2/fwTjJw7tk2yfzTfw+mQyWlaLv e8vLDEuRooziplxOpPQM6WaYPoMnpsDzSVH0dOCdQRwJzjyZRqIq3qjA58yTY9dc4A tl8abjZQbMlu9bvICbC/Sz7JjOHiHtzQGrACO2aEvIfb6x8jXO5Bz36vkEAv2PsYK2 NxTbVxjtV+o9CWBk0GfSvlLzMbw4j9ABGwvNmCBR62uiU2nHA3dH+0ese/E4g2sYCD kshT/tuIRCF4457nvigcbVhTOWimP7MsXQBNlFLaNbzHxNw4VWjYeZ9BbfrQXLq1WK ex7MQOaRfmpvQ== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: Han Gao , Paul Walmsley , Sasha Levin , palmer@dabbelt.com, aou@eecs.berkeley.edu, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 6.18] riscv: kexec_file: Constrain segment placement to direct map Date: Mon, 31 Aug 2026 09:22:59 -0400 Message-ID: <20260831133314.4125787-151-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-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org RnJvbTogSGFuIEdhbyA8Z2FvaGFuQGlzY2FzLmFjLmNuPgoKWyBVcHN0cmVhbSBjb21taXQgYjY3 YTFlZTBkYjAwOTRjNmNjMTU4YjA4N2JlNmMzMzRhZDg4MWE0MSBdCgpXaGVuIGtleGVjX2ZpbGVf bG9hZCBwbGFjZXMgc2VnbWVudHMgd2l0aCBidWZfbWF4PVVMT05HX01BWCBhbmQKdG9wX2Rvd249 dHJ1ZSwgdGhleSBsYW5kIGF0IHRoZSBoaWdoZXN0IGF2YWlsYWJsZSBwaHlzaWNhbCBhZGRyZXNz ZXMuCk9uIFJJU0MtViB0aGUgc2l6ZSBvZiB0aGUgbGluZWFyIG1hcHBpbmcgaXMgZGV0ZXJtaW5l ZCBieSB0aGUgYWN0aXZlClZNIG1vZGU6IFNWMzkgY2FwcyB0aGUgZGlyZWN0IG1hcCBhdCByb3Vn aGx5IDEyOEdCLCB3aGlsZSBTVjQ4L1NWNTcKZXh0ZW5kIHRoZSByYW5nZSBzdWJzdGFudGlhbGx5 IGZ1cnRoZXIuIFdoZW4gdGhlIGluc3RhbGxlZCBwaHlzaWNhbAptZW1vcnkgZXhjZWVkcyB0aGUg ZGlyZWN0IG1hcCBzaXplIG9mIHRoZSBhY3RpdmUgbW9kZSwgdG9wLWRvd24KcGxhY2VtZW50IHB1 dHMgRFRCL2luaXRyZCBhdCBwaHlzaWNhbCBhZGRyZXNzZXMgb3V0c2lkZSB0aGUgbGluZWFybHkK bWFwcGVkIHJlZ2lvbi4gVGhlIGtleGVjJ2Qga2VybmVsIGNhbm5vdCByZWFjaCB0aGVtIGR1cmlu ZyBlYXJseQpib290LCB0cmlnZ2VyaW5nIGEgcGFnZSBmYXVsdCBhdCBtZW1jbXAgaW4gc3RhcnRf a2VybmVsLgoKRml4IGJ5IGNvbnN0cmFpbmluZyBidWZfbWF4IHRvIFBGTl9QSFlTKG1heF9sb3df cGZuKSwgd2hpY2ggcmVmbGVjdHMKdGhlIHJ1bnRpbWUgZGlyZWN0IG1hcCBib3VuZGFyeSBmb3Ig dGhlIGFjdGl2ZSBWTSBtb2RlIChTVjM5L1NWNDgvClNWNTcpLiBUaGlzIGtlZXBzIGFsbCBrZXhl YyBzZWdtZW50cyB3aXRoaW4gdGhlIGxpbmVhcmx5IG1hcHBlZApyZWdpb24gd2hpbGUgcHJlc2Vy dmluZyB0aGUgdXBzdHJlYW0gdG9wX2Rvd24gYWxsb2NhdGlvbiBzdHJhdGVneS4KClNpZ25lZC1v ZmYtYnk6IEhhbiBHYW8gPGdhb2hhbkBpc2Nhcy5hYy5jbj4KTGluazogaHR0cHM6Ly9wYXRjaC5t c2dpZC5saW5rLzIwMjYwNTE5MTcwNjQxLjEyMzUxNy0xLWdhb2hhbkBpc2Nhcy5hYy5jbgpTaWdu ZWQtb2ZmLWJ5OiBQYXVsIFdhbG1zbGV5IDxwandAa2VybmVsLm9yZz4KU2lnbmVkLW9mZi1ieTog U2FzaGEgTGV2aW4gPHNhc2hhbEBrZXJuZWwub3JnPgotLS0KCkxMTSBHZW5lcmF0ZWQgZXhwbGFu YXRpb25zLCBtYXkgYmUgY29tcGxldGVseSBib2d1czoKCiMjIFBoYXNlIDE6IENvbW1pdCBNZXNz YWdlIEZvcmVuc2ljcwoKKipTdGVwIDEuMSDigJQgU3ViamVjdCBsaW5lKioKClJlY29yZDogYFty aXNjdjoga2V4ZWNfZmlsZV1gIGBbQ29uc3RyYWluXWAg4oCUIENvbnN0cmFpbiBrZXhlY19maWxl CnNlZ21lbnQgcGxhY2VtZW50IHRvIHN0YXkgd2l0aGluIHRoZSBSSVNDLVYgZGlyZWN0IChsaW5l YXIpIG1hcC4KCioqU3RlcCAxLjIg4oCUIFRhZ3MqKgoKUmVjb3JkOgotIGBTaWduZWQtb2ZmLWJ5 OiBIYW4gR2FvIDxnYW9oYW5AaXNjYXMuYWMuY24+YCAoYXV0aG9yKQotIGBMaW5rOgogIGh0dHBz Oi8vcGF0Y2gubXNnaWQubGluay8yMDI2MDUxOTE3MDY0MS4xMjM1MTctMS1nYW9oYW5AaXNjYXMu YWMuY25gCi0gYFNpZ25lZC1vZmYtYnk6IFBhdWwgV2FsbXNsZXkgPHBqd0BrZXJuZWwub3JnPmAg KFJJU0MtViBtYWludGFpbmVyKQotIE5vIGBGaXhlczpgLCBgUmVwb3J0ZWQtYnk6YCwgYFRlc3Rl ZC1ieTpgLCBgUmV2aWV3ZWQtYnk6YCwgYENjOgogIHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmdgCi0g Tm90YWJsZTogbWFpbnRhaW5lciBhY2s7IG5vIHN5emJvdCBvciB1c2VyIGJ1ZyByZXBvcnQgdGFn cwoKKipTdGVwIDEuMyDigJQgQm9keSBhbmFseXNpcyoqCgpSZWNvcmQ6Ci0gKipCdWc6KiogV2l0 aCBgYnVmX21heD1VTE9OR19NQVhgIGFuZCBgdG9wX2Rvd249dHJ1ZWAsIGtleGVjX2ZpbGUKICBz ZWdtZW50cyAoRFRCLCBpbml0cmQsIHB1cmdhdG9yeSwgZWxmY29yZWhkcikgYXJlIHBsYWNlZCBh dCB0aGUKICBoaWdoZXN0IHBoeXNpY2FsIGFkZHJlc3Nlcy4gT24gUklTQy1WLCB0aGUgbGluZWFy IG1hcCBzaXplIGRlcGVuZHMgb24KICB0aGUgYWN0aXZlIFZNIG1vZGUgKFNWMzkg4omIIDEyOCBH QjsgU1Y0OC9TVjU3IGxhcmdlcikuIFdoZW4gaW5zdGFsbGVkCiAgUkFNIGV4Y2VlZHMgdGhlIGRp cmVjdC1tYXAgbGltaXQsIHNlZ21lbnRzIGxhbmQgb3V0c2lkZSB0aGUgbGluZWFybHkKICBtYXBw ZWQgcmVnaW9uLgotICoqU3ltcHRvbToqKiBUaGUga2V4ZWMnZCBrZXJuZWwgcGFnZS1mYXVsdHMg aW4gYG1lbWNtcGAgZHVyaW5nCiAgYHN0YXJ0X2tlcm5lbGAgYmVjYXVzZSBpdCBjYW5ub3QgYWNj ZXNzIGluaXRyZC9EVEIuCi0gKipSb290IGNhdXNlOioqIFRvcC1kb3duIHBsYWNlbWVudCBpcyB1 bmNvbnN0cmFpbmVkIGJ5IHRoZSBkaXJlY3QtbWFwCiAgYm91bmRhcnkuCi0gKipGaXggYXBwcm9h Y2g6KiogU2V0IGBidWZfbWF4ID0gUEZOX1BIWVMobWF4X2xvd19wZm4pYCB0byBjYXAKICBwbGFj ZW1lbnQgYXQgdGhlIHJ1bnRpbWUgZGlyZWN0LW1hcCBsaW1pdC4KCioqU3RlcCAxLjQg4oCUIEhp ZGRlbiBidWcgZml4PyoqCgpSZWNvcmQ6IE5vIOKAlCB0aGlzIGlzIGFuIGV4cGxpY2l0IGJ1ZyBm aXgsIG5vdCBkaXNndWlzZWQgY2xlYW51cC4gSXQKcHJldmVudHMgYSBkZXRlcm1pbmlzdGljIGJv b3QgY3Jhc2ggb24gYWZmZWN0ZWQgaGFyZHdhcmUuCgotLS0KCiMjIFBoYXNlIDI6IERpZmYgQW5h bHlzaXMKCioqU3RlcCAyLjEg4oCUIEludmVudG9yeSoqCgpSZWNvcmQ6Ci0gKipGaWxlczoqKiBg YXJjaC9yaXNjdi9rZXJuZWwvbWFjaGluZV9rZXhlY19maWxlLmNgICgrMiwg4oiSMSkKLSAqKkZ1 bmN0aW9uczoqKiBgbG9hZF9leHRyYV9zZWdtZW50cygpYAotICoqU2NvcGU6KiogU2luZ2xlLWZp bGUsIHN1cmdpY2FsICgzIGxpbmVzIG5ldCkKCioqU3RlcCAyLjIg4oCUIENvZGUgZmxvdyBjaGFu Z2UqKgoKUmVjb3JkOgotICoqQmVmb3JlOioqIGBrYnVmLmJ1Zl9tYXggPSBVTE9OR19NQVhgIOKA lCB0b3AtZG93biBwbGFjZW1lbnQgY2FuIHVzZQogIGFueSBzeXN0ZW0gUkFNIGFkZHJlc3MgdXAg dG8gYFVMT05HX01BWGAuCi0gKipBZnRlcjoqKiBga2J1Zi5idWZfbWF4ID0gUEZOX1BIWVMobWF4 X2xvd19wZm4pYCDigJQgdG9wLWRvd24gcGxhY2VtZW50CiAgaXMgY2FwcGVkIGF0IHRoZSBlbmQg b2YgdGhlIGxpbmVhcmx5IG1hcHBlZCByZWdpb24uCi0gKipQYXRoIGFmZmVjdGVkOioqIGBsb2Fk X2V4dHJhX3NlZ21lbnRzKClgIOKGkiBga2V4ZWNfYWRkX2J1ZmZlcigpYCDihpIKICBga2V4ZWNf bG9jYXRlX21lbV9ob2xlKClgIOKGkiBgbG9jYXRlX21lbV9ob2xlX3RvcF9kb3duKClgLCB3aGlj aCB1c2VzCiAgYHRlbXBfZW5kID0gbWluKGVuZCwga2J1Zi0+YnVmX21heClgLgoKKipTdGVwIDIu MyDigJQgQnVnIG1lY2hhbmlzbSoqCgpSZWNvcmQ6Ci0gKipDYXRlZ29yeToqKiBMb2dpYy9jb3Jy ZWN0bmVzcyDigJQgaW5jb3JyZWN0IG1lbW9yeSBwbGFjZW1lbnQuCi0gKipNZWNoYW5pc206Kiog YGxvY2F0ZV9tZW1faG9sZV90b3BfZG93bigpYCBpbiBga2VybmVsL2tleGVjX2ZpbGUuY2AKICBw bGFjZXMgYnVmZmVycyBhdCB0aGUgdG9wIG9mIGVhY2ggUkFNIHJhbmdlLCBib3VuZGVkIG9ubHkg YnkKICBgYnVmX21heGAuIFdpdGggYFVMT05HX01BWGAsIHNlZ21lbnRzIGNhbiBiZSBwbGFjZWQg YmV5b25kIHRoZSBkaXJlY3QKICBtYXAuIFRoZSBrZXhlYydkIGtlcm5lbCdzIGVhcmx5IGJvb3Qg dXNlcyBgX192YSgpYC9saW5lYXIgbWFwcGluZyB0bwogIGFjY2VzcyBEVEIvaW5pdHJkLCBjYXVz aW5nIGEgcGFnZSBmYXVsdCBpZiB0aG9zZSBhZGRyZXNzZXMgYXJlIG5vdAogIGxpbmVhcmx5IG1h cHBlZC4KCioqU3RlcCAyLjQg4oCUIEZpeCBxdWFsaXR5KioKClJlY29yZDoKLSBGaXggaXMgbWlu aW1hbCBhbmQgY2xlYXJseSBjb3JyZWN0OiBgbWF4X2xvd19wZm5gIGlzIHNldCBhZnRlcgogIG1l bWJsb2NrIGNhcHBpbmcgaW4gYGFyY2gvcmlzY3YvbW0vaW5pdC5jYCB3aGVuIFJBTSBleGNlZWRz CiAgYEtFUk5fVklSVF9TSVpFYC4KLSBgbWF4X2xvd19wZm5gIGlzIGFscmVhZHkgZGVjbGFyZWQg aW4gYGxpbnV4L21lbWJsb2NrLmhgIChhbHJlYWR5CiAgaW5jbHVkZWQpLgotIFJlZ3Jlc3Npb24g cmlzayBpcyB2ZXJ5IGxvdzsgd29yc3QgY2FzZSBpcyBgLUVBRERSTk9UQVZBSUxgIGlmIG5vIGhv bGUKICBleGlzdHMgd2l0aGluIHRoZSBjb25zdHJhaW5lZCByYW5nZSAocHJlZmVyYWJsZSB0byBh IGJvb3QgY3Jhc2gpLgoKLS0tCgojIyBQaGFzZSAzOiBHaXQgSGlzdG9yeSBJbnZlc3RpZ2F0aW9u CgoqKlN0ZXAgMy4xIOKAlCBCbGFtZSoqCgpSZWNvcmQ6IGBrYnVmLmJ1Zl9tYXggPSBVTE9OR19N QVhgIGludHJvZHVjZWQgaW4gYDFkZjQ1ZjhhOWZlYTVgIChTb25nClNodWFpLCAyMDI1LTA0LTA5 KSBkdXJpbmcgdGhlIGBsb2FkX2V4dHJhX3NlZ21lbnRzKClgIHJlZmFjdG9yLiBUaGUKdW5kZXJs eWluZyBgdG9wX2Rvd249dHJ1ZWAgKyBgVUxPTkdfTUFYYCBwYXR0ZXJuIGRhdGVzIHRvCmA0OWFm N2EyY2Q1ZjY3YCAoVG9yc3RlbiBEdXdlLCAyMDIzLTA4LTA0KSBpbiB0aGUgcHJlLXJlZmFjdG9y CmBlbGZfa2V4ZWMuY2AuCgoqKlN0ZXAgMy4yIOKAlCBGaXhlczogdGFnKioKClJlY29yZDogTm8g YEZpeGVzOmAgdGFnLiBUaGUgcmVncmVzc2lvbiB3YXMgaW50cm9kdWNlZCBieQpgNDlhZjdhMmNk NWY2N2AgKCJyaXNjdi9rZXhlYzogbG9hZCBpbml0cmQgaGlnaCBpbiBhdmFpbGFibGUgbWVtb3J5 IiksCndoaWNoIGlzIGFuIGFuY2VzdG9yIG9mIHRoaXMgNi4xOC55IHRyZWUuCgoqKlN0ZXAgMy4z IOKAlCBSZWxhdGVkIGNvbW1pdHMqKgoKUmVjb3JkOgotIGAxZGY0NWY4YTlmZWE1YCDigJQgc3Bs aXQgbG9hZGluZyBpbnRvIGBsb2FkX2V4dHJhX3NlZ21lbnRzKClgIChwcmVzZW50CiAgaW4gdHJl ZSkKLSBgODA5YTExZWVhOGU4Y2Ag4oCUIEltYWdlIGJpbmFyeSBrZXhlY19maWxlIHN1cHBvcnQg KHByZXNlbnQpCi0gYDQ5YWY3YTJjZDVmNjdgIOKAlCB0b3BfZG93biBpbml0cmQgbG9hZGluZyAo cHJlc2VudDsgaGFkIGBDYzoKICBzdGFibGVAdmdlci5rZXJuZWwub3JnYCkKLSBgYjY3YTFlZTBk YjAwOWAg4oCUIHRoaXMgZml4IChvbiBtYXN0ZXI7ICoqbm90KiogaW4gNi4xOC55KQotIFN0YW5k YWxvbmUgZml4LCBub3QgcGFydCBvZiBhIHNlcmllcy4KCioqU3RlcCAzLjQg4oCUIEF1dGhvciBj b250ZXh0KioKClJlY29yZDogSGFuIEdhbyBpcyBhbiBhY3RpdmUgUklTQy1WIGNvbnRyaWJ1dG9y IChEVFMsIEFDUEkpLiBQYXVsCldhbG1zbGV5IGNvbW1pdHRlZCB0aGUgZml4LiBObyBwcmlvciBr ZXhlYyB3b3JrIGZyb20gdGhpcyBhdXRob3IgaW4gdGhpcwp0cmVlLgoKKipTdGVwIDMuNSDigJQg RGVwZW5kZW5jaWVzKioKClJlY29yZDogTm8gcHJlcmVxdWlzaXRlcy4gUGF0Y2ggYXBwbGllcyBj bGVhbmx5IChgZ2l0IGFwcGx5IC0tY2hlY2tgCnBhc3NlZCkuIGBsb2FkX2V4dHJhX3NlZ21lbnRz KClgIGFuZCBgbWFjaGluZV9rZXhlY19maWxlLmNgIGV4aXN0IGluCjYuMTguNDQuCgotLS0KCiMj IFBoYXNlIDQ6IE1haWxpbmcgTGlzdCBhbmQgRXh0ZXJuYWwgUmVzZWFyY2gKCioqU3RlcCA0LjEg 4oCUIE9yaWdpbmFsIGRpc2N1c3Npb24qKgoKUmVjb3JkOgotIGBiNCBkaWcgLWMgYjY3YTFlZTBk YjAwOWA6CiAgaHR0cHM6Ly9wYXRjaC5tc2dpZC5saW5rLzIwMjYwNTE5MTcwNjQxLjEyMzUxNy0x LWdhb2hhbkBpc2Nhcy5hYy5jbgotIFNpbmdsZSB2MSBwYXRjaCAobm8gcmV2aXNpb25zKQotIFBh dWwgV2FsbXNsZXkgcmVwbGllZDogIlRoYW5rcywgcXVldWVkIGZvciB2Ny4xLXJjLiIKLSBObyBl eHBsaWNpdCBzdGFibGUgbm9taW5hdGlvbiBpbiB0aHJlYWQ7IG5vIE5BS3MKCioqU3RlcCA0LjIg 4oCUIFJldmlld2VycyoqCgpSZWNvcmQ6IENDJ2QgdG8gUGF1bCBXYWxtc2xleSwgUGFsbWVyIERh YmJlbHQsIEFsZXhhbmRyZSBHaGl0aSwgU29uZwpTaHVhaSwgQmrDtnJuIFTDtnBlbCwgQnJlbm8g TGVpdGFvLCBLZWVzIENvb2ssIGxpbnV4LXJpc2N2QCwgbGludXgta2VybmVsQAoKKipTdGVwIDQu MyDigJQgQnVnIHJlcG9ydCoqCgpSZWNvcmQ6IE5vIGV4dGVybmFsIGJ1ZyByZXBvcnQgb3Igc3l6 Ym90IGxpbmsuIEJ1ZyBkZXNjcmliZWQgaW4gY29tbWl0Cm1lc3NhZ2Ugd2l0aCBjb25jcmV0ZSBm YWlsdXJlIG1vZGUgKGBtZW1jbXBgIHBhZ2UgZmF1bHQgaW4KYHN0YXJ0X2tlcm5lbGApLgoKKipT dGVwIDQuNCDigJQgU2VyaWVzIGNvbnRleHQqKgoKUmVjb3JkOiBTdGFuZGFsb25lIDEtcGF0Y2gg Zml4LgoKKipTdGVwIDQuNSDigJQgU3RhYmxlIGxpc3QqKgoKUmVjb3JkOiBObyBzdGFibGUtbGlz dCBkaXNjdXNzaW9uIGZvdW5kIGZvciB0aGlzIHNwZWNpZmljIGZpeC4gVGhlCm9yaWdpbmFsIHRv cF9kb3duIGNvbW1pdCAoYDQ5YWY3YTJjZDVmNjdgKSB3YXMgbm9taW5hdGVkIGZvciBzdGFibGUu CgotLS0KCiMjIFBoYXNlIDU6IENvZGUgU2VtYW50aWMgQW5hbHlzaXMKCioqU3RlcCA1LjEg4oCU IEtleSBmdW5jdGlvbnMqKgoKUmVjb3JkOiBgbG9hZF9leHRyYV9zZWdtZW50cygpYCAobW9kaWZp ZWQpOyBjYWxsZXJzOiBgZWxmX2tleGVjX2xvYWQoKWAKaW4gYGtleGVjX2VsZi5jYCwgYGltYWdl X2xvYWQoKWAgaW4gYGtleGVjX2ltYWdlLmNgLgoKKipTdGVwIDUuMiDigJQgQ2FsbGVycyoqCgpS ZWNvcmQ6Ci0gYGVsZl9rZXhlY19sb2FkKClgIOKAlCBFTEYgdm1saW51eCBrZXhlY19maWxlIHBh dGgKLSBgaW1hZ2VfbG9hZCgpYCDigJQgcmF3IEltYWdlIGtleGVjX2ZpbGUgcGF0aAotIEJvdGgg aW52b2tlZCBmcm9tIHRoZSBrZXhlY19maWxlIHN5c2NhbGwgcGF0aCAoYGtleGVjX2ZpbGVfbG9h ZGApCgoqKlN0ZXAgNS4zIOKAlCBDYWxsZWVzKioKClJlY29yZDogYGtleGVjX2FkZF9idWZmZXIo KWAsIGBrZXhlY19sb2FkX3B1cmdhdG9yeSgpYCwKYG9mX2tleGVjX2FsbG9jX2FuZF9zZXR1cF9m ZHQoKWAsIGBwcmVwYXJlX2VsZl9oZWFkZXJzKClgIChrZHVtcCkuCgoqKlN0ZXAgNS40IOKAlCBS ZWFjaGFiaWxpdHkqKgoKUmVjb3JkOiBSZWFjaGFibGUgZnJvbSB1c2Vyc3BhY2UgdmlhIGBrZXhl Y19maWxlX2xvYWQoKWAgd2hlbgpgQ09ORklHX0tFWEVDX0ZJTEVgIGlzIGVuYWJsZWQgb24gUklT Qy1WLiBBZmZlY3RzIGluaXRyZCwgRFRCLApwdXJnYXRvcnksIGFuZCBrZHVtcCBlbGZjb3JlaGRy IHBsYWNlbWVudC4gVHJpZ2dlciByZXF1aXJlcyBwaHlzaWNhbCBSQU0KZXhjZWVkaW5nIHRoZSBk aXJlY3QtbWFwIHNpemUgKGUuZy4gPn4xMjggR0Igb24gU1YzOSkuCgoqKlN0ZXAgNS41IOKAlCBT aW1pbGFyIHBhdHRlcm5zKioKClJlY29yZDogYGtleGVjX2VsZi5jYCBhbmQgYGtleGVjX2ltYWdl LmNgIHN0aWxsIHVzZSBgYnVmX21heCA9ClVMT05HX01BWGAgZm9yIGtlcm5lbCBsb2FkaW5nLCBi dXQgd2l0aCBgdG9wX2Rvd24gPSBmYWxzZWAgKGJvdHRvbS11cCksCnNvIHRoZXkgYXJlIG5vdCBh ZmZlY3RlZC4gT25seSBgbG9hZF9leHRyYV9zZWdtZW50cygpYCB1c2VzIGB0b3BfZG93biA9CnRy dWVgIHdpdGggdW5jb25zdHJhaW5lZCBgYnVmX21heGAuCgotLS0KCiMjIFBoYXNlIDY6IENyb3Nz LVJlZmVyZW5jZSBBZ2FpbnN0IExvY2FsIFRyZWUgKDYuMTguNDQpCgoqKlN0ZXAgNi4xIOKAlCBC dWdneSBjb2RlIHByZXNlbnQ/KioKClJlY29yZDogKipZZXMuKiogTG9jYWwgdHJlZSBpcyBgdjYu MTguNDRgIG9uIGBzdGFibGUvbGludXgtNi4xOC55YC4gTGluZQoyNjkgb2YgYGFyY2gvcmlzY3Yv a2VybmVsL21hY2hpbmVfa2V4ZWNfZmlsZS5jYCBzdGlsbCBoYXMgYGtidWYuYnVmX21heAo9IFVM T05HX01BWGAuIEJ1ZyBwcmVzZW50IHNpbmNlIGA0OWFmN2EyY2Q1ZjY3YCAoMjAyMyk7IHJlZmFj dG9yIGluCmAxZGY0NWY4YTlmZWE1YCAobWVyZ2VkIGluIDYuMTYpIG1vdmVkIGNvZGUgd2l0aG91 dCBmaXhpbmcgdGhlIGlzc3VlLgoKKipTdGVwIDYuMiDigJQgQmFja3BvcnQgY29tcGxpY2F0aW9u cyoqCgpSZWNvcmQ6IFBhdGNoIGFwcGxpZXMgY2xlYW5seSB3aXRoIG5vIGNvbmZsaWN0cy4gVHdv LWxpbmUgZnVuY3Rpb25hbApjaGFuZ2UgcGx1cyBvbmUgaW5jbHVkZS4KCioqU3RlcCA2LjMg4oCU IFJlbGF0ZWQgZml4ZXMgYWxyZWFkeSBwcmVzZW50PyoqCgpSZWNvcmQ6IEZpeCBjb21taXQgYGI2 N2ExZWUwZGIwMDlgIGlzICoqbm90KiogaW4gNi4xOC55IChgZ2l0IG1lcmdlLWJhc2UKLS1pcy1h bmNlc3RvcmAgY29uZmlybXMpLiBObyBhbHRlcm5hdGl2ZSBmaXggZm91bmQuCgotLS0KCiMjIFBo YXNlIDc6IFN1YnN5c3RlbSBhbmQgTWFpbnRhaW5lciBDb250ZXh0CgoqKlN0ZXAgNy4xIOKAlCBT dWJzeXN0ZW0qKgoKUmVjb3JkOiBgYXJjaC9yaXNjdmAg4oCUIGtleGVjX2ZpbGUgYm9vdCBwYXRo LiBDcml0aWNhbGl0eTogKipJTVBPUlRBTlQqKgoobm90IHVuaXZlcnNhbCBjb3JlLCBidXQgYm9v dC9jcmFzaC1kdW1wIGluZnJhc3RydWN0dXJlIGZvciBSSVNDLVYKc2VydmVycykuCgoqKlN0ZXAg Ny4yIOKAlCBBY3Rpdml0eSoqCgpSZWNvcmQ6IEFjdGl2ZSBzdWJzeXN0ZW07IHJlY2VudCBrZXhl Y19maWxlIHdvcmsgaW5jbHVkZXMgSW1hZ2Ugc3VwcG9ydAooNi4xNikgYW5kIGBsb2FkX2V4dHJh X3NlZ21lbnRzKClgIHJlZmFjdG9yLgoKLS0tCgojIyBQaGFzZSA4OiBJbXBhY3QgYW5kIFJpc2sg QXNzZXNzbWVudAoKKipTdGVwIDguMSDigJQgV2hvIGlzIGFmZmVjdGVkKioKClJlY29yZDogUklT Qy1WIHN5c3RlbXMgd2l0aCBgQ09ORklHX0tFWEVDX0ZJTEVgIChhbmQgb3B0aW9uYWxseQpgQ09O RklHX0NSQVNIX0RVTVBgKSB3aGVyZSBpbnN0YWxsZWQgUkFNIGV4Y2VlZHMgdGhlIGRpcmVjdC1t YXAgc2l6ZSBmb3IKdGhlIGFjdGl2ZSBWTSBtb2RlIChtb3N0IGNvbW1vbmx5IFNWMzkgd2l0aCA+ fjEyOCBHQikuIFNlcnZlci1jbGFzcwpoYXJkd2FyZSAoZS5nLiBoaWdoLW1lbW9yeSBTRzIwNDIt Y2xhc3MgcGxhdGZvcm1zKS4KCioqU3RlcCA4LjIg4oCUIFRyaWdnZXIgY29uZGl0aW9ucyoqCgpS ZWNvcmQ6Ci0gVXNlci9hZG1pbiBpbnZva2VzIGBrZXhlY19maWxlX2xvYWRgIChmYXN0IHJlYm9v dCBvciBrZHVtcCBzZXR1cCkKLSBTeXN0ZW0gUkFNIGV4Y2VlZHMgbGluZWFyLW1hcCBjYXBhY2l0 eQotIE5vdCB0aW1pbmctZGVwZW5kZW50OyBkZXRlcm1pbmlzdGljIG9uIGFmZmVjdGVkIGNvbmZp Z3MKLSBSZXF1aXJlcyByb290IChrZXhlYyBzeXNjYWxsKSwgbm90IGFuIHVucHJpdmlsZWdlZCBh dHRhY2sgdmVjdG9yCgoqKlN0ZXAgOC4zIOKAlCBGYWlsdXJlIHNldmVyaXR5KioKClJlY29yZDog KipDUklUSUNBTCoqIOKAlCBrZXhlYydkIGtlcm5lbCBjYW5ub3QgYm9vdDsgcGFnZSBmYXVsdCBk dXJpbmcKZWFybHkgYHN0YXJ0X2tlcm5lbGAuIGtkdW1wIG1heSBhbHNvIGZhaWwgdG8gY2FwdHVy ZSBjcmFzaGVzIG9uIGxhcmdlLQptZW1vcnkgc3lzdGVtcy4KCioqU3RlcCA4LjQg4oCUIFJpc2st YmVuZWZpdCoqCgpSZWNvcmQ6Ci0gKipCZW5lZml0OioqIEhJR0ggZm9yIGFmZmVjdGVkIFJJU0Mt ViBrZXhlYy9rZHVtcCB1c2VycwotICoqUmlzazoqKiBWRVJZIExPVyDigJQgMy1saW5lIGNoYW5n ZSwgd2VsbC11bmRlcnN0b29kIGJvdW5kYXJ5LAogIG1haW50YWluZXItcmV2aWV3ZWQKLSAqKlJh dGlvOioqIFN0cm9uZ2x5IGZhdm9ycyBiYWNrcG9ydAoKLS0tCgojIyBQaGFzZSA5OiBGaW5hbCBT eW50aGVzaXMKCioqRXZpZGVuY2UgRk9SIGJhY2twb3J0OioqCi0gRml4ZXMgYSByZWFsLCByZXBy b2R1Y2libGUgYm9vdCBjcmFzaCBvbiBsYXJnZS1tZW1vcnkgUklTQy1WIHN5c3RlbXMKLSBTbWFs bCwgc3VyZ2ljYWwsIG1haW50YWluZXItY29tbWl0dGVkIGZpeAotIEFwcGxpZXMgY2xlYW5seSB0 byA2LjE4LnkKLSBCdWcgaGFzIGV4aXN0ZWQgc2luY2UgQXVnIDIwMjMgKHRvcF9kb3duIHBsYWNl bWVudCkKLSBVbmRlcmx5aW5nIHJlZ3Jlc3Npb24gY29tbWl0IGlzIGluIHRoaXMgdHJlZQotIFNh bWUgcGF0dGVybiBhcyB0aGUgb3JpZ2luYWwgdG9wX2Rvd24gY29tbWl0LCB3aGljaCB3YXMgc3Rh YmxlLQogIG5vbWluYXRlZAoKKipFdmlkZW5jZSBBR0FJTlNUOioqCi0gQWZmZWN0cyBhIGNvbmZp Zy1zcGVjaWZpYyBzdWJzZXQgKFJJU0MtViArIGtleGVjX2ZpbGUgKyBoaWdoIG1lbW9yeSkKLSBO byBzeXpib3QvdXNlciBSZXBvcnRlZC1ieSB0YWdzCi0gTm8gZXhwbGljaXQgc3RhYmxlIG5vbWlu YXRpb24gb24gdGhpcyBwYXRjaAoKKipTdGFibGUgcnVsZXMgY2hlY2tsaXN0OioqCjEuIE9idmlv dXNseSBjb3JyZWN0IGFuZCB0ZXN0ZWQ/ICoqUEFTUyoqIOKAlCBsb2dpYyB2ZXJpZmllZCBhZ2Fp bnN0CiAgIGBsb2NhdGVfbWVtX2hvbGVfdG9wX2Rvd24oKWAgYW5kIGBtYXhfbG93X3BmbmAgc2V0 dXAgaW4KICAgYGFyY2gvcmlzY3YvbW0vaW5pdC5jYDsgbWFpbnRhaW5lciBjb21taXR0ZWQKMi4g Rml4ZXMgYSByZWFsIGJ1Zz8gKipQQVNTKiog4oCUIGtleGVjIGJvb3QgZmFpbHVyZSBvbiBsYXJn ZS1tZW1vcnkKICAgUklTQy1WCjMuIEltcG9ydGFudCBpc3N1ZT8gKipQQVNTKiog4oCUIGJvb3Qg Y3Jhc2ggLyBrZHVtcCBmYWlsdXJlIChDUklUSUNBTCBmb3IKICAgYWZmZWN0ZWQgdXNlcnMpCjQu IFNtYWxsIGFuZCBjb250YWluZWQ/ICoqUEFTUyoqIOKAlCAzIGxpbmVzLCBvbmUgZmlsZQo1LiBO byBuZXcgZmVhdHVyZXMvQVBJcz8gKipQQVNTKiog4oCUIGNvbnN0cmFpbnQgb25seQo2LiBDYW4g YXBwbHkgdG8gbG9jYWwgdHJlZT8gKipQQVNTKiog4oCUIGNsZWFuIGFwcGx5IHZlcmlmaWVkCgoq KkV4Y2VwdGlvbiBjYXRlZ29yeToqKiBOL0EgKHN0YW5kYXJkIGJ1ZyBmaXgpCgotLS0KCiMjIFZl cmlmaWNhdGlvbgoKLSBbUGhhc2UgMV0gUGFyc2VkIGNvbW1pdCBtZXNzYWdlIGFuZCB0YWdzIGZy b20gdXNlci1wcm92aWRlZCBkaWZmIGFuZAogIGBnaXQgc2hvdyBiNjdhMWVlMGRiMDA5YAotIFtQ aGFzZSAyXSBSZWFkIGN1cnJlbnQgYG1hY2hpbmVfa2V4ZWNfZmlsZS5jYCBhbmQKICBgbG9jYXRl X21lbV9ob2xlX3RvcF9kb3duKClgIGluIGBrZXJuZWwva2V4ZWNfZmlsZS5jYAotIFtQaGFzZSAz XSBgZ2l0IGJsYW1lYDogYnVnZ3kgbGluZSBmcm9tIGAxZGY0NWY4YTlmZWE1YDsgdG9wX2Rvd24g ZnJvbQogIGA0OWFmN2EyY2Q1ZjY3YAotIFtQaGFzZSAzXSBgZ2l0IG1lcmdlLWJhc2UgLS1pcy1h bmNlc3RvcmA6IGJ1ZyBjb21taXQgaW4gdHJlZSwgZml4CiAgY29tbWl0IG5vdCBpbiB0cmVlCi0g W1BoYXNlIDNdIGBnaXQgbG9nIC0tb25lbGluZSAtMjAgLS0KICBhcmNoL3Jpc2N2L2tlcm5lbC9t YWNoaW5lX2tleGVjX2ZpbGUuY2AKLSBbUGhhc2UgM10gYGdpdCBhcHBseSAtLWNoZWNrYCBvbiBm aXggcGF0Y2g6IGFwcGxpZXMgY2xlYW5seQotIFtQaGFzZSA0XSBgYjQgZGlnIC1jIGI2N2ExZWUw ZGIwMDkgLXcgLWEgLW1gOiBsb3JlIFVSTCwgcmVjaXBpZW50cywgdjEKICBvbmx5LCBQYXVsIFdh bG1zbGV5IGFjawotIFtQaGFzZSA0XSBSZWFkIGAvdG1wL2tleGVjX2RpcmVjdF9tYXAubWJveGA6 IG5vIHN0YWJsZSBub21pbmF0aW9uLCBubwogIE5BS3MKLSBbUGhhc2UgNV0gYGdyZXAgbG9hZF9l eHRyYV9zZWdtZW50c2A6IGNhbGxlcnMgaW4gYGtleGVjX2VsZi5jYCwKICBga2V4ZWNfaW1hZ2Uu Y2AKLSBbUGhhc2UgNV0gVmVyaWZpZWQgYGtleGVjX2xvY2F0ZV9tZW1faG9sZSgpYCB1c2VzCiAg YGtleGVjX3dhbGtfcmVzb3VyY2VzKClgIG9uIG5vbi1BQ1BJIFJJU0MtViAobm8gYEFSQ0hfS0VF UF9NRU1CTE9DS2ApCi0gW1BoYXNlIDZdIGBnaXQgZGVzY3JpYmUgSEVBRGA6IHY2LjE4LjQ0OyBi dWdneSBgVUxPTkdfTUFYYCBhdCBsaW5lIDI2OQogIGNvbmZpcm1lZAotIFtQaGFzZSA2XSBSZWFk IGBhcmNoL3Jpc2N2L21tL2luaXQuY2AgbGluZXMgMjY04oCTMjk1OiBtZW1ibG9jayBjYXBwaW5n CiAgYW5kIGBtYXhfbG93X3BmbmAgYXNzaWdubWVudAotIFtQaGFzZSA2XSBSZWFkIGBhcmNoL3Jp c2N2L2luY2x1ZGUvYXNtL3BndGFibGUuaGA6IGBLRVJOX1ZJUlRfU0laRWAsCiAgYERJUkVDVF9N QVBfUEhZU01FTV9FTkRgCi0gW1BoYXNlIDhdIENvbmZpcm1lZCBmYWlsdXJlIG1vZGU6IHBhZ2Ug ZmF1bHQgaW4gZWFybHkgYm9vdCBvZiBrZXhlYydkCiAga2VybmVsCgpUaGlzIGZpeCBwcmV2ZW50 cyBrZXhlY19maWxlIGFuZCBrZHVtcCBmYWlsdXJlcyBvbiBSSVNDLVYgc3lzdGVtcyB3aGVyZQpw aHlzaWNhbCBtZW1vcnkgZXhjZWVkcyB0aGUgU1YzOSBkaXJlY3QtbWFwIGxpbWl0ICh+MTI4IEdC KS4gVGhlIGJ1ZyBpcwpwcmVzZW50IGluIDYuMTguNDQsIHRoZSBwYXRjaCBpcyBtaW5pbWFsIGFu ZCBhcHBsaWVzIGNsZWFubHksIGFuZCB0aGUKZmFpbHVyZSBtb2RlIGlzIGEgYm9vdCBjcmFzaCDi gJQgYSBjbGVhciBzdGFibGUgYmFja3BvcnQgY2FuZGlkYXRlIGZvcgp0aGlzIHRyZWUuCgoqKllF UyoqVGhlIGJhY2tncm91bmQgc2VhcmNoIGZpbmlzaGVkIHN1Y2Nlc3NmdWxseS4gSXQgZGlkbuKA mXQgcHJpbnQKbWF0Y2hlcyBvbiBpdHMgb3duLCBidXQgdGhlIGVhcmxpZXIgaW52ZXN0aWdhdGlv biBhbHJlYWR5IHBpbm5lZCB0aGUgZml4CnRvICoqYGI2N2ExZWUwZGIwMDlgKiogb24gbWFzdGVy IChgcmlzY3Y6IGtleGVjX2ZpbGU6IENvbnN0cmFpbiBzZWdtZW50CnBsYWNlbWVudCB0byBkaXJl Y3QgbWFwYCkuCgoqKlZlcmRpY3QgZm9yIHRoaXMgdHJlZSAobGludXgtNi4xOC55IC8gdjYuMTgu NDQpOiBZRVMqKgoKLSBUaGUgYnVnIGlzIHByZXNlbnQ6IGBsb2FkX2V4dHJhX3NlZ21lbnRzKClg IHN0aWxsIHVzZXMgYGJ1Zl9tYXggPQogIFVMT05HX01BWGAgd2l0aCB0b3AtZG93biBwbGFjZW1l bnQuCi0gT24gUklTQy1WIHN5c3RlbXMgd2l0aCBSQU0gYmV5b25kIHRoZSBTVjM5IGRpcmVjdCBt YXAgKH4xMjggR0IpLAogIGtleGVjX2ZpbGUgY2FuIHBsYWNlIERUQi9pbml0cmQgb3V0c2lkZSB0 aGUgbGluZWFyIG1hcCwgY2F1c2luZyB0aGUKICBrZXhlYydkIGtlcm5lbCB0byBwYWdlLWZhdWx0 IGR1cmluZyBlYXJseSBib290LgotIFRoZSBmaXggaXMgYSAzLWxpbmUgY2hhbmdlIHRoYXQgYXBw bGllcyBjbGVhbmx5OyBpdCBzaG91bGQgYmUKICBiYWNrcG9ydGVkIHRvIDYuMTgueS4KCiBhcmNo L3Jpc2N2L2tlcm5lbC9tYWNoaW5lX2tleGVjX2ZpbGUuYyB8IDMgKystCiAxIGZpbGUgY2hhbmdl ZCwgMiBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNj di9rZXJuZWwvbWFjaGluZV9rZXhlY19maWxlLmMgYi9hcmNoL3Jpc2N2L2tlcm5lbC9tYWNoaW5l X2tleGVjX2ZpbGUuYwppbmRleCBkZDlkOTJhOTY1MTc0Li5iNWZlMTcyMzhkZjJmIDEwMDY0NAot LS0gYS9hcmNoL3Jpc2N2L2tlcm5lbC9tYWNoaW5lX2tleGVjX2ZpbGUuYworKysgYi9hcmNoL3Jp c2N2L2tlcm5lbC9tYWNoaW5lX2tleGVjX2ZpbGUuYwpAQCAtMTMsNiArMTMsNyBAQAogI2luY2x1 ZGUgPGxpbnV4L2xpYmZkdC5oPgogI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CiAjaW5jbHVkZSA8 bGludXgvbWVtYmxvY2suaD4KKyNpbmNsdWRlIDxsaW51eC9wZm4uaD4KICNpbmNsdWRlIDxsaW51 eC92bWFsbG9jLmg+CiAjaW5jbHVkZSA8YXNtL3NldHVwLmg+CiAjaW5jbHVkZSA8YXNtL2luc24u aD4KQEAgLTI2Niw3ICsyNjcsNyBAQCBpbnQgbG9hZF9leHRyYV9zZWdtZW50cyhzdHJ1Y3Qga2lt YWdlICppbWFnZSwgdW5zaWduZWQgbG9uZyBrZXJuZWxfc3RhcnQsCiAKIAlrYnVmLmltYWdlID0g aW1hZ2U7CiAJa2J1Zi5idWZfbWluID0ga2VybmVsX3N0YXJ0ICsga2VybmVsX2xlbjsKLQlrYnVm LmJ1Zl9tYXggPSBVTE9OR19NQVg7CisJa2J1Zi5idWZfbWF4ID0gUEZOX1BIWVMobWF4X2xvd19w Zm4pOwogCiAjaWZkZWYgQ09ORklHX0NSQVNIX0RVTVAKIAkvKiBBZGQgZWxmY29yZWhkciAqLwot LSAKMi41My4wCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KbGludXgtcmlzY3YgbWFpbGluZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5v cmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1yaXNj dgo=