Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=48b22cf993cbc8f62c9b4025cfe0cfccd800181a
Commit:     48b22cf993cbc8f62c9b4025cfe0cfccd800181a
Parent:     a62a3861e0adfd2612372883b5b1fc05a5182796
Author:     Paul Mundt <[EMAIL PROTECTED]>
AuthorDate: Sat Nov 10 19:53:31 2007 +0900
Committer:  Paul Mundt <[EMAIL PROTECTED]>
CommitDate: Mon Jan 28 13:18:42 2008 +0900

    sh: Move in the SH-5 ptrace impl.
    
    Signed-off-by: Paul Mundt <[EMAIL PROTECTED]>
---
 arch/sh/kernel/Makefile_32 |    2 +-
 arch/sh/kernel/Makefile_64 |    2 +-
 arch/sh/kernel/ptrace.c    |  274 ------------------------------------
 arch/sh/kernel/ptrace_32.c |  274 ++++++++++++++++++++++++++++++++++++
 arch/sh/kernel/ptrace_64.c |  332 ++++++++++++++++++++++++++++++++++++++++++++
 arch/sh64/kernel/ptrace.c  |  332 --------------------------------------------
 6 files changed, 608 insertions(+), 608 deletions(-)

diff --git a/arch/sh/kernel/Makefile_32 b/arch/sh/kernel/Makefile_32
index 9864be6..54b5a2d 100644
--- a/arch/sh/kernel/Makefile_32
+++ b/arch/sh/kernel/Makefile_32
@@ -5,7 +5,7 @@
 extra-y        := head.o init_task.o vmlinux.lds
 
 obj-y  := debugtraps.o io.o io_generic.o irq.o machvec.o process_32.o \
-          ptrace.o semaphore.o setup.o signal.o sys_sh.o syscalls.o \
+          ptrace_32.o semaphore.o setup.o signal.o sys_sh.o syscalls.o \
           time.o topology.o traps.o
 
 obj-y                          += cpu/ timers/
diff --git a/arch/sh/kernel/Makefile_64 b/arch/sh/kernel/Makefile_64
index 7dd7de9..7dc995d 100644
--- a/arch/sh/kernel/Makefile_64
+++ b/arch/sh/kernel/Makefile_64
@@ -1,7 +1,7 @@
 extra-y        := head.o init_task.o vmlinux.lds
 
 obj-y  := debugtraps.o io.o io_generic.o irq.o machvec.o process_64.o \
-          ptrace.o semaphore.o setup.o signal.o sys_sh.o syscalls.o \
+          ptrace_64.o semaphore.o setup.o signal.o sys_sh.o syscalls.o \
           time.o topology.o traps.o
 
 obj-y                          += cpu/ timers/
