ARM: add uprobes support
authorDavid A. Long <dave.long@linaro.org>
Fri, 7 Mar 2014 16:23:04 +0000 (11:23 -0500)
committerDavid A. Long <dave.long@linaro.org>
Tue, 18 Mar 2014 20:39:40 +0000 (16:39 -0400)
Using Rabin Vincent's ARM uprobes patches as a base, enable uprobes
support on ARM.

Caveats:

 - Thumb is not supported

Signed-off-by: Rabin Vincent <rabin@rab.in>
Signed-off-by: David A. Long <dave.long@linaro.org>
arch/arm/Kconfig
arch/arm/include/asm/ptrace.h
arch/arm/include/asm/thread_info.h
arch/arm/include/asm/uprobes.h [new file with mode: 0644]
arch/arm/kernel/Makefile
arch/arm/kernel/signal.c
arch/arm/kernel/uprobes-arm.c [new file with mode: 0644]
arch/arm/kernel/uprobes.c [new file with mode: 0644]
arch/arm/kernel/uprobes.h [new file with mode: 0644]

index e254198177914ca13050f37519a6ca43e0da596d..4d05bb93714abddf3ed5b8c1c05a146a4e3e0475 100644 (file)
@@ -207,6 +207,9 @@ config ZONE_DMA
 config NEED_DMA_MAP_STATE
        def_bool y
 
+config ARCH_SUPPORTS_UPROBES
+       def_bool y
+
 config ARCH_HAS_DMA_SET_COHERENT_MASK
        bool
 
index 04c99f36ff7f902208c475066e28cbf67077f606..ee688b0a13c309ab90b00d6ef4fd650c51dc1705 100644 (file)
@@ -80,6 +80,12 @@ static inline long regs_return_value(struct pt_regs *regs)
 
 #define instruction_pointer(regs)      (regs)->ARM_pc
 
+static inline void instruction_pointer_set(struct pt_regs *regs,
+                                          unsigned long val)
+{
+       instruction_pointer(regs) = val;
+}
+
 #ifdef CONFIG_SMP
 extern unsigned long profile_pc(struct pt_regs *regs);
 #else
