s390/uprobes: architecture backend for uprobes

Signed-off-by: Jan Willeke <willeke@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

10 files changed, 430 insertions, 13 deletions

diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig
index 47492fc692f4..608adfb65dd3 100644
--- a/arch/s390/Kconfig
+++ b/arch/s390/Kconfig
@@ -58,6 +58,9 @@ config NO_IOPORT_MAP
 config PCI_QUIRKS
         def_bool n
 
+config ARCH_SUPPORTS_UPROBES
+        def_bool 64BIT
+
 config S390
         def_bool y
         select ARCH_HAS_ATOMIC64_DEC_IF_POSITIVE
diff --git a/arch/s390/include/asm/ptrace.h b/arch/s390/include/asm/ptrace.h
index 55d69dd7473c..be317feff7ac 100644
--- a/arch/s390/include/asm/ptrace.h
+++ b/arch/s390/include/asm/ptrace.h
@@ -161,6 +161,12 @@ static inline long regs_return_value(struct pt_regs *regs)
         return regs->gprs[2];
 }
 
+static inline void instruction_pointer_set(struct pt_regs *regs,
+                                           unsigned long val)
+{
+        regs->psw.addr = val | PSW_ADDR_AMODE;
+}
+
 int regs_query_register_offset(const char *name);
 const char *regs_query_register_name(unsigned int offset);
 unsigned long regs_get_register(struct pt_regs *regs, unsigned int offset);
diff --git a/arch/s390/include/asm/thread_info.h b/arch/s390/include/asm/thread_info.h
index b833e9c0bfbf..4d62fd5b56e5 100644
--- a/arch/s390/include/asm/thread_info.h
+++ b/arch/s390/include/asm/thread_info.h
@@ -84,11 +84,13 @@ static inline struct thread_info *current_thread_info(void)
 #define TIF_SYSCALL_AUDIT       4       /* syscall auditing active */
 #define TIF_SECCOMP             5       /* secure computing */
 #define TIF_SYSCALL_TRACEPOINT  6       /* syscall tracepoint instrumentation */
+#define TIF_UPROBE              7       /* breakpointed or single-stepping */
 #define TIF_31BIT               16      /* 32bit process */
 #define TIF_MEMDIE              17      /* is terminating due to OOM killer */
 #define TIF_RESTORE_SIGMASK     18      /* restore signal mask in do_signal() */
 #define TIF_SINGLE_STEP         19      /* This task is single stepped */
 #define TIF_BLOCK_STEP          20      /* This task is block stepped */
+#define TIF_UPROBE_SINGLESTEP   21      /* This task is uprobe single stepped */
 
 #define _TIF_NOTIFY_RESUME      (1<<TIF_NOTIFY_RESUME)
 #define _TIF_SIGPENDING         (1<<TIF_SIGPENDING)
@@ -97,6 +99,7 @@ static inline struct thread_info *current_thread_info(void)
 #define _TIF_SYSCALL_AUDIT      (1<<TIF_SYSCALL_AUDIT)
 #define _TIF_SECCOMP            (1<<TIF_SECCOMP)
 #define _TIF_SYSCALL_TRACEPOINT (1<<TIF_SYSCALL_TRACEPOINT)
+#define _TIF_UPROBE             (1<<TIF_UPROBE)
 #define _TIF_31BIT              (1<<TIF_31BIT)
 #define _TIF_SINGLE_STEP        (1<<TIF_SINGLE_STEP)
 