diff --git a/arch/sh/kernel/ptrace.c b/arch/sh/kernel/ptrace.c
deleted file mode 100644
index ac725f0..0000000
--- a/arch/sh/kernel/ptrace.c
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- * linux/arch/sh/kernel/ptrace.c
- *
- * Original x86 implementation:
- *     By Ross Biro 1/23/92
- *     edited by Linus Torvalds
- *
- * SuperH version:   Copyright (C) 1999, 2000  Kaz Kojima & Niibe Yutaka
- *
- */
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/mm.h>
-#include <linux/smp.h>
-#include <linux/errno.h>
-#include <linux/ptrace.h>
-#include <linux/user.h>
-#include <linux/slab.h>
-#include <linux/security.h>
-#include <linux/signal.h>
-#include <linux/io.h>
-#include <asm/uaccess.h>
-#include <asm/pgtable.h>
-#include <asm/system.h>
-#include <asm/processor.h>
-#include <asm/mmu_context.h>
-
-/*
- * does not yet catch signals sent when the child dies.
- * in exit.c or in signal.c.
- */
-
-/*
- * This routine will get a word off of the process kernel stack.
- */
-static inline int get_stack_long(struct task_struct *task, int offset)
-{
-       unsigned char *stack;
-
-       stack = (unsigned char *)task_pt_regs(task);
-       stack += offset;
-       return (*((int *)stack));
-}
-
-/*
- * This routine will put a word on the process kernel stack.
- */
-static inline int put_stack_long(struct task_struct *task, int offset,
-                                unsigned long data)
-{
-       unsigned char *stack;
-
-       stack = (unsigned char *)task_pt_regs(task);
-       stack += offset;
-       *(unsigned long *) stack = data;
-       return 0;
-}
-
-static void ptrace_disable_singlestep(struct task_struct *child)
-{
-       clear_tsk_thread_flag(child, TIF_SINGLESTEP);
-
-       /*
-        * Ensure the UBC is not programmed at the next context switch.
-        *
-        * Normally this is not needed but there are sequences such as
-        * singlestep, signal delivery, and continue that leave the
-        * ubc_pc non-zero leading to spurious SIGTRAPs.
-        */
-       if (child->thread.ubc_pc != 0) {
-               ubc_usercnt -= 1;
-               child->thread.ubc_pc = 0;
-       }
-}
-
-/*
- * Called by kernel/ptrace.c when detaching..
- *
- * Make sure single step bits etc are not set.
- */
-void ptrace_disable(struct task_struct *child)
-{
-       ptrace_disable_singlestep(child);
-}
-
-long arch_ptrace(struct task_struct *child, long request, long addr, long data)
-{
-       struct user * dummy = NULL;
-       int ret;
-
-       switch (request) {
-       /* when I and D space are separate, these will need to be fixed. */
-       case PTRACE_PEEKTEXT: /* read word at location addr. */
-       case PTRACE_PEEKDATA:
-               ret = generic_ptrace_peekdata(child, addr, data);
-               break;
-
-       /* read the word at location addr in the USER area. */
-       case PTRACE_PEEKUSR: {
-               unsigned long tmp;
-
-               ret = -EIO;
-               if ((addr & 3) || addr < 0 ||
-                   addr > sizeof(struct user) - 3)
-                       break;
-
-               if (addr < sizeof(struct pt_regs))
-                       tmp = get_stack_long(child, addr);
-               else if (addr >= (long) &dummy->fpu &&
-                        addr < (long) &dummy->u_fpvalid) {
-                       if (!tsk_used_math(child)) {
-                               if (addr == (long)&dummy->fpu.fpscr)
-                                       tmp = FPSCR_INIT;
-                               else
-                                       tmp = 0;
-                       } else
-                               tmp = ((long *)&child->thread.fpu)
-                                       [(addr - (long)&dummy->fpu) >> 2];
-               } else if (addr == (long) &dummy->u_fpvalid)
-                       tmp = !!tsk_used_math(child);
-               else
-                       tmp = 0;
-               ret = put_user(tmp, (unsigned long __user *)data);
-               break;
-       }
-
-       /* when I and D space are separate, this will have to be fixed. */
-       case PTRACE_POKETEXT: /* write the word at location addr. */
-       case PTRACE_POKEDATA:
-               ret = generic_ptrace_pokedata(child, addr, data);
-               break;
-
-       case PTRACE_POKEUSR: /* write the word at location addr in the USER 
area */
-               ret = -EIO;
-               if ((addr & 3) || addr < 0 ||
-                   addr > sizeof(struct user) - 3)
-                       break;
-
-               if (addr < sizeof(struct pt_regs))
-                       ret = put_stack_long(child, addr, data);
-               else if (addr >= (long) &dummy->fpu &&
-                        addr < (long) &dummy->u_fpvalid) {
-                       set_stopped_child_used_math(child);
-                       ((long *)&child->thread.fpu)
-                               [(addr - (long)&dummy->fpu) >> 2] = data;
-                       ret = 0;
-               } else if (addr == (long) &dummy->u_fpvalid) {
-                       conditional_stopped_child_used_math(data, child);
-                       ret = 0;
-               }
-               break;
-
-       case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall 
*/
-       case PTRACE_CONT: { /* restart after signal. */
-               ret = -EIO;
-               if (!valid_signal(data))
-                       break;
-               if (request == PTRACE_SYSCALL)
-                       set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-               else
-                       clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-
-               ptrace_disable_singlestep(child);
-
-               child->exit_code = data;
-               wake_up_process(child);
-               ret = 0;
-               break;
-       }
-
-/*
- * 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: {
-               ret = 0;
-               if (child->exit_state == EXIT_ZOMBIE)   /* already dead */
-                       break;
-               ptrace_disable_singlestep(child);
-               child->exit_code = SIGKILL;
-               wake_up_process(child);
-               break;
-       }
-
-       case PTRACE_SINGLESTEP: {  /* set the trap flag. */
-               long pc;
-               struct pt_regs *regs = NULL;
-
-               ret = -EIO;
-               if (!valid_signal(data))
-                       break;
-               clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-               if ((child->ptrace & PT_DTRACE) == 0) {
-                       /* Spurious delayed TF traps may occur */
-                       child->ptrace |= PT_DTRACE;
-               }
-
-               pc = get_stack_long(child, (long)&regs->pc);
-
-               /* Next scheduling will set up UBC */
-               if (child->thread.ubc_pc == 0)
-                       ubc_usercnt += 1;
-               child->thread.ubc_pc = pc;
-
-               set_tsk_thread_flag(child, TIF_SINGLESTEP);
-               child->exit_code = data;
-               /* give it a chance to run. */
-               wake_up_process(child);
-               ret = 0;
-               break;
-       }
-
-#ifdef CONFIG_SH_DSP
-       case PTRACE_GETDSPREGS: {
-               unsigned long dp;
-
-               ret = -EIO;
-               dp = ((unsigned long) child) + THREAD_SIZE -
-                        sizeof(struct pt_dspregs);
-               if (*((int *) (dp - 4)) == SR_FD) {
-                       copy_to_user(addr, (void *) dp,
-                               sizeof(struct pt_dspregs));
-                       ret = 0;
-               }
-               break;
-       }
-
-       case PTRACE_SETDSPREGS: {
-               unsigned long dp;
-
-               ret = -EIO;
-               dp = ((unsigned long) child) + THREAD_SIZE -
-                        sizeof(struct pt_dspregs);
-               if (*((int *) (dp - 4)) == SR_FD) {
-                       copy_from_user((void *) dp, addr,
-                               sizeof(struct pt_dspregs));
-                       ret = 0;
-               }
-               break;
-       }
-#endif
-       default:
-               ret = ptrace_request(child, request, addr, data);
-               break;
-       }
-
-       return ret;
-}
-
-asmlinkage void do_syscall_trace(void)
-{
-       struct task_struct *tsk = current;
-
-       if (!test_thread_flag(TIF_SYSCALL_TRACE) &&
-           !test_thread_flag(TIF_SINGLESTEP))
-               return;
-       if (!(tsk->ptrace & PT_PTRACED))
-               return;
-       /* the 0x80 provides a way for the tracing parent to distinguish
-          between a syscall stop and SIGTRAP delivery */
-       ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD) &&
-                                !test_thread_flag(TIF_SINGLESTEP) ? 0x80 : 0));
-
-       /*
-        * 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
-        */
-       if (tsk->exit_code) {
-               send_sig(tsk->exit_code, tsk, 1);
-               tsk->exit_code = 0;
-       }
-}
diff --git a/arch/sh/kernel/ptrace_32.c b/arch/sh/kernel/ptrace_32.c
new file mode 100644
index 0000000..ac725f0
--- /dev/null
+++ b/arch/sh/kernel/ptrace_32.c
@@ -0,0 +1,274 @@
+/*
+ * linux/arch/sh/kernel/ptrace.c
+ *
+ * Original x86 implementation:
+ *     By Ross Biro 1/23/92
+ *     edited by Linus Torvalds
+ *
+ * SuperH version:   Copyright (C) 1999, 2000  Kaz Kojima & Niibe Yutaka
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/mm.h>
+#include <linux/smp.h>
+#include <linux/errno.h>
+#include <linux/ptrace.h>
+#include <linux/user.h>
+#include <linux/slab.h>
+#include <linux/security.h>
+#include <linux/signal.h>
+#include <linux/io.h>
+#include <asm/uaccess.h>
+#include <asm/pgtable.h>
+#include <asm/system.h>
+#include <asm/processor.h>
+#include <asm/mmu_context.h>
+
+/*
+ * does not yet catch signals sent when the child dies.
+ * in exit.c or in signal.c.
+ */
+
+/*
+ * This routine will get a word off of the process kernel stack.
+ */
+static inline int get_stack_long(struct task_struct *task, int offset)
+{
+       unsigned char *stack;
+
+       stack = (unsigned char *)task_pt_regs(task);
+       stack += offset;
+       return (*((int *)stack));
+}
+
+/*
+ * This routine will put a word on the process kernel stack.
+ */
+static inline int put_stack_long(struct task_struct *task, int offset,
+                                unsigned long data)
+{
+       unsigned char *stack;
+
+       stack = (unsigned char *)task_pt_regs(task);
+       stack += offset;
+       *(unsigned long *) stack = data;
+       return 0;
+}
+
+static void ptrace_disable_singlestep(struct task_struct *child)
+{
+       clear_tsk_thread_flag(child, TIF_SINGLESTEP);
+
+       /*
+        * Ensure the UBC is not programmed at the next context switch.
+        *
+        * Normally this is not needed but there are sequences such as
+        * singlestep, signal delivery, and continue that leave the
+        * ubc_pc non-zero leading to spurious SIGTRAPs.
+        */
+       if (child->thread.ubc_pc != 0) {
+               ubc_usercnt -= 1;
+               child->thread.ubc_pc = 0;
+       }
+}
+
+/*
+ * Called by kernel/ptrace.c when detaching..
+ *
+ * Make sure single step bits etc are not set.
+ */
+void ptrace_disable(struct task_struct *child)
+{
+       ptrace_disable_singlestep(child);
+}
+
+long arch_ptrace(struct task_struct *child, long request, long addr, long data)
+{
+       struct user * dummy = NULL;
+       int ret;
+
+       switch (request) {
+       /* when I and D space are separate, these will need to be fixed. */
+       case PTRACE_PEEKTEXT: /* read word at location addr. */
+       case PTRACE_PEEKDATA:
+               ret = generic_ptrace_peekdata(child, addr, data);
+               break;
+
+       /* read the word at location addr in the USER area. */
+       case PTRACE_PEEKUSR: {
+               unsigned long tmp;
+
+               ret = -EIO;
+               if ((addr & 3) || addr < 0 ||
+                   addr > sizeof(struct user) - 3)
+                       break;
+
+               if (addr < sizeof(struct pt_regs))
+                       tmp = get_stack_long(child, addr);
+               else if (addr >= (long) &dummy->fpu &&
+                        addr < (long) &dummy->u_fpvalid) {
+                       if (!tsk_used_math(child)) {
+                               if (addr == (long)&dummy->fpu.fpscr)
+                                       tmp = FPSCR_INIT;
+                               else
+                                       tmp = 0;
+                       } else
+                               tmp = ((long *)&child->thread.fpu)
+                                       [(addr - (long)&dummy->fpu) >> 2];
+               } else if (addr == (long) &dummy->u_fpvalid)
+                       tmp = !!tsk_used_math(child);
+               else
+                       tmp = 0;
+               ret = put_user(tmp, (unsigned long __user *)data);
+               break;
+       }
+
+       /* when I and D space are separate, this will have to be fixed. */
+       case PTRACE_POKETEXT: /* write the word at location addr. */
+       case PTRACE_POKEDATA:
+               ret = generic_ptrace_pokedata(child, addr, data);
+               break;
+
+       case PTRACE_POKEUSR: /* write the word at location addr in the USER 
area */
+               ret = -EIO;
+               if ((addr & 3) || addr < 0 ||
+                   addr > sizeof(struct user) - 3)
+                       break;
+
+               if (addr < sizeof(struct pt_regs))
+                       ret = put_stack_long(child, addr, data);
+               else if (addr >= (long) &dummy->fpu &&
+                        addr < (long) &dummy->u_fpvalid) {
+                       set_stopped_child_used_math(child);
+                       ((long *)&child->thread.fpu)
+                               [(addr - (long)&dummy->fpu) >> 2] = data;
+                       ret = 0;
+               } else if (addr == (long) &dummy->u_fpvalid) {
+                       conditional_stopped_child_used_math(data, child);
+                       ret = 0;
+               }
+               break;
+
+       case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall 
*/
+       case PTRACE_CONT: { /* restart after signal. */
+               ret = -EIO;
+               if (!valid_signal(data))
+                       break;
+               if (request == PTRACE_SYSCALL)
+                       set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+               else
+                       clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+
+               ptrace_disable_singlestep(child);
+
+               child->exit_code = data;
+               wake_up_process(child);
+               ret = 0;
+               break;
+       }
+
+/*
+ * 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: {
+               ret = 0;
+               if (child->exit_state == EXIT_ZOMBIE)   /* already dead */
+                       break;
+               ptrace_disable_singlestep(child);
+               child->exit_code = SIGKILL;
+               wake_up_process(child);
+               break;
+       }
+
+       case PTRACE_SINGLESTEP: {  /* set the trap flag. */
+               long pc;
+               struct pt_regs *regs = NULL;
+
+               ret = -EIO;
+               if (!valid_signal(data))
+                       break;
+               clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+               if ((child->ptrace & PT_DTRACE) == 0) {
+                       /* Spurious delayed TF traps may occur */
+                       child->ptrace |= PT_DTRACE;
+               }
+
+               pc = get_stack_long(child, (long)&regs->pc);
+
+               /* Next scheduling will set up UBC */
+               if (child->thread.ubc_pc == 0)
+                       ubc_usercnt += 1;
+               child->thread.ubc_pc = pc;
+
+               set_tsk_thread_flag(child, TIF_SINGLESTEP);
+               child->exit_code = data;
+               /* give it a chance to run. */
+               wake_up_process(child);
+               ret = 0;
+               break;
+       }
+
+#ifdef CONFIG_SH_DSP
+       case PTRACE_GETDSPREGS: {
+               unsigned long dp;
+
+               ret = -EIO;
+               dp = ((unsigned long) child) + THREAD_SIZE -
+                        sizeof(struct pt_dspregs);
+               if (*((int *) (dp - 4)) == SR_FD) {
+                       copy_to_user(addr, (void *) dp,
+                               sizeof(struct pt_dspregs));
+                       ret = 0;
+               }
+               break;
+       }
+
+       case PTRACE_SETDSPREGS: {
+               unsigned long dp;
+
+               ret = -EIO;
+               dp = ((unsigned long) child) + THREAD_SIZE -
+                        sizeof(struct pt_dspregs);
+               if (*((int *) (dp - 4)) == SR_FD) {
+                       copy_from_user((void *) dp, addr,
+                               sizeof(struct pt_dspregs));
+                       ret = 0;
+               }
+               break;
+       }
+#endif
+       default:
+               ret = ptrace_request(child, request, addr, data);
+               break;
+       }
+
+       return ret;
+}
+
+asmlinkage void do_syscall_trace(void)
+{
+       struct task_struct *tsk = current;
+
+       if (!test_thread_flag(TIF_SYSCALL_TRACE) &&
+           !test_thread_flag(TIF_SINGLESTEP))
+               return;
+       if (!(tsk->ptrace & PT_PTRACED))
+               return;
+       /* the 0x80 provides a way for the tracing parent to distinguish
+          between a syscall stop and SIGTRAP delivery */
+       ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD) &&
+                                !test_thread_flag(TIF_SINGLESTEP) ? 0x80 : 0));
+
+       /*
+        * 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
+        */
+       if (tsk->exit_code) {
+               send_sig(tsk->exit_code, tsk, 1);
+               tsk->exit_code = 0;
+       }
+}
diff --git a/arch/sh/kernel/ptrace_64.c b/arch/sh/kernel/ptrace_64.c
new file mode 100644
index 0000000..8a2d339
--- /dev/null
+++ b/arch/sh/kernel/ptrace_64.c
@@ -0,0 +1,332 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * arch/sh64/kernel/ptrace.c
+ *
+ * Copyright (C) 2000, 2001  Paolo Alberelli
+ * Copyright (C) 2003  Paul Mundt
+ *
+ * Started from SH3/4 version:
+ *   SuperH version:   Copyright (C) 1999, 2000  Kaz Kojima & Niibe Yutaka
+ *
+ *   Original x86 implementation:
+ *     By Ross Biro 1/23/92
+ *     edited by Linus Torvalds
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/rwsem.h>
+#include <linux/sched.h>
+#include <linux/mm.h>
+#include <linux/smp.h>
+#include <linux/smp_lock.h>
+#include <linux/errno.h>
+#include <linux/ptrace.h>
+#include <linux/user.h>
+#include <linux/signal.h>
+#include <linux/syscalls.h>
+
+#include <asm/io.h>
+#include <asm/uaccess.h>
+#include <asm/pgtable.h>
+#include <asm/system.h>
+#include <asm/processor.h>
+#include <asm/mmu_context.h>
+
+/* This mask defines the bits of the SR which the user is not allowed to
+   change, which are everything except S, Q, M, PR, SZ, FR. */
+#define SR_MASK      (0xffff8cfd)
+
+/*
+ * does not yet catch signals sent when the child dies.
+ * in exit.c or in signal.c.
+ */
+
+/*
+ * This routine will get a word from the user area in the process kernel stack.
+ */
+static inline int get_stack_long(struct task_struct *task, int offset)
+{
+       unsigned char *stack;
+
+       stack = (unsigned char *)(task->thread.uregs);
+       stack += offset;
+       return (*((int *)stack));
+}
+
+static inline unsigned long
+get_fpu_long(struct task_struct *task, unsigned long addr)
+{
+       unsigned long tmp;
+       struct pt_regs *regs;
+       regs = (struct pt_regs*)((unsigned char *)task + THREAD_SIZE) - 1;
+
+       if (!tsk_used_math(task)) {
+               if (addr == offsetof(struct user_fpu_struct, fpscr)) {
+                       tmp = FPSCR_INIT;
+               } else {
+                       tmp = 0xffffffffUL; /* matches initial value in fpu.c */
+               }
+               return tmp;
+       }
+
+       if (last_task_used_math == task) {
+               grab_fpu();
+               fpsave(&task->thread.fpu.hard);
+               release_fpu();
+               last_task_used_math = 0;
+               regs->sr |= SR_FD;
+       }
+
+       tmp = ((long *)&task->thread.fpu)[addr / sizeof(unsigned long)];
+       return tmp;
+}
+
+/*
+ * This routine will put a word into the user area in the process kernel stack.
+ */
+static inline int put_stack_long(struct task_struct *task, int offset,
+                                unsigned long data)
+{
+       unsigned char *stack;
+
+       stack = (unsigned char *)(task->thread.uregs);
+       stack += offset;
+       *(unsigned long *) stack = data;
+       return 0;
+}
+
+static inline int
+put_fpu_long(struct task_struct *task, unsigned long addr, unsigned long data)
+{
+       struct pt_regs *regs;
+
+       regs = (struct pt_regs*)((unsigned char *)task + THREAD_SIZE) - 1;
+
+       if (!tsk_used_math(task)) {
+               fpinit(&task->thread.fpu.hard);
+               set_stopped_child_used_math(task);
+       } else if (last_task_used_math == task) {
+               grab_fpu();
+               fpsave(&task->thread.fpu.hard);
+               release_fpu();
+               last_task_used_math = 0;
+               regs->sr |= SR_FD;
+       }
+
+       ((long *)&task->thread.fpu)[addr / sizeof(unsigned long)] = data;
+       return 0;
+}
+
+
+long arch_ptrace(struct task_struct *child, long request, long addr, long data)
+{
+       int ret;
+
+       switch (request) {
+       /* when I and D space are separate, these will need to be fixed. */
+       case PTRACE_PEEKTEXT: /* read word at location addr. */
+       case PTRACE_PEEKDATA:
+               ret = generic_ptrace_peekdata(child, addr, data);
+               break;
+
+       /* read the word at location addr in the USER area. */
+       case PTRACE_PEEKUSR: {
+               unsigned long tmp;
+
+               ret = -EIO;
+               if ((addr & 3) || addr < 0)
+                       break;
+
+               if (addr < sizeof(struct pt_regs))
+                       tmp = get_stack_long(child, addr);
+               else if ((addr >= offsetof(struct user, fpu)) &&
+                        (addr <  offsetof(struct user, u_fpvalid))) {
+                       tmp = get_fpu_long(child, addr - offsetof(struct user, 
fpu));
+               } else if (addr == offsetof(struct user, u_fpvalid)) {
+                       tmp = !!tsk_used_math(child);
+               } else {
+                       break;
+               }
+               ret = put_user(tmp, (unsigned long *)data);
+               break;
+       }
+
+       /* when I and D space are separate, this will have to be fixed. */
+       case PTRACE_POKETEXT: /* write the word at location addr. */
+       case PTRACE_POKEDATA:
+               ret = generic_ptrace_pokedata(child, addr, data);
+               break;
+
+       case PTRACE_POKEUSR:
+                /* write the word at location addr in the USER area. We must
+                   disallow any changes to certain SR bits or u_fpvalid, since
+                   this could crash the kernel or result in a security
+                   loophole. */
+               ret = -EIO;
+               if ((addr & 3) || addr < 0)
+                       break;
+
+               if (addr < sizeof(struct pt_regs)) {
+                       /* Ignore change of top 32 bits of SR */
+                       if (addr == offsetof (struct pt_regs, sr)+4)
+                       {
+                               ret = 0;
+                               break;
+                       }
+                       /* If lower 32 bits of SR, ignore non-user bits */
+                       if (addr == offsetof (struct pt_regs, sr))
+                       {
+                               long cursr = get_stack_long(child, addr);
+                               data &= ~(SR_MASK);
+                               data |= (cursr & SR_MASK);
+                       }
+                       ret = put_stack_long(child, addr, data);
+               }
+               else if ((addr >= offsetof(struct user, fpu)) &&
+                        (addr <  offsetof(struct user, u_fpvalid))) {
+                       ret = put_fpu_long(child, addr - offsetof(struct user, 
fpu), data);
+               }
+               break;
+
+       case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall 
*/
+       case PTRACE_CONT: { /* restart after signal. */
+               ret = -EIO;
+               if (!valid_signal(data))
+                       break;
+               if (request == PTRACE_SYSCALL)
+                       set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+               else
+                       clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+               child->exit_code = data;
+               wake_up_process(child);
+               ret = 0;
+               break;
+       }
+
+/*
+ * 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: {
+               ret = 0;
+               if (child->exit_state == EXIT_ZOMBIE)   /* already dead */
+                       break;
+               child->exit_code = SIGKILL;
+               wake_up_process(child);
+               break;
+       }
+
+       case PTRACE_SINGLESTEP: {  /* set the trap flag. */
+               struct pt_regs *regs;
+
+               ret = -EIO;
+               if (!valid_signal(data))
+                       break;
+               clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+               if ((child->ptrace & PT_DTRACE) == 0) {
+                       /* Spurious delayed TF traps may occur */
+                       child->ptrace |= PT_DTRACE;
+               }
+
+               regs = child->thread.uregs;
+
+               regs->sr |= SR_SSTEP;   /* auto-resetting upon exception */
+
+               child->exit_code = data;
+               /* give it a chance to run. */
+               wake_up_process(child);
+               ret = 0;
+               break;
+       }
+
+       default:
+               ret = ptrace_request(child, request, addr, data);
+               break;
+       }
+       return ret;
+}
+
+asmlinkage int sh64_ptrace(long request, long pid, long addr, long data)
+{
+       extern void poke_real_address_q(unsigned long long addr, unsigned long 
long data);
+#define WPC_DBRMODE 0x0d104008
+       static int first_call = 1;
+
+       lock_kernel();
+       if (first_call) {
+               /* Set WPC.DBRMODE to 0.  This makes all debug events get
+                * delivered through RESVEC, i.e. into the handlers in entry.S.
+                * (If the kernel was downloaded using a remote gdb, WPC.DBRMODE
+                * would normally be left set to 1, which makes debug events get
+                * delivered through DBRVEC, i.e. into the remote gdb's
+                * handlers.  This prevents ptrace getting them, and confuses
+                * the remote gdb.) */
+               printk("DBRMODE set to 0 to permit native debugging\n");
+               poke_real_address_q(WPC_DBRMODE, 0);
+               first_call = 0;
+       }
+       unlock_kernel();
+
+       return sys_ptrace(request, pid, addr, data);
+}
+
+asmlinkage void syscall_trace(void)
+{
+       struct task_struct *tsk = current;
+
+       if (!test_thread_flag(TIF_SYSCALL_TRACE))
+               return;
+       if (!(tsk->ptrace & PT_PTRACED))
+               return;
+
+       ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
+                                ? 0x80 : 0));
+       /*
+        * 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
+        */
+       if (tsk->exit_code) {
+               send_sig(tsk->exit_code, tsk, 1);
+               tsk->exit_code = 0;
+       }
+}
+
+/* Called with interrupts disabled */
+asmlinkage void do_single_step(unsigned long long vec, struct pt_regs *regs)
+{
+       /* This is called after a single step exception (DEBUGSS).
+          There is no need to change the PC, as it is a post-execution
+          exception, as entry.S does not do anything to the PC for DEBUGSS.
+          We need to clear the Single Step setting in SR to avoid
+          continually stepping. */
+       local_irq_enable();
+       regs->sr &= ~SR_SSTEP;
+       force_sig(SIGTRAP, current);
+}
+
+/* Called with interrupts disabled */
+asmlinkage void do_software_break_point(unsigned long long vec,
+                                       struct pt_regs *regs)
+{
+       /* We need to forward step the PC, to counteract the backstep done
+          in signal.c. */
+       local_irq_enable();
+       force_sig(SIGTRAP, current);
+       regs->pc += 4;
+}
+
+/*
+ * Called by kernel/ptrace.c when detaching..
+ *
+ * Make sure single step bits etc are not set.
+ */
+void ptrace_disable(struct task_struct *child)
+{
+        /* nothing to do.. */
+}
diff --git a/arch/sh64/kernel/ptrace.c b/arch/sh64/kernel/ptrace.c
deleted file mode 100644
index 8a2d339..0000000
--- a/arch/sh64/kernel/ptrace.c
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file "COPYING" in the main directory of this archive
- * for more details.
- *
- * arch/sh64/kernel/ptrace.c
- *
- * Copyright (C) 2000, 2001  Paolo Alberelli
- * Copyright (C) 2003  Paul Mundt
- *
- * Started from SH3/4 version:
- *   SuperH version:   Copyright (C) 1999, 2000  Kaz Kojima & Niibe Yutaka
- *
- *   Original x86 implementation:
- *     By Ross Biro 1/23/92
- *     edited by Linus Torvalds
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/rwsem.h>
-#include <linux/sched.h>
-#include <linux/mm.h>
-#include <linux/smp.h>
-#include <linux/smp_lock.h>
-#include <linux/errno.h>
-#include <linux/ptrace.h>
-#include <linux/user.h>
-#include <linux/signal.h>
-#include <linux/syscalls.h>
-
-#include <asm/io.h>
-#include <asm/uaccess.h>
-#include <asm/pgtable.h>
-#include <asm/system.h>
-#include <asm/processor.h>
-#include <asm/mmu_context.h>
-
-/* This mask defines the bits of the SR which the user is not allowed to
-   change, which are everything except S, Q, M, PR, SZ, FR. */
-#define SR_MASK      (0xffff8cfd)
-
-/*
- * does not yet catch signals sent when the child dies.
- * in exit.c or in signal.c.
- */
-
-/*
- * This routine will get a word from the user area in the process kernel stack.
- */
-static inline int get_stack_long(struct task_struct *task, int offset)
-{
-       unsigned char *stack;
-
-       stack = (unsigned char *)(task->thread.uregs);
-       stack += offset;
-       return (*((int *)stack));
-}
-
-static inline unsigned long
-get_fpu_long(struct task_struct *task, unsigned long addr)
-{
-       unsigned long tmp;
-       struct pt_regs *regs;
-       regs = (struct pt_regs*)((unsigned char *)task + THREAD_SIZE) - 1;
-
-       if (!tsk_used_math(task)) {
-               if (addr == offsetof(struct user_fpu_struct, fpscr)) {
-                       tmp = FPSCR_INIT;
-               } else {
-                       tmp = 0xffffffffUL; /* matches initial value in fpu.c */
-               }
-               return tmp;
-       }
-
-       if (last_task_used_math == task) {
-               grab_fpu();
-               fpsave(&task->thread.fpu.hard);
-               release_fpu();
-               last_task_used_math = 0;
-               regs->sr |= SR_FD;
-       }
-
-       tmp = ((long *)&task->thread.fpu)[addr / sizeof(unsigned long)];
-       return tmp;
-}
-
-/*
- * This routine will put a word into the user area in the process kernel stack.
- */
-static inline int put_stack_long(struct task_struct *task, int offset,
-                                unsigned long data)
-{
-       unsigned char *stack;
-
-       stack = (unsigned char *)(task->thread.uregs);
-       stack += offset;
-       *(unsigned long *) stack = data;
-       return 0;
-}
-
-static inline int
-put_fpu_long(struct task_struct *task, unsigned long addr, unsigned long data)
-{
-       struct pt_regs *regs;
-
-       regs = (struct pt_regs*)((unsigned char *)task + THREAD_SIZE) - 1;
-
-       if (!tsk_used_math(task)) {
-               fpinit(&task->thread.fpu.hard);
-               set_stopped_child_used_math(task);
-       } else if (last_task_used_math == task) {
-               grab_fpu();
-               fpsave(&task->thread.fpu.hard);
-               release_fpu();
-               last_task_used_math = 0;
-               regs->sr |= SR_FD;
-       }
-
-       ((long *)&task->thread.fpu)[addr / sizeof(unsigned long)] = data;
-       return 0;
-}
-
-
-long arch_ptrace(struct task_struct *child, long request, long addr, long data)
-{
-       int ret;
-
-       switch (request) {
-       /* when I and D space are separate, these will need to be fixed. */
-       case PTRACE_PEEKTEXT: /* read word at location addr. */
-       case PTRACE_PEEKDATA:
-               ret = generic_ptrace_peekdata(child, addr, data);
-               break;
-
-       /* read the word at location addr in the USER area. */
-       case PTRACE_PEEKUSR: {
-               unsigned long tmp;
-
-               ret = -EIO;
-               if ((addr & 3) || addr < 0)
-                       break;
-
-               if (addr < sizeof(struct pt_regs))
-                       tmp = get_stack_long(child, addr);
-               else if ((addr >= offsetof(struct user, fpu)) &&
-                        (addr <  offsetof(struct user, u_fpvalid))) {
-                       tmp = get_fpu_long(child, addr - offsetof(struct user, 
fpu));
-               } else if (addr == offsetof(struct user, u_fpvalid)) {
-                       tmp = !!tsk_used_math(child);
-               } else {
-                       break;
-               }
-               ret = put_user(tmp, (unsigned long *)data);
-               break;
-       }
-
-       /* when I and D space are separate, this will have to be fixed. */
-       case PTRACE_POKETEXT: /* write the word at location addr. */
-       case PTRACE_POKEDATA:
-               ret = generic_ptrace_pokedata(child, addr, data);
-               break;
-
-       case PTRACE_POKEUSR:
-                /* write the word at location addr in the USER area. We must
-                   disallow any changes to certain SR bits or u_fpvalid, since
-                   this could crash the kernel or result in a security
-                   loophole. */
-               ret = -EIO;
-               if ((addr & 3) || addr < 0)
-                       break;
-
-               if (addr < sizeof(struct pt_regs)) {
-                       /* Ignore change of top 32 bits of SR */
-                       if (addr == offsetof (struct pt_regs, sr)+4)
-                       {
-                               ret = 0;
-                               break;
-                       }
-                       /* If lower 32 bits of SR, ignore non-user bits */
-                       if (addr == offsetof (struct pt_regs, sr))
-                       {
-                               long cursr = get_stack_long(child, addr);
-                               data &= ~(SR_MASK);
-                               data |= (cursr & SR_MASK);
-                       }
-                       ret = put_stack_long(child, addr, data);
-               }
-               else if ((addr >= offsetof(struct user, fpu)) &&
-                        (addr <  offsetof(struct user, u_fpvalid))) {
-                       ret = put_fpu_long(child, addr - offsetof(struct user, 
fpu), data);
-               }
-               break;
-
-       case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall 
*/
-       case PTRACE_CONT: { /* restart after signal. */
-               ret = -EIO;
-               if (!valid_signal(data))
-                       break;
-               if (request == PTRACE_SYSCALL)
-                       set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-               else
-                       clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-               child->exit_code = data;
-               wake_up_process(child);
-               ret = 0;
-               break;
-       }
-
-/*
- * 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: {
-               ret = 0;
-               if (child->exit_state == EXIT_ZOMBIE)   /* already dead */
-                       break;
-               child->exit_code = SIGKILL;
-               wake_up_process(child);
-               break;
-       }
-
-       case PTRACE_SINGLESTEP: {  /* set the trap flag. */
-               struct pt_regs *regs;
-
-               ret = -EIO;
-               if (!valid_signal(data))
-                       break;
-               clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-               if ((child->ptrace & PT_DTRACE) == 0) {
-                       /* Spurious delayed TF traps may occur */
-                       child->ptrace |= PT_DTRACE;
-               }
-
-               regs = child->thread.uregs;
-
-               regs->sr |= SR_SSTEP;   /* auto-resetting upon exception */
-
-               child->exit_code = data;
-               /* give it a chance to run. */
-               wake_up_process(child);
-               ret = 0;
-               break;
-       }
-
-       default:
-               ret = ptrace_request(child, request, addr, data);
-               break;
-       }
-       return ret;
-}
-
-asmlinkage int sh64_ptrace(long request, long pid, long addr, long data)
-{
-       extern void poke_real_address_q(unsigned long long addr, unsigned long 
long data);
-#define WPC_DBRMODE 0x0d104008
-       static int first_call = 1;
-
-       lock_kernel();
-       if (first_call) {
-               /* Set WPC.DBRMODE to 0.  This makes all debug events get
-                * delivered through RESVEC, i.e. into the handlers in entry.S.
-                * (If the kernel was downloaded using a remote gdb, WPC.DBRMODE
-                * would normally be left set to 1, which makes debug events get
-                * delivered through DBRVEC, i.e. into the remote gdb's
-                * handlers.  This prevents ptrace getting them, and confuses
-                * the remote gdb.) */
-               printk("DBRMODE set to 0 to permit native debugging\n");
-               poke_real_address_q(WPC_DBRMODE, 0);
-               first_call = 0;
-       }
-       unlock_kernel();
-
-       return sys_ptrace(request, pid, addr, data);
-}
-
-asmlinkage void syscall_trace(void)
-{
-       struct task_struct *tsk = current;
-
-       if (!test_thread_flag(TIF_SYSCALL_TRACE))
-               return;
-       if (!(tsk->ptrace & PT_PTRACED))
-               return;
-
-       ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
-                                ? 0x80 : 0));
-       /*
-        * 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
-        */
-       if (tsk->exit_code) {
-               send_sig(tsk->exit_code, tsk, 1);
-               tsk->exit_code = 0;
-       }
-}
-
-/* Called with interrupts disabled */
-asmlinkage void do_single_step(unsigned long long vec, struct pt_regs *regs)
-{
-       /* This is called after a single step exception (DEBUGSS).
-          There is no need to change the PC, as it is a post-execution
-          exception, as entry.S does not do anything to the PC for DEBUGSS.
-          We need to clear the Single Step setting in SR to avoid
-          continually stepping. */
-       local_irq_enable();
-       regs->sr &= ~SR_SSTEP;
-       force_sig(SIGTRAP, current);
-}
-
-/* Called with interrupts disabled */
-asmlinkage void do_software_break_point(unsigned long long vec,
-                                       struct pt_regs *regs)
-{
-       /* We need to forward step the PC, to counteract the backstep done
-          in signal.c. */
-       local_irq_enable();
-       force_sig(SIGTRAP, current);
-       regs->pc += 4;
-}
-
-/*
- * Called by kernel/ptrace.c when detaching..
- *
- * Make sure single step bits etc are not set.
- */
-void ptrace_disable(struct task_struct *child)
-{
-        /* nothing to do.. */
-}
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to