Commit 8858ac8e authored by Sven Schnelle's avatar Sven Schnelle Committed by Helge Deller
Browse files

parisc: Implement kprobes 



Implement kprobes support for PA-RISC.

Signed-off-by: default avatarSven Schnelle <svens@stackframe.org>
Signed-off-by: default avatarHelge Deller <deller@gmx.de>
parent ea1afe33

arch/parisc/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -55,6 +55,7 @@ config PARISC 
	select NEED_DMA_MAP_STATE

	select NEED_SG_DMA_LENGTH

	select HAVE_ARCH_KGDB

	select HAVE_KPROBES



	help

	  The PA-RISC microprocessor is designed by Hewlett-Packard and used

arch/parisc/include/asm/kprobes.h

0 → 100644
+55 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * arch/parisc/include/asm/kprobes.h

 *

 * PA-RISC kprobes implementation

 *

 * Copyright (c) 2019 Sven Schnelle <svens@stackframe.org>

 */



#ifndef _PARISC_KPROBES_H

#define _PARISC_KPROBES_H



#ifdef CONFIG_KPROBES



#include <asm-generic/kprobes.h>

#include <linux/types.h>

#include <linux/ptrace.h>

#include <linux/notifier.h>



#define PARISC_KPROBES_BREAK_INSN	0x3ff801f

#define  __ARCH_WANT_KPROBES_INSN_SLOT

#define MAX_INSN_SIZE 1



typedef u32 kprobe_opcode_t;

struct kprobe;



void arch_remove_kprobe(struct kprobe *p);



#define flush_insn_slot(p) \

	flush_icache_range((unsigned long)&(p)->ainsn.insn[0], \

			   (unsigned long)&(p)->ainsn.insn[0] + \

			   sizeof(kprobe_opcode_t))



#define kretprobe_blacklist_size    0



struct arch_specific_insn {

	kprobe_opcode_t *insn;

};



struct prev_kprobe {

	struct kprobe *kp;

	unsigned long status;

};



struct kprobe_ctlblk {

	unsigned int kprobe_status;

	struct prev_kprobe prev_kprobe;

	unsigned long iaoq[2];

};



int __kprobes parisc_kprobe_break_handler(struct pt_regs *regs);

int __kprobes parisc_kprobe_ss_handler(struct pt_regs *regs);



#endif /* CONFIG_KPROBES */

#endif /* _PARISC_KPROBES_H */

arch/parisc/kernel/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -34,3 +34,4 @@ obj-$(CONFIG_PARISC_CPU_TOPOLOGY) += topology.o 
obj-$(CONFIG_FUNCTION_TRACER)		+= ftrace.o

obj-$(CONFIG_FUNCTION_GRAPH_TRACER)	+= ftrace.o

obj-$(CONFIG_KGDB)			+= kgdb.o

obj-$(CONFIG_KPROBES)			+= kprobes.o

arch/parisc/kernel/kprobes.c

0 → 100644
+183 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * arch/parisc/kernel/kprobes.c

 *

 * PA-RISC kprobes implementation

 *

 * Copyright (c) 2019 Sven Schnelle <svens@stackframe.org>

 */



#include <linux/types.h>

#include <linux/kprobes.h>

#include <linux/slab.h>

#include <asm/cacheflush.h>

#include <asm/patch.h>



DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL;

DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);



int __kprobes arch_prepare_kprobe(struct kprobe *p)

{

	if ((unsigned long)p->addr & 3UL)

		return -EINVAL;



	p->ainsn.insn = get_insn_slot();

	if (!p->ainsn.insn)

		return -ENOMEM;



	memcpy(p->ainsn.insn, p->addr,

		MAX_INSN_SIZE * sizeof(kprobe_opcode_t));

	p->opcode = *p->addr;

	flush_insn_slot(p);

	return 0;

}



void __kprobes arch_remove_kprobe(struct kprobe *p)

{

	if (!p->ainsn.insn)

		return;



	free_insn_slot(p->ainsn.insn, 0);

	p->ainsn.insn = NULL;

}



void __kprobes arch_arm_kprobe(struct kprobe *p)

{

	patch_text(p->addr, PARISC_KPROBES_BREAK_INSN);

}



void __kprobes arch_disarm_kprobe(struct kprobe *p)

{

	patch_text(p->addr, p->opcode);

}



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 setup_singlestep(struct kprobe *p,

		struct kprobe_ctlblk *kcb, struct pt_regs *regs)

{

	kcb->iaoq[0] = regs->iaoq[0];

	kcb->iaoq[1] = regs->iaoq[1];

	regs->iaoq[0] = (unsigned long)p->ainsn.insn;

	mtctl(0, 0);

	regs->gr[0] |= PSW_R;

}



int __kprobes parisc_kprobe_break_handler(struct pt_regs *regs)

{

	struct kprobe *p;

	struct kprobe_ctlblk *kcb;



	preempt_disable();



	kcb = get_kprobe_ctlblk();

	p = get_kprobe((unsigned long *)regs->iaoq[0]);



	if (!p) {

		preempt_enable_no_resched();

		return 0;

	}



	if (kprobe_running()) {

		/*

		 * 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.

		 */

		save_previous_kprobe(kcb);

		set_current_kprobe(p);

		kprobes_inc_nmissed_count(p);

		setup_singlestep(p, kcb, 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, kcb, regs);

		kcb->kprobe_status = KPROBE_HIT_SS;

	} else {

		reset_current_kprobe();

		preempt_enable_no_resched();

	}

	return 1;

}



int __kprobes parisc_kprobe_ss_handler(struct pt_regs *regs)

{

	struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();

	struct kprobe *p = kprobe_running();



	if (regs->iaoq[0] != (unsigned long)p->ainsn.insn+4)

		return 0;



	/* restore back original saved kprobe variables and continue */

	if (kcb->kprobe_status == KPROBE_REENTER) {

		restore_previous_kprobe(kcb);

		return 1;

	}



	/* for absolute branch instructions we can copy iaoq_b. for relative

	 * branch instructions we need to calculate the new address based on the

	 * difference between iaoq_f and iaoq_b. We cannot use iaoq_b without

	 * modificationt because it's based on our ainsn.insn address.

	 */



	if (p->post_handler)

		p->post_handler(p, regs, 0);



	switch (regs->iir >> 26) {

	case 0x38: /* BE */

	case 0x39: /* BE,L */

	case 0x3a: /* BV */

	case 0x3b: /* BVE */

		/* for absolute branches, regs->iaoq[1] has already the right

		 * address

		 */

		regs->iaoq[0] = kcb->iaoq[1];

		break;

	default:

		regs->iaoq[1] = kcb->iaoq[0];

		regs->iaoq[1] += (regs->iaoq[1] - regs->iaoq[0]) + 4;

		regs->iaoq[0] = kcb->iaoq[1];

		break;

	}

	kcb->kprobe_status = KPROBE_HIT_SSDONE;

	reset_current_kprobe();

	return 1;

}



bool arch_kprobe_on_func_entry(unsigned long offset)

{

	return !offset;

}



int __init arch_init_kprobes(void)

{

	return 0;

}

arch/parisc/kernel/traps.c

+14 −0
Original line number Diff line number Diff line
@@ -43,6 +43,7 @@ 
#include <asm/tlbflush.h>

#include <asm/cacheflush.h>

#include <linux/kgdb.h>

#include <linux/kprobes.h>



#include "../math-emu/math-emu.h"	/* for handle_fpe() */
@@ -294,6 +295,14 @@ static void handle_break(struct pt_regs *regs) 
			(tt == BUG_TRAP_TYPE_NONE) ? 9 : 0);

	}



#ifdef CONFIG_KPROBES

	if (unlikely(iir == PARISC_KPROBES_BREAK_INSN)) {

		parisc_kprobe_break_handler(regs);

		return;

	}



#endif



#ifdef CONFIG_KGDB

	if (unlikely(iir == PARISC_KGDB_COMPILED_BREAK_INSN ||

		iir == PARISC_KGDB_BREAK_INSN)) {
@@ -528,6 +537,11 @@ void notrace handle_interruption(int code, struct pt_regs *regs) 
		/* Recovery counter trap */

		regs->gr[0] &= ~PSW_R;



#ifdef CONFIG_KPROBES

		if (parisc_kprobe_ss_handler(regs))

			return;

#endif



#ifdef CONFIG_KGDB

		if (kgdb_single_step) {

			kgdb_handle_exception(0, SIGTRAP, 0, regs);

CRA Git | Maintained and supported by SUSTech CRA and CCSE