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 E0DDC5432ED; Mon, 19 Oct 2026 14:06:03 +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=1792418766; cv=none; b=VvgQvnbxPeQXfQjhtme8GRh+NYZxNiCj/VXRCsoW7xnBgswU+E+yH8CG8ORgMkewPL11HfptoiF5xa2NjSZL6kG0H22rMmjceDJMAhlXt31IPWuLt+1dx4Ff7vE2Z2/z2XwKuSSfFbkO84+UufQKgWtX7zdK88Ehmgh89ofj3ZQ= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1792418766; c=relaxed/simple; bh=yu2MuGHm1FaRE8vsG0Ysv/5p86UK3dzAw/ie4BXiA0c=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=b+jMz2ghyVL2vzygT7QW33Y2ad2kf535Cp4703HIOYql4hooguKuJn6V1yFam6P+/IEpEOoxRz9pd4LvUFN7cOgXC6/XWGJiHzsM315hKYtepSpBNVnolZG64OjsRcgbFOh22ezlA83/p5/pIS0BL3hS0oeDaUtJxB9ha12JtxY= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=K/xu3MXy; 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="K/xu3MXy" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0DC1A1F000D0; Mon, 19 Oct 2026 14:06:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1792418763; bh=j0uQS4vSaxc/yio3qUhmLXjUkn3ACaDPz7vnrn8DEOk=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=K/xu3MXyRtVWD5MRzDNO3aY83t6umkUoVjiVCO9dqGSd65uWSKG5K0bRZ1QpOpQBX c7fbT1Bb/zE5/cIjzfd+5GD6yyPrjQuiqKz2+zPGyFB7Z3M9bkcWJNg6RTwkbXoNdD I+cUBpVYxT0B37sJiHmQAfnAdBRQ6eD/ycVI9a9k2yG7yOyHHHZ3KWIvl8M6SMXNZ1 gTuBPu8nqY07zEU5Fij8//c5e1TfRbWKz49+YeXTv7Ttvv0Ztkw4YnXlZ6dytTJWp4 pSEsrD4WdkjYTa5kAew1DYaVZde6ez2xOwPhmBZUDtaVQ+OKP4OwOfwCXirNvQXPQ1 brTc0u+xmvNtg== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: Kuan-Wei Chiu , Pu Lehui , Kumar Kartikeya Dwivedi , Sasha Levin , ast@kernel.org, daniel@iogearbox.net, andrii@kernel.org, eddyz87@gmail.com, luke.r.nels@gmail.com, xi.wang@gmail.com, pjw@kernel.org, palmer@dabbelt.com, aou@eecs.berkeley.edu, bpf@vger.kernel.org, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 6.18-5.10] riscv, bpf: Add support for BPF_MOVSX in RV32 JIT Date: Mon, 19 Oct 2026 09:52:49 -0400 Message-ID: <20261019135441.1420968-478-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> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: 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 From: Kuan-Wei Chiu [ Upstream commit c6a08afdfe3a81b1a54e921921e9481dd6c78f8a ] The current rv32 bpf jit compiler incorrectly treats BPF_MOVSX as a standard zero-extended move operation. The bpf instruction set allows sign-extension moves by reusing the BPF_MOV opcode with the instruction offset set to 8, 16, or 32. Update the bpf_jit_emit_insn() function to check the offset field for both ALU and ALU64 MOV operations. If the offset is non-zero, emit the correct slli and srai instructions to perform the sign extension. Before this patch: [ 19.549705] test_bpf: #82 ALU_MOVSX | BPF_B jited:1 ret 2 != 1 (0x2 != 0x1)FAIL (1 times) [ 19.551354] test_bpf: #83 ALU_MOVSX | BPF_H jited:1 ret 2 != 1 (0x2 != 0x1)FAIL (1 times) [ 19.552576] test_bpf: #84 ALU64_MOVSX | BPF_B jited:1 ret 2 != 1 (0x2 != 0x1)FAIL (1 times) [ 19.553542] test_bpf: #85 ALU64_MOVSX | BPF_H jited:1 ret 2 != 1 (0x2 != 0x1)FAIL (1 times) [ 19.554807] test_bpf: #86 ALU64_MOVSX | BPF_W jited:1 ret 2 != 1 (0x2 != 0x1)FAIL (1 times) After this patch: [ 17.931172] test_bpf: #82 ALU_MOVSX | BPF_B jited:1 125 PASS [ 17.932198] test_bpf: #83 ALU_MOVSX | BPF_H jited:1 124 PASS [ 17.933039] test_bpf: #84 ALU64_MOVSX | BPF_B jited:1 124 PASS [ 17.933918] test_bpf: #85 ALU64_MOVSX | BPF_H jited:1 124 PASS [ 17.934751] test_bpf: #86 ALU64_MOVSX | BPF_W jited:1 122 PASS Signed-off-by: Kuan-Wei Chiu Reviewed-by: Pu Lehui Link: https://lore.kernel.org/bpf/20260714002451.4091139-3-visitorckw@gmail.com Signed-off-by: Kumar Kartikeya Dwivedi Signed-off-by: Sasha Levin --- LLM Generated explanations, may be completely bogus: This is a real RV32 eBPF JIT miscompilation of an existing CPU-v4 instruction, not a new userspace API. On this 7.3-rc4 tree the RV32 JIT and BPF_MOVSX ISA are both present, the patch is small and tested, and it should be included. ## PHASE 1: COMMIT MESSAGE FORENSICS **Step 1.1: PARSE THE SUBJECT LINE** Record: [riscv, bpf] [Add support] [RV32 JIT was compiling BPF_MOVSX as a plain zero-extending MOV; emit slli/srai sign-extend when insn->off is 8/16/32] **Step 1.2: PARSE ALL COMMIT MESSAGE TAGS** Record: - Reviewed-by: Pu Lehui (RISC-V BPF JIT reviewer; also authored RV64 MOVSX in 694896ad3ca79) - Link: https://lore.kernel.org/bpf/20260714002451.4091139-3- visitorckw@gmail.com - Signed-off-by: Kuan-Wei Chiu (author) - Signed-off-by: Kumar Kartikeya Dwivedi (BPF maintainer, applied to bpf-next) - No Fixes:, no Reported-by, no Cc: stable, no syzbot (absence expected) - Ignore pipeline SOBs/Upstream markers: none present on the real commit c6a08afdfe3a8 **Step 1.3: ANALYZE THE COMMIT BODY TEXT** Record: - Bug: RV32 JIT treats BPF_MOVSX as a normal zero-extended move. BPF reuses BPF_MOV with off=8/16/32 for sign-extending moves. - Symptom: test_bpf cases #82–#86 fail with `jited:1 ret 2 != 1` (JIT ran, produced the wrong return). - After: those five tests PASS. - Root cause: `bpf_jit_emit_insn()` did not inspect `insn->off` on ALU/ALU64 MOV|X, so it fell through into `emit_alu_r64`/`emit_alu_r32` BPF_MOV (plain copy). - No version range in the message. ISA support dates to v6.6-era (8100928c88148, 2023). **Step 1.4: DETECT HIDDEN BUG FIXES** Record: Yes. The subject says “Add support”, but the body is explicit miscompilation. Cover letter for the series: the JIT “ignor[es] the instruction offset field and treat[s] them as unsigned or zero- extended.” v1 was titled “Fix support…”. v2 added Fixes: tags; v3 “Remove the Fixes: tag and update title” for bpf-next process, not because it stopped being a bug. Unlike patch 3/3 (atomics), which *does* fall back to the interpreter, MOVSX is a supported opcode that emits the wrong code. ## PHASE 2: DIFF ANALYSIS **Step 2.1: INVENTORY THE CHANGES** Record: - File: `arch/riscv/net/bpf_jit_comp32.c` (+32 / −0) - Function: `bpf_jit_emit_insn()` only - Scope: single-file surgical JIT codegen **Step 2.2: UNDERSTAND THE CODE FLOW CHANGE** Record: - Hunk 1 (`BPF_ALU64 | BPF_MOV | BPF_X`): before, always fell through to `emit_alu_r64()` which copies lo/hi. After, if `off != 0`, sign-extend lo (slli/srai 24 for byte, 16 for half, or copy lo for word) then `srai hi, lo, 31` to fill the upper 32 bits of the RV32 register pair. - Hunk 2 (`BPF_ALU | BPF_MOV | BPF_X`): after the existing `imm == 1` zext special case, if `off != 0` sign-extend lo for off 8 or 16, then `bpf_put_reg32()` (which still zero-extends hi unless `verifier_zext`). - Normal `off == 0` MOV is unchanged (`fallthrough`). **Step 2.3: IDENTIFY THE BUG MECHANISM** Record: [Logic / correctness — JIT miscompilation] - Broken: BPF_MOVSX shares the MOV opcode; offset was ignored, so sign- extend became a full register copy. test_bpf then compares against the sign-extended expected value and fails (`ret 2`). - Fix: emit the same slli/srai pattern other 32-bit JITs use (see arm32 `emit_a32_movsx_r64`). **Step 2.4: ASSESS THE FIX QUALITY** Record: Obviously correct relative to the ISA and to RV64 (`switch (insn->off)` at bpf_jit_comp64.c:1408). Minimal. Regression risk is low: only the previously-wrong `off != 0` path changes. ALU32 does not handle off==32, which matches the ISA (MOVSX32 is 8 or 16 only). ALU64’s `else` treats any other non-zero off as word sign-extend (off==32); the verifier should not emit other values. No API/data-structure change. ## PHASE 3: GIT HISTORY INVESTIGATION **Step 3.1: BLAME THE CHANGED LINES** Record: The MOV|X fallthrough and `emit_alu_r64` BPF_MOV copy were introduced in 5f316b65e99f1 (“riscv, bpf: Add RV32G eBPF JIT”, 2020, v5.6). That was correct until BPF_MOVSX existed. ISA commit 8100928c88148 (“bpf: Support new sign-extension mov insns”, v6.5-rc2-583, in 6.6). RV64 JIT got MOVSX in 694896ad3ca79 (2023). RV32 was left emitting the old MOV path until this commit. **Step 3.2: FOLLOW THE FIXES: TAG** Record: No Fixes: on the landed commit. v2 of the series had Fixes: tags; they were dropped in v3 when the series was retitled for bpf-next. The semantically “buggy” point is 8100928c88148 (MOVSX added, RV32 JIT not updated). That commit is an ancestor of this tree. **Step 3.3: CHECK FILE HISTORY FOR RELATED CHANGES** Record: Same-day series on the same file: - 2e0fa2389c50f — BPF_SDIV/SMOD (patch 1/3) - c6a08afdfe3a8 — this commit (patch 2/3) - a1b37972efc0b — 32-bit atomics (patch 3/3) MOVSX does not use the SDIV `emit_alu_r32()` signature change and does not use the atomic helper. Standalone. **Step 3.4: CHECK THE AUTHOR'S OTHER COMMITS** Record: Kuan-Wei Chiu’s only RV32 JIT work in this tree is this 3-patch series. Reviewer Pu Lehui maintains RISC-V BPF JIT (RV64 MOVSX, later kfunc sign-extend fix f2aaa62159109). Applied by Kartikeya. Strong maintainer path. **Step 3.5: CHECK FOR DEPENDENT/PREREQUISITE COMMITS** Record: Uses `bpf_get_reg64`/`bpf_put_reg64`/`bpf_get_reg32`/`bpf_put_re g32`/`rv_slli`/`rv_srai`/`rv_addi` — all from the original 2020 JIT. No new helpers. Can apply standalone. ## PHASE 4: MAILING LIST AND EXTERNAL RESEARCH **Step 4.1: FIND THE ORIGINAL PATCH DISCUSSION** Record: - b4 dig: https://patch.msgid.link/20260714002451.4091139-3-visitorckw@gmail.com - Series: bpf-next v1→v4, “signed operations and 32-bit atomics” - v1 (2026-04-29): “Fix support for BPF_SDIV and BPF_SMOD” - v2: “Add missing Fixes tags” - v3: “Remove the Fixes: tag and update title” - v4 (applied): this version - No NAKs. Pu Lehui Reviewed-by on this patch; Tested-by on the series (test_bpf failures drop). - No reviewer asked for Cc: stable. **Step 4.2: CHECK WHO REVIEWED THE PATCH** Record: To/Cc included bpf@vger, linux-riscv, ast, daniel, andrii, eddyz87, memxor, palmer, aou, pulehui, yonghong.song (original MOVSX ISA author), alex@ghiti.fr. Appropriate lists. Applied by Kartikeya to bpf- next. **Step 4.3: SEARCH FOR THE BUG REPORT** Record: No external bugzilla/syzbot. Evidence is in-tree `lib/test_bpf.c` ALU_MOVSX tests (from daabb2b098e04, cpuv4 tests). Failure is `jited:1` with wrong R0. **Step 4.4: CHECK FOR RELATED PATCHES AND SERIES** Record: 3/3 series. 1/3 is the same class of bug (SDIV/SMOD as unsigned). 3/3 is a feature (atomics already interpreter-fallback). This patch does not depend on either. **Step 4.5: CHECK STABLE MAILING LIST HISTORY** Record: lore.kernel.org returned 403 to WebFetch. b4 mbox of the matched thread has no stable@ discussion. UNVERIFIED: no independent confirmation from lore.kernel.org/stable/. ## PHASE 5: CODE SEMANTIC ANALYSIS **Step 5.1: KEY FUNCTIONS** Record: `bpf_jit_emit_insn()` (modified). Helpers used, not modified: `bpf_get_reg64`, `bpf_put_reg64`, `bpf_get_reg32`, `bpf_put_reg32`, `emit`. **Step 5.2: TRACE CALLERS** Record: `build_body()` in `arch/riscv/net/bpf_jit_core.c` calls `bpf_jit_emit_insn()` for every instruction when a program is JIT- compiled. That is the eBPF load/attach path (tracing, networking, cgroup, seccomp, etc.), not init-only. **Step 5.3: TRACE CALLEES** Record: Emits RISC-V ALU (slli/srai/addi) and the existing stacked- register get/put. No allocation, no locking. **Step 5.4: FOLLOW THE CALL CHAIN** Record: userspace bpf(2) / `BPF_PROG_LOAD` → verifier (accepts MOVSX since 8100928c88148) → `bpf_int_jit_compile` → `build_body` → `bpf_jit_emit_insn`. RISC-V selects `HAVE_EBPF_JIT if MMU`. JIT is used when enabled; tests ran with `jited:1`. Reachable from program load. Typically CAP_BPF/CAP_SYS_ADMIN; not a syzbot-style unprivileged UAF, but verifier/JIT mismatch is still a sandbox correctness issue. **Step 5.5: SEARCH FOR SIMILAR PATTERNS** Record: RV64 already handled off 8/16/32 (694896ad3ca79). arm32: fc832653fa0db then c6f48506ba30c. LoongArch had a later “Fix sign- extension mov” (772cbe948fb07). Same bug class: MOV|X with nonzero off must sign-extend. ## PHASE 6: CROSS-REFERENCING AGAINST THE LOCAL TREE **Step 6.1: DOES THE BUGGY CODE EXIST IN THIS TREE?** Record: - Local tree: v7.3-rc4-27-gf0100363d8c37, `VERSION=7 PATCHLEVEL=3 SUBLEVEL=0 EXTRAVERSION=-rc4`. - RV32 JIT file exists; MOVSX macros exist in `include/linux/filter.h`; tests exist in `lib/test_bpf.c`. - Commit c6a08afdfe3a8 *is* an ancestor of HEAD (landed in 7.3 via `bpf- next-7.3`, merge 5a8cd539ac19f). Not in v7.2. - Without this change, the 2020 MOV fallthrough is still the codegen for MOVSX. The bug is in this lineage from 6.6 through 7.2. **Step 6.2: CHECK FOR BACKPORT COMPLICATIONS** Record: Clean apply on this tree. Surrounding MOV cases and get/put helpers match the patch. Expected difficulty: clean apply. **Step 6.3: CHECK IF RELATED FIXES ARE ALREADY HERE** Record: This is the RV32 MOVSX fix. No earlier substitute on bpf_jit_comp32.c. RV64 already had support. No competing fix. ## PHASE 7: SUBSYSTEM AND MAINTAINER CONTEXT **Step 7.1: IDENTIFY THE SUBSYSTEM** Record: [arch/riscv BPF JIT] [IMPORTANT for RV32 + BPF users; PERIPHERAL vs core mm/net — 32-bit RISC-V is a real but smaller population] **Step 7.2: ASSESS SUBSYSTEM ACTIVITY** Record: Active enough (atomics, arena, CFI, kfunc sign-extend) but the MOV path itself was untouched since 2020. Long-standing gap, not a brand-new subsystem. ## PHASE 8: IMPACT AND RISK ASSESSMENT **Step 8.1: WHO IS AFFECTED** Record: RV32 kernels with eBPF JIT (HAVE_EBPF_JIT && MMU) running programs that use CPU-v4 sign-extending moves (clang casts to s8/s16/s32). Not universal; not staging. **Step 8.2: TRIGGER CONDITIONS** Record: Loading/attaching a BPF program that contains MOVSX, with JIT on. Common for cpu v4 compiles. Privileged load in default configs. Not a timing race. test_bpf reproduces it every run. **Step 8.3: FAILURE MODE SEVERITY** Record: [Wrong JIT results / verifier-vs-JIT mismatch] [HIGH] - Not an oops/deadlock. - JIT returns different register values than the interpreter and than the verifier’s sign-extended ranges (test: expected 1, got 2). - If the verifier pruned a bounds check on the assumption that MOVSX ran, runtime can see a non-sign-extended value. That is BPF sandbox incorrectness, not a cosmetic test fail. **Step 8.4: RISK-BENEFIT RATIO** Record: Benefit high for RV32+BPF (correct JIT, closes verifier mismatch). Risk very low (32 lines, one switch, existing emit helpers, test_bpf before/after in the message, RISC-V BPF reviewer Tested-by). Ratio favors taking it. ## PHASE 9: FINAL SYNTHESIS **Step 9.1: COMPILE THE EVIDENCE** FOR: - Concrete miscompilation: JIT runs and produces the wrong value (`jited:1 ret 2 != 1`). - BPF_MOVSX has been in the ISA/verifier/interpreter since ~6.6; RV32 JIT never honored `insn->off`. - Interpreter is correct; only the JIT is wrong — classic “supported opcode, wrong codegen.” - 32-line, single-function, no new APIs. - Reviewed and tested by Pu Lehui; applied by BPF maintainer. - Independent of the other two series patches. - Helpers and MOV cases exist in this tree since 5.6. AGAINST: - Subject/process treated it as bpf-next “Add support”; Fixes: tags were deliberately removed in v3. - RV32 is a smaller user base than RV64. - Failure is wrong results, not a panic. - Series patch 3/3 is a genuine feature (do not bundle it). UNRESOLVED: - Could not fetch lore.kernel.org/stable/ (HTTP 403). Thread mbox had no stable discussion. **Step 9.2: STABLE RULES CHECKLIST** 1. Obviously correct and tested? **PASS** — slli/srai matches the ISA; test_bpf #82–#86; reviewer Tested-by. 2. Fixes a real bug that affects users? **PASS** — JIT’d MOVSX is wrong on RV32; userspace can load such programs. 3. Important issue? **PASS** — verifier/JIT mismatch on sign extension is sandbox/correctness, not a style issue. Severity HIGH, not a dead- code WARN. 4. Small and contained? **PASS** — +32 lines, one file, one function. 5. No new features or APIs? **PASS** — does not add a new opcode to BPF; it compiles an opcode the verifier already accepts. (Title is “Add support”; semantically it is fixing ignored `off`.) 6. Can apply to the local tree? **PASS** — file, helpers, and MOV cases are here. **Step 9.3: CHECK FOR EXCEPTION CATEGORIES** Record: Not a device-ID/quirk/DT/build/docs exception. Ordinary correctness fix. **Step 9.4: DECISION** This tree is 7.3-rc4: it has the RV32 JIT and BPF_MOVSX. The bug is “MOV|X ignores off,” which is user-visible wrong BPF execution and a verifier/JIT disagreement. The patch is small, obviously correct, tested, and self-contained. bpf-next dropping Fixes: is process, not a finding that the codegen was fine. It should be backported to this tree. ### What it solves for stable users RV32 eBPF JIT compiled sign-extending moves as ordinary copies. Any JIT’d program using BPF_MOVSX (cpu v4 / compiler casts) gets wrong register values. That breaks test_bpf and can disagree with verifier range tracking. ### Risk vs benefit Benefit: correct JIT and closed verifier mismatch on a real ISA instruction. Risk: very low, localized ALU emit. ### Concerns Do not pull series 3/3 (atomics feature). 1/3 (SDIV/SMOD) is the same miscompilation class but is not required for this patch. No backport rework needed on this tree. Verification: - [Phase 1] Tags: Reviewed-by Pu Lehui, Link lore/bpf, SOB author + Kartikeya; no Fixes/syzbot/Cc:stable - [Phase 1] Body: test_bpf #82–#86 `jited:1 ret 2 != 1` before, PASS after - [Phase 2] Diff: +32 in `bpf_jit_emit_insn()`, two MOV|X cases, slli/srai sign-extend - [Phase 2] Confirmed `emit_alu_r64` BPF_MOV is lo/hi copy; `emit_alu_r32` BPF_MOV is lo copy (pre-fix path) - [Phase 3] blame: MOV fallthrough from 5f316b65e99f1 (v5.6); ISA 8100928c88148 (~6.6); RV64 694896ad3ca79 - [Phase 3] `git merge-base --is-ancestor c6a08afdfe3a8 HEAD` yes; not ancestor of v7.2; is ancestor of v7.3-rc1 - [Phase 3] Series patches 2e0fa2389c50f / c6a08afdfe3a8 / a1b37972efc0b; this one independent - [Phase 4] `b4 dig -c c6a08afdfe3a8`: v4 2/3, msgid 20260714002451.4091139-3 - [Phase 4] `b4 dig -a`: v1–v4; v3 removed Fixes: and retitled - [Phase 4] `b4 dig -m`: 7 messages; Pu Lehui R-b/T-b; no NAK; no stable Cc - [Phase 4] WebFetch lore: 403 — UNVERIFIED via HTTP; thread recovered via b4 mbox - [Phase 5] Caller: `build_body()` → every JIT’d insn; `HAVE_EBPF_JIT if MMU` - [Phase 5] Tests in lib/test_bpf.c ALU_MOVSX / ALU64_MOVSX - [Phase 6] `git describe HEAD` = v7.3-rc4-27-gf0100363d8c37; `make kernelversion` = 7.3.0-rc4 - [Phase 6] bpf_jit_comp32.c and BPF_MOVSX64_REG present; helpers from original JIT - [Phase 8] Failure: wrong JIT output / verifier mismatch, HIGH; not a panic - UNVERIFIED: stable@ mailing list archive (HTTP 403) **YES** arch/riscv/net/bpf_jit_comp32.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/arch/riscv/net/bpf_jit_comp32.c b/arch/riscv/net/bpf_jit_comp32.c index 89153946a4e46..39e2b0b907dc3 100644 --- a/arch/riscv/net/bpf_jit_comp32.c +++ b/arch/riscv/net/bpf_jit_comp32.c @@ -972,6 +972,24 @@ int bpf_jit_emit_insn(const struct bpf_insn *insn, struct rv_jit_context *ctx, switch (code) { case BPF_ALU64 | BPF_MOV | BPF_X: + if (insn->off != 0) { + const s8 *rd = bpf_get_reg64(dst, tmp1, ctx); + const s8 *rs = bpf_get_reg64(src, tmp2, ctx); + + if (insn->off == 8) { + emit(rv_slli(lo(rd), lo(rs), 24), ctx); + emit(rv_srai(lo(rd), lo(rd), 24), ctx); + } else if (insn->off == 16) { + emit(rv_slli(lo(rd), lo(rs), 16), ctx); + emit(rv_srai(lo(rd), lo(rd), 16), ctx); + } else { + emit(rv_addi(lo(rd), lo(rs), 0), ctx); + } + emit(rv_srai(hi(rd), lo(rd), 31), ctx); + bpf_put_reg64(dst, rd, ctx); + break; + } + fallthrough; case BPF_ALU64 | BPF_ADD | BPF_X: case BPF_ALU64 | BPF_ADD | BPF_K: @@ -1022,6 +1040,20 @@ int bpf_jit_emit_insn(const struct bpf_insn *insn, struct rv_jit_context *ctx, emit_zext64(dst, ctx); break; } + if (insn->off != 0) { + const s8 *rd = bpf_get_reg32(dst, tmp1, ctx); + const s8 *rs = bpf_get_reg32(src, tmp2, ctx); + + if (insn->off == 8) { + emit(rv_slli(lo(rd), lo(rs), 24), ctx); + emit(rv_srai(lo(rd), lo(rd), 24), ctx); + } else if (insn->off == 16) { + emit(rv_slli(lo(rd), lo(rs), 16), ctx); + emit(rv_srai(lo(rd), lo(rd), 16), ctx); + } + bpf_put_reg32(dst, rd, ctx); + break; + } fallthrough; case BPF_ALU | BPF_ADD | BPF_X: -- 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 73E92CCF2E3 for ; Mon, 19 Oct 2026 14:06:20 +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=ZPID16XXm8EVwOLZ2P1+Oipxy9ViUxqTqE1RBSEv45A=; b=ZgCwZTzYz4epm+ A2wOVdJ4azXy05dG3ns9T0shAoTEKWH5ULnhvGPF4W2LSRQdkNyaY4BVfSOQdmKKUwOW5v0DoPZIE 34kIHV4Cmh5Xh5CPtEdXwcswrLu5HphviQmUr35RBR3/QLkWFQDU3xtU5dVpOaAshfTKFuyFhoJWF MsDBB9UsFN+h17OUXf9gEmDd6SiSYu/iPeU75p6iXMCVDSK+5CXnQo/KS5NAj3YX6HUUIxecOLuWb 5rBr3kYakYNjf2fLwwMKAegefS8EY4A3EBeqic233m2/Nm/BHhMGIFx+6Yb4FrCIxFQox2Q/F05QR HztexFLaZFdaZy3QUu2g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1xIo07-00000007gfv-00UA; Mon, 19 Oct 2026 14:06:07 +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 1xIo04-00000007gdg-0z5B for linux-riscv@lists.infradead.org; Mon, 19 Oct 2026 14:06:04 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id DFA1043AC7; Mon, 19 Oct 2026 14:06:03 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0DC1A1F000D0; Mon, 19 Oct 2026 14:06:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1792418763; bh=j0uQS4vSaxc/yio3qUhmLXjUkn3ACaDPz7vnrn8DEOk=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=K/xu3MXyRtVWD5MRzDNO3aY83t6umkUoVjiVCO9dqGSd65uWSKG5K0bRZ1QpOpQBX c7fbT1Bb/zE5/cIjzfd+5GD6yyPrjQuiqKz2+zPGyFB7Z3M9bkcWJNg6RTwkbXoNdD I+cUBpVYxT0B37sJiHmQAfnAdBRQ6eD/ycVI9a9k2yG7yOyHHHZ3KWIvl8M6SMXNZ1 gTuBPu8nqY07zEU5Fij8//c5e1TfRbWKz49+YeXTv7Ttvv0Ztkw4YnXlZ6dytTJWp4 pSEsrD4WdkjYTa5kAew1DYaVZde6ez2xOwPhmBZUDtaVQ+OKP4OwOfwCXirNvQXPQ1 brTc0u+xmvNtg== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: Kuan-Wei Chiu , Pu Lehui , Kumar Kartikeya Dwivedi , Sasha Levin , ast@kernel.org, daniel@iogearbox.net, andrii@kernel.org, eddyz87@gmail.com, luke.r.nels@gmail.com, xi.wang@gmail.com, pjw@kernel.org, palmer@dabbelt.com, aou@eecs.berkeley.edu, bpf@vger.kernel.org, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 6.18-5.10] riscv, bpf: Add support for BPF_MOVSX in RV32 JIT Date: Mon, 19 Oct 2026 09:52:49 -0400 Message-ID: <20261019135441.1420968-478-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 RnJvbTogS3Vhbi1XZWkgQ2hpdSA8dmlzaXRvcmNrd0BnbWFpbC5jb20+CgpbIFVwc3RyZWFtIGNv bW1pdCBjNmEwOGFmZGZlM2E4MWIxYTU0ZTkyMTkyMWU5NDgxZGQ2Yzc4ZjhhIF0KClRoZSBjdXJy ZW50IHJ2MzIgYnBmIGppdCBjb21waWxlciBpbmNvcnJlY3RseSB0cmVhdHMgQlBGX01PVlNYIGFz IGEKc3RhbmRhcmQgemVyby1leHRlbmRlZCBtb3ZlIG9wZXJhdGlvbi4gVGhlIGJwZiBpbnN0cnVj dGlvbiBzZXQgYWxsb3dzCnNpZ24tZXh0ZW5zaW9uIG1vdmVzIGJ5IHJldXNpbmcgdGhlIEJQRl9N T1Ygb3Bjb2RlIHdpdGggdGhlIGluc3RydWN0aW9uCm9mZnNldCBzZXQgdG8gOCwgMTYsIG9yIDMy LgoKVXBkYXRlIHRoZSBicGZfaml0X2VtaXRfaW5zbigpIGZ1bmN0aW9uIHRvIGNoZWNrIHRoZSBv ZmZzZXQgZmllbGQgZm9yCmJvdGggQUxVIGFuZCBBTFU2NCBNT1Ygb3BlcmF0aW9ucy4gSWYgdGhl IG9mZnNldCBpcyBub24temVybywgZW1pdCB0aGUKY29ycmVjdCBzbGxpIGFuZCBzcmFpIGluc3Ry dWN0aW9ucyB0byBwZXJmb3JtIHRoZSBzaWduIGV4dGVuc2lvbi4KCkJlZm9yZSB0aGlzIHBhdGNo OgpbICAgMTkuNTQ5NzA1XSB0ZXN0X2JwZjogIzgyIEFMVV9NT1ZTWCB8IEJQRl9CIGppdGVkOjEg cmV0IDIgIT0gMSAoMHgyICE9IDB4MSlGQUlMICgxIHRpbWVzKQpbICAgMTkuNTUxMzU0XSB0ZXN0 X2JwZjogIzgzIEFMVV9NT1ZTWCB8IEJQRl9IIGppdGVkOjEgcmV0IDIgIT0gMSAoMHgyICE9IDB4 MSlGQUlMICgxIHRpbWVzKQpbICAgMTkuNTUyNTc2XSB0ZXN0X2JwZjogIzg0IEFMVTY0X01PVlNY IHwgQlBGX0Igaml0ZWQ6MSByZXQgMiAhPSAxICgweDIgIT0gMHgxKUZBSUwgKDEgdGltZXMpClsg ICAxOS41NTM1NDJdIHRlc3RfYnBmOiAjODUgQUxVNjRfTU9WU1ggfCBCUEZfSCBqaXRlZDoxIHJl dCAyICE9IDEgKDB4MiAhPSAweDEpRkFJTCAoMSB0aW1lcykKWyAgIDE5LjU1NDgwN10gdGVzdF9i cGY6ICM4NiBBTFU2NF9NT1ZTWCB8IEJQRl9XIGppdGVkOjEgcmV0IDIgIT0gMSAoMHgyICE9IDB4 MSlGQUlMICgxIHRpbWVzKQoKQWZ0ZXIgdGhpcyBwYXRjaDoKWyAgIDE3LjkzMTE3Ml0gdGVzdF9i cGY6ICM4MiBBTFVfTU9WU1ggfCBCUEZfQiBqaXRlZDoxIDEyNSBQQVNTClsgICAxNy45MzIxOThd IHRlc3RfYnBmOiAjODMgQUxVX01PVlNYIHwgQlBGX0ggaml0ZWQ6MSAxMjQgUEFTUwpbICAgMTcu OTMzMDM5XSB0ZXN0X2JwZjogIzg0IEFMVTY0X01PVlNYIHwgQlBGX0Igaml0ZWQ6MSAxMjQgUEFT UwpbICAgMTcuOTMzOTE4XSB0ZXN0X2JwZjogIzg1IEFMVTY0X01PVlNYIHwgQlBGX0ggaml0ZWQ6 MSAxMjQgUEFTUwpbICAgMTcuOTM0NzUxXSB0ZXN0X2JwZjogIzg2IEFMVTY0X01PVlNYIHwgQlBG X1cgaml0ZWQ6MSAxMjIgUEFTUwoKU2lnbmVkLW9mZi1ieTogS3Vhbi1XZWkgQ2hpdSA8dmlzaXRv cmNrd0BnbWFpbC5jb20+ClJldmlld2VkLWJ5OiBQdSBMZWh1aSA8cHVsZWh1aUBodWF3ZWkuY29t PgpMaW5rOiBodHRwczovL2xvcmUua2VybmVsLm9yZy9icGYvMjAyNjA3MTQwMDI0NTEuNDA5MTEz OS0zLXZpc2l0b3Jja3dAZ21haWwuY29tClNpZ25lZC1vZmYtYnk6IEt1bWFyIEthcnRpa2V5YSBE d2l2ZWRpIDxtZW14b3JAZ21haWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBTYXNoYSBMZXZpbiA8c2Fz aGFsQGtlcm5lbC5vcmc+Ci0tLQoKTExNIEdlbmVyYXRlZCBleHBsYW5hdGlvbnMsIG1heSBiZSBj b21wbGV0ZWx5IGJvZ3VzOgoKVGhpcyBpcyBhIHJlYWwgUlYzMiBlQlBGIEpJVCBtaXNjb21waWxh dGlvbiBvZiBhbiBleGlzdGluZyBDUFUtdjQKaW5zdHJ1Y3Rpb24sIG5vdCBhIG5ldyB1c2Vyc3Bh Y2UgQVBJLiBPbiB0aGlzIDcuMy1yYzQgdHJlZSB0aGUgUlYzMiBKSVQKYW5kIEJQRl9NT1ZTWCBJ U0EgYXJlIGJvdGggcHJlc2VudCwgdGhlIHBhdGNoIGlzIHNtYWxsIGFuZCB0ZXN0ZWQsIGFuZApp dCBzaG91bGQgYmUgaW5jbHVkZWQuCgojIyBQSEFTRSAxOiBDT01NSVQgTUVTU0FHRSBGT1JFTlNJ Q1MKCioqU3RlcCAxLjE6IFBBUlNFIFRIRSBTVUJKRUNUIExJTkUqKgpSZWNvcmQ6IFtyaXNjdiwg YnBmXSBbQWRkIHN1cHBvcnRdIFtSVjMyIEpJVCB3YXMgY29tcGlsaW5nIEJQRl9NT1ZTWCBhcwph IHBsYWluIHplcm8tZXh0ZW5kaW5nIE1PVjsgZW1pdCBzbGxpL3NyYWkgc2lnbi1leHRlbmQgd2hl biBpbnNuLT5vZmYgaXMKOC8xNi8zMl0KCioqU3RlcCAxLjI6IFBBUlNFIEFMTCBDT01NSVQgTUVT U0FHRSBUQUdTKioKUmVjb3JkOgotIFJldmlld2VkLWJ5OiBQdSBMZWh1aSA8cHVsZWh1aUBodWF3 ZWkuY29tPiAoUklTQy1WIEJQRiBKSVQgcmV2aWV3ZXI7CiAgYWxzbyBhdXRob3JlZCBSVjY0IE1P VlNYIGluIDY5NDg5NmFkM2NhNzkpCi0gTGluazogaHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvYnBm LzIwMjYwNzE0MDAyNDUxLjQwOTExMzktMy0KICB2aXNpdG9yY2t3QGdtYWlsLmNvbQotIFNpZ25l ZC1vZmYtYnk6IEt1YW4tV2VpIENoaXUgPHZpc2l0b3Jja3dAZ21haWwuY29tPiAoYXV0aG9yKQot IFNpZ25lZC1vZmYtYnk6IEt1bWFyIEthcnRpa2V5YSBEd2l2ZWRpIDxtZW14b3JAZ21haWwuY29t PiAoQlBGCiAgbWFpbnRhaW5lciwgYXBwbGllZCB0byBicGYtbmV4dCkKLSBObyBGaXhlczosIG5v IFJlcG9ydGVkLWJ5LCBubyBDYzogc3RhYmxlLCBubyBzeXpib3QgKGFic2VuY2UgZXhwZWN0ZWQp Ci0gSWdub3JlIHBpcGVsaW5lIFNPQnMvVXBzdHJlYW0gbWFya2Vyczogbm9uZSBwcmVzZW50IG9u IHRoZSByZWFsIGNvbW1pdAogIGM2YTA4YWZkZmUzYTgKCioqU3RlcCAxLjM6IEFOQUxZWkUgVEhF IENPTU1JVCBCT0RZIFRFWFQqKgpSZWNvcmQ6Ci0gQnVnOiBSVjMyIEpJVCB0cmVhdHMgQlBGX01P VlNYIGFzIGEgbm9ybWFsIHplcm8tZXh0ZW5kZWQgbW92ZS4gQlBGCiAgcmV1c2VzIEJQRl9NT1Yg d2l0aCBvZmY9OC8xNi8zMiBmb3Igc2lnbi1leHRlbmRpbmcgbW92ZXMuCi0gU3ltcHRvbTogdGVz dF9icGYgY2FzZXMgIzgy4oCTIzg2IGZhaWwgd2l0aCBgaml0ZWQ6MSByZXQgMiAhPSAxYCAoSklU CiAgcmFuLCBwcm9kdWNlZCB0aGUgd3JvbmcgcmV0dXJuKS4KLSBBZnRlcjogdGhvc2UgZml2ZSB0 ZXN0cyBQQVNTLgotIFJvb3QgY2F1c2U6IGBicGZfaml0X2VtaXRfaW5zbigpYCBkaWQgbm90IGlu c3BlY3QgYGluc24tPm9mZmAgb24KICBBTFUvQUxVNjQgTU9WfFgsIHNvIGl0IGZlbGwgdGhyb3Vn aCBpbnRvIGBlbWl0X2FsdV9yNjRgL2BlbWl0X2FsdV9yMzJgCiAgQlBGX01PViAocGxhaW4gY29w eSkuCi0gTm8gdmVyc2lvbiByYW5nZSBpbiB0aGUgbWVzc2FnZS4gSVNBIHN1cHBvcnQgZGF0ZXMg dG8gdjYuNi1lcmEKICAoODEwMDkyOGM4ODE0OCwgMjAyMykuCgoqKlN0ZXAgMS40OiBERVRFQ1Qg SElEREVOIEJVRyBGSVhFUyoqClJlY29yZDogWWVzLiBUaGUgc3ViamVjdCBzYXlzIOKAnEFkZCBz dXBwb3J04oCdLCBidXQgdGhlIGJvZHkgaXMgZXhwbGljaXQKbWlzY29tcGlsYXRpb24uIENvdmVy IGxldHRlciBmb3IgdGhlIHNlcmllczogdGhlIEpJVCDigJxpZ25vcltlc10gdGhlCmluc3RydWN0 aW9uIG9mZnNldCBmaWVsZCBhbmQgdHJlYXRbc10gdGhlbSBhcyB1bnNpZ25lZCBvciB6ZXJvLQpl eHRlbmRlZC7igJ0gdjEgd2FzIHRpdGxlZCDigJxGaXggc3VwcG9ydOKApuKAnS4gdjIgYWRkZWQg Rml4ZXM6IHRhZ3M7IHYzCuKAnFJlbW92ZSB0aGUgRml4ZXM6IHRhZyBhbmQgdXBkYXRlIHRpdGxl 4oCdIGZvciBicGYtbmV4dCBwcm9jZXNzLCBub3QKYmVjYXVzZSBpdCBzdG9wcGVkIGJlaW5nIGEg YnVnLiBVbmxpa2UgcGF0Y2ggMy8zIChhdG9taWNzKSwgd2hpY2ggKmRvZXMqCmZhbGwgYmFjayB0 byB0aGUgaW50ZXJwcmV0ZXIsIE1PVlNYIGlzIGEgc3VwcG9ydGVkIG9wY29kZSB0aGF0IGVtaXRz IHRoZQp3cm9uZyBjb2RlLgoKIyMgUEhBU0UgMjogRElGRiBBTkFMWVNJUwoKKipTdGVwIDIuMTog SU5WRU5UT1JZIFRIRSBDSEFOR0VTKioKUmVjb3JkOgotIEZpbGU6IGBhcmNoL3Jpc2N2L25ldC9i cGZfaml0X2NvbXAzMi5jYCAoKzMyIC8g4oiSMCkKLSBGdW5jdGlvbjogYGJwZl9qaXRfZW1pdF9p bnNuKClgIG9ubHkKLSBTY29wZTogc2luZ2xlLWZpbGUgc3VyZ2ljYWwgSklUIGNvZGVnZW4KCioq U3RlcCAyLjI6IFVOREVSU1RBTkQgVEhFIENPREUgRkxPVyBDSEFOR0UqKgpSZWNvcmQ6Ci0gSHVu ayAxIChgQlBGX0FMVTY0IHwgQlBGX01PViB8IEJQRl9YYCk6IGJlZm9yZSwgYWx3YXlzIGZlbGwg dGhyb3VnaCB0bwogIGBlbWl0X2FsdV9yNjQoKWAgd2hpY2ggY29waWVzIGxvL2hpLiBBZnRlciwg aWYgYG9mZiAhPSAwYCwgc2lnbi1leHRlbmQKICBsbyAoc2xsaS9zcmFpIDI0IGZvciBieXRlLCAx NiBmb3IgaGFsZiwgb3IgY29weSBsbyBmb3Igd29yZCkgdGhlbgogIGBzcmFpIGhpLCBsbywgMzFg IHRvIGZpbGwgdGhlIHVwcGVyIDMyIGJpdHMgb2YgdGhlIFJWMzIgcmVnaXN0ZXIgcGFpci4KLSBI dW5rIDIgKGBCUEZfQUxVIHwgQlBGX01PViB8IEJQRl9YYCk6IGFmdGVyIHRoZSBleGlzdGluZyBg aW1tID09IDFgCiAgemV4dCBzcGVjaWFsIGNhc2UsIGlmIGBvZmYgIT0gMGAgc2lnbi1leHRlbmQg bG8gZm9yIG9mZiA4IG9yIDE2LCB0aGVuCiAgYGJwZl9wdXRfcmVnMzIoKWAgKHdoaWNoIHN0aWxs IHplcm8tZXh0ZW5kcyBoaSB1bmxlc3MKICBgdmVyaWZpZXJfemV4dGApLgotIE5vcm1hbCBgb2Zm ID09IDBgIE1PViBpcyB1bmNoYW5nZWQgKGBmYWxsdGhyb3VnaGApLgoKKipTdGVwIDIuMzogSURF TlRJRlkgVEhFIEJVRyBNRUNIQU5JU00qKgpSZWNvcmQ6IFtMb2dpYyAvIGNvcnJlY3RuZXNzIOKA lCBKSVQgbWlzY29tcGlsYXRpb25dCi0gQnJva2VuOiBCUEZfTU9WU1ggc2hhcmVzIHRoZSBNT1Yg b3Bjb2RlOyBvZmZzZXQgd2FzIGlnbm9yZWQsIHNvIHNpZ24tCiAgZXh0ZW5kIGJlY2FtZSBhIGZ1 bGwgcmVnaXN0ZXIgY29weS4gdGVzdF9icGYgdGhlbiBjb21wYXJlcyBhZ2FpbnN0IHRoZQogIHNp Z24tZXh0ZW5kZWQgZXhwZWN0ZWQgdmFsdWUgYW5kIGZhaWxzIChgcmV0IDJgKS4KLSBGaXg6IGVt aXQgdGhlIHNhbWUgc2xsaS9zcmFpIHBhdHRlcm4gb3RoZXIgMzItYml0IEpJVHMgdXNlIChzZWUg YXJtMzIKICBgZW1pdF9hMzJfbW92c3hfcjY0YCkuCgoqKlN0ZXAgMi40OiBBU1NFU1MgVEhFIEZJ WCBRVUFMSVRZKioKUmVjb3JkOiBPYnZpb3VzbHkgY29ycmVjdCByZWxhdGl2ZSB0byB0aGUgSVNB IGFuZCB0byBSVjY0IChgc3dpdGNoCihpbnNuLT5vZmYpYCBhdCBicGZfaml0X2NvbXA2NC5jOjE0 MDgpLiBNaW5pbWFsLiBSZWdyZXNzaW9uIHJpc2sgaXMgbG93Ogpvbmx5IHRoZSBwcmV2aW91c2x5 LXdyb25nIGBvZmYgIT0gMGAgcGF0aCBjaGFuZ2VzLiBBTFUzMiBkb2VzIG5vdCBoYW5kbGUKb2Zm PT0zMiwgd2hpY2ggbWF0Y2hlcyB0aGUgSVNBIChNT1ZTWDMyIGlzIDggb3IgMTYgb25seSkuIEFM VTY04oCZcyBgZWxzZWAKdHJlYXRzIGFueSBvdGhlciBub24temVybyBvZmYgYXMgd29yZCBzaWdu LWV4dGVuZCAob2ZmPT0zMik7IHRoZQp2ZXJpZmllciBzaG91bGQgbm90IGVtaXQgb3RoZXIgdmFs dWVzLiBObyBBUEkvZGF0YS1zdHJ1Y3R1cmUgY2hhbmdlLgoKIyMgUEhBU0UgMzogR0lUIEhJU1RP UlkgSU5WRVNUSUdBVElPTgoKKipTdGVwIDMuMTogQkxBTUUgVEhFIENIQU5HRUQgTElORVMqKgpS ZWNvcmQ6IFRoZSBNT1Z8WCBmYWxsdGhyb3VnaCBhbmQgYGVtaXRfYWx1X3I2NGAgQlBGX01PViBj b3B5IHdlcmUKaW50cm9kdWNlZCBpbiA1ZjMxNmI2NWU5OWYxICjigJxyaXNjdiwgYnBmOiBBZGQg UlYzMkcgZUJQRiBKSVTigJ0sIDIwMjAsCnY1LjYpLiBUaGF0IHdhcyBjb3JyZWN0IHVudGlsIEJQ Rl9NT1ZTWCBleGlzdGVkLiBJU0EgY29tbWl0CjgxMDA5MjhjODgxNDggKOKAnGJwZjogU3VwcG9y dCBuZXcgc2lnbi1leHRlbnNpb24gbW92IGluc25z4oCdLAp2Ni41LXJjMi01ODMsIGluIDYuNiku IFJWNjQgSklUIGdvdCBNT1ZTWCBpbiA2OTQ4OTZhZDNjYTc5ICgyMDIzKS4gUlYzMgp3YXMgbGVm dCBlbWl0dGluZyB0aGUgb2xkIE1PViBwYXRoIHVudGlsIHRoaXMgY29tbWl0LgoKKipTdGVwIDMu MjogRk9MTE9XIFRIRSBGSVhFUzogVEFHKioKUmVjb3JkOiBObyBGaXhlczogb24gdGhlIGxhbmRl ZCBjb21taXQuIHYyIG9mIHRoZSBzZXJpZXMgaGFkIEZpeGVzOgp0YWdzOyB0aGV5IHdlcmUgZHJv cHBlZCBpbiB2MyB3aGVuIHRoZSBzZXJpZXMgd2FzIHJldGl0bGVkIGZvciBicGYtbmV4dC4KVGhl IHNlbWFudGljYWxseSDigJxidWdneeKAnSBwb2ludCBpcyA4MTAwOTI4Yzg4MTQ4IChNT1ZTWCBh ZGRlZCwgUlYzMiBKSVQKbm90IHVwZGF0ZWQpLiBUaGF0IGNvbW1pdCBpcyBhbiBhbmNlc3RvciBv ZiB0aGlzIHRyZWUuCgoqKlN0ZXAgMy4zOiBDSEVDSyBGSUxFIEhJU1RPUlkgRk9SIFJFTEFURUQg Q0hBTkdFUyoqClJlY29yZDogU2FtZS1kYXkgc2VyaWVzIG9uIHRoZSBzYW1lIGZpbGU6Ci0gMmUw ZmEyMzg5YzUwZiDigJQgQlBGX1NESVYvU01PRCAocGF0Y2ggMS8zKQotIGM2YTA4YWZkZmUzYTgg 4oCUIHRoaXMgY29tbWl0IChwYXRjaCAyLzMpCi0gYTFiMzc5NzJlZmMwYiDigJQgMzItYml0IGF0 b21pY3MgKHBhdGNoIDMvMykKTU9WU1ggZG9lcyBub3QgdXNlIHRoZSBTRElWIGBlbWl0X2FsdV9y MzIoKWAgc2lnbmF0dXJlIGNoYW5nZSBhbmQgZG9lcwpub3QgdXNlIHRoZSBhdG9taWMgaGVscGVy LiBTdGFuZGFsb25lLgoKKipTdGVwIDMuNDogQ0hFQ0sgVEhFIEFVVEhPUidTIE9USEVSIENPTU1J VFMqKgpSZWNvcmQ6IEt1YW4tV2VpIENoaXXigJlzIG9ubHkgUlYzMiBKSVQgd29yayBpbiB0aGlz IHRyZWUgaXMgdGhpcyAzLXBhdGNoCnNlcmllcy4gUmV2aWV3ZXIgUHUgTGVodWkgbWFpbnRhaW5z IFJJU0MtViBCUEYgSklUIChSVjY0IE1PVlNYLCBsYXRlcgprZnVuYyBzaWduLWV4dGVuZCBmaXgg ZjJhYWE2MjE1OTEwOSkuIEFwcGxpZWQgYnkgS2FydGlrZXlhLiBTdHJvbmcKbWFpbnRhaW5lciBw YXRoLgoKKipTdGVwIDMuNTogQ0hFQ0sgRk9SIERFUEVOREVOVC9QUkVSRVFVSVNJVEUgQ09NTUlU UyoqClJlY29yZDogVXNlcyBgYnBmX2dldF9yZWc2NGAvYGJwZl9wdXRfcmVnNjRgL2BicGZfZ2V0 X3JlZzMyYC9gYnBmX3B1dF9yZQpnMzJgL2Bydl9zbGxpYC9gcnZfc3JhaWAvYHJ2X2FkZGlgIOKA lCBhbGwgZnJvbSB0aGUgb3JpZ2luYWwgMjAyMCBKSVQuIE5vCm5ldyBoZWxwZXJzLiBDYW4gYXBw bHkgc3RhbmRhbG9uZS4KCiMjIFBIQVNFIDQ6IE1BSUxJTkcgTElTVCBBTkQgRVhURVJOQUwgUkVT RUFSQ0gKCioqU3RlcCA0LjE6IEZJTkQgVEhFIE9SSUdJTkFMIFBBVENIIERJU0NVU1NJT04qKgpS ZWNvcmQ6Ci0gYjQgZGlnOgogIGh0dHBzOi8vcGF0Y2gubXNnaWQubGluay8yMDI2MDcxNDAwMjQ1 MS40MDkxMTM5LTMtdmlzaXRvcmNrd0BnbWFpbC5jb20KLSBTZXJpZXM6IGJwZi1uZXh0IHYx4oaS djQsIOKAnHNpZ25lZCBvcGVyYXRpb25zIGFuZCAzMi1iaXQgYXRvbWljc+KAnQotIHYxICgyMDI2 LTA0LTI5KTog4oCcRml4IHN1cHBvcnQgZm9yIEJQRl9TRElWIGFuZCBCUEZfU01PROKAnQotIHYy OiDigJxBZGQgbWlzc2luZyBGaXhlcyB0YWdz4oCdCi0gdjM6IOKAnFJlbW92ZSB0aGUgRml4ZXM6 IHRhZyBhbmQgdXBkYXRlIHRpdGxl4oCdCi0gdjQgKGFwcGxpZWQpOiB0aGlzIHZlcnNpb24KLSBO byBOQUtzLiBQdSBMZWh1aSBSZXZpZXdlZC1ieSBvbiB0aGlzIHBhdGNoOyBUZXN0ZWQtYnkgb24g dGhlIHNlcmllcwogICh0ZXN0X2JwZiBmYWlsdXJlcyBkcm9wKS4KLSBObyByZXZpZXdlciBhc2tl ZCBmb3IgQ2M6IHN0YWJsZS4KCioqU3RlcCA0LjI6IENIRUNLIFdITyBSRVZJRVdFRCBUSEUgUEFU Q0gqKgpSZWNvcmQ6IFRvL0NjIGluY2x1ZGVkIGJwZkB2Z2VyLCBsaW51eC1yaXNjdiwgYXN0LCBk YW5pZWwsIGFuZHJpaSwKZWRkeXo4NywgbWVteG9yLCBwYWxtZXIsIGFvdSwgcHVsZWh1aSwgeW9u Z2hvbmcuc29uZyAob3JpZ2luYWwgTU9WU1ggSVNBCmF1dGhvciksIGFsZXhAZ2hpdGkuZnIuIEFw cHJvcHJpYXRlIGxpc3RzLiBBcHBsaWVkIGJ5IEthcnRpa2V5YSB0byBicGYtCm5leHQuCgoqKlN0 ZXAgNC4zOiBTRUFSQ0ggRk9SIFRIRSBCVUcgUkVQT1JUKioKUmVjb3JkOiBObyBleHRlcm5hbCBi dWd6aWxsYS9zeXpib3QuIEV2aWRlbmNlIGlzIGluLXRyZWUKYGxpYi90ZXN0X2JwZi5jYCBBTFVf TU9WU1ggdGVzdHMgKGZyb20gZGFhYmIyYjA5OGUwNCwgY3B1djQgdGVzdHMpLgpGYWlsdXJlIGlz IGBqaXRlZDoxYCB3aXRoIHdyb25nIFIwLgoKKipTdGVwIDQuNDogQ0hFQ0sgRk9SIFJFTEFURUQg UEFUQ0hFUyBBTkQgU0VSSUVTKioKUmVjb3JkOiAzLzMgc2VyaWVzLiAxLzMgaXMgdGhlIHNhbWUg Y2xhc3Mgb2YgYnVnIChTRElWL1NNT0QgYXMKdW5zaWduZWQpLiAzLzMgaXMgYSBmZWF0dXJlIChh dG9taWNzIGFscmVhZHkgaW50ZXJwcmV0ZXItZmFsbGJhY2spLiBUaGlzCnBhdGNoIGRvZXMgbm90 IGRlcGVuZCBvbiBlaXRoZXIuCgoqKlN0ZXAgNC41OiBDSEVDSyBTVEFCTEUgTUFJTElORyBMSVNU IEhJU1RPUlkqKgpSZWNvcmQ6IGxvcmUua2VybmVsLm9yZyByZXR1cm5lZCA0MDMgdG8gV2ViRmV0 Y2guIGI0IG1ib3ggb2YgdGhlIG1hdGNoZWQKdGhyZWFkIGhhcyBubyBzdGFibGVAIGRpc2N1c3Np b24uIFVOVkVSSUZJRUQ6IG5vIGluZGVwZW5kZW50CmNvbmZpcm1hdGlvbiBmcm9tIGxvcmUua2Vy bmVsLm9yZy9zdGFibGUvLgoKIyMgUEhBU0UgNTogQ09ERSBTRU1BTlRJQyBBTkFMWVNJUwoKKipT dGVwIDUuMTogS0VZIEZVTkNUSU9OUyoqClJlY29yZDogYGJwZl9qaXRfZW1pdF9pbnNuKClgICht b2RpZmllZCkuIEhlbHBlcnMgdXNlZCwgbm90IG1vZGlmaWVkOgpgYnBmX2dldF9yZWc2NGAsIGBi cGZfcHV0X3JlZzY0YCwgYGJwZl9nZXRfcmVnMzJgLCBgYnBmX3B1dF9yZWczMmAsCmBlbWl0YC4K CioqU3RlcCA1LjI6IFRSQUNFIENBTExFUlMqKgpSZWNvcmQ6IGBidWlsZF9ib2R5KClgIGluIGBh cmNoL3Jpc2N2L25ldC9icGZfaml0X2NvcmUuY2AgY2FsbHMKYGJwZl9qaXRfZW1pdF9pbnNuKClg IGZvciBldmVyeSBpbnN0cnVjdGlvbiB3aGVuIGEgcHJvZ3JhbSBpcyBKSVQtCmNvbXBpbGVkLiBU aGF0IGlzIHRoZSBlQlBGIGxvYWQvYXR0YWNoIHBhdGggKHRyYWNpbmcsIG5ldHdvcmtpbmcsCmNn cm91cCwgc2VjY29tcCwgZXRjLiksIG5vdCBpbml0LW9ubHkuCgoqKlN0ZXAgNS4zOiBUUkFDRSBD QUxMRUVTKioKUmVjb3JkOiBFbWl0cyBSSVNDLVYgQUxVIChzbGxpL3NyYWkvYWRkaSkgYW5kIHRo ZSBleGlzdGluZyBzdGFja2VkLQpyZWdpc3RlciBnZXQvcHV0LiBObyBhbGxvY2F0aW9uLCBubyBs b2NraW5nLgoKKipTdGVwIDUuNDogRk9MTE9XIFRIRSBDQUxMIENIQUlOKioKUmVjb3JkOiB1c2Vy c3BhY2UgYnBmKDIpIC8gYEJQRl9QUk9HX0xPQURgIOKGkiB2ZXJpZmllciAoYWNjZXB0cyBNT1ZT WApzaW5jZSA4MTAwOTI4Yzg4MTQ4KSDihpIgYGJwZl9pbnRfaml0X2NvbXBpbGVgIOKGkiBgYnVp bGRfYm9keWAg4oaSCmBicGZfaml0X2VtaXRfaW5zbmAuIFJJU0MtViBzZWxlY3RzIGBIQVZFX0VC UEZfSklUIGlmIE1NVWAuIEpJVCBpcyB1c2VkCndoZW4gZW5hYmxlZDsgdGVzdHMgcmFuIHdpdGgg YGppdGVkOjFgLiBSZWFjaGFibGUgZnJvbSBwcm9ncmFtIGxvYWQuClR5cGljYWxseSBDQVBfQlBG L0NBUF9TWVNfQURNSU47IG5vdCBhIHN5emJvdC1zdHlsZSB1bnByaXZpbGVnZWQgVUFGLApidXQg dmVyaWZpZXIvSklUIG1pc21hdGNoIGlzIHN0aWxsIGEgc2FuZGJveCBjb3JyZWN0bmVzcyBpc3N1 ZS4KCioqU3RlcCA1LjU6IFNFQVJDSCBGT1IgU0lNSUxBUiBQQVRURVJOUyoqClJlY29yZDogUlY2 NCBhbHJlYWR5IGhhbmRsZWQgb2ZmIDgvMTYvMzIgKDY5NDg5NmFkM2NhNzkpLiBhcm0zMjoKZmM4 MzI2NTNmYTBkYiB0aGVuIGM2ZjQ4NTA2YmEzMGMuIExvb25nQXJjaCBoYWQgYSBsYXRlciDigJxG aXggc2lnbi0KZXh0ZW5zaW9uIG1vduKAnSAoNzcyY2JlOTQ4ZmIwNykuIFNhbWUgYnVnIGNsYXNz OiBNT1Z8WCB3aXRoIG5vbnplcm8gb2ZmCm11c3Qgc2lnbi1leHRlbmQuCgojIyBQSEFTRSA2OiBD Uk9TUy1SRUZFUkVOQ0lORyBBR0FJTlNUIFRIRSBMT0NBTCBUUkVFCgoqKlN0ZXAgNi4xOiBET0VT IFRIRSBCVUdHWSBDT0RFIEVYSVNUIElOIFRISVMgVFJFRT8qKgpSZWNvcmQ6Ci0gTG9jYWwgdHJl ZTogdjcuMy1yYzQtMjctZ2YwMTAwMzYzZDhjMzcsIGBWRVJTSU9OPTcgUEFUQ0hMRVZFTD0zCiAg U1VCTEVWRUw9MCBFWFRSQVZFUlNJT049LXJjNGAuCi0gUlYzMiBKSVQgZmlsZSBleGlzdHM7IE1P VlNYIG1hY3JvcyBleGlzdCBpbiBgaW5jbHVkZS9saW51eC9maWx0ZXIuaGA7CiAgdGVzdHMgZXhp c3QgaW4gYGxpYi90ZXN0X2JwZi5jYC4KLSBDb21taXQgYzZhMDhhZmRmZTNhOCAqaXMqIGFuIGFu Y2VzdG9yIG9mIEhFQUQgKGxhbmRlZCBpbiA3LjMgdmlhIGBicGYtCiAgbmV4dC03LjNgLCBtZXJn ZSA1YThjZDUzOWFjMTlmKS4gTm90IGluIHY3LjIuCi0gV2l0aG91dCB0aGlzIGNoYW5nZSwgdGhl IDIwMjAgTU9WIGZhbGx0aHJvdWdoIGlzIHN0aWxsIHRoZSBjb2RlZ2VuIGZvcgogIE1PVlNYLiBU aGUgYnVnIGlzIGluIHRoaXMgbGluZWFnZSBmcm9tIDYuNiB0aHJvdWdoIDcuMi4KCioqU3RlcCA2 LjI6IENIRUNLIEZPUiBCQUNLUE9SVCBDT01QTElDQVRJT05TKioKUmVjb3JkOiBDbGVhbiBhcHBs eSBvbiB0aGlzIHRyZWUuIFN1cnJvdW5kaW5nIE1PViBjYXNlcyBhbmQgZ2V0L3B1dApoZWxwZXJz IG1hdGNoIHRoZSBwYXRjaC4gRXhwZWN0ZWQgZGlmZmljdWx0eTogY2xlYW4gYXBwbHkuCgoqKlN0 ZXAgNi4zOiBDSEVDSyBJRiBSRUxBVEVEIEZJWEVTIEFSRSBBTFJFQURZIEhFUkUqKgpSZWNvcmQ6 IFRoaXMgaXMgdGhlIFJWMzIgTU9WU1ggZml4LiBObyBlYXJsaWVyIHN1YnN0aXR1dGUgb24KYnBm X2ppdF9jb21wMzIuYy4gUlY2NCBhbHJlYWR5IGhhZCBzdXBwb3J0LiBObyBjb21wZXRpbmcgZml4 LgoKIyMgUEhBU0UgNzogU1VCU1lTVEVNIEFORCBNQUlOVEFJTkVSIENPTlRFWFQKCioqU3RlcCA3 LjE6IElERU5USUZZIFRIRSBTVUJTWVNURU0qKgpSZWNvcmQ6IFthcmNoL3Jpc2N2IEJQRiBKSVRd IFtJTVBPUlRBTlQgZm9yIFJWMzIgKyBCUEYgdXNlcnM7IFBFUklQSEVSQUwKdnMgY29yZSBtbS9u ZXQg4oCUIDMyLWJpdCBSSVNDLVYgaXMgYSByZWFsIGJ1dCBzbWFsbGVyIHBvcHVsYXRpb25dCgoq KlN0ZXAgNy4yOiBBU1NFU1MgU1VCU1lTVEVNIEFDVElWSVRZKioKUmVjb3JkOiBBY3RpdmUgZW5v dWdoIChhdG9taWNzLCBhcmVuYSwgQ0ZJLCBrZnVuYyBzaWduLWV4dGVuZCkgYnV0IHRoZQpNT1Yg cGF0aCBpdHNlbGYgd2FzIHVudG91Y2hlZCBzaW5jZSAyMDIwLiBMb25nLXN0YW5kaW5nIGdhcCwg bm90IGEKYnJhbmQtbmV3IHN1YnN5c3RlbS4KCiMjIFBIQVNFIDg6IElNUEFDVCBBTkQgUklTSyBB U1NFU1NNRU5UCgoqKlN0ZXAgOC4xOiBXSE8gSVMgQUZGRUNURUQqKgpSZWNvcmQ6IFJWMzIga2Vy bmVscyB3aXRoIGVCUEYgSklUIChIQVZFX0VCUEZfSklUICYmIE1NVSkgcnVubmluZwpwcm9ncmFt cyB0aGF0IHVzZSBDUFUtdjQgc2lnbi1leHRlbmRpbmcgbW92ZXMgKGNsYW5nIGNhc3RzIHRvCnM4 L3MxNi9zMzIpLiBOb3QgdW5pdmVyc2FsOyBub3Qgc3RhZ2luZy4KCioqU3RlcCA4LjI6IFRSSUdH RVIgQ09ORElUSU9OUyoqClJlY29yZDogTG9hZGluZy9hdHRhY2hpbmcgYSBCUEYgcHJvZ3JhbSB0 aGF0IGNvbnRhaW5zIE1PVlNYLCB3aXRoIEpJVApvbi4gQ29tbW9uIGZvciBjcHUgdjQgY29tcGls ZXMuIFByaXZpbGVnZWQgbG9hZCBpbiBkZWZhdWx0IGNvbmZpZ3MuIE5vdAphIHRpbWluZyByYWNl LiB0ZXN0X2JwZiByZXByb2R1Y2VzIGl0IGV2ZXJ5IHJ1bi4KCioqU3RlcCA4LjM6IEZBSUxVUkUg TU9ERSBTRVZFUklUWSoqClJlY29yZDogW1dyb25nIEpJVCByZXN1bHRzIC8gdmVyaWZpZXItdnMt SklUIG1pc21hdGNoXSBbSElHSF0KLSBOb3QgYW4gb29wcy9kZWFkbG9jay4KLSBKSVQgcmV0dXJu cyBkaWZmZXJlbnQgcmVnaXN0ZXIgdmFsdWVzIHRoYW4gdGhlIGludGVycHJldGVyIGFuZCB0aGFu CiAgdGhlIHZlcmlmaWVy4oCZcyBzaWduLWV4dGVuZGVkIHJhbmdlcyAodGVzdDogZXhwZWN0ZWQg MSwgZ290IDIpLgotIElmIHRoZSB2ZXJpZmllciBwcnVuZWQgYSBib3VuZHMgY2hlY2sgb24gdGhl IGFzc3VtcHRpb24gdGhhdCBNT1ZTWAogIHJhbiwgcnVudGltZSBjYW4gc2VlIGEgbm9uLXNpZ24t ZXh0ZW5kZWQgdmFsdWUuIFRoYXQgaXMgQlBGIHNhbmRib3gKICBpbmNvcnJlY3RuZXNzLCBub3Qg YSBjb3NtZXRpYyB0ZXN0IGZhaWwuCgoqKlN0ZXAgOC40OiBSSVNLLUJFTkVGSVQgUkFUSU8qKgpS ZWNvcmQ6IEJlbmVmaXQgaGlnaCBmb3IgUlYzMitCUEYgKGNvcnJlY3QgSklULCBjbG9zZXMgdmVy aWZpZXIKbWlzbWF0Y2gpLiBSaXNrIHZlcnkgbG93ICgzMiBsaW5lcywgb25lIHN3aXRjaCwgZXhp c3RpbmcgZW1pdCBoZWxwZXJzLAp0ZXN0X2JwZiBiZWZvcmUvYWZ0ZXIgaW4gdGhlIG1lc3NhZ2Us IFJJU0MtViBCUEYgcmV2aWV3ZXIgVGVzdGVkLWJ5KS4KUmF0aW8gZmF2b3JzIHRha2luZyBpdC4K CiMjIFBIQVNFIDk6IEZJTkFMIFNZTlRIRVNJUwoKKipTdGVwIDkuMTogQ09NUElMRSBUSEUgRVZJ REVOQ0UqKgoKRk9SOgotIENvbmNyZXRlIG1pc2NvbXBpbGF0aW9uOiBKSVQgcnVucyBhbmQgcHJv ZHVjZXMgdGhlIHdyb25nIHZhbHVlCiAgKGBqaXRlZDoxIHJldCAyICE9IDFgKS4KLSBCUEZfTU9W U1ggaGFzIGJlZW4gaW4gdGhlIElTQS92ZXJpZmllci9pbnRlcnByZXRlciBzaW5jZSB+Ni42OyBS VjMyCiAgSklUIG5ldmVyIGhvbm9yZWQgYGluc24tPm9mZmAuCi0gSW50ZXJwcmV0ZXIgaXMgY29y cmVjdDsgb25seSB0aGUgSklUIGlzIHdyb25nIOKAlCBjbGFzc2ljIOKAnHN1cHBvcnRlZAogIG9w Y29kZSwgd3JvbmcgY29kZWdlbi7igJ0KLSAzMi1saW5lLCBzaW5nbGUtZnVuY3Rpb24sIG5vIG5l dyBBUElzLgotIFJldmlld2VkIGFuZCB0ZXN0ZWQgYnkgUHUgTGVodWk7IGFwcGxpZWQgYnkgQlBG IG1haW50YWluZXIuCi0gSW5kZXBlbmRlbnQgb2YgdGhlIG90aGVyIHR3byBzZXJpZXMgcGF0Y2hl cy4KLSBIZWxwZXJzIGFuZCBNT1YgY2FzZXMgZXhpc3QgaW4gdGhpcyB0cmVlIHNpbmNlIDUuNi4K CkFHQUlOU1Q6Ci0gU3ViamVjdC9wcm9jZXNzIHRyZWF0ZWQgaXQgYXMgYnBmLW5leHQg4oCcQWRk IHN1cHBvcnTigJ07IEZpeGVzOiB0YWdzIHdlcmUKICBkZWxpYmVyYXRlbHkgcmVtb3ZlZCBpbiB2 My4KLSBSVjMyIGlzIGEgc21hbGxlciB1c2VyIGJhc2UgdGhhbiBSVjY0LgotIEZhaWx1cmUgaXMg d3JvbmcgcmVzdWx0cywgbm90IGEgcGFuaWMuCi0gU2VyaWVzIHBhdGNoIDMvMyBpcyBhIGdlbnVp bmUgZmVhdHVyZSAoZG8gbm90IGJ1bmRsZSBpdCkuCgpVTlJFU09MVkVEOgotIENvdWxkIG5vdCBm ZXRjaCBsb3JlLmtlcm5lbC5vcmcvc3RhYmxlLyAoSFRUUCA0MDMpLiBUaHJlYWQgbWJveCBoYWQg bm8KICBzdGFibGUgZGlzY3Vzc2lvbi4KCioqU3RlcCA5LjI6IFNUQUJMRSBSVUxFUyBDSEVDS0xJ U1QqKgoxLiBPYnZpb3VzbHkgY29ycmVjdCBhbmQgdGVzdGVkPyAqKlBBU1MqKiDigJQgc2xsaS9z cmFpIG1hdGNoZXMgdGhlIElTQTsKICAgdGVzdF9icGYgIzgy4oCTIzg2OyByZXZpZXdlciBUZXN0 ZWQtYnkuCjIuIEZpeGVzIGEgcmVhbCBidWcgdGhhdCBhZmZlY3RzIHVzZXJzPyAqKlBBU1MqKiDi gJQgSklU4oCZZCBNT1ZTWCBpcyB3cm9uZwogICBvbiBSVjMyOyB1c2Vyc3BhY2UgY2FuIGxvYWQg c3VjaCBwcm9ncmFtcy4KMy4gSW1wb3J0YW50IGlzc3VlPyAqKlBBU1MqKiDigJQgdmVyaWZpZXIv SklUIG1pc21hdGNoIG9uIHNpZ24gZXh0ZW5zaW9uCiAgIGlzIHNhbmRib3gvY29ycmVjdG5lc3Ms IG5vdCBhIHN0eWxlIGlzc3VlLiBTZXZlcml0eSBISUdILCBub3QgYSBkZWFkLQogICBjb2RlIFdB Uk4uCjQuIFNtYWxsIGFuZCBjb250YWluZWQ/ICoqUEFTUyoqIOKAlCArMzIgbGluZXMsIG9uZSBm aWxlLCBvbmUgZnVuY3Rpb24uCjUuIE5vIG5ldyBmZWF0dXJlcyBvciBBUElzPyAqKlBBU1MqKiDi gJQgZG9lcyBub3QgYWRkIGEgbmV3IG9wY29kZSB0byBCUEY7CiAgIGl0IGNvbXBpbGVzIGFuIG9w Y29kZSB0aGUgdmVyaWZpZXIgYWxyZWFkeSBhY2NlcHRzLiAoVGl0bGUgaXMg4oCcQWRkCiAgIHN1 cHBvcnTigJ07IHNlbWFudGljYWxseSBpdCBpcyBmaXhpbmcgaWdub3JlZCBgb2ZmYC4pCjYuIENh biBhcHBseSB0byB0aGUgbG9jYWwgdHJlZT8gKipQQVNTKiog4oCUIGZpbGUsIGhlbHBlcnMsIGFu ZCBNT1YgY2FzZXMKICAgYXJlIGhlcmUuCgoqKlN0ZXAgOS4zOiBDSEVDSyBGT1IgRVhDRVBUSU9O IENBVEVHT1JJRVMqKgpSZWNvcmQ6IE5vdCBhIGRldmljZS1JRC9xdWlyay9EVC9idWlsZC9kb2Nz IGV4Y2VwdGlvbi4gT3JkaW5hcnkKY29ycmVjdG5lc3MgZml4LgoKKipTdGVwIDkuNDogREVDSVNJ T04qKgpUaGlzIHRyZWUgaXMgNy4zLXJjNDogaXQgaGFzIHRoZSBSVjMyIEpJVCBhbmQgQlBGX01P VlNYLiBUaGUgYnVnIGlzCuKAnE1PVnxYIGlnbm9yZXMgb2ZmLOKAnSB3aGljaCBpcyB1c2VyLXZp c2libGUgd3JvbmcgQlBGIGV4ZWN1dGlvbiBhbmQgYQp2ZXJpZmllci9KSVQgZGlzYWdyZWVtZW50 LiBUaGUgcGF0Y2ggaXMgc21hbGwsIG9idmlvdXNseSBjb3JyZWN0LAp0ZXN0ZWQsIGFuZCBzZWxm LWNvbnRhaW5lZC4gYnBmLW5leHQgZHJvcHBpbmcgRml4ZXM6IGlzIHByb2Nlc3MsIG5vdCBhCmZp bmRpbmcgdGhhdCB0aGUgY29kZWdlbiB3YXMgZmluZS4gSXQgc2hvdWxkIGJlIGJhY2twb3J0ZWQg dG8gdGhpcyB0cmVlLgoKIyMjIFdoYXQgaXQgc29sdmVzIGZvciBzdGFibGUgdXNlcnMKUlYzMiBl QlBGIEpJVCBjb21waWxlZCBzaWduLWV4dGVuZGluZyBtb3ZlcyBhcyBvcmRpbmFyeSBjb3BpZXMu IEFueQpKSVTigJlkIHByb2dyYW0gdXNpbmcgQlBGX01PVlNYIChjcHUgdjQgLyBjb21waWxlciBj YXN0cykgZ2V0cyB3cm9uZwpyZWdpc3RlciB2YWx1ZXMuIFRoYXQgYnJlYWtzIHRlc3RfYnBmIGFu ZCBjYW4gZGlzYWdyZWUgd2l0aCB2ZXJpZmllcgpyYW5nZSB0cmFja2luZy4KCiMjIyBSaXNrIHZz IGJlbmVmaXQKQmVuZWZpdDogY29ycmVjdCBKSVQgYW5kIGNsb3NlZCB2ZXJpZmllciBtaXNtYXRj aCBvbiBhIHJlYWwgSVNBCmluc3RydWN0aW9uLiBSaXNrOiB2ZXJ5IGxvdywgbG9jYWxpemVkIEFM VSBlbWl0LgoKIyMjIENvbmNlcm5zCkRvIG5vdCBwdWxsIHNlcmllcyAzLzMgKGF0b21pY3MgZmVh dHVyZSkuIDEvMyAoU0RJVi9TTU9EKSBpcyB0aGUgc2FtZQptaXNjb21waWxhdGlvbiBjbGFzcyBi dXQgaXMgbm90IHJlcXVpcmVkIGZvciB0aGlzIHBhdGNoLiBObyBiYWNrcG9ydApyZXdvcmsgbmVl ZGVkIG9uIHRoaXMgdHJlZS4KClZlcmlmaWNhdGlvbjoKLSBbUGhhc2UgMV0gVGFnczogUmV2aWV3 ZWQtYnkgUHUgTGVodWksIExpbmsgbG9yZS9icGYsIFNPQiBhdXRob3IgKwogIEthcnRpa2V5YTsg bm8gRml4ZXMvc3l6Ym90L0NjOnN0YWJsZQotIFtQaGFzZSAxXSBCb2R5OiB0ZXN0X2JwZiAjODLi gJMjODYgYGppdGVkOjEgcmV0IDIgIT0gMWAgYmVmb3JlLCBQQVNTCiAgYWZ0ZXIKLSBbUGhhc2Ug Ml0gRGlmZjogKzMyIGluIGBicGZfaml0X2VtaXRfaW5zbigpYCwgdHdvIE1PVnxYIGNhc2VzLAog IHNsbGkvc3JhaSBzaWduLWV4dGVuZAotIFtQaGFzZSAyXSBDb25maXJtZWQgYGVtaXRfYWx1X3I2 NGAgQlBGX01PViBpcyBsby9oaSBjb3B5OwogIGBlbWl0X2FsdV9yMzJgIEJQRl9NT1YgaXMgbG8g Y29weSAocHJlLWZpeCBwYXRoKQotIFtQaGFzZSAzXSBibGFtZTogTU9WIGZhbGx0aHJvdWdoIGZy b20gNWYzMTZiNjVlOTlmMSAodjUuNik7IElTQQogIDgxMDA5MjhjODgxNDggKH42LjYpOyBSVjY0 IDY5NDg5NmFkM2NhNzkKLSBbUGhhc2UgM10gYGdpdCBtZXJnZS1iYXNlIC0taXMtYW5jZXN0b3Ig YzZhMDhhZmRmZTNhOCBIRUFEYCB5ZXM7IG5vdAogIGFuY2VzdG9yIG9mIHY3LjI7IGlzIGFuY2Vz dG9yIG9mIHY3LjMtcmMxCi0gW1BoYXNlIDNdIFNlcmllcyBwYXRjaGVzIDJlMGZhMjM4OWM1MGYg LyBjNmEwOGFmZGZlM2E4IC8KICBhMWIzNzk3MmVmYzBiOyB0aGlzIG9uZSBpbmRlcGVuZGVudAot IFtQaGFzZSA0XSBgYjQgZGlnIC1jIGM2YTA4YWZkZmUzYThgOiB2NCAyLzMsIG1zZ2lkCiAgMjAy NjA3MTQwMDI0NTEuNDA5MTEzOS0zCi0gW1BoYXNlIDRdIGBiNCBkaWcgLWFgOiB2MeKAk3Y0OyB2 MyByZW1vdmVkIEZpeGVzOiBhbmQgcmV0aXRsZWQKLSBbUGhhc2UgNF0gYGI0IGRpZyAtbWA6IDcg bWVzc2FnZXM7IFB1IExlaHVpIFItYi9ULWI7IG5vIE5BSzsgbm8gc3RhYmxlCiAgQ2MKLSBbUGhh c2UgNF0gV2ViRmV0Y2ggbG9yZTogNDAzIOKAlCBVTlZFUklGSUVEIHZpYSBIVFRQOyB0aHJlYWQg cmVjb3ZlcmVkCiAgdmlhIGI0IG1ib3gKLSBbUGhhc2UgNV0gQ2FsbGVyOiBgYnVpbGRfYm9keSgp YCDihpIgZXZlcnkgSklU4oCZZCBpbnNuOyBgSEFWRV9FQlBGX0pJVCBpZgogIE1NVWAKLSBbUGhh c2UgNV0gVGVzdHMgaW4gbGliL3Rlc3RfYnBmLmMgQUxVX01PVlNYIC8gQUxVNjRfTU9WU1gKLSBb UGhhc2UgNl0gYGdpdCBkZXNjcmliZSBIRUFEYCA9IHY3LjMtcmM0LTI3LWdmMDEwMDM2M2Q4YzM3 OyBgbWFrZQogIGtlcm5lbHZlcnNpb25gID0gNy4zLjAtcmM0Ci0gW1BoYXNlIDZdIGJwZl9qaXRf Y29tcDMyLmMgYW5kIEJQRl9NT1ZTWDY0X1JFRyBwcmVzZW50OyBoZWxwZXJzIGZyb20KICBvcmln aW5hbCBKSVQKLSBbUGhhc2UgOF0gRmFpbHVyZTogd3JvbmcgSklUIG91dHB1dCAvIHZlcmlmaWVy IG1pc21hdGNoLCBISUdIOyBub3QgYQogIHBhbmljCi0gVU5WRVJJRklFRDogc3RhYmxlQCBtYWls aW5nIGxpc3QgYXJjaGl2ZSAoSFRUUCA0MDMpCgoqKllFUyoqCgogYXJjaC9yaXNjdi9uZXQvYnBm X2ppdF9jb21wMzIuYyB8IDMyICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAxIGZp bGUgY2hhbmdlZCwgMzIgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvbmV0 L2JwZl9qaXRfY29tcDMyLmMgYi9hcmNoL3Jpc2N2L25ldC9icGZfaml0X2NvbXAzMi5jCmluZGV4 IDg5MTUzOTQ2YTRlNDYuLjM5ZTJiMGI5MDdkYzMgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3YvbmV0 L2JwZl9qaXRfY29tcDMyLmMKKysrIGIvYXJjaC9yaXNjdi9uZXQvYnBmX2ppdF9jb21wMzIuYwpA QCAtOTcyLDYgKzk3MiwyNCBAQCBpbnQgYnBmX2ppdF9lbWl0X2luc24oY29uc3Qgc3RydWN0IGJw Zl9pbnNuICppbnNuLCBzdHJ1Y3QgcnZfaml0X2NvbnRleHQgKmN0eCwKIAogCXN3aXRjaCAoY29k ZSkgewogCWNhc2UgQlBGX0FMVTY0IHwgQlBGX01PViB8IEJQRl9YOgorCQlpZiAoaW5zbi0+b2Zm ICE9IDApIHsKKwkJCWNvbnN0IHM4ICpyZCA9IGJwZl9nZXRfcmVnNjQoZHN0LCB0bXAxLCBjdHgp OworCQkJY29uc3QgczggKnJzID0gYnBmX2dldF9yZWc2NChzcmMsIHRtcDIsIGN0eCk7CisKKwkJ CWlmIChpbnNuLT5vZmYgPT0gOCkgeworCQkJCWVtaXQocnZfc2xsaShsbyhyZCksIGxvKHJzKSwg MjQpLCBjdHgpOworCQkJCWVtaXQocnZfc3JhaShsbyhyZCksIGxvKHJkKSwgMjQpLCBjdHgpOwor CQkJfSBlbHNlIGlmIChpbnNuLT5vZmYgPT0gMTYpIHsKKwkJCQllbWl0KHJ2X3NsbGkobG8ocmQp LCBsbyhycyksIDE2KSwgY3R4KTsKKwkJCQllbWl0KHJ2X3NyYWkobG8ocmQpLCBsbyhyZCksIDE2 KSwgY3R4KTsKKwkJCX0gZWxzZSB7CisJCQkJZW1pdChydl9hZGRpKGxvKHJkKSwgbG8ocnMpLCAw KSwgY3R4KTsKKwkJCX0KKwkJCWVtaXQocnZfc3JhaShoaShyZCksIGxvKHJkKSwgMzEpLCBjdHgp OworCQkJYnBmX3B1dF9yZWc2NChkc3QsIHJkLCBjdHgpOworCQkJYnJlYWs7CisJCX0KKwkJZmFs bHRocm91Z2g7CiAKIAljYXNlIEJQRl9BTFU2NCB8IEJQRl9BREQgfCBCUEZfWDoKIAljYXNlIEJQ Rl9BTFU2NCB8IEJQRl9BREQgfCBCUEZfSzoKQEAgLTEwMjIsNiArMTA0MCwyMCBAQCBpbnQgYnBm X2ppdF9lbWl0X2luc24oY29uc3Qgc3RydWN0IGJwZl9pbnNuICppbnNuLCBzdHJ1Y3QgcnZfaml0 X2NvbnRleHQgKmN0eCwKIAkJCWVtaXRfemV4dDY0KGRzdCwgY3R4KTsKIAkJCWJyZWFrOwogCQl9 CisJCWlmIChpbnNuLT5vZmYgIT0gMCkgeworCQkJY29uc3QgczggKnJkID0gYnBmX2dldF9yZWcz Mihkc3QsIHRtcDEsIGN0eCk7CisJCQljb25zdCBzOCAqcnMgPSBicGZfZ2V0X3JlZzMyKHNyYywg dG1wMiwgY3R4KTsKKworCQkJaWYgKGluc24tPm9mZiA9PSA4KSB7CisJCQkJZW1pdChydl9zbGxp KGxvKHJkKSwgbG8ocnMpLCAyNCksIGN0eCk7CisJCQkJZW1pdChydl9zcmFpKGxvKHJkKSwgbG8o cmQpLCAyNCksIGN0eCk7CisJCQl9IGVsc2UgaWYgKGluc24tPm9mZiA9PSAxNikgeworCQkJCWVt aXQocnZfc2xsaShsbyhyZCksIGxvKHJzKSwgMTYpLCBjdHgpOworCQkJCWVtaXQocnZfc3JhaShs byhyZCksIGxvKHJkKSwgMTYpLCBjdHgpOworCQkJfQorCQkJYnBmX3B1dF9yZWczMihkc3QsIHJk LCBjdHgpOworCQkJYnJlYWs7CisJCX0KIAkJZmFsbHRocm91Z2g7CiAKIAljYXNlIEJQRl9BTFUg fCBCUEZfQUREIHwgQlBGX1g6Ci0tIAoyLjUzLjAKCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1yaXNjdiBtYWlsaW5nIGxpc3QKbGludXgtcmlz Y3ZAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFu L2xpc3RpbmZvL2xpbnV4LXJpc2N2Cg==