index 71a06b293489ddffd1b4177eca38572501c0ce36..f989d7c22dc5ac00c17d3f8ab0b6d3a74565e062 100644 (file)
@@ -153,6 +153,7 @@ extern int vfp_restore_user_hwstate(struct user_vfp __user *,
 #define TIF_SIGPENDING         0
 #define TIF_NEED_RESCHED       1
 #define TIF_NOTIFY_RESUME      2       /* callback before returning to user */
+#define TIF_UPROBE             7
 #define TIF_SYSCALL_TRACE      8
 #define TIF_SYSCALL_AUDIT      9
 #define TIF_SYSCALL_TRACEPOINT 10
@@ -165,6 +166,7 @@ extern int vfp_restore_user_hwstate(struct user_vfp __user *,
 #define _TIF_SIGPENDING                (1 << TIF_SIGPENDING)
 #define _TIF_NEED_RESCHED      (1 << TIF_NEED_RESCHED)
 #define _TIF_NOTIFY_RESUME     (1 << TIF_NOTIFY_RESUME)
+#define _TIF_UPROBE            (1 << TIF_UPROBE)
 #define _TIF_SYSCALL_TRACE     (1 << TIF_SYSCALL_TRACE)
 #define _TIF_SYSCALL_AUDIT     (1 << TIF_SYSCALL_AUDIT)
 #define _TIF_SYSCALL_TRACEPOINT        (1 << TIF_SYSCALL_TRACEPOINT)
@@ -178,7 +180,8 @@ extern int vfp_restore_user_hwstate(struct user_vfp __user *,
 /*
  * Change these and you break ASM code in entry-common.S
  */
-#define _TIF_WORK_MASK         (_TIF_NEED_RESCHED | _TIF_SIGPENDING | _TIF_NOTIFY_RESUME)
+#define _TIF_WORK_MASK         (_TIF_NEED_RESCHED | _TIF_SIGPENDING | \
+                                _TIF_NOTIFY_RESUME | _TIF_UPROBE)
 
 #endif /* __KERNEL__ */
 #endif /* __ASM_ARM_THREAD_INFO_H */
diff --git a/arch/arm/include/asm/uprobes.h b/arch/arm/include/asm/uprobes.h
new file mode 100644 (file)
index 0000000..9472c20
--- /dev/null
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2012 Rabin Vincent <rabin at rab.in>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _ASM_UPROBES_H
+#define _ASM_UPROBES_H
+
+#include <asm/probes.h>
+#include <asm/opcodes.h>
+
+typedef u32 uprobe_opcode_t;
+
+#define MAX_UINSN_BYTES                4
+#define UPROBE_XOL_SLOT_BYTES  64
+
+#define UPROBE_SWBP_ARM_INSN   0xe7f001f9
+#define UPROBE_SS_ARM_INSN     0xe7f001fa
+#define UPROBE_SWBP_INSN       __opcode_to_mem_arm(UPROBE_SWBP_ARM_INSN)
+#define UPROBE_SWBP_INSN_SIZE  4
+
+struct arch_uprobe_task {
+       u32 backup;
+       unsigned long   saved_trap_no;
+};
+
+struct arch_uprobe {
+       u8 insn[MAX_UINSN_BYTES];
+       unsigned long ixol[2];
+       uprobe_opcode_t bpinsn;
+       bool simulate;
+       u32 pcreg;
+       void (*prehandler)(struct arch_uprobe *auprobe,
+                          struct arch_uprobe_task *autask,
+                          struct pt_regs *regs);
+       void (*posthandler)(struct arch_uprobe *auprobe,
+                           struct arch_uprobe_task *autask,
+                           struct pt_regs *regs);
+       struct arch_probes_insn asi;
+};
+
+#endif
index bb739f28dd80c850764df502e99a660c09507788..a766bcbaf8adfbca3e4bb5ef4446bc5700454d7d 100644 (file)
@@ -50,6 +50,7 @@ obj-$(CONFIG_DYNAMIC_FTRACE)  += ftrace.o insn.o
 obj-$(CONFIG_FUNCTION_GRAPH_TRACER)    += ftrace.o insn.o
 obj-$(CONFIG_JUMP_LABEL)       += jump_label.o insn.o patch.o
 obj-$(CONFIG_KEXEC)            += machine_kexec.o relocate_kernel.o
+obj-$(CONFIG_UPROBES)          += probes.o probes-arm.o uprobes.o uprobes-arm.o
 obj-$(CONFIG_KPROBES)          += probes.o kprobes.o kprobes-common.o patch.o
 ifdef CONFIG_THUMB2_KERNEL
 obj-$(CONFIG_KPROBES)          += kprobes-thumb.o probes-thumb.o
index 04d63880037f9c293741230f95e9520c19ee3dee..bd1983437205190f349b892361e1e488e87f3f79 100644 (file)
@@ -13,6 +13,7 @@
 #include <linux/personality.h>
 #include <linux/uaccess.h>
 #include <linux/tracehook.h>
+#include <linux/uprobes.h>
 
 #include <asm/elf.h>
 #include <asm/cacheflush.h>
@@ -590,6 +591,9 @@ do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall)
                                        return restart;
                                }
                                syscall = 0;
