X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=arch%2Fsparc64%2Fkernel%2Fptrace.c;h=d8cfba61cb741acf241480ac9e4fb1107b634d56;hb=16c70f8c1b54b61c3b951b6fb220df250fe09b32;hp=d935eb602ce6882aff22616b4f489b5c08de6c0a;hpb=5273a3df6485dc2ad6aa7ddd441b9a21970f003b;p=linux-2.6.git diff --git a/arch/sparc64/kernel/ptrace.c b/arch/sparc64/kernel/ptrace.c index d935eb602..d8cfba61c 100644 --- a/arch/sparc64/kernel/ptrace.c +++ b/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,629 +11,799 @@ */ #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 -/* 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. - */ -static inline void pt_error_return(struct pt_regs *regs, unsigned long error) +#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) { - 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); + 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; + } -static inline void pt_succ_return(struct pt_regs *regs, unsigned long value) -{ - regs->u_regs[UREG_I0] = value; - regs->tstate &= ~(TSTATE_ICARRY | TSTATE_XCARRY); - regs->tpc = regs->tnpc; - regs->tnpc += 4; -} + err = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + win, GENREG_L0 * 8, + GENREG_TSTATE * 8); + } -static inline void -pt_succ_return_linux(struct pt_regs *regs, unsigned long value, long *addr) -{ - if (test_thread_flag(TIF_32BIT)) { - if (put_user(value, (unsigned int *)addr)) - return pt_error_return(regs, EFAULT); - } else { - if (put_user(value, addr)) - return pt_error_return(regs, EFAULT); + 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; } - regs->u_regs[UREG_I0] = 0; - regs->tstate &= ~(TSTATE_ICARRY | TSTATE_XCARRY); - regs->tpc = regs->tnpc; - regs->tnpc += 4; + + return err; } -static void -pt_os_succ_return (struct pt_regs *regs, unsigned long val, long *addr) +/* Consistent with signal handling, we only allow userspace to + * modify the %asi, %icc, and %xcc fields of the %tstate register. + */ +#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) { - if (current->personality == PER_SUNOS) - pt_succ_return (regs, val); - else - pt_succ_return_linux (regs, val, addr); + 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 ALLOW_INIT_TRACING */ -/* #define DEBUG_PTRACE */ - -#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", "" -}; -#endif +#define FPREG_F0 0 +#define FPREG_FSR 32 +#define FPREG_GSR 33 +#define FPREG_FPRS 34 -/* - * Called by kernel/ptrace.c when detaching.. - * - * Make sure single step bits etc are not set. - */ -void ptrace_disable(struct task_struct *child) +#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) { - /* nothing to do */ + 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; + } + if (!vx_check(vx_task_xid(child), VX_WATCH|VX_IDENT)) { + pt_error_return(regs, ESRCH); + goto out_tsk; + } + + return err; } -asmlinkage void do_ptrace(struct pt_regs *regs) +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) { - int request = regs->u_regs[UREG_I0]; - pid_t pid = regs->u_regs[UREG_I1]; - unsigned long addr = regs->u_regs[UREG_I2]; - unsigned long data = regs->u_regs[UREG_I3]; - unsigned long addr2 = regs->u_regs[UREG_I4]; - struct task_struct *child; - int ret; - - if (test_thread_flag(TIF_32BIT)) { - addr &= 0xffffffffUL; - data &= 0xffffffffUL; - addr2 &= 0xffffffffUL; + 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; } - lock_kernel(); -#ifdef DEBUG_PTRACE + + return err; +} + +static const struct utrace_regset native_regsets[] = { + { + .n = SPARC64_NGREGS, + .size = sizeof(long), .align = sizeof(long), + .get = genregs_get, .set = genregs_set + }, { - char *s; + .n = SPARC64_NFPREGS, + .size = sizeof(long), .align = sizeof(long), + .get = fpregs_get, .set = fpregs_set + }, +}; - if ((request >= 0) && (request <= 24)) - s = pt_rq [request]; +const struct utrace_regset_view utrace_sparc64_native_view = { + .name = UTS_MACHINE, .e_machine = ELF_ARCH, + .regsets = native_regsets, + .n = sizeof native_regsets / sizeof native_regsets[0], +}; +EXPORT_SYMBOL_GPL(utrace_sparc64_native_view); + +#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) +{ + 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 - s = "unknown"; - - if (request == PTRACE_POKEDATA && data == 0x91d02001){ - printk ("do_ptrace: breakpoint pid=%d, addr=%016lx addr2=%016lx\n", - pid, addr, addr2); - } else - printk("do_ptrace: rq=%s(%d) pid=%d addr=%016lx data=%016lx addr2=%016lx\n", - s, request, pid, addr, data, addr2); + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); } -#endif - if (request == PTRACE_TRACEME) { - int ret; - /* are we already being traced? */ - if (current->ptrace & PT_PTRACED) { - pt_error_return(regs, EPERM); - goto out; - } - ret = security_ptrace(current->parent, current); - if (ret) { - pt_error_return(regs, -ret); - goto out; + 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; } - /* set the ptrace bit in the process flags. */ - current->ptrace |= PT_PTRACED; - pt_succ_return(regs, 0); - goto out; - } -#ifndef ALLOW_INIT_TRACING - if (pid == 1) { - /* Can't dork with init. */ - pt_error_return(regs, EPERM); - goto out; + 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); + } } -#endif - read_lock(&tasklist_lock); - child = find_task_by_pid(pid); - if (child) - get_task_struct(child); - read_unlock(&tasklist_lock); - if (!child) { - pt_error_return(regs, ESRCH); - goto out; - } + if (count > 0 && pos == (GENREG32_PSR * 4)) { + u32 psr = tstate_to_psr(regs->tstate); - if ((current->personality == PER_SUNOS && request == PTRACE_SUNATTACH) - || (current->personality != PER_SUNOS && request == PTRACE_ATTACH)) { - if (ptrace_attach(child)) { - pt_error_return(regs, EPERM); - goto out_tsk; - } - pt_succ_return(regs, 0); - goto out_tsk; + 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); } - ret = ptrace_check_attach(child, request == PTRACE_KILL); - if (ret < 0) { - pt_error_return(regs, -ret); - goto out_tsk; - } + if (count > 0 && pos == (GENREG32_PC * 4)) { + u32 val = regs->tpc; - if (!(test_thread_flag(TIF_32BIT)) && - ((request == PTRACE_READDATA64) || - (request == PTRACE_WRITEDATA64) || - (request == PTRACE_READTEXT64) || - (request == PTRACE_WRITETEXT64) || - (request == PTRACE_PEEKTEXT64) || - (request == PTRACE_POKETEXT64) || - (request == PTRACE_PEEKDATA64) || - (request == PTRACE_POKEDATA64))) { - addr = regs->u_regs[UREG_G2]; - addr2 = regs->u_regs[UREG_G3]; - request -= 30; /* wheee... */ + 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); } - switch(request) { - case PTRACE_PEEKTEXT: /* read word at location addr. */ - case PTRACE_PEEKDATA: { - unsigned long tmp64; - unsigned int tmp32; - int res, copied; - - res = -EIO; - if (test_thread_flag(TIF_32BIT)) { - copied = access_process_vm(child, addr, - &tmp32, sizeof(tmp32), 0); - tmp64 = (unsigned long) tmp32; - if (copied == sizeof(tmp32)) - res = 0; - } else { - copied = access_process_vm(child, addr, - &tmp64, sizeof(tmp64), 0); - if (copied == sizeof(tmp64)) - res = 0; - } - if (res < 0) - pt_error_return(regs, -res); + 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 - pt_os_succ_return(regs, tmp64, (long *) data); - goto flush_and_out; + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); } - case PTRACE_POKETEXT: /* write the word at location addr. */ - case PTRACE_POKEDATA: { - unsigned long tmp64; - unsigned int tmp32; - int copied, res = -EIO; - - if (test_thread_flag(TIF_32BIT)) { - tmp32 = data; - copied = access_process_vm(child, addr, - &tmp32, sizeof(tmp32), 1); - if (copied == sizeof(tmp32)) - res = 0; - } else { - tmp64 = data; - copied = access_process_vm(child, addr, - &tmp64, sizeof(tmp64), 1); - if (copied == sizeof(tmp64)) - res = 0; - } - if (res < 0) - pt_error_return(regs, -res); + 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 - pt_succ_return(regs, res); - goto flush_and_out; + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); } - case PTRACE_GETREGS: { - struct pt_regs32 *pregs = (struct pt_regs32 *) addr; - struct pt_regs *cregs = child->thread_info->kregs; - int rval; - - if (__put_user(tstate_to_psr(cregs->tstate), (&pregs->psr)) || - __put_user(cregs->tpc, (&pregs->pc)) || - __put_user(cregs->tnpc, (&pregs->npc)) || - __put_user(cregs->y, (&pregs->y))) { - pt_error_return(regs, EFAULT); - goto out_tsk; - } - for (rval = 1; rval < 16; rval++) - if (__put_user(cregs->u_regs[rval], (&pregs->u_regs[rval - 1]))) { - pt_error_return(regs, EFAULT); - goto out_tsk; - } - pt_succ_return(regs, 0); -#ifdef DEBUG_PTRACE - printk ("PC=%lx nPC=%lx o7=%lx\n", cregs->tpc, cregs->tnpc, cregs->u_regs [15]); -#endif - goto out_tsk; + if (count > 0) { + if (kbuf) + memset(kbuf, 0, count); + else if (clear_user(ubuf, count)) + return -EFAULT; } - case PTRACE_GETREGS64: { - struct pt_regs *pregs = (struct pt_regs *) addr; - struct pt_regs *cregs = child->thread_info->kregs; - unsigned long tpc = cregs->tpc; - int rval; - - if ((child->thread_info->flags & _TIF_32BIT) != 0) - tpc &= 0xffffffff; - if (__put_user(cregs->tstate, (&pregs->tstate)) || - __put_user(tpc, (&pregs->tpc)) || - __put_user(cregs->tnpc, (&pregs->tnpc)) || - __put_user(cregs->y, (&pregs->y))) { - pt_error_return(regs, EFAULT); - goto out_tsk; - } - for (rval = 1; rval < 16; rval++) - if (__put_user(cregs->u_regs[rval], (&pregs->u_regs[rval - 1]))) { - pt_error_return(regs, EFAULT); - goto out_tsk; - } - pt_succ_return(regs, 0); -#ifdef DEBUG_PTRACE - printk ("PC=%lx nPC=%lx o7=%lx\n", cregs->tpc, cregs->tnpc, cregs->u_regs [15]); -#endif - goto out_tsk; - } + return 0; +} - case PTRACE_SETREGS: { - struct pt_regs32 *pregs = (struct pt_regs32 *) addr; - struct pt_regs *cregs = child->thread_info->kregs; - unsigned int psr, pc, npc, y; - int i; - - /* Must be careful, tracing process can only set certain - * bits in the psr. - */ - if (__get_user(psr, (&pregs->psr)) || - __get_user(pc, (&pregs->pc)) || - __get_user(npc, (&pregs->npc)) || - __get_user(y, (&pregs->y))) { - pt_error_return(regs, EFAULT); - goto out_tsk; - } - cregs->tstate &= ~(TSTATE_ICC); - cregs->tstate |= psr_to_tstate_icc(psr); - if (!((pc | npc) & 3)) { - cregs->tpc = pc; - cregs->tnpc = npc; - } - cregs->y = y; - for (i = 1; i < 16; i++) { - if (__get_user(cregs->u_regs[i], (&pregs->u_regs[i-1]))) { - pt_error_return(regs, EFAULT); - goto out_tsk; - } - } - pt_succ_return(regs, 0); - goto out_tsk; +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); } - case PTRACE_SETREGS64: { - struct pt_regs *pregs = (struct pt_regs *) addr; - struct pt_regs *cregs = child->thread_info->kregs; - unsigned long tstate, tpc, tnpc, y; - int i; - - /* Must be careful, tracing process can only set certain - * bits in the psr. - */ - if (__get_user(tstate, (&pregs->tstate)) || - __get_user(tpc, (&pregs->tpc)) || - __get_user(tnpc, (&pregs->tnpc)) || - __get_user(y, (&pregs->y))) { - pt_error_return(regs, EFAULT); - goto out_tsk; - } - if ((child->thread_info->flags & _TIF_32BIT) != 0) { - tpc &= 0xffffffff; - tnpc &= 0xffffffff; - } - tstate &= (TSTATE_ICC | TSTATE_XCC); - cregs->tstate &= ~(TSTATE_ICC | TSTATE_XCC); - cregs->tstate |= tstate; - if (!((tpc | tnpc) & 3)) { - cregs->tpc = tpc; - cregs->tnpc = tnpc; - } - cregs->y = y; - for (i = 1; i < 16; i++) { - if (__get_user(cregs->u_regs[i], (&pregs->u_regs[i-1]))) { - pt_error_return(regs, EFAULT); - goto out_tsk; - } - } - pt_succ_return(regs, 0); - goto out_tsk; + 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; } - case PTRACE_GETFPREGS: { - struct fps { - unsigned int regs[32]; - unsigned int fsr; - unsigned int flags; - unsigned int extra; - unsigned int fpqd; - struct fq { - unsigned int insnaddr; - unsigned int insn; - } fpq[16]; - } *fps = (struct fps *) addr; - unsigned long *fpregs = child->thread_info->fpregs; - - if (copy_to_user(&fps->regs[0], fpregs, - (32 * sizeof(unsigned int))) || - __put_user(child->thread_info->xfsr[0], (&fps->fsr)) || - __put_user(0, (&fps->fpqd)) || - __put_user(0, (&fps->flags)) || - __put_user(0, (&fps->extra)) || - clear_user(&fps->fpq[0], 32 * sizeof(unsigned int))) { - pt_error_return(regs, EFAULT); - goto out_tsk; - } - pt_succ_return(regs, 0); - goto out_tsk; - } + if (count > 0 && pos == (GENREG32_PSR * 4)) { + unsigned long tstate, tstate_save; + u32 psr; - case PTRACE_GETFPREGS64: { - struct fps { - unsigned int regs[64]; - unsigned long fsr; - } *fps = (struct fps *) addr; - unsigned long *fpregs = child->thread_info->fpregs; - - if (copy_to_user(&fps->regs[0], fpregs, - (64 * sizeof(unsigned int))) || - __put_user(child->thread_info->xfsr[0], (&fps->fsr))) { - pt_error_return(regs, EFAULT); - goto out_tsk; - } - pt_succ_return(regs, 0); - goto out_tsk; - } + tstate_save = regs->tstate&~(TSTATE_ICC|TSTATE_XCC); - case PTRACE_SETFPREGS: { - struct fps { - unsigned int regs[32]; - unsigned int fsr; - unsigned int flags; - unsigned int extra; - unsigned int fpqd; - struct fq { - unsigned int insnaddr; - unsigned int insn; - } fpq[16]; - } *fps = (struct fps *) addr; - unsigned long *fpregs = child->thread_info->fpregs; - unsigned fsr; - - if (copy_from_user(fpregs, &fps->regs[0], - (32 * sizeof(unsigned int))) || - __get_user(fsr, (&fps->fsr))) { - pt_error_return(regs, EFAULT); - goto out_tsk; - } - child->thread_info->xfsr[0] &= 0xffffffff00000000UL; - child->thread_info->xfsr[0] |= fsr; - if (!(child->thread_info->fpsaved[0] & FPRS_FEF)) - child->thread_info->gsr[0] = 0; - child->thread_info->fpsaved[0] |= (FPRS_FEF | FPRS_DL); - pt_succ_return(regs, 0); - goto out_tsk; + 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; } - case PTRACE_SETFPREGS64: { - struct fps { - unsigned int regs[64]; - unsigned long fsr; - } *fps = (struct fps *) addr; - unsigned long *fpregs = child->thread_info->fpregs; - - if (copy_from_user(fpregs, &fps->regs[0], - (64 * sizeof(unsigned int))) || - __get_user(child->thread_info->xfsr[0], (&fps->fsr))) { - pt_error_return(regs, EFAULT); - goto out_tsk; - } - if (!(child->thread_info->fpsaved[0] & FPRS_FEF)) - child->thread_info->gsr[0] = 0; - child->thread_info->fpsaved[0] |= (FPRS_FEF | FPRS_DL | FPRS_DU); - pt_succ_return(regs, 0); - goto out_tsk; + 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); } - case PTRACE_READTEXT: - case PTRACE_READDATA: { - int res = ptrace_readdata(child, addr, - (void *)addr2, data); - if (res == data) { - pt_succ_return(regs, 0); - goto flush_and_out; - } - if (res >= 0) - res = -EIO; - pt_error_return(regs, -res); - goto flush_and_out; + 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); } - case PTRACE_WRITETEXT: - case PTRACE_WRITEDATA: { - int res = ptrace_writedata(child, (void *) addr2, - addr, data); - if (res == data) { - pt_succ_return(regs, 0); - goto flush_and_out; - } - if (res >= 0) - res = -EIO; - pt_error_return(regs, -res); - goto flush_and_out; + 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); } - case PTRACE_SYSCALL: /* continue and stop at (return from) syscall */ - addr = 1; - case PTRACE_CONT: { /* restart after signal. */ - if (data > _NSIG) { - pt_error_return(regs, EIO); - goto out_tsk; - } - if (addr != 1) { - unsigned long pc_mask = ~0UL; - - if ((child->thread_info->flags & _TIF_32BIT) != 0) - pc_mask = 0xffffffff; - - if (addr & 3) { - pt_error_return(regs, EINVAL); - goto out_tsk; - } -#ifdef DEBUG_PTRACE - printk ("Original: %016lx %016lx\n", - child->thread_info->kregs->tpc, - child->thread_info->kregs->tnpc); - printk ("Continuing with %016lx %016lx\n", addr, addr+4); -#endif - child->thread_info->kregs->tpc = (addr & pc_mask); - child->thread_info->kregs->tnpc = ((addr + 4) & pc_mask); - } + /* Ignore WIM and TBR */ - if (request == PTRACE_SYSCALL) { - set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); - } else { - clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); - } + return 0; +} - child->exit_code = data; -#ifdef DEBUG_PTRACE - printk("CONT: %s [%d]: set exit_code = %x %lx %lx\n", child->comm, - child->pid, child->exit_code, - child->thread_info->kregs->tpc, - child->thread_info->kregs->tnpc); - -#endif - wake_up_process(child); - pt_succ_return(regs, 0); - goto out_tsk; - } +#define FPREG32_F0 0 +#define FPREG32_FSR 32 -/* - * make the child exit. Best I can do is send it a sigkill. - * perhaps it should be put in the status that it wants to - * exit. - */ - case PTRACE_KILL: { - if (child->state == TASK_ZOMBIE) { /* already dead */ - pt_succ_return(regs, 0); - goto out_tsk; - } - child->exit_code = SIGKILL; - wake_up_process(child); - pt_succ_return(regs, 0); - goto out_tsk; - } +#define SPARC32_NFPREGS 33 - case PTRACE_SUNDETACH: { /* detach a process that was attached. */ - int error = ptrace_detach(child, data); - if (error) { - pt_error_return(regs, EIO); - goto out_tsk; - } - pt_succ_return(regs, 0); - goto out_tsk; +static int fpregs32_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, 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; } - /* PTRACE_DUMPCORE unsupported... */ + return err; +} - default: { - int err = ptrace_request(child, request, addr, data); - if (err) - pt_error_return(regs, -err); - else - pt_succ_return(regs, 0); - goto out_tsk; - } +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; + + 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; } -flush_and_out: + + return 0; +} + +static const struct utrace_regset sparc32_regsets[] = { + { + .n = SPARC32_NGREGS, + .size = sizeof(u32), .align = sizeof(u32), + .get = genregs32_get, .set = genregs32_set + }, { - unsigned long va; + .n = SPARC32_NFPREGS, + .size = sizeof(u32), .align = sizeof(u32), + .get = fpregs32_get, .set = fpregs32_set + }, +}; + +const struct utrace_regset_view utrace_sparc32_view = { + .name = "sparc", .e_machine = EM_SPARC, + .regsets = sparc32_regsets, + .n = sizeof sparc32_regsets / sizeof sparc32_regsets[0], +}; +EXPORT_SYMBOL_GPL(utrace_sparc32_view); + +#endif /* CONFIG_COMPAT */ + +/* 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 + * to memcpy to read/write the data from that page. + * + * Now, the only thing we have to do is: + * 1) flush the D-cache if it's possible than an illegal alias + * has been created + * 2) flush the I-cache if this is pre-cheetah and we did a write + */ +void flush_ptrace_access(struct vm_area_struct *vma, struct page *page, + unsigned long uaddr, void *kaddr, + unsigned long len, int write) +{ + BUG_ON(len > PAGE_SIZE); - if (tlb_type == cheetah || tlb_type == cheetah_plus) { - for (va = 0; va < (1 << 16); va += (1 << 5)) - spitfire_put_dcache_tag(va, 0x0); - /* No need to mess with I-cache on Cheetah. */ + if (tlb_type == hypervisor) + return; + +#ifdef DCACHE_ALIASING_POSSIBLE + /* If bit 13 of the kernel address we used to access the + * user page is the same as the virtual address that page + * is mapped to in the user's address space, we can skip the + * D-cache flush. + */ + if ((uaddr ^ (unsigned long) kaddr) & (1UL << 13)) { + unsigned long start = __pa(kaddr); + unsigned long end = start + len; + unsigned long dcache_line_size; + + dcache_line_size = local_cpu_data().dcache_line_size; + + if (tlb_type == spitfire) { + for (; start < end; start += dcache_line_size) + spitfire_put_dcache_tag(start & 0x3fe0, 0x0); } else { - for (va = 0; va < L1DCACHE_SIZE; va += 32) - spitfire_put_dcache_tag(va, 0x0); - if (request == PTRACE_PEEKTEXT || - request == PTRACE_POKETEXT || - request == PTRACE_READTEXT || - request == PTRACE_WRITETEXT) { - for (va = 0; va < (PAGE_SIZE << 1); va += 32) - spitfire_put_icache_tag(va, 0x0); - __asm__ __volatile__("flush %g6"); - } + start &= ~(dcache_line_size - 1); + for (; start < end; start += dcache_line_size) + __asm__ __volatile__( + "stxa %%g0, [%0] %1\n\t" + "membar #Sync" + : /* no outputs */ + : "r" (start), + "i" (ASI_DCACHE_INVALIDATE)); } } -out_tsk: - if (child) - put_task_struct(child); -out: - unlock_kernel(); +#endif + if (write && tlb_type == spitfire) { + unsigned long start = (unsigned long) kaddr; + unsigned long end = start + len; + unsigned long icache_line_size; + + icache_line_size = local_cpu_data().icache_line_size; + + for (; start < end; start += icache_line_size) + flushi(start); + } } -asmlinkage void syscall_trace(void) +#ifdef CONFIG_PTRACE +static const struct ptrace_layout_segment sparc64_getregs_layout[] = { + { 0, offsetof(struct pt_regs, u_regs[15]), 0, sizeof(long) }, + { offsetof(struct pt_regs, u_regs[15]), + offsetof(struct pt_regs, tstate), + -1, 0 }, + { offsetof(struct pt_regs, tstate), offsetof(struct pt_regs, y), + 0, 32 * sizeof(long) }, + {0, 0, -1, 0} +}; + +int arch_ptrace(long *request, struct task_struct *child, + struct utrace_attached_engine *engine, + unsigned long addr, unsigned long data, + long *retval) { -#ifdef DEBUG_PTRACE - printk("%s [%d]: syscall_trace\n", current->comm, current->pid); -#endif - if (!test_thread_flag(TIF_SYSCALL_TRACE)) - return; - if (!(current->ptrace & PT_PTRACED)) - return; - current->exit_code = SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD) - ? 0x80 : 0); - current->state = TASK_STOPPED; - notify_parent(current, SIGCHLD); - schedule(); - - /* - * this isn't the same as continuing with a signal, but it will do - * for normal use. strace only continues with a signal if the - * stopping signal is not SIGTRAP. -brl - */ -#ifdef DEBUG_PTRACE - printk("%s [%d]: syscall_trace exit= %x\n", current->comm, - current->pid, current->exit_code); -#endif - if (current->exit_code) { - send_sig (current->exit_code, current, 1); - current->exit_code = 0; + void __user *uaddr = (void __user *) addr; + struct pt_regs *uregs = uaddr; + int err = -ENOSYS; + + switch (*request) { + case PTRACE_GETREGS64: + err = ptrace_layout_access(child, engine, + &utrace_sparc64_native_view, + sparc64_getregs_layout, + 0, offsetof(struct pt_regs, y), + uaddr, NULL, 0); + if (!err && + (put_user(task_pt_regs(child)->y, &uregs->y) || + put_user(task_pt_regs(child)->fprs, &uregs->fprs))) + err = -EFAULT; + break; + + case PTRACE_SETREGS64: + err = ptrace_layout_access(child, engine, + &utrace_sparc64_native_view, + sparc64_getregs_layout, + 0, offsetof(struct pt_regs, y), + uaddr, NULL, 1); + if (!err && + (get_user(task_pt_regs(child)->y, &uregs->y) || + get_user(task_pt_regs(child)->fprs, &uregs->fprs))) + err = -EFAULT; + break; + + case PTRACE_GETFPREGS64: + case PTRACE_SETFPREGS64: + err = ptrace_regset_access(child, engine, + utrace_native_view(current), + 2, 0, 34 * sizeof(long), uaddr, + (*request == PTRACE_SETFPREGS64)); + break; + + case PTRACE_SUNDETACH: + *request = PTRACE_DETACH; + break; + + default: + break; + }; + return err; +} + +#ifdef CONFIG_COMPAT +static const struct ptrace_layout_segment sparc32_getregs_layout[] = { + { 0, offsetof(struct pt_regs32, u_regs[0]), + 0, GENREG32_PSR * sizeof(u32) }, + { offsetof(struct pt_regs32, u_regs[0]), + offsetof(struct pt_regs32, u_regs[15]), + 0, 1 * sizeof(u32) }, + { offsetof(struct pt_regs32, u_regs[15]), sizeof(struct pt_regs32), + -1, 0 }, + {0, 0, -1, 0} +}; + +int arch_compat_ptrace(compat_long_t *request, struct task_struct *child, + struct utrace_attached_engine *engine, + compat_ulong_t addr, compat_ulong_t data, + compat_long_t *retval) +{ + void __user *uaddr = (void __user *) (unsigned long) addr; + int err = -ENOSYS; + + switch (*request) { + case PTRACE_GETREGS: + case PTRACE_SETREGS: + err = ptrace_layout_access(child, engine, + &utrace_sparc32_view, + sparc32_getregs_layout, + 0, sizeof(struct pt_regs32), + uaddr, NULL, + (*request == + PTRACE_SETREGS)); + break; + + case PTRACE_GETFPREGS: + case PTRACE_SETFPREGS: + err = ptrace_whole_regset(child, engine, addr, 1, + (*request == PTRACE_SETFPREGS)); + break; + + case PTRACE_SUNDETACH: + *request = PTRACE_DETACH; + break; + + default: + break; + }; + return err; +} +#endif /* CONFIG_COMPAT */ +#endif /* CONFIG_PTRACE */ + +asmlinkage void syscall_trace(struct pt_regs *regs, int syscall_exit_p) +{ + /* do the secure computing check first */ + if (!syscall_exit_p) + secure_computing(regs->u_regs[UREG_G1]); + + if (unlikely(current->audit_context) && syscall_exit_p) { + unsigned long tstate = regs->tstate; + int result = AUDITSC_SUCCESS; + + if (unlikely(tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) + result = AUDITSC_FAILURE; + + audit_syscall_exit(result, regs->u_regs[UREG_I0]); } + + if (test_thread_flag(TIF_SYSCALL_TRACE)) + tracehook_report_syscall(regs, syscall_exit_p); + + if (unlikely(current->audit_context) && !syscall_exit_p) + audit_syscall_entry((test_thread_flag(TIF_32BIT) ? + AUDIT_ARCH_SPARC : + AUDIT_ARCH_SPARC64), + regs->u_regs[UREG_G1], + regs->u_regs[UREG_I0], + regs->u_regs[UREG_I1], + regs->u_regs[UREG_I2], + regs->u_regs[UREG_I3]); }