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 ED4CECCF2DE for ; Mon, 19 Oct 2026 14:05:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Content-Transfer-Encoding: Content-Type: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=OJnDRXaD8MXKY+HfVAGx8ycJVEcnB4lWDfYJHPvkKb0=; b=c0TIZyeLEpZFkU8gRYhLLJ/A55 IxLO6TsukEbcEeBA6Uc7GB4M/8/kvUnG0HqVmF6IZwFF3OMQf++wzwzfkcZc+Q0J/D5S7psotkvI7 juBYocr/NNb5LFjGHlN+opxQrsYHu4CgiDJ+wUaOI7TycDRx+0+QOFqcXE6A7ovJ3uEtSqQ3XMBCw xv/ysfcIUCPd9Esv4JjltYAeO+g5JlSrrbNF3O67wRaQemSgvaCFQyUDclAbXLe8moCq1wgwM4aXp 6eALMdyX4hC2NyBjUO+quA9unEmP2uvxOmXDJ9fauNyUA0CS4IE+4HNwLSmnpd8QPuWZ4cnDRwyZM hn+YzBxQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1xInzH-00000007g68-0xC8; Mon, 19 Oct 2026 14:05:15 +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 1xInzG-00000007g5N-0hFJ; Mon, 19 Oct 2026 14:05:14 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id E533E4142A; Mon, 19 Oct 2026 14:05:13 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 43C221F000C9; Mon, 19 Oct 2026 14:05:12 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1792418713; bh=OJnDRXaD8MXKY+HfVAGx8ycJVEcnB4lWDfYJHPvkKb0=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=bf/E01hjpu608+YAIXvBZ8sLKTH6wN4X6fCJ266yZXD9IUA84iZ5tHSbvtTkUThwg j7b75Zfd9bwTyHXiMvYncHq4rvcE65DsDqz/aIEmmci2ek9dbiCVmsmivlxi4rmXyd 0hCF6sI/KvQuEynwTYJ3xs7j8KKiF54nWaVmGdVaTduzmV2qBJSfrnLNuFyQhPu7B0 0DReVvYr6GaJMZb1Ucxw9mccPd0om2AQlljhVhl6eKiHMuvKaCcGbZ2BYq7EugqtFN 7gGQJvbk6uaR63I2smHhQLXfeH4HjMUkcU7kYw8EBcxoGPlfWo7yzzg1aumaig8pA0 2sqzRO8psMLCg== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: Atish Patra , Sashiko AI , Charlie Jenkins , Paul Walmsley , Sasha Levin , atish.patra@linux.dev, will@kernel.org, mark.rutland@arm.com, palmer@dabbelt.com, aou@eecs.berkeley.edu, linux-riscv@lists.infradead.org, linux-arm-kernel@lists.infradead.org, linux-perf-users@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 6.18-6.12] RISC-V: perf: fix resource cleanup on driver probe failure Date: Mon, 19 Oct 2026 09:52:14 -0400 Message-ID: <20261019135441.1420968-443-sashal@kernel.org> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20261019135441.1420968-1-sashal@kernel.org> References: <20261019135441.1420968-1-sashal@kernel.org> MIME-Version: 1.0 X-stable: review X-Patchwork-Hint: Ignore X-stable-base: Linux 6.18.57 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org From: Atish Patra [ Upstream commit e24a1418e90beac2ef4384bc9b0b5a10f19b806e ] Sashiko pointed out various UAF and memory leak issues around pmu_sbi_device_probe() error paths. If the probe fails, here are list of cleanups needed. a. Already registered pmu must be freed b. per cpu IRQ must be released c. pmu_ctr_list data structure must be freed d. cpu hotplug state must be cleaned up only if added. Fix the resource cleanup by reorganizing the code around probe failure. Reported-by: Sashiko AI Reviewed-by: Charlie Jenkins Signed-off-by: Atish Patra Link: https://patch.msgid.link/20260807-counter_delegation-v9-1-58658104e487@meta.com Signed-off-by: Paul Walmsley Signed-off-by: Sasha Levin --- LLM Generated explanations, may be completely bogus: This tree is **6.12.111** (`pending-6.12`). The buggy probe cleanup is present here, the patch applies, and it is a real UAF/leak/crash fix — a YES for this tree. --- ## PHASE 1: COMMIT MESSAGE FORENSICS **Step 1.1: PARSE THE SUBJECT LINE** Record: `[RISC-V perf / SBI PMU] [fix] [resource cleanup on driver probe failure]` **Step 1.2: PARSE ALL COMMIT MESSAGE TAGS** Record: - `Reported-by: Sashiko AI ` — static-analysis bot, not a user oops, but it named concrete UAF/leak paths - `Reviewed-by: Charlie Jenkins ` — RISC-V reviewer - `Signed-off-by: Atish Patra ` — original SBI PMU driver author - `Link: https://patch.msgid.link/20260807-counter_delegation-v9-1- 58658104e487@meta.com` — **v9 01/20** of the counter-delegation series - `Signed-off-by: Paul Walmsley ` — RISC-V maintainer - No `Fixes:` tag (expected) - Ignore pipeline `Signed-off-by: Sasha Levin` / `[Upstream commit ...]` — none on the real commit `e24a1418e90be` **Step 1.3: ANALYZE THE COMMIT BODY TEXT** Record: - **Bug:** `pmu_sbi_device_probe()` error paths leak and leave live references to freed objects - **Needed cleanups:** (a) unregister an already-registered PMU, (b) release the per-CPU IRQ, (c) free `pmu_ctr_list`, (d) remove the CPU- hotplug instance only if it was added - **Symptom:** UAF and memory leaks if probe fails after partial setup - **Root cause:** probe does `goto out_unregister` / `out_free` without matching teardown - **Version info:** none in the message; code dates to 2022–2024 **Step 1.4: DETECT HIDDEN BUG FIXES** Record: Not disguised. It is an explicit error-path UAF/leak fix. “Reorganizing probe failure” is the usual `goto` cleanup pattern, not a refactor-for-its-own-sake. --- ## PHASE 2: DIFF ANALYSIS **Step 2.1: INVENTORY THE CHANGES** Record: - File: `drivers/perf/riscv_pmu_sbi.c` — **+27 / −6** (33 insertions, 6 deletions) - Functions: `pmu_sbi_setup_irqs()`, `riscv_pmu_destroy()`, `pmu_sbi_device_probe()` - Scope: single-file surgical error-path fix **Step 2.2: UNDERSTAND THE CODE FLOW CHANGE** Record: 1. **`pmu_sbi_setup_irqs()`** - Before: domain/mapping/request failures return immediately. `riscv_pmu_use_irq` can stay **true** even though no IRQ was installed. Mapping leaked if `request_percpu_irq()` failed. - After: those paths `goto err`, dispose a created mapping, set `riscv_pmu_use_irq = false`. 2. **`riscv_pmu_destroy()`** - Before: always `cpuhp_state_remove_instance()` even when the instance was never added. - After: only if `!hlist_unhashed(&pmu->node)`. 3. **`pmu_sbi_device_probe()`** - Before: `riscv_pm_pmu_register` / `perf_pmu_register` failures jump to `out_unregister` (destroy + `kfree(pmu)` only). Snapshot-alloc and cpuhp-add failures also skip `perf_pmu_unregister`. IRQ, `hw_events`, and `pmu_ctr_list` never freed. - After: `irq_requested` tracks a successful IRQ request. Failures before PMU register go to `out_destroy`. Failures after register go to `out_unregister` which now calls `perf_pmu_unregister`. Then IRQ/percpu/`pmu_ctr_list`/`pmu` are freed. **Step 2.3: IDENTIFY THE BUG MECHANISM** Record: **Error-path resource leak + UAF + NULL deref**, with a logic fix on the IRQ fallback path. Verified mechanisms in **this** tree: | Bug | Mechanism | |---|---| | **UAF of registered PMU** | `perf_pmu_register()` then `pmu_sbi_snapshot_alloc()` or `cpuhp_state_add_instance()` fails → `kfree(pmu)` while the PMU stays in perf core | | **NULL deref / list corruption** | `riscv_pmu_destroy()` → `cpuhp_state_remove_instance()` → `hlist_del()` → `WRITE_ONCE(*pprev, next)` with `pprev == NULL` on a `kzalloc`’d node | | **IRQ + cookie UAF** | successful `request_percpu_irq(..., hw_events)` then later probe fail frees `pmu`/`hw_events` without `free_percpu_irq` | | **Leaks** | `alloc_percpu` `hw_events` and `kcalloc` `pmu_ctr_list` only freed on the new `out_free` | | **Wrong IRQ flag on success path** | IRQ setup failure is **non- fatal**; probe continues with `PERF_PMU_CAP_NO_INTERRUPT` but `riscv_pmu_use_irq` stayed true, so `pmu_sbi_starting_cpu()` can `enable_percpu_irq(0)` | **Step 2.4: ASSESS THE FIX QUALITY** Record: Obviously correct and minimal. `out_unregister` is only reached after a successful `perf_pmu_register`. `out_destroy` does not unregister. `hlist_unhashed` matches `cpuhp` (node is hashed only after successful add). IRQ free happens before `free_percpu(hw_events)`. Regression risk: **low**. Remaining gaps (sysctl not unregistered; `sbi_pmu_snapshot_available` static key not disabled) are pre-existing and not introduced here. They do not make this patch unsafe. --- ## PHASE 3: GIT HISTORY INVESTIGATION **Step 3.1: BLAME THE CHANGED LINES** Record: - IRQ error returns: `4905ec2fb7e642` (Atish Patra, 2022-02-18) — sscofpmf - Destroy / `out_unregister`: `e9a023f2b73ac3` (Eric Lin, 2022-07-05) — PM notifier - Snapshot + moving `cpuhp_state_add_instance` **after** register: `a8625217a054ca` (Atish Patra, 2024-04-20) — **this is when the registered-PMU UAF became real** - Original `kfree(pmu)`-only `out_free`: `e9991434596f53` (2022-02-18) — driver introduction All of these are ancestors of this 6.12 tree. **Step 3.2: FOLLOW THE FIXES: TAG** Record: No `Fixes:` tag. Buggy code is still in this checkout (see Phase 6). **Step 3.3: CHECK FILE HISTORY FOR RELATED CHANGES** Record (this tree, `git log --oneline -20 -- drivers/perf/riscv_pmu_sbi.c`): overflow-IRQ NULL check, bitmap cmask, errno/firmware-event fixes. None of those replace this cleanup. `git log --oneline e24a1418e90be..origin/master -- drivers/perf/riscv_pmu_sbi.c` only shows later overflow-mask/bitmap work; they do not revert or redo this cleanup. **Step 3.4: CHECK THE AUTHOR'S OTHER COMMITS** Record: Atish Patra wrote the SBI PMU driver (`e9991434596f53`) and the snapshot code. This is a maintainer-area fix, not drive-by. **Step 3.5: CHECK FOR DEPENDENT/PREREQUISITE COMMITS** Record: Msgid is `counter_delegation-v9-1`. Patches 2–20 add Smcsrind/Ssccfg/Smcdeleg and a new PMU path. They are **features**, not prerequisites. This hunk only uses `hlist_unhashed`, `perf_pmu_unregister`, `free_percpu_irq`, `irq_dispose_mapping`, `free_percpu`, `pmu_ctr_list` — all already in 6.12. **Standalone.** `git show e24a1418e90be | git apply --check` succeeded (offsets only). --- ## PHASE 4: MAILING LIST AND EXTERNAL RESEARCH **Step 4.1: FIND THE ORIGINAL PATCH DISCUSSION** Record: - `b4 dig -c e24a1418e90be`: matched patch-id; lore URL `https://patch.m sgid.link/20260807-counter_delegation-v9-1-58658104e487@meta.com` - `b4 dig -a`: cleanup first appeared as **v7 01/22** (2026-06-22), then **v9 01/20** (committed) - WebFetch of lore returned **403** (Anubis). Thread was recovered via `b4 dig -m /tmp/riscv-pmu-cleanup.mbox` - No NAK on this patch. Paul Walmsley queued the first ten patches (including this one) for `riscv/for-next` **Step 4.2: CHECK WHO REVIEWED THE PATCH** Record: Charlie Jenkins `Reviewed-by`. Paul Walmsley applied it. Recipients are the RISC-V list / maintainers (from msgid and SOBs). No `Cc: stable` in review. **Step 4.3: SEARCH FOR THE BUG REPORT** Record: Reporter is Sashiko, not syzbot. v9 review of **this** patch restates remaining **pre-existing** issues (snapshot disable without CPU pin, static key, sysctl leak, init-time cpuhp leak). It does **not** NAK the cleanup. The UAF it describes of a registered-then-freed PMU is exactly what `perf_pmu_unregister` addresses. **Step 4.4: CHECK FOR RELATED PATCHES AND SERIES** Record: Rest of v9 is new ISA / delegation code. Not needed for this cleanup. Later origin/master commits on this file do not change these error labels. **Step 4.5: CHECK STABLE MAILING LIST HISTORY** Record: lore.kernel.org/stable WebFetch also 403. **UNVERIFIED** whether stable@ already discussed this. Absence of `Cc: stable` is expected for this review queue. --- ## PHASE 5: CODE SEMANTIC ANALYSIS **Step 5.1: KEY FUNCTIONS** Record: `pmu_sbi_setup_irqs`, `riscv_pmu_destroy`, `pmu_sbi_device_probe`. Related: `pmu_sbi_starting_cpu`, `riscv_pmu_alloc`, `pmu_sbi_get_ctrinfo`. **Step 5.2: TRACE CALLERS** Record: - `pmu_sbi_device_probe` — `.probe` of `pmu_sbi_driver` - Called from `pmu_sbi_devinit()` (`device_initcall`) via `platform_device_register_simple(RISCV_PMU_SBI_PDEV_NAME, ...)` - `pmu_sbi_starting_cpu` / `pmu_sbi_dying_cpu` read `riscv_pmu_use_irq` (the flag this patch clears on IRQ setup failure) **Step 5.3: TRACE CALLEES** Record: `riscv_pmu_alloc()` does `kzalloc` + `alloc_percpu_gfp` (this tree, `drivers/perf/riscv_pmu.c`). `pmu_sbi_get_ctrinfo()` `kcalloc`s `pmu_ctr_list`. `cpuhp_state_remove_instance()` always `hlist_del()`s. **Step 5.4: FOLLOW THE CALL CHAIN** Record: Boot/init on RISC-V with SBI PMU (`CONFIG_RISCV_PMU_SBI` **default y**). Trigger is probe failure after partial success: `snapshot_alloc` ENOMEM, `perf_pmu_register` failure, `cpuhp_state_add_instance` failure, or `cpu_pm_register_notifier` failure. After a successful `perf_pmu_register` and a later fail, userspace `perf` can touch a PMU whose `struct riscv_pmu` is already `kfree`d — **userspace-reachable UAF**. **Step 5.5: SEARCH FOR SIMILAR PATTERNS** Record: Same file’s `pmu_sbi_devinit()` still leaks `cpuhp_setup_state_multi` if `platform_driver_register` fails. Pre- existing, out of this patch’s scope. --- ## PHASE 6: CROSS-REFERENCING AGAINST THE LOCAL TREE **Step 6.1: DOES THE BUGGY CODE EXIST IN THIS TREE?** Record: **Yes.** This checkout is 6.12.111; `e24a1418e90be` is **not** an ancestor (`git merge-base --is-ancestor` exit 1). Current probe error path (`drivers/perf/riscv_pmu_sbi.c`): ```1462:1468:drivers/perf/riscv_pmu_sbi.c out_unregister: riscv_pmu_destroy(pmu); out_free: kfree(pmu); return ret; ``` `riscv_pmu_destroy()` still unconditionally removes the cpuhp instance. `pmu_sbi_setup_irqs()` still returns without clearing `riscv_pmu_use_irq` or disposing a mapping. Bug introduced: leaks since v5.17-era driver; UAF of registered PMU since snapshot/cpuhp reorder in `a8625217a054ca` (in this tree). **Step 6.2: CHECK FOR BACKPORT COMPLICATIONS** Record: **Clean apply** (`git apply --check` — all 6 hunks succeeded with −54 line offset). Context differs (`bitmap_copy` vs mainline `pmu->cmask = cmask`) because 6.12 already has `143668c424772` (counter mask as bitmap). No rework required. **Step 6.3: CHECK IF RELATED FIXES ARE ALREADY HERE** Record: No equivalent cleanup. Bitmap and overflow-IRQ fixes in this tree are independent. --- ## PHASE 7: SUBSYSTEM AND MAINTAINER CONTEXT **Step 7.1: SUBSYSTEM AND CRITICALITY** Record: `drivers/perf` / RISC-V SBI PMU. **IMPORTANT** for RISC-V (default-on perf), not core-mm/VFS. Not staging. **Step 7.2: SUBSYSTEM ACTIVITY** Record: Mature driver (2022) with ongoing RISC-V perf fixes. This is a long-standing error-path hole, not churn in brand-new code. --- ## PHASE 8: IMPACT AND RISK ASSESSMENT **Step 8.1: WHO IS AFFECTED** Record: RISC-V systems with `CONFIG_RISCV_PMU_SBI` (default y) and SBI PMU (QEMU virt, most recent boards). Driver-specific, not universal. **Step 8.2: TRIGGER CONDITIONS** Record: - Common path: probe succeeds — no crash - Realistic fail: `pmu_sbi_snapshot_alloc()` ENOMEM (page alloc GFP_ATOMIC per CPU) **after** `perf_pmu_register` - IRQ mapping fail with SSCOF/T-Head/Andes: probe **continues**, `riscv_pmu_use_irq` wrongly stays true - Unprivileged user cannot force probe, but **can** open the registered `"cpu"` PMU in the failure window **Step 8.3: FAILURE MODE SEVERITY** Record: - Registered PMU then `kfree(pmu)` → **UAF** → HIGH - `hlist_del` on unhashed node → **oops** → HIGH - IRQ cookie UAF → HIGH - One-time leaks if probe dies before register → MEDIUM - `enable_percpu_irq(0)` on fallback success path → MEDIUM–HIGH **Step 8.4: RISK-BENEFIT RATIO** Record: - **Benefit:** high for RISC-V 6.12 — prevents oops/UAF on probe fail and a wrong IRQ flag on a continued probe - **Risk:** low — ~27 net lines, error path + one flag clear, applies cleanly - **Ratio:** favor backport --- ## PHASE 9: FINAL SYNTHESIS **Step 9.1: EVIDENCE** **FOR:** - Real UAF: perf-registered PMU freed without unregister (snapshot/cpuhp fail after `perf_pmu_register`) - Real oops: `cpuhp_state_remove_instance` → `hlist_del` with NULL `pprev` - Real IRQ leak/UAF and `pmu_ctr_list`/`hw_events` leaks - `riscv_pmu_use_irq` left true on non-fatal IRQ setup failure (success- path bug) - Small, obviously correct, reviewed by Charlie Jenkins, authored by the driver owner - Buggy code and helpers exist in 6.12; patch applies cleanly - Standalone despite being 01/20 of a feature series **AGAINST:** - Probe-fail is uncommon (except IRQ-setup fallback, which is not fatal and is common on some platforms) - Incomplete: sysctl, snapshot static key, init-time cpuhp still leak (pre-existing) - RISC-V only - Reported by an AI bot, not a production oops **UNRESOLVED:** stable@ thread (lore 403); whether Sashiko had a concrete reproducer beyond code review. **Step 9.2: STABLE RULES CHECKLIST** 1. Obviously correct and tested? **PASS** — reviewed, applied by RISC-V maintainer, logic matches the four listed holes 2. Fixes a real bug that affects users? **PASS** — UAF/oops/leaks in the default RISC-V PMU driver 3. Important issue? **PASS** — UAF and NULL deref are HIGH; not a style cleanup 4. Small and contained? **PASS** — one file, +27/−6 5. No new features or APIs? **PASS** 6. Can apply to the local tree? **PASS** — `git apply --check` clean **Step 9.3: EXCEPTION CATEGORIES** Record: None. Ordinary bugfix. **Step 9.4: DECISION** This 6.12 tree has the buggy probe path. The fix is small, applies, and closes UAF/oops/leak holes in a default-on RISC-V driver. Remaining cleanup gaps are not a reason to withhold the part that is correct. --- ## What this means for 6.12 users On RISC-V with SBI PMU, a failed probe after `perf_pmu_register()` currently frees `struct riscv_pmu` while perf still holds it, and `riscv_pmu_destroy()` oopses by deleting an unhashed cpuhp node. The same path leaks the per-CPU IRQ cookie, `hw_events`, and `pmu_ctr_list`. IRQ setup failure is treated as non-fatal but leaves `riscv_pmu_use_irq` set, so hotplug can enable IRQ 0. The patch only rewires those gotos and frees; it does not pull in counter-delegation. Risk is low relative to leaving a registered-PMU UAF in a long-term tree. --- ## Verification - **[Phase 1]** Parsed tags: Sashiko Reported-by, Charlie Jenkins Reviewed-by, Atish Patra + Paul Walmsley SOBs, msgid v9 01/20; no Fixes - **[Phase 2]** Diff: +27/−6 in `riscv_pmu_sbi.c`; IRQ err goto, `hlist_unhashed` guard, `perf_pmu_unregister`, `free_percpu_irq`/`free_percpu`/`kfree(pmu_ctr_list)` - **[Phase 2]** Read 6.12 `pmu_sbi_device_probe` lines 1367–1468: destroy + `kfree(pmu)` only - **[Phase 2]** Read `kernel/cpu.c` `__cpuhp_state_remove_instance`: always `hlist_del(node)` - **[Phase 2]** Read `include/linux/list.h` `__hlist_del`: `WRITE_ONCE(*pprev, next)` NULL-derefs if never hashed - **[Phase 2]** Read `__cpuhp_state_add_instance_cpuslocked`: `hlist_add_head` only on success - **[Phase 3]** `git blame` IRQ path `4905ec2fb7e642` (2022); destroy `e9a023f2b73ac3` (2022); snapshot/cpuhp order `a8625217a054ca` (2024, in this tree) - **[Phase 3]** `git merge-base --is-ancestor e24a1418e90be HEAD` → not in this tree; `e9a023f2b73ac3` / `a8625217a054ca` / `e9991434596f53` → in this tree - **[Phase 3]** Follow-ups on origin/master do not redo this cleanup - **[Phase 4]** `b4 dig -c e24a1418e90be` → patch.msgid.link v9-1; `-a` shows v7 first, v9 applied - **[Phase 4]** `b4 dig -m`: 31-message mbox; Sashiko comments are pre- existing leftovers; Paul queued first ten patches; no NAK - **[Phase 4]** WebFetch lore/stable: 403 — UNVERIFIED stable-list discussion - **[Phase 5]** Probe from `device_initcall(pmu_sbi_devinit)`; `riscv_pmu_alloc` allocates `hw_events`; `pmu_sbi_get_ctrinfo` allocates `pmu_ctr_list` - **[Phase 5]** `pmu_sbi_starting_cpu` uses `riscv_pmu_use_irq` / `riscv_pmu_irq` - **[Phase 6]** `git describe HEAD` → `p-6.12-4-gbf6fcdf761abd`; `make kernelversion` → **6.12.111** - **[Phase 6]** `git apply --check` of `e24a1418e90be`: all hunks OK - **[Phase 7]** `CONFIG_RISCV_PMU_SBI` default y in `drivers/perf/Kconfig` - **[Phase 8]** Failure mode: UAF of registered PMU + cpuhp oops → HIGH - **UNVERIFIED:** live user oops; stable@ nomination history **YES** drivers/perf/riscv_pmu_sbi.c | 33 +++++++++++++++++++++++++++------ 1 file changed, 27 insertions(+), 6 deletions(-) diff --git a/drivers/perf/riscv_pmu_sbi.c b/drivers/perf/riscv_pmu_sbi.c index 25f3a45dd7869..10f64b7b60c53 100644 --- a/drivers/perf/riscv_pmu_sbi.c +++ b/drivers/perf/riscv_pmu_sbi.c @@ -1258,22 +1258,29 @@ static int pmu_sbi_setup_irqs(struct riscv_pmu *pmu, struct platform_device *pde DOMAIN_BUS_ANY); if (!domain) { pr_err("Failed to find INTC IRQ root domain\n"); - return -ENODEV; + ret = -ENODEV; + goto err; } riscv_pmu_irq = irq_create_mapping(domain, riscv_pmu_irq_num); if (!riscv_pmu_irq) { pr_err("Failed to map PMU interrupt for node\n"); - return -ENODEV; + ret = -ENODEV; + goto err; } ret = request_percpu_irq(riscv_pmu_irq, pmu_sbi_ovf_handler, "riscv-pmu", hw_events); if (ret) { pr_err("registering percpu irq failed [%d]\n", ret); - return ret; + irq_dispose_mapping(riscv_pmu_irq); + riscv_pmu_irq = 0; + goto err; } return 0; +err: + riscv_pmu_use_irq = false; + return ret; } #ifdef CONFIG_CPU_PM @@ -1340,7 +1347,8 @@ static void riscv_pmu_destroy(struct riscv_pmu *pmu) } } riscv_pm_pmu_unregister(pmu); - cpuhp_state_remove_instance(CPUHP_AP_PERF_RISCV_STARTING, &pmu->node); + if (!hlist_unhashed(&pmu->node)) + cpuhp_state_remove_instance(CPUHP_AP_PERF_RISCV_STARTING, &pmu->node); } static void pmu_sbi_event_init(struct perf_event *event) @@ -1462,6 +1470,7 @@ static int pmu_sbi_device_probe(struct platform_device *pdev) struct riscv_pmu *pmu = NULL; int ret = -ENODEV; int num_counters; + bool irq_requested = false; pr_info("SBI PMU extension is available\n"); pmu = riscv_pmu_alloc(); @@ -1490,6 +1499,7 @@ static int pmu_sbi_device_probe(struct platform_device *pdev) pmu->pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT; pmu->pmu.capabilities |= PERF_PMU_CAP_NO_EXCLUDE; } + irq_requested = (ret == 0); pmu->pmu.attr_groups = riscv_pmu_attr_groups; pmu->pmu.parent = &pdev->dev; @@ -1508,11 +1518,11 @@ static int pmu_sbi_device_probe(struct platform_device *pdev) ret = riscv_pm_pmu_register(pmu); if (ret) - goto out_unregister; + goto out_destroy; ret = perf_pmu_register(&pmu->pmu, "cpu", PERF_TYPE_RAW); if (ret) - goto out_unregister; + goto out_destroy; /* SBI PMU Snapsphot is only available in SBI v2.0 */ if (sbi_v2_available) { @@ -1553,9 +1563,20 @@ static int pmu_sbi_device_probe(struct platform_device *pdev) return 0; out_unregister: + perf_pmu_unregister(&pmu->pmu); + +out_destroy: riscv_pmu_destroy(pmu); + if (irq_requested) { + free_percpu_irq(riscv_pmu_irq, pmu->hw_events); + irq_dispose_mapping(riscv_pmu_irq); + riscv_pmu_irq = 0; + } out_free: + free_percpu(pmu->hw_events); + kfree(pmu_ctr_list); + pmu_ctr_list = NULL; kfree(pmu); return ret; } -- 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 C0DD7CCF2DE for ; Mon, 19 Oct 2026 14:05:30 +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=uh9CsG/nheWLhCHpBqL1X1qdqxUAXAAhE/sihOAv9tw=; b=NOLfBtZFxQ0Q5N G9ZyR+KKyo1gX9qAN++pdCgazfank+uclQWdKIrxxyJO1Am8Zy/8sBDq3ASGqh0Khs/b1cx+V415o lkH5Xa9gaVZ7xON5qt/bLfAsE+iY/C00mFLg1nfQlRJ44jpR3clLgUUC2BLmY5dou6IGAnYnL032s NpYP0K0p7CQkGfcKn6wIxpkMB6RZOiGxDOzuZUub/D1E2ZXQ3WeG5X6lNcXJgnTC0CIv510vRPraL RpVAlDj0C1pw7OIDjzGQy6k5BEwMzNQqYYlnmMRERZbHVmQMizFe7nPS5yaIjuB1/BwhiJXZlOVkP x9H+GQEx0lYUyMZ3eChQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1xInzH-00000007g6Q-1W3v; Mon, 19 Oct 2026 14:05:15 +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 1xInzG-00000007g5N-0hFJ; Mon, 19 Oct 2026 14:05:14 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id E533E4142A; Mon, 19 Oct 2026 14:05:13 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 43C221F000C9; Mon, 19 Oct 2026 14:05:12 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1792418713; bh=OJnDRXaD8MXKY+HfVAGx8ycJVEcnB4lWDfYJHPvkKb0=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=bf/E01hjpu608+YAIXvBZ8sLKTH6wN4X6fCJ266yZXD9IUA84iZ5tHSbvtTkUThwg j7b75Zfd9bwTyHXiMvYncHq4rvcE65DsDqz/aIEmmci2ek9dbiCVmsmivlxi4rmXyd 0hCF6sI/KvQuEynwTYJ3xs7j8KKiF54nWaVmGdVaTduzmV2qBJSfrnLNuFyQhPu7B0 0DReVvYr6GaJMZb1Ucxw9mccPd0om2AQlljhVhl6eKiHMuvKaCcGbZ2BYq7EugqtFN 7gGQJvbk6uaR63I2smHhQLXfeH4HjMUkcU7kYw8EBcxoGPlfWo7yzzg1aumaig8pA0 2sqzRO8psMLCg== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: Atish Patra , Sashiko AI , Charlie Jenkins , Paul Walmsley , Sasha Levin , atish.patra@linux.dev, will@kernel.org, mark.rutland@arm.com, palmer@dabbelt.com, aou@eecs.berkeley.edu, linux-riscv@lists.infradead.org, linux-arm-kernel@lists.infradead.org, linux-perf-users@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 6.18-6.12] RISC-V: perf: fix resource cleanup on driver probe failure Date: Mon, 19 Oct 2026 09:52:14 -0400 Message-ID: <20261019135441.1420968-443-sashal@kernel.org> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20261019135441.1420968-1-sashal@kernel.org> References: <20261019135441.1420968-1-sashal@kernel.org> MIME-Version: 1.0 X-stable: review X-Patchwork-Hint: Ignore X-stable-base: Linux 6.18.57 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 RnJvbTogQXRpc2ggUGF0cmEgPGF0aXNocEBtZXRhLmNvbT4KClsgVXBzdHJlYW0gY29tbWl0IGUy NGExNDE4ZTkwYmVhYzJlZjQzODRiYzliMGI1YTEwZjE5YjgwNmUgXQoKU2FzaGlrbyBwb2ludGVk IG91dCB2YXJpb3VzIFVBRiBhbmQgbWVtb3J5IGxlYWsgaXNzdWVzIGFyb3VuZApwbXVfc2JpX2Rl dmljZV9wcm9iZSgpIGVycm9yIHBhdGhzLgoKSWYgdGhlIHByb2JlIGZhaWxzLCBoZXJlIGFyZSBs aXN0IG9mIGNsZWFudXBzIG5lZWRlZC4KYS4gQWxyZWFkeSByZWdpc3RlcmVkIHBtdSBtdXN0IGJl IGZyZWVkCmIuIHBlciBjcHUgSVJRIG11c3QgYmUgcmVsZWFzZWQKYy4gcG11X2N0cl9saXN0IGRh dGEgc3RydWN0dXJlIG11c3QgYmUgZnJlZWQKZC4gY3B1IGhvdHBsdWcgc3RhdGUgbXVzdCBiZSBj bGVhbmVkIHVwIG9ubHkgaWYgYWRkZWQuCgpGaXggdGhlIHJlc291cmNlIGNsZWFudXAgYnkgcmVv cmdhbml6aW5nIHRoZSBjb2RlIGFyb3VuZCBwcm9iZSBmYWlsdXJlLgoKUmVwb3J0ZWQtYnk6IFNh c2hpa28gQUkgPHNhc2hpa28tYm90QGtlcm5lbC5vcmc+ClJldmlld2VkLWJ5OiBDaGFybGllIEpl bmtpbnMgPHRoZWNoYXJsZXNqZW5raW5zQGdtYWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogQXRpc2gg UGF0cmEgPGF0aXNocEBtZXRhLmNvbT4KTGluazogaHR0cHM6Ly9wYXRjaC5tc2dpZC5saW5rLzIw MjYwODA3LWNvdW50ZXJfZGVsZWdhdGlvbi12OS0xLTU4NjU4MTA0ZTQ4N0BtZXRhLmNvbQpTaWdu ZWQtb2ZmLWJ5OiBQYXVsIFdhbG1zbGV5IDxwandAa2VybmVsLm9yZz4KU2lnbmVkLW9mZi1ieTog U2FzaGEgTGV2aW4gPHNhc2hhbEBrZXJuZWwub3JnPgotLS0KCkxMTSBHZW5lcmF0ZWQgZXhwbGFu YXRpb25zLCBtYXkgYmUgY29tcGxldGVseSBib2d1czoKClRoaXMgdHJlZSBpcyAqKjYuMTIuMTEx KiogKGBwZW5kaW5nLTYuMTJgKS4gVGhlIGJ1Z2d5IHByb2JlIGNsZWFudXAgaXMKcHJlc2VudCBo ZXJlLCB0aGUgcGF0Y2ggYXBwbGllcywgYW5kIGl0IGlzIGEgcmVhbCBVQUYvbGVhay9jcmFzaCBm aXgg4oCUIGEKWUVTIGZvciB0aGlzIHRyZWUuCgotLS0KCiMjIFBIQVNFIDE6IENPTU1JVCBNRVNT QUdFIEZPUkVOU0lDUwoKKipTdGVwIDEuMTogUEFSU0UgVEhFIFNVQkpFQ1QgTElORSoqCgpSZWNv cmQ6IGBbUklTQy1WIHBlcmYgLyBTQkkgUE1VXSBbZml4XSBbcmVzb3VyY2UgY2xlYW51cCBvbiBk cml2ZXIgcHJvYmUKZmFpbHVyZV1gCgoqKlN0ZXAgMS4yOiBQQVJTRSBBTEwgQ09NTUlUIE1FU1NB R0UgVEFHUyoqCgpSZWNvcmQ6Ci0gYFJlcG9ydGVkLWJ5OiBTYXNoaWtvIEFJIDxzYXNoaWtvLWJv dEBrZXJuZWwub3JnPmAg4oCUIHN0YXRpYy1hbmFseXNpcwogIGJvdCwgbm90IGEgdXNlciBvb3Bz LCBidXQgaXQgbmFtZWQgY29uY3JldGUgVUFGL2xlYWsgcGF0aHMKLSBgUmV2aWV3ZWQtYnk6IENo YXJsaWUgSmVua2lucyA8dGhlY2hhcmxlc2plbmtpbnNAZ21haWwuY29tPmAg4oCUIFJJU0MtVgog IHJldmlld2VyCi0gYFNpZ25lZC1vZmYtYnk6IEF0aXNoIFBhdHJhIDxhdGlzaHBAbWV0YS5jb20+ YCDigJQgb3JpZ2luYWwgU0JJIFBNVQogIGRyaXZlciBhdXRob3IKLSBgTGluazogaHR0cHM6Ly9w YXRjaC5tc2dpZC5saW5rLzIwMjYwODA3LWNvdW50ZXJfZGVsZWdhdGlvbi12OS0xLQogIDU4NjU4 MTA0ZTQ4N0BtZXRhLmNvbWAg4oCUICoqdjkgMDEvMjAqKiBvZiB0aGUgY291bnRlci1kZWxlZ2F0 aW9uIHNlcmllcwotIGBTaWduZWQtb2ZmLWJ5OiBQYXVsIFdhbG1zbGV5IDxwandAa2VybmVsLm9y Zz5gIOKAlCBSSVNDLVYgbWFpbnRhaW5lcgotIE5vIGBGaXhlczpgIHRhZyAoZXhwZWN0ZWQpCi0g SWdub3JlIHBpcGVsaW5lIGBTaWduZWQtb2ZmLWJ5OiBTYXNoYSBMZXZpbmAgLyBgW1Vwc3RyZWFt IGNvbW1pdCAuLi5dYAogIOKAlCBub25lIG9uIHRoZSByZWFsIGNvbW1pdCBgZTI0YTE0MThlOTBi ZWAKCioqU3RlcCAxLjM6IEFOQUxZWkUgVEhFIENPTU1JVCBCT0RZIFRFWFQqKgoKUmVjb3JkOgot ICoqQnVnOioqIGBwbXVfc2JpX2RldmljZV9wcm9iZSgpYCBlcnJvciBwYXRocyBsZWFrIGFuZCBs ZWF2ZSBsaXZlCiAgcmVmZXJlbmNlcyB0byBmcmVlZCBvYmplY3RzCi0gKipOZWVkZWQgY2xlYW51 cHM6KiogKGEpIHVucmVnaXN0ZXIgYW4gYWxyZWFkeS1yZWdpc3RlcmVkIFBNVSwgKGIpCiAgcmVs ZWFzZSB0aGUgcGVyLUNQVSBJUlEsIChjKSBmcmVlIGBwbXVfY3RyX2xpc3RgLCAoZCkgcmVtb3Zl IHRoZSBDUFUtCiAgaG90cGx1ZyBpbnN0YW5jZSBvbmx5IGlmIGl0IHdhcyBhZGRlZAotICoqU3lt cHRvbToqKiBVQUYgYW5kIG1lbW9yeSBsZWFrcyBpZiBwcm9iZSBmYWlscyBhZnRlciBwYXJ0aWFs IHNldHVwCi0gKipSb290IGNhdXNlOioqIHByb2JlIGRvZXMgYGdvdG8gb3V0X3VucmVnaXN0ZXJg IC8gYG91dF9mcmVlYCB3aXRob3V0CiAgbWF0Y2hpbmcgdGVhcmRvd24KLSAqKlZlcnNpb24gaW5m bzoqKiBub25lIGluIHRoZSBtZXNzYWdlOyBjb2RlIGRhdGVzIHRvIDIwMjLigJMyMDI0CgoqKlN0 ZXAgMS40OiBERVRFQ1QgSElEREVOIEJVRyBGSVhFUyoqCgpSZWNvcmQ6IE5vdCBkaXNndWlzZWQu IEl0IGlzIGFuIGV4cGxpY2l0IGVycm9yLXBhdGggVUFGL2xlYWsgZml4LgrigJxSZW9yZ2FuaXpp bmcgcHJvYmUgZmFpbHVyZeKAnSBpcyB0aGUgdXN1YWwgYGdvdG9gIGNsZWFudXAgcGF0dGVybiwg bm90IGEKcmVmYWN0b3ItZm9yLWl0cy1vd24tc2FrZS4KCi0tLQoKIyMgUEhBU0UgMjogRElGRiBB TkFMWVNJUwoKKipTdGVwIDIuMTogSU5WRU5UT1JZIFRIRSBDSEFOR0VTKioKClJlY29yZDoKLSBG aWxlOiBgZHJpdmVycy9wZXJmL3Jpc2N2X3BtdV9zYmkuY2Ag4oCUICoqKzI3IC8g4oiSNioqICgz MyBpbnNlcnRpb25zLCA2CiAgZGVsZXRpb25zKQotIEZ1bmN0aW9uczogYHBtdV9zYmlfc2V0dXBf aXJxcygpYCwgYHJpc2N2X3BtdV9kZXN0cm95KClgLAogIGBwbXVfc2JpX2RldmljZV9wcm9iZSgp YAotIFNjb3BlOiBzaW5nbGUtZmlsZSBzdXJnaWNhbCBlcnJvci1wYXRoIGZpeAoKKipTdGVwIDIu MjogVU5ERVJTVEFORCBUSEUgQ09ERSBGTE9XIENIQU5HRSoqCgpSZWNvcmQ6CgoxLiAqKmBwbXVf c2JpX3NldHVwX2lycXMoKWAqKgogICAtIEJlZm9yZTogZG9tYWluL21hcHBpbmcvcmVxdWVzdCBm YWlsdXJlcyByZXR1cm4gaW1tZWRpYXRlbHkuCiAgICAgYHJpc2N2X3BtdV91c2VfaXJxYCBjYW4g c3RheSAqKnRydWUqKiBldmVuIHRob3VnaCBubyBJUlEgd2FzCiAgICAgaW5zdGFsbGVkLiBNYXBw aW5nIGxlYWtlZCBpZiBgcmVxdWVzdF9wZXJjcHVfaXJxKClgIGZhaWxlZC4KICAgLSBBZnRlcjog dGhvc2UgcGF0aHMgYGdvdG8gZXJyYCwgZGlzcG9zZSBhIGNyZWF0ZWQgbWFwcGluZywgc2V0CiAg ICAgYHJpc2N2X3BtdV91c2VfaXJxID0gZmFsc2VgLgoKMi4gKipgcmlzY3ZfcG11X2Rlc3Ryb3ko KWAqKgogICAtIEJlZm9yZTogYWx3YXlzIGBjcHVocF9zdGF0ZV9yZW1vdmVfaW5zdGFuY2UoKWAg ZXZlbiB3aGVuIHRoZQogICAgIGluc3RhbmNlIHdhcyBuZXZlciBhZGRlZC4KICAgLSBBZnRlcjog b25seSBpZiBgIWhsaXN0X3VuaGFzaGVkKCZwbXUtPm5vZGUpYC4KCjMuICoqYHBtdV9zYmlfZGV2 aWNlX3Byb2JlKClgKioKICAgLSBCZWZvcmU6IGByaXNjdl9wbV9wbXVfcmVnaXN0ZXJgIC8gYHBl cmZfcG11X3JlZ2lzdGVyYCBmYWlsdXJlcyBqdW1wCiAgICAgdG8gYG91dF91bnJlZ2lzdGVyYCAo ZGVzdHJveSArIGBrZnJlZShwbXUpYCBvbmx5KS4gU25hcHNob3QtYWxsb2MKICAgICBhbmQgY3B1 aHAtYWRkIGZhaWx1cmVzIGFsc28gc2tpcCBgcGVyZl9wbXVfdW5yZWdpc3RlcmAuIElSUSwKICAg ICBgaHdfZXZlbnRzYCwgYW5kIGBwbXVfY3RyX2xpc3RgIG5ldmVyIGZyZWVkLgogICAtIEFmdGVy OiBgaXJxX3JlcXVlc3RlZGAgdHJhY2tzIGEgc3VjY2Vzc2Z1bCBJUlEgcmVxdWVzdC4gRmFpbHVy ZXMKICAgICBiZWZvcmUgUE1VIHJlZ2lzdGVyIGdvIHRvIGBvdXRfZGVzdHJveWAuIEZhaWx1cmVz IGFmdGVyIHJlZ2lzdGVyIGdvCiAgICAgdG8gYG91dF91bnJlZ2lzdGVyYCB3aGljaCBub3cgY2Fs bHMgYHBlcmZfcG11X3VucmVnaXN0ZXJgLiBUaGVuCiAgICAgSVJRL3BlcmNwdS9gcG11X2N0cl9s aXN0YC9gcG11YCBhcmUgZnJlZWQuCgoqKlN0ZXAgMi4zOiBJREVOVElGWSBUSEUgQlVHIE1FQ0hB TklTTSoqCgpSZWNvcmQ6ICoqRXJyb3ItcGF0aCByZXNvdXJjZSBsZWFrICsgVUFGICsgTlVMTCBk ZXJlZioqLCB3aXRoIGEgbG9naWMKZml4IG9uIHRoZSBJUlEgZmFsbGJhY2sgcGF0aC4KClZlcmlm aWVkIG1lY2hhbmlzbXMgaW4gKip0aGlzKiogdHJlZToKCnwgQnVnIHwgTWVjaGFuaXNtIHwKfC0t LXwtLS18CnwgKipVQUYgb2YgcmVnaXN0ZXJlZCBQTVUqKiB8IGBwZXJmX3BtdV9yZWdpc3Rlcigp YCB0aGVuCmBwbXVfc2JpX3NuYXBzaG90X2FsbG9jKClgIG9yIGBjcHVocF9zdGF0ZV9hZGRfaW5z dGFuY2UoKWAgZmFpbHMg4oaSCmBrZnJlZShwbXUpYCB3aGlsZSB0aGUgUE1VIHN0YXlzIGluIHBl cmYgY29yZSB8CnwgKipOVUxMIGRlcmVmIC8gbGlzdCBjb3JydXB0aW9uKiogfCBgcmlzY3ZfcG11 X2Rlc3Ryb3koKWAg4oaSCmBjcHVocF9zdGF0ZV9yZW1vdmVfaW5zdGFuY2UoKWAg4oaSIGBobGlz dF9kZWwoKWAg4oaSIGBXUklURV9PTkNFKCpwcHJldiwKbmV4dClgIHdpdGggYHBwcmV2ID09IE5V TExgIG9uIGEgYGt6YWxsb2Ng4oCZZCBub2RlIHwKfCAqKklSUSArIGNvb2tpZSBVQUYqKiB8IHN1 Y2Nlc3NmdWwgYHJlcXVlc3RfcGVyY3B1X2lycSguLi4sIGh3X2V2ZW50cylgCnRoZW4gbGF0ZXIg cHJvYmUgZmFpbCBmcmVlcyBgcG11YC9gaHdfZXZlbnRzYCB3aXRob3V0IGBmcmVlX3BlcmNwdV9p cnFgCnwKfCAqKkxlYWtzKiogfCBgYWxsb2NfcGVyY3B1YCBgaHdfZXZlbnRzYCBhbmQgYGtjYWxs b2NgIGBwbXVfY3RyX2xpc3RgCm9ubHkgZnJlZWQgb24gdGhlIG5ldyBgb3V0X2ZyZWVgIHwKfCAq Kldyb25nIElSUSBmbGFnIG9uIHN1Y2Nlc3MgcGF0aCoqIHwgSVJRIHNldHVwIGZhaWx1cmUgaXMg Kipub24tCmZhdGFsKio7IHByb2JlIGNvbnRpbnVlcyB3aXRoIGBQRVJGX1BNVV9DQVBfTk9fSU5U RVJSVVBUYCBidXQKYHJpc2N2X3BtdV91c2VfaXJxYCBzdGF5ZWQgdHJ1ZSwgc28gYHBtdV9zYmlf c3RhcnRpbmdfY3B1KClgIGNhbgpgZW5hYmxlX3BlcmNwdV9pcnEoMClgIHwKCioqU3RlcCAyLjQ6 IEFTU0VTUyBUSEUgRklYIFFVQUxJVFkqKgoKUmVjb3JkOiBPYnZpb3VzbHkgY29ycmVjdCBhbmQg bWluaW1hbC4gYG91dF91bnJlZ2lzdGVyYCBpcyBvbmx5IHJlYWNoZWQKYWZ0ZXIgYSBzdWNjZXNz ZnVsIGBwZXJmX3BtdV9yZWdpc3RlcmAuIGBvdXRfZGVzdHJveWAgZG9lcyBub3QKdW5yZWdpc3Rl ci4gYGhsaXN0X3VuaGFzaGVkYCBtYXRjaGVzIGBjcHVocGAgKG5vZGUgaXMgaGFzaGVkIG9ubHkg YWZ0ZXIKc3VjY2Vzc2Z1bCBhZGQpLiBJUlEgZnJlZSBoYXBwZW5zIGJlZm9yZSBgZnJlZV9wZXJj cHUoaHdfZXZlbnRzKWAuCgpSZWdyZXNzaW9uIHJpc2s6ICoqbG93KiouIFJlbWFpbmluZyBnYXBz IChzeXNjdGwgbm90IHVucmVnaXN0ZXJlZDsKYHNiaV9wbXVfc25hcHNob3RfYXZhaWxhYmxlYCBz dGF0aWMga2V5IG5vdCBkaXNhYmxlZCkgYXJlIHByZS1leGlzdGluZwphbmQgbm90IGludHJvZHVj ZWQgaGVyZS4gVGhleSBkbyBub3QgbWFrZSB0aGlzIHBhdGNoIHVuc2FmZS4KCi0tLQoKIyMgUEhB U0UgMzogR0lUIEhJU1RPUlkgSU5WRVNUSUdBVElPTgoKKipTdGVwIDMuMTogQkxBTUUgVEhFIENI QU5HRUQgTElORVMqKgoKUmVjb3JkOgotIElSUSBlcnJvciByZXR1cm5zOiBgNDkwNWVjMmZiN2U2 NDJgIChBdGlzaCBQYXRyYSwgMjAyMi0wMi0xOCkg4oCUCiAgc3Njb2ZwbWYKLSBEZXN0cm95IC8g YG91dF91bnJlZ2lzdGVyYDogYGU5YTAyM2YyYjczYWMzYCAoRXJpYyBMaW4sIDIwMjItMDctMDUp IOKAlAogIFBNIG5vdGlmaWVyCi0gU25hcHNob3QgKyBtb3ZpbmcgYGNwdWhwX3N0YXRlX2FkZF9p bnN0YW5jZWAgKiphZnRlcioqIHJlZ2lzdGVyOgogIGBhODYyNTIxN2EwNTRjYWAgKEF0aXNoIFBh dHJhLCAyMDI0LTA0LTIwKSDigJQgKip0aGlzIGlzIHdoZW4gdGhlCiAgcmVnaXN0ZXJlZC1QTVUg VUFGIGJlY2FtZSByZWFsKioKLSBPcmlnaW5hbCBga2ZyZWUocG11KWAtb25seSBgb3V0X2ZyZWVg OiBgZTk5OTE0MzQ1OTZmNTNgICgyMDIyLTAyLTE4KSDigJQKICBkcml2ZXIgaW50cm9kdWN0aW9u CgpBbGwgb2YgdGhlc2UgYXJlIGFuY2VzdG9ycyBvZiB0aGlzIDYuMTIgdHJlZS4KCioqU3RlcCAz LjI6IEZPTExPVyBUSEUgRklYRVM6IFRBRyoqCgpSZWNvcmQ6IE5vIGBGaXhlczpgIHRhZy4gQnVn Z3kgY29kZSBpcyBzdGlsbCBpbiB0aGlzIGNoZWNrb3V0IChzZWUgUGhhc2UKNikuCgoqKlN0ZXAg My4zOiBDSEVDSyBGSUxFIEhJU1RPUlkgRk9SIFJFTEFURUQgQ0hBTkdFUyoqCgpSZWNvcmQgKHRo aXMgdHJlZSwgYGdpdCBsb2cgLS1vbmVsaW5lIC0yMCAtLQpkcml2ZXJzL3BlcmYvcmlzY3ZfcG11 X3NiaS5jYCk6IG92ZXJmbG93LUlSUSBOVUxMIGNoZWNrLCBiaXRtYXAgY21hc2ssCmVycm5vL2Zp cm13YXJlLWV2ZW50IGZpeGVzLiBOb25lIG9mIHRob3NlIHJlcGxhY2UgdGhpcyBjbGVhbnVwLiBg Z2l0IGxvZwotLW9uZWxpbmUgZTI0YTE0MThlOTBiZS4ub3JpZ2luL21hc3RlciAtLSBkcml2ZXJz L3BlcmYvcmlzY3ZfcG11X3NiaS5jYApvbmx5IHNob3dzIGxhdGVyIG92ZXJmbG93LW1hc2svYml0 bWFwIHdvcms7IHRoZXkgZG8gbm90IHJldmVydCBvciByZWRvCnRoaXMgY2xlYW51cC4KCioqU3Rl cCAzLjQ6IENIRUNLIFRIRSBBVVRIT1InUyBPVEhFUiBDT01NSVRTKioKClJlY29yZDogQXRpc2gg UGF0cmEgd3JvdGUgdGhlIFNCSSBQTVUgZHJpdmVyIChgZTk5OTE0MzQ1OTZmNTNgKSBhbmQgdGhl CnNuYXBzaG90IGNvZGUuIFRoaXMgaXMgYSBtYWludGFpbmVyLWFyZWEgZml4LCBub3QgZHJpdmUt YnkuCgoqKlN0ZXAgMy41OiBDSEVDSyBGT1IgREVQRU5ERU5UL1BSRVJFUVVJU0lURSBDT01NSVRT KioKClJlY29yZDogTXNnaWQgaXMgYGNvdW50ZXJfZGVsZWdhdGlvbi12OS0xYC4gUGF0Y2hlcyAy 4oCTMjAgYWRkClNtY3NyaW5kL1NzY2NmZy9TbWNkZWxlZyBhbmQgYSBuZXcgUE1VIHBhdGguIFRo ZXkgYXJlICoqZmVhdHVyZXMqKiwgbm90CnByZXJlcXVpc2l0ZXMuIFRoaXMgaHVuayBvbmx5IHVz ZXMgYGhsaXN0X3VuaGFzaGVkYCwKYHBlcmZfcG11X3VucmVnaXN0ZXJgLCBgZnJlZV9wZXJjcHVf aXJxYCwgYGlycV9kaXNwb3NlX21hcHBpbmdgLApgZnJlZV9wZXJjcHVgLCBgcG11X2N0cl9saXN0 YCDigJQgYWxsIGFscmVhZHkgaW4gNi4xMi4gKipTdGFuZGFsb25lLioqCmBnaXQgc2hvdyBlMjRh MTQxOGU5MGJlIHwgZ2l0IGFwcGx5IC0tY2hlY2tgIHN1Y2NlZWRlZCAob2Zmc2V0cyBvbmx5KS4K Ci0tLQoKIyMgUEhBU0UgNDogTUFJTElORyBMSVNUIEFORCBFWFRFUk5BTCBSRVNFQVJDSAoKKipT dGVwIDQuMTogRklORCBUSEUgT1JJR0lOQUwgUEFUQ0ggRElTQ1VTU0lPTioqCgpSZWNvcmQ6Ci0g YGI0IGRpZyAtYyBlMjRhMTQxOGU5MGJlYDogbWF0Y2hlZCBwYXRjaC1pZDsgbG9yZSBVUkwgYGh0 dHBzOi8vcGF0Y2gubQogIHNnaWQubGluay8yMDI2MDgwNy1jb3VudGVyX2RlbGVnYXRpb24tdjkt MS01ODY1ODEwNGU0ODdAbWV0YS5jb21gCi0gYGI0IGRpZyAtYWA6IGNsZWFudXAgZmlyc3QgYXBw ZWFyZWQgYXMgKip2NyAwMS8yMioqICgyMDI2LTA2LTIyKSwgdGhlbgogICoqdjkgMDEvMjAqKiAo Y29tbWl0dGVkKQotIFdlYkZldGNoIG9mIGxvcmUgcmV0dXJuZWQgKio0MDMqKiAoQW51YmlzKS4g VGhyZWFkIHdhcyByZWNvdmVyZWQgdmlhCiAgYGI0IGRpZyAtbSAvdG1wL3Jpc2N2LXBtdS1jbGVh bnVwLm1ib3hgCi0gTm8gTkFLIG9uIHRoaXMgcGF0Y2guIFBhdWwgV2FsbXNsZXkgcXVldWVkIHRo ZSBmaXJzdCB0ZW4gcGF0Y2hlcwogIChpbmNsdWRpbmcgdGhpcyBvbmUpIGZvciBgcmlzY3YvZm9y LW5leHRgCgoqKlN0ZXAgNC4yOiBDSEVDSyBXSE8gUkVWSUVXRUQgVEhFIFBBVENIKioKClJlY29y ZDogQ2hhcmxpZSBKZW5raW5zIGBSZXZpZXdlZC1ieWAuIFBhdWwgV2FsbXNsZXkgYXBwbGllZCBp dC4KUmVjaXBpZW50cyBhcmUgdGhlIFJJU0MtViBsaXN0IC8gbWFpbnRhaW5lcnMgKGZyb20gbXNn aWQgYW5kIFNPQnMpLiBObwpgQ2M6IHN0YWJsZWAgaW4gcmV2aWV3LgoKKipTdGVwIDQuMzogU0VB UkNIIEZPUiBUSEUgQlVHIFJFUE9SVCoqCgpSZWNvcmQ6IFJlcG9ydGVyIGlzIFNhc2hpa28sIG5v dCBzeXpib3QuIHY5IHJldmlldyBvZiAqKnRoaXMqKiBwYXRjaApyZXN0YXRlcyByZW1haW5pbmcg KipwcmUtZXhpc3RpbmcqKiBpc3N1ZXMgKHNuYXBzaG90IGRpc2FibGUgd2l0aG91dCBDUFUKcGlu LCBzdGF0aWMga2V5LCBzeXNjdGwgbGVhaywgaW5pdC10aW1lIGNwdWhwIGxlYWspLiBJdCBkb2Vz ICoqbm90KiogTkFLCnRoZSBjbGVhbnVwLiBUaGUgVUFGIGl0IGRlc2NyaWJlcyBvZiBhIHJlZ2lz dGVyZWQtdGhlbi1mcmVlZCBQTVUgaXMKZXhhY3RseSB3aGF0IGBwZXJmX3BtdV91bnJlZ2lzdGVy YCBhZGRyZXNzZXMuCgoqKlN0ZXAgNC40OiBDSEVDSyBGT1IgUkVMQVRFRCBQQVRDSEVTIEFORCBT RVJJRVMqKgoKUmVjb3JkOiBSZXN0IG9mIHY5IGlzIG5ldyBJU0EgLyBkZWxlZ2F0aW9uIGNvZGUu IE5vdCBuZWVkZWQgZm9yIHRoaXMKY2xlYW51cC4gTGF0ZXIgb3JpZ2luL21hc3RlciBjb21taXRz IG9uIHRoaXMgZmlsZSBkbyBub3QgY2hhbmdlIHRoZXNlCmVycm9yIGxhYmVscy4KCioqU3RlcCA0 LjU6IENIRUNLIFNUQUJMRSBNQUlMSU5HIExJU1QgSElTVE9SWSoqCgpSZWNvcmQ6IGxvcmUua2Vy bmVsLm9yZy9zdGFibGUgV2ViRmV0Y2ggYWxzbyA0MDMuICoqVU5WRVJJRklFRCoqIHdoZXRoZXIK c3RhYmxlQCBhbHJlYWR5IGRpc2N1c3NlZCB0aGlzLiBBYnNlbmNlIG9mIGBDYzogc3RhYmxlYCBp cyBleHBlY3RlZCBmb3IKdGhpcyByZXZpZXcgcXVldWUuCgotLS0KCiMjIFBIQVNFIDU6IENPREUg U0VNQU5USUMgQU5BTFlTSVMKCioqU3RlcCA1LjE6IEtFWSBGVU5DVElPTlMqKgoKUmVjb3JkOiBg cG11X3NiaV9zZXR1cF9pcnFzYCwgYHJpc2N2X3BtdV9kZXN0cm95YCwKYHBtdV9zYmlfZGV2aWNl X3Byb2JlYC4gUmVsYXRlZDogYHBtdV9zYmlfc3RhcnRpbmdfY3B1YCwKYHJpc2N2X3BtdV9hbGxv Y2AsIGBwbXVfc2JpX2dldF9jdHJpbmZvYC4KCioqU3RlcCA1LjI6IFRSQUNFIENBTExFUlMqKgoK UmVjb3JkOgotIGBwbXVfc2JpX2RldmljZV9wcm9iZWAg4oCUIGAucHJvYmVgIG9mIGBwbXVfc2Jp X2RyaXZlcmAKLSBDYWxsZWQgZnJvbSBgcG11X3NiaV9kZXZpbml0KClgIChgZGV2aWNlX2luaXRj YWxsYCkgdmlhCiAgYHBsYXRmb3JtX2RldmljZV9yZWdpc3Rlcl9zaW1wbGUoUklTQ1ZfUE1VX1NC SV9QREVWX05BTUUsIC4uLilgCi0gYHBtdV9zYmlfc3RhcnRpbmdfY3B1YCAvIGBwbXVfc2JpX2R5 aW5nX2NwdWAgcmVhZCBgcmlzY3ZfcG11X3VzZV9pcnFgCiAgKHRoZSBmbGFnIHRoaXMgcGF0Y2gg Y2xlYXJzIG9uIElSUSBzZXR1cCBmYWlsdXJlKQoKKipTdGVwIDUuMzogVFJBQ0UgQ0FMTEVFUyoq CgpSZWNvcmQ6IGByaXNjdl9wbXVfYWxsb2MoKWAgZG9lcyBga3phbGxvY2AgKyBgYWxsb2NfcGVy Y3B1X2dmcGAgKHRoaXMKdHJlZSwgYGRyaXZlcnMvcGVyZi9yaXNjdl9wbXUuY2ApLiBgcG11X3Ni aV9nZXRfY3RyaW5mbygpYCBga2NhbGxvY2BzCmBwbXVfY3RyX2xpc3RgLiBgY3B1aHBfc3RhdGVf cmVtb3ZlX2luc3RhbmNlKClgIGFsd2F5cyBgaGxpc3RfZGVsKClgcy4KCioqU3RlcCA1LjQ6IEZP TExPVyBUSEUgQ0FMTCBDSEFJTioqCgpSZWNvcmQ6IEJvb3QvaW5pdCBvbiBSSVNDLVYgd2l0aCBT QkkgUE1VIChgQ09ORklHX1JJU0NWX1BNVV9TQklgCioqZGVmYXVsdCB5KiopLiBUcmlnZ2VyIGlz IHByb2JlIGZhaWx1cmUgYWZ0ZXIgcGFydGlhbCBzdWNjZXNzOgpgc25hcHNob3RfYWxsb2NgIEVO T01FTSwgYHBlcmZfcG11X3JlZ2lzdGVyYCBmYWlsdXJlLApgY3B1aHBfc3RhdGVfYWRkX2luc3Rh bmNlYCBmYWlsdXJlLCBvciBgY3B1X3BtX3JlZ2lzdGVyX25vdGlmaWVyYApmYWlsdXJlLiBBZnRl ciBhIHN1Y2Nlc3NmdWwgYHBlcmZfcG11X3JlZ2lzdGVyYCBhbmQgYSBsYXRlciBmYWlsLAp1c2Vy c3BhY2UgYHBlcmZgIGNhbiB0b3VjaCBhIFBNVSB3aG9zZSBgc3RydWN0IHJpc2N2X3BtdWAgaXMg YWxyZWFkeQpga2ZyZWVgZCDigJQgKip1c2Vyc3BhY2UtcmVhY2hhYmxlIFVBRioqLgoKKipTdGVw IDUuNTogU0VBUkNIIEZPUiBTSU1JTEFSIFBBVFRFUk5TKioKClJlY29yZDogU2FtZSBmaWxl4oCZ cyBgcG11X3NiaV9kZXZpbml0KClgIHN0aWxsIGxlYWtzCmBjcHVocF9zZXR1cF9zdGF0ZV9tdWx0 aWAgaWYgYHBsYXRmb3JtX2RyaXZlcl9yZWdpc3RlcmAgZmFpbHMuIFByZS0KZXhpc3RpbmcsIG91 dCBvZiB0aGlzIHBhdGNo4oCZcyBzY29wZS4KCi0tLQoKIyMgUEhBU0UgNjogQ1JPU1MtUkVGRVJF TkNJTkcgQUdBSU5TVCBUSEUgTE9DQUwgVFJFRQoKKipTdGVwIDYuMTogRE9FUyBUSEUgQlVHR1kg Q09ERSBFWElTVCBJTiBUSElTIFRSRUU/KioKClJlY29yZDogKipZZXMuKiogVGhpcyBjaGVja291 dCBpcyA2LjEyLjExMTsgYGUyNGExNDE4ZTkwYmVgIGlzICoqbm90KioKYW4gYW5jZXN0b3IgKGBn aXQgbWVyZ2UtYmFzZSAtLWlzLWFuY2VzdG9yYCBleGl0IDEpLgoKQ3VycmVudCBwcm9iZSBlcnJv ciBwYXRoIChgZHJpdmVycy9wZXJmL3Jpc2N2X3BtdV9zYmkuY2ApOgoKYGBgMTQ2MjoxNDY4OmRy aXZlcnMvcGVyZi9yaXNjdl9wbXVfc2JpLmMKb3V0X3VucmVnaXN0ZXI6CiAgICAgICAgcmlzY3Zf cG11X2Rlc3Ryb3kocG11KTsKCm91dF9mcmVlOgogICAgICAgIGtmcmVlKHBtdSk7CiAgICAgICAg cmV0dXJuIHJldDsKYGBgCgpgcmlzY3ZfcG11X2Rlc3Ryb3koKWAgc3RpbGwgdW5jb25kaXRpb25h bGx5IHJlbW92ZXMgdGhlIGNwdWhwIGluc3RhbmNlLgpgcG11X3NiaV9zZXR1cF9pcnFzKClgIHN0 aWxsIHJldHVybnMgd2l0aG91dCBjbGVhcmluZwpgcmlzY3ZfcG11X3VzZV9pcnFgIG9yIGRpc3Bv c2luZyBhIG1hcHBpbmcuCgpCdWcgaW50cm9kdWNlZDogbGVha3Mgc2luY2UgdjUuMTctZXJhIGRy aXZlcjsgVUFGIG9mIHJlZ2lzdGVyZWQgUE1VCnNpbmNlIHNuYXBzaG90L2NwdWhwIHJlb3JkZXIg aW4gYGE4NjI1MjE3YTA1NGNhYCAoaW4gdGhpcyB0cmVlKS4KCioqU3RlcCA2LjI6IENIRUNLIEZP UiBCQUNLUE9SVCBDT01QTElDQVRJT05TKioKClJlY29yZDogKipDbGVhbiBhcHBseSoqIChgZ2l0 IGFwcGx5IC0tY2hlY2tgIOKAlCBhbGwgNiBodW5rcyBzdWNjZWVkZWQKd2l0aCDiiJI1NCBsaW5l IG9mZnNldCkuIENvbnRleHQgZGlmZmVycyAoYGJpdG1hcF9jb3B5YCB2cyBtYWlubGluZQpgcG11 LT5jbWFzayA9IGNtYXNrYCkgYmVjYXVzZSA2LjEyIGFscmVhZHkgaGFzIGAxNDM2NjhjNDI0Nzcy YCAoY291bnRlcgptYXNrIGFzIGJpdG1hcCkuIE5vIHJld29yayByZXF1aXJlZC4KCioqU3RlcCA2 LjM6IENIRUNLIElGIFJFTEFURUQgRklYRVMgQVJFIEFMUkVBRFkgSEVSRSoqCgpSZWNvcmQ6IE5v IGVxdWl2YWxlbnQgY2xlYW51cC4gQml0bWFwIGFuZCBvdmVyZmxvdy1JUlEgZml4ZXMgaW4gdGhp cwp0cmVlIGFyZSBpbmRlcGVuZGVudC4KCi0tLQoKIyMgUEhBU0UgNzogU1VCU1lTVEVNIEFORCBN QUlOVEFJTkVSIENPTlRFWFQKCioqU3RlcCA3LjE6IFNVQlNZU1RFTSBBTkQgQ1JJVElDQUxJVFkq KgoKUmVjb3JkOiBgZHJpdmVycy9wZXJmYCAvIFJJU0MtViBTQkkgUE1VLiAqKklNUE9SVEFOVCoq IGZvciBSSVNDLVYKKGRlZmF1bHQtb24gcGVyZiksIG5vdCBjb3JlLW1tL1ZGUy4gTm90IHN0YWdp bmcuCgoqKlN0ZXAgNy4yOiBTVUJTWVNURU0gQUNUSVZJVFkqKgoKUmVjb3JkOiBNYXR1cmUgZHJp dmVyICgyMDIyKSB3aXRoIG9uZ29pbmcgUklTQy1WIHBlcmYgZml4ZXMuIFRoaXMgaXMgYQpsb25n LXN0YW5kaW5nIGVycm9yLXBhdGggaG9sZSwgbm90IGNodXJuIGluIGJyYW5kLW5ldyBjb2RlLgoK LS0tCgojIyBQSEFTRSA4OiBJTVBBQ1QgQU5EIFJJU0sgQVNTRVNTTUVOVAoKKipTdGVwIDguMTog V0hPIElTIEFGRkVDVEVEKioKClJlY29yZDogUklTQy1WIHN5c3RlbXMgd2l0aCBgQ09ORklHX1JJ U0NWX1BNVV9TQklgIChkZWZhdWx0IHkpIGFuZCBTQkkKUE1VIChRRU1VIHZpcnQsIG1vc3QgcmVj ZW50IGJvYXJkcykuIERyaXZlci1zcGVjaWZpYywgbm90IHVuaXZlcnNhbC4KCioqU3RlcCA4LjI6 IFRSSUdHRVIgQ09ORElUSU9OUyoqCgpSZWNvcmQ6Ci0gQ29tbW9uIHBhdGg6IHByb2JlIHN1Y2Nl ZWRzIOKAlCBubyBjcmFzaAotIFJlYWxpc3RpYyBmYWlsOiBgcG11X3NiaV9zbmFwc2hvdF9hbGxv YygpYCBFTk9NRU0gKHBhZ2UgYWxsb2MKICBHRlBfQVRPTUlDIHBlciBDUFUpICoqYWZ0ZXIqKiBg cGVyZl9wbXVfcmVnaXN0ZXJgCi0gSVJRIG1hcHBpbmcgZmFpbCB3aXRoIFNTQ09GL1QtSGVhZC9B bmRlczogcHJvYmUgKipjb250aW51ZXMqKiwKICBgcmlzY3ZfcG11X3VzZV9pcnFgIHdyb25nbHkg c3RheXMgdHJ1ZQotIFVucHJpdmlsZWdlZCB1c2VyIGNhbm5vdCBmb3JjZSBwcm9iZSwgYnV0ICoq Y2FuKiogb3BlbiB0aGUgcmVnaXN0ZXJlZAogIGAiY3B1ImAgUE1VIGluIHRoZSBmYWlsdXJlIHdp bmRvdwoKKipTdGVwIDguMzogRkFJTFVSRSBNT0RFIFNFVkVSSVRZKioKClJlY29yZDoKLSBSZWdp c3RlcmVkIFBNVSB0aGVuIGBrZnJlZShwbXUpYCDihpIgKipVQUYqKiDihpIgSElHSAotIGBobGlz dF9kZWxgIG9uIHVuaGFzaGVkIG5vZGUg4oaSICoqb29wcyoqIOKGkiBISUdICi0gSVJRIGNvb2tp ZSBVQUYg4oaSIEhJR0gKLSBPbmUtdGltZSBsZWFrcyBpZiBwcm9iZSBkaWVzIGJlZm9yZSByZWdp c3RlciDihpIgTUVESVVNCi0gYGVuYWJsZV9wZXJjcHVfaXJxKDApYCBvbiBmYWxsYmFjayBzdWNj ZXNzIHBhdGgg4oaSIE1FRElVTeKAk0hJR0gKCioqU3RlcCA4LjQ6IFJJU0stQkVORUZJVCBSQVRJ TyoqCgpSZWNvcmQ6Ci0gKipCZW5lZml0OioqIGhpZ2ggZm9yIFJJU0MtViA2LjEyIOKAlCBwcmV2 ZW50cyBvb3BzL1VBRiBvbiBwcm9iZSBmYWlsCiAgYW5kIGEgd3JvbmcgSVJRIGZsYWcgb24gYSBj b250aW51ZWQgcHJvYmUKLSAqKlJpc2s6KiogbG93IOKAlCB+MjcgbmV0IGxpbmVzLCBlcnJvciBw YXRoICsgb25lIGZsYWcgY2xlYXIsIGFwcGxpZXMKICBjbGVhbmx5Ci0gKipSYXRpbzoqKiBmYXZv ciBiYWNrcG9ydAoKLS0tCgojIyBQSEFTRSA5OiBGSU5BTCBTWU5USEVTSVMKCioqU3RlcCA5LjE6 IEVWSURFTkNFKioKCioqRk9SOioqCi0gUmVhbCBVQUY6IHBlcmYtcmVnaXN0ZXJlZCBQTVUgZnJl ZWQgd2l0aG91dCB1bnJlZ2lzdGVyIChzbmFwc2hvdC9jcHVocAogIGZhaWwgYWZ0ZXIgYHBlcmZf cG11X3JlZ2lzdGVyYCkKLSBSZWFsIG9vcHM6IGBjcHVocF9zdGF0ZV9yZW1vdmVfaW5zdGFuY2Vg IOKGkiBgaGxpc3RfZGVsYCB3aXRoIE5VTEwKICBgcHByZXZgCi0gUmVhbCBJUlEgbGVhay9VQUYg YW5kIGBwbXVfY3RyX2xpc3RgL2Bod19ldmVudHNgIGxlYWtzCi0gYHJpc2N2X3BtdV91c2VfaXJx YCBsZWZ0IHRydWUgb24gbm9uLWZhdGFsIElSUSBzZXR1cCBmYWlsdXJlIChzdWNjZXNzLQogIHBh dGggYnVnKQotIFNtYWxsLCBvYnZpb3VzbHkgY29ycmVjdCwgcmV2aWV3ZWQgYnkgQ2hhcmxpZSBK ZW5raW5zLCBhdXRob3JlZCBieSB0aGUKICBkcml2ZXIgb3duZXIKLSBCdWdneSBjb2RlIGFuZCBo ZWxwZXJzIGV4aXN0IGluIDYuMTI7IHBhdGNoIGFwcGxpZXMgY2xlYW5seQotIFN0YW5kYWxvbmUg ZGVzcGl0ZSBiZWluZyAwMS8yMCBvZiBhIGZlYXR1cmUgc2VyaWVzCgoqKkFHQUlOU1Q6KioKLSBQ cm9iZS1mYWlsIGlzIHVuY29tbW9uIChleGNlcHQgSVJRLXNldHVwIGZhbGxiYWNrLCB3aGljaCBp cyBub3QgZmF0YWwKICBhbmQgaXMgY29tbW9uIG9uIHNvbWUgcGxhdGZvcm1zKQotIEluY29tcGxl dGU6IHN5c2N0bCwgc25hcHNob3Qgc3RhdGljIGtleSwgaW5pdC10aW1lIGNwdWhwIHN0aWxsIGxl YWsKICAocHJlLWV4aXN0aW5nKQotIFJJU0MtViBvbmx5Ci0gUmVwb3J0ZWQgYnkgYW4gQUkgYm90 LCBub3QgYSBwcm9kdWN0aW9uIG9vcHMKCioqVU5SRVNPTFZFRDoqKiBzdGFibGVAIHRocmVhZCAo bG9yZSA0MDMpOyB3aGV0aGVyIFNhc2hpa28gaGFkIGEKY29uY3JldGUgcmVwcm9kdWNlciBiZXlv bmQgY29kZSByZXZpZXcuCgoqKlN0ZXAgOS4yOiBTVEFCTEUgUlVMRVMgQ0hFQ0tMSVNUKioKCjEu IE9idmlvdXNseSBjb3JyZWN0IGFuZCB0ZXN0ZWQ/ICoqUEFTUyoqIOKAlCByZXZpZXdlZCwgYXBw bGllZCBieSBSSVNDLVYKICAgbWFpbnRhaW5lciwgbG9naWMgbWF0Y2hlcyB0aGUgZm91ciBsaXN0 ZWQgaG9sZXMKMi4gRml4ZXMgYSByZWFsIGJ1ZyB0aGF0IGFmZmVjdHMgdXNlcnM/ICoqUEFTUyoq IOKAlCBVQUYvb29wcy9sZWFrcyBpbiB0aGUKICAgZGVmYXVsdCBSSVNDLVYgUE1VIGRyaXZlcgoz LiBJbXBvcnRhbnQgaXNzdWU/ICoqUEFTUyoqIOKAlCBVQUYgYW5kIE5VTEwgZGVyZWYgYXJlIEhJ R0g7IG5vdCBhIHN0eWxlCiAgIGNsZWFudXAKNC4gU21hbGwgYW5kIGNvbnRhaW5lZD8gKipQQVNT Kiog4oCUIG9uZSBmaWxlLCArMjcv4oiSNgo1LiBObyBuZXcgZmVhdHVyZXMgb3IgQVBJcz8gKipQ QVNTKioKNi4gQ2FuIGFwcGx5IHRvIHRoZSBsb2NhbCB0cmVlPyAqKlBBU1MqKiDigJQgYGdpdCBh cHBseSAtLWNoZWNrYCBjbGVhbgoKKipTdGVwIDkuMzogRVhDRVBUSU9OIENBVEVHT1JJRVMqKgoK UmVjb3JkOiBOb25lLiBPcmRpbmFyeSBidWdmaXguCgoqKlN0ZXAgOS40OiBERUNJU0lPTioqCgpU aGlzIDYuMTIgdHJlZSBoYXMgdGhlIGJ1Z2d5IHByb2JlIHBhdGguIFRoZSBmaXggaXMgc21hbGws IGFwcGxpZXMsIGFuZApjbG9zZXMgVUFGL29vcHMvbGVhayBob2xlcyBpbiBhIGRlZmF1bHQtb24g UklTQy1WIGRyaXZlci4gUmVtYWluaW5nCmNsZWFudXAgZ2FwcyBhcmUgbm90IGEgcmVhc29uIHRv IHdpdGhob2xkIHRoZSBwYXJ0IHRoYXQgaXMgY29ycmVjdC4KCi0tLQoKIyMgV2hhdCB0aGlzIG1l YW5zIGZvciA2LjEyIHVzZXJzCgpPbiBSSVNDLVYgd2l0aCBTQkkgUE1VLCBhIGZhaWxlZCBwcm9i ZSBhZnRlciBgcGVyZl9wbXVfcmVnaXN0ZXIoKWAKY3VycmVudGx5IGZyZWVzIGBzdHJ1Y3Qgcmlz Y3ZfcG11YCB3aGlsZSBwZXJmIHN0aWxsIGhvbGRzIGl0LCBhbmQKYHJpc2N2X3BtdV9kZXN0cm95 KClgIG9vcHNlcyBieSBkZWxldGluZyBhbiB1bmhhc2hlZCBjcHVocCBub2RlLiBUaGUKc2FtZSBw YXRoIGxlYWtzIHRoZSBwZXItQ1BVIElSUSBjb29raWUsIGBod19ldmVudHNgLCBhbmQgYHBtdV9j dHJfbGlzdGAuCklSUSBzZXR1cCBmYWlsdXJlIGlzIHRyZWF0ZWQgYXMgbm9uLWZhdGFsIGJ1dCBs ZWF2ZXMgYHJpc2N2X3BtdV91c2VfaXJxYApzZXQsIHNvIGhvdHBsdWcgY2FuIGVuYWJsZSBJUlEg MC4gVGhlIHBhdGNoIG9ubHkgcmV3aXJlcyB0aG9zZSBnb3RvcyBhbmQKZnJlZXM7IGl0IGRvZXMg bm90IHB1bGwgaW4gY291bnRlci1kZWxlZ2F0aW9uLgoKUmlzayBpcyBsb3cgcmVsYXRpdmUgdG8g bGVhdmluZyBhIHJlZ2lzdGVyZWQtUE1VIFVBRiBpbiBhIGxvbmctdGVybQp0cmVlLgoKLS0tCgoj IyBWZXJpZmljYXRpb24KCi0gKipbUGhhc2UgMV0qKiBQYXJzZWQgdGFnczogU2FzaGlrbyBSZXBv cnRlZC1ieSwgQ2hhcmxpZSBKZW5raW5zCiAgUmV2aWV3ZWQtYnksIEF0aXNoIFBhdHJhICsgUGF1 bCBXYWxtc2xleSBTT0JzLCBtc2dpZCB2OSAwMS8yMDsgbm8KICBGaXhlcwotICoqW1BoYXNlIDJd KiogRGlmZjogKzI3L+KIkjYgaW4gYHJpc2N2X3BtdV9zYmkuY2A7IElSUSBlcnIgZ290bywKICBg aGxpc3RfdW5oYXNoZWRgIGd1YXJkLCBgcGVyZl9wbXVfdW5yZWdpc3RlcmAsCiAgYGZyZWVfcGVy Y3B1X2lycWAvYGZyZWVfcGVyY3B1YC9ga2ZyZWUocG11X2N0cl9saXN0KWAKLSAqKltQaGFzZSAy XSoqIFJlYWQgNi4xMiBgcG11X3NiaV9kZXZpY2VfcHJvYmVgIGxpbmVzIDEzNjfigJMxNDY4Ogog IGRlc3Ryb3kgKyBga2ZyZWUocG11KWAgb25seQotICoqW1BoYXNlIDJdKiogUmVhZCBga2VybmVs L2NwdS5jYCBgX19jcHVocF9zdGF0ZV9yZW1vdmVfaW5zdGFuY2VgOgogIGFsd2F5cyBgaGxpc3Rf ZGVsKG5vZGUpYAotICoqW1BoYXNlIDJdKiogUmVhZCBgaW5jbHVkZS9saW51eC9saXN0LmhgIGBf X2hsaXN0X2RlbGA6CiAgYFdSSVRFX09OQ0UoKnBwcmV2LCBuZXh0KWAgTlVMTC1kZXJlZnMgaWYg bmV2ZXIgaGFzaGVkCi0gKipbUGhhc2UgMl0qKiBSZWFkIGBfX2NwdWhwX3N0YXRlX2FkZF9pbnN0 YW5jZV9jcHVzbG9ja2VkYDoKICBgaGxpc3RfYWRkX2hlYWRgIG9ubHkgb24gc3VjY2VzcwotICoq W1BoYXNlIDNdKiogYGdpdCBibGFtZWAgSVJRIHBhdGggYDQ5MDVlYzJmYjdlNjQyYCAoMjAyMik7 IGRlc3Ryb3kKICBgZTlhMDIzZjJiNzNhYzNgICgyMDIyKTsgc25hcHNob3QvY3B1aHAgb3JkZXIg YGE4NjI1MjE3YTA1NGNhYCAoMjAyNCwKICBpbiB0aGlzIHRyZWUpCi0gKipbUGhhc2UgM10qKiBg Z2l0IG1lcmdlLWJhc2UgLS1pcy1hbmNlc3RvciBlMjRhMTQxOGU5MGJlIEhFQURgIOKGkiBub3QK ICBpbiB0aGlzIHRyZWU7IGBlOWEwMjNmMmI3M2FjM2AgLyBgYTg2MjUyMTdhMDU0Y2FgIC8gYGU5 OTkxNDM0NTk2ZjUzYCDihpIKICBpbiB0aGlzIHRyZWUKLSAqKltQaGFzZSAzXSoqIEZvbGxvdy11 cHMgb24gb3JpZ2luL21hc3RlciBkbyBub3QgcmVkbyB0aGlzIGNsZWFudXAKLSAqKltQaGFzZSA0 XSoqIGBiNCBkaWcgLWMgZTI0YTE0MThlOTBiZWAg4oaSIHBhdGNoLm1zZ2lkLmxpbmsgdjktMTsg YC1hYAogIHNob3dzIHY3IGZpcnN0LCB2OSBhcHBsaWVkCi0gKipbUGhhc2UgNF0qKiBgYjQgZGln IC1tYDogMzEtbWVzc2FnZSBtYm94OyBTYXNoaWtvIGNvbW1lbnRzIGFyZSBwcmUtCiAgZXhpc3Rp bmcgbGVmdG92ZXJzOyBQYXVsIHF1ZXVlZCBmaXJzdCB0ZW4gcGF0Y2hlczsgbm8gTkFLCi0gKipb UGhhc2UgNF0qKiBXZWJGZXRjaCBsb3JlL3N0YWJsZTogNDAzIOKAlCBVTlZFUklGSUVEIHN0YWJs ZS1saXN0CiAgZGlzY3Vzc2lvbgotICoqW1BoYXNlIDVdKiogUHJvYmUgZnJvbSBgZGV2aWNlX2lu aXRjYWxsKHBtdV9zYmlfZGV2aW5pdClgOwogIGByaXNjdl9wbXVfYWxsb2NgIGFsbG9jYXRlcyBg aHdfZXZlbnRzYDsgYHBtdV9zYmlfZ2V0X2N0cmluZm9gCiAgYWxsb2NhdGVzIGBwbXVfY3RyX2xp c3RgCi0gKipbUGhhc2UgNV0qKiBgcG11X3NiaV9zdGFydGluZ19jcHVgIHVzZXMgYHJpc2N2X3Bt dV91c2VfaXJxYCAvCiAgYHJpc2N2X3BtdV9pcnFgCi0gKipbUGhhc2UgNl0qKiBgZ2l0IGRlc2Ny aWJlIEhFQURgIOKGkiBgcC02LjEyLTQtZ2JmNmZjZGY3NjFhYmRgOyBgbWFrZQogIGtlcm5lbHZl cnNpb25gIOKGkiAqKjYuMTIuMTExKioKLSAqKltQaGFzZSA2XSoqIGBnaXQgYXBwbHkgLS1jaGVj a2Agb2YgYGUyNGExNDE4ZTkwYmVgOiBhbGwgaHVua3MgT0sKLSAqKltQaGFzZSA3XSoqIGBDT05G SUdfUklTQ1ZfUE1VX1NCSWAgZGVmYXVsdCB5IGluCiAgYGRyaXZlcnMvcGVyZi9LY29uZmlnYAot ICoqW1BoYXNlIDhdKiogRmFpbHVyZSBtb2RlOiBVQUYgb2YgcmVnaXN0ZXJlZCBQTVUgKyBjcHVo cCBvb3BzIOKGkiBISUdICi0gKipVTlZFUklGSUVEOioqIGxpdmUgdXNlciBvb3BzOyBzdGFibGVA IG5vbWluYXRpb24gaGlzdG9yeQoKKipZRVMqKgoKIGRyaXZlcnMvcGVyZi9yaXNjdl9wbXVfc2Jp LmMgfCAzMyArKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0KIDEgZmlsZSBjaGFuZ2Vk LCAyNyBpbnNlcnRpb25zKCspLCA2IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMv cGVyZi9yaXNjdl9wbXVfc2JpLmMgYi9kcml2ZXJzL3BlcmYvcmlzY3ZfcG11X3NiaS5jCmluZGV4 IDI1ZjNhNDVkZDc4NjkuLjEwZjY0YjdiNjBjNTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGVyZi9y aXNjdl9wbXVfc2JpLmMKKysrIGIvZHJpdmVycy9wZXJmL3Jpc2N2X3BtdV9zYmkuYwpAQCAtMTI1 OCwyMiArMTI1OCwyOSBAQCBzdGF0aWMgaW50IHBtdV9zYmlfc2V0dXBfaXJxcyhzdHJ1Y3Qgcmlz Y3ZfcG11ICpwbXUsIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZQogCQkJCQkgIERPTUFJTl9C VVNfQU5ZKTsKIAlpZiAoIWRvbWFpbikgewogCQlwcl9lcnIoIkZhaWxlZCB0byBmaW5kIElOVEMg SVJRIHJvb3QgZG9tYWluXG4iKTsKLQkJcmV0dXJuIC1FTk9ERVY7CisJCXJldCA9IC1FTk9ERVY7 CisJCWdvdG8gZXJyOwogCX0KIAogCXJpc2N2X3BtdV9pcnEgPSBpcnFfY3JlYXRlX21hcHBpbmco ZG9tYWluLCByaXNjdl9wbXVfaXJxX251bSk7CiAJaWYgKCFyaXNjdl9wbXVfaXJxKSB7CiAJCXBy X2VycigiRmFpbGVkIHRvIG1hcCBQTVUgaW50ZXJydXB0IGZvciBub2RlXG4iKTsKLQkJcmV0dXJu IC1FTk9ERVY7CisJCXJldCA9IC1FTk9ERVY7CisJCWdvdG8gZXJyOwogCX0KIAogCXJldCA9IHJl cXVlc3RfcGVyY3B1X2lycShyaXNjdl9wbXVfaXJxLCBwbXVfc2JpX292Zl9oYW5kbGVyLCAicmlz Y3YtcG11IiwgaHdfZXZlbnRzKTsKIAlpZiAocmV0KSB7CiAJCXByX2VycigicmVnaXN0ZXJpbmcg cGVyY3B1IGlycSBmYWlsZWQgWyVkXVxuIiwgcmV0KTsKLQkJcmV0dXJuIHJldDsKKwkJaXJxX2Rp c3Bvc2VfbWFwcGluZyhyaXNjdl9wbXVfaXJxKTsKKwkJcmlzY3ZfcG11X2lycSA9IDA7CisJCWdv dG8gZXJyOwogCX0KIAogCXJldHVybiAwOworZXJyOgorCXJpc2N2X3BtdV91c2VfaXJxID0gZmFs c2U7CisJcmV0dXJuIHJldDsKIH0KIAogI2lmZGVmIENPTkZJR19DUFVfUE0KQEAgLTEzNDAsNyAr MTM0Nyw4IEBAIHN0YXRpYyB2b2lkIHJpc2N2X3BtdV9kZXN0cm95KHN0cnVjdCByaXNjdl9wbXUg KnBtdSkKIAkJfQogCX0KIAlyaXNjdl9wbV9wbXVfdW5yZWdpc3RlcihwbXUpOwotCWNwdWhwX3N0 YXRlX3JlbW92ZV9pbnN0YW5jZShDUFVIUF9BUF9QRVJGX1JJU0NWX1NUQVJUSU5HLCAmcG11LT5u b2RlKTsKKwlpZiAoIWhsaXN0X3VuaGFzaGVkKCZwbXUtPm5vZGUpKQorCQljcHVocF9zdGF0ZV9y ZW1vdmVfaW5zdGFuY2UoQ1BVSFBfQVBfUEVSRl9SSVNDVl9TVEFSVElORywgJnBtdS0+bm9kZSk7 CiB9CiAKIHN0YXRpYyB2b2lkIHBtdV9zYmlfZXZlbnRfaW5pdChzdHJ1Y3QgcGVyZl9ldmVudCAq ZXZlbnQpCkBAIC0xNDYyLDYgKzE0NzAsNyBAQCBzdGF0aWMgaW50IHBtdV9zYmlfZGV2aWNlX3By b2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJc3RydWN0IHJpc2N2X3BtdSAqcG11 ID0gTlVMTDsKIAlpbnQgcmV0ID0gLUVOT0RFVjsKIAlpbnQgbnVtX2NvdW50ZXJzOworCWJvb2wg aXJxX3JlcXVlc3RlZCA9IGZhbHNlOwogCiAJcHJfaW5mbygiU0JJIFBNVSBleHRlbnNpb24gaXMg YXZhaWxhYmxlXG4iKTsKIAlwbXUgPSByaXNjdl9wbXVfYWxsb2MoKTsKQEAgLTE0OTAsNiArMTQ5 OSw3IEBAIHN0YXRpYyBpbnQgcG11X3NiaV9kZXZpY2VfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikKIAkJcG11LT5wbXUuY2FwYWJpbGl0aWVzIHw9IFBFUkZfUE1VX0NBUF9OT19J TlRFUlJVUFQ7CiAJCXBtdS0+cG11LmNhcGFiaWxpdGllcyB8PSBQRVJGX1BNVV9DQVBfTk9fRVhD TFVERTsKIAl9CisJaXJxX3JlcXVlc3RlZCA9IChyZXQgPT0gMCk7CiAKIAlwbXUtPnBtdS5hdHRy X2dyb3VwcyA9IHJpc2N2X3BtdV9hdHRyX2dyb3VwczsKIAlwbXUtPnBtdS5wYXJlbnQgPSAmcGRl di0+ZGV2OwpAQCAtMTUwOCwxMSArMTUxOCwxMSBAQCBzdGF0aWMgaW50IHBtdV9zYmlfZGV2aWNl X3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAKIAlyZXQgPSByaXNjdl9wbV9w bXVfcmVnaXN0ZXIocG11KTsKIAlpZiAocmV0KQotCQlnb3RvIG91dF91bnJlZ2lzdGVyOworCQln b3RvIG91dF9kZXN0cm95OwogCiAJcmV0ID0gcGVyZl9wbXVfcmVnaXN0ZXIoJnBtdS0+cG11LCAi Y3B1IiwgUEVSRl9UWVBFX1JBVyk7CiAJaWYgKHJldCkKLQkJZ290byBvdXRfdW5yZWdpc3RlcjsK KwkJZ290byBvdXRfZGVzdHJveTsKIAogCS8qIFNCSSBQTVUgU25hcHNwaG90IGlzIG9ubHkgYXZh aWxhYmxlIGluIFNCSSB2Mi4wICovCiAJaWYgKHNiaV92Ml9hdmFpbGFibGUpIHsKQEAgLTE1NTMs OSArMTU2MywyMCBAQCBzdGF0aWMgaW50IHBtdV9zYmlfZGV2aWNlX3Byb2JlKHN0cnVjdCBwbGF0 Zm9ybV9kZXZpY2UgKnBkZXYpCiAJcmV0dXJuIDA7CiAKIG91dF91bnJlZ2lzdGVyOgorCXBlcmZf cG11X3VucmVnaXN0ZXIoJnBtdS0+cG11KTsKKworb3V0X2Rlc3Ryb3k6CiAJcmlzY3ZfcG11X2Rl c3Ryb3kocG11KTsKKwlpZiAoaXJxX3JlcXVlc3RlZCkgeworCQlmcmVlX3BlcmNwdV9pcnEocmlz Y3ZfcG11X2lycSwgcG11LT5od19ldmVudHMpOworCQlpcnFfZGlzcG9zZV9tYXBwaW5nKHJpc2N2 X3BtdV9pcnEpOworCQlyaXNjdl9wbXVfaXJxID0gMDsKKwl9CiAKIG91dF9mcmVlOgorCWZyZWVf cGVyY3B1KHBtdS0+aHdfZXZlbnRzKTsKKwlrZnJlZShwbXVfY3RyX2xpc3QpOworCXBtdV9jdHJf bGlzdCA9IE5VTEw7CiAJa2ZyZWUocG11KTsKIAlyZXR1cm4gcmV0OwogfQotLSAKMi41My4wCgoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtcmlz Y3YgbWFpbGluZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xp c3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1yaXNjdgo=