[linux-block.git] / arch / arc / kernel / kprobes.c

// 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));
	}
}

static 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, 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);
}
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
4d86dfbb VG	2	/*
4d86dfbb VG	3	* Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
4d86dfbb VG	4	*/
	5
	6	#include <linux/types.h>
	7	#include <linux/kprobes.h>
	8	#include <linux/slab.h>
	9	#include <linux/module.h>
4d86dfbb VG	10	#include <linux/kdebug.h>
	11	#include <linux/sched.h>
	12	#include <linux/uaccess.h>
	13	#include <asm/cacheflush.h>
	14	#include <asm/current.h>
	15	#include <asm/disasm.h>
	16
	17	#define MIN_STACK_SIZE(addr) min((unsigned long)MAX_STACK_SIZE, \
	18	(unsigned long)current_thread_info() + THREAD_SIZE - (addr))
	19
	20	DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL;
	21	DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
	22
	23	int __kprobes arch_prepare_kprobe(struct kprobe *p)
	24	{
	25	/* Attempt to probe at unaligned address */
	26	if ((unsigned long)p->addr & 0x01)
	27	return -EINVAL;
	28
	29	/* Address should not be in exception handling code */
	30
	31	p->ainsn.is_short = is_short_instr((unsigned long)p->addr);
	32	p->opcode = *p->addr;
	33
	34	return 0;
	35	}
	36
	37	void __kprobes arch_arm_kprobe(struct kprobe *p)
	38	{
	39	*p->addr = UNIMP_S_INSTRUCTION;
	40
	41	flush_icache_range((unsigned long)p->addr,
	42	(unsigned long)p->addr + sizeof(kprobe_opcode_t));
	43	}
	44
	45	void __kprobes arch_disarm_kprobe(struct kprobe *p)
	46	{
	47	*p->addr = p->opcode;
	48
	49	flush_icache_range((unsigned long)p->addr,
	50	(unsigned long)p->addr + sizeof(kprobe_opcode_t));
	51	}
	52
	53	void __kprobes arch_remove_kprobe(struct kprobe *p)
	54	{
	55	arch_disarm_kprobe(p);
	56
	57	/* Can we remove the kprobe in the middle of kprobe handling? */
	58	if (p->ainsn.t1_addr) {
	59	*(p->ainsn.t1_addr) = p->ainsn.t1_opcode;
	60
	61	flush_icache_range((unsigned long)p->ainsn.t1_addr,
	62	(unsigned long)p->ainsn.t1_addr +
	63	sizeof(kprobe_opcode_t));
	64
	65	p->ainsn.t1_addr = NULL;
	66	}
	67
	68	if (p->ainsn.t2_addr) {
	69	*(p->ainsn.t2_addr) = p->ainsn.t2_opcode;
	70
	71	flush_icache_range((unsigned long)p->ainsn.t2_addr,
	72	(unsigned long)p->ainsn.t2_addr +
	73	sizeof(kprobe_opcode_t));
74
75	p->ainsn.t2_addr = NULL;
76	}
77	}
78
79	static void __kprobes save_previous_kprobe(struct kprobe_ctlblk *kcb)
80	{
81	kcb->prev_kprobe.kp = kprobe_running();
82	kcb->prev_kprobe.status = kcb->kprobe_status;
83	}
84
85	static void __kprobes restore_previous_kprobe(struct kprobe_ctlblk *kcb)
86	{
6855e95c	87	__this_cpu_write(current_kprobe, kcb->prev_kprobe.kp);
4d86dfbb VG	88	kcb->kprobe_status = kcb->prev_kprobe.status;
	89	}
	90
	91	static inline void __kprobes set_current_kprobe(struct kprobe *p)
	92	{
6855e95c	93	__this_cpu_write(current_kprobe, p);
4d86dfbb VG	94	}
	95
	96	static void __kprobes resume_execution(struct kprobe *p, unsigned long addr,
	97	struct pt_regs *regs)
	98	{
	99	/* Remove the trap instructions inserted for single step and
	100	* restore the original instructions
	101	*/
	102	if (p->ainsn.t1_addr) {
	103	*(p->ainsn.t1_addr) = p->ainsn.t1_opcode;
	104
	105	flush_icache_range((unsigned long)p->ainsn.t1_addr,
	106	(unsigned long)p->ainsn.t1_addr +
	107	sizeof(kprobe_opcode_t));
	108
	109	p->ainsn.t1_addr = NULL;
	110	}
	111
	112	if (p->ainsn.t2_addr) {
	113	*(p->ainsn.t2_addr) = p->ainsn.t2_opcode;
	114
	115	flush_icache_range((unsigned long)p->ainsn.t2_addr,
	116	(unsigned long)p->ainsn.t2_addr +
	117	sizeof(kprobe_opcode_t));
	118
	119	p->ainsn.t2_addr = NULL;
	120	}
	121
	122	return;
	123	}
	124
	125	static void __kprobes setup_singlestep(struct kprobe p, struct pt_regs regs)
	126	{
	127	unsigned long next_pc;
	128	unsigned long tgt_if_br = 0;
	129	int is_branch;
	130	unsigned long bta;
	131
	132	/* Copy the opcode back to the kprobe location and execute the
	133	* instruction. Because of this we will not be able to get into the
	134	* same kprobe until this kprobe is done
	135	*/
	136	*(p->addr) = p->opcode;
	137
	138	flush_icache_range((unsigned long)p->addr,
	139	(unsigned long)p->addr + sizeof(kprobe_opcode_t));
	140
	141	/* Now we insert the trap at the next location after this instruction to
	142	* single step. If it is a branch we insert the trap at possible branch
	143	* targets
	144	*/
	145
	146	bta = regs->bta;
	147
	148	if (regs->status32 & 0x40) {
	149	/* We are in a delay slot with the branch taken */
	150
	151	next_pc = bta & ~0x01;
	152
	153	if (!p->ainsn.is_short) {
	154	if (bta & 0x01)
	155	regs->blink += 2;
	156	else {
	157	/* Branch not taken */
158	next_pc += 2;
159
160	/* next pc is taken from bta after executing the
161	* delay slot instruction
162	*/
163	regs->bta += 2;
164	}
165	}
166
167	is_branch = 0;
168	} else
169	is_branch =
170	disasm_next_pc((unsigned long)p->addr, regs,
171	(struct callee_regs *) current->thread.callee_reg,
172	&next_pc, &tgt_if_br);
173
174	p->ainsn.t1_addr = (kprobe_opcode_t *) next_pc;
175	p->ainsn.t1_opcode = *(p->ainsn.t1_addr);
176	*(p->ainsn.t1_addr) = TRAP_S_2_INSTRUCTION;
177
178	flush_icache_range((unsigned long)p->ainsn.t1_addr,
179	(unsigned long)p->ainsn.t1_addr +
180	sizeof(kprobe_opcode_t));
181
182	if (is_branch) {
183	p->ainsn.t2_addr = (kprobe_opcode_t *) tgt_if_br;
184	p->ainsn.t2_opcode = *(p->ainsn.t2_addr);
185	*(p->ainsn.t2_addr) = TRAP_S_2_INSTRUCTION;
186
187	flush_icache_range((unsigned long)p->ainsn.t2_addr,
188	(unsigned long)p->ainsn.t2_addr +
189	sizeof(kprobe_opcode_t));
190	}
191	}
192
db70d9f9 VG	193	static int
db70d9f9 VG	194	__kprobes arc_kprobe_handler(unsigned long addr, struct pt_regs *regs)
4d86dfbb VG	195	{
	196	struct kprobe *p;
	197	struct kprobe_ctlblk *kcb;
	198
	199	preempt_disable();
	200
	201	kcb = get_kprobe_ctlblk();
	202	p = get_kprobe((unsigned long *)addr);
	203
	204	if (p) {
	205	/*
	206	* We have reentered the kprobe_handler, since another kprobe
	207	* was hit while within the handler, we save the original
	208	* kprobes and single step on the instruction of the new probe
	209	* without calling any user handlers to avoid recursive
	210	* kprobes.
	211	*/
	212	if (kprobe_running()) {
	213	save_previous_kprobe(kcb);
	214	set_current_kprobe(p);
	215	kprobes_inc_nmissed_count(p);
	216	setup_singlestep(p, regs);
	217	kcb->kprobe_status = KPROBE_REENTER;
	218	return 1;
	219	}
	220
	221	set_current_kprobe(p);
	222	kcb->kprobe_status = KPROBE_HIT_ACTIVE;
	223
	224	/* If we have no pre-handler or it returned 0, we continue with
	225	* normal processing. If we have a pre-handler and it returned
e00f1993 MH	226	* non-zero - which means user handler setup registers to exit
e00f1993 MH	227	* to another instruction, we must skip the single stepping.
4d86dfbb VG	228	*/
	229	if (!p->pre_handler \|\| !p->pre_handler(p, regs)) {
	230	setup_singlestep(p, regs);
	231	kcb->kprobe_status = KPROBE_HIT_SS;
cce188bd MH	232	} else {
	233	reset_current_kprobe();
	234	preempt_enable_no_resched();
4d86dfbb VG	235	}
	236
	237	return 1;
4d86dfbb VG	238	}
	239
	240	/* no_kprobe: */
	241	preempt_enable_no_resched();
	242	return 0;
	243	}
	244
