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>
This commit is contained in:
Jan Willeke
Martin Schwidefsky
parent
975fab1739
commit
2a0a5b2299
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
@ -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 \
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -322,6 +327,16 @@ sysc_notify_resume:
|
|||
larl %r14,sysc_return
|
||||
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
|
||||
#
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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 *) ®s->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(®s->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;
|
||||
}
|
||||
Loading…
Reference in New Issue