From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from canpmsgout09.his.huawei.com (canpmsgout09.his.huawei.com [113.46.200.224]) (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 1DFC0305665; Mon, 17 Aug 2026 01:52:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=113.46.200.224 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786931556; cv=none; b=Jmhdee9JwXli/qmAAybI90n6EfB7SXwJBRkx9yEBtZy+8fyyme+j0coZCHRXZy6tU08g9DhoBlx+YXcJ7gJpoAGApfS+RPTh40jCp6QTuit75iLOC96PI8yIGb7tx159mvRGfdNAESaDe4SS9KWMeLYrRWn0RRjTd4O2c4jDMnk= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786931556; c=relaxed/simple; bh=Em5+JleXmfQ+tSKIywginRF4M4++sM3CUoEfoqJB7OM=; h=Message-ID:Date:MIME-Version:Subject:To:CC:References:From: In-Reply-To:Content-Type; b=OXA6dWqJfYdSRLwzlOppXMKMTTICNRFl5MqEplYj09Le+VYMpYXf3EfGZ7LihnbpHCo36pFfy0bW+joct8NmHiouqc9IdgWlLoemJnBp/aE5u27NnsW1J2+Fvy+MQ3696WORDSRKEpw8CgT6SfvSnwZpgPYmZaDrxXu/QsfCAvQ= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=huawei.com; spf=pass smtp.mailfrom=huawei.com; dkim=pass (1024-bit key) header.d=huawei.com header.i=@huawei.com header.b=ofTbkbQt; arc=none smtp.client-ip=113.46.200.224 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=huawei.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=huawei.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=huawei.com header.i=@huawei.com header.b="ofTbkbQt" dkim-signature: v=1; a=rsa-sha256; d=huawei.com; s=dkim; c=relaxed/relaxed; q=dns/txt; h=From; bh=IJmVtDUb7XIXFtur5WMo0s7yV4lH1fkofPtZwxK+itg=; b=ofTbkbQtdBBQ+yJPEy7FUu3xAYwE6iKLjhMprk41MzSXuZE4ws9IDxxr2ddP/XGp9vE+py+m1 T66MFV6wW8yPCmERJgPJMfMkhY8q2tqW6q1HKgVerDvDNfiXss+HL+vPMJ0EQ4HHXEV9MG1BPpK pq6Ru4C4y3wD4g0YzBhjvX0= Received: from mail.maildlp.com (unknown [172.19.163.15]) by canpmsgout09.his.huawei.com (SkyGuard) with ESMTPS id 4hNbCq1p5wz1cyPY; Mon, 17 Aug 2026 09:41:43 +0800 (CST) Received: from kwepemf100007.china.huawei.com (unknown [7.202.181.221]) by mail.maildlp.com (Postfix) with ESMTPS id 5F9A940578; Mon, 17 Aug 2026 09:52:22 +0800 (CST) Received: from [10.67.110.68] (10.67.110.68) by kwepemf100007.china.huawei.com (7.202.181.221) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1544.36; Mon, 17 Aug 2026 09:52:21 +0800 Message-ID: <729d2110-20b2-4e63-af44-99ca8cebdbfd@huawei.com> Date: Mon, 17 Aug 2026 09:52:20 +0800 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH bpf-next v3 1/2] bpf, riscv: Add BPF stack arguments support for RV64 JIT Content-Language: en-US To: Feng Jiang , Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , Eduard Zingerman , Kumar Kartikeya Dwivedi , Martin KaFai Lau , Song Liu , Yonghong Song , Jiri Olsa , Emil Tsalapatis , Ihor Solodrai , Luke Nelson , Xi Wang , =?UTF-8?B?QmrDtnJuIFTDtnBlbA==?= , Puranjay Mohan , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexandre Ghiti , Shuah Khan , Nathan Chancellor , Nick Desaulniers , Bill Wendling , Justin Stitt CC: , , , , References: <20260814-bpf-riscv-stack-args-v3-0-2160de56fea3@kylinos.cn> <20260814-bpf-riscv-stack-args-v3-1-2160de56fea3@kylinos.cn> From: Pu Lehui In-Reply-To: <20260814-bpf-riscv-stack-args-v3-1-2160de56fea3@kylinos.cn> Content-Type: text/plain; charset="UTF-8"; format=flowed Content-Transfer-Encoding: 8bit X-ClientProxiedBy: kwepems500001.china.huawei.com (7.221.188.70) To kwepemf100007.china.huawei.com (7.202.181.221) Hi Feng Jiang, On 2026/8/14 9:29, Feng Jiang wrote: > Add bpf_jit_supports_stack_args() for the RV64 JIT so BPF subprograms > and kfuncs can receive more than 5 arguments via the stack > (BPF_REG_PARAMS / r11). > > For BPF-to-BPF calls the caller writes outgoing arguments at the > bottom of its frame (SP-relative). The callee reads them with > FP-relative loads. Its FP is set to the caller SP in the prologue, > so the offsets match. > > The RISC-V ABI puts arguments 6-8 in A5-A7 and arguments 9+ at > SP+0. Before each kfunc call, load arguments 6-8 from the outgoing > area into A5-A7 and copy any remaining arguments down so argument 9 > lands at SP+0. bpf2bpf calls pass extra arguments entirely on the stack, whereas kfuncs pass them via a mix of registers and the stack. This inconsistency not only wastes stack slots in kfunc scenarios but is also error-prone and easy to overlook during maintenance. To make argument passing more straightforward and consistent, I think we can align it with the standard riscv calling convention: use a0-a7 for the first 8 arguments and pass any remaining arguments on the stack. To support this, the current bpf-to-rv register mapping needs to be revised: T0 -> BPF_REG_0 (ftrace use T0 too, but it might not be an issue / needs verification) T6 -> TCC T7 -> BPF_REG_AX (rarely used, so let's move to t7) Note that this remapping affects multiple places and requires careful auditing. > > A5 (BPF_REG_0), A6 (TCC) and A7 are safe to clobber here: R0 is not > live before a call, TCC is backed up on the stack, and A7 is unused > by the JIT. > > Limit the existing kfunc sign-extension loop to MAX_BPF_FUNC_REG_ARGS > iterations; otherwise idx >= 5 resolves to S1-S5 (BPF_R6-FP) and > corrupts callee-saved registers. > > Signed-off-by: Feng Jiang > --- > arch/riscv/net/bpf_jit.h | 1 + > arch/riscv/net/bpf_jit_comp64.c | 79 +++++++++++++++++++++++++++++++++++++++-- > arch/riscv/net/bpf_jit_core.c | 4 +++ > 3 files changed, 81 insertions(+), 3 deletions(-) > > diff --git a/arch/riscv/net/bpf_jit.h b/arch/riscv/net/bpf_jit.h > index 419b9d795f2a..9eb4e149505d 100644 > --- a/arch/riscv/net/bpf_jit.h > +++ b/arch/riscv/net/bpf_jit.h > @@ -82,6 +82,7 @@ struct rv_jit_context { > unsigned long flags; > int stack_size; > int tcc_offset; > + u16 stack_arg_size; > u64 arena_vm_start; > u64 user_vm_start; > }; > diff --git a/arch/riscv/net/bpf_jit_comp64.c b/arch/riscv/net/bpf_jit_comp64.c > index 6b9972b07c1b..58cb3e5ff6b4 100644 > --- a/arch/riscv/net/bpf_jit_comp64.c > +++ b/arch/riscv/net/bpf_jit_comp64.c > @@ -1815,18 +1815,43 @@ int bpf_jit_emit_insn(const struct bpf_insn *insn, struct rv_jit_context *ctx, > > if (insn->src_reg == BPF_PSEUDO_KFUNC_CALL) { > const struct btf_func_model *fm; > - int idx; > + int idx, nargs; > > fm = bpf_jit_find_kfunc_model(ctx->prog, insn); > if (!fm) > return -EINVAL; > > - for (idx = 0; idx < fm->nr_args; idx++) { > + nargs = min_t(int, fm->nr_args, MAX_BPF_FUNC_REG_ARGS); > + for (idx = 0; idx < nargs; idx++) { > u8 reg = bpf_to_rv_reg(BPF_REG_1 + idx, ctx); > > if (fm->arg_size[idx] == sizeof(int)) > emit_sextw(reg, reg, ctx); > } > + > + /* BPF stack args -> RISC-V ABI: args 6-8 in A5-A7, 9+ at SP+0 */ > + if (fm->nr_args > MAX_BPF_FUNC_REG_ARGS) { > + int n_stack = fm->nr_args - MAX_BPF_FUNC_REG_ARGS; > + int n_reg = min_t(int, n_stack, > + RV_MAX_REG_ARGS - MAX_BPF_FUNC_REG_ARGS); > + > + for (idx = 0; idx < n_reg; idx++) { > + int sz = fm->arg_size[MAX_BPF_FUNC_REG_ARGS + idx]; > + > + emit_ld(RV_REG_A5 + idx, idx * 8, RV_REG_SP, ctx); > + if (sz == sizeof(int)) > + emit_sextw(RV_REG_A5 + idx, RV_REG_A5 + idx, ctx); > + } > + > + for (idx = n_reg; idx < n_stack; idx++) { > + int sz = fm->arg_size[MAX_BPF_FUNC_REG_ARGS + idx]; > + > + emit_ld(RV_REG_T1, idx * 8, RV_REG_SP, ctx); > + if (sz == sizeof(int)) > + emit_sextw(RV_REG_T1, RV_REG_T1, ctx); > + emit_sd(RV_REG_SP, (idx - n_reg) * 8, RV_REG_T1, ctx); > + } > + } looks a bit complicated, how about the following after redefine regmap: ``` for (idx = 0; idx < fm->nr_args; idx++) { if (idx < RV_MAX_REG_ARGS) { u8 reg = RV_REG_A0 + idx; sign_extend(reg, reg, xxx) } else { load from stack to T1 sign_extend retore from T1 to orig stack slot } } ``` > } > > /* restore TCC to RV_REG_TCC before bpf2bpf call */ > @@ -1891,6 +1916,21 @@ int bpf_jit_emit_insn(const struct bpf_insn *insn, struct rv_jit_context *ctx, > case BPF_LDX | BPF_MEM | BPF_H: > case BPF_LDX | BPF_MEM | BPF_W: > case BPF_LDX | BPF_MEM | BPF_DW: > + if (insn->src_reg == BPF_REG_PARAMS) { pls use is_stack_arg_ldx/st/stx instead. > + int idx = off / 8 - 1; > + > + if (is_12b_int(idx * 8)) { > + emit_ldx_insn(rd, idx * 8, RV_REG_FP, BPF_SIZE(code), false, ctx); > + } else { > + emit_imm(RV_REG_T1, idx * 8, ctx); > + emit_add(RV_REG_T1, RV_REG_T1, RV_REG_FP, ctx); > + emit_ldx_insn(rd, 0, RV_REG_T1, BPF_SIZE(code), false, ctx); > + } > + if (BPF_SIZE(code) != BPF_DW && insn_is_zext(&insn[1])) > + return 1; > + break; This piece of code was refactored not long ago. Let's see if we can merge it into the logic below or fold it into emit_ldx—let's give it a try. > + } > + fallthrough; > case BPF_LDX | BPF_PROBE_MEM | BPF_B: > case BPF_LDX | BPF_PROBE_MEM | BPF_H: > case BPF_LDX | BPF_PROBE_MEM | BPF_W: > @@ -1938,6 +1978,20 @@ int bpf_jit_emit_insn(const struct bpf_insn *insn, struct rv_jit_context *ctx, > case BPF_ST | BPF_MEM | BPF_H: > case BPF_ST | BPF_MEM | BPF_W: > case BPF_ST | BPF_MEM | BPF_DW: > + if (insn->dst_reg == BPF_REG_PARAMS) { > + int idx = -off / 8 - 1; > + > + emit_imm(RV_REG_T1, imm, ctx); > + if (is_12b_int(idx * 8)) { > + emit_stx_insn(RV_REG_SP, idx * 8, RV_REG_T1, BPF_SIZE(code), ctx); > + } else { > + emit_imm(RV_REG_T2, idx * 8, ctx); > + emit_add(RV_REG_T2, RV_REG_SP, RV_REG_T2, ctx); > + emit_stx_insn(RV_REG_T2, 0, RV_REG_T1, BPF_SIZE(code), ctx); > + } > + break; > + } > + fallthrough; ditto > /* ST | PROBE_MEM32: *(size *)(dst + RV_REG_ARENA + off) = imm */ > case BPF_ST | BPF_PROBE_MEM32 | BPF_B: > case BPF_ST | BPF_PROBE_MEM32 | BPF_H: > @@ -1960,6 +2014,19 @@ int bpf_jit_emit_insn(const struct bpf_insn *insn, struct rv_jit_context *ctx, > case BPF_STX | BPF_MEM | BPF_H: > case BPF_STX | BPF_MEM | BPF_W: > case BPF_STX | BPF_MEM | BPF_DW: > + if (insn->dst_reg == BPF_REG_PARAMS) { > + int idx = -off / 8 - 1; > + > + if (is_12b_int(idx * 8)) { > + emit_stx_insn(RV_REG_SP, idx * 8, rs, BPF_SIZE(code), ctx); > + } else { > + emit_imm(RV_REG_T1, idx * 8, ctx); > + emit_add(RV_REG_T1, RV_REG_SP, RV_REG_T1, ctx); > + emit_stx_insn(RV_REG_T1, 0, rs, BPF_SIZE(code), ctx); > + } > + break; > + } > + fallthrough; ditto > /* STX | PROBE_MEM32: *(size *)(dst + RV_REG_ARENA + off) = src */ > case BPF_STX | BPF_PROBE_MEM32 | BPF_B: > case BPF_STX | BPF_PROBE_MEM32 | BPF_H: > @@ -2036,6 +2103,7 @@ void bpf_jit_build_prologue(struct rv_jit_context *ctx, bool is_subprog) > > stack_adjust = round_up(stack_adjust, STACK_ALIGN); > stack_adjust += bpf_stack_adjust; > + stack_adjust += ctx->stack_arg_size; > > store_offset = stack_adjust - 8; > > @@ -2093,7 +2161,7 @@ void bpf_jit_build_prologue(struct rv_jit_context *ctx, bool is_subprog) > emit_addi(RV_REG_FP, RV_REG_SP, stack_adjust, ctx); > > if (bpf_stack_adjust) > - emit_addi(RV_REG_S5, RV_REG_SP, bpf_stack_adjust, ctx); > + emit_addi(RV_REG_S5, RV_REG_SP, ctx->stack_arg_size + bpf_stack_adjust, ctx); > > ctx->stack_size = stack_adjust; > > @@ -2171,3 +2239,8 @@ bool bpf_jit_supports_timed_may_goto(void) > { > return true; > } > + > +bool bpf_jit_supports_stack_args(void) > +{ > + return true; > +} > diff --git a/arch/riscv/net/bpf_jit_core.c b/arch/riscv/net/bpf_jit_core.c > index cbfcd287ea16..844a0f3e0fa9 100644 > --- a/arch/riscv/net/bpf_jit_core.c > +++ b/arch/riscv/net/bpf_jit_core.c > @@ -72,6 +72,10 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_verifier_env *env, struct bpf_pr > ctx->arena_vm_start = bpf_arena_get_kern_vm_start(prog->aux->arena); > ctx->user_vm_start = bpf_arena_get_user_vm_start(prog->aux->arena); > ctx->prog = prog; > + > + ctx->stack_arg_size = round_up(bpf_out_stack_arg_cnt(env, prog) * > + sizeof(u64), STACK_ALIGN); It's not u64—since every stack slot is aligned to the pointer size (sizeof(long)), I think using 8 is fine. > + > ctx->offset = kvzalloc_objs(int, prog->len); > if (!ctx->offset) > goto out_offset; > 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 C30D6C5DF66 for ; Mon, 17 Aug 2026 01:53:03 +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-Type: Content-Transfer-Encoding:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:From:References:CC:To:Subject: MIME-Version:Date:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=oW1lFUtczgO7D3K30v83NgUqKaVx3QaN8LumL4jFlYc=; b=k/e2gdQvR45n1b sJzKRYCwwlA4amJ3gVHymiHwFbf0aewsVI8uNwLxqxRxql1wyiow6cWI1KL0Jhpbs2tiHpVUYxxGS GJ3Dwz9i/AtEiRvWmcbTFMwYbsKfN7DA0lPY2ENmlrD5L6m6hSIN5CHUV4qPoSz269hBYRWYcagNy Ial1G8Oe+I8sqUBChQ79sJYFMgMUaaRi/VbAPsAOBLeE+LTHbTnnkurtg0tUxBzgic5qPKXVIiGKZ YrD6bV6fkbMkycwX+NrjLCVRiQcjx8JCZm3aAjo5zjeNfVPUaCXQPVkuwojtFWuUsBaGeHiBZhDLW DWRizEFrG24fGqsbtEFA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wvmWo-00000005HTC-1j6t; Mon, 17 Aug 2026 01:52:42 +0000 Received: from canpmsgout09.his.huawei.com ([113.46.200.224]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wvmWk-00000005HSg-1T6i for linux-riscv@lists.infradead.org; Mon, 17 Aug 2026 01:52:40 +0000 dkim-signature: v=1; a=rsa-sha256; d=huawei.com; s=dkim; c=relaxed/relaxed; q=dns/txt; h=From; bh=IJmVtDUb7XIXFtur5WMo0s7yV4lH1fkofPtZwxK+itg=; b=ofTbkbQtdBBQ+yJPEy7FUu3xAYwE6iKLjhMprk41MzSXuZE4ws9IDxxr2ddP/XGp9vE+py+m1 T66MFV6wW8yPCmERJgPJMfMkhY8q2tqW6q1HKgVerDvDNfiXss+HL+vPMJ0EQ4HHXEV9MG1BPpK pq6Ru4C4y3wD4g0YzBhjvX0= Received: from mail.maildlp.com (unknown [172.19.163.15]) by canpmsgout09.his.huawei.com (SkyGuard) with ESMTPS id 4hNbCq1p5wz1cyPY; Mon, 17 Aug 2026 09:41:43 +0800 (CST) Received: from kwepemf100007.china.huawei.com (unknown [7.202.181.221]) by mail.maildlp.com (Postfix) with ESMTPS id 5F9A940578; Mon, 17 Aug 2026 09:52:22 +0800 (CST) Received: from [10.67.110.68] (10.67.110.68) by kwepemf100007.china.huawei.com (7.202.181.221) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1544.36; Mon, 17 Aug 2026 09:52:21 +0800 Message-ID: <729d2110-20b2-4e63-af44-99ca8cebdbfd@huawei.com> Date: Mon, 17 Aug 2026 09:52:20 +0800 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH bpf-next v3 1/2] bpf, riscv: Add BPF stack arguments support for RV64 JIT Content-Language: en-US To: Feng Jiang , Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , Eduard Zingerman , Kumar Kartikeya Dwivedi , Martin KaFai Lau , Song Liu , Yonghong Song , Jiri Olsa , Emil Tsalapatis , Ihor Solodrai , Luke Nelson , Xi Wang , =?UTF-8?B?QmrDtnJuIFTDtnBlbA==?= , Puranjay Mohan , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexandre Ghiti , Shuah Khan , Nathan Chancellor , Nick Desaulniers , Bill Wendling , Justin Stitt CC: , , , , References: <20260814-bpf-riscv-stack-args-v3-0-2160de56fea3@kylinos.cn> <20260814-bpf-riscv-stack-args-v3-1-2160de56fea3@kylinos.cn> From: Pu Lehui In-Reply-To: <20260814-bpf-riscv-stack-args-v3-1-2160de56fea3@kylinos.cn> X-Originating-IP: [10.67.110.68] X-ClientProxiedBy: kwepems500001.china.huawei.com (7.221.188.70) To kwepemf100007.china.huawei.com (7.202.181.221) X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.9.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260816_185239_018386_5B94E616 X-CRM114-Status: GOOD ( 27.74 ) 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-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org SGkgRmVuZyBKaWFuZywKCk9uIDIwMjYvOC8xNCA5OjI5LCBGZW5nIEppYW5nIHdyb3RlOgo+IEFk ZCBicGZfaml0X3N1cHBvcnRzX3N0YWNrX2FyZ3MoKSBmb3IgdGhlIFJWNjQgSklUIHNvIEJQRiBz dWJwcm9ncmFtcwo+IGFuZCBrZnVuY3MgY2FuIHJlY2VpdmUgbW9yZSB0aGFuIDUgYXJndW1lbnRz IHZpYSB0aGUgc3RhY2sKPiAoQlBGX1JFR19QQVJBTVMgLyByMTEpLgo+IAo+IEZvciBCUEYtdG8t QlBGIGNhbGxzIHRoZSBjYWxsZXIgd3JpdGVzIG91dGdvaW5nIGFyZ3VtZW50cyBhdCB0aGUKPiBi b3R0b20gb2YgaXRzIGZyYW1lIChTUC1yZWxhdGl2ZSkuIFRoZSBjYWxsZWUgcmVhZHMgdGhlbSB3 aXRoCj4gRlAtcmVsYXRpdmUgbG9hZHMuIEl0cyBGUCBpcyBzZXQgdG8gdGhlIGNhbGxlciBTUCBp biB0aGUgcHJvbG9ndWUsCj4gc28gdGhlIG9mZnNldHMgbWF0Y2guCj4gCj4gVGhlIFJJU0MtViBB QkkgcHV0cyBhcmd1bWVudHMgNi04IGluIEE1LUE3IGFuZCBhcmd1bWVudHMgOSsgYXQKPiBTUCsw LiBCZWZvcmUgZWFjaCBrZnVuYyBjYWxsLCBsb2FkIGFyZ3VtZW50cyA2LTggZnJvbSB0aGUgb3V0 Z29pbmcKPiBhcmVhIGludG8gQTUtQTcgYW5kIGNvcHkgYW55IHJlbWFpbmluZyBhcmd1bWVudHMg ZG93biBzbyBhcmd1bWVudCA5Cj4gbGFuZHMgYXQgU1ArMC4KCmJwZjJicGYgY2FsbHMgcGFzcyBl eHRyYSBhcmd1bWVudHMgZW50aXJlbHkgb24gdGhlIHN0YWNrLCB3aGVyZWFzIGtmdW5jcyAKcGFz cyB0aGVtIHZpYSBhIG1peCBvZiByZWdpc3RlcnMgYW5kIHRoZSBzdGFjay4gVGhpcyBpbmNvbnNp c3RlbmN5IG5vdCAKb25seSB3YXN0ZXMgc3RhY2sgc2xvdHMgaW4ga2Z1bmMgc2NlbmFyaW9zIGJ1 dCBpcyBhbHNvIGVycm9yLXByb25lIGFuZCAKZWFzeSB0byBvdmVybG9vayBkdXJpbmcgbWFpbnRl bmFuY2UuCgpUbyBtYWtlIGFyZ3VtZW50IHBhc3NpbmcgbW9yZSBzdHJhaWdodGZvcndhcmQgYW5k IGNvbnNpc3RlbnQsIEkgdGhpbmsgd2UgCmNhbiBhbGlnbiBpdCB3aXRoIHRoZSBzdGFuZGFyZCBy aXNjdiBjYWxsaW5nIGNvbnZlbnRpb246IHVzZSBhMC1hNyBmb3IgCnRoZSBmaXJzdCA4IGFyZ3Vt ZW50cyBhbmQgcGFzcyBhbnkgcmVtYWluaW5nIGFyZ3VtZW50cyBvbiB0aGUgc3RhY2suCgpUbyBz dXBwb3J0IHRoaXMsIHRoZSBjdXJyZW50IGJwZi10by1ydiByZWdpc3RlciBtYXBwaW5nIG5lZWRz IHRvIGJlIHJldmlzZWQ6CgpUMCAtPiBCUEZfUkVHXzAgKGZ0cmFjZSB1c2UgVDAgdG9vLCBidXQg aXQgbWlnaHQgbm90IGJlIGFuIGlzc3VlIC8gbmVlZHMgCnZlcmlmaWNhdGlvbikKVDYgLT4gVEND ClQ3IC0+IEJQRl9SRUdfQVggKHJhcmVseSB1c2VkLCBzbyBsZXQncyBtb3ZlIHRvIHQ3KQoKTm90 ZSB0aGF0IHRoaXMgcmVtYXBwaW5nIGFmZmVjdHMgbXVsdGlwbGUgcGxhY2VzIGFuZCByZXF1aXJl cyBjYXJlZnVsIAphdWRpdGluZy4KCj4gCj4gQTUgKEJQRl9SRUdfMCksIEE2IChUQ0MpIGFuZCBB NyBhcmUgc2FmZSB0byBjbG9iYmVyIGhlcmU6IFIwIGlzIG5vdAo+IGxpdmUgYmVmb3JlIGEgY2Fs bCwgVENDIGlzIGJhY2tlZCB1cCBvbiB0aGUgc3RhY2ssIGFuZCBBNyBpcyB1bnVzZWQKPiBieSB0 aGUgSklULgoKCgo+IAo+IExpbWl0IHRoZSBleGlzdGluZyBrZnVuYyBzaWduLWV4dGVuc2lvbiBs b29wIHRvIE1BWF9CUEZfRlVOQ19SRUdfQVJHUwo+IGl0ZXJhdGlvbnM7IG90aGVyd2lzZSBpZHgg Pj0gNSByZXNvbHZlcyB0byBTMS1TNSAoQlBGX1I2LUZQKSBhbmQKPiBjb3JydXB0cyBjYWxsZWUt c2F2ZWQgcmVnaXN0ZXJzLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEZlbmcgSmlhbmcgPGppYW5nZmVu Z0BreWxpbm9zLmNuPgo+IC0tLQo+ICAgYXJjaC9yaXNjdi9uZXQvYnBmX2ppdC5oICAgICAgICB8 ICAxICsKPiAgIGFyY2gvcmlzY3YvbmV0L2JwZl9qaXRfY29tcDY0LmMgfCA3OSArKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKystLQo+ICAgYXJjaC9yaXNjdi9uZXQvYnBmX2pp dF9jb3JlLmMgICB8ICA0ICsrKwo+ICAgMyBmaWxlcyBjaGFuZ2VkLCA4MSBpbnNlcnRpb25zKCsp LCAzIGRlbGV0aW9ucygtKQo+IAo+IGRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L25ldC9icGZfaml0 LmggYi9hcmNoL3Jpc2N2L25ldC9icGZfaml0LmgKPiBpbmRleCA0MTliOWQ3OTVmMmEuLjllYjRl MTQ5NTA1ZCAxMDA2NDQKPiAtLS0gYS9hcmNoL3Jpc2N2L25ldC9icGZfaml0LmgKPiArKysgYi9h cmNoL3Jpc2N2L25ldC9icGZfaml0LmgKPiBAQCAtODIsNiArODIsNyBAQCBzdHJ1Y3QgcnZfaml0 X2NvbnRleHQgewo+ICAgCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cj4gICAJaW50IHN0YWNrX3NpemU7 Cj4gICAJaW50IHRjY19vZmZzZXQ7Cj4gKwl1MTYgc3RhY2tfYXJnX3NpemU7Cj4gICAJdTY0IGFy ZW5hX3ZtX3N0YXJ0Owo+ICAgCXU2NCB1c2VyX3ZtX3N0YXJ0Owo+ICAgfTsKPiBkaWZmIC0tZ2l0 IGEvYXJjaC9yaXNjdi9uZXQvYnBmX2ppdF9jb21wNjQuYyBiL2FyY2gvcmlzY3YvbmV0L2JwZl9q aXRfY29tcDY0LmMKPiBpbmRleCA2Yjk5NzJiMDdjMWIuLjU4Y2IzZTVmZjZiNCAxMDA2NDQKPiAt LS0gYS9hcmNoL3Jpc2N2L25ldC9icGZfaml0X2NvbXA2NC5jCj4gKysrIGIvYXJjaC9yaXNjdi9u ZXQvYnBmX2ppdF9jb21wNjQuYwo+IEBAIC0xODE1LDE4ICsxODE1LDQzIEBAIGludCBicGZfaml0 X2VtaXRfaW5zbihjb25zdCBzdHJ1Y3QgYnBmX2luc24gKmluc24sIHN0cnVjdCBydl9qaXRfY29u dGV4dCAqY3R4LAo+ICAgCj4gICAJCWlmIChpbnNuLT5zcmNfcmVnID09IEJQRl9QU0VVRE9fS0ZV TkNfQ0FMTCkgewo+ICAgCQkJY29uc3Qgc3RydWN0IGJ0Zl9mdW5jX21vZGVsICpmbTsKPiAtCQkJ aW50IGlkeDsKPiArCQkJaW50IGlkeCwgbmFyZ3M7Cj4gICAKPiAgIAkJCWZtID0gYnBmX2ppdF9m aW5kX2tmdW5jX21vZGVsKGN0eC0+cHJvZywgaW5zbik7Cj4gICAJCQlpZiAoIWZtKQo+ICAgCQkJ CXJldHVybiAtRUlOVkFMOwo+ICAgCj4gLQkJCWZvciAoaWR4ID0gMDsgaWR4IDwgZm0tPm5yX2Fy Z3M7IGlkeCsrKSB7Cj4gKwkJCW5hcmdzID0gbWluX3QoaW50LCBmbS0+bnJfYXJncywgTUFYX0JQ Rl9GVU5DX1JFR19BUkdTKTsKPiArCQkJZm9yIChpZHggPSAwOyBpZHggPCBuYXJnczsgaWR4Kysp IHsKPiAgIAkJCQl1OCByZWcgPSBicGZfdG9fcnZfcmVnKEJQRl9SRUdfMSArIGlkeCwgY3R4KTsK PiAgIAo+ICAgCQkJCWlmIChmbS0+YXJnX3NpemVbaWR4XSA9PSBzaXplb2YoaW50KSkKPiAgIAkJ CQkJZW1pdF9zZXh0dyhyZWcsIHJlZywgY3R4KTsKPiAgIAkJCX0KPiArCj4gKwkJCS8qIEJQRiBz dGFjayBhcmdzIC0+IFJJU0MtViBBQkk6IGFyZ3MgNi04IGluIEE1LUE3LCA5KyBhdCBTUCswICov Cj4gKwkJCWlmIChmbS0+bnJfYXJncyA+IE1BWF9CUEZfRlVOQ19SRUdfQVJHUykgewo+ICsJCQkJ aW50IG5fc3RhY2sgPSBmbS0+bnJfYXJncyAtIE1BWF9CUEZfRlVOQ19SRUdfQVJHUzsKPiArCQkJ CWludCBuX3JlZyA9IG1pbl90KGludCwgbl9zdGFjaywKPiArCQkJCQkJICBSVl9NQVhfUkVHX0FS R1MgLSBNQVhfQlBGX0ZVTkNfUkVHX0FSR1MpOwo+ICsKPiArCQkJCWZvciAoaWR4ID0gMDsgaWR4 IDwgbl9yZWc7IGlkeCsrKSB7Cj4gKwkJCQkJaW50IHN6ID0gZm0tPmFyZ19zaXplW01BWF9CUEZf RlVOQ19SRUdfQVJHUyArIGlkeF07Cj4gKwo+ICsJCQkJCWVtaXRfbGQoUlZfUkVHX0E1ICsgaWR4 LCBpZHggKiA4LCBSVl9SRUdfU1AsIGN0eCk7Cj4gKwkJCQkJaWYgKHN6ID09IHNpemVvZihpbnQp KQo+ICsJCQkJCQllbWl0X3NleHR3KFJWX1JFR19BNSArIGlkeCwgUlZfUkVHX0E1ICsgaWR4LCBj dHgpOwo+ICsJCQkJfQo+ICsKPiArCQkJCWZvciAoaWR4ID0gbl9yZWc7IGlkeCA8IG5fc3RhY2s7 IGlkeCsrKSB7Cj4gKwkJCQkJaW50IHN6ID0gZm0tPmFyZ19zaXplW01BWF9CUEZfRlVOQ19SRUdf QVJHUyArIGlkeF07Cj4gKwo+ICsJCQkJCWVtaXRfbGQoUlZfUkVHX1QxLCBpZHggKiA4LCBSVl9S RUdfU1AsIGN0eCk7Cj4gKwkJCQkJaWYgKHN6ID09IHNpemVvZihpbnQpKQo+ICsJCQkJCQllbWl0 X3NleHR3KFJWX1JFR19UMSwgUlZfUkVHX1QxLCBjdHgpOwo+ICsJCQkJCWVtaXRfc2QoUlZfUkVH X1NQLCAoaWR4IC0gbl9yZWcpICogOCwgUlZfUkVHX1QxLCBjdHgpOwo+ICsJCQkJfQo+ICsJCQl9 Cgpsb29rcyBhIGJpdCBjb21wbGljYXRlZCwgaG93IGFib3V0IHRoZSBmb2xsb3dpbmcgYWZ0ZXIg cmVkZWZpbmUgcmVnbWFwOgoKYGBgCmZvciAoaWR4ID0gMDsgaWR4IDwgZm0tPm5yX2FyZ3M7IGlk eCsrKSB7CiAgIGlmIChpZHggPCBSVl9NQVhfUkVHX0FSR1MpIHsKICAgICB1OCByZWcgPSBSVl9S RUdfQTAgKyBpZHg7CgogICAgIHNpZ25fZXh0ZW5kKHJlZywgcmVnLCB4eHgpCiAgIH0gZWxzZSB7 CiAgICAgbG9hZCBmcm9tIHN0YWNrIHRvIFQxCiAgICAgc2lnbl9leHRlbmQKICAgICByZXRvcmUg ZnJvbSBUMSB0byBvcmlnIHN0YWNrIHNsb3QKICAgfQp9CmBgYAoKPiAgIAkJfQo+ICAgCj4gICAJ CS8qIHJlc3RvcmUgVENDIHRvIFJWX1JFR19UQ0MgYmVmb3JlIGJwZjJicGYgY2FsbCAqLwo+IEBA IC0xODkxLDYgKzE5MTYsMjEgQEAgaW50IGJwZl9qaXRfZW1pdF9pbnNuKGNvbnN0IHN0cnVjdCBi cGZfaW5zbiAqaW5zbiwgc3RydWN0IHJ2X2ppdF9jb250ZXh0ICpjdHgsCj4gICAJY2FzZSBCUEZf TERYIHwgQlBGX01FTSB8IEJQRl9IOgo+ICAgCWNhc2UgQlBGX0xEWCB8IEJQRl9NRU0gfCBCUEZf VzoKPiAgIAljYXNlIEJQRl9MRFggfCBCUEZfTUVNIHwgQlBGX0RXOgo+ICsJCWlmIChpbnNuLT5z cmNfcmVnID09IEJQRl9SRUdfUEFSQU1TKSB7CgpwbHMgdXNlIGlzX3N0YWNrX2FyZ19sZHgvc3Qv c3R4IGluc3RlYWQuCgo+ICsJCQlpbnQgaWR4ID0gb2ZmIC8gOCAtIDE7Cj4gKwo+ICsJCQlpZiAo aXNfMTJiX2ludChpZHggKiA4KSkgewo+ICsJCQkJZW1pdF9sZHhfaW5zbihyZCwgaWR4ICogOCwg UlZfUkVHX0ZQLCBCUEZfU0laRShjb2RlKSwgZmFsc2UsIGN0eCk7Cj4gKwkJCX0gZWxzZSB7Cj4g KwkJCQllbWl0X2ltbShSVl9SRUdfVDEsIGlkeCAqIDgsIGN0eCk7Cj4gKwkJCQllbWl0X2FkZChS Vl9SRUdfVDEsIFJWX1JFR19UMSwgUlZfUkVHX0ZQLCBjdHgpOwo+ICsJCQkJZW1pdF9sZHhfaW5z bihyZCwgMCwgUlZfUkVHX1QxLCBCUEZfU0laRShjb2RlKSwgZmFsc2UsIGN0eCk7Cj4gKwkJCX0K PiArCQkJaWYgKEJQRl9TSVpFKGNvZGUpICE9IEJQRl9EVyAmJiBpbnNuX2lzX3pleHQoJmluc25b MV0pKQo+ICsJCQkJcmV0dXJuIDE7Cj4gKwkJCWJyZWFrOwoKVGhpcyBwaWVjZSBvZiBjb2RlIHdh cyByZWZhY3RvcmVkIG5vdCBsb25nIGFnby4gTGV0J3Mgc2VlIGlmIHdlIGNhbiAKbWVyZ2UgaXQg aW50byB0aGUgbG9naWMgYmVsb3cgb3IgZm9sZCBpdCBpbnRvIGVtaXRfbGR44oCUbGV0J3MgZ2l2 ZSBpdCBhIHRyeS4KCj4gKwkJfQo+ICsJCWZhbGx0aHJvdWdoOwo+ICAgCWNhc2UgQlBGX0xEWCB8 IEJQRl9QUk9CRV9NRU0gfCBCUEZfQjoKPiAgIAljYXNlIEJQRl9MRFggfCBCUEZfUFJPQkVfTUVN IHwgQlBGX0g6Cj4gICAJY2FzZSBCUEZfTERYIHwgQlBGX1BST0JFX01FTSB8IEJQRl9XOgo+IEBA IC0xOTM4LDYgKzE5NzgsMjAgQEAgaW50IGJwZl9qaXRfZW1pdF9pbnNuKGNvbnN0IHN0cnVjdCBi cGZfaW5zbiAqaW5zbiwgc3RydWN0IHJ2X2ppdF9jb250ZXh0ICpjdHgsCj4gICAJY2FzZSBCUEZf U1QgfCBCUEZfTUVNIHwgQlBGX0g6Cj4gICAJY2FzZSBCUEZfU1QgfCBCUEZfTUVNIHwgQlBGX1c6 Cj4gICAJY2FzZSBCUEZfU1QgfCBCUEZfTUVNIHwgQlBGX0RXOgo+ICsJCWlmIChpbnNuLT5kc3Rf cmVnID09IEJQRl9SRUdfUEFSQU1TKSB7Cj4gKwkJCWludCBpZHggPSAtb2ZmIC8gOCAtIDE7Cj4g Kwo+ICsJCQllbWl0X2ltbShSVl9SRUdfVDEsIGltbSwgY3R4KTsKPiArCQkJaWYgKGlzXzEyYl9p bnQoaWR4ICogOCkpIHsKPiArCQkJCWVtaXRfc3R4X2luc24oUlZfUkVHX1NQLCBpZHggKiA4LCBS Vl9SRUdfVDEsIEJQRl9TSVpFKGNvZGUpLCBjdHgpOwo+ICsJCQl9IGVsc2Ugewo+ICsJCQkJZW1p dF9pbW0oUlZfUkVHX1QyLCBpZHggKiA4LCBjdHgpOwo+ICsJCQkJZW1pdF9hZGQoUlZfUkVHX1Qy LCBSVl9SRUdfU1AsIFJWX1JFR19UMiwgY3R4KTsKPiArCQkJCWVtaXRfc3R4X2luc24oUlZfUkVH X1QyLCAwLCBSVl9SRUdfVDEsIEJQRl9TSVpFKGNvZGUpLCBjdHgpOwo+ICsJCQl9Cj4gKwkJCWJy ZWFrOwo+ICsJCX0KPiArCQlmYWxsdGhyb3VnaDsKCmRpdHRvCgo+ICAgCS8qIFNUIHwgUFJPQkVf TUVNMzI6ICooc2l6ZSAqKShkc3QgKyBSVl9SRUdfQVJFTkEgKyBvZmYpID0gaW1tICovCj4gICAJ Y2FzZSBCUEZfU1QgfCBCUEZfUFJPQkVfTUVNMzIgfCBCUEZfQjoKPiAgIAljYXNlIEJQRl9TVCB8 IEJQRl9QUk9CRV9NRU0zMiB8IEJQRl9IOgo+IEBAIC0xOTYwLDYgKzIwMTQsMTkgQEAgaW50IGJw Zl9qaXRfZW1pdF9pbnNuKGNvbnN0IHN0cnVjdCBicGZfaW5zbiAqaW5zbiwgc3RydWN0IHJ2X2pp dF9jb250ZXh0ICpjdHgsCj4gICAJY2FzZSBCUEZfU1RYIHwgQlBGX01FTSB8IEJQRl9IOgo+ICAg CWNhc2UgQlBGX1NUWCB8IEJQRl9NRU0gfCBCUEZfVzoKPiAgIAljYXNlIEJQRl9TVFggfCBCUEZf TUVNIHwgQlBGX0RXOgo+ICsJCWlmIChpbnNuLT5kc3RfcmVnID09IEJQRl9SRUdfUEFSQU1TKSB7 Cj4gKwkJCWludCBpZHggPSAtb2ZmIC8gOCAtIDE7Cj4gKwo+ICsJCQlpZiAoaXNfMTJiX2ludChp ZHggKiA4KSkgewo+ICsJCQkJZW1pdF9zdHhfaW5zbihSVl9SRUdfU1AsIGlkeCAqIDgsIHJzLCBC UEZfU0laRShjb2RlKSwgY3R4KTsKPiArCQkJfSBlbHNlIHsKPiArCQkJCWVtaXRfaW1tKFJWX1JF R19UMSwgaWR4ICogOCwgY3R4KTsKPiArCQkJCWVtaXRfYWRkKFJWX1JFR19UMSwgUlZfUkVHX1NQ LCBSVl9SRUdfVDEsIGN0eCk7Cj4gKwkJCQllbWl0X3N0eF9pbnNuKFJWX1JFR19UMSwgMCwgcnMs IEJQRl9TSVpFKGNvZGUpLCBjdHgpOwo+ICsJCQl9Cj4gKwkJCWJyZWFrOwo+ICsJCX0KPiArCQlm YWxsdGhyb3VnaDsKCmRpdHRvCgo+ICAgCS8qIFNUWCB8IFBST0JFX01FTTMyOiAqKHNpemUgKiko ZHN0ICsgUlZfUkVHX0FSRU5BICsgb2ZmKSA9IHNyYyAqLwo+ICAgCWNhc2UgQlBGX1NUWCB8IEJQ Rl9QUk9CRV9NRU0zMiB8IEJQRl9COgo+ICAgCWNhc2UgQlBGX1NUWCB8IEJQRl9QUk9CRV9NRU0z MiB8IEJQRl9IOgo+IEBAIC0yMDM2LDYgKzIxMDMsNyBAQCB2b2lkIGJwZl9qaXRfYnVpbGRfcHJv bG9ndWUoc3RydWN0IHJ2X2ppdF9jb250ZXh0ICpjdHgsIGJvb2wgaXNfc3VicHJvZykKPiAgIAo+ ICAgCXN0YWNrX2FkanVzdCA9IHJvdW5kX3VwKHN0YWNrX2FkanVzdCwgU1RBQ0tfQUxJR04pOwo+ ICAgCXN0YWNrX2FkanVzdCArPSBicGZfc3RhY2tfYWRqdXN0Owo+ICsJc3RhY2tfYWRqdXN0ICs9 IGN0eC0+c3RhY2tfYXJnX3NpemU7Cj4gICAKPiAgIAlzdG9yZV9vZmZzZXQgPSBzdGFja19hZGp1 c3QgLSA4Owo+ICAgCj4gQEAgLTIwOTMsNyArMjE2MSw3IEBAIHZvaWQgYnBmX2ppdF9idWlsZF9w cm9sb2d1ZShzdHJ1Y3QgcnZfaml0X2NvbnRleHQgKmN0eCwgYm9vbCBpc19zdWJwcm9nKQo+ICAg CWVtaXRfYWRkaShSVl9SRUdfRlAsIFJWX1JFR19TUCwgc3RhY2tfYWRqdXN0LCBjdHgpOwo+ICAg Cj4gICAJaWYgKGJwZl9zdGFja19hZGp1c3QpCj4gLQkJZW1pdF9hZGRpKFJWX1JFR19TNSwgUlZf UkVHX1NQLCBicGZfc3RhY2tfYWRqdXN0LCBjdHgpOwo+ICsJCWVtaXRfYWRkaShSVl9SRUdfUzUs IFJWX1JFR19TUCwgY3R4LT5zdGFja19hcmdfc2l6ZSArIGJwZl9zdGFja19hZGp1c3QsIGN0eCk7 Cj4gICAKPiAgIAljdHgtPnN0YWNrX3NpemUgPSBzdGFja19hZGp1c3Q7Cj4gICAKPiBAQCAtMjE3 MSwzICsyMjM5LDggQEAgYm9vbCBicGZfaml0X3N1cHBvcnRzX3RpbWVkX21heV9nb3RvKHZvaWQp Cj4gICB7Cj4gICAJcmV0dXJuIHRydWU7Cj4gICB9Cj4gKwo+ICtib29sIGJwZl9qaXRfc3VwcG9y dHNfc3RhY2tfYXJncyh2b2lkKQo+ICt7Cj4gKwlyZXR1cm4gdHJ1ZTsKPiArfQo+IGRpZmYgLS1n aXQgYS9hcmNoL3Jpc2N2L25ldC9icGZfaml0X2NvcmUuYyBiL2FyY2gvcmlzY3YvbmV0L2JwZl9q aXRfY29yZS5jCj4gaW5kZXggY2JmY2QyODdlYTE2Li44NDRhMGYzZTBmYTkgMTAwNjQ0Cj4gLS0t IGEvYXJjaC9yaXNjdi9uZXQvYnBmX2ppdF9jb3JlLmMKPiArKysgYi9hcmNoL3Jpc2N2L25ldC9i cGZfaml0X2NvcmUuYwo+IEBAIC03Miw2ICs3MiwxMCBAQCBzdHJ1Y3QgYnBmX3Byb2cgKmJwZl9p bnRfaml0X2NvbXBpbGUoc3RydWN0IGJwZl92ZXJpZmllcl9lbnYgKmVudiwgc3RydWN0IGJwZl9w cgo+ICAgCWN0eC0+YXJlbmFfdm1fc3RhcnQgPSBicGZfYXJlbmFfZ2V0X2tlcm5fdm1fc3RhcnQo cHJvZy0+YXV4LT5hcmVuYSk7Cj4gICAJY3R4LT51c2VyX3ZtX3N0YXJ0ID0gYnBmX2FyZW5hX2dl dF91c2VyX3ZtX3N0YXJ0KHByb2ctPmF1eC0+YXJlbmEpOwo+ICAgCWN0eC0+cHJvZyA9IHByb2c7 Cj4gKwo+ICsJY3R4LT5zdGFja19hcmdfc2l6ZSA9IHJvdW5kX3VwKGJwZl9vdXRfc3RhY2tfYXJn X2NudChlbnYsIHByb2cpICoKPiArCQkJCSAgICAgICBzaXplb2YodTY0KSwgU1RBQ0tfQUxJR04p OwoKSXQncyBub3QgdTY04oCUc2luY2UgZXZlcnkgc3RhY2sgc2xvdCBpcyBhbGlnbmVkIHRvIHRo ZSBwb2ludGVyIHNpemUgCihzaXplb2YobG9uZykpLCBJIHRoaW5rIHVzaW5nIDggaXMgZmluZS4K Cj4gKwo+ICAgCWN0eC0+b2Zmc2V0ID0ga3Z6YWxsb2Nfb2JqcyhpbnQsIHByb2ctPmxlbik7Cj4g ICAJaWYgKCFjdHgtPm9mZnNldCkKPiAgIAkJZ290byBvdXRfb2Zmc2V0Owo+IAoKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtcmlzY3YgbWFpbGlu ZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJh ZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1yaXNjdgo=