diff --git a/arch/s390/include/asm/uprobes.h b/arch/s390/include/asm/uprobes.h
new file mode 100644
index 000000000000..1411dff7fea7
--- /dev/null
+++ b/arch/s390/include/asm/uprobes.h
@@ -0,0 +1,42 @@
+/*
+ *    User-space Probes (UProbes) for s390
+ *
+ *    Copyright IBM Corp. 2014
+ *    Author(s): Jan Willeke,
+ */
+
+#ifndef _ASM_UPROBES_H
+#define _ASM_UPROBES_H
+
+#include <linux/notifier.h>
+
+typedef u16 uprobe_opcode_t;
+
+#define UPROBE_XOL_SLOT_BYTES   256 /* cache aligned */
+
+#define UPROBE_SWBP_INSN        0x0002
+#define UPROBE_SWBP_INSN_SIZE   2
+
+struct arch_uprobe {
+        union{
+                uprobe_opcode_t insn[3];
+                uprobe_opcode_t ixol[3];
+        };
+        unsigned int saved_per : 1;
+        unsigned int saved_int_code;
+};
+
+struct arch_uprobe_task {
+};
+
+int arch_uprobe_analyze_insn(struct arch_uprobe *aup, struct mm_struct *mm,
+                             unsigned long addr);
+int arch_uprobe_pre_xol(struct arch_uprobe *aup, struct pt_regs *regs);
+int arch_uprobe_post_xol(struct arch_uprobe *aup, struct pt_regs *regs);
+bool arch_uprobe_xol_was_trapped(struct task_struct *tsk);
+int arch_uprobe_exception_notify(struct notifier_block *self, unsigned long val,
+                                 void *data);
+void arch_uprobe_abort_xol(struct arch_uprobe *ap, struct pt_regs *regs);
+unsigned long arch_uretprobe_hijack_return_addr(unsigned long trampoline,
+                                                struct pt_regs *regs);
+#endif  /* _ASM_UPROBES_H */
diff --git a/arch/s390/kernel/Makefile b/arch/s390/kernel/Makefile
index d44245d4df37..3249e1f36d55 100644
--- a/arch/s390/kernel/Makefile
+++ b/arch/s390/kernel/Makefile
@@ -55,6 +55,7 @@ obj-$(CONFIG_KPROBES)		+= kprobes.o
 obj-$(CONFIG_FUNCTION_TRACER)   += $(if $(CONFIG_64BIT),mcount64.o,mcount.o)
 obj-$(CONFIG_FUNCTION_TRACER)   += ftrace.o
 obj-$(CONFIG_CRASH_DUMP)        += crash_dump.o
+obj-$(CONFIG_UPROBES)           += uprobes.o
 
 ifdef CONFIG_64BIT
 obj-$(CONFIG_PERF_EVENTS)       += perf_event.o perf_cpum_cf.o perf_cpum_sf.o \
diff --git a/arch/s390/kernel/entry.h b/arch/s390/kernel/entry.h
index 1aad48398d06..58541633b8d6 100644
--- a/arch/s390/kernel/entry.h
+++ b/arch/s390/kernel/entry.h
@@ -45,6 +45,7 @@ void transaction_exception(struct pt_regs *regs);
 void translation_exception(struct pt_regs *regs);
 
 void do_per_trap(struct pt_regs *regs);
+void do_report_trap(struct pt_regs *regs, int si_signo, int si_code, char *str);
 void syscall_trace(struct pt_regs *regs, int entryexit);
 void kernel_stack_overflow(struct pt_regs * regs);
 void do_signal(struct pt_regs *regs);
diff --git a/arch/s390/kernel/entry64.S b/arch/s390/kernel/entry64.S
index f2e674c702e1..7b2e03afd017 100644
--- a/arch/s390/kernel/entry64.S
+++ b/arch/s390/kernel/entry64.S
@@ -42,7 +42,8 @@ STACK_SHIFT = PAGE_SHIFT + THREAD_ORDER
 STACK_SIZE  = 1 << STACK_SHIFT
 STACK_INIT = STACK_SIZE - STACK_FRAME_OVERHEAD - __PT_SIZE
 
-_TIF_WORK       = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED)
+_TIF_WORK       = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \
+                   _TIF_UPROBE)
 _TIF_TRACE      = (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | _TIF_SECCOMP | \
                    _TIF_SYSCALL_TRACEPOINT)
 _CIF_WORK       = (_CIF_MCCK_PENDING | _CIF_ASCE)
@@ -265,6 +266,10 @@ sysc_work:
         jo      sysc_mcck_pending
         tm      __TI_flags+7(%r12),_TIF_NEED_RESCHED
         jo      sysc_reschedule
+#ifdef CONFIG_UPROBES
+        tm      __TI_flags+7(%r12),_TIF_UPROBE
+        jo      sysc_uprobe_notify
+#endif
         tm      __PT_FLAGS+7(%r11),_PIF_PER_TRAP
         jo      sysc_singlestep
         tm      __TI_flags+7(%r12),_TIF_SIGPENDING
@@ -323,6 +328,16 @@ sysc_notify_resume:
         jg      do_notify_resume
 
 #
+# _TIF_UPROBE is set, call uprobe_notify_resume
+#
+#ifdef CONFIG_UPROBES
+sysc_uprobe_notify:
+        lgr     %r2,%r11                # pass pointer to pt_regs
+        larl    %r14,sysc_return
+        jg      uprobe_notify_resume
+#endif
+
+#
 # _PIF_PER_TRAP is set, call do_per_trap
 #
 sysc_singlestep:
diff --git a/arch/s390/kernel/ptrace.c b/arch/s390/kernel/ptrace.c
index 5dc7ad9e2fbf..fe99d6b3f185 100644
--- a/arch/s390/kernel/ptrace.c
+++ b/arch/s390/kernel/ptrace.c
@@ -84,7 +84,8 @@ void update_cr_regs(struct task_struct *task)
         new.end = thread->per_user.end;
 
         /* merge TIF_SINGLE_STEP into user specified PER registers. */
-        if (test_tsk_thread_flag(task, TIF_SINGLE_STEP)) {
+        if (test_tsk_thread_flag(task, TIF_SINGLE_STEP) ||
+            test_tsk_thread_flag(task, TIF_UPROBE_SINGLESTEP)) {
                 if (test_tsk_thread_flag(task, TIF_BLOCK_STEP))
                         new.control |= PER_EVENT_BRANCH;
                 else
@@ -93,6 +94,8 @@ void update_cr_regs(struct task_struct *task)
                 new.control |= PER_CONTROL_SUSPENSION;
                 new.control |= PER_EVENT_TRANSACTION_END;
 #endif
+                if (test_tsk_thread_flag(task, TIF_UPROBE_SINGLESTEP))
+                        new.control |= PER_EVENT_IFETCH;
                 new.start = 0;
                 new.end = PSW_ADDR_INSN;
         }
diff --git a/arch/s390/kernel/traps.c b/arch/s390/kernel/traps.c
index c5762324d9ee..e3e06a4fdfce 100644
--- a/arch/s390/kernel/traps.c
+++ b/arch/s390/kernel/traps.c
@@ -58,15 +58,10 @@ int is_valid_bugaddr(unsigned long addr)
         return 1;
 }
 
-static void __kprobes do_trap(struct pt_regs *regs,
-                              int si_signo, int si_code, char *str)
+void do_report_trap(struct pt_regs *regs, int si_signo, int si_code, char *str)
 {
         siginfo_t info;
 
-        if (notify_die(DIE_TRAP, str, regs, 0,
-                       regs->int_code, si_signo) == NOTIFY_STOP)
-                return;
-
         if (user_mode(regs)) {
                 info.si_signo = si_signo;
                 info.si_errno = 0;
@@ -90,6 +85,15 @@ static void __kprobes do_trap(struct pt_regs *regs,
         }
 }
 
+static void __kprobes do_trap(struct pt_regs *regs, int si_signo, int si_code,
+                              char *str)
+{
+        if (notify_die(DIE_TRAP, str, regs, 0,
+                       regs->int_code, si_signo) == NOTIFY_STOP)
+                return;
+        do_report_trap(regs, si_signo, si_code, str);
+}
+
 void __kprobes do_per_trap(struct pt_regs *regs)
 {
         siginfo_t info;
@@ -178,6 +182,7 @@ void __kprobes illegal_op(struct pt_regs *regs)
         siginfo_t info;
         __u8 opcode[6];
         __u16 __user *location;
+        int is_uprobe_insn = 0;
         int signal = 0;
 
         location = get_trap_ip(regs);
@@ -194,6 +199,10 @@ void __kprobes illegal_op(struct pt_regs *regs)
                                 force_sig_info(SIGTRAP, &info, current);
                         } else
                                 signal = SIGILL;
+#ifdef CONFIG_UPROBES
+                } else if (*((__u16 *) opcode) == UPROBE_SWBP_INSN) {
+                        is_uprobe_insn = 1;
+#endif
 #ifdef CONFIG_MATHEMU
                 } else if (opcode[0] == 0xb3) {
                         if (get_user(*((__u16 *) (opcode+2)), location+1))
@@ -219,11 +228,13 @@ void __kprobes illegal_op(struct pt_regs *regs)
 #endif
                 } else
                         signal = SIGILL;
