From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from out30-111.freemail.mail.aliyun.com (out30-111.freemail.mail.aliyun.com [115.124.30.111]) (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 E2ACB3939AF; Tue, 2 Jun 2026 11:18:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=115.124.30.111 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780399114; cv=none; b=s4wUwPEqsOaXukbbBF6LiLKkivSiGcuyQcAyCtfMxnmsMfYbW5Ih1BBcXz4nKPoCVhstEk3u7drA0ltBqZGy0pQgu0NCwaKLeDMD3vgDGraKlDi4dE/ggkwBiRWjFz0XHyLeccOIvTv6UYvIVmuZxNTR292Mmuewh8cG7Vt2LfA= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780399114; c=relaxed/simple; bh=ilFK4yQPZYLFYk0uM3eLL1YO5hEB0Sk0/m5Gv9HEqE4=; h=Message-ID:Date:MIME-Version:Subject:To:Cc:References:From: In-Reply-To:Content-Type; b=AGcIn7/WR/Pqhz+EEzctNc79LIr6gOufOuZBHwlCD4cWnsgKHnOyASgw0pziCUd03vBGXUdO7/y1eDB1vmpyG3J9Cc6jLexmQ6AmNEofmZTMf/uj9iF8uCnhPyDoh3LFM8SkfqezQzU2wdCLLiIpMrIdcb8CqmuMNgjc2UP3NAA= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.alibaba.com; spf=pass smtp.mailfrom=linux.alibaba.com; dkim=pass (1024-bit key) header.d=linux.alibaba.com header.i=@linux.alibaba.com header.b=YenA2L1N; arc=none smtp.client-ip=115.124.30.111 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.alibaba.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.alibaba.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linux.alibaba.com header.i=@linux.alibaba.com header.b="YenA2L1N" DKIM-Signature:v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.alibaba.com; s=default; t=1780399102; h=Message-ID:Date:MIME-Version:Subject:To:From:Content-Type; bh=ws7qGhlw3CmmKGFGVKopwlLd0gA4vT4eK0El0Pe0xPg=; b=YenA2L1NYn6iogApH/qarp7611ei7TRNWwJJJLiVXm/u5hm71iCKs6bT5/eQtSmJ3mMj0NHu/8NLp0SIa7pbRHqh0GJASQLChG+3f/axk+go0hUaDnmEFf/RV1gsL9ZDFO5PQ6EGGr0e/entKYkc2vLez745iW2JT7pm/3wpTQA= X-Alimail-AntiSpam:AC=PASS;BC=-1|-1;BR=01201311R311e4;CH=green;DM=||false|;DS=||;FP=0|-1|-1|-1|0|-1|-1|-1;HT=maildocker-contentspam011083073210;MF=xueshuai@linux.alibaba.com;NM=1;PH=DS;RN=34;SR=0;TI=SMTPD_---0X44Nt1W_1780399098; Received: from 30.100.154.88(mailfrom:xueshuai@linux.alibaba.com fp:SMTPD_---0X44Nt1W_1780399098 cluster:ay36) by smtp.aliyun-inc.com; Tue, 02 Jun 2026 19:18:20 +0800 Message-ID: <425ce2d4-bf35-4bff-8dc8-93093b8aaba2@linux.alibaba.com> Date: Tue, 2 Jun 2026 19:18:17 +0800 Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v2 2/8] riscv: stacktrace: Add frame record metadata To: Wang Han , Paul Walmsley , Palmer Dabbelt , Albert Ou Cc: Steven Rostedt , Alexandre Ghiti , Masami Hiramatsu , Mark Rutland , Catalin Marinas , Chen Pei , Andy Chiu , =?UTF-8?B?QmrDtnJuIFTDtnBlbA==?= , Deepak Gupta , Puranjay Mohan , Conor Dooley , Josh Poimboeuf , Jiri Kosina , Miroslav Benes , Petr Mladek , Joe Lawrence , Shuah Khan , Peter Zijlstra , Ingo Molnar , Arnaldo Carvalho de Melo , Namhyung Kim , oliver.yang@linux.alibaba.com, zhuo.song@linux.alibaba.com, jkchen@linux.alibaba.com, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, live-patching@vger.kernel.org, linux-kselftest@vger.kernel.org, linux-perf-users@vger.kernel.org References: <20260527123530.2593918-1-wanghan@linux.alibaba.com> <20260528082310.1994388-3-wanghan@linux.alibaba.com> From: Shuai Xue In-Reply-To: <20260528082310.1994388-3-wanghan@linux.alibaba.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit On 5/28/26 4:23 PM, Wang Han wrote: > Reliable frame-pointer unwinding needs an explicit way to identify > exception boundaries and the final entry frame. The existing unwinder > infers those boundaries from return addresses, which is too loose for a > future reliable unwinder. > > Add a small metadata frame record to pt_regs and initialize it on > exception entry, kernel thread fork, user fork, and early idle task > setup. The record uses a zero {fp, ra} sentinel plus a type field so a > later unwinder can distinguish a final user-to-kernel boundary from a > nested kernel pt_regs boundary. > > This follows the arm64 metadata frame-record model, adapted to the > RISC-V {fp, ra} frame record convention. > > The metadata is established at the RISC-V entry boundaries that need an > explicit unwind marker: > > * exception entry clears the metadata {fp, ra} pair and uses SPP > (or MPP in M-mode) to record whether the pt_regs frame is the final > user-to-kernel boundary or a nested kernel boundary; > * _start_kernel builds the init task's final metadata record, while > the secondary CPU path sets up s0 before smp_callin() so idle-task > unwinding does not inherit an undefined caller frame; > * copy_thread creates matching final metadata records for new kernel > and user tasks, and keeps s0 available for the frame-pointer chain; > * call_on_irq_stack still reserves an aligned stack slot, but links the > saved {fp, ra} with the raw frame-record size so s0 points at the > RISC-V frame record rather than past the alignment padding. > > These changes keep s0 reserved for the frame-pointer chain at task and > stack-switch boundaries. > > Signed-off-by: Wang Han > --- > arch/riscv/include/asm/ptrace.h | 9 ++++ > arch/riscv/include/asm/stacktrace/frame.h | 53 +++++++++++++++++++++++ > arch/riscv/kernel/asm-offsets.c | 4 ++ > arch/riscv/kernel/entry.S | 30 +++++++++++-- > arch/riscv/kernel/head.S | 23 ++++++++++ > arch/riscv/kernel/process.c | 31 ++++++++++++- > 6 files changed, 144 insertions(+), 6 deletions(-) > create mode 100644 arch/riscv/include/asm/stacktrace/frame.h > > diff --git a/arch/riscv/include/asm/ptrace.h b/arch/riscv/include/asm/ptrace.h > index addc8188152f..4b9b0f279214 100644 > --- a/arch/riscv/include/asm/ptrace.h > +++ b/arch/riscv/include/asm/ptrace.h > @@ -8,6 +8,7 @@ > > #include > #include > +#include > #include > > #ifndef __ASSEMBLER__ > @@ -53,6 +54,14 @@ struct pt_regs { > unsigned long cause; > /* a0 value before the syscall */ > unsigned long orig_a0; > + > + /* > + * This frame record is entirely zeroed on exception entry, allowing the > + * unwinder to identify exception boundaries. The type field encodes > + * whether the exception was taken from user (FINAL) or kernel (PT_REGS) > + * mode. > + */ > + struct frame_record_meta stackframe; > }; > > #define PTRACE_SYSEMU 0x1f > diff --git a/arch/riscv/include/asm/stacktrace/frame.h b/arch/riscv/include/asm/stacktrace/frame.h > new file mode 100644 > index 000000000000..5720a6c65fe8 > --- /dev/null > +++ b/arch/riscv/include/asm/stacktrace/frame.h > @@ -0,0 +1,53 @@ > +/* SPDX-License-Identifier: GPL-2.0-only */ > +#ifndef __ASM_RISCV_STACKTRACE_FRAME_H > +#define __ASM_RISCV_STACKTRACE_FRAME_H > + > +/* > + * See: arch/arm64/include/asm/stacktrace/frame.h for the reference > + * implementation. > + */ > + > +/* > + * - FRAME_META_TYPE_NONE > + * > + * This value is reserved. > + * > + * - FRAME_META_TYPE_FINAL > + * > + * The record is the last entry on the stack. > + * Unwinding should terminate successfully. > + * > + * - FRAME_META_TYPE_PT_REGS > + * > + * The record is embedded within a struct pt_regs, recording the registers at > + * an arbitrary point in time. > + * Unwinding should consume pt_regs::epc, followed by pt_regs::ra. > + * > + * Note: all other values are reserved and should result in unwinding > + * terminating with an error. > + */ > +#define FRAME_META_TYPE_NONE 0 > +#define FRAME_META_TYPE_FINAL 1 > +#define FRAME_META_TYPE_PT_REGS 2 > + > +#ifndef __ASSEMBLER__ > +/* > + * A standard RISC-V frame record. > + */ > +struct frame_record { > + unsigned long fp; > + unsigned long ra; > +}; > + > +/* > + * A metadata frame record indicating a special unwind. > + * The record::{fp,ra} fields must be zero to indicate the presence of > + * metadata. > + */ > +struct frame_record_meta { > + struct frame_record record; > + unsigned long type; > +}; > +#endif /* __ASSEMBLER__ */ > + > +#endif /* __ASM_RISCV_STACKTRACE_FRAME_H */ > diff --git a/arch/riscv/kernel/asm-offsets.c b/arch/riscv/kernel/asm-offsets.c > index af827448a609..8dfcb5a44bb8 100644 > --- a/arch/riscv/kernel/asm-offsets.c > +++ b/arch/riscv/kernel/asm-offsets.c > @@ -131,6 +131,9 @@ void asm_offsets(void) > OFFSET(PT_BADADDR, pt_regs, badaddr); > OFFSET(PT_CAUSE, pt_regs, cause); > > + DEFINE(S_STACKFRAME, offsetof(struct pt_regs, stackframe)); > + DEFINE(S_STACKFRAME_TYPE, offsetof(struct pt_regs, stackframe.type)); > + > OFFSET(SUSPEND_CONTEXT_REGS, suspend_context, regs); > > OFFSET(HIBERN_PBE_ADDR, pbe, address); > @@ -501,6 +504,7 @@ void asm_offsets(void) > OFFSET(SBI_HART_BOOT_STACK_PTR_OFFSET, sbi_hart_boot_data, stack_ptr); > > DEFINE(STACKFRAME_SIZE_ON_STACK, ALIGN(sizeof(struct stackframe), STACK_ALIGN)); > + DEFINE(STACKFRAME_RECORD_SIZE, sizeof(struct stackframe)); > OFFSET(STACKFRAME_FP, stackframe, fp); > OFFSET(STACKFRAME_RA, stackframe, ra); > #ifdef CONFIG_FUNCTION_TRACER > diff --git a/arch/riscv/kernel/entry.S b/arch/riscv/kernel/entry.S > index d011fb51c59a..9cae0e1eba1c 100644 > --- a/arch/riscv/kernel/entry.S > +++ b/arch/riscv/kernel/entry.S > @@ -11,6 +11,7 @@ > #include > #include > #include > +#include > #include > #include > #include > @@ -193,6 +194,27 @@ SYM_CODE_START(handle_exception) > REG_S s4, PT_CAUSE(sp) > REG_S s5, PT_TP(sp) > > + /* > + * Create a metadata frame record. The unwinder will use this to > + * identify and unwind exception boundaries. > + */ > + REG_S zero, (S_STACKFRAME + STACKFRAME_FP)(sp) /* stackframe.record.fp = 0 */ > + REG_S zero, (S_STACKFRAME + STACKFRAME_RA)(sp) /* stackframe.record.ra = 0 */ > +#ifdef CONFIG_RISCV_M_MODE > + li t0, SR_MPP > + and t0, s1, t0 > +#else > + andi t0, s1, SR_SPP > +#endif > + bnez t0, 1f > + li t0, FRAME_META_TYPE_FINAL > + j 2f > +1: > + li t0, FRAME_META_TYPE_PT_REGS > +2: > + REG_S t0, S_STACKFRAME_TYPE(sp) > + addi s0, sp, S_STACKFRAME + STACKFRAME_RECORD_SIZE > + One spot for symmetry (non-blocking, robustness only): handle_kernel_stack_overflow in entry.S allocates a full PT_SIZE_ON_STACK frame (including the new stackframe metadata fields) but, unlike .Lsave_context, never initialises stackframe.{record,type} nor repoints s0 at the metadata. Those three words are therefore left as whatever was on the overflow_stack. In practice this is currently harmless: handle_bad_stack() only calls __show_regs() (register dump, no unwind) followed by panic(), so the reliable unwinder never actually consumes that metadata today. So this is not an active bug — purely a robustness / symmetry gap. It would still be worth initialising it, because the moment someone adds a dump_stack() here, or another CPU NMI-backtraces this task, or a kdump image is walked offline via the frame-record chain, the garbage type byte would mislead the unwinder. Since the overflow path is by definition entered from kernel context, FRAME_META_TYPE_PT_REGS is the right type, and it has the nice property that the unwinder will resume from frame_pointer(regs)==regs->s0 (the pre-overflow s0 is already saved into PT_S0 by save_from_x6_to_x31), giving the pre-overflow call chain instead of a hard stop. > /* > * Set the scratch register to 0, so that if a recursive exception > * occurs, the exception vector knows it came from the kernel > @@ -357,8 +379,8 @@ ASM_NOKPROBE(handle_kernel_stack_overflow) > > SYM_CODE_START(ret_from_fork_kernel_asm) > call schedule_tail > - move a0, s1 /* fn_arg */ > - move a1, s0 /* fn */ > + move a0, s3 /* fn_arg */ > + move a1, s2 /* fn */ > move a2, sp /* pt_regs */ > call ret_from_fork_kernel > j ret_from_exception > @@ -383,7 +405,7 @@ SYM_FUNC_START(call_on_irq_stack) > addi sp, sp, -STACKFRAME_SIZE_ON_STACK > REG_S ra, STACKFRAME_RA(sp) > REG_S s0, STACKFRAME_FP(sp) > - addi s0, sp, STACKFRAME_SIZE_ON_STACK > + addi s0, sp, STACKFRAME_RECORD_SIZE > > /* Switch to the per-CPU shadow call stack */ > scs_save_current > @@ -399,7 +421,7 @@ SYM_FUNC_START(call_on_irq_stack) > scs_load_current > > /* Switch back to the thread stack and restore ra and s0 */ > - addi sp, s0, -STACKFRAME_SIZE_ON_STACK > + addi sp, s0, -STACKFRAME_RECORD_SIZE Worth calling out explicitly that this is more than a cosmetic refactor: on RV32 the previous code is actually wrong, and this hunk fixes it. STACKFRAME_SIZE_ON_STACK = ALIGN(sizeof(struct stackframe), STACK_ALIGN) STACKFRAME_RECORD_SIZE = sizeof(struct stackframe) RV64: sizeof(stackframe) == STACK_ALIGN == 16, so the two are equal and the old code happened to work. RV32: sizeof(stackframe) == 8 but STACK_ALIGN == 16, so the old "addi s0, sp, STACKFRAME_SIZE_ON_STACK" left s0 pointing 8 bytes past the saved {fp, ra} pair, into the alignment padding. An FP unwinder that derives the frame record from s0 (e.g. via "(struct stackframe *)s0 - 1" or fixed -8/-16(s0) loads) would then read garbage instead of the saved fp/ra at the IRQ-stack After the change s0 lands exactly at the end of the {fp, ra} record on both RV32 and RV64, while the aligned slot is still reserved by the unchanged "addi sp, sp, -STACKFRAME_SIZE_ON_STACK" / matching restore. Could you mention this in the v3 commit message? It's load-bearing context for anyone bisecting an RV32 unwind regression later, and it also justifies why the change is correct to apply ahead of the reliable unwinder rather than folded into it. > REG_L ra, STACKFRAME_RA(sp) > REG_L s0, STACKFRAME_FP(sp) > addi sp, sp, STACKFRAME_SIZE_ON_STACK > diff --git a/arch/riscv/kernel/head.S b/arch/riscv/kernel/head.S > index f6a8ca49e627..00e16a24f149 100644 > --- a/arch/riscv/kernel/head.S > +++ b/arch/riscv/kernel/head.S > @@ -14,6 +14,7 @@ > #include > #include > #include > +#include > #include > #include "efi-header.S" > > @@ -177,6 +178,14 @@ secondary_start_sbi: > REG_S a0, (a1) > 1: > #endif > + > + /* > + * Set up the frame pointer for the secondary idle task so reliable > + * stack unwinding terminates at the metadata frame in task_pt_regs(). > + * Without this, the first frame records can inherit an undefined caller > + * fp and unwind past smp_callin() into .Lsecondary_park. > + */ > + addi s0, sp, S_STACKFRAME + STACKFRAME_RECORD_SIZE > scs_load_current > call smp_callin > #endif /* CONFIG_SMP */ > @@ -305,6 +314,20 @@ SYM_CODE_START(_start_kernel) > la tp, init_task > la sp, init_thread_union + THREAD_SIZE > addi sp, sp, -PT_SIZE_ON_STACK > + > + /* > + * Set up a metadata frame record for the init task so that > + * the unwinder can identify the outermost frame by its > + * {fp, ra} = {0, 0} sentinel at the bottom of pt_regs. > + * fp/s0 points above the metadata record (RISC-V > + * convention). > + */ > + REG_S zero, (S_STACKFRAME + STACKFRAME_FP)(sp) > + REG_S zero, (S_STACKFRAME + STACKFRAME_RA)(sp) > + li t0, FRAME_META_TYPE_FINAL > + REG_S t0, S_STACKFRAME_TYPE(sp) > + addi s0, sp, S_STACKFRAME + STACKFRAME_RECORD_SIZE > + > #if defined(CONFIG_RISCV_SBI) && defined(CONFIG_RISCV_USER_CFI) > li a7, SBI_EXT_FWFT > li a6, SBI_EXT_FWFT_SET > diff --git a/arch/riscv/kernel/process.c b/arch/riscv/kernel/process.c > index b2df7f72241a..5212926b926b 100644 > --- a/arch/riscv/kernel/process.c > +++ b/arch/riscv/kernel/process.c > @@ -258,8 +258,23 @@ int copy_thread(struct task_struct *p, const struct kernel_clone_args *args) > /* Supervisor/Machine, irqs on: */ > childregs->status = SR_PP | SR_PIE; > > - p->thread.s[0] = (unsigned long)args->fn; > - p->thread.s[1] = (unsigned long)args->fn_arg; > + /* > + * Set up a metadata frame record at the bottom of the > + * stack for the unwinder. Use FRAME_META_TYPE_FINAL > + * since this is the outermost kernel entry for the new > + * task. The frame_record::{fp,ra} are already zero from > + * memset(). > + * > + * fp/s0 points above the metadata record (RISC-V > + * convention). fn and fn_arg are passed via s2/s3, > + * keeping s0 available for the frame pointer chain. > + */ > + childregs->stackframe.type = FRAME_META_TYPE_FINAL; > + > + p->thread.s[0] = (unsigned long)(&childregs->stackframe) > + + sizeof(struct frame_record); > + p->thread.s[2] = (unsigned long)args->fn; > + p->thread.s[3] = (unsigned long)args->fn_arg; > p->thread.ra = (unsigned long)ret_from_fork_kernel_asm; > } else { > /* allocate new shadow stack if needed. In case of CLONE_VM we have to */ > @@ -278,6 +293,18 @@ int copy_thread(struct task_struct *p, const struct kernel_clone_args *args) > if (clone_flags & CLONE_SETTLS) > childregs->tp = tls; > childregs->a0 = 0; /* Return value of fork() */ > + > + /* > + * Set up the unwind boundary: ensure the metadata > + * frame record has its {fp,ra} sentinel zeroed and > + * point fp/s0 above the metadata record. The type > + * field is inherited from the parent's pt_regs. > + */ > + childregs->stackframe.record.fp = 0; > + childregs->stackframe.record.ra = 0; This relies on the parent always entering kernel via handle_exception on a user->kernel boundary (which writes FRAME_META_TYPE_FINAL). That is true for fork()/clone() today, but: - The kernel-thread path right above explicitly assigns type = FINAL, so the user-thread path looks asymmetric and like a possible omission to anyone reading it cold. - A future caller invoking kernel_clone() from a nested-kernel context (parent pt_regs.type == PT_REGS) would silently produce a broken unwind boundary on the new task. Recommend explicitly setting it here too: childregs->stackframe.type = FRAME_META_TYPE_FINAL; Even if currently redundant, it is one assignment, costs nothing, is self-documenting, and fails closed instead of open. Thanks. Shuai 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 113F4CD6E4A for ; Tue, 2 Jun 2026 11:18:51 +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=yO9iiBV3I0db/y8lB69ucHSE4NooeMv9B0MgYzGUwzU=; b=IdoyIqR/ylhOov tBedjLn+V3wCfdToL9F6Jx64kKOaQVyxmNC0kykzUgd2hMRgCy3rOi9dEkSk35a6j9EoZjIi5i/pH 23zsWD+IySEc+dEg6TJMAEkfuM4wNA8Fz2KNCuhETKRPq0CpKVtz32Mxw7CW5AI5G2LKqtt7iiSrP gusLFn6w+lea9JLy2mtsD6xgrwAoQVK4aQe1ELDas4sAJpjmFDXcz4w6zVThNzLKGhGW4ZfLjxOam aM4ETQ8eTP8mnFLv5ahVJye13IVNeoBknc6MKeAuv+pAJfDN493taT+77xoM2lDGF10E7dkPEXhwU fVCgF312T1qmGco7NaoQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wUN8j-0000000CrYg-2sbU; Tue, 02 Jun 2026 11:18:33 +0000 Received: from out30-113.freemail.mail.aliyun.com ([115.124.30.113]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wUN8f-0000000CrXo-1haZ for linux-riscv@lists.infradead.org; Tue, 02 Jun 2026 11:18:32 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.alibaba.com; s=default; t=1780399101; h=Message-ID:Date:MIME-Version:Subject:To:From:Content-Type; bh=ws7qGhlw3CmmKGFGVKopwlLd0gA4vT4eK0El0Pe0xPg=; b=NgkbCOBhEMYiEQEgI4iriQPjpzz854R5wvuCQaicvquLgkV8gychHSEqaUrC0RReockrY7kOV9cNQDpqxWsh+qgfl0YnEfR29zFKUtndOHTHyXdWVI9fam5nyeXnrqbieLxd9eW2dQQmT2lZndDV3yfzFHeQc6jeGxGNOg6YE2M= X-Alimail-AntiSpam: AC=PASS;BC=-1|-1;BR=01201311R311e4;CH=green;DM=||false|;DS=||;FP=0|-1|-1|-1|0|-1|-1|-1;HT=maildocker-contentspam011083073210;MF=xueshuai@linux.alibaba.com;NM=1;PH=DS;RN=34;SR=0;TI=SMTPD_---0X44Nt1W_1780399098; Received: from 30.100.154.88(mailfrom:xueshuai@linux.alibaba.com fp:SMTPD_---0X44Nt1W_1780399098 cluster:ay36) by smtp.aliyun-inc.com; Tue, 02 Jun 2026 19:18:20 +0800 Message-ID: <425ce2d4-bf35-4bff-8dc8-93093b8aaba2@linux.alibaba.com> Date: Tue, 2 Jun 2026 19:18:17 +0800 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v2 2/8] riscv: stacktrace: Add frame record metadata To: Wang Han , Paul Walmsley , Palmer Dabbelt , Albert Ou Cc: Steven Rostedt , Alexandre Ghiti , Masami Hiramatsu , Mark Rutland , Catalin Marinas , Chen Pei , Andy Chiu , =?UTF-8?B?QmrDtnJuIFTDtnBlbA==?= , Deepak Gupta , Puranjay Mohan , Conor Dooley , Josh Poimboeuf , Jiri Kosina , Miroslav Benes , Petr Mladek , Joe Lawrence , Shuah Khan , Peter Zijlstra , Ingo Molnar , Arnaldo Carvalho de Melo , Namhyung Kim , oliver.yang@linux.alibaba.com, zhuo.song@linux.alibaba.com, jkchen@linux.alibaba.com, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, live-patching@vger.kernel.org, linux-kselftest@vger.kernel.org, linux-perf-users@vger.kernel.org References: <20260527123530.2593918-1-wanghan@linux.alibaba.com> <20260528082310.1994388-3-wanghan@linux.alibaba.com> From: Shuai Xue In-Reply-To: <20260528082310.1994388-3-wanghan@linux.alibaba.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.9.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260602_041830_528953_D2A3ADED X-CRM114-Status: GOOD ( 42.39 ) 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 CgpPbiA1LzI4LzI2IDQ6MjMgUE0sIFdhbmcgSGFuIHdyb3RlOgo+IFJlbGlhYmxlIGZyYW1lLXBv aW50ZXIgdW53aW5kaW5nIG5lZWRzIGFuIGV4cGxpY2l0IHdheSB0byBpZGVudGlmeQo+IGV4Y2Vw dGlvbiBib3VuZGFyaWVzIGFuZCB0aGUgZmluYWwgZW50cnkgZnJhbWUuIFRoZSBleGlzdGluZyB1 bndpbmRlcgo+IGluZmVycyB0aG9zZSBib3VuZGFyaWVzIGZyb20gcmV0dXJuIGFkZHJlc3Nlcywg d2hpY2ggaXMgdG9vIGxvb3NlIGZvciBhCj4gZnV0dXJlIHJlbGlhYmxlIHVud2luZGVyLgo+IAo+ IEFkZCBhIHNtYWxsIG1ldGFkYXRhIGZyYW1lIHJlY29yZCB0byBwdF9yZWdzIGFuZCBpbml0aWFs aXplIGl0IG9uCj4gZXhjZXB0aW9uIGVudHJ5LCBrZXJuZWwgdGhyZWFkIGZvcmssIHVzZXIgZm9y aywgYW5kIGVhcmx5IGlkbGUgdGFzawo+IHNldHVwLiBUaGUgcmVjb3JkIHVzZXMgYSB6ZXJvIHtm cCwgcmF9IHNlbnRpbmVsIHBsdXMgYSB0eXBlIGZpZWxkIHNvIGEKPiBsYXRlciB1bndpbmRlciBj YW4gZGlzdGluZ3Vpc2ggYSBmaW5hbCB1c2VyLXRvLWtlcm5lbCBib3VuZGFyeSBmcm9tIGEKPiBu ZXN0ZWQga2VybmVsIHB0X3JlZ3MgYm91bmRhcnkuCj4gCj4gVGhpcyBmb2xsb3dzIHRoZSBhcm02 NCBtZXRhZGF0YSBmcmFtZS1yZWNvcmQgbW9kZWwsIGFkYXB0ZWQgdG8gdGhlCj4gUklTQy1WIHtm cCwgcmF9IGZyYW1lIHJlY29yZCBjb252ZW50aW9uLgo+IAo+IFRoZSBtZXRhZGF0YSBpcyBlc3Rh Ymxpc2hlZCBhdCB0aGUgUklTQy1WIGVudHJ5IGJvdW5kYXJpZXMgdGhhdCBuZWVkIGFuCj4gZXhw bGljaXQgdW53aW5kIG1hcmtlcjoKPiAKPiAgICAqIGV4Y2VwdGlvbiBlbnRyeSBjbGVhcnMgdGhl IG1ldGFkYXRhIHtmcCwgcmF9IHBhaXIgYW5kIHVzZXMgU1BQCj4gICAgICAob3IgTVBQIGluIE0t bW9kZSkgdG8gcmVjb3JkIHdoZXRoZXIgdGhlIHB0X3JlZ3MgZnJhbWUgaXMgdGhlIGZpbmFsCj4g ICAgICB1c2VyLXRvLWtlcm5lbCBib3VuZGFyeSBvciBhIG5lc3RlZCBrZXJuZWwgYm91bmRhcnk7 Cj4gICAgKiBfc3RhcnRfa2VybmVsIGJ1aWxkcyB0aGUgaW5pdCB0YXNrJ3MgZmluYWwgbWV0YWRh dGEgcmVjb3JkLCB3aGlsZQo+ICAgICAgdGhlIHNlY29uZGFyeSBDUFUgcGF0aCBzZXRzIHVwIHMw IGJlZm9yZSBzbXBfY2FsbGluKCkgc28gaWRsZS10YXNrCj4gICAgICB1bndpbmRpbmcgZG9lcyBu b3QgaW5oZXJpdCBhbiB1bmRlZmluZWQgY2FsbGVyIGZyYW1lOwo+ICAgICogY29weV90aHJlYWQg Y3JlYXRlcyBtYXRjaGluZyBmaW5hbCBtZXRhZGF0YSByZWNvcmRzIGZvciBuZXcga2VybmVsCj4g ICAgICBhbmQgdXNlciB0YXNrcywgYW5kIGtlZXBzIHMwIGF2YWlsYWJsZSBmb3IgdGhlIGZyYW1l LXBvaW50ZXIgY2hhaW47Cj4gICAgKiBjYWxsX29uX2lycV9zdGFjayBzdGlsbCByZXNlcnZlcyBh biBhbGlnbmVkIHN0YWNrIHNsb3QsIGJ1dCBsaW5rcyB0aGUKPiAgICAgIHNhdmVkIHtmcCwgcmF9 IHdpdGggdGhlIHJhdyBmcmFtZS1yZWNvcmQgc2l6ZSBzbyBzMCBwb2ludHMgYXQgdGhlCj4gICAg ICBSSVNDLVYgZnJhbWUgcmVjb3JkIHJhdGhlciB0aGFuIHBhc3QgdGhlIGFsaWdubWVudCBwYWRk aW5nLgo+IAo+IFRoZXNlIGNoYW5nZXMga2VlcCBzMCByZXNlcnZlZCBmb3IgdGhlIGZyYW1lLXBv aW50ZXIgY2hhaW4gYXQgdGFzayBhbmQKPiBzdGFjay1zd2l0Y2ggYm91bmRhcmllcy4KPiAKPiBT aWduZWQtb2ZmLWJ5OiBXYW5nIEhhbiA8d2FuZ2hhbkBsaW51eC5hbGliYWJhLmNvbT4KPiAtLS0K PiAgIGFyY2gvcmlzY3YvaW5jbHVkZS9hc20vcHRyYWNlLmggICAgICAgICAgIHwgIDkgKysrKwo+ ICAgYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9zdGFja3RyYWNlL2ZyYW1lLmggfCA1MyArKysrKysr KysrKysrKysrKysrKysrKwo+ICAgYXJjaC9yaXNjdi9rZXJuZWwvYXNtLW9mZnNldHMuYyAgICAg ICAgICAgfCAgNCArKwo+ICAgYXJjaC9yaXNjdi9rZXJuZWwvZW50cnkuUyAgICAgICAgICAgICAg ICAgfCAzMCArKysrKysrKysrKy0tCj4gICBhcmNoL3Jpc2N2L2tlcm5lbC9oZWFkLlMgICAgICAg ICAgICAgICAgICB8IDIzICsrKysrKysrKysKPiAgIGFyY2gvcmlzY3Yva2VybmVsL3Byb2Nlc3Mu YyAgICAgICAgICAgICAgIHwgMzEgKysrKysrKysrKysrLQo+ICAgNiBmaWxlcyBjaGFuZ2VkLCAx NDQgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkKPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBh cmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3N0YWNrdHJhY2UvZnJhbWUuaAo+IAo+IGRpZmYgLS1naXQg YS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3B0cmFjZS5oIGIvYXJjaC9yaXNjdi9pbmNsdWRlL2Fz bS9wdHJhY2UuaAo+IGluZGV4IGFkZGM4MTg4MTUyZi4uNGI5YjBmMjc5MjE0IDEwMDY0NAo+IC0t LSBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vcHRyYWNlLmgKPiArKysgYi9hcmNoL3Jpc2N2L2lu Y2x1ZGUvYXNtL3B0cmFjZS5oCj4gQEAgLTgsNiArOCw3IEBACj4gICAKPiAgICNpbmNsdWRlIDx1 YXBpL2FzbS9wdHJhY2UuaD4KPiAgICNpbmNsdWRlIDxhc20vY3NyLmg+Cj4gKyNpbmNsdWRlIDxh c20vc3RhY2t0cmFjZS9mcmFtZS5oPgo+ICAgI2luY2x1ZGUgPGxpbnV4L2NvbXBpbGVyLmg+Cj4g ICAKPiAgICNpZm5kZWYgX19BU1NFTUJMRVJfXwo+IEBAIC01Myw2ICs1NCwxNCBAQCBzdHJ1Y3Qg cHRfcmVncyB7Cj4gICAJdW5zaWduZWQgbG9uZyBjYXVzZTsKPiAgIAkvKiBhMCB2YWx1ZSBiZWZv cmUgdGhlIHN5c2NhbGwgKi8KPiAgIAl1bnNpZ25lZCBsb25nIG9yaWdfYTA7Cj4gKwo+ICsJLyoK PiArCSAqIFRoaXMgZnJhbWUgcmVjb3JkIGlzIGVudGlyZWx5IHplcm9lZCBvbiBleGNlcHRpb24g ZW50cnksIGFsbG93aW5nIHRoZQo+ICsJICogdW53aW5kZXIgdG8gaWRlbnRpZnkgZXhjZXB0aW9u IGJvdW5kYXJpZXMuIFRoZSB0eXBlIGZpZWxkIGVuY29kZXMKPiArCSAqIHdoZXRoZXIgdGhlIGV4 Y2VwdGlvbiB3YXMgdGFrZW4gZnJvbSB1c2VyIChGSU5BTCkgb3Iga2VybmVsIChQVF9SRUdTKQo+ ICsJICogbW9kZS4KPiArCSAqLwo+ICsJc3RydWN0IGZyYW1lX3JlY29yZF9tZXRhIHN0YWNrZnJh bWU7Cj4gICB9Owo+ICAgCj4gICAjZGVmaW5lIFBUUkFDRV9TWVNFTVUJCQkweDFmCj4gZGlmZiAt LWdpdCBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vc3RhY2t0cmFjZS9mcmFtZS5oIGIvYXJjaC9y aXNjdi9pbmNsdWRlL2FzbS9zdGFja3RyYWNlL2ZyYW1lLmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0 NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uNTcyMGE2YzY1ZmU4Cj4gLS0tIC9kZXYvbnVsbAo+ICsr KyBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vc3RhY2t0cmFjZS9mcmFtZS5oCj4gQEAgLTAsMCAr MSw1MyBAQAo+ICsvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5ICovCj4g KyNpZm5kZWYgX19BU01fUklTQ1ZfU1RBQ0tUUkFDRV9GUkFNRV9ICj4gKyNkZWZpbmUgX19BU01f UklTQ1ZfU1RBQ0tUUkFDRV9GUkFNRV9ICj4gKwo+ICsvKgo+ICsgKiBTZWU6IGFyY2gvYXJtNjQv aW5jbHVkZS9hc20vc3RhY2t0cmFjZS9mcmFtZS5oIGZvciB0aGUgcmVmZXJlbmNlCj4gKyAqIGlt cGxlbWVudGF0aW9uLgo+ICsgKi8KPiArCj4gKy8qCj4gKyAqIC0gRlJBTUVfTUVUQV9UWVBFX05P TkUKPiArICoKPiArICogICBUaGlzIHZhbHVlIGlzIHJlc2VydmVkLgo+ICsgKgo+ICsgKiAtIEZS QU1FX01FVEFfVFlQRV9GSU5BTAo+ICsgKgo+ICsgKiAgIFRoZSByZWNvcmQgaXMgdGhlIGxhc3Qg ZW50cnkgb24gdGhlIHN0YWNrLgo+ICsgKiAgIFVud2luZGluZyBzaG91bGQgdGVybWluYXRlIHN1 Y2Nlc3NmdWxseS4KPiArICoKPiArICogLSBGUkFNRV9NRVRBX1RZUEVfUFRfUkVHUwo+ICsgKgo+ ICsgKiAgIFRoZSByZWNvcmQgaXMgZW1iZWRkZWQgd2l0aGluIGEgc3RydWN0IHB0X3JlZ3MsIHJl Y29yZGluZyB0aGUgcmVnaXN0ZXJzIGF0Cj4gKyAqICAgYW4gYXJiaXRyYXJ5IHBvaW50IGluIHRp bWUuCj4gKyAqICAgVW53aW5kaW5nIHNob3VsZCBjb25zdW1lIHB0X3JlZ3M6OmVwYywgZm9sbG93 ZWQgYnkgcHRfcmVnczo6cmEuCj4gKyAqCj4gKyAqIE5vdGU6IGFsbCBvdGhlciB2YWx1ZXMgYXJl IHJlc2VydmVkIGFuZCBzaG91bGQgcmVzdWx0IGluIHVud2luZGluZwo+ICsgKiB0ZXJtaW5hdGlu ZyB3aXRoIGFuIGVycm9yLgo+ICsgKi8KPiArI2RlZmluZSBGUkFNRV9NRVRBX1RZUEVfTk9ORQkJ MAo+ICsjZGVmaW5lIEZSQU1FX01FVEFfVFlQRV9GSU5BTAkJMQo+ICsjZGVmaW5lIEZSQU1FX01F VEFfVFlQRV9QVF9SRUdTCQkyCj4gKwo+ICsjaWZuZGVmIF9fQVNTRU1CTEVSX18KPiArLyoKPiAr ICogQSBzdGFuZGFyZCBSSVNDLVYgZnJhbWUgcmVjb3JkLgo+ICsgKi8KPiArc3RydWN0IGZyYW1l X3JlY29yZCB7Cj4gKwl1bnNpZ25lZCBsb25nIGZwOwo+ICsJdW5zaWduZWQgbG9uZyByYTsKPiAr fTsKPiArCj4gKy8qCj4gKyAqIEEgbWV0YWRhdGEgZnJhbWUgcmVjb3JkIGluZGljYXRpbmcgYSBz cGVjaWFsIHVud2luZC4KPiArICogVGhlIHJlY29yZDo6e2ZwLHJhfSBmaWVsZHMgbXVzdCBiZSB6 ZXJvIHRvIGluZGljYXRlIHRoZSBwcmVzZW5jZSBvZgo+ICsgKiBtZXRhZGF0YS4KPiArICovCj4g K3N0cnVjdCBmcmFtZV9yZWNvcmRfbWV0YSB7Cj4gKwlzdHJ1Y3QgZnJhbWVfcmVjb3JkIHJlY29y ZDsKPiArCXVuc2lnbmVkIGxvbmcgdHlwZTsKPiArfTsKPiArI2VuZGlmIC8qIF9fQVNTRU1CTEVS X18gKi8KPiArCj4gKyNlbmRpZiAvKiBfX0FTTV9SSVNDVl9TVEFDS1RSQUNFX0ZSQU1FX0ggKi8K PiBkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJuZWwvYXNtLW9mZnNldHMuYyBiL2FyY2gvcmlz Y3Yva2VybmVsL2FzbS1vZmZzZXRzLmMKPiBpbmRleCBhZjgyNzQ0OGE2MDkuLjhkZmNiNWE0NGJi OCAxMDA2NDQKPiAtLS0gYS9hcmNoL3Jpc2N2L2tlcm5lbC9hc20tb2Zmc2V0cy5jCj4gKysrIGIv YXJjaC9yaXNjdi9rZXJuZWwvYXNtLW9mZnNldHMuYwo+IEBAIC0xMzEsNiArMTMxLDkgQEAgdm9p ZCBhc21fb2Zmc2V0cyh2b2lkKQo+ICAgCU9GRlNFVChQVF9CQURBRERSLCBwdF9yZWdzLCBiYWRh ZGRyKTsKPiAgIAlPRkZTRVQoUFRfQ0FVU0UsIHB0X3JlZ3MsIGNhdXNlKTsKPiAgIAo+ICsJREVG SU5FKFNfU1RBQ0tGUkFNRSwJCW9mZnNldG9mKHN0cnVjdCBwdF9yZWdzLCBzdGFja2ZyYW1lKSk7 Cj4gKwlERUZJTkUoU19TVEFDS0ZSQU1FX1RZUEUsCW9mZnNldG9mKHN0cnVjdCBwdF9yZWdzLCBz dGFja2ZyYW1lLnR5cGUpKTsKPiArCj4gICAJT0ZGU0VUKFNVU1BFTkRfQ09OVEVYVF9SRUdTLCBz dXNwZW5kX2NvbnRleHQsIHJlZ3MpOwo+ICAgCj4gICAJT0ZGU0VUKEhJQkVSTl9QQkVfQUREUiwg cGJlLCBhZGRyZXNzKTsKPiBAQCAtNTAxLDYgKzUwNCw3IEBAIHZvaWQgYXNtX29mZnNldHModm9p ZCkKPiAgIAlPRkZTRVQoU0JJX0hBUlRfQk9PVF9TVEFDS19QVFJfT0ZGU0VULCBzYmlfaGFydF9i b290X2RhdGEsIHN0YWNrX3B0cik7Cj4gICAKPiAgIAlERUZJTkUoU1RBQ0tGUkFNRV9TSVpFX09O X1NUQUNLLCBBTElHTihzaXplb2Yoc3RydWN0IHN0YWNrZnJhbWUpLCBTVEFDS19BTElHTikpOwo+ ICsJREVGSU5FKFNUQUNLRlJBTUVfUkVDT1JEX1NJWkUsIHNpemVvZihzdHJ1Y3Qgc3RhY2tmcmFt ZSkpOwo+ICAgCU9GRlNFVChTVEFDS0ZSQU1FX0ZQLCBzdGFja2ZyYW1lLCBmcCk7Cj4gICAJT0ZG U0VUKFNUQUNLRlJBTUVfUkEsIHN0YWNrZnJhbWUsIHJhKTsKPiAgICNpZmRlZiBDT05GSUdfRlVO Q1RJT05fVFJBQ0VSCj4gZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3Yva2VybmVsL2VudHJ5LlMgYi9h cmNoL3Jpc2N2L2tlcm5lbC9lbnRyeS5TCj4gaW5kZXggZDAxMWZiNTFjNTlhLi45Y2FlMGUxZWJh MWMgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9yaXNjdi9rZXJuZWwvZW50cnkuUwo+ICsrKyBiL2FyY2gv cmlzY3Yva2VybmVsL2VudHJ5LlMKPiBAQCAtMTEsNiArMTEsNyBAQAo+ICAgI2luY2x1ZGUgPGFz bS9hc20uaD4KPiAgICNpbmNsdWRlIDxhc20vY3NyLmg+Cj4gICAjaW5jbHVkZSA8YXNtL3Njcy5o Pgo+ICsjaW5jbHVkZSA8YXNtL3N0YWNrdHJhY2UvZnJhbWUuaD4KPiAgICNpbmNsdWRlIDxhc20v dW5pc3RkLmg+Cj4gICAjaW5jbHVkZSA8YXNtL3BhZ2UuaD4KPiAgICNpbmNsdWRlIDxhc20vdGhy ZWFkX2luZm8uaD4KPiBAQCAtMTkzLDYgKzE5NCwyNyBAQCBTWU1fQ09ERV9TVEFSVChoYW5kbGVf ZXhjZXB0aW9uKQo+ICAgCVJFR19TIHM0LCBQVF9DQVVTRShzcCkKPiAgIAlSRUdfUyBzNSwgUFRf VFAoc3ApCj4gICAKPiArCS8qCj4gKwkgKiBDcmVhdGUgYSBtZXRhZGF0YSBmcmFtZSByZWNvcmQu IFRoZSB1bndpbmRlciB3aWxsIHVzZSB0aGlzIHRvCj4gKwkgKiBpZGVudGlmeSBhbmQgdW53aW5k IGV4Y2VwdGlvbiBib3VuZGFyaWVzLgo+ICsJICovCj4gKwlSRUdfUyB6ZXJvLCAoU19TVEFDS0ZS QU1FICsgU1RBQ0tGUkFNRV9GUCkoc3ApIC8qIHN0YWNrZnJhbWUucmVjb3JkLmZwID0gMCAqLwo+ ICsJUkVHX1MgemVybywgKFNfU1RBQ0tGUkFNRSArIFNUQUNLRlJBTUVfUkEpKHNwKSAvKiBzdGFj a2ZyYW1lLnJlY29yZC5yYSA9IDAgKi8KPiArI2lmZGVmIENPTkZJR19SSVNDVl9NX01PREUKPiAr CWxpIHQwLCBTUl9NUFAKPiArCWFuZCB0MCwgczEsIHQwCj4gKyNlbHNlCj4gKwlhbmRpIHQwLCBz MSwgU1JfU1BQCj4gKyNlbmRpZgo+ICsJYm5leiB0MCwgMWYKPiArCWxpIHQwLCBGUkFNRV9NRVRB X1RZUEVfRklOQUwKPiArCWogMmYKPiArMToKPiArCWxpIHQwLCBGUkFNRV9NRVRBX1RZUEVfUFRf UkVHUwo+ICsyOgo+ICsJUkVHX1MgdDAsIFNfU1RBQ0tGUkFNRV9UWVBFKHNwKQo+ICsJYWRkaSBz MCwgc3AsIFNfU1RBQ0tGUkFNRSArIFNUQUNLRlJBTUVfUkVDT1JEX1NJWkUKPiArCgpPbmUgc3Bv dCBmb3Igc3ltbWV0cnkgKG5vbi1ibG9ja2luZywgcm9idXN0bmVzcyBvbmx5KToKCmhhbmRsZV9r ZXJuZWxfc3RhY2tfb3ZlcmZsb3cgaW4gZW50cnkuUyBhbGxvY2F0ZXMgYSBmdWxsClBUX1NJWkVf T05fU1RBQ0sgZnJhbWUgKGluY2x1ZGluZyB0aGUgbmV3IHN0YWNrZnJhbWUgbWV0YWRhdGEgZmll bGRzKQpidXQsIHVubGlrZSAuTHNhdmVfY29udGV4dCwgbmV2ZXIgaW5pdGlhbGlzZXMgc3RhY2tm cmFtZS57cmVjb3JkLHR5cGV9Cm5vciByZXBvaW50cyBzMCBhdCB0aGUgbWV0YWRhdGEuIFRob3Nl IHRocmVlIHdvcmRzIGFyZSB0aGVyZWZvcmUgbGVmdAphcyB3aGF0ZXZlciB3YXMgb24gdGhlIG92 ZXJmbG93X3N0YWNrLgoKSW4gcHJhY3RpY2UgdGhpcyBpcyBjdXJyZW50bHkgaGFybWxlc3M6IGhh bmRsZV9iYWRfc3RhY2soKSBvbmx5IGNhbGxzCl9fc2hvd19yZWdzKCkgKHJlZ2lzdGVyIGR1bXAs IG5vIHVud2luZCkgZm9sbG93ZWQgYnkgcGFuaWMoKSwgc28gdGhlCnJlbGlhYmxlIHVud2luZGVy IG5ldmVyIGFjdHVhbGx5IGNvbnN1bWVzIHRoYXQgbWV0YWRhdGEgdG9kYXkuIFNvIHRoaXMKaXMg bm90IGFuIGFjdGl2ZSBidWcg4oCUIHB1cmVseSBhIHJvYnVzdG5lc3MgLyBzeW1tZXRyeSBnYXAu CgpJdCB3b3VsZCBzdGlsbCBiZSB3b3J0aCBpbml0aWFsaXNpbmcgaXQsIGJlY2F1c2UgdGhlIG1v bWVudCBzb21lb25lCmFkZHMgYSBkdW1wX3N0YWNrKCkgaGVyZSwgb3IgYW5vdGhlciBDUFUgTk1J LWJhY2t0cmFjZXMgdGhpcyB0YXNrLCBvciBhCmtkdW1wIGltYWdlIGlzIHdhbGtlZCBvZmZsaW5l IHZpYSB0aGUgZnJhbWUtcmVjb3JkIGNoYWluLCB0aGUgZ2FyYmFnZQp0eXBlIGJ5dGUgd291bGQg bWlzbGVhZCB0aGUgdW53aW5kZXIuIFNpbmNlIHRoZSBvdmVyZmxvdyBwYXRoIGlzIGJ5CmRlZmlu aXRpb24gZW50ZXJlZCBmcm9tIGtlcm5lbCBjb250ZXh0LCBGUkFNRV9NRVRBX1RZUEVfUFRfUkVH UyBpcyB0aGUKcmlnaHQgdHlwZSwgYW5kIGl0IGhhcyB0aGUgbmljZSBwcm9wZXJ0eSB0aGF0IHRo ZSB1bndpbmRlciB3aWxsIHJlc3VtZQpmcm9tIGZyYW1lX3BvaW50ZXIocmVncyk9PXJlZ3MtPnMw ICh0aGUgcHJlLW92ZXJmbG93IHMwIGlzIGFscmVhZHkKc2F2ZWQgaW50byBQVF9TMCBieSBzYXZl X2Zyb21feDZfdG9feDMxKSwgZ2l2aW5nIHRoZSBwcmUtb3ZlcmZsb3cgY2FsbApjaGFpbiBpbnN0 ZWFkIG9mIGEgaGFyZCBzdG9wLgoKCj4gICAJLyoKPiAgIAkgKiBTZXQgdGhlIHNjcmF0Y2ggcmVn aXN0ZXIgdG8gMCwgc28gdGhhdCBpZiBhIHJlY3Vyc2l2ZSBleGNlcHRpb24KPiAgIAkgKiBvY2N1 cnMsIHRoZSBleGNlcHRpb24gdmVjdG9yIGtub3dzIGl0IGNhbWUgZnJvbSB0aGUga2VybmVsCj4g QEAgLTM1Nyw4ICszNzksOCBAQCBBU01fTk9LUFJPQkUoaGFuZGxlX2tlcm5lbF9zdGFja19vdmVy ZmxvdykKPiAgIAo+ICAgU1lNX0NPREVfU1RBUlQocmV0X2Zyb21fZm9ya19rZXJuZWxfYXNtKQo+ ICAgCWNhbGwgc2NoZWR1bGVfdGFpbAo+IC0JbW92ZSBhMCwgczEgLyogZm5fYXJnICovCj4gLQlt b3ZlIGExLCBzMCAvKiBmbiAqLwo+ICsJbW92ZSBhMCwgczMgLyogZm5fYXJnICovCj4gKwltb3Zl IGExLCBzMiAvKiBmbiAqLwo+ICAgCW1vdmUgYTIsIHNwIC8qIHB0X3JlZ3MgKi8KPiAgIAljYWxs IHJldF9mcm9tX2Zvcmtfa2VybmVsCj4gICAJaiByZXRfZnJvbV9leGNlcHRpb24KPiBAQCAtMzgz LDcgKzQwNSw3IEBAIFNZTV9GVU5DX1NUQVJUKGNhbGxfb25faXJxX3N0YWNrKQo+ICAgCWFkZGkJ c3AsIHNwLCAtU1RBQ0tGUkFNRV9TSVpFX09OX1NUQUNLCj4gICAJUkVHX1MJcmEsIFNUQUNLRlJB TUVfUkEoc3ApCj4gICAJUkVHX1MJczAsIFNUQUNLRlJBTUVfRlAoc3ApCj4gLQlhZGRpCXMwLCBz cCwgU1RBQ0tGUkFNRV9TSVpFX09OX1NUQUNLCj4gKwlhZGRpCXMwLCBzcCwgU1RBQ0tGUkFNRV9S RUNPUkRfU0laRQo+ICAgCj4gICAJLyogU3dpdGNoIHRvIHRoZSBwZXItQ1BVIHNoYWRvdyBjYWxs IHN0YWNrICovCj4gICAJc2NzX3NhdmVfY3VycmVudAo+IEBAIC0zOTksNyArNDIxLDcgQEAgU1lN X0ZVTkNfU1RBUlQoY2FsbF9vbl9pcnFfc3RhY2spCj4gICAJc2NzX2xvYWRfY3VycmVudAo+ICAg Cj4gICAJLyogU3dpdGNoIGJhY2sgdG8gdGhlIHRocmVhZCBzdGFjayBhbmQgcmVzdG9yZSByYSBh bmQgczAgKi8KPiAtCWFkZGkJc3AsIHMwLCAtU1RBQ0tGUkFNRV9TSVpFX09OX1NUQUNLCj4gKwlh ZGRpCXNwLCBzMCwgLVNUQUNLRlJBTUVfUkVDT1JEX1NJWkUKCldvcnRoIGNhbGxpbmcgb3V0IGV4 cGxpY2l0bHkgdGhhdCB0aGlzIGlzIG1vcmUgdGhhbiBhIGNvc21ldGljIHJlZmFjdG9yOgpvbiBS VjMyIHRoZSBwcmV2aW91cyBjb2RlIGlzIGFjdHVhbGx5IHdyb25nLCBhbmQgdGhpcyBodW5rIGZp eGVzIGl0LgoKICAgU1RBQ0tGUkFNRV9TSVpFX09OX1NUQUNLID0gQUxJR04oc2l6ZW9mKHN0cnVj dCBzdGFja2ZyYW1lKSwgU1RBQ0tfQUxJR04pCiAgIFNUQUNLRlJBTUVfUkVDT1JEX1NJWkUgICA9 IHNpemVvZihzdHJ1Y3Qgc3RhY2tmcmFtZSkKCiAgIFJWNjQ6IHNpemVvZihzdGFja2ZyYW1lKSA9 PSBTVEFDS19BTElHTiA9PSAxNiwgc28gdGhlIHR3byBhcmUgZXF1YWwKICAgICAgICAgYW5kIHRo ZSBvbGQgY29kZSBoYXBwZW5lZCB0byB3b3JrLgogICBSVjMyOiBzaXplb2Yoc3RhY2tmcmFtZSkg PT0gOCBidXQgU1RBQ0tfQUxJR04gPT0gMTYsIHNvIHRoZSBvbGQKICAgICAgICAgImFkZGkgczAs IHNwLCBTVEFDS0ZSQU1FX1NJWkVfT05fU1RBQ0siIGxlZnQgczAgcG9pbnRpbmcgOCBieXRlcwog ICAgICAgICBwYXN0IHRoZSBzYXZlZCB7ZnAsIHJhfSBwYWlyLCBpbnRvIHRoZSBhbGlnbm1lbnQg cGFkZGluZy4gQW4gRlAKICAgICAgICAgdW53aW5kZXIgdGhhdCBkZXJpdmVzIHRoZSBmcmFtZSBy ZWNvcmQgZnJvbSBzMCAoZS5nLiB2aWEKICAgICAgICAgIihzdHJ1Y3Qgc3RhY2tmcmFtZSAqKXMw IC0gMSIgb3IgZml4ZWQgLTgvLTE2KHMwKSBsb2Fkcykgd291bGQKICAgICAgICAgdGhlbiByZWFk IGdhcmJhZ2UgaW5zdGVhZCBvZiB0aGUgc2F2ZWQgZnAvcmEgYXQgdGhlIElSUS1zdGFjawoKQWZ0 ZXIgdGhlIGNoYW5nZSBzMCBsYW5kcyBleGFjdGx5IGF0IHRoZSBlbmQgb2YgdGhlIHtmcCwgcmF9 IHJlY29yZCBvbgpib3RoIFJWMzIgYW5kIFJWNjQsIHdoaWxlIHRoZSBhbGlnbmVkIHNsb3QgaXMg c3RpbGwgcmVzZXJ2ZWQgYnkgdGhlCnVuY2hhbmdlZCAiYWRkaSBzcCwgc3AsIC1TVEFDS0ZSQU1F X1NJWkVfT05fU1RBQ0siIC8gbWF0Y2hpbmcgcmVzdG9yZS4KCkNvdWxkIHlvdSBtZW50aW9uIHRo aXMgaW4gdGhlIHYzIGNvbW1pdCBtZXNzYWdlPyBJdCdzIGxvYWQtYmVhcmluZwpjb250ZXh0IGZv ciBhbnlvbmUgYmlzZWN0aW5nIGFuIFJWMzIgdW53aW5kIHJlZ3Jlc3Npb24gbGF0ZXIsIGFuZCBp dAphbHNvIGp1c3RpZmllcyB3aHkgdGhlIGNoYW5nZSBpcyBjb3JyZWN0IHRvIGFwcGx5IGFoZWFk IG9mIHRoZSByZWxpYWJsZQp1bndpbmRlciByYXRoZXIgdGhhbiBmb2xkZWQgaW50byBpdC4KCj4g ICAJUkVHX0wJcmEsIFNUQUNLRlJBTUVfUkEoc3ApCj4gICAJUkVHX0wJczAsIFNUQUNLRlJBTUVf RlAoc3ApCj4gICAJYWRkaQlzcCwgc3AsIFNUQUNLRlJBTUVfU0laRV9PTl9TVEFDSwo+IGRpZmYg LS1naXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC9oZWFkLlMgYi9hcmNoL3Jpc2N2L2tlcm5lbC9oZWFk LlMKPiBpbmRleCBmNmE4Y2E0OWU2MjcuLjAwZTE2YTI0ZjE0OSAxMDA2NDQKPiAtLS0gYS9hcmNo L3Jpc2N2L2tlcm5lbC9oZWFkLlMKPiArKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9oZWFkLlMKPiBA QCAtMTQsNiArMTQsNyBAQAo+ICAgI2luY2x1ZGUgPGFzbS9od2NhcC5oPgo+ICAgI2luY2x1ZGUg PGFzbS9pbWFnZS5oPgo+ICAgI2luY2x1ZGUgPGFzbS9zY3MuaD4KPiArI2luY2x1ZGUgPGFzbS9z dGFja3RyYWNlL2ZyYW1lLmg+Cj4gICAjaW5jbHVkZSA8YXNtL3VzZXJjZmkuaD4KPiAgICNpbmNs dWRlICJlZmktaGVhZGVyLlMiCj4gICAKPiBAQCAtMTc3LDYgKzE3OCwxNCBAQCBzZWNvbmRhcnlf c3RhcnRfc2JpOgo+ICAgCVJFR19TIGEwLCAoYTEpCj4gICAxOgo+ICAgI2VuZGlmCj4gKwo+ICsJ LyoKPiArCSAqIFNldCB1cCB0aGUgZnJhbWUgcG9pbnRlciBmb3IgdGhlIHNlY29uZGFyeSBpZGxl IHRhc2sgc28gcmVsaWFibGUKPiArCSAqIHN0YWNrIHVud2luZGluZyB0ZXJtaW5hdGVzIGF0IHRo ZSBtZXRhZGF0YSBmcmFtZSBpbiB0YXNrX3B0X3JlZ3MoKS4KPiArCSAqIFdpdGhvdXQgdGhpcywg dGhlIGZpcnN0IGZyYW1lIHJlY29yZHMgY2FuIGluaGVyaXQgYW4gdW5kZWZpbmVkIGNhbGxlcgo+ ICsJICogZnAgYW5kIHVud2luZCBwYXN0IHNtcF9jYWxsaW4oKSBpbnRvIC5Mc2Vjb25kYXJ5X3Bh cmsuCj4gKwkgKi8KPiArCWFkZGkgczAsIHNwLCBTX1NUQUNLRlJBTUUgKyBTVEFDS0ZSQU1FX1JF Q09SRF9TSVpFCj4gICAJc2NzX2xvYWRfY3VycmVudAo+ICAgCWNhbGwgc21wX2NhbGxpbgo+ICAg I2VuZGlmIC8qIENPTkZJR19TTVAgKi8KPiBAQCAtMzA1LDYgKzMxNCwyMCBAQCBTWU1fQ09ERV9T VEFSVChfc3RhcnRfa2VybmVsKQo+ICAgCWxhIHRwLCBpbml0X3Rhc2sKPiAgIAlsYSBzcCwgaW5p dF90aHJlYWRfdW5pb24gKyBUSFJFQURfU0laRQo+ICAgCWFkZGkgc3AsIHNwLCAtUFRfU0laRV9P Tl9TVEFDSwo+ICsKPiArCS8qCj4gKwkgKiBTZXQgdXAgYSBtZXRhZGF0YSBmcmFtZSByZWNvcmQg Zm9yIHRoZSBpbml0IHRhc2sgc28gdGhhdAo+ICsJICogdGhlIHVud2luZGVyIGNhbiBpZGVudGlm eSB0aGUgb3V0ZXJtb3N0IGZyYW1lIGJ5IGl0cwo+ICsJICoge2ZwLCByYX0gPSB7MCwgMH0gc2Vu dGluZWwgYXQgdGhlIGJvdHRvbSBvZiBwdF9yZWdzLgo+ICsJICogZnAvczAgcG9pbnRzIGFib3Zl IHRoZSBtZXRhZGF0YSByZWNvcmQgKFJJU0MtVgo+ICsJICogY29udmVudGlvbikuCj4gKwkgKi8K PiArCVJFR19TIHplcm8sIChTX1NUQUNLRlJBTUUgKyBTVEFDS0ZSQU1FX0ZQKShzcCkKPiArCVJF R19TIHplcm8sIChTX1NUQUNLRlJBTUUgKyBTVEFDS0ZSQU1FX1JBKShzcCkKPiArCWxpIHQwLCBG UkFNRV9NRVRBX1RZUEVfRklOQUwKPiArCVJFR19TIHQwLCBTX1NUQUNLRlJBTUVfVFlQRShzcCkK PiArCWFkZGkgczAsIHNwLCBTX1NUQUNLRlJBTUUgKyBTVEFDS0ZSQU1FX1JFQ09SRF9TSVpFCj4g Kwo+ICAgI2lmIGRlZmluZWQoQ09ORklHX1JJU0NWX1NCSSkgJiYgZGVmaW5lZChDT05GSUdfUklT Q1ZfVVNFUl9DRkkpCj4gICAJbGkgYTcsIFNCSV9FWFRfRldGVAo+ICAgCWxpIGE2LCBTQklfRVhU X0ZXRlRfU0VUCj4gZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3Yva2VybmVsL3Byb2Nlc3MuYyBiL2Fy Y2gvcmlzY3Yva2VybmVsL3Byb2Nlc3MuYwo+IGluZGV4IGIyZGY3ZjcyMjQxYS4uNTIxMjkyNmI5 MjZiIDEwMDY0NAo+IC0tLSBhL2FyY2gvcmlzY3Yva2VybmVsL3Byb2Nlc3MuYwo+ICsrKyBiL2Fy Y2gvcmlzY3Yva2VybmVsL3Byb2Nlc3MuYwo+IEBAIC0yNTgsOCArMjU4LDIzIEBAIGludCBjb3B5 X3RocmVhZChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAsIGNvbnN0IHN0cnVjdCBrZXJuZWxfY2xvbmVf YXJncyAqYXJncykKPiAgIAkJLyogU3VwZXJ2aXNvci9NYWNoaW5lLCBpcnFzIG9uOiAqLwo+ICAg CQljaGlsZHJlZ3MtPnN0YXR1cyA9IFNSX1BQIHwgU1JfUElFOwo+ICAgCj4gLQkJcC0+dGhyZWFk LnNbMF0gPSAodW5zaWduZWQgbG9uZylhcmdzLT5mbjsKPiAtCQlwLT50aHJlYWQuc1sxXSA9ICh1 bnNpZ25lZCBsb25nKWFyZ3MtPmZuX2FyZzsKPiArCQkvKgo+ICsJCSAqIFNldCB1cCBhIG1ldGFk YXRhIGZyYW1lIHJlY29yZCBhdCB0aGUgYm90dG9tIG9mIHRoZQo+ICsJCSAqIHN0YWNrIGZvciB0 aGUgdW53aW5kZXIuIFVzZSBGUkFNRV9NRVRBX1RZUEVfRklOQUwKPiArCQkgKiBzaW5jZSB0aGlz IGlzIHRoZSBvdXRlcm1vc3Qga2VybmVsIGVudHJ5IGZvciB0aGUgbmV3Cj4gKwkJICogdGFzay4g VGhlIGZyYW1lX3JlY29yZDo6e2ZwLHJhfSBhcmUgYWxyZWFkeSB6ZXJvIGZyb20KPiArCQkgKiBt ZW1zZXQoKS4KPiArCQkgKgo+ICsJCSAqIGZwL3MwIHBvaW50cyBhYm92ZSB0aGUgbWV0YWRhdGEg cmVjb3JkIChSSVNDLVYKPiArCQkgKiBjb252ZW50aW9uKS4gZm4gYW5kIGZuX2FyZyBhcmUgcGFz c2VkIHZpYSBzMi9zMywKPiArCQkgKiBrZWVwaW5nIHMwIGF2YWlsYWJsZSBmb3IgdGhlIGZyYW1l IHBvaW50ZXIgY2hhaW4uCj4gKwkJICovCj4gKwkJY2hpbGRyZWdzLT5zdGFja2ZyYW1lLnR5cGUg PSBGUkFNRV9NRVRBX1RZUEVfRklOQUw7Cj4gKwo+ICsJCXAtPnRocmVhZC5zWzBdID0gKHVuc2ln bmVkIGxvbmcpKCZjaGlsZHJlZ3MtPnN0YWNrZnJhbWUpCj4gKwkJCQkrIHNpemVvZihzdHJ1Y3Qg ZnJhbWVfcmVjb3JkKTsKPiArCQlwLT50aHJlYWQuc1syXSA9ICh1bnNpZ25lZCBsb25nKWFyZ3Mt PmZuOwo+ICsJCXAtPnRocmVhZC5zWzNdID0gKHVuc2lnbmVkIGxvbmcpYXJncy0+Zm5fYXJnOwo+ ICAgCQlwLT50aHJlYWQucmEgPSAodW5zaWduZWQgbG9uZylyZXRfZnJvbV9mb3JrX2tlcm5lbF9h c207Cj4gICAJfSBlbHNlIHsKPiAgIAkJLyogYWxsb2NhdGUgbmV3IHNoYWRvdyBzdGFjayBpZiBu ZWVkZWQuIEluIGNhc2Ugb2YgQ0xPTkVfVk0gd2UgaGF2ZSB0byAqLwo+IEBAIC0yNzgsNiArMjkz LDE4IEBAIGludCBjb3B5X3RocmVhZChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAsIGNvbnN0IHN0cnVj dCBrZXJuZWxfY2xvbmVfYXJncyAqYXJncykKPiAgIAkJaWYgKGNsb25lX2ZsYWdzICYgQ0xPTkVf U0VUVExTKQo+ICAgCQkJY2hpbGRyZWdzLT50cCA9IHRsczsKPiAgIAkJY2hpbGRyZWdzLT5hMCA9 IDA7IC8qIFJldHVybiB2YWx1ZSBvZiBmb3JrKCkgKi8KPiArCj4gKwkJLyoKPiArCQkgKiBTZXQg dXAgdGhlIHVud2luZCBib3VuZGFyeTogZW5zdXJlIHRoZSBtZXRhZGF0YQo+ICsJCSAqIGZyYW1l IHJlY29yZCBoYXMgaXRzIHtmcCxyYX0gc2VudGluZWwgemVyb2VkIGFuZAo+ICsJCSAqIHBvaW50 IGZwL3MwIGFib3ZlIHRoZSBtZXRhZGF0YSByZWNvcmQuIFRoZSB0eXBlCj4gKwkJICogZmllbGQg aXMgaW5oZXJpdGVkIGZyb20gdGhlIHBhcmVudCdzIHB0X3JlZ3MuCj4gKwkJICovCj4gKwkJY2hp bGRyZWdzLT5zdGFja2ZyYW1lLnJlY29yZC5mcCA9IDA7Cj4gKwkJY2hpbGRyZWdzLT5zdGFja2Zy YW1lLnJlY29yZC5yYSA9IDA7CgpUaGlzIHJlbGllcyBvbiB0aGUgcGFyZW50IGFsd2F5cyBlbnRl cmluZyBrZXJuZWwgdmlhIGhhbmRsZV9leGNlcHRpb24Kb24gYSB1c2VyLT5rZXJuZWwgYm91bmRh cnkgKHdoaWNoIHdyaXRlcyBGUkFNRV9NRVRBX1RZUEVfRklOQUwpLgpUaGF0IGlzIHRydWUgZm9y IGZvcmsoKS9jbG9uZSgpIHRvZGF5LCBidXQ6CgogICAtIFRoZSBrZXJuZWwtdGhyZWFkIHBhdGgg cmlnaHQgYWJvdmUgZXhwbGljaXRseSBhc3NpZ25zIHR5cGUgPQogICAgIEZJTkFMLCBzbyB0aGUg dXNlci10aHJlYWQgcGF0aCBsb29rcyBhc3ltbWV0cmljIGFuZCBsaWtlIGEKICAgICBwb3NzaWJs ZSBvbWlzc2lvbiB0byBhbnlvbmUgcmVhZGluZyBpdCBjb2xkLgogICAtIEEgZnV0dXJlIGNhbGxl ciBpbnZva2luZyBrZXJuZWxfY2xvbmUoKSBmcm9tIGEgbmVzdGVkLWtlcm5lbAogICAgIGNvbnRl eHQgKHBhcmVudCBwdF9yZWdzLnR5cGUgPT0gUFRfUkVHUykgd291bGQgc2lsZW50bHkgcHJvZHVj ZQogICAgIGEgYnJva2VuIHVud2luZCBib3VuZGFyeSBvbiB0aGUgbmV3IHRhc2suCgpSZWNvbW1l bmQgZXhwbGljaXRseSBzZXR0aW5nIGl0IGhlcmUgdG9vOgoKICAgICAgIGNoaWxkcmVncy0+c3Rh Y2tmcmFtZS50eXBlID0gRlJBTUVfTUVUQV9UWVBFX0ZJTkFMOwoKRXZlbiBpZiBjdXJyZW50bHkg cmVkdW5kYW50LCBpdCBpcyBvbmUgYXNzaWdubWVudCwgY29zdHMgbm90aGluZywgaXMKc2VsZi1k b2N1bWVudGluZywgYW5kIGZhaWxzIGNsb3NlZCBpbnN0ZWFkIG9mIG9wZW4uCgoKVGhhbmtzLgpT aHVhaQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGlu dXgtcmlzY3YgbWFpbGluZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0 cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1yaXNjdgo=