db70d9f9 VG	245	static int
db70d9f9 VG	246	__kprobes arc_post_kprobe_handler(unsigned long addr, struct pt_regs *regs)
4d86dfbb VG	247	{
	248	struct kprobe *cur = kprobe_running();
	249	struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
	250
	251	if (!cur)
	252	return 0;
	253
	254	resume_execution(cur, addr, regs);
	255
	256	/* Rearm the kprobe */
	257	arch_arm_kprobe(cur);
	258
	259	/*
	260	* When we return from trap instruction we go to the next instruction
	261	* We restored the actual instruction in resume_exectuiont and we to
	262	* return to the same address and execute it
	263	*/
	264	regs->ret = addr;
	265
	266	if ((kcb->kprobe_status != KPROBE_REENTER) && cur->post_handler) {
	267	kcb->kprobe_status = KPROBE_HIT_SSDONE;
	268	cur->post_handler(cur, regs, 0);
	269	}
	270
	271	if (kcb->kprobe_status == KPROBE_REENTER) {
	272	restore_previous_kprobe(kcb);
	273	goto out;
	274	}
	275
	276	reset_current_kprobe();
	277
	278	out:
	279	preempt_enable_no_resched();
	280	return 1;
	281	}
	282
	283	/*
	284	* Fault can be for the instruction being single stepped or for the
	285	* pre/post handlers in the module.
	286	* This is applicable for applications like user probes, where we have the
	287	* probe in user space and the handlers in the kernel
	288	*/
	289
	290	int __kprobes kprobe_fault_handler(struct pt_regs *regs, unsigned long trapnr)
	291	{
	292	struct kprobe *cur = kprobe_running();
	293	struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
	294
	295	switch (kcb->kprobe_status) {
	296	case KPROBE_HIT_SS:
	297	case KPROBE_REENTER:
	298	/*
	299	* We are here because the instruction being single stepped
	300	* caused the fault. We reset the current kprobe and allow the
	301	* exception handler as if it is regular exception. In our
	302	* case it doesn't matter because the system will be halted
	303	*/
	304	resume_execution(cur, (unsigned long)cur->addr, regs);
	305
	306	if (kcb->kprobe_status == KPROBE_REENTER)
	307	restore_previous_kprobe(kcb);
	308	else
	309	reset_current_kprobe();
	310
311	preempt_enable_no_resched();
312	break;
313
314	case KPROBE_HIT_ACTIVE:
315	case KPROBE_HIT_SSDONE:
316	/*
317	* We are here because the instructions in the pre/post handler
318	* caused the fault.
319	*/
320
4d86dfbb VG	321	/*
	322	* In case the user-specified fault handler returned zero,
	323	* try to fix up.
	324	*/
	325	if (fixup_exception(regs))
	326	return 1;
	327
	328	/*
	329	* fixup_exception() could not handle it,
	330	* Let do_page_fault() fix it.
	331	*/
	332	break;
	333
	334	default:
	335	break;
	336	}
	337	return 0;
	338	}
	339
	340	int __kprobes kprobe_exceptions_notify(struct notifier_block *self,
	341	unsigned long val, void *data)
	342	{
	343	struct die_args *args = data;
	344	unsigned long addr = args->err;
	345	int ret = NOTIFY_DONE;
	346
	347	switch (val) {
	348	case DIE_IERR:
	349	if (arc_kprobe_handler(addr, args->regs))
	350	return NOTIFY_STOP;
	351	break;
	352
	353	case DIE_TRAP:
	354	if (arc_post_kprobe_handler(addr, args->regs))
	355	return NOTIFY_STOP;
	356	break;
	357
	358	default:
	359	break;
	360	}
	361
	362	return ret;
	363	}
	364