+                       } else if (thread_flags & _TIF_UPROBE) {
+                               clear_thread_flag(TIF_UPROBE);
+                               uprobe_notify_resume(regs);
                        } else {
                                clear_thread_flag(TIF_NOTIFY_RESUME);
                                tracehook_notify_resume(regs);
diff --git a/arch/arm/kernel/uprobes-arm.c b/arch/arm/kernel/uprobes-arm.c
new file mode 100644 (file)
index 0000000..d3b655f
--- /dev/null
@@ -0,0 +1,234 @@
+/*
+ * Copyright (C) 2012 Rabin Vincent <rabin at rab.in>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/stddef.h>
+#include <linux/wait.h>
+#include <linux/uprobes.h>
+#include <linux/module.h>
+
+#include "probes.h"
+#include "probes-arm.h"
+#include "uprobes.h"
+
+static int uprobes_substitute_pc(unsigned long *pinsn, u32 oregs)
+{
+       probes_opcode_t insn = __mem_to_opcode_arm(*pinsn);
+       probes_opcode_t temp;
+       probes_opcode_t mask;
+       int freereg;
+       u32 free = 0xffff;
+       u32 regs;
+
+       for (regs = oregs; regs; regs >>= 4, insn >>= 4) {
+               if ((regs & 0xf) == REG_TYPE_NONE)
+                       continue;
+
+               free &= ~(1 << (insn & 0xf));
+       }
+
+       /* No PC, no problem */
+       if (free & (1 << 15))
+               return 15;
+
+       if (!free)
+               return -1;
+
+       /*
+        * fls instead of ffs ensures that for "ldrd r0, r1, [pc]" we would
+        * pick LR instead of R1.
+        */
+       freereg = free = fls(free) - 1;
+
+       temp = __mem_to_opcode_arm(*pinsn);
+       insn = temp;
+       regs = oregs;
+       mask = 0xf;
+
+       for (; regs; regs >>= 4, mask <<= 4, free <<= 4, temp >>= 4) {
+               if ((regs & 0xf) == REG_TYPE_NONE)
+                       continue;
+
+               if ((temp & 0xf) != 15)
+                       continue;
+
+               insn &= ~mask;
+               insn |= free & mask;
+       }
+
+       *pinsn = __opcode_to_mem_arm(insn);
+       return freereg;
+}
+
+static void uprobe_set_pc(struct arch_uprobe *auprobe,
+                         struct arch_uprobe_task *autask,
+                         struct pt_regs *regs)
+{
+       u32 pcreg = auprobe->pcreg;
+
+       autask->backup = regs->uregs[pcreg];
+       regs->uregs[pcreg] = regs->ARM_pc + 8;
+}
+
+static void uprobe_unset_pc(struct arch_uprobe *auprobe,
+                           struct arch_uprobe_task *autask,
+                           struct pt_regs *regs)
+{
+       /* PC will be taken care of by common code */
+       regs->uregs[auprobe->pcreg] = autask->backup;
+}
+
+static void uprobe_aluwrite_pc(struct arch_uprobe *auprobe,
+                              struct arch_uprobe_task *autask,
+                              struct pt_regs *regs)
+{
+       u32 pcreg = auprobe->pcreg;
+
+       alu_write_pc(regs->uregs[pcreg], regs);
+       regs->uregs[pcreg] = autask->backup;
+}
+
+static void uprobe_write_pc(struct arch_uprobe *auprobe,
+                           struct arch_uprobe_task *autask,
+                           struct pt_regs *regs)
+{
+       u32 pcreg = auprobe->pcreg;
+
+       load_write_pc(regs->uregs[pcreg], regs);
+       regs->uregs[pcreg] = autask->backup;
+}
+
+enum probes_insn
+decode_pc_ro(probes_opcode_t insn, struct arch_probes_insn *asi,
+            const struct decode_header *d)
+{
+       struct arch_uprobe *auprobe = container_of(asi, struct arch_uprobe,
+                                                  asi);
+       struct decode_emulate *decode = (struct decode_emulate *) d;
+       u32 regs = decode->header.type_regs.bits >> DECODE_TYPE_BITS;
+       int reg;
+
+       reg = uprobes_substitute_pc(&auprobe->ixol[0], regs);
+       if (reg == 15)
+               return INSN_GOOD;
+
+       if (reg == -1)
+               return INSN_REJECTED;
+
+       auprobe->pcreg = reg;
+       auprobe->prehandler = uprobe_set_pc;
+       auprobe->posthandler = uprobe_unset_pc;
+
+       return INSN_GOOD;
+}
+
+enum probes_insn
+decode_wb_pc(probes_opcode_t insn, struct arch_probes_insn *asi,
+            const struct decode_header *d, bool alu)
+{
+       struct arch_uprobe *auprobe = container_of(asi, struct arch_uprobe,
+                                                  asi);
+       enum probes_insn ret = decode_pc_ro(insn, asi, d);
+
+       if (((insn >> 12) & 0xf) == 15)
+               auprobe->posthandler = alu ? uprobe_aluwrite_pc
+                                          : uprobe_write_pc;
+
+       return ret;
+}
+
+enum probes_insn
+decode_rd12rn16rm0rs8_rwflags(probes_opcode_t insn,
+                             struct arch_probes_insn *asi,
+                             const struct decode_header *d)
+{
+       return decode_wb_pc(insn, asi, d, true);
+}
+
+enum probes_insn
+decode_ldr(probes_opcode_t insn, struct arch_probes_insn *asi,
+          const struct decode_header *d)
+{
+       return decode_wb_pc(insn, asi, d, false);
+}
+
+enum probes_insn
+uprobe_decode_ldmstm(probes_opcode_t insn,
+                    struct arch_probes_insn *asi,
+                    const struct decode_header *d)
+{
+       struct arch_uprobe *auprobe = container_of(asi, struct arch_uprobe,
+                                                  asi);
+       unsigned reglist = insn & 0xffff;
+       int rn = (insn >> 16) & 0xf;
+       int lbit = insn & (1 << 20);
+       unsigned used = reglist | (1 << rn);
+
+       if (rn == 15)
+               return INSN_REJECTED;
+
+       if (!(used & (1 << 15)))
+               return INSN_GOOD;
+
+       if (used & (1 << 14))
+               return INSN_REJECTED;
+
+       /* Use LR instead of PC */
+       insn ^= 0xc000;
+
+       auprobe->pcreg = 14;
+       auprobe->ixol[0] = __opcode_to_mem_arm(insn);
+
+       auprobe->prehandler = uprobe_set_pc;
+       if (lbit)
+               auprobe->posthandler = uprobe_write_pc;
+       else
+               auprobe->posthandler = uprobe_unset_pc;
+
+       return INSN_GOOD;
+}
+
+const union decode_action uprobes_probes_actions[] = {
+       [PROBES_EMULATE_NONE] = {.handler = probes_simulate_nop},
+       [PROBES_SIMULATE_NOP] = {.handler = probes_simulate_nop},
+       [PROBES_PRELOAD_IMM] = {.handler = probes_simulate_nop},
+       [PROBES_PRELOAD_REG] = {.handler = probes_simulate_nop},
+       [PROBES_BRANCH_IMM] = {.handler = simulate_blx1},
+       [PROBES_MRS] = {.handler = simulate_mrs},
+       [PROBES_BRANCH_REG] = {.handler = simulate_blx2bx},
+       [PROBES_CLZ] = {.handler = probes_simulate_nop},
+       [PROBES_SATURATING_ARITHMETIC] = {.handler = probes_simulate_nop},
+       [PROBES_MUL1] = {.handler = probes_simulate_nop},
+       [PROBES_MUL2] = {.handler = probes_simulate_nop},
+       [PROBES_SWP] = {.handler = probes_simulate_nop},
+       [PROBES_LDRSTRD] = {.decoder = decode_pc_ro},
+       [PROBES_LOAD_EXTRA] = {.decoder = decode_pc_ro},
+       [PROBES_LOAD] = {.decoder = decode_ldr},
+       [PROBES_STORE_EXTRA] = {.decoder = decode_pc_ro},
+       [PROBES_STORE] = {.decoder = decode_pc_ro},
+       [PROBES_MOV_IP_SP] = {.handler = simulate_mov_ipsp},
+       [PROBES_DATA_PROCESSING_REG] = {
+               .decoder = decode_rd12rn16rm0rs8_rwflags},
+       [PROBES_DATA_PROCESSING_IMM] = {
+               .decoder = decode_rd12rn16rm0rs8_rwflags},
+       [PROBES_MOV_HALFWORD] = {.handler = probes_simulate_nop},
+       [PROBES_SEV] = {.handler = probes_simulate_nop},
+       [PROBES_WFE] = {.handler = probes_simulate_nop},
+       [PROBES_SATURATE] = {.handler = probes_simulate_nop},
+       [PROBES_REV] = {.handler = probes_simulate_nop},
+       [PROBES_MMI] = {.handler = probes_simulate_nop},
+       [PROBES_PACK] = {.handler = probes_simulate_nop},
+       [PROBES_EXTEND] = {.handler = probes_simulate_nop},
+       [PROBES_EXTEND_ADD] = {.handler = probes_simulate_nop},
+       [PROBES_MUL_ADD_LONG] = {.handler = probes_simulate_nop},
+       [PROBES_MUL_ADD] = {.handler = probes_simulate_nop},
+       [PROBES_BITFIELD] = {.handler = probes_simulate_nop},
+       [PROBES_BRANCH] = {.handler = simulate_bbl},
+       [PROBES_LDMSTM] = {.decoder = uprobe_decode_ldmstm}
+};
diff --git a/arch/arm/kernel/uprobes.c b/arch/arm/kernel/uprobes.c
new file mode 100644 (file)
index 0000000..f9bacee
--- /dev/null
@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) 2012 Rabin Vincent <rabin at rab.in>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/errno.h>
+#include <linux/highmem.h>
+#include <linux/sched.h>
+#include <linux/uprobes.h>
+#include <linux/notifier.h>
+
+#include <asm/opcodes.h>
+#include <asm/traps.h>
+
+#include "probes.h"
+#include "probes-arm.h"
+#include "uprobes.h"
+
+#define UPROBE_TRAP_NR UINT_MAX
+
+bool is_swbp_insn(uprobe_opcode_t *insn)
+{
+       return (__mem_to_opcode_arm(*insn) & 0x0fffffff) ==
+               (UPROBE_SWBP_ARM_INSN & 0x0fffffff);
+}
+
+int set_swbp(struct arch_uprobe *auprobe, struct mm_struct *mm,
+            unsigned long vaddr)
+{
+       return uprobe_write_opcode(mm, vaddr,
+                  __opcode_to_mem_arm(auprobe->bpinsn));
+}
+
+bool arch_uprobe_ignore(struct arch_uprobe *auprobe, struct pt_regs *regs)
+{
+       if (!auprobe->asi.insn_check_cc(regs->ARM_cpsr)) {
+               regs->ARM_pc += 4;
+               return true;
+       }
+
+       return false;
+}
+
+bool arch_uprobe_skip_sstep(struct arch_uprobe *auprobe, struct pt_regs *regs)
+{
+       probes_opcode_t opcode;
+
+       if (!auprobe->simulate)
+               return false;
+
+       opcode = __mem_to_opcode_arm(*(unsigned int *) auprobe->insn);
+
+       auprobe->asi.insn_singlestep(opcode, &auprobe->asi, regs);
+
+       return true;
+}
+
+unsigned long
+arch_uretprobe_hijack_return_addr(unsigned long trampoline_vaddr,
+                                 struct pt_regs *regs)
+{
+       unsigned long orig_ret_vaddr;
+
+       orig_ret_vaddr = regs->ARM_lr;
+       /* Replace the return addr with trampoline addr */
+       regs->ARM_lr = trampoline_vaddr;
+       return orig_ret_vaddr;
+}
+
+int arch_uprobe_analyze_insn(struct arch_uprobe *auprobe, struct mm_struct *mm,
+                            unsigned long addr)
+{
+       unsigned int insn;
+       unsigned int bpinsn;
+       enum probes_insn ret;
+
+       /* Thumb not yet support */
+       if (addr & 0x3)
+               return -EINVAL;
+
+       insn = __mem_to_opcode_arm(*(unsigned int *)auprobe->insn);
+       auprobe->ixol[0] = __opcode_to_mem_arm(insn);
+       auprobe->ixol[1] = __opcode_to_mem_arm(UPROBE_SS_ARM_INSN);
+
+       ret = arm_probes_decode_insn(insn, &auprobe->asi, false,
+                                    uprobes_probes_actions);
+       switch (ret) {
+       case INSN_REJECTED:
+               return -EINVAL;
+
+       case INSN_GOOD_NO_SLOT:
+               auprobe->simulate = true;
+               break;
+
+       case INSN_GOOD:
+       default:
+               break;
+       }
+
+       bpinsn = UPROBE_SWBP_ARM_INSN & 0x0fffffff;
+       if (insn >= 0xe0000000)
+               bpinsn |= 0xe0000000;  /* Unconditional instruction */
+       else
+               bpinsn |= insn & 0xf0000000;  /* Copy condition from insn */
+
+       auprobe->bpinsn = bpinsn;
+
+       return 0;
+}
+
+int arch_uprobe_pre_xol(struct arch_uprobe *auprobe, struct pt_regs *regs)
+{
+       struct uprobe_task *utask = current->utask;
+
+       if (auprobe->prehandler)
+               auprobe->prehandler(auprobe, &utask->autask, regs);
+
+       utask->autask.saved_trap_no = current->thread.trap_no;
+       current->thread.trap_no = UPROBE_TRAP_NR;
+       regs->ARM_pc = utask->xol_vaddr;
+
+       return 0;
+}
+
+int arch_uprobe_post_xol(struct arch_uprobe *auprobe, struct pt_regs *regs)
+{
+       struct uprobe_task *utask = current->utask;
+
+       WARN_ON_ONCE(current->thread.trap_no != UPROBE_TRAP_NR);
+
+       current->thread.trap_no = utask->autask.saved_trap_no;
+       regs->ARM_pc = utask->vaddr + 4;
+
+       if (auprobe->posthandler)
+               auprobe->posthandler(auprobe, &utask->autask, regs);
+
+       return 0;
+}
+
+bool arch_uprobe_xol_was_trapped(struct task_struct *t)
+{
+       if (t->thread.trap_no != UPROBE_TRAP_NR)
+               return true;
+
+       return false;
+}
+
+void arch_uprobe_abort_xol(struct arch_uprobe *auprobe, struct pt_regs *regs)
+{
+       struct uprobe_task *utask = current->utask;
+
+       current->thread.trap_no = utask->autask.saved_trap_no;
+       instruction_pointer_set(regs, utask->vaddr);
+}
+
+int arch_uprobe_exception_notify(struct notifier_block *self,
+                                unsigned long val, void *data)
+{
+       return NOTIFY_DONE;
+}
+
+static int uprobe_trap_handler(struct pt_regs *regs, unsigned int instr)
+{
+       unsigned long flags;
+
+       local_irq_save(flags);
+       instr &= 0x0fffffff;
+       if (instr == (UPROBE_SWBP_ARM_INSN & 0x0fffffff))
+               uprobe_pre_sstep_notifier(regs);
+       else if (instr == (UPROBE_SS_ARM_INSN & 0x0fffffff))
+               uprobe_post_sstep_notifier(regs);
+       local_irq_restore(flags);
+
+       return 0;
+}
+
+unsigned long uprobe_get_swbp_addr(struct pt_regs *regs)
+{
+       return instruction_pointer(regs);
+}
+
+static struct undef_hook uprobes_arm_break_hook = {
+       .instr_mask     = 0x0fffffff,
+       .instr_val      = (UPROBE_SWBP_ARM_INSN & 0x0fffffff),
+       .cpsr_mask      = MODE_MASK,
+       .cpsr_val       = USR_MODE,
+       .fn             = uprobe_trap_handler,
+};
+
+static struct undef_hook uprobes_arm_ss_hook = {
+       .instr_mask     = 0x0fffffff,
+       .instr_val      = (UPROBE_SS_ARM_INSN & 0x0fffffff),
+       .cpsr_mask      = MODE_MASK,
+       .cpsr_val       = USR_MODE,
+       .fn             = uprobe_trap_handler,
+};
+
+static int arch_uprobes_init(void)
+{
+       register_undef_hook(&uprobes_arm_break_hook);
+       register_undef_hook(&uprobes_arm_ss_hook);
+
+       return 0;
+}
+device_initcall(arch_uprobes_init);
diff --git a/arch/arm/kernel/uprobes.h b/arch/arm/kernel/uprobes.h
new file mode 100644 (file)
index 0000000..1d0c12d
--- /dev/null
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2012 Rabin Vincent <rabin at rab.in>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __ARM_KERNEL_UPROBES_H
+#define __ARM_KERNEL_UPROBES_H
+
+enum probes_insn uprobe_decode_ldmstm(probes_opcode_t insn,
+                                     struct arch_probes_insn *asi,
+                                     const struct decode_header *d);
+
+enum probes_insn decode_ldr(probes_opcode_t insn,
+                           struct arch_probes_insn *asi,
+                           const struct decode_header *d);
+
+enum probes_insn
+decode_rd12rn16rm0rs8_rwflags(probes_opcode_t insn,
+                             struct arch_probes_insn *asi,
+                             const struct decode_header *d);
+
+enum probes_insn
+decode_wb_pc(probes_opcode_t insn, struct arch_probes_insn *asi,
+            const struct decode_header *d, bool alu);
+
+enum probes_insn
+decode_pc_ro(probes_opcode_t insn, struct arch_probes_insn *asi,
+            const struct decode_header *d);
+
+extern const union decode_action uprobes_probes_actions[];
+
+#endif