-        } else {
-                /*
-                 * If we get an illegal op in kernel mode, send it through the
-                 * kprobes notifier. If kprobes doesn't pick it up, SIGILL
-                 */
+        }
+        /*
+         * We got either an illegal op in kernel mode, or user space trapped
+         * on a uprobes illegal instruction. See if kprobes or uprobes picks
+         * it up. If not, SIGILL.
+         */
+        if (is_uprobe_insn || !user_mode(regs)) {
                 if (notify_die(DIE_BPT, "bpt", regs, 0,
                                3, SIGTRAP) != NOTIFY_STOP)
                         signal = SIGILL;
diff --git a/arch/s390/kernel/uprobes.c b/arch/s390/kernel/uprobes.c
new file mode 100644
index 000000000000..956f4f7a591c
--- /dev/null
+++ b/arch/s390/kernel/uprobes.c
@@ -0,0 +1,332 @@
+/*
+ *  User-space Probes (UProbes) for s390
+ *
+ *    Copyright IBM Corp. 2014
+ *    Author(s): Jan Willeke,
+ */
+
+#include <linux/kprobes.h>
+#include <linux/uaccess.h>
+#include <linux/uprobes.h>
+#include <linux/compat.h>
+#include <linux/kdebug.h>
+#include <asm/switch_to.h>
+#include <asm/facility.h>
+#include <asm/dis.h>
+#include "entry.h"
+
+#define UPROBE_TRAP_NR  UINT_MAX
+
+int arch_uprobe_analyze_insn(struct arch_uprobe *auprobe, struct mm_struct *mm,
+                             unsigned long addr)
+{
+        return probe_is_prohibited_opcode(auprobe->insn);
+}
+
+int arch_uprobe_pre_xol(struct arch_uprobe *auprobe, struct pt_regs *regs)
+{
+        if (psw_bits(regs->psw).eaba == PSW_AMODE_24BIT)
+                return -EINVAL;
+        if (!is_compat_task() && psw_bits(regs->psw).eaba == PSW_AMODE_31BIT)
+                return -EINVAL;
+        clear_pt_regs_flag(regs, PIF_PER_TRAP);
+        auprobe->saved_per = psw_bits(regs->psw).r;
+        auprobe->saved_int_code = regs->int_code;
+        regs->int_code = UPROBE_TRAP_NR;
+        regs->psw.addr = current->utask->xol_vaddr;
+        set_tsk_thread_flag(current, TIF_UPROBE_SINGLESTEP);
+        update_cr_regs(current);
+        return 0;
+}
+
+bool arch_uprobe_xol_was_trapped(struct task_struct *tsk)
+{
+        struct pt_regs *regs = task_pt_regs(tsk);
+
+        if (regs->int_code != UPROBE_TRAP_NR)
+                return true;
+        return false;
+}
+
+int arch_uprobe_post_xol(struct arch_uprobe *auprobe, struct pt_regs *regs)
+{
+        int fixup = probe_get_fixup_type(auprobe->insn);
+        struct uprobe_task *utask = current->utask;
+
+        clear_tsk_thread_flag(current, TIF_UPROBE_SINGLESTEP);
+        update_cr_regs(current);
+        psw_bits(regs->psw).r = auprobe->saved_per;
+        regs->int_code = auprobe->saved_int_code;
+
+        if (fixup & FIXUP_PSW_NORMAL)
+                regs->psw.addr += utask->vaddr - utask->xol_vaddr;
+        if (fixup & FIXUP_RETURN_REGISTER) {
+                int reg = (auprobe->insn[0] & 0xf0) >> 4;
+
+                regs->gprs[reg] += utask->vaddr - utask->xol_vaddr;
+        }
+        if (fixup & FIXUP_BRANCH_NOT_TAKEN) {
+                int ilen = insn_length(auprobe->insn[0] >> 8);
+
+                if (regs->psw.addr - utask->xol_vaddr == ilen)
+                        regs->psw.addr = utask->vaddr + ilen;
+        }
+        /* If per tracing was active generate trap */
+        if (regs->psw.mask & PSW_MASK_PER)
+                do_per_trap(regs);
+        return 0;
+}
+
+int arch_uprobe_exception_notify(struct notifier_block *self, unsigned long val,
+                                 void *data)
+{
+        struct die_args *args = data;
+        struct pt_regs *regs = args->regs;
+
+        if (!user_mode(regs))
+                return NOTIFY_DONE;
+        if (regs->int_code & 0x200) /* Trap during transaction */
+                return NOTIFY_DONE;
+        switch (val) {
+        case DIE_BPT:
+                if (uprobe_pre_sstep_notifier(regs))
+                        return NOTIFY_STOP;
+                break;
+        case DIE_SSTEP:
+                if (uprobe_post_sstep_notifier(regs))
+                        return NOTIFY_STOP;
+        default:
+                break;
+        }
+        return NOTIFY_DONE;
+}
+
+void arch_uprobe_abort_xol(struct arch_uprobe *auprobe, struct pt_regs *regs)
+{
+        clear_thread_flag(TIF_UPROBE_SINGLESTEP);
+        regs->int_code = auprobe->saved_int_code;
+        regs->psw.addr = current->utask->vaddr;
+}
+
+unsigned long arch_uretprobe_hijack_return_addr(unsigned long trampoline,
+                                                struct pt_regs *regs)
+{
+        unsigned long orig;
+
+        orig = regs->gprs[14];
+        regs->gprs[14] = trampoline;
+        return orig;
+}
+
+/* Instruction Emulation */
+
+static void adjust_psw_addr(psw_t *psw, unsigned long len)
+{
+        psw->addr = __rewind_psw(*psw, -len);
+}
+
+#define EMU_ILLEGAL_OP          1
+#define EMU_SPECIFICATION       2
+#define EMU_ADDRESSING          3
+
+#define emu_load_ril(ptr, output)                       \
+({                                                      \
+        unsigned int mask = sizeof(*(ptr)) - 1;         \
+        __typeof__(*(ptr)) input;                       \
+        int __rc = 0;                                   \
+                                                        \
+        if (!test_facility(34))                         \
+                __rc = EMU_ILLEGAL_OP;                  \
+        else if ((u64 __force)ptr & mask)               \
+                __rc = EMU_SPECIFICATION;               \
+        else if (get_user(input, ptr))                  \
+                __rc = EMU_ADDRESSING;                  \
+        else                                            \
+                *(output) = input;                      \
+        __rc;                                           \
+})
+
+#define emu_store_ril(ptr, input)                       \
+({                                                      \
+        unsigned int mask = sizeof(*(ptr)) - 1;         \
+        int __rc = 0;                                   \
+                                                        \
+        if (!test_facility(34))                         \
+                __rc = EMU_ILLEGAL_OP;                  \
+        else if ((u64 __force)ptr & mask)               \
+                __rc = EMU_SPECIFICATION;               \
+        else if (put_user(*(input), ptr))               \
+                __rc = EMU_ADDRESSING;                  \
+        __rc;                                           \
+})
+
+#define emu_cmp_ril(regs, ptr, cmp)                     \
+({                                                      \
+        unsigned int mask = sizeof(*(ptr)) - 1;         \
+        __typeof__(*(ptr)) input;                       \
+        int __rc = 0;                                   \
+                                                        \
+        if (!test_facility(34))                         \
+                __rc = EMU_ILLEGAL_OP;                  \
+        else if ((u64 __force)ptr & mask)               \
+                __rc = EMU_SPECIFICATION;               \
+        else if (get_user(input, ptr))                  \
+                __rc = EMU_ADDRESSING;                  \
+        else if (input > *(cmp))                        \
+                psw_bits((regs)->psw).cc = 1;           \
+        else if (input < *(cmp))                        \
+                psw_bits((regs)->psw).cc = 2;           \
+        else                                            \
+                psw_bits((regs)->psw).cc = 0;           \
+        __rc;                                           \
+})
+
+struct insn_ril {
+        u8 opc0;
+        u8 reg  : 4;
+        u8 opc1 : 4;
+        s32 disp;
+} __packed;
+
+union split_register {
+        u64 u64;
+        u32 u32[2];
+        u16 u16[4];
+        s64 s64;
+        s32 s32[2];
+        s16 s16[4];
+};
+
+/*
+ * pc relative instructions are emulated, since parameters may not be
+ * accessible from the xol area due to range limitations.
+ */
+static void handle_insn_ril(struct arch_uprobe *auprobe, struct pt_regs *regs)
+{
+        union split_register *rx;
+        struct insn_ril *insn;
+        unsigned int ilen;
+        void *uptr;
+        int rc = 0;
+
+        insn = (struct insn_ril *) &auprobe->insn;
+        rx = (union split_register *) &regs->gprs[insn->reg];
+        uptr = (void *)(regs->psw.addr + (insn->disp * 2));
+        ilen = insn_length(insn->opc0);
+
+        switch (insn->opc0) {
+        case 0xc0:
+                switch (insn->opc1) {
+                case 0x00: /* larl */
+                        rx->u64 = (unsigned long)uptr;
+                        break;
+                }
+                break;
+        case 0xc4:
+                switch (insn->opc1) {
+                case 0x02: /* llhrl */
+                        rc = emu_load_ril((u16 __user *)uptr, &rx->u32[1]);
+                        break;
+                case 0x04: /* lghrl */
+                        rc = emu_load_ril((s16 __user *)uptr, &rx->u64);
+                        break;
+                case 0x05: /* lhrl */
+                        rc = emu_load_ril((s16 __user *)uptr, &rx->u32[1]);
+                        break;
+                case 0x06: /* llghrl */
+                        rc = emu_load_ril((u16 __user *)uptr, &rx->u64);
+                        break;
+                case 0x08: /* lgrl */
+                        rc = emu_load_ril((u64 __user *)uptr, &rx->u64);
+                        break;
+                case 0x0c: /* lgfrl */
+                        rc = emu_load_ril((s32 __user *)uptr, &rx->u64);
+                        break;
+                case 0x0d: /* lrl */
+                        rc = emu_load_ril((u32 __user *)uptr, &rx->u32[1]);
+                        break;
+                case 0x0e: /* llgfrl */
+                        rc = emu_load_ril((u32 __user *)uptr, &rx->u64);
+                        break;
+                case 0x07: /* sthrl */
+                        rc = emu_store_ril((u16 __user *)uptr, &rx->u16[3]);
+                        break;
+                case 0x0b: /* stgrl */
+                        rc = emu_store_ril((u64 __user *)uptr, &rx->u64);
+                        break;
+                case 0x0f: /* strl */
+                        rc = emu_store_ril((u32 __user *)uptr, &rx->u32[1]);
+                        break;
+                }
+                break;
+        case 0xc6:
+                switch (insn->opc1) {
+                case 0x02: /* pfdrl */
+                        if (!test_facility(34))
+                                rc = EMU_ILLEGAL_OP;
+                        break;
+                case 0x04: /* cghrl */
+                        rc = emu_cmp_ril(regs, (s16 __user *)uptr, &rx->s64);
+                        break;
+                case 0x05: /* chrl */
+                        rc = emu_cmp_ril(regs, (s16 __user *)uptr, &rx->s32[1]);
+                        break;
+                case 0x06: /* clghrl */
+                        rc = emu_cmp_ril(regs, (u16 __user *)uptr, &rx->u64);
+                        break;
+                case 0x07: /* clhrl */
+                        rc = emu_cmp_ril(regs, (u16 __user *)uptr, &rx->u32[1]);
+                        break;
+                case 0x08: /* cgrl */
+                        rc = emu_cmp_ril(regs, (s64 __user *)uptr, &rx->s64);
+                        break;
+                case 0x0a: /* clgrl */
+                        rc = emu_cmp_ril(regs, (u64 __user *)uptr, &rx->u64);
+                        break;
+                case 0x0c: /* cgfrl */
+                        rc = emu_cmp_ril(regs, (s32 __user *)uptr, &rx->s64);
+                        break;
+                case 0x0d: /* crl */
+                        rc = emu_cmp_ril(regs, (s32 __user *)uptr, &rx->s32[1]);
+                        break;
+                case 0x0e: /* clgfrl */
+                        rc = emu_cmp_ril(regs, (u32 __user *)uptr, &rx->u64);
+                        break;
+                case 0x0f: /* clrl */
+                        rc = emu_cmp_ril(regs, (u32 __user *)uptr, &rx->u32[1]);
+                        break;
+                }
+                break;
+        }
+        adjust_psw_addr(&regs->psw, ilen);
+        switch (rc) {
+        case EMU_ILLEGAL_OP:
+                regs->int_code = ilen << 16 | 0x0001;
+                do_report_trap(regs, SIGILL, ILL_ILLOPC, NULL);
+                break;
+        case EMU_SPECIFICATION:
+                regs->int_code = ilen << 16 | 0x0006;
+                do_report_trap(regs, SIGILL, ILL_ILLOPC , NULL);
+                break;
+        case EMU_ADDRESSING:
+                regs->int_code = ilen << 16 | 0x0005;
+                do_report_trap(regs, SIGSEGV, SEGV_MAPERR, NULL);
+                break;
+        }
+}
+
+bool arch_uprobe_skip_sstep(struct arch_uprobe *auprobe, struct pt_regs *regs)
+{
+        if ((psw_bits(regs->psw).eaba == PSW_AMODE_24BIT) ||
+            ((psw_bits(regs->psw).eaba == PSW_AMODE_31BIT) &&
+             !is_compat_task())) {
+                regs->psw.addr = __rewind_psw(regs->psw, UPROBE_SWBP_INSN_SIZE);
+                do_report_trap(regs, SIGILL, ILL_ILLADR, NULL);
+                return true;
+        }
+        if (probe_is_insn_relative_long(auprobe->insn)) {
+                handle_insn_ril(auprobe, regs);
+                return true;
+        }
+        return false;
+}