4d86dfbb VG	365	static void __used kretprobe_trampoline_holder(void)
4d86dfbb VG	366	{
adf8a61a MH	367	__asm__ __volatile__(".global __kretprobe_trampoline\n"
	368	"__kretprobe_trampoline:\n"
	369	"nop\n");
4d86dfbb VG	370	}
	371
	372	void __kprobes arch_prepare_kretprobe(struct kretprobe_instance *ri,
	373	struct pt_regs *regs)
	374	{
	375
	376	ri->ret_addr = (kprobe_opcode_t *) regs->blink;
f75dd136	377	ri->fp = NULL;
4d86dfbb VG	378
4d86dfbb VG	379	/* Replace the return addr with trampoline addr */
adf8a61a	380	regs->blink = (unsigned long)&__kretprobe_trampoline;
4d86dfbb VG	381	}
	382
	383	static int __kprobes trampoline_probe_handler(struct kprobe *p,
	384	struct pt_regs *regs)
	385	{
96fed8ac	386	regs->ret = __kretprobe_trampoline_handler(regs, NULL);
4d86dfbb VG	387
	388	/* By returning a non zero value, we are telling the kprobe handler
	389	* that we don't want the post_handler to run
	390	*/
	391	return 1;
	392	}
	393
	394	static struct kprobe trampoline_p = {
adf8a61a	395	.addr = (kprobe_opcode_t *) &__kretprobe_trampoline,
4d86dfbb VG	396	.pre_handler = trampoline_probe_handler
	397	};
	398
	399	int __init arch_init_kprobes(void)
	400	{
	401	/* Registering the trampoline code for the kret probe */
	402	return register_kprobe(&trampoline_p);
	403	}
	404
	405	int __kprobes arch_trampoline_kprobe(struct kprobe *p)
	406	{
adf8a61a	407	if (p->addr == (kprobe_opcode_t *) &__kretprobe_trampoline)
4d86dfbb VG	408	return 1;
	409
	410	return 0;
	411	}
	412
38a9ff6d	413	void trap_is_kprobe(unsigned long address, struct pt_regs *regs)
4d86dfbb	414	{
38a9ff6d	415	notify_die(DIE_TRAP, "kprobe_trap", regs, address, 0, SIGTRAP);
4d86dfbb	416	}