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 X-Spam-Level: X-Spam-Status: No, score=-10.1 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4507DC433DF for ; Sat, 4 Jul 2020 03:35:06 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 109B9208C7 for ; Sat, 4 Jul 2020 03:35:06 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1593833706; bh=jpjU/u6i/jThSccwzq+d3pvPE1Wlai62r8dutr484YI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:List-ID:From; b=soK8TESdscESMfGU4k6iMmJXRlLPzb9FtoPj2tFcb4RMQfwmWwCa7c9HPXeet7a+F H3PdiS0aKm/V7K/0PdTjnYAdJub/yrsx3GzaOs2tJtKItGFW8RgUQlK4bKI5hpePkA CEcEEiO6D1j2iIBYaMO6mDaj9fpnbitKUJ69nwK4= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727109AbgGDDfF (ORCPT ); Fri, 3 Jul 2020 23:35:05 -0400 Received: from mail.kernel.org ([198.145.29.99]:48468 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726501AbgGDDfF (ORCPT ); Fri, 3 Jul 2020 23:35:05 -0400 Received: from localhost.localdomain (89.208.247.74.16clouds.com [89.208.247.74]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id E2B4F20899; Sat, 4 Jul 2020 03:35:00 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1593833704; bh=jpjU/u6i/jThSccwzq+d3pvPE1Wlai62r8dutr484YI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=V/1umE4jrtnrOZ3OYN6GPuqJ76Dop2nKuBqN+fQ+rOZFqjNNZynKYcAOz6+9mMSmU CKYg8EyzdIdPGMOJLVCOimZzbU7VCL1amEIJqNtW7AvL6iXqY1LOIBfS0LDM2DeTiy rKvoFzfKGQ/8T6bfeqe5WGzhZ3BBpDFBSr6U+UMI= From: guoren@kernel.org To: palmerdabbelt@google.com, paul.walmsley@sifive.com, anup@brainfault.org, greentime.hu@sifive.com, zong.li@sifive.com, me@packi.ch, bjorn.topel@gmail.com, atish.patra@wdc.com Cc: linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux-csky@vger.kernel.org, guoren@kernel.org, Guo Ren , Masami Hiramatsu Subject: [PATCH V1 4/5] riscv: Add kprobes supported Date: Sat, 4 Jul 2020 03:34:18 +0000 Message-Id: <1593833659-26224-5-git-send-email-guoren@kernel.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1593833659-26224-1-git-send-email-guoren@kernel.org> References: <1593833659-26224-1-git-send-email-guoren@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-csky-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-csky@vger.kernel.org From: Guo Ren This patch enables "kprobe & kretprobe" to work with ftrace interface. It utilized software breakpoint as single-step mechanism. Some instructions which can't be single-step executed must be simulated in kernel execution slot, such as: branch, jal, auipc, la ... Some instructions should be rejected for probing and we use a blacklist to filter, such as: ecall, ebreak, ... We use ebreak & c.ebreak to replace origin instruction and the kprobe handler prepares an executable memory slot for out-of-line execution with a copy of the original instruction being probed. In execution slot we add ebreak behind original instruction to simulate a single-setp mechanism. The patch is based on packi's work [1] and csky's work [2]. - The kprobes_trampoline.S is all from packi's patch - The single-step mechanism is new designed for riscv without hw single-step trap - The simulation codes are from csky - Frankly, all codes refer to other archs' implementation [1] https://lore.kernel.org/linux-riscv/20181113195804.22825-1-me@packi.ch/ [2] https://lore.kernel.org/linux-csky/20200403044150.20562-9-guoren@kernel.org/ Signed-off-by: Guo Ren Co-Developed-by: Patrick Stählin Cc: Patrick Stählin Cc: Masami Hiramatsu Cc: Palmer Dabbelt Cc: Björn Töpel --- arch/riscv/Kconfig | 2 + arch/riscv/include/asm/kprobes.h | 40 +++ arch/riscv/include/asm/probes.h | 24 ++ arch/riscv/kernel/Makefile | 1 + arch/riscv/kernel/probes/Makefile | 4 + arch/riscv/kernel/probes/decode-insn.c | 48 +++ arch/riscv/kernel/probes/decode-insn.h | 18 + arch/riscv/kernel/probes/kprobes.c | 471 ++++++++++++++++++++++++++ arch/riscv/kernel/probes/kprobes_trampoline.S | 93 +++++ arch/riscv/kernel/probes/simulate-insn.c | 85 +++++ arch/riscv/kernel/probes/simulate-insn.h | 47 +++ arch/riscv/kernel/traps.c | 9 + arch/riscv/mm/fault.c | 4 + 13 files changed, 846 insertions(+) create mode 100644 arch/riscv/include/asm/probes.h create mode 100644 arch/riscv/kernel/probes/Makefile create mode 100644 arch/riscv/kernel/probes/decode-insn.c create mode 100644 arch/riscv/kernel/probes/decode-insn.h create mode 100644 arch/riscv/kernel/probes/kprobes.c create mode 100644 arch/riscv/kernel/probes/kprobes_trampoline.S create mode 100644 arch/riscv/kernel/probes/simulate-insn.c create mode 100644 arch/riscv/kernel/probes/simulate-insn.h diff --git a/arch/riscv/Kconfig b/arch/riscv/Kconfig index 58d6f66..a295f0b 100644 --- a/arch/riscv/Kconfig +++ b/arch/riscv/Kconfig @@ -57,6 +57,8 @@ config RISCV select HAVE_EBPF_JIT if MMU select HAVE_FUTEX_CMPXCHG if FUTEX select HAVE_GENERIC_VDSO if MMU && 64BIT + select HAVE_KPROBES + select HAVE_KRETPROBES select HAVE_PCI select HAVE_PERF_EVENTS select HAVE_PERF_REGS diff --git a/arch/riscv/include/asm/kprobes.h b/arch/riscv/include/asm/kprobes.h index 56a98ea3..4647d38 100644 --- a/arch/riscv/include/asm/kprobes.h +++ b/arch/riscv/include/asm/kprobes.h @@ -11,4 +11,44 @@ #include +#ifdef CONFIG_KPROBES +#include +#include +#include + +#define __ARCH_WANT_KPROBES_INSN_SLOT +#define MAX_INSN_SIZE 2 + +#define flush_insn_slot(p) do { } while (0) +#define kretprobe_blacklist_size 0 + +#include + +struct prev_kprobe { + struct kprobe *kp; + unsigned int status; +}; + +/* Single step context for kprobe */ +struct kprobe_step_ctx { + unsigned long ss_pending; + unsigned long match_addr; +}; + +/* per-cpu kprobe control block */ +struct kprobe_ctlblk { + unsigned int kprobe_status; + unsigned long saved_status; + struct prev_kprobe prev_kprobe; + struct kprobe_step_ctx ss_ctx; +}; + +void arch_remove_kprobe(struct kprobe *p); +int kprobe_fault_handler(struct pt_regs *regs, unsigned int trapnr); +bool kprobe_breakpoint_handler(struct pt_regs *regs); +bool kprobe_single_step_handler(struct pt_regs *regs); +void kretprobe_trampoline(void); +void __kprobes *trampoline_probe_handler(struct pt_regs *regs); + +#endif /* CONFIG_KPROBES */ #endif /* _ASM_RISCV_KPROBES_H */ diff --git a/arch/riscv/include/asm/probes.h b/arch/riscv/include/asm/probes.h new file mode 100644 index 00000000..a787e6d --- /dev/null +++ b/arch/riscv/include/asm/probes.h @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef _ASM_RISCV_PROBES_H +#define _ASM_RISCV_PROBES_H + +typedef u32 probe_opcode_t; +typedef bool (probes_handler_t) (u32 opcode, unsigned long addr, struct pt_regs *); + +/* architecture specific copy of original instruction */ +struct arch_probe_insn { + probe_opcode_t *insn; + probes_handler_t *handler; + /* restore address after simulation */ + unsigned long restore; +}; + +#ifdef CONFIG_KPROBES +typedef u32 kprobe_opcode_t; +struct arch_specific_insn { + struct arch_probe_insn api; +}; +#endif + +#endif /* _ASM_RISCV_PROBES_H */ diff --git a/arch/riscv/kernel/Makefile b/arch/riscv/kernel/Makefile index b355cf4..c3fff3e 100644 --- a/arch/riscv/kernel/Makefile +++ b/arch/riscv/kernel/Makefile @@ -29,6 +29,7 @@ obj-y += riscv_ksyms.o obj-y += stacktrace.o obj-y += cacheinfo.o obj-y += patch.o +obj-y += probes/ obj-$(CONFIG_MMU) += vdso.o vdso/ obj-$(CONFIG_RISCV_M_MODE) += clint.o traps_misaligned.o diff --git a/arch/riscv/kernel/probes/Makefile b/arch/riscv/kernel/probes/Makefile new file mode 100644 index 00000000..8a39507 --- /dev/null +++ b/arch/riscv/kernel/probes/Makefile @@ -0,0 +1,4 @@ +# SPDX-License-Identifier: GPL-2.0 +obj-$(CONFIG_KPROBES) += kprobes.o decode-insn.o simulate-insn.o +obj-$(CONFIG_KPROBES) += kprobes_trampoline.o +CFLAGS_REMOVE_simulate-insn.o = $(CC_FLAGS_FTRACE) diff --git a/arch/riscv/kernel/probes/decode-insn.c b/arch/riscv/kernel/probes/decode-insn.c new file mode 100644 index 00000000..0876c30 --- /dev/null +++ b/arch/riscv/kernel/probes/decode-insn.c @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: GPL-2.0+ + +#include +#include +#include +#include +#include + +#include "decode-insn.h" +#include "simulate-insn.h" + +/* Return: + * INSN_REJECTED If instruction is one not allowed to kprobe, + * INSN_GOOD_NO_SLOT If instruction is supported but doesn't use its slot. + */ +enum probe_insn __kprobes +riscv_probe_decode_insn(probe_opcode_t *addr, struct arch_probe_insn *api) +{ + probe_opcode_t insn = le32_to_cpu(*addr); + + /* + * Reject instructions list: + */ + RISCV_INSN_REJECTED(system, insn); + RISCV_INSN_REJECTED(fence, insn); + + /* + * Simulate instructions list: + * TODO: the REJECTED ones below need to be implemented + */ +#ifdef CONFIG_RISCV_ISA_C + RISCV_INSN_REJECTED(c_j, insn); + RISCV_INSN_REJECTED(c_jr, insn); + RISCV_INSN_REJECTED(c_jal, insn); + RISCV_INSN_REJECTED(c_jalr, insn); + RISCV_INSN_REJECTED(c_beqz, insn); + RISCV_INSN_REJECTED(c_bnez, insn); + RISCV_INSN_REJECTED(c_ebreak, insn); +#endif + + RISCV_INSN_REJECTED(auipc, insn); + RISCV_INSN_REJECTED(branch, insn); + + RISCV_INSN_SET_SIMULATE(jal, insn); + RISCV_INSN_SET_SIMULATE(jalr, insn); + + return INSN_GOOD; +} diff --git a/arch/riscv/kernel/probes/decode-insn.h b/arch/riscv/kernel/probes/decode-insn.h new file mode 100644 index 00000000..42269a7 --- /dev/null +++ b/arch/riscv/kernel/probes/decode-insn.h @@ -0,0 +1,18 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ + +#ifndef _RISCV_KERNEL_KPROBES_DECODE_INSN_H +#define _RISCV_KERNEL_KPROBES_DECODE_INSN_H + +#include +#include + +enum probe_insn { + INSN_REJECTED, + INSN_GOOD_NO_SLOT, + INSN_GOOD, +}; + +enum probe_insn __kprobes +riscv_probe_decode_insn(probe_opcode_t *addr, struct arch_probe_insn *asi); + +#endif /* _RISCV_KERNEL_KPROBES_DECODE_INSN_H */ diff --git a/arch/riscv/kernel/probes/kprobes.c b/arch/riscv/kernel/probes/kprobes.c new file mode 100644 index 00000000..31b6196 --- /dev/null +++ b/arch/riscv/kernel/probes/kprobes.c @@ -0,0 +1,471 @@ +// SPDX-License-Identifier: GPL-2.0+ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "decode-insn.h" + +DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL; +DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk); + +static void __kprobes +post_kprobe_handler(struct kprobe_ctlblk *, struct pt_regs *); + +static void __kprobes arch_prepare_ss_slot(struct kprobe *p) +{ + unsigned long offset = GET_INSN_LENGTH(p->opcode); + + p->ainsn.api.restore = (unsigned long)p->addr + offset; + + patch_text(p->ainsn.api.insn, p->opcode); + patch_text((void *)((unsigned long)(p->ainsn.api.insn) + offset), + __BUG_INSN_32); +} + +static void __kprobes arch_prepare_simulate(struct kprobe *p) +{ + p->ainsn.api.restore = 0; +} + +static void __kprobes arch_simulate_insn(struct kprobe *p, struct pt_regs *regs) +{ + struct kprobe_ctlblk *kcb = get_kprobe_ctlblk(); + + if (p->ainsn.api.handler) + p->ainsn.api.handler((u32)p->opcode, + (unsigned long)p->addr, regs); + + post_kprobe_handler(kcb, regs); +} + +int __kprobes arch_prepare_kprobe(struct kprobe *p) +{ + unsigned long probe_addr = (unsigned long)p->addr; + + if (probe_addr & 0x1) { + pr_warn("Address not aligned.\n"); + + return -EINVAL; + } + + /* copy instruction */ + p->opcode = le32_to_cpu(*p->addr); + + /* decode instruction */ + switch (riscv_probe_decode_insn(p->addr, &p->ainsn.api)) { + case INSN_REJECTED: /* insn not supported */ + return -EINVAL; + + case INSN_GOOD_NO_SLOT: /* insn need simulation */ + p->ainsn.api.insn = NULL; + break; + + case INSN_GOOD: /* instruction uses slot */ + p->ainsn.api.insn = get_insn_slot(); + if (!p->ainsn.api.insn) + return -ENOMEM; + break; + } + + /* prepare the instruction */ + if (p->ainsn.api.insn) + arch_prepare_ss_slot(p); + else + arch_prepare_simulate(p); + + return 0; +} + +/* install breakpoint in text */ +void __kprobes arch_arm_kprobe(struct kprobe *p) +{ + if ((p->opcode & __INSN_LENGTH_MASK) == __INSN_LENGTH_32) + patch_text(p->addr, __BUG_INSN_32); + else + patch_text(p->addr, __BUG_INSN_16); +} + +/* remove breakpoint from text */ +void __kprobes arch_disarm_kprobe(struct kprobe *p) +{ + patch_text(p->addr, p->opcode); +} + +void __kprobes arch_remove_kprobe(struct kprobe *p) +{ +} + +static void __kprobes save_previous_kprobe(struct kprobe_ctlblk *kcb) +{ + kcb->prev_kprobe.kp = kprobe_running(); + kcb->prev_kprobe.status = kcb->kprobe_status; +} + +static void __kprobes restore_previous_kprobe(struct kprobe_ctlblk *kcb) +{ + __this_cpu_write(current_kprobe, kcb->prev_kprobe.kp); + kcb->kprobe_status = kcb->prev_kprobe.status; +} + +static void __kprobes set_current_kprobe(struct kprobe *p) +{ + __this_cpu_write(current_kprobe, p); +} + +/* + * Interrupts need to be disabled before single-step mode is set, and not + * reenabled until after single-step mode ends. + * Without disabling interrupt on local CPU, there is a chance of + * interrupt occurrence in the period of exception return and start of + * out-of-line single-step, that result in wrongly single stepping + * into the interrupt handler. + */ +static void __kprobes kprobes_save_local_irqflag(struct kprobe_ctlblk *kcb, + struct pt_regs *regs) +{ + kcb->saved_status = regs->status; + regs->status &= ~SR_SPIE; +} + +static void __kprobes kprobes_restore_local_irqflag(struct kprobe_ctlblk *kcb, + struct pt_regs *regs) +{ + regs->status = kcb->saved_status; +} + +static void __kprobes +set_ss_context(struct kprobe_ctlblk *kcb, unsigned long addr, struct kprobe *p) +{ + unsigned long offset = GET_INSN_LENGTH(p->opcode); + + kcb->ss_ctx.ss_pending = true; + kcb->ss_ctx.match_addr = addr + offset; +} + +static void __kprobes clear_ss_context(struct kprobe_ctlblk *kcb) +{ + kcb->ss_ctx.ss_pending = false; + kcb->ss_ctx.match_addr = 0; +} + +static void __kprobes setup_singlestep(struct kprobe *p, + struct pt_regs *regs, + struct kprobe_ctlblk *kcb, int reenter) +{ + unsigned long slot; + + if (reenter) { + save_previous_kprobe(kcb); + set_current_kprobe(p); + kcb->kprobe_status = KPROBE_REENTER; + } else { + kcb->kprobe_status = KPROBE_HIT_SS; + } + + if (p->ainsn.api.insn) { + /* prepare for single stepping */ + slot = (unsigned long)p->ainsn.api.insn; + + set_ss_context(kcb, slot, p); /* mark pending ss */ + + /* IRQs and single stepping do not mix well. */ + kprobes_save_local_irqflag(kcb, regs); + + instruction_pointer_set(regs, slot); + } else { + /* insn simulation */ + arch_simulate_insn(p, regs); + } +} + +static int __kprobes reenter_kprobe(struct kprobe *p, + struct pt_regs *regs, + struct kprobe_ctlblk *kcb) +{ + switch (kcb->kprobe_status) { + case KPROBE_HIT_SSDONE: + case KPROBE_HIT_ACTIVE: + kprobes_inc_nmissed_count(p); + setup_singlestep(p, regs, kcb, 1); + break; + case KPROBE_HIT_SS: + case KPROBE_REENTER: + pr_warn("Unrecoverable kprobe detected.\n"); + dump_kprobe(p); + BUG(); + break; + default: + WARN_ON(1); + return 0; + } + + return 1; +} + +static void __kprobes +post_kprobe_handler(struct kprobe_ctlblk *kcb, struct pt_regs *regs) +{ + struct kprobe *cur = kprobe_running(); + + if (!cur) + return; + + /* return addr restore if non-branching insn */ + if (cur->ainsn.api.restore != 0) + regs->epc = cur->ainsn.api.restore; + + /* restore back original saved kprobe variables and continue */ + if (kcb->kprobe_status == KPROBE_REENTER) { + restore_previous_kprobe(kcb); + return; + } + + /* call post handler */ + kcb->kprobe_status = KPROBE_HIT_SSDONE; + if (cur->post_handler) { + /* post_handler can hit breakpoint and single step + * again, so we enable D-flag for recursive exception. + */ + cur->post_handler(cur, regs, 0); + } + + reset_current_kprobe(); +} + +int __kprobes kprobe_fault_handler(struct pt_regs *regs, unsigned int trapnr) +{ + struct kprobe *cur = kprobe_running(); + struct kprobe_ctlblk *kcb = get_kprobe_ctlblk(); + + switch (kcb->kprobe_status) { + case KPROBE_HIT_SS: + case KPROBE_REENTER: + /* + * We are here because the instruction being single + * stepped caused a page fault. We reset the current + * kprobe and the ip points back to the probe address + * and allow the page fault handler to continue as a + * normal page fault. + */ + regs->epc = (unsigned long) cur->addr; + if (!instruction_pointer(regs)) + BUG(); + + if (kcb->kprobe_status == KPROBE_REENTER) + restore_previous_kprobe(kcb); + else + reset_current_kprobe(); + + break; + case KPROBE_HIT_ACTIVE: + case KPROBE_HIT_SSDONE: + /* + * We increment the nmissed count for accounting, + * we can also use npre/npostfault count for accounting + * these specific fault cases. + */ + kprobes_inc_nmissed_count(cur); + + /* + * We come here because instructions in the pre/post + * handler caused the page_fault, this could happen + * if handler tries to access user space by + * copy_from_user(), get_user() etc. Let the + * user-specified handler try to fix it first. + */ + if (cur->fault_handler && cur->fault_handler(cur, regs, trapnr)) + return 1; + + /* + * In case the user-specified fault handler returned + * zero, try to fix up. + */ + if (fixup_exception(regs)) + return 1; + } + return 0; +} + +bool __kprobes +kprobe_breakpoint_handler(struct pt_regs *regs) +{ + struct kprobe *p, *cur_kprobe; + struct kprobe_ctlblk *kcb; + unsigned long addr = instruction_pointer(regs); + + kcb = get_kprobe_ctlblk(); + cur_kprobe = kprobe_running(); + + p = get_kprobe((kprobe_opcode_t *) addr); + + if (p) { + if (cur_kprobe) { + if (reenter_kprobe(p, regs, kcb)) + return true; + } else { + /* Probe hit */ + set_current_kprobe(p); + kcb->kprobe_status = KPROBE_HIT_ACTIVE; + + /* + * If we have no pre-handler or it returned 0, we + * continue with normal processing. If we have a + * pre-handler and it returned non-zero, it will + * modify the execution path and no need to single + * stepping. Let's just reset current kprobe and exit. + * + * pre_handler can hit a breakpoint and can step thru + * before return. + */ + if (!p->pre_handler || !p->pre_handler(p, regs)) + setup_singlestep(p, regs, kcb, 0); + else + reset_current_kprobe(); + } + return true; + } + + /* + * The breakpoint instruction was removed right + * after we hit it. Another cpu has removed + * either a probepoint or a debugger breakpoint + * at this address. In either case, no further + * handling of this interrupt is appropriate. + * Return back to original instruction, and continue. + */ + return false; +} + +bool __kprobes +kprobe_single_step_handler(struct pt_regs *regs) +{ + struct kprobe_ctlblk *kcb = get_kprobe_ctlblk(); + + if ((kcb->ss_ctx.ss_pending) + && (kcb->ss_ctx.match_addr == instruction_pointer(regs))) { + clear_ss_context(kcb); /* clear pending ss */ + + kprobes_restore_local_irqflag(kcb, regs); + + post_kprobe_handler(kcb, regs); + return true; + } + return false; +} + +/* + * Provide a blacklist of symbols identifying ranges which cannot be kprobed. + * This blacklist is exposed to userspace via debugfs (kprobes/blacklist). + */ +int __init arch_populate_kprobe_blacklist(void) +{ + int ret; + + ret = kprobe_add_area_blacklist((unsigned long)__irqentry_text_start, + (unsigned long)__irqentry_text_end); + return ret; +} + +void __kprobes __used *trampoline_probe_handler(struct pt_regs *regs) +{ + struct kretprobe_instance *ri = NULL; + struct hlist_head *head, empty_rp; + struct hlist_node *tmp; + unsigned long flags, orig_ret_address = 0; + unsigned long trampoline_address = + (unsigned long)&kretprobe_trampoline; + kprobe_opcode_t *correct_ret_addr = NULL; + + INIT_HLIST_HEAD(&empty_rp); + kretprobe_hash_lock(current, &head, &flags); + + /* + * It is possible to have multiple instances associated with a given + * task either because multiple functions in the call path have + * return probes installed on them, and/or more than one + * return probe was registered for a target function. + * + * We can handle this because: + * - instances are always pushed into the head of the list + * - when multiple return probes are registered for the same + * function, the (chronologically) first instance's ret_addr + * will be the real return address, and all the rest will + * point to kretprobe_trampoline. + */ + hlist_for_each_entry_safe(ri, tmp, head, hlist) { + if (ri->task != current) + /* another task is sharing our hash bucket */ + continue; + + orig_ret_address = (unsigned long)ri->ret_addr; + + if (orig_ret_address != trampoline_address) + /* + * This is the real return address. Any other + * instances associated with this task are for + * other calls deeper on the call stack + */ + break; + } + + kretprobe_assert(ri, orig_ret_address, trampoline_address); + + correct_ret_addr = ri->ret_addr; + hlist_for_each_entry_safe(ri, tmp, head, hlist) { + if (ri->task != current) + /* another task is sharing our hash bucket */ + continue; + + orig_ret_address = (unsigned long)ri->ret_addr; + if (ri->rp && ri->rp->handler) { + __this_cpu_write(current_kprobe, &ri->rp->kp); + get_kprobe_ctlblk()->kprobe_status = KPROBE_HIT_ACTIVE; + ri->ret_addr = correct_ret_addr; + ri->rp->handler(ri, regs); + __this_cpu_write(current_kprobe, NULL); + } + + recycle_rp_inst(ri, &empty_rp); + + if (orig_ret_address != trampoline_address) + /* + * This is the real return address. Any other + * instances associated with this task are for + * other calls deeper on the call stack + */ + break; + } + + kretprobe_hash_unlock(current, &flags); + + hlist_for_each_entry_safe(ri, tmp, &empty_rp, hlist) { + hlist_del(&ri->hlist); + kfree(ri); + } + return (void *)orig_ret_address; +} + +void __kprobes arch_prepare_kretprobe(struct kretprobe_instance *ri, + struct pt_regs *regs) +{ + ri->ret_addr = (kprobe_opcode_t *)regs->ra; + regs->ra = (unsigned long) &kretprobe_trampoline; +} + +int __kprobes arch_trampoline_kprobe(struct kprobe *p) +{ + return 0; +} + +int __init arch_init_kprobes(void) +{ + return 0; +} diff --git a/arch/riscv/kernel/probes/kprobes_trampoline.S b/arch/riscv/kernel/probes/kprobes_trampoline.S new file mode 100644 index 00000000..6e85d02 --- /dev/null +++ b/arch/riscv/kernel/probes/kprobes_trampoline.S @@ -0,0 +1,93 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Author: Patrick Stählin + */ +#include + +#include +#include + + .text + .altmacro + + .macro save_all_base_regs + REG_S x1, PT_RA(sp) + REG_S x3, PT_GP(sp) + REG_S x4, PT_TP(sp) + REG_S x5, PT_T0(sp) + REG_S x6, PT_T1(sp) + REG_S x7, PT_T2(sp) + REG_S x8, PT_S0(sp) + REG_S x9, PT_S1(sp) + REG_S x10, PT_A0(sp) + REG_S x11, PT_A1(sp) + REG_S x12, PT_A2(sp) + REG_S x13, PT_A3(sp) + REG_S x14, PT_A4(sp) + REG_S x15, PT_A5(sp) + REG_S x16, PT_A6(sp) + REG_S x17, PT_A7(sp) + REG_S x18, PT_S2(sp) + REG_S x19, PT_S3(sp) + REG_S x20, PT_S4(sp) + REG_S x21, PT_S5(sp) + REG_S x22, PT_S6(sp) + REG_S x23, PT_S7(sp) + REG_S x24, PT_S8(sp) + REG_S x25, PT_S9(sp) + REG_S x26, PT_S10(sp) + REG_S x27, PT_S11(sp) + REG_S x28, PT_T3(sp) + REG_S x29, PT_T4(sp) + REG_S x30, PT_T5(sp) + REG_S x31, PT_T6(sp) + .endm + + .macro restore_all_base_regs + REG_L x3, PT_GP(sp) + REG_L x4, PT_TP(sp) + REG_L x5, PT_T0(sp) + REG_L x6, PT_T1(sp) + REG_L x7, PT_T2(sp) + REG_L x8, PT_S0(sp) + REG_L x9, PT_S1(sp) + REG_L x10, PT_A0(sp) + REG_L x11, PT_A1(sp) + REG_L x12, PT_A2(sp) + REG_L x13, PT_A3(sp) + REG_L x14, PT_A4(sp) + REG_L x15, PT_A5(sp) + REG_L x16, PT_A6(sp) + REG_L x17, PT_A7(sp) + REG_L x18, PT_S2(sp) + REG_L x19, PT_S3(sp) + REG_L x20, PT_S4(sp) + REG_L x21, PT_S5(sp) + REG_L x22, PT_S6(sp) + REG_L x23, PT_S7(sp) + REG_L x24, PT_S8(sp) + REG_L x25, PT_S9(sp) + REG_L x26, PT_S10(sp) + REG_L x27, PT_S11(sp) + REG_L x28, PT_T3(sp) + REG_L x29, PT_T4(sp) + REG_L x30, PT_T5(sp) + REG_L x31, PT_T6(sp) + .endm + +ENTRY(kretprobe_trampoline) + addi sp, sp, -(PT_SIZE_ON_STACK) + save_all_base_regs + + move a0, sp /* pt_regs */ + + call trampoline_probe_handler + + /* use the result as the return-address */ + move ra, a0 + + restore_all_base_regs + addi sp, sp, PT_SIZE_ON_STACK + + ret +ENDPROC(kretprobe_trampoline) diff --git a/arch/riscv/kernel/probes/simulate-insn.c b/arch/riscv/kernel/probes/simulate-insn.c new file mode 100644 index 00000000..2519ce2 --- /dev/null +++ b/arch/riscv/kernel/probes/simulate-insn.c @@ -0,0 +1,85 @@ +// SPDX-License-Identifier: GPL-2.0+ + +#include +#include +#include + +#include "decode-insn.h" +#include "simulate-insn.h" + +static inline bool rv_insn_reg_get_val(struct pt_regs *regs, u32 index, + unsigned long *ptr) +{ + if (index == 0) + *ptr = 0; + else if (index <= 31) + *ptr = *((unsigned long *)regs + index); + else + return false; + + return true; +} + +static inline bool rv_insn_reg_set_val(struct pt_regs *regs, u32 index, + unsigned long val) +{ + if (index == 0) + return false; + else if (index <= 31) + *((unsigned long *)regs + index) = val; + else + return false; + + return true; +} + +bool __kprobes simulate_jal(u32 opcode, unsigned long addr, struct pt_regs *regs) +{ + /* + * 31 30 21 20 19 12 11 7 6 0 + * imm [20] | imm[10:1] | imm[11] | imm[19:12] | rd | opcode + * 1 10 1 8 5 JAL/J + */ + bool ret; + u32 imm; + u32 index = (opcode >> 7) & 0x1f; + + ret = rv_insn_reg_set_val(regs, index, addr + 4); + if (!ret) + return ret; + + imm = ((opcode >> 21) & 0x3ff) << 1; + imm |= ((opcode >> 20) & 0x1) << 11; + imm |= ((opcode >> 12) & 0xff) << 12; + imm |= ((opcode >> 31) & 0x1) << 20; + + instruction_pointer_set(regs, addr + sign_extend32((imm), 20)); + + return ret; +} + +bool __kprobes simulate_jalr(u32 opcode, unsigned long addr, struct pt_regs *regs) +{ + /* + * 31 20 19 15 14 12 11 7 6 0 + * offset[11:0] | rs1 | 010 | rd | opcode + * 12 5 3 5 JALR/JR + */ + bool ret; + unsigned long base_addr; + u32 imm = (opcode >> 20) & 0xfff; + u32 rd_index = (opcode >> 7) & 0x1f; + u32 rs1_index = (opcode >> 15) & 0x1f; + + ret = rv_insn_reg_set_val(regs, rd_index, addr + 4); + if (!ret) + return ret; + + ret = rv_insn_reg_get_val(regs, rs1_index, &base_addr); + if (!ret) + return ret; + + instruction_pointer_set(regs, (base_addr + sign_extend32((imm), 11))&~1); + + return ret; +} diff --git a/arch/riscv/kernel/probes/simulate-insn.h b/arch/riscv/kernel/probes/simulate-insn.h new file mode 100644 index 00000000..a62d784 --- /dev/null +++ b/arch/riscv/kernel/probes/simulate-insn.h @@ -0,0 +1,47 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ + +#ifndef _RISCV_KERNEL_PROBES_SIMULATE_INSN_H +#define _RISCV_KERNEL_PROBES_SIMULATE_INSN_H + +#define __RISCV_INSN_FUNCS(name, mask, val) \ +static __always_inline bool riscv_insn_is_##name(probe_opcode_t code) \ +{ \ + BUILD_BUG_ON(~(mask) & (val)); \ + return (code & (mask)) == (val); \ +} \ +bool simulate_##name(u32 opcode, unsigned long addr, \ + struct pt_regs *regs); + +#define RISCV_INSN_REJECTED(name, code) \ + do { \ + if (riscv_insn_is_##name(code)) { \ + return INSN_REJECTED; \ + } \ + } while (0) + +__RISCV_INSN_FUNCS(system, 0x7f, 0x73) +__RISCV_INSN_FUNCS(fence, 0x7f, 0x0f) + +#define RISCV_INSN_SET_SIMULATE(name, code) \ + do { \ + if (riscv_insn_is_##name(code)) { \ + api->handler = simulate_##name; \ + return INSN_GOOD_NO_SLOT; \ + } \ + } while (0) + +__RISCV_INSN_FUNCS(c_j, 0xe003, 0xa001) +__RISCV_INSN_FUNCS(c_jr, 0xf007, 0x8002) +__RISCV_INSN_FUNCS(c_jal, 0xe003, 0x2001) +__RISCV_INSN_FUNCS(c_jalr, 0xf007, 0x9002) +__RISCV_INSN_FUNCS(c_beqz, 0xe003, 0xc001) +__RISCV_INSN_FUNCS(c_bnez, 0xe003, 0xe001) +__RISCV_INSN_FUNCS(c_ebreak, 0xffff, 0x9002) + +__RISCV_INSN_FUNCS(auipc, 0x7f, 0x17) +__RISCV_INSN_FUNCS(branch, 0x7f, 0x63) + +__RISCV_INSN_FUNCS(jal, 0x7f, 0x6f) +__RISCV_INSN_FUNCS(jalr, 0x707f, 0x67) + +#endif /* _RISCV_KERNEL_PROBES_SIMULATE_INSN_H */ diff --git a/arch/riscv/kernel/traps.c b/arch/riscv/kernel/traps.c index ecec177..ac2e786 100644 --- a/arch/riscv/kernel/traps.c +++ b/arch/riscv/kernel/traps.c @@ -12,6 +12,7 @@ #include #include #include +#include #include #include #include @@ -145,6 +146,14 @@ static inline unsigned long get_break_insn_length(unsigned long pc) asmlinkage __visible void do_trap_break(struct pt_regs *regs) { +#ifdef CONFIG_KPROBES + if (kprobe_single_step_handler(regs)) + return; + + if (kprobe_breakpoint_handler(regs)) + return; +#endif + if (user_mode(regs)) force_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *)regs->epc); #ifdef CONFIG_KGDB diff --git a/arch/riscv/mm/fault.c b/arch/riscv/mm/fault.c index ae7b7fe..da0c08c 100644 --- a/arch/riscv/mm/fault.c +++ b/arch/riscv/mm/fault.c @@ -13,6 +13,7 @@ #include #include #include +#include #include #include @@ -40,6 +41,9 @@ asmlinkage void do_page_fault(struct pt_regs *regs) tsk = current; mm = tsk->mm; + if (kprobe_page_fault(regs, cause)) + return; + /* * Fault-in kernel-space virtual memory on-demand. * The 'reference' page table is init_mm.pgd. -- 2.7.4 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 X-Spam-Level: X-Spam-Status: No, score=-10.0 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE, SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7519DC433E0 for ; Sat, 4 Jul 2020 03:35:17 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 29DDD2084C for ; Sat, 4 Jul 2020 03:35:17 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="A+6MohHU"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=kernel.org header.i=@kernel.org header.b="V/1umE4j" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 29DDD2084C Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-Id:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=89cp/fDx/LWTK8I2pKUWJDiSXZZ1xUzfPqFIKIKmCbE=; b=A+6MohHU+gnpc4Cln/h07EHwb XKajBFEXu9N7PvL6EXeRXuaRlAfEG61rcvlyyzkEW4DEDYOupzd0DsBUGrrYiyH0WjmA/RpVhpCbR WrtDMlQJ8Yd4emLNH1S44yPzh7KjTbiHby+WEF2ivuDwntvEimZ69tzCn9zREUgJJ16boMHn35xSU AR07OmP2o9JpFdIgElOO5RmC4kr759gxJBHBJnO0aOdcYuEkkdqVT/kED5/ufkeA0s6wN3SVfUSM6 VlOmv9tFvfwKD+LwxtgRb6mB5wdAJZd2o+t72jB7pwf6eCLii6brsZLxTcwQ5bAufP9zoQSFo5n03 55iOgemqw==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1jrYxI-0007ug-Dj; Sat, 04 Jul 2020 03:35:08 +0000 Received: from mail.kernel.org ([198.145.29.99]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jrYxE-0007tc-WE for linux-riscv@lists.infradead.org; Sat, 04 Jul 2020 03:35:06 +0000 Received: from localhost.localdomain (89.208.247.74.16clouds.com [89.208.247.74]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id E2B4F20899; Sat, 4 Jul 2020 03:35:00 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1593833704; bh=jpjU/u6i/jThSccwzq+d3pvPE1Wlai62r8dutr484YI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=V/1umE4jrtnrOZ3OYN6GPuqJ76Dop2nKuBqN+fQ+rOZFqjNNZynKYcAOz6+9mMSmU CKYg8EyzdIdPGMOJLVCOimZzbU7VCL1amEIJqNtW7AvL6iXqY1LOIBfS0LDM2DeTiy rKvoFzfKGQ/8T6bfeqe5WGzhZ3BBpDFBSr6U+UMI= From: guoren@kernel.org To: palmerdabbelt@google.com, paul.walmsley@sifive.com, anup@brainfault.org, greentime.hu@sifive.com, zong.li@sifive.com, me@packi.ch, bjorn.topel@gmail.com, atish.patra@wdc.com Subject: [PATCH V1 4/5] riscv: Add kprobes supported Date: Sat, 4 Jul 2020 03:34:18 +0000 Message-Id: <1593833659-26224-5-git-send-email-guoren@kernel.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1593833659-26224-1-git-send-email-guoren@kernel.org> References: <1593833659-26224-1-git-send-email-guoren@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200703_233505_217222_B12BA4DB X-CRM114-Status: GOOD ( 28.70 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Guo Ren , linux-kernel@vger.kernel.org, linux-csky@vger.kernel.org, guoren@kernel.org, Masami Hiramatsu , linux-riscv@lists.infradead.org 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 RnJvbTogR3VvIFJlbiA8Z3VvcmVuQGxpbnV4LmFsaWJhYmEuY29tPgoKVGhpcyBwYXRjaCBlbmFi bGVzICJrcHJvYmUgJiBrcmV0cHJvYmUiIHRvIHdvcmsgd2l0aCBmdHJhY2UKaW50ZXJmYWNlLiBJ dCB1dGlsaXplZCBzb2Z0d2FyZSBicmVha3BvaW50IGFzIHNpbmdsZS1zdGVwCm1lY2hhbmlzbS4K ClNvbWUgaW5zdHJ1Y3Rpb25zIHdoaWNoIGNhbid0IGJlIHNpbmdsZS1zdGVwIGV4ZWN1dGVkIG11 c3QgYmUKc2ltdWxhdGVkIGluIGtlcm5lbCBleGVjdXRpb24gc2xvdCwgc3VjaCBhczogYnJhbmNo LCBqYWwsIGF1aXBjLApsYSAuLi4KClNvbWUgaW5zdHJ1Y3Rpb25zIHNob3VsZCBiZSByZWplY3Rl ZCBmb3IgcHJvYmluZyBhbmQgd2UgdXNlIGEKYmxhY2tsaXN0IHRvIGZpbHRlciwgc3VjaCBhczog ZWNhbGwsIGVicmVhaywgLi4uCgpXZSB1c2UgZWJyZWFrICYgYy5lYnJlYWsgdG8gcmVwbGFjZSBv cmlnaW4gaW5zdHJ1Y3Rpb24gYW5kIHRoZQprcHJvYmUgaGFuZGxlciBwcmVwYXJlcyBhbiBleGVj dXRhYmxlIG1lbW9yeSBzbG90IGZvciBvdXQtb2YtbGluZQpleGVjdXRpb24gd2l0aCBhIGNvcHkg b2YgdGhlIG9yaWdpbmFsIGluc3RydWN0aW9uIGJlaW5nIHByb2JlZC4KSW4gZXhlY3V0aW9uIHNs b3Qgd2UgYWRkIGVicmVhayBiZWhpbmQgb3JpZ2luYWwgaW5zdHJ1Y3Rpb24gdG8Kc2ltdWxhdGUg YSBzaW5nbGUtc2V0cCBtZWNoYW5pc20uCgpUaGUgcGF0Y2ggaXMgYmFzZWQgb24gcGFja2kncyB3 b3JrIFsxXSBhbmQgY3NreSdzIHdvcmsgWzJdLgogLSBUaGUga3Byb2Jlc190cmFtcG9saW5lLlMg aXMgYWxsIGZyb20gcGFja2kncyBwYXRjaAogLSBUaGUgc2luZ2xlLXN0ZXAgbWVjaGFuaXNtIGlz IG5ldyBkZXNpZ25lZCBmb3IgcmlzY3Ygd2l0aG91dCBodwogICBzaW5nbGUtc3RlcCB0cmFwCiAt IFRoZSBzaW11bGF0aW9uIGNvZGVzIGFyZSBmcm9tIGNza3kKIC0gRnJhbmtseSwgYWxsIGNvZGVz IHJlZmVyIHRvIG90aGVyIGFyY2hzJyBpbXBsZW1lbnRhdGlvbgoKIFsxXSBodHRwczovL2xvcmUu a2VybmVsLm9yZy9saW51eC1yaXNjdi8yMDE4MTExMzE5NTgwNC4yMjgyNS0xLW1lQHBhY2tpLmNo LwogWzJdIGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL2xpbnV4LWNza3kvMjAyMDA0MDMwNDQxNTAu MjA1NjItOS1ndW9yZW5Aa2VybmVsLm9yZy8KClNpZ25lZC1vZmYtYnk6IEd1byBSZW4gPGd1b3Jl bkBsaW51eC5hbGliYWJhLmNvbT4KQ28tRGV2ZWxvcGVkLWJ5OiBQYXRyaWNrIFN0w6RobGluIDxt ZUBwYWNraS5jaD4KQ2M6IFBhdHJpY2sgU3TDpGhsaW4gPG1lQHBhY2tpLmNoPgpDYzogTWFzYW1p IEhpcmFtYXRzdSA8bWhpcmFtYXRAa2VybmVsLm9yZz4KQ2M6IFBhbG1lciBEYWJiZWx0IDxwYWxt ZXJkYWJiZWx0QGdvb2dsZS5jb20+CkNjOiBCasO2cm4gVMO2cGVsIDxiam9ybi50b3BlbEBnbWFp bC5jb20+Ci0tLQogYXJjaC9yaXNjdi9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICAgICAg IHwgICAyICsKIGFyY2gvcmlzY3YvaW5jbHVkZS9hc20va3Byb2Jlcy5oICAgICAgICAgICAgICB8 ICA0MCArKysKIGFyY2gvcmlzY3YvaW5jbHVkZS9hc20vcHJvYmVzLmggICAgICAgICAgICAgICB8 ICAyNCArKwogYXJjaC9yaXNjdi9rZXJuZWwvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgIHwg ICAxICsKIGFyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9NYWtlZmlsZSAgICAgICAgICAgICB8ICAg NCArCiBhcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvZGVjb2RlLWluc24uYyAgICAgICAgfCAgNDgg KysrCiBhcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvZGVjb2RlLWluc24uaCAgICAgICAgfCAgMTgg KwogYXJjaC9yaXNjdi9rZXJuZWwvcHJvYmVzL2twcm9iZXMuYyAgICAgICAgICAgIHwgNDcxICsr KysrKysrKysrKysrKysrKysrKysrKysrCiBhcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMva3Byb2Jl c190cmFtcG9saW5lLlMgfCAgOTMgKysrKysKIGFyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9zaW11 bGF0ZS1pbnNuLmMgICAgICB8ICA4NSArKysrKwogYXJjaC9yaXNjdi9rZXJuZWwvcHJvYmVzL3Np bXVsYXRlLWluc24uaCAgICAgIHwgIDQ3ICsrKwogYXJjaC9yaXNjdi9rZXJuZWwvdHJhcHMuYyAg ICAgICAgICAgICAgICAgICAgIHwgICA5ICsKIGFyY2gvcmlzY3YvbW0vZmF1bHQuYyAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgNCArCiAxMyBmaWxlcyBjaGFuZ2VkLCA4NDYgaW5zZXJ0aW9u cygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGFyY2gvcmlzY3YvaW5jbHVkZS9hc20vcHJvYmVzLmgK IGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvTWFrZWZpbGUKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvZGVjb2RlLWluc24uYwog Y3JlYXRlIG1vZGUgMTAwNjQ0IGFyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9kZWNvZGUtaW5zbi5o CiBjcmVhdGUgbW9kZSAxMDA2NDQgYXJjaC9yaXNjdi9rZXJuZWwvcHJvYmVzL2twcm9iZXMuYwog Y3JlYXRlIG1vZGUgMTAwNjQ0IGFyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9rcHJvYmVzX3RyYW1w b2xpbmUuUwogY3JlYXRlIG1vZGUgMTAwNjQ0IGFyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9zaW11 bGF0ZS1pbnNuLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMv c2ltdWxhdGUtaW5zbi5oCgpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9LY29uZmlnIGIvYXJjaC9y aXNjdi9LY29uZmlnCmluZGV4IDU4ZDZmNjYuLmEyOTVmMGIgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlz Y3YvS2NvbmZpZworKysgYi9hcmNoL3Jpc2N2L0tjb25maWcKQEAgLTU3LDYgKzU3LDggQEAgY29u ZmlnIFJJU0NWCiAJc2VsZWN0IEhBVkVfRUJQRl9KSVQgaWYgTU1VCiAJc2VsZWN0IEhBVkVfRlVU RVhfQ01QWENIRyBpZiBGVVRFWAogCXNlbGVjdCBIQVZFX0dFTkVSSUNfVkRTTyBpZiBNTVUgJiYg NjRCSVQKKwlzZWxlY3QgSEFWRV9LUFJPQkVTCisJc2VsZWN0IEhBVkVfS1JFVFBST0JFUwogCXNl bGVjdCBIQVZFX1BDSQogCXNlbGVjdCBIQVZFX1BFUkZfRVZFTlRTCiAJc2VsZWN0IEhBVkVfUEVS Rl9SRUdTCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL2twcm9iZXMuaCBiL2Fy Y2gvcmlzY3YvaW5jbHVkZS9hc20va3Byb2Jlcy5oCmluZGV4IDU2YTk4ZWEzLi40NjQ3ZDM4IDEw MDY0NAotLS0gYS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL2twcm9iZXMuaAorKysgYi9hcmNoL3Jp c2N2L2luY2x1ZGUvYXNtL2twcm9iZXMuaApAQCAtMTEsNCArMTEsNDQgQEAKIAogI2luY2x1ZGUg PGFzbS1nZW5lcmljL2twcm9iZXMuaD4KIAorI2lmZGVmIENPTkZJR19LUFJPQkVTCisjaW5jbHVk ZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9wdHJhY2UuaD4KKyNpbmNsdWRlIDxs aW51eC9wZXJjcHUuaD4KKworI2RlZmluZSBfX0FSQ0hfV0FOVF9LUFJPQkVTX0lOU05fU0xPVAor I2RlZmluZSBNQVhfSU5TTl9TSVpFCQkJMgorCisjZGVmaW5lIGZsdXNoX2luc25fc2xvdChwKQkJ ZG8geyB9IHdoaWxlICgwKQorI2RlZmluZSBrcmV0cHJvYmVfYmxhY2tsaXN0X3NpemUJMAorCisj aW5jbHVkZSA8YXNtL3Byb2Jlcy5oPgorCitzdHJ1Y3QgcHJldl9rcHJvYmUgeworCXN0cnVjdCBr cHJvYmUgKmtwOworCXVuc2lnbmVkIGludCBzdGF0dXM7Cit9OworCisvKiBTaW5nbGUgc3RlcCBj b250ZXh0IGZvciBrcHJvYmUgKi8KK3N0cnVjdCBrcHJvYmVfc3RlcF9jdHggeworCXVuc2lnbmVk IGxvbmcgc3NfcGVuZGluZzsKKwl1bnNpZ25lZCBsb25nIG1hdGNoX2FkZHI7Cit9OworCisvKiBw ZXItY3B1IGtwcm9iZSBjb250cm9sIGJsb2NrICovCitzdHJ1Y3Qga3Byb2JlX2N0bGJsayB7CisJ dW5zaWduZWQgaW50IGtwcm9iZV9zdGF0dXM7CisJdW5zaWduZWQgbG9uZyBzYXZlZF9zdGF0dXM7 CisJc3RydWN0IHByZXZfa3Byb2JlIHByZXZfa3Byb2JlOworCXN0cnVjdCBrcHJvYmVfc3RlcF9j dHggc3NfY3R4OworfTsKKwordm9pZCBhcmNoX3JlbW92ZV9rcHJvYmUoc3RydWN0IGtwcm9iZSAq cCk7CitpbnQga3Byb2JlX2ZhdWx0X2hhbmRsZXIoc3RydWN0IHB0X3JlZ3MgKnJlZ3MsIHVuc2ln bmVkIGludCB0cmFwbnIpOworYm9vbCBrcHJvYmVfYnJlYWtwb2ludF9oYW5kbGVyKHN0cnVjdCBw dF9yZWdzICpyZWdzKTsKK2Jvb2wga3Byb2JlX3NpbmdsZV9zdGVwX2hhbmRsZXIoc3RydWN0IHB0 X3JlZ3MgKnJlZ3MpOwordm9pZCBrcmV0cHJvYmVfdHJhbXBvbGluZSh2b2lkKTsKK3ZvaWQgX19r cHJvYmVzICp0cmFtcG9saW5lX3Byb2JlX2hhbmRsZXIoc3RydWN0IHB0X3JlZ3MgKnJlZ3MpOwor CisjZW5kaWYgLyogQ09ORklHX0tQUk9CRVMgKi8KICNlbmRpZiAvKiBfQVNNX1JJU0NWX0tQUk9C RVNfSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9wcm9iZXMuaCBiL2Fy Y2gvcmlzY3YvaW5jbHVkZS9hc20vcHJvYmVzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAuLmE3ODdlNmQKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3Jpc2N2L2luY2x1ZGUv YXNtL3Byb2Jlcy5oCkBAIC0wLDAgKzEsMjQgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBHUEwtMi4wICovCisKKyNpZm5kZWYgX0FTTV9SSVNDVl9QUk9CRVNfSAorI2RlZmluZSBfQVNN X1JJU0NWX1BST0JFU19ICisKK3R5cGVkZWYgdTMyIHByb2JlX29wY29kZV90OwordHlwZWRlZiBi b29sIChwcm9iZXNfaGFuZGxlcl90KSAodTMyIG9wY29kZSwgdW5zaWduZWQgbG9uZyBhZGRyLCBz dHJ1Y3QgcHRfcmVncyAqKTsKKworLyogYXJjaGl0ZWN0dXJlIHNwZWNpZmljIGNvcHkgb2Ygb3Jp Z2luYWwgaW5zdHJ1Y3Rpb24gKi8KK3N0cnVjdCBhcmNoX3Byb2JlX2luc24geworCXByb2JlX29w Y29kZV90ICppbnNuOworCXByb2Jlc19oYW5kbGVyX3QgKmhhbmRsZXI7CisJLyogcmVzdG9yZSBh ZGRyZXNzIGFmdGVyIHNpbXVsYXRpb24gKi8KKwl1bnNpZ25lZCBsb25nIHJlc3RvcmU7Cit9Owor CisjaWZkZWYgQ09ORklHX0tQUk9CRVMKK3R5cGVkZWYgdTMyIGtwcm9iZV9vcGNvZGVfdDsKK3N0 cnVjdCBhcmNoX3NwZWNpZmljX2luc24geworCXN0cnVjdCBhcmNoX3Byb2JlX2luc24gYXBpOwor fTsKKyNlbmRpZgorCisjZW5kaWYgLyogX0FTTV9SSVNDVl9QUk9CRVNfSCAqLwpkaWZmIC0tZ2l0 IGEvYXJjaC9yaXNjdi9rZXJuZWwvTWFrZWZpbGUgYi9hcmNoL3Jpc2N2L2tlcm5lbC9NYWtlZmls ZQppbmRleCBiMzU1Y2Y0Li5jM2ZmZjNlIDEwMDY0NAotLS0gYS9hcmNoL3Jpc2N2L2tlcm5lbC9N YWtlZmlsZQorKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9NYWtlZmlsZQpAQCAtMjksNiArMjksNyBA QCBvYmoteQkrPSByaXNjdl9rc3ltcy5vCiBvYmoteQkrPSBzdGFja3RyYWNlLm8KIG9iai15CSs9 IGNhY2hlaW5mby5vCiBvYmoteQkrPSBwYXRjaC5vCitvYmoteQkrPSBwcm9iZXMvCiBvYmotJChD T05GSUdfTU1VKSArPSB2ZHNvLm8gdmRzby8KIAogb2JqLSQoQ09ORklHX1JJU0NWX01fTU9ERSkJ Kz0gY2xpbnQubyB0cmFwc19taXNhbGlnbmVkLm8KZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3Yva2Vy bmVsL3Byb2Jlcy9NYWtlZmlsZSBiL2FyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9NYWtlZmlsZQpu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMC4uOGEzOTUwNwotLS0gL2Rldi9udWxs CisrKyBiL2FyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9NYWtlZmlsZQpAQCAtMCwwICsxLDQgQEAK KyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKK29iai0kKENPTkZJR19LUFJPQkVT KQkJKz0ga3Byb2Jlcy5vIGRlY29kZS1pbnNuLm8gc2ltdWxhdGUtaW5zbi5vCitvYmotJChDT05G SUdfS1BST0JFUykJCSs9IGtwcm9iZXNfdHJhbXBvbGluZS5vCitDRkxBR1NfUkVNT1ZFX3NpbXVs YXRlLWluc24ubyA9ICQoQ0NfRkxBR1NfRlRSQUNFKQpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9r ZXJuZWwvcHJvYmVzL2RlY29kZS1pbnNuLmMgYi9hcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvZGVj b2RlLWluc24uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMC4uMDg3NmMzMAot LS0gL2Rldi9udWxsCisrKyBiL2FyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9kZWNvZGUtaW5zbi5j CkBAIC0wLDAgKzEsNDggQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKwor CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgva3Byb2Jlcy5oPgor I2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L2thbGxzeW1zLmg+Cisj aW5jbHVkZSA8YXNtL3NlY3Rpb25zLmg+CisKKyNpbmNsdWRlICJkZWNvZGUtaW5zbi5oIgorI2lu Y2x1ZGUgInNpbXVsYXRlLWluc24uaCIKKworLyogUmV0dXJuOgorICogICBJTlNOX1JFSkVDVEVE ICAgICBJZiBpbnN0cnVjdGlvbiBpcyBvbmUgbm90IGFsbG93ZWQgdG8ga3Byb2JlLAorICogICBJ TlNOX0dPT0RfTk9fU0xPVCBJZiBpbnN0cnVjdGlvbiBpcyBzdXBwb3J0ZWQgYnV0IGRvZXNuJ3Qg dXNlIGl0cyBzbG90LgorICovCitlbnVtIHByb2JlX2luc24gX19rcHJvYmVzCityaXNjdl9wcm9i ZV9kZWNvZGVfaW5zbihwcm9iZV9vcGNvZGVfdCAqYWRkciwgc3RydWN0IGFyY2hfcHJvYmVfaW5z biAqYXBpKQoreworCXByb2JlX29wY29kZV90IGluc24gPSBsZTMyX3RvX2NwdSgqYWRkcik7CisK KwkvKgorCSAqIFJlamVjdCBpbnN0cnVjdGlvbnMgbGlzdDoKKwkgKi8KKwlSSVNDVl9JTlNOX1JF SkVDVEVEKHN5c3RlbSwJCWluc24pOworCVJJU0NWX0lOU05fUkVKRUNURUQoZmVuY2UsCQlpbnNu KTsKKworCS8qCisJICogU2ltdWxhdGUgaW5zdHJ1Y3Rpb25zIGxpc3Q6CisJICogVE9ETzogdGhl IFJFSkVDVEVEIG9uZXMgYmVsb3cgbmVlZCB0byBiZSBpbXBsZW1lbnRlZAorCSAqLworI2lmZGVm IENPTkZJR19SSVNDVl9JU0FfQworCVJJU0NWX0lOU05fUkVKRUNURUQoY19qLAkJaW5zbik7CisJ UklTQ1ZfSU5TTl9SRUpFQ1RFRChjX2pyLAkJaW5zbik7CisJUklTQ1ZfSU5TTl9SRUpFQ1RFRChj X2phbCwJCWluc24pOworCVJJU0NWX0lOU05fUkVKRUNURUQoY19qYWxyLAkJaW5zbik7CisJUklT Q1ZfSU5TTl9SRUpFQ1RFRChjX2JlcXosCQlpbnNuKTsKKwlSSVNDVl9JTlNOX1JFSkVDVEVEKGNf Ym5leiwJCWluc24pOworCVJJU0NWX0lOU05fUkVKRUNURUQoY19lYnJlYWssCQlpbnNuKTsKKyNl bmRpZgorCisJUklTQ1ZfSU5TTl9SRUpFQ1RFRChhdWlwYywJCWluc24pOworCVJJU0NWX0lOU05f UkVKRUNURUQoYnJhbmNoLAkJaW5zbik7CisKKwlSSVNDVl9JTlNOX1NFVF9TSU1VTEFURShqYWws CQlpbnNuKTsKKwlSSVNDVl9JTlNOX1NFVF9TSU1VTEFURShqYWxyLAkJaW5zbik7CisKKwlyZXR1 cm4gSU5TTl9HT09EOworfQpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJuZWwvcHJvYmVzL2Rl Y29kZS1pbnNuLmggYi9hcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvZGVjb2RlLWluc24uaApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMC4uNDIyNjlhNwotLS0gL2Rldi9udWxsCisr KyBiL2FyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9kZWNvZGUtaW5zbi5oCkBAIC0wLDAgKzEsMTgg QEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKyAqLworCisjaWZuZGVmIF9S SVNDVl9LRVJORUxfS1BST0JFU19ERUNPREVfSU5TTl9ICisjZGVmaW5lIF9SSVNDVl9LRVJORUxf S1BST0JFU19ERUNPREVfSU5TTl9ICisKKyNpbmNsdWRlIDxhc20vc2VjdGlvbnMuaD4KKyNpbmNs dWRlIDxhc20va3Byb2Jlcy5oPgorCitlbnVtIHByb2JlX2luc24geworCUlOU05fUkVKRUNURUQs CisJSU5TTl9HT09EX05PX1NMT1QsCisJSU5TTl9HT09ELAorfTsKKworZW51bSBwcm9iZV9pbnNu IF9fa3Byb2JlcworcmlzY3ZfcHJvYmVfZGVjb2RlX2luc24ocHJvYmVfb3Bjb2RlX3QgKmFkZHIs IHN0cnVjdCBhcmNoX3Byb2JlX2luc24gKmFzaSk7CisKKyNlbmRpZiAvKiBfUklTQ1ZfS0VSTkVM X0tQUk9CRVNfREVDT0RFX0lOU05fSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJuZWwv cHJvYmVzL2twcm9iZXMuYyBiL2FyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9rcHJvYmVzLmMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAuLjMxYjYxOTYKLS0tIC9kZXYvbnVsbAor KysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMva3Byb2Jlcy5jCkBAIC0wLDAgKzEsNDcxIEBA CisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsKKworI2luY2x1ZGUgPGxpbnV4 L2twcm9iZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9leHRhYmxlLmg+CisjaW5jbHVkZSA8bGludXgv c2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L3N0b3BfbWFjaGluZS5oPgorI2luY2x1ZGUgPGFzbS9w dHJhY2UuaD4KKyNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CisjaW5jbHVkZSA8YXNtL3NlY3Rp b25zLmg+CisjaW5jbHVkZSA8YXNtL2NhY2hlZmx1c2guaD4KKyNpbmNsdWRlIDxhc20vYnVnLmg+ CisjaW5jbHVkZSA8YXNtL3BhdGNoLmg+CisKKyNpbmNsdWRlICJkZWNvZGUtaW5zbi5oIgorCitE RUZJTkVfUEVSX0NQVShzdHJ1Y3Qga3Byb2JlICosIGN1cnJlbnRfa3Byb2JlKSA9IE5VTEw7CitE RUZJTkVfUEVSX0NQVShzdHJ1Y3Qga3Byb2JlX2N0bGJsaywga3Byb2JlX2N0bGJsayk7CisKK3N0 YXRpYyB2b2lkIF9fa3Byb2JlcworcG9zdF9rcHJvYmVfaGFuZGxlcihzdHJ1Y3Qga3Byb2JlX2N0 bGJsayAqLCBzdHJ1Y3QgcHRfcmVncyAqKTsKKworc3RhdGljIHZvaWQgX19rcHJvYmVzIGFyY2hf cHJlcGFyZV9zc19zbG90KHN0cnVjdCBrcHJvYmUgKnApCit7CisJdW5zaWduZWQgbG9uZyBvZmZz ZXQgPSBHRVRfSU5TTl9MRU5HVEgocC0+b3Bjb2RlKTsKKworCXAtPmFpbnNuLmFwaS5yZXN0b3Jl ID0gKHVuc2lnbmVkIGxvbmcpcC0+YWRkciArIG9mZnNldDsKKworCXBhdGNoX3RleHQocC0+YWlu c24uYXBpLmluc24sIHAtPm9wY29kZSk7CisJcGF0Y2hfdGV4dCgodm9pZCAqKSgodW5zaWduZWQg bG9uZykocC0+YWluc24uYXBpLmluc24pICsgb2Zmc2V0KSwKKwkJICAgX19CVUdfSU5TTl8zMik7 Cit9CisKK3N0YXRpYyB2b2lkIF9fa3Byb2JlcyBhcmNoX3ByZXBhcmVfc2ltdWxhdGUoc3RydWN0 IGtwcm9iZSAqcCkKK3sKKwlwLT5haW5zbi5hcGkucmVzdG9yZSA9IDA7Cit9CisKK3N0YXRpYyB2 b2lkIF9fa3Byb2JlcyBhcmNoX3NpbXVsYXRlX2luc24oc3RydWN0IGtwcm9iZSAqcCwgc3RydWN0 IHB0X3JlZ3MgKnJlZ3MpCit7CisJc3RydWN0IGtwcm9iZV9jdGxibGsgKmtjYiA9IGdldF9rcHJv YmVfY3RsYmxrKCk7CisKKwlpZiAocC0+YWluc24uYXBpLmhhbmRsZXIpCisJCXAtPmFpbnNuLmFw aS5oYW5kbGVyKCh1MzIpcC0+b3Bjb2RlLAorCQkJCQkodW5zaWduZWQgbG9uZylwLT5hZGRyLCBy ZWdzKTsKKworCXBvc3Rfa3Byb2JlX2hhbmRsZXIoa2NiLCByZWdzKTsKK30KKworaW50IF9fa3By b2JlcyBhcmNoX3ByZXBhcmVfa3Byb2JlKHN0cnVjdCBrcHJvYmUgKnApCit7CisJdW5zaWduZWQg bG9uZyBwcm9iZV9hZGRyID0gKHVuc2lnbmVkIGxvbmcpcC0+YWRkcjsKKworCWlmIChwcm9iZV9h ZGRyICYgMHgxKSB7CisJCXByX3dhcm4oIkFkZHJlc3Mgbm90IGFsaWduZWQuXG4iKTsKKworCQly ZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKiBjb3B5IGluc3RydWN0aW9uICovCisJcC0+b3Bjb2Rl ID0gbGUzMl90b19jcHUoKnAtPmFkZHIpOworCisJLyogZGVjb2RlIGluc3RydWN0aW9uICovCisJ c3dpdGNoIChyaXNjdl9wcm9iZV9kZWNvZGVfaW5zbihwLT5hZGRyLCAmcC0+YWluc24uYXBpKSkg eworCWNhc2UgSU5TTl9SRUpFQ1RFRDoJLyogaW5zbiBub3Qgc3VwcG9ydGVkICovCisJCXJldHVy biAtRUlOVkFMOworCisJY2FzZSBJTlNOX0dPT0RfTk9fU0xPVDoJLyogaW5zbiBuZWVkIHNpbXVs YXRpb24gKi8KKwkJcC0+YWluc24uYXBpLmluc24gPSBOVUxMOworCQlicmVhazsKKworCWNhc2Ug SU5TTl9HT09EOgkvKiBpbnN0cnVjdGlvbiB1c2VzIHNsb3QgKi8KKwkJcC0+YWluc24uYXBpLmlu c24gPSBnZXRfaW5zbl9zbG90KCk7CisJCWlmICghcC0+YWluc24uYXBpLmluc24pCisJCQlyZXR1 cm4gLUVOT01FTTsKKwkJYnJlYWs7CisJfQorCisJLyogcHJlcGFyZSB0aGUgaW5zdHJ1Y3Rpb24g Ki8KKwlpZiAocC0+YWluc24uYXBpLmluc24pCisJCWFyY2hfcHJlcGFyZV9zc19zbG90KHApOwor CWVsc2UKKwkJYXJjaF9wcmVwYXJlX3NpbXVsYXRlKHApOworCisJcmV0dXJuIDA7Cit9CisKKy8q IGluc3RhbGwgYnJlYWtwb2ludCBpbiB0ZXh0ICovCit2b2lkIF9fa3Byb2JlcyBhcmNoX2FybV9r cHJvYmUoc3RydWN0IGtwcm9iZSAqcCkKK3sKKwlpZiAoKHAtPm9wY29kZSAmIF9fSU5TTl9MRU5H VEhfTUFTSykgPT0gX19JTlNOX0xFTkdUSF8zMikKKwkJcGF0Y2hfdGV4dChwLT5hZGRyLCBfX0JV R19JTlNOXzMyKTsKKwllbHNlCisJCXBhdGNoX3RleHQocC0+YWRkciwgX19CVUdfSU5TTl8xNik7 Cit9CisKKy8qIHJlbW92ZSBicmVha3BvaW50IGZyb20gdGV4dCAqLwordm9pZCBfX2twcm9iZXMg YXJjaF9kaXNhcm1fa3Byb2JlKHN0cnVjdCBrcHJvYmUgKnApCit7CisJcGF0Y2hfdGV4dChwLT5h ZGRyLCBwLT5vcGNvZGUpOworfQorCit2b2lkIF9fa3Byb2JlcyBhcmNoX3JlbW92ZV9rcHJvYmUo c3RydWN0IGtwcm9iZSAqcCkKK3sKK30KKworc3RhdGljIHZvaWQgX19rcHJvYmVzIHNhdmVfcHJl dmlvdXNfa3Byb2JlKHN0cnVjdCBrcHJvYmVfY3RsYmxrICprY2IpCit7CisJa2NiLT5wcmV2X2tw cm9iZS5rcCA9IGtwcm9iZV9ydW5uaW5nKCk7CisJa2NiLT5wcmV2X2twcm9iZS5zdGF0dXMgPSBr Y2ItPmtwcm9iZV9zdGF0dXM7Cit9CisKK3N0YXRpYyB2b2lkIF9fa3Byb2JlcyByZXN0b3JlX3By ZXZpb3VzX2twcm9iZShzdHJ1Y3Qga3Byb2JlX2N0bGJsayAqa2NiKQoreworCV9fdGhpc19jcHVf d3JpdGUoY3VycmVudF9rcHJvYmUsIGtjYi0+cHJldl9rcHJvYmUua3ApOworCWtjYi0+a3Byb2Jl X3N0YXR1cyA9IGtjYi0+cHJldl9rcHJvYmUuc3RhdHVzOworfQorCitzdGF0aWMgdm9pZCBfX2tw cm9iZXMgc2V0X2N1cnJlbnRfa3Byb2JlKHN0cnVjdCBrcHJvYmUgKnApCit7CisJX190aGlzX2Nw dV93cml0ZShjdXJyZW50X2twcm9iZSwgcCk7Cit9CisKKy8qCisgKiBJbnRlcnJ1cHRzIG5lZWQg dG8gYmUgZGlzYWJsZWQgYmVmb3JlIHNpbmdsZS1zdGVwIG1vZGUgaXMgc2V0LCBhbmQgbm90Cisg KiByZWVuYWJsZWQgdW50aWwgYWZ0ZXIgc2luZ2xlLXN0ZXAgbW9kZSBlbmRzLgorICogV2l0aG91 dCBkaXNhYmxpbmcgaW50ZXJydXB0IG9uIGxvY2FsIENQVSwgdGhlcmUgaXMgYSBjaGFuY2Ugb2YK KyAqIGludGVycnVwdCBvY2N1cnJlbmNlIGluIHRoZSBwZXJpb2Qgb2YgZXhjZXB0aW9uIHJldHVy biBhbmQgIHN0YXJ0IG9mCisgKiBvdXQtb2YtbGluZSBzaW5nbGUtc3RlcCwgdGhhdCByZXN1bHQg aW4gd3JvbmdseSBzaW5nbGUgc3RlcHBpbmcKKyAqIGludG8gdGhlIGludGVycnVwdCBoYW5kbGVy LgorICovCitzdGF0aWMgdm9pZCBfX2twcm9iZXMga3Byb2Jlc19zYXZlX2xvY2FsX2lycWZsYWco c3RydWN0IGtwcm9iZV9jdGxibGsgKmtjYiwKKwkJCQkJCXN0cnVjdCBwdF9yZWdzICpyZWdzKQor eworCWtjYi0+c2F2ZWRfc3RhdHVzID0gcmVncy0+c3RhdHVzOworCXJlZ3MtPnN0YXR1cyAmPSB+ U1JfU1BJRTsKK30KKworc3RhdGljIHZvaWQgX19rcHJvYmVzIGtwcm9iZXNfcmVzdG9yZV9sb2Nh bF9pcnFmbGFnKHN0cnVjdCBrcHJvYmVfY3RsYmxrICprY2IsCisJCQkJCQlzdHJ1Y3QgcHRfcmVn cyAqcmVncykKK3sKKwlyZWdzLT5zdGF0dXMgPSBrY2ItPnNhdmVkX3N0YXR1czsKK30KKworc3Rh dGljIHZvaWQgX19rcHJvYmVzCitzZXRfc3NfY29udGV4dChzdHJ1Y3Qga3Byb2JlX2N0bGJsayAq a2NiLCB1bnNpZ25lZCBsb25nIGFkZHIsIHN0cnVjdCBrcHJvYmUgKnApCit7CisJdW5zaWduZWQg bG9uZyBvZmZzZXQgPSBHRVRfSU5TTl9MRU5HVEgocC0+b3Bjb2RlKTsKKworCWtjYi0+c3NfY3R4 LnNzX3BlbmRpbmcgPSB0cnVlOworCWtjYi0+c3NfY3R4Lm1hdGNoX2FkZHIgPSBhZGRyICsgb2Zm c2V0OworfQorCitzdGF0aWMgdm9pZCBfX2twcm9iZXMgY2xlYXJfc3NfY29udGV4dChzdHJ1Y3Qg a3Byb2JlX2N0bGJsayAqa2NiKQoreworCWtjYi0+c3NfY3R4LnNzX3BlbmRpbmcgPSBmYWxzZTsK KwlrY2ItPnNzX2N0eC5tYXRjaF9hZGRyID0gMDsKK30KKworc3RhdGljIHZvaWQgX19rcHJvYmVz IHNldHVwX3NpbmdsZXN0ZXAoc3RydWN0IGtwcm9iZSAqcCwKKwkJCQkgICAgICAgc3RydWN0IHB0 X3JlZ3MgKnJlZ3MsCisJCQkJICAgICAgIHN0cnVjdCBrcHJvYmVfY3RsYmxrICprY2IsIGludCBy ZWVudGVyKQoreworCXVuc2lnbmVkIGxvbmcgc2xvdDsKKworCWlmIChyZWVudGVyKSB7CisJCXNh dmVfcHJldmlvdXNfa3Byb2JlKGtjYik7CisJCXNldF9jdXJyZW50X2twcm9iZShwKTsKKwkJa2Ni LT5rcHJvYmVfc3RhdHVzID0gS1BST0JFX1JFRU5URVI7CisJfSBlbHNlIHsKKwkJa2NiLT5rcHJv YmVfc3RhdHVzID0gS1BST0JFX0hJVF9TUzsKKwl9CisKKwlpZiAocC0+YWluc24uYXBpLmluc24p IHsKKwkJLyogcHJlcGFyZSBmb3Igc2luZ2xlIHN0ZXBwaW5nICovCisJCXNsb3QgPSAodW5zaWdu ZWQgbG9uZylwLT5haW5zbi5hcGkuaW5zbjsKKworCQlzZXRfc3NfY29udGV4dChrY2IsIHNsb3Qs IHApOwkvKiBtYXJrIHBlbmRpbmcgc3MgKi8KKworCQkvKiBJUlFzIGFuZCBzaW5nbGUgc3RlcHBp bmcgZG8gbm90IG1peCB3ZWxsLiAqLworCQlrcHJvYmVzX3NhdmVfbG9jYWxfaXJxZmxhZyhrY2Is IHJlZ3MpOworCisJCWluc3RydWN0aW9uX3BvaW50ZXJfc2V0KHJlZ3MsIHNsb3QpOworCX0gZWxz ZSB7CisJCS8qIGluc24gc2ltdWxhdGlvbiAqLworCQlhcmNoX3NpbXVsYXRlX2luc24ocCwgcmVn cyk7CisJfQorfQorCitzdGF0aWMgaW50IF9fa3Byb2JlcyByZWVudGVyX2twcm9iZShzdHJ1Y3Qg a3Byb2JlICpwLAorCQkJCSAgICBzdHJ1Y3QgcHRfcmVncyAqcmVncywKKwkJCQkgICAgc3RydWN0 IGtwcm9iZV9jdGxibGsgKmtjYikKK3sKKwlzd2l0Y2ggKGtjYi0+a3Byb2JlX3N0YXR1cykgewor CWNhc2UgS1BST0JFX0hJVF9TU0RPTkU6CisJY2FzZSBLUFJPQkVfSElUX0FDVElWRToKKwkJa3By b2Jlc19pbmNfbm1pc3NlZF9jb3VudChwKTsKKwkJc2V0dXBfc2luZ2xlc3RlcChwLCByZWdzLCBr Y2IsIDEpOworCQlicmVhazsKKwljYXNlIEtQUk9CRV9ISVRfU1M6CisJY2FzZSBLUFJPQkVfUkVF TlRFUjoKKwkJcHJfd2FybigiVW5yZWNvdmVyYWJsZSBrcHJvYmUgZGV0ZWN0ZWQuXG4iKTsKKwkJ ZHVtcF9rcHJvYmUocCk7CisJCUJVRygpOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlXQVJOX09O KDEpOworCQlyZXR1cm4gMDsKKwl9CisKKwlyZXR1cm4gMTsKK30KKworc3RhdGljIHZvaWQgX19r cHJvYmVzCitwb3N0X2twcm9iZV9oYW5kbGVyKHN0cnVjdCBrcHJvYmVfY3RsYmxrICprY2IsIHN0 cnVjdCBwdF9yZWdzICpyZWdzKQoreworCXN0cnVjdCBrcHJvYmUgKmN1ciA9IGtwcm9iZV9ydW5u aW5nKCk7CisKKwlpZiAoIWN1cikKKwkJcmV0dXJuOworCisJLyogcmV0dXJuIGFkZHIgcmVzdG9y ZSBpZiBub24tYnJhbmNoaW5nIGluc24gKi8KKwlpZiAoY3VyLT5haW5zbi5hcGkucmVzdG9yZSAh PSAwKQorCQlyZWdzLT5lcGMgPSBjdXItPmFpbnNuLmFwaS5yZXN0b3JlOworCisJLyogcmVzdG9y ZSBiYWNrIG9yaWdpbmFsIHNhdmVkIGtwcm9iZSB2YXJpYWJsZXMgYW5kIGNvbnRpbnVlICovCisJ aWYgKGtjYi0+a3Byb2JlX3N0YXR1cyA9PSBLUFJPQkVfUkVFTlRFUikgeworCQlyZXN0b3JlX3By ZXZpb3VzX2twcm9iZShrY2IpOworCQlyZXR1cm47CisJfQorCisJLyogY2FsbCBwb3N0IGhhbmRs ZXIgKi8KKwlrY2ItPmtwcm9iZV9zdGF0dXMgPSBLUFJPQkVfSElUX1NTRE9ORTsKKwlpZiAoY3Vy LT5wb3N0X2hhbmRsZXIpCXsKKwkJLyogcG9zdF9oYW5kbGVyIGNhbiBoaXQgYnJlYWtwb2ludCBh bmQgc2luZ2xlIHN0ZXAKKwkJICogYWdhaW4sIHNvIHdlIGVuYWJsZSBELWZsYWcgZm9yIHJlY3Vy c2l2ZSBleGNlcHRpb24uCisJCSAqLworCQljdXItPnBvc3RfaGFuZGxlcihjdXIsIHJlZ3MsIDAp OworCX0KKworCXJlc2V0X2N1cnJlbnRfa3Byb2JlKCk7Cit9CisKK2ludCBfX2twcm9iZXMga3By b2JlX2ZhdWx0X2hhbmRsZXIoc3RydWN0IHB0X3JlZ3MgKnJlZ3MsIHVuc2lnbmVkIGludCB0cmFw bnIpCit7CisJc3RydWN0IGtwcm9iZSAqY3VyID0ga3Byb2JlX3J1bm5pbmcoKTsKKwlzdHJ1Y3Qg a3Byb2JlX2N0bGJsayAqa2NiID0gZ2V0X2twcm9iZV9jdGxibGsoKTsKKworCXN3aXRjaCAoa2Ni LT5rcHJvYmVfc3RhdHVzKSB7CisJY2FzZSBLUFJPQkVfSElUX1NTOgorCWNhc2UgS1BST0JFX1JF RU5URVI6CisJCS8qCisJCSAqIFdlIGFyZSBoZXJlIGJlY2F1c2UgdGhlIGluc3RydWN0aW9uIGJl aW5nIHNpbmdsZQorCQkgKiBzdGVwcGVkIGNhdXNlZCBhIHBhZ2UgZmF1bHQuIFdlIHJlc2V0IHRo ZSBjdXJyZW50CisJCSAqIGtwcm9iZSBhbmQgdGhlIGlwIHBvaW50cyBiYWNrIHRvIHRoZSBwcm9i ZSBhZGRyZXNzCisJCSAqIGFuZCBhbGxvdyB0aGUgcGFnZSBmYXVsdCBoYW5kbGVyIHRvIGNvbnRp bnVlIGFzIGEKKwkJICogbm9ybWFsIHBhZ2UgZmF1bHQuCisJCSAqLworCQlyZWdzLT5lcGMgPSAo dW5zaWduZWQgbG9uZykgY3VyLT5hZGRyOworCQlpZiAoIWluc3RydWN0aW9uX3BvaW50ZXIocmVn cykpCisJCQlCVUcoKTsKKworCQlpZiAoa2NiLT5rcHJvYmVfc3RhdHVzID09IEtQUk9CRV9SRUVO VEVSKQorCQkJcmVzdG9yZV9wcmV2aW91c19rcHJvYmUoa2NiKTsKKwkJZWxzZQorCQkJcmVzZXRf Y3VycmVudF9rcHJvYmUoKTsKKworCQlicmVhazsKKwljYXNlIEtQUk9CRV9ISVRfQUNUSVZFOgor CWNhc2UgS1BST0JFX0hJVF9TU0RPTkU6CisJCS8qCisJCSAqIFdlIGluY3JlbWVudCB0aGUgbm1p c3NlZCBjb3VudCBmb3IgYWNjb3VudGluZywKKwkJICogd2UgY2FuIGFsc28gdXNlIG5wcmUvbnBv c3RmYXVsdCBjb3VudCBmb3IgYWNjb3VudGluZworCQkgKiB0aGVzZSBzcGVjaWZpYyBmYXVsdCBj YXNlcy4KKwkJICovCisJCWtwcm9iZXNfaW5jX25taXNzZWRfY291bnQoY3VyKTsKKworCQkvKgor CQkgKiBXZSBjb21lIGhlcmUgYmVjYXVzZSBpbnN0cnVjdGlvbnMgaW4gdGhlIHByZS9wb3N0CisJ CSAqIGhhbmRsZXIgY2F1c2VkIHRoZSBwYWdlX2ZhdWx0LCB0aGlzIGNvdWxkIGhhcHBlbgorCQkg KiBpZiBoYW5kbGVyIHRyaWVzIHRvIGFjY2VzcyB1c2VyIHNwYWNlIGJ5CisJCSAqIGNvcHlfZnJv bV91c2VyKCksIGdldF91c2VyKCkgZXRjLiBMZXQgdGhlCisJCSAqIHVzZXItc3BlY2lmaWVkIGhh bmRsZXIgdHJ5IHRvIGZpeCBpdCBmaXJzdC4KKwkJICovCisJCWlmIChjdXItPmZhdWx0X2hhbmRs ZXIgJiYgY3VyLT5mYXVsdF9oYW5kbGVyKGN1ciwgcmVncywgdHJhcG5yKSkKKwkJCXJldHVybiAx OworCisJCS8qCisJCSAqIEluIGNhc2UgdGhlIHVzZXItc3BlY2lmaWVkIGZhdWx0IGhhbmRsZXIg cmV0dXJuZWQKKwkJICogemVybywgdHJ5IHRvIGZpeCB1cC4KKwkJICovCisJCWlmIChmaXh1cF9l eGNlcHRpb24ocmVncykpCisJCQlyZXR1cm4gMTsKKwl9CisJcmV0dXJuIDA7Cit9CisKK2Jvb2wg X19rcHJvYmVzCitrcHJvYmVfYnJlYWtwb2ludF9oYW5kbGVyKHN0cnVjdCBwdF9yZWdzICpyZWdz KQoreworCXN0cnVjdCBrcHJvYmUgKnAsICpjdXJfa3Byb2JlOworCXN0cnVjdCBrcHJvYmVfY3Rs YmxrICprY2I7CisJdW5zaWduZWQgbG9uZyBhZGRyID0gaW5zdHJ1Y3Rpb25fcG9pbnRlcihyZWdz KTsKKworCWtjYiA9IGdldF9rcHJvYmVfY3RsYmxrKCk7CisJY3VyX2twcm9iZSA9IGtwcm9iZV9y dW5uaW5nKCk7CisKKwlwID0gZ2V0X2twcm9iZSgoa3Byb2JlX29wY29kZV90ICopIGFkZHIpOwor CisJaWYgKHApIHsKKwkJaWYgKGN1cl9rcHJvYmUpIHsKKwkJCWlmIChyZWVudGVyX2twcm9iZShw LCByZWdzLCBrY2IpKQorCQkJCXJldHVybiB0cnVlOworCQl9IGVsc2UgeworCQkJLyogUHJvYmUg aGl0ICovCisJCQlzZXRfY3VycmVudF9rcHJvYmUocCk7CisJCQlrY2ItPmtwcm9iZV9zdGF0dXMg PSBLUFJPQkVfSElUX0FDVElWRTsKKworCQkJLyoKKwkJCSAqIElmIHdlIGhhdmUgbm8gcHJlLWhh bmRsZXIgb3IgaXQgcmV0dXJuZWQgMCwgd2UKKwkJCSAqIGNvbnRpbnVlIHdpdGggbm9ybWFsIHBy b2Nlc3NpbmcuICBJZiB3ZSBoYXZlIGEKKwkJCSAqIHByZS1oYW5kbGVyIGFuZCBpdCByZXR1cm5l ZCBub24temVybywgaXQgd2lsbAorCQkJICogbW9kaWZ5IHRoZSBleGVjdXRpb24gcGF0aCBhbmQg bm8gbmVlZCB0byBzaW5nbGUKKwkJCSAqIHN0ZXBwaW5nLiBMZXQncyBqdXN0IHJlc2V0IGN1cnJl bnQga3Byb2JlIGFuZCBleGl0LgorCQkJICoKKwkJCSAqIHByZV9oYW5kbGVyIGNhbiBoaXQgYSBi cmVha3BvaW50IGFuZCBjYW4gc3RlcCB0aHJ1CisJCQkgKiBiZWZvcmUgcmV0dXJuLgorCQkJICov CisJCQlpZiAoIXAtPnByZV9oYW5kbGVyIHx8ICFwLT5wcmVfaGFuZGxlcihwLCByZWdzKSkKKwkJ CQlzZXR1cF9zaW5nbGVzdGVwKHAsIHJlZ3MsIGtjYiwgMCk7CisJCQllbHNlCisJCQkJcmVzZXRf Y3VycmVudF9rcHJvYmUoKTsKKwkJfQorCQlyZXR1cm4gdHJ1ZTsKKwl9CisKKwkvKgorCSAqIFRo ZSBicmVha3BvaW50IGluc3RydWN0aW9uIHdhcyByZW1vdmVkIHJpZ2h0CisJICogYWZ0ZXIgd2Ug aGl0IGl0LiAgQW5vdGhlciBjcHUgaGFzIHJlbW92ZWQKKwkgKiBlaXRoZXIgYSBwcm9iZXBvaW50 IG9yIGEgZGVidWdnZXIgYnJlYWtwb2ludAorCSAqIGF0IHRoaXMgYWRkcmVzcy4gIEluIGVpdGhl ciBjYXNlLCBubyBmdXJ0aGVyCisJICogaGFuZGxpbmcgb2YgdGhpcyBpbnRlcnJ1cHQgaXMgYXBw cm9wcmlhdGUuCisJICogUmV0dXJuIGJhY2sgdG8gb3JpZ2luYWwgaW5zdHJ1Y3Rpb24sIGFuZCBj b250aW51ZS4KKwkgKi8KKwlyZXR1cm4gZmFsc2U7Cit9CisKK2Jvb2wgX19rcHJvYmVzCitrcHJv YmVfc2luZ2xlX3N0ZXBfaGFuZGxlcihzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3sKKwlzdHJ1Y3Qg a3Byb2JlX2N0bGJsayAqa2NiID0gZ2V0X2twcm9iZV9jdGxibGsoKTsKKworCWlmICgoa2NiLT5z c19jdHguc3NfcGVuZGluZykKKwkgICAgJiYgKGtjYi0+c3NfY3R4Lm1hdGNoX2FkZHIgPT0gaW5z dHJ1Y3Rpb25fcG9pbnRlcihyZWdzKSkpIHsKKwkJY2xlYXJfc3NfY29udGV4dChrY2IpOwkvKiBj bGVhciBwZW5kaW5nIHNzICovCisKKwkJa3Byb2Jlc19yZXN0b3JlX2xvY2FsX2lycWZsYWcoa2Ni LCByZWdzKTsKKworCQlwb3N0X2twcm9iZV9oYW5kbGVyKGtjYiwgcmVncyk7CisJCXJldHVybiB0 cnVlOworCX0KKwlyZXR1cm4gZmFsc2U7Cit9CisKKy8qCisgKiBQcm92aWRlIGEgYmxhY2tsaXN0 IG9mIHN5bWJvbHMgaWRlbnRpZnlpbmcgcmFuZ2VzIHdoaWNoIGNhbm5vdCBiZSBrcHJvYmVkLgor ICogVGhpcyBibGFja2xpc3QgaXMgZXhwb3NlZCB0byB1c2Vyc3BhY2UgdmlhIGRlYnVnZnMgKGtw cm9iZXMvYmxhY2tsaXN0KS4KKyAqLworaW50IF9faW5pdCBhcmNoX3BvcHVsYXRlX2twcm9iZV9i bGFja2xpc3Qodm9pZCkKK3sKKwlpbnQgcmV0OworCisJcmV0ID0ga3Byb2JlX2FkZF9hcmVhX2Js YWNrbGlzdCgodW5zaWduZWQgbG9uZylfX2lycWVudHJ5X3RleHRfc3RhcnQsCisJCQkJCSh1bnNp Z25lZCBsb25nKV9faXJxZW50cnlfdGV4dF9lbmQpOworCXJldHVybiByZXQ7Cit9CisKK3ZvaWQg X19rcHJvYmVzIF9fdXNlZCAqdHJhbXBvbGluZV9wcm9iZV9oYW5kbGVyKHN0cnVjdCBwdF9yZWdz ICpyZWdzKQoreworCXN0cnVjdCBrcmV0cHJvYmVfaW5zdGFuY2UgKnJpID0gTlVMTDsKKwlzdHJ1 Y3QgaGxpc3RfaGVhZCAqaGVhZCwgZW1wdHlfcnA7CisJc3RydWN0IGhsaXN0X25vZGUgKnRtcDsK Kwl1bnNpZ25lZCBsb25nIGZsYWdzLCBvcmlnX3JldF9hZGRyZXNzID0gMDsKKwl1bnNpZ25lZCBs b25nIHRyYW1wb2xpbmVfYWRkcmVzcyA9CisJCSh1bnNpZ25lZCBsb25nKSZrcmV0cHJvYmVfdHJh bXBvbGluZTsKKwlrcHJvYmVfb3Bjb2RlX3QgKmNvcnJlY3RfcmV0X2FkZHIgPSBOVUxMOworCisJ SU5JVF9ITElTVF9IRUFEKCZlbXB0eV9ycCk7CisJa3JldHByb2JlX2hhc2hfbG9jayhjdXJyZW50 LCAmaGVhZCwgJmZsYWdzKTsKKworCS8qCisJICogSXQgaXMgcG9zc2libGUgdG8gaGF2ZSBtdWx0 aXBsZSBpbnN0YW5jZXMgYXNzb2NpYXRlZCB3aXRoIGEgZ2l2ZW4KKwkgKiB0YXNrIGVpdGhlciBi ZWNhdXNlIG11bHRpcGxlIGZ1bmN0aW9ucyBpbiB0aGUgY2FsbCBwYXRoIGhhdmUKKwkgKiByZXR1 cm4gcHJvYmVzIGluc3RhbGxlZCBvbiB0aGVtLCBhbmQvb3IgbW9yZSB0aGFuIG9uZQorCSAqIHJl dHVybiBwcm9iZSB3YXMgcmVnaXN0ZXJlZCBmb3IgYSB0YXJnZXQgZnVuY3Rpb24uCisJICoKKwkg KiBXZSBjYW4gaGFuZGxlIHRoaXMgYmVjYXVzZToKKwkgKiAgICAgLSBpbnN0YW5jZXMgYXJlIGFs d2F5cyBwdXNoZWQgaW50byB0aGUgaGVhZCBvZiB0aGUgbGlzdAorCSAqICAgICAtIHdoZW4gbXVs dGlwbGUgcmV0dXJuIHByb2JlcyBhcmUgcmVnaXN0ZXJlZCBmb3IgdGhlIHNhbWUKKwkgKgkgZnVu Y3Rpb24sIHRoZSAoY2hyb25vbG9naWNhbGx5KSBmaXJzdCBpbnN0YW5jZSdzIHJldF9hZGRyCisJ ICoJIHdpbGwgYmUgdGhlIHJlYWwgcmV0dXJuIGFkZHJlc3MsIGFuZCBhbGwgdGhlIHJlc3Qgd2ls bAorCSAqCSBwb2ludCB0byBrcmV0cHJvYmVfdHJhbXBvbGluZS4KKwkgKi8KKwlobGlzdF9mb3Jf ZWFjaF9lbnRyeV9zYWZlKHJpLCB0bXAsIGhlYWQsIGhsaXN0KSB7CisJCWlmIChyaS0+dGFzayAh PSBjdXJyZW50KQorCQkJLyogYW5vdGhlciB0YXNrIGlzIHNoYXJpbmcgb3VyIGhhc2ggYnVja2V0 ICovCisJCQljb250aW51ZTsKKworCQlvcmlnX3JldF9hZGRyZXNzID0gKHVuc2lnbmVkIGxvbmcp cmktPnJldF9hZGRyOworCisJCWlmIChvcmlnX3JldF9hZGRyZXNzICE9IHRyYW1wb2xpbmVfYWRk cmVzcykKKwkJCS8qCisJCQkgKiBUaGlzIGlzIHRoZSByZWFsIHJldHVybiBhZGRyZXNzLiBBbnkg b3RoZXIKKwkJCSAqIGluc3RhbmNlcyBhc3NvY2lhdGVkIHdpdGggdGhpcyB0YXNrIGFyZSBmb3IK KwkJCSAqIG90aGVyIGNhbGxzIGRlZXBlciBvbiB0aGUgY2FsbCBzdGFjaworCQkJICovCisJCQli cmVhazsKKwl9CisKKwlrcmV0cHJvYmVfYXNzZXJ0KHJpLCBvcmlnX3JldF9hZGRyZXNzLCB0cmFt cG9saW5lX2FkZHJlc3MpOworCisJY29ycmVjdF9yZXRfYWRkciA9IHJpLT5yZXRfYWRkcjsKKwlo bGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHJpLCB0bXAsIGhlYWQsIGhsaXN0KSB7CisJCWlmIChy aS0+dGFzayAhPSBjdXJyZW50KQorCQkJLyogYW5vdGhlciB0YXNrIGlzIHNoYXJpbmcgb3VyIGhh c2ggYnVja2V0ICovCisJCQljb250aW51ZTsKKworCQlvcmlnX3JldF9hZGRyZXNzID0gKHVuc2ln bmVkIGxvbmcpcmktPnJldF9hZGRyOworCQlpZiAocmktPnJwICYmIHJpLT5ycC0+aGFuZGxlcikg eworCQkJX190aGlzX2NwdV93cml0ZShjdXJyZW50X2twcm9iZSwgJnJpLT5ycC0+a3ApOworCQkJ Z2V0X2twcm9iZV9jdGxibGsoKS0+a3Byb2JlX3N0YXR1cyA9IEtQUk9CRV9ISVRfQUNUSVZFOwor CQkJcmktPnJldF9hZGRyID0gY29ycmVjdF9yZXRfYWRkcjsKKwkJCXJpLT5ycC0+aGFuZGxlcihy aSwgcmVncyk7CisJCQlfX3RoaXNfY3B1X3dyaXRlKGN1cnJlbnRfa3Byb2JlLCBOVUxMKTsKKwkJ fQorCisJCXJlY3ljbGVfcnBfaW5zdChyaSwgJmVtcHR5X3JwKTsKKworCQlpZiAob3JpZ19yZXRf YWRkcmVzcyAhPSB0cmFtcG9saW5lX2FkZHJlc3MpCisJCQkvKgorCQkJICogVGhpcyBpcyB0aGUg cmVhbCByZXR1cm4gYWRkcmVzcy4gQW55IG90aGVyCisJCQkgKiBpbnN0YW5jZXMgYXNzb2NpYXRl ZCB3aXRoIHRoaXMgdGFzayBhcmUgZm9yCisJCQkgKiBvdGhlciBjYWxscyBkZWVwZXIgb24gdGhl IGNhbGwgc3RhY2sKKwkJCSAqLworCQkJYnJlYWs7CisJfQorCisJa3JldHByb2JlX2hhc2hfdW5s b2NrKGN1cnJlbnQsICZmbGFncyk7CisKKwlobGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHJpLCB0 bXAsICZlbXB0eV9ycCwgaGxpc3QpIHsKKwkJaGxpc3RfZGVsKCZyaS0+aGxpc3QpOworCQlrZnJl ZShyaSk7CisJfQorCXJldHVybiAodm9pZCAqKW9yaWdfcmV0X2FkZHJlc3M7Cit9CisKK3ZvaWQg X19rcHJvYmVzIGFyY2hfcHJlcGFyZV9rcmV0cHJvYmUoc3RydWN0IGtyZXRwcm9iZV9pbnN0YW5j ZSAqcmksCisJCQkJICAgICAgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJcmktPnJldF9hZGRy ID0gKGtwcm9iZV9vcGNvZGVfdCAqKXJlZ3MtPnJhOworCXJlZ3MtPnJhID0gKHVuc2lnbmVkIGxv bmcpICZrcmV0cHJvYmVfdHJhbXBvbGluZTsKK30KKworaW50IF9fa3Byb2JlcyBhcmNoX3RyYW1w b2xpbmVfa3Byb2JlKHN0cnVjdCBrcHJvYmUgKnApCit7CisJcmV0dXJuIDA7Cit9CisKK2ludCBf X2luaXQgYXJjaF9pbml0X2twcm9iZXModm9pZCkKK3sKKwlyZXR1cm4gMDsKK30KZGlmZiAtLWdp dCBhL2FyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9rcHJvYmVzX3RyYW1wb2xpbmUuUyBiL2FyY2gv cmlzY3Yva2VybmVsL3Byb2Jlcy9rcHJvYmVzX3RyYW1wb2xpbmUuUwpuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMC4uNmU4NWQwMgotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvcmlz Y3Yva2VybmVsL3Byb2Jlcy9rcHJvYmVzX3RyYW1wb2xpbmUuUwpAQCAtMCwwICsxLDkzIEBACisv KiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsgKi8KKy8qCisgKiBBdXRob3I6IFBh dHJpY2sgU3TDpGhsaW4gPG1lQHBhY2tpLmNoPgorICovCisjaW5jbHVkZSA8bGludXgvbGlua2Fn ZS5oPgorCisjaW5jbHVkZSA8YXNtL2FzbS5oPgorI2luY2x1ZGUgPGFzbS9hc20tb2Zmc2V0cy5o PgorCisJLnRleHQKKwkuYWx0bWFjcm8KKworCS5tYWNybyBzYXZlX2FsbF9iYXNlX3JlZ3MKKwlS RUdfUyB4MSwgIFBUX1JBKHNwKQorCVJFR19TIHgzLCAgUFRfR1Aoc3ApCisJUkVHX1MgeDQsICBQ VF9UUChzcCkKKwlSRUdfUyB4NSwgIFBUX1QwKHNwKQorCVJFR19TIHg2LCAgUFRfVDEoc3ApCisJ UkVHX1MgeDcsICBQVF9UMihzcCkKKwlSRUdfUyB4OCwgIFBUX1MwKHNwKQorCVJFR19TIHg5LCAg UFRfUzEoc3ApCisJUkVHX1MgeDEwLCBQVF9BMChzcCkKKwlSRUdfUyB4MTEsIFBUX0ExKHNwKQor CVJFR19TIHgxMiwgUFRfQTIoc3ApCisJUkVHX1MgeDEzLCBQVF9BMyhzcCkKKwlSRUdfUyB4MTQs IFBUX0E0KHNwKQorCVJFR19TIHgxNSwgUFRfQTUoc3ApCisJUkVHX1MgeDE2LCBQVF9BNihzcCkK KwlSRUdfUyB4MTcsIFBUX0E3KHNwKQorCVJFR19TIHgxOCwgUFRfUzIoc3ApCisJUkVHX1MgeDE5 LCBQVF9TMyhzcCkKKwlSRUdfUyB4MjAsIFBUX1M0KHNwKQorCVJFR19TIHgyMSwgUFRfUzUoc3Ap CisJUkVHX1MgeDIyLCBQVF9TNihzcCkKKwlSRUdfUyB4MjMsIFBUX1M3KHNwKQorCVJFR19TIHgy NCwgUFRfUzgoc3ApCisJUkVHX1MgeDI1LCBQVF9TOShzcCkKKwlSRUdfUyB4MjYsIFBUX1MxMChz cCkKKwlSRUdfUyB4MjcsIFBUX1MxMShzcCkKKwlSRUdfUyB4MjgsIFBUX1QzKHNwKQorCVJFR19T IHgyOSwgUFRfVDQoc3ApCisJUkVHX1MgeDMwLCBQVF9UNShzcCkKKwlSRUdfUyB4MzEsIFBUX1Q2 KHNwKQorCS5lbmRtCisKKwkubWFjcm8gcmVzdG9yZV9hbGxfYmFzZV9yZWdzCisJUkVHX0wgeDMs ICBQVF9HUChzcCkKKwlSRUdfTCB4NCwgIFBUX1RQKHNwKQorCVJFR19MIHg1LCAgUFRfVDAoc3Ap CisJUkVHX0wgeDYsICBQVF9UMShzcCkKKwlSRUdfTCB4NywgIFBUX1QyKHNwKQorCVJFR19MIHg4 LCAgUFRfUzAoc3ApCisJUkVHX0wgeDksICBQVF9TMShzcCkKKwlSRUdfTCB4MTAsIFBUX0EwKHNw KQorCVJFR19MIHgxMSwgUFRfQTEoc3ApCisJUkVHX0wgeDEyLCBQVF9BMihzcCkKKwlSRUdfTCB4 MTMsIFBUX0EzKHNwKQorCVJFR19MIHgxNCwgUFRfQTQoc3ApCisJUkVHX0wgeDE1LCBQVF9BNShz cCkKKwlSRUdfTCB4MTYsIFBUX0E2KHNwKQorCVJFR19MIHgxNywgUFRfQTcoc3ApCisJUkVHX0wg eDE4LCBQVF9TMihzcCkKKwlSRUdfTCB4MTksIFBUX1MzKHNwKQorCVJFR19MIHgyMCwgUFRfUzQo c3ApCisJUkVHX0wgeDIxLCBQVF9TNShzcCkKKwlSRUdfTCB4MjIsIFBUX1M2KHNwKQorCVJFR19M IHgyMywgUFRfUzcoc3ApCisJUkVHX0wgeDI0LCBQVF9TOChzcCkKKwlSRUdfTCB4MjUsIFBUX1M5 KHNwKQorCVJFR19MIHgyNiwgUFRfUzEwKHNwKQorCVJFR19MIHgyNywgUFRfUzExKHNwKQorCVJF R19MIHgyOCwgUFRfVDMoc3ApCisJUkVHX0wgeDI5LCBQVF9UNChzcCkKKwlSRUdfTCB4MzAsIFBU X1Q1KHNwKQorCVJFR19MIHgzMSwgUFRfVDYoc3ApCisJLmVuZG0KKworRU5UUlkoa3JldHByb2Jl X3RyYW1wb2xpbmUpCisJYWRkaSBzcCwgc3AsIC0oUFRfU0laRV9PTl9TVEFDSykKKwlzYXZlX2Fs bF9iYXNlX3JlZ3MKKworCW1vdmUgYTAsIHNwIC8qIHB0X3JlZ3MgKi8KKworCWNhbGwgdHJhbXBv bGluZV9wcm9iZV9oYW5kbGVyCisKKwkvKiB1c2UgdGhlIHJlc3VsdCBhcyB0aGUgcmV0dXJuLWFk ZHJlc3MgKi8KKwltb3ZlIHJhLCBhMAorCisJcmVzdG9yZV9hbGxfYmFzZV9yZWdzCisJYWRkaSBz cCwgc3AsIFBUX1NJWkVfT05fU1RBQ0sKKworCXJldAorRU5EUFJPQyhrcmV0cHJvYmVfdHJhbXBv bGluZSkKZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9zaW11bGF0ZS1pbnNu LmMgYi9hcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvc2ltdWxhdGUtaW5zbi5jCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwLi4yNTE5Y2UyCi0tLSAvZGV2L251bGwKKysrIGIvYXJj aC9yaXNjdi9rZXJuZWwvcHJvYmVzL3NpbXVsYXRlLWluc24uYwpAQCAtMCwwICsxLDg1IEBACisv LyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsKKworI2luY2x1ZGUgPGxpbnV4L2Jp dG9wcy5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2twcm9i ZXMuaD4KKworI2luY2x1ZGUgImRlY29kZS1pbnNuLmgiCisjaW5jbHVkZSAic2ltdWxhdGUtaW5z bi5oIgorCitzdGF0aWMgaW5saW5lIGJvb2wgcnZfaW5zbl9yZWdfZ2V0X3ZhbChzdHJ1Y3QgcHRf cmVncyAqcmVncywgdTMyIGluZGV4LAorCQkJCSAgICAgICB1bnNpZ25lZCBsb25nICpwdHIpCit7 CisJaWYgKGluZGV4ID09IDApCisJCSpwdHIgPSAwOworCWVsc2UgaWYgKGluZGV4IDw9IDMxKQor CQkqcHRyID0gKigodW5zaWduZWQgbG9uZyAqKXJlZ3MgKyBpbmRleCk7CisJZWxzZQorCQlyZXR1 cm4gZmFsc2U7CisKKwlyZXR1cm4gdHJ1ZTsKK30KKworc3RhdGljIGlubGluZSBib29sIHJ2X2lu c25fcmVnX3NldF92YWwoc3RydWN0IHB0X3JlZ3MgKnJlZ3MsIHUzMiBpbmRleCwKKwkJCQkgICAg ICAgdW5zaWduZWQgbG9uZyB2YWwpCit7CisJaWYgKGluZGV4ID09IDApCisJCXJldHVybiBmYWxz ZTsKKwllbHNlIGlmIChpbmRleCA8PSAzMSkKKwkJKigodW5zaWduZWQgbG9uZyAqKXJlZ3MgKyBp bmRleCkgPSB2YWw7CisJZWxzZQorCQlyZXR1cm4gZmFsc2U7CisKKwlyZXR1cm4gdHJ1ZTsKK30K KworYm9vbCBfX2twcm9iZXMgc2ltdWxhdGVfamFsKHUzMiBvcGNvZGUsIHVuc2lnbmVkIGxvbmcg YWRkciwgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJLyoKKwkgKiAgICAgMzEgICAgMzAgICAg ICAgMjEgICAgMjAgICAgIDE5ICAgICAgICAxMiAxMSA3IDYgICAgICAwCisJICogaW1tIFsyMF0g fCBpbW1bMTA6MV0gfCBpbW1bMTFdIHwgaW1tWzE5OjEyXSB8IHJkIHwgb3Bjb2RlCisJICogICAg IDEgICAgICAgICAxMCAgICAgICAgICAxICAgICAgICAgICA4ICAgICAgIDUgICAgSkFML0oKKwkg Ki8KKwlib29sIHJldDsKKwl1MzIgaW1tOworCXUzMiBpbmRleCA9IChvcGNvZGUgPj4gNykgJiAw eDFmOworCisJcmV0ID0gcnZfaW5zbl9yZWdfc2V0X3ZhbChyZWdzLCBpbmRleCwgYWRkciArIDQp OworCWlmICghcmV0KQorCQlyZXR1cm4gcmV0OworCisJaW1tICA9ICgob3Bjb2RlID4+IDIxKSAm IDB4M2ZmKSA8PCAxOworCWltbSB8PSAoKG9wY29kZSA+PiAyMCkgJiAweDEpICAgPDwgMTE7CisJ aW1tIHw9ICgob3Bjb2RlID4+IDEyKSAmIDB4ZmYpICA8PCAxMjsKKwlpbW0gfD0gKChvcGNvZGUg Pj4gMzEpICYgMHgxKSAgIDw8IDIwOworCisJaW5zdHJ1Y3Rpb25fcG9pbnRlcl9zZXQocmVncywg YWRkciArIHNpZ25fZXh0ZW5kMzIoKGltbSksIDIwKSk7CisKKwlyZXR1cm4gcmV0OworfQorCiti b29sIF9fa3Byb2JlcyBzaW11bGF0ZV9qYWxyKHUzMiBvcGNvZGUsIHVuc2lnbmVkIGxvbmcgYWRk ciwgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJLyoKKwkgKiAzMSAgICAgICAgICAyMCAxOSAx NSAxNCAxMiAxMSA3IDYgICAgICAwCisJICogIG9mZnNldFsxMTowXSB8IHJzMSB8IDAxMCB8IHJk IHwgb3Bjb2RlCisJICogICAgICAxMiAgICAgICAgIDUgICAgICAzICAgIDUgICAgSkFMUi9KUgor CSAqLworCWJvb2wgcmV0OworCXVuc2lnbmVkIGxvbmcgYmFzZV9hZGRyOworCXUzMiBpbW0gPSAo b3Bjb2RlID4+IDIwKSAmIDB4ZmZmOworCXUzMiByZF9pbmRleCA9IChvcGNvZGUgPj4gNykgJiAw eDFmOworCXUzMiByczFfaW5kZXggPSAob3Bjb2RlID4+IDE1KSAmIDB4MWY7CisKKwlyZXQgPSBy dl9pbnNuX3JlZ19zZXRfdmFsKHJlZ3MsIHJkX2luZGV4LCBhZGRyICsgNCk7CisJaWYgKCFyZXQp CisJCXJldHVybiByZXQ7CisKKwlyZXQgPSBydl9pbnNuX3JlZ19nZXRfdmFsKHJlZ3MsIHJzMV9p bmRleCwgJmJhc2VfYWRkcik7CisJaWYgKCFyZXQpCisJCXJldHVybiByZXQ7CisKKwlpbnN0cnVj dGlvbl9wb2ludGVyX3NldChyZWdzLCAoYmFzZV9hZGRyICsgc2lnbl9leHRlbmQzMigoaW1tKSwg MTEpKSZ+MSk7CisKKwlyZXR1cm4gcmV0OworfQpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJu ZWwvcHJvYmVzL3NpbXVsYXRlLWluc24uaCBiL2FyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9zaW11 bGF0ZS1pbnNuLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAuLmE2MmQ3ODQK LS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvc2ltdWxhdGUtaW5z bi5oCkBAIC0wLDAgKzEsNDcgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4w KyAqLworCisjaWZuZGVmIF9SSVNDVl9LRVJORUxfUFJPQkVTX1NJTVVMQVRFX0lOU05fSAorI2Rl ZmluZSBfUklTQ1ZfS0VSTkVMX1BST0JFU19TSU1VTEFURV9JTlNOX0gKKworI2RlZmluZSBfX1JJ U0NWX0lOU05fRlVOQ1MobmFtZSwgbWFzaywgdmFsKQkJCQlcCitzdGF0aWMgX19hbHdheXNfaW5s aW5lIGJvb2wgcmlzY3ZfaW5zbl9pc18jI25hbWUocHJvYmVfb3Bjb2RlX3QgY29kZSkJXAorewkJ CQkJCQkJCVwKKwlCVUlMRF9CVUdfT04ofihtYXNrKSAmICh2YWwpKTsJCQkJCVwKKwlyZXR1cm4g KGNvZGUgJiAobWFzaykpID09ICh2YWwpOwkJCQlcCit9CQkJCQkJCQkJXAorYm9vbCBzaW11bGF0 ZV8jI25hbWUodTMyIG9wY29kZSwgdW5zaWduZWQgbG9uZyBhZGRyLAkJCVwKKwkJICAgICBzdHJ1 Y3QgcHRfcmVncyAqcmVncyk7CisKKyNkZWZpbmUgUklTQ1ZfSU5TTl9SRUpFQ1RFRChuYW1lLCBj b2RlKQkJCQkJXAorCWRvIHsJCQkJCQkJCVwKKwkJaWYgKHJpc2N2X2luc25faXNfIyNuYW1lKGNv ZGUpKSB7CQkJXAorCQkJcmV0dXJuIElOU05fUkVKRUNURUQ7CQkJCVwKKwkJfQkJCQkJCQlcCisJ fSB3aGlsZSAoMCkKKworX19SSVNDVl9JTlNOX0ZVTkNTKHN5c3RlbSwJMHg3ZiwgMHg3MykKK19f UklTQ1ZfSU5TTl9GVU5DUyhmZW5jZSwJMHg3ZiwgMHgwZikKKworI2RlZmluZSBSSVNDVl9JTlNO X1NFVF9TSU1VTEFURShuYW1lLCBjb2RlKQkJCQlcCisJZG8gewkJCQkJCQkJXAorCQlpZiAocmlz Y3ZfaW5zbl9pc18jI25hbWUoY29kZSkpIHsJCQlcCisJCQlhcGktPmhhbmRsZXIgPSBzaW11bGF0 ZV8jI25hbWU7CQkJXAorCQkJcmV0dXJuIElOU05fR09PRF9OT19TTE9UOwkJCVwKKwkJfQkJCQkJ CQlcCisJfSB3aGlsZSAoMCkKKworX19SSVNDVl9JTlNOX0ZVTkNTKGNfaiwJCTB4ZTAwMywgMHhh MDAxKQorX19SSVNDVl9JTlNOX0ZVTkNTKGNfanIsCTB4ZjAwNywgMHg4MDAyKQorX19SSVNDVl9J TlNOX0ZVTkNTKGNfamFsLAkweGUwMDMsIDB4MjAwMSkKK19fUklTQ1ZfSU5TTl9GVU5DUyhjX2ph bHIsCTB4ZjAwNywgMHg5MDAyKQorX19SSVNDVl9JTlNOX0ZVTkNTKGNfYmVxeiwJMHhlMDAzLCAw eGMwMDEpCitfX1JJU0NWX0lOU05fRlVOQ1MoY19ibmV6LAkweGUwMDMsIDB4ZTAwMSkKK19fUklT Q1ZfSU5TTl9GVU5DUyhjX2VicmVhaywJMHhmZmZmLCAweDkwMDIpCisKK19fUklTQ1ZfSU5TTl9G VU5DUyhhdWlwYywJMHg3ZiwgMHgxNykKK19fUklTQ1ZfSU5TTl9GVU5DUyhicmFuY2gsCTB4N2Ys IDB4NjMpCisKK19fUklTQ1ZfSU5TTl9GVU5DUyhqYWwsCQkweDdmLCAweDZmKQorX19SSVNDVl9J TlNOX0ZVTkNTKGphbHIsCTB4NzA3ZiwgMHg2NykKKworI2VuZGlmIC8qIF9SSVNDVl9LRVJORUxf UFJPQkVTX1NJTVVMQVRFX0lOU05fSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJuZWwv dHJhcHMuYyBiL2FyY2gvcmlzY3Yva2VybmVsL3RyYXBzLmMKaW5kZXggZWNlYzE3Ny4uYWMyZTc4 NiAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9rZXJuZWwvdHJhcHMuYworKysgYi9hcmNoL3Jpc2N2 L2tlcm5lbC90cmFwcy5jCkBAIC0xMiw2ICsxMiw3IEBACiAjaW5jbHVkZSA8bGludXgvc2lnbmFs Lmg+CiAjaW5jbHVkZSA8bGludXgva2RlYnVnLmg+CiAjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5o PgorI2luY2x1ZGUgPGxpbnV4L2twcm9iZXMuaD4KICNpbmNsdWRlIDxsaW51eC9tbS5oPgogI2lu Y2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2lycS5oPgpAQCAtMTQ1LDYg KzE0NiwxNCBAQCBzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgZ2V0X2JyZWFrX2luc25fbGVu Z3RoKHVuc2lnbmVkIGxvbmcgcGMpCiAKIGFzbWxpbmthZ2UgX192aXNpYmxlIHZvaWQgZG9fdHJh cF9icmVhayhzdHJ1Y3QgcHRfcmVncyAqcmVncykKIHsKKyNpZmRlZiBDT05GSUdfS1BST0JFUwor CWlmIChrcHJvYmVfc2luZ2xlX3N0ZXBfaGFuZGxlcihyZWdzKSkKKwkJcmV0dXJuOworCisJaWYg KGtwcm9iZV9icmVha3BvaW50X2hhbmRsZXIocmVncykpCisJCXJldHVybjsKKyNlbmRpZgorCiAJ aWYgKHVzZXJfbW9kZShyZWdzKSkKIAkJZm9yY2Vfc2lnX2ZhdWx0KFNJR1RSQVAsIFRSQVBfQlJL UFQsICh2b2lkIF9fdXNlciAqKXJlZ3MtPmVwYyk7CiAjaWZkZWYgQ09ORklHX0tHREIKZGlmZiAt LWdpdCBhL2FyY2gvcmlzY3YvbW0vZmF1bHQuYyBiL2FyY2gvcmlzY3YvbW0vZmF1bHQuYwppbmRl eCBhZTdiN2ZlLi5kYTBjMDhjIDEwMDY0NAotLS0gYS9hcmNoL3Jpc2N2L21tL2ZhdWx0LmMKKysr IGIvYXJjaC9yaXNjdi9tbS9mYXVsdC5jCkBAIC0xMyw2ICsxMyw3IEBACiAjaW5jbHVkZSA8bGlu dXgvcGVyZl9ldmVudC5oPgogI2luY2x1ZGUgPGxpbnV4L3NpZ25hbC5oPgogI2luY2x1ZGUgPGxp bnV4L3VhY2Nlc3MuaD4KKyNpbmNsdWRlIDxsaW51eC9rcHJvYmVzLmg+CiAKICNpbmNsdWRlIDxh c20vcGdhbGxvYy5oPgogI2luY2x1ZGUgPGFzbS9wdHJhY2UuaD4KQEAgLTQwLDYgKzQxLDkgQEAg YXNtbGlua2FnZSB2b2lkIGRvX3BhZ2VfZmF1bHQoc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCiAJdHNr ID0gY3VycmVudDsKIAltbSA9IHRzay0+bW07CiAKKwlpZiAoa3Byb2JlX3BhZ2VfZmF1bHQocmVn cywgY2F1c2UpKQorCQlyZXR1cm47CisKIAkvKgogCSAqIEZhdWx0LWluIGtlcm5lbC1zcGFjZSB2 aXJ0dWFsIG1lbW9yeSBvbi1kZW1hbmQuCiAJICogVGhlICdyZWZlcmVuY2UnIHBhZ2UgdGFibGUg aXMgaW5pdF9tbS5wZ2QuCi0tIAoyLjcuNAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmxpbnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBs aXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlz dGluZm8vbGludXgtcmlzY3YK