From mboxrd@z Thu Jan 1 00:00:00 1970 From: me@packi.ch (=?UTF-8?q?Patrick=20St=C3=A4hlin?=) Date: Tue, 13 Nov 2018 20:58:04 +0100 Subject: [RFC/RFT 2/2] RISC-V: kprobes/kretprobe support In-Reply-To: <20181113195804.22825-1-me@packi.ch> References: <20181113195804.22825-1-me@packi.ch> Message-ID: <20181113195804.22825-3-me@packi.ch> To: linux-riscv@lists.infradead.org List-Id: linux-riscv.lists.infradead.org First implementation, adapted from arm64. The C.ADDISP16 instruction gets simulated and the kprobes-handler called by inserting a C.EBREAK instruction. C.ADDISP16 was chosen as it sets-up the stack frame for functions. Some work has been done to support probes on non-compressed instructions but there is no support yet for decoding those. The way forward should be to uncompress the instructions for simulation to reduce the number of instructions used to decode the immediate values on probe hit. Signed-off-by: Patrick St?hlin --- arch/riscv/Kconfig | 5 +- arch/riscv/include/asm/kprobes.h | 30 ++ arch/riscv/include/asm/probes.h | 26 ++ arch/riscv/kernel/Makefile | 1 + arch/riscv/kernel/probes/Makefile | 3 + arch/riscv/kernel/probes/decode-insn.c | 38 ++ arch/riscv/kernel/probes/decode-insn.h | 23 + arch/riscv/kernel/probes/kprobes.c | 401 ++++++++++++++++++ arch/riscv/kernel/probes/kprobes_trampoline.S | 91 ++++ arch/riscv/kernel/probes/simulate-insn.c | 33 ++ arch/riscv/kernel/probes/simulate-insn.h | 8 + arch/riscv/kernel/traps.c | 13 +- arch/riscv/mm/fault.c | 28 +- 13 files changed, 694 insertions(+), 6 deletions(-) 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 b157ac82d486..11ef4030e8f2 100644 --- a/arch/riscv/Kconfig +++ b/arch/riscv/Kconfig @@ -44,6 +44,8 @@ config RISCV select GENERIC_IRQ_MULTI_HANDLER select ARCH_HAS_PTE_SPECIAL select HAVE_REGS_AND_STACK_ACCESS_API + select HAVE_KPROBES + select HAVE_KRETPROBES config MMU def_bool y @@ -89,9 +91,6 @@ config PGTABLE_LEVELS default 3 if 64BIT default 2 -config HAVE_KPROBES - def_bool n - menu "Platform type" choice diff --git a/arch/riscv/include/asm/kprobes.h b/arch/riscv/include/asm/kprobes.h index c7eb010d1528..657adcd35a3d 100644 --- a/arch/riscv/include/asm/kprobes.h +++ b/arch/riscv/include/asm/kprobes.h @@ -19,4 +19,34 @@ #include +#ifdef CONFIG_KPROBES +#include +#include +#include + +#define flush_insn_slot(p) do { } while (0) +#define kretprobe_blacklist_size 0 + +#include + +struct prev_kprobe { + struct kprobe *kp; + unsigned int status; +}; + +/* per-cpu kprobe control block */ +struct kprobe_ctlblk { + unsigned int kprobe_status; + struct prev_kprobe prev_kprobe; +}; + +void arch_remove_kprobe(struct kprobe *p); +int kprobe_fault_handler(struct pt_regs *regs, unsigned int cause); +int kprobe_exceptions_notify(struct notifier_block *self, + unsigned long val, void *data); +int kprobe_breakpoint_handler(struct pt_regs *regs); +void kretprobe_trampoline(void); +void __kprobes *trampoline_probe_handler(struct pt_regs *regs); + +#endif /* CONFIG_KPROBES */ #endif /* _RISCV_KPROBES_H */ diff --git a/arch/riscv/include/asm/probes.h b/arch/riscv/include/asm/probes.h new file mode 100644 index 000000000000..64cf12567539 --- /dev/null +++ b/arch/riscv/include/asm/probes.h @@ -0,0 +1,26 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Based on arch/arm64/include/asm/probes.h + * + * Copyright (C) 2013 Linaro Limited + */ +#ifndef _RISCV_PROBES_H +#define _RISCV_PROBES_H + +typedef u32 probe_opcode_t; +typedef void (probes_handler_t) (u32 opcode, long addr, struct pt_regs *); + +/* architecture specific copy of original instruction */ +struct arch_probe_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 /* _RISCV_PROBES_H */ diff --git a/arch/riscv/kernel/Makefile b/arch/riscv/kernel/Makefile index f13f7f276639..5360a445b9d3 100644 --- a/arch/riscv/kernel/Makefile +++ b/arch/riscv/kernel/Makefile @@ -28,6 +28,7 @@ obj-y += stacktrace.o obj-y += vdso.o obj-y += cacheinfo.o obj-y += vdso/ +obj-y += probes/ CFLAGS_setup.o := -mcmodel=medany diff --git a/arch/riscv/kernel/probes/Makefile b/arch/riscv/kernel/probes/Makefile new file mode 100644 index 000000000000..144d1c1743fb --- /dev/null +++ b/arch/riscv/kernel/probes/Makefile @@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0 +obj-$(CONFIG_KPROBES) += kprobes.o kprobes_trampoline.o \ + decode-insn.o simulate-insn.o diff --git a/arch/riscv/kernel/probes/decode-insn.c b/arch/riscv/kernel/probes/decode-insn.c new file mode 100644 index 000000000000..2d8f46f4c2e7 --- /dev/null +++ b/arch/riscv/kernel/probes/decode-insn.c @@ -0,0 +1,38 @@ +// SPDX-License-Identifier: GPL-2.0+ + +#include +#include +#include +#include +#include + +#include "decode-insn.h" +#include "simulate-insn.h" + +#define C_ADDISP16_MASK 0x6F83 +#define C_ADDISP16_VAL 0x6101 + +/* 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(kprobe_opcode_t *addr, struct arch_probe_insn *api) +{ + probe_opcode_t insn = le32_to_cpu(*addr); + + if (!is_compressed_insn(insn)) { + pr_warn("Can't handle non-compressed instruction %x\n", insn); + return INSN_REJECTED; + } + + /* c.addisp16 imm */ + if ((insn & C_ADDISP16_MASK) == C_ADDISP16_VAL) { + api->handler = simulate_caddisp16; + } else { + pr_warn("Rejected unknown instruction %x\n", insn); + return INSN_REJECTED; + } + + return INSN_GOOD_NO_SLOT; +} diff --git a/arch/riscv/kernel/probes/decode-insn.h b/arch/riscv/kernel/probes/decode-insn.h new file mode 100644 index 000000000000..0053ed6a308a --- /dev/null +++ b/arch/riscv/kernel/probes/decode-insn.h @@ -0,0 +1,23 @@ +/* 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, +}; + +/* + * Compressed instruction format: + * xxxxxxxxxxxxxxaa where aa != 11 + */ +#define is_compressed_insn(insn) ((insn & 0x3) != 0x3) + +#ifdef CONFIG_KPROBES +enum probe_insn __kprobes +riscv_probe_decode_insn(kprobe_opcode_t *addr, struct arch_probe_insn *asi); +#endif +#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 000000000000..3c7b5cf72ee1 --- /dev/null +++ b/arch/riscv/kernel/probes/kprobes.c @@ -0,0 +1,401 @@ +// SPDX-License-Identifier: GPL-2.0+ + +/* + * Kprobes support for RISC-V + * + * Author: Patrick St?hlin + */ +#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 int __kprobes patch_text(kprobe_opcode_t *addr, u32 opcode) +{ + if (is_compressed_insn(opcode)) + *(u16 *)addr = cpu_to_le16(opcode); + else + *addr = cpu_to_le32(opcode); + + return 0; +} + +static void __kprobes arch_prepare_simulate(struct kprobe *p) +{ + unsigned long offset = is_compressed_insn(p->opcode) ? 2 : 4; + + p->ainsn.api.restore = (unsigned long)p->addr + offset; +} + +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, (long)p->addr, regs); + + /* single instruction simulated, now go for post processing */ + post_kprobe_handler(kcb, regs); +} + +int __kprobes arch_prepare_kprobe(struct kprobe *p) +{ + unsigned long probe_addr = (unsigned long)p->addr; + extern char __start_rodata[]; + extern char __end_rodata[]; + + if (probe_addr & 0x1) { + pr_warn("Address not aligned.\n"); + return -EINVAL; + } + + /* copy instruction */ + p->opcode = le32_to_cpu(*p->addr); + + if (probe_addr >= (unsigned long) __start_rodata && + probe_addr <= (unsigned long) __end_rodata) { + return -EINVAL; + } + + /* 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 needs simulation */ + break; + } + + arch_prepare_simulate(p); + + return 0; +} + +#define C_EBREAK_OPCODE 0x9002 + +/* arm kprobe: install breakpoint in text */ +void __kprobes arch_arm_kprobe(struct kprobe *p) +{ + patch_text(p->addr, C_EBREAK_OPCODE); +} + +/* disarm kprobe: 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); +} + +static void __kprobes simulate(struct kprobe *p, + struct pt_regs *regs, + struct kprobe_ctlblk *kcb, int reenter) +{ + if (reenter) { + save_previous_kprobe(kcb); + set_current_kprobe(p); + kcb->kprobe_status = KPROBE_REENTER; + } else { + kcb->kprobe_status = KPROBE_HIT_SS; + } + + 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); + simulate(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) + instruction_pointer_set(regs, 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 cause) +{ + 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. + */ + instruction_pointer_set(regs, (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, cause)) + return 1; + + /* + * In case the user-specified fault handler returned + * zero, try to fix up. + */ + if (fixup_exception(regs)) + return 1; + } + return 0; +} + +static void __kprobes kprobe_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; + } 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, keep PSTATE D-flag enabled until + * pre_handler return back. + */ + if (!p->pre_handler || !p->pre_handler(p, regs)) + simulate(p, regs, kcb, 0); + else + reset_current_kprobe(); + } + } + /* + * 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. + */ +} + +int __kprobes +kprobe_breakpoint_handler(struct pt_regs *regs) +{ + kprobe_handler(regs); + return 1; +} + +bool arch_within_kprobe_blacklist(unsigned long addr) +{ + if ((addr >= (unsigned long)__kprobes_text_start && + addr < (unsigned long)__kprobes_text_end) || + (addr >= (unsigned long)__entry_text_start && + addr < (unsigned long)__entry_text_end) || + !!search_exception_tables(addr)) + return true; + + return false; +} + +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 = (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 000000000000..c7ceda9556a3 --- /dev/null +++ b/arch/riscv/kernel/probes/kprobes_trampoline.S @@ -0,0 +1,91 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ + +#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 000000000000..5734d9bae22f --- /dev/null +++ b/arch/riscv/kernel/probes/simulate-insn.c @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: GPL-2.0+ + +#include +#include +#include + +#include "simulate-insn.h" + +#define bit_at(value, bit) ((value) & (1 << (bit))) +#define move_bit_at(value, bit, to) ((bit_at(value, bit) >> bit) << to) + +void __kprobes +simulate_caddisp16(u32 opcode, long addr, struct pt_regs *regs) +{ + s16 imm; + + /* + * Immediate value layout in c.addisp16: + * xxx9 xxxx x468 75xx + * 1 1 8 4 0 + * 5 2 + */ + imm = sign_extend32( + move_bit_at(opcode, 12, 9) | + move_bit_at(opcode, 6, 4) | + move_bit_at(opcode, 5, 6) | + move_bit_at(opcode, 4, 8) | + move_bit_at(opcode, 3, 7) | + move_bit_at(opcode, 2, 5), + 9); + + regs->sp += imm; +} diff --git a/arch/riscv/kernel/probes/simulate-insn.h b/arch/riscv/kernel/probes/simulate-insn.h new file mode 100644 index 000000000000..dc2c06c30167 --- /dev/null +++ b/arch/riscv/kernel/probes/simulate-insn.h @@ -0,0 +1,8 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ + +#ifndef _RISCV_KERNEL_KPROBES_SIMULATE_INSN_H +#define _RISCV_KERNEL_KPROBES_SIMULATE_INSN_H + +void simulate_caddisp16(u32 opcode, long addr, struct pt_regs *regs); + +#endif /* _RISCV_KERNEL_KPROBES_SIMULATE_INSN_H */ diff --git a/arch/riscv/kernel/traps.c b/arch/riscv/kernel/traps.c index 24a9333dda2c..d7113178d401 100644 --- a/arch/riscv/kernel/traps.c +++ b/arch/riscv/kernel/traps.c @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -120,8 +121,14 @@ DO_ERROR_INFO(do_trap_ecall_m, asmlinkage void do_trap_break(struct pt_regs *regs) { + bool handler_found = false; + +#ifdef CONFIG_KPROBES + if (kprobe_breakpoint_handler(regs)) + handler_found = 1; +#endif #ifdef CONFIG_GENERIC_BUG - if (!user_mode(regs)) { + if (!handler_found && !user_mode(regs)) { enum bug_trap_type type; type = report_bug(regs->sepc, regs); @@ -137,7 +144,9 @@ asmlinkage void do_trap_break(struct pt_regs *regs) } #endif /* CONFIG_GENERIC_BUG */ - force_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *)(regs->sepc), current); + if (!handler_found) + force_sig_fault(SIGTRAP, TRAP_BRKPT, + (void __user *)(regs->sepc), current); } #ifdef CONFIG_GENERIC_BUG diff --git a/arch/riscv/mm/fault.c b/arch/riscv/mm/fault.c index 88401d5125bc..eff816e33479 100644 --- a/arch/riscv/mm/fault.c +++ b/arch/riscv/mm/fault.c @@ -22,6 +22,7 @@ #include #include +#include #include #include #include @@ -30,11 +31,33 @@ #include #include +#ifdef CONFIG_KPROBES +static inline int notify_page_fault(struct pt_regs *regs, unsigned int cause) +{ + int ret = 0; + + /* kprobe_running() needs smp_processor_id() */ + if (!user_mode(regs)) { + preempt_disable(); + if (kprobe_running() && kprobe_fault_handler(regs, cause)) + ret = 1; + preempt_enable(); + } + + return ret; +} +#else +static inline int notify_page_fault(struct pt_regs *regs, unsigned int cause) +{ + return 0; +} +#endif + /* * This routine handles page faults. It determines the address and the * problem, and then passes it off to one of the appropriate routines. */ -asmlinkage void do_page_fault(struct pt_regs *regs) +asmlinkage void __kprobes do_page_fault(struct pt_regs *regs) { struct task_struct *tsk; struct vm_area_struct *vma; @@ -47,6 +70,9 @@ asmlinkage void do_page_fault(struct pt_regs *regs) cause = regs->scause; addr = regs->sbadaddr; + if (notify_page_fault(regs, cause)) + return; + tsk = current; mm = tsk->mm; -- 2.17.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-10.5 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED,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 B7B64C43441 for ; Tue, 13 Nov 2018 19:59:05 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id 8502B223C8 for ; Tue, 13 Nov 2018 19:59:05 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="QVQ5wdMm" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8502B223C8 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=packi.ch Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-riscv-bounces+infradead-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=bombadil.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=dVOVC5ypP+qBNV/h/RMvR9QIXji3CZpD/pg0YQNV5gQ=; b=QVQ5wdMmboqdBs 90H5np3BeR/pAIZiZHlLBhQQtKMSfxYHDOZ7Ik4BROy7VS+akVqV6nT4C6y7Cw0yG0Q/yCa6TTJRW 1ae+Xqw5qJ8eWeUk2OL7jq6N3zeNYo7EZLTaZWCgJRe+K/nvMcWsuSEleFFyIvyy8m4v14DI5tUWP zS+77aXhmYm31m8EwgUyg4hFkF/CkzFpBqwj5aHYtrNDmAiKnun2QLUj6eXMEk03qLFro1gYLc9KC KbVQqA1VwT50JptlBROFaava+wytE6DD7tPBeYm7Zf+CnZtcqjlcW33rbDQaNe5JlIYQT8FF8LJHR qxqOR41W6AZefmdqj8bw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gMeq0-0002k2-Qu; Tue, 13 Nov 2018 19:59:04 +0000 Received: from mail.binarylogic.ch ([2a01:4f8:222:24c1::ff02]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1gMepw-0002iG-GF for linux-riscv@lists.infradead.org; Tue, 13 Nov 2018 19:59:03 +0000 Received: from fortknox.localdomain (unknown [192.168.122.1]) by mail.binarylogic.ch (Postfix) with ESMTP id DA6C7DF700; Tue, 13 Nov 2018 20:58:47 +0100 (CET) From: =?UTF-8?q?Patrick=20St=C3=A4hlin?= To: linux-riscv@lists.infradead.org Subject: [RFC/RFT 2/2] RISC-V: kprobes/kretprobe support Date: Tue, 13 Nov 2018 20:58:04 +0100 Message-Id: <20181113195804.22825-3-me@packi.ch> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20181113195804.22825-1-me@packi.ch> References: <20181113195804.22825-1-me@packi.ch> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20181113_115900_939423_9FD2A516 X-CRM114-Status: GOOD ( 21.51 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Patrick=20St=C3=A4hlin?= , Albert Ou , Anders Roxell , Andrew Morton , Alan Kao , Catalin Marinas , Palmer Dabbelt , Will Deacon , linux-kernel@vger.kernel.org, Al Viro , Souptick Joarder , Zong Li , Masami Hiramatsu , Thomas Gleixner , Jim Wilson , zhong jiang , Ingo Molnar , Luc Van Oostenryck , "Eric W. Biederman" Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+infradead-linux-riscv=archiver.kernel.org@lists.infradead.org Message-ID: <20181113195804.sdtGHxu206r7zM-8hn36xmr_t5eB8z5V1nMsOn35axI@z> Rmlyc3QgaW1wbGVtZW50YXRpb24sIGFkYXB0ZWQgZnJvbSBhcm02NC4gVGhlIEMuQURESVNQMTYg aW5zdHJ1Y3Rpb24KZ2V0cyBzaW11bGF0ZWQgYW5kIHRoZSBrcHJvYmVzLWhhbmRsZXIgY2FsbGVk IGJ5IGluc2VydGluZyBhIEMuRUJSRUFLCmluc3RydWN0aW9uLgoKQy5BRERJU1AxNiB3YXMgY2hv c2VuIGFzIGl0IHNldHMtdXAgdGhlIHN0YWNrIGZyYW1lIGZvciBmdW5jdGlvbnMuClNvbWUgd29y ayBoYXMgYmVlbiBkb25lIHRvIHN1cHBvcnQgcHJvYmVzIG9uIG5vbi1jb21wcmVzc2VkCmluc3Ry dWN0aW9ucyBidXQgdGhlcmUgaXMgbm8gc3VwcG9ydCB5ZXQgZm9yIGRlY29kaW5nIHRob3NlLgoK VGhlIHdheSBmb3J3YXJkIHNob3VsZCBiZSB0byB1bmNvbXByZXNzIHRoZSBpbnN0cnVjdGlvbnMg Zm9yIHNpbXVsYXRpb24KdG8gcmVkdWNlIHRoZSBudW1iZXIgb2YgaW5zdHJ1Y3Rpb25zIHVzZWQg dG8gZGVjb2RlIHRoZSBpbW1lZGlhdGUKdmFsdWVzIG9uIHByb2JlIGhpdC4KClNpZ25lZC1vZmYt Ynk6IFBhdHJpY2sgU3TDpGhsaW4gPG1lQHBhY2tpLmNoPgotLS0KIGFyY2gvcmlzY3YvS2NvbmZp ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgNSArLQogYXJjaC9yaXNjdi9pbmNsdWRl L2FzbS9rcHJvYmVzLmggICAgICAgICAgICAgIHwgIDMwICsrCiBhcmNoL3Jpc2N2L2luY2x1ZGUv YXNtL3Byb2Jlcy5oICAgICAgICAgICAgICAgfCAgMjYgKysKIGFyY2gvcmlzY3Yva2VybmVsL01h a2VmaWxlICAgICAgICAgICAgICAgICAgICB8ICAgMSArCiBhcmNoL3Jpc2N2L2tlcm5lbC9wcm9i ZXMvTWFrZWZpbGUgICAgICAgICAgICAgfCAgIDMgKwogYXJjaC9yaXNjdi9rZXJuZWwvcHJvYmVz L2RlY29kZS1pbnNuLmMgICAgICAgIHwgIDM4ICsrCiBhcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMv ZGVjb2RlLWluc24uaCAgICAgICAgfCAgMjMgKwogYXJjaC9yaXNjdi9rZXJuZWwvcHJvYmVzL2tw cm9iZXMuYyAgICAgICAgICAgIHwgNDAxICsrKysrKysrKysrKysrKysrKwogYXJjaC9yaXNjdi9r ZXJuZWwvcHJvYmVzL2twcm9iZXNfdHJhbXBvbGluZS5TIHwgIDkxICsrKysKIGFyY2gvcmlzY3Yv a2VybmVsL3Byb2Jlcy9zaW11bGF0ZS1pbnNuLmMgICAgICB8ICAzMyArKwogYXJjaC9yaXNjdi9r ZXJuZWwvcHJvYmVzL3NpbXVsYXRlLWluc24uaCAgICAgIHwgICA4ICsKIGFyY2gvcmlzY3Yva2Vy bmVsL3RyYXBzLmMgICAgICAgICAgICAgICAgICAgICB8ICAxMyArLQogYXJjaC9yaXNjdi9tbS9m YXVsdC5jICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDI4ICstCiAxMyBmaWxlcyBjaGFuZ2Vk LCA2OTQgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBh cmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3Byb2Jlcy5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgYXJjaC9y aXNjdi9rZXJuZWwvcHJvYmVzL01ha2VmaWxlCiBjcmVhdGUgbW9kZSAxMDA2NDQgYXJjaC9yaXNj di9rZXJuZWwvcHJvYmVzL2RlY29kZS1pbnNuLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL3Jp c2N2L2tlcm5lbC9wcm9iZXMvZGVjb2RlLWluc24uaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGFyY2gv cmlzY3Yva2VybmVsL3Byb2Jlcy9rcHJvYmVzLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL3Jp c2N2L2tlcm5lbC9wcm9iZXMva3Byb2Jlc190cmFtcG9saW5lLlMKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBhcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvc2ltdWxhdGUtaW5zbi5jCiBjcmVhdGUgbW9kZSAx MDA2NDQgYXJjaC9yaXNjdi9rZXJuZWwvcHJvYmVzL3NpbXVsYXRlLWluc24uaAoKZGlmZiAtLWdp dCBhL2FyY2gvcmlzY3YvS2NvbmZpZyBiL2FyY2gvcmlzY3YvS2NvbmZpZwppbmRleCBiMTU3YWM4 MmQ0ODYuLjExZWY0MDMwZThmMiAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9LY29uZmlnCisrKyBi L2FyY2gvcmlzY3YvS2NvbmZpZwpAQCAtNDQsNiArNDQsOCBAQCBjb25maWcgUklTQ1YKIAlzZWxl Y3QgR0VORVJJQ19JUlFfTVVMVElfSEFORExFUgogCXNlbGVjdCBBUkNIX0hBU19QVEVfU1BFQ0lB TAogCXNlbGVjdCBIQVZFX1JFR1NfQU5EX1NUQUNLX0FDQ0VTU19BUEkKKwlzZWxlY3QgSEFWRV9L UFJPQkVTCisJc2VsZWN0IEhBVkVfS1JFVFBST0JFUwogCiBjb25maWcgTU1VCiAJZGVmX2Jvb2wg eQpAQCAtODksOSArOTEsNiBAQCBjb25maWcgUEdUQUJMRV9MRVZFTFMKIAlkZWZhdWx0IDMgaWYg NjRCSVQKIAlkZWZhdWx0IDIKIAotY29uZmlnIEhBVkVfS1BST0JFUwotCWRlZl9ib29sIG4KLQog bWVudSAiUGxhdGZvcm0gdHlwZSIKIAogY2hvaWNlCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2lu Y2x1ZGUvYXNtL2twcm9iZXMuaCBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20va3Byb2Jlcy5oCmlu ZGV4IGM3ZWIwMTBkMTUyOC4uNjU3YWRjZDM1YTNkIDEwMDY0NAotLS0gYS9hcmNoL3Jpc2N2L2lu Y2x1ZGUvYXNtL2twcm9iZXMuaAorKysgYi9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL2twcm9iZXMu aApAQCAtMTksNCArMTksMzQgQEAKIAogI2luY2x1ZGUgPGFzbS1nZW5lcmljL2twcm9iZXMuaD4K IAorI2lmZGVmIENPTkZJR19LUFJPQkVTCisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNs dWRlIDxsaW51eC9wdHJhY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9wZXJjcHUuaD4KKworI2RlZmlu ZSBmbHVzaF9pbnNuX3Nsb3QocCkJCWRvIHsgfSB3aGlsZSAoMCkKKyNkZWZpbmUga3JldHByb2Jl X2JsYWNrbGlzdF9zaXplCTAKKworI2luY2x1ZGUgPGFzbS9wcm9iZXMuaD4KKworc3RydWN0IHBy ZXZfa3Byb2JlIHsKKwlzdHJ1Y3Qga3Byb2JlICprcDsKKwl1bnNpZ25lZCBpbnQgc3RhdHVzOwor fTsKKworLyogcGVyLWNwdSBrcHJvYmUgY29udHJvbCBibG9jayAqLworc3RydWN0IGtwcm9iZV9j dGxibGsgeworCXVuc2lnbmVkIGludCBrcHJvYmVfc3RhdHVzOworCXN0cnVjdCBwcmV2X2twcm9i ZSBwcmV2X2twcm9iZTsKK307CisKK3ZvaWQgYXJjaF9yZW1vdmVfa3Byb2JlKHN0cnVjdCBrcHJv YmUgKnApOworaW50IGtwcm9iZV9mYXVsdF9oYW5kbGVyKHN0cnVjdCBwdF9yZWdzICpyZWdzLCB1 bnNpZ25lZCBpbnQgY2F1c2UpOworaW50IGtwcm9iZV9leGNlcHRpb25zX25vdGlmeShzdHJ1Y3Qg bm90aWZpZXJfYmxvY2sgKnNlbGYsCisJCQkgICAgIHVuc2lnbmVkIGxvbmcgdmFsLCB2b2lkICpk YXRhKTsKK2ludCBrcHJvYmVfYnJlYWtwb2ludF9oYW5kbGVyKHN0cnVjdCBwdF9yZWdzICpyZWdz KTsKK3ZvaWQga3JldHByb2JlX3RyYW1wb2xpbmUodm9pZCk7Cit2b2lkIF9fa3Byb2JlcyAqdHJh bXBvbGluZV9wcm9iZV9oYW5kbGVyKHN0cnVjdCBwdF9yZWdzICpyZWdzKTsKKworI2VuZGlmIC8q IENPTkZJR19LUFJPQkVTICovCiAjZW5kaWYgLyogX1JJU0NWX0tQUk9CRVNfSCAqLwpkaWZmIC0t Z2l0IGEvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9wcm9iZXMuaCBiL2FyY2gvcmlzY3YvaW5jbHVk ZS9hc20vcHJvYmVzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi42 NGNmMTI1Njc1MzkKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3By b2Jlcy5oCkBAIC0wLDAgKzEsMjYgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwt Mi4wICovCisvKgorICogQmFzZWQgb24gYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9wcm9iZXMuaAor ICoKKyAqIENvcHlyaWdodCAoQykgMjAxMyBMaW5hcm8gTGltaXRlZAorICovCisjaWZuZGVmIF9S SVNDVl9QUk9CRVNfSAorI2RlZmluZSBfUklTQ1ZfUFJPQkVTX0gKKwordHlwZWRlZiB1MzIgcHJv YmVfb3Bjb2RlX3Q7Cit0eXBlZGVmIHZvaWQgKHByb2Jlc19oYW5kbGVyX3QpICh1MzIgb3Bjb2Rl LCBsb25nIGFkZHIsIHN0cnVjdCBwdF9yZWdzICopOworCisvKiBhcmNoaXRlY3R1cmUgc3BlY2lm aWMgY29weSBvZiBvcmlnaW5hbCBpbnN0cnVjdGlvbiAqLworc3RydWN0IGFyY2hfcHJvYmVfaW5z biB7CisJcHJvYmVzX2hhbmRsZXJfdCAqaGFuZGxlcjsKKwkvKiByZXN0b3JlIGFkZHJlc3MgYWZ0 ZXIgc2ltdWxhdGlvbiAqLworCXVuc2lnbmVkIGxvbmcgcmVzdG9yZTsKK307CisjaWZkZWYgQ09O RklHX0tQUk9CRVMKK3R5cGVkZWYgdTMyIGtwcm9iZV9vcGNvZGVfdDsKK3N0cnVjdCBhcmNoX3Nw ZWNpZmljX2luc24geworCXN0cnVjdCBhcmNoX3Byb2JlX2luc24gYXBpOworfTsKKyNlbmRpZgor CisjZW5kaWYgLyogX1JJU0NWX1BST0JFU19IICovCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2tl cm5lbC9NYWtlZmlsZSBiL2FyY2gvcmlzY3Yva2VybmVsL01ha2VmaWxlCmluZGV4IGYxM2Y3ZjI3 NjYzOS4uNTM2MGE0NDViOWQzIDEwMDY0NAotLS0gYS9hcmNoL3Jpc2N2L2tlcm5lbC9NYWtlZmls ZQorKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9NYWtlZmlsZQpAQCAtMjgsNiArMjgsNyBAQCBvYmot eQkrPSBzdGFja3RyYWNlLm8KIG9iai15CSs9IHZkc28ubwogb2JqLXkJKz0gY2FjaGVpbmZvLm8K IG9iai15CSs9IHZkc28vCitvYmoteQkrPSBwcm9iZXMvCiAKIENGTEFHU19zZXR1cC5vIDo9IC1t Y21vZGVsPW1lZGFueQogCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvTWFr ZWZpbGUgYi9hcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xNDRkMWMxNzQzZmIKLS0tIC9kZXYvbnVsbAorKysg Yi9hcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvTWFrZWZpbGUKQEAgLTAsMCArMSwzIEBACisjIFNQ RFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCitvYmotJChDT05GSUdfS1BST0JFUykJCSs9 IGtwcm9iZXMubyBrcHJvYmVzX3RyYW1wb2xpbmUubyBcCisJCQkJICAgZGVjb2RlLWluc24ubyBz aW11bGF0ZS1pbnNuLm8KZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9kZWNv ZGUtaW5zbi5jIGIvYXJjaC9yaXNjdi9rZXJuZWwvcHJvYmVzL2RlY29kZS1pbnNuLmMKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4yZDhmNDZmNGMyZTcKLS0tIC9kZXYv bnVsbAorKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvZGVjb2RlLWluc24uYwpAQCAtMCww ICsxLDM4IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsKKworI2luY2x1 ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2twcm9iZXMuaD4KKyNpbmNsdWRl IDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9rYWxsc3ltcy5oPgorI2luY2x1ZGUg PGFzbS9zZWN0aW9ucy5oPgorCisjaW5jbHVkZSAiZGVjb2RlLWluc24uaCIKKyNpbmNsdWRlICJz aW11bGF0ZS1pbnNuLmgiCisKKyNkZWZpbmUgQ19BRERJU1AxNl9NQVNLIDB4NkY4MworI2RlZmlu ZSBDX0FERElTUDE2X1ZBTCAgMHg2MTAxCisKKy8qIFJldHVybjoKKyAqICAgSU5TTl9SRUpFQ1RF RCAgICAgSWYgaW5zdHJ1Y3Rpb24gaXMgb25lIG5vdCBhbGxvd2VkIHRvIGtwcm9iZSwKKyAqICAg SU5TTl9HT09EX05PX1NMT1QgSWYgaW5zdHJ1Y3Rpb24gaXMgc3VwcG9ydGVkIGJ1dCBkb2Vzbid0 IHVzZSBpdHMgc2xvdC4KKyAqLworZW51bSBwcm9iZV9pbnNuIF9fa3Byb2JlcworcmlzY3ZfcHJv YmVfZGVjb2RlX2luc24oa3Byb2JlX29wY29kZV90ICphZGRyLCBzdHJ1Y3QgYXJjaF9wcm9iZV9p bnNuICphcGkpCit7CisJcHJvYmVfb3Bjb2RlX3QgaW5zbiA9IGxlMzJfdG9fY3B1KCphZGRyKTsK KworCWlmICghaXNfY29tcHJlc3NlZF9pbnNuKGluc24pKSB7CisJCXByX3dhcm4oIkNhbid0IGhh bmRsZSBub24tY29tcHJlc3NlZCBpbnN0cnVjdGlvbiAleFxuIiwgaW5zbik7CisJCXJldHVybiBJ TlNOX1JFSkVDVEVEOworCX0KKworCS8qIGMuYWRkaXNwMTYgaW1tICovCisJaWYgKChpbnNuICYg Q19BRERJU1AxNl9NQVNLKSA9PSBDX0FERElTUDE2X1ZBTCkgeworCQlhcGktPmhhbmRsZXIgPSBz aW11bGF0ZV9jYWRkaXNwMTY7CisJfSBlbHNlIHsKKwkJcHJfd2FybigiUmVqZWN0ZWQgdW5rbm93 biBpbnN0cnVjdGlvbiAleFxuIiwgaW5zbik7CisJCXJldHVybiBJTlNOX1JFSkVDVEVEOworCX0K KworCXJldHVybiBJTlNOX0dPT0RfTk9fU0xPVDsKK30KZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3Yv a2VybmVsL3Byb2Jlcy9kZWNvZGUtaW5zbi5oIGIvYXJjaC9yaXNjdi9rZXJuZWwvcHJvYmVzL2Rl Y29kZS1pbnNuLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4wMDUz ZWQ2YTMwOGEKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvZGVj b2RlLWluc24uaApAQCAtMCwwICsxLDIzIEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog R1BMLTIuMCsgKi8KKyNpZm5kZWYgX1JJU0NWX0tFUk5FTF9LUFJPQkVTX0RFQ09ERV9JTlNOX0gK KyNkZWZpbmUgX1JJU0NWX0tFUk5FTF9LUFJPQkVTX0RFQ09ERV9JTlNOX0gKKworI2luY2x1ZGUg PGFzbS9zZWN0aW9ucy5oPgorI2luY2x1ZGUgPGFzbS9rcHJvYmVzLmg+CisKK2VudW0gcHJvYmVf aW5zbiB7CisJSU5TTl9SRUpFQ1RFRCwKKwlJTlNOX0dPT0RfTk9fU0xPVCwKK307CisKKy8qCisg KiBDb21wcmVzc2VkIGluc3RydWN0aW9uIGZvcm1hdDoKKyAqIHh4eHh4eHh4eHh4eHh4YWEgd2hl cmUgYWEgIT0gMTEKKyAqLworI2RlZmluZSBpc19jb21wcmVzc2VkX2luc24oaW5zbikgKChpbnNu ICYgMHgzKSAhPSAweDMpCisKKyNpZmRlZiBDT05GSUdfS1BST0JFUworZW51bSBwcm9iZV9pbnNu IF9fa3Byb2JlcworcmlzY3ZfcHJvYmVfZGVjb2RlX2luc24oa3Byb2JlX29wY29kZV90ICphZGRy LCBzdHJ1Y3QgYXJjaF9wcm9iZV9pbnNuICphc2kpOworI2VuZGlmCisjZW5kaWYgLyogX1JJU0NW X0tFUk5FTF9LUFJPQkVTX0RFQ09ERV9JTlNOX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3Yv a2VybmVsL3Byb2Jlcy9rcHJvYmVzLmMgYi9hcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMva3Byb2Jl cy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uM2M3YjVjZjcyZWUx Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9yaXNjdi9rZXJuZWwvcHJvYmVzL2twcm9iZXMuYwpA QCAtMCwwICsxLDQwMSBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjArCisK Ky8qCisgKiBLcHJvYmVzIHN1cHBvcnQgZm9yIFJJU0MtVgorICoKKyAqIEF1dGhvcjogUGF0cmlj ayBTdMOkaGxpbiA8bWVAcGFja2kuY2g+CisgKi8KKyNpbmNsdWRlIDxsaW51eC9rcHJvYmVzLmg+ CisjaW5jbHVkZSA8bGludXgvZXh0YWJsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNp bmNsdWRlIDxhc20vcHRyYWNlLmg+CisjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgorI2luY2x1 ZGUgPGFzbS9zZWN0aW9ucy5oPgorCisjaW5jbHVkZSAiZGVjb2RlLWluc24uaCIKKworREVGSU5F X1BFUl9DUFUoc3RydWN0IGtwcm9iZSAqLCBjdXJyZW50X2twcm9iZSkgPSBOVUxMOworREVGSU5F X1BFUl9DUFUoc3RydWN0IGtwcm9iZV9jdGxibGssIGtwcm9iZV9jdGxibGspOworCitzdGF0aWMg dm9pZCBfX2twcm9iZXMKK3Bvc3Rfa3Byb2JlX2hhbmRsZXIoc3RydWN0IGtwcm9iZV9jdGxibGsg Kiwgc3RydWN0IHB0X3JlZ3MgKik7CisKK3N0YXRpYyBpbnQgX19rcHJvYmVzIHBhdGNoX3RleHQo a3Byb2JlX29wY29kZV90ICphZGRyLCB1MzIgb3Bjb2RlKQoreworCWlmIChpc19jb21wcmVzc2Vk X2luc24ob3Bjb2RlKSkKKwkJKih1MTYgKilhZGRyID0gY3B1X3RvX2xlMTYob3Bjb2RlKTsKKwll bHNlCisJCSphZGRyID0gY3B1X3RvX2xlMzIob3Bjb2RlKTsKKworCXJldHVybiAwOworfQorCitz dGF0aWMgdm9pZCBfX2twcm9iZXMgYXJjaF9wcmVwYXJlX3NpbXVsYXRlKHN0cnVjdCBrcHJvYmUg KnApCit7CisJdW5zaWduZWQgbG9uZyBvZmZzZXQgPSBpc19jb21wcmVzc2VkX2luc24ocC0+b3Bj b2RlKSA/IDIgOiA0OworCisJcC0+YWluc24uYXBpLnJlc3RvcmUgPSAodW5zaWduZWQgbG9uZylw LT5hZGRyICsgb2Zmc2V0OworfQorCitzdGF0aWMgdm9pZCBfX2twcm9iZXMgYXJjaF9zaW11bGF0 ZV9pbnNuKHN0cnVjdCBrcHJvYmUgKnAsIHN0cnVjdCBwdF9yZWdzICpyZWdzKQoreworCXN0cnVj dCBrcHJvYmVfY3RsYmxrICprY2IgPSBnZXRfa3Byb2JlX2N0bGJsaygpOworCisJaWYgKHAtPmFp bnNuLmFwaS5oYW5kbGVyKQorCQlwLT5haW5zbi5hcGkuaGFuZGxlcigodTMyKXAtPm9wY29kZSwg KGxvbmcpcC0+YWRkciwgcmVncyk7CisKKwkvKiBzaW5nbGUgaW5zdHJ1Y3Rpb24gc2ltdWxhdGVk LCBub3cgZ28gZm9yIHBvc3QgcHJvY2Vzc2luZyAqLworCXBvc3Rfa3Byb2JlX2hhbmRsZXIoa2Ni LCByZWdzKTsKK30KKworaW50IF9fa3Byb2JlcyBhcmNoX3ByZXBhcmVfa3Byb2JlKHN0cnVjdCBr cHJvYmUgKnApCit7CisJdW5zaWduZWQgbG9uZyBwcm9iZV9hZGRyID0gKHVuc2lnbmVkIGxvbmcp cC0+YWRkcjsKKwlleHRlcm4gY2hhciBfX3N0YXJ0X3JvZGF0YVtdOworCWV4dGVybiBjaGFyIF9f ZW5kX3JvZGF0YVtdOworCisJaWYgKHByb2JlX2FkZHIgJiAweDEpIHsKKwkJcHJfd2FybigiQWRk cmVzcyBub3QgYWxpZ25lZC5cbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKiBjb3B5 IGluc3RydWN0aW9uICovCisJcC0+b3Bjb2RlID0gbGUzMl90b19jcHUoKnAtPmFkZHIpOworCisJ aWYgKHByb2JlX2FkZHIgPj0gKHVuc2lnbmVkIGxvbmcpIF9fc3RhcnRfcm9kYXRhICYmCisJICAg IHByb2JlX2FkZHIgPD0gKHVuc2lnbmVkIGxvbmcpIF9fZW5kX3JvZGF0YSkgeworCQlyZXR1cm4g LUVJTlZBTDsKKwl9CisKKwkvKiBkZWNvZGUgaW5zdHJ1Y3Rpb24gKi8KKwlzd2l0Y2ggKHJpc2N2 X3Byb2JlX2RlY29kZV9pbnNuKHAtPmFkZHIsICZwLT5haW5zbi5hcGkpKSB7CisJY2FzZSBJTlNO X1JFSkVDVEVEOgkvKiBpbnNuIG5vdCBzdXBwb3J0ZWQgKi8KKwkJcmV0dXJuIC1FSU5WQUw7CisK KwljYXNlIElOU05fR09PRF9OT19TTE9UOgkvKiBpbnNuIG5lZWRzIHNpbXVsYXRpb24gKi8KKwkJ YnJlYWs7CisJfQorCisJYXJjaF9wcmVwYXJlX3NpbXVsYXRlKHApOworCisJcmV0dXJuIDA7Cit9 CisKKyNkZWZpbmUgQ19FQlJFQUtfT1BDT0RFIDB4OTAwMgorCisvKiBhcm0ga3Byb2JlOiBpbnN0 YWxsIGJyZWFrcG9pbnQgaW4gdGV4dCAqLwordm9pZCBfX2twcm9iZXMgYXJjaF9hcm1fa3Byb2Jl KHN0cnVjdCBrcHJvYmUgKnApCit7CisJcGF0Y2hfdGV4dChwLT5hZGRyLCBDX0VCUkVBS19PUENP REUpOworfQorCisvKiBkaXNhcm0ga3Byb2JlOiByZW1vdmUgYnJlYWtwb2ludCBmcm9tIHRleHQg Ki8KK3ZvaWQgX19rcHJvYmVzIGFyY2hfZGlzYXJtX2twcm9iZShzdHJ1Y3Qga3Byb2JlICpwKQor eworCXBhdGNoX3RleHQocC0+YWRkciwgcC0+b3Bjb2RlKTsKK30KKwordm9pZCBfX2twcm9iZXMg YXJjaF9yZW1vdmVfa3Byb2JlKHN0cnVjdCBrcHJvYmUgKnApCit7Cit9CisKK3N0YXRpYyB2b2lk IF9fa3Byb2JlcyBzYXZlX3ByZXZpb3VzX2twcm9iZShzdHJ1Y3Qga3Byb2JlX2N0bGJsayAqa2Ni KQoreworCWtjYi0+cHJldl9rcHJvYmUua3AgPSBrcHJvYmVfcnVubmluZygpOworCWtjYi0+cHJl dl9rcHJvYmUuc3RhdHVzID0ga2NiLT5rcHJvYmVfc3RhdHVzOworfQorCitzdGF0aWMgdm9pZCBf X2twcm9iZXMgcmVzdG9yZV9wcmV2aW91c19rcHJvYmUoc3RydWN0IGtwcm9iZV9jdGxibGsgKmtj YikKK3sKKwlfX3RoaXNfY3B1X3dyaXRlKGN1cnJlbnRfa3Byb2JlLCBrY2ItPnByZXZfa3Byb2Jl LmtwKTsKKwlrY2ItPmtwcm9iZV9zdGF0dXMgPSBrY2ItPnByZXZfa3Byb2JlLnN0YXR1czsKK30K Kworc3RhdGljIHZvaWQgX19rcHJvYmVzIHNldF9jdXJyZW50X2twcm9iZShzdHJ1Y3Qga3Byb2Jl ICpwKQoreworCV9fdGhpc19jcHVfd3JpdGUoY3VycmVudF9rcHJvYmUsIHApOworfQorCitzdGF0 aWMgdm9pZCBfX2twcm9iZXMgc2ltdWxhdGUoc3RydWN0IGtwcm9iZSAqcCwKKwkJCSAgICAgICBz dHJ1Y3QgcHRfcmVncyAqcmVncywKKwkJCSAgICAgICBzdHJ1Y3Qga3Byb2JlX2N0bGJsayAqa2Ni LCBpbnQgcmVlbnRlcikKK3sKKwlpZiAocmVlbnRlcikgeworCQlzYXZlX3ByZXZpb3VzX2twcm9i ZShrY2IpOworCQlzZXRfY3VycmVudF9rcHJvYmUocCk7CisJCWtjYi0+a3Byb2JlX3N0YXR1cyA9 IEtQUk9CRV9SRUVOVEVSOworCX0gZWxzZSB7CisJCWtjYi0+a3Byb2JlX3N0YXR1cyA9IEtQUk9C RV9ISVRfU1M7CisJfQorCisJYXJjaF9zaW11bGF0ZV9pbnNuKHAsIHJlZ3MpOworfQorCitzdGF0 aWMgaW50IF9fa3Byb2JlcyByZWVudGVyX2twcm9iZShzdHJ1Y3Qga3Byb2JlICpwLAorCQkJCSAg ICBzdHJ1Y3QgcHRfcmVncyAqcmVncywKKwkJCQkgICAgc3RydWN0IGtwcm9iZV9jdGxibGsgKmtj YikKK3sKKwlzd2l0Y2ggKGtjYi0+a3Byb2JlX3N0YXR1cykgeworCWNhc2UgS1BST0JFX0hJVF9T U0RPTkU6CisJY2FzZSBLUFJPQkVfSElUX0FDVElWRToKKwkJa3Byb2Jlc19pbmNfbm1pc3NlZF9j b3VudChwKTsKKwkJc2ltdWxhdGUocCwgcmVncywga2NiLCAxKTsKKwkJYnJlYWs7CisJY2FzZSBL UFJPQkVfSElUX1NTOgorCWNhc2UgS1BST0JFX1JFRU5URVI6CisJCXByX3dhcm4oIlVucmVjb3Zl cmFibGUga3Byb2JlIGRldGVjdGVkLlxuIik7CisJCWR1bXBfa3Byb2JlKHApOworCQlCVUcoKTsK KwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJV0FSTl9PTigxKTsKKwkJcmV0dXJuIDA7CisJfQorCisJ cmV0dXJuIDE7Cit9CisKK3N0YXRpYyB2b2lkIF9fa3Byb2JlcworcG9zdF9rcHJvYmVfaGFuZGxl cihzdHJ1Y3Qga3Byb2JlX2N0bGJsayAqa2NiLCBzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3sKKwlz dHJ1Y3Qga3Byb2JlICpjdXIgPSBrcHJvYmVfcnVubmluZygpOworCisJaWYgKCFjdXIpCisJCXJl dHVybjsKKworCS8qIHJldHVybiBhZGRyIHJlc3RvcmUgaWYgbm9uLWJyYW5jaGluZyBpbnNuICov CisJaWYgKGN1ci0+YWluc24uYXBpLnJlc3RvcmUgIT0gMCkKKwkJaW5zdHJ1Y3Rpb25fcG9pbnRl cl9zZXQocmVncywgY3VyLT5haW5zbi5hcGkucmVzdG9yZSk7CisKKwkvKiByZXN0b3JlIGJhY2sg b3JpZ2luYWwgc2F2ZWQga3Byb2JlIHZhcmlhYmxlcyBhbmQgY29udGludWUgKi8KKwlpZiAoa2Ni LT5rcHJvYmVfc3RhdHVzID09IEtQUk9CRV9SRUVOVEVSKSB7CisJCXJlc3RvcmVfcHJldmlvdXNf a3Byb2JlKGtjYik7CisJCXJldHVybjsKKwl9CisJLyogY2FsbCBwb3N0IGhhbmRsZXIgKi8KKwlr Y2ItPmtwcm9iZV9zdGF0dXMgPSBLUFJPQkVfSElUX1NTRE9ORTsKKwlpZiAoY3VyLT5wb3N0X2hh bmRsZXIpCXsKKwkJLyogcG9zdF9oYW5kbGVyIGNhbiBoaXQgYnJlYWtwb2ludCBhbmQgc2luZ2xl IHN0ZXAKKwkJICogYWdhaW4sIHNvIHdlIGVuYWJsZSBELWZsYWcgZm9yIHJlY3Vyc2l2ZSBleGNl cHRpb24uCisJCSAqLworCQljdXItPnBvc3RfaGFuZGxlcihjdXIsIHJlZ3MsIDApOworCX0KKwor CXJlc2V0X2N1cnJlbnRfa3Byb2JlKCk7Cit9CisKK2ludCBfX2twcm9iZXMga3Byb2JlX2ZhdWx0 X2hhbmRsZXIoc3RydWN0IHB0X3JlZ3MgKnJlZ3MsIHVuc2lnbmVkIGludCBjYXVzZSkKK3sKKwlz dHJ1Y3Qga3Byb2JlICpjdXIgPSBrcHJvYmVfcnVubmluZygpOworCXN0cnVjdCBrcHJvYmVfY3Rs YmxrICprY2IgPSBnZXRfa3Byb2JlX2N0bGJsaygpOworCisJc3dpdGNoIChrY2ItPmtwcm9iZV9z dGF0dXMpIHsKKwljYXNlIEtQUk9CRV9ISVRfU1M6CisJY2FzZSBLUFJPQkVfUkVFTlRFUjoKKwkJ LyoKKwkJICogV2UgYXJlIGhlcmUgYmVjYXVzZSB0aGUgaW5zdHJ1Y3Rpb24gYmVpbmcgc2luZ2xl CisJCSAqIHN0ZXBwZWQgY2F1c2VkIGEgcGFnZSBmYXVsdC4gV2UgcmVzZXQgdGhlIGN1cnJlbnQK KwkJICoga3Byb2JlIGFuZCB0aGUgaXAgcG9pbnRzIGJhY2sgdG8gdGhlIHByb2JlIGFkZHJlc3MK KwkJICogYW5kIGFsbG93IHRoZSBwYWdlIGZhdWx0IGhhbmRsZXIgdG8gY29udGludWUgYXMgYQor CQkgKiBub3JtYWwgcGFnZSBmYXVsdC4KKwkJICovCisJCWluc3RydWN0aW9uX3BvaW50ZXJfc2V0 KHJlZ3MsICh1bnNpZ25lZCBsb25nKSBjdXItPmFkZHIpOworCQlpZiAoIWluc3RydWN0aW9uX3Bv aW50ZXIocmVncykpCisJCQlCVUcoKTsKKworCQlpZiAoa2NiLT5rcHJvYmVfc3RhdHVzID09IEtQ Uk9CRV9SRUVOVEVSKQorCQkJcmVzdG9yZV9wcmV2aW91c19rcHJvYmUoa2NiKTsKKwkJZWxzZQor CQkJcmVzZXRfY3VycmVudF9rcHJvYmUoKTsKKworCQlicmVhazsKKwljYXNlIEtQUk9CRV9ISVRf QUNUSVZFOgorCWNhc2UgS1BST0JFX0hJVF9TU0RPTkU6CisJCS8qCisJCSAqIFdlIGluY3JlbWVu dCB0aGUgbm1pc3NlZCBjb3VudCBmb3IgYWNjb3VudGluZywKKwkJICogd2UgY2FuIGFsc28gdXNl IG5wcmUvbnBvc3RmYXVsdCBjb3VudCBmb3IgYWNjb3VudGluZworCQkgKiB0aGVzZSBzcGVjaWZp YyBmYXVsdCBjYXNlcy4KKwkJICovCisJCWtwcm9iZXNfaW5jX25taXNzZWRfY291bnQoY3VyKTsK KworCQkvKgorCQkgKiBXZSBjb21lIGhlcmUgYmVjYXVzZSBpbnN0cnVjdGlvbnMgaW4gdGhlIHBy ZS9wb3N0CisJCSAqIGhhbmRsZXIgY2F1c2VkIHRoZSBwYWdlX2ZhdWx0LCB0aGlzIGNvdWxkIGhh cHBlbgorCQkgKiBpZiBoYW5kbGVyIHRyaWVzIHRvIGFjY2VzcyB1c2VyIHNwYWNlIGJ5CisJCSAq IGNvcHlfZnJvbV91c2VyKCksIGdldF91c2VyKCkgZXRjLiBMZXQgdGhlCisJCSAqIHVzZXItc3Bl Y2lmaWVkIGhhbmRsZXIgdHJ5IHRvIGZpeCBpdCBmaXJzdC4KKwkJICovCisJCWlmIChjdXItPmZh dWx0X2hhbmRsZXIgJiYgY3VyLT5mYXVsdF9oYW5kbGVyKGN1ciwgcmVncywgY2F1c2UpKQorCQkJ cmV0dXJuIDE7CisKKwkJLyoKKwkJICogSW4gY2FzZSB0aGUgdXNlci1zcGVjaWZpZWQgZmF1bHQg aGFuZGxlciByZXR1cm5lZAorCQkgKiB6ZXJvLCB0cnkgdG8gZml4IHVwLgorCQkgKi8KKwkJaWYg KGZpeHVwX2V4Y2VwdGlvbihyZWdzKSkKKwkJCXJldHVybiAxOworCX0KKwlyZXR1cm4gMDsKK30K Kworc3RhdGljIHZvaWQgX19rcHJvYmVzIGtwcm9iZV9oYW5kbGVyKHN0cnVjdCBwdF9yZWdzICpy ZWdzKQoreworCXN0cnVjdCBrcHJvYmUgKnAsICpjdXJfa3Byb2JlOworCXN0cnVjdCBrcHJvYmVf Y3RsYmxrICprY2I7CisJdW5zaWduZWQgbG9uZyBhZGRyID0gaW5zdHJ1Y3Rpb25fcG9pbnRlcihy ZWdzKTsKKworCWtjYiA9IGdldF9rcHJvYmVfY3RsYmxrKCk7CisJY3VyX2twcm9iZSA9IGtwcm9i ZV9ydW5uaW5nKCk7CisKKwlwID0gZ2V0X2twcm9iZSgoa3Byb2JlX29wY29kZV90ICopIGFkZHIp OworCisJaWYgKHApIHsKKwkJaWYgKGN1cl9rcHJvYmUpIHsKKwkJCWlmIChyZWVudGVyX2twcm9i ZShwLCByZWdzLCBrY2IpKQorCQkJCXJldHVybjsKKwkJfSBlbHNlIHsKKwkJCS8qIFByb2JlIGhp dCAqLworCQkJc2V0X2N1cnJlbnRfa3Byb2JlKHApOworCQkJa2NiLT5rcHJvYmVfc3RhdHVzID0g S1BST0JFX0hJVF9BQ1RJVkU7CisKKwkJCS8qCisJCQkgKiBJZiB3ZSBoYXZlIG5vIHByZS1oYW5k bGVyIG9yIGl0IHJldHVybmVkIDAsIHdlCisJCQkgKiBjb250aW51ZSB3aXRoIG5vcm1hbCBwcm9j ZXNzaW5nLiAgSWYgd2UgaGF2ZSBhCisJCQkgKiBwcmUtaGFuZGxlciBhbmQgaXQgcmV0dXJuZWQg bm9uLXplcm8sIGl0IHdpbGwKKwkJCSAqIG1vZGlmeSB0aGUgZXhlY3V0aW9uIHBhdGggYW5kIG5v IG5lZWQgdG8gc2luZ2xlCisJCQkgKiBzdGVwcGluZy4gTGV0J3MganVzdCByZXNldCBjdXJyZW50 IGtwcm9iZSBhbmQgZXhpdC4KKwkJCSAqCisJCQkgKiBwcmVfaGFuZGxlciBjYW4gaGl0IGEgYnJl YWtwb2ludCBhbmQgY2FuIHN0ZXAgdGhydQorCQkJICogYmVmb3JlIHJldHVybiwga2VlcCBQU1RB VEUgRC1mbGFnIGVuYWJsZWQgdW50aWwKKwkJCSAqIHByZV9oYW5kbGVyIHJldHVybiBiYWNrLgor CQkJICovCisJCQlpZiAoIXAtPnByZV9oYW5kbGVyIHx8ICFwLT5wcmVfaGFuZGxlcihwLCByZWdz KSkKKwkJCQlzaW11bGF0ZShwLCByZWdzLCBrY2IsIDApOworCQkJZWxzZQorCQkJCXJlc2V0X2N1 cnJlbnRfa3Byb2JlKCk7CisJCX0KKwl9CisJLyoKKwkgKiBUaGUgYnJlYWtwb2ludCBpbnN0cnVj dGlvbiB3YXMgcmVtb3ZlZCByaWdodAorCSAqIGFmdGVyIHdlIGhpdCBpdC4gIEFub3RoZXIgY3B1 IGhhcyByZW1vdmVkCisJICogZWl0aGVyIGEgcHJvYmVwb2ludCBvciBhIGRlYnVnZ2VyIGJyZWFr cG9pbnQKKwkgKiBhdCB0aGlzIGFkZHJlc3MuICBJbiBlaXRoZXIgY2FzZSwgbm8gZnVydGhlcgor CSAqIGhhbmRsaW5nIG9mIHRoaXMgaW50ZXJydXB0IGlzIGFwcHJvcHJpYXRlLgorCSAqIFJldHVy biBiYWNrIHRvIG9yaWdpbmFsIGluc3RydWN0aW9uLCBhbmQgY29udGludWUuCisJICovCit9CisK K2ludCBfX2twcm9iZXMKK2twcm9iZV9icmVha3BvaW50X2hhbmRsZXIoc3RydWN0IHB0X3JlZ3Mg KnJlZ3MpCit7CisJa3Byb2JlX2hhbmRsZXIocmVncyk7CisJcmV0dXJuIDE7Cit9CisKK2Jvb2wg YXJjaF93aXRoaW5fa3Byb2JlX2JsYWNrbGlzdCh1bnNpZ25lZCBsb25nIGFkZHIpCit7CisJaWYg KChhZGRyID49ICh1bnNpZ25lZCBsb25nKV9fa3Byb2Jlc190ZXh0X3N0YXJ0ICYmCisJICAgIGFk ZHIgPCAodW5zaWduZWQgbG9uZylfX2twcm9iZXNfdGV4dF9lbmQpIHx8CisJICAgIChhZGRyID49 ICh1bnNpZ25lZCBsb25nKV9fZW50cnlfdGV4dF9zdGFydCAmJgorCSAgICBhZGRyIDwgKHVuc2ln bmVkIGxvbmcpX19lbnRyeV90ZXh0X2VuZCkgfHwKKwkgICAgISFzZWFyY2hfZXhjZXB0aW9uX3Rh YmxlcyhhZGRyKSkKKwkJcmV0dXJuIHRydWU7CisKKwlyZXR1cm4gZmFsc2U7Cit9CisKK3ZvaWQg 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 ID0gKGtwcm9iZV9vcGNvZGVfdCAqKXJlZ3MtPnJhOworCXJlZ3MtPnJhID0gKGxvbmcpJmtyZXRw cm9iZV90cmFtcG9saW5lOworfQorCitpbnQgX19rcHJvYmVzIGFyY2hfdHJhbXBvbGluZV9rcHJv YmUoc3RydWN0IGtwcm9iZSAqcCkKK3sKKwlyZXR1cm4gMDsKK30KKworaW50IF9faW5pdCBhcmNo X2luaXRfa3Byb2Jlcyh2b2lkKQoreworCXJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvYXJjaC9y aXNjdi9rZXJuZWwvcHJvYmVzL2twcm9iZXNfdHJhbXBvbGluZS5TIGIvYXJjaC9yaXNjdi9rZXJu ZWwvcHJvYmVzL2twcm9iZXNfdHJhbXBvbGluZS5TCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMC4uYzdjZWRhOTU1NmEzCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9yaXNj di9rZXJuZWwvcHJvYmVzL2twcm9iZXNfdHJhbXBvbGluZS5TCkBAIC0wLDAgKzEsOTEgQEAKKy8q IFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKyAqLworCisjaW5jbHVkZSA8bGludXgv bGlua2FnZS5oPgorCisjaW5jbHVkZSA8YXNtL2FzbS5oPgorI2luY2x1ZGUgPGFzbS9hc20tb2Zm c2V0cy5oPgorCisJLnRleHQKKwkuYWx0bWFjcm8KKworCS5tYWNybyBzYXZlX2FsbF9iYXNlX3Jl Z3MKKwlSRUdfUyB4MSwgIFBUX1JBKHNwKQorCVJFR19TIHgzLCAgUFRfR1Aoc3ApCisJUkVHX1Mg eDQsICBQVF9UUChzcCkKKwlSRUdfUyB4NSwgIFBUX1QwKHNwKQorCVJFR19TIHg2LCAgUFRfVDEo c3ApCisJUkVHX1MgeDcsICBQVF9UMihzcCkKKwlSRUdfUyB4OCwgIFBUX1MwKHNwKQorCVJFR19T IHg5LCAgUFRfUzEoc3ApCisJUkVHX1MgeDEwLCBQVF9BMChzcCkKKwlSRUdfUyB4MTEsIFBUX0Ex KHNwKQorCVJFR19TIHgxMiwgUFRfQTIoc3ApCisJUkVHX1MgeDEzLCBQVF9BMyhzcCkKKwlSRUdf UyB4MTQsIFBUX0E0KHNwKQorCVJFR19TIHgxNSwgUFRfQTUoc3ApCisJUkVHX1MgeDE2LCBQVF9B NihzcCkKKwlSRUdfUyB4MTcsIFBUX0E3KHNwKQorCVJFR19TIHgxOCwgUFRfUzIoc3ApCisJUkVH X1MgeDE5LCBQVF9TMyhzcCkKKwlSRUdfUyB4MjAsIFBUX1M0KHNwKQorCVJFR19TIHgyMSwgUFRf UzUoc3ApCisJUkVHX1MgeDIyLCBQVF9TNihzcCkKKwlSRUdfUyB4MjMsIFBUX1M3KHNwKQorCVJF R19TIHgyNCwgUFRfUzgoc3ApCisJUkVHX1MgeDI1LCBQVF9TOShzcCkKKwlSRUdfUyB4MjYsIFBU X1MxMChzcCkKKwlSRUdfUyB4MjcsIFBUX1MxMShzcCkKKwlSRUdfUyB4MjgsIFBUX1QzKHNwKQor CVJFR19TIHgyOSwgUFRfVDQoc3ApCisJUkVHX1MgeDMwLCBQVF9UNShzcCkKKwlSRUdfUyB4MzEs IFBUX1Q2KHNwKQorCS5lbmRtCisKKwkubWFjcm8gcmVzdG9yZV9hbGxfYmFzZV9yZWdzCisJUkVH X0wgeDMsICBQVF9HUChzcCkKKwlSRUdfTCB4NCwgIFBUX1RQKHNwKQorCVJFR19MIHg1LCAgUFRf VDAoc3ApCisJUkVHX0wgeDYsICBQVF9UMShzcCkKKwlSRUdfTCB4NywgIFBUX1QyKHNwKQorCVJF R19MIHg4LCAgUFRfUzAoc3ApCisJUkVHX0wgeDksICBQVF9TMShzcCkKKwlSRUdfTCB4MTAsIFBU X0EwKHNwKQorCVJFR19MIHgxMSwgUFRfQTEoc3ApCisJUkVHX0wgeDEyLCBQVF9BMihzcCkKKwlS RUdfTCB4MTMsIFBUX0EzKHNwKQorCVJFR19MIHgxNCwgUFRfQTQoc3ApCisJUkVHX0wgeDE1LCBQ VF9BNShzcCkKKwlSRUdfTCB4MTYsIFBUX0E2KHNwKQorCVJFR19MIHgxNywgUFRfQTcoc3ApCisJ UkVHX0wgeDE4LCBQVF9TMihzcCkKKwlSRUdfTCB4MTksIFBUX1MzKHNwKQorCVJFR19MIHgyMCwg UFRfUzQoc3ApCisJUkVHX0wgeDIxLCBQVF9TNShzcCkKKwlSRUdfTCB4MjIsIFBUX1M2KHNwKQor CVJFR19MIHgyMywgUFRfUzcoc3ApCisJUkVHX0wgeDI0LCBQVF9TOChzcCkKKwlSRUdfTCB4MjUs IFBUX1M5KHNwKQorCVJFR19MIHgyNiwgUFRfUzEwKHNwKQorCVJFR19MIHgyNywgUFRfUzExKHNw KQorCVJFR19MIHgyOCwgUFRfVDMoc3ApCisJUkVHX0wgeDI5LCBQVF9UNChzcCkKKwlSRUdfTCB4 MzAsIFBUX1Q1KHNwKQorCVJFR19MIHgzMSwgUFRfVDYoc3ApCisJLmVuZG0KKworRU5UUlkoa3Jl dHByb2JlX3RyYW1wb2xpbmUpCisJYWRkaSBzcCwgc3AsIC0oUFRfU0laRV9PTl9TVEFDSykKKwlz YXZlX2FsbF9iYXNlX3JlZ3MKKworCW1vdmUgYTAsIHNwIC8qIHB0X3JlZ3MgKi8KKworCWNhbGwg dHJhbXBvbGluZV9wcm9iZV9oYW5kbGVyCisKKwkvKiB1c2UgdGhlIHJlc3VsdCBhcyB0aGUgcmV0 dXJuLWFkZHJlc3MgKi8KKwltb3ZlIHJhLCBhMAorCisJcmVzdG9yZV9hbGxfYmFzZV9yZWdzCisJ YWRkaSBzcCwgc3AsIFBUX1NJWkVfT05fU1RBQ0sKKworCXJldAorRU5EUFJPQyhrcmV0cHJvYmVf dHJhbXBvbGluZSkKZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9zaW11bGF0 ZS1pbnNuLmMgYi9hcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvc2ltdWxhdGUtaW5zbi5jCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNTczNGQ5YmFlMjJmCi0tLSAvZGV2 L251bGwKKysrIGIvYXJjaC9yaXNjdi9rZXJuZWwvcHJvYmVzL3NpbXVsYXRlLWluc24uYwpAQCAt MCwwICsxLDMzIEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsKKworI2lu Y2x1ZGUgPGxpbnV4L2JpdG9wcy5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1 ZGUgPGxpbnV4L2twcm9iZXMuaD4KKworI2luY2x1ZGUgInNpbXVsYXRlLWluc24uaCIKKworI2Rl ZmluZSBiaXRfYXQodmFsdWUsIGJpdCkJCSgodmFsdWUpICYgKDEgPDwgKGJpdCkpKQorI2RlZmlu ZSBtb3ZlX2JpdF9hdCh2YWx1ZSwgYml0LCB0bykJKChiaXRfYXQodmFsdWUsIGJpdCkgPj4gYml0 KSA8PCB0bykKKwordm9pZCBfX2twcm9iZXMKK3NpbXVsYXRlX2NhZGRpc3AxNih1MzIgb3Bjb2Rl LCBsb25nIGFkZHIsIHN0cnVjdCBwdF9yZWdzICpyZWdzKQoreworCXMxNiBpbW07CisKKwkvKgor CSAqIEltbWVkaWF0ZSB2YWx1ZSBsYXlvdXQgaW4gYy5hZGRpc3AxNjoKKwkgKiB4eHg5IHh4eHgg eDQ2OCA3NXh4CisJICogMSAgMSAgICA4ICAgIDQgICAgMAorCSAqIDUgIDIKKwkgKi8KKwlpbW0g PSBzaWduX2V4dGVuZDMyKAorCQltb3ZlX2JpdF9hdChvcGNvZGUsIDEyLCA5KSB8CisJCW1vdmVf Yml0X2F0KG9wY29kZSwgNiwgNCkgfAorCQltb3ZlX2JpdF9hdChvcGNvZGUsIDUsIDYpIHwKKwkJ bW92ZV9iaXRfYXQob3Bjb2RlLCA0LCA4KSB8CisJCW1vdmVfYml0X2F0KG9wY29kZSwgMywgNykg fAorCQltb3ZlX2JpdF9hdChvcGNvZGUsIDIsIDUpLAorCQk5KTsKKworCXJlZ3MtPnNwICs9IGlt bTsKK30KZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3Yva2VybmVsL3Byb2Jlcy9zaW11bGF0ZS1pbnNu LmggYi9hcmNoL3Jpc2N2L2tlcm5lbC9wcm9iZXMvc2ltdWxhdGUtaW5zbi5oCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZGMyYzA2YzMwMTY3Ci0tLSAvZGV2L251bGwK KysrIGIvYXJjaC9yaXNjdi9rZXJuZWwvcHJvYmVzL3NpbXVsYXRlLWluc24uaApAQCAtMCwwICsx LDggQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKyAqLworCisjaWZuZGVm IF9SSVNDVl9LRVJORUxfS1BST0JFU19TSU1VTEFURV9JTlNOX0gKKyNkZWZpbmUgX1JJU0NWX0tF Uk5FTF9LUFJPQkVTX1NJTVVMQVRFX0lOU05fSAorCit2b2lkIHNpbXVsYXRlX2NhZGRpc3AxNih1 MzIgb3Bjb2RlLCBsb25nIGFkZHIsIHN0cnVjdCBwdF9yZWdzICpyZWdzKTsKKworI2VuZGlmIC8q IF9SSVNDVl9LRVJORUxfS1BST0JFU19TSU1VTEFURV9JTlNOX0ggKi8KZGlmZiAtLWdpdCBhL2Fy Y2gvcmlzY3Yva2VybmVsL3RyYXBzLmMgYi9hcmNoL3Jpc2N2L2tlcm5lbC90cmFwcy5jCmluZGV4 IDI0YTkzMzNkZGEyYy4uZDcxMTMxNzhkNDAxIDEwMDY0NAotLS0gYS9hcmNoL3Jpc2N2L2tlcm5l bC90cmFwcy5jCisrKyBiL2FyY2gvcmlzY3Yva2VybmVsL3RyYXBzLmMKQEAgLTE4LDYgKzE4LDcg QEAKICNpbmNsdWRlIDxsaW51eC9zY2hlZC9zaWduYWwuaD4KICNpbmNsdWRlIDxsaW51eC9zaWdu YWwuaD4KICNpbmNsdWRlIDxsaW51eC9rZGVidWcuaD4KKyNpbmNsdWRlIDxsaW51eC9rcHJvYmVz Lmg+CiAjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgogI2luY2x1ZGUgPGxpbnV4L21tLmg+CiAj aW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CkBAIC0xMjAsOCArMTIxLDE0IEBAIERPX0VSUk9SX0lO Rk8oZG9fdHJhcF9lY2FsbF9tLAogCiBhc21saW5rYWdlIHZvaWQgZG9fdHJhcF9icmVhayhzdHJ1 Y3QgcHRfcmVncyAqcmVncykKIHsKKwlib29sIGhhbmRsZXJfZm91bmQgPSBmYWxzZTsKKworI2lm ZGVmIENPTkZJR19LUFJPQkVTCisJaWYgKGtwcm9iZV9icmVha3BvaW50X2hhbmRsZXIocmVncykp CisJCWhhbmRsZXJfZm91bmQgPSAxOworI2VuZGlmCiAjaWZkZWYgQ09ORklHX0dFTkVSSUNfQlVH Ci0JaWYgKCF1c2VyX21vZGUocmVncykpIHsKKwlpZiAoIWhhbmRsZXJfZm91bmQgJiYgIXVzZXJf bW9kZShyZWdzKSkgewogCQllbnVtIGJ1Z190cmFwX3R5cGUgdHlwZTsKIAogCQl0eXBlID0gcmVw b3J0X2J1ZyhyZWdzLT5zZXBjLCByZWdzKTsKQEAgLTEzNyw3ICsxNDQsOSBAQCBhc21saW5rYWdl IHZvaWQgZG9fdHJhcF9icmVhayhzdHJ1Y3QgcHRfcmVncyAqcmVncykKIAl9CiAjZW5kaWYgLyog Q09ORklHX0dFTkVSSUNfQlVHICovCiAKLQlmb3JjZV9zaWdfZmF1bHQoU0lHVFJBUCwgVFJBUF9C UktQVCwgKHZvaWQgX191c2VyICopKHJlZ3MtPnNlcGMpLCBjdXJyZW50KTsKKwlpZiAoIWhhbmRs ZXJfZm91bmQpCisJCWZvcmNlX3NpZ19mYXVsdChTSUdUUkFQLCBUUkFQX0JSS1BULAorCQkJKHZv aWQgX191c2VyICopKHJlZ3MtPnNlcGMpLCBjdXJyZW50KTsKIH0KIAogI2lmZGVmIENPTkZJR19H RU5FUklDX0JVRwpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9tbS9mYXVsdC5jIGIvYXJjaC9yaXNj di9tbS9mYXVsdC5jCmluZGV4IDg4NDAxZDUxMjViYy4uZWZmODE2ZTMzNDc5IDEwMDY0NAotLS0g YS9hcmNoL3Jpc2N2L21tL2ZhdWx0LmMKKysrIGIvYXJjaC9yaXNjdi9tbS9mYXVsdC5jCkBAIC0y Miw2ICsyMiw3IEBACiAKICNpbmNsdWRlIDxsaW51eC9tbS5oPgogI2luY2x1ZGUgPGxpbnV4L2tl cm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2twcm9iZXMuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRl cnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC9wZXJmX2V2ZW50Lmg+CiAjaW5jbHVkZSA8bGludXgv c2lnbmFsLmg+CkBAIC0zMCwxMSArMzEsMzMgQEAKICNpbmNsdWRlIDxhc20vcGdhbGxvYy5oPgog I2luY2x1ZGUgPGFzbS9wdHJhY2UuaD4KIAorI2lmZGVmIENPTkZJR19LUFJPQkVTCitzdGF0aWMg aW5saW5lIGludCBub3RpZnlfcGFnZV9mYXVsdChzdHJ1Y3QgcHRfcmVncyAqcmVncywgdW5zaWdu ZWQgaW50IGNhdXNlKQoreworCWludCByZXQgPSAwOworCisJLyoga3Byb2JlX3J1bm5pbmcoKSBu ZWVkcyBzbXBfcHJvY2Vzc29yX2lkKCkgKi8KKwlpZiAoIXVzZXJfbW9kZShyZWdzKSkgeworCQlw cmVlbXB0X2Rpc2FibGUoKTsKKwkJaWYgKGtwcm9iZV9ydW5uaW5nKCkgJiYga3Byb2JlX2ZhdWx0 X2hhbmRsZXIocmVncywgY2F1c2UpKQorCQkJcmV0ID0gMTsKKwkJcHJlZW1wdF9lbmFibGUoKTsK Kwl9CisKKwlyZXR1cm4gcmV0OworfQorI2Vsc2UKK3N0YXRpYyBpbmxpbmUgaW50IG5vdGlmeV9w YWdlX2ZhdWx0KHN0cnVjdCBwdF9yZWdzICpyZWdzLCB1bnNpZ25lZCBpbnQgY2F1c2UpCit7CisJ cmV0dXJuIDA7Cit9CisjZW5kaWYKKwogLyoKICAqIFRoaXMgcm91dGluZSBoYW5kbGVzIHBhZ2Ug ZmF1bHRzLiAgSXQgZGV0ZXJtaW5lcyB0aGUgYWRkcmVzcyBhbmQgdGhlCiAgKiBwcm9ibGVtLCBh bmQgdGhlbiBwYXNzZXMgaXQgb2ZmIHRvIG9uZSBvZiB0aGUgYXBwcm9wcmlhdGUgcm91dGluZXMu CiAgKi8KLWFzbWxpbmthZ2Ugdm9pZCBkb19wYWdlX2ZhdWx0KHN0cnVjdCBwdF9yZWdzICpyZWdz KQorYXNtbGlua2FnZSB2b2lkIF9fa3Byb2JlcyBkb19wYWdlX2ZhdWx0KHN0cnVjdCBwdF9yZWdz ICpyZWdzKQogewogCXN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrOwogCXN0cnVjdCB2bV9hcmVhX3N0 cnVjdCAqdm1hOwpAQCAtNDcsNiArNzAsOSBAQCBhc21saW5rYWdlIHZvaWQgZG9fcGFnZV9mYXVs dChzdHJ1Y3QgcHRfcmVncyAqcmVncykKIAljYXVzZSA9IHJlZ3MtPnNjYXVzZTsKIAlhZGRyID0g cmVncy0+c2JhZGFkZHI7CiAKKwlpZiAobm90aWZ5X3BhZ2VfZmF1bHQocmVncywgY2F1c2UpKQor CQlyZXR1cm47CisKIAl0c2sgPSBjdXJyZW50OwogCW1tID0gdHNrLT5tbTsKIAotLSAKMi4xNy4x CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgt cmlzY3YgbWFpbGluZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDov L2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1yaXNjdgo=