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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id EEEEFC61DA4 for ; Wed, 22 Feb 2023 03:31:44 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230374AbjBVDbn (ORCPT ); Tue, 21 Feb 2023 22:31:43 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54534 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230356AbjBVDbn (ORCPT ); Tue, 21 Feb 2023 22:31:43 -0500 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4C7F635257; Tue, 21 Feb 2023 19:31:18 -0800 (PST) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id A4CC46123A; Wed, 22 Feb 2023 03:31:17 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id BAFD9C4339B; Wed, 22 Feb 2023 03:31:10 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1677036677; bh=H5TOhT9ycJV0MKojNZxUpdws9Ud34UAIOla4M9GstOo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=WJJgDNDBc3v1IyTP/QGcFGW4xC+SiReQ4efMlpEZJ+5OmTAhcUXkppU5J4kmhGT6N OyZ/NJ3Ioy3QUXFSKPPVuCguthvelNVPAMCgttksA+zTozH+bFoZXIuqVEaSSTUlhg Nur86LQu6BA6fRqfwrpXjdmTipOvQm9BEXRZo6nYEbX3NjuK/lmWE5zvUdY/kEu7dO qkBqz0X++sh4uBhVRh1xt2HUeqBOSEApEDoFxaJgYdfmP8hJ1y7pyLCn6rGNR3oxee gu6g3z9+pyocne6REUxunWI+rs9WqC54oEWK2gOmkxKPN9/wwgm3s1CN575psqGIlf 1aiJg+pokUWIg== From: guoren@kernel.org To: arnd@arndb.de, guoren@kernel.org, palmer@rivosinc.com, tglx@linutronix.de, peterz@infradead.org, luto@kernel.org, conor.dooley@microchip.com, heiko@sntech.de, jszhang@kernel.org, lazyparser@gmail.com, falcon@tinylab.org, chenhuacai@kernel.org, apatel@ventanamicro.com, atishp@atishpatra.org, mark.rutland@arm.com, ben@decadent.org.uk, bjorn@kernel.org, palmer@dabbelt.com Cc: linux-arch@vger.kernel.org, linux-kernel@vger.kernel.org, linux-riscv@lists.infradead.org, Guo Ren , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , Yipeng Zou Subject: [PATCH -next V17 4/7] riscv: entry: Convert to generic entry Date: Tue, 21 Feb 2023 22:30:18 -0500 Message-Id: <20230222033021.983168-5-guoren@kernel.org> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20230222033021.983168-1-guoren@kernel.org> References: <20230222033021.983168-1-guoren@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-arch@vger.kernel.org From: Guo Ren This patch converts riscv to use the generic entry infrastructure from kernel/entry/*. The generic entry makes maintainers' work easier and codes more elegant. Here are the changes: - More clear entry.S with handle_exception and ret_from_exception - Get rid of complex custom signal implementation - Move syscall procedure from assembly to C, which is much more readable. - Connect ret_from_fork & ret_from_kernel_thread to generic entry. - Wrap with irqentry_enter/exit and syscall_enter/exit_from_user_mode - Use the standard preemption code instead of custom Suggested-by: Huacai Chen Reviewed-by: Björn Töpel Tested-by: Yipeng Zou Tested-by: Jisheng Zhang Signed-off-by: Guo Ren Signed-off-by: Guo Ren Cc: Ben Hutchings --- arch/riscv/Kconfig | 1 + arch/riscv/include/asm/asm-prototypes.h | 2 + arch/riscv/include/asm/csr.h | 1 - arch/riscv/include/asm/entry-common.h | 11 ++ arch/riscv/include/asm/ptrace.h | 10 +- arch/riscv/include/asm/stacktrace.h | 5 + arch/riscv/include/asm/syscall.h | 21 ++ arch/riscv/include/asm/thread_info.h | 13 +- arch/riscv/kernel/entry.S | 242 ++++-------------------- arch/riscv/kernel/head.h | 1 - arch/riscv/kernel/ptrace.c | 43 ----- arch/riscv/kernel/signal.c | 29 +-- arch/riscv/kernel/traps.c | 140 ++++++++++++-- arch/riscv/mm/fault.c | 6 +- 14 files changed, 210 insertions(+), 315 deletions(-) create mode 100644 arch/riscv/include/asm/entry-common.h diff --git a/arch/riscv/Kconfig b/arch/riscv/Kconfig index 81eb031887d2..7e27c8c01ae8 100644 --- a/arch/riscv/Kconfig +++ b/arch/riscv/Kconfig @@ -61,6 +61,7 @@ config RISCV select GENERIC_ATOMIC64 if !64BIT select GENERIC_CLOCKEVENTS_BROADCAST if SMP select GENERIC_EARLY_IOREMAP + select GENERIC_ENTRY select GENERIC_GETTIMEOFDAY if HAVE_GENERIC_VDSO select GENERIC_IDLE_POLL_SETUP select GENERIC_IOREMAP if MMU diff --git a/arch/riscv/include/asm/asm-prototypes.h b/arch/riscv/include/asm/asm-prototypes.h index ef386fcf3939..61ba8ed43d8f 100644 --- a/arch/riscv/include/asm/asm-prototypes.h +++ b/arch/riscv/include/asm/asm-prototypes.h @@ -27,5 +27,7 @@ DECLARE_DO_ERROR_INFO(do_trap_break); asmlinkage unsigned long get_overflow_stack(void); asmlinkage void handle_bad_stack(struct pt_regs *regs); +asmlinkage void do_page_fault(struct pt_regs *regs); +asmlinkage void do_irq(struct pt_regs *regs); #endif /* _ASM_RISCV_PROTOTYPES_H */ diff --git a/arch/riscv/include/asm/csr.h b/arch/riscv/include/asm/csr.h index 0e571f6483d9..7c2b8cdb7b77 100644 --- a/arch/riscv/include/asm/csr.h +++ b/arch/riscv/include/asm/csr.h @@ -40,7 +40,6 @@ #define SR_UXL _AC(0x300000000, UL) /* XLEN mask for U-mode */ #define SR_UXL_32 _AC(0x100000000, UL) /* XLEN = 32 for U-mode */ #define SR_UXL_64 _AC(0x200000000, UL) /* XLEN = 64 for U-mode */ -#define SR_UXL_SHIFT 32 #endif /* SATP flags */ diff --git a/arch/riscv/include/asm/entry-common.h b/arch/riscv/include/asm/entry-common.h new file mode 100644 index 000000000000..6e4dee49d84b --- /dev/null +++ b/arch/riscv/include/asm/entry-common.h @@ -0,0 +1,11 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef _ASM_RISCV_ENTRY_COMMON_H +#define _ASM_RISCV_ENTRY_COMMON_H + +#include + +void handle_page_fault(struct pt_regs *regs); +void handle_break(struct pt_regs *regs); + +#endif /* _ASM_RISCV_ENTRY_COMMON_H */ diff --git a/arch/riscv/include/asm/ptrace.h b/arch/riscv/include/asm/ptrace.h index 6ecd461129d2..b5b0adcc85c1 100644 --- a/arch/riscv/include/asm/ptrace.h +++ b/arch/riscv/include/asm/ptrace.h @@ -53,6 +53,9 @@ struct pt_regs { unsigned long orig_a0; }; +#define PTRACE_SYSEMU 0x1f +#define PTRACE_SYSEMU_SINGLESTEP 0x20 + #ifdef CONFIG_64BIT #define REG_FMT "%016lx" #else @@ -121,8 +124,6 @@ extern unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs, void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr, unsigned long frame_pointer); -int do_syscall_trace_enter(struct pt_regs *regs); -void do_syscall_trace_exit(struct pt_regs *regs); /** * regs_get_register() - get register value from its offset @@ -172,6 +173,11 @@ static inline unsigned long regs_get_kernel_argument(struct pt_regs *regs, return 0; } +static inline int regs_irqs_disabled(struct pt_regs *regs) +{ + return !(regs->status & SR_PIE); +} + #endif /* __ASSEMBLY__ */ #endif /* _ASM_RISCV_PTRACE_H */ diff --git a/arch/riscv/include/asm/stacktrace.h b/arch/riscv/include/asm/stacktrace.h index 3450c1912afd..f7e8ef2418b9 100644 --- a/arch/riscv/include/asm/stacktrace.h +++ b/arch/riscv/include/asm/stacktrace.h @@ -16,4 +16,9 @@ extern void notrace walk_stackframe(struct task_struct *task, struct pt_regs *re extern void dump_backtrace(struct pt_regs *regs, struct task_struct *task, const char *loglvl); +static inline bool on_thread_stack(void) +{ + return !(((unsigned long)(current->stack) ^ current_stack_pointer) & ~(THREAD_SIZE - 1)); +} + #endif /* _ASM_RISCV_STACKTRACE_H */ diff --git a/arch/riscv/include/asm/syscall.h b/arch/riscv/include/asm/syscall.h index 384a63b86420..736110e1fd78 100644 --- a/arch/riscv/include/asm/syscall.h +++ b/arch/riscv/include/asm/syscall.h @@ -74,5 +74,26 @@ static inline int syscall_get_arch(struct task_struct *task) #endif } +typedef long (*syscall_t)(ulong, ulong, ulong, ulong, ulong, ulong, ulong); +static inline void syscall_handler(struct pt_regs *regs, ulong syscall) +{ + syscall_t fn; + +#ifdef CONFIG_COMPAT + if ((regs->status & SR_UXL) == SR_UXL_32) + fn = compat_sys_call_table[syscall]; + else +#endif + fn = sys_call_table[syscall]; + + regs->a0 = fn(regs->orig_a0, regs->a1, regs->a2, + regs->a3, regs->a4, regs->a5, regs->a6); +} + +static inline bool arch_syscall_is_vdso_sigreturn(struct pt_regs *regs) +{ + return false; +} + asmlinkage long sys_riscv_flush_icache(uintptr_t, uintptr_t, uintptr_t); #endif /* _ASM_RISCV_SYSCALL_H */ diff --git a/arch/riscv/include/asm/thread_info.h b/arch/riscv/include/asm/thread_info.h index f704c8dd57e0..e0d202134b44 100644 --- a/arch/riscv/include/asm/thread_info.h +++ b/arch/riscv/include/asm/thread_info.h @@ -67,6 +67,7 @@ struct thread_info { long kernel_sp; /* Kernel stack pointer */ long user_sp; /* User stack pointer */ int cpu; + unsigned long syscall_work; /* SYSCALL_WORK_ flags */ }; /* @@ -89,26 +90,18 @@ struct thread_info { * - pending work-to-be-done flags are in lowest half-word * - other flags in upper half-word(s) */ -#define TIF_SYSCALL_TRACE 0 /* syscall trace active */ #define TIF_NOTIFY_RESUME 1 /* callback before returning to user */ #define TIF_SIGPENDING 2 /* signal pending */ #define TIF_NEED_RESCHED 3 /* rescheduling necessary */ #define TIF_RESTORE_SIGMASK 4 /* restore signal mask in do_signal() */ #define TIF_MEMDIE 5 /* is terminating due to OOM killer */ -#define TIF_SYSCALL_TRACEPOINT 6 /* syscall tracepoint instrumentation */ -#define TIF_SYSCALL_AUDIT 7 /* syscall auditing */ -#define TIF_SECCOMP 8 /* syscall secure computing */ #define TIF_NOTIFY_SIGNAL 9 /* signal notifications exist */ #define TIF_UPROBE 10 /* uprobe breakpoint or singlestep */ #define TIF_32BIT 11 /* compat-mode 32bit process */ -#define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) #define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME) #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) -#define _TIF_SYSCALL_TRACEPOINT (1 << TIF_SYSCALL_TRACEPOINT) -#define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT) -#define _TIF_SECCOMP (1 << TIF_SECCOMP) #define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL) #define _TIF_UPROBE (1 << TIF_UPROBE) @@ -116,8 +109,4 @@ struct thread_info { (_TIF_NOTIFY_RESUME | _TIF_SIGPENDING | _TIF_NEED_RESCHED | \ _TIF_NOTIFY_SIGNAL | _TIF_UPROBE) -#define _TIF_SYSCALL_WORK \ - (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_TRACEPOINT | _TIF_SYSCALL_AUDIT | \ - _TIF_SECCOMP) - #endif /* _ASM_RISCV_THREAD_INFO_H */ diff --git a/arch/riscv/kernel/entry.S b/arch/riscv/kernel/entry.S index 99d38fdf8b18..bc322f92ba34 100644 --- a/arch/riscv/kernel/entry.S +++ b/arch/riscv/kernel/entry.S @@ -14,11 +14,7 @@ #include #include -#if !IS_ENABLED(CONFIG_PREEMPTION) -.set resume_kernel, restore_all -#endif - -ENTRY(handle_exception) +SYM_CODE_START(handle_exception) /* * If coming from userspace, preserve the user thread pointer and load * the kernel thread pointer. If we came from the kernel, the scratch @@ -106,19 +102,8 @@ _save_context: .option norelax la gp, __global_pointer$ .option pop - -#ifdef CONFIG_TRACE_IRQFLAGS - call __trace_hardirqs_off -#endif - -#ifdef CONFIG_CONTEXT_TRACKING_USER - /* If previous state is in user mode, call user_exit_callable(). */ - li a0, SR_PP - and a0, s1, a0 - bnez a0, skip_context_tracking - call user_exit_callable -skip_context_tracking: -#endif + move a0, sp /* pt_regs */ + la ra, ret_from_exception /* * MSB of cause differentiates between @@ -126,38 +111,13 @@ skip_context_tracking: */ bge s4, zero, 1f - la ra, ret_from_exception - /* Handle interrupts */ - move a0, sp /* pt_regs */ - la a1, generic_handle_arch_irq - jr a1 -1: - /* - * Exceptions run with interrupts enabled or disabled depending on the - * state of SR_PIE in m/sstatus. - */ - andi t0, s1, SR_PIE - beqz t0, 1f - /* kprobes, entered via ebreak, must have interrupts disabled. */ - li t0, EXC_BREAKPOINT - beq s4, t0, 1f -#ifdef CONFIG_TRACE_IRQFLAGS - call __trace_hardirqs_on -#endif - csrs CSR_STATUS, SR_IE - + tail do_irq 1: - la ra, ret_from_exception - /* Handle syscalls */ - li t0, EXC_SYSCALL - beq s4, t0, handle_syscall - /* Handle other exceptions */ slli t0, s4, RISCV_LGPTR la t1, excp_vect_table la t2, excp_vect_table_end - move a0, sp /* pt_regs */ add t0, t1, t0 /* Check if exception code lies within bounds */ bgeu t0, t2, 1f @@ -165,95 +125,17 @@ skip_context_tracking: jr t0 1: tail do_trap_unknown +SYM_CODE_END(handle_exception) -handle_syscall: -#ifdef CONFIG_RISCV_M_MODE - /* - * When running is M-Mode (no MMU config), MPIE does not get set. - * As a result, we need to force enable interrupts here because - * handle_exception did not do set SR_IE as it always sees SR_PIE - * being cleared. - */ - csrs CSR_STATUS, SR_IE -#endif -#if defined(CONFIG_TRACE_IRQFLAGS) || defined(CONFIG_CONTEXT_TRACKING_USER) - /* Recover a0 - a7 for system calls */ - REG_L a0, PT_A0(sp) - REG_L a1, PT_A1(sp) - REG_L a2, PT_A2(sp) - REG_L a3, PT_A3(sp) - REG_L a4, PT_A4(sp) - REG_L a5, PT_A5(sp) - REG_L a6, PT_A6(sp) - REG_L a7, PT_A7(sp) -#endif - /* save the initial A0 value (needed in signal handlers) */ - REG_S a0, PT_ORIG_A0(sp) - /* - * Advance SEPC to avoid executing the original - * scall instruction on sret - */ - addi s2, s2, 0x4 - REG_S s2, PT_EPC(sp) - /* Trace syscalls, but only if requested by the user. */ - REG_L t0, TASK_TI_FLAGS(tp) - andi t0, t0, _TIF_SYSCALL_WORK - bnez t0, handle_syscall_trace_enter -check_syscall_nr: - /* Check to make sure we don't jump to a bogus syscall number. */ - li t0, __NR_syscalls - la s0, sys_ni_syscall - /* - * Syscall number held in a7. - * If syscall number is above allowed value, redirect to ni_syscall. - */ - bgeu a7, t0, 3f -#ifdef CONFIG_COMPAT - REG_L s0, PT_STATUS(sp) - srli s0, s0, SR_UXL_SHIFT - andi s0, s0, (SR_UXL >> SR_UXL_SHIFT) - li t0, (SR_UXL_32 >> SR_UXL_SHIFT) - sub t0, s0, t0 - bnez t0, 1f - - /* Call compat_syscall */ - la s0, compat_sys_call_table - j 2f -1: -#endif - /* Call syscall */ - la s0, sys_call_table -2: - slli t0, a7, RISCV_LGPTR - add s0, s0, t0 - REG_L s0, 0(s0) -3: - jalr s0 - -ret_from_syscall: - /* Set user a0 to kernel a0 */ - REG_S a0, PT_A0(sp) - /* - * We didn't execute the actual syscall. - * Seccomp already set return value for the current task pt_regs. - * (If it was configured with SECCOMP_RET_ERRNO/TRACE) - */ -ret_from_syscall_rejected: -#ifdef CONFIG_DEBUG_RSEQ - move a0, sp - call rseq_syscall -#endif - /* Trace syscalls, but only if requested by the user. */ - REG_L t0, TASK_TI_FLAGS(tp) - andi t0, t0, _TIF_SYSCALL_WORK - bnez t0, handle_syscall_trace_exit - +/* + * The ret_from_exception must be called with interrupt disabled. Here is the + * caller list: + * - handle_exception + * - ret_from_fork + * - ret_from_kernel_thread + */ SYM_CODE_START_NOALIGN(ret_from_exception) REG_L s0, PT_STATUS(sp) - csrc CSR_STATUS, SR_IE -#ifdef CONFIG_TRACE_IRQFLAGS - call __trace_hardirqs_off -#endif #ifdef CONFIG_RISCV_M_MODE /* the MPP value is too large to be used as an immediate arg for addi */ li t0, SR_MPP @@ -261,17 +143,7 @@ SYM_CODE_START_NOALIGN(ret_from_exception) #else andi s0, s0, SR_SPP #endif - bnez s0, resume_kernel -SYM_CODE_END(ret_from_exception) - - /* Interrupts must be disabled here so flags are checked atomically */ - REG_L s0, TASK_TI_FLAGS(tp) /* current_thread_info->flags */ - andi s1, s0, _TIF_WORK_MASK - bnez s1, resume_userspace_slow -resume_userspace: -#ifdef CONFIG_CONTEXT_TRACKING_USER - call user_enter_callable -#endif + bnez s0, 1f /* Save unwound kernel stack pointer in thread_info */ addi s0, sp, PT_SIZE_ON_STACK @@ -282,18 +154,7 @@ resume_userspace: * structures again. */ csrw CSR_SCRATCH, tp - -restore_all: -#ifdef CONFIG_TRACE_IRQFLAGS - REG_L s1, PT_STATUS(sp) - andi t0, s1, SR_PIE - beqz t0, 1f - call __trace_hardirqs_on - j 2f 1: - call __trace_hardirqs_off -2: -#endif REG_L a0, PT_STATUS(sp) /* * The current load reservation is effectively part of the processor's @@ -356,47 +217,10 @@ restore_all: #else sret #endif - -#if IS_ENABLED(CONFIG_PREEMPTION) -resume_kernel: - REG_L s0, TASK_TI_PREEMPT_COUNT(tp) - bnez s0, restore_all - REG_L s0, TASK_TI_FLAGS(tp) - andi s0, s0, _TIF_NEED_RESCHED - beqz s0, restore_all - call preempt_schedule_irq - j restore_all -#endif - -resume_userspace_slow: - /* Enter slow path for supplementary processing */ - move a0, sp /* pt_regs */ - move a1, s0 /* current_thread_info->flags */ - call do_work_pending - j resume_userspace - -/* Slow paths for ptrace. */ -handle_syscall_trace_enter: - move a0, sp - call do_syscall_trace_enter - move t0, a0 - REG_L a0, PT_A0(sp) - REG_L a1, PT_A1(sp) - REG_L a2, PT_A2(sp) - REG_L a3, PT_A3(sp) - REG_L a4, PT_A4(sp) - REG_L a5, PT_A5(sp) - REG_L a6, PT_A6(sp) - REG_L a7, PT_A7(sp) - bnez t0, ret_from_syscall_rejected - j check_syscall_nr -handle_syscall_trace_exit: - move a0, sp - call do_syscall_trace_exit - j ret_from_exception +SYM_CODE_END(ret_from_exception) #ifdef CONFIG_VMAP_STACK -handle_kernel_stack_overflow: +SYM_CODE_START_LOCAL(handle_kernel_stack_overflow) /* * Takes the psuedo-spinlock for the shadow stack, in case multiple * harts are concurrently overflowing their kernel stacks. We could @@ -505,23 +329,25 @@ restore_caller_reg: REG_S s5, PT_TP(sp) move a0, sp tail handle_bad_stack +SYM_CODE_END(handle_kernel_stack_overflow) #endif -END(handle_exception) - -ENTRY(ret_from_fork) +SYM_CODE_START(ret_from_fork) + call schedule_tail + move a0, sp /* pt_regs */ la ra, ret_from_exception - tail schedule_tail -ENDPROC(ret_from_fork) + tail syscall_exit_to_user_mode +SYM_CODE_END(ret_from_fork) -ENTRY(ret_from_kernel_thread) +SYM_CODE_START(ret_from_kernel_thread) call schedule_tail /* Call fn(arg) */ - la ra, ret_from_exception move a0, s1 - jr s0 -ENDPROC(ret_from_kernel_thread) - + jalr s0 + move a0, sp /* pt_regs */ + la ra, ret_from_exception + tail syscall_exit_to_user_mode +SYM_CODE_END(ret_from_kernel_thread) /* * Integer register context switch @@ -533,7 +359,7 @@ ENDPROC(ret_from_kernel_thread) * The value of a0 and a1 must be preserved by this function, as that's how * arguments are passed to schedule_tail. */ -ENTRY(__switch_to) +SYM_FUNC_START(__switch_to) /* Save context into prev->thread */ li a4, TASK_THREAD_RA add a3, a0, a4 @@ -570,7 +396,7 @@ ENTRY(__switch_to) /* The offset of thread_info in task_struct is zero. */ move tp, a1 ret -ENDPROC(__switch_to) +SYM_FUNC_END(__switch_to) #ifndef CONFIG_MMU #define do_page_fault do_trap_unknown @@ -579,7 +405,7 @@ ENDPROC(__switch_to) .section ".rodata" .align LGREG /* Exception vector table */ -ENTRY(excp_vect_table) +SYM_CODE_START(excp_vect_table) RISCV_PTR do_trap_insn_misaligned ALT_INSN_FAULT(RISCV_PTR do_trap_insn_fault) RISCV_PTR do_trap_insn_illegal @@ -588,7 +414,7 @@ ENTRY(excp_vect_table) RISCV_PTR do_trap_load_fault RISCV_PTR do_trap_store_misaligned RISCV_PTR do_trap_store_fault - RISCV_PTR do_trap_ecall_u /* system call, gets intercepted */ + RISCV_PTR do_trap_ecall_u /* system call */ RISCV_PTR do_trap_ecall_s RISCV_PTR do_trap_unknown RISCV_PTR do_trap_ecall_m @@ -598,11 +424,11 @@ ENTRY(excp_vect_table) RISCV_PTR do_trap_unknown RISCV_PTR do_page_fault /* store page fault */ excp_vect_table_end: -END(excp_vect_table) +SYM_CODE_END(excp_vect_table) #ifndef CONFIG_MMU -ENTRY(__user_rt_sigreturn) +SYM_CODE_START(__user_rt_sigreturn) li a7, __NR_rt_sigreturn scall -END(__user_rt_sigreturn) +SYM_CODE_END(__user_rt_sigreturn) #endif diff --git a/arch/riscv/kernel/head.h b/arch/riscv/kernel/head.h index 726731ada534..a556fdaafed9 100644 --- a/arch/riscv/kernel/head.h +++ b/arch/riscv/kernel/head.h @@ -10,7 +10,6 @@ extern atomic_t hart_lottery; -asmlinkage void do_page_fault(struct pt_regs *regs); asmlinkage void __init setup_vm(uintptr_t dtb_pa); #ifdef CONFIG_XIP_KERNEL asmlinkage void __init __copy_data(void); diff --git a/arch/riscv/kernel/ptrace.c b/arch/riscv/kernel/ptrace.c index 44f4b1ca315d..23c48b14a0e7 100644 --- a/arch/riscv/kernel/ptrace.c +++ b/arch/riscv/kernel/ptrace.c @@ -19,9 +19,6 @@ #include #include -#define CREATE_TRACE_POINTS -#include - enum riscv_regset { REGSET_X, #ifdef CONFIG_FPU @@ -228,46 +225,6 @@ long arch_ptrace(struct task_struct *child, long request, return ret; } -/* - * Allows PTRACE_SYSCALL to work. These are called from entry.S in - * {handle,ret_from}_syscall. - */ -__visible int do_syscall_trace_enter(struct pt_regs *regs) -{ - if (test_thread_flag(TIF_SYSCALL_TRACE)) - if (ptrace_report_syscall_entry(regs)) - return -1; - - /* - * Do the secure computing after ptrace; failures should be fast. - * If this fails we might have return value in a0 from seccomp - * (via SECCOMP_RET_ERRNO/TRACE). - */ - if (secure_computing() == -1) - return -1; - -#ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS - if (test_thread_flag(TIF_SYSCALL_TRACEPOINT)) - trace_sys_enter(regs, syscall_get_nr(current, regs)); -#endif - - audit_syscall_entry(regs->a7, regs->a0, regs->a1, regs->a2, regs->a3); - return 0; -} - -__visible void do_syscall_trace_exit(struct pt_regs *regs) -{ - audit_syscall_exit(regs); - - if (test_thread_flag(TIF_SYSCALL_TRACE)) - ptrace_report_syscall_exit(regs, 0); - -#ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS - if (test_thread_flag(TIF_SYSCALL_TRACEPOINT)) - trace_sys_exit(regs, regs_return_value(regs)); -#endif -} - #ifdef CONFIG_COMPAT static int compat_riscv_gpr_get(struct task_struct *target, const struct user_regset *regset, diff --git a/arch/riscv/kernel/signal.c b/arch/riscv/kernel/signal.c index bfb2afa4135f..2e365084417e 100644 --- a/arch/riscv/kernel/signal.c +++ b/arch/riscv/kernel/signal.c @@ -12,6 +12,7 @@ #include #include #include +#include #include #include @@ -274,7 +275,7 @@ static void handle_signal(struct ksignal *ksig, struct pt_regs *regs) signal_setup_done(ret, ksig, 0); } -static void do_signal(struct pt_regs *regs) +void arch_do_signal_or_restart(struct pt_regs *regs) { struct ksignal ksig; @@ -311,29 +312,3 @@ static void do_signal(struct pt_regs *regs) */ restore_saved_sigmask(); } - -/* - * Handle any pending work on the resume-to-userspace path, as indicated by - * _TIF_WORK_MASK. Entered from assembly with IRQs off. - */ -asmlinkage __visible void do_work_pending(struct pt_regs *regs, - unsigned long thread_info_flags) -{ - do { - if (thread_info_flags & _TIF_NEED_RESCHED) { - schedule(); - } else { - local_irq_enable(); - if (thread_info_flags & _TIF_UPROBE) - uprobe_notify_resume(regs); - /* Handle pending signal delivery */ - if (thread_info_flags & (_TIF_SIGPENDING | - _TIF_NOTIFY_SIGNAL)) - do_signal(regs); - if (thread_info_flags & _TIF_NOTIFY_RESUME) - resume_user_mode_work(regs); - } - local_irq_disable(); - thread_info_flags = read_thread_flags(); - } while (thread_info_flags & _TIF_WORK_MASK); -} diff --git a/arch/riscv/kernel/traps.c b/arch/riscv/kernel/traps.c index 02727a4fe8be..1f4e37be7eb3 100644 --- a/arch/riscv/kernel/traps.c +++ b/arch/riscv/kernel/traps.c @@ -17,12 +17,14 @@ #include #include #include +#include #include #include #include #include #include +#include #include int show_unhandled_signals = 1; @@ -123,10 +125,18 @@ static void do_trap_error(struct pt_regs *regs, int signo, int code, #else #define __trap_section noinstr #endif -#define DO_ERROR_INFO(name, signo, code, str) \ -asmlinkage __visible __trap_section void name(struct pt_regs *regs) \ -{ \ - do_trap_error(regs, signo, code, regs->epc, "Oops - " str); \ +#define DO_ERROR_INFO(name, signo, code, str) \ +asmlinkage __visible __trap_section void name(struct pt_regs *regs) \ +{ \ + if (user_mode(regs)) { \ + irqentry_enter_from_user_mode(regs); \ + do_trap_error(regs, signo, code, regs->epc, "Oops - " str); \ + irqentry_exit_to_user_mode(regs); \ + } else { \ + irqentry_state_t state = irqentry_nmi_enter(regs); \ + do_trap_error(regs, signo, code, regs->epc, "Oops - " str); \ + irqentry_nmi_exit(regs, state); \ + } \ } DO_ERROR_INFO(do_trap_unknown, @@ -148,26 +158,50 @@ DO_ERROR_INFO(do_trap_store_misaligned, int handle_misaligned_load(struct pt_regs *regs); int handle_misaligned_store(struct pt_regs *regs); -asmlinkage void __trap_section do_trap_load_misaligned(struct pt_regs *regs) +asmlinkage __visible __trap_section void do_trap_load_misaligned(struct pt_regs *regs) { - if (!handle_misaligned_load(regs)) - return; - do_trap_error(regs, SIGBUS, BUS_ADRALN, regs->epc, - "Oops - load address misaligned"); + if (user_mode(regs)) { + irqentry_enter_from_user_mode(regs); + + if (handle_misaligned_load(regs)) + do_trap_error(regs, SIGBUS, BUS_ADRALN, regs->epc, + "Oops - load address misaligned"); + + irqentry_exit_to_user_mode(regs); + } else { + irqentry_state_t state = irqentry_nmi_enter(regs); + + if (handle_misaligned_load(regs)) + do_trap_error(regs, SIGBUS, BUS_ADRALN, regs->epc, + "Oops - load address misaligned"); + + irqentry_nmi_exit(regs, state); + } } -asmlinkage void __trap_section do_trap_store_misaligned(struct pt_regs *regs) +asmlinkage __visible __trap_section void do_trap_store_misaligned(struct pt_regs *regs) { - if (!handle_misaligned_store(regs)) - return; - do_trap_error(regs, SIGBUS, BUS_ADRALN, regs->epc, - "Oops - store (or AMO) address misaligned"); + if (user_mode(regs)) { + irqentry_enter_from_user_mode(regs); + + if (handle_misaligned_store(regs)) + do_trap_error(regs, SIGBUS, BUS_ADRALN, regs->epc, + "Oops - store (or AMO) address misaligned"); + + irqentry_exit_to_user_mode(regs); + } else { + irqentry_state_t state = irqentry_nmi_enter(regs); + + if (handle_misaligned_store(regs)) + do_trap_error(regs, SIGBUS, BUS_ADRALN, regs->epc, + "Oops - store (or AMO) address misaligned"); + + irqentry_nmi_exit(regs, state); + } } #endif DO_ERROR_INFO(do_trap_store_fault, SIGSEGV, SEGV_ACCERR, "store (or AMO) access fault"); -DO_ERROR_INFO(do_trap_ecall_u, - SIGILL, ILL_ILLTRP, "environment call from U-mode"); DO_ERROR_INFO(do_trap_ecall_s, SIGILL, ILL_ILLTRP, "environment call from S-mode"); DO_ERROR_INFO(do_trap_ecall_m, @@ -183,7 +217,7 @@ static inline unsigned long get_break_insn_length(unsigned long pc) return GET_INSN_LENGTH(insn); } -asmlinkage __visible __trap_section void do_trap_break(struct pt_regs *regs) +void handle_break(struct pt_regs *regs) { #ifdef CONFIG_KPROBES if (kprobe_single_step_handler(regs)) @@ -213,7 +247,77 @@ asmlinkage __visible __trap_section void do_trap_break(struct pt_regs *regs) else die(regs, "Kernel BUG"); } -NOKPROBE_SYMBOL(do_trap_break); + +asmlinkage __visible __trap_section void do_trap_break(struct pt_regs *regs) +{ + if (user_mode(regs)) { + irqentry_enter_from_user_mode(regs); + + handle_break(regs); + + irqentry_exit_to_user_mode(regs); + } else { + irqentry_state_t state = irqentry_nmi_enter(regs); + + handle_break(regs); + + irqentry_nmi_exit(regs, state); + } +} + +asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs) +{ + if (user_mode(regs)) { + ulong syscall = regs->a7; + + syscall = syscall_enter_from_user_mode(regs, syscall); + + regs->epc += 4; + regs->orig_a0 = regs->a0; + + if (syscall < NR_syscalls) + syscall_handler(regs, syscall); + else + regs->a0 = -ENOSYS; + + syscall_exit_to_user_mode(regs); + } else { + irqentry_state_t state = irqentry_nmi_enter(regs); + + do_trap_error(regs, SIGILL, ILL_ILLTRP, regs->epc, + "Oops - environment call from U-mode"); + + irqentry_nmi_exit(regs, state); + } + +} + +#ifdef CONFIG_MMU +asmlinkage __visible noinstr void do_page_fault(struct pt_regs *regs) +{ + irqentry_state_t state = irqentry_enter(regs); + + handle_page_fault(regs); + + local_irq_disable(); + + irqentry_exit(regs, state); +} +#endif + +asmlinkage __visible noinstr void do_irq(struct pt_regs *regs) +{ + struct pt_regs *old_regs; + irqentry_state_t state = irqentry_enter(regs); + + irq_enter_rcu(); + old_regs = set_irq_regs(regs); + handle_arch_irq(regs); + set_irq_regs(old_regs); + irq_exit_rcu(); + + irqentry_exit(regs, state); +} #ifdef CONFIG_GENERIC_BUG int is_valid_bugaddr(unsigned long pc) diff --git a/arch/riscv/mm/fault.c b/arch/riscv/mm/fault.c index eb0774d9c03b..efc36be38bce 100644 --- a/arch/riscv/mm/fault.c +++ b/arch/riscv/mm/fault.c @@ -15,6 +15,7 @@ #include #include #include +#include #include #include @@ -204,7 +205,7 @@ static inline bool access_error(unsigned long cause, struct vm_area_struct *vma) * This routine handles page faults. It determines the address and the * problem, and then passes it off to one of the appropriate routines. */ -asmlinkage void do_page_fault(struct pt_regs *regs) +void handle_page_fault(struct pt_regs *regs) { struct task_struct *tsk; struct vm_area_struct *vma; @@ -251,7 +252,7 @@ asmlinkage void do_page_fault(struct pt_regs *regs) } #endif /* Enable interrupts if they were enabled in the parent context. */ - if (likely(regs->status & SR_PIE)) + if (!regs_irqs_disabled(regs)) local_irq_enable(); /* @@ -353,4 +354,3 @@ asmlinkage void do_page_fault(struct pt_regs *regs) } return; } -NOKPROBE_SYMBOL(do_page_fault); -- 2.36.1 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 539AAC61DA4 for ; Wed, 22 Feb 2023 03:31:31 +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=OizwOWPD1p8mLMqqvPRZt4NVWxef00pl6tIlJqMnLR8=; b=xgbFZDvuPsOlOz N7eUo3tYt6h24WCuSJikrViNmdieaz5Jym+uSiWT4eylCKoqWWSBiGb3UbAbYd8/eubohGIBzOOCi v7GfOizv7o6KsoGb9j9hAKbfvXZxL1zqbxYTnfPPRnatUpYN2hfcQp2mnOUCSydkQLCkDcyRBmr+b igagCkYZ/GquoG5Snnnb+EyOjVksoOBWVG4EAL+s5uCtAxNTrdKOMbXl5u3rpiOKVV5Toa+19UouT M06OUMIT4ip9ezxrTSx4o+cii5Bg/3k8Uq6JvfL3ZO+U5YlvcJ3YhAqbAVVs6MvFMshQgWdRn1crx RP//9i2Lb/UAKcgP/TEA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1pUfqk-00AbON-K3; Wed, 22 Feb 2023 03:31:22 +0000 Received: from dfw.source.kernel.org ([139.178.84.217]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1pUfqg-00AbLf-4v for linux-riscv@lists.infradead.org; Wed, 22 Feb 2023 03:31:21 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id A65056123F; Wed, 22 Feb 2023 03:31:17 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id BAFD9C4339B; Wed, 22 Feb 2023 03:31:10 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1677036677; bh=H5TOhT9ycJV0MKojNZxUpdws9Ud34UAIOla4M9GstOo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=WJJgDNDBc3v1IyTP/QGcFGW4xC+SiReQ4efMlpEZJ+5OmTAhcUXkppU5J4kmhGT6N OyZ/NJ3Ioy3QUXFSKPPVuCguthvelNVPAMCgttksA+zTozH+bFoZXIuqVEaSSTUlhg Nur86LQu6BA6fRqfwrpXjdmTipOvQm9BEXRZo6nYEbX3NjuK/lmWE5zvUdY/kEu7dO qkBqz0X++sh4uBhVRh1xt2HUeqBOSEApEDoFxaJgYdfmP8hJ1y7pyLCn6rGNR3oxee gu6g3z9+pyocne6REUxunWI+rs9WqC54oEWK2gOmkxKPN9/wwgm3s1CN575psqGIlf 1aiJg+pokUWIg== From: guoren@kernel.org To: arnd@arndb.de, guoren@kernel.org, palmer@rivosinc.com, tglx@linutronix.de, peterz@infradead.org, luto@kernel.org, conor.dooley@microchip.com, heiko@sntech.de, jszhang@kernel.org, lazyparser@gmail.com, falcon@tinylab.org, chenhuacai@kernel.org, apatel@ventanamicro.com, atishp@atishpatra.org, mark.rutland@arm.com, ben@decadent.org.uk, bjorn@kernel.org, palmer@dabbelt.com Cc: linux-arch@vger.kernel.org, linux-kernel@vger.kernel.org, linux-riscv@lists.infradead.org, Guo Ren , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , Yipeng Zou Subject: [PATCH -next V17 4/7] riscv: entry: Convert to generic entry Date: Tue, 21 Feb 2023 22:30:18 -0500 Message-Id: <20230222033021.983168-5-guoren@kernel.org> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20230222033021.983168-1-guoren@kernel.org> References: <20230222033021.983168-1-guoren@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20230221_193118_328390_D493661E X-CRM114-Status: GOOD ( 31.08 ) 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 RnJvbTogR3VvIFJlbiA8Z3VvcmVuQGxpbnV4LmFsaWJhYmEuY29tPgoKVGhpcyBwYXRjaCBjb252 ZXJ0cyByaXNjdiB0byB1c2UgdGhlIGdlbmVyaWMgZW50cnkgaW5mcmFzdHJ1Y3R1cmUgZnJvbQpr ZXJuZWwvZW50cnkvKi4gVGhlIGdlbmVyaWMgZW50cnkgbWFrZXMgbWFpbnRhaW5lcnMnIHdvcmsg ZWFzaWVyIGFuZApjb2RlcyBtb3JlIGVsZWdhbnQuIEhlcmUgYXJlIHRoZSBjaGFuZ2VzOgoKIC0g TW9yZSBjbGVhciBlbnRyeS5TIHdpdGggaGFuZGxlX2V4Y2VwdGlvbiBhbmQgcmV0X2Zyb21fZXhj ZXB0aW9uCiAtIEdldCByaWQgb2YgY29tcGxleCBjdXN0b20gc2lnbmFsIGltcGxlbWVudGF0aW9u CiAtIE1vdmUgc3lzY2FsbCBwcm9jZWR1cmUgZnJvbSBhc3NlbWJseSB0byBDLCB3aGljaCBpcyBt dWNoIG1vcmUKICAgcmVhZGFibGUuCiAtIENvbm5lY3QgcmV0X2Zyb21fZm9yayAmIHJldF9mcm9t X2tlcm5lbF90aHJlYWQgdG8gZ2VuZXJpYyBlbnRyeS4KIC0gV3JhcCB3aXRoIGlycWVudHJ5X2Vu dGVyL2V4aXQgYW5kIHN5c2NhbGxfZW50ZXIvZXhpdF9mcm9tX3VzZXJfbW9kZQogLSBVc2UgdGhl IHN0YW5kYXJkIHByZWVtcHRpb24gY29kZSBpbnN0ZWFkIG9mIGN1c3RvbQoKU3VnZ2VzdGVkLWJ5 OiBIdWFjYWkgQ2hlbiA8Y2hlbmh1YWNhaUBrZXJuZWwub3JnPgpSZXZpZXdlZC1ieTogQmrDtnJu IFTDtnBlbCA8Ympvcm5Acml2b3NpbmMuY29tPgpUZXN0ZWQtYnk6IFlpcGVuZyBab3UgPHpvdXlp cGVuZ0BodWF3ZWkuY29tPgpUZXN0ZWQtYnk6IEppc2hlbmcgWmhhbmcgPGpzemhhbmdAa2VybmVs Lm9yZz4KU2lnbmVkLW9mZi1ieTogR3VvIFJlbiA8Z3VvcmVuQGxpbnV4LmFsaWJhYmEuY29tPgpT aWduZWQtb2ZmLWJ5OiBHdW8gUmVuIDxndW9yZW5Aa2VybmVsLm9yZz4KQ2M6IEJlbiBIdXRjaGlu Z3MgPGJlbkBkZWNhZGVudC5vcmcudWs+Ci0tLQogYXJjaC9yaXNjdi9LY29uZmlnICAgICAgICAg ICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvcmlzY3YvaW5jbHVkZS9hc20vYXNtLXByb3RvdHlw ZXMuaCB8ICAgMiArCiBhcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL2Nzci5oICAgICAgICAgICAgfCAg IDEgLQogYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9lbnRyeS1jb21tb24uaCAgIHwgIDExICsrCiBh cmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3B0cmFjZS5oICAgICAgICAgfCAgMTAgKy0KIGFyY2gvcmlz Y3YvaW5jbHVkZS9hc20vc3RhY2t0cmFjZS5oICAgICB8ICAgNSArCiBhcmNoL3Jpc2N2L2luY2x1 ZGUvYXNtL3N5c2NhbGwuaCAgICAgICAgfCAgMjEgKysKIGFyY2gvcmlzY3YvaW5jbHVkZS9hc20v dGhyZWFkX2luZm8uaCAgICB8ICAxMyArLQogYXJjaC9yaXNjdi9rZXJuZWwvZW50cnkuUyAgICAg ICAgICAgICAgIHwgMjQyICsrKystLS0tLS0tLS0tLS0tLS0tLS0tLQogYXJjaC9yaXNjdi9rZXJu ZWwvaGVhZC5oICAgICAgICAgICAgICAgIHwgICAxIC0KIGFyY2gvcmlzY3Yva2VybmVsL3B0cmFj ZS5jICAgICAgICAgICAgICB8ICA0MyAtLS0tLQogYXJjaC9yaXNjdi9rZXJuZWwvc2lnbmFsLmMg ICAgICAgICAgICAgIHwgIDI5ICstLQogYXJjaC9yaXNjdi9rZXJuZWwvdHJhcHMuYyAgICAgICAg ICAgICAgIHwgMTQwICsrKysrKysrKysrKy0tCiBhcmNoL3Jpc2N2L21tL2ZhdWx0LmMgICAgICAg ICAgICAgICAgICAgfCAgIDYgKy0KIDE0IGZpbGVzIGNoYW5nZWQsIDIxMCBpbnNlcnRpb25zKCsp LCAzMTUgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgYXJjaC9yaXNjdi9pbmNsdWRl L2FzbS9lbnRyeS1jb21tb24uaAoKZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvS2NvbmZpZyBiL2Fy Y2gvcmlzY3YvS2NvbmZpZwppbmRleCA4MWViMDMxODg3ZDIuLjdlMjdjOGMwMWFlOCAxMDA2NDQK LS0tIGEvYXJjaC9yaXNjdi9LY29uZmlnCisrKyBiL2FyY2gvcmlzY3YvS2NvbmZpZwpAQCAtNjEs NiArNjEsNyBAQCBjb25maWcgUklTQ1YKIAlzZWxlY3QgR0VORVJJQ19BVE9NSUM2NCBpZiAhNjRC SVQKIAlzZWxlY3QgR0VORVJJQ19DTE9DS0VWRU5UU19CUk9BRENBU1QgaWYgU01QCiAJc2VsZWN0 IEdFTkVSSUNfRUFSTFlfSU9SRU1BUAorCXNlbGVjdCBHRU5FUklDX0VOVFJZCiAJc2VsZWN0IEdF TkVSSUNfR0VUVElNRU9GREFZIGlmIEhBVkVfR0VORVJJQ19WRFNPCiAJc2VsZWN0IEdFTkVSSUNf SURMRV9QT0xMX1NFVFVQCiAJc2VsZWN0IEdFTkVSSUNfSU9SRU1BUCBpZiBNTVUKZGlmZiAtLWdp dCBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vYXNtLXByb3RvdHlwZXMuaCBiL2FyY2gvcmlzY3Yv aW5jbHVkZS9hc20vYXNtLXByb3RvdHlwZXMuaAppbmRleCBlZjM4NmZjZjM5MzkuLjYxYmE4ZWQ0 M2Q4ZiAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9hc20tcHJvdG90eXBlcy5o CisrKyBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vYXNtLXByb3RvdHlwZXMuaApAQCAtMjcsNSAr MjcsNyBAQCBERUNMQVJFX0RPX0VSUk9SX0lORk8oZG9fdHJhcF9icmVhayk7CiAKIGFzbWxpbmth Z2UgdW5zaWduZWQgbG9uZyBnZXRfb3ZlcmZsb3dfc3RhY2sodm9pZCk7CiBhc21saW5rYWdlIHZv aWQgaGFuZGxlX2JhZF9zdGFjayhzdHJ1Y3QgcHRfcmVncyAqcmVncyk7Cithc21saW5rYWdlIHZv aWQgZG9fcGFnZV9mYXVsdChzdHJ1Y3QgcHRfcmVncyAqcmVncyk7Cithc21saW5rYWdlIHZvaWQg ZG9faXJxKHN0cnVjdCBwdF9yZWdzICpyZWdzKTsKIAogI2VuZGlmIC8qIF9BU01fUklTQ1ZfUFJP VE9UWVBFU19IICovCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL2Nzci5oIGIv YXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9jc3IuaAppbmRleCAwZTU3MWY2NDgzZDkuLjdjMmI4Y2Ri N2I3NyAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9jc3IuaAorKysgYi9hcmNo L3Jpc2N2L2luY2x1ZGUvYXNtL2Nzci5oCkBAIC00MCw3ICs0MCw2IEBACiAjZGVmaW5lIFNSX1VY TAkJX0FDKDB4MzAwMDAwMDAwLCBVTCkgLyogWExFTiBtYXNrIGZvciBVLW1vZGUgKi8KICNkZWZp bmUgU1JfVVhMXzMyCV9BQygweDEwMDAwMDAwMCwgVUwpIC8qIFhMRU4gPSAzMiBmb3IgVS1tb2Rl ICovCiAjZGVmaW5lIFNSX1VYTF82NAlfQUMoMHgyMDAwMDAwMDAsIFVMKSAvKiBYTEVOID0gNjQg Zm9yIFUtbW9kZSAqLwotI2RlZmluZSBTUl9VWExfU0hJRlQJMzIKICNlbmRpZgogCiAvKiBTQVRQ IGZsYWdzICovCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL2VudHJ5LWNvbW1v bi5oIGIvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9lbnRyeS1jb21tb24uaApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjZlNGRlZTQ5ZDg0YgotLS0gL2Rldi9udWxsCisr KyBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vZW50cnktY29tbW9uLmgKQEAgLTAsMCArMSwxMSBA QAorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgKi8KKworI2lmbmRlZiBfQVNN X1JJU0NWX0VOVFJZX0NPTU1PTl9ICisjZGVmaW5lIF9BU01fUklTQ1ZfRU5UUllfQ09NTU9OX0gK KworI2luY2x1ZGUgPGFzbS9zdGFja3RyYWNlLmg+CisKK3ZvaWQgaGFuZGxlX3BhZ2VfZmF1bHQo c3RydWN0IHB0X3JlZ3MgKnJlZ3MpOwordm9pZCBoYW5kbGVfYnJlYWsoc3RydWN0IHB0X3JlZ3Mg KnJlZ3MpOworCisjZW5kaWYgLyogX0FTTV9SSVNDVl9FTlRSWV9DT01NT05fSCAqLwpkaWZmIC0t Z2l0IGEvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9wdHJhY2UuaCBiL2FyY2gvcmlzY3YvaW5jbHVk ZS9hc20vcHRyYWNlLmgKaW5kZXggNmVjZDQ2MTEyOWQyLi5iNWIwYWRjYzg1YzEgMTAwNjQ0Ci0t LSBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vcHRyYWNlLmgKKysrIGIvYXJjaC9yaXNjdi9pbmNs dWRlL2FzbS9wdHJhY2UuaApAQCAtNTMsNiArNTMsOSBAQCBzdHJ1Y3QgcHRfcmVncyB7CiAJdW5z aWduZWQgbG9uZyBvcmlnX2EwOwogfTsKIAorI2RlZmluZSBQVFJBQ0VfU1lTRU1VCQkJMHgxZgor I2RlZmluZSBQVFJBQ0VfU1lTRU1VX1NJTkdMRVNURVAJMHgyMAorCiAjaWZkZWYgQ09ORklHXzY0 QklUCiAjZGVmaW5lIFJFR19GTVQgIiUwMTZseCIKICNlbHNlCkBAIC0xMjEsOCArMTI0LDYgQEAg ZXh0ZXJuIHVuc2lnbmVkIGxvbmcgcmVnc19nZXRfa2VybmVsX3N0YWNrX250aChzdHJ1Y3QgcHRf cmVncyAqcmVncywKIAogdm9pZCBwcmVwYXJlX2Z0cmFjZV9yZXR1cm4odW5zaWduZWQgbG9uZyAq cGFyZW50LCB1bnNpZ25lZCBsb25nIHNlbGZfYWRkciwKIAkJCSAgIHVuc2lnbmVkIGxvbmcgZnJh bWVfcG9pbnRlcik7Ci1pbnQgZG9fc3lzY2FsbF90cmFjZV9lbnRlcihzdHJ1Y3QgcHRfcmVncyAq cmVncyk7Ci12b2lkIGRvX3N5c2NhbGxfdHJhY2VfZXhpdChzdHJ1Y3QgcHRfcmVncyAqcmVncyk7 CiAKIC8qKgogICogcmVnc19nZXRfcmVnaXN0ZXIoKSAtIGdldCByZWdpc3RlciB2YWx1ZSBmcm9t IGl0cyBvZmZzZXQKQEAgLTE3Miw2ICsxNzMsMTEgQEAgc3RhdGljIGlubGluZSB1bnNpZ25lZCBs b25nIHJlZ3NfZ2V0X2tlcm5lbF9hcmd1bWVudChzdHJ1Y3QgcHRfcmVncyAqcmVncywKIAlyZXR1 cm4gMDsKIH0KIAorc3RhdGljIGlubGluZSBpbnQgcmVnc19pcnFzX2Rpc2FibGVkKHN0cnVjdCBw dF9yZWdzICpyZWdzKQoreworCXJldHVybiAhKHJlZ3MtPnN0YXR1cyAmIFNSX1BJRSk7Cit9CisK ICNlbmRpZiAvKiBfX0FTU0VNQkxZX18gKi8KIAogI2VuZGlmIC8qIF9BU01fUklTQ1ZfUFRSQUNF X0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vc3RhY2t0cmFjZS5oIGIv YXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9zdGFja3RyYWNlLmgKaW5kZXggMzQ1MGMxOTEyYWZkLi5m N2U4ZWYyNDE4YjkgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vc3RhY2t0cmFj ZS5oCisrKyBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vc3RhY2t0cmFjZS5oCkBAIC0xNiw0ICsx Niw5IEBAIGV4dGVybiB2b2lkIG5vdHJhY2Ugd2Fsa19zdGFja2ZyYW1lKHN0cnVjdCB0YXNrX3N0 cnVjdCAqdGFzaywgc3RydWN0IHB0X3JlZ3MgKnJlCiBleHRlcm4gdm9pZCBkdW1wX2JhY2t0cmFj ZShzdHJ1Y3QgcHRfcmVncyAqcmVncywgc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLAogCQkJICAg Y29uc3QgY2hhciAqbG9nbHZsKTsKIAorc3RhdGljIGlubGluZSBib29sIG9uX3RocmVhZF9zdGFj ayh2b2lkKQoreworCXJldHVybiAhKCgodW5zaWduZWQgbG9uZykoY3VycmVudC0+c3RhY2spIF4g Y3VycmVudF9zdGFja19wb2ludGVyKSAmIH4oVEhSRUFEX1NJWkUgLSAxKSk7Cit9CisKICNlbmRp ZiAvKiBfQVNNX1JJU0NWX1NUQUNLVFJBQ0VfSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9p bmNsdWRlL2FzbS9zeXNjYWxsLmggYi9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3N5c2NhbGwuaApp bmRleCAzODRhNjNiODY0MjAuLjczNjExMGUxZmQ3OCAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9p bmNsdWRlL2FzbS9zeXNjYWxsLmgKKysrIGIvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9zeXNjYWxs LmgKQEAgLTc0LDUgKzc0LDI2IEBAIHN0YXRpYyBpbmxpbmUgaW50IHN5c2NhbGxfZ2V0X2FyY2go c3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQogI2VuZGlmCiB9CiAKK3R5cGVkZWYgbG9uZyAoKnN5 c2NhbGxfdCkodWxvbmcsIHVsb25nLCB1bG9uZywgdWxvbmcsIHVsb25nLCB1bG9uZywgdWxvbmcp Oworc3RhdGljIGlubGluZSB2b2lkIHN5c2NhbGxfaGFuZGxlcihzdHJ1Y3QgcHRfcmVncyAqcmVn cywgdWxvbmcgc3lzY2FsbCkKK3sKKwlzeXNjYWxsX3QgZm47CisKKyNpZmRlZiBDT05GSUdfQ09N UEFUCisJaWYgKChyZWdzLT5zdGF0dXMgJiBTUl9VWEwpID09IFNSX1VYTF8zMikKKwkJZm4gPSBj b21wYXRfc3lzX2NhbGxfdGFibGVbc3lzY2FsbF07CisJZWxzZQorI2VuZGlmCisJCWZuID0gc3lz X2NhbGxfdGFibGVbc3lzY2FsbF07CisKKwlyZWdzLT5hMCA9IGZuKHJlZ3MtPm9yaWdfYTAsIHJl Z3MtPmExLCByZWdzLT5hMiwKKwkJICAgICAgcmVncy0+YTMsIHJlZ3MtPmE0LCByZWdzLT5hNSwg cmVncy0+YTYpOworfQorCitzdGF0aWMgaW5saW5lIGJvb2wgYXJjaF9zeXNjYWxsX2lzX3Zkc29f c2lncmV0dXJuKHN0cnVjdCBwdF9yZWdzICpyZWdzKQoreworCXJldHVybiBmYWxzZTsKK30KKwog YXNtbGlua2FnZSBsb25nIHN5c19yaXNjdl9mbHVzaF9pY2FjaGUodWludHB0cl90LCB1aW50cHRy X3QsIHVpbnRwdHJfdCk7CiAjZW5kaWYJLyogX0FTTV9SSVNDVl9TWVNDQUxMX0ggKi8KZGlmZiAt LWdpdCBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vdGhyZWFkX2luZm8uaCBiL2FyY2gvcmlzY3Yv aW5jbHVkZS9hc20vdGhyZWFkX2luZm8uaAppbmRleCBmNzA0YzhkZDU3ZTAuLmUwZDIwMjEzNGI0 NCAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS90aHJlYWRfaW5mby5oCisrKyBi L2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vdGhyZWFkX2luZm8uaApAQCAtNjcsNiArNjcsNyBAQCBz dHJ1Y3QgdGhyZWFkX2luZm8gewogCWxvbmcJCQlrZXJuZWxfc3A7CS8qIEtlcm5lbCBzdGFjayBw b2ludGVyICovCiAJbG9uZwkJCXVzZXJfc3A7CS8qIFVzZXIgc3RhY2sgcG9pbnRlciAqLwogCWlu dAkJCWNwdTsKKwl1bnNpZ25lZCBsb25nCQlzeXNjYWxsX3dvcms7CS8qIFNZU0NBTExfV09SS18g ZmxhZ3MgKi8KIH07CiAKIC8qCkBAIC04OSwyNiArOTAsMTggQEAgc3RydWN0IHRocmVhZF9pbmZv IHsKICAqIC0gcGVuZGluZyB3b3JrLXRvLWJlLWRvbmUgZmxhZ3MgYXJlIGluIGxvd2VzdCBoYWxm LXdvcmQKICAqIC0gb3RoZXIgZmxhZ3MgaW4gdXBwZXIgaGFsZi13b3JkKHMpCiAgKi8KLSNkZWZp bmUgVElGX1NZU0NBTExfVFJBQ0UJMAkvKiBzeXNjYWxsIHRyYWNlIGFjdGl2ZSAqLwogI2RlZmlu ZSBUSUZfTk9USUZZX1JFU1VNRQkxCS8qIGNhbGxiYWNrIGJlZm9yZSByZXR1cm5pbmcgdG8gdXNl ciAqLwogI2RlZmluZSBUSUZfU0lHUEVORElORwkJMgkvKiBzaWduYWwgcGVuZGluZyAqLwogI2Rl ZmluZSBUSUZfTkVFRF9SRVNDSEVECTMJLyogcmVzY2hlZHVsaW5nIG5lY2Vzc2FyeSAqLwogI2Rl ZmluZSBUSUZfUkVTVE9SRV9TSUdNQVNLCTQJLyogcmVzdG9yZSBzaWduYWwgbWFzayBpbiBkb19z aWduYWwoKSAqLwogI2RlZmluZSBUSUZfTUVNRElFCQk1CS8qIGlzIHRlcm1pbmF0aW5nIGR1ZSB0 byBPT00ga2lsbGVyICovCi0jZGVmaW5lIFRJRl9TWVNDQUxMX1RSQUNFUE9JTlQgIDYgICAgICAg Lyogc3lzY2FsbCB0cmFjZXBvaW50IGluc3RydW1lbnRhdGlvbiAqLwotI2RlZmluZSBUSUZfU1lT Q0FMTF9BVURJVAk3CS8qIHN5c2NhbGwgYXVkaXRpbmcgKi8KLSNkZWZpbmUgVElGX1NFQ0NPTVAJ CTgJLyogc3lzY2FsbCBzZWN1cmUgY29tcHV0aW5nICovCiAjZGVmaW5lIFRJRl9OT1RJRllfU0lH TkFMCTkJLyogc2lnbmFsIG5vdGlmaWNhdGlvbnMgZXhpc3QgKi8KICNkZWZpbmUgVElGX1VQUk9C RQkJMTAJLyogdXByb2JlIGJyZWFrcG9pbnQgb3Igc2luZ2xlc3RlcCAqLwogI2RlZmluZSBUSUZf MzJCSVQJCTExCS8qIGNvbXBhdC1tb2RlIDMyYml0IHByb2Nlc3MgKi8KIAotI2RlZmluZSBfVElG X1NZU0NBTExfVFJBQ0UJKDEgPDwgVElGX1NZU0NBTExfVFJBQ0UpCiAjZGVmaW5lIF9USUZfTk9U SUZZX1JFU1VNRQkoMSA8PCBUSUZfTk9USUZZX1JFU1VNRSkKICNkZWZpbmUgX1RJRl9TSUdQRU5E SU5HCQkoMSA8PCBUSUZfU0lHUEVORElORykKICNkZWZpbmUgX1RJRl9ORUVEX1JFU0NIRUQJKDEg PDwgVElGX05FRURfUkVTQ0hFRCkKLSNkZWZpbmUgX1RJRl9TWVNDQUxMX1RSQUNFUE9JTlQJKDEg PDwgVElGX1NZU0NBTExfVFJBQ0VQT0lOVCkKLSNkZWZpbmUgX1RJRl9TWVNDQUxMX0FVRElUCSgx IDw8IFRJRl9TWVNDQUxMX0FVRElUKQotI2RlZmluZSBfVElGX1NFQ0NPTVAJCSgxIDw8IFRJRl9T RUNDT01QKQogI2RlZmluZSBfVElGX05PVElGWV9TSUdOQUwJKDEgPDwgVElGX05PVElGWV9TSUdO QUwpCiAjZGVmaW5lIF9USUZfVVBST0JFCQkoMSA8PCBUSUZfVVBST0JFKQogCkBAIC0xMTYsOCAr MTA5LDQgQEAgc3RydWN0IHRocmVhZF9pbmZvIHsKIAkoX1RJRl9OT1RJRllfUkVTVU1FIHwgX1RJ Rl9TSUdQRU5ESU5HIHwgX1RJRl9ORUVEX1JFU0NIRUQgfCBcCiAJIF9USUZfTk9USUZZX1NJR05B TCB8IF9USUZfVVBST0JFKQogCi0jZGVmaW5lIF9USUZfU1lTQ0FMTF9XT1JLIFwKLQkoX1RJRl9T WVNDQUxMX1RSQUNFIHwgX1RJRl9TWVNDQUxMX1RSQUNFUE9JTlQgfCBfVElGX1NZU0NBTExfQVVE SVQgfCBcCi0JIF9USUZfU0VDQ09NUCkKLQogI2VuZGlmIC8qIF9BU01fUklTQ1ZfVEhSRUFEX0lO Rk9fSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJuZWwvZW50cnkuUyBiL2FyY2gvcmlz Y3Yva2VybmVsL2VudHJ5LlMKaW5kZXggOTlkMzhmZGY4YjE4Li5iYzMyMmY5MmJhMzQgMTAwNjQ0 Ci0tLSBhL2FyY2gvcmlzY3Yva2VybmVsL2VudHJ5LlMKKysrIGIvYXJjaC9yaXNjdi9rZXJuZWwv ZW50cnkuUwpAQCAtMTQsMTEgKzE0LDcgQEAKICNpbmNsdWRlIDxhc20vYXNtLW9mZnNldHMuaD4K ICNpbmNsdWRlIDxhc20vZXJyYXRhX2xpc3QuaD4KIAotI2lmICFJU19FTkFCTEVEKENPTkZJR19Q UkVFTVBUSU9OKQotLnNldCByZXN1bWVfa2VybmVsLCByZXN0b3JlX2FsbAotI2VuZGlmCi0KLUVO VFJZKGhhbmRsZV9leGNlcHRpb24pCitTWU1fQ09ERV9TVEFSVChoYW5kbGVfZXhjZXB0aW9uKQog CS8qCiAJICogSWYgY29taW5nIGZyb20gdXNlcnNwYWNlLCBwcmVzZXJ2ZSB0aGUgdXNlciB0aHJl YWQgcG9pbnRlciBhbmQgbG9hZAogCSAqIHRoZSBrZXJuZWwgdGhyZWFkIHBvaW50ZXIuICBJZiB3 ZSBjYW1lIGZyb20gdGhlIGtlcm5lbCwgdGhlIHNjcmF0Y2gKQEAgLTEwNiwxOSArMTAyLDggQEAg X3NhdmVfY29udGV4dDoKIC5vcHRpb24gbm9yZWxheAogCWxhIGdwLCBfX2dsb2JhbF9wb2ludGVy JAogLm9wdGlvbiBwb3AKLQotI2lmZGVmIENPTkZJR19UUkFDRV9JUlFGTEFHUwotCWNhbGwgX190 cmFjZV9oYXJkaXJxc19vZmYKLSNlbmRpZgotCi0jaWZkZWYgQ09ORklHX0NPTlRFWFRfVFJBQ0tJ TkdfVVNFUgotCS8qIElmIHByZXZpb3VzIHN0YXRlIGlzIGluIHVzZXIgbW9kZSwgY2FsbCB1c2Vy X2V4aXRfY2FsbGFibGUoKS4gKi8KLQlsaSAgIGEwLCBTUl9QUAotCWFuZCBhMCwgczEsIGEwCi0J Ym5leiBhMCwgc2tpcF9jb250ZXh0X3RyYWNraW5nCi0JY2FsbCB1c2VyX2V4aXRfY2FsbGFibGUK LXNraXBfY29udGV4dF90cmFja2luZzoKLSNlbmRpZgorCW1vdmUgYTAsIHNwIC8qIHB0X3JlZ3Mg Ki8KKwlsYSByYSwgcmV0X2Zyb21fZXhjZXB0aW9uCiAKIAkvKgogCSAqIE1TQiBvZiBjYXVzZSBk aWZmZXJlbnRpYXRlcyBiZXR3ZWVuCkBAIC0xMjYsMzggKzExMSwxMyBAQCBza2lwX2NvbnRleHRf dHJhY2tpbmc6CiAJICovCiAJYmdlIHM0LCB6ZXJvLCAxZgogCi0JbGEgcmEsIHJldF9mcm9tX2V4 Y2VwdGlvbgotCiAJLyogSGFuZGxlIGludGVycnVwdHMgKi8KLQltb3ZlIGEwLCBzcCAvKiBwdF9y ZWdzICovCi0JbGEgYTEsIGdlbmVyaWNfaGFuZGxlX2FyY2hfaXJxCi0JanIgYTEKLTE6Ci0JLyoK LQkgKiBFeGNlcHRpb25zIHJ1biB3aXRoIGludGVycnVwdHMgZW5hYmxlZCBvciBkaXNhYmxlZCBk ZXBlbmRpbmcgb24gdGhlCi0JICogc3RhdGUgb2YgU1JfUElFIGluIG0vc3N0YXR1cy4KLQkgKi8K LQlhbmRpIHQwLCBzMSwgU1JfUElFCi0JYmVxeiB0MCwgMWYKLQkvKiBrcHJvYmVzLCBlbnRlcmVk IHZpYSBlYnJlYWssIG11c3QgaGF2ZSBpbnRlcnJ1cHRzIGRpc2FibGVkLiAqLwotCWxpIHQwLCBF WENfQlJFQUtQT0lOVAotCWJlcSBzNCwgdDAsIDFmCi0jaWZkZWYgQ09ORklHX1RSQUNFX0lSUUZM QUdTCi0JY2FsbCBfX3RyYWNlX2hhcmRpcnFzX29uCi0jZW5kaWYKLQljc3JzIENTUl9TVEFUVVMs IFNSX0lFCi0KKwl0YWlsIGRvX2lycQogMToKLQlsYSByYSwgcmV0X2Zyb21fZXhjZXB0aW9uCi0J LyogSGFuZGxlIHN5c2NhbGxzICovCi0JbGkgdDAsIEVYQ19TWVNDQUxMCi0JYmVxIHM0LCB0MCwg aGFuZGxlX3N5c2NhbGwKLQogCS8qIEhhbmRsZSBvdGhlciBleGNlcHRpb25zICovCiAJc2xsaSB0 MCwgczQsIFJJU0NWX0xHUFRSCiAJbGEgdDEsIGV4Y3BfdmVjdF90YWJsZQogCWxhIHQyLCBleGNw X3ZlY3RfdGFibGVfZW5kCi0JbW92ZSBhMCwgc3AgLyogcHRfcmVncyAqLwogCWFkZCB0MCwgdDEs IHQwCiAJLyogQ2hlY2sgaWYgZXhjZXB0aW9uIGNvZGUgbGllcyB3aXRoaW4gYm91bmRzICovCiAJ YmdldSB0MCwgdDIsIDFmCkBAIC0xNjUsOTUgKzEyNSwxNyBAQCBza2lwX2NvbnRleHRfdHJhY2tp bmc6CiAJanIgdDAKIDE6CiAJdGFpbCBkb190cmFwX3Vua25vd24KK1NZTV9DT0RFX0VORChoYW5k bGVfZXhjZXB0aW9uKQogCi1oYW5kbGVfc3lzY2FsbDoKLSNpZmRlZiBDT05GSUdfUklTQ1ZfTV9N T0RFCi0JLyoKLQkgKiBXaGVuIHJ1bm5pbmcgaXMgTS1Nb2RlIChubyBNTVUgY29uZmlnKSwgTVBJ RSBkb2VzIG5vdCBnZXQgc2V0LgotCSAqIEFzIGEgcmVzdWx0LCB3ZSBuZWVkIHRvIGZvcmNlIGVu YWJsZSBpbnRlcnJ1cHRzIGhlcmUgYmVjYXVzZQotCSAqIGhhbmRsZV9leGNlcHRpb24gZGlkIG5v dCBkbyBzZXQgU1JfSUUgYXMgaXQgYWx3YXlzIHNlZXMgU1JfUElFCi0JICogYmVpbmcgY2xlYXJl ZC4KLQkgKi8KLQljc3JzIENTUl9TVEFUVVMsIFNSX0lFCi0jZW5kaWYKLSNpZiBkZWZpbmVkKENP TkZJR19UUkFDRV9JUlFGTEFHUykgfHwgZGVmaW5lZChDT05GSUdfQ09OVEVYVF9UUkFDS0lOR19V U0VSKQotCS8qIFJlY292ZXIgYTAgLSBhNyBmb3Igc3lzdGVtIGNhbGxzICovCi0JUkVHX0wgYTAs IFBUX0EwKHNwKQotCVJFR19MIGExLCBQVF9BMShzcCkKLQlSRUdfTCBhMiwgUFRfQTIoc3ApCi0J UkVHX0wgYTMsIFBUX0EzKHNwKQotCVJFR19MIGE0LCBQVF9BNChzcCkKLQlSRUdfTCBhNSwgUFRf QTUoc3ApCi0JUkVHX0wgYTYsIFBUX0E2KHNwKQotCVJFR19MIGE3LCBQVF9BNyhzcCkKLSNlbmRp ZgotCSAvKiBzYXZlIHRoZSBpbml0aWFsIEEwIHZhbHVlIChuZWVkZWQgaW4gc2lnbmFsIGhhbmRs ZXJzKSAqLwotCVJFR19TIGEwLCBQVF9PUklHX0EwKHNwKQotCS8qCi0JICogQWR2YW5jZSBTRVBD IHRvIGF2b2lkIGV4ZWN1dGluZyB0aGUgb3JpZ2luYWwKLQkgKiBzY2FsbCBpbnN0cnVjdGlvbiBv biBzcmV0Ci0JICovCi0JYWRkaSBzMiwgczIsIDB4NAotCVJFR19TIHMyLCBQVF9FUEMoc3ApCi0J LyogVHJhY2Ugc3lzY2FsbHMsIGJ1dCBvbmx5IGlmIHJlcXVlc3RlZCBieSB0aGUgdXNlci4gKi8K LQlSRUdfTCB0MCwgVEFTS19USV9GTEFHUyh0cCkKLQlhbmRpIHQwLCB0MCwgX1RJRl9TWVNDQUxM X1dPUksKLQlibmV6IHQwLCBoYW5kbGVfc3lzY2FsbF90cmFjZV9lbnRlcgotY2hlY2tfc3lzY2Fs bF9ucjoKLQkvKiBDaGVjayB0byBtYWtlIHN1cmUgd2UgZG9uJ3QganVtcCB0byBhIGJvZ3VzIHN5 c2NhbGwgbnVtYmVyLiAqLwotCWxpIHQwLCBfX05SX3N5c2NhbGxzCi0JbGEgczAsIHN5c19uaV9z eXNjYWxsCi0JLyoKLQkgKiBTeXNjYWxsIG51bWJlciBoZWxkIGluIGE3LgotCSAqIElmIHN5c2Nh bGwgbnVtYmVyIGlzIGFib3ZlIGFsbG93ZWQgdmFsdWUsIHJlZGlyZWN0IHRvIG5pX3N5c2NhbGwu Ci0JICovCi0JYmdldSBhNywgdDAsIDNmCi0jaWZkZWYgQ09ORklHX0NPTVBBVAotCVJFR19MIHMw LCBQVF9TVEFUVVMoc3ApCi0Jc3JsaSBzMCwgczAsIFNSX1VYTF9TSElGVAotCWFuZGkgczAsIHMw LCAoU1JfVVhMID4+IFNSX1VYTF9TSElGVCkKLQlsaSB0MCwgKFNSX1VYTF8zMiA+PiBTUl9VWExf U0hJRlQpCi0Jc3ViIHQwLCBzMCwgdDAKLQlibmV6IHQwLCAxZgotCi0JLyogQ2FsbCBjb21wYXRf c3lzY2FsbCAqLwotCWxhIHMwLCBjb21wYXRfc3lzX2NhbGxfdGFibGUKLQlqIDJmCi0xOgotI2Vu ZGlmCi0JLyogQ2FsbCBzeXNjYWxsICovCi0JbGEgczAsIHN5c19jYWxsX3RhYmxlCi0yOgotCXNs bGkgdDAsIGE3LCBSSVNDVl9MR1BUUgotCWFkZCBzMCwgczAsIHQwCi0JUkVHX0wgczAsIDAoczAp Ci0zOgotCWphbHIgczAKLQotcmV0X2Zyb21fc3lzY2FsbDoKLQkvKiBTZXQgdXNlciBhMCB0byBr ZXJuZWwgYTAgKi8KLQlSRUdfUyBhMCwgUFRfQTAoc3ApCi0JLyoKLQkgKiBXZSBkaWRuJ3QgZXhl Y3V0ZSB0aGUgYWN0dWFsIHN5c2NhbGwuCi0JICogU2VjY29tcCBhbHJlYWR5IHNldCByZXR1cm4g dmFsdWUgZm9yIHRoZSBjdXJyZW50IHRhc2sgcHRfcmVncy4KLQkgKiAoSWYgaXQgd2FzIGNvbmZp Z3VyZWQgd2l0aCBTRUNDT01QX1JFVF9FUlJOTy9UUkFDRSkKLQkgKi8KLXJldF9mcm9tX3N5c2Nh bGxfcmVqZWN0ZWQ6Ci0jaWZkZWYgQ09ORklHX0RFQlVHX1JTRVEKLQltb3ZlIGEwLCBzcAotCWNh bGwgcnNlcV9zeXNjYWxsCi0jZW5kaWYKLQkvKiBUcmFjZSBzeXNjYWxscywgYnV0IG9ubHkgaWYg cmVxdWVzdGVkIGJ5IHRoZSB1c2VyLiAqLwotCVJFR19MIHQwLCBUQVNLX1RJX0ZMQUdTKHRwKQot CWFuZGkgdDAsIHQwLCBfVElGX1NZU0NBTExfV09SSwotCWJuZXogdDAsIGhhbmRsZV9zeXNjYWxs X3RyYWNlX2V4aXQKLQorLyoKKyAqIFRoZSByZXRfZnJvbV9leGNlcHRpb24gbXVzdCBiZSBjYWxs ZWQgd2l0aCBpbnRlcnJ1cHQgZGlzYWJsZWQuIEhlcmUgaXMgdGhlCisgKiBjYWxsZXIgbGlzdDoK KyAqICAtIGhhbmRsZV9leGNlcHRpb24KKyAqICAtIHJldF9mcm9tX2ZvcmsKKyAqICAtIHJldF9m cm9tX2tlcm5lbF90aHJlYWQKKyAqLwogU1lNX0NPREVfU1RBUlRfTk9BTElHTihyZXRfZnJvbV9l eGNlcHRpb24pCiAJUkVHX0wgczAsIFBUX1NUQVRVUyhzcCkKLQljc3JjIENTUl9TVEFUVVMsIFNS X0lFCi0jaWZkZWYgQ09ORklHX1RSQUNFX0lSUUZMQUdTCi0JY2FsbCBfX3RyYWNlX2hhcmRpcnFz X29mZgotI2VuZGlmCiAjaWZkZWYgQ09ORklHX1JJU0NWX01fTU9ERQogCS8qIHRoZSBNUFAgdmFs dWUgaXMgdG9vIGxhcmdlIHRvIGJlIHVzZWQgYXMgYW4gaW1tZWRpYXRlIGFyZyBmb3IgYWRkaSAq LwogCWxpIHQwLCBTUl9NUFAKQEAgLTI2MSwxNyArMTQzLDcgQEAgU1lNX0NPREVfU1RBUlRfTk9B TElHTihyZXRfZnJvbV9leGNlcHRpb24pCiAjZWxzZQogCWFuZGkgczAsIHMwLCBTUl9TUFAKICNl bmRpZgotCWJuZXogczAsIHJlc3VtZV9rZXJuZWwKLVNZTV9DT0RFX0VORChyZXRfZnJvbV9leGNl cHRpb24pCi0KLQkvKiBJbnRlcnJ1cHRzIG11c3QgYmUgZGlzYWJsZWQgaGVyZSBzbyBmbGFncyBh cmUgY2hlY2tlZCBhdG9taWNhbGx5ICovCi0JUkVHX0wgczAsIFRBU0tfVElfRkxBR1ModHApIC8q IGN1cnJlbnRfdGhyZWFkX2luZm8tPmZsYWdzICovCi0JYW5kaSBzMSwgczAsIF9USUZfV09SS19N QVNLCi0JYm5leiBzMSwgcmVzdW1lX3VzZXJzcGFjZV9zbG93Ci1yZXN1bWVfdXNlcnNwYWNlOgot I2lmZGVmIENPTkZJR19DT05URVhUX1RSQUNLSU5HX1VTRVIKLQljYWxsIHVzZXJfZW50ZXJfY2Fs bGFibGUKLSNlbmRpZgorCWJuZXogczAsIDFmCiAKIAkvKiBTYXZlIHVud291bmQga2VybmVsIHN0 YWNrIHBvaW50ZXIgaW4gdGhyZWFkX2luZm8gKi8KIAlhZGRpIHMwLCBzcCwgUFRfU0laRV9PTl9T VEFDSwpAQCAtMjgyLDE4ICsxNTQsNyBAQCByZXN1bWVfdXNlcnNwYWNlOgogCSAqIHN0cnVjdHVy ZXMgYWdhaW4uCiAJICovCiAJY3NydyBDU1JfU0NSQVRDSCwgdHAKLQotcmVzdG9yZV9hbGw6Ci0j aWZkZWYgQ09ORklHX1RSQUNFX0lSUUZMQUdTCi0JUkVHX0wgczEsIFBUX1NUQVRVUyhzcCkKLQlh bmRpIHQwLCBzMSwgU1JfUElFCi0JYmVxeiB0MCwgMWYKLQljYWxsIF9fdHJhY2VfaGFyZGlycXNf b24KLQlqIDJmCiAxOgotCWNhbGwgX190cmFjZV9oYXJkaXJxc19vZmYKLTI6Ci0jZW5kaWYKIAlS RUdfTCBhMCwgUFRfU1RBVFVTKHNwKQogCS8qCiAJICogVGhlIGN1cnJlbnQgbG9hZCByZXNlcnZh dGlvbiBpcyBlZmZlY3RpdmVseSBwYXJ0IG9mIHRoZSBwcm9jZXNzb3IncwpAQCAtMzU2LDQ3ICsy MTcsMTAgQEAgcmVzdG9yZV9hbGw6CiAjZWxzZQogCXNyZXQKICNlbmRpZgotCi0jaWYgSVNfRU5B QkxFRChDT05GSUdfUFJFRU1QVElPTikKLXJlc3VtZV9rZXJuZWw6Ci0JUkVHX0wgczAsIFRBU0tf VElfUFJFRU1QVF9DT1VOVCh0cCkKLQlibmV6IHMwLCByZXN0b3JlX2FsbAotCVJFR19MIHMwLCBU QVNLX1RJX0ZMQUdTKHRwKQotCWFuZGkgczAsIHMwLCBfVElGX05FRURfUkVTQ0hFRAotCWJlcXog czAsIHJlc3RvcmVfYWxsCi0JY2FsbCBwcmVlbXB0X3NjaGVkdWxlX2lycQotCWogcmVzdG9yZV9h bGwKLSNlbmRpZgotCi1yZXN1bWVfdXNlcnNwYWNlX3Nsb3c6Ci0JLyogRW50ZXIgc2xvdyBwYXRo IGZvciBzdXBwbGVtZW50YXJ5IHByb2Nlc3NpbmcgKi8KLQltb3ZlIGEwLCBzcCAvKiBwdF9yZWdz ICovCi0JbW92ZSBhMSwgczAgLyogY3VycmVudF90aHJlYWRfaW5mby0+ZmxhZ3MgKi8KLQljYWxs IGRvX3dvcmtfcGVuZGluZwotCWogcmVzdW1lX3VzZXJzcGFjZQotCi0vKiBTbG93IHBhdGhzIGZv ciBwdHJhY2UuICovCi1oYW5kbGVfc3lzY2FsbF90cmFjZV9lbnRlcjoKLQltb3ZlIGEwLCBzcAot CWNhbGwgZG9fc3lzY2FsbF90cmFjZV9lbnRlcgotCW1vdmUgdDAsIGEwCi0JUkVHX0wgYTAsIFBU X0EwKHNwKQotCVJFR19MIGExLCBQVF9BMShzcCkKLQlSRUdfTCBhMiwgUFRfQTIoc3ApCi0JUkVH X0wgYTMsIFBUX0EzKHNwKQotCVJFR19MIGE0LCBQVF9BNChzcCkKLQlSRUdfTCBhNSwgUFRfQTUo c3ApCi0JUkVHX0wgYTYsIFBUX0E2KHNwKQotCVJFR19MIGE3LCBQVF9BNyhzcCkKLQlibmV6IHQw LCByZXRfZnJvbV9zeXNjYWxsX3JlamVjdGVkCi0JaiBjaGVja19zeXNjYWxsX25yCi1oYW5kbGVf c3lzY2FsbF90cmFjZV9leGl0OgotCW1vdmUgYTAsIHNwCi0JY2FsbCBkb19zeXNjYWxsX3RyYWNl X2V4aXQKLQlqIHJldF9mcm9tX2V4Y2VwdGlvbgorU1lNX0NPREVfRU5EKHJldF9mcm9tX2V4Y2Vw dGlvbikKIAogI2lmZGVmIENPTkZJR19WTUFQX1NUQUNLCi1oYW5kbGVfa2VybmVsX3N0YWNrX292 ZXJmbG93OgorU1lNX0NPREVfU1RBUlRfTE9DQUwoaGFuZGxlX2tlcm5lbF9zdGFja19vdmVyZmxv dykKIAkvKgogCSAqIFRha2VzIHRoZSBwc3VlZG8tc3BpbmxvY2sgZm9yIHRoZSBzaGFkb3cgc3Rh Y2ssIGluIGNhc2UgbXVsdGlwbGUKIAkgKiBoYXJ0cyBhcmUgY29uY3VycmVudGx5IG92ZXJmbG93 aW5nIHRoZWlyIGtlcm5lbCBzdGFja3MuICBXZSBjb3VsZApAQCAtNTA1LDIzICszMjksMjUgQEAg cmVzdG9yZV9jYWxsZXJfcmVnOgogCVJFR19TIHM1LCBQVF9UUChzcCkKIAltb3ZlIGEwLCBzcAog CXRhaWwgaGFuZGxlX2JhZF9zdGFjaworU1lNX0NPREVfRU5EKGhhbmRsZV9rZXJuZWxfc3RhY2tf b3ZlcmZsb3cpCiAjZW5kaWYKIAotRU5EKGhhbmRsZV9leGNlcHRpb24pCi0KLUVOVFJZKHJldF9m cm9tX2ZvcmspCitTWU1fQ09ERV9TVEFSVChyZXRfZnJvbV9mb3JrKQorCWNhbGwgc2NoZWR1bGVf dGFpbAorCW1vdmUgYTAsIHNwIC8qIHB0X3JlZ3MgKi8KIAlsYSByYSwgcmV0X2Zyb21fZXhjZXB0 aW9uCi0JdGFpbCBzY2hlZHVsZV90YWlsCi1FTkRQUk9DKHJldF9mcm9tX2ZvcmspCisJdGFpbCBz eXNjYWxsX2V4aXRfdG9fdXNlcl9tb2RlCitTWU1fQ09ERV9FTkQocmV0X2Zyb21fZm9yaykKIAot RU5UUlkocmV0X2Zyb21fa2VybmVsX3RocmVhZCkKK1NZTV9DT0RFX1NUQVJUKHJldF9mcm9tX2tl cm5lbF90aHJlYWQpCiAJY2FsbCBzY2hlZHVsZV90YWlsCiAJLyogQ2FsbCBmbihhcmcpICovCi0J bGEgcmEsIHJldF9mcm9tX2V4Y2VwdGlvbgogCW1vdmUgYTAsIHMxCi0JanIgczAKLUVORFBST0Mo cmV0X2Zyb21fa2VybmVsX3RocmVhZCkKLQorCWphbHIgczAKKwltb3ZlIGEwLCBzcCAvKiBwdF9y ZWdzICovCisJbGEgcmEsIHJldF9mcm9tX2V4Y2VwdGlvbgorCXRhaWwgc3lzY2FsbF9leGl0X3Rv X3VzZXJfbW9kZQorU1lNX0NPREVfRU5EKHJldF9mcm9tX2tlcm5lbF90aHJlYWQpCiAKIC8qCiAg KiBJbnRlZ2VyIHJlZ2lzdGVyIGNvbnRleHQgc3dpdGNoCkBAIC01MzMsNyArMzU5LDcgQEAgRU5E UFJPQyhyZXRfZnJvbV9rZXJuZWxfdGhyZWFkKQogICogVGhlIHZhbHVlIG9mIGEwIGFuZCBhMSBt dXN0IGJlIHByZXNlcnZlZCBieSB0aGlzIGZ1bmN0aW9uLCBhcyB0aGF0J3MgaG93CiAgKiBhcmd1 bWVudHMgYXJlIHBhc3NlZCB0byBzY2hlZHVsZV90YWlsLgogICovCi1FTlRSWShfX3N3aXRjaF90 bykKK1NZTV9GVU5DX1NUQVJUKF9fc3dpdGNoX3RvKQogCS8qIFNhdmUgY29udGV4dCBpbnRvIHBy ZXYtPnRocmVhZCAqLwogCWxpICAgIGE0LCAgVEFTS19USFJFQURfUkEKIAlhZGQgICBhMywgYTAs IGE0CkBAIC01NzAsNyArMzk2LDcgQEAgRU5UUlkoX19zd2l0Y2hfdG8pCiAJLyogVGhlIG9mZnNl dCBvZiB0aHJlYWRfaW5mbyBpbiB0YXNrX3N0cnVjdCBpcyB6ZXJvLiAqLwogCW1vdmUgdHAsIGEx CiAJcmV0Ci1FTkRQUk9DKF9fc3dpdGNoX3RvKQorU1lNX0ZVTkNfRU5EKF9fc3dpdGNoX3RvKQog CiAjaWZuZGVmIENPTkZJR19NTVUKICNkZWZpbmUgZG9fcGFnZV9mYXVsdCBkb190cmFwX3Vua25v d24KQEAgLTU3OSw3ICs0MDUsNyBAQCBFTkRQUk9DKF9fc3dpdGNoX3RvKQogCS5zZWN0aW9uICIu cm9kYXRhIgogCS5hbGlnbiBMR1JFRwogCS8qIEV4Y2VwdGlvbiB2ZWN0b3IgdGFibGUgKi8KLUVO VFJZKGV4Y3BfdmVjdF90YWJsZSkKK1NZTV9DT0RFX1NUQVJUKGV4Y3BfdmVjdF90YWJsZSkKIAlS SVNDVl9QVFIgZG9fdHJhcF9pbnNuX21pc2FsaWduZWQKIAlBTFRfSU5TTl9GQVVMVChSSVNDVl9Q VFIgZG9fdHJhcF9pbnNuX2ZhdWx0KQogCVJJU0NWX1BUUiBkb190cmFwX2luc25faWxsZWdhbApA QCAtNTg4LDcgKzQxNCw3IEBAIEVOVFJZKGV4Y3BfdmVjdF90YWJsZSkKIAlSSVNDVl9QVFIgZG9f dHJhcF9sb2FkX2ZhdWx0CiAJUklTQ1ZfUFRSIGRvX3RyYXBfc3RvcmVfbWlzYWxpZ25lZAogCVJJ U0NWX1BUUiBkb190cmFwX3N0b3JlX2ZhdWx0Ci0JUklTQ1ZfUFRSIGRvX3RyYXBfZWNhbGxfdSAv KiBzeXN0ZW0gY2FsbCwgZ2V0cyBpbnRlcmNlcHRlZCAqLworCVJJU0NWX1BUUiBkb190cmFwX2Vj YWxsX3UgLyogc3lzdGVtIGNhbGwgKi8KIAlSSVNDVl9QVFIgZG9fdHJhcF9lY2FsbF9zCiAJUklT Q1ZfUFRSIGRvX3RyYXBfdW5rbm93bgogCVJJU0NWX1BUUiBkb190cmFwX2VjYWxsX20KQEAgLTU5 OCwxMSArNDI0LDExIEBAIEVOVFJZKGV4Y3BfdmVjdF90YWJsZSkKIAlSSVNDVl9QVFIgZG9fdHJh cF91bmtub3duCiAJUklTQ1ZfUFRSIGRvX3BhZ2VfZmF1bHQgICAvKiBzdG9yZSBwYWdlIGZhdWx0 ICovCiBleGNwX3ZlY3RfdGFibGVfZW5kOgotRU5EKGV4Y3BfdmVjdF90YWJsZSkKK1NZTV9DT0RF X0VORChleGNwX3ZlY3RfdGFibGUpCiAKICNpZm5kZWYgQ09ORklHX01NVQotRU5UUlkoX191c2Vy X3J0X3NpZ3JldHVybikKK1NZTV9DT0RFX1NUQVJUKF9fdXNlcl9ydF9zaWdyZXR1cm4pCiAJbGkg YTcsIF9fTlJfcnRfc2lncmV0dXJuCiAJc2NhbGwKLUVORChfX3VzZXJfcnRfc2lncmV0dXJuKQor U1lNX0NPREVfRU5EKF9fdXNlcl9ydF9zaWdyZXR1cm4pCiAjZW5kaWYKZGlmZiAtLWdpdCBhL2Fy Y2gvcmlzY3Yva2VybmVsL2hlYWQuaCBiL2FyY2gvcmlzY3Yva2VybmVsL2hlYWQuaAppbmRleCA3 MjY3MzFhZGE1MzQuLmE1NTZmZGFhZmVkOSAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9rZXJuZWwv aGVhZC5oCisrKyBiL2FyY2gvcmlzY3Yva2VybmVsL2hlYWQuaApAQCAtMTAsNyArMTAsNiBAQAog CiBleHRlcm4gYXRvbWljX3QgaGFydF9sb3R0ZXJ5OwogCi1hc21saW5rYWdlIHZvaWQgZG9fcGFn ZV9mYXVsdChzdHJ1Y3QgcHRfcmVncyAqcmVncyk7CiBhc21saW5rYWdlIHZvaWQgX19pbml0IHNl dHVwX3ZtKHVpbnRwdHJfdCBkdGJfcGEpOwogI2lmZGVmIENPTkZJR19YSVBfS0VSTkVMCiBhc21s aW5rYWdlIHZvaWQgX19pbml0IF9fY29weV9kYXRhKHZvaWQpOwpkaWZmIC0tZ2l0IGEvYXJjaC9y aXNjdi9rZXJuZWwvcHRyYWNlLmMgYi9hcmNoL3Jpc2N2L2tlcm5lbC9wdHJhY2UuYwppbmRleCA0 NGY0YjFjYTMxNWQuLjIzYzQ4YjE0YTBlNyAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9rZXJuZWwv cHRyYWNlLmMKKysrIGIvYXJjaC9yaXNjdi9rZXJuZWwvcHRyYWNlLmMKQEAgLTE5LDkgKzE5LDYg QEAKICNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NjaGVkL3Rhc2tf c3RhY2suaD4KIAotI2RlZmluZSBDUkVBVEVfVFJBQ0VfUE9JTlRTCi0jaW5jbHVkZSA8dHJhY2Uv ZXZlbnRzL3N5c2NhbGxzLmg+Ci0KIGVudW0gcmlzY3ZfcmVnc2V0IHsKIAlSRUdTRVRfWCwKICNp ZmRlZiBDT05GSUdfRlBVCkBAIC0yMjgsNDYgKzIyNSw2IEBAIGxvbmcgYXJjaF9wdHJhY2Uoc3Ry dWN0IHRhc2tfc3RydWN0ICpjaGlsZCwgbG9uZyByZXF1ZXN0LAogCXJldHVybiByZXQ7CiB9CiAK LS8qCi0gKiBBbGxvd3MgUFRSQUNFX1NZU0NBTEwgdG8gd29yay4gIFRoZXNlIGFyZSBjYWxsZWQg ZnJvbSBlbnRyeS5TIGluCi0gKiB7aGFuZGxlLHJldF9mcm9tfV9zeXNjYWxsLgotICovCi1fX3Zp c2libGUgaW50IGRvX3N5c2NhbGxfdHJhY2VfZW50ZXIoc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCi17 Ci0JaWYgKHRlc3RfdGhyZWFkX2ZsYWcoVElGX1NZU0NBTExfVFJBQ0UpKQotCQlpZiAocHRyYWNl X3JlcG9ydF9zeXNjYWxsX2VudHJ5KHJlZ3MpKQotCQkJcmV0dXJuIC0xOwotCi0JLyoKLQkgKiBE byB0aGUgc2VjdXJlIGNvbXB1dGluZyBhZnRlciBwdHJhY2U7IGZhaWx1cmVzIHNob3VsZCBiZSBm YXN0LgotCSAqIElmIHRoaXMgZmFpbHMgd2UgbWlnaHQgaGF2ZSByZXR1cm4gdmFsdWUgaW4gYTAg ZnJvbSBzZWNjb21wCi0JICogKHZpYSBTRUNDT01QX1JFVF9FUlJOTy9UUkFDRSkuCi0JICovCi0J aWYgKHNlY3VyZV9jb21wdXRpbmcoKSA9PSAtMSkKLQkJcmV0dXJuIC0xOwotCi0jaWZkZWYgQ09O RklHX0hBVkVfU1lTQ0FMTF9UUkFDRVBPSU5UUwotCWlmICh0ZXN0X3RocmVhZF9mbGFnKFRJRl9T WVNDQUxMX1RSQUNFUE9JTlQpKQotCQl0cmFjZV9zeXNfZW50ZXIocmVncywgc3lzY2FsbF9nZXRf bnIoY3VycmVudCwgcmVncykpOwotI2VuZGlmCi0KLQlhdWRpdF9zeXNjYWxsX2VudHJ5KHJlZ3Mt PmE3LCByZWdzLT5hMCwgcmVncy0+YTEsIHJlZ3MtPmEyLCByZWdzLT5hMyk7Ci0JcmV0dXJuIDA7 Ci19Ci0KLV9fdmlzaWJsZSB2b2lkIGRvX3N5c2NhbGxfdHJhY2VfZXhpdChzdHJ1Y3QgcHRfcmVn cyAqcmVncykKLXsKLQlhdWRpdF9zeXNjYWxsX2V4aXQocmVncyk7Ci0KLQlpZiAodGVzdF90aHJl YWRfZmxhZyhUSUZfU1lTQ0FMTF9UUkFDRSkpCi0JCXB0cmFjZV9yZXBvcnRfc3lzY2FsbF9leGl0 KHJlZ3MsIDApOwotCi0jaWZkZWYgQ09ORklHX0hBVkVfU1lTQ0FMTF9UUkFDRVBPSU5UUwotCWlm ICh0ZXN0X3RocmVhZF9mbGFnKFRJRl9TWVNDQUxMX1RSQUNFUE9JTlQpKQotCQl0cmFjZV9zeXNf ZXhpdChyZWdzLCByZWdzX3JldHVybl92YWx1ZShyZWdzKSk7Ci0jZW5kaWYKLX0KLQogI2lmZGVm IENPTkZJR19DT01QQVQKIHN0YXRpYyBpbnQgY29tcGF0X3Jpc2N2X2dwcl9nZXQoc3RydWN0IHRh c2tfc3RydWN0ICp0YXJnZXQsCiAJCQkJY29uc3Qgc3RydWN0IHVzZXJfcmVnc2V0ICpyZWdzZXQs CmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC9zaWduYWwuYyBiL2FyY2gvcmlzY3Yva2Vy bmVsL3NpZ25hbC5jCmluZGV4IGJmYjJhZmE0MTM1Zi4uMmUzNjUwODQ0MTdlIDEwMDY0NAotLS0g YS9hcmNoL3Jpc2N2L2tlcm5lbC9zaWduYWwuYworKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9zaWdu YWwuYwpAQCAtMTIsNiArMTIsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3N5c2NhbGxzLmg+CiAjaW5j bHVkZSA8bGludXgvcmVzdW1lX3VzZXJfbW9kZS5oPgogI2luY2x1ZGUgPGxpbnV4L2xpbmthZ2Uu aD4KKyNpbmNsdWRlIDxsaW51eC9lbnRyeS1jb21tb24uaD4KIAogI2luY2x1ZGUgPGFzbS91Y29u dGV4dC5oPgogI2luY2x1ZGUgPGFzbS92ZHNvLmg+CkBAIC0yNzQsNyArMjc1LDcgQEAgc3RhdGlj IHZvaWQgaGFuZGxlX3NpZ25hbChzdHJ1Y3Qga3NpZ25hbCAqa3NpZywgc3RydWN0IHB0X3JlZ3Mg KnJlZ3MpCiAJc2lnbmFsX3NldHVwX2RvbmUocmV0LCBrc2lnLCAwKTsKIH0KIAotc3RhdGljIHZv aWQgZG9fc2lnbmFsKHN0cnVjdCBwdF9yZWdzICpyZWdzKQordm9pZCBhcmNoX2RvX3NpZ25hbF9v cl9yZXN0YXJ0KHN0cnVjdCBwdF9yZWdzICpyZWdzKQogewogCXN0cnVjdCBrc2lnbmFsIGtzaWc7 CiAKQEAgLTMxMSwyOSArMzEyLDMgQEAgc3RhdGljIHZvaWQgZG9fc2lnbmFsKHN0cnVjdCBwdF9y ZWdzICpyZWdzKQogCSAqLwogCXJlc3RvcmVfc2F2ZWRfc2lnbWFzaygpOwogfQotCi0vKgotICog SGFuZGxlIGFueSBwZW5kaW5nIHdvcmsgb24gdGhlIHJlc3VtZS10by11c2Vyc3BhY2UgcGF0aCwg YXMgaW5kaWNhdGVkIGJ5Ci0gKiBfVElGX1dPUktfTUFTSy4gRW50ZXJlZCBmcm9tIGFzc2VtYmx5 IHdpdGggSVJRcyBvZmYuCi0gKi8KLWFzbWxpbmthZ2UgX192aXNpYmxlIHZvaWQgZG9fd29ya19w ZW5kaW5nKHN0cnVjdCBwdF9yZWdzICpyZWdzLAotCQkJCQkgIHVuc2lnbmVkIGxvbmcgdGhyZWFk X2luZm9fZmxhZ3MpCi17Ci0JZG8gewotCQlpZiAodGhyZWFkX2luZm9fZmxhZ3MgJiBfVElGX05F RURfUkVTQ0hFRCkgewotCQkJc2NoZWR1bGUoKTsKLQkJfSBlbHNlIHsKLQkJCWxvY2FsX2lycV9l bmFibGUoKTsKLQkJCWlmICh0aHJlYWRfaW5mb19mbGFncyAmIF9USUZfVVBST0JFKQotCQkJCXVw cm9iZV9ub3RpZnlfcmVzdW1lKHJlZ3MpOwotCQkJLyogSGFuZGxlIHBlbmRpbmcgc2lnbmFsIGRl bGl2ZXJ5ICovCi0JCQlpZiAodGhyZWFkX2luZm9fZmxhZ3MgJiAoX1RJRl9TSUdQRU5ESU5HIHwK LQkJCQkJCSBfVElGX05PVElGWV9TSUdOQUwpKQotCQkJCWRvX3NpZ25hbChyZWdzKTsKLQkJCWlm ICh0aHJlYWRfaW5mb19mbGFncyAmIF9USUZfTk9USUZZX1JFU1VNRSkKLQkJCQlyZXN1bWVfdXNl cl9tb2RlX3dvcmsocmVncyk7Ci0JCX0KLQkJbG9jYWxfaXJxX2Rpc2FibGUoKTsKLQkJdGhyZWFk X2luZm9fZmxhZ3MgPSByZWFkX3RocmVhZF9mbGFncygpOwotCX0gd2hpbGUgKHRocmVhZF9pbmZv X2ZsYWdzICYgX1RJRl9XT1JLX01BU0spOwotfQpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJu ZWwvdHJhcHMuYyBiL2FyY2gvcmlzY3Yva2VybmVsL3RyYXBzLmMKaW5kZXggMDI3MjdhNGZlOGJl Li4xZjRlMzdiZTdlYjMgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3Yva2VybmVsL3RyYXBzLmMKKysr IGIvYXJjaC9yaXNjdi9rZXJuZWwvdHJhcHMuYwpAQCAtMTcsMTIgKzE3LDE0IEBACiAjaW5jbHVk ZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvaXJxLmg+CiAjaW5jbHVkZSA8bGlu dXgva2V4ZWMuaD4KKyNpbmNsdWRlIDxsaW51eC9lbnRyeS1jb21tb24uaD4KIAogI2luY2x1ZGUg PGFzbS9hc20tcHJvdG90eXBlcy5oPgogI2luY2x1ZGUgPGFzbS9idWcuaD4KICNpbmNsdWRlIDxh c20vY3NyLmg+CiAjaW5jbHVkZSA8YXNtL3Byb2Nlc3Nvci5oPgogI2luY2x1ZGUgPGFzbS9wdHJh Y2UuaD4KKyNpbmNsdWRlIDxhc20vc3lzY2FsbC5oPgogI2luY2x1ZGUgPGFzbS90aHJlYWRfaW5m by5oPgogCiBpbnQgc2hvd191bmhhbmRsZWRfc2lnbmFscyA9IDE7CkBAIC0xMjMsMTAgKzEyNSwx OCBAQCBzdGF0aWMgdm9pZCBkb190cmFwX2Vycm9yKHN0cnVjdCBwdF9yZWdzICpyZWdzLCBpbnQg c2lnbm8sIGludCBjb2RlLAogI2Vsc2UKICNkZWZpbmUgX190cmFwX3NlY3Rpb24gbm9pbnN0cgog I2VuZGlmCi0jZGVmaW5lIERPX0VSUk9SX0lORk8obmFtZSwgc2lnbm8sIGNvZGUsIHN0cikJCQkJ XAotYXNtbGlua2FnZSBfX3Zpc2libGUgX190cmFwX3NlY3Rpb24gdm9pZCBuYW1lKHN0cnVjdCBw dF9yZWdzICpyZWdzKQlcCi17CQkJCQkJCQkJXAotCWRvX3RyYXBfZXJyb3IocmVncywgc2lnbm8s IGNvZGUsIHJlZ3MtPmVwYywgIk9vcHMgLSAiIHN0cik7CVwKKyNkZWZpbmUgRE9fRVJST1JfSU5G TyhuYW1lLCBzaWdubywgY29kZSwgc3RyKQkJCQkJXAorYXNtbGlua2FnZSBfX3Zpc2libGUgX190 cmFwX3NlY3Rpb24gdm9pZCBuYW1lKHN0cnVjdCBwdF9yZWdzICpyZWdzKQkJXAorewkJCQkJCQkJ CQlcCisJaWYgKHVzZXJfbW9kZShyZWdzKSkgewkJCQkJCQlcCisJCWlycWVudHJ5X2VudGVyX2Zy b21fdXNlcl9tb2RlKHJlZ3MpOwkJCQlcCisJCWRvX3RyYXBfZXJyb3IocmVncywgc2lnbm8sIGNv ZGUsIHJlZ3MtPmVwYywgIk9vcHMgLSAiIHN0cik7CVwKKwkJaXJxZW50cnlfZXhpdF90b191c2Vy X21vZGUocmVncyk7CQkJCVwKKwl9IGVsc2UgewkJCQkJCQkJXAorCQlpcnFlbnRyeV9zdGF0ZV90 IHN0YXRlID0gaXJxZW50cnlfbm1pX2VudGVyKHJlZ3MpOwkJXAorCQlkb190cmFwX2Vycm9yKHJl Z3MsIHNpZ25vLCBjb2RlLCByZWdzLT5lcGMsICJPb3BzIC0gIiBzdHIpOwlcCisJCWlycWVudHJ5 X25taV9leGl0KHJlZ3MsIHN0YXRlKTsJCQkJCVwKKwl9CQkJCQkJCQkJXAogfQogCiBET19FUlJP Ul9JTkZPKGRvX3RyYXBfdW5rbm93biwKQEAgLTE0OCwyNiArMTU4LDUwIEBAIERPX0VSUk9SX0lO Rk8oZG9fdHJhcF9zdG9yZV9taXNhbGlnbmVkLAogaW50IGhhbmRsZV9taXNhbGlnbmVkX2xvYWQo c3RydWN0IHB0X3JlZ3MgKnJlZ3MpOwogaW50IGhhbmRsZV9taXNhbGlnbmVkX3N0b3JlKHN0cnVj dCBwdF9yZWdzICpyZWdzKTsKIAotYXNtbGlua2FnZSB2b2lkIF9fdHJhcF9zZWN0aW9uIGRvX3Ry YXBfbG9hZF9taXNhbGlnbmVkKHN0cnVjdCBwdF9yZWdzICpyZWdzKQorYXNtbGlua2FnZSBfX3Zp c2libGUgX190cmFwX3NlY3Rpb24gdm9pZCBkb190cmFwX2xvYWRfbWlzYWxpZ25lZChzdHJ1Y3Qg cHRfcmVncyAqcmVncykKIHsKLQlpZiAoIWhhbmRsZV9taXNhbGlnbmVkX2xvYWQocmVncykpCi0J CXJldHVybjsKLQlkb190cmFwX2Vycm9yKHJlZ3MsIFNJR0JVUywgQlVTX0FEUkFMTiwgcmVncy0+ ZXBjLAotCQkgICAgICAiT29wcyAtIGxvYWQgYWRkcmVzcyBtaXNhbGlnbmVkIik7CisJaWYgKHVz ZXJfbW9kZShyZWdzKSkgeworCQlpcnFlbnRyeV9lbnRlcl9mcm9tX3VzZXJfbW9kZShyZWdzKTsK KworCQlpZiAoaGFuZGxlX21pc2FsaWduZWRfbG9hZChyZWdzKSkKKwkJCWRvX3RyYXBfZXJyb3Io cmVncywgU0lHQlVTLCBCVVNfQURSQUxOLCByZWdzLT5lcGMsCisJCQkgICAgICAiT29wcyAtIGxv YWQgYWRkcmVzcyBtaXNhbGlnbmVkIik7CisKKwkJaXJxZW50cnlfZXhpdF90b191c2VyX21vZGUo cmVncyk7CisJfSBlbHNlIHsKKwkJaXJxZW50cnlfc3RhdGVfdCBzdGF0ZSA9IGlycWVudHJ5X25t aV9lbnRlcihyZWdzKTsKKworCQlpZiAoaGFuZGxlX21pc2FsaWduZWRfbG9hZChyZWdzKSkKKwkJ CWRvX3RyYXBfZXJyb3IocmVncywgU0lHQlVTLCBCVVNfQURSQUxOLCByZWdzLT5lcGMsCisJCQkg ICAgICAiT29wcyAtIGxvYWQgYWRkcmVzcyBtaXNhbGlnbmVkIik7CisKKwkJaXJxZW50cnlfbm1p X2V4aXQocmVncywgc3RhdGUpOworCX0KIH0KIAotYXNtbGlua2FnZSB2b2lkIF9fdHJhcF9zZWN0 aW9uIGRvX3RyYXBfc3RvcmVfbWlzYWxpZ25lZChzdHJ1Y3QgcHRfcmVncyAqcmVncykKK2FzbWxp bmthZ2UgX192aXNpYmxlIF9fdHJhcF9zZWN0aW9uIHZvaWQgZG9fdHJhcF9zdG9yZV9taXNhbGln bmVkKHN0cnVjdCBwdF9yZWdzICpyZWdzKQogewotCWlmICghaGFuZGxlX21pc2FsaWduZWRfc3Rv cmUocmVncykpCi0JCXJldHVybjsKLQlkb190cmFwX2Vycm9yKHJlZ3MsIFNJR0JVUywgQlVTX0FE UkFMTiwgcmVncy0+ZXBjLAotCQkgICAgICAiT29wcyAtIHN0b3JlIChvciBBTU8pIGFkZHJlc3Mg bWlzYWxpZ25lZCIpOworCWlmICh1c2VyX21vZGUocmVncykpIHsKKwkJaXJxZW50cnlfZW50ZXJf ZnJvbV91c2VyX21vZGUocmVncyk7CisKKwkJaWYgKGhhbmRsZV9taXNhbGlnbmVkX3N0b3JlKHJl Z3MpKQorCQkJZG9fdHJhcF9lcnJvcihyZWdzLCBTSUdCVVMsIEJVU19BRFJBTE4sIHJlZ3MtPmVw YywKKwkJCQkiT29wcyAtIHN0b3JlIChvciBBTU8pIGFkZHJlc3MgbWlzYWxpZ25lZCIpOworCisJ CWlycWVudHJ5X2V4aXRfdG9fdXNlcl9tb2RlKHJlZ3MpOworCX0gZWxzZSB7CisJCWlycWVudHJ5 X3N0YXRlX3Qgc3RhdGUgPSBpcnFlbnRyeV9ubWlfZW50ZXIocmVncyk7CisKKwkJaWYgKGhhbmRs ZV9taXNhbGlnbmVkX3N0b3JlKHJlZ3MpKQorCQkJZG9fdHJhcF9lcnJvcihyZWdzLCBTSUdCVVMs IEJVU19BRFJBTE4sIHJlZ3MtPmVwYywKKwkJCQkiT29wcyAtIHN0b3JlIChvciBBTU8pIGFkZHJl c3MgbWlzYWxpZ25lZCIpOworCisJCWlycWVudHJ5X25taV9leGl0KHJlZ3MsIHN0YXRlKTsKKwl9 CiB9CiAjZW5kaWYKIERPX0VSUk9SX0lORk8oZG9fdHJhcF9zdG9yZV9mYXVsdCwKIAlTSUdTRUdW LCBTRUdWX0FDQ0VSUiwgInN0b3JlIChvciBBTU8pIGFjY2VzcyBmYXVsdCIpOwotRE9fRVJST1Jf SU5GTyhkb190cmFwX2VjYWxsX3UsCi0JU0lHSUxMLCBJTExfSUxMVFJQLCAiZW52aXJvbm1lbnQg Y2FsbCBmcm9tIFUtbW9kZSIpOwogRE9fRVJST1JfSU5GTyhkb190cmFwX2VjYWxsX3MsCiAJU0lH SUxMLCBJTExfSUxMVFJQLCAiZW52aXJvbm1lbnQgY2FsbCBmcm9tIFMtbW9kZSIpOwogRE9fRVJS T1JfSU5GTyhkb190cmFwX2VjYWxsX20sCkBAIC0xODMsNyArMjE3LDcgQEAgc3RhdGljIGlubGlu ZSB1bnNpZ25lZCBsb25nIGdldF9icmVha19pbnNuX2xlbmd0aCh1bnNpZ25lZCBsb25nIHBjKQog CXJldHVybiBHRVRfSU5TTl9MRU5HVEgoaW5zbik7CiB9CiAKLWFzbWxpbmthZ2UgX192aXNpYmxl IF9fdHJhcF9zZWN0aW9uIHZvaWQgZG9fdHJhcF9icmVhayhzdHJ1Y3QgcHRfcmVncyAqcmVncykK K3ZvaWQgaGFuZGxlX2JyZWFrKHN0cnVjdCBwdF9yZWdzICpyZWdzKQogewogI2lmZGVmIENPTkZJ R19LUFJPQkVTCiAJaWYgKGtwcm9iZV9zaW5nbGVfc3RlcF9oYW5kbGVyKHJlZ3MpKQpAQCAtMjEz LDcgKzI0Nyw3NyBAQCBhc21saW5rYWdlIF9fdmlzaWJsZSBfX3RyYXBfc2VjdGlvbiB2b2lkIGRv X3RyYXBfYnJlYWsoc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCiAJZWxzZQogCQlkaWUocmVncywgIktl cm5lbCBCVUciKTsKIH0KLU5PS1BST0JFX1NZTUJPTChkb190cmFwX2JyZWFrKTsKKworYXNtbGlu a2FnZSBfX3Zpc2libGUgX190cmFwX3NlY3Rpb24gdm9pZCBkb190cmFwX2JyZWFrKHN0cnVjdCBw dF9yZWdzICpyZWdzKQoreworCWlmICh1c2VyX21vZGUocmVncykpIHsKKwkJaXJxZW50cnlfZW50 ZXJfZnJvbV91c2VyX21vZGUocmVncyk7CisKKwkJaGFuZGxlX2JyZWFrKHJlZ3MpOworCisJCWly cWVudHJ5X2V4aXRfdG9fdXNlcl9tb2RlKHJlZ3MpOworCX0gZWxzZSB7CisJCWlycWVudHJ5X3N0 YXRlX3Qgc3RhdGUgPSBpcnFlbnRyeV9ubWlfZW50ZXIocmVncyk7CisKKwkJaGFuZGxlX2JyZWFr KHJlZ3MpOworCisJCWlycWVudHJ5X25taV9leGl0KHJlZ3MsIHN0YXRlKTsKKwl9Cit9CisKK2Fz bWxpbmthZ2UgX192aXNpYmxlIF9fdHJhcF9zZWN0aW9uIHZvaWQgZG9fdHJhcF9lY2FsbF91KHN0 cnVjdCBwdF9yZWdzICpyZWdzKQoreworCWlmICh1c2VyX21vZGUocmVncykpIHsKKwkJdWxvbmcg c3lzY2FsbCA9IHJlZ3MtPmE3OworCisJCXN5c2NhbGwgPSBzeXNjYWxsX2VudGVyX2Zyb21fdXNl cl9tb2RlKHJlZ3MsIHN5c2NhbGwpOworCisJCXJlZ3MtPmVwYyArPSA0OworCQlyZWdzLT5vcmln X2EwID0gcmVncy0+YTA7CisKKwkJaWYgKHN5c2NhbGwgPCBOUl9zeXNjYWxscykKKwkJCXN5c2Nh bGxfaGFuZGxlcihyZWdzLCBzeXNjYWxsKTsKKwkJZWxzZQorCQkJcmVncy0+YTAgPSAtRU5PU1lT OworCisJCXN5c2NhbGxfZXhpdF90b191c2VyX21vZGUocmVncyk7CisJfSBlbHNlIHsKKwkJaXJx ZW50cnlfc3RhdGVfdCBzdGF0ZSA9IGlycWVudHJ5X25taV9lbnRlcihyZWdzKTsKKworCQlkb190 cmFwX2Vycm9yKHJlZ3MsIFNJR0lMTCwgSUxMX0lMTFRSUCwgcmVncy0+ZXBjLAorCQkJIk9vcHMg LSBlbnZpcm9ubWVudCBjYWxsIGZyb20gVS1tb2RlIik7CisKKwkJaXJxZW50cnlfbm1pX2V4aXQo cmVncywgc3RhdGUpOworCX0KKworfQorCisjaWZkZWYgQ09ORklHX01NVQorYXNtbGlua2FnZSBf X3Zpc2libGUgbm9pbnN0ciB2b2lkIGRvX3BhZ2VfZmF1bHQoc3RydWN0IHB0X3JlZ3MgKnJlZ3Mp Cit7CisJaXJxZW50cnlfc3RhdGVfdCBzdGF0ZSA9IGlycWVudHJ5X2VudGVyKHJlZ3MpOworCisJ aGFuZGxlX3BhZ2VfZmF1bHQocmVncyk7CisKKwlsb2NhbF9pcnFfZGlzYWJsZSgpOworCisJaXJx ZW50cnlfZXhpdChyZWdzLCBzdGF0ZSk7Cit9CisjZW5kaWYKKworYXNtbGlua2FnZSBfX3Zpc2li bGUgbm9pbnN0ciB2b2lkIGRvX2lycShzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3sKKwlzdHJ1Y3Qg cHRfcmVncyAqb2xkX3JlZ3M7CisJaXJxZW50cnlfc3RhdGVfdCBzdGF0ZSA9IGlycWVudHJ5X2Vu dGVyKHJlZ3MpOworCisJaXJxX2VudGVyX3JjdSgpOworCW9sZF9yZWdzID0gc2V0X2lycV9yZWdz KHJlZ3MpOworCWhhbmRsZV9hcmNoX2lycShyZWdzKTsKKwlzZXRfaXJxX3JlZ3Mob2xkX3JlZ3Mp OworCWlycV9leGl0X3JjdSgpOworCisJaXJxZW50cnlfZXhpdChyZWdzLCBzdGF0ZSk7Cit9CiAK ICNpZmRlZiBDT05GSUdfR0VORVJJQ19CVUcKIGludCBpc192YWxpZF9idWdhZGRyKHVuc2lnbmVk IGxvbmcgcGMpCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L21tL2ZhdWx0LmMgYi9hcmNoL3Jpc2N2 L21tL2ZhdWx0LmMKaW5kZXggZWIwNzc0ZDljMDNiLi5lZmMzNmJlMzhiY2UgMTAwNjQ0Ci0tLSBh L2FyY2gvcmlzY3YvbW0vZmF1bHQuYworKysgYi9hcmNoL3Jpc2N2L21tL2ZhdWx0LmMKQEAgLTE1 LDYgKzE1LDcgQEAKICNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CiAjaW5jbHVkZSA8bGludXgv a3Byb2Jlcy5oPgogI2luY2x1ZGUgPGxpbnV4L2tmZW5jZS5oPgorI2luY2x1ZGUgPGxpbnV4L2Vu dHJ5LWNvbW1vbi5oPgogCiAjaW5jbHVkZSA8YXNtL3B0cmFjZS5oPgogI2luY2x1ZGUgPGFzbS90 bGJmbHVzaC5oPgpAQCAtMjA0LDcgKzIwNSw3IEBAIHN0YXRpYyBpbmxpbmUgYm9vbCBhY2Nlc3Nf ZXJyb3IodW5zaWduZWQgbG9uZyBjYXVzZSwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCiAg KiBUaGlzIHJvdXRpbmUgaGFuZGxlcyBwYWdlIGZhdWx0cy4gIEl0IGRldGVybWluZXMgdGhlIGFk ZHJlc3MgYW5kIHRoZQogICogcHJvYmxlbSwgYW5kIHRoZW4gcGFzc2VzIGl0IG9mZiB0byBvbmUg b2YgdGhlIGFwcHJvcHJpYXRlIHJvdXRpbmVzLgogICovCi1hc21saW5rYWdlIHZvaWQgZG9fcGFn ZV9mYXVsdChzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3ZvaWQgaGFuZGxlX3BhZ2VfZmF1bHQoc3Ry dWN0IHB0X3JlZ3MgKnJlZ3MpCiB7CiAJc3RydWN0IHRhc2tfc3RydWN0ICp0c2s7CiAJc3RydWN0 IHZtX2FyZWFfc3RydWN0ICp2bWE7CkBAIC0yNTEsNyArMjUyLDcgQEAgYXNtbGlua2FnZSB2b2lk IGRvX3BhZ2VfZmF1bHQoc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCiAJfQogI2VuZGlmCiAJLyogRW5h YmxlIGludGVycnVwdHMgaWYgdGhleSB3ZXJlIGVuYWJsZWQgaW4gdGhlIHBhcmVudCBjb250ZXh0 LiAqLwotCWlmIChsaWtlbHkocmVncy0+c3RhdHVzICYgU1JfUElFKSkKKwlpZiAoIXJlZ3NfaXJx c19kaXNhYmxlZChyZWdzKSkKIAkJbG9jYWxfaXJxX2VuYWJsZSgpOwogCiAJLyoKQEAgLTM1Myw0 ICszNTQsMyBAQCBhc21saW5rYWdlIHZvaWQgZG9fcGFnZV9mYXVsdChzdHJ1Y3QgcHRfcmVncyAq cmVncykKIAl9CiAJcmV0dXJuOwogfQotTk9LUFJPQkVfU1lNQk9MKGRvX3BhZ2VfZmF1bHQpOwot LSAKMi4zNi4xCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KbGludXgtcmlzY3YgbWFpbGluZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5v cmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1yaXNj dgo=