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 3941AE77173 for ; Fri, 6 Dec 2024 16:42:40 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Content-Transfer-Encoding: Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:Cc: To:From:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=pZs2436mAWrHKZxo6XHcSc+Z7MR9g3Sqc/8PR7lb/OY=; b=kiBnCRfnLX0be1EXq2rCLT+yWI dPcMXe1Ix8V559AA85L+FT5eI13u80FLpAaTniG6KoNKscJn5s85ni7BANLz2XM2BKQuYZs1aFBvk TpvG/LrcYZQ8G1ThhQVZYEZr1WMarXoLkGswPyo4l2kQCR8R+mAEl0zKKQX5w9//6SHilJTwaTL17 tja+loKOJQfKsGselgCeWS/3A6ACMT/d8v4+sWVApUGrIXIgYGQ/FDcTvDmtPCfyUu22eXRe/9Kyv M6/juqetTAxaBn6bVCFcu44q6OYMDjk9JoxwxVOu8ywW8GA6J5tSzoyy2QC8lgLumtrSjCxOkCTdD o8Q4+YSg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1tJbPR-00000002D9x-3PLu; Fri, 06 Dec 2024 16:42:29 +0000 Received: from mail-wr1-x429.google.com ([2a00:1450:4864:20::429]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1tJbEX-00000002AKJ-0wIv for linux-arm-kernel@lists.infradead.org; Fri, 06 Dec 2024 16:31:14 +0000 Received: by mail-wr1-x429.google.com with SMTP id ffacd0b85a97d-385e25c5d75so1263484f8f.1 for ; Fri, 06 Dec 2024 08:31:12 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=rivosinc-com.20230601.gappssmtp.com; s=20230601; t=1733502671; x=1734107471; darn=lists.infradead.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=pZs2436mAWrHKZxo6XHcSc+Z7MR9g3Sqc/8PR7lb/OY=; b=NWQECNgyNfMgAImmZ01Qaw/837ga/0zS1UxO536VdiPxRPYdcIhO9IFTMi37csUv8q GP6e115YGJeZfwtfvgeR+9EAYr+ZgjkSgsYwdoF+evTlP+EAx4wyMjXdbFb8BSK5Wfpw WMcX/3T58Wj5YQ0dCS1H0i2GL6yihIrrhMfnK3UANizI06/GJHrBehndW2HH7j5SN+s1 1YCJjQ6L0FI5W7R7F/FMJM7QaDp9mM7JCczTJeoYP8JjzGvf+/zSZtG1PZTGbW0ARq2L 21NFYFVPO+tjhqdLdj8k1s48GBCHf7eG2tna19H0ohAiwlGZJf/9PeuKFz/7ykxFkaLW g2Hw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1733502671; x=1734107471; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=pZs2436mAWrHKZxo6XHcSc+Z7MR9g3Sqc/8PR7lb/OY=; b=UbBs0WWsGWx9xVDXabzmp7oqlztdE2JZGNVKDD5MEuXIVBWjVVbDhup73QI0FsQHxq T19IBaayA2RxTK03FAzh5Xo8NKg8DKVytIFSHzFBowcVHmSoX2tWzA+7ehVve8QSr8V8 C2xLavTsCX+wEF81t5gQq1TjL7+gCGwSnCkKcNbODmx0b8cbnL1q6HDXx40KxfZe/EGN 6A5GTO6iWWThN36w/YR9NOCDmE6y4smQy/QUw3umwiwYiOjV9AcsqvwJgZgIkKUWndWg asUp2nrwTcds09vn273NhKnUEjz5e8nNTj/nOWBsN705iugKXzjHpjsigsKNFMWWZMD+ VdnA== X-Forwarded-Encrypted: i=1; AJvYcCWH3mcvIJvb/A8l5iAtLv5tant8cgsTmPfMfsgRFTiF/1WsuF4pe9K+5qMCeSZIGTgfledtrkYARWGJmccwmMRl@lists.infradead.org X-Gm-Message-State: AOJu0YyL+n4OFkCFQKDolDPBf2+XqdbHyNzTRhuuGiq2lnejd3nOlqQv wz+4LACVX4AbOk4NhLa4l8VSsFHehryl6sZEfyoHjMbHYbHQ9RVkrtmzpYYPrPA= X-Gm-Gg: ASbGncvqj5V2Tjezz0N3pbVQukonz1Kb0jfa7NlVrOix6oOR5+IDOd71/r68+eTa7db A1BZp7V7XVLrGUHjllLhttHTeQNr1Qqhx5NXGorl6qYz6hzPN6K3GA4bBA1gSc6NuqjsilvbWlG CDrx2JalCq/ZRVoGK24NBPcq5FAM6/eX1YLQnmJzQFbvCiQr2shz3fH/+llF6NYsIHlOzXQFeu1 ITL5ckbyyTq1EL34bf9skD4JWF9yzd7t2zxplLzxsaxRM3h9Rg= X-Google-Smtp-Source: AGHT+IFHTqdtI6/G+fllUvPdGXlMfmZ7zOUkMH4p5p0imSiny8q9+zdmJJro+C/BeLlZrxw2h4Qlqg== X-Received: by 2002:a05:6000:1548:b0:385:dffb:4d70 with SMTP id ffacd0b85a97d-3862b3e818dmr2258522f8f.54.1733502671081; Fri, 06 Dec 2024 08:31:11 -0800 (PST) Received: from carbon-x1.. ([2a01:e0a:e17:9700:16d2:7456:6634:9626]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3862f02f5c3sm1151942f8f.65.2024.12.06.08.31.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 06 Dec 2024 08:31:10 -0800 (PST) From: =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= To: Paul Walmsley , Palmer Dabbelt , linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Cc: =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= , Himanshu Chauhan , Anup Patel , Xu Lu , Atish Patra Subject: [PATCH v3 2/4] riscv: add support for SBI Supervisor Software Events extension Date: Fri, 6 Dec 2024 17:30:58 +0100 Message-ID: <20241206163102.843505-3-cleger@rivosinc.com> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20241206163102.843505-1-cleger@rivosinc.com> References: <20241206163102.843505-1-cleger@rivosinc.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20241206_083113_275896_C352FCEC X-CRM114-Status: GOOD ( 33.60 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org The SBI SSE extension allows the supervisor software to be notified by the SBI of specific events that are not maskable. The context switch is handled partially by the firmware which will save registers a6 and a7. When entering kernel we can rely on these 2 registers to setup the stack and save all the registers. Since SSE events can be delivered at any time to the kernel (including during exception handling, we need a way to locate the current_task for context tracking. On RISC-V, it is sotred in scratch when in user space or tp when in kernel space (in which case SSCRATCH is zero). But at a at the beginning of exception handling, SSCRATCH is used to swap tp and check the origin of the exception. If interrupted at that point, then, there is no way to reliably know were is located the current task_struct. Even checking the interruption location won't work as SSE event can be nested on top of each other so the original interruption site might be lost at some point. In order to retrieve it reliably, store the current task in an additionnal __sse_entry_task per_cpu array. This array is then used to retrieve the current task based on the hart ID that is passed to the SSE event handler in a6. That being said, the way the current task struct is stored should probably be reworked to find a better reliable alternative. Since each events (and each CPU for local events) have their own context and can preempt each other, allocate a stack (and a shadow stack if needed for each of them (and for each cpu for local events). When completing the event, if we were coming from kernel with interrupts disabled, simply return there. If coming from userspace or kernel with interrupts enabled, simulate an interrupt exception by setting IE_SIE in CSR_IP to allow delivery of signals to user task. For instance this can happen, when a RAS event has been generated by a user application and a SIGBUS has been sent to a task. Signed-off-by: Clément Léger --- arch/riscv/include/asm/asm.h | 14 ++- arch/riscv/include/asm/scs.h | 7 ++ arch/riscv/include/asm/sse.h | 38 ++++++ arch/riscv/include/asm/switch_to.h | 14 +++ arch/riscv/include/asm/thread_info.h | 1 + arch/riscv/kernel/Makefile | 1 + arch/riscv/kernel/asm-offsets.c | 12 ++ arch/riscv/kernel/sse.c | 134 +++++++++++++++++++++ arch/riscv/kernel/sse_entry.S | 171 +++++++++++++++++++++++++++ 9 files changed, 389 insertions(+), 3 deletions(-) create mode 100644 arch/riscv/include/asm/sse.h create mode 100644 arch/riscv/kernel/sse.c create mode 100644 arch/riscv/kernel/sse_entry.S diff --git a/arch/riscv/include/asm/asm.h b/arch/riscv/include/asm/asm.h index 776354895b81..de8427c58f02 100644 --- a/arch/riscv/include/asm/asm.h +++ b/arch/riscv/include/asm/asm.h @@ -89,16 +89,24 @@ #define PER_CPU_OFFSET_SHIFT 3 #endif -.macro asm_per_cpu dst sym tmp - REG_L \tmp, TASK_TI_CPU_NUM(tp) - slli \tmp, \tmp, PER_CPU_OFFSET_SHIFT +.macro asm_per_cpu_with_cpu dst sym tmp cpu + slli \tmp, \cpu, PER_CPU_OFFSET_SHIFT la \dst, __per_cpu_offset add \dst, \dst, \tmp REG_L \tmp, 0(\dst) la \dst, \sym add \dst, \dst, \tmp .endm + +.macro asm_per_cpu dst sym tmp + REG_L \tmp, TASK_TI_CPU_NUM(tp) + asm_per_cpu_with_cpu \dst \sym \tmp \tmp +.endm #else /* CONFIG_SMP */ +.macro asm_per_cpu_with_cpu dst sym tmp cpu + la \dst, \sym +.endm + .macro asm_per_cpu dst sym tmp la \dst, \sym .endm diff --git a/arch/riscv/include/asm/scs.h b/arch/riscv/include/asm/scs.h index 0e45db78b24b..62344daad73d 100644 --- a/arch/riscv/include/asm/scs.h +++ b/arch/riscv/include/asm/scs.h @@ -18,6 +18,11 @@ load_per_cpu gp, irq_shadow_call_stack_ptr, \tmp .endm +/* Load the per-CPU IRQ shadow call stack to gp. */ +.macro scs_load_sse_stack reg_evt + REG_L gp, SSE_REG_EVT_SHADOW_STACK(\reg_evt) +.endm + /* Load task_scs_sp(current) to gp. */ .macro scs_load_current REG_L gp, TASK_TI_SCS_SP(tp) @@ -41,6 +46,8 @@ .endm .macro scs_load_irq_stack tmp .endm +.macro scs_load_sse_stack reg_evt +.endm .macro scs_load_current .endm .macro scs_load_current_if_task_changed prev diff --git a/arch/riscv/include/asm/sse.h b/arch/riscv/include/asm/sse.h new file mode 100644 index 000000000000..431a19d4cd9c --- /dev/null +++ b/arch/riscv/include/asm/sse.h @@ -0,0 +1,38 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (C) 2024 Rivos Inc. + */ +#ifndef __ASM_SSE_H +#define __ASM_SSE_H + +#ifdef CONFIG_RISCV_SSE + +struct sse_event_interrupted_state { + unsigned long a6; + unsigned long a7; +}; + +struct sse_event_arch_data { + void *stack; + void *shadow_stack; + unsigned long tmp; + struct sse_event_interrupted_state interrupted; + unsigned long interrupted_state_phys; + u32 evt_id; +}; + +struct sse_registered_event; +int arch_sse_init_event(struct sse_event_arch_data *arch_evt, u32 evt_id, + int cpu); +void arch_sse_free_event(struct sse_event_arch_data *arch_evt); +int arch_sse_register_event(struct sse_event_arch_data *arch_evt); + +void sse_handle_event(struct sse_event_arch_data *arch_evt, + struct pt_regs *regs); +asmlinkage void handle_sse(void); +asmlinkage void do_sse(struct sse_event_arch_data *arch_evt, + struct pt_regs *reg); + +#endif + +#endif diff --git a/arch/riscv/include/asm/switch_to.h b/arch/riscv/include/asm/switch_to.h index 94e33216b2d9..e166fabe04ab 100644 --- a/arch/riscv/include/asm/switch_to.h +++ b/arch/riscv/include/asm/switch_to.h @@ -88,6 +88,19 @@ static inline void __switch_to_envcfg(struct task_struct *next) :: "r" (next->thread.envcfg) : "memory"); } +#ifdef CONFIG_RISCV_SSE +DECLARE_PER_CPU(struct task_struct *, __sse_entry_task); + +static inline void __switch_sse_entry_task(struct task_struct *next) +{ + __this_cpu_write(__sse_entry_task, next); +} +#else +static inline void __switch_sse_entry_task(struct task_struct *next) +{ +} +#endif + extern struct task_struct *__switch_to(struct task_struct *, struct task_struct *); @@ -122,6 +135,7 @@ do { \ if (switch_to_should_flush_icache(__next)) \ local_flush_icache_all(); \ __switch_to_envcfg(__next); \ + __switch_sse_entry_task(__next); \ ((last) = __switch_to(__prev, __next)); \ } while (0) diff --git a/arch/riscv/include/asm/thread_info.h b/arch/riscv/include/asm/thread_info.h index f5916a70879a..28e9805e61fc 100644 --- a/arch/riscv/include/asm/thread_info.h +++ b/arch/riscv/include/asm/thread_info.h @@ -36,6 +36,7 @@ #define OVERFLOW_STACK_SIZE SZ_4K #define IRQ_STACK_SIZE THREAD_SIZE +#define SSE_STACK_SIZE THREAD_SIZE #ifndef __ASSEMBLY__ diff --git a/arch/riscv/kernel/Makefile b/arch/riscv/kernel/Makefile index 063d1faf5a53..1e8fb83b1162 100644 --- a/arch/riscv/kernel/Makefile +++ b/arch/riscv/kernel/Makefile @@ -99,6 +99,7 @@ obj-$(CONFIG_DYNAMIC_FTRACE) += mcount-dyn.o obj-$(CONFIG_PERF_EVENTS) += perf_callchain.o obj-$(CONFIG_HAVE_PERF_REGS) += perf_regs.o obj-$(CONFIG_RISCV_SBI) += sbi.o sbi_ecall.o +obj-$(CONFIG_RISCV_SSE) += sse.o sse_entry.o ifeq ($(CONFIG_RISCV_SBI), y) obj-$(CONFIG_SMP) += sbi-ipi.o obj-$(CONFIG_SMP) += cpu_ops_sbi.o diff --git a/arch/riscv/kernel/asm-offsets.c b/arch/riscv/kernel/asm-offsets.c index e89455a6a0e5..60590a3d9519 100644 --- a/arch/riscv/kernel/asm-offsets.c +++ b/arch/riscv/kernel/asm-offsets.c @@ -14,6 +14,8 @@ #include #include #include +#include +#include #include void asm_offsets(void); @@ -511,4 +513,14 @@ void asm_offsets(void) DEFINE(FREGS_A6, offsetof(struct __arch_ftrace_regs, a6)); DEFINE(FREGS_A7, offsetof(struct __arch_ftrace_regs, a7)); #endif + +#ifdef CONFIG_RISCV_SSE + OFFSET(SSE_REG_EVT_STACK, sse_event_arch_data, stack); + OFFSET(SSE_REG_EVT_SHADOW_STACK, sse_event_arch_data, shadow_stack); + OFFSET(SSE_REG_EVT_TMP, sse_event_arch_data, tmp); + + DEFINE(SBI_EXT_SSE, SBI_EXT_SSE); + DEFINE(SBI_SSE_EVENT_COMPLETE, SBI_SSE_EVENT_COMPLETE); + DEFINE(NR_CPUS, NR_CPUS); +#endif } diff --git a/arch/riscv/kernel/sse.c b/arch/riscv/kernel/sse.c new file mode 100644 index 000000000000..b48ae69dad8d --- /dev/null +++ b/arch/riscv/kernel/sse.c @@ -0,0 +1,134 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Copyright (C) 2024 Rivos Inc. + */ +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +DEFINE_PER_CPU(struct task_struct *, __sse_entry_task); + +void __weak sse_handle_event(struct sse_event_arch_data *arch_evt, struct pt_regs *regs) +{ +} + +void do_sse(struct sse_event_arch_data *arch_evt, struct pt_regs *regs) +{ + nmi_enter(); + + /* Retrieve missing GPRs from SBI */ + sbi_ecall(SBI_EXT_SSE, SBI_SSE_EVENT_ATTR_READ, arch_evt->evt_id, + SBI_SSE_ATTR_INTERRUPTED_A6, + (SBI_SSE_ATTR_INTERRUPTED_A7 - SBI_SSE_ATTR_INTERRUPTED_A6) + 1, + arch_evt->interrupted_state_phys, 0, 0); + + memcpy(®s->a6, &arch_evt->interrupted, sizeof(arch_evt->interrupted)); + + sse_handle_event(arch_evt, regs); + + /* + * The SSE delivery path does not uses the "standard" exception path and + * thus does not process any pending signal/softirqs. Some drivers might + * enqueue pending work that needs to be handled as soon as possible. + * For that purpose, set the software interrupt pending bit which will + * be serviced once interrupts are reenabled + */ + csr_set(CSR_IP, IE_SIE); + + nmi_exit(); +} + +#ifdef CONFIG_VMAP_STACK +static unsigned long *sse_stack_alloc(unsigned int cpu, unsigned int size) +{ + return arch_alloc_vmap_stack(size, cpu_to_node(cpu)); +} + +static void sse_stack_free(unsigned long *stack) +{ + vfree(stack); +} +#else /* CONFIG_VMAP_STACK */ + +static unsigned long *sse_stack_alloc(unsigned int cpu, unsigned int size) +{ + return kmalloc(size, GFP_KERNEL); +} + +static void sse_stack_free(unsigned long *stack) +{ + kfree(stack); +} + +#endif /* CONFIG_VMAP_STACK */ + +static int sse_init_scs(int cpu, struct sse_event_arch_data *arch_evt) +{ + void *stack; + + if (!scs_is_enabled()) + return 0; + + stack = scs_alloc(cpu_to_node(cpu)); + if (!stack) + return 1; + + arch_evt->shadow_stack = stack; + + return 0; +} + +int arch_sse_init_event(struct sse_event_arch_data *arch_evt, u32 evt_id, int cpu) +{ + void *stack; + + arch_evt->evt_id = evt_id; + stack = sse_stack_alloc(cpu, SSE_STACK_SIZE); + if (!stack) + return -ENOMEM; + + arch_evt->stack = stack + SSE_STACK_SIZE; + + if (sse_init_scs(cpu, arch_evt)) + goto free_stack; + + if (is_kernel_percpu_address((unsigned long)&arch_evt->interrupted)) { + arch_evt->interrupted_state_phys = + per_cpu_ptr_to_phys(&arch_evt->interrupted); + } else { + arch_evt->interrupted_state_phys = + virt_to_phys(&arch_evt->interrupted); + } + + return 0; + +free_stack: + sse_stack_free(arch_evt->stack - SSE_STACK_SIZE); + + return -ENOMEM; +} + +void arch_sse_free_event(struct sse_event_arch_data *arch_evt) +{ + scs_free(arch_evt->shadow_stack); + sse_stack_free(arch_evt->stack - SSE_STACK_SIZE); +} + +int arch_sse_register_event(struct sse_event_arch_data *arch_evt) +{ + struct sbiret sret; + + sret = sbi_ecall(SBI_EXT_SSE, SBI_SSE_EVENT_REGISTER, arch_evt->evt_id, + (unsigned long) handle_sse, (unsigned long) arch_evt, + 0, 0, 0); + + return sbi_err_map_linux_errno(sret.error); +} diff --git a/arch/riscv/kernel/sse_entry.S b/arch/riscv/kernel/sse_entry.S new file mode 100644 index 000000000000..0b2f890edd89 --- /dev/null +++ b/arch/riscv/kernel/sse_entry.S @@ -0,0 +1,171 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (C) 2024 Rivos Inc. + */ + +#include +#include + +#include +#include +#include + +/* When entering handle_sse, the following registers are set: + * a6: contains the hartid + * a6: contains struct sse_registered_event pointer + */ +SYM_CODE_START(handle_sse) + /* Save stack temporarily */ + REG_S sp, SSE_REG_EVT_TMP(a7) + /* Set entry stack */ + REG_L sp, SSE_REG_EVT_STACK(a7) + + addi sp, sp, -(PT_SIZE_ON_STACK) + REG_S ra, PT_RA(sp) + REG_S s0, PT_S0(sp) + REG_S s1, PT_S1(sp) + REG_S s2, PT_S2(sp) + REG_S s3, PT_S3(sp) + REG_S s4, PT_S4(sp) + REG_S s5, PT_S5(sp) + REG_S s6, PT_S6(sp) + REG_S s7, PT_S7(sp) + REG_S s8, PT_S8(sp) + REG_S s9, PT_S9(sp) + REG_S s10, PT_S10(sp) + REG_S s11, PT_S11(sp) + REG_S tp, PT_TP(sp) + REG_S t0, PT_T0(sp) + REG_S t1, PT_T1(sp) + REG_S t2, PT_T2(sp) + REG_S t3, PT_T3(sp) + REG_S t4, PT_T4(sp) + REG_S t5, PT_T5(sp) + REG_S t6, PT_T6(sp) + REG_S gp, PT_GP(sp) + REG_S a0, PT_A0(sp) + REG_S a1, PT_A1(sp) + REG_S a2, PT_A2(sp) + REG_S a3, PT_A3(sp) + REG_S a4, PT_A4(sp) + REG_S a5, PT_A5(sp) + + /* Retrieve entry sp */ + REG_L a4, SSE_REG_EVT_TMP(a7) + /* Save CSRs */ + csrr a0, CSR_EPC + csrr a1, CSR_SSTATUS + csrr a2, CSR_STVAL + csrr a3, CSR_SCAUSE + + REG_S a0, PT_EPC(sp) + REG_S a1, PT_STATUS(sp) + REG_S a2, PT_BADADDR(sp) + REG_S a3, PT_CAUSE(sp) + REG_S a4, PT_SP(sp) + + /* Disable user memory access and floating/vector computing */ + li t0, SR_SUM | SR_FS_VS + csrc CSR_STATUS, t0 + + load_global_pointer + scs_load_sse_stack a7 + + /* Restore current task struct from __sse_entry_task */ + li t1, NR_CPUS + move t3, zero + +#ifdef CONFIG_SMP + /* Find the CPU id associated to the hart id */ + la t0, __cpuid_to_hartid_map +.Lhart_id_loop: + REG_L t2, 0(t0) + beq t2, a6, .Lcpu_id_found + + /* Increment pointer and CPU number */ + addi t3, t3, 1 + addi t0, t0, RISCV_SZPTR + bltu t3, t1, .Lhart_id_loop + + /* + * This should never happen since we expect the hart_id to match one + * of our CPU, but better be safe than sorry + */ + la tp, init_task + la a0, sse_hart_id_panic_string + la t0, panic + jalr t0 + +.Lcpu_id_found: +#endif + asm_per_cpu_with_cpu t2 __sse_entry_task t1 t3 + REG_L tp, 0(t2) + + move a1, sp /* pt_regs on stack */ + /* Kernel was interrupted, create stack frame */ + beqz s1, .Lcall_do_sse + +.Lcall_do_sse: + /* + * Save sscratch for restoration since we might have interrupted the + * kernel in early exception path and thus, we don't know the content of + * sscratch. + */ + csrr s4, CSR_SSCRATCH + /* In-kernel scratch is 0 */ + csrw CSR_SCRATCH, x0 + + move a0, a7 + + call do_sse + + csrw CSR_SSCRATCH, s4 + + REG_L a0, PT_EPC(sp) + REG_L a1, PT_STATUS(sp) + REG_L a2, PT_BADADDR(sp) + REG_L a3, PT_CAUSE(sp) + csrw CSR_EPC, a0 + csrw CSR_SSTATUS, a1 + csrw CSR_STVAL, a2 + csrw CSR_SCAUSE, a3 + + REG_L ra, PT_RA(sp) + REG_L s0, PT_S0(sp) + REG_L s1, PT_S1(sp) + REG_L s2, PT_S2(sp) + REG_L s3, PT_S3(sp) + REG_L s4, PT_S4(sp) + REG_L s5, PT_S5(sp) + REG_L s6, PT_S6(sp) + REG_L s7, PT_S7(sp) + REG_L s8, PT_S8(sp) + REG_L s9, PT_S9(sp) + REG_L s10, PT_S10(sp) + REG_L s11, PT_S11(sp) + REG_L tp, PT_TP(sp) + REG_L t0, PT_T0(sp) + REG_L t1, PT_T1(sp) + REG_L t2, PT_T2(sp) + REG_L t3, PT_T3(sp) + REG_L t4, PT_T4(sp) + REG_L t5, PT_T5(sp) + REG_L t6, PT_T6(sp) + REG_L gp, PT_GP(sp) + 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 sp, PT_SP(sp) + + li a7, SBI_EXT_SSE + li a6, SBI_SSE_EVENT_COMPLETE + ecall + +SYM_CODE_END(handle_sse) + +sse_hart_id_panic_string: + .ascii "Unable to match hart_id with cpu\0" -- 2.45.2 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 B06E8E77173 for ; Fri, 6 Dec 2024 16:41:32 +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=thBWqOYbI5NvnPZH7qF4GPDPxS4zAmAKNMl2kN59jFI=; b=U55qUUdJ2+zlk0 pIBOl5PNezTuFCRYlQ3t4H8kDjmPqFCqTdBSB4YZm3ByCWkusW/cdF7IyBdwfYohvksU97nTln/Xj exK9rybHPyjbRLIM8OOUlPgp8kY+rCD2I7IDLLdY+XNw3TOHcqMPTH1ydyQ7iahJqjq047IBFB2+9 ZsSB1Wm7criJACyT2EQOghVWu8xbqe8FPUJx+Gcw4UO/b/GepGyiy7dPR1zhaCQCAuphe53Es0hIJ G8nzXxEZK5TPMpqzNMxGGFBUro0O3b7RbNIPL4cbzQ8Q45y7RmlDOgUrgfawKqkWZ1q/guRRcA6eL fQoJfvzZjdcOysvUtaGw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1tJbOS-00000002Cvb-0LAU; Fri, 06 Dec 2024 16:41:28 +0000 Received: from mail-wr1-x431.google.com ([2a00:1450:4864:20::431]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1tJbEX-00000002AKI-0vXX for linux-riscv@lists.infradead.org; Fri, 06 Dec 2024 16:31:14 +0000 Received: by mail-wr1-x431.google.com with SMTP id ffacd0b85a97d-3862d6d5765so432022f8f.3 for ; Fri, 06 Dec 2024 08:31:12 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=rivosinc-com.20230601.gappssmtp.com; s=20230601; t=1733502671; x=1734107471; darn=lists.infradead.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=pZs2436mAWrHKZxo6XHcSc+Z7MR9g3Sqc/8PR7lb/OY=; b=NWQECNgyNfMgAImmZ01Qaw/837ga/0zS1UxO536VdiPxRPYdcIhO9IFTMi37csUv8q GP6e115YGJeZfwtfvgeR+9EAYr+ZgjkSgsYwdoF+evTlP+EAx4wyMjXdbFb8BSK5Wfpw WMcX/3T58Wj5YQ0dCS1H0i2GL6yihIrrhMfnK3UANizI06/GJHrBehndW2HH7j5SN+s1 1YCJjQ6L0FI5W7R7F/FMJM7QaDp9mM7JCczTJeoYP8JjzGvf+/zSZtG1PZTGbW0ARq2L 21NFYFVPO+tjhqdLdj8k1s48GBCHf7eG2tna19H0ohAiwlGZJf/9PeuKFz/7ykxFkaLW g2Hw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1733502671; x=1734107471; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=pZs2436mAWrHKZxo6XHcSc+Z7MR9g3Sqc/8PR7lb/OY=; b=iqkIgFyDnane0fX9Mu0sb052MtxwqdKakArDygDmp/N/WCGGgPiGq3JuF8HGU7J9d2 D32gzg8MplC+JofxVjgeOnV3+jt9rF/VVw7m1bNURYYmI5h9EzgOngcUdC+YrYCAMOJR muy65wZ/0HJ3r9wUU8RxKd2ryWSmRgC4PvMd7I/8uXp/d6KbWQOT9bRbPt8lJaxJWd1s tdi0EaHIBCLwOrJ1gH5Jl0AqSOxBr80dQ/m2KE0qFexikkcHiNIvozUhkLrR89NZLv9L JJc1d4TeeGbqwHWGXVcbOnUTo/AggIL+loBNGo8K8Vo7CVudUleb9Gj5OPyebQ5lkF06 yn4w== X-Forwarded-Encrypted: i=1; AJvYcCV5ZC8Fy8OPuN8P8xkzIeVAdXmtBYsGUCbhiuIRQ4SO46GxnEKJYG1FMxoDT4Ihu9vh5S6WgTtK+tda8g==@lists.infradead.org X-Gm-Message-State: AOJu0Yw6oH4JvUewb9Ry+e4QOSv7ABGcQSpXpqxvE29O9H9M8BEwz1Kb /h87VvQ+eQGqAAfDfN0nRGevrkKQeoqSqg8pGl04pGRgrmmBTRPBiEn5dAax7tU= X-Gm-Gg: ASbGncsyQgx6K/NbU1JFikbe82hJyN01WxjhZnigGyL/wmDfJdZ9T4L+asutP/yrtZU 5sSzjv7QjjeSVYz+YFEOAYnnxcjTmyuS/MZCshQ6eY7xxYYIIdekI4XojYpeUOwtdm7z7Tm7QbP pTmRb4IxV9pGCOuk/lCuf/Q93Tq/l24da6eWWk7DQwbPE1jGDhPS9TiSdK6XhBVlRIqNM6nuYOB Fb/coGLbeW7t7SHy8gMnGJFrm7jKxj4ljB1STPZXqm3WO4FGF8= X-Google-Smtp-Source: AGHT+IFHTqdtI6/G+fllUvPdGXlMfmZ7zOUkMH4p5p0imSiny8q9+zdmJJro+C/BeLlZrxw2h4Qlqg== X-Received: by 2002:a05:6000:1548:b0:385:dffb:4d70 with SMTP id ffacd0b85a97d-3862b3e818dmr2258522f8f.54.1733502671081; Fri, 06 Dec 2024 08:31:11 -0800 (PST) Received: from carbon-x1.. ([2a01:e0a:e17:9700:16d2:7456:6634:9626]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3862f02f5c3sm1151942f8f.65.2024.12.06.08.31.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 06 Dec 2024 08:31:10 -0800 (PST) From: =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= To: Paul Walmsley , Palmer Dabbelt , linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Cc: =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= , Himanshu Chauhan , Anup Patel , Xu Lu , Atish Patra Subject: [PATCH v3 2/4] riscv: add support for SBI Supervisor Software Events extension Date: Fri, 6 Dec 2024 17:30:58 +0100 Message-ID: <20241206163102.843505-3-cleger@rivosinc.com> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20241206163102.843505-1-cleger@rivosinc.com> References: <20241206163102.843505-1-cleger@rivosinc.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20241206_083113_273348_C9060FBE X-CRM114-Status: GOOD ( 32.06 ) 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 VGhlIFNCSSBTU0UgZXh0ZW5zaW9uIGFsbG93cyB0aGUgc3VwZXJ2aXNvciBzb2Z0d2FyZSB0byBi ZSBub3RpZmllZCBieQp0aGUgU0JJIG9mIHNwZWNpZmljIGV2ZW50cyB0aGF0IGFyZSBub3QgbWFz a2FibGUuIFRoZSBjb250ZXh0IHN3aXRjaCBpcwpoYW5kbGVkIHBhcnRpYWxseSBieSB0aGUgZmly bXdhcmUgd2hpY2ggd2lsbCBzYXZlIHJlZ2lzdGVycyBhNiBhbmQgYTcuCldoZW4gZW50ZXJpbmcg a2VybmVsIHdlIGNhbiByZWx5IG9uIHRoZXNlIDIgcmVnaXN0ZXJzIHRvIHNldHVwIHRoZSBzdGFj awphbmQgc2F2ZSBhbGwgdGhlIHJlZ2lzdGVycy4KClNpbmNlIFNTRSBldmVudHMgY2FuIGJlIGRl bGl2ZXJlZCBhdCBhbnkgdGltZSB0byB0aGUga2VybmVsIChpbmNsdWRpbmcKZHVyaW5nIGV4Y2Vw dGlvbiBoYW5kbGluZywgd2UgbmVlZCBhIHdheSB0byBsb2NhdGUgdGhlIGN1cnJlbnRfdGFzayBm b3IKY29udGV4dCB0cmFja2luZy4gT24gUklTQy1WLCBpdCBpcyBzb3RyZWQgaW4gc2NyYXRjaCB3 aGVuIGluIHVzZXIgc3BhY2UKb3IgdHAgd2hlbiBpbiBrZXJuZWwgc3BhY2UgKGluIHdoaWNoIGNh c2UgU1NDUkFUQ0ggaXMgemVybykuIEJ1dCBhdCBhCmF0IHRoZSBiZWdpbm5pbmcgb2YgZXhjZXB0 aW9uIGhhbmRsaW5nLCBTU0NSQVRDSCBpcyB1c2VkIHRvIHN3YXAgdHAgYW5kCmNoZWNrIHRoZSBv cmlnaW4gb2YgdGhlIGV4Y2VwdGlvbi4gSWYgaW50ZXJydXB0ZWQgYXQgdGhhdCBwb2ludCwgdGhl biwKdGhlcmUgaXMgbm8gd2F5IHRvIHJlbGlhYmx5IGtub3cgd2VyZSBpcyBsb2NhdGVkIHRoZSBj dXJyZW50CnRhc2tfc3RydWN0LiBFdmVuIGNoZWNraW5nIHRoZSBpbnRlcnJ1cHRpb24gbG9jYXRp b24gd29uJ3Qgd29yayBhcyBTU0UKZXZlbnQgY2FuIGJlIG5lc3RlZCBvbiB0b3Agb2YgZWFjaCBv dGhlciBzbyB0aGUgb3JpZ2luYWwgaW50ZXJydXB0aW9uCnNpdGUgbWlnaHQgYmUgbG9zdCBhdCBz b21lIHBvaW50LiBJbiBvcmRlciB0byByZXRyaWV2ZSBpdCByZWxpYWJseSwKc3RvcmUgdGhlIGN1 cnJlbnQgdGFzayBpbiBhbiBhZGRpdGlvbm5hbCBfX3NzZV9lbnRyeV90YXNrIHBlcl9jcHUgYXJy YXkuClRoaXMgYXJyYXkgaXMgdGhlbiB1c2VkIHRvIHJldHJpZXZlIHRoZSBjdXJyZW50IHRhc2sg YmFzZWQgb24gdGhlCmhhcnQgSUQgdGhhdCBpcyBwYXNzZWQgdG8gdGhlIFNTRSBldmVudCBoYW5k bGVyIGluIGE2LgoKVGhhdCBiZWluZyBzYWlkLCB0aGUgd2F5IHRoZSBjdXJyZW50IHRhc2sgc3Ry dWN0IGlzIHN0b3JlZCBzaG91bGQKcHJvYmFibHkgYmUgcmV3b3JrZWQgdG8gZmluZCBhIGJldHRl ciByZWxpYWJsZSBhbHRlcm5hdGl2ZS4KClNpbmNlIGVhY2ggZXZlbnRzIChhbmQgZWFjaCBDUFUg Zm9yIGxvY2FsIGV2ZW50cykgaGF2ZSB0aGVpciBvd24KY29udGV4dCBhbmQgY2FuIHByZWVtcHQg ZWFjaCBvdGhlciwgYWxsb2NhdGUgYSBzdGFjayAoYW5kIGEgc2hhZG93IHN0YWNrCmlmIG5lZWRl ZCBmb3IgZWFjaCBvZiB0aGVtIChhbmQgZm9yIGVhY2ggY3B1IGZvciBsb2NhbCBldmVudHMpLgoK V2hlbiBjb21wbGV0aW5nIHRoZSBldmVudCwgaWYgd2Ugd2VyZSBjb21pbmcgZnJvbSBrZXJuZWwg d2l0aCBpbnRlcnJ1cHRzCmRpc2FibGVkLCBzaW1wbHkgcmV0dXJuIHRoZXJlLiBJZiBjb21pbmcg ZnJvbSB1c2Vyc3BhY2Ugb3Iga2VybmVsIHdpdGgKaW50ZXJydXB0cyBlbmFibGVkLCBzaW11bGF0 ZSBhbiBpbnRlcnJ1cHQgZXhjZXB0aW9uIGJ5IHNldHRpbmcgSUVfU0lFIGluCkNTUl9JUCB0byBh bGxvdyBkZWxpdmVyeSBvZiBzaWduYWxzIHRvIHVzZXIgdGFzay4gRm9yIGluc3RhbmNlIHRoaXMg Y2FuCmhhcHBlbiwgd2hlbiBhIFJBUyBldmVudCBoYXMgYmVlbiBnZW5lcmF0ZWQgYnkgYSB1c2Vy IGFwcGxpY2F0aW9uIGFuZCBhClNJR0JVUyBoYXMgYmVlbiBzZW50IHRvIGEgdGFzay4KClNpZ25l ZC1vZmYtYnk6IENsw6ltZW50IEzDqWdlciA8Y2xlZ2VyQHJpdm9zaW5jLmNvbT4KLS0tCiBhcmNo L3Jpc2N2L2luY2x1ZGUvYXNtL2FzbS5oICAgICAgICAgfCAgMTQgKystCiBhcmNoL3Jpc2N2L2lu Y2x1ZGUvYXNtL3Njcy5oICAgICAgICAgfCAgIDcgKysKIGFyY2gvcmlzY3YvaW5jbHVkZS9hc20v c3NlLmggICAgICAgICB8ICAzOCArKysrKysKIGFyY2gvcmlzY3YvaW5jbHVkZS9hc20vc3dpdGNo X3RvLmggICB8ICAxNCArKysKIGFyY2gvcmlzY3YvaW5jbHVkZS9hc20vdGhyZWFkX2luZm8uaCB8 ICAgMSArCiBhcmNoL3Jpc2N2L2tlcm5lbC9NYWtlZmlsZSAgICAgICAgICAgfCAgIDEgKwogYXJj aC9yaXNjdi9rZXJuZWwvYXNtLW9mZnNldHMuYyAgICAgIHwgIDEyICsrCiBhcmNoL3Jpc2N2L2tl cm5lbC9zc2UuYyAgICAgICAgICAgICAgfCAxMzQgKysrKysrKysrKysrKysrKysrKysrCiBhcmNo L3Jpc2N2L2tlcm5lbC9zc2VfZW50cnkuUyAgICAgICAgfCAxNzEgKysrKysrKysrKysrKysrKysr KysrKysrKysrCiA5IGZpbGVzIGNoYW5nZWQsIDM4OSBpbnNlcnRpb25zKCspLCAzIGRlbGV0aW9u cygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGFyY2gvcmlzY3YvaW5jbHVkZS9hc20vc3NlLmgKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL3Jpc2N2L2tlcm5lbC9zc2UuYwogY3JlYXRlIG1vZGUgMTAw NjQ0IGFyY2gvcmlzY3Yva2VybmVsL3NzZV9lbnRyeS5TCgpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNj di9pbmNsdWRlL2FzbS9hc20uaCBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vYXNtLmgKaW5kZXgg Nzc2MzU0ODk1YjgxLi5kZTg0MjdjNThmMDIgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3YvaW5jbHVk ZS9hc20vYXNtLmgKKysrIGIvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9hc20uaApAQCAtODksMTYg Kzg5LDI0IEBACiAjZGVmaW5lIFBFUl9DUFVfT0ZGU0VUX1NISUZUIDMKICNlbmRpZgogCi0ubWFj cm8gYXNtX3Blcl9jcHUgZHN0IHN5bSB0bXAKLQlSRUdfTCBcdG1wLCBUQVNLX1RJX0NQVV9OVU0o dHApCi0Jc2xsaSAgXHRtcCwgXHRtcCwgUEVSX0NQVV9PRkZTRVRfU0hJRlQKKy5tYWNybyBhc21f cGVyX2NwdV93aXRoX2NwdSBkc3Qgc3ltIHRtcCBjcHUKKwlzbGxpICBcdG1wLCBcY3B1LCBQRVJf Q1BVX09GRlNFVF9TSElGVAogCWxhICAgIFxkc3QsIF9fcGVyX2NwdV9vZmZzZXQKIAlhZGQgICBc ZHN0LCBcZHN0LCBcdG1wCiAJUkVHX0wgXHRtcCwgMChcZHN0KQogCWxhICAgIFxkc3QsIFxzeW0K IAlhZGQgICBcZHN0LCBcZHN0LCBcdG1wCiAuZW5kbQorCisubWFjcm8gYXNtX3Blcl9jcHUgZHN0 IHN5bSB0bXAKKwlSRUdfTCBcdG1wLCBUQVNLX1RJX0NQVV9OVU0odHApCisJYXNtX3Blcl9jcHVf d2l0aF9jcHUgXGRzdCBcc3ltIFx0bXAgXHRtcAorLmVuZG0KICNlbHNlIC8qIENPTkZJR19TTVAg Ki8KKy5tYWNybyBhc21fcGVyX2NwdV93aXRoX2NwdSBkc3Qgc3ltIHRtcCBjcHUKKwlsYSAgICBc ZHN0LCBcc3ltCisuZW5kbQorCiAubWFjcm8gYXNtX3Blcl9jcHUgZHN0IHN5bSB0bXAKIAlsYSAg ICBcZHN0LCBcc3ltCiAuZW5kbQpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9z Y3MuaCBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vc2NzLmgKaW5kZXggMGU0NWRiNzhiMjRiLi42 MjM0NGRhYWQ3M2QgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vc2NzLmgKKysr IGIvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9zY3MuaApAQCAtMTgsNiArMTgsMTEgQEAKIAlsb2Fk X3Blcl9jcHUgZ3AsIGlycV9zaGFkb3dfY2FsbF9zdGFja19wdHIsIFx0bXAKIC5lbmRtCiAKKy8q IExvYWQgdGhlIHBlci1DUFUgSVJRIHNoYWRvdyBjYWxsIHN0YWNrIHRvIGdwLiAqLworLm1hY3Jv IHNjc19sb2FkX3NzZV9zdGFjayByZWdfZXZ0CisJUkVHX0wgZ3AsIFNTRV9SRUdfRVZUX1NIQURP V19TVEFDSyhccmVnX2V2dCkKKy5lbmRtCisKIC8qIExvYWQgdGFza19zY3Nfc3AoY3VycmVudCkg dG8gZ3AuICovCiAubWFjcm8gc2NzX2xvYWRfY3VycmVudAogCVJFR19MCWdwLCBUQVNLX1RJX1ND U19TUCh0cCkKQEAgLTQxLDYgKzQ2LDggQEAKIC5lbmRtCiAubWFjcm8gc2NzX2xvYWRfaXJxX3N0 YWNrIHRtcAogLmVuZG0KKy5tYWNybyBzY3NfbG9hZF9zc2Vfc3RhY2sgcmVnX2V2dAorLmVuZG0K IC5tYWNybyBzY3NfbG9hZF9jdXJyZW50CiAuZW5kbQogLm1hY3JvIHNjc19sb2FkX2N1cnJlbnRf aWZfdGFza19jaGFuZ2VkIHByZXYKZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20v c3NlLmggYi9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3NzZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMC4uNDMxYTE5ZDRjZDljCi0tLSAvZGV2L251bGwKKysrIGIvYXJj aC9yaXNjdi9pbmNsdWRlL2FzbS9zc2UuaApAQCAtMCwwICsxLDM4IEBACisvKiBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5ICovCisvKgorICogQ29weXJpZ2h0IChDKSAyMDI0 IFJpdm9zIEluYy4KKyAqLworI2lmbmRlZiBfX0FTTV9TU0VfSAorI2RlZmluZSBfX0FTTV9TU0Vf SAorCisjaWZkZWYgQ09ORklHX1JJU0NWX1NTRQorCitzdHJ1Y3Qgc3NlX2V2ZW50X2ludGVycnVw dGVkX3N0YXRlIHsKKwl1bnNpZ25lZCBsb25nIGE2OworCXVuc2lnbmVkIGxvbmcgYTc7Cit9Owor CitzdHJ1Y3Qgc3NlX2V2ZW50X2FyY2hfZGF0YSB7CisJdm9pZCAqc3RhY2s7CisJdm9pZCAqc2hh ZG93X3N0YWNrOworCXVuc2lnbmVkIGxvbmcgdG1wOworCXN0cnVjdCBzc2VfZXZlbnRfaW50ZXJy dXB0ZWRfc3RhdGUgaW50ZXJydXB0ZWQ7CisJdW5zaWduZWQgbG9uZyBpbnRlcnJ1cHRlZF9zdGF0 ZV9waHlzOworCXUzMiBldnRfaWQ7Cit9OworCitzdHJ1Y3Qgc3NlX3JlZ2lzdGVyZWRfZXZlbnQ7 CitpbnQgYXJjaF9zc2VfaW5pdF9ldmVudChzdHJ1Y3Qgc3NlX2V2ZW50X2FyY2hfZGF0YSAqYXJj aF9ldnQsIHUzMiBldnRfaWQsCisJCQlpbnQgY3B1KTsKK3ZvaWQgYXJjaF9zc2VfZnJlZV9ldmVu dChzdHJ1Y3Qgc3NlX2V2ZW50X2FyY2hfZGF0YSAqYXJjaF9ldnQpOworaW50IGFyY2hfc3NlX3Jl Z2lzdGVyX2V2ZW50KHN0cnVjdCBzc2VfZXZlbnRfYXJjaF9kYXRhICphcmNoX2V2dCk7CisKK3Zv aWQgc3NlX2hhbmRsZV9ldmVudChzdHJ1Y3Qgc3NlX2V2ZW50X2FyY2hfZGF0YSAqYXJjaF9ldnQs CisJCSAgICAgIHN0cnVjdCBwdF9yZWdzICpyZWdzKTsKK2FzbWxpbmthZ2Ugdm9pZCBoYW5kbGVf c3NlKHZvaWQpOworYXNtbGlua2FnZSB2b2lkIGRvX3NzZShzdHJ1Y3Qgc3NlX2V2ZW50X2FyY2hf ZGF0YSAqYXJjaF9ldnQsCisJCQkJc3RydWN0IHB0X3JlZ3MgKnJlZyk7CisKKyNlbmRpZgorCisj ZW5kaWYKZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vc3dpdGNoX3RvLmggYi9h cmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3N3aXRjaF90by5oCmluZGV4IDk0ZTMzMjE2YjJkOS4uZTE2 NmZhYmUwNGFiIDEwMDY0NAotLS0gYS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3N3aXRjaF90by5o CisrKyBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vc3dpdGNoX3RvLmgKQEAgLTg4LDYgKzg4LDE5 IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBfX3N3aXRjaF90b19lbnZjZmcoc3RydWN0IHRhc2tfc3Ry dWN0ICpuZXh0KQogCQkJOjogInIiIChuZXh0LT50aHJlYWQuZW52Y2ZnKSA6ICJtZW1vcnkiKTsK IH0KIAorI2lmZGVmIENPTkZJR19SSVNDVl9TU0UKK0RFQ0xBUkVfUEVSX0NQVShzdHJ1Y3QgdGFz a19zdHJ1Y3QgKiwgX19zc2VfZW50cnlfdGFzayk7CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX3N3 aXRjaF9zc2VfZW50cnlfdGFzayhzdHJ1Y3QgdGFza19zdHJ1Y3QgKm5leHQpCit7CisJX190aGlz X2NwdV93cml0ZShfX3NzZV9lbnRyeV90YXNrLCBuZXh0KTsKK30KKyNlbHNlCitzdGF0aWMgaW5s aW5lIHZvaWQgX19zd2l0Y2hfc3NlX2VudHJ5X3Rhc2soc3RydWN0IHRhc2tfc3RydWN0ICpuZXh0 KQoreworfQorI2VuZGlmCisKIGV4dGVybiBzdHJ1Y3QgdGFza19zdHJ1Y3QgKl9fc3dpdGNoX3Rv KHN0cnVjdCB0YXNrX3N0cnVjdCAqLAogCQkJCSAgICAgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKik7 CiAKQEAgLTEyMiw2ICsxMzUsNyBAQCBkbyB7CQkJCQkJCVwKIAlpZiAoc3dpdGNoX3RvX3Nob3Vs ZF9mbHVzaF9pY2FjaGUoX19uZXh0KSkJXAogCQlsb2NhbF9mbHVzaF9pY2FjaGVfYWxsKCk7CQlc CiAJX19zd2l0Y2hfdG9fZW52Y2ZnKF9fbmV4dCk7CQkJXAorCV9fc3dpdGNoX3NzZV9lbnRyeV90 YXNrKF9fbmV4dCk7CQkJXAogCSgobGFzdCkgPSBfX3N3aXRjaF90byhfX3ByZXYsIF9fbmV4dCkp OwkJXAogfSB3aGlsZSAoMCkKIApkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS90 aHJlYWRfaW5mby5oIGIvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS90aHJlYWRfaW5mby5oCmluZGV4 IGY1OTE2YTcwODc5YS4uMjhlOTgwNWU2MWZjIDEwMDY0NAotLS0gYS9hcmNoL3Jpc2N2L2luY2x1 ZGUvYXNtL3RocmVhZF9pbmZvLmgKKysrIGIvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS90aHJlYWRf aW5mby5oCkBAIC0zNiw2ICszNiw3IEBACiAjZGVmaW5lIE9WRVJGTE9XX1NUQUNLX1NJWkUgICAg IFNaXzRLCiAKICNkZWZpbmUgSVJRX1NUQUNLX1NJWkUJCVRIUkVBRF9TSVpFCisjZGVmaW5lIFNT RV9TVEFDS19TSVpFCQlUSFJFQURfU0laRQogCiAjaWZuZGVmIF9fQVNTRU1CTFlfXwogCmRpZmYg LS1naXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC9NYWtlZmlsZSBiL2FyY2gvcmlzY3Yva2VybmVsL01h a2VmaWxlCmluZGV4IDA2M2QxZmFmNWE1My4uMWU4ZmI4M2IxMTYyIDEwMDY0NAotLS0gYS9hcmNo L3Jpc2N2L2tlcm5lbC9NYWtlZmlsZQorKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9NYWtlZmlsZQpA QCAtOTksNiArOTksNyBAQCBvYmotJChDT05GSUdfRFlOQU1JQ19GVFJBQ0UpCSs9IG1jb3VudC1k eW4ubwogb2JqLSQoQ09ORklHX1BFUkZfRVZFTlRTKQkrPSBwZXJmX2NhbGxjaGFpbi5vCiBvYmot JChDT05GSUdfSEFWRV9QRVJGX1JFR1MpCSs9IHBlcmZfcmVncy5vCiBvYmotJChDT05GSUdfUklT Q1ZfU0JJKQkJKz0gc2JpLm8gc2JpX2VjYWxsLm8KK29iai0kKENPTkZJR19SSVNDVl9TU0UpCQkr PSBzc2UubyBzc2VfZW50cnkubwogaWZlcSAoJChDT05GSUdfUklTQ1ZfU0JJKSwgeSkKIG9iai0k KENPTkZJR19TTVApCQkrPSBzYmktaXBpLm8KIG9iai0kKENPTkZJR19TTVApICs9IGNwdV9vcHNf c2JpLm8KZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3Yva2VybmVsL2FzbS1vZmZzZXRzLmMgYi9hcmNo L3Jpc2N2L2tlcm5lbC9hc20tb2Zmc2V0cy5jCmluZGV4IGU4OTQ1NWE2YTBlNS4uNjA1OTBhM2Q5 NTE5IDEwMDY0NAotLS0gYS9hcmNoL3Jpc2N2L2tlcm5lbC9hc20tb2Zmc2V0cy5jCisrKyBiL2Fy Y2gvcmlzY3Yva2VybmVsL2FzbS1vZmZzZXRzLmMKQEAgLTE0LDYgKzE0LDggQEAKICNpbmNsdWRl IDxhc20vcHRyYWNlLmg+CiAjaW5jbHVkZSA8YXNtL2NwdV9vcHNfc2JpLmg+CiAjaW5jbHVkZSA8 YXNtL3N0YWNrdHJhY2UuaD4KKyNpbmNsdWRlIDxhc20vc2JpLmg+CisjaW5jbHVkZSA8YXNtL3Nz ZS5oPgogI2luY2x1ZGUgPGFzbS9zdXNwZW5kLmg+CiAKIHZvaWQgYXNtX29mZnNldHModm9pZCk7 CkBAIC01MTEsNCArNTEzLDE0IEBAIHZvaWQgYXNtX29mZnNldHModm9pZCkKIAlERUZJTkUoRlJF R1NfQTYsCSAgICBvZmZzZXRvZihzdHJ1Y3QgX19hcmNoX2Z0cmFjZV9yZWdzLCBhNikpOwogCURF RklORShGUkVHU19BNywJICAgIG9mZnNldG9mKHN0cnVjdCBfX2FyY2hfZnRyYWNlX3JlZ3MsIGE3 KSk7CiAjZW5kaWYKKworI2lmZGVmIENPTkZJR19SSVNDVl9TU0UKKwlPRkZTRVQoU1NFX1JFR19F VlRfU1RBQ0ssIHNzZV9ldmVudF9hcmNoX2RhdGEsIHN0YWNrKTsKKwlPRkZTRVQoU1NFX1JFR19F VlRfU0hBRE9XX1NUQUNLLCBzc2VfZXZlbnRfYXJjaF9kYXRhLCBzaGFkb3dfc3RhY2spOworCU9G RlNFVChTU0VfUkVHX0VWVF9UTVAsIHNzZV9ldmVudF9hcmNoX2RhdGEsIHRtcCk7CisKKwlERUZJ TkUoU0JJX0VYVF9TU0UsIFNCSV9FWFRfU1NFKTsKKwlERUZJTkUoU0JJX1NTRV9FVkVOVF9DT01Q TEVURSwgU0JJX1NTRV9FVkVOVF9DT01QTEVURSk7CisJREVGSU5FKE5SX0NQVVMsIE5SX0NQVVMp OworI2VuZGlmCiB9CmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC9zc2UuYyBiL2FyY2gv cmlzY3Yva2VybmVsL3NzZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MC4uYjQ4YWU2OWRhZDhkCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9yaXNjdi9rZXJuZWwvc3Nl LmMKQEAgLTAsMCArMSwxMzQgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4w LW9yLWxhdGVyCisvKgorICogQ29weXJpZ2h0IChDKSAyMDI0IFJpdm9zIEluYy4KKyAqLworI2lu Y2x1ZGUgPGxpbnV4L25taS5oPgorI2luY2x1ZGUgPGxpbnV4L3Njcy5oPgorI2luY2x1ZGUgPGxp bnV4L2JpdGZpZWxkLmg+CisjaW5jbHVkZSA8bGludXgvcmlzY3Zfc3NlLmg+CisjaW5jbHVkZSA8 bGludXgvcGVyY3B1LWRlZnMuaD4KKworI2luY2x1ZGUgPGFzbS9hc20tcHJvdG90eXBlcy5oPgor I2luY2x1ZGUgPGFzbS9zd2l0Y2hfdG8uaD4KKyNpbmNsdWRlIDxhc20vaXJxX3N0YWNrLmg+Cisj aW5jbHVkZSA8YXNtL3NiaS5oPgorI2luY2x1ZGUgPGFzbS9zc2UuaD4KKworREVGSU5FX1BFUl9D UFUoc3RydWN0IHRhc2tfc3RydWN0ICosIF9fc3NlX2VudHJ5X3Rhc2spOworCit2b2lkIF9fd2Vh ayBzc2VfaGFuZGxlX2V2ZW50KHN0cnVjdCBzc2VfZXZlbnRfYXJjaF9kYXRhICphcmNoX2V2dCwg c3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7Cit9CisKK3ZvaWQgZG9fc3NlKHN0cnVjdCBzc2VfZXZl bnRfYXJjaF9kYXRhICphcmNoX2V2dCwgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJbm1pX2Vu dGVyKCk7CisKKwkvKiBSZXRyaWV2ZSBtaXNzaW5nIEdQUnMgZnJvbSBTQkkgKi8KKwlzYmlfZWNh bGwoU0JJX0VYVF9TU0UsIFNCSV9TU0VfRVZFTlRfQVRUUl9SRUFELCBhcmNoX2V2dC0+ZXZ0X2lk LAorCQkgIFNCSV9TU0VfQVRUUl9JTlRFUlJVUFRFRF9BNiwKKwkJICAoU0JJX1NTRV9BVFRSX0lO VEVSUlVQVEVEX0E3IC0gU0JJX1NTRV9BVFRSX0lOVEVSUlVQVEVEX0E2KSArIDEsCisJCSAgYXJj aF9ldnQtPmludGVycnVwdGVkX3N0YXRlX3BoeXMsIDAsIDApOworCisJbWVtY3B5KCZyZWdzLT5h NiwgJmFyY2hfZXZ0LT5pbnRlcnJ1cHRlZCwgc2l6ZW9mKGFyY2hfZXZ0LT5pbnRlcnJ1cHRlZCkp OworCisJc3NlX2hhbmRsZV9ldmVudChhcmNoX2V2dCwgcmVncyk7CisKKwkvKgorCSAqIFRoZSBT U0UgZGVsaXZlcnkgcGF0aCBkb2VzIG5vdCB1c2VzIHRoZSAic3RhbmRhcmQiIGV4Y2VwdGlvbiBw YXRoIGFuZAorCSAqIHRodXMgZG9lcyBub3QgcHJvY2VzcyBhbnkgcGVuZGluZyBzaWduYWwvc29m dGlycXMuIFNvbWUgZHJpdmVycyBtaWdodAorCSAqIGVucXVldWUgcGVuZGluZyB3b3JrIHRoYXQg bmVlZHMgdG8gYmUgaGFuZGxlZCBhcyBzb29uIGFzIHBvc3NpYmxlLgorCSAqIEZvciB0aGF0IHB1 cnBvc2UsIHNldCB0aGUgc29mdHdhcmUgaW50ZXJydXB0IHBlbmRpbmcgYml0IHdoaWNoIHdpbGwK KwkgKiBiZSBzZXJ2aWNlZCBvbmNlIGludGVycnVwdHMgYXJlIHJlZW5hYmxlZAorCSAqLworCWNz cl9zZXQoQ1NSX0lQLCBJRV9TSUUpOworCisJbm1pX2V4aXQoKTsKK30KKworI2lmZGVmIENPTkZJ R19WTUFQX1NUQUNLCitzdGF0aWMgdW5zaWduZWQgbG9uZyAqc3NlX3N0YWNrX2FsbG9jKHVuc2ln bmVkIGludCBjcHUsIHVuc2lnbmVkIGludCBzaXplKQoreworCXJldHVybiBhcmNoX2FsbG9jX3Zt YXBfc3RhY2soc2l6ZSwgY3B1X3RvX25vZGUoY3B1KSk7Cit9CisKK3N0YXRpYyB2b2lkIHNzZV9z dGFja19mcmVlKHVuc2lnbmVkIGxvbmcgKnN0YWNrKQoreworCXZmcmVlKHN0YWNrKTsKK30KKyNl bHNlIC8qIENPTkZJR19WTUFQX1NUQUNLICovCisKK3N0YXRpYyB1bnNpZ25lZCBsb25nICpzc2Vf c3RhY2tfYWxsb2ModW5zaWduZWQgaW50IGNwdSwgdW5zaWduZWQgaW50IHNpemUpCit7CisJcmV0 dXJuIGttYWxsb2Moc2l6ZSwgR0ZQX0tFUk5FTCk7Cit9CisKK3N0YXRpYyB2b2lkIHNzZV9zdGFj a19mcmVlKHVuc2lnbmVkIGxvbmcgKnN0YWNrKQoreworCWtmcmVlKHN0YWNrKTsKK30KKworI2Vu ZGlmIC8qIENPTkZJR19WTUFQX1NUQUNLICovCisKK3N0YXRpYyBpbnQgc3NlX2luaXRfc2NzKGlu dCBjcHUsIHN0cnVjdCBzc2VfZXZlbnRfYXJjaF9kYXRhICphcmNoX2V2dCkKK3sKKwl2b2lkICpz dGFjazsKKworCWlmICghc2NzX2lzX2VuYWJsZWQoKSkKKwkJcmV0dXJuIDA7CisKKwlzdGFjayA9 IHNjc19hbGxvYyhjcHVfdG9fbm9kZShjcHUpKTsKKwlpZiAoIXN0YWNrKQorCQlyZXR1cm4gMTsK KworCWFyY2hfZXZ0LT5zaGFkb3dfc3RhY2sgPSBzdGFjazsKKworCXJldHVybiAwOworfQorCitp bnQgYXJjaF9zc2VfaW5pdF9ldmVudChzdHJ1Y3Qgc3NlX2V2ZW50X2FyY2hfZGF0YSAqYXJjaF9l dnQsIHUzMiBldnRfaWQsIGludCBjcHUpCit7CisJdm9pZCAqc3RhY2s7CisKKwlhcmNoX2V2dC0+ ZXZ0X2lkID0gZXZ0X2lkOworCXN0YWNrID0gc3NlX3N0YWNrX2FsbG9jKGNwdSwgU1NFX1NUQUNL X1NJWkUpOworCWlmICghc3RhY2spCisJCXJldHVybiAtRU5PTUVNOworCisJYXJjaF9ldnQtPnN0 YWNrID0gc3RhY2sgKyBTU0VfU1RBQ0tfU0laRTsKKworCWlmIChzc2VfaW5pdF9zY3MoY3B1LCBh cmNoX2V2dCkpCisJCWdvdG8gZnJlZV9zdGFjazsKKworCWlmIChpc19rZXJuZWxfcGVyY3B1X2Fk ZHJlc3MoKHVuc2lnbmVkIGxvbmcpJmFyY2hfZXZ0LT5pbnRlcnJ1cHRlZCkpIHsKKwkJYXJjaF9l dnQtPmludGVycnVwdGVkX3N0YXRlX3BoeXMgPQorCQkJCXBlcl9jcHVfcHRyX3RvX3BoeXMoJmFy Y2hfZXZ0LT5pbnRlcnJ1cHRlZCk7CisJfSBlbHNlIHsKKwkJYXJjaF9ldnQtPmludGVycnVwdGVk X3N0YXRlX3BoeXMgPQorCQkJCXZpcnRfdG9fcGh5cygmYXJjaF9ldnQtPmludGVycnVwdGVkKTsK Kwl9CisKKwlyZXR1cm4gMDsKKworZnJlZV9zdGFjazoKKwlzc2Vfc3RhY2tfZnJlZShhcmNoX2V2 dC0+c3RhY2sgLSBTU0VfU1RBQ0tfU0laRSk7CisKKwlyZXR1cm4gLUVOT01FTTsKK30KKwordm9p ZCBhcmNoX3NzZV9mcmVlX2V2ZW50KHN0cnVjdCBzc2VfZXZlbnRfYXJjaF9kYXRhICphcmNoX2V2 dCkKK3sKKwlzY3NfZnJlZShhcmNoX2V2dC0+c2hhZG93X3N0YWNrKTsKKwlzc2Vfc3RhY2tfZnJl ZShhcmNoX2V2dC0+c3RhY2sgLSBTU0VfU1RBQ0tfU0laRSk7Cit9CisKK2ludCBhcmNoX3NzZV9y ZWdpc3Rlcl9ldmVudChzdHJ1Y3Qgc3NlX2V2ZW50X2FyY2hfZGF0YSAqYXJjaF9ldnQpCit7CisJ c3RydWN0IHNiaXJldCBzcmV0OworCisJc3JldCA9IHNiaV9lY2FsbChTQklfRVhUX1NTRSwgU0JJ X1NTRV9FVkVOVF9SRUdJU1RFUiwgYXJjaF9ldnQtPmV2dF9pZCwKKwkJCSAodW5zaWduZWQgbG9u ZykgaGFuZGxlX3NzZSwgKHVuc2lnbmVkIGxvbmcpIGFyY2hfZXZ0LAorCQkJIDAsIDAsIDApOwor CisJcmV0dXJuIHNiaV9lcnJfbWFwX2xpbnV4X2Vycm5vKHNyZXQuZXJyb3IpOworfQpkaWZmIC0t Z2l0IGEvYXJjaC9yaXNjdi9rZXJuZWwvc3NlX2VudHJ5LlMgYi9hcmNoL3Jpc2N2L2tlcm5lbC9z c2VfZW50cnkuUwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjBiMmY4 OTBlZGQ4OQotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvcmlzY3Yva2VybmVsL3NzZV9lbnRyeS5T CkBAIC0wLDAgKzEsMTcxIEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1v bmx5ICovCisvKgorICogQ29weXJpZ2h0IChDKSAyMDI0IFJpdm9zIEluYy4KKyAqLworCisjaW5j bHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L2xpbmthZ2UuaD4KKworI2luY2x1 ZGUgPGFzbS9hc20uaD4KKyNpbmNsdWRlIDxhc20vY3NyLmg+CisjaW5jbHVkZSA8YXNtL3Njcy5o PgorCisvKiBXaGVuIGVudGVyaW5nIGhhbmRsZV9zc2UsIHRoZSBmb2xsb3dpbmcgcmVnaXN0ZXJz IGFyZSBzZXQ6CisgKiBhNjogY29udGFpbnMgdGhlIGhhcnRpZAorICogYTY6IGNvbnRhaW5zIHN0 cnVjdCBzc2VfcmVnaXN0ZXJlZF9ldmVudCBwb2ludGVyCisgKi8KK1NZTV9DT0RFX1NUQVJUKGhh bmRsZV9zc2UpCisJLyogU2F2ZSBzdGFjayB0ZW1wb3JhcmlseSAqLworCVJFR19TIHNwLCBTU0Vf UkVHX0VWVF9UTVAoYTcpCisJLyogU2V0IGVudHJ5IHN0YWNrICovCisJUkVHX0wgc3AsIFNTRV9S RUdfRVZUX1NUQUNLKGE3KQorCisJYWRkaSBzcCwgc3AsIC0oUFRfU0laRV9PTl9TVEFDSykKKwlS RUdfUyByYSwgUFRfUkEoc3ApCisJUkVHX1MgczAsIFBUX1MwKHNwKQorCVJFR19TIHMxLCBQVF9T MShzcCkKKwlSRUdfUyBzMiwgUFRfUzIoc3ApCisJUkVHX1MgczMsIFBUX1MzKHNwKQorCVJFR19T IHM0LCBQVF9TNChzcCkKKwlSRUdfUyBzNSwgUFRfUzUoc3ApCisJUkVHX1MgczYsIFBUX1M2KHNw KQorCVJFR19TIHM3LCBQVF9TNyhzcCkKKwlSRUdfUyBzOCwgUFRfUzgoc3ApCisJUkVHX1Mgczks IFBUX1M5KHNwKQorCVJFR19TIHMxMCwgUFRfUzEwKHNwKQorCVJFR19TIHMxMSwgUFRfUzExKHNw KQorCVJFR19TIHRwLCBQVF9UUChzcCkKKwlSRUdfUyB0MCwgUFRfVDAoc3ApCisJUkVHX1MgdDEs IFBUX1QxKHNwKQorCVJFR19TIHQyLCBQVF9UMihzcCkKKwlSRUdfUyB0MywgUFRfVDMoc3ApCisJ UkVHX1MgdDQsIFBUX1Q0KHNwKQorCVJFR19TIHQ1LCBQVF9UNShzcCkKKwlSRUdfUyB0NiwgUFRf VDYoc3ApCisJUkVHX1MgZ3AsIFBUX0dQKHNwKQorCVJFR19TIGEwLCBQVF9BMChzcCkKKwlSRUdf UyBhMSwgUFRfQTEoc3ApCisJUkVHX1MgYTIsIFBUX0EyKHNwKQorCVJFR19TIGEzLCBQVF9BMyhz cCkKKwlSRUdfUyBhNCwgUFRfQTQoc3ApCisJUkVHX1MgYTUsIFBUX0E1KHNwKQorCisJLyogUmV0 cmlldmUgZW50cnkgc3AgKi8KKwlSRUdfTCBhNCwgU1NFX1JFR19FVlRfVE1QKGE3KQorCS8qIFNh dmUgQ1NScyAqLworCWNzcnIgYTAsIENTUl9FUEMKKwljc3JyIGExLCBDU1JfU1NUQVRVUworCWNz cnIgYTIsIENTUl9TVFZBTAorCWNzcnIgYTMsIENTUl9TQ0FVU0UKKworCVJFR19TIGEwLCBQVF9F UEMoc3ApCisJUkVHX1MgYTEsIFBUX1NUQVRVUyhzcCkKKwlSRUdfUyBhMiwgUFRfQkFEQUREUihz cCkKKwlSRUdfUyBhMywgUFRfQ0FVU0Uoc3ApCisJUkVHX1MgYTQsIFBUX1NQKHNwKQorCisJLyog RGlzYWJsZSB1c2VyIG1lbW9yeSBhY2Nlc3MgYW5kIGZsb2F0aW5nL3ZlY3RvciBjb21wdXRpbmcg Ki8KKwlsaSB0MCwgU1JfU1VNIHwgU1JfRlNfVlMKKwljc3JjIENTUl9TVEFUVVMsIHQwCisKKwls b2FkX2dsb2JhbF9wb2ludGVyCisJc2NzX2xvYWRfc3NlX3N0YWNrIGE3CisKKwkvKiBSZXN0b3Jl IGN1cnJlbnQgdGFzayBzdHJ1Y3QgZnJvbSBfX3NzZV9lbnRyeV90YXNrICovCisJbGkgdDEsIE5S X0NQVVMKKwltb3ZlIHQzLCB6ZXJvCisKKyNpZmRlZiBDT05GSUdfU01QCisJLyogRmluZCB0aGUg Q1BVIGlkIGFzc29jaWF0ZWQgdG8gdGhlIGhhcnQgaWQgKi8KKwlsYSB0MCwgX19jcHVpZF90b19o YXJ0aWRfbWFwCisuTGhhcnRfaWRfbG9vcDoKKwlSRUdfTCB0MiwgMCh0MCkKKwliZXEgdDIsIGE2 LCAuTGNwdV9pZF9mb3VuZAorCisJLyogSW5jcmVtZW50IHBvaW50ZXIgYW5kIENQVSBudW1iZXIg Ki8KKwlhZGRpIHQzLCB0MywgMQorCWFkZGkgdDAsIHQwLCBSSVNDVl9TWlBUUgorCWJsdHUgdDMs IHQxLCAuTGhhcnRfaWRfbG9vcAorCisJLyoKKwkgKiBUaGlzIHNob3VsZCBuZXZlciBoYXBwZW4g c2luY2Ugd2UgZXhwZWN0IHRoZSBoYXJ0X2lkIHRvIG1hdGNoIG9uZQorCSAqIG9mIG91ciBDUFUs IGJ1dCBiZXR0ZXIgYmUgc2FmZSB0aGFuIHNvcnJ5CisJICovCisJbGEgdHAsIGluaXRfdGFzawor CWxhIGEwLCBzc2VfaGFydF9pZF9wYW5pY19zdHJpbmcKKwlsYSB0MCwgcGFuaWMKKwlqYWxyIHQw CisKKy5MY3B1X2lkX2ZvdW5kOgorI2VuZGlmCisJYXNtX3Blcl9jcHVfd2l0aF9jcHUgdDIgX19z c2VfZW50cnlfdGFzayB0MSB0MworCVJFR19MIHRwLCAwKHQyKQorCisJbW92ZSBhMSwgc3AgLyog cHRfcmVncyBvbiBzdGFjayAqLworCS8qIEtlcm5lbCB3YXMgaW50ZXJydXB0ZWQsIGNyZWF0ZSBz dGFjayBmcmFtZSAqLworCWJlcXogczEsIC5MY2FsbF9kb19zc2UKKworLkxjYWxsX2RvX3NzZToK KwkvKgorCSAqIFNhdmUgc3NjcmF0Y2ggZm9yIHJlc3RvcmF0aW9uIHNpbmNlIHdlIG1pZ2h0IGhh dmUgaW50ZXJydXB0ZWQgdGhlCisJICoga2VybmVsIGluIGVhcmx5IGV4Y2VwdGlvbiBwYXRoIGFu ZCB0aHVzLCB3ZSBkb24ndCBrbm93IHRoZSBjb250ZW50IG9mCisJICogc3NjcmF0Y2guCisJICov CisJY3NyciBzNCwgQ1NSX1NTQ1JBVENICisJLyogSW4ta2VybmVsIHNjcmF0Y2ggaXMgMCAqLwor CWNzcncgQ1NSX1NDUkFUQ0gsIHgwCisKKwltb3ZlIGEwLCBhNworCisJY2FsbCBkb19zc2UKKwor CWNzcncgQ1NSX1NTQ1JBVENILCBzNAorCisJUkVHX0wgYTAsIFBUX0VQQyhzcCkKKwlSRUdfTCBh MSwgUFRfU1RBVFVTKHNwKQorCVJFR19MIGEyLCBQVF9CQURBRERSKHNwKQorCVJFR19MIGEzLCBQ VF9DQVVTRShzcCkKKwljc3J3IENTUl9FUEMsIGEwCisJY3NydyBDU1JfU1NUQVRVUywgYTEKKwlj c3J3IENTUl9TVFZBTCwgYTIKKwljc3J3IENTUl9TQ0FVU0UsIGEzCisKKwlSRUdfTCByYSwgUFRf UkEoc3ApCisJUkVHX0wgczAsIFBUX1MwKHNwKQorCVJFR19MIHMxLCBQVF9TMShzcCkKKwlSRUdf TCBzMiwgUFRfUzIoc3ApCisJUkVHX0wgczMsIFBUX1MzKHNwKQorCVJFR19MIHM0LCBQVF9TNChz cCkKKwlSRUdfTCBzNSwgUFRfUzUoc3ApCisJUkVHX0wgczYsIFBUX1M2KHNwKQorCVJFR19MIHM3 LCBQVF9TNyhzcCkKKwlSRUdfTCBzOCwgUFRfUzgoc3ApCisJUkVHX0wgczksIFBUX1M5KHNwKQor CVJFR19MIHMxMCwgUFRfUzEwKHNwKQorCVJFR19MIHMxMSwgUFRfUzExKHNwKQorCVJFR19MIHRw LCBQVF9UUChzcCkKKwlSRUdfTCB0MCwgUFRfVDAoc3ApCisJUkVHX0wgdDEsIFBUX1QxKHNwKQor CVJFR19MIHQyLCBQVF9UMihzcCkKKwlSRUdfTCB0MywgUFRfVDMoc3ApCisJUkVHX0wgdDQsIFBU X1Q0KHNwKQorCVJFR19MIHQ1LCBQVF9UNShzcCkKKwlSRUdfTCB0NiwgUFRfVDYoc3ApCisJUkVH X0wgZ3AsIFBUX0dQKHNwKQorCVJFR19MIGEwLCBQVF9BMChzcCkKKwlSRUdfTCBhMSwgUFRfQTEo c3ApCisJUkVHX0wgYTIsIFBUX0EyKHNwKQorCVJFR19MIGEzLCBQVF9BMyhzcCkKKwlSRUdfTCBh NCwgUFRfQTQoc3ApCisJUkVHX0wgYTUsIFBUX0E1KHNwKQorCisJUkVHX0wgc3AsIFBUX1NQKHNw KQorCisJbGkgYTcsIFNCSV9FWFRfU1NFCisJbGkgYTYsIFNCSV9TU0VfRVZFTlRfQ09NUExFVEUK KwllY2FsbAorCitTWU1fQ09ERV9FTkQoaGFuZGxlX3NzZSkKKworc3NlX2hhcnRfaWRfcGFuaWNf c3RyaW5nOgorICAgIC5hc2NpaSAiVW5hYmxlIHRvIG1hdGNoIGhhcnRfaWQgd2l0aCBjcHVcMCIK LS0gCjIuNDUuMgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCmxpbnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQu b3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcmlz Y3YK