forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
414 lines
9.8 KiB
414 lines
9.8 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com) |
|
*/ |
|
|
|
#include <linux/types.h> |
|
#include <linux/kprobes.h> |
|
#include <linux/slab.h> |
|
#include <linux/module.h> |
|
#include <linux/kdebug.h> |
|
#include <linux/sched.h> |
|
#include <linux/uaccess.h> |
|
#include <asm/cacheflush.h> |
|
#include <asm/current.h> |
|
#include <asm/disasm.h> |
|
|
|
#define MIN_STACK_SIZE(addr) min((unsigned long)MAX_STACK_SIZE, \ |
|
(unsigned long)current_thread_info() + THREAD_SIZE - (addr)) |
|
|
|
DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL; |
|
DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk); |
|
|
|
int __kprobes arch_prepare_kprobe(struct kprobe *p) |
|
{ |
|
/* Attempt to probe at unaligned address */ |
|
if ((unsigned long)p->addr & 0x01) |
|
return -EINVAL; |
|
|
|
/* Address should not be in exception handling code */ |
|
|
|
p->ainsn.is_short = is_short_instr((unsigned long)p->addr); |
|
p->opcode = *p->addr; |
|
|
|
return 0; |
|
} |
|
|
|
void __kprobes arch_arm_kprobe(struct kprobe *p) |
|
{ |
|
*p->addr = UNIMP_S_INSTRUCTION; |
|
|
|
flush_icache_range((unsigned long)p->addr, |
|
(unsigned long)p->addr + sizeof(kprobe_opcode_t)); |
|
} |
|
|
|
void __kprobes arch_disarm_kprobe(struct kprobe *p) |
|
{ |
|
*p->addr = p->opcode; |
|
|
|
flush_icache_range((unsigned long)p->addr, |
|
(unsigned long)p->addr + sizeof(kprobe_opcode_t)); |
|
} |
|
|
|
void __kprobes arch_remove_kprobe(struct kprobe *p) |
|
{ |
|
arch_disarm_kprobe(p); |
|
|
|
/* Can we remove the kprobe in the middle of kprobe handling? */ |
|
if (p->ainsn.t1_addr) { |
|
*(p->ainsn.t1_addr) = p->ainsn.t1_opcode; |
|
|
|
flush_icache_range((unsigned long)p->ainsn.t1_addr, |
|
(unsigned long)p->ainsn.t1_addr + |
|
sizeof(kprobe_opcode_t)); |
|
|
|
p->ainsn.t1_addr = NULL; |
|
} |
|
|
|
if (p->ainsn.t2_addr) { |
|
*(p->ainsn.t2_addr) = p->ainsn.t2_opcode; |
|
|
|
flush_icache_range((unsigned long)p->ainsn.t2_addr, |
|
(unsigned long)p->ainsn.t2_addr + |
|
sizeof(kprobe_opcode_t)); |
|
|
|
p->ainsn.t2_addr = NULL; |
|
} |
|
} |
|
|
|
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 inline void __kprobes set_current_kprobe(struct kprobe *p) |
|
{ |
|
__this_cpu_write(current_kprobe, p); |
|
} |
|
|
|
static void __kprobes resume_execution(struct kprobe *p, unsigned long addr, |
|
struct pt_regs *regs) |
|
{ |
|
/* Remove the trap instructions inserted for single step and |
|
* restore the original instructions |
|
*/ |
|
if (p->ainsn.t1_addr) { |
|
*(p->ainsn.t1_addr) = p->ainsn.t1_opcode; |
|
|
|
flush_icache_range((unsigned long)p->ainsn.t1_addr, |
|
(unsigned long)p->ainsn.t1_addr + |
|
sizeof(kprobe_opcode_t)); |
|
|
|
p->ainsn.t1_addr = NULL; |
|
} |
|
|
|
if (p->ainsn.t2_addr) { |
|
*(p->ainsn.t2_addr) = p->ainsn.t2_opcode; |
|
|
|
flush_icache_range((unsigned long)p->ainsn.t2_addr, |
|
(unsigned long)p->ainsn.t2_addr + |
|
sizeof(kprobe_opcode_t)); |
|
|
|
p->ainsn.t2_addr = NULL; |
|
} |
|
|
|
return; |
|
} |
|
|
|
static void __kprobes setup_singlestep(struct kprobe *p, struct pt_regs *regs) |
|
{ |
|
unsigned long next_pc; |
|
unsigned long tgt_if_br = 0; |
|
int is_branch; |
|
unsigned long bta; |
|
|
|
/* Copy the opcode back to the kprobe location and execute the |
|
* instruction. Because of this we will not be able to get into the |
|
* same kprobe until this kprobe is done |
|
*/ |
|
*(p->addr) = p->opcode; |
|
|
|
flush_icache_range((unsigned long)p->addr, |
|
(unsigned long)p->addr + sizeof(kprobe_opcode_t)); |
|
|
|
/* Now we insert the trap at the next location after this instruction to |
|
* single step. If it is a branch we insert the trap at possible branch |
|
* targets |
|
*/ |
|
|
|
bta = regs->bta; |
|
|
|
if (regs->status32 & 0x40) { |
|
/* We are in a delay slot with the branch taken */ |
|
|
|
next_pc = bta & ~0x01; |
|
|
|
if (!p->ainsn.is_short) { |
|
if (bta & 0x01) |
|
regs->blink += 2; |
|
else { |
|
/* Branch not taken */ |
|
next_pc += 2; |
|
|
|
/* next pc is taken from bta after executing the |
|
* delay slot instruction |
|
*/ |
|
regs->bta += 2; |
|
} |
|
} |
|
|
|
is_branch = 0; |
|
} else |
|
is_branch = |
|
disasm_next_pc((unsigned long)p->addr, regs, |
|
(struct callee_regs *) current->thread.callee_reg, |
|
&next_pc, &tgt_if_br); |
|
|
|
p->ainsn.t1_addr = (kprobe_opcode_t *) next_pc; |
|
p->ainsn.t1_opcode = *(p->ainsn.t1_addr); |
|
*(p->ainsn.t1_addr) = TRAP_S_2_INSTRUCTION; |
|
|
|
flush_icache_range((unsigned long)p->ainsn.t1_addr, |
|
(unsigned long)p->ainsn.t1_addr + |
|
sizeof(kprobe_opcode_t)); |
|
|
|
if (is_branch) { |
|
p->ainsn.t2_addr = (kprobe_opcode_t *) tgt_if_br; |
|
p->ainsn.t2_opcode = *(p->ainsn.t2_addr); |
|
*(p->ainsn.t2_addr) = TRAP_S_2_INSTRUCTION; |
|
|
|
flush_icache_range((unsigned long)p->ainsn.t2_addr, |
|
(unsigned long)p->ainsn.t2_addr + |
|
sizeof(kprobe_opcode_t)); |
|
} |
|
} |
|
|
|
int __kprobes arc_kprobe_handler(unsigned long addr, struct pt_regs *regs) |
|
{ |
|
struct kprobe *p; |
|
struct kprobe_ctlblk *kcb; |
|
|
|
preempt_disable(); |
|
|
|
kcb = get_kprobe_ctlblk(); |
|
p = get_kprobe((unsigned long *)addr); |
|
|
|
if (p) { |
|
/* |
|
* We have reentered the kprobe_handler, since another kprobe |
|
* was hit while within the handler, we save the original |
|
* kprobes and single step on the instruction of the new probe |
|
* without calling any user handlers to avoid recursive |
|
* kprobes. |
|
*/ |
|
if (kprobe_running()) { |
|
save_previous_kprobe(kcb); |
|
set_current_kprobe(p); |
|
kprobes_inc_nmissed_count(p); |
|
setup_singlestep(p, regs); |
|
kcb->kprobe_status = KPROBE_REENTER; |
|
return 1; |
|
} |
|
|
|
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 - which means user handler setup registers to exit |
|
* to another instruction, we must skip the single stepping. |
|
*/ |
|
if (!p->pre_handler || !p->pre_handler(p, regs)) { |
|
setup_singlestep(p, regs); |
|
kcb->kprobe_status = KPROBE_HIT_SS; |
|
} else { |
|
reset_current_kprobe(); |
|
preempt_enable_no_resched(); |
|
} |
|
|
|
return 1; |
|
} |
|
|
|
/* no_kprobe: */ |
|
preempt_enable_no_resched(); |
|
return 0; |
|
} |
|
|
|
static int __kprobes arc_post_kprobe_handler(unsigned long addr, |
|
struct pt_regs *regs) |
|
{ |
|
struct kprobe *cur = kprobe_running(); |
|
struct kprobe_ctlblk *kcb = get_kprobe_ctlblk(); |
|
|
|
if (!cur) |
|
return 0; |
|
|
|
resume_execution(cur, addr, regs); |
|
|
|
/* Rearm the kprobe */ |
|
arch_arm_kprobe(cur); |
|
|
|
/* |
|
* When we return from trap instruction we go to the next instruction |
|
* We restored the actual instruction in resume_exectuiont and we to |
|
* return to the same address and execute it |
|
*/ |
|
regs->ret = addr; |
|
|
|
if ((kcb->kprobe_status != KPROBE_REENTER) && cur->post_handler) { |
|
kcb->kprobe_status = KPROBE_HIT_SSDONE; |
|
cur->post_handler(cur, regs, 0); |
|
} |
|
|
|
if (kcb->kprobe_status == KPROBE_REENTER) { |
|
restore_previous_kprobe(kcb); |
|
goto out; |
|
} |
|
|
|
reset_current_kprobe(); |
|
|
|
out: |
|
preempt_enable_no_resched(); |
|
return 1; |
|
} |
|
|
|
/* |
|
* Fault can be for the instruction being single stepped or for the |
|
* pre/post handlers in the module. |
|
* This is applicable for applications like user probes, where we have the |
|
* probe in user space and the handlers in the kernel |
|
*/ |
|
|
|
int __kprobes kprobe_fault_handler(struct pt_regs *regs, unsigned long 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 the fault. We reset the current kprobe and allow the |
|
* exception handler as if it is regular exception. In our |
|
* case it doesn't matter because the system will be halted |
|
*/ |
|
resume_execution(cur, (unsigned long)cur->addr, regs); |
|
|
|
if (kcb->kprobe_status == KPROBE_REENTER) |
|
restore_previous_kprobe(kcb); |
|
else |
|
reset_current_kprobe(); |
|
|
|
preempt_enable_no_resched(); |
|
break; |
|
|
|
case KPROBE_HIT_ACTIVE: |
|
case KPROBE_HIT_SSDONE: |
|
/* |
|
* We are here because the instructions in the pre/post handler |
|
* caused the fault. |
|
*/ |
|
|
|
/* |
|
* In case the user-specified fault handler returned zero, |
|
* try to fix up. |
|
*/ |
|
if (fixup_exception(regs)) |
|
return 1; |
|
|
|
/* |
|
* fixup_exception() could not handle it, |
|
* Let do_page_fault() fix it. |
|
*/ |
|
break; |
|
|
|
default: |
|
break; |
|
} |
|
return 0; |
|
} |
|
|
|
int __kprobes kprobe_exceptions_notify(struct notifier_block *self, |
|
unsigned long val, void *data) |
|
{ |
|
struct die_args *args = data; |
|
unsigned long addr = args->err; |
|
int ret = NOTIFY_DONE; |
|
|
|
switch (val) { |
|
case DIE_IERR: |
|
if (arc_kprobe_handler(addr, args->regs)) |
|
return NOTIFY_STOP; |
|
break; |
|
|
|
case DIE_TRAP: |
|
if (arc_post_kprobe_handler(addr, args->regs)) |
|
return NOTIFY_STOP; |
|
break; |
|
|
|
default: |
|
break; |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
static void __used kretprobe_trampoline_holder(void) |
|
{ |
|
__asm__ __volatile__(".global kretprobe_trampoline\n" |
|
"kretprobe_trampoline:\n" "nop\n"); |
|
} |
|
|
|
void __kprobes arch_prepare_kretprobe(struct kretprobe_instance *ri, |
|
struct pt_regs *regs) |
|
{ |
|
|
|
ri->ret_addr = (kprobe_opcode_t *) regs->blink; |
|
ri->fp = NULL; |
|
|
|
/* Replace the return addr with trampoline addr */ |
|
regs->blink = (unsigned long)&kretprobe_trampoline; |
|
} |
|
|
|
static int __kprobes trampoline_probe_handler(struct kprobe *p, |
|
struct pt_regs *regs) |
|
{ |
|
regs->ret = __kretprobe_trampoline_handler(regs, &kretprobe_trampoline, NULL); |
|
|
|
/* By returning a non zero value, we are telling the kprobe handler |
|
* that we don't want the post_handler to run |
|
*/ |
|
return 1; |
|
} |
|
|
|
static struct kprobe trampoline_p = { |
|
.addr = (kprobe_opcode_t *) &kretprobe_trampoline, |
|
.pre_handler = trampoline_probe_handler |
|
}; |
|
|
|
int __init arch_init_kprobes(void) |
|
{ |
|
/* Registering the trampoline code for the kret probe */ |
|
return register_kprobe(&trampoline_p); |
|
} |
|
|
|
int __kprobes arch_trampoline_kprobe(struct kprobe *p) |
|
{ |
|
if (p->addr == (kprobe_opcode_t *) &kretprobe_trampoline) |
|
return 1; |
|
|
|
return 0; |
|
} |
|
|
|
void trap_is_kprobe(unsigned long address, struct pt_regs *regs) |
|
{ |
|
notify_die(DIE_TRAP, "kprobe_trap", regs, address, 0, SIGTRAP); |
|
}
|
|
|