[PATCH 2b] utrace: sparc64 regset support This patch converts the machine-dependent ptrace code into utrace regset support for sparc64. Signed-off-by: Roland McGrath Signed-off-by: David S. Miller --- arch/sparc64/kernel/Makefile | 2 arch/sparc64/kernel/ptrace.c | 631 +++++++++++++++++++++++++++++++++++++---- arch/sparc64/kernel/systbls.S | 4 3 files changed, 568 insertions(+), 69 deletions(-) --- linux-2.6/arch/sparc64/kernel/Makefile +++ linux-2.6/arch/sparc64/kernel/Makefile @@ -5,6 +5,8 @@ EXTRA_AFLAGS := -ansi EXTRA_CFLAGS := -Werror +CFLAGS_ptrace.o += -DUTS_MACHINE='"$(UTS_MACHINE)"' + extra-y := head.o init_task.o vmlinux.lds obj-y := process.o setup.o cpu.o idprom.o \ --- linux-2.6/arch/sparc64/kernel/ptrace.c +++ linux-2.6/arch/sparc64/kernel/ptrace.c @@ -1,6 +1,6 @@ -/* ptrace.c: Sparc process tracing support. +/* ptrace.c: Sparc64 process tracing support. * - * Copyright (C) 1996 David S. Miller (davem@caipfs.rutgers.edu) + * Copyright (C) 1996, 2006 David S. Miller (davem@davemloft.net) * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz) * * Based upon code written by Ross Biro, Linus Torvalds, Bob Manson, @@ -11,106 +11,603 @@ */ #include +#include #include #include -#include -#include -#include -#include -#include #include #include #include -#include #include +#include +#include #include #include #include -#include -#include -#include #include #include #include +#include -#if 0 /* XXX */ -/* Returning from ptrace is a bit tricky because the syscall return - * low level code assumes any value returned which is negative and - * is a valid errno will mean setting the condition codes to indicate - * an error return. This doesn't work, so we have this hook. +#define GENREG_G0 0 +#define GENREG_O0 8 +#define GENREG_L0 16 +#define GENREG_I0 24 +#define GENREG_TSTATE 32 +#define GENREG_TPC 33 +#define GENREG_TNPC 34 +#define GENREG_Y 35 + +#define SPARC64_NGREGS 36 + +static int genregs_get(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + void *kbuf, void __user *ubuf) +{ + struct pt_regs *regs = task_pt_regs(target); + int err; + + err = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, regs->u_regs, + GENREG_G0 * 8, GENREG_L0 * 8); + + if (err == 0 && count > 0 && pos < (GENREG_TSTATE * 8)) { + struct thread_info *t = task_thread_info(target); + unsigned long rwindow[16], fp, *win; + int wsaved; + + if (target == current) + flushw_user(); + + wsaved = __thread_flag_byte_ptr(t)[TI_FLAG_BYTE_WSAVED]; + fp = regs->u_regs[UREG_FP] + STACK_BIAS; + if (wsaved && t->rwbuf_stkptrs[wsaved - 1] == fp) + win = &t->reg_window[wsaved - 1].locals[0]; + else { + if (target == current) { + if (copy_from_user(rwindow, + (void __user *) fp, + 16 * sizeof(long))) + err = -EFAULT; + } else + err = access_process_vm(target, fp, rwindow, + 16 * sizeof(long), 0); + if (err) + return err; + win = rwindow; + } + + err = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + win, GENREG_L0 * 8, + GENREG_TSTATE * 8); + } + + if (err == 0) + err = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + ®s->tstate, GENREG_TSTATE * 8, + GENREG_Y * 8); + if (err == 0 && count > 0) { + if (kbuf) + *(unsigned long *) kbuf = regs->y; + else if (put_user(regs->y, (unsigned long __user *) ubuf)) + return -EFAULT; + } + + return err; +} + +/* Consistent with signal handling, we only allow userspace to + * modify the %asi, %icc, and %xcc fields of the %tstate register. */ -static inline void pt_error_return(struct pt_regs *regs, unsigned long error) +#define TSTATE_DEBUGCHANGE (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC) + +static int genregs_set(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, const void __user *ubuf) { - regs->u_regs[UREG_I0] = error; - regs->tstate |= (TSTATE_ICARRY | TSTATE_XCARRY); - regs->tpc = regs->tnpc; - regs->tnpc += 4; + struct pt_regs *regs = task_pt_regs(target); + unsigned long tstate_save; + int err; + + err = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, regs->u_regs, + GENREG_G0 * 8, GENREG_L0 * 8); + + if (err == 0 && count > 0 && pos < (GENREG_TSTATE * 8)) { + unsigned long fp = regs->u_regs[UREG_FP] + STACK_BIAS; + unsigned long rwindow[16], *winbuf; + unsigned int copy = (GENREG_TSTATE * 8) - pos; + unsigned int off; + int err; + + if (target == current) + flushw_user(); + + if (count < copy) + copy = count; + off = pos - (GENREG_L0 * 8); + + if (kbuf) { + winbuf = (unsigned long *) kbuf; + kbuf += copy; + } + else { + winbuf = rwindow; + if (copy_from_user(winbuf, ubuf, copy)) + return -EFAULT; + ubuf += copy; + } + count -= copy; + pos += copy; + + if (target == current) + err = copy_to_user((void __user *) fp + off, + winbuf, copy); + else + err = access_process_vm(target, fp + off, + winbuf, copy, 1); + } + + tstate_save = regs->tstate &~ TSTATE_DEBUGCHANGE; + + if (err == 0) + err = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + ®s->tstate, GENREG_TSTATE * 8, + GENREG_Y * 8); + + regs->tstate &= TSTATE_DEBUGCHANGE; + regs->tstate |= tstate_save; + + if (err == 0 && count > 0) { + if (kbuf) + regs->y = *(unsigned long *) kbuf; + else if (get_user(regs->y, (unsigned long __user *) ubuf)) + return -EFAULT; + } + + return err; +} + +#define FPREG_F0 0 +#define FPREG_FSR 32 +#define FPREG_GSR 33 +#define FPREG_FPRS 34 + +#define SPARC64_NFPREGS 35 + +static int fpregs_get(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + void *kbuf, void __user *ubuf) +{ + struct thread_info *t = task_thread_info(target); + int err; + + err = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + t->fpregs, FPREG_F0 * 8, FPREG_FSR * 8); + + if (err == 0) + err = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + &t->xfsr[0], FPREG_FSR * 8, + FPREG_GSR * 8); + + if (err == 0) + err = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + &t->gsr[0], FPREG_GSR * 8, + FPREG_FPRS * 8); + + if (err == 0 && count > 0) { + struct pt_regs *regs = task_pt_regs(target); + + if (kbuf) + *(unsigned long *) kbuf = regs->fprs; + else if (put_user(regs->fprs, (unsigned long __user *) ubuf)) + return -EFAULT; + } + + return err; } -static inline void pt_succ_return(struct pt_regs *regs, unsigned long value) +static int fpregs_set(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, const void __user *ubuf) { - regs->u_regs[UREG_I0] = value; - regs->tstate &= ~(TSTATE_ICARRY | TSTATE_XCARRY); - regs->tpc = regs->tnpc; - regs->tnpc += 4; + struct thread_info *t = task_thread_info(target); + int err; + + err = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + t->fpregs, FPREG_F0 * 8, FPREG_FSR * 8); + + if (err == 0) + err = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + &t->xfsr[0], FPREG_FSR * 8, + FPREG_GSR * 8); + + if (err == 0) + err = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + &t->gsr[0], FPREG_GSR * 8, + FPREG_FPRS * 8); + + if (err == 0 && count > 0) { + struct pt_regs *regs = task_pt_regs(target); + + if (kbuf) + regs->fprs = *(unsigned long *) kbuf; + else if (get_user(regs->fprs, (unsigned long __user *) ubuf)) + return -EFAULT; + } + + return err; } -static inline void -pt_succ_return_linux(struct pt_regs *regs, unsigned long value, void __user *addr) +static const struct utrace_regset native_regsets[] = { + { + .n = SPARC64_NGREGS, + .size = sizeof(long), .align = sizeof(long), + .get = genregs_get, .set = genregs_set + }, + { + .n = SPARC64_NFPREGS, + .size = sizeof(long), .align = sizeof(long), + .get = fpregs_get, .set = fpregs_set + }, +}; + +static const struct utrace_regset_view utrace_sparc64_native_view = { + .name = UTS_MACHINE, .e_machine = ELF_ARCH, + .regsets = native_regsets, .n = ARRAY_SIZE(native_regsets) +}; + +#ifdef CONFIG_COMPAT + +#define GENREG32_G0 0 +#define GENREG32_O0 8 +#define GENREG32_L0 16 +#define GENREG32_I0 24 +#define GENREG32_PSR 32 +#define GENREG32_PC 33 +#define GENREG32_NPC 34 +#define GENREG32_Y 35 +#define GENREG32_WIM 36 +#define GENREG32_TBR 37 + +#define SPARC32_NGREGS 38 + +static int genregs32_get(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + void *kbuf, void __user *ubuf) { - if (test_thread_flag(TIF_32BIT)) { - if (put_user(value, (unsigned int __user *) addr)) { - pt_error_return(regs, EFAULT); - return; - } - } else { - if (put_user(value, (long __user *) addr)) { - pt_error_return(regs, EFAULT); - return; + struct pt_regs *regs = task_pt_regs(target); + + while (count > 0 && pos < (GENREG32_L0 * 4)) { + u32 val = regs->u_regs[(pos - (GENREG32_G0*4))/sizeof(u32)]; + if (kbuf) { + *(u32 *) kbuf = val; + kbuf += sizeof(u32); + } else if (put_user(val, (u32 __user *) ubuf)) + return -EFAULT; + else + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); + } + + if (count > 0 && pos < (GENREG32_PSR * 4)) { + struct thread_info *t = task_thread_info(target); + unsigned long fp; + u32 rwindow[16]; + int wsaved; + + if (target == current) + flushw_user(); + + wsaved = __thread_flag_byte_ptr(t)[TI_FLAG_BYTE_WSAVED]; + fp = regs->u_regs[UREG_FP] & 0xffffffffUL; + if (wsaved && t->rwbuf_stkptrs[wsaved - 1] == fp) { + int i; + for (i = 0; i < 8; i++) + rwindow[i + 0] = + t->reg_window[wsaved-1].locals[i]; + for (i = 0; i < 8; i++) + rwindow[i + 8] = + t->reg_window[wsaved-1].ins[i]; + } else { + int err; + + if (target == current) { + err = 0; + if (copy_from_user(rwindow, (void __user *) fp, + 16 * sizeof(u32))) + err = -EFAULT; + } else + err = access_process_vm(target, fp, rwindow, + 16 * sizeof(u32), 0); + if (err) + return err; + } + + while (count > 0 && pos < (GENREG32_PSR * 4)) { + u32 val = rwindow[(pos - (GENREG32_L0*4))/sizeof(u32)]; + + if (kbuf) { + *(u32 *) kbuf = val; + kbuf += sizeof(u32); + } else if (put_user(val, (u32 __user *) ubuf)) + return -EFAULT; + else + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); } } - regs->u_regs[UREG_I0] = 0; - regs->tstate &= ~(TSTATE_ICARRY | TSTATE_XCARRY); - regs->tpc = regs->tnpc; - regs->tnpc += 4; + + if (count > 0 && pos == (GENREG32_PSR * 4)) { + u32 psr = tstate_to_psr(regs->tstate); + + if (kbuf) { + *(u32 *) kbuf = psr; + kbuf += sizeof(u32); + } else if (put_user(psr, (u32 __user *) ubuf)) + return -EFAULT; + else + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); + } + + if (count > 0 && pos == (GENREG32_PC * 4)) { + u32 val = regs->tpc; + + if (kbuf) { + *(u32 *) kbuf = val; + kbuf += sizeof(u32); + } else if (put_user(val, (u32 __user *) ubuf)) + return -EFAULT; + else + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); + } + + if (count > 0 && pos == (GENREG32_NPC * 4)) { + u32 val = regs->tnpc; + + if (kbuf) { + *(u32 *) kbuf = val; + kbuf += sizeof(u32); + } else if (put_user(val, (u32 __user *) ubuf)) + return -EFAULT; + else + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); + } + + if (count > 0 && pos == (GENREG32_Y * 4)) { + if (kbuf) { + *(u32 *) kbuf = regs->y; + kbuf += sizeof(u32); + } else if (put_user(regs->y, (u32 __user *) ubuf)) + return -EFAULT; + else + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); + } + + if (count > 0) { + if (kbuf) + memset(kbuf, 0, count); + else if (clear_user(ubuf, count)) + return -EFAULT; + } + + return 0; +} + +static int genregs32_set(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, const void __user *ubuf) +{ + struct pt_regs *regs = task_pt_regs(target); + + while (count > 0 && pos < (GENREG32_L0 * 4)) { + unsigned long *loc; + loc = ®s->u_regs[(pos - (GENREG32_G0*4))/sizeof(u32)]; + if (kbuf) { + *loc = *(u32 *) kbuf; + kbuf += sizeof(u32); + } else if (get_user(*loc, (u32 __user *) ubuf)) + return -EFAULT; + else + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); + } + + if (count > 0 && pos < (GENREG32_PSR * 4)) { + unsigned long fp; + u32 regbuf[16]; + unsigned int off, copy; + int err; + + if (target == current) + flushw_user(); + + copy = (GENREG32_PSR * 4) - pos; + if (count < copy) + copy = count; + BUG_ON(copy > 16 * sizeof(u32)); + + fp = regs->u_regs[UREG_FP] & 0xffffffffUL; + off = pos - (GENREG32_L0 * 4); + if (kbuf) { + memcpy(regbuf, kbuf, copy); + kbuf += copy; + } else if (copy_from_user(regbuf, ubuf, copy)) + return -EFAULT; + else + ubuf += copy; + pos += copy; + count -= copy; + + if (target == current) { + err = 0; + if (copy_to_user((void __user *) fp + off, + regbuf, count)) + err = -EFAULT; + } else + err = access_process_vm(target, fp + off, + regbuf, count, 1); + if (err) + return err; + } + + if (count > 0 && pos == (GENREG32_PSR * 4)) { + unsigned long tstate, tstate_save; + u32 psr; + + tstate_save = regs->tstate&~(TSTATE_ICC|TSTATE_XCC); + + if (kbuf) { + psr = *(u32 *) kbuf; + kbuf += sizeof(u32); + } else if (get_user(psr, (u32 __user *) ubuf)) + return -EFAULT; + else + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); + + tstate = psr_to_tstate_icc(psr); + regs->tstate = tstate_save | tstate; + } + + if (count > 0 && pos == (GENREG32_PC * 4)) { + if (kbuf) { + regs->tpc = *(u32 *) kbuf; + kbuf += sizeof(u32); + } else if (get_user(regs->tpc, (u32 __user *) ubuf)) + return -EFAULT; + else + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); + } + + if (count > 0 && pos == (GENREG32_NPC * 4)) { + if (kbuf) { + regs->tnpc = *(u32 *) kbuf; + kbuf += sizeof(u32); + } else if (get_user(regs->tnpc, (u32 __user *) ubuf)) + return -EFAULT; + else + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); + } + + if (count > 0 && pos == (GENREG32_Y * 4)) { + if (kbuf) { + regs->y = *(u32 *) kbuf; + kbuf += sizeof(u32); + } else if (get_user(regs->y, (u32 __user *) ubuf)) + return -EFAULT; + else + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); + } + + /* Ignore WIM and TBR */ + + return 0; } -static void -pt_os_succ_return (struct pt_regs *regs, unsigned long val, void __user *addr) +#define FPREG32_F0 0 +#define FPREG32_FSR 32 + +#define SPARC32_NFPREGS 33 + +static int fpregs32_get(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + void *kbuf, void __user *ubuf) { - if (current->personality == PER_SUNOS) - pt_succ_return (regs, val); - else - pt_succ_return_linux (regs, val, addr); + struct thread_info *t = task_thread_info(target); + int err; + + err = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + t->fpregs, FPREG32_F0 * 4, + FPREG32_FSR * 4); + + if (err == 0 && count > 0) { + if (kbuf) { + *(u32 *) kbuf = t->xfsr[0]; + } else if (put_user(t->xfsr[0], (u32 __user *) ubuf)) + return -EFAULT; + } + + return err; } -#endif -/* #define ALLOW_INIT_TRACING */ -/* #define DEBUG_PTRACE */ +static int fpregs32_set(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, const void __user *ubuf) +{ + struct thread_info *t = task_thread_info(target); + int err; -#ifdef DEBUG_PTRACE -char *pt_rq [] = { - /* 0 */ "TRACEME", "PEEKTEXT", "PEEKDATA", "PEEKUSR", - /* 4 */ "POKETEXT", "POKEDATA", "POKEUSR", "CONT", - /* 8 */ "KILL", "SINGLESTEP", "SUNATTACH", "SUNDETACH", - /* 12 */ "GETREGS", "SETREGS", "GETFPREGS", "SETFPREGS", - /* 16 */ "READDATA", "WRITEDATA", "READTEXT", "WRITETEXT", - /* 20 */ "GETFPAREGS", "SETFPAREGS", "unknown", "unknown", - /* 24 */ "SYSCALL", "" + err = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + t->fpregs, FPREG32_F0 * 4, + FPREG32_FSR * 4); + + if (err == 0 && count > 0) { + u32 fsr; + if (kbuf) { + fsr = *(u32 *) kbuf; + } else if (get_user(fsr, (u32 __user *) ubuf)) + return -EFAULT; + t->xfsr[0] = (t->xfsr[0] & 0xffffffff00000000UL) | fsr; + } + + return 0; +} + +static const struct utrace_regset sparc32_regsets[] = { + { + .n = SPARC32_NGREGS, + .size = sizeof(u32), .align = sizeof(u32), + .get = genregs32_get, .set = genregs32_set + }, + { + .n = SPARC32_NFPREGS, + .size = sizeof(u32), .align = sizeof(u32), + .get = fpregs32_get, .set = fpregs32_set + }, }; -#endif -/* - * Called by kernel/ptrace.c when detaching.. - * - * Make sure single step bits etc are not set. - */ -void ptrace_disable(struct task_struct *child) +static const struct utrace_regset_view utrace_sparc32_view = { + .name = "sparc", .e_machine = EM_SPARC, + .regsets = sparc32_regsets, .n = ARRAY_SIZE(sparc32_regsets) +}; + +#endif /* CONFIG_COMPAT */ + +const struct utrace_regset_view *utrace_native_view(struct task_struct *tsk) { - /* nothing to do */ +#ifdef CONFIG_COMPAT + if (test_tsk_thread_flag(tsk, TIF_32BIT)) + return &utrace_sparc32_view; +#endif + return &utrace_sparc64_native_view; } + /* To get the necessary page struct, access_process_vm() first calls * get_user_pages(). This has done a flush_dcache_page() on the * accessed page. Then our caller (copy_{to,from}_user_page()) did --- linux-2.6/arch/sparc64/kernel/systbls.S +++ linux-2.6/arch/sparc64/kernel/systbls.S @@ -24,7 +24,7 @@ sys_call_table32: /*10*/ .word sys_unlink, sunos_execv, sys_chdir, sys32_chown16, sys32_mknod /*15*/ .word sys_chmod, sys32_lchown16, sparc_brk, sys32_perfctr, sys32_lseek /*20*/ .word sys_getpid, sys_capget, sys_capset, sys32_setuid16, sys32_getuid16 -/*25*/ .word sys32_vmsplice, sys_ptrace, sys_alarm, sys32_sigaltstack, sys32_pause +/*25*/ .word sys32_vmsplice, compat_sys_ptrace, sys_alarm, sys32_sigaltstack, sys32_pause /*30*/ .word compat_sys_utime, sys_lchown, sys_fchown, sys32_access, sys32_nice .word sys_chown, sys_sync, sys32_kill, compat_sys_newstat, sys32_sendfile /*40*/ .word compat_sys_newlstat, sys_dup, sys_pipe, compat_sys_times, sys_getuid @@ -170,7 +170,7 @@ sunos_sys_table: .word sys_chmod, sys32_lchown16, sunos_brk .word sunos_nosys, sys32_lseek, sunos_getpid .word sunos_nosys, sunos_nosys, sunos_nosys - .word sunos_getuid, sunos_nosys, sys_ptrace + .word sunos_getuid, sunos_nosys, compat_sys_ptrace .word sunos_nosys, sunos_nosys, sunos_nosys .word sunos_nosys, sunos_nosys, sunos_nosys .word sys_access, sunos_nosys, sunos_nosys