parisc: Implement kprobes

Implement kprobes support for PA-RISC.

Signed-off-by: Sven Schnelle <svens@stackframe.org>
Signed-off-by: Helge Deller <deller@gmx.de>

diff --git a/arch/parisc/Kconfig b/arch/parisc/Kconfig
index a80c19c..7712688 100644 (file)
--- a/arch/parisc/Kconfig
+++ b/arch/parisc/Kconfig
@@ -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

diff --git a/arch/parisc/include/asm/kprobes.h b/arch/parisc/include/asm/kprobes.h
new file mode 100644 (file)
index 0000000..e09cf2d
--- /dev/null
+++ b/arch/parisc/include/asm/kprobes.h
@@ -0,0 +1,55 @@
+/* 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 */

diff --git a/arch/parisc/kernel/Makefile b/arch/parisc/kernel/Makefile
index 5012da9..b818b28 100644 (file)
--- a/arch/parisc/kernel/Makefile
+++ b/arch/parisc/kernel/Makefile
@@ -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

diff --git a/arch/parisc/kernel/kprobes.c b/arch/parisc/kernel/kprobes.c
new file mode 100644 (file)
index 0000000..8b1977c
--- /dev/null
+++ b/arch/parisc/kernel/kprobes.c
@@ -0,0 +1,183 @@
+// 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;
+}

diff --git a/arch/parisc/kernel/traps.c b/arch/parisc/kernel/traps.c
index 4a05165..096e319 100644 (file)
--- a/arch/parisc/kernel/traps.c
+++ b/arch/parisc/kernel/traps.c
@